Struct gtk4::GLArea

#[repr(transparent)]
pub struct GLArea { /* private fields */ }

GLArea is a widget that allows drawing with OpenGL.

GLArea sets up its own gdk::GLContext, and creates a custom GL framebuffer that the widget will do GL rendering onto. It also ensures that this framebuffer is the default GL rendering target when rendering.

In order to draw, you have to connect to the signal::GLArea::render signal, or subclass GLArea and override the GtkGLAreaClass.render virtual function.

The GLArea widget ensures that the gdk::GLContext is associated with the widget’s drawing area, and it is kept updated when the size and position of the drawing area changes.

Drawing with GtkGLArea

The simplest way to draw using OpenGL commands in a GLArea is to create a widget instance and connect to the signal::GLArea::render signal:

The render() function will be called when the GLArea is ready for you to draw its content:

⚠️ The following code is in c ⚠️

static gboolean
render (GtkGLArea *area, GdkGLContext *context)
{
  // inside this function it's safe to use GL; the given
  // GdkGLContext has been made current to the drawable
  // surface used by the `GtkGLArea` and the viewport has
  // already been set to be the size of the allocation

  // we can start by clearing the buffer
  glClearColor (0, 0, 0, 0);
  glClear (GL_COLOR_BUFFER_BIT);

  // draw your object
  // draw_an_object ();

  // we completed our drawing; the draw commands will be
  // flushed at the end of the signal emission chain, and
  // the buffers will be drawn on the window
  return TRUE;
}

void setup_glarea (void)
{
  // create a GtkGLArea instance
  GtkWidget *gl_area = gtk_gl_area_new ();

  // connect to the "render" signal
  g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
}

If you need to initialize OpenGL state, e.g. buffer objects or shaders, you should use the signal::Widget::realize signal; you can use the signal::Widget::unrealize signal to clean up. Since the gdk::GLContext creation and initialization may fail, you will need to check for errors, using GLAreaExt::error().

An example of how to safely initialize the GL state is:

⚠️ The following code is in c ⚠️

static void
on_realize (GtkGLarea *area)
{
  // We need to make the context current if we want to
  // call GL API
  gtk_gl_area_make_current (area);

  // If there were errors during the initialization or
  // when trying to make the context current, this
  // function will return a GError for you to catch
  if (gtk_gl_area_get_error (area) != NULL)
    return;

  // You can also use gtk_gl_area_set_error() in order
  // to show eventual initialization errors on the
  // GtkGLArea widget itself
  GError *internal_error = NULL;
  init_buffer_objects (&error);
  if (error != NULL)
    {
      gtk_gl_area_set_error (area, error);
      g_error_free (error);
      return;
    }

  init_shaders (&error);
  if (error != NULL)
    {
      gtk_gl_area_set_error (area, error);
      g_error_free (error);
      return;
    }
}

If you need to change the options for creating the gdk::GLContext you should use the signal::GLArea::create-context signal.

Implements

GLAreaExt, WidgetExt, glib::ObjectExt, AccessibleExt, BuildableExt, ConstraintTargetExt, WidgetExtManual, AccessibleExtManual

Implementations

impl GLArea

pub const NONE: Option<&'static GLArea> = None

pub fn new() -> GLArea

Creates a new GLArea widget.

Returns

a new GLArea

pub fn builder() -> GLAreaBuilder

Creates a new builder-pattern struct instance to construct GLArea objects.

This method returns an instance of GLAreaBuilder which can be used to create GLArea objects.

Trait Implementations

impl Clone for GLArea

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GLArea

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GLArea

fn default() -> Self

Returns the “default value” for a type.

impl Display for GLArea

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for GLArea

fn hash<H>(&self, state: &mut H)where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: GLAreaImpl> IsSubclassable<T> for GLArea

fn class_init(class: &mut Class<Self>)

Override the virtual methods of this class for the given subclass and do other class initialization.

fn instance_init(instance: &mut InitializingObject<T>)

Instance specific initialization.

impl Ord for GLArea

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl ParentClassIs for GLArea

type Parent = Widget

impl<OT: ObjectType> PartialEq<OT> for GLArea

fn eq(&self, other: &OT) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for GLArea

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for GLArea

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for GLArea

impl IsA<Accessible> for GLArea

impl IsA<Buildable> for GLArea

impl IsA<ConstraintTarget> for GLArea

impl IsA<Widget> for GLArea