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

pub trait GLAreaExt: 'static {

Show methods    fn attach_buffers(&self);

    fn is_auto_render(&self) -> bool;

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

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

    fn has_alpha(&self) -> bool;

    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_alpha(&self, has_alpha: bool);

    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_alpha_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

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 frambuffer.

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 glib::Error or None

Returns whether the area has an alpha component.

Returns

true if the self has an alpha component, false otherwise

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 set using set_required_version().

Returns

major

return location for the required major version

minor

return location for the required minor version

This is supported on crate feature v3_22 only.

Retrieves the value set by 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, ensuring that the signal::GLArea::render signal is emitted during the draw.

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

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 seldomly, 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 glib::Error, or None to unset the error

If has_alpha is true the buffer allocated by the widget will have an alpha channel component, and when rendering to the window the result will be composited over whatever is below the widget.

If has_alpha is false there will be no alpha channel, and the buffer will fully replace anything below the widget.

has_alpha

true to add an alpha component

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

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

This is supported on crate feature v3_22 only.

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

The ::create-context signal is emitted when the widget is being realized, and 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.

The ::render signal is 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.

The ::resize signal is 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

This is supported on crate feature v3_22 only.

Implementors