replace public native_event APIs with typesafe APIs

This adds Xlib and Win32 typesafe replacements for
cogl_renderer_handle_native_event, cogl_renderer_add_native_filter,
cogl_renderer_remove_native_filter. The old functions are kept as an
implementation detail so we can share code.

14 files changed, 242 insertions, 88 deletions

diff --git a/cogl/Makefile.am b/cogl/Makefile.am
index 714dc13f..01507278 100644
--- a/cogl/Makefile.am
+++ b/cogl/Makefile.am
@@ -332,6 +332,7 @@ cogl_sources_c += \
 endif
 if SUPPORT_WGL
 cogl_sources_c += \
+	$(srcdir)/winsys/cogl-win32-renderer.c \
 	$(srcdir)/winsys/cogl-winsys-wgl.c \
 	$(srcdir)/winsys/cogl-winsys-wgl-feature-functions.h
 endif
diff --git a/cogl/cogl-renderer-private.h b/cogl/cogl-renderer-private.h
index fa07b320..a6110d35 100644
--- a/cogl/cogl-renderer-private.h
+++ b/cogl/cogl-renderer-private.h
@@ -53,4 +53,21 @@ struct _CoglRenderer
   void *winsys;
 };
 
+typedef CoglFilterReturn (* CoglNativeFilterFunc) (void *native_event,
+                                                   void *data);
+
+CoglFilterReturn
+_cogl_renderer_handle_native_event (CoglRenderer *renderer,
+                                    void *event);
+
+void
+_cogl_renderer_add_native_filter (CoglRenderer *renderer,
+                                  CoglNativeFilterFunc func,
+                                  void *data);
+
+void
+_cogl_renderer_remove_native_filter (CoglRenderer *renderer,
+                                     CoglNativeFilterFunc func,
+                                     void *data);
+
 #endif /* __COGL_RENDERER_PRIVATE_H */
diff --git a/cogl/cogl-renderer-xlib.c b/cogl/cogl-renderer-xlib.c
index f8dbe504..ec5eb2a7 100644
--- a/cogl/cogl-renderer-xlib.c
+++ b/cogl/cogl-renderer-xlib.c
@@ -198,3 +198,29 @@ cogl_renderer_xlib_get_display (CoglRenderer *renderer)
 
   return xlib_renderer->xdpy;
 }
+
+CoglFilterReturn
+cogl_xlib_renderer_handle_event (CoglRenderer *renderer,
+                                 XEvent *event)
+{
+  return _cogl_renderer_handle_native_event (renderer, event);
+}
+
+void
+cogl_xlib_renderer_add_filter (CoglRenderer *renderer,
+                               CoglXlibFilterFunc func,
+                               void *data)
+{
+  _cogl_renderer_add_native_filter (renderer,
+                                    (CoglNativeFilterFunc)func, data);
+}
+
+void
+cogl_xlib_renderer_remove_filter (CoglRenderer *renderer,
+                                  CoglXlibFilterFunc func,
+                                  void *data)
+{
+  _cogl_renderer_remove_native_filter (renderer,
+                                       (CoglNativeFilterFunc)func, data);
+}
+
diff --git a/cogl/cogl-renderer.c b/cogl/cogl-renderer.c
index d89065d5..fb6e9486 100644
--- a/cogl/cogl-renderer.c
+++ b/cogl/cogl-renderer.c
@@ -229,8 +229,8 @@ cogl_renderer_connect (CoglRenderer *renderer, GError **error)
 }
 
 CoglFilterReturn
