brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
77db999339
mutter/clutter/gdk/clutter-backend-gdk.c
Rui Matos b192ad1300 gdk: Disable cogl wayland event dispatching if requested 
If gdk event retrieval has been disabled and gdk's backend is wayland
we must also disable cogl's wayland event dispatching otherwise cogl
will try to dispatch wayland events itself which blocks the main
loop.

https://bugzilla.gnome.org/show_bug.cgi?id=744058
2015-02-05 18:31:44 +01:00

498 lines
14 KiB
C
Raw Blame History

/* Clutter.
* An OpenGL based 'interactive canvas' library.
* Authored By Matthew Allum <mallum@openedhand.com>
* 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 <http://www.gnu.org/licenses/>.
*
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <glib/gi18n-lib.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <gdk/gdk.h>
#include <cogl/cogl.h>
#ifndef GDK_WINDOWING_WIN32
#include <sys/ioctl.h>
#endif
#if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT)
#include <cogl/cogl-xlib.h>
#endif
#if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT)
#include <cogl/cogl-wayland-client.h>
#endif
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#ifdef GDK_WINDOWING_WAYLAND
#include <gdk/gdkwayland.h>
#endif
#ifdef GDK_WINDOWING_WIN32
#include <gdk/gdkwin32.h>
#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"
#define clutter_backend_gdk_get_type _clutter_backend_gdk_get_type
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));
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 void
clutter_backend_gdk_copy_event_data (ClutterBackend *backend,
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_backend_gdk_free_event_data (ClutterBackend *backend,
ClutterEvent *event)
{
GdkEvent *gdk_event;
gdk_event = _clutter_event_get_platform_data (event);
if (gdk_event != NULL)
gdk_event_free (gdk_event);
}
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
#if defined(GDK_WINDOWING_WIN32)
if (GDK_IS_WIN32_DISPLAY (backend_gdk->display))
{
/* Force a WGL winsys on windows */
cogl_renderer_set_winsys_id (renderer, COGL_WINSYS_ID_WGL);
cogl_win32_renderer_set_event_retrieval_enabled (renderer, FALSE);
}
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;
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->copy_event_data = clutter_backend_gdk_copy_event_data;
backend_class->free_event_data = clutter_backend_gdk_free_event_data;
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)
{
/* nothing to do here */
}
/**
* 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;
}
Reference in New Issue View Git Blame Copy Permalink