Trait gtk4::prelude::GLAreaExt[−][src]

pub trait GLAreaExt: 'static {

Show 24 methods    fn attach_buffers(&self);

    fn is_auto_render(&self) -> bool;

    fn context(&self) -> Option<GLContext>;

    fn error(&self) -> Option<Error>;

    fn has_depth_buffer(&self) -> bool;

    fn has_stencil_buffer(&self) -> bool;

    fn required_version(&self) -> (i32, i32);

    fn uses_es(&self) -> bool;

    fn make_current(&self);

    fn queue_render(&self);

    fn set_auto_render(&self, auto_render: bool);

    fn set_error(&self, error: Option<&Error>);

    fn set_has_depth_buffer(&self, has_depth_buffer: bool);

    fn set_has_stencil_buffer(&self, has_stencil_buffer: bool);

    fn set_required_version(&self, major: i32, minor: i32);

    fn set_use_es(&self, use_es: bool);

    fn connect_create_context<F: Fn(&Self) -> Option<GLContext> + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_render<F: Fn(&Self, &GLContext) -> Inhibit + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_resize<F: Fn(&Self, i32, i32) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_auto_render_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_context_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_has_depth_buffer_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_has_stencil_buffer_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_use_es_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

}
Expand description

Trait containing all GLArea methods.

Implementors

GLArea

Required methods

Binds buffers to the framebuffer.

Ensures that the self framebuffer object is made the current draw and read target, and that all the required buffers for the self are created and bound to the framebuffer.

This function is automatically called before emitting the signal::GLArea::render signal, and doesn’t normally need to be called by application code.

Returns whether the area is in auto render mode or not.

Returns

true if the self is auto rendering, false otherwise

Retrieves the gdk::GLContext used by self.

Returns

the gdk::GLContext

Gets the current error set on the self.

Returns

the GError

Returns whether the area has a depth buffer.

Returns

true if the self has a depth buffer, false otherwise

Returns whether the area has a stencil buffer.

Returns

true if the self has a stencil buffer, false otherwise

Retrieves the required version of OpenGL.

See set_required_version().

Returns
major

return location for the required major version

minor

return location for the required minor version

Returns whether the GLArea should use OpenGL ES.

See set_use_es().

Returns

true if the GLArea should create an OpenGL ES context and false otherwise

Ensures that the gdk::GLContext used by self is associated with the GLArea.

This function is automatically called before emitting the signal::GLArea::render signal, and doesn’t normally need to be called by application code.

Marks the currently rendered data (if any) as invalid, and queues a redraw of the widget.

This ensures that the signal::GLArea::render signal is emitted during the draw.

This is only needed when set_auto_render() has been called with a false value. The default behaviour is to emit signal::GLArea::render on each draw.

Sets whether the GLArea is in auto render mode.

If auto_render is true the signal::GLArea::render signal will be emitted every time the widget draws. This is the default and is useful if drawing the widget is faster.

If auto_render is false the data from previous rendering is kept around and will be used for drawing the widget the next time, unless the window is resized. In order to force a rendering queue_render() must be called. This mode is useful when the scene changes seldom, but takes a long time to redraw.

auto_render

a boolean

Sets an error on the area which will be shown instead of the GL rendering.

This is useful in the signal::GLArea::create-context signal if GL context creation fails.

error

a new GError, or None to unset the error

Sets whether the GLArea should use a depth buffer.

If has_depth_buffer is true the widget will allocate and enable a depth buffer for the target framebuffer. Otherwise there will be none.

has_depth_buffer

true to add a depth buffer

Sets whether the GLArea should use a stencil buffer.

If has_stencil_buffer is true the widget will allocate and enable a stencil buffer for the target framebuffer. Otherwise there will be none.

has_stencil_buffer

true to add a stencil buffer

Sets the required version of OpenGL to be used when creating the context for the widget.

This function must be called before the area has been realized.

major

the major version

minor

the minor version

Sets whether the self should create an OpenGL or an OpenGL ES context.

You should check the capabilities of the gdk::GLContext before drawing with either API.

use_es

whether to use OpenGL or OpenGL ES

Emitted when the widget is being realized.

This allows you to override how the GL context is created. This is useful when you want to reuse an existing GL context, or if you want to try creating different kinds of GL options.

If context creation fails then the signal handler can use set_error() to register a more detailed error of how the construction failed.

Returns

a newly created gdk::GLContext; the GLArea widget will take ownership of the returned value.

Emitted every time the contents of the GLArea should be redrawn.

The context is bound to the area prior to emitting this function, and the buffers are painted to the window once the emission terminates.

context

the gdk::GLContext used by area

Returns

true to stop other handlers from being invoked for the event. false to propagate the event further.

Emitted once when the widget is realized, and then each time the widget is changed while realized.

This is useful in order to keep GL state up to date with the widget size, like for instance camera properties which may depend on the width/height ratio.

The GL context for the area is guaranteed to be current when this signal is emitted.

The default handler sets up the GL viewport.

width

the width of the viewport

height

the height of the viewport

Implementors