forked from AuroraMiddleware/gtk
eabac453e6
The history before this was kind of twisted as several different approaches were tested, so that was all squashed into this initial commit to hide the uninteresting changes and files that were later removed.
501 lines
13 KiB
C
501 lines
13 KiB
C
/* GDK - The GIMP Drawing Kit
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* 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. See the ChangeLog
|
|
* files for a list of changes. These files are distributed with
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xutil.h>
|
|
|
|
#include "gdkx.h"
|
|
#include "gdkinput.h"
|
|
#include "gdkprivate.h"
|
|
#include "gdkinputprivate.h"
|
|
#include "gdkscreen-x11.h"
|
|
#include "gdkdisplay-x11.h"
|
|
#include "gdkalias.h"
|
|
|
|
static GdkDeviceAxis gdk_input_core_axes[] = {
|
|
{ GDK_AXIS_X, 0, 0 },
|
|
{ GDK_AXIS_Y, 0, 0 }
|
|
};
|
|
|
|
void
|
|
_gdk_init_input_core (GdkDisplay *display)
|
|
{
|
|
GdkDevicePrivate *private;
|
|
|
|
display->core_pointer = g_object_new (GDK_TYPE_DEVICE, NULL);
|
|
private = (GdkDevicePrivate *)display->core_pointer;
|
|
|
|
display->core_pointer->name = "Core Pointer";
|
|
display->core_pointer->source = GDK_SOURCE_MOUSE;
|
|
display->core_pointer->mode = GDK_MODE_SCREEN;
|
|
display->core_pointer->has_cursor = TRUE;
|
|
display->core_pointer->num_axes = 2;
|
|
display->core_pointer->axes = gdk_input_core_axes;
|
|
display->core_pointer->num_keys = 0;
|
|
display->core_pointer->keys = NULL;
|
|
|
|
private->display = display;
|
|
}
|
|
|
|
static void gdk_device_class_init (GdkDeviceClass *klass);
|
|
static void gdk_device_dispose (GObject *object);
|
|
|
|
static gpointer gdk_device_parent_class = NULL;
|
|
|
|
GType
|
|
gdk_device_get_type (void)
|
|
{
|
|
static GType object_type = 0;
|
|
|
|
if (!object_type)
|
|
{
|
|
static const GTypeInfo object_info =
|
|
{
|
|
sizeof (GdkDeviceClass),
|
|
(GBaseInitFunc) NULL,
|
|
(GBaseFinalizeFunc) NULL,
|
|
(GClassInitFunc) gdk_device_class_init,
|
|
NULL, /* class_finalize */
|
|
NULL, /* class_data */
|
|
sizeof (GdkDevicePrivate),
|
|
0, /* n_preallocs */
|
|
(GInstanceInitFunc) NULL,
|
|
};
|
|
|
|
object_type = g_type_register_static (G_TYPE_OBJECT,
|
|
g_intern_static_string ("GdkDevice"),
|
|
&object_info, 0);
|
|
}
|
|
|
|
return object_type;
|
|
}
|
|
|
|
static void
|
|
gdk_device_class_init (GdkDeviceClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
gdk_device_parent_class = g_type_class_peek_parent (klass);
|
|
|
|
object_class->dispose = gdk_device_dispose;
|
|
}
|
|
|
|
static void
|
|
gdk_device_dispose (GObject *object)
|
|
{
|
|
GdkDevicePrivate *gdkdev = (GdkDevicePrivate *) object;
|
|
|
|
if (gdkdev->display && !GDK_IS_CORE (gdkdev))
|
|
{
|
|
#ifndef XINPUT_NONE
|
|
if (gdkdev->xdevice)
|
|
{
|
|
XCloseDevice (GDK_DISPLAY_XDISPLAY (gdkdev->display), gdkdev->xdevice);
|
|
gdkdev->xdevice = NULL;
|
|
}
|
|
g_free (gdkdev->axes);
|
|
gdkdev->axes = NULL;
|
|
#endif /* !XINPUT_NONE */
|
|
|
|
g_free (gdkdev->info.name);
|
|
g_free (gdkdev->info.keys);
|
|
g_free (gdkdev->info.axes);
|
|
|
|
gdkdev->info.name = NULL;
|
|
gdkdev->info.keys = NULL;
|
|
gdkdev->info.axes = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (gdk_device_parent_class)->dispose (object);
|
|
}
|
|
|
|
/**
|
|
* 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_display_list_devices (gdk_display_get_default ());
|
|
}
|
|
|
|
/**
|
|
* 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 *display)
|
|
{
|
|
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
|
|
|
|
return GDK_DISPLAY_X11 (display)->input_devices;
|
|
}
|
|
|
|
void
|
|
gdk_device_set_source (GdkDevice *device,
|
|
GdkInputSource source)
|
|
{
|
|
g_return_if_fail (device != NULL);
|
|
|
|
device->source = source;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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.;
|
|
device->axes[index].max = 0.;
|
|
break;
|
|
case GDK_AXIS_XTILT:
|
|
case GDK_AXIS_YTILT:
|
|
device->axes[index].min = -1.;
|
|
device->axes[index].max = 1;
|
|
break;
|
|
default:
|
|
device->axes[index].min = 0.;
|
|
device->axes[index].max = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gdk_device_get_history:
|
|
* @device: a #GdkDevice
|
|
* @window: the window with respect to which which the event coordinates will be reported
|
|
* @start: starting timestamp for range of events to return
|
|
* @stop: ending timestamp for the range of events to return
|
|
* @events: location to store a newly-allocated array of #GdkTimeCoord, or %NULL
|
|
* @n_events: location to store the length of @events, or %NULL
|
|
*
|
|
* Obtains the motion history for a device; given a starting and
|
|
* ending timestamp, return all events in the motion history for
|
|
* the device in the given range of time. Some windowing systems
|
|
* do not support motion history, in which case, %FALSE will
|
|
* be returned. (This is not distinguishable from the case where
|
|
* motion history is supported and no events were found.)
|
|
*
|
|
* Return value: %TRUE if the windowing system supports motion history and
|
|
* at least one event was found.
|
|
**/
|
|
gboolean
|
|
gdk_device_get_history (GdkDevice *device,
|
|
GdkWindow *window,
|
|
guint32 start,
|
|
guint32 stop,
|
|
GdkTimeCoord ***events,
|
|
gint *n_events)
|
|
{
|
|
GdkTimeCoord **coords = NULL;
|
|
gboolean result = FALSE;
|
|
int tmp_n_events = 0;
|
|
int i;
|
|
|
|
g_return_val_if_fail (GDK_WINDOW_IS_X11 (window), FALSE);
|
|
|
|
if (GDK_WINDOW_DESTROYED (window))
|
|
/* Nothing */ ;
|
|
else if (GDK_IS_CORE (device))
|
|
{
|
|
XTimeCoord *xcoords;
|
|
|
|
xcoords = XGetMotionEvents (GDK_DRAWABLE_XDISPLAY (window),
|
|
GDK_DRAWABLE_XID (window),
|
|
start, stop, &tmp_n_events);
|
|
if (xcoords)
|
|
{
|
|
coords = _gdk_device_allocate_history (device, tmp_n_events);
|
|
for (i=0; i<tmp_n_events; i++)
|
|
{
|
|
coords[i]->time = xcoords[i].time;
|
|
coords[i]->axes[0] = xcoords[i].x;
|
|
coords[i]->axes[1] = xcoords[i].y;
|
|
}
|
|
|
|
XFree (xcoords);
|
|
|
|
result = TRUE;
|
|
}
|
|
else
|
|
result = FALSE;
|
|
}
|
|
else
|
|
result = _gdk_device_get_history (device, window, start, stop, &coords, &tmp_n_events);
|
|
|
|
if (n_events)
|
|
*n_events = tmp_n_events;
|
|
if (events)
|
|
*events = coords;
|
|
else if (coords)
|
|
gdk_device_free_history (coords, tmp_n_events);
|
|
|
|
return result;
|
|
}
|
|
|
|
GdkTimeCoord **
|
|
_gdk_device_allocate_history (GdkDevice *device,
|
|
gint n_events)
|
|
{
|
|
GdkTimeCoord **result = g_new (GdkTimeCoord *, n_events);
|
|
gint i;
|
|
|
|
for (i=0; i<n_events; i++)
|
|
result[i] = g_malloc (sizeof (GdkTimeCoord) -
|
|
sizeof (double) * (GDK_MAX_TIMECOORD_AXES - device->num_axes));
|
|
|
|
return result;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
GdkInputWindow *
|
|
_gdk_input_window_find(GdkWindow *window)
|
|
{
|
|
GList *tmp_list;
|
|
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (window));
|
|
|
|
for (tmp_list=display_x11->input_windows; tmp_list; tmp_list=tmp_list->next)
|
|
if (((GdkInputWindow *)(tmp_list->data))->window == window)
|
|
return (GdkInputWindow *)(tmp_list->data);
|
|
|
|
return NULL; /* Not found */
|
|
}
|
|
|
|
/* FIXME: this routine currently needs to be called between creation
|
|
and the corresponding configure event (because it doesn't get the
|
|
root_relative_geometry). This should work with
|
|
gtk_window_set_extension_events, but will likely fail in other
|
|
cases */
|
|
|
|
void
|
|
gdk_input_set_extension_events (GdkWindow *window, gint mask,
|
|
GdkExtensionMode mode)
|
|
{
|
|
GdkWindowObject *window_private;
|
|
GList *tmp_list;
|
|
GdkInputWindow *iw;
|
|
GdkDisplayX11 *display_x11;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
g_return_if_fail (GDK_WINDOW_IS_X11 (window));
|
|
|
|
window_private = (GdkWindowObject*) window;
|
|
display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (window));
|
|
if (GDK_WINDOW_DESTROYED (window))
|
|
return;
|
|
|
|
if (mode == GDK_EXTENSION_EVENTS_NONE)
|
|
mask = 0;
|
|
|
|
iw = _gdk_input_window_find (window);
|
|
|
|
if (mask != 0)
|
|
{
|
|
if (!iw)
|
|
{
|
|
iw = g_new(GdkInputWindow,1);
|
|
|
|
iw->window = window;
|
|
iw->mode = mode;
|
|
|
|
iw->obscuring = NULL;
|
|
iw->num_obscuring = 0;
|
|
iw->grabbed = FALSE;
|
|
|
|
display_x11->input_windows = g_list_append(display_x11->input_windows,iw);
|
|
}
|
|
|
|
window_private->extension_events = mask;
|
|
|
|
#ifndef XINPUT_NONE
|
|
/* Add enter window events to the event mask */
|
|
/* this is not needed for XINPUT_NONE */
|
|
gdk_window_set_events (window,
|
|
gdk_window_get_events (window) |
|
|
GDK_ENTER_NOTIFY_MASK);
|
|
|
|
/* we might not receive ConfigureNotify so get the root_relative_geometry
|
|
* now, just in case */
|
|
_gdk_input_get_root_relative_geometry (GDK_WINDOW_XDISPLAY (window),
|
|
GDK_WINDOW_XWINDOW (window),
|
|
&iw->root_x, &iw->root_y, NULL, NULL);
|
|
#endif /* !XINPUT_NONE */
|
|
}
|
|
else
|
|
{
|
|
if (iw)
|
|
{
|
|
display_x11->input_windows = g_list_remove(display_x11->input_windows,iw);
|
|
g_free(iw);
|
|
}
|
|
|
|
window_private->extension_events = 0;
|
|
}
|
|
|
|
for (tmp_list = display_x11->input_devices; tmp_list; tmp_list = tmp_list->next)
|
|
{
|
|
GdkDevicePrivate *gdkdev = tmp_list->data;
|
|
|
|
if (!GDK_IS_CORE (gdkdev))
|
|
{
|
|
if (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED
|
|
&& (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL))
|
|
_gdk_input_enable_window (window,gdkdev);
|
|
else
|
|
_gdk_input_disable_window (window,gdkdev);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
_gdk_input_window_destroy (GdkWindow *window)
|
|
{
|
|
GdkInputWindow *input_window;
|
|
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (GDK_WINDOW_DISPLAY (window));
|
|
|
|
input_window = _gdk_input_window_find (window);
|
|
g_return_if_fail (input_window != NULL);
|
|
|
|
display_x11->input_windows = g_list_remove (display_x11->input_windows, input_window);
|
|
g_free(input_window);
|
|
}
|
|
|
|
void
|
|
_gdk_input_exit (void)
|
|
{
|
|
GList *tmp_list;
|
|
GSList *display_list;
|
|
GdkDevicePrivate *gdkdev;
|
|
|
|
for (display_list = _gdk_displays ; display_list ; display_list = display_list->next)
|
|
{
|
|
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display_list->data);
|
|
|
|
for (tmp_list = display_x11->input_devices; tmp_list; tmp_list = tmp_list->next)
|
|
{
|
|
gdkdev = (GdkDevicePrivate *)(tmp_list->data);
|
|
if (!GDK_IS_CORE (gdkdev))
|
|
{
|
|
gdk_device_set_mode (&gdkdev->info, GDK_MODE_DISABLED);
|
|
g_object_unref(gdkdev);
|
|
}
|
|
}
|
|
|
|
g_list_free(display_x11->input_devices);
|
|
|
|
for (tmp_list = display_x11->input_windows; tmp_list; tmp_list = tmp_list->next)
|
|
g_free(tmp_list->data);
|
|
|
|
g_list_free(display_x11->input_windows);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
#define __GDK_INPUT_C__
|
|
#include "gdkaliasdef.c"
|