diff options
Diffstat (limited to 'x11-toolkits/gtkada3/files/patch-namespace')
| -rw-r--r-- | x11-toolkits/gtkada3/files/patch-namespace | 727 |
1 files changed, 727 insertions, 0 deletions
diff --git a/x11-toolkits/gtkada3/files/patch-namespace b/x11-toolkits/gtkada3/files/patch-namespace new file mode 100644 index 000000000000..03ff6f5893b7 --- /dev/null +++ b/x11-toolkits/gtkada3/files/patch-namespace @@ -0,0 +1,727 @@ +Workaround for name collisions with stuff that was added to GTK+ + +http://pkgs.fedoraproject.org/cgit/GtkAda3.git/tree/GtkAda-3.8.2-namespace.patch + +diff -u --recursive src/opengl/gdk-gl.adb src/opengl/gdk-gl.adb +--- src/opengl/gdk-gl.adb 2014-01-06 11:22:20.000000000 +0100 ++++ src/opengl/gdk-gl.adb 2015-03-21 20:25:54.034038707 +0100 +@@ -32,7 +32,7 @@ + function Query return Boolean + is + function Internal return Gint; +- pragma Import (C, Internal, "gdk_gl_query"); ++ pragma Import (C, Internal, "gdkada_gl_query"); + begin + return Boolean'Val (Internal); + end Query; +diff -u --recursive src/opengl/gdkgl.c src/opengl/gdkgl.c +--- src/opengl/gdkgl.c 2014-01-06 11:22:20.000000000 +0100 ++++ src/opengl/gdkgl.c 2015-03-21 20:23:58.813868867 +0100 +@@ -39,16 +39,16 @@ + #endif + + /* +- * The GdkGLContext class ++ * The GdkadaGLContext class + */ +-struct _GdkGLContext { ++struct _GdkadaGLContext { + GObject parent; + #if defined GDK_WINDOWING_WIN32 + gboolean initialised; + HGLRC hglrc; + HDC hdc; + HWND hwnd; +- GdkGLContext *share; ++ GdkadaGLContext *share; + PIXELFORMATDESCRIPTOR pfd; + #elif defined GDK_WINDOWING_X11 + Display *xdisplay; +@@ -56,13 +56,13 @@ + #endif + }; + +-struct _GdkGLContextClass { ++struct _GdkadaGLContextClass { + GObjectClass parent_class; + }; +-typedef struct _GdkGLContextClass GdkGLContextClass; ++typedef struct _GdkadaGLContextClass GdkadaGLContextClass; + + static GObjectClass *glcontext_parent_class; +-static void gdk_gl_context_class_init (GdkGLContextClass *class); ++static void gdkada_gl_context_class_init (GdkadaGLContextClass *class); + + /* + * Local helper functions +@@ -78,7 +78,7 @@ + * Generic GL support + */ + +-gint gdk_gl_query(void) ++gint gdkada_gl_query(void) + { + #if defined GDK_WINDOWING_WIN32 + return TRUE; +@@ -90,7 +90,7 @@ + } + + +-gchar *gdk_gl_get_info() ++gchar *gdkada_gl_get_info() + { + char const *vendor, *version, *extensions; + #if defined GDK_WINDOWING_WIN32 +@@ -111,7 +111,7 @@ + } + + +-GdkVisual *gdk_gl_choose_visual(int *attrlist) ++GdkVisual *gdkada_gl_choose_visual(int *attrlist) + { + #if defined GDK_WINDOWING_WIN32 + return gdk_visual_get_system (); +@@ -131,13 +131,13 @@ + XFree(vi); + return visual; + #else +- g_warning ("gdk_gl_choose_visual not implemented on " PLATFORM); ++ g_warning ("gdkada_gl_choose_visual not implemented on " PLATFORM); + return NULL; + #endif + } + + +-int gdk_gl_get_config(GdkVisual *visual, int attrib) ++int gdkada_gl_get_config(GdkVisual *visual, int attrib) + { + #if defined GDK_WINDOWING_X11 + Display *dpy; +@@ -158,7 +158,7 @@ + XFree(vi); + return -1; + #else +- g_warning ("gdk_gl_get_config not implemented on " PLATFORM); ++ g_warning ("gdkada_gl_get_config not implemented on " PLATFORM); + return 0; + #endif + } +@@ -169,7 +169,7 @@ + */ + + GType +-gdk_gl_context_get_type (void) ++gdkada_gl_context_get_type (void) + { + static GType object_type = 0; + +@@ -177,30 +177,30 @@ + { + static const GTypeInfo object_info = + { +- sizeof (GdkGLContextClass), ++ sizeof (GdkadaGLContextClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, +- (GClassInitFunc) gdk_gl_context_class_init, ++ (GClassInitFunc) gdkada_gl_context_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ +- sizeof (GdkGLContext), ++ sizeof (GdkadaGLContext), + 0, /* n_preallocs */ + (GInstanceInitFunc) NULL, + }; + + object_type = g_type_register_static (G_TYPE_OBJECT, +- "GdkGLContext", ++ "GdkadaGLContext", + &object_info, 0); + } + return object_type; + } + + static void +-gdk_gl_context_finalize(GObject *object) ++gdkada_gl_context_finalize(GObject *object) + { +- GdkGLContext *context; ++ GdkadaGLContext *context; + +- context = GDK_GL_CONTEXT(object); ++ context = GDKADA_GL_CONTEXT(object); + + #if defined GDK_WINDOWING_WIN32 + if (context->hglrc == wglGetCurrentContext ()) +@@ -227,47 +227,47 @@ + + + static void +-gdk_gl_context_class_init(GdkGLContextClass *class) ++gdkada_gl_context_class_init(GdkadaGLContextClass *class) + { + GObjectClass *gobject_class; + + gobject_class = G_OBJECT_CLASS(class); + glcontext_parent_class = g_type_class_peek_parent(class); + +- gobject_class->finalize = gdk_gl_context_finalize; ++ gobject_class->finalize = gdkada_gl_context_finalize; + } + + +-GdkGLContext * +-gdk_gl_context_new(GdkVisual *visual) ++GdkadaGLContext * ++gdkada_gl_context_new(GdkVisual *visual) + { + #if defined GDK_WINDOWING_WIN32 || defined GDK_WINDOWING_X11 +- return gdk_gl_context_share_new(visual, NULL, FALSE); ++ return gdkada_gl_context_share_new(visual, NULL, FALSE); + #else +- g_warning ("gdk_gl_context_new not implemented on " PLATFORM); ++ g_warning ("gdkada_gl_context_new not implemented on " PLATFORM); + return NULL; + #endif + } + + +-GdkGLContext * +-gdk_gl_context_share_new(GdkVisual *visual, GdkGLContext *sharelist, gint direct) ++GdkadaGLContext * ++gdkada_gl_context_share_new(GdkVisual *visual, GdkadaGLContext *sharelist, gint direct) + { + #if defined GDK_WINDOWING_WIN32 +- GdkGLContext *context; ++ GdkadaGLContext *context; + #elif defined GDK_WINDOWING_X11 + Display *dpy; + XVisualInfo *vi; + GLXContext glxcontext; +- GdkGLContext *context; ++ GdkadaGLContext *context; + #else +- g_warning ("gdk_gl_context_share_new not implemented on " PLATFORM); ++ g_warning ("gdkada_gl_context_share_new not implemented on " PLATFORM); + return NULL; + #endif + + g_return_val_if_fail (visual != NULL, NULL); + +- context = g_object_new(GDK_TYPE_GL_CONTEXT, NULL); ++ context = g_object_new(GDKADA_TYPE_GL_CONTEXT, NULL); + if (!context) + return NULL; + +@@ -313,21 +313,21 @@ + return context; + } + +-GdkGLContext *gdk_gl_context_attrlist_share_new(int *attrlist, GdkGLContext *sharelist, gint direct) ++GdkadaGLContext *gdkada_gl_context_attrlist_share_new(int *attrlist, GdkadaGLContext *sharelist, gint direct) + { + #if defined GDK_WINDOWING_WIN32 +- GdkGLContext *context; ++ GdkadaGLContext *context; + #elif defined GDK_WINDOWING_X11 + GdkVisual *visual; + #else +- g_warning ("gdk_gl_context_attrlist_share_new not implemented on " PLATFORM); ++ g_warning ("gdkada_gl_context_attrlist_share_new not implemented on " PLATFORM); + return NULL; + #endif + + g_return_val_if_fail(attrlist != NULL, NULL); + + #if defined GDK_WINDOWING_WIN32 +- context = g_object_new(GDK_TYPE_GL_CONTEXT, NULL); ++ context = g_object_new(GDKADA_TYPE_GL_CONTEXT, NULL); + if (!context) + return NULL; + +@@ -340,19 +340,19 @@ + + return context; + #elif defined GDK_WINDOWING_X11 +- visual = gdk_gl_choose_visual(attrlist); ++ visual = gdkada_gl_choose_visual(attrlist); + if (!visual) + return NULL; + +- return gdk_gl_context_share_new(visual, sharelist, direct); ++ return gdkada_gl_context_share_new(visual, sharelist, direct); + #endif + } + + +-gint gdk_gl_make_current(GdkWindow *window, GdkGLContext *context) ++gint gdkada_gl_make_current(GdkWindow *window, GdkadaGLContext *context) + { + // g_return_val_if_fail (GDK_IS_DRAWABLE(drawable), FALSE); +-// g_return_val_if_fail (GDK_IS_GL_CONTEXT(context), FALSE); ++// g_return_val_if_fail (GDKADA_IS_GL_CONTEXT(context), FALSE); + + #if defined GDK_WINDOWING_WIN32 + if (!context->initialised) +@@ -405,11 +405,11 @@ + } + #endif + #else +- g_warning ("gdk_gl_make_current not implemented on " PLATFORM); ++ g_warning ("gdkada_gl_make_current not implemented on " PLATFORM); + #endif + } + +-void gdk_gl_swap_buffers(GdkWindow *window) ++void gdkada_gl_swap_buffers(GdkWindow *window) + { + #if defined GDK_WINDOWING_WIN32 + HDC hdc; +@@ -423,7 +423,7 @@ + hdc = GetDC (hwnd); + if (hdc == NULL) + { +- g_warning ("gdk_gl_swap_buffers: GetDC failed"); ++ g_warning ("gdkada_gl_swap_buffers: GetDC failed"); + return; + } + SwapBuffers (hdc); +@@ -431,11 +431,11 @@ + #elif defined GDK_WINDOWING_X11 + glXSwapBuffers(GDK_WINDOW_XDISPLAY(window), gdk_x11_window_get_xid(window)); + #else +- g_warning ("gdk_gl_swap_buffers not implemented on " PLATFORM); ++ g_warning ("gdkada_gl_swap_buffers not implemented on " PLATFORM); + #endif + } + +-void gdk_gl_wait_gdk(void) ++void gdkada_gl_wait_gdk(void) + { + #if defined GDK_WINDOWING_WIN32 + GdiFlush(); +@@ -444,7 +444,7 @@ + #endif + } + +-void gdk_gl_wait_gl (void) ++void gdkada_gl_wait_gl (void) + { + #if defined GDK_WINDOWING_WIN32 + glFinish(); +diff -u --recursive src/opengl/gdkgl.h src/opengl/gdkgl.h +--- src/opengl/gdkgl.h 2014-01-06 11:49:08.000000000 +0100 ++++ src/opengl/gdkgl.h 2015-03-21 20:17:59.401585102 +0100 +@@ -17,8 +17,8 @@ + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +-#ifndef __GDK_GL_H__ +-#define __GDK_GL_H__ ++#ifndef __GDKADA_GL_H__ ++#define __GDKADA_GL_H__ + + #include <glib.h> + #include <cairo/cairo.h> +@@ -71,46 +71,46 @@ + }; + + +-#define GDK_TYPE_GL_CONTEXT (gdk_gl_context_get_type()) +-#define GDK_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_CONTEXT, GdkGLContext)) +-#define GDK_GL_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDK_TYPE_GL_CONTEXT, GdkGLContextClass)) +-#define GDK_IS_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_CONTEXT)) +-#define GDK_IS_GL_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GL_CONTEXT)) +-#define GDK_GL_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GL_CONTEXT, GdkGLContext)) ++#define GDKADA_TYPE_GL_CONTEXT (gdkada_gl_context_get_type()) ++#define GDKADA_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDKADA_TYPE_GL_CONTEXT, GdkadaGLContext)) ++#define GDKADA_GL_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GDKADA_TYPE_GL_CONTEXT, GdkadaGLContextClass)) ++#define GDKADA_IS_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDKADA_TYPE_GL_CONTEXT)) ++#define GDKADA_IS_GL_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDKADA_TYPE_GL_CONTEXT)) ++#define GDKADA_GL_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDKADA_TYPE_GL_CONTEXT, GdkadaGLContext)) + +-typedef struct _GdkGLContext GdkGLContext; ++typedef struct _GdkadaGLContext GdkadaGLContext; + + +-gint gdk_gl_query(void); +-gchar *gdk_gl_get_info(void); ++gint gdkada_gl_query(void); ++gchar *gdkada_gl_get_info(void); + +-GdkVisual *gdk_gl_choose_visual(int *attrlist); +-int gdk_gl_get_config(GdkVisual *visual, int attrib); ++GdkVisual *gdkada_gl_choose_visual(int *attrlist); ++int gdkada_gl_get_config(GdkVisual *visual, int attrib); + +-GType gdk_gl_context_get_type(void); +-GdkGLContext *gdk_gl_context_new(GdkVisual *visual); +-GdkGLContext *gdk_gl_context_share_new(GdkVisual *visual, GdkGLContext *sharelist, gint direct); +-GdkGLContext *gdk_gl_context_attrlist_share_new(int *attrlist, GdkGLContext *sharelist, gint direct); ++GType gdkada_gl_context_get_type(void); ++GdkadaGLContext *gdkada_gl_context_new(GdkVisual *visual); ++GdkadaGLContext *gdkada_gl_context_share_new(GdkVisual *visual, GdkadaGLContext *sharelist, gint direct); ++GdkadaGLContext *gdkada_gl_context_attrlist_share_new(int *attrlist, GdkadaGLContext *sharelist, gint direct); + +-gint gdk_gl_make_current(GdkWindow *window, GdkGLContext *context); +-void gdk_gl_swap_buffers(GdkWindow *window); ++gint gdkada_gl_make_current(GdkWindow *window, GdkadaGLContext *context); ++void gdkada_gl_swap_buffers(GdkWindow *window); + + +-void gdk_gl_wait_gdk(void); +-void gdk_gl_wait_gl(void); ++void gdkada_gl_wait_gdk(void); ++void gdkada_gl_wait_gl(void); + + /* fonts */ +-// void gdk_gl_use_gdk_font(GdkFont *font, int first, int count, int list_base); ++// void gdkada_gl_use_gdk_font(GdkFont *font, int first, int count, int list_base); + + + #ifndef GTKGL_DISABLE_DEPRECATED +-# define gdk_gl_context_ref(context) g_object_ref(context) +-# define gdk_gl_context_unref(context) g_object_unref(context) +-# define gdk_gl_pixmap_ref(pixmap) g_object_ref(pixmap) +-# define gdk_gl_pixmap_unref(pixmap) g_object_unref(pixmap) ++# define gdkada_gl_context_ref(context) g_object_ref(context) ++# define gdkada_gl_context_unref(context) g_object_unref(context) ++# define gdkada_gl_pixmap_ref(pixmap) g_object_ref(pixmap) ++# define gdkada_gl_pixmap_unref(pixmap) g_object_unref(pixmap) + #endif + + G_END_DECLS + +-#endif /* __GDK_GL_H__ */ ++#endif /* __GDKADA_GL_H__ */ + +diff -u --recursive src/opengl/gtk-glarea.adb src/opengl/gtk-glarea.adb +--- src/opengl/gtk-glarea.adb 2014-01-06 11:22:20.000000000 +0100 ++++ src/opengl/gtk-glarea.adb 2015-03-21 20:36:47.933805110 +0100 +@@ -69,7 +69,7 @@ + Attr_List : Attributes_Array) + is + function Internal (Attr_List : System.Address) return System.Address; +- pragma Import (C, Internal, "gtk_gl_area_new"); ++ pragma Import (C, Internal, "gtkada_gl_area_new"); + Attributes : Attributes_Array (0 .. Attr_List'Length); + use type System.Address; + S : System.Address; +@@ -113,7 +113,7 @@ + function Internal (Attr_List : System.Address; + Share : System.Address) + return System.Address; +- pragma Import (C, Internal, "gtk_gl_area_share_new"); ++ pragma Import (C, Internal, "gtkada_gl_area_share_new"); + Attributes : Attributes_Array (0 .. Attr_List'Length); + begin + Attributes (0 .. Attr_List'Length - 1) := Attr_List; +@@ -133,7 +133,7 @@ + return Boolean + is + function Internal (GLArea : System.Address) return Gint; +- pragma Import (C, Internal, "gtk_gl_area_make_current"); ++ pragma Import (C, Internal, "gtkada_gl_area_make_current"); + begin + return Boolean'Val (Internal (Get_Object (Glarea))); + end Make_Current; +@@ -144,7 +144,7 @@ + + procedure Swap_Buffers (Glarea : access Gtk_GLArea_Record'Class) is + procedure Internal (Glarea : System.Address); +- pragma Import (C, Internal, "gtk_gl_area_swap_buffers"); ++ pragma Import (C, Internal, "gtkada_gl_area_swap_buffers"); + begin + Internal (Get_Object (Glarea)); + end Swap_Buffers; +diff -u --recursive src/opengl/gtk-glarea.ads src/opengl/gtk-glarea.ads +--- src/opengl/gtk-glarea.ads 2014-01-06 11:22:20.000000000 +0100 ++++ src/opengl/gtk-glarea.ads 2015-03-21 20:37:40.293985032 +0100 +@@ -94,5 +94,5 @@ + type Gtk_GLArea_Record is + new Gtk.Drawing_Area.Gtk_Drawing_Area_Record with null record; + +- pragma Import (C, Get_Type, "gtk_gl_area_get_type"); ++ pragma Import (C, Get_Type, "gtkada_gl_area_get_type"); + end Gtk.GLArea; +diff -u --recursive src/opengl/gtkglarea.c src/opengl/gtkglarea.c +--- src/opengl/gtkglarea.c 2014-01-06 11:22:20.000000000 +0100 ++++ src/opengl/gtkglarea.c 2015-03-21 20:22:44.511050540 +0100 +@@ -22,15 +22,15 @@ + #include "gdkgl.h" + #include "gtkglarea.h" + +-static void gtk_gl_area_class_init (GtkGLAreaClass *klass); +-static void gtk_gl_area_init (GtkGLArea *glarea); +-static void gtk_gl_area_destroy (GObject *object); /* change to finalize? */ ++static void gtkada_gl_area_class_init (GtkadaGLAreaClass *klass); ++static void gtkada_gl_area_init (GtkadaGLArea *glarea); ++static void gtkada_gl_area_destroy (GObject *object); /* change to finalize? */ + + static GtkDrawingAreaClass *parent_class = NULL; + + + GType +-gtk_gl_area_get_type (void) ++gtkada_gl_area_get_type (void) + { + static GType object_type = 0; + +@@ -38,38 +38,38 @@ + { + static const GTypeInfo object_info = + { +- sizeof (GtkGLAreaClass), ++ sizeof (GtkadaGLAreaClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, +- (GClassInitFunc) gtk_gl_area_class_init, ++ (GClassInitFunc) gtkada_gl_area_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ +- sizeof (GtkGLArea), ++ sizeof (GtkadaGLArea), + 0, /* n_preallocs */ +- (GInstanceInitFunc) gtk_gl_area_init, ++ (GInstanceInitFunc) gtkada_gl_area_init, + }; + + object_type = g_type_register_static (GTK_TYPE_DRAWING_AREA, +- "GtkGLArea", ++ "GtkadaGLArea", + &object_info, 0); + } + return object_type; + } + + static void +-gtk_gl_area_class_init (GtkGLAreaClass *klass) ++gtkada_gl_area_class_init (GtkadaGLAreaClass *klass) + { + GObjectClass *object_class; + + parent_class = g_type_class_peek_parent(klass); + object_class = (GObjectClass*) klass; + +- object_class->finalize = gtk_gl_area_destroy; ++ object_class->finalize = gtkada_gl_area_destroy; + } + + + static void +-gtk_gl_area_init (GtkGLArea *gl_area) ++gtkada_gl_area_init (GtkadaGLArea *gl_area) + { + gl_area->glcontext = NULL; + gtk_widget_set_double_buffered(GTK_WIDGET(gl_area), FALSE); +@@ -78,7 +78,7 @@ + + + GtkWidget* +-gtk_gl_area_new_vargs(GtkGLArea *share, ...) ++gtkada_gl_area_new_vargs(GtkadaGLArea *share, ...) + { + GtkWidget *glarea; + va_list ap; +@@ -99,7 +99,7 @@ + i++; + va_end(ap); + +- glarea = gtk_gl_area_share_new(attrlist, share); ++ glarea = gtkada_gl_area_share_new(attrlist, share); + + g_free(attrlist); + +@@ -107,30 +107,30 @@ + } + + GtkWidget* +-gtk_gl_area_new (int *attrlist) ++gtkada_gl_area_new (int *attrlist) + { +- return gtk_gl_area_share_new(attrlist, NULL); ++ return gtkada_gl_area_share_new(attrlist, NULL); + } + + GtkWidget* +-gtk_gl_area_share_new (int *attrlist, GtkGLArea *share) ++gtkada_gl_area_share_new (int *attrlist, GtkadaGLArea *share) + { +- GdkGLContext *glcontext; +- GtkGLArea *gl_area; ++ GdkadaGLContext *glcontext; ++ GtkadaGLArea *gl_area; + #if defined GDK_WINDOWING_X11 + GdkVisual *visual; + #endif + +- g_return_val_if_fail(share == NULL || GTK_IS_GL_AREA(share), NULL); ++ g_return_val_if_fail(share == NULL || GTKADA_IS_GL_AREA(share), NULL); + + #if defined GDK_WINDOWING_X11 +- visual = gdk_gl_choose_visual(attrlist); ++ visual = gdkada_gl_choose_visual(attrlist); + if (visual == NULL) + return NULL; + +- glcontext = gdk_gl_context_share_new(visual, share ? share->glcontext : NULL, TRUE); ++ glcontext = gdkada_gl_context_share_new(visual, share ? share->glcontext : NULL, TRUE); + #else +- glcontext = gdk_gl_context_attrlist_share_new(attrlist, share ? share->glcontext : NULL, TRUE); ++ glcontext = gdkada_gl_context_attrlist_share_new(attrlist, share ? share->glcontext : NULL, TRUE); + #endif + if (glcontext == NULL) + return NULL; +@@ -141,7 +141,7 @@ + // gtk_widget_push_visual(visual); + #endif + +- gl_area = g_object_new(GTK_TYPE_GL_AREA, NULL); ++ gl_area = g_object_new(GTKADA_TYPE_GL_AREA, NULL); + gl_area->glcontext = glcontext; + + #if defined GDK_WINDOWING_X11 +@@ -155,14 +155,14 @@ + + + static void +-gtk_gl_area_destroy(GObject *object) ++gtkada_gl_area_destroy(GObject *object) + { +- GtkGLArea *gl_area; ++ GtkadaGLArea *gl_area; + + g_return_if_fail (object != NULL); +- g_return_if_fail (GTK_IS_GL_AREA(object)); ++ g_return_if_fail (GTKADA_IS_GL_AREA(object)); + +- gl_area = GTK_GL_AREA(object); ++ gl_area = GTKADA_GL_AREA(object); + + if (gl_area->glcontext) + g_object_unref(gl_area->glcontext); +@@ -173,20 +173,20 @@ + } + + +-gint gtk_gl_area_make_current(GtkGLArea *gl_area) ++gint gtkada_gl_area_make_current(GtkadaGLArea *gl_area) + { + g_return_val_if_fail(gl_area != NULL, FALSE); +- g_return_val_if_fail(GTK_IS_GL_AREA (gl_area), FALSE); ++ g_return_val_if_fail(GTKADA_IS_GL_AREA (gl_area), FALSE); + // g_return_val_if_fail(GTK_WIDGET_REALIZED(gl_area), FALSE); + +- return gdk_gl_make_current(gtk_widget_get_window(GTK_WIDGET(gl_area)), gl_area->glcontext); ++ return gdkada_gl_make_current(gtk_widget_get_window(GTK_WIDGET(gl_area)), gl_area->glcontext); + } + +-void gtk_gl_area_swap_buffers(GtkGLArea *gl_area) ++void gtkada_gl_area_swap_buffers(GtkadaGLArea *gl_area) + { + g_return_if_fail(gl_area != NULL); +- g_return_if_fail(GTK_IS_GL_AREA(gl_area)); ++ g_return_if_fail(GTKADA_IS_GL_AREA(gl_area)); + // g_return_if_fail(GTK_WIDGET_REALIZED(gl_area)); + +- gdk_gl_swap_buffers(gtk_widget_get_window (GTK_WIDGET (gl_area))); ++ gdkada_gl_swap_buffers(gtk_widget_get_window (GTK_WIDGET (gl_area))); + } +diff -u --recursive src/opengl/gtkglarea.h src/opengl/gtkglarea.h +--- src/opengl/gtkglarea.h 2014-01-06 11:49:08.000000000 +0100 ++++ src/opengl/gtkglarea.h 2015-03-21 20:19:16.546358090 +0100 +@@ -18,8 +18,8 @@ + */ + + +-#ifndef __GTK_GL_AREA_H__ +-#define __GTK_GL_AREA_H__ ++#ifndef __GTKADA_GL_AREA_H__ ++#define __GTKADA_GL_AREA_H__ + + #include <gdk/gdk.h> + #include <gdkgl.h> +@@ -28,57 +28,57 @@ + + G_BEGIN_DECLS + +-#define GTK_TYPE_GL_AREA (gtk_gl_area_get_type()) +-#define GTK_GL_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_GL_AREA, GtkGLArea)) +-#define GTK_GL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GTK_TYPE_GL_AREA, GtkGLAreaClass)) +-#define GTK_IS_GL_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_GL_AREA)) +-#define GTK_IS_GL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_GL_AREA)) +-#define GTK_GL_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GL_AREA, GtkGLArea)) ++#define GTKADA_TYPE_GL_AREA (gtkada_gl_area_get_type()) ++#define GTKADA_GL_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTKADA_TYPE_GL_AREA, GtkadaGLArea)) ++#define GTKADA_GL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, GTKADA_TYPE_GL_AREA, GtkadaGLAreaClass)) ++#define GTKADA_IS_GL_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTKADA_TYPE_GL_AREA)) ++#define GTKADA_IS_GL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTKADA_TYPE_GL_AREA)) ++#define GTKADA_GL_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTKADA_TYPE_GL_AREA, GtkadaGLArea)) + + +-typedef struct _GtkGLArea GtkGLArea; +-typedef struct _GtkGLAreaClass GtkGLAreaClass; ++typedef struct _GtkadaGLArea GtkadaGLArea; ++typedef struct _GtkadaGLAreaClass GtkadaGLAreaClass; + + +-struct _GtkGLArea ++struct _GtkadaGLArea + { + GtkDrawingArea darea; +- GdkGLContext *glcontext; ++ GdkadaGLContext *glcontext; + }; + +-struct _GtkGLAreaClass ++struct _GtkadaGLAreaClass + { + GtkDrawingAreaClass parent_class; + }; + +-GType gtk_gl_area_get_type (void); +-GtkWidget* gtk_gl_area_new (int *attrList); +-GtkWidget* gtk_gl_area_share_new (int *attrList, +- GtkGLArea *share); +-GtkWidget* gtk_gl_area_new_vargs (GtkGLArea *share, ++GType gtkada_gl_area_get_type (void); ++GtkWidget* gtkada_gl_area_new (int *attrList); ++GtkWidget* gtkada_gl_area_share_new (int *attrList, ++ GtkadaGLArea *share); ++GtkWidget* gtkada_gl_area_new_vargs (GtkadaGLArea *share, + ...); + + +-gint gtk_gl_area_make_current(GtkGLArea *glarea); ++gint gtkada_gl_area_make_current(GtkadaGLArea *glarea); + +-void gtk_gl_area_endgl (GtkGLArea *glarea); /* deprecated */ ++void gtkada_gl_area_endgl (GtkadaGLArea *glarea); /* deprecated */ + +-void gtk_gl_area_swap_buffers(GtkGLArea *glarea); ++void gtkada_gl_area_swap_buffers(GtkadaGLArea *glarea); + + + #ifndef GTKGL_DISABLE_DEPRECATED + +-# define gtk_gl_area_begingl(glarea) \ +- gtk_gl_area_make_current(glarea) +-# define gtk_gl_area_endgl(glarea) \ ++# define gtkada_gl_area_begingl(glarea) \ ++ gtkada_gl_area_make_current(glarea) ++# define gtkada_gl_area_endgl(glarea) \ + glFlush() +-# define gtk_gl_area_swapbuffers(glarea) \ +- gtk_gl_area_swap_buffers(glarea) +-# define gtk_gl_area_size(glarea, width, height) \ ++# define gtkada_gl_area_swapbuffers(glarea) \ ++ gtkada_gl_area_swap_buffers(glarea) ++# define gtkada_gl_area_size(glarea, width, height) \ + gtk_widget_set_size_request(GTK_WIDGET(glarea), (width), (height)) + + #endif + + G_END_DECLS + +-#endif /* __GTK_GL_AREA_H__ */ ++#endif /* __GTKADA_GL_AREA_H__ */ |