GNOME.org
 

[gtkmm] Add Gtk::GLArea and example to gtkmm-demo.

commit e4f542c84549e28716abd0c89ca2d22a04187938
Author: Daniel Hams <daniel hams gmail com>
Date:   Wed Jul 22 15:13:26 2015 +0100

    Add Gtk::GLArea and example to gtkmm-demo.
    
    Bug #752314

 .gitignore                                |    4 +
 configure.ac                              |    3 +
 demos/Makefile.am                         |    6 +-
 demos/gtk-demo/demo.gresource.xml         |    5 +
 demos/gtk-demo/demos.h                    |    2 +
 demos/gtk-demo/example_glarea.cc          |  391 +++++++++++++++++++++++++++++
 demos/gtk-demo/glarea-fragment.glsl       |    9 +
 demos/gtk-demo/glarea-vertex.glsl         |    8 +
 gdk/gdkmm.h                               |    1 +
 gdk/src/filelist.am                       |    1 +
 gdk/src/gdk_docs.xml                      |    2 +-
 gdk/src/gdk_signals.defs                  |   28 ++
 gdk/src/glcontext.ccg                     |   23 ++
 gdk/src/glcontext.hg                      |   65 +++++
 gdk/src/window.ccg                        |    2 +-
 gdk/src/window.hg                         |   17 ++
 gtk/gtkmm.h                               |    1 +
 gtk/src/filelist.am                       |    1 +
 gtk/src/glarea.ccg                        |   43 ++++
 gtk/src/glarea.hg                         |  107 ++++++++
 gtk/src/gtk_signals.defs                  |   72 ++++++
 tools/extra_defs_gen/generate_defs_gdk.cc |    1 +
 tools/extra_defs_gen/generate_defs_gtk.cc |    1 +
 tools/m4/convert_gdk.m4                   |    9 +
 24 files changed, 799 insertions(+), 3 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index 1025aa7..ff62af3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -76,6 +76,8 @@ gdk/gdkmm/dragcontext.cc
 gdk/gdkmm/dragcontext.h
 gdk/gdkmm/event.cc
 gdk/gdkmm/event.h
+gdk/gdkmm/glcontext.cc
+gdk/gdkmm/glcontext.h
 gdk/gdkmm/pixbuf.cc
 gdk/gdkmm/pixbuf.h
 gdk/gdkmm/pixbufanimation.cc
@@ -280,6 +282,8 @@ gtk/gtkmm/gestureswipe.cc
 gtk/gtkmm/gestureswipe.h
 gtk/gtkmm/gesturezoom.cc
 gtk/gtkmm/gesturezoom.h
+gtk/gtkmm/glarea.cc
+gtk/gtkmm/glarea.h
 gtk/gtkmm/grid.cc
 gtk/gtkmm/grid.h
 gtk/gtkmm/handlebox.cc
diff --git a/configure.ac b/configure.ac
index 3689eeb..dc7e779 100644
--- a/configure.ac
+++ b/configure.ac
@@ -107,8 +107,11 @@ AS_IF([test "x$gtkmm_enable_api_atkmm" != xno],
       [GTKMM_MODULES="atkmm-1.6 >= 2.23.2 $GTKMM_MODULES"])
 AC_SUBST([GTKMM_MODULES])
 
+AC_SUBST([GTKMM_DEMOS_EXTRA_MODULES], ['epoxy >= 1.2'])
+
 PKG_CHECK_MODULES([GDKMM], [$GDKMM_MODULES])
 PKG_CHECK_MODULES([GTKMM], [$GTKMM_MODULES])
+PKG_CHECK_MODULES([GTKMM_DEMOS_EXTRA], [$GTKMM_DEMOS_EXTRA_MODULES])
 
 MM_PKG_CONFIG_SUBST([GTHREAD_CFLAGS], [--cflags-only-other gthread-2.0])
 MM_PKG_CONFIG_SUBST([GTHREAD_LIBS], [--libs gthread-2.0])
diff --git a/demos/Makefile.am b/demos/Makefile.am
index 1c2b2bc..5bf3d56 100644
--- a/demos/Makefile.am
+++ b/demos/Makefile.am
@@ -45,6 +45,7 @@ GTK_DEMOS = \
   gtk-demo/example_drawingarea.cc \
   gtk-demo/example_flowbox.cc \
   gtk-demo/example_gestures.cc \
+  gtk-demo/example_glarea.cc \
   gtk-demo/example_headerbar.cc \
   gtk-demo/example_iconbrowser.cc \
   gtk-demo/example_iconview.cc \
@@ -67,6 +68,8 @@ GTK_DEMO_RESOURCES = \
   gtk-demo/apple-red.png \
   gtk-demo/background.jpg \
   gtk-demo/floppybuddy.gif \
+  gtk-demo/glarea-fragment.glsl \
+  gtk-demo/glarea-vertex.glsl \
   gtk-demo/gnome-applets.png \
   gtk-demo/gnome-calendar.png \
   gtk-demo/gnome-foot.png \
@@ -96,4 +99,5 @@ local_cppflags = -DDEMOCODEDIR=\""$(democodedir)"\"
 AM_CPPFLAGS = $(local_includes) $(GTHREAD_CFLAGS) $(GTKMM_CFLAGS) $(local_cppflags)
 AM_CXXFLAGS = $(GTKMM_WXXFLAGS) -DGLIBMM_DISABLE_DEPRECATED -DGIOMM_DISABLE_DEPRECATED 
-DGTKMM_DISABLE_DEPRECATED -DGDKMM_DISABLE_DEPRECATED
 