-cogl_renderer_handle_native_event (CoglRenderer *renderer,
-                                   void *event)
+_cogl_renderer_handle_native_event (CoglRenderer *renderer,
+                                    void *event)
 {
   GSList *l, *next;
 
@@ -254,9 +254,9 @@ cogl_renderer_handle_native_event (CoglRenderer *renderer,
 }
 
 void
-cogl_renderer_add_native_filter (CoglRenderer *renderer,
-                                 CoglNativeFilterFunc func,
-                                 void *data)
+_cogl_renderer_add_native_filter (CoglRenderer *renderer,
+                                  CoglNativeFilterFunc func,
+                                  void *data)
 {
   CoglNativeFilterClosure *closure;
 
@@ -268,9 +268,9 @@ cogl_renderer_add_native_filter (CoglRenderer *renderer,
 }
 
 void
-cogl_renderer_remove_native_filter (CoglRenderer *renderer,
-                                    CoglNativeFilterFunc func,
-                                    void *data)
+_cogl_renderer_remove_native_filter (CoglRenderer *renderer,
+                                     CoglNativeFilterFunc func,
+                                     void *data)
 {
   GSList *l, *prev = NULL;
 
diff --git a/cogl/cogl-renderer.h b/cogl/cogl-renderer.h
index 2c6d9d0e..13679b79 100644
--- a/cogl/cogl-renderer.h
+++ b/cogl/cogl-renderer.h
@@ -122,17 +122,17 @@ cogl_renderer_set_winsys_id (CoglRenderer *renderer,
 CoglWinsysID
 cogl_renderer_get_winsys_id (CoglRenderer *renderer);
 
-#define cogl_renderer_handle_native_event cogl_renderer_handle_native_event_EXP
+#ifdef COGL_HAS_XLIB
+
+#define cogl_xlib_renderer_handle_event \
+  cogl_xlib_renderer_handle_event_EXP
 /*
- * cogl_renderer_handle_native_event:
- * @event: pointer to native event structure
+ * cogl_xlib_renderer_handle_event:
+ * @event: pointer to an XEvent structure
  *
  * This function processes a single event; it can be used to hook into
  * external event retrieval (for example that done by Clutter or
- * GDK). The type of the structure that event points to depends on the
- * window system used for the renderer. On an xlib renderer it would
- * be a pointer to an XEvent or an a Windows renderer it would be a
- * pointer to a MSG struct.
+ * GDK).
  *
  * Return value: #CoglFilterReturn. %COGL_FILTER_REMOVE indicates that
  * Cogl has internally handled the event and the caller should do no
@@ -141,38 +141,47 @@ cogl_renderer_get_winsys_id (CoglRenderer *renderer);
  * internal state without taking any exclusive action.
  */
 CoglFilterReturn
-cogl_renderer_handle_native_event (CoglRenderer *renderer,
-                                   void *event);
+cogl_xlib_renderer_handle_event (CoglRenderer *renderer,
+                                 XEvent *event);
+
+/*
+ * CoglXlibFilterFunc:
+ * @event: pointer to an XEvent structure
+ * @data: The data that was given when the filter was added
+ *
+ * A callback function that can be registered with
+ * cogl_xlib_renderer_add_filter(). The function should return
+ * %COGL_FILTER_REMOVE if it wants to prevent further processing or
+ * %COGL_FILTER_CONTINUE otherwise.
+ */
+typedef CoglFilterReturn (* CoglXlibFilterFunc) (XEvent *event,
+                                                 void *data);
 
-#define cogl_renderer_add_native_filter cogl_renderer_add_native_filter_EXP
+#define cogl_xlib_renderer_add_filter cogl_xlib_renderer_add_filter_EXP
 /*
- * cogl_renderer_add_native_filter:
+ * cogl_xlib_renderer_add_filter:
  *
  * Adds a callback function that will receive all native events. The
  * function can stop further processing of the event by return
- * %COGL_FILTER_REMOVE. What is considered a native event depends on
- * the type of renderer used. An xlib based renderer would pass all
- * XEvents whereas a Windows based renderer would pass MSGs.
+ * %COGL_FILTER_REMOVE.
  */
 void
-cogl_renderer_add_native_filter (CoglRenderer *renderer,
-                                 CoglNativeFilterFunc func,
-                                 void *data);
+cogl_xlib_renderer_add_filter (CoglRenderer *renderer,
+                               CoglXlibFilterFunc func,
+                               void *data);
 
-#define cogl_renderer_remove_native_filter \
-  cogl_renderer_remove_native_filter_EXP
+#define cogl_xlib_renderer_remove_filter \
+  cogl_xlib_renderer_remove_filter_EXP
 /*
- * cogl_renderer_remove_native_filter:
+ * cogl_xlib_renderer_remove_filter:
  *
  * Removes a callback that was previously added with
- * cogl_renderer_add_native_filter().
+ * cogl_xlib_renderer_add_filter().
  */
 void
-cogl_renderer_remove_native_filter (CoglRenderer *renderer,
-                                    CoglNativeFilterFunc func,
-                                    void *data);
-
-#ifdef COGL_HAS_XLIB
+cogl_xlib_renderer_remove_filter (CoglRenderer *renderer,
+                                  CoglXlibFilterFunc func,
+                                  void *data);
 
 #define cogl_renderer_xlib_get_foreign_display \
   cogl_renderer_xlib_get_foreign_display_EXP
@@ -228,6 +237,68 @@ struct wl_compositor *
 cogl_renderer_wayland_get_compositor (CoglRenderer *renderer);
 #endif /* COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT */
 
+#ifdef COGL_HAS_WGL_SUPPORT
+
+#define cogl_win32_renderer_handle_event \
+  cogl_win32_renderer_handle_event_EXP
+/*
+ * cogl_win32_renderer_handle_event:
+ * @message: A pointer to a win32 MSG struct
+ *
+ * This function processes a single event; it can be used to hook into
+ * external event retrieval (for example that done by Clutter or
+ * GDK).
+ *
+ * Return value: #CoglFilterReturn. %COGL_FILTER_REMOVE indicates that
+ * Cogl has internally handled the event and the caller should do no
+ * further processing. %COGL_FILTER_CONTINUE indicates that Cogl is
+ * either not interested in the event, or has used the event to update
+ * internal state without taking any exclusive action.
+ */
+CoglFilterReturn
+cogl_win32_renderer_handle_event (CoglRenderer *renderer,
+                                  MSG *message);
+
+/*
+ * CoglXlibFilterFunc:
+ * @message: A pointer to a win32 MSG struct
+ * @data: The data that was given when the filter was added
+ *
+ * A callback function that can be registered with
+ * cogl_win32_renderer_add_filter(). The function should return
+ * %COGL_FILTER_REMOVE if it wants to prevent further processing or
+ * %COGL_FILTER_CONTINUE otherwise.
+ */
+typedef CoglFilterReturn (* CoglWin32FilterFunc) (MSG *message,
+                                                  void *data);
+
+#define cogl_win32_renderer_add_filter cogl_win32_renderer_add_filter_EXP
+/*
+ * cogl_win32_renderer_add_filter:
+ *
+ * Adds a callback function that will receive all native events. The
+ * function can stop further processing of the event by return
+ * %COGL_FILTER_REMOVE.
+ */
+void
+cogl_win32_renderer_add_filter (CoglRenderer *renderer,
+                                CoglWin32FilterFunc func,
+                                void *data);
+
+#define cogl_win32_renderer_remove_filter \
+  cogl_win32_renderer_remove_filter_EXP
+/*
+ * cogl_win32_renderer_remove_filter:
+ *
+ * Removes a callback that was previously added with
+ * cogl_win32_renderer_add_filter().
+ */
+void
+cogl_win32_renderer_remove_filter (CoglRenderer *renderer,
+                                   CoglWin32FilterFunc func,
+                                   void *data);
+#endif /* COGL_HAS_WGL_SUPPORT */
+
 #define cogl_renderer_check_onscreen_template \
   cogl_renderer_check_onscreen_template_EXP
 gboolean
diff --git a/cogl/cogl-types.h b/cogl/cogl-types.h
index ab610c17..55f22969 100644
--- a/cogl/cogl-types.h
+++ b/cogl/cogl-types.h
@@ -671,28 +671,6 @@ typedef enum _CoglWinsysFeature
   COGL_WINSYS_FEATURE_N_FEATURES
 } CoglWinsysFeature;
 
-/* XXX: Note these enum types are only referenced by experimental API
- * so although they aren't explicitly guarded they are implicitly
- * experimental too. */
-
-/*
- * CoglNativeFilterFunc:
- * @native_event: A pointer to the native system event
- * @data: The data that was given when the filter was added
- *
- * A callback function that can be registered with
- * cogl_renderer_add_native_filter(). The function should return
- * %COGL_FILTER_REMOVE if it wants to prevent further processing or
- * %COGL_FILTER_CONTINUE otherwise.
- *
- * The type that @native_event points to depends on the type of the
- * underlying renderer. On xlib based renderers this would point to an
- * XEvent struct and on Windows it would point to a MSG struct.
- */
-typedef CoglFilterReturn (* CoglNativeFilterFunc) (void *native_event,
-                                                   void *data);
-
-
 G_END_DECLS
 
 #endif /* __COGL_TYPES_H__ */
diff --git a/cogl/cogl-win32-renderer.c b/cogl/cogl-win32-renderer.c
new file mode 100644
index 00000000..82ae7e08
--- /dev/null
+++ b/cogl/cogl-win32-renderer.c
@@ -0,0 +1,55 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2011 Intel Corporation.
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Authors:
+ *   Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+CoglFilterReturn
+cogl_win32_renderer_handle_event (CoglRenderer *renderer,
+                                  XEvent *event)
+{
+  return _cogl_renderer_handle_native_event (renderer, event);
+}
+
+void
+cogl_win32_renderer_add_filter (CoglRenderer *renderer,
+                                CoglWin32FilterFunc func,
+                                void *data)
+{
+  _cogl_renderer_add_native_filter (renderer,
+                                    (CoglNativeFilterFunc)func, data);
+}
+
+void
+cogl_win32_renderer_remove_filter (CoglRenderer *renderer,
+                                   CoglWin32FilterFunc func,
+                                   void *data)
+{
+  _cogl_renderer_remove_native_filter (renderer,
+                                       (CoglNativeFilterFunc)func, data);
+}
+
diff --git a/cogl/cogl-xlib.c b/cogl/cogl-xlib.c
index e70992f0..2f65dc92 100644
--- a/cogl/cogl-xlib.c
+++ b/cogl/cogl-xlib.c
@@ -78,7 +78,7 @@ cogl_xlib_handle_event (XEvent *xevent)
   _COGL_GET_CONTEXT (ctx, COGL_FILTER_CONTINUE);
 
   /* Pass the event on to the renderer */
-  return cogl_renderer_handle_native_event (ctx->display->renderer, xevent);
+  return cogl_xlib_renderer_handle_event (ctx->display->renderer, xevent);
 }
 
 void
diff --git a/cogl/winsys/cogl-texture-pixmap-x11.c b/cogl/winsys/cogl-texture-pixmap-x11.c
index 48bcaac4..e4d69bc7 100644
--- a/cogl/winsys/cogl-texture-pixmap-x11.c
+++ b/cogl/winsys/cogl-texture-pixmap-x11.c
@@ -241,9 +241,9 @@ set_damage_object_internal (CoglContext *ctx,
 {
   if (tex_pixmap->damage)
     {
-      cogl_renderer_remove_native_filter (ctx->display->renderer,
-                                          _cogl_texture_pixmap_x11_filter,
-                                          tex_pixmap);
+      cogl_xlib_renderer_remove_filter (ctx->display->renderer,
+                                        _cogl_texture_pixmap_x11_filter,
+                                        tex_pixmap);
 
       if (tex_pixmap->damage_owned)
         {
@@ -256,9 +256,9 @@ set_damage_object_internal (CoglContext *ctx,
   tex_pixmap->damage_report_level = report_level;
 
   if (damage)
-    cogl_renderer_add_native_filter (ctx->display->renderer,
-                                     _cogl_texture_pixmap_x11_filter,
-                                     tex_pixmap);
+    cogl_xlib_renderer_add_filter (ctx->display->renderer,
+                                   _cogl_texture_pixmap_x11_filter,
+                                   tex_pixmap);
 }
 
 CoglHandle
diff --git a/cogl/winsys/cogl-winsys-egl.c b/cogl/winsys/cogl-winsys-egl.c
index 69da5299..a9a33fb5 100644
--- a/cogl/winsys/cogl-winsys-egl.c
+++ b/cogl/winsys/cogl-winsys-egl.c
@@ -1108,9 +1108,9 @@ _cogl_winsys_context_init (CoglContext *context, GError **error)
   context->winsys = g_new0 (CoglContextEGL, 1);
 
 #ifdef COGL_HAS_EGL_PLATFORM_POWERVR_X11_SUPPORT
-  cogl_renderer_add_native_filter (context->display->renderer,
-                                   event_filter_cb,
-                                   context);
+  cogl_xlib_renderer_add_filter (context->display->renderer,
+                                 event_filter_cb,
+                                 context);
 #endif
   update_winsys_features (context);
 
@@ -1121,9 +1121,9 @@ static void
 _cogl_winsys_context_deinit (CoglContext *context)
 {
 #ifdef COGL_HAS_EGL_PLATFORM_POWERVR_X11_SUPPORT
-  cogl_renderer_remove_native_filter (context->display->renderer,
-                                      event_filter_cb,
-                                      context);
+  cogl_xlib_renderer_remove_filter (context->display->renderer,
+                                    event_filter_cb,
+                                    context);
 #endif
   g_free (context->winsys);
 }
diff --git a/cogl/winsys/cogl-winsys-glx.c b/cogl/winsys/cogl-winsys-glx.c
index 77e7ebe4..92ccec2a 100644
--- a/cogl/winsys/cogl-winsys-glx.c
+++ b/cogl/winsys/cogl-winsys-glx.c
@@ -672,9 +672,9 @@ _cogl_winsys_context_init (CoglContext *context, GError **error)
 {
   context->winsys = g_new0 (CoglContextGLX, 1);
 
-  cogl_renderer_add_native_filter (context->display->renderer,
-                                   glx_event_filter_cb,
-                                   context);
+  cogl_xlib_renderer_add_filter (context->display->renderer,
+                                 glx_event_filter_cb,
+                                 context);
   update_winsys_features (context);
 
   return TRUE;
@@ -683,9 +683,9 @@ _cogl_winsys_context_init (CoglContext *context, GError **error)
 static void
 _cogl_winsys_context_deinit (CoglContext *context)
 {
-  cogl_renderer_remove_native_filter (context->display->renderer,
-                                      glx_event_filter_cb,
-                                      context);
+  cogl_xlib_renderer_remove_filter (context->display->renderer,
+                                    glx_event_filter_cb,
+                                    context);
   g_free (context->winsys);
 }
 
diff --git a/cogl/winsys/cogl-winsys-wgl.c b/cogl/winsys/cogl-winsys-wgl.c
index a20cd02d..4ea72c29 100644
--- a/cogl/winsys/cogl-winsys-wgl.c
+++ b/cogl/winsys/cogl-winsys-wgl.c
@@ -217,7 +217,7 @@ window_proc (HWND hwnd, UINT umsg,
      the window proc is. We want the application to forward on all
      messages through Cogl so that it can have a chance to process
      them which might mean that that in it's GetMessage loop it could
-     call cogl_renderer_handle_native_event for every message. However
+     call cogl_win32_renderer_handle_event for every message. However
      the message loop would usually call DispatchMessage as well which
      mean this window proc would be invoked and Cogl would see the
      message twice. However we can't just ignore messages in the
@@ -260,7 +260,7 @@ window_proc (HWND hwnd, UINT umsg,
       renderer = COGL_FRAMEBUFFER (onscreen)->context->display->renderer;
 
       message_handled =
-        cogl_renderer_handle_native_event (renderer, &msg);
+        cogl_win32_renderer_handle_event (renderer, &msg);
     }
 
   if (!message_handled)
@@ -587,9 +587,9 @@ _cogl_winsys_context_init (CoglContext *context, GError **error)
 
   wgl_context = context->winsys = g_new0 (CoglContextWgl, 1);
 
-  cogl_renderer_add_native_filter (context->display->renderer,
-                                   win32_event_filter_cb,
-                                   context);
+  cogl_win32_renderer_add_filter (context->display->renderer,
+                                  win32_event_filter_cb,
+                                  context);
 
   update_winsys_features (context);
 
@@ -599,9 +599,9 @@ _cogl_winsys_context_init (CoglContext *context, GError **error)
 static void
 _cogl_winsys_context_deinit (CoglContext *context)
 {
-  cogl_renderer_remove_native_filter (context->display->renderer,
-                                      win32_event_filter_cb,
-                                      context);
+  cogl_win32_renderer_remove_filter (context->display->renderer,
+                                     win32_event_filter_cb,
+                                     context);
 
   g_free (context->winsys);
 }
diff --git a/doc/reference/cogl-2.0-experimental/cogl-sections.txt b/doc/reference/cogl-2.0-experimental/cogl-sections.txt
index 8909a72e..a4da2561 100644
--- a/doc/reference/cogl-2.0-experimental/cogl-sections.txt
+++ b/doc/reference/cogl-2.0-experimental/cogl-sections.txt
@@ -21,9 +21,16 @@ cogl_renderer_xlib_set_foreign_display
 cogl_renderer_xlib_get_foreign_display
 
 <SUBSECTION>
-cogl_renderer_add_native_filter
-cogl_renderer_remove_native_filter
-cogl_renderer_handle_native_event
+CoglXlibFilterFunc
+cogl_xlib_renderer_add_native_filter
+cogl_xlib_renderer_remove_native_filter
+cogl_xlib_renderer_handle_native_event
+
+<SUBSECTION>
+CoglWin32FilterFunc
+cogl_win32_renderer_add_native_filter
+cogl_win32_renderer_remove_native_filter
+cogl_win32_renderer_handle_native_event
 
 <SUBSECTION>
 cogl_renderer_wayland_set_foreign_display
diff --git a/examples/x11-foreign.c b/examples/x11-foreign.c
index 6f68adef..9337d9ec 100644
--- a/examples/x11-foreign.c
+++ b/examples/x11-foreign.c
@@ -175,8 +175,7 @@ main (int argc, char **argv)
             case ButtonRelease:
               return 0;
             }
-          /* FIXME: This should be replaced with some equivalent cogl_xlib_ typesafe API... */
-          cogl_renderer_handle_native_event (renderer, &event);
+          cogl_xlib_renderer_handle_event (renderer, &event);
         }
       cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
       cogl_primitive_draw (triangle);