/* 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, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #ifdef HAVE_UNISTD_H #include #endif #include #include #include #include #include "clutter-backend-x11.h" #include "clutter-stage-x11.h" #include "clutter-x11.h" #include #ifdef HAVE_XINPUT #include #endif #include "../clutter-event.h" #include "../clutter-main.h" #include "../clutter-debug.h" #include "../clutter-private.h" #include "cogl/cogl.h" G_DEFINE_TYPE (ClutterBackendX11, clutter_backend_x11, CLUTTER_TYPE_BACKEND); struct _ClutterX11XInputDevice { ClutterInputDevice device; #ifdef HAVE_XINPUT XDevice *xdevice; XEventClass xevent_list[5]; /* MAX 5 event types */ int num_events; #endif }; #ifdef HAVE_XINPUT void _clutter_x11_register_xinput (); #endif /* atoms; remember to add the code that assigns the atom value to * the member of the ClutterBackendX11 structure if you add an * atom name here. do not change the order! */ static const gchar *atom_names[] = { "_NET_WM_PID", "_NET_WM_PING", "_NET_WM_STATE", "_NET_WM_STATE_FULLSCREEN", "_NET_WM_USER_TIME", "WM_PROTOCOLS", "WM_DELETE_WINDOW", "_XEMBED", "_XEMBED_INFO", "_NET_WM_NAME", "UTF8_STRING", }; static const guint n_atom_names = G_N_ELEMENTS (atom_names); /* singleton object */ static ClutterBackendX11 *backend_singleton = NULL; /* various flags corresponding to pre init setup calls */ static gboolean _no_xevent_retrieval = FALSE; static gboolean clutter_enable_xinput = FALSE; static Display *_foreign_dpy = NULL; /* options */ static gchar *clutter_display_name = NULL; static gint clutter_screen = -1; static gboolean clutter_synchronise = FALSE; /* X error trap */ static int TrappedErrorCode = 0; static int (* old_error_handler) (Display *, XErrorEvent *); gboolean clutter_backend_x11_pre_parse (ClutterBackend *backend, GError **error) { const gchar *env_string; /* we don't fail here if DISPLAY is not set, as the user * might pass the --display command line switch */ env_string = g_getenv ("DISPLAY"); if (env_string) { clutter_display_name = g_strdup (env_string); env_string = NULL; } return TRUE; } gboolean clutter_backend_x11_post_parse (ClutterBackend *backend, GError **error) { ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend); if (_foreign_dpy) backend_x11->xdpy = _foreign_dpy; /* * Only open connection if not already set by prior call to * clutter_x11_set_display() */ if (!backend_x11->xdpy) { if (clutter_display_name) { CLUTTER_NOTE (BACKEND, "XOpenDisplay on '%s'", clutter_display_name); backend_x11->xdpy = XOpenDisplay (clutter_display_name); if (backend_x11->xdpy == None) { g_set_error (error, CLUTTER_INIT_ERROR, CLUTTER_INIT_ERROR_BACKEND, "Unable to open display '%s'", clutter_display_name); return FALSE; } } else { g_set_error (error, CLUTTER_INIT_ERROR, CLUTTER_INIT_ERROR_BACKEND, "Unable to open display. You have to set the DISPLAY " "environment variable, or use the --display command " "line argument"); return FALSE; } } if (backend_x11->xdpy) { Atom atoms[n_atom_names]; double dpi; CLUTTER_NOTE (BACKEND, "Getting the X screen"); if (clutter_screen == -1) backend_x11->xscreen = DefaultScreenOfDisplay (backend_x11->xdpy); else backend_x11->xscreen = ScreenOfDisplay (backend_x11->xdpy, clutter_screen); backend_x11->xscreen_num = XScreenNumberOfScreen (backend_x11->xscreen); backend_x11->xwin_root = RootWindow (backend_x11->xdpy, backend_x11->xscreen_num); backend_x11->display_name = g_strdup (clutter_display_name); dpi = (((double) DisplayHeight (backend_x11->xdpy, backend_x11->xscreen_num) * 25.4) / (double) DisplayHeightMM (backend_x11->xdpy, backend_x11->xscreen_num)); clutter_backend_set_resolution (backend, dpi); #ifdef HAVE_XINPUT _clutter_x11_register_xinput (); #endif if (clutter_synchronise) XSynchronize (backend_x11->xdpy, True); XInternAtoms (backend_x11->xdpy, (char **) atom_names, n_atom_names, False, atoms); backend_x11->atom_NET_WM_PID = atoms[0]; backend_x11->atom_NET_WM_PING = atoms[1]; backend_x11->atom_NET_WM_STATE = atoms[2]; backend_x11->atom_NET_WM_STATE_FULLSCREEN = atoms[3]; backend_x11->atom_NET_WM_USER_TIME = atoms[4]; backend_x11->atom_WM_PROTOCOLS = atoms[5]; backend_x11->atom_WM_DELETE_WINDOW = atoms[6]; backend_x11->atom_XEMBED = atoms[7]; backend_x11->atom_XEMBED_INFO = atoms[8]; backend_x11->atom_NET_WM_NAME = atoms[9]; backend_x11->atom_UTF8_STRING = atoms[10]; } g_free (clutter_display_name); CLUTTER_NOTE (BACKEND, "X Display '%s'[%p] opened (screen:%d, root:%u, dpi:%f)", backend_x11->display_name, backend_x11->xdpy, backend_x11->xscreen_num, (unsigned int) backend_x11->xwin_root, clutter_backend_get_resolution (backend)); return TRUE; } static void clutter_backend_x11_init_events (ClutterBackend *backend) { CLUTTER_NOTE (EVENT, "initialising the event loop"); if (!_no_xevent_retrieval) _clutter_backend_x11_events_init (backend); } static const GOptionEntry entries[] = { { "display", 0, G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_STRING, &clutter_display_name, N_("X display to use"), "DISPLAY" }, { "screen", 0, G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_INT, &clutter_screen, N_("X screen to use"), "SCREEN" }, { "synch", 0, 0, G_OPTION_ARG_NONE, &clutter_synchronise, N_("Make X calls synchronous"), NULL }, #ifdef HAVE_XINPUT { "enable-xinput", 0, 0, G_OPTION_ARG_NONE, &clutter_enable_xinput, N_("Enable XInput support"), NULL }, #endif /* HAVE_XINPUT */ { NULL } }; void clutter_backend_x11_add_options (ClutterBackend *backend, GOptionGroup *group) { g_option_group_add_entries (group, entries); } static void clutter_backend_x11_finalize (GObject *gobject) { ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (gobject); g_free (backend_x11->display_name); XCloseDisplay (backend_x11->xdpy); if (backend_singleton) backend_singleton = NULL; G_OBJECT_CLASS (clutter_backend_x11_parent_class)->finalize (gobject); } static void clutter_backend_x11_dispose (GObject *gobject) { ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (gobject); ClutterStageManager *stage_manager; CLUTTER_NOTE (BACKEND, "Disposing the of stages"); stage_manager = clutter_stage_manager_get_default (); /* Destroy all of the stages. g_slist_foreach is used because the finalizer for the stages will remove the stage from the stage_manager's list and g_slist_foreach has some basic protection against this */ g_slist_foreach (stage_manager->stages, (GFunc) clutter_actor_destroy, NULL); CLUTTER_NOTE (BACKEND, "Removing the event source"); _clutter_backend_x11_events_uninit (CLUTTER_BACKEND (backend_x11)); G_OBJECT_CLASS (clutter_backend_x11_parent_class)->dispose (gobject); } static GObject * clutter_backend_x11_constructor (GType gtype, guint n_params, GObjectConstructParam *params) { GObjectClass *parent_class; GObject *retval; if (!backend_singleton) { parent_class = G_OBJECT_CLASS (clutter_backend_x11_parent_class); retval = parent_class->constructor (gtype, n_params, params); backend_singleton = CLUTTER_BACKEND_X11 (retval); return retval; } g_warning ("Attempting to create a new backend object. This should " "never happen, so we return the singleton instance."); return g_object_ref (backend_singleton); } ClutterFeatureFlags clutter_backend_x11_get_features (ClutterBackend *backend) { return CLUTTER_FEATURE_STAGE_USER_RESIZE | CLUTTER_FEATURE_STAGE_CURSOR; } static void clutter_backend_x11_class_init (ClutterBackendX11Class *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); ClutterBackendClass *backend_class = CLUTTER_BACKEND_CLASS (klass); gobject_class->constructor = clutter_backend_x11_constructor; gobject_class->dispose = clutter_backend_x11_dispose; gobject_class->finalize = clutter_backend_x11_finalize; backend_class->pre_parse = clutter_backend_x11_pre_parse; backend_class->post_parse = clutter_backend_x11_post_parse; backend_class->init_events = clutter_backend_x11_init_events; backend_class->add_options = clutter_backend_x11_add_options; backend_class->get_features = clutter_backend_x11_get_features; } static void clutter_backend_x11_init (ClutterBackendX11 *backend_x11) { ClutterBackend *backend = CLUTTER_BACKEND (backend_x11); /* FIXME: get from xsettings */ clutter_backend_set_double_click_time (backend, 250); clutter_backend_set_double_click_distance (backend, 5); clutter_backend_set_resolution (backend, 96.0); backend_x11->last_event_time = CurrentTime; } static int error_handler(Display *xdpy, XErrorEvent *error) { TrappedErrorCode = error->error_code; return 0; } /** * clutter_x11_trap_x_errors: * * Traps every X error until clutter_x11_untrap_x_errors() is called. * * Since: 0.6 */ void clutter_x11_trap_x_errors (void) { TrappedErrorCode = 0; old_error_handler = XSetErrorHandler (error_handler); } /** * clutter_x11_untrap_x_errors: * * Removes the X error trap and returns the current status. * * Return value: the trapped error code, or 0 for success * * Since: 0.4 */ gint clutter_x11_untrap_x_errors (void) { XSetErrorHandler (old_error_handler); return TrappedErrorCode; } /** * clutter_x11_get_default_display: * * Retrieves the pointer to the default display. * * Return value: the default display * * Since: 0.6 */ Display * clutter_x11_get_default_display (void) { if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return NULL; } return backend_singleton->xdpy; } /** * clutter_x11_set_display: * @xdpy: pointer to a X 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_x11_set_display() before g_option_context_parse(). * * Since: 0.8 */ void clutter_x11_set_display (Display *xdpy) { if (_clutter_context_is_initialized ()) { g_critical ("Display connection already exists. You can only call " "clutter_x11_set_display() before clutter_init()"); return; } _foreign_dpy= xdpy; } /** * clutter_x11_enable_xinput: * * Enables the use of the XInput extension if present on connected * XServer and support built into Clutter. XInput allows for multiple * pointing devices to be used. This must be called before * clutter_init(). * * You should use #clutter_x11_has_xinput to see if support was enabled. * * Since: 0.8 */ void clutter_x11_enable_xinput (void) { if (_clutter_context_is_initialized ()) { g_critical ("clutter_x11_enable_xinput() can only be called " "before clutter_init()"); return; } clutter_enable_xinput = TRUE; } /** * clutter_x11_disable_event_retrieval * * Disables retrieval of X events in the main loop. Use to create event-less * canvas or in conjunction with clutter_x11_handle_event. * * This function can only be called before calling clutter_init(). * * Since: 0.8 */ void clutter_x11_disable_event_retrieval (void) { if (_clutter_context_is_initialized ()) { g_warning ("clutter_x11_disable_event_retrieval() can only be " "called before clutter_init()"); return; } _no_xevent_retrieval = TRUE; } /** * clutter_x11_has_event_retrieval * * Queries the X11 backend to check if event collection has been disabled. * * Return value: TRUE if event retrival has been disabled. FALSE otherwise. * * Since: 0.8 */ gboolean clutter_x11_has_event_retrieval (void) { return !_no_xevent_retrieval; } /** * clutter_x11_get_default_screen: * * Gets the number of the default X Screen object. * * Return value: the number of the default screen * * Since: 0.6 */ int clutter_x11_get_default_screen (void) { if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return 0; } return backend_singleton->xscreen_num; } /** * clutter_x11_get_root_window: * * Retrieves the root window. * * Return value: the id of the root window * * Since: 0.6 */ Window clutter_x11_get_root_window (void) { if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return None; } return backend_singleton->xwin_root; } /** * clutter_x11_add_filter: * @func: a filter function * @data: user data to be passed to the filter function, or %NULL * * Adds an event filter function. * * Since: 0.6 */ void clutter_x11_add_filter (ClutterX11FilterFunc func, gpointer data) { ClutterX11EventFilter *filter; g_return_if_fail (func != NULL); if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return; } filter = g_new0 (ClutterX11EventFilter, 1); filter->func = func; filter->data = data; backend_singleton->event_filters = g_slist_append (backend_singleton->event_filters, filter); return; } /** * clutter_x11_remove_filter: * @func: a filter function * @data: user data to be passed to the filter function, or %NULL * * Removes the given filter function. * * Since: 0.6 */ void clutter_x11_remove_filter (ClutterX11FilterFunc func, gpointer data) { GSList *tmp_list, *this; ClutterX11EventFilter *filter; g_return_if_fail (func != NULL); tmp_list = backend_singleton->event_filters; while (tmp_list) { filter = tmp_list->data; this = tmp_list; tmp_list = tmp_list->next; if (filter->func == func && filter->data == data) { backend_singleton->event_filters = g_slist_remove_link (backend_singleton->event_filters, this); g_slist_free_1 (this); g_free (filter); return; } } } void _clutter_x11_register_xinput () { #ifdef HAVE_XINPUT XDeviceInfo *xdevices = NULL; XDeviceInfo *info = NULL; XDevice *xdevice = NULL; XInputClassInfo *xclass_info = NULL; gint opcode, event, error; gint res; gint num_devices = 0; gint num_events = 0; gint i = 0, j = 0; gboolean have_an_xpointer = FALSE; ClutterBackendX11 *x11b; ClutterX11XInputDevice *device = NULL; ClutterMainContext *context; GSList *input_devices = NULL; if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return; } if (!clutter_enable_xinput) { CLUTTER_NOTE (BACKEND, "Not enabling XInput"); return; } context = _clutter_context_get_default (); backend_singleton->have_xinput = FALSE; /* is the XInput extension available? */ res = XQueryExtension (backend_singleton->xdpy, "XInputExtension", &opcode, &event, &error); if (!res) { CLUTTER_NOTE (BACKEND, "X Input extension not available"); return; } x11b = backend_singleton; xdevices = XListInputDevices (x11b->xdpy, &num_devices); CLUTTER_NOTE (BACKEND, "%d XINPUT devices found", num_devices); if (num_devices == 0) return; for (i = 0; i < num_devices; i++) { info = xdevices + i; num_events = 0; CLUTTER_NOTE (BACKEND, "Considering %li with type %d", info->id, info->use); /* Only want 'raw' devices themselves not virtual ones */ if (info->use == IsXExtensionPointer || /*info->use == IsXExtensionKeyboard || XInput 1.x is broken */ info->use == IsXExtensionDevice) { clutter_x11_trap_x_errors (); xdevice = XOpenDevice (backend_singleton->xdpy, info->id); if (clutter_x11_untrap_x_errors () || xdevice == NULL) continue; /* Create the appropriate Clutter device */ device = g_slice_new0 (ClutterX11XInputDevice); device->device.id = info->id; switch (info->use) { case IsXExtensionPointer: device->device.device_type = CLUTTER_POINTER_DEVICE; have_an_xpointer = TRUE; break; #if 0 /* XInput 1.x is broken for keyboards: */ case IsXExtensionKeyboard: device->device.type = CLUTTER_KEYBOARD_DEVICE; break; #endif case IsXExtensionDevice: device->device.device_type = CLUTTER_EXTENSION_DEVICE; break; } /* FIXME: some kind of general device_init() call should do below */ device->device.click_count = 0; device->device.previous_time = 0; device->device.previous_x = -1; device->device.previous_y = -1; device->device.previous_button_number = -1; device->num_events = 0; device->xdevice = xdevice; CLUTTER_NOTE (BACKEND, "Registering XINPUT device with XID: %li", xdevice->device_id); /* We must go through all the classes supported by this device and * register the appropriate events we want. Each class only appears * once. We need to store the types with the stage since they are * created dynamically by the server. They are not device specific. */ for (j = 0; j < xdevice->num_classes; j++) { xclass_info = xdevice->classes + j; switch (xclass_info->input_class) { #if 0 /* XInput 1.x is broken for keyboards: */ case KeyClass: DeviceKeyPress (xdevice, x11b->event_types[CLUTTER_X11_XINPUT_KEY_PRESS_EVENT], device->xevent_list [num_events]); num_events++; DeviceKeyRelease (xdevice, x11b->event_types[CLUTTER_X11_XINPUT_KEY_RELEASE_EVENT], device->xevent_list [num_events]); num_events++; break; #endif case ButtonClass: DeviceButtonPress (xdevice, x11b->event_types[CLUTTER_X11_XINPUT_BUTTON_PRESS_EVENT], device->xevent_list [num_events]); num_events++; DeviceButtonRelease (xdevice, x11b->event_types[CLUTTER_X11_XINPUT_BUTTON_RELEASE_EVENT], device->xevent_list [num_events]); num_events++; break; case ValuatorClass: DeviceMotionNotify (xdevice, x11b->event_types[CLUTTER_X11_XINPUT_MOTION_NOTIFY_EVENT], device->xevent_list [num_events]); num_events++; break; } } if (info->use == IsXExtensionPointer && num_events > 0) have_an_xpointer = TRUE; device->num_events = num_events; input_devices = g_slist_prepend (input_devices, device); } } XFree (xdevices); if (!have_an_xpointer) { GSList *l; /* Something is likely wrong with Xinput setup so we basically * abort here and fall back to lofi regular xinput. */ g_warning ("No usuable XInput pointing devices found"); for (l = input_devices; l != NULL; l = l->next) g_slice_free (ClutterX11XInputDevice, l->data); g_slist_free (input_devices); context->input_devices = NULL; return; } /* store the list of input devices */ context->input_devices = g_slist_reverse (input_devices); /* why yes, we are awesome */ backend_singleton->have_xinput = TRUE; #endif /* HAVE_XINPUT */ } void _clutter_x11_unregister_xinput () { } void _clutter_x11_select_events (Window xwin) { #ifdef HAVE_XINPUT GSList *list_it; ClutterX11XInputDevice *device = NULL; ClutterMainContext *context; context = _clutter_context_get_default (); if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return; } for (list_it = context->input_devices; list_it != NULL; list_it = list_it->next) { device = (ClutterX11XInputDevice *)list_it->data; XSelectExtensionEvent (backend_singleton->xdpy, xwin, device->xevent_list, device->num_events); } #endif /* HAVE_XINPUT */ } ClutterInputDevice * _clutter_x11_get_device_for_xid (XID id) { #ifdef HAVE_XINPUT ClutterMainContext *context; GSList *l; context = _clutter_context_get_default (); if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return NULL; } for (l = context->input_devices; l != NULL; l = l->next) { ClutterX11XInputDevice *device = l->data; if (device->xdevice->device_id == id) return (ClutterInputDevice *) device; } #endif /* HAVE_XINPUT */ return NULL; } /* FIXME: This nasty little func needs moving elsewhere.. */ G_CONST_RETURN GSList * clutter_x11_get_input_devices (void) { #ifdef HAVE_XINPUT ClutterMainContext *context; if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return NULL; } context = _clutter_context_get_default (); return context->input_devices; #else /* !HAVE_XINPUT */ return NULL; #endif /* HAVE_XINPUT */ } /** * clutter_x11_has_xinput: * * Gets whether Clutter has XInput support. * * Return value: %TRUE if Clutter was compiled with XInput support * and XInput support is available at run time. * * Since: 0.8 */ gboolean clutter_x11_has_xinput (void) { #ifdef HAVE_XINPUT if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return FALSE; } return backend_singleton->have_xinput; #else return FALSE; #endif } gboolean clutter_x11_has_composite_extension (void) { static gboolean have_composite = FALSE, done_check = FALSE; int error = 0, event = 0; Display *dpy; if (done_check) return have_composite; if (!backend_singleton) { g_critical ("X11 backend has not been initialised"); return FALSE; } dpy = clutter_x11_get_default_display(); if (XCompositeQueryExtension (dpy, &event, &error)) { int major = 0, minor = 0; if (XCompositeQueryVersion (dpy, &major, &minor)) { if (major >= 0 && minor >= 3) have_composite = TRUE; } } done_check = TRUE; return have_composite; } XVisualInfo * clutter_backend_x11_get_visual_info (ClutterBackendX11 *backend_x11, gboolean for_offscreen) { ClutterBackendX11Class *klass; g_return_val_if_fail (CLUTTER_IS_BACKEND_X11 (backend_x11), NULL); klass = CLUTTER_BACKEND_X11_GET_CLASS (backend_x11); if (klass->get_visual_info) return klass->get_visual_info (backend_x11, for_offscreen); return NULL; }