From 04c84b049f51fd4908f4b26987c5760669eed58f Mon Sep 17 00:00:00 2001 From: Ray Strode Date: Tue, 12 Jan 2016 12:04:41 -0500 Subject: [PATCH] gdk: drop gdk backend --- clutter/Makefile.am | 56 -- clutter/clutter-backend.c | 14 - clutter/clutter-main.c | 9 - clutter/clutter-master-clock.c | 13 +- clutter/gdk/clutter-backend-gdk-private.h | 32 - clutter/gdk/clutter-backend-gdk.c | 519 ------------ clutter/gdk/clutter-backend-gdk.h | 74 -- clutter/gdk/clutter-device-manager-gdk.c | 292 ------- clutter/gdk/clutter-device-manager-gdk.h | 63 -- clutter/gdk/clutter-event-gdk.c | 361 --------- clutter/gdk/clutter-gdk.h | 69 -- clutter/gdk/clutter-input-device-gdk.c | 189 ----- clutter/gdk/clutter-input-device-gdk.h | 55 -- clutter/gdk/clutter-master-clock-gdk.c | 594 -------------- clutter/gdk/clutter-master-clock-gdk.h | 48 -- clutter/gdk/clutter-settings-gdk.h | 29 - clutter/gdk/clutter-stage-gdk.c | 933 ---------------------- clutter/gdk/clutter-stage-gdk.h | 95 --- configure.ac | 24 - 19 files changed, 1 insertion(+), 3468 deletions(-) delete mode 100644 clutter/gdk/clutter-backend-gdk-private.h delete mode 100644 clutter/gdk/clutter-backend-gdk.c delete mode 100644 clutter/gdk/clutter-backend-gdk.h delete mode 100644 clutter/gdk/clutter-device-manager-gdk.c delete mode 100644 clutter/gdk/clutter-device-manager-gdk.h delete mode 100644 clutter/gdk/clutter-event-gdk.c delete mode 100644 clutter/gdk/clutter-gdk.h delete mode 100644 clutter/gdk/clutter-input-device-gdk.c delete mode 100644 clutter/gdk/clutter-input-device-gdk.h delete mode 100644 clutter/gdk/clutter-master-clock-gdk.c delete mode 100644 clutter/gdk/clutter-master-clock-gdk.h delete mode 100644 clutter/gdk/clutter-settings-gdk.h delete mode 100644 clutter/gdk/clutter-stage-gdk.c delete mode 100644 clutter/gdk/clutter-stage-gdk.h diff --git a/clutter/Makefile.am b/clutter/Makefile.am index fb52faabb..da4cae102 100644 --- a/clutter/Makefile.am +++ b/clutter/Makefile.am @@ -491,45 +491,6 @@ compat_libs += \ $(NULL) endif -# GDK backend rules -gdk_source_c = \ - gdk/clutter-backend-gdk.c \ - gdk/clutter-device-manager-gdk.c \ - gdk/clutter-event-gdk.c \ - gdk/clutter-input-device-gdk.c \ - gdk/clutter-master-clock-gdk.c \ - gdk/clutter-stage-gdk.c \ - $(NULL) - -gdk_source_h = \ - gdk/clutter-gdk.h \ - $(NULL) - -gdk_source_h_priv = \ - gdk/clutter-settings-gdk.h \ - gdk/clutter-backend-gdk.h \ - gdk/clutter-device-manager-gdk.h \ - gdk/clutter-input-device-gdk.h \ - gdk/clutter-master-clock-gdk.h \ - gdk/clutter-stage-gdk.h \ - $(NULL) - -if SUPPORT_GDK -backend_source_h += $(gdk_source_h) -backend_source_c += $(gdk_source_c) -backend_source_h_priv += $(gdk_source_h_priv) - -cluttergdk_includedir = $(clutter_includedir)/gdk -cluttergdk_include_HEADERS = $(gdk_source_h) - -clutter-gdk-$(CLUTTER_API_VERSION).pc: clutter-$(CLUTTER_API_VERSION).pc - $(QUIET_GEN)cp -f $< $(@F) - -pc_files += clutter-gdk-$(CLUTTER_API_VERSION).pc - -gdk_introspection = $(gdk_source_c) $(gdk_source_h) -endif # SUPPORT_GDK - egl_tslib_h = tslib/clutter-event-tslib.h egl_tslib_c = tslib/clutter-event-tslib.c @@ -801,23 +762,6 @@ ClutterX11_@CLUTTER_API_VERSION_AM@_gir_SCANNERFLAGS = \ INTROSPECTION_GIRS += ClutterX11-@CLUTTER_API_VERSION@.gir endif # SUPPORT_X11 -if SUPPORT_GDK -ClutterGdk-@CLUTTER_API_VERSION@.gir: Makefile Clutter-@CLUTTER_API_VERSION@.gir - -ClutterGdk_@CLUTTER_API_VERSION_AM@_gir_NAMESPACE = ClutterGdk -ClutterGdk_@CLUTTER_API_VERSION_AM@_gir_INCLUDES = Gdk-3.0 -ClutterGdk_@CLUTTER_API_VERSION_AM@_gir_LIBS = libclutter-@CLUTTER_API_VERSION@.la -ClutterGdk_@CLUTTER_API_VERSION_AM@_gir_FILES = $(gdk_introspection) -ClutterGdk_@CLUTTER_API_VERSION_AM@_gir_CFLAGS = $(AM_CPPFLAGS) $(CLUTTER_CFLAGS) -ClutterGdk_@CLUTTER_API_VERSION_AM@_gir_SCANNERFLAGS = \ - --warn-all \ - --c-include='clutter/gdk/clutter-gdk.h' \ - --pkg-export=clutter-gdk-@CLUTTER_API_VERSION@ \ - --include-uninstalled=$(top_builddir)/clutter/Clutter-@CLUTTER_API_VERSION@.gir - -INTROSPECTION_GIRS += ClutterGdk-@CLUTTER_API_VERSION@.gir -endif # SUPPORT_GDK - # INTROSPECTION_GIRDIR/INTROSPECTION_TYPELIBDIR aren't the right place to # install anything - we need to install inside our prefix. girdir = $(datadir)/gir-1.0 diff --git a/clutter/clutter-backend.c b/clutter/clutter-backend.c index 5f85b1d89..47dfcc1b3 100644 --- a/clutter/clutter-backend.c +++ b/clutter/clutter-backend.c @@ -67,9 +67,6 @@ #ifdef CLUTTER_INPUT_X11 #include "x11/clutter-backend-x11.h" #endif -#ifdef CLUTTER_INPUT_GDK -#include "gdk/clutter-backend-gdk.h" -#endif #ifdef CLUTTER_INPUT_EVDEV #include "evdev/clutter-device-manager-evdev.h" #endif @@ -524,9 +521,6 @@ static const struct { const char *name; ClutterBackend * (* create_backend) (void); } available_backends[] = { -#ifdef CLUTTER_WINDOWING_GDK - { CLUTTER_WINDOWING_GDK, clutter_backend_gdk_new }, -#endif #ifdef CLUTTER_WINDOWING_X11 { CLUTTER_WINDOWING_X11, clutter_backend_x11_new }, #endif @@ -605,14 +599,6 @@ clutter_backend_real_init_events (ClutterBackend *backend) } else #endif -#ifdef CLUTTER_INPUT_GDK - if (clutter_check_windowing_backend (CLUTTER_WINDOWING_GDK) && - (input_backend == NULL || input_backend == I_(CLUTTER_INPUT_GDK))) - { - _clutter_backend_gdk_events_init (backend); - } - else -#endif #ifdef CLUTTER_INPUT_EVDEV /* Evdev can be used regardless of the windowing system */ if ((input_backend != NULL && strcmp (input_backend, CLUTTER_INPUT_EVDEV) == 0) diff --git a/clutter/clutter-main.c b/clutter/clutter-main.c index ccac23175..e1b424ed0 100644 --- a/clutter/clutter-main.c +++ b/clutter/clutter-main.c @@ -70,9 +70,6 @@ #include "clutter-stage-private.h" #include "clutter-version.h" /* For flavour define */ -#ifdef CLUTTER_WINDOWING_GDK -#include "gdk/clutter-backend-gdk.h" -#endif #ifdef CLUTTER_WINDOWING_X11 #include "x11/clutter-backend-x11.h" #endif @@ -3643,12 +3640,6 @@ clutter_check_windowing_backend (const char *backend_type) return TRUE; else #endif -#ifdef CLUTTER_WINDOWING_GDK - if (backend_type == I_(CLUTTER_WINDOWING_GDK) && - CLUTTER_IS_BACKEND_GDK (context->backend)) - return TRUE; - else -#endif #ifdef CLUTTER_WINDOWING_X11 if (backend_type == I_(CLUTTER_WINDOWING_X11) && CLUTTER_IS_BACKEND_X11 (context->backend)) diff --git a/clutter/clutter-master-clock.c b/clutter/clutter-master-clock.c index ccaa308c5..df769326d 100644 --- a/clutter/clutter-master-clock.c +++ b/clutter/clutter-master-clock.c @@ -38,10 +38,6 @@ #include "clutter-master-clock.h" #include "clutter-master-clock-default.h" #include "clutter-private.h" -#ifdef CLUTTER_WINDOWING_GDK -#include "gdk/clutter-backend-gdk.h" -#include "gdk/clutter-master-clock-gdk.h" -#endif #define clutter_master_clock_get_type _clutter_master_clock_get_type @@ -60,14 +56,7 @@ _clutter_master_clock_get_default (void) ClutterMainContext *context = _clutter_context_get_default (); if (G_UNLIKELY (context->master_clock == NULL)) - { -#ifdef CLUTTER_WINDOWING_GDK - if (CLUTTER_IS_BACKEND_GDK (context->backend)) - context->master_clock = g_object_new (CLUTTER_TYPE_MASTER_CLOCK_GDK, NULL); - else -#endif - context->master_clock = g_object_new (CLUTTER_TYPE_MASTER_CLOCK_DEFAULT, NULL); - } + context->master_clock = g_object_new (CLUTTER_TYPE_MASTER_CLOCK_DEFAULT, NULL); return context->master_clock; diff --git a/clutter/gdk/clutter-backend-gdk-private.h b/clutter/gdk/clutter-backend-gdk-private.h deleted file mode 100644 index 18c53facd..000000000 --- a/clutter/gdk/clutter-backend-gdk-private.h +++ /dev/null @@ -1,32 +0,0 @@ -/* An OpenGL based 'interactive canvas' library. - * Authored By Matthew Allum - * Copyright (C) 2006-2007 OpenedHand - * - * 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, see . - * - * - */ - -#ifndef __CLUTTER_BACKEND_PRIVATE_X11_H__ -#define __CLUTTER_BACKEND_PRIVATE_X11_H__ - - -G_BEGIN_DECLS - -void _clutter_backend_x11_events_init (ClutterBackend *backend); -void _clutter_backend_x11_events_uninit (ClutterBackend *backend); - -G_END_DECLS - -#endif diff --git a/clutter/gdk/clutter-backend-gdk.c b/clutter/gdk/clutter-backend-gdk.c deleted file mode 100644 index 1ec293848..000000000 --- a/clutter/gdk/clutter-backend-gdk.c +++ /dev/null @@ -1,519 +0,0 @@ -/* Clutter. - * An OpenGL based 'interactive canvas' library. - * Authored By Matthew Allum - * Copyright (C) 2006-2007 OpenedHand - * - * 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, see . - * - * - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#define CLUTTER_ENABLE_EXPERIMENTAL_API - -#include - -#include -#ifdef HAVE_UNISTD_H -#include -#endif -#include -#include -#include -#include - -#include -#include - -#include - -#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) -#include -#endif - -#if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) -#include -#endif - -#ifdef GDK_WINDOWING_X11 -#include -#endif - -#ifdef GDK_WINDOWING_WAYLAND -#include -#endif - -#include "clutter-backend-gdk.h" -#include "clutter-device-manager-gdk.h" -#include "clutter-settings-gdk.h" -#include "clutter-stage-gdk.h" -#include "clutter-gdk.h" - -#include "clutter-backend.h" -#include "clutter-debug.h" -#include "clutter-device-manager-private.h" -#include "clutter-event-private.h" -#include "clutter-main.h" -#include "clutter-private.h" -#include "clutter-settings-private.h" - -G_DEFINE_TYPE (ClutterBackendGdk, clutter_backend_gdk, CLUTTER_TYPE_BACKEND); - -/* global for pre init setup calls */ -static GdkDisplay *_foreign_dpy = NULL; - -static gboolean disable_event_retrieval = FALSE; - -static void -clutter_backend_gdk_init_settings (ClutterBackendGdk *backend_gdk) -{ - ClutterSettings *settings = clutter_settings_get_default (); - int i; - - for (i = 0; i < G_N_ELEMENTS (_clutter_settings_map); i++) - { - GValue val = G_VALUE_INIT; - - g_value_init (&val, CLUTTER_SETTING_TYPE(i)); - if (gdk_screen_get_setting (backend_gdk->screen, - CLUTTER_SETTING_GDK_NAME (i), - &val)) - { - clutter_settings_set_property_internal (settings, - CLUTTER_SETTING_PROPERTY (i), - &val); - } - g_value_unset (&val); - } -} - -void -_clutter_backend_gdk_update_setting (ClutterBackendGdk *backend_gdk, - const gchar *setting_name) -{ - ClutterSettings *settings = clutter_settings_get_default (); - int i; - - for (i = 0; i < G_N_ELEMENTS (_clutter_settings_map); i++) - { - if (g_strcmp0 (CLUTTER_SETTING_GDK_NAME (i), setting_name) == 0) - { - GValue val = G_VALUE_INIT; - - g_value_init (&val, CLUTTER_SETTING_TYPE (i)); - gdk_screen_get_setting (backend_gdk->screen, - CLUTTER_SETTING_GDK_NAME (i), - &val); - clutter_settings_set_property_internal (settings, - CLUTTER_SETTING_PROPERTY (i), - &val); - g_value_unset (&val); - - break; - } - } -} - -static GdkFilterReturn -cogl_gdk_filter (GdkXEvent *xevent, - GdkEvent *event, - gpointer data) -{ -#ifdef GDK_WINDOWING_X11 - ClutterBackend *backend = data; - CoglFilterReturn ret; - - ret = cogl_xlib_renderer_handle_event (backend->cogl_renderer, (XEvent *) xevent); - switch (ret) - { - case COGL_FILTER_REMOVE: - return GDK_FILTER_REMOVE; - - case COGL_FILTER_CONTINUE: - default: - return GDK_FILTER_CONTINUE; - } -#endif - - return GDK_FILTER_CONTINUE; -} - -static gboolean -_clutter_backend_gdk_post_parse (ClutterBackend *backend, - GError **error) -{ - ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); - - if (_foreign_dpy != NULL) - backend_gdk->display = _foreign_dpy; - - /* Init Gdk, if outside code did not already */ - if (!gdk_init_check (NULL, NULL)) - { - g_set_error (error, CLUTTER_INIT_ERROR, CLUTTER_INIT_ERROR_BACKEND, - _("Could not initialize Gdk")); - return FALSE; - } - - /* - * Only open connection if not already set by prior call to - * clutter_gdk_set_display() - */ - if (backend_gdk->display == NULL) - backend_gdk->display = g_object_ref (gdk_display_get_default ()); - - g_assert (backend_gdk->display != NULL); - - backend_gdk->screen = gdk_display_get_default_screen (backend_gdk->display); - - /* add event filter for Cogl events */ - gdk_window_add_filter (NULL, cogl_gdk_filter, backend_gdk); - - clutter_backend_gdk_init_settings (backend_gdk); - - CLUTTER_NOTE (BACKEND, - "Gdk Display '%s' opened", - gdk_display_get_name (backend_gdk->display)); - - return TRUE; -} - -static void -gdk_event_handler (GdkEvent *event, - gpointer user_data) -{ - clutter_gdk_handle_event (event); -} - -void -_clutter_backend_gdk_events_init (ClutterBackend *backend) -{ - ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); - - CLUTTER_NOTE (EVENT, "initialising the event loop"); - - backend->device_manager = - g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_GDK, - "backend", backend, - "gdk-display", backend_gdk->display, - NULL); - - if (!disable_event_retrieval) - gdk_event_handler_set (gdk_event_handler, NULL, NULL); -} - -static void -clutter_backend_gdk_finalize (GObject *gobject) -{ - ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (gobject); - - gdk_window_remove_filter (NULL, cogl_gdk_filter, backend_gdk); - g_object_unref (backend_gdk->display); - - G_OBJECT_CLASS (clutter_backend_gdk_parent_class)->finalize (gobject); -} - -static void -clutter_backend_gdk_dispose (GObject *gobject) -{ - G_OBJECT_CLASS (clutter_backend_gdk_parent_class)->dispose (gobject); -} - -static ClutterFeatureFlags -clutter_backend_gdk_get_features (ClutterBackend *backend) -{ - ClutterBackendClass *parent_class; - - parent_class = CLUTTER_BACKEND_CLASS (clutter_backend_gdk_parent_class); - - return parent_class->get_features (backend) - | CLUTTER_FEATURE_STAGE_USER_RESIZE - | CLUTTER_FEATURE_STAGE_CURSOR; -} - -static CoglRenderer * -clutter_backend_gdk_get_renderer (ClutterBackend *backend, - GError **error) -{ - ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); - CoglRenderer *renderer = cogl_renderer_new (); - -#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) - if (GDK_IS_X11_DISPLAY (backend_gdk->display)) - { - Display *xdisplay = gdk_x11_display_get_xdisplay (backend_gdk->display); - - cogl_xlib_renderer_set_foreign_display (renderer, xdisplay); - } - else -#endif -#if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) - if (GDK_IS_WAYLAND_DISPLAY (backend_gdk->display)) - { - struct wl_display *display = gdk_wayland_display_get_wl_display (backend_gdk->display); - - /* Force a Wayland winsys */ - cogl_renderer_set_winsys_id (renderer, COGL_WINSYS_ID_EGL_WAYLAND); - cogl_wayland_renderer_set_foreign_display (renderer, display); - cogl_wayland_renderer_set_event_dispatch_enabled (renderer, !disable_event_retrieval); - } - else -#endif - { - g_set_error (error, CLUTTER_INIT_ERROR, - CLUTTER_INIT_ERROR_BACKEND, - _("Could not find a suitable CoglWinsys for a GdkDisplay of type %s"), - G_OBJECT_TYPE_NAME (backend_gdk->display)); - cogl_object_unref (renderer); - - return NULL; - } - - return renderer; -} - -static CoglDisplay * -clutter_backend_gdk_get_display (ClutterBackend *backend, - CoglRenderer *renderer, - CoglSwapChain *swap_chain, - GError **error) -{ - ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); - CoglOnscreenTemplate *onscreen_template; - GError *internal_error = NULL; - CoglDisplay *display; - gboolean has_rgba_visual; - gboolean res; - - /* We default to an RGBA visual if there is one */ - has_rgba_visual = gdk_screen_get_rgba_visual (backend_gdk->screen) != NULL; - - CLUTTER_NOTE (BACKEND, "Alpha on Cogl swap chain: %s", - has_rgba_visual ? "enabled" : "disabled"); - - cogl_swap_chain_set_has_alpha (swap_chain, has_rgba_visual); - - onscreen_template = cogl_onscreen_template_new (swap_chain); - - res = cogl_renderer_check_onscreen_template (renderer, - onscreen_template, - &internal_error); - if (!res && has_rgba_visual) - { - CLUTTER_NOTE (BACKEND, - "Creation of a context with a ARGB visual failed: %s", - internal_error != NULL ? internal_error->message - : "Unknown reason"); - - g_clear_error (&internal_error); - - /* It's possible that the current renderer doesn't support transparency - * in a swap_chain so lets see if we can fallback to not having any - * transparency... - * - * XXX: It might be nice to have a CoglRenderer feature we could - * explicitly check for ahead of time. - */ - cogl_swap_chain_set_has_alpha (swap_chain, FALSE); - res = cogl_renderer_check_onscreen_template (renderer, - onscreen_template, - &internal_error); - } - - if (!res) - { - g_set_error_literal (error, CLUTTER_INIT_ERROR, - CLUTTER_INIT_ERROR_BACKEND, - internal_error->message); - - g_error_free (internal_error); - cogl_object_unref (onscreen_template); - - return NULL; - } - - display = cogl_display_new (renderer, onscreen_template); - cogl_object_unref (onscreen_template); - - return display; -} - -static void -clutter_backend_gdk_class_init (ClutterBackendGdkClass *klass) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (klass); - ClutterBackendClass *backend_class = CLUTTER_BACKEND_CLASS (klass); - - gobject_class->dispose = clutter_backend_gdk_dispose; - gobject_class->finalize = clutter_backend_gdk_finalize; - - backend_class->stage_window_type = CLUTTER_TYPE_STAGE_GDK; - - backend_class->post_parse = _clutter_backend_gdk_post_parse; - - backend_class->get_features = clutter_backend_gdk_get_features; - - backend_class->get_renderer = clutter_backend_gdk_get_renderer; - backend_class->get_display = clutter_backend_gdk_get_display; -} - -static void -clutter_backend_gdk_init (ClutterBackendGdk *backend_gdk) -{ - /* Deactivate sync to vblank since we have the GdkFrameClock to - * drive us from the compositor. - */ - _clutter_set_sync_to_vblank (FALSE); -} - -ClutterBackend * -clutter_backend_gdk_new (void) -{ - return g_object_new (CLUTTER_TYPE_BACKEND_GDK, NULL); -} - -/** - * clutter_gdk_get_default_display: - * - * Retrieves the pointer to the default display. - * - * Return value: (transfer none): the default display - * - * Since: 0.6 - */ -GdkDisplay * -clutter_gdk_get_default_display (void) -{ - ClutterBackend *backend = clutter_get_default_backend (); - - if (backend == NULL) - { - g_critical ("The Clutter backend has not been initialised"); - return NULL; - } - - if (!CLUTTER_IS_BACKEND_GDK (backend)) - { - g_critical ("The Clutter backend is not a GDK backend"); - return NULL; - } - - return CLUTTER_BACKEND_GDK (backend)->display; -} - -/** - * clutter_gdk_set_display: - * @display: pointer to a GDK display connection. - * - * Sets the display connection Clutter should use; must be called - * before clutter_init(), clutter_init_with_args() or other functions - * pertaining Clutter's initialization process. - * - * If you are parsing the command line arguments by retrieving Clutter's - * #GOptionGroup with clutter_get_option_group() and calling - * g_option_context_parse() yourself, you should also call - * clutter_gdk_set_display() before g_option_context_parse(). - * - * Since: 0.8 - */ -void -clutter_gdk_set_display (GdkDisplay *display) -{ - if (_clutter_context_is_initialized ()) - { - g_warning ("%s() can only be used before calling clutter_init()", - G_STRFUNC); - return; - } - - _foreign_dpy = g_object_ref (display); -} - -/** - * clutter_gdk_disable_event_retrieval: - * - * Disable the event retrieval in Clutter. - * - * Callers of this function have to set up an event filter using the - * GDK API, and call clutter_gdk_handle_event(). - * - * This function should only be used when embedding Clutter into - * a GDK based toolkit. - * - * Since: 1.10 - */ -void -clutter_gdk_disable_event_retrieval (void) -{ - if (_clutter_context_is_initialized ()) - { - g_warning ("%s() can only be used before calling clutter_init()", - G_STRFUNC); - return; - } - - disable_event_retrieval = TRUE; -} - -/** - * clutter_gdk_get_visual: - * - * Retrieves the #GdkVisual used by Clutter. - * - * This function should be used when embedding Clutter inside GDK-based - * foreign toolkits, to ensure that the visual applied to the #GdkWindow - * used to render the #ClutterStage is the correct one. - * - * Returns: (transfer none): a #GdkVisual instance - * - * Since: 1.22 - */ -GdkVisual * -clutter_gdk_get_visual (void) -{ - ClutterBackend *backend = clutter_get_default_backend (); - GdkScreen *screen; - - if (backend == NULL) - { - g_critical ("The Clutter backend has not been initialised"); - return NULL; - } - - if (!CLUTTER_IS_BACKEND_GDK (backend)) - { - g_critical ("The Clutter backend is not a GDK backend"); - return NULL; - } - - screen = CLUTTER_BACKEND_GDK (backend)->screen; - g_assert (screen != NULL); - -#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) - if (GDK_IS_X11_SCREEN (screen)) - { - XVisualInfo *xvisinfo = cogl_xlib_renderer_get_visual_info (backend->cogl_renderer); - if (xvisinfo != NULL) - return gdk_x11_screen_lookup_visual (screen, xvisinfo->visualid); - } -#endif - - if (gdk_screen_get_rgba_visual (screen) != NULL) - return gdk_screen_get_rgba_visual (screen); - - return gdk_screen_get_system_visual (screen); -} diff --git a/clutter/gdk/clutter-backend-gdk.h b/clutter/gdk/clutter-backend-gdk.h deleted file mode 100644 index 3b8bc3497..000000000 --- a/clutter/gdk/clutter-backend-gdk.h +++ /dev/null @@ -1,74 +0,0 @@ -/* Clutter. - * An OpenGL based 'interactive canvas' library. - * Authored By Matthew Allum - * Copyright (C) 2006-2007 OpenedHand - * 2011 Giovanni Campagna - * - * 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, see . - * - * - */ - -#ifndef __CLUTTER_BACKEND_GDK_H__ -#define __CLUTTER_BACKEND_GDK_H__ - -#include -#include -#include - -#include "clutter-gdk.h" - -#include "clutter-backend-private.h" - -G_BEGIN_DECLS - -#define CLUTTER_TYPE_BACKEND_GDK (clutter_backend_gdk_get_type ()) -#define CLUTTER_BACKEND_GDK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BACKEND_GDK, ClutterBackendGdk)) -#define CLUTTER_IS_BACKEND_GDK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BACKEND_GDK)) -#define CLUTTER_BACKEND_GDK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BACKEND_GDK, ClutterBackendGdkClass)) -#define CLUTTER_IS_BACKEND_GDK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BACKEND_GDK)) -#define CLUTTER_BACKEND_GDK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BACKEND_GDK, ClutterBackendGdkClass)) - -typedef struct _ClutterBackendGdk ClutterBackendGdk; -typedef struct _ClutterBackendGdkClass ClutterBackendGdkClass; - -struct _ClutterBackendGdk -{ - ClutterBackend parent_instance; - - GdkDisplay *display; - GdkScreen *screen; - - ClutterDeviceManager *device_manager; -}; - -struct _ClutterBackendGdkClass -{ - ClutterBackendClass parent_class; - - /* nothing here, for now */ -}; - -GType clutter_backend_gdk_get_type (void) G_GNUC_CONST; - -ClutterBackend *clutter_backend_gdk_new (void); - -void _clutter_backend_gdk_events_init (ClutterBackend *backend); - -void _clutter_backend_gdk_update_setting (ClutterBackendGdk *backend, - const gchar *name); - -G_END_DECLS - -#endif /* __CLUTTER_BACKEND_GDK_H__ */ diff --git a/clutter/gdk/clutter-device-manager-gdk.c b/clutter/gdk/clutter-device-manager-gdk.c deleted file mode 100644 index 04a997097..000000000 --- a/clutter/gdk/clutter-device-manager-gdk.c +++ /dev/null @@ -1,292 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Copyright © 2011 Intel Corp. - * 2011 Giovanni Campagna - * - * 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, see . - * - * Author: Emmanuele Bassi - */ - -#include "config.h" - -#ifdef HAVE_STDINT_H -#include -#endif - -/* XXX: We're using the GdkDeviceManager deprecated API because - * porting to the new GdkSeat API would imply adding an equivalent - * API to Clutter. - */ -#define GDK_DISABLE_DEPRECATION_WARNINGS - -#include "clutter-device-manager-gdk.h" - -#include "clutter-backend-gdk.h" -#include "clutter-input-device-gdk.h" -#include "clutter-stage-gdk.h" - -#include "clutter-backend.h" -#include "clutter-debug.h" -#include "clutter-device-manager-private.h" -#include "clutter-event-private.h" -#include "clutter-event-translator.h" -#include "clutter-stage-private.h" -#include "clutter-private.h" - -#define clutter_device_manager_gdk_get_type _clutter_device_manager_gdk_get_type - -static void clutter_event_extender_iface_init (ClutterEventExtenderInterface *iface); - -G_DEFINE_TYPE_WITH_CODE (ClutterDeviceManagerGdk, clutter_device_manager_gdk, - CLUTTER_TYPE_DEVICE_MANAGER, - G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_EVENT_EXTENDER, - clutter_event_extender_iface_init)) - -enum { - PROP_0, - PROP_GDK_DISPLAY, - PROP_LAST -}; - -static void -clutter_device_manager_gdk_copy_event_data (ClutterEventExtender *event_extender, - const ClutterEvent *src, - ClutterEvent *dest) -{ - GdkEvent *gdk_event; - - gdk_event = _clutter_event_get_platform_data (src); - if (gdk_event != NULL) - _clutter_event_set_platform_data (dest, gdk_event_copy (gdk_event)); -} - -static void -clutter_device_manager_gdk_free_event_data (ClutterEventExtender *event_extender, - ClutterEvent *event) -{ - GdkEvent *gdk_event; - - gdk_event = _clutter_event_get_platform_data (event); - if (gdk_event != NULL) - gdk_event_free (gdk_event); -} - -static void -clutter_event_extender_iface_init (ClutterEventExtenderInterface *iface) -{ - iface->copy_event_data = clutter_device_manager_gdk_copy_event_data; - iface->free_event_data = clutter_device_manager_gdk_free_event_data; -} - -ClutterInputDevice * -_clutter_device_manager_gdk_lookup_device (ClutterDeviceManager *manager, - GdkDevice *device) -{ - ClutterDeviceManagerGdk *manager_gdk = CLUTTER_DEVICE_MANAGER_GDK (manager); - ClutterInputDevice *clutter_device; - - clutter_device = g_object_get_data (G_OBJECT (device), "clutter-device"); - if (clutter_device != NULL) - return clutter_device; - - clutter_device = _clutter_input_device_gdk_new (manager, device); - g_object_set_data_full (G_OBJECT (device), "clutter-device", clutter_device, g_object_unref); - - manager_gdk->device_cache = g_slist_prepend (manager_gdk->device_cache, g_object_ref (clutter_device)); - g_hash_table_replace (manager_gdk->device_by_id, - GINT_TO_POINTER (clutter_input_device_get_device_id (clutter_device)), - g_object_ref (clutter_device)); - - return clutter_device; -} - -static void -clutter_device_manager_gdk_add_device (ClutterDeviceManager *manager, - ClutterInputDevice *device) -{ - /* XXX implement */ -} - -static void -clutter_device_manager_gdk_remove_device (ClutterDeviceManager *manager, - ClutterInputDevice *device) -{ - /* XXX implement */ -} - -static const GSList * -clutter_device_manager_gdk_get_devices (ClutterDeviceManager *manager) -{ - ClutterDeviceManagerGdk *manager_gdk = CLUTTER_DEVICE_MANAGER_GDK (manager); - - return manager_gdk->device_cache; -} - -static ClutterInputDevice * -clutter_device_manager_gdk_get_device (ClutterDeviceManager *manager, - gint id) -{ - ClutterDeviceManagerGdk *manager_gdk = CLUTTER_DEVICE_MANAGER_GDK (manager); - - return g_hash_table_lookup (manager_gdk->device_by_id, GINT_TO_POINTER (id)); -} - -static ClutterInputDevice * -clutter_device_manager_gdk_get_core_device (ClutterDeviceManager *manager, - ClutterInputDeviceType device_type) -{ - ClutterDeviceManagerGdk *manager_gdk = CLUTTER_DEVICE_MANAGER_GDK (manager); - GdkDevice *gdk_device; - - gdk_device = gdk_device_manager_get_client_pointer (manager_gdk->device_manager); - - g_assert (gdk_device != NULL); - - if (device_type == CLUTTER_KEYBOARD_DEVICE) - gdk_device = gdk_device_get_associated_device (gdk_device); - else if (device_type != CLUTTER_POINTER_DEVICE) - return NULL; - - return _clutter_device_manager_gdk_lookup_device (manager, gdk_device); -} - -static void -gdk_device_added (GdkDeviceManager *gdk_manager, - GdkDevice *device, - ClutterDeviceManager *self) -{ - /* this will do the right thing if the device is not there */ - ClutterInputDevice *clutter_device = _clutter_device_manager_gdk_lookup_device (self, device); - - _clutter_device_manager_add_device (self, clutter_device); -} - -static void -gdk_device_removed (GdkDeviceManager *gdk_manager, - GdkDevice *device, - ClutterDeviceManagerGdk *self) -{ - ClutterInputDevice *clutter_device = g_object_get_data (G_OBJECT (device), "clutter-device"); - - if (clutter_device == NULL) - return; - - self->device_cache = g_slist_remove (self->device_cache, clutter_device); - g_object_unref (clutter_device); - - g_hash_table_remove (self->device_by_id, - GINT_TO_POINTER (clutter_input_device_get_device_id (clutter_device))); - - _clutter_device_manager_remove_device (CLUTTER_DEVICE_MANAGER (self), clutter_device); -} - -static void -gdk_device_foreach_cb (gpointer data, - gpointer user_data) -{ - _clutter_device_manager_gdk_lookup_device (user_data, data); -} - -static void -clutter_device_manager_gdk_constructed (GObject *gobject) -{ - ClutterDeviceManagerGdk *manager_gdk = CLUTTER_DEVICE_MANAGER_GDK (gobject); - GList *all_devices; - - g_assert (manager_gdk->device_manager != NULL); - - all_devices = gdk_device_manager_list_devices (manager_gdk->device_manager, - GDK_DEVICE_TYPE_MASTER); - g_list_foreach (all_devices, gdk_device_foreach_cb, manager_gdk); - g_list_free (all_devices); - - all_devices = gdk_device_manager_list_devices (manager_gdk->device_manager, - GDK_DEVICE_TYPE_SLAVE); - g_list_foreach (all_devices, gdk_device_foreach_cb, manager_gdk); - g_list_free (all_devices); - - all_devices = gdk_device_manager_list_devices (manager_gdk->device_manager, - GDK_DEVICE_TYPE_FLOATING); - g_list_foreach (all_devices, gdk_device_foreach_cb, manager_gdk); - g_list_free (all_devices); - - g_object_connect (manager_gdk->device_manager, - "object-signal::device-added", gdk_device_added, gobject, - "object-signal::device-removed", gdk_device_removed, gobject, - NULL); - - if (G_OBJECT_CLASS (clutter_device_manager_gdk_parent_class)->constructed) - G_OBJECT_CLASS (clutter_device_manager_gdk_parent_class)->constructed (gobject); -} - -static void -clutter_device_manager_gdk_set_property (GObject *gobject, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - ClutterDeviceManagerGdk *manager_gdk = CLUTTER_DEVICE_MANAGER_GDK (gobject); - GdkDisplay *gdk_display; - - switch (prop_id) - { - case PROP_GDK_DISPLAY: - gdk_display = GDK_DISPLAY (g_value_get_object (value)); - manager_gdk->device_manager = gdk_display_get_device_manager (gdk_display); - g_object_ref (manager_gdk->device_manager); - break; - - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); - break; - } -} - -static void -clutter_device_manager_gdk_class_init (ClutterDeviceManagerGdkClass *klass) -{ - ClutterDeviceManagerClass *manager_class; - GObjectClass *gobject_class; - GParamSpec *pspec; - - gobject_class = G_OBJECT_CLASS (klass); - - gobject_class->constructed = clutter_device_manager_gdk_constructed; - gobject_class->set_property = clutter_device_manager_gdk_set_property; - - manager_class = CLUTTER_DEVICE_MANAGER_CLASS (klass); - manager_class->add_device = clutter_device_manager_gdk_add_device; - manager_class->remove_device = clutter_device_manager_gdk_remove_device; - manager_class->get_devices = clutter_device_manager_gdk_get_devices; - manager_class->get_core_device = clutter_device_manager_gdk_get_core_device; - manager_class->get_device = clutter_device_manager_gdk_get_device; - - pspec = g_param_spec_object ("gdk-display", - "GdkDisplay", - "The GDK display", - GDK_TYPE_DISPLAY, - CLUTTER_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); - g_object_class_install_property (gobject_class, PROP_GDK_DISPLAY, pspec); -} - -static void -clutter_device_manager_gdk_init (ClutterDeviceManagerGdk *self) -{ - self->device_by_id = g_hash_table_new_full (NULL, NULL, - NULL, (GDestroyNotify) g_object_unref); -} diff --git a/clutter/gdk/clutter-device-manager-gdk.h b/clutter/gdk/clutter-device-manager-gdk.h deleted file mode 100644 index ade24cd89..000000000 --- a/clutter/gdk/clutter-device-manager-gdk.h +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Copyright © 2011 Intel Corp. - * - * 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, see . - * - * Author: Emmanuele Bassi - */ - -#ifndef __CLUTTER_DEVICE_MANAGER_GDK_H__ -#define __CLUTTER_DEVICE_MANAGER_GDK_H__ - -#include -#include - -G_BEGIN_DECLS - -#define CLUTTER_TYPE_DEVICE_MANAGER_GDK (_clutter_device_manager_gdk_get_type ()) -#define CLUTTER_DEVICE_MANAGER_GDK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_DEVICE_MANAGER_GDK, ClutterDeviceManagerGdk)) -#define CLUTTER_IS_DEVICE_MANAGER_GDK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_DEVICE_MANAGER_GDK)) -#define CLUTTER_DEVICE_MANAGER_GDK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_DEVICE_MANAGER_GDK, ClutterDeviceManagerGdkClass)) -#define CLUTTER_IS_DEVICE_MANAGER_GDK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DEVICE_MANAGER_GDK)) -#define CLUTTER_DEVICE_MANAGER_GDK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DEVICE_MANAGER_GDK, ClutterDeviceManagerGdkClass)) - -typedef struct _ClutterDeviceManagerGdk ClutterDeviceManagerGdk; -typedef struct _ClutterDeviceManagerGdkClass ClutterDeviceManagerGdkClass; - -struct _ClutterDeviceManagerGdk -{ - ClutterDeviceManager parent_instance; - - GdkDeviceManager *device_manager; - GSList *device_cache; - GHashTable *device_by_id; -}; - -struct _ClutterDeviceManagerGdkClass -{ - ClutterDeviceManagerClass parent_class; -}; - -GType _clutter_device_manager_gdk_get_type (void) G_GNUC_CONST; - -ClutterInputDevice * _clutter_device_manager_gdk_lookup_device (ClutterDeviceManager *manager, - GdkDevice *device); - -G_END_DECLS - -#endif /* __CLUTTER_DEVICE_MANAGER_GDK_H__ */ diff --git a/clutter/gdk/clutter-event-gdk.c b/clutter/gdk/clutter-event-gdk.c deleted file mode 100644 index a438f2f16..000000000 --- a/clutter/gdk/clutter-event-gdk.c +++ /dev/null @@ -1,361 +0,0 @@ -/* Clutter. - * An OpenGL based 'interactive canvas' library. - * - * Copyright (C) 2006, 2007, 2008 OpenedHand Ltd - * Copyright (C) 2009, 2010 Intel Corp. - * 2011 Giovanni Campagna - * - * 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, see . - * - * - * - * Authored by: - * Matthew Allum - * Emmanuele Bassi - */ - -#include "config.h" - -#include "clutter-gdk.h" -#include "clutter-backend-gdk.h" -#include "clutter-device-manager-gdk.h" -#include "clutter-stage-gdk.h" - -#include "clutter-actor-private.h" -#include "clutter-backend-private.h" -#include "clutter-debug.h" -#include "clutter-device-manager-private.h" -#include "clutter-event-private.h" -#include "clutter-main.h" -#include "clutter-paint-volume-private.h" -#include "clutter-stage-private.h" - -#include - -#include - -/** - * clutter_gdk_handle_event: - * @event: a #GdkEvent - * - * This function processes a single GDK event; it can be used to hook - * into external event processing - * - * Return value: #GdkFilterReturn. %GDK_FILTER_REMOVE indicates that - * Clutter has internally handled the event and the caller should do - * no further processing. %GDK_FILTER_CONTINUE indicates that Clutter - * is either not interested in the event, or has used the event to - * update internal state without taking any exclusive action. - * %GDK_FILTER_TRANSLATE will not occur. - * - */ -GdkFilterReturn -clutter_gdk_handle_event (GdkEvent *gdk_event) -{ - ClutterDeviceManager *device_manager; - ClutterBackendGdk *backend_gdk; - ClutterBackend *backend; - ClutterStage *stage = NULL; - ClutterEvent *event = NULL; - gint spin = 0; - GdkFilterReturn result = GDK_FILTER_CONTINUE; - ClutterInputDevice *device, *source_device; - GdkDevice *gdk_device; - - backend = clutter_get_default_backend (); - if (!CLUTTER_IS_BACKEND_GDK (backend)) - return GDK_FILTER_CONTINUE; - - if (gdk_event->any.window == NULL) - return GDK_FILTER_CONTINUE; - - device_manager = clutter_device_manager_get_default (); - if (G_UNLIKELY (device_manager == NULL)) - return GDK_FILTER_CONTINUE; - - backend_gdk = CLUTTER_BACKEND_GDK (backend); - stage = clutter_gdk_get_stage_from_window (gdk_event->any.window); - - gdk_device = gdk_event_get_device (gdk_event); - if (gdk_device != NULL) - device = _clutter_device_manager_gdk_lookup_device (device_manager, - gdk_device); - else - device = NULL; - - gdk_device = gdk_event_get_source_device (gdk_event); - if (gdk_device != NULL) - source_device = _clutter_device_manager_gdk_lookup_device (device_manager, - gdk_device); - else - source_device = NULL; - - if (stage == NULL) - return GDK_FILTER_CONTINUE; - - _clutter_threads_acquire_lock (); - - switch (gdk_event->type) - { - case GDK_DELETE: - event = clutter_event_new (CLUTTER_DELETE); - break; - - case GDK_DESTROY: - event = clutter_event_new (CLUTTER_DESTROY_NOTIFY); - break; - - case GDK_EXPOSE: - { - ClutterPaintVolume clip; - ClutterVertex origin; - - CLUTTER_NOTE (EVENT, "Expose for stage '%s' [%p] { %d, %d - %d x %d }", - _clutter_actor_get_debug_name (CLUTTER_ACTOR (stage)), - stage, - gdk_event->expose.area.x, - gdk_event->expose.area.y, - gdk_event->expose.area.width, - gdk_event->expose.area.height); - - origin.x = gdk_event->expose.area.x; - origin.y = gdk_event->expose.area.y; - origin.z = 0; - - _clutter_paint_volume_init_static (&clip, CLUTTER_ACTOR (stage)); - - clutter_paint_volume_set_origin (&clip, &origin); - clutter_paint_volume_set_width (&clip, gdk_event->expose.area.width); - clutter_paint_volume_set_height (&clip, gdk_event->expose.area.height); - - _clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stage), 0, &clip); - - clutter_paint_volume_free (&clip); - } - break; - - case GDK_DAMAGE: - /* This is handled by cogl */ - break; - - case GDK_MOTION_NOTIFY: - event = clutter_event_new (CLUTTER_MOTION); - event->motion.time = gdk_event->motion.time; - event->motion.x = gdk_event->motion.x; - event->motion.y = gdk_event->motion.y; - event->motion.axes = NULL; - /* It's all X in the end, right? */ - event->motion.modifier_state = gdk_event->motion.state; - clutter_event_set_device (event, device); - clutter_event_set_source_device (event, source_device); - CLUTTER_NOTE (EVENT, "Motion notifiy [%.2f, %.2f]", - event->motion.x, - event->motion.y); - break; - - case GDK_BUTTON_PRESS: - case GDK_BUTTON_RELEASE: - event = clutter_event_new (gdk_event->type == GDK_BUTTON_PRESS ? - CLUTTER_BUTTON_PRESS : - CLUTTER_BUTTON_RELEASE); - event->button.time = gdk_event->button.time; - event->button.x = gdk_event->button.x; - event->button.y = gdk_event->button.y; - event->button.axes = NULL; - event->button.modifier_state = gdk_event->button.state; - event->button.button = gdk_event->button.button; - event->button.click_count = 1; - clutter_event_set_device (event, device); - clutter_event_set_source_device (event, source_device); - CLUTTER_NOTE (EVENT, "Button %d %s [%.2f, %.2f]", - event->button.button, - event->type == CLUTTER_BUTTON_PRESS ? "press" : "release", - event->button.x, - event->button.y); - break; - - case GDK_TOUCH_BEGIN: - case GDK_TOUCH_END: - case GDK_TOUCH_CANCEL: - case GDK_TOUCH_UPDATE: - event = clutter_event_new (gdk_event->type == GDK_TOUCH_BEGIN ? - CLUTTER_TOUCH_BEGIN : - ((gdk_event->type == GDK_TOUCH_END) ? - CLUTTER_TOUCH_END : - (gdk_event->type == GDK_TOUCH_UPDATE ? - CLUTTER_TOUCH_UPDATE : - CLUTTER_TOUCH_CANCEL))); - event->touch.time = gdk_event->touch.time; - event->touch.x = gdk_event->touch.x; - event->touch.y = gdk_event->touch.y; - event->touch.sequence = (ClutterEventSequence *) gdk_event->touch.sequence; - event->touch.modifier_state = gdk_event->touch.state; - clutter_event_set_device (event, device); - clutter_event_set_source_device (event, source_device); - CLUTTER_NOTE (EVENT, "Touch %p %s [%", - event->touch.sequence, - event->type == CLUTTER_TOUCH_BEGIN ? "begin" : - (event->type == CLUTTER_TOUCH_END ? "end" : - (event->type == CLUTTER_TOUCH_UPDATE ? "update" - : "cancel")), - event->touch.x, event->touch.y); - break; - - case GDK_2BUTTON_PRESS: - case GDK_3BUTTON_PRESS: - /* these are handled by clutter-main.c updating click_count */ - break; - - case GDK_KEY_PRESS: - case GDK_KEY_RELEASE: - event = clutter_event_new (gdk_event->type == GDK_KEY_PRESS ? - CLUTTER_KEY_PRESS : - CLUTTER_KEY_RELEASE); - event->key.time = gdk_event->key.time; - event->key.modifier_state = gdk_event->key.state; - event->key.keyval = gdk_event->key.keyval; - event->key.hardware_keycode = gdk_event->key.hardware_keycode; - event->key.unicode_value = g_utf8_get_char (gdk_event->key.string); - clutter_event_set_device (event, device); - clutter_event_set_source_device (event, source_device); - CLUTTER_NOTE (EVENT, "Key %d %s", - event->key.keyval, - event->type == CLUTTER_KEY_PRESS ? "press" : "release"); - break; - - case GDK_ENTER_NOTIFY: - case GDK_LEAVE_NOTIFY: - event = clutter_event_new (gdk_event->type == GDK_ENTER_NOTIFY ? - CLUTTER_ENTER : - CLUTTER_LEAVE); - event->crossing.source = CLUTTER_ACTOR (stage); - event->crossing.time = gdk_event_get_time (gdk_event); - event->crossing.x = gdk_event->crossing.x; - event->crossing.y = gdk_event->crossing.y; - - /* XXX: no better fallback here? */ - clutter_event_set_device (event, device); - clutter_event_set_source_device (event, source_device); - if (gdk_event->type == GDK_ENTER_NOTIFY) - _clutter_input_device_set_stage (clutter_event_get_device (event), stage); - else if (gdk_event->type == GDK_LEAVE_NOTIFY && - gdk_event->crossing.mode != GDK_CROSSING_TOUCH_BEGIN && - gdk_event->crossing.mode != GDK_CROSSING_TOUCH_END && - gdk_event->crossing.mode != GDK_CROSSING_DEVICE_SWITCH) - _clutter_input_device_set_stage (clutter_event_get_device (event), NULL); - CLUTTER_NOTE (EVENT, "Crossing %s [%.2f, %.2f]", - event->type == CLUTTER_ENTER ? "enter" : "leave", - event->crossing.x, - event->crossing.y); - break; - - case GDK_FOCUS_CHANGE: - if (gdk_event->focus_change.in) - _clutter_stage_update_state (stage, 0, CLUTTER_STAGE_STATE_ACTIVATED); - else - _clutter_stage_update_state (stage, CLUTTER_STAGE_STATE_ACTIVATED, 0); - break; - - case GDK_CONFIGURE: - { - gfloat w, h; - - clutter_actor_get_size (CLUTTER_ACTOR (stage), &w, &h); - - /* Notify gdk stage backend of the new position. This is used - by foreign stages to reposition themselves on wayland. */ - _clutter_stage_gdk_notify_configure (CLUTTER_STAGE_GDK (_clutter_stage_get_window (stage)), - gdk_event->configure.x, - gdk_event->configure.y, - gdk_event->configure.width, - gdk_event->configure.height); - - if ((int) w != gdk_event->configure.width || - (int) h != gdk_event->configure.height) - { - clutter_actor_set_size (CLUTTER_ACTOR (stage), - gdk_event->configure.width, - gdk_event->configure.height); - } - } - break; - - case GDK_SCROLL: - event = clutter_event_new (CLUTTER_SCROLL); - event->scroll.time = gdk_event->scroll.time; - event->scroll.x = gdk_event->scroll.x; - event->scroll.y = gdk_event->scroll.y; - event->scroll.modifier_state = gdk_event->scroll.state; - event->scroll.axes = NULL; - /* XXX: must keep ClutterScrollDirection compatible with GdkScrollDirection */ - event->scroll.direction = (ClutterScrollDirection) gdk_event->scroll.direction; - clutter_event_set_device (event, device); - clutter_event_set_source_device (event, source_device); - clutter_event_set_scroll_delta (event, - gdk_event->scroll.delta_x, - gdk_event->scroll.delta_y); - break; - - case GDK_WINDOW_STATE: - if (gdk_event->window_state.changed_mask & GDK_WINDOW_STATE_FULLSCREEN) - { - gboolean is_fullscreen; - - is_fullscreen = (gdk_event->window_state.new_window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0; - if (is_fullscreen) - _clutter_stage_update_state (stage, 0, CLUTTER_STAGE_STATE_FULLSCREEN); - else - _clutter_stage_update_state (stage, CLUTTER_STAGE_STATE_FULLSCREEN, 0); - } - break; - - case GDK_SETTING: - _clutter_backend_gdk_update_setting (backend_gdk, gdk_event->setting.name); - break; - - default: - break; - } - - if (event != NULL) - { - event->any.stage = stage; - - if (gdk_event->any.send_event) - event->any.flags = CLUTTER_EVENT_FLAG_SYNTHETIC; - - _clutter_event_push (event, FALSE); - - spin = 1; - - CLUTTER_NOTE (EVENT, "Translated one event from Gdk"); - - /* handle also synthetic enter/leave events */ - if (event->type == CLUTTER_MOTION) - spin += 2; - - while (spin > 0 && (event = clutter_event_get ())) - { - /* forward the event into clutter for emission etc. */ - _clutter_stage_queue_event (event->any.stage, event, FALSE); - --spin; - } - - result = GDK_FILTER_REMOVE; - } - - _clutter_threads_release_lock (); - - return result; -} diff --git a/clutter/gdk/clutter-gdk.h b/clutter/gdk/clutter-gdk.h deleted file mode 100644 index c5b979bc1..000000000 --- a/clutter/gdk/clutter-gdk.h +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Authored By Matthew Allum - * - * Copyright (C) 2006 OpenedHand - * - * 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, see . - * - * - */ - -/** - * SECTION:clutter-gdk - * @short_description: GDK specific API - * - * The GDK backend for Clutter provides some specific API, allowing - * integration with the GDK API for manipulating the stage window and - * handling events outside of Clutter. - */ - -#ifndef __CLUTTER_GDK_H__ -#define __CLUTTER_GDK_H__ - -#include -#include -#include - -G_BEGIN_DECLS - -CLUTTER_AVAILABLE_IN_1_10 -GdkDisplay * clutter_gdk_get_default_display (void); -CLUTTER_AVAILABLE_IN_1_10 -void clutter_gdk_set_display (GdkDisplay *display); - -CLUTTER_AVAILABLE_IN_1_10 -GdkWindow * clutter_gdk_get_stage_window (ClutterStage *stage); -CLUTTER_AVAILABLE_IN_1_10 -gboolean clutter_gdk_set_stage_foreign (ClutterStage *stage, - GdkWindow *window); - -CLUTTER_AVAILABLE_IN_1_10 -GdkFilterReturn clutter_gdk_handle_event (GdkEvent *event); - -CLUTTER_AVAILABLE_IN_1_10 -ClutterStage * clutter_gdk_get_stage_from_window (GdkWindow *window); - -CLUTTER_AVAILABLE_IN_1_10 -void clutter_gdk_disable_event_retrieval (void); - -CLUTTER_AVAILABLE_IN_1_22 -GdkVisual * clutter_gdk_get_visual (void); - -G_END_DECLS - -#endif /* __CLUTTER_GDK_H__ */ diff --git a/clutter/gdk/clutter-input-device-gdk.c b/clutter/gdk/clutter-input-device-gdk.c deleted file mode 100644 index 2a079e936..000000000 --- a/clutter/gdk/clutter-input-device-gdk.c +++ /dev/null @@ -1,189 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Copyright © 2011 Intel Corp. - * 2011 Giovanni Campagna - * - * 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, see . - * - * Author: Emmanuele Bassi - */ - -#include "config.h" - -#include "clutter-input-device-gdk.h" - -#ifdef GDK_WINDOWING_X11 -#include -#endif - -#include "clutter-debug.h" -#include "clutter-device-manager-private.h" -#include "clutter-private.h" -#include "clutter-stage-private.h" - -#include "clutter-backend-gdk.h" -#include "clutter-stage-gdk.h" - -typedef struct _ClutterInputDeviceClass ClutterInputDeviceGdkClass; - -#define clutter_input_device_gdk_get_type _clutter_input_device_gdk_get_type - -G_DEFINE_TYPE (ClutterInputDeviceGdk, - clutter_input_device_gdk, - CLUTTER_TYPE_INPUT_DEVICE); - -static int device_int_counter; - -enum { - PROP_0, - PROP_GDK_DEVICE, - PROP_LAST -}; - -static void -clutter_input_device_gdk_set_property (GObject *gobject, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - ClutterInputDeviceGdk *self = CLUTTER_INPUT_DEVICE_GDK (gobject); - - switch (prop_id) - { - case PROP_GDK_DEVICE: - self->gdk_device = GDK_DEVICE (g_value_get_object (value)); - break; - - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); - break; - } -} - -static void -clutter_input_device_gdk_class_init (ClutterInputDeviceGdkClass *klass) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (klass); - - gobject_class->set_property = clutter_input_device_gdk_set_property; - - g_object_class_install_property (gobject_class, PROP_GDK_DEVICE, - g_param_spec_object ("gdk-device", - "GdkDevice", - "The GDK device", - GDK_TYPE_DEVICE, - CLUTTER_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)); -} - -static void -clutter_input_device_gdk_init (ClutterInputDeviceGdk *self) -{ -} - -ClutterInputDevice* -_clutter_input_device_gdk_new (ClutterDeviceManager *manager, - GdkDevice *device) -{ - ClutterBackend *backend; - ClutterInputDevice *clutter_device; - ClutterInputMode input_mode = CLUTTER_INPUT_MODE_FLOATING; - ClutterInputDeviceType device_type = CLUTTER_EXTENSION_DEVICE; - gboolean has_cursor = FALSE; - const gchar *name; - gboolean is_enabled = FALSE; - gint device_id; - const char *vendor_id = NULL; - const char *product_id = NULL; - - g_object_get (manager, "backend", &backend, NULL); - - /* yay for name consistency */ - switch (gdk_device_get_device_type (device)) - { - case GDK_DEVICE_TYPE_MASTER: - input_mode = CLUTTER_INPUT_MODE_MASTER; - is_enabled = TRUE; - break; - case GDK_DEVICE_TYPE_SLAVE: - input_mode = CLUTTER_INPUT_MODE_SLAVE; - is_enabled = FALSE; - break; - case GDK_DEVICE_TYPE_FLOATING: - input_mode = CLUTTER_INPUT_MODE_FLOATING; - is_enabled = FALSE; - break; - } - - switch (gdk_device_get_source (device)) - { - case GDK_SOURCE_MOUSE: - device_type = CLUTTER_POINTER_DEVICE; - break; - case GDK_SOURCE_PEN: - device_type = CLUTTER_PEN_DEVICE; - break; - case GDK_SOURCE_ERASER: - device_type = CLUTTER_ERASER_DEVICE; - break; - case GDK_SOURCE_CURSOR: - device_type = CLUTTER_CURSOR_DEVICE; - break; - case GDK_SOURCE_KEYBOARD: - device_type = CLUTTER_KEYBOARD_DEVICE; - break; - case GDK_SOURCE_TOUCHSCREEN: - device_type = CLUTTER_TOUCHSCREEN_DEVICE; - break; - case GDK_SOURCE_TOUCHPAD: - device_type = CLUTTER_TOUCHPAD_DEVICE; - break; - } - - if (device_type != CLUTTER_KEYBOARD_DEVICE) - has_cursor = gdk_device_get_has_cursor (device); - - name = gdk_device_get_name (device); - -#if defined(GDK_WINDOWING_X11) - /* If we're on X11, keep the device id in sync */ - if (GDK_IS_X11_DISPLAY (gdk_device_get_display (device))) - device_id = gdk_x11_device_get_id (device); - else -#endif - device_id = device_int_counter++; - - if (gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_MASTER) - { - product_id = gdk_device_get_product_id (device); - vendor_id = gdk_device_get_vendor_id (device); - } - - clutter_device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_GDK, - "backend", backend, - "device-manager", manager, - "device-mode", input_mode, - "device-type", device_type, - "has-cursor", has_cursor, - "gdk-device", device, - "id", device_id, - "name", name, - "enabled", is_enabled, - "product-id", product_id, - "vendor-id", vendor_id, - NULL); - return clutter_device; -} diff --git a/clutter/gdk/clutter-input-device-gdk.h b/clutter/gdk/clutter-input-device-gdk.h deleted file mode 100644 index bcc57183a..000000000 --- a/clutter/gdk/clutter-input-device-gdk.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Copyright © 2011 Intel Corp. - * - * 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, see . - * - * Author: Emmanuele Bassi - */ - -#ifndef __CLUTTER_INPUT_DEVICE_GDK_H__ -#define __CLUTTER_INPUT_DEVICE_GDK_H__ - -#include -#include - -#include "clutter-backend.h" -#include "clutter-device-manager-private.h" - -G_BEGIN_DECLS - -#define CLUTTER_TYPE_INPUT_DEVICE_GDK (_clutter_input_device_gdk_get_type ()) -#define CLUTTER_INPUT_DEVICE_GDK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_INPUT_DEVICE_GDK, ClutterInputDeviceGdk)) -#define CLUTTER_IS_INPUT_DEVICE_GDK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_INPUT_DEVICE_GDK)) - -typedef struct _ClutterInputDeviceGdk ClutterInputDeviceGdk; - -struct _ClutterInputDeviceGdk -{ - ClutterInputDevice parent; - - GdkDevice *gdk_device; -}; - -GType _clutter_input_device_gdk_get_type (void) G_GNUC_CONST; - -ClutterInputDevice * _clutter_input_device_gdk_new (ClutterDeviceManager *manager, - GdkDevice *device); - -G_END_DECLS - -#endif /* __CLUTTER_INPUT_DEVICE_GDK_H__ */ diff --git a/clutter/gdk/clutter-master-clock-gdk.c b/clutter/gdk/clutter-master-clock-gdk.c deleted file mode 100644 index 90c4cce79..000000000 --- a/clutter/gdk/clutter-master-clock-gdk.c +++ /dev/null @@ -1,594 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Authored By: Lionel Landwerlin - * - * Copyright (C) 2015 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, see . - */ - -/* - * SECTION:clutter-master-clock-gdk - * @short_description: The GDK master clock for all animations - * - * The #ClutterMasterClockDefault class is the GdkFrameClock based implementation - * of #ClutterMasterClock. - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include - -#include "clutter-master-clock.h" -#include "clutter-master-clock-gdk.h" -#include "clutter-stage-gdk.h" -#include "clutter-debug.h" -#include "clutter-private.h" -#include "clutter-stage-manager-private.h" -#include "clutter-stage-private.h" - -#ifdef CLUTTER_ENABLE_DEBUG -#define clutter_warn_if_over_budget(master_clock,start_time,section) G_STMT_START { \ - gint64 __delta = g_get_monotonic_time () - start_time; \ - gint64 __budget = master_clock->remaining_budget; \ - if (__budget > 0 && __delta >= __budget) { \ - _clutter_diagnostic_message ("%s took %" G_GINT64_FORMAT " microseconds " \ - "more than the remaining budget of %" G_GINT64_FORMAT \ - " microseconds", \ - section, __delta - __budget, __budget); \ - } } G_STMT_END -#else -#define clutter_warn_if_over_budget(master_clock,start_time,section) -#endif - -typedef struct _ClutterClockSource ClutterClockSource; - -struct _ClutterMasterClockGdk -{ - GObject parent_instance; - - /* the list of timelines handled by the clock */ - GSList *timelines; - - /* mapping between ClutterStages and GdkFrameClocks. - * - * @stage_to_clock: a direct mapping because each stage has at most one clock - * @clock_to_stage: each clock can have more than one stage - */ - GHashTable *stage_to_clock; - GHashTable *clock_to_stage; - - /* the current state of the clock, in usecs */ - gint64 cur_tick; - - /* the previous state of the clock, in usecs, used to compute the delta */ - gint64 prev_tick; - -#ifdef CLUTTER_ENABLE_DEBUG - gint64 frame_budget; - gint64 remaining_budget; -#endif -}; - -struct _ClutterClockSource -{ - GSource source; - - ClutterMasterClock *master_clock; -}; - -static void clutter_master_clock_iface_init (ClutterMasterClockIface *iface); - -G_DEFINE_TYPE_WITH_CODE (ClutterMasterClockGdk, - clutter_master_clock_gdk, - G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_MASTER_CLOCK, - clutter_master_clock_iface_init)); - -static void -master_clock_schedule_forced_stages_updates (ClutterMasterClockGdk *master_clock) -{ - GHashTableIter iter; - gpointer stage, frame_clock; - - g_hash_table_iter_init (&iter, master_clock->stage_to_clock); - while (g_hash_table_iter_next (&iter, &stage, &frame_clock)) - gdk_frame_clock_request_phase (GDK_FRAME_CLOCK (frame_clock), - GDK_FRAME_CLOCK_PHASE_PAINT); -} - -static void -master_clock_sync_frame_clock_update (ClutterMasterClockGdk *master_clock) -{ - gboolean updating = master_clock->timelines != NULL; - gpointer frame_clock, stage_list; - GHashTableIter iter; - - g_hash_table_iter_init (&iter, master_clock->clock_to_stage); - while (g_hash_table_iter_next (&iter, &frame_clock, &stage_list)) - { - gboolean clock_updating = - GPOINTER_TO_UINT (g_object_get_data (frame_clock, - "clutter-master-clock-updating")); - if (clock_updating != updating) - { - if (updating) - gdk_frame_clock_begin_updating (GDK_FRAME_CLOCK (frame_clock)); - else - gdk_frame_clock_end_updating (GDK_FRAME_CLOCK (frame_clock)); - g_object_set_data (frame_clock, - "clutter-master-clock-updating", - GUINT_TO_POINTER (updating)); - } - } -} - -static void -master_clock_schedule_stage_update (ClutterMasterClockGdk *master_clock, - ClutterStage *stage, - GdkFrameClock *frame_clock) -{ - /* Clear the old update time */ - _clutter_stage_clear_update_time (stage); - - /* And if there is still work to be done, schedule a new one */ - if (_clutter_stage_has_queued_events (stage) || - _clutter_stage_needs_update (stage)) - _clutter_stage_schedule_update (stage); - - /* We can avoid to schedule a new frame if the stage doesn't need - * anymore redrawing. But in the case we still have timelines alive, - * we have no choice, we need to advance the timelines for the next - * frame. */ - if (master_clock->timelines != NULL) - gdk_frame_clock_request_phase (frame_clock, GDK_FRAME_CLOCK_PHASE_PAINT); -} - -static void -master_clock_process_stage_events (ClutterMasterClockGdk *master_clock, - ClutterStage *stage) -{ -#ifdef CLUTTER_ENABLE_DEBUG - gint64 start = g_get_monotonic_time (); -#endif - - /* Process queued events */ - _clutter_stage_process_queued_events (stage); - -#ifdef CLUTTER_ENABLE_DEBUG - if (_clutter_diagnostic_enabled ()) - clutter_warn_if_over_budget (master_clock, start, "Event processing"); - - master_clock->remaining_budget -= (g_get_monotonic_time () - start); -#endif -} - -/* - * master_clock_advance_timelines: - * @master_clock: a #ClutterMasterClock - * - * Advances all the timelines held by the master clock. This function - * should be called before calling _clutter_stage_do_update() to - * make sure that all the timelines are advanced and the scene is updated. - */ -static void -master_clock_advance_timelines (ClutterMasterClockGdk *master_clock) -{ - GSList *timelines, *l; -#ifdef CLUTTER_ENABLE_DEBUG - gint64 start = g_get_monotonic_time (); -#endif - - /* we protect ourselves from timelines being removed during - * the advancement by other timelines by copying the list of - * timelines, taking a reference on them, iterating over the - * copied list and then releasing the reference. - * - * we cannot simply take a reference on the timelines and still - * use the list held by the master clock because the do_tick() - * might result in the creation of a new timeline, which gets - * added at the end of the list with no reference increase and - * thus gets disposed at the end of the iteration. - * - * this implies that a newly added timeline will not be advanced - * by this clock iteration, which is perfectly fine since we're - * in its first cycle. - * - * we also cannot steal the master clock timelines list because - * a timeline might be removed as the direct result of do_tick() - * and remove_timeline() would not find the timeline, failing - * and leaving a dangling pointer behind. - */ - timelines = g_slist_copy (master_clock->timelines); - g_slist_foreach (timelines, (GFunc) g_object_ref, NULL); - - for (l = timelines; l != NULL; l = l->next) - _clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000); - - g_slist_foreach (timelines, (GFunc) g_object_unref, NULL); - g_slist_free (timelines); - -#ifdef CLUTTER_ENABLE_DEBUG - if (_clutter_diagnostic_enabled ()) - clutter_warn_if_over_budget (master_clock, start, "Animations"); - - master_clock->remaining_budget -= (g_get_monotonic_time () - start); -#endif -} - -static gboolean -master_clock_update_stage (ClutterMasterClockGdk *master_clock, - ClutterStage *stage) -{ - gboolean stage_updated = FALSE; -#ifdef CLUTTER_ENABLE_DEBUG - gint64 start = g_get_monotonic_time (); -#endif - - _clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_PRE_PAINT); - - /* Update any stage that needs redraw/relayout after the clock - * is advanced. - */ - stage_updated |= _clutter_stage_do_update (stage); - - _clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_POST_PAINT); - -#ifdef CLUTTER_ENABLE_DEBUG - if (_clutter_diagnostic_enabled ()) - clutter_warn_if_over_budget (master_clock, start, "Updating the stage"); - - master_clock->remaining_budget -= (g_get_monotonic_time () - start); -#endif - - return stage_updated; -} - -static void -clutter_master_clock_gdk_update (GdkFrameClock *frame_clock, - ClutterMasterClockGdk *master_clock) -{ - GList *stages, *l; - - _clutter_threads_acquire_lock (); - - /* Get the time to use for this frame */ - master_clock->cur_tick = gdk_frame_clock_get_frame_time (frame_clock); - -#ifdef CLUTTER_ENABLE_DEBUG - /* Update the remaining budget */ - master_clock->remaining_budget = master_clock->frame_budget; -#endif - - stages = g_hash_table_lookup (master_clock->clock_to_stage, frame_clock); - CLUTTER_NOTE (SCHEDULER, "Updating %d stages tied to frame clock %p", - g_list_length (stages), frame_clock); - for (l = stages; l != NULL; l = l->next) - { - ClutterStage *stage = l->data; - - CLUTTER_NOTE (SCHEDULER, "Master clock (stage:%p, clock:%p) [tick]", stage, frame_clock); - - /* Each frame is split into three separate phases: */ - - /* 1. process all the events; goes through the stage's event queue - * and processes each event according to its type, then emits the - * various signals that are associated with the event - */ - master_clock_process_stage_events (master_clock, stage); - - /* 2. advance the timelines */ - master_clock_advance_timelines (master_clock); - - /* 3. relayout and redraw the stage; the stage might have been - * destroyed in 1. when processing events, check whether it's - * still alive. - */ - - if (g_hash_table_lookup (master_clock->stage_to_clock, stage) != NULL) - { - master_clock_update_stage (master_clock, stage); - master_clock_schedule_stage_update (master_clock, stage, frame_clock); - } - } - - master_clock->prev_tick = master_clock->cur_tick; - - _clutter_threads_release_lock (); -} - -static void -clutter_master_clock_gdk_remove_stage_clock (ClutterMasterClockGdk *master_clock, - ClutterStage *stage) -{ - gpointer frame_clock = g_hash_table_lookup (master_clock->stage_to_clock, stage); - GList *stages; - - if (frame_clock == NULL) - return; - - CLUTTER_NOTE (SCHEDULER, "Removing stage %p with clock %p", stage, frame_clock); - - g_hash_table_remove (master_clock->stage_to_clock, stage); - - stages = g_hash_table_lookup (master_clock->clock_to_stage, frame_clock); - if (stages != NULL) - { - if (stages->next == NULL) - { - /* Deleting the last stage linked to a given clock. We can stop - listening to that clock and also tell the clock we're finish - updating it. */ - if (GPOINTER_TO_UINT (g_object_get_data (frame_clock, - "clutter-master-clock-updating"))) - { - gdk_frame_clock_end_updating (GDK_FRAME_CLOCK (frame_clock)); - g_object_set_data (frame_clock, "clutter-master-clock-updating", NULL); - } - g_signal_handlers_disconnect_by_func (frame_clock, - clutter_master_clock_gdk_update, - master_clock); - - g_hash_table_remove (master_clock->clock_to_stage, frame_clock); - g_list_free (stages); - } - else - { - stages = g_list_remove (stages, stage); - g_hash_table_replace (master_clock->clock_to_stage, - g_object_ref (frame_clock), - stages); - } - } -} - -static void -clutter_master_clock_gdk_add_stage_clock (ClutterMasterClockGdk *master_clock, - ClutterStage *stage, - GdkFrameClock *frame_clock) -{ - GList *stages; - - clutter_master_clock_gdk_remove_stage_clock (master_clock, stage); - - CLUTTER_NOTE (SCHEDULER, "Adding stage %p with clock %p", stage, frame_clock); - - g_hash_table_insert (master_clock->stage_to_clock, stage, g_object_ref (frame_clock)); - - stages = g_hash_table_lookup (master_clock->clock_to_stage, frame_clock); - if (stages == NULL) - { - g_hash_table_insert (master_clock->clock_to_stage, g_object_ref (frame_clock), - g_list_append (NULL, stage)); - - g_signal_connect (frame_clock, "paint", - G_CALLBACK (clutter_master_clock_gdk_update), - master_clock); - } - else - stages = g_list_append (stages, stage); - - if (master_clock->timelines != NULL) - { - _clutter_master_clock_start_running ((ClutterMasterClock *) master_clock); - /* We only need to synchronize the frame clock state if we have - timelines running. */ - master_clock_sync_frame_clock_update (master_clock); - } -} - -static void -clutter_master_clock_gdk_listen_to_stage (ClutterMasterClockGdk *master_clock, - ClutterStage *stage) -{ - ClutterStageWindow *stage_window; - ClutterStageGdk *stage_window_gdk; - GdkFrameClock *frame_clock; - - stage_window = _clutter_stage_get_window (stage); - if (stage_window == NULL) - { - clutter_master_clock_gdk_remove_stage_clock (master_clock, stage); - return; - } - - stage_window_gdk = CLUTTER_STAGE_GDK (stage_window); - if (stage_window_gdk->window == NULL) - { - clutter_master_clock_gdk_remove_stage_clock (master_clock, stage); - return; - } - - frame_clock = gdk_window_get_frame_clock (stage_window_gdk->window); - if (frame_clock == NULL) - { - clutter_master_clock_gdk_remove_stage_clock (master_clock, stage); - return; - } - - clutter_master_clock_gdk_add_stage_clock (master_clock, stage, frame_clock); -} - -static void -clutter_master_clock_gdk_stage_visibility (ClutterStage *stage, - GParamSpec *spec, - ClutterMasterClockGdk *master_clock) -{ - ClutterActor *actor = CLUTTER_ACTOR (stage); - if (clutter_actor_is_mapped (actor)) - clutter_master_clock_gdk_listen_to_stage (master_clock, stage); - else - clutter_master_clock_gdk_remove_stage_clock (master_clock, stage); -} - -static void -clutter_master_clock_gdk_stage_added (ClutterStageManager *manager, - ClutterStage *stage, - ClutterMasterClockGdk *master_clock) -{ - g_signal_connect (stage, "notify::mapped", - G_CALLBACK (clutter_master_clock_gdk_stage_visibility), - master_clock); - - clutter_master_clock_gdk_stage_visibility (stage, NULL, master_clock); -} - -static void -clutter_master_clock_gdk_stage_removed (ClutterStageManager *manager, - ClutterStage *stage, - ClutterMasterClockGdk *master_clock) -{ - clutter_master_clock_gdk_remove_stage_clock (master_clock, stage); - - g_signal_handlers_disconnect_by_func (stage, - clutter_master_clock_gdk_stage_visibility, - master_clock); -} - -static void -clutter_master_clock_gdk_dispose (GObject *gobject) -{ - ClutterStageManager *manager = clutter_stage_manager_get_default (); - - g_signal_handlers_disconnect_by_func (manager, - clutter_master_clock_gdk_stage_added, - gobject); - g_signal_handlers_disconnect_by_func (manager, - clutter_master_clock_gdk_stage_removed, - gobject); - - G_OBJECT_CLASS (clutter_master_clock_gdk_parent_class)->dispose (gobject); -} - -static void -clutter_master_clock_gdk_finalize (GObject *gobject) -{ - ClutterMasterClockGdk *master_clock = CLUTTER_MASTER_CLOCK_GDK (gobject); - - g_hash_table_unref (master_clock->clock_to_stage); - g_hash_table_unref (master_clock->stage_to_clock); - g_slist_free (master_clock->timelines); - - G_OBJECT_CLASS (clutter_master_clock_gdk_parent_class)->finalize (gobject); -} - -static void -clutter_master_clock_gdk_class_init (ClutterMasterClockGdkClass *klass) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (klass); - - gobject_class->dispose = clutter_master_clock_gdk_dispose; - gobject_class->finalize = clutter_master_clock_gdk_finalize; -} - -static void -clutter_master_clock_gdk_init (ClutterMasterClockGdk *self) -{ - ClutterStageManager *manager; - const GSList *stages, *l; - -#ifdef CLUTTER_ENABLE_DEBUG - self->frame_budget = G_USEC_PER_SEC / 60; -#endif - - self->clock_to_stage = g_hash_table_new_full (g_direct_hash, g_direct_equal, - g_object_unref, NULL); - self->stage_to_clock = g_hash_table_new_full (g_direct_hash, g_direct_equal, - NULL, g_object_unref); - - manager = clutter_stage_manager_get_default (); - g_signal_connect (manager, "stage-added", - G_CALLBACK (clutter_master_clock_gdk_stage_added), self); - g_signal_connect (manager, "stage-removed", - G_CALLBACK (clutter_master_clock_gdk_stage_removed), self); - - stages = clutter_stage_manager_peek_stages (manager); - for (l = stages; l; l = l->next) - clutter_master_clock_gdk_stage_added (manager, l->data, self); - - if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_CONTINUOUS_REDRAW)) - g_warning ("Continuous redraw is not supported with the GDK backend."); -} - -static void -clutter_master_clock_gdk_add_timeline (ClutterMasterClock *clock, - ClutterTimeline *timeline) -{ - ClutterMasterClockGdk *master_clock = (ClutterMasterClockGdk *) clock; - gboolean is_first; - - if (g_slist_find (master_clock->timelines, timeline)) - return; - - is_first = master_clock->timelines == NULL; - - master_clock->timelines = g_slist_prepend (master_clock->timelines, - timeline); - - if (is_first) - { - _clutter_master_clock_start_running (clock); - /* Sync frame clock update state if needed. */ - master_clock_sync_frame_clock_update (master_clock); - } -} - -static void -clutter_master_clock_gdk_remove_timeline (ClutterMasterClock *clock, - ClutterTimeline *timeline) -{ - ClutterMasterClockGdk *master_clock = (ClutterMasterClockGdk *) clock; - - master_clock->timelines = g_slist_remove (master_clock->timelines, - timeline); - - /* Sync frame clock update state if we have no more timelines running. */ - if (master_clock->timelines == NULL) - master_clock_sync_frame_clock_update (master_clock); -} - -static void -clutter_master_clock_gdk_start_running (ClutterMasterClock *clock) -{ - master_clock_schedule_forced_stages_updates ((ClutterMasterClockGdk *) clock); -} - -static void -clutter_master_clock_gdk_ensure_next_iteration (ClutterMasterClock *clock) -{ - master_clock_schedule_forced_stages_updates ((ClutterMasterClockGdk *) clock); -} - -static void -clutter_master_clock_gdk_set_paused (ClutterMasterClock *clock, - gboolean paused) -{ - /* GdkFrameClock runs the show here. We do not decide whether the - clock is paused or not. */ -} - -static void -clutter_master_clock_iface_init (ClutterMasterClockIface *iface) -{ - iface->add_timeline = clutter_master_clock_gdk_add_timeline; - iface->remove_timeline = clutter_master_clock_gdk_remove_timeline; - iface->start_running = clutter_master_clock_gdk_start_running; - iface->ensure_next_iteration = clutter_master_clock_gdk_ensure_next_iteration; - iface->set_paused = clutter_master_clock_gdk_set_paused; -} diff --git a/clutter/gdk/clutter-master-clock-gdk.h b/clutter/gdk/clutter-master-clock-gdk.h deleted file mode 100644 index 3bc809b41..000000000 --- a/clutter/gdk/clutter-master-clock-gdk.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Clutter. - * - * An OpenGL based 'interactive canvas' library. - * - * Authored By: Lionel Landwerlin - * - * Copyright (C) 2015 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, see . - */ - -#ifndef __CLUTTER_MASTER_CLOCK_GDK_H__ -#define __CLUTTER_MASTER_CLOCK_GDK_H__ - -#include - -G_BEGIN_DECLS - -#define CLUTTER_TYPE_MASTER_CLOCK_GDK (clutter_master_clock_gdk_get_type ()) -#define CLUTTER_MASTER_CLOCK_GDK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MASTER_CLOCK_GDK, ClutterMasterClockGdk)) -#define CLUTTER_IS_MASTER_CLOCK_GDK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MASTER_CLOCK_GDK)) -#define CLUTTER_MASTER_CLOCK_GDK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MASTER_CLOCK_GDK, ClutterMasterClockGdkClass)) - -typedef struct _ClutterMasterClockGdk ClutterMasterClockGdk; -typedef struct _ClutterMasterClockGdkClass ClutterMasterClockGdkClass; - -struct _ClutterMasterClockGdkClass -{ - GObjectClass parent_class; -}; - -GType clutter_master_clock_gdk_get_type (void) G_GNUC_CONST; - -G_END_DECLS - -#endif /* __CLUTTER_MASTER_CLOCK_GDK_H__ */ diff --git a/clutter/gdk/clutter-settings-gdk.h b/clutter/gdk/clutter-settings-gdk.h deleted file mode 100644 index 9c0fd4f1f..000000000 --- a/clutter/gdk/clutter-settings-gdk.h +++ /dev/null @@ -1,29 +0,0 @@ -#ifndef __CLUTTER_SETTINGS_GDK_H__ -#define __CLUTTER_SETTINGS_GDK_H__ - -/* XSETTINGS key names to ClutterSettings properties */ -static const struct { - const char *gdk_setting_name; - const char *settings_property; - GType type; -} _clutter_settings_map[] = { - { "gdk-window-scaling-factor", "window-scaling-factor", G_TYPE_INT }, - { "gtk-double-click-time", "double-click-time", G_TYPE_INT }, - { "gtk-double-click-distance", "double-click-distance", G_TYPE_INT }, - { "gtk-dnd-drag-threshold", "dnd-drag-threshold", G_TYPE_INT }, - { "gtk-font-name", "font-name", G_TYPE_STRING }, - { "gtk-xft-antialias", "font-antialias", G_TYPE_INT }, - { "gtk-xft-dpi", "font-dpi", G_TYPE_INT }, - { "gtk-xft-hinting", "font-hinting", G_TYPE_INT }, - { "gtk-xft-hintstyle", "font-hint-style", G_TYPE_STRING }, - { "gtk-xft-rgba", "font-subpixel-order", G_TYPE_STRING }, - { "gtk-fontconfig-timestamp", "fontconfig-timestamp", G_TYPE_UINT }, -}; - -static const gint _n_clutter_settings_map = G_N_ELEMENTS (_clutter_settings_map); - -#define CLUTTER_SETTING_TYPE(id) (_clutter_settings_map[(id)].type) -#define CLUTTER_SETTING_GDK_NAME(id) (_clutter_settings_map[(id)].gdk_setting_name) -#define CLUTTER_SETTING_PROPERTY(id) (_clutter_settings_map[(id)].settings_property) - -#endif /* __CLUTTER_SETTINGS_GDK_H__ */ diff --git a/clutter/gdk/clutter-stage-gdk.c b/clutter/gdk/clutter-stage-gdk.c deleted file mode 100644 index 144b4c32c..000000000 --- a/clutter/gdk/clutter-stage-gdk.c +++ /dev/null @@ -1,933 +0,0 @@ -/* Clutter. - * An OpenGL based 'interactive canvas' library. - * Authored By Matthew Allum - * Copyright (C) 2006-2007 OpenedHand - * - * 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, see . - * - * - */ - -#include "config.h" - -#include - -#ifdef HAVE_UNISTD_H -#include -#endif - -#include - -#ifdef COGL_HAS_XLIB_SUPPORT -#include -#endif - -#define GDK_DISABLE_DEPRECATION_WARNINGS - -#include -#ifdef GDK_WINDOWING_X11 -#include -#endif -#ifdef GDK_WINDOWING_WAYLAND -#include -#endif - -#include "clutter-backend-gdk.h" -#include "clutter-stage-gdk.h" -#include "clutter-gdk.h" - -#include "clutter-actor-private.h" -#include "clutter-debug.h" -#include "clutter-device-manager-private.h" -#include "clutter-enum-types.h" -#include "clutter-event-translator.h" -#include "clutter-event-private.h" -#include "clutter-feature.h" -#include "clutter-main.h" -#include "clutter-paint-volume-private.h" -#include "clutter-private.h" -#include "clutter-stage-private.h" - -static void clutter_stage_window_iface_init (ClutterStageWindowIface *iface); - -static ClutterStageWindowIface *clutter_stage_window_parent_iface = NULL; - -#define clutter_stage_gdk_get_type _clutter_stage_gdk_get_type - -G_DEFINE_TYPE_WITH_CODE (ClutterStageGdk, - clutter_stage_gdk, - CLUTTER_TYPE_STAGE_COGL, - G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_STAGE_WINDOW, - clutter_stage_window_iface_init)); - -#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) -static void -clutter_stage_gdk_update_foreign_event_mask (CoglOnscreen *onscreen, - guint32 event_mask, - void *user_data) -{ - ClutterStageGdk *stage_gdk = user_data; - - /* we assume that a GDK event mask is bitwise compatible with X11 - event masks */ - gdk_window_set_events (stage_gdk->window, event_mask | CLUTTER_STAGE_GDK_EVENT_MASK); -} -#endif - -static void -clutter_stage_gdk_set_gdk_geometry (ClutterStageGdk *stage) -{ - GdkGeometry geometry; - ClutterStage *wrapper = CLUTTER_STAGE_COGL (stage)->wrapper; - gboolean resize = clutter_stage_get_user_resizable (wrapper); - - if (!resize) - { - geometry.min_width = geometry.max_width = gdk_window_get_width (stage->window); - geometry.min_height = geometry.max_height = gdk_window_get_height (stage->window); - - gdk_window_set_geometry_hints (stage->window, - &geometry, - GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE); - } - else - { - clutter_stage_get_minimum_size (wrapper, - (guint *)&geometry.min_width, - (guint *)&geometry.min_height); - - gdk_window_set_geometry_hints (stage->window, - &geometry, - GDK_HINT_MIN_SIZE); - } -} - -static void -clutter_stage_gdk_get_geometry (ClutterStageWindow *stage_window, - cairo_rectangle_int_t *geometry) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - geometry->x = geometry->y = 0; - - if (stage_gdk->window != NULL) - { - geometry->width = gdk_window_get_width (stage_gdk->window); - geometry->height = gdk_window_get_height (stage_gdk->window); - } - else - { - geometry->width = 800; - geometry->height = 600; - } -} - -static void -clutter_stage_gdk_resize (ClutterStageWindow *stage_window, - gint width, - gint height) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - if (width == 0 || height == 0) - { - /* Should not happen, if this turns up we need to debug it and - * determine the cleanest way to fix. - */ - g_warning ("GDK stage not allowed to have 0 width or height"); - width = 1; - height = 1; - } - - CLUTTER_NOTE (BACKEND, "New size received: (%d, %d)", width, height); - - /* No need to resize foreign windows, it should be handled by the - * embedding framework, but on wayland we might need to resize our - * own subsurface. - */ - if (!stage_gdk->foreign_window) - gdk_window_resize (stage_gdk->window, width, height); -#if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) - else if (GDK_IS_WAYLAND_WINDOW (stage_gdk->window)) - { - int scale = gdk_window_get_scale_factor (stage_gdk->window); - cogl_wayland_onscreen_resize (CLUTTER_STAGE_COGL (stage_gdk)->onscreen, - width * scale, height * scale, 0, 0); - } -#endif -} - -static void -clutter_stage_gdk_unrealize (ClutterStageWindow *stage_window) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - if (stage_gdk->window != NULL) - { - g_object_set_data (G_OBJECT (stage_gdk->window), - "clutter-stage-window", NULL); - - if (stage_gdk->foreign_window) - { - ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window); - - g_object_unref (stage_gdk->window); - - /* Clutter still uses part of the deprecated stateful API of - * Cogl (in particulart cogl_set_framebuffer). It means Cogl - * can keep an internal reference to the onscreen object we - * rendered to. In the case of foreign window, we want to - * avoid this, as we don't know what's going to happen to - * that window. - * - * The following call sets the current Cogl framebuffer to a - * dummy 1x1 one if we're unrealizing the current one, so - * Cogl doesn't keep any reference to the foreign window. - */ - if (cogl_get_draw_framebuffer () == COGL_FRAMEBUFFER (stage_cogl->onscreen)) - _clutter_backend_reset_cogl_framebuffer (stage_cogl->backend); - } - else - gdk_window_destroy (stage_gdk->window); - - stage_gdk->window = NULL; - } - - clutter_stage_window_parent_iface->unrealize (stage_window); - -#if defined(GDK_WINDOWING_WAYLAND) - g_clear_pointer (&stage_gdk->subsurface, wl_subsurface_destroy); - g_clear_pointer (&stage_gdk->clutter_surface, wl_surface_destroy); -#endif -} - -#if defined(GDK_WINDOWING_WAYLAND) -static struct wl_surface * -clutter_stage_gdk_wayland_surface (ClutterStageGdk *stage_gdk) -{ - GdkDisplay *display; - struct wl_compositor *compositor; - struct wl_surface *parent_surface; - struct wl_region *input_region; - gint x, y; - - if (!stage_gdk->foreign_window || - gdk_window_get_window_type (stage_gdk->window) != GDK_WINDOW_CHILD) - return gdk_wayland_window_get_wl_surface (stage_gdk->window); - - if (stage_gdk->clutter_surface) - return stage_gdk->clutter_surface; - - /* On Wayland if we render to a foreign window, we setup our own - * surface to not render in the same buffers as the embedding - * framework. - */ - display = gdk_display_get_default (); - compositor = gdk_wayland_display_get_wl_compositor (display); - stage_gdk->clutter_surface = wl_compositor_create_surface (compositor); - - /* Since we run inside GDK, we can let the embedding framework - * dispatch the events to Clutter. For that to happen we need to - * disable input on our surface. */ - input_region = wl_compositor_create_region (compositor); - wl_region_add (input_region, 0, 0, 0, 0); - wl_surface_set_input_region (stage_gdk->clutter_surface, input_region); - wl_region_destroy (input_region); - - wl_surface_set_buffer_scale (stage_gdk->clutter_surface, - gdk_window_get_scale_factor (stage_gdk->window)); - - parent_surface = gdk_wayland_window_get_wl_surface (gdk_window_get_toplevel (stage_gdk->window)); - stage_gdk->subsurface = wl_subcompositor_get_subsurface (stage_gdk->subcompositor, - stage_gdk->clutter_surface, - parent_surface); - - gdk_window_get_origin (stage_gdk->window, &x, &y); - wl_subsurface_set_position (stage_gdk->subsurface, x, y); - wl_subsurface_set_desync (stage_gdk->subsurface); - - return stage_gdk->clutter_surface; -} -#endif - -void -_clutter_stage_gdk_notify_configure (ClutterStageGdk *stage_gdk, - gint x, - gint y, - gint width, - gint height) -{ - if (x < 0 || y < 0 || width < 1 || height < 1) - return; - - if (stage_gdk->foreign_window) - { - ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_gdk); - int scale = gdk_window_get_scale_factor (stage_gdk->window); - -#if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) - if (GDK_IS_WAYLAND_WINDOW (stage_gdk->window) && - gdk_window_get_window_type (stage_gdk->window) == GDK_WINDOW_CHILD && - stage_gdk->subsurface) - { - gint rx, ry; - gdk_window_get_origin (stage_gdk->window, &rx, &ry); - wl_subsurface_set_position (stage_gdk->subsurface, rx, ry); - - wl_surface_set_buffer_scale (stage_gdk->clutter_surface, scale); - cogl_wayland_onscreen_resize (stage_cogl->onscreen, - width * scale, height * scale, 0, 0); - } - else -#endif -#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) - if (GDK_IS_X11_WINDOW (stage_gdk->window)) - { - ClutterBackend *backend = CLUTTER_BACKEND (stage_cogl->backend); - XConfigureEvent xevent = { ConfigureNotify }; - xevent.window = GDK_WINDOW_XID (stage_gdk->window); - xevent.width = width * scale; - xevent.height = height * scale; - - /* Ensure cogl knows about the new size immediately, as we will - * draw before we get the ConfigureNotify response. */ - cogl_xlib_renderer_handle_event (backend->cogl_renderer, (XEvent *)&xevent); - } - else -#endif - { - /* Currently we only support X11 and Wayland. */ - g_assert_not_reached(); - } - } -} - -static gboolean -clutter_stage_gdk_realize (ClutterStageWindow *stage_window) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window); - ClutterBackend *backend = CLUTTER_BACKEND (stage_cogl->backend); - ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); - GdkWindowAttr attributes; - gboolean cursor_visible; - gboolean use_alpha; - gfloat width, height; - int scale; - - if (backend->cogl_context == NULL) - { - g_warning ("Missing Cogl context: was Clutter correctly initialized?"); - return FALSE; - } - - if (!stage_gdk->foreign_window) - { - if (stage_gdk->window != NULL) - { - /* complete realizing the stage */ - cairo_rectangle_int_t geometry; - - clutter_stage_gdk_get_geometry (stage_window, &geometry); - clutter_actor_set_size (CLUTTER_ACTOR (stage_cogl->wrapper), - geometry.width, - geometry.height); - - gdk_window_ensure_native (stage_gdk->window); - gdk_window_set_events (stage_gdk->window, CLUTTER_STAGE_GDK_EVENT_MASK); - - return TRUE; - } - else - { - attributes.title = NULL; - g_object_get (stage_cogl->wrapper, - "cursor-visible", &cursor_visible, - "title", &attributes.title, - "width", &width, - "height", &height, - "use-alpha", &use_alpha, - NULL); - - attributes.width = width; - attributes.height = height; - attributes.wclass = GDK_INPUT_OUTPUT; - attributes.window_type = GDK_WINDOW_TOPLEVEL; - attributes.event_mask = CLUTTER_STAGE_GDK_EVENT_MASK; - - attributes.cursor = NULL; - if (!cursor_visible) - { - if (stage_gdk->blank_cursor == NULL) - stage_gdk->blank_cursor = gdk_cursor_new_for_display (backend_gdk->display, GDK_BLANK_CURSOR); - - attributes.cursor = stage_gdk->blank_cursor; - } - - /* If the ClutterStage:use-alpha is set, but GDK does not have an - * RGBA visual, then we unset the property on the Stage - */ - if (use_alpha) - { - if (gdk_screen_get_rgba_visual (backend_gdk->screen) == NULL) - { - clutter_stage_set_use_alpha (stage_cogl->wrapper, FALSE); - use_alpha = FALSE; - } - } - -#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) - if (GDK_IS_X11_DISPLAY (backend_gdk->display)) - { - XVisualInfo *xvisinfo = cogl_clutter_winsys_xlib_get_visual_info (); - if (xvisinfo != NULL) - { - attributes.visual = gdk_x11_screen_lookup_visual (backend_gdk->screen, - xvisinfo->visualid); - } - } - else -#endif - { - attributes.visual = use_alpha - ? gdk_screen_get_rgba_visual (backend_gdk->screen) - : gdk_screen_get_system_visual (backend_gdk->screen); - } - - if (attributes.visual == NULL) - { - /* This could still be an RGBA visual, although normally it's not */ - attributes.visual = gdk_screen_get_system_visual (backend_gdk->screen); - } - - stage_gdk->foreign_window = FALSE; - stage_gdk->window = gdk_window_new (NULL, &attributes, - GDK_WA_TITLE | GDK_WA_CURSOR | GDK_WA_VISUAL); - - g_free (attributes.title); - } - - clutter_stage_gdk_set_gdk_geometry (stage_gdk); - gdk_window_ensure_native (stage_gdk->window); - } - else - { - width = gdk_window_get_width (stage_gdk->window); - height = gdk_window_get_height (stage_gdk->window); - } - - g_object_set_data (G_OBJECT (stage_gdk->window), "clutter-stage-window", stage_gdk); - - scale = gdk_window_get_scale_factor (stage_gdk->window); - stage_cogl->onscreen = cogl_onscreen_new (backend->cogl_context, - width * scale, height * scale); - -#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) - if (GDK_IS_X11_WINDOW (stage_gdk->window)) - { - cogl_x11_onscreen_set_foreign_window_xid (stage_cogl->onscreen, - GDK_WINDOW_XID (stage_gdk->window), - clutter_stage_gdk_update_foreign_event_mask, - stage_gdk); - } - else -#endif -#if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) - if (GDK_IS_WAYLAND_WINDOW (stage_gdk->window)) - { - cogl_wayland_onscreen_set_foreign_surface (stage_cogl->onscreen, - clutter_stage_gdk_wayland_surface (stage_gdk)); - } - else -#endif - { - g_warning ("Cannot find an appropriate CoglWinsys for a " - "GdkWindow of type %s", G_OBJECT_TYPE_NAME (stage_gdk->window)); - - cogl_object_unref (stage_cogl->onscreen); - stage_cogl->onscreen = NULL; - - if (!stage_gdk->foreign_window) - gdk_window_destroy (stage_gdk->window); - - stage_gdk->window = NULL; - - return FALSE; - } - - return clutter_stage_window_parent_iface->realize (stage_window); -} - -static void -clutter_stage_gdk_set_fullscreen (ClutterStageWindow *stage_window, - gboolean is_fullscreen) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window); - ClutterStage *stage = CLUTTER_STAGE_COGL (stage_window)->wrapper; - gboolean swap_throttle; - - if (stage == NULL || CLUTTER_ACTOR_IN_DESTRUCTION (stage)) - return; - - if (stage_gdk->window == NULL || stage_gdk->foreign_window) - return; - - CLUTTER_NOTE (BACKEND, "%ssetting fullscreen", is_fullscreen ? "" : "un"); - - if (is_fullscreen) - gdk_window_fullscreen (stage_gdk->window); - else - gdk_window_unfullscreen (stage_gdk->window); - - /* Full-screen stages are usually unredirected to improve performance - * by avoiding a copy; when that happens, we need to turn back swap - * throttling because we won't be managed by the compositor any more, - */ - swap_throttle = is_fullscreen; - -#ifdef GDK_WINDOWING_WAYLAND - { - /* Except on Wayland, where there's a deadlock due to both Cogl - * and GDK attempting to consume the throttling event; see bug - * https://bugzilla.gnome.org/show_bug.cgi?id=754671#c1 - */ - GdkDisplay *display = clutter_gdk_get_default_display (); - if (GDK_IS_WAYLAND_DISPLAY (display)) - swap_throttle = FALSE; - } -#endif - - cogl_onscreen_set_swap_throttled (stage_cogl->onscreen, swap_throttle); -} - -static void -clutter_stage_gdk_set_cursor_visible (ClutterStageWindow *stage_window, - gboolean cursor_visible) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - if (stage_gdk->window == NULL) - return; - - if (cursor_visible) - { - gdk_window_set_cursor (stage_gdk->window, NULL); - } - else - { - if (stage_gdk->blank_cursor == NULL) - { - GdkDisplay *display = clutter_gdk_get_default_display (); - - stage_gdk->blank_cursor = gdk_cursor_new_for_display (display, GDK_BLANK_CURSOR); - } - - gdk_window_set_cursor (stage_gdk->window, stage_gdk->blank_cursor); - } -} - -static void -clutter_stage_gdk_set_title (ClutterStageWindow *stage_window, - const gchar *title) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - if (stage_gdk->window == NULL || stage_gdk->foreign_window) - return; - - gdk_window_set_title (stage_gdk->window, title); -} - -static void -clutter_stage_gdk_set_user_resizable (ClutterStageWindow *stage_window, - gboolean is_resizable) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - GdkWMFunction function; - - if (stage_gdk->window == NULL || stage_gdk->foreign_window) - return; - - function = GDK_FUNC_MOVE | GDK_FUNC_MINIMIZE | GDK_FUNC_CLOSE; - if (is_resizable) - function |= GDK_FUNC_RESIZE | GDK_FUNC_MAXIMIZE; - - gdk_window_set_functions (stage_gdk->window, function); - - clutter_stage_gdk_set_gdk_geometry (stage_gdk); -} - -static void -clutter_stage_gdk_set_accept_focus (ClutterStageWindow *stage_window, - gboolean accept_focus) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - if (stage_gdk->window == NULL || stage_gdk->foreign_window) - return; - - gdk_window_set_accept_focus (stage_gdk->window, accept_focus); -} - -static void -clutter_stage_gdk_show (ClutterStageWindow *stage_window, - gboolean do_raise) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - g_return_if_fail (stage_gdk->window != NULL); - - clutter_actor_map (CLUTTER_ACTOR (CLUTTER_STAGE_COGL (stage_gdk)->wrapper)); - - /* Foreign window should be shown by the embedding framework. */ - if (!stage_gdk->foreign_window) - { - if (do_raise) - gdk_window_show (stage_gdk->window); - else - gdk_window_show_unraised (stage_gdk->window); - } -} - -static void -clutter_stage_gdk_hide (ClutterStageWindow *stage_window) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - g_return_if_fail (stage_gdk->window != NULL); - - clutter_actor_unmap (CLUTTER_ACTOR (CLUTTER_STAGE_COGL (stage_gdk)->wrapper)); - - /* Foreign window should be hidden by the embedding framework. */ - if (!stage_gdk->foreign_window) - gdk_window_hide (stage_gdk->window); -} - -static gboolean -clutter_stage_gdk_can_clip_redraws (ClutterStageWindow *stage_window) -{ - return TRUE; -} - -static int -clutter_stage_gdk_get_scale_factor (ClutterStageWindow *stage_window) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - - if (stage_gdk->window == NULL) - return 1; - - return gdk_window_get_scale_factor (stage_gdk->window); -} - -static void -clutter_stage_gdk_redraw (ClutterStageWindow *stage_window) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - GdkFrameClock *clock; - - if (stage_gdk->window == NULL || - (clock = gdk_window_get_frame_clock (stage_gdk->window)) == NULL) - { - clutter_stage_window_parent_iface->redraw (stage_window); - return; - } - - gdk_frame_clock_begin_updating (clock); - - clutter_stage_window_parent_iface->redraw (stage_window); - - gdk_frame_clock_end_updating (clock); -} - -static void -clutter_stage_gdk_schedule_update (ClutterStageWindow *stage_window, - gint sync_delay) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - GdkFrameClock *clock; - - if (stage_gdk->window == NULL || - (clock = gdk_window_get_frame_clock (stage_gdk->window)) == NULL) - { - clutter_stage_window_parent_iface->schedule_update (stage_window, sync_delay); - return; - } - - gdk_frame_clock_request_phase (clock, GDK_FRAME_CLOCK_PHASE_PAINT); - - clutter_stage_window_parent_iface->schedule_update (stage_window, sync_delay); -} - -static gint64 -clutter_stage_gdk_get_update_time (ClutterStageWindow *stage_window) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); - GdkFrameClock *frame_clock; - GdkFrameTimings *frame_timings; - - if (stage_gdk->window == NULL || - (frame_clock = gdk_window_get_frame_clock (stage_gdk->window)) == NULL || - (frame_timings = gdk_frame_clock_get_current_timings (frame_clock)) == NULL || - !gdk_frame_timings_get_complete (frame_timings)) - return -1; /* No data, indefinite */ - - return (gdk_frame_timings_get_presentation_time (frame_timings) + - gdk_frame_timings_get_refresh_interval (frame_timings)); -} - -static void -clutter_stage_gdk_dispose (GObject *gobject) -{ - ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (gobject); - - if (stage_gdk->window != NULL) - { - g_object_set_data (G_OBJECT (stage_gdk->window), - "clutter-stage-window", NULL); - if (stage_gdk->foreign_window) - g_object_unref (stage_gdk->window); - else - gdk_window_destroy (stage_gdk->window); - stage_gdk->window = NULL; - } - - if (stage_gdk->blank_cursor != NULL) - { - g_object_unref (stage_gdk->blank_cursor); - stage_gdk->blank_cursor = NULL; - } - - G_OBJECT_CLASS (clutter_stage_gdk_parent_class)->dispose (gobject); -} - -static void -clutter_stage_gdk_class_init (ClutterStageGdkClass *klass) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (klass); - - gobject_class->dispose = clutter_stage_gdk_dispose; -} - -#if defined(GDK_WINDOWING_WAYLAND) -static void -registry_handle_global (void *data, - struct wl_registry *registry, - uint32_t name, - const char *interface, - uint32_t version) -{ - ClutterStageGdk *stage_gdk = data; - - if (strcmp (interface, "wl_subcompositor") == 0) - { - stage_gdk->subcompositor = wl_registry_bind (registry, - name, - &wl_subcompositor_interface, - 1); - } -} - -static void -registry_handle_global_remove (void *data, - struct wl_registry *registry, - uint32_t name) -{ -} - -static const struct wl_registry_listener registry_listener = { - registry_handle_global, - registry_handle_global_remove -}; -#endif - -static void -clutter_stage_gdk_init (ClutterStageGdk *stage) -{ -#if defined(GDK_WINDOWING_WAYLAND) - { - GdkDisplay *gdk_display = gdk_display_get_default (); - if (GDK_IS_WAYLAND_DISPLAY (gdk_display)) - { - struct wl_display *display; - struct wl_registry *registry; - - display = gdk_wayland_display_get_wl_display (gdk_display); - registry = wl_display_get_registry (display); - wl_registry_add_listener (registry, ®istry_listener, stage); - - wl_display_roundtrip (display); - } - } -#endif -} - -static void -clutter_stage_window_iface_init (ClutterStageWindowIface *iface) -{ - clutter_stage_window_parent_iface = g_type_interface_peek_parent (iface); - - iface->set_title = clutter_stage_gdk_set_title; - iface->set_fullscreen = clutter_stage_gdk_set_fullscreen; - iface->set_cursor_visible = clutter_stage_gdk_set_cursor_visible; - iface->set_user_resizable = clutter_stage_gdk_set_user_resizable; - iface->set_accept_focus = clutter_stage_gdk_set_accept_focus; - iface->show = clutter_stage_gdk_show; - iface->hide = clutter_stage_gdk_hide; - iface->resize = clutter_stage_gdk_resize; - iface->get_geometry = clutter_stage_gdk_get_geometry; - iface->realize = clutter_stage_gdk_realize; - iface->unrealize = clutter_stage_gdk_unrealize; - iface->can_clip_redraws = clutter_stage_gdk_can_clip_redraws; - iface->get_scale_factor = clutter_stage_gdk_get_scale_factor; - - iface->redraw = clutter_stage_gdk_redraw; - iface->schedule_update = clutter_stage_gdk_schedule_update; - iface->get_update_time = clutter_stage_gdk_get_update_time; -} - -/** - * clutter_gdk_get_stage_window: - * @stage: a #ClutterStage - * - * Gets the stages GdkWindow. - * - * Return value: (transfer none): A GdkWindow* for the stage window. - * - * Since: 1.10 - */ -GdkWindow * -clutter_gdk_get_stage_window (ClutterStage *stage) -{ - ClutterStageWindow *impl; - - g_return_val_if_fail (CLUTTER_IS_STAGE (stage), NULL); - - impl = _clutter_stage_get_window (stage); - if (!CLUTTER_IS_STAGE_GDK (impl)) - { - g_critical ("The Clutter backend is not a GDK backend"); - return NULL; - } - - return CLUTTER_STAGE_GDK (impl)->window; -} - -/** - * clutter_gdk_get_stage_from_window: - * @window: a #GtkWindow - * - * Gets the stage for a particular X window. - * - * Return value: (transfer none): A #ClutterStage, or% NULL if a stage - * does not exist for the window - * - * Since: 1.10 - */ -ClutterStage * -clutter_gdk_get_stage_from_window (GdkWindow *window) -{ - ClutterStageGdk *stage_gdk = g_object_get_data (G_OBJECT (window), "clutter-stage-window"); - - if (stage_gdk != NULL && CLUTTER_IS_STAGE_GDK (stage_gdk)) - return CLUTTER_STAGE_COGL (stage_gdk)->wrapper; - - return NULL; -} - -typedef struct -{ - ClutterStageGdk *stage_gdk; - GdkWindow *window; -} ForeignWindowClosure; - -static void -set_foreign_window_callback (ClutterActor *actor, - void *data) -{ - ForeignWindowClosure *closure = data; - ClutterStageGdk *stage_gdk = closure->stage_gdk; - - stage_gdk->window = closure->window; - stage_gdk->foreign_window = TRUE; - - /* calling this with the stage unrealized will unset the stage - * from the GL context; once the stage is realized the GL context - * will be set again - */ - clutter_stage_ensure_current (CLUTTER_STAGE (actor)); -} - -/** - * clutter_gdk_set_stage_foreign: - * @stage: a #ClutterStage - * @window: an existing #GdkWindow - * - * Target the #ClutterStage to use an existing external #GdkWindow - * - * Return value: %TRUE if foreign window is valid - * - * Since: 1.10 - */ -gboolean -clutter_gdk_set_stage_foreign (ClutterStage *stage, - GdkWindow *window) -{ - ForeignWindowClosure closure; - ClutterStageGdk *stage_gdk; - ClutterStageWindow *impl; - ClutterActor *actor; - - g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE); - g_return_val_if_fail (!CLUTTER_ACTOR_IN_DESTRUCTION (stage), FALSE); - g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE); - - impl = _clutter_stage_get_window (stage); - if (!CLUTTER_IS_STAGE_GDK (impl)) - { - g_critical ("The Clutter backend is not a GDK backend"); - return FALSE; - } - - stage_gdk = CLUTTER_STAGE_GDK (impl); - - if (g_object_get_data (G_OBJECT (window), "clutter-stage-window") != NULL) - { - g_critical ("The provided GdkWindow is already in use by another ClutterStage"); - return FALSE; - } - - closure.stage_gdk = stage_gdk; - closure.window = g_object_ref (window); - - actor = CLUTTER_ACTOR (stage); - - _clutter_actor_rerealize (actor, - set_foreign_window_callback, - &closure); - - /* Queue a relayout - so the stage will be allocated the new - * window size. - * - * Note also that when the stage gets allocated the new - * window size that will result in the stage's - * priv->viewport being changed, which will in turn result - * in the Cogl viewport changing when _clutter_do_redraw - * calls _clutter_stage_maybe_setup_viewport(). - */ - clutter_actor_queue_relayout (actor); - - return TRUE; -} diff --git a/clutter/gdk/clutter-stage-gdk.h b/clutter/gdk/clutter-stage-gdk.h deleted file mode 100644 index effc3098c..000000000 --- a/clutter/gdk/clutter-stage-gdk.h +++ /dev/null @@ -1,95 +0,0 @@ -/* Clutter. - * An OpenGL based 'interactive canvas' library. - * Authored By Matthew Allum - * Copyright (C) 2006-2007 OpenedHand - * 2011 Giovanni Campagna - * - * 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, see . - * - * - */ - -#ifndef __CLUTTER_STAGE_GDK_H__ -#define __CLUTTER_STAGE_GDK_H__ - -#include -#include -#include - -#include "clutter-backend-gdk.h" -#include "cogl/clutter-stage-cogl.h" - -G_BEGIN_DECLS - -#define CLUTTER_TYPE_STAGE_GDK (_clutter_stage_gdk_get_type ()) -#define CLUTTER_STAGE_GDK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STAGE_GDK, ClutterStageGdk)) -#define CLUTTER_IS_STAGE_GDK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STAGE_GDK)) -#define CLUTTER_STAGE_GDK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_STAGE_GDK, ClutterStageGdkClass)) -#define CLUTTER_IS_STAGE_GDK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_STAGE_GDK)) -#define CLUTTER_STAGE_GDK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_STAGE_GDK, ClutterStageGdkClass)) - -typedef struct _ClutterStageGdk ClutterStageGdk; -typedef struct _ClutterStageGdkClass ClutterStageGdkClass; - -struct _ClutterStageGdk -{ - ClutterStageCogl parent_instance; - - GdkWindow *window; - GdkCursor *blank_cursor; - - gboolean foreign_window; - -#if defined(GDK_WINDOWING_WAYLAND) - struct wl_subcompositor *subcompositor; - struct wl_surface *clutter_surface; - struct wl_subsurface *subsurface; -#endif -}; - -struct _ClutterStageGdkClass -{ - ClutterStageCoglClass parent_class; -}; - -#define CLUTTER_STAGE_GDK_EVENT_MASK \ - (GDK_STRUCTURE_MASK | \ - GDK_FOCUS_CHANGE_MASK | \ - GDK_EXPOSURE_MASK | \ - GDK_PROPERTY_CHANGE_MASK | \ - GDK_ENTER_NOTIFY_MASK | \ - GDK_LEAVE_NOTIFY_MASK | \ - GDK_KEY_PRESS_MASK | \ - GDK_KEY_RELEASE_MASK | \ - GDK_BUTTON_PRESS_MASK | \ - GDK_BUTTON_RELEASE_MASK | \ - GDK_POINTER_MOTION_MASK | \ - GDK_TOUCH_MASK | \ - GDK_SCROLL_MASK) - -GType _clutter_stage_gdk_get_type (void) G_GNUC_CONST; - -void _clutter_stage_gdk_notify_configure (ClutterStageGdk *stage_gdk, - gint x, - gint y, - gint width, - gint height); - -void _clutter_stage_gdk_update_foreign_event_mask (CoglOnscreen *onscreen, - guint32 event_mask, - void *user_data); - -G_END_DECLS - -#endif /* __CLUTTER_STAGE_H__ */ diff --git a/configure.ac b/configure.ac index c45a80e27..6b9e39f82 100644 --- a/configure.ac +++ b/configure.ac @@ -214,10 +214,6 @@ AC_ARG_ENABLE([x11-backend], [AS_HELP_STRING([--enable-x11-backend=@<:@yes/no@:>@], [Enable the X11 backend (default=check)])], [enable_x11=$enableval], [enable_x11=check]) -AC_ARG_ENABLE([gdk-backend], - [AS_HELP_STRING([--enable-gdk-backend=@<:@yes/no@:>@], [Enable the GDK backend (default=check)])], - [enable_gdk=$enableval], - [enable_gdk=check]) AC_ARG_ENABLE([wayland-backend], [AS_HELP_STRING([--enable-wayland-backend=@<:@yes/no@:>@], [Enable the Wayland client backend (default=check)])], [enable_wayland=$enableval], @@ -242,10 +238,6 @@ AS_IF([test "x$enable_x11" = xcheck], [ PKG_CHECK_EXISTS([x11], [enable_x11=yes], [enable_x11=no]) ]) -AS_IF([test "x$enable_gdk" = xcheck], [ - PKG_CHECK_EXISTS([gdk-3.0 >= gdk_req_version], [enable_gdk=yes], [enable_gdk=no]) -]) - AS_IF([test "x$enable_egl" = xcheck], [ PKG_CHECK_EXISTS([egl], [enable_egl=yes], [enable_egl=no]) PKG_CHECK_EXISTS([libinput], [enable_evdev=yes], [enable_evdev=no]) @@ -272,17 +264,6 @@ AS_IF([test "x$enable_x11" = "xyes"], []) ]) -AS_IF([test "x$enable_gdk" = "xyes"], - [ - CLUTTER_BACKENDS="$CLUTTER_BACKENDS gdk" - CLUTTER_INPUT_BACKENDS="$CLUTTER_INPUT_BACKENDS gdk" - - SUPPORT_GDK=1 - SUPPORT_COGL=1 - - BACKEND_PC_FILES="$BACKEND_PC_FILES gdk-3.0" - ]) - AS_IF([test "x$enable_wayland" != xno], [ # We need to manually check for Wayland support in Cogl because @@ -401,7 +382,6 @@ AS_IF([test "x$enable_evdev" = xyes], [ # conditionals for use in automake files... AM_CONDITIONAL(SUPPORT_GLX, [test "x$SUPPORT_GLX" = "x1"]) AM_CONDITIONAL(SUPPORT_X11, [test "x$SUPPORT_X11" = "x1"]) -AM_CONDITIONAL(SUPPORT_GDK, [test "x$SUPPORT_GDK" = "x1"]) AM_CONDITIONAL(SUPPORT_EGL, [test "x$SUPPORT_EGL" = "x1"]) AM_CONDITIONAL(SUPPORT_WAYLAND, [test "x$SUPPORT_WAYLAND" = "x1"]) @@ -441,10 +421,6 @@ AS_IF([test "x$SUPPORT_X11" = "x1"], [CLUTTER_CONFIG_DEFINES="$CLUTTER_CONFIG_DEFINES #define CLUTTER_WINDOWING_X11 \"x11\" #define CLUTTER_INPUT_X11 \"x11\""]) -AS_IF([test "x$SUPPORT_GDK" = "x1"], - [CLUTTER_CONFIG_DEFINES="$CLUTTER_CONFIG_DEFINES -#define CLUTTER_WINDOWING_GDK \"gdk\" -#define CLUTTER_INPUT_GDK \"gdk\""]) AS_IF([test "x$SUPPORT_GLX" = "x1"], [CLUTTER_CONFIG_DEFINES="$CLUTTER_CONFIG_DEFINES #define CLUTTER_WINDOWING_GLX \"glx\""])