/* GDK - The GIMP Drawing Kit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * Copyright (C) 1999 Tor Lillqvist * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. */ /* * GTK+ DirectFB backend * Copyright (C) 2001-2002 convergence integrated media GmbH * Copyright (C) 2002-2004 convergence GmbH * Written by Denis Oliver Kropp and * Sven Neumann */ #include "config.h" #include "gdk.h" #include "gdkdirectfb.h" #include "gdkprivate-directfb.h" #include "gdkinput-directfb.h" #include "gdkinput.h" #include "gdkkeysyms.h" #include "gdkalias.h" static GdkDeviceAxis gdk_input_core_axes[] = { { GDK_AXIS_X, 0, 0 }, { GDK_AXIS_Y, 0, 0 } }; GdkDevice *_gdk_core_pointer = NULL; GList *_gdk_input_devices = NULL; gboolean _gdk_input_ignore_core = FALSE; int _gdk_directfb_mouse_x = 0; int _gdk_directfb_mouse_y = 0; void _gdk_init_input_core (void) { GdkDisplay *display = GDK_DISPLAY_OBJECT (_gdk_display); _gdk_core_pointer = g_object_new (GDK_TYPE_DEVICE, NULL); _gdk_core_pointer->name = "Core Pointer"; _gdk_core_pointer->source = GDK_SOURCE_MOUSE; _gdk_core_pointer->mode = GDK_MODE_SCREEN; _gdk_core_pointer->has_cursor = TRUE; _gdk_core_pointer->num_axes = 2; _gdk_core_pointer->axes = gdk_input_core_axes; _gdk_core_pointer->num_keys = 0; _gdk_core_pointer->keys = NULL; display->core_pointer = _gdk_core_pointer; } static void gdk_device_finalize (GObject *object) { g_error ("A GdkDevice object was finalized. This should not happen"); } static void gdk_device_class_init (GObjectClass *class) { class->finalize = gdk_device_finalize; } GType gdk_device_get_type (void) { static GType object_type = 0; if (!object_type) { const GTypeInfo object_info = { sizeof (GdkDeviceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gdk_device_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (GdkDevice), 0, /* n_preallocs */ (GInstanceInitFunc) NULL, }; object_type = g_type_register_static (G_TYPE_OBJECT, "GdkDevice", &object_info, 0); } return object_type; } /** * gdk_devices_list: * * Returns the list of available input devices for the default display. * The list is statically allocated and should not be freed. * * Return value: a list of #GdkDevice **/ GList * gdk_devices_list (void) { return _gdk_input_devices; } /** * gdk_display_list_devices: * @display: a #GdkDisplay * * Returns the list of available input devices attached to @display. * The list is statically allocated and should not be freed. * * Return value: a list of #GdkDevice * * Since: 2.2 **/ GList * gdk_display_list_devices (GdkDisplay *dpy) { return _gdk_input_devices; } /** * gdk_device_get_name: * @device: a #GdkDevice * * Determines the name of the device. * * Return value: a name * * Since: 2.22 **/ const gchar * gdk_device_get_name (GdkDevice *device) { g_return_val_if_fail (GDK_IS_DEVICE (device), NULL); return device->name; } /** * gdk_device_get_source: * @device: a #GdkDevice * * Determines the type of the device. * * Return value: a #GdkInputSource * * Since: 2.22 **/ GdkInputSource gdk_device_get_source (GdkDevice *device) { g_return_val_if_fail (GDK_IS_DEVICE (device), 0); return device->source; } /** * gdk_device_get_mode: * @device: a #GdkDevice * * Determines the mode of the device. * * Return value: a #GdkInputSource * * Since: 2.22 **/ GdkInputMode gdk_device_get_mode (GdkDevice *device) { g_return_val_if_fail (GDK_IS_DEVICE (device), 0); return device->mode; } /** * gdk_device_get_has_cursor: * @device: a #GdkDevice * * Determines whether the pointer follows device motion. * * Return value: %TRUE if the pointer follows device motion * * Since: 2.22 **/ gboolean gdk_device_get_has_cursor (GdkDevice *device) { g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE); return device->has_cursor; } void gdk_device_set_source (GdkDevice *device, GdkInputSource source) { g_return_if_fail (device != NULL); device->source = source; } /** * gdk_device_get_key: * @device: a #GdkDevice. * @index: the index of the macro button to get. * @keyval: return value for the keyval. * @modifiers: return value for modifiers. * * If @index has a valid keyval, this function will * fill in @keyval and @modifiers with the keyval settings. * * Since: 2.22 **/ void gdk_device_get_key (GdkDevice *device, guint index, guint *keyval, GdkModifierType *modifiers) { g_return_if_fail (GDK_IS_DEVICE (device)); g_return_if_fail (index < device->num_keys); if (!device->keys[index].keyval && !device->keys[index].modifiers) return; if (keyval) *keyval = device->keys[index].keyval; if (modifiers) *modifiers = device->keys[index].modifiers; } /** * gdk_device_get_axis_use: * @device: a #GdkDevice. * @index: the index of the axis. * * Returns the axis use for @index. * * Returns: a #GdkAxisUse specifying how the axis is used. * * Since: 2.22 **/ GdkAxisUse gdk_device_get_axis_use (GdkDevice *device, guint index) { g_return_val_if_fail (GDK_IS_DEVICE (device), GDK_AXIS_IGNORE); g_return_val_if_fail (index < device->num_axes, GDK_AXIS_IGNORE); return device->axes[index].use; } gint gdk_device_get_n_keys (GdkDevice *device) { g_return_val_if_fail (GDK_IS_DEVICE (device), 0); return device->num_keys; } /** * gdk_device_get_n_axes: * @device: a #GdkDevice. * * Gets the number of axes of a device. * * Returns: the number of axes of @device * * Since: 2.22 **/ gint gdk_device_get_n_axes (GdkDevice *device) { g_return_val_if_fail (GDK_IS_DEVICE (device), 0); return device->num_axes; } void gdk_device_set_axis_use (GdkDevice *device, guint index, GdkAxisUse use) { g_return_if_fail (device != NULL); g_return_if_fail (index < device->num_axes); device->axes[index].use = use; switch (use) { case GDK_AXIS_X: case GDK_AXIS_Y: device->axes[index].min = 0.0; device->axes[index].max = 0.0; break; case GDK_AXIS_XTILT: case GDK_AXIS_YTILT: device->axes[index].min = -1.0; device->axes[index].max = 1.0; break; default: device->axes[index].min = 0.0; device->axes[index].max = 1.0; break; } } gboolean gdk_device_set_mode (GdkDevice *device, GdkInputMode mode) { g_message ("unimplemented %s", G_STRFUNC); return FALSE; } gboolean gdk_device_get_history (GdkDevice *device, GdkWindow *window, guint32 start, guint32 stop, GdkTimeCoord ***events, gint *n_events) { g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE); g_return_val_if_fail (events != NULL, FALSE); g_return_val_if_fail (n_events != NULL, FALSE); *n_events = 0; *events = NULL; if (GDK_WINDOW_DESTROYED (window)) return FALSE; if (GDK_IS_CORE (device)) return FALSE; else return FALSE; //TODODO_gdk_device_get_history (device, window, start, stop, events, n_events); } void gdk_device_free_history (GdkTimeCoord **events, gint n_events) { gint i; for (i = 0; i < n_events; i++) g_free (events[i]); g_free (events); } void gdk_device_get_state (GdkDevice *device, GdkWindow *window, gdouble *axes, GdkModifierType *mask) { g_return_if_fail (device != NULL); g_return_if_fail (GDK_IS_WINDOW (window)); if (mask) *mask = _gdk_directfb_modifiers; } void gdk_directfb_mouse_get_info (gint *x, gint *y, GdkModifierType *mask) { if (x) *x = _gdk_directfb_mouse_x; if (y) *y = _gdk_directfb_mouse_y; if (mask) *mask = _gdk_directfb_modifiers; } void gdk_input_set_extension_events (GdkWindow *window, gint mask, GdkExtensionMode mode) { g_message ("unimplemented %s", G_STRFUNC); } void gdk_device_set_key (GdkDevice *device, guint index, guint keyval, GdkModifierType modifiers) { g_return_if_fail (device != NULL); g_return_if_fail (index < device->num_keys); device->keys[index].keyval = keyval; device->keys[index].modifiers = modifiers; } /** * gdk_device_get_axis: * @device: a #GdkDevice * @axes: pointer to an array of axes * @use: the use to look for * @value: location to store the found value. * * Interprets an array of double as axis values for a given device, * and locates the value in the array for a given axis use. * * Return value: %TRUE if the given axis use was found, otherwise %FALSE **/ gboolean gdk_device_get_axis (GdkDevice *device, gdouble *axes, GdkAxisUse use, gdouble *value) { gint i; g_return_val_if_fail (device != NULL, FALSE); if (axes == NULL) return FALSE; for (i = 0; i < device->num_axes; i++) if (device->axes[i].use == use) { if (value) *value = axes[i]; return TRUE; } return FALSE; } void _gdk_input_init (void) { _gdk_init_input_core (); _gdk_input_devices = g_list_append (NULL, _gdk_core_pointer); _gdk_input_ignore_core = FALSE; } void _gdk_input_exit (void) { GList *tmp_list; GdkDevice *gdkdev; for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next) { gdkdev = (GdkDevice *)(tmp_list->data); if (!GDK_IS_CORE (gdkdev)) { gdk_device_set_mode ((GdkDevice *)gdkdev, GDK_MODE_DISABLED); g_free (gdkdev->name); g_free (gdkdev->axes); g_free (gdkdev->keys); g_free (gdkdev); } } g_list_free (_gdk_input_devices); } #define __GDK_INPUT_NONE_C__ #define __GDK_INPUT_C__ #include "gdkaliasdef.c"