AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'device-cleanup' into 'master'

Browse Source 
Device cleanup

See merge request GNOME/gtk!2068
This commit is contained in:
Matthias Clasen 2020-06-10 13:06:13 +00:00
commit bdd6ae3252
10 changed files with 48 additions and 321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/reference/gdk/gdk4-sections.txt
View File

@ -357,9 +357,6 @@ gdk_device_get_name
gdk_device_get_vendor_id
gdk_device_get_product_id
gdk_device_get_source
gdk_device_set_key
gdk_device_get_key
gdk_device_set_axis_use
gdk_device_get_axis_use
gdk_device_get_associated_device
gdk_device_list_slave_devices
@ -367,7 +364,6 @@ gdk_device_get_device_type
gdk_device_get_display
gdk_device_get_has_cursor
gdk_device_get_n_axes
gdk_device_get_n_keys
gdk_device_get_axes
gdk_device_get_seat
gdk_device_get_num_touches

4
gdk/broadway/gdkdevice-broadway.c
View File

@ -73,8 +73,8 @@ gdk_broadway_device_init (GdkBroadwayDevice *device_core)
device = GDK_DEVICE (device_core);
_gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
_gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
_gdk_device_add_axis (device, GDK_AXIS_X, 0, 0, 1);
_gdk_device_add_axis (device, GDK_AXIS_Y, 0, 0, 1);
}
static void

241
gdk/gdkdevice.c
View File

