brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9215987189
mutter/clutter/clutter-device-manager.c

439 lines
13 KiB
C
Raw Normal View History

Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 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 <http://www.gnu.org/licenses/>.
*
* Author: Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
docs: Documentation fixes for DeviceManager
2010-01-15 15:29:52 +00:00
* SECTION:clutter-device-manager
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
* @short_description: Maintains the list of input devices
*
* #ClutterDeviceManager is a singleton object, owned by Clutter, which
* maintains the list of #ClutterInputDevice<!-- -->s.
*
docs: Documentation fixes for DeviceManager
2010-01-15 15:29:52 +00:00
* Depending on the backend used by Clutter it is possible to use the
* #ClutterDeviceManager::device-added and
* #ClutterDeviceManager::device-removed to monitor addition and removal
* of devices.
*
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
* #ClutterDeviceManager is available since Clutter 1.2
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
Clean up clutter-private.h/4 Move the private Backend API to a separate header. This also allows us to finally move the class vtable and instance structure to a separate file and plug the visibility hole that left the Backend class bare for everyone to poke into.
2010-10-21 10:49:37 +00:00
#include "clutter-backend-private.h"
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
#include "clutter-debug.h"
Clean up clutter-private.h/1 Move DeviceManager/InputDevice private API to a different header.
2010-10-21 09:54:14 +00:00
#include "clutter-device-manager-private.h"
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
#include "clutter-enum-types.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
device-manager: Use per-stage motion event toggle Now that we have internal support for per-stage granularity of motion event delivery, let's use it when updating the state of the input devices.
2011-02-18 19:27:58 +00:00
#include "clutter-stage-private.h"
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
#define CLUTTER_DEVICE_MANAGER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_DEVICE_MANAGER, ClutterDeviceManagerPrivate))
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
struct _ClutterDeviceManagerPrivate
{
/* back-pointer to the backend */
ClutterBackend *backend;
};
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
enum
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
PROP_0,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
PROP_BACKEND,
PROP_LAST
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
};
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
static GParamSpec *obj_props[PROP_LAST];
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
enum
{
DEVICE_ADDED,
DEVICE_REMOVED,
LAST_SIGNAL
};
static guint manager_signals[LAST_SIGNAL] = { 0, };
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
G_DEFINE_ABSTRACT_TYPE (ClutterDeviceManager,
clutter_device_manager,
G_TYPE_OBJECT);
static void
clutter_device_manager_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterDeviceManagerPrivate *priv = CLUTTER_DEVICE_MANAGER (gobject)->priv;
switch (prop_id)
{
case PROP_BACKEND:
priv->backend = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
static void
clutter_device_manager_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterDeviceManagerPrivate *priv = CLUTTER_DEVICE_MANAGER (gobject)->priv;
switch (prop_id)
{
case PROP_BACKEND:
g_value_set_object (value, priv->backend);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
static void
clutter_device_manager_class_init (ClutterDeviceManagerClass *klass)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (ClutterDeviceManagerPrivate));
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
obj_props[PROP_BACKEND] =
g_param_spec_object ("backend",
P_("Backend"),
P_("The ClutterBackend of the device manager"),
CLUTTER_TYPE_BACKEND,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
gobject_class->set_property = clutter_device_manager_set_property;
gobject_class->get_property = clutter_device_manager_get_property;
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_class_install_properties (gobject_class,
PROP_LAST,
obj_props);
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
device-manager: Fix the signals definition Add documentation for the signals, as well as using the correct type for the marshallers.
2010-01-15 15:29:14 +00:00
/**
* ClutterDeviceManager::device-added:
* @manager: the #ClutterDeviceManager that emitted the signal
* @device: the newly added #ClutterInputDevice
*
* The ::device-added signal is emitted each time a device has been
* added to the #ClutterDeviceManager
*
* Since: 1.2
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
manager_signals[DEVICE_ADDED] =
g_signal_new (I_("device-added"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
Hide the marshallers The marshallers we use for the signals are declared in a private header, and it stands to reason that they should also be hidden in the shared object by using the common '_' prefix. We are also using some direct g_cclosure_marshal_* symbol from GLib, instead of consistently use the clutter_marshal_* symbol.
2010-06-11 14:49:46 +00:00
_clutter_marshal_VOID__OBJECT,
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
G_TYPE_NONE, 1,
device-manager: Fix the signals definition Add documentation for the signals, as well as using the correct type for the marshallers.
2010-01-15 15:29:14 +00:00
CLUTTER_TYPE_INPUT_DEVICE);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device-manager: Fix the signals definition Add documentation for the signals, as well as using the correct type for the marshallers.
2010-01-15 15:29:14 +00:00
/**
* ClutterDeviceManager::device-removed:
* @manager: the #ClutterDeviceManager that emitted the signal
* @device: the removed #ClutterInputDevice
*
* The ::device-removed signal is emitted each time a device has been
* removed from the #ClutterDeviceManager
*
* Since: 1.2
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
manager_signals[DEVICE_REMOVED] =
g_signal_new (I_("device-removed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
Hide the marshallers The marshallers we use for the signals are declared in a private header, and it stands to reason that they should also be hidden in the shared object by using the common '_' prefix. We are also using some direct g_cclosure_marshal_* symbol from GLib, instead of consistently use the clutter_marshal_* symbol.
2010-06-11 14:49:46 +00:00
_clutter_marshal_VOID__OBJECT,
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
G_TYPE_NONE, 1,
device-manager: Fix the signals definition Add documentation for the signals, as well as using the correct type for the marshallers.
2010-01-15 15:29:14 +00:00
CLUTTER_TYPE_INPUT_DEVICE);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
static void
clutter_device_manager_init (ClutterDeviceManager *self)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
self->priv = CLUTTER_DEVICE_MANAGER_GET_PRIVATE (self);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/**
* clutter_device_manager_get_default:
*
* Retrieves the device manager singleton
*
* Return value: (transfer none): the #ClutterDeviceManager singleton.
* The returned instance is owned by Clutter and it should not be
* modified or freed
*
* Since: 1.2
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
ClutterDeviceManager *
clutter_device_manager_get_default (void)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
ClutterBackendClass *klass;
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
klass = CLUTTER_BACKEND_GET_CLASS (clutter_get_default_backend ());
g_assert (klass->get_device_manager != NULL);
return klass->get_device_manager (clutter_get_default_backend ());
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/**
* clutter_device_manager_list_devices:
* @device_manager: a #ClutterDeviceManager
*
* Lists all currently registered input devices
*
Further annotation fixes
2010-09-08 15:41:47 +00:00
* Return value: (transfer container) (element-type Clutter.InputDevice):
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
* a newly allocated list of #ClutterInputDevice objects. Use
* g_slist_free() to deallocate it when done
*
* Since: 1.2
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
GSList *
clutter_device_manager_list_devices (ClutterDeviceManager *device_manager)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
const GSList *devices;
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
devices = clutter_device_manager_peek_devices (device_manager);
return g_slist_copy ((GSList *) devices);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/**
* clutter_device_manager_peek_devices:
* @device_manager: a #ClutterDeviceManager
*
* Lists all currently registered input devices
*
Further annotation fixes
2010-09-08 15:41:47 +00:00
* Return value: (transfer none) (element-type Clutter.InputDevice):
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
* a pointer to the internal list of #ClutterInputDevice objects. The
* returned list is owned by the #ClutterDeviceManager and should never
* be modified or freed
*
* Since: 1.2
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
const GSList *
clutter_device_manager_peek_devices (ClutterDeviceManager *device_manager)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
ClutterDeviceManagerClass *manager_class;
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
return manager_class->get_devices (device_manager);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/**
* clutter_device_manager_get_device:
* @device_manager: a #ClutterDeviceManager
* @device_id: the integer id of a device
*
* Retrieves the #ClutterInputDevice with the given @device_id
*
* Return value: (transfer none): a #ClutterInputDevice or %NULL. The
* returned device is owned by the #ClutterDeviceManager and should
* never be modified or freed
*
* Since: 1.2
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
ClutterInputDevice *
clutter_device_manager_get_device (ClutterDeviceManager *device_manager,
gint device_id)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
ClutterDeviceManagerClass *manager_class;
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
return manager_class->get_device (device_manager, device_id);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
/**
* clutter_device_manager_get_core_device:
* @device_manager: a #ClutterDeviceManager
* @device_type: the type of the core device
*
* Retrieves the core #ClutterInputDevice of type @device_type
*
* Core devices are devices created automatically by the default
* Clutter backend
*
* Return value: (transfer none): a #ClutterInputDevice or %NULL. The
* returned device is owned by the #ClutterDeviceManager and should
* not be modified or freed
*
* Since: 1.2
*/
ClutterInputDevice *
clutter_device_manager_get_core_device (ClutterDeviceManager *device_manager,
ClutterInputDeviceType device_type)
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
ClutterDeviceManagerClass *manager_class;
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
return manager_class->get_core_device (device_manager, device_type);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
event/x11: Rework the way we translate X11 events This is a lump commit that is fairly difficult to break down without either breaking bisecting or breaking the test cases. The new design for handling X11 event translation works this way: - ClutterBackend::translate_event() has been added as the central point used by a ClutterBackend implementation to translate a native event into a ClutterEvent; - ClutterEventTranslator is a private interface that should be implemented by backend-specific objects, like stage implementations and ClutterDeviceManager sub-classes, and allows dealing with class-specific event translation; - ClutterStageX11 implements EventTranslator, and deals with the stage-relative X11 events coming from the X11 event source; - ClutterStageGLX overrides EventTranslator, in order to deal with the INTEL_GLX_swap_event extension, and it chains up to the X11 default implementation; - ClutterDeviceManagerX11 has been split into two separate classes, one that deals with core and (optionally) XI1 events, and the other that deals with XI2 events; the selection is done at run-time, since the core+XI1 and XI2 mechanisms are mutually exclusive. All the other backends we officially support still use their own custom event source and translation function, but the end goal is to migrate them to the translate_event() virtual function, and have the event source be a shared part of Clutter core.
2011-01-04 12:32:04 +00:00
void
_clutter_device_manager_select_stage_events (ClutterDeviceManager *device_manager,
ClutterStage *stage,
gint event_flags)
{
ClutterDeviceManagerClass *manager_class;
const GSList *devices, *d;
g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
devices = manager_class->get_devices (device_manager);
for (d = devices; d != NULL; d = d->next)
{
ClutterInputDevice *device = d->data;
_clutter_input_device_select_stage_events (device, stage, event_flags);
}
}
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/*
* _clutter_device_manager_add_device:
* @device_manager: a #ClutterDeviceManager
* @device: a #ClutterInputDevice
*
* Adds @device to the list of #ClutterInputDevice<!-- -->s maintained
* by @device_manager
*
* The reference count of @device is not increased
*
* The #ClutterDeviceManager::device-added signal is emitted after
* adding @device to the list
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
void
_clutter_device_manager_add_device (ClutterDeviceManager *device_manager,
ClutterInputDevice *device)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
ClutterDeviceManagerClass *manager_class;
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
g_assert (manager_class->add_device != NULL);
manager_class->add_device (device_manager, device);
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
g_signal_emit (device_manager, manager_signals[DEVICE_ADDED], 0, device);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/*
docs: Update the API reference Add the new symbols for InputDevice and DeviceManager
2009-12-07 18:38:18 +00:00
* _clutter_device_manager_remove_device:
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
* @device_manager: a #ClutterDeviceManager
* @device: a #ClutterInputDevice
*
* Removes @device from the list of #ClutterInputDevice<!-- -->s
* maintained by @device_manager
*
* The reference count of @device is not decreased
*
* The #ClutterDeviceManager::device-removed signal is emitted after
* removing @device from the list
*/
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
void
_clutter_device_manager_remove_device (ClutterDeviceManager *device_manager,
ClutterInputDevice *device)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
ClutterDeviceManagerClass *manager_class;
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
g_assert (manager_class->remove_device != NULL);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
manager_class->remove_device (device_manager, device);
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
g_signal_emit (device_manager, manager_signals[DEVICE_REMOVED], 0, device);
Add ClutterDeviceManager The ClutterDeviceManager is a singleton object that behaves like the StageManager: it holds all input devices and notifies on addition and removal.
2009-11-20 15:35:40 +00:00
}
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/*
* _clutter_device_manager_update_devices:
* @device_manager: a #ClutterDeviceManager
*
* Updates every #ClutterInputDevice handled by @device_manager
* by performing a pick paint at the coordinates of each pointer
* device
*/
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
void
_clutter_device_manager_update_devices (ClutterDeviceManager *device_manager)
{
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
const GSList *d;
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
device: Impose per-backend DeviceManager The DeviceManager class should be abstract in Clutter, and implemented by each backend, as different backends will have different ways to detect, initialize and list devices; the X11 backend alone has *two* ways of dealing with devices. This commit makes DeviceManager an abstract class and delegates the device initialization and enumeration to per-backend sub-classes. The responsible for creating the device manager is, obviously, the backend singleton. The X11 and Win32 backends have been updated to the new layout; the Win32 backend has been updated blindly, so it might require additional testing.
2010-02-17 17:06:25 +00:00
for (d = clutter_device_manager_peek_devices (device_manager);
d != NULL;
d = d->next)
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
{
ClutterInputDevice *device = d->data;
ClutterInputDeviceType device_type;
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/* we only care about pointer devices */
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
device_type = clutter_input_device_get_device_type (device);
if (device_type != CLUTTER_POINTER_DEVICE)
continue;
Add docs and licensing notices
2009-11-24 16:22:44 +00:00
/* out of stage */
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
if (device->stage == NULL)
continue;
device-manager: Use per-stage motion event toggle Now that we have internal support for per-stage granularity of motion event delivery, let's use it when updating the state of the input devices.
2011-02-18 19:27:58 +00:00
/* the user disabled motion events delivery on actors for
* the stage the device is on; we don't perform any picking
* since the source of the events will always be set to be
* the stage
*/
stage: Make per-actor motion event delivery accessors public Complete the quest of commit bc548dc86271d38918d310c26c9c59de76218d16 by making the ClutterStage methods for controlling the per-actor motion and crossing event delivery public, and deprecating the global ones.
2011-06-20 10:41:28 +00:00
if (!clutter_stage_get_motion_events_enabled (device->stage))
device-manager: Use per-stage motion event toggle Now that we have internal support for per-stage granularity of motion event delivery, let's use it when updating the state of the input devices.
2011-02-18 19:27:58 +00:00
continue;
Clean up crossing event synthesis code Clutter should just require that the windowing system used by a backend adds a device to the stage when the device enters, and removes it from the stage when the device leaves; with this information, we can synthesize every crossing event and update the device state without other intervention from the backend-specific code. The generation of additional crossing events for actors that are covering the stage at the coordinates of the crossing event should be delegated to the event processing code. The x11 and win32 backends need to be modified to relay the enter and leave events from the windowing system.
2011-01-27 17:26:16 +00:00
_clutter_input_device_update (device, TRUE);
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
}
}
event/x11: Rework the way we translate X11 events This is a lump commit that is fairly difficult to break down without either breaking bisecting or breaking the test cases. The new design for handling X11 event translation works this way: - ClutterBackend::translate_event() has been added as the central point used by a ClutterBackend implementation to translate a native event into a ClutterEvent; - ClutterEventTranslator is a private interface that should be implemented by backend-specific objects, like stage implementations and ClutterDeviceManager sub-classes, and allows dealing with class-specific event translation; - ClutterStageX11 implements EventTranslator, and deals with the stage-relative X11 events coming from the X11 event source; - ClutterStageGLX overrides EventTranslator, in order to deal with the INTEL_GLX_swap_event extension, and it chains up to the X11 default implementation; - ClutterDeviceManagerX11 has been split into two separate classes, one that deals with core and (optionally) XI1 events, and the other that deals with XI2 events; the selection is done at run-time, since the core+XI1 and XI2 mechanisms are mutually exclusive. All the other backends we officially support still use their own custom event source and translation function, but the end goal is to migrate them to the translate_event() virtual function, and have the event source be a shared part of Clutter core.
2011-01-04 12:32:04 +00:00
ClutterBackend *
_clutter_device_manager_get_backend (ClutterDeviceManager *manager)
{
g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (manager), NULL);
return manager->priv->backend;
}
Reference in New Issue Copy Permalink