-gtk_demo_gtkmm_demo_LDADD = $(GTKMM_LIBS) $(local_ldadd)
+gtk_demo_gtkmm_demo_CPPFLAGS = $(AM_CPPFLAGS) $(GTKMM_DEMOS_EXTRA_CFLAGS)
+gtk_demo_gtkmm_demo_LDADD = $(GTKMM_LIBS) $(GTKMM_DEMOS_EXTRA_LIBS) $(local_ldadd)
diff --git a/demos/gtk-demo/demo.gresource.xml b/demos/gtk-demo/demo.gresource.xml
index 98bc1a8..e5bb3ad 100644
--- a/demos/gtk-demo/demo.gresource.xml
+++ b/demos/gtk-demo/demo.gresource.xml
@@ -7,6 +7,10 @@
     <file preprocess="to-pixdata">gnome-fs-directory.png</file>
     <file preprocess="to-pixdata">gnome-fs-regular.png</file>
   </gresource>
+  <gresource prefix="/glarea">
+    <file>glarea-fragment.glsl</file>
+    <file>glarea-vertex.glsl</file>
+  </gresource>
   <gresource prefix="/images">
     <file>alphatest.png</file>
     <file>floppybuddy.gif</file>
@@ -33,6 +37,7 @@
     <file>example_drawingarea.cc</file>
     <file>example_flowbox.cc</file>
     <file>example_gestures.cc</file>
+    <file>example_glarea.cc</file>
     <file>example_headerbar.cc</file>
     <file>example_iconbrowser.cc</file>
     <file>example_iconview.cc</file>
diff --git a/demos/gtk-demo/demos.h b/demos/gtk-demo/demos.h
index 28466a2..bbe1e3b 100644
--- a/demos/gtk-demo/demos.h
+++ b/demos/gtk-demo/demos.h
@@ -23,6 +23,7 @@ Gtk::Window* do_dialog();
 Gtk::Window* do_drawingarea();
 Gtk::Window* do_flowbox();
 Gtk::Window* do_gestures();
+Gtk::Window* do_glarea();
 Gtk::Window* do_headerbar();
 Gtk::Window* do_iconbrowser();
 Gtk::Window* do_iconview();
@@ -64,6 +65,7 @@ Demo testgtk_demos[] =
   { "Icon View", "example_iconview.cc", sigc::ptr_fun(&do_iconview), 0 },
   { "Images", "example_images.cc", sigc::ptr_fun(&do_images), 0 },
   { "Menus", "example_menus.cc", sigc::ptr_fun(&do_menus), 0 },
+  { "OpenGL Area", "example_glarea.cc", sigc::ptr_fun(&do_glarea), 0 },
   { "Overlay", "example_overlay.cc", sigc::ptr_fun(&do_overlay), 0 },
   { "Paned Widgets", "example_panes.cc", sigc::ptr_fun(&do_panes), 0 },
   { "Pixbufs", "example_pixbufs.cc", sigc::ptr_fun(&do_pixbufs), 0 },
