mirror of
https://github.com/Ardour/ardour.git
synced 2026-01-06 05:35:47 +01:00
Localize stripped down gtk2
This is intended mainly for GNU/Linux distros who will remove GTK2 support in the near future.
This commit is contained in:
Robin Gareus
parent
2a928dae19
commit
ad51c7c2ba
1528 changed files with 915658 additions and 57 deletions
755
libs/tk/ydk/quartz/gdkinput.c
Normal file
755
libs/tk/ydk/quartz/gdkinput.c
Normal file
|
|
@ -0,0 +1,755 @@
|
|||
/* 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>
|
||||
|
||||
#import <Cocoa/Cocoa.h>
|
||||
#include <Carbon/Carbon.h>
|
||||
|
||||
#include "gdkprivate-quartz.h"
|
||||
#include "gdkscreen-quartz.h"
|
||||
#include "gdkinput.h"
|
||||
#include "gdkprivate.h"
|
||||
#include "gdkinputprivate.h"
|
||||
|
||||
|
||||
#define N_CORE_POINTER_AXES 2
|
||||
#define N_INPUT_DEVICE_AXES 5
|
||||
|
||||
|
||||
static GdkDeviceAxis gdk_input_core_axes[] = {
|
||||
{ GDK_AXIS_X, 0, 0 },
|
||||
{ GDK_AXIS_Y, 0, 0 }
|
||||
};
|
||||
|
||||
static GdkDeviceAxis gdk_quartz_pen_axes[] = {
|
||||
{ GDK_AXIS_X, 0, 0 },
|
||||
{ GDK_AXIS_Y, 0, 0 },
|
||||
{ GDK_AXIS_PRESSURE, 0, 1 },
|
||||
{ GDK_AXIS_XTILT, -1, 1 },
|
||||
{ GDK_AXIS_YTILT, -1, 1 }
|
||||
};
|
||||
|
||||
static GdkDeviceAxis gdk_quartz_cursor_axes[] = {
|
||||
{ GDK_AXIS_X, 0, 0 },
|
||||
{ GDK_AXIS_Y, 0, 0 },
|
||||
{ GDK_AXIS_PRESSURE, 0, 1 },
|
||||
{ GDK_AXIS_XTILT, -1, 1 },
|
||||
{ GDK_AXIS_YTILT, -1, 1 }
|
||||
};
|
||||
|
||||
static GdkDeviceAxis gdk_quartz_eraser_axes[] = {
|
||||
{ GDK_AXIS_X, 0, 0 },
|
||||
{ GDK_AXIS_Y, 0, 0 },
|
||||
{ GDK_AXIS_PRESSURE, 0, 1 },
|
||||
{ GDK_AXIS_XTILT, -1, 1 },
|
||||
{ GDK_AXIS_YTILT, -1, 1 }
|
||||
};
|
||||
|
||||
|
||||
/* Global variables */
|
||||
static GList *_gdk_input_windows = NULL;
|
||||
static GList *_gdk_input_devices = NULL;
|
||||
static GdkDevice *_gdk_core_pointer = NULL;
|
||||
static GdkDevice *_gdk_quartz_pen = NULL;
|
||||
static GdkDevice *_gdk_quartz_cursor = NULL;
|
||||
static GdkDevice *_gdk_quartz_eraser = NULL;
|
||||
static GdkDevice *active_device = NULL;
|
||||
|
||||
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 (GdkDevicePrivate),
|
||||
0, /* n_preallocs */
|
||||
(GInstanceInitFunc) NULL,
|
||||
};
|
||||
|
||||
object_type = g_type_register_static (G_TYPE_OBJECT,
|
||||
"GdkDevice",
|
||||
&object_info, 0);
|
||||
}
|
||||
|
||||
return object_type;
|
||||
}
|
||||
|
||||
GList *
|
||||
gdk_devices_list (void)
|
||||
{
|
||||
return _gdk_input_devices;
|
||||
}
|
||||
|
||||
GList *
|
||||
gdk_display_list_devices (GdkDisplay *dpy)
|
||||
{
|
||||
return _gdk_input_devices;
|
||||
}
|
||||
|
||||
const gchar *
|
||||
gdk_device_get_name (GdkDevice *device)
|
||||
{
|
||||
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
|
||||
|
||||
return device->name;
|
||||
}
|
||||
|
||||
GdkInputSource
|
||||
gdk_device_get_source (GdkDevice *device)
|
||||
{
|
||||
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
|
||||
|
||||
return device->source;
|
||||
}
|
||||
|
||||
GdkInputMode
|
||||
gdk_device_get_mode (GdkDevice *device)
|
||||
{
|
||||
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
|
||||
|
||||
return device->mode;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
device->source = source;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
#if 0
|
||||
/* Remapping axes is unsupported for now */
|
||||
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;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* gdk_input_set_device_state:
|
||||
* @device: The devices to set
|
||||
* @mask: The new button mask
|
||||
* @axes: The new axes values
|
||||
*
|
||||
* Set the state of a device's inputs for later
|
||||
* retrieval by gdk_device_get_state.
|
||||
*/
|
||||
static void
|
||||
gdk_input_set_device_state (GdkDevice *device,
|
||||
GdkModifierType mask,
|
||||
gdouble *axes)
|
||||
{
|
||||
GdkDevicePrivate *priv;
|
||||
gint i;
|
||||
|
||||
if (device != _gdk_core_pointer)
|
||||
{
|
||||
priv = (GdkDevicePrivate *)device;
|
||||
priv->last_state = mask;
|
||||
|
||||
for (i = 0; i < device->num_axes; ++i)
|
||||
priv->last_axes_state[i] = axes[i];
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
gdk_device_get_state (GdkDevice *device,
|
||||
GdkWindow *window,
|
||||
gdouble *axes,
|
||||
GdkModifierType *mask)
|
||||
{
|
||||
GdkDevicePrivate *priv;
|
||||
gint i;
|
||||
|
||||
if (device == _gdk_core_pointer)
|
||||
{
|
||||
gint x_int, y_int;
|
||||
|
||||
gdk_window_get_pointer (window, &x_int, &y_int, mask);
|
||||
|
||||
if (axes)
|
||||
{
|
||||
axes[0] = x_int;
|
||||
axes[1] = y_int;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
priv = (GdkDevicePrivate *)device;
|
||||
|
||||
if (mask)
|
||||
*mask = priv->last_state;
|
||||
|
||||
if (axes)
|
||||
for (i = 0; i < device->num_axes; ++i)
|
||||
axes[i] = priv->last_axes_state[i];
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
gboolean
|
||||
gdk_device_get_history (GdkDevice *device,
|
||||
GdkWindow *window,
|
||||
guint32 start,
|
||||
guint32 stop,
|
||||
GdkTimeCoord ***events,
|
||||
gint *n_events)
|
||||
{
|
||||
g_return_val_if_fail (window != NULL, FALSE);
|
||||
g_return_val_if_fail (GDK_WINDOW_IS_QUARTZ (window), FALSE);
|
||||
g_return_val_if_fail (events != NULL, FALSE);
|
||||
g_return_val_if_fail (n_events != NULL, FALSE);
|
||||
|
||||
*n_events = 0;
|
||||
*events = NULL;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
gboolean
|
||||
gdk_device_set_mode (GdkDevice *device,
|
||||
GdkInputMode mode)
|
||||
{
|
||||
/* FIXME: Window mode isn't supported yet */
|
||||
if (device != _gdk_core_pointer &&
|
||||
(mode == GDK_MODE_DISABLED || mode == GDK_MODE_SCREEN))
|
||||
{
|
||||
device->mode = mode;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
gint
|
||||
_gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
gint
|
||||
_gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
GdkInputWindow *
|
||||
_gdk_input_window_find(GdkWindow *window)
|
||||
{
|
||||
GList *tmp_list;
|
||||
|
||||
for (tmp_list=_gdk_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;
|
||||
|
||||
g_return_if_fail (window != NULL);
|
||||
g_return_if_fail (GDK_WINDOW_IS_QUARTZ (window));
|
||||
|
||||
window_private = (GdkWindowObject*) window;
|
||||
|
||||
if (mode == GDK_EXTENSION_EVENTS_NONE)
|
||||
mask = 0;
|
||||
|
||||
if (mask != 0)
|
||||
{
|
||||
iw = g_new(GdkInputWindow,1);
|
||||
|
||||
iw->window = window;
|
||||
iw->mode = mode;
|
||||
|
||||
iw->obscuring = NULL;
|
||||
iw->num_obscuring = 0;
|
||||
iw->grabbed = FALSE;
|
||||
|
||||
_gdk_input_windows = g_list_append (_gdk_input_windows,iw);
|
||||
window_private->extension_events = mask;
|
||||
|
||||
/* Add enter window events to the event mask */
|
||||
/* FIXME, this is not needed for XINPUT_NONE */
|
||||
gdk_window_set_events (window,
|
||||
gdk_window_get_events (window) |
|
||||
GDK_ENTER_NOTIFY_MASK);
|
||||
}
|
||||
else
|
||||
{
|
||||
iw = _gdk_input_window_find (window);
|
||||
if (iw)
|
||||
{
|
||||
_gdk_input_windows = g_list_remove (_gdk_input_windows,iw);
|
||||
g_free (iw);
|
||||
}
|
||||
|
||||
window_private->extension_events = 0;
|
||||
}
|
||||
|
||||
for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
|
||||
{
|
||||
GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data);
|
||||
|
||||
if (gdkdev != (GdkDevicePrivate *)_gdk_core_pointer)
|
||||
{
|
||||
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;
|
||||
|
||||
input_window = _gdk_input_window_find (window);
|
||||
g_return_if_fail (input_window != NULL);
|
||||
|
||||
_gdk_input_windows = g_list_remove (_gdk_input_windows,input_window);
|
||||
g_free (input_window);
|
||||
}
|
||||
|
||||
void
|
||||
_gdk_input_init (void)
|
||||
{
|
||||
GdkDevicePrivate *priv;
|
||||
|
||||
_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 = N_CORE_POINTER_AXES;
|
||||
_gdk_core_pointer->axes = gdk_input_core_axes;
|
||||
_gdk_core_pointer->num_keys = 0;
|
||||
_gdk_core_pointer->keys = NULL;
|
||||
|
||||
_gdk_display->core_pointer = _gdk_core_pointer;
|
||||
_gdk_input_devices = g_list_append (NULL, _gdk_core_pointer);
|
||||
|
||||
_gdk_quartz_pen = g_object_new (GDK_TYPE_DEVICE, NULL);
|
||||
_gdk_quartz_pen->name = "Quartz Pen";
|
||||
_gdk_quartz_pen->source = GDK_SOURCE_PEN;
|
||||
_gdk_quartz_pen->mode = GDK_MODE_SCREEN;
|
||||
_gdk_quartz_pen->has_cursor = TRUE;
|
||||
_gdk_quartz_pen->num_axes = N_INPUT_DEVICE_AXES;
|
||||
_gdk_quartz_pen->axes = gdk_quartz_pen_axes;
|
||||
_gdk_quartz_pen->num_keys = 0;
|
||||
_gdk_quartz_pen->keys = NULL;
|
||||
|
||||
priv = (GdkDevicePrivate *)_gdk_quartz_pen;
|
||||
priv->last_axes_state = g_malloc_n (_gdk_quartz_pen->num_axes, sizeof (gdouble));
|
||||
|
||||
_gdk_input_devices = g_list_append (_gdk_input_devices, _gdk_quartz_pen);
|
||||
|
||||
_gdk_quartz_cursor = g_object_new (GDK_TYPE_DEVICE, NULL);
|
||||
_gdk_quartz_cursor->name = "Quartz Cursor";
|
||||
_gdk_quartz_cursor->source = GDK_SOURCE_CURSOR;
|
||||
_gdk_quartz_cursor->mode = GDK_MODE_SCREEN;
|
||||
_gdk_quartz_cursor->has_cursor = TRUE;
|
||||
_gdk_quartz_cursor->num_axes = N_INPUT_DEVICE_AXES;
|
||||
_gdk_quartz_cursor->axes = gdk_quartz_cursor_axes;
|
||||
_gdk_quartz_cursor->num_keys = 0;
|
||||
_gdk_quartz_cursor->keys = NULL;
|
||||
|
||||
priv = (GdkDevicePrivate *)_gdk_quartz_cursor;
|
||||
priv->last_axes_state = g_malloc_n (_gdk_quartz_cursor->num_axes, sizeof (gdouble));
|
||||
|
||||
_gdk_input_devices = g_list_append (_gdk_input_devices, _gdk_quartz_cursor);
|
||||
|
||||
_gdk_quartz_eraser = g_object_new (GDK_TYPE_DEVICE, NULL);
|
||||
_gdk_quartz_eraser->name = "Quartz Eraser";
|
||||
_gdk_quartz_eraser->source = GDK_SOURCE_ERASER;
|
||||
_gdk_quartz_eraser->mode = GDK_MODE_SCREEN;
|
||||
_gdk_quartz_eraser->has_cursor = TRUE;
|
||||
_gdk_quartz_eraser->num_axes = N_INPUT_DEVICE_AXES;
|
||||
_gdk_quartz_eraser->axes = gdk_quartz_eraser_axes;
|
||||
_gdk_quartz_eraser->num_keys = 0;
|
||||
_gdk_quartz_eraser->keys = NULL;
|
||||
|
||||
priv = (GdkDevicePrivate *)_gdk_quartz_eraser;
|
||||
priv->last_axes_state = g_malloc_n (_gdk_quartz_eraser->num_axes, sizeof (gdouble));
|
||||
|
||||
_gdk_input_devices = g_list_append (_gdk_input_devices, _gdk_quartz_eraser);
|
||||
|
||||
active_device = _gdk_core_pointer;
|
||||
}
|
||||
|
||||
void
|
||||
_gdk_input_exit (void)
|
||||
{
|
||||
GList *tmp_list;
|
||||
GdkDevicePrivate *gdkdev;
|
||||
|
||||
for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
|
||||
{
|
||||
gdkdev = (GdkDevicePrivate *)(tmp_list->data);
|
||||
if (gdkdev != (GdkDevicePrivate *)_gdk_core_pointer)
|
||||
{
|
||||
gdk_device_set_mode ((GdkDevice *)gdkdev, GDK_MODE_DISABLED);
|
||||
|
||||
g_free (gdkdev->info.name);
|
||||
g_free (gdkdev->info.axes);
|
||||
g_free (gdkdev->info.keys);
|
||||
g_free (gdkdev->last_axes_state);
|
||||
g_free (gdkdev);
|
||||
}
|
||||
}
|
||||
|
||||
g_list_free (_gdk_input_devices);
|
||||
|
||||
for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
|
||||
{
|
||||
g_free (tmp_list->data);
|
||||
}
|
||||
g_list_free (_gdk_input_windows);
|
||||
}
|
||||
|
||||
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_window_crossing (GdkWindow *window,
|
||||
gboolean enter)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* _gdk_input_quartz_tablet_proximity:
|
||||
* @deviceType: The result of [nsevent pointingDeviceType]
|
||||
*
|
||||
* Update the current active device based on a proximity event.
|
||||
*/
|
||||
void
|
||||
_gdk_input_quartz_tablet_proximity (NSPointingDeviceType deviceType)
|
||||
{
|
||||
if (deviceType == NSPenPointingDevice)
|
||||
active_device = _gdk_quartz_pen;
|
||||
else if (deviceType == NSCursorPointingDevice)
|
||||
active_device = _gdk_quartz_cursor;
|
||||
else if (deviceType == NSEraserPointingDevice)
|
||||
active_device = _gdk_quartz_eraser;
|
||||
else
|
||||
active_device = _gdk_core_pointer;
|
||||
}
|
||||
|
||||
/**
|
||||
* _gdk_input_fill_quartz_input_event:
|
||||
* @event: The GDK mouse event.
|
||||
* @nsevent: The NSEvent that generated the mouse event.
|
||||
* @input_event: (out): Return location for the input event.
|
||||
*
|
||||
* Handle extended input for the passed event, the GdkEvent object
|
||||
* passed in should be a filled mouse button or motion event.
|
||||
*
|
||||
* Return value: %TRUE if an extended input event was generated.
|
||||
*/
|
||||
gboolean
|
||||
_gdk_input_fill_quartz_input_event (GdkEvent *event,
|
||||
NSEvent *nsevent,
|
||||
GdkEvent *input_event)
|
||||
{
|
||||
gdouble *axes;
|
||||
gint x, y;
|
||||
gint x_target, y_target;
|
||||
gdouble x_root, y_root;
|
||||
gint state;
|
||||
GdkInputWindow *iw;
|
||||
GdkWindow *target_window;
|
||||
GdkScreenQuartz *screen_quartz;
|
||||
|
||||
if ([nsevent subtype] == NSTabletProximityEventSubtype)
|
||||
{
|
||||
_gdk_input_quartz_tablet_proximity ([nsevent pointingDeviceType]);
|
||||
}
|
||||
else if (([nsevent subtype] != NSTabletPointEventSubtype) ||
|
||||
(active_device == _gdk_core_pointer) ||
|
||||
(active_device->mode == GDK_MODE_DISABLED))
|
||||
{
|
||||
_gdk_display->ignore_core_events = FALSE;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
switch (event->any.type)
|
||||
{
|
||||
case GDK_MOTION_NOTIFY:
|
||||
x = event->motion.x;
|
||||
y = event->motion.y;
|
||||
state = event->motion.state;
|
||||
break;
|
||||
case GDK_BUTTON_PRESS:
|
||||
case GDK_BUTTON_RELEASE:
|
||||
x = event->button.x;
|
||||
y = event->button.y;
|
||||
state = event->button.state;
|
||||
break;
|
||||
default:
|
||||
/* Not an input related event */
|
||||
return FALSE;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Input events won't be propagated through windows that aren't listening
|
||||
* for input events, so _gdk_window_get_input_window_for_event finds the
|
||||
* window to directly send the event to.
|
||||
*/
|
||||
target_window = _gdk_window_get_input_window_for_event (event->any.window,
|
||||
event->any.type,
|
||||
0, x, y, 0);
|
||||
|
||||
iw = _gdk_input_window_find (target_window);
|
||||
|
||||
if (!iw)
|
||||
{
|
||||
/* Return if the target window doesn't have extended events enabled or
|
||||
* hasn't asked for this type of event.
|
||||
*/
|
||||
_gdk_display->ignore_core_events = FALSE;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* The cursor is inside an extended events window, block propagation of the
|
||||
* core motion / button events
|
||||
*/
|
||||
_gdk_display->ignore_core_events = TRUE;
|
||||
|
||||
axes = g_malloc_n (N_INPUT_DEVICE_AXES, sizeof (gdouble));
|
||||
|
||||
gdk_window_get_origin (target_window, &x_target, &y_target);
|
||||
|
||||
/* Equation for root x & y taken from _gdk_quartz_window_xy_to_gdk_xy
|
||||
* recalculated here to get doubles instead of ints.
|
||||
*/
|
||||
screen_quartz = GDK_SCREEN_QUARTZ (_gdk_screen);
|
||||
x_root = [NSEvent mouseLocation].x - screen_quartz->min_x;
|
||||
y_root = screen_quartz->height - [NSEvent mouseLocation].y + screen_quartz->min_y;
|
||||
|
||||
axes[0] = x_root - x_target;
|
||||
axes[1] = y_root - y_target;
|
||||
axes[2] = [nsevent pressure];
|
||||
axes[3] = [nsevent tilt].x;
|
||||
axes[4] = [nsevent tilt].y;
|
||||
|
||||
gdk_input_set_device_state (active_device, state, axes);
|
||||
|
||||
input_event->any.window = target_window;
|
||||
input_event->any.type = event->any.type;
|
||||
input_event->any.send_event = event->any.send_event;
|
||||
|
||||
switch (event->any.type)
|
||||
{
|
||||
case GDK_MOTION_NOTIFY:
|
||||
input_event->motion.device = active_device;
|
||||
input_event->motion.x = axes[0];
|
||||
input_event->motion.y = axes[1];
|
||||
input_event->motion.axes = axes;
|
||||
input_event->motion.x_root = x_root;
|
||||
input_event->motion.y_root = y_root;
|
||||
|
||||
input_event->motion.time = event->motion.time;
|
||||
input_event->motion.state = event->motion.state;
|
||||
input_event->motion.is_hint = event->motion.is_hint;
|
||||
break;
|
||||
case GDK_BUTTON_PRESS:
|
||||
case GDK_BUTTON_RELEASE:
|
||||
input_event->button.device = active_device;
|
||||
input_event->button.x = axes[0];
|
||||
input_event->button.y = axes[1];
|
||||
input_event->button.axes = axes;
|
||||
input_event->button.x_root = x_root;
|
||||
input_event->button.y_root = y_root;
|
||||
|
||||
input_event->button.time = event->button.time;
|
||||
input_event->button.state = event->button.state;
|
||||
input_event->button.button = event->button.button;
|
||||
break;
|
||||
default:
|
||||
return FALSE;
|
||||
break;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue