isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-26 12:52:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
8e3674dcc1
mutter/clutter/clutter-device-manager.c

407 lines
12 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
#include "clutter-debug.h"
#include "clutter-device-manager.h"
#include "clutter-enum-types.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
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;
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
_clutter_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
}
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
Do not pick when motion event delivery is disabled The device manager does not need to update the state of the devices when the user has disabled the delivery of motion events to actors: the events will always be delivered as they are to the stage.
2009-11-24 17:54:02 +00:00
/* the user disabled motion events delivery on actors; we
* don't perform any picking since the source of the events
* will always be set to be the stage
*/
if (!clutter_get_motion_events_enabled ())
return;
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;
_clutter_input_device_update (device);
}
}
Reference in New Issue Copy Permalink