diff --git a/demos/gtk-demo/example_glarea.cc b/demos/gtk-demo/example_glarea.cc
new file mode 100644
index 0000000..59a7808
--- /dev/null
+++ b/demos/gtk-demo/example_glarea.cc
@@ -0,0 +1,391 @@
+/* Open GL Area
+ *
+ * Gtk::GLArea is a widget that allows custom drawing using OpenGL calls.
+ *
+ */
+
+#include <iostream>
+#include <string>
+
+#include <gtkmm.h>
+#include <giomm/resource.h>
+#include <epoxy/gl.h>
+
+using std::cerr;
+using std::endl;
+using std::string;
+
+enum {
+  X_AXIS,
+  Y_AXIS,
+  Z_AXIS,
+
+  N_AXIS
+};
+
+static const GLfloat vertex_data[] = {
+  0.f,   0.5f,   0.f, 1.f,
+  0.5f, -0.366f, 0.f, 1.f,
+ -0.5f, -0.366f, 0.f, 1.f,
+};
+
+class Example_GLArea : public Gtk::Window
+{
+public:
+  Example_GLArea();
+  virtual ~Example_GLArea();
+
+protected:
+  Gtk::Box m_VBox {Gtk::ORIENTATION_VERTICAL, false};
+  Gtk::GLArea m_GLArea;
+  Gtk::Box m_Controls {Gtk::ORIENTATION_VERTICAL, false};
+  Gtk::Button m_Button {"Quit"};
+
+  GLuint m_Vao {0};
+  GLuint m_Buffer {0};
+  GLuint m_Program {0};
+  GLuint m_Mvp {0};
+
+  float m_RotationAngles[N_AXIS] {0.0f, 0.0f, 0.0f};
+
+  void on_axis_value_change(int axis, const Glib::RefPtr<Gtk::Adjustment>& adj);
+
+  void realize();
+  void unrealize();
+  bool render(const Glib::RefPtr<Gdk::GLContext>& context);
+
+  Gtk::Box* create_axis_slider_box(int axis);
+  void init_buffers();
+  void init_shaders();
+  void draw_triangle();
+};
+
+Gtk::Window* do_glarea()
+{
+  return new Example_GLArea();
+}
+
+Example_GLArea::Example_GLArea()
+{
+  set_title("GL Area");
+  set_default_size(400, 600);
+  set_border_width(12);
+
+  m_VBox.set_spacing(6);
+  add(m_VBox);
+
+  m_GLArea.set_hexpand(true);
+  m_GLArea.set_vexpand(true);
+  m_GLArea.set_auto_render(true);
+  m_VBox.add(m_GLArea);
+
+  // Connect gl area signals
+  m_GLArea.signal_realize().connect(sigc::mem_fun(this, &Example_GLArea::realize));
+  // Important that the unrealize signal calls our handler to clean up
+  // GL resources _before_ the default unrealize handler is called (the "false")
+  m_GLArea.signal_unrealize().connect(sigc::mem_fun(this, &Example_GLArea::unrealize), false);
+  m_GLArea.signal_render().connect(sigc::mem_fun(this, &Example_GLArea::render));
+
+  m_VBox.add(m_Controls);
+  m_Controls.set_hexpand(true);
+
+  for(int i = 0 ; i < N_AXIS ; ++i)
+  {
+    auto sliderBox = create_axis_slider_box(i);
+    m_Controls.add(*sliderBox);
+  }
+
+  m_Button.set_hexpand(true);
+  m_VBox.add(m_Button);
+  // Connect clicked to close of window
+  m_Button.signal_clicked().connect(sigc::mem_fun(this, &Gtk::Window::close));
+
+  show_all();
+}
+
+Example_GLArea::~Example_GLArea()
+{
+}
+
+void Example_GLArea::on_axis_value_change(int axis, const Glib::RefPtr<Gtk::Adjustment>& adj)
+{
+  m_RotationAngles[axis] = adj->get_value();
+  m_GLArea.queue_draw();
+}
+
+void Example_GLArea::realize()
+{
+  m_GLArea.make_current();
+  try
+  {
+    m_GLArea.throw_if_error();
+    init_buffers();
+    init_shaders();
+  }
+  catch(const Gdk::GLError& gle)
+  {
+    cerr << "An error occured making the context current during realize:" << endl;
+    cerr << gle.domain() << "-" << gle.code() << "-" << gle.what() << endl;
+  }
+}
+
+void Example_GLArea::unrealize()
+{
+  m_GLArea.make_current();
+  try
+  {
+    m_GLArea.throw_if_error();
+
+    // Delete buffers and program
+    glDeleteBuffers(1, &m_Vao);
+    glDeleteProgram(m_Program);
+  }
+  catch(const Gdk::GLError& gle)
+  {
+    cerr << "An error occured making the context current during unrealize" << endl;
+    cerr << gle.domain() << "-" << gle.code() << "-" << gle.what() << endl;
+  }
+}
+
+bool Example_GLArea::render(const Glib::RefPtr<Gdk::GLContext>& /* context */)
+{
+  try
+  {
+    m_GLArea.throw_if_error();
+    glClearColor(0.5, 0.5, 0.5, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    draw_triangle();
+
+    glFlush();
+
+    return true;
+  }
+  catch(const Gdk::GLError& gle)
+  {
+    cerr << "An error occurred in the render callback of the GLArea" << endl;
+    cerr << gle.domain() << "-" << gle.code() << "-" << gle.what() << endl;
+    return false;
+  }
+}
+
+Gtk::Box* Example_GLArea::create_axis_slider_box(int axis)
+{
+  auto box = Gtk::manage(new Gtk::Box{Gtk::ORIENTATION_HORIZONTAL, false});
+
+  const char* text;
+
+  switch(axis)
+  {
+    case X_AXIS:
+    {
+      text = "X axis";
+      break;
+    }
+    case Y_AXIS:
+    {
+      text = "Y axis";
+      break;
+    }
+    case Z_AXIS:
+    {
+      text = "Z axis";
+      break;
+    }
+    default:
+    {
+      g_assert_not_reached();
+    }
+  }
+
+  auto label = Gtk::manage(new Gtk::Label{text});
+  box->add(*label);
+  label->show();
+
+  auto adj = Gtk::Adjustment::create(0.0, 0.0, 360.0, 1.0, 12.0, 0.0);
+
+  adj->signal_value_changed().connect(
+    sigc::bind(sigc::mem_fun(this, &Example_GLArea::on_axis_value_change), axis, adj)
+                                      );
+  auto slider = Gtk::manage(new Gtk::Scale{adj, Gtk::ORIENTATION_HORIZONTAL});
+  box->add(*slider);
+  slider->set_hexpand(true);
+  slider->show();
+
+  box->show();
+
+  return box;
+}
+
+void Example_GLArea::init_buffers()
+{
+  glGenVertexArrays(1, &m_Vao);
+  glBindVertexArray(m_Vao);
+
+  glGenBuffers(1, &m_Buffer);
+  glBindBuffer(GL_ARRAY_BUFFER, m_Buffer);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+static GLuint create_shader(int type, const char *src)
+{
+  auto shader = glCreateShader(type);
+  glShaderSource(shader, 1, &src, nullptr);
+  glCompileShader(shader);
+
+  int status;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+  if(status == GL_FALSE)
+  {
+    int log_len;
+    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len);
+
+    string log_space(log_len+1, ' ');
+    glGetShaderInfoLog(shader, log_len, nullptr, (GLchar*)log_space.c_str());
+
+    cerr << "Compile failure in " <<
+      (type == GL_VERTEX_SHADER ? "vertex" : "fragment") <<
+      " shader: " << log_space << endl;
+
+    glDeleteShader(shader);
+
+    return 0;
+  }
+
+  return shader;
+}
+
+void Example_GLArea::init_shaders()
+{
+  auto vshader_bytes = Gio::Resource::lookup_data_global("/glarea/glarea-vertex.glsl");
+  if(!vshader_bytes)
+  {
+    cerr << "Failed fetching vertex shader resource" << endl;
+    m_Program = 0;
+    return;
+  }
+  gsize vshader_size {vshader_bytes->get_size()};
+  auto vertex = create_shader(GL_VERTEX_SHADER,
+                         (const char*)vshader_bytes->get_data(vshader_size));
+
+  if(vertex == 0)
+  {
+    m_Program = 0;
+    return;
+  }
+
+  auto fshader_bytes = Gio::Resource::lookup_data_global("/glarea/glarea-fragment.glsl");
+  if(!fshader_bytes)
+  {
+    cerr << "Failed fetching fragment shader resource" << endl;
+    glDeleteShader(vertex);
+    m_Program = 0;
+    return;
+  }
+  gsize fshader_size {fshader_bytes->get_size()};
+  auto fragment = create_shader(GL_FRAGMENT_SHADER,
+                           (const char*)fshader_bytes->get_data(fshader_size));
+
+  if(fragment == 0)
+  {
+    glDeleteShader(vertex);
+    m_Program = 0;
+    return;
+  }
+
+  m_Program = glCreateProgram();
+  glAttachShader(m_Program, vertex);
+  glAttachShader(m_Program, fragment);
+
+  glLinkProgram(m_Program);
+
+  int status;
+  glGetProgramiv(m_Program, GL_LINK_STATUS, &status);
+  if(status == GL_FALSE)
+  {
+    int log_len;
+    glGetProgramiv(m_Program, GL_INFO_LOG_LENGTH, &log_len);
+
+    string log_space(log_len+1, ' ');
+    glGetProgramInfoLog(m_Program, log_len, nullptr, (GLchar*)log_space.c_str());
+
+    cerr << "Linking failure: " << log_space << endl;
+
+    glDeleteProgram(m_Program);
+    m_Program = 0;
+  }
+  else
+  {
+    /* Get the location of the "mvp" uniform */
+    m_Mvp = glGetUniformLocation(m_Program, "mvp");
+
+    glDetachShader(m_Program, vertex);
+    glDetachShader(m_Program, fragment);
+  }
+  glDeleteShader(vertex);
+  glDeleteShader(fragment);
+}
+
+static void compute_mvp(float *res,
+                        float phi,
+                        float theta,
+                        float psi)
+{
+  float x       {phi * ((float)G_PI / 180.f)};
+  float y       {theta * ((float)G_PI / 180.f)};
+  float z       {psi * ((float)G_PI / 180.f)};
+  float c1      {cosf (x)};
+  float s1      {sinf (x)};
+  float c2      {cosf (y)};
+  float s2      {sinf (y)};
+  float c3      {cosf (z)};
+  float s3      {sinf (z)};
+  float c3c2    {c3 * c2};
+  float s3c1    {s3 * c1};
+  float c3s2s1  {c3 * s2 * s1};
+  float s3s1    {s3 * s1};
+  float c3s2c1  {c3 * s2 * c1};
+  float s3c2    {s3 * c2};
+  float c3c1    {c3 * c1};
+  float s3s2s1  {s3 * s2 * s1};
+  float c3s1    {c3 * s1};
+  float s3s2c1  {s3 * s2 * c1};
+  float c2s1    {c2 * s1};
+  float c2c1    {c2 * c1};
+
+  /* apply all three rotations using the three matrices:
+   *
+   * ⎡  c3 s3 0 ⎤ ⎡ c2  0 -s2 ⎤ ⎡ 1   0  0 ⎤
+   * ⎢ -s3 c3 0 ⎥ ⎢  0  1   0 ⎥ ⎢ 0  c1 s1 ⎥
+   * ⎣   0  0 1 ⎦ ⎣ s2  0  c2 ⎦ ⎣ 0 -s1 c1 ⎦
+   */
+  res[0] = c3c2;  res[4] = s3c1 + c3s2s1;  res[8] = s3s1 - c3s2c1; res[12] = 0.f;
+  res[1] = -s3c2; res[5] = c3c1 - s3s2s1;  res[9] = c3s1 + s3s2c1; res[13] = 0.f;
+  res[2] = s2;    res[6] = -c2s1;         res[10] = c2c1;          res[14] = 0.f;
+  res[3] = 0.f;   res[7] = 0.f;           res[11] = 0.f;           res[15] = 1.f;
+}
+
+void Example_GLArea::draw_triangle()
+{
+  float mvp[16];
+
+  compute_mvp(mvp,
+              m_RotationAngles[X_AXIS],
+              m_RotationAngles[Y_AXIS],
+              m_RotationAngles[Z_AXIS]);
+
+  glUseProgram(m_Program);
+
+  glUniformMatrix4fv(m_Mvp, 1, GL_FALSE, &mvp[0]);
+
+  glBindBuffer(GL_ARRAY_BUFFER, m_Vao);
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
+
+  glDrawArrays(GL_TRIANGLES, 0, 3);
+
+  glDisableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glUseProgram(0);
+}
diff --git a/demos/gtk-demo/glarea-fragment.glsl b/demos/gtk-demo/glarea-fragment.glsl
new file mode 100644
index 0000000..aaa7305
--- /dev/null
+++ b/demos/gtk-demo/glarea-fragment.glsl
@@ -0,0 +1,9 @@
+#version 330
+
+out vec4 outputColor;
+
+void main() {
+  float lerpVal = gl_FragCoord.y / 500.0f;
+
+  outputColor = mix(vec4(1.0f, 0.85f, 0.35f, 1.0f), vec4(0.2f, 0.2f, 0.2f, 1.0f), lerpVal);
+}
diff --git a/demos/gtk-demo/glarea-vertex.glsl b/demos/gtk-demo/glarea-vertex.glsl
new file mode 100644
index 0000000..163f6ef
--- /dev/null
+++ b/demos/gtk-demo/glarea-vertex.glsl
@@ -0,0 +1,8 @@
+#version 330
+
+layout(location = 0) in vec4 position;
+uniform mat4 mvp;
+
+void main() {
+  gl_Position = mvp * position;
+}
diff --git a/gdk/gdkmm.h b/gdk/gdkmm.h
index 244ea0d..6848c11 100644
--- a/gdk/gdkmm.h
+++ b/gdk/gdkmm.h
@@ -32,6 +32,7 @@
 #include <gdkmm/pixbufloader.h>
 #include <gdkmm/applaunchcontext.h>
 #include <gdkmm/cursor.h>
+#include <gdkmm/glcontext.h>
 #include <gdkmm/rectangle.h>
 #include <gdkmm/display.h>
 #include <gdkmm/displaymanager.h>
diff --git a/gdk/src/filelist.am b/gdk/src/filelist.am
index 91158d4..bbd5860 100644
--- a/gdk/src/filelist.am
+++ b/gdk/src/filelist.am
@@ -21,6 +21,7 @@ gdkmm_files_any_hg =          \
        displaymanager.hg       \
        dragcontext.hg          \
        event.hg                \
+       glcontext.hg            \
        pixbuf.hg               \
        pixbufanimation.hg      \
        pixbufanimationiter.hg  \
diff --git a/gdk/src/gdk_docs.xml b/gdk/src/gdk_docs.xml
index 836e6c4..d92e74d 100644
--- a/gdk/src/gdk_docs.xml
+++ b/gdk/src/gdk_docs.xml
@@ -1362,7 +1362,7 @@ Since: 3.8
 
 <property name="GdkGLContext:display">
 <description>
-The #GdkWindow the gl context is bound to.
+The #GdkDisplay used to create the #GdkGLContext.
 
 Since: 3.16
 
diff --git a/gdk/src/gdk_signals.defs b/gdk/src/gdk_signals.defs
index dce4204..decdd58 100644
--- a/gdk/src/gdk_signals.defs
+++ b/gdk/src/gdk_signals.defs
@@ -266,3 +266,31 @@
   (construct-only #f)
 )
 
+;; From GdkGLContext
+
+(define-property display
+  (of-object "GdkGLContext")
+  (prop-type "GParamObject")
+  (docs "The GDK display the context is from")
+  (readable #t)
+  (writable #t)
+  (construct-only #t)
+)
+
+(define-property window
+  (of-object "GdkGLContext")
+  (prop-type "GParamObject")
+  (docs "The GDK window bound to the GL context")
+  (readable #t)
+  (writable #t)
+  (construct-only #t)
+)
+
+(define-property shared-context
+  (of-object "GdkGLContext")
+  (prop-type "GParamObject")
+  (docs "The GL context this context share data with")
+  (readable #t)
+  (writable #t)
+  (construct-only #t)
+)
diff --git a/gdk/src/glcontext.ccg b/gdk/src/glcontext.ccg
new file mode 100644
index 0000000..a983de1
--- /dev/null
+++ b/gdk/src/glcontext.ccg
@@ -0,0 +1,23 @@
+/* Copyright (C) 2015 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <gdk/gdk.h>
+
+namespace Gdk
+{
+
+} // namespace Gdk
diff --git a/gdk/src/glcontext.hg b/gdk/src/glcontext.hg
new file mode 100644
index 0000000..1a536be
--- /dev/null
+++ b/gdk/src/glcontext.hg
@@ -0,0 +1,65 @@
+/* Copyright (C) 2015 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <gdkmmconfig.h>
+#include <gdkmm/display.h>
+#include <gdkmm/window.h>
+
+_DEFS(gdkmm,gdk)
+_PINCLUDE(glibmm/private/object_p.h)
+
+namespace Gdk
+{
+
+_WRAP_GERROR(GLError, GdkGLError, GDK_GL_ERROR, newin "3,18")
+
+/** A Gdk::GLContext is an OpenGL context abstraction. It's a low-level object, used to implement high-level 
objects such
+ * as Gtk::GLArea on the GTK+ level.
+ * @newin{3,18}
+ */
+class GLContext : public Glib::Object
+{
+  _CLASS_GOBJECT(GLContext,GdkGLContext,GDK_GL_CONTEXT,Glib::Object,GObject)
+
+protected:
+  _CTOR_DEFAULT
+
+public:
+  _WRAP_METHOD(Glib::RefPtr<Display> get_display(), gdk_gl_context_get_display, refreturn, newin "3,18")
+  _WRAP_METHOD(Glib::RefPtr<const Display> get_display() const, gdk_gl_context_get_display, refreturn, 
constversion, newin "3,18")
+  _WRAP_METHOD(Glib::RefPtr<Window> get_window(), gdk_gl_context_get_window, refreturn, newin "3,18")
+  _WRAP_METHOD(Glib::RefPtr<const Window> get_window() const, gdk_gl_context_get_window, refreturn, 
constversion, newin "3,18")
+  _WRAP_METHOD(Glib::RefPtr<GLContext> get_shared_context(), gdk_gl_context_get_shared_context, refreturn, 
newin "3,18")
+  _WRAP_METHOD(Glib::RefPtr<const GLContext> get_shared_context() const, gdk_gl_context_get_shared_context, 
refreturn, constversion, newin "3,18")
+  _WRAP_METHOD(void get_version(int& major, int& minor) const, gdk_gl_context_get_version, newin "3,18")
+  _WRAP_METHOD(void get_required_version(int& major, int& minor) const, gdk_gl_context_get_required_version, 
newin "3,18")
+  _WRAP_METHOD(void set_required_version(int major, int minor), gdk_gl_context_set_required_version, newin 
"3,18")
+  _WRAP_METHOD(bool get_debug_enabled() const, gdk_gl_context_get_debug_enabled, newin "3,18")
+  _WRAP_METHOD(void set_debug_enabled(bool enabled = true), gdk_gl_context_set_debug_enabled, newin "3,18")
+  _WRAP_METHOD(bool get_forward_compatible() const, gdk_gl_context_get_forward_compatible, newin "3,18")
+  _WRAP_METHOD(void set_forward_compatible(bool compatible = true), gdk_gl_context_set_forward_compatible, 
newin "3,18")
+  _WRAP_METHOD(bool realize(), gdk_gl_context_realize, errthrow, newin "3,18")
+  _WRAP_METHOD(void make_current(), gdk_gl_context_make_current, newin "3,18")
+  _WRAP_METHOD(static Glib::RefPtr<GLContext> get_current(), gdk_gl_context_get_current, refreturn, newin 
"3,18")
+  _WRAP_METHOD(static void clear_current(), gdk_gl_context_clear_current, newin "3,18")
+
+  _WRAP_PROPERTY("display", Glib::RefPtr<Display>, newin "3,18")
+  _WRAP_PROPERTY("shared-context", Glib::RefPtr<GLContext>, newin "3,18")
+  _WRAP_PROPERTY("window", Glib::RefPtr<Window>, newin "3,18")
+};
+
+} // namespace Gdk
diff --git a/gdk/src/window.ccg b/gdk/src/window.ccg
index eda9989..15b4196 100644
--- a/gdk/src/window.ccg
+++ b/gdk/src/window.ccg
@@ -19,7 +19,7 @@
 #include <gdkmm/cursor.h>
 #include <gdkmm/device.h>
 #include <gdkmm/types.h>
-
+#include <gdkmm/glcontext.h>
 
 namespace Gdk
 {
diff --git a/gdk/src/window.hg b/gdk/src/window.hg
index ebb6f49..971b8d7 100644
--- a/gdk/src/window.hg
+++ b/gdk/src/window.hg
@@ -47,6 +47,7 @@ _WRAP_ENUM(FullscreenMode, GdkFullscreenMode)
 
 class Cursor;
 class Pixbuf;
+class GLContext;
 
 /** A Gdk::Window is a rectangular region on the screen. It's a low-level object, used to implement 
high-level objects such
  * as Gtk::Widget and Gtk::Window on the GTK+ level. A Gtk::Window is a toplevel window, the thing a user 
might think of as
@@ -395,6 +396,22 @@ public:
   //TODO: Use Gdk::Event when we use it elsewhere - See also, for instance, Gdk::Display::put_event().
   _WRAP_METHOD(bool show_window_menu(GdkEvent* event), gdk_window_show_window_menu)
 
+  /** Creates a new GLContext matching the framebuffer format to the visual of the
+   * Window. The context is disconnected from any particular window or surface.
+   *
+   * If the creation of the GLContext failed an error will be thrown.
+   *
+   * Before using the returned GLContext, you will need to call
+   * GLContext::make_current() or GLContext::realize().
+   *
+   * @newin{3,18}
+   *
+   * @return GLContext The newly created context.
+   *
+   * @throws GLError On missing GL implementation or extension required for context creation.
+   */
+  _WRAP_METHOD(Glib::RefPtr<Gdk::GLContext> create_gl_context(), gdk_window_create_gl_context, refreturn, 
errthrow)
+
   _WRAP_PROPERTY("cursor", Glib::RefPtr<Cursor>)
 };
 
diff --git a/gtk/gtkmm.h b/gtk/gtkmm.h
index c656130..7e64304 100644
--- a/gtk/gtkmm.h
+++ b/gtk/gtkmm.h
@@ -174,6 +174,7 @@ extern const int gtkmm_micro_version;
 #include <gtkmm/gesturesingle.h>
 #include <gtkmm/gestureswipe.h>
 #include <gtkmm/gesturezoom.h>
+#include <gtkmm/glarea.h>
 #include <gtkmm/grid.h>
 #include <gtkmm/handlebox.h>
 #include <gtkmm/headerbar.h>
diff --git a/gtk/src/filelist.am b/gtk/src/filelist.am
index ba40433..11e131a 100644
--- a/gtk/src/filelist.am
+++ b/gtk/src/filelist.am
@@ -94,6 +94,7 @@ gtkmm_files_any_hg =          \
        gesturesingle.hg        \
        gestureswipe.hg \
        gesturezoom.hg  \
+       glarea.hg                       \
        grid.hg                 \
        headerbar.hg    \
        hvbox.hg                \
diff --git a/gtk/src/glarea.ccg b/gtk/src/glarea.ccg
new file mode 100644
index 0000000..8e457e1
--- /dev/null
+++ b/gtk/src/glarea.ccg
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2015 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <gtk/gtk.h>
+
+namespace Gtk
+{
+
+bool GLArea::has_error() const
+{
+  return gtk_gl_area_get_error(const_cast<GtkGLArea*>(gobj()));
+}
+
+void GLArea::throw_if_error() const
+{
+  GError* error = gtk_gl_area_get_error(const_cast<GtkGLArea*>(gobj()));
+  if(error)
+  {
+    Glib::Error::throw_exception(g_error_copy(error));
+  }
+}
+
+void GLArea::unset_error()
+{
+  gtk_gl_area_set_error(gobj(), nullptr);
+}
+
+} //namespace Gtk
diff --git a/gtk/src/glarea.hg b/gtk/src/glarea.hg
new file mode 100644
index 0000000..686bba9
--- /dev/null
+++ b/gtk/src/glarea.hg
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2015 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <gtkmm/widget.h>
+_DEFS(gtkmm,gtk)
+_PINCLUDE(gtkmm/private/widget_p.h)
+
+#include <gdkmm/glcontext.h>
+
+namespace Gtk
+{
+
+/** A widget used for drawing with OpenGL.
+ * @newin{3,18}
+ * @ingroup Widgets
+ */
+class GLArea : public Widget
+{
+  _CLASS_GTKOBJECT(GLArea,GtkGLArea,GTK_GL_AREA,Gtk::Widget,GtkWidget)
+public:
+
+  _CTOR_DEFAULT
+
+  _WRAP_METHOD(Glib::RefPtr<Gdk::GLContext> get_context(), gtk_gl_area_get_context, refreturn, newin "3,18")
+  _WRAP_METHOD(Glib::RefPtr<const Gdk::GLContext> get_context() const, gtk_gl_area_get_context, refreturn, 
constversion, newin "3,18")
+  _WRAP_METHOD(void make_current(), gtk_gl_area_make_current, newin "3,18")
+  _WRAP_METHOD(void queue_render(), gtk_gl_area_queue_render, newin "3,18")
+  _WRAP_METHOD(void attach_buffers(), gtk_gl_area_attach_buffers, newin "3,18")
+  /** Check if any error is currently set on this <i>area</i>.
+   *
+   * The error may be obtained by using throw_if_error() and
+   * set using set_error().
+   *
+   * @newin{3,18}
+   *
+   * @return true if an error is currently set.
+   */
+  bool has_error() const;
+
+  _IGNORE(gtk_gl_area_get_error)
+  /** Will throw the correct Glib::Error subclass if
+   * any is currently set on this <i>area</i>.
+   *
+   * @newin{3,18}
+   *
+   * @throw Throws any currently set error (e.g. Gdk::GLError).
+   */
+  void throw_if_error() const;
+
+#m4 _CONVERSION(`const Glib::Error&', `const GError*', __FR2P)
+  /** Sets an error on the <i>area</i> which will be shown
+   * instead of GL rendering.
+   *
+   * This is useful in the signal_create_context() handler
+   * if GL context creation fails.
+   *
+   * @newin{3,18}
+   *
+   * @param error The error to set on the <i>area</i>.
+   */
+  _WRAP_METHOD(void set_error(const Glib::Error& error), gtk_gl_area_set_error)
+  /** Clears any previous set error on this <i>area</i> made with set_error().
+   *
+   * @newin{3,18}
+   */
+  void unset_error();
+  _WRAP_METHOD(bool get_has_alpha() const, gtk_gl_area_get_has_alpha, newin "3,18")
+  _WRAP_METHOD(void set_has_alpha(bool has_alpha = true), gtk_gl_area_set_has_alpha, newin "3,18")
+  _WRAP_METHOD(bool get_has_depth_buffer() const, gtk_gl_area_get_has_depth_buffer, newin "3,18")
+  _WRAP_METHOD(void set_has_depth_buffer(bool has_depth_buffer = true), gtk_gl_area_set_has_depth_buffer, 
newin "3,18")
+  _WRAP_METHOD(bool get_has_stencil_buffer() const, gtk_gl_area_get_has_stencil_buffer, newin "3,18")
+  _WRAP_METHOD(void set_has_stencil_buffer(bool has_stencil_buffer = true), 
gtk_gl_area_set_has_stencil_buffer, newin "3,18")
+  _WRAP_METHOD(bool get_auto_render() const, gtk_gl_area_get_auto_render, newin "3,18")
+  _WRAP_METHOD(void set_auto_render(bool auto_render = true), gtk_gl_area_set_auto_render, newin "3,18")
+  _WRAP_METHOD(void get_required_version(int& major, int& minor) const, gtk_gl_area_get_required_version, 
newin "3,18")
+  _WRAP_METHOD(void set_required_version(int major, int minor), gtk_gl_area_set_required_version, newin 
"3,18")
+
+  _WRAP_PROPERTY("auto-render", bool, newin "3,18")
+  _WRAP_PROPERTY("context", Glib::RefPtr<Gdk::GLContext>, newin "3,18")
+  _WRAP_PROPERTY("has-alpha", bool, newin "3,18")
+  _WRAP_PROPERTY("has-depth-buffer", bool, newin "3,18")
+  _WRAP_PROPERTY("has-stencil-buffer", bool, newin "3,18")
+
+#m4 _CONVERSION(`Glib::RefPtr<Gdk::GLContext>', `GdkGLContext*', Glib::unwrap($3))
+  _WRAP_SIGNAL(Glib::RefPtr<Gdk::GLContext> create_context(), "create_context", newin "3,18")
+#m4 _CONVERSION(`GdkGLContext*', `const Glib::RefPtr<Gdk::GLContext>&', Glib::wrap($3, true))
+  _WRAP_SIGNAL(bool render(const Glib::RefPtr<Gdk::GLContext>& context), render, newin "3,18")
+  _WRAP_SIGNAL(void resize(int width, int height), "resize", newin "3,18")
+
+};
+
+} //namespace Gtk
diff --git a/gtk/src/gtk_signals.defs b/gtk/src/gtk_signals.defs
index 7ac21a3..5a079bc 100644
--- a/gtk/src/gtk_signals.defs
+++ b/gtk/src/gtk_signals.defs
@@ -4739,6 +4739,78 @@
   )
 )
 
+;; From GtkGLArea
+
+(define-signal resize
+  (of-object "GtkGLArea")
+  (return-type "void")
+  (when "last")
+  (parameters
+    '("gint" "p0")
+    '("gint" "p1")
+  )
+)
+
+(define-signal render
+  (of-object "GtkGLArea")
+  (return-type "gboolean")
+  (when "last")
+  (parameters
+    '("GdkGLContext*" "p0")
+  )
+)
+
+(define-signal create-context
+  (of-object "GtkGLArea")
+  (return-type "GdkGLContext*")
+  (when "last")
+)
+
+(define-property context
+  (of-object "GtkGLArea")
+  (prop-type "GParamObject")
+  (docs "The GL context")
+  (readable #t)
+  (writable #f)
+  (construct-only #f)
+)
+
+(define-property has-alpha
+  (of-object "GtkGLArea")
+  (prop-type "GParamBoolean")
+  (docs "Whether the color buffer has an alpha component")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
+(define-property has-depth-buffer
+  (of-object "GtkGLArea")
+  (prop-type "GParamBoolean")
+  (docs "Whether a depth buffer is allocated")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
+(define-property has-stencil-buffer
+  (of-object "GtkGLArea")
+  (prop-type "GParamBoolean")
+  (docs "Whether a stencil buffer is allocated")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
+(define-property auto-render
+  (of-object "GtkGLArea")
+  (prop-type "GParamBoolean")
+  (docs "Whether the GtkGLArea renders on each redraw")
+  (readable #t)
+  (writable #t)
+  (construct-only #f)
+)
+
 ;; From GtkGrid
 
 (define-property row-spacing
diff --git a/tools/extra_defs_gen/generate_defs_gdk.cc b/tools/extra_defs_gen/generate_defs_gdk.cc
index f625270..8a45c99 100644
--- a/tools/extra_defs_gen/generate_defs_gdk.cc
+++ b/tools/extra_defs_gen/generate_defs_gdk.cc
@@ -48,6 +48,7 @@ int main(int argc, char** argv)
             << get_defs( GDK_TYPE_SCREEN )
             << get_defs( GDK_TYPE_VISUAL )
             << get_defs( GDK_TYPE_WINDOW )
+            << get_defs( GDK_TYPE_GL_CONTEXT )
             ;
   return 0;
 }
diff --git a/tools/extra_defs_gen/generate_defs_gtk.cc b/tools/extra_defs_gen/generate_defs_gtk.cc
index 633048b..db96a48 100644
--- a/tools/extra_defs_gen/generate_defs_gtk.cc
+++ b/tools/extra_defs_gen/generate_defs_gtk.cc
@@ -132,6 +132,7 @@ int main(int argc, char** argv)
             << get_defs( GTK_TYPE_GESTURE_SINGLE )
             << get_defs( GTK_TYPE_GESTURE_SWIPE )
             << get_defs( GTK_TYPE_GESTURE_ZOOM )
+            << get_defs( GTK_TYPE_GL_AREA )
             << get_defs( GTK_TYPE_GRID )
             << get_defs( GTK_TYPE_HANDLE_BOX )
             << get_defs( GTK_TYPE_HEADER_BAR )
diff --git a/tools/m4/convert_gdk.m4 b/tools/m4/convert_gdk.m4
index da869cb..a0ef8b4 100644
--- a/tools/m4/convert_gdk.m4
+++ b/tools/m4/convert_gdk.m4
@@ -68,6 +68,7 @@ _CONV_ENUM(Gdk,WMDecoration)
 _CONV_ENUM(Gdk,WMFunction)
 _CONV_ENUM(Gdk,GrabStatus)
 _CONV_ENUM(Gdk,PixbufRotation)
+_CONV_ENUM(Gdk,GLError)
 
 _CONVERSION(`guint32&',`guint32*',`&($3)')
 
@@ -113,6 +114,8 @@ _CONVERSION(`const Glib::RefPtr<const Cursor>&',`GdkCursor*',__CONVERT_CONST_REF
 _CONVERSION(`const Glib::RefPtr<Gdk::Pixmap>&',`GdkPixmap*',__CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Gdk::Window>&',`GdkWindow*',__CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Window>&',`GdkWindow*',__CONVERT_REFPTR_TO_P)
+_CONVERSION(`const Glib::RefPtr<GLContext>&',`GdkGLContext*',__CONVERT_REFPTR_TO_P)
+_CONVERSION(`const Glib::RefPtr<Gdk::GLContext>&',`GdkGLContext*',__CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Pixmap>&',`GdkPixmap*',__CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Gdk::Pixmap>&',`GdkPixmap*',__CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Bitmap>&',`GdkBitmap*',__CONVERT_REFPTR_TO_P)
@@ -170,6 +173,8 @@ _CONVERSION(`const Glib::RefPtr<const Gdk::Device>&', `GdkDevice*',__CONVERT_CON
 _CONVERSION(`const Glib::RefPtr<const Gdk::Pixmap>&', 
`GdkPixmap*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::Pixmap))
 _CONVERSION(`const Glib::RefPtr<const Gdk::Window>&', 
`GdkWindow*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::Window))
 _CONVERSION(`const Glib::RefPtr<const Window>&', `GdkWindow*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::Window))
+_CONVERSION(`const Glib::RefPtr<const Gdk::GLContext>&', 
`GdkGLContext*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::GLContext))
+_CONVERSION(`const Glib::RefPtr<const GLContext>&', 
`GdkGLContext*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::GLContext))
 _CONVERSION(`const Glib::RefPtr<const Gdk::Colormap>&', 
`GdkColormap*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::Colormap))
 _CONVERSION(`const Glib::RefPtr<const Gdk::Visual>&', 
`GdkVisual*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::Visual))
 _CONVERSION(`const Glib::RefPtr<const Gdk::Bitmap>&', 
`GdkBitmap*',__CONVERT_CONST_REFPTR_TO_P_SUN(Gdk::Bitmap))
@@ -186,6 +191,10 @@ _CONVERSION(`GdkWindow*',`Glib::RefPtr<Window>', `Glib::wrap($3)')
 _CONVERSION(`GdkWindow*',`Glib::RefPtr<const Window>', `Glib::wrap($3)')
 _CONVERSION(`GdkWindow*',`Glib::RefPtr<Gdk::Window>', `Glib::wrap($3)')
 _CONVERSION(`GdkWindow*',`Glib::RefPtr<const Gdk::Window>', `Glib::wrap($3)')
+_CONVERSION(`GdkGLContext*',`Glib::RefPtr<GLContext>', `Glib::wrap($3)')
+_CONVERSION(`GdkGLContext*',`Glib::RefPtr<const GLContext>', `Glib::wrap($3)')
+_CONVERSION(`GdkGLContext*',`Glib::RefPtr<Gdk::GLContext>', `Glib::wrap($3)')
+_CONVERSION(`GdkGLContext*',`Glib::RefPtr<const Gdk::GLContext>', `Glib::wrap($3)')
 _CONVERSION(`GdkPixmap*',`Glib::RefPtr<Pixmap>', `Glib::wrap((GdkPixmapObject*)($3))')
 _CONVERSION(`GdkPixmap*',`Glib::RefPtr<const Pixmap>', `Glib::wrap((GdkPixmapObject*)($3))')
 _CONVERSION(`GdkPixmap*',`Glib::RefPtr<const Gdk::Pixmap>', `Glib::wrap((GdkPixmapObject*)($3))')
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]