@ -51,9 +51,7 @@ typedef struct _GdkAxisInfo GdkAxisInfo;
struct _GdkAxisInfo
{
char *label;
GdkAxisUse use;
gdouble min_axis;
gdouble max_axis;
gdouble min_value;
@ -366,19 +364,10 @@ gdk_device_class_init (GdkDeviceClass *klass)
G_TYPE_NONE, 1, GDK_TYPE_DEVICE_TOOL);
}
static void
gdk_device_axis_info_clear (gpointer data)
{
GdkAxisInfo *info = data;
g_free (info->label);
}
static void
gdk_device_init (GdkDevice *device)
{
device->axes = g_array_new (FALSE, TRUE, sizeof (GdkAxisInfo));
g_array_set_clear_func (device->axes, gdk_device_axis_info_clear);
}
static void
@ -393,7 +382,6 @@ gdk_device_finalize (GObject *object)
}
g_clear_pointer (&device->name, g_free);
g_clear_pointer (&device->keys, g_free);
g_clear_pointer (&device->vendor_id, g_free);
g_clear_pointer (&device->product_id, g_free);
@ -684,79 +672,6 @@ gdk_device_get_source (GdkDevice *device)
return device->source;
}
/**
* gdk_device_get_n_keys:
* @device: a #GdkDevice
*
* Returns the number of keys the device currently has.
*
* Returns: the number of keys.
**/
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_key:
* @device: a #GdkDevice.
* @index_: the index of the macro button to get.
* @keyval: (out): return value for the keyval.
* @modifiers: (out): return value for modifiers.
*
* If @index_ has a valid keyval, this function will return %TRUE
* and fill in @keyval and @modifiers with the keyval settings.
*
* Returns: %TRUE if keyval is set for @index.
**/
gboolean
gdk_device_get_key (GdkDevice *device,
guint index_,
guint *keyval,
GdkModifierType *modifiers)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
g_return_val_if_fail (index_ < device->num_keys, FALSE);
if (!device->keys[index_].keyval &&
!device->keys[index_].modifiers)
return FALSE;
if (keyval)
*keyval = device->keys[index_].keyval;
if (modifiers)
*modifiers = device->keys[index_].modifiers;
return TRUE;
}
/**
* gdk_device_set_key:
* @device: a #GdkDevice
* @index_: the index of the macro button to set
* @keyval: the keyval to generate
* @modifiers: the modifiers to set
*
* Specifies the X key event to generate when a macro button of a device
* is pressed.
**/
void
gdk_device_set_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);
device->keys[index_].keyval = keyval;
device->keys[index_].modifiers = modifiers;
}
/**
* gdk_device_get_axis_use:
* @device: a pointer #GdkDevice.
@ -781,47 +696,6 @@ gdk_device_get_axis_use (GdkDevice *device,
return info->use;
}
/**
* gdk_device_set_axis_use:
* @device: a pointer #GdkDevice
* @index_: the index of the axis
* @use: specifies how the axis is used
*
* Specifies how an axis of a device is used.
**/
void
gdk_device_set_axis_use (GdkDevice *device,
guint index_,
GdkAxisUse use)
{
GdkAxisInfo *info;
g_return_if_fail (GDK_IS_DEVICE (device));
g_return_if_fail (device->source != GDK_SOURCE_KEYBOARD);
g_return_if_fail (index_ < device->axes->len);
info = &g_array_index (device->axes, GdkAxisInfo, index_);
info->use = use;
switch ((guint) use)
{
case GDK_AXIS_X:
case GDK_AXIS_Y:
info->min_axis = 0;
info->max_axis = 0;
break;
case GDK_AXIS_XTILT:
case GDK_AXIS_YTILT:
info->min_axis = -1;
info->max_axis = 1;
break;
default:
info->min_axis = 0;
info->max_axis = 1;
break;
}
}
/**
* gdk_device_get_display:
* @device: a #GdkDevice
@ -987,89 +861,6 @@ gdk_device_get_n_axes (GdkDevice *device)
return device->axes->len;
}
/**
* gdk_device_get_axis_names:
* @device: a #GdkDevice
*
* Returns a null-terminated array of strings, containing the labels for
* the axes that @device currently has.
* If the device has no axes, %NULL is returned.
*
* Returns: (nullable) (transfer full): A null-terminated string array,
* free with g_strfreev().
**/
char **
gdk_device_get_axis_names (GdkDevice *device)
{
GPtrArray *axes;
gint i;
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
g_return_val_if_fail (device->source != GDK_SOURCE_KEYBOARD, NULL);
if (device->axes->len == 0)
return NULL;
axes = g_ptr_array_new ();
for (i = 0; i < device->axes->len; i++)
{
GdkAxisInfo axis_info;
axis_info = g_array_index (device->axes, GdkAxisInfo, i);
g_ptr_array_add (axes, g_strdup (axis_info.label));
}
g_ptr_array_add (axes, NULL);
return (char **) g_ptr_array_free (axes, FALSE);
}
/**
* gdk_device_get_axis_value: (skip)
* @device: a pointer #GdkDevice.
* @axes: (array): pointer to an array of axes
* @axis_label: name of the label
* @value: (out): 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 label, as returned
* by gdk_device_get_axes()
*
* Returns: %TRUE if the given axis use was found, otherwise %FALSE.
**/
gboolean
gdk_device_get_axis_value (GdkDevice *device,
gdouble *axes,
const char *axis_label,
gdouble *value)
{
gint i;
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
g_return_val_if_fail (device->source != GDK_SOURCE_KEYBOARD, FALSE);
if (axes == NULL)
return FALSE;
for (i = 0; i < device->axes->len; i++)
{
GdkAxisInfo axis_info;
axis_info = g_array_index (device->axes, GdkAxisInfo, i);
if (!g_str_equal (axis_info.label, axis_label))
continue;
if (value)
*value = axes[i];
return TRUE;
}
return FALSE;
}
/**
* gdk_device_get_axis: (skip)
* @device: a #GdkDevice
@ -1206,7 +997,6 @@ _gdk_device_reset_axes (GdkDevice *device)
guint
_gdk_device_add_axis (GdkDevice *device,
const char *label_name,
GdkAxisUse use,
gdouble min_value,
gdouble max_value,
@ -1216,7 +1006,6 @@ _gdk_device_add_axis (GdkDevice *device,
guint pos;
axis_info.use = use;
axis_info.label = g_strdup (label_name);
axis_info.min_value = min_value;
axis_info.max_value = max_value;
axis_info.resolution = resolution;
@ -1252,12 +1041,11 @@ _gdk_device_add_axis (GdkDevice *device,
void
_gdk_device_get_axis_info (GdkDevice *device,
guint index_,
const char **label_name,
GdkAxisUse *use,
gdouble *min_value,
gdouble *max_value,
gdouble *resolution)
guint index_,
GdkAxisUse *use,
gdouble *min_value,
gdouble *max_value,
gdouble *resolution)
{
GdkAxisInfo *info;
@ -1266,23 +1054,12 @@ _gdk_device_get_axis_info (GdkDevice *device,
info = &g_array_index (device->axes, GdkAxisInfo, index_);
*label_name = info->label;
*use = info->use;
*min_value = info->min_value;
*max_value = info->max_value;
*resolution = info->resolution;
}
void
_gdk_device_set_keys (GdkDevice *device,
guint num_keys)
{
g_free (device->keys);
device->num_keys = num_keys;
device->keys = g_new0 (GdkDeviceKey, num_keys);
}
static GdkAxisInfo *
find_axis_info (GArray *array,
GdkAxisUse use)
@ -1303,10 +1080,10 @@ find_axis_info (GArray *array,
gboolean
_gdk_device_translate_surface_coord (GdkDevice *device,
GdkSurface *surface,
guint index_,
gdouble value,
gdouble *axis_value)
GdkSurface *surface,
guint index_,
gdouble value,
gdouble *axis_value)
{
GdkAxisInfo axis_info;
GdkAxisInfo *axis_info_x, *axis_info_y;

20
gdk/gdkdevice.h
View File

@ -115,26 +115,9 @@ gboolean gdk_device_get_has_cursor (GdkDevice *device);
GDK_AVAILABLE_IN_ALL
GdkInputSource gdk_device_get_source (GdkDevice *device);
GDK_AVAILABLE_IN_ALL
gint gdk_device_get_n_keys (GdkDevice *device);
GDK_AVAILABLE_IN_ALL
gboolean gdk_device_get_key (GdkDevice *device,
guint index_,
guint *keyval,
GdkModifierType *modifiers);
GDK_AVAILABLE_IN_ALL
void gdk_device_set_key (GdkDevice *device,
guint index_,
guint keyval,
GdkModifierType modifiers);
GDK_AVAILABLE_IN_ALL
GdkAxisUse gdk_device_get_axis_use (GdkDevice *device,
guint index_);
GDK_AVAILABLE_IN_ALL
void gdk_device_set_axis_use (GdkDevice *device,
guint index_,
GdkAxisUse use);
GDK_AVAILABLE_IN_ALL
@ -150,11 +133,8 @@ GdkSurface * gdk_device_get_surface_at_position (GdkDevice *device,
GDK_AVAILABLE_IN_ALL
gint gdk_device_get_n_axes (GdkDevice *device);
GDK_AVAILABLE_IN_ALL
char ** gdk_device_get_axis_names (GdkDevice *device);
GDK_AVAILABLE_IN_ALL
gboolean gdk_device_get_axis_value (GdkDevice *device,
gdouble *axes,
const char *axis_label,
gdouble *value);
GDK_AVAILABLE_IN_ALL

24
gdk/gdkdeviceprivate.h
View File

@ -31,13 +31,6 @@ G_BEGIN_DECLS
#define GDK_DEVICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE, GdkDeviceClass))
typedef struct _GdkDeviceClass GdkDeviceClass;
typedef struct _GdkDeviceKey GdkDeviceKey;
struct _GdkDeviceKey
{
guint keyval;
GdkModifierType modifiers;
};
struct _GdkDevice
{
@ -46,9 +39,7 @@ struct _GdkDevice
gchar *name;
GdkInputSource source;
gboolean has_cursor;
gint num_keys;
GdkAxisFlags axis_flags;
GdkDeviceKey *keys;
GdkDisplay *display;
/* Paired master for master,
* associated master for slaves
@ -106,21 +97,16 @@ void _gdk_device_set_associated_device (GdkDevice *device,
void _gdk_device_reset_axes (GdkDevice *device);
guint _gdk_device_add_axis (GdkDevice *device,
const char *label_atom,
GdkAxisUse use,
gdouble min_value,
gdouble max_value,
gdouble resolution);
void _gdk_device_get_axis_info (GdkDevice *device,
guint index,
const char**label_atom,
GdkAxisUse *use,
gdouble *min_value,
gdouble *max_value,
gdouble *resolution);
void _gdk_device_set_keys (GdkDevice *device,
guint num_keys);
guint index,
GdkAxisUse *use,
gdouble *min_value,
gdouble *max_value,
gdouble *resolution);
gboolean _gdk_device_translate_surface_coord (GdkDevice *device,
GdkSurface *surface,

25
gdk/wayland/gdkdevice-wayland.c
View File

@ -832,8 +832,8 @@ gdk_wayland_device_init (GdkWaylandDevice *device_core)
device = GDK_DEVICE (device_core);
_gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
_gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
_gdk_device_add_axis (device, GDK_AXIS_X, 0, 0, 1);
_gdk_device_add_axis (device, GDK_AXIS_Y, 0, 0, 1);
}
static gint
@ -3386,42 +3386,42 @@ gdk_wayland_device_tablet_clone_tool_axes (GdkWaylandTabletData *tablet,
g_object_freeze_notify (G_OBJECT (tablet->current_device));
_gdk_device_reset_axes (tablet->current_device);
_gdk_device_add_axis (tablet->current_device, NULL, GDK_AXIS_X, 0, 0, 0);
_gdk_device_add_axis (tablet->current_device, NULL, GDK_AXIS_Y, 0, 0, 0);
_gdk_device_add_axis (tablet->current_device, GDK_AXIS_X, 0, 0, 0);
_gdk_device_add_axis (tablet->current_device, GDK_AXIS_Y, 0, 0, 0);
if (tool->tool_axes & (GDK_AXIS_FLAG_XTILT | GDK_AXIS_FLAG_YTILT))
{
axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
axis_pos = _gdk_device_add_axis (tablet->current_device,
GDK_AXIS_XTILT, -90, 90, 0);
tablet->axis_indices[GDK_AXIS_XTILT] = axis_pos;
axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
axis_pos = _gdk_device_add_axis (tablet->current_device,
GDK_AXIS_YTILT, -90, 90, 0);
tablet->axis_indices[GDK_AXIS_YTILT] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_DISTANCE)
{
axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
axis_pos = _gdk_device_add_axis (tablet->current_device,
GDK_AXIS_DISTANCE, 0, 65535, 0);
tablet->axis_indices[GDK_AXIS_DISTANCE] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_PRESSURE)
{
axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
axis_pos = _gdk_device_add_axis (tablet->current_device,
GDK_AXIS_PRESSURE, 0, 65535, 0);
tablet->axis_indices[GDK_AXIS_PRESSURE] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_ROTATION)
{
axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
axis_pos = _gdk_device_add_axis (tablet->current_device,
GDK_AXIS_ROTATION, 0, 360, 0);
tablet->axis_indices[GDK_AXIS_ROTATION] = axis_pos;
}
if (tool->tool_axes & GDK_AXIS_FLAG_SLIDER)
{
axis_pos = _gdk_device_add_axis (tablet->current_device, NULL,
axis_pos = _gdk_device_add_axis (tablet->current_device,
GDK_AXIS_SLIDER, -65535, 65535, 0);
tablet->axis_indices[GDK_AXIS_SLIDER] = axis_pos;
}
@ -3440,7 +3440,6 @@ gdk_wayland_mimic_device_axes (GdkDevice *master,
GdkDevice *slave)
{
gdouble axis_min, axis_max, axis_resolution;
const char *axis_label;
GdkAxisUse axis_use;
gint axis_count;
gint i;
@ -3451,9 +3450,9 @@ gdk_wayland_mimic_device_axes (GdkDevice *master,
for (i = 0; i < axis_count; i++)
{
_gdk_device_get_axis_info (slave, i, &axis_label, &axis_use, &axis_min,
_gdk_device_get_axis_info (slave, i, &axis_use, &axis_min,
&axis_max, &axis_resolution);
_gdk_device_add_axis (master, axis_label, axis_use, axis_min,
_gdk_device_add_axis (master, axis_use, axis_min,
axis_max, axis_resolution);
}

16
gdk/win32/gdkdevice-virtual.c
View File

@ -32,11 +32,10 @@ G_DEFINE_TYPE (GdkDeviceVirtual, gdk_device_virtual, GDK_TYPE_DEVICE)
void
_gdk_device_virtual_set_active (GdkDevice *device,
GdkDevice *new_active)
GdkDevice *new_active)
{
GdkDeviceVirtual *virtual = GDK_DEVICE_VIRTUAL (device);
int n_axes, i;
const char *label_atom;
GdkAxisUse use;
gdouble min_value, max_value, resolution;
@ -50,14 +49,11 @@ _gdk_device_virtual_set_active (GdkDevice *device,
_gdk_device_reset_axes (device);
n_axes = gdk_device_get_n_axes (new_active);
for (i = 0; i < n_axes; i++)
{
_gdk_device_get_axis_info (new_active, i,
&label_atom, &use,
&min_value, &max_value, &resolution);
_gdk_device_add_axis (device,
label_atom, use,
min_value, max_value, resolution);
}
{
_gdk_device_get_axis_info (new_active, i, &use,
&min_value, &max_value, &resolution);
_gdk_device_add_axis (device, use, min_value, max_value, resolution);
}
}
g_signal_emit_by_name (G_OBJECT (device), "changed");

4
gdk/win32/gdkdevice-win32.c
View File

@ -239,6 +239,6 @@ gdk_device_win32_init (GdkDeviceWin32 *device_win32)
device = GDK_DEVICE (device_win32);
_gdk_device_add_axis (device, NULL, GDK_AXIS_X, 0, 0, 1);
_gdk_device_add_axis (device, NULL, GDK_AXIS_Y, 0, 0, 1);
_gdk_device_add_axis (device, GDK_AXIS_X, 0, 0, 1);
_gdk_device_add_axis (device, GDK_AXIS_Y, 0, 0, 1);
}

5
gdk/win32/gdkdevicemanager-win32.c
View File

@ -577,7 +577,6 @@ wintab_init_check (GdkDeviceManagerWin32 *device_manager)
if (device->pktdata & PK_X)
{
_gdk_device_add_axis (GDK_DEVICE (device),
NULL,
GDK_AXIS_X,
axis_x.axMin,
axis_x.axMax,
@ -588,7 +587,6 @@ wintab_init_check (GdkDeviceManagerWin32 *device_manager)
if (device->pktdata & PK_Y)
{
_gdk_device_add_axis (GDK_DEVICE (device),
NULL,
GDK_AXIS_Y,
axis_y.axMin,
axis_y.axMax,
@ -600,7 +598,6 @@ wintab_init_check (GdkDeviceManagerWin32 *device_manager)
if (device->pktdata & PK_NORMAL_PRESSURE)
{
_gdk_device_add_axis (GDK_DEVICE (device),
NULL,
GDK_AXIS_PRESSURE,
axis_npressure.axMin,
axis_npressure.axMax,
@ -617,14 +614,12 @@ wintab_init_check (GdkDeviceManagerWin32 *device_manager)
* we convert to x and y tilt in the -1000..1000 range
*/
_gdk_device_add_axis (GDK_DEVICE (device),
NULL,
GDK_AXIS_XTILT,
-1000,
1000,
1000);
_gdk_device_add_axis (GDK_DEVICE (device),
NULL,
GDK_AXIS_YTILT,
-1000,
1000,

26
gdk/x11/gdkdevicemanager-xi2.c
View File

@ -211,7 +211,6 @@ translate_valuator_class (GdkDisplay *display,
static gboolean initialized = FALSE;
static Atom label_atoms [GDK_AXIS_LAST] = { 0 };
GdkAxisUse use = GDK_AXIS_IGNORE;
const char *label;
gint i;
if (!initialized)
@ -234,13 +233,18 @@ translate_valuator_class (GdkDisplay *display,
}
}
if (valuator_label != None)
label = gdk_x11_get_xatom_name_for_display (display, valuator_label);
else
label = NULL;
_gdk_device_add_axis (device, use, min, max, resolution);
GDK_DISPLAY_NOTE (display, INPUT,
{
const char *label;
_gdk_device_add_axis (device, label, use, min, max, resolution);
GDK_DISPLAY_NOTE (display, INPUT, g_message ("\n\taxis: %s %s", label, use == GDK_AXIS_IGNORE ? "(ignored)" : "(used)"));
if (valuator_label != None)
label = gdk_x11_get_xatom_name_for_display (display, valuator_label);
else
label = NULL;
g_message ("\n\taxis: %s %s", label, use == GDK_AXIS_IGNORE ? "(ignored)" : "(used)");
});
}
static void
@ -261,13 +265,7 @@ translate_device_classes (GdkDisplay *display,
{
case XIKeyClass:
{
XIKeyClassInfo *key_info = (XIKeyClassInfo *) class_info;
gint j;
_gdk_device_set_keys (device, key_info->num_keycodes);
for (j = 0; j < key_info->num_keycodes; j++)
gdk_device_set_key (device, j, key_info->keycodes[j], 0);
/* Not used */
}
break;
case XIValuatorClass: