Class

Gtk.GLArea

Description [src]

class Gtk.GLArea : Gtk.Widget {
  /* No available fields */
}

GtkGLArea is a widget that allows drawing with OpenGL.

An example GtkGLArea

GtkGLArea sets up its own GdkGLContext, 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 GtkGLArea::render signal, or subclass GtkGLArea and override the GtkGLAreaClass.render virtual function.

The GtkGLArea widget ensures that the GdkGLContext 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 GtkGLArea is to create a widget instance and connect to the GtkGLArea::render signal:

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

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 GtkWidget::realize signal; you can use the GtkWidget::unrealize signal to clean up. Since the GdkGLContext creation and initialization may fail, you will need to check for errors, using gtk_gl_area_get_error().

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

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 GdkGLContext you should use the GtkGLArea::create-context signal.

Ancestors

Constructors

gtk_gl_area_new

Creates a new GtkGLArea widget.

Instance methods

gtk_gl_area_attach_buffers

Binds buffers to the framebuffer.

gtk_gl_area_get_auto_render

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

gtk_gl_area_get_context

Retrieves the GdkGLContext used by area.

gtk_gl_area_get_error

Gets the current error set on the area.

gtk_gl_area_get_has_depth_buffer

Returns whether the area has a depth buffer.

gtk_gl_area_get_has_stencil_buffer

Returns whether the area has a stencil buffer.

gtk_gl_area_get_required_version

Retrieves the required version of OpenGL.

gtk_gl_area_get_use_es

Returns whether the GtkGLArea should use OpenGL ES.

gtk_gl_area_make_current

Ensures that the GdkGLContext used by area is associated with the GtkGLArea.

gtk_gl_area_queue_render

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

gtk_gl_area_set_auto_render

Sets whether the GtkGLArea is in auto render mode.

gtk_gl_area_set_error

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

gtk_gl_area_set_has_depth_buffer

Sets whether the GtkGLArea should use a depth buffer.

gtk_gl_area_set_has_stencil_buffer

Sets whether the GtkGLArea should use a stencil buffer.

gtk_gl_area_set_required_version

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

gtk_gl_area_set_use_es

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

Methods inherited from GtkWidget (159)
Methods inherited from GtkBuildable (1)

Signals

Gtk.GLArea::create-context

Emitted when the widget is being realized.

Gtk.GLArea::render

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

Gtk.GLArea::resize

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

Class structure

struct GtkGLAreaClass {
  gboolean (* render) (
    GtkGLArea* area,
    GdkGLContext* context
  );
  void (* resize) (
    GtkGLArea* area,
    int width,
    int height
  );
  GdkGLContext* (* create_context) (
    GtkGLArea* area
  );
  
}
Class members
render
gboolean (* render) (
    GtkGLArea* area,
    GdkGLContext* context
  )
  No description available.
resize
void (* resize) (
    GtkGLArea* area,
    int width,
    int height
  )
  No description available.
create_context
GdkGLContext* (* create_context) (
    GtkGLArea* area
  )
  No description available.

Virtual methods

Gtk.GLAreaClass.create_context
No description available.
Gtk.GLAreaClass.render
No description available.
Gtk.GLAreaClass.resize
No description available.