gtk2/gdk/gdkdevice.c

1379 lines
38 KiB
C
Raw Normal View History

2010-05-25 22:38:44 +00:00
/* GDK - The GIMP Drawing Kit
* Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
*
* 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
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
2010-05-25 22:38:44 +00:00
*/
#include "config.h"
#include <math.h>
2010-05-25 22:38:44 +00:00
#include "gdkdeviceprivate.h"
2016-04-09 19:20:07 +00:00
#include "gdkdevicetool.h"
#include "gdkdisplayprivate.h"
#include "gdkinternals.h"
2010-05-25 22:38:44 +00:00
#include "gdkintl.h"
#include "gdkkeysprivate.h"
2010-12-25 05:02:39 +00:00
/**
* SECTION:gdkdevice
* @Short_description: Object representing an input device
* @Title: GdkDevice
* @See_also: #GdkSeat
2010-12-25 05:02:39 +00:00
*
* The #GdkDevice object represents a single input device, such
* as a keyboard, a mouse, a touchpad, etc.
2010-12-25 05:02:39 +00:00
*
* See the #GdkSeat documentation for more information
* about the various kinds of logical and physical devices, and their
2010-12-25 05:02:39 +00:00
* relationships.
*/
2017-12-26 19:39:24 +00:00
/**
* GdkDevice:
*
* The GdkDevice struct contains only private fields and
* should not be accessed directly.
*/
2010-05-25 22:38:44 +00:00
typedef struct _GdkAxisInfo GdkAxisInfo;
struct _GdkAxisInfo
{
GdkAxisUse use;
2020-07-24 20:32:16 +00:00
double min_axis;
double max_axis;
double min_value;
double max_value;
double resolution;
2010-05-25 22:38:44 +00:00
};
enum {
CHANGED,
TOOL_CHANGED,
LAST_SIGNAL
};
static guint signals [LAST_SIGNAL] = { 0 };
static void gdk_device_finalize (GObject *object);
2010-05-25 22:38:44 +00:00
static void gdk_device_dispose (GObject *object);
static void gdk_device_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gdk_device_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
G_DEFINE_ABSTRACT_TYPE (GdkDevice, gdk_device, G_TYPE_OBJECT)
enum {
PROP_0,
PROP_DISPLAY,
PROP_NAME,
PROP_SOURCE,
2010-05-25 22:38:44 +00:00
PROP_HAS_CURSOR,
PROP_N_AXES,
PROP_VENDOR_ID,
PROP_PRODUCT_ID,
PROP_SEAT,
PROP_NUM_TOUCHES,
PROP_TOOL,
PROP_DIRECTION,
PROP_HAS_BIDI_LAYOUTS,
PROP_CAPS_LOCK_STATE,
PROP_NUM_LOCK_STATE,
PROP_SCROLL_LOCK_STATE,
PROP_MODIFIER_STATE,
LAST_PROP
2010-05-25 22:38:44 +00:00
};
static GParamSpec *device_props[LAST_PROP] = { NULL, };
2010-05-25 22:38:44 +00:00
static void
gdk_device_class_init (GdkDeviceClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gdk_device_finalize;
2010-05-25 22:38:44 +00:00
object_class->dispose = gdk_device_dispose;
object_class->set_property = gdk_device_set_property;
object_class->get_property = gdk_device_get_property;
/**
* GdkDevice:display:
*
* The #GdkDisplay the #GdkDevice pertains to.
*/
device_props[PROP_DISPLAY] =
g_param_spec_object ("display",
P_("Device Display"),
P_("Display which the device belongs to"),
GDK_TYPE_DISPLAY,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
2010-05-25 22:38:44 +00:00
/**
* GdkDevice:name:
*
* The device name.
*/
device_props[PROP_NAME] =
g_param_spec_string ("name",
P_("Device name"),
P_("Device name"),
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
2010-05-25 22:38:44 +00:00
/**
* GdkDevice:source:
2010-05-25 22:38:44 +00:00
*
* Source type for the device.
*/
device_props[PROP_SOURCE] =
g_param_spec_enum ("source",
P_("Input source"),
P_("Source type for the device"),
GDK_TYPE_INPUT_SOURCE,
GDK_SOURCE_MOUSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
2010-05-25 22:38:44 +00:00
/**
* GdkDevice:has-cursor:
*
* Whether the device is represented by a cursor on the screen.
2010-05-25 22:38:44 +00:00
*/
device_props[PROP_HAS_CURSOR] =
g_param_spec_boolean ("has-cursor",
P_("Whether the device has a cursor"),
P_("Whether there is a visible cursor following device motion"),
FALSE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
2010-05-25 22:38:44 +00:00
/**
* GdkDevice:n-axes:
*
* Number of axes in the device.
*/
device_props[PROP_N_AXES] =
g_param_spec_uint ("n-axes",
P_("Number of axes in the device"),
P_("Number of axes in the device"),
0, G_MAXUINT,
0,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* GdkDevice:vendor-id:
*
* Vendor ID of this device, see gdk_device_get_vendor_id().
*/
device_props[PROP_VENDOR_ID] =
g_param_spec_string ("vendor-id",
P_("Vendor ID"),
P_("Vendor ID"),
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
/**
* GdkDevice:product-id:
*
* Product ID of this device, see gdk_device_get_product_id().
*/
device_props[PROP_PRODUCT_ID] =
g_param_spec_string ("product-id",
P_("Product ID"),
P_("Product ID"),
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
/**
* GdkDevice:seat:
*
* #GdkSeat of this device.
*/
device_props[PROP_SEAT] =
g_param_spec_object ("seat",
P_("Seat"),
P_("Seat"),
GDK_TYPE_SEAT,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* GdkDevice:num-touches:
*
* The maximal number of concurrent touches on a touch device.
* Will be 0 if the device is not a touch device or if the number
* of touches is unknown.
*/
device_props[PROP_NUM_TOUCHES] =
g_param_spec_uint ("num-touches",
P_("Number of concurrent touches"),
P_("Number of concurrent touches"),
0, G_MAXUINT,
0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
device_props[PROP_TOOL] =
g_param_spec_object ("tool",
P_("Tool"),
P_("The tool that is currently used with this device"),
GDK_TYPE_DEVICE_TOOL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
device_props[PROP_DIRECTION] =
g_param_spec_enum ("direction",
P_("Direction"),
P_("The direction of the current layout of the keyboard"),
PANGO_TYPE_DIRECTION, PANGO_DIRECTION_NEUTRAL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
device_props[PROP_HAS_BIDI_LAYOUTS] =
g_param_spec_boolean ("has-bidi-layouts",
P_("Has bidi layouts"),
P_("Whether the keyboard has bidi layouts"),
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
device_props[PROP_CAPS_LOCK_STATE] =
g_param_spec_boolean ("caps-lock-state",
P_("Caps lock state"),
P_("Whether the keyboard caps lock is on"),
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
device_props[PROP_NUM_LOCK_STATE] =
g_param_spec_boolean ("num-lock-state",
P_("Num lock state"),
P_("Whether the keyboard num lock is on"),
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
device_props[PROP_SCROLL_LOCK_STATE] =
g_param_spec_boolean ("scroll-lock-state",
P_("Scroll lock state"),
P_("Whether the keyboard scroll lock is on"),
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
device_props[PROP_MODIFIER_STATE] =
g_param_spec_flags ("modifier-state",
P_("Modifier state"),
P_("The modifier state of the keyboard"),
GDK_TYPE_MODIFIER_TYPE, 0,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, LAST_PROP, device_props);
2010-05-25 22:38:44 +00:00
/**
* GdkDevice::changed:
* @device: the #GdkDevice that changed.
*
* The ::changed signal is emitted either when the #GdkDevice
* has changed the number of either axes or keys. For example
* on X11 this will normally happen when the physical device
* routing events through the logical device changes (for
* example, user switches from the USB mouse to a tablet); in
* that case the logical device will change to reflect the axes
* and keys on the new physical device.
*/
signals[CHANGED] =
g_signal_new (g_intern_static_string ("changed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
2010-12-15 10:52:33 +00:00
0, NULL, NULL,
NULL,
G_TYPE_NONE, 0);
/**
* GdkDevice::tool-changed:
* @device: the #GdkDevice that changed.
* @tool: The new current tool
*
* The ::tool-changed signal is emitted on pen/eraser
* #GdkDevices whenever tools enter or leave proximity.
*/
signals[TOOL_CHANGED] =
g_signal_new (g_intern_static_string ("tool-changed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
NULL,
G_TYPE_NONE, 1, GDK_TYPE_DEVICE_TOOL);
2010-05-25 22:38:44 +00:00
}
static void
gdk_device_init (GdkDevice *device)
{
device->axes = g_array_new (FALSE, TRUE, sizeof (GdkAxisInfo));
2010-05-25 22:38:44 +00:00
}
static void
gdk_device_finalize (GObject *object)
{
GdkDevice *device = GDK_DEVICE (object);
if (device->axes)
{
g_array_free (device->axes, TRUE);
device->axes = NULL;
}
g_clear_pointer (&device->name, g_free);
g_clear_pointer (&device->vendor_id, g_free);
g_clear_pointer (&device->product_id, g_free);
G_OBJECT_CLASS (gdk_device_parent_class)->finalize (object);
}
2010-05-25 22:38:44 +00:00
static void
gdk_device_dispose (GObject *object)
{
GdkDevice *device = GDK_DEVICE (object);
GdkDevice *associated = device->associated;
2010-05-25 22:38:44 +00:00
if (associated)
_gdk_device_remove_physical_device (associated, device);
if (associated)
2010-05-25 22:38:44 +00:00
{
device->associated = NULL;
if (associated->associated == device)
_gdk_device_set_associated_device (associated, NULL);
g_object_unref (associated);
2010-05-25 22:38:44 +00:00
}
g_clear_object (&device->last_tool);
2010-05-25 22:38:44 +00:00
G_OBJECT_CLASS (gdk_device_parent_class)->dispose (object);
}
static void
gdk_device_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GdkDevice *device = GDK_DEVICE (object);
switch (prop_id)
{
case PROP_DISPLAY:
device->display = g_value_get_object (value);
2010-05-25 22:38:44 +00:00
break;
case PROP_NAME:
g_free (device->name);
2010-05-25 22:38:44 +00:00
device->name = g_value_dup_string (value);
2010-05-25 22:38:44 +00:00
break;
case PROP_SOURCE:
device->source = g_value_get_enum (value);
2010-05-25 22:38:44 +00:00
break;
case PROP_HAS_CURSOR:
device->has_cursor = g_value_get_boolean (value);
2010-05-25 22:38:44 +00:00
break;
case PROP_VENDOR_ID:
device->vendor_id = g_value_dup_string (value);
break;
case PROP_PRODUCT_ID:
device->product_id = g_value_dup_string (value);
break;
case PROP_SEAT:
device->seat = g_value_get_object (value);
break;
case PROP_NUM_TOUCHES:
device->num_touches = g_value_get_uint (value);
break;
2010-05-25 22:38:44 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gdk_device_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GdkDevice *device = GDK_DEVICE (object);
switch (prop_id)
{
case PROP_DISPLAY:
g_value_set_object (value, device->display);
2010-05-25 22:38:44 +00:00
break;
case PROP_NAME:
g_value_set_string (value, device->name);
2010-05-25 22:38:44 +00:00
break;
case PROP_SOURCE:
g_value_set_enum (value, device->source);
2010-05-25 22:38:44 +00:00
break;
case PROP_HAS_CURSOR:
g_value_set_boolean (value, device->has_cursor);
2010-05-25 22:38:44 +00:00
break;
case PROP_N_AXES:
g_value_set_uint (value, device->axes->len);
2010-05-25 22:38:44 +00:00
break;
case PROP_VENDOR_ID:
g_value_set_string (value, device->vendor_id);
break;
case PROP_PRODUCT_ID:
g_value_set_string (value, device->product_id);
break;
case PROP_SEAT:
g_value_set_object (value, device->seat);
break;
case PROP_NUM_TOUCHES:
g_value_set_uint (value, device->num_touches);
break;
case PROP_TOOL:
g_value_set_object (value, device->last_tool);
break;
case PROP_DIRECTION:
g_value_set_enum (value, gdk_device_get_direction (device));
break;
case PROP_HAS_BIDI_LAYOUTS:
g_value_set_boolean (value, gdk_device_has_bidi_layouts (device));
break;
case PROP_CAPS_LOCK_STATE:
g_value_set_boolean (value, gdk_device_get_caps_lock_state (device));
break;
case PROP_NUM_LOCK_STATE:
g_value_set_boolean (value, gdk_device_get_num_lock_state (device));
break;
case PROP_SCROLL_LOCK_STATE:
g_value_set_boolean (value, gdk_device_get_scroll_lock_state (device));
break;
case PROP_MODIFIER_STATE:
g_value_set_flags (value, gdk_device_get_modifier_state (device));
break;
2010-05-25 22:38:44 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/*
* gdk_device_get_position:
* @device: pointer device to query status about.
* @x: (out): location to store root window X coordinate of @device
* @y: (out): location to store root window Y coordinate of @device
*
* Gets the current location of @device in double precision.
*/
void
gdk_device_get_position (GdkDevice *device,
double *x,
double *y)
{
g_return_if_fail (GDK_IS_DEVICE (device));
g_return_if_fail (device->source != GDK_SOURCE_KEYBOARD);
_gdk_device_query_state (device, NULL, NULL, x, y, NULL);
}
/**
* gdk_device_get_surface_at_position:
* @device: pointer #GdkDevice to query info to.
* @win_x: (out) (allow-none): return location for the X coordinate of the device location,
* relative to the surface origin, or %NULL.
* @win_y: (out) (allow-none): return location for the Y coordinate of the device location,
* relative to the surface origin, or %NULL.
*
* Obtains the surface underneath @device, returning the location of the device in @win_x and @win_y in
* double precision. Returns %NULL if the surface tree under @device is not known to GDK (for example,
* belongs to another application).
*
GdkWindow -> GdkSurface initial type rename This renames the GdkWindow class and related classes (impl, backend subclasses) to surface. Additionally it renames related types: GdkWindowAttr, GdkWindowPaint, GdkWindowWindowClass, GdkWindowType, GdkWindowTypeHint, GdkWindowHints, GdkWindowState, GdkWindowEdge This is an automatic conversion using the below commands: git sed -f g GdkWindowWindowClass GdkSurfaceSurfaceClass git sed -f g GdkWindow GdkSurface git sed -f g "gdk_window\([ _\(\),;]\|$\)" "gdk_surface\1" # Avoid hitting gdk_windowing git sed -f g "GDK_WINDOW\([ _\(]\|$\)" "GDK_SURFACE\1" # Avoid hitting GDK_WINDOWING git sed "GDK_\([A-Z]*\)IS_WINDOW\([_ (]\|$\)" "GDK_\1IS_SURFACE\2" git sed GDK_TYPE_WINDOW GDK_TYPE_SURFACE git sed -f g GdkPointerWindowInfo GdkPointerSurfaceInfo git sed -f g "BROADWAY_WINDOW" "BROADWAY_SURFACE" git sed -f g "broadway_window" "broadway_surface" git sed -f g "BroadwayWindow" "BroadwaySurface" git sed -f g "WAYLAND_WINDOW" "WAYLAND_SURFACE" git sed -f g "wayland_window" "wayland_surface" git sed -f g "WaylandWindow" "WaylandSurface" git sed -f g "X11_WINDOW" "X11_SURFACE" git sed -f g "x11_window" "x11_surface" git sed -f g "X11Window" "X11Surface" git sed -f g "WIN32_WINDOW" "WIN32_SURFACE" git sed -f g "win32_window" "win32_surface" git sed -f g "Win32Window" "Win32Surface" git sed -f g "QUARTZ_WINDOW" "QUARTZ_SURFACE" git sed -f g "quartz_window" "quartz_surface" git sed -f g "QuartzWindow" "QuartzSurface" git checkout NEWS* po-properties
2018-03-20 10:40:08 +00:00
* Returns: (nullable) (transfer none): the #GdkSurface under the
* device position, or %NULL.
**/
GdkWindow -> GdkSurface initial type rename This renames the GdkWindow class and related classes (impl, backend subclasses) to surface. Additionally it renames related types: GdkWindowAttr, GdkWindowPaint, GdkWindowWindowClass, GdkWindowType, GdkWindowTypeHint, GdkWindowHints, GdkWindowState, GdkWindowEdge This is an automatic conversion using the below commands: git sed -f g GdkWindowWindowClass GdkSurfaceSurfaceClass git sed -f g GdkWindow GdkSurface git sed -f g "gdk_window\([ _\(\),;]\|$\)" "gdk_surface\1" # Avoid hitting gdk_windowing git sed -f g "GDK_WINDOW\([ _\(]\|$\)" "GDK_SURFACE\1" # Avoid hitting GDK_WINDOWING git sed "GDK_\([A-Z]*\)IS_WINDOW\([_ (]\|$\)" "GDK_\1IS_SURFACE\2" git sed GDK_TYPE_WINDOW GDK_TYPE_SURFACE git sed -f g GdkPointerWindowInfo GdkPointerSurfaceInfo git sed -f g "BROADWAY_WINDOW" "BROADWAY_SURFACE" git sed -f g "broadway_window" "broadway_surface" git sed -f g "BroadwayWindow" "BroadwaySurface" git sed -f g "WAYLAND_WINDOW" "WAYLAND_SURFACE" git sed -f g "wayland_window" "wayland_surface" git sed -f g "WaylandWindow" "WaylandSurface" git sed -f g "X11_WINDOW" "X11_SURFACE" git sed -f g "x11_window" "x11_surface" git sed -f g "X11Window" "X11Surface" git sed -f g "WIN32_WINDOW" "WIN32_SURFACE" git sed -f g "win32_window" "win32_surface" git sed -f g "Win32Window" "Win32Surface" git sed -f g "QUARTZ_WINDOW" "QUARTZ_SURFACE" git sed -f g "quartz_window" "quartz_surface" git sed -f g "QuartzWindow" "QuartzSurface" git checkout NEWS* po-properties
2018-03-20 10:40:08 +00:00
GdkSurface *
gdk_device_get_surface_at_position (GdkDevice *device,
double *win_x,
double *win_y)
{
2020-07-24 20:32:16 +00:00
double tmp_x, tmp_y;
GdkSurface *surface;
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
g_return_val_if_fail (device->source != GDK_SOURCE_KEYBOARD, NULL);
surface = _gdk_device_surface_at_position (device, &tmp_x, &tmp_y, NULL);
if (win_x)
*win_x = tmp_x;
if (win_y)
*win_y = tmp_y;
return surface;
}
2010-05-25 22:38:44 +00:00
/**
* gdk_device_get_name:
* @device: a #GdkDevice
*
* Determines the name of the device.
*
* Returns: a name
2010-05-25 22:38:44 +00:00
**/
2020-07-24 18:40:36 +00:00
const char *
2010-05-25 22:38:44 +00:00
gdk_device_get_name (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return device->name;
2010-05-25 22:38:44 +00:00
}
/**
* gdk_device_get_has_cursor:
* @device: a #GdkDevice
*
* Determines whether the pointer follows device motion.
* This is not meaningful for keyboard devices, which don't have a pointer.
2010-05-25 22:38:44 +00:00
*
* Returns: %TRUE if the pointer follows device motion
2010-05-25 22:38:44 +00:00
**/
gboolean
gdk_device_get_has_cursor (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
return device->has_cursor;
2010-05-25 22:38:44 +00:00
}
/**
* gdk_device_get_source:
* @device: a #GdkDevice
*
* Determines the type of the device.
*
* Returns: a #GdkInputSource
2010-05-25 22:38:44 +00:00
**/
GdkInputSource
gdk_device_get_source (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
return device->source;
2010-05-25 22:38:44 +00:00
}
/**
* gdk_device_get_axis_use:
* @device: a pointer #GdkDevice.
2010-05-25 22:38:44 +00:00
* @index_: the index of the axis.
*
* Returns the axis use for @index_.
*
* Returns: a #GdkAxisUse specifying how the axis is used.
**/
GdkAxisUse
gdk_device_get_axis_use (GdkDevice *device,
guint index_)
{
GdkAxisInfo *info;
2010-05-25 22:38:44 +00:00
g_return_val_if_fail (GDK_IS_DEVICE (device), GDK_AXIS_IGNORE);
g_return_val_if_fail (device->source != GDK_SOURCE_KEYBOARD, GDK_AXIS_IGNORE);
g_return_val_if_fail (index_ < device->axes->len, GDK_AXIS_IGNORE);
info = &g_array_index (device->axes, GdkAxisInfo, index_);
2010-05-25 22:38:44 +00:00
return info->use;
2010-05-25 22:38:44 +00:00
}
/**
* gdk_device_get_display:
* @device: a #GdkDevice
*
* Returns the #GdkDisplay to which @device pertains.
*
* Returns: (transfer none): a #GdkDisplay. This memory is owned
* by GTK+, and must not be freed or unreffed.
2010-05-25 22:38:44 +00:00
**/
GdkDisplay *
gdk_device_get_display (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return device->display;
2010-05-25 22:38:44 +00:00
}
void
_gdk_device_set_associated_device (GdkDevice *device,
GdkDevice *associated)
{
g_return_if_fail (GDK_IS_DEVICE (device));
g_return_if_fail (associated == NULL || GDK_IS_DEVICE (associated));
2010-05-25 22:38:44 +00:00
if (device->associated == associated)
2010-05-25 22:38:44 +00:00
return;
if (device->associated)
2010-05-25 22:38:44 +00:00
{
g_object_unref (device->associated);
device->associated = NULL;
2010-05-25 22:38:44 +00:00
}
if (associated)
device->associated = g_object_ref (associated);
}
/**
* gdk_device_list_physical_devices:
* @device: a logical #GdkDevice
*
* Returns the list of physical devices attached to the given logical
* #GdkDevice.
*
* Returns: (nullable) (transfer container) (element-type GdkDevice):
* the list of physical devices attached to a logical #GdkDevice
*/
GList *
gdk_device_list_physical_devices (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return g_list_copy (device->physical_devices);
}
void
_gdk_device_add_physical_device (GdkDevice *device,
GdkDevice *physical)
{
if (!g_list_find (device->physical_devices, physical))
device->physical_devices = g_list_prepend (device->physical_devices, physical);
}
void
_gdk_device_remove_physical_device (GdkDevice *device,
GdkDevice *physical)
{
GList *elem;
elem = g_list_find (device->physical_devices, physical);
if (elem == NULL)
return;
device->physical_devices = g_list_delete_link (device->physical_devices, elem);
2010-05-25 22:38:44 +00:00
}
/**
* gdk_device_get_n_axes:
* @device: a pointer #GdkDevice
2010-05-25 22:38:44 +00:00
*
* Returns the number of axes the device currently has.
*
* Returns: the number of axes.
**/
2020-07-24 13:54:49 +00:00
int
2010-05-25 22:38:44 +00:00
gdk_device_get_n_axes (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
g_return_val_if_fail (device->source != GDK_SOURCE_KEYBOARD, 0);
2010-05-25 22:38:44 +00:00
return device->axes->len;
2010-05-25 22:38:44 +00:00
}
/**
* gdk_device_get_axis: (skip)
2010-05-25 22:38:44 +00:00
* @device: a #GdkDevice
* @axes: (array): pointer to an array of axes
2010-05-25 22:38:44 +00:00
* @use: the use to look for
* @value: (out): location to store the found value.
2010-05-25 22:38:44 +00:00
*
* Interprets an array of double as axis values for a given device,
* and locates the value in the array for a given axis use.
*
* Returns: %TRUE if the given axis use was found, otherwise %FALSE
2010-05-25 22:38:44 +00:00
**/
gboolean
gdk_device_get_axis (GdkDevice *device,
2020-07-24 20:32:16 +00:00
double *axes,
2010-05-25 22:38:44 +00:00
GdkAxisUse use,
2020-07-24 20:32:16 +00:00
double *value)
2010-05-25 22:38:44 +00:00
{
2020-07-24 13:54:49 +00:00
int i;
2010-05-25 22:38:44 +00:00
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
g_return_val_if_fail (device->source != GDK_SOURCE_KEYBOARD, FALSE);
2010-05-25 22:38:44 +00:00
if (axes == NULL)
return FALSE;
g_return_val_if_fail (device->axes != NULL, FALSE);
2010-05-25 22:38:44 +00:00
for (i = 0; i < device->axes->len; i++)
2010-05-25 22:38:44 +00:00
{
GdkAxisInfo axis_info;
axis_info = g_array_index (device->axes, GdkAxisInfo, i);
2010-05-25 22:38:44 +00:00
if (axis_info.use != use)
continue;
if (value)
*value = axes[i];
return TRUE;
}
return FALSE;
}
static GdkEventMask
get_native_grab_event_mask (GdkEventMask grab_mask)
{
/* Similar to the above but for pointer events only */
return
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_SCROLL_MASK |
(grab_mask &
~(GDK_BUTTON_MOTION_MASK |
2010-05-25 22:38:44 +00:00
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON3_MOTION_MASK));
}
GdkGrabStatus
gdk_device_grab (GdkDevice *device,
GdkSurface *surface,
2010-05-25 22:38:44 +00:00
gboolean owner_events,
GdkEventMask event_mask,
GdkCursor *cursor,
guint32 time_)
{
GdkGrabStatus res;
g_return_val_if_fail (GDK_IS_DEVICE (device), GDK_GRAB_FAILED);
g_return_val_if_fail (GDK_IS_SURFACE (surface), GDK_GRAB_FAILED);
g_return_val_if_fail (gdk_surface_get_display (surface) == gdk_device_get_display (device), GDK_GRAB_FAILED);
2010-05-25 22:38:44 +00:00
if (GDK_SURFACE_DESTROYED (surface))
return GDK_GRAB_NOT_VIEWABLE;
res = GDK_DEVICE_GET_CLASS (device)->grab (device,
surface,
owner_events,
get_native_grab_event_mask (event_mask),
NULL,
cursor,
time_);
2010-05-25 22:38:44 +00:00
if (res == GDK_GRAB_SUCCESS)
{
GdkDisplay *display;
gulong serial;
display = gdk_surface_get_display (surface);
serial = _gdk_display_get_next_serial (display);
2010-05-25 22:38:44 +00:00
_gdk_display_add_device_grab (display,
device,
surface,
2010-05-25 22:38:44 +00:00
owner_events,
event_mask,
serial,
time_,
FALSE);
}
return res;
}
void
gdk_device_ungrab (GdkDevice *device,
guint32 time_)
{
g_return_if_fail (GDK_IS_DEVICE (device));
GDK_DEVICE_GET_CLASS (device)->ungrab (device, time_);
}
2010-05-25 22:38:44 +00:00
/* Private API */
void
_gdk_device_reset_axes (GdkDevice *device)
{
2020-07-24 13:54:49 +00:00
int i;
2010-05-25 22:38:44 +00:00
for (i = device->axes->len - 1; i >= 0; i--)
g_array_remove_index (device->axes, i);
2010-05-25 22:38:44 +00:00
g_object_notify_by_pspec (G_OBJECT (device), device_props[PROP_N_AXES]);
2010-05-25 22:38:44 +00:00
}
guint
_gdk_device_add_axis (GdkDevice *device,
GdkAxisUse use,
2020-07-24 20:32:16 +00:00
double min_value,
double max_value,
double resolution)
2010-05-25 22:38:44 +00:00
{
GdkAxisInfo axis_info;
guint pos;
axis_info.use = use;
axis_info.min_value = min_value;
axis_info.max_value = max_value;
axis_info.resolution = resolution;
switch ((guint) use)
2010-05-25 22:38:44 +00:00
{
case GDK_AXIS_X:
case GDK_AXIS_Y:
axis_info.min_axis = 0;
axis_info.max_axis = 0;
break;
case GDK_AXIS_XTILT:
case GDK_AXIS_YTILT:
axis_info.min_axis = -1;
axis_info.max_axis = 1;
break;
default:
axis_info.min_axis = 0;
axis_info.max_axis = 1;
break;
}
device->axes = g_array_append_val (device->axes, axis_info);
pos = device->axes->len - 1;
2010-05-25 22:38:44 +00:00
g_object_notify_by_pspec (G_OBJECT (device), device_props[PROP_N_AXES]);
2010-05-25 22:38:44 +00:00
return pos;
}
void
_gdk_device_get_axis_info (GdkDevice *device,
guint index_,
GdkAxisUse *use,
2020-07-24 20:32:16 +00:00
double *min_value,
double *max_value,
double *resolution)
{
GdkAxisInfo *info;
g_return_if_fail (GDK_IS_DEVICE (device));
g_return_if_fail (index_ < device->axes->len);
info = &g_array_index (device->axes, GdkAxisInfo, index_);
*use = info->use;
*min_value = info->min_value;
*max_value = info->max_value;
*resolution = info->resolution;
}
2010-05-25 22:38:44 +00:00
static GdkAxisInfo *
find_axis_info (GArray *array,
GdkAxisUse use)
{
GdkAxisInfo *info;
2020-07-24 13:54:49 +00:00
int i;
2010-05-25 22:38:44 +00:00
for (i = 0; i < GDK_AXIS_LAST; i++)
{
info = &g_array_index (array, GdkAxisInfo, i);
if (info->use == use)
return info;
}
return NULL;
}
gboolean
GdkSurface: Rename various functions and variables This is an automatic rename of various things related to the window->surface rename. Public symbols changed by this is: GDK_MODE_WINDOW gdk_device_get_window_at_position gdk_device_get_window_at_position_double gdk_device_get_last_event_window gdk_display_get_monitor_at_window gdk_drag_context_get_source_window gdk_drag_context_get_dest_window gdk_drag_context_get_drag_window gdk_draw_context_get_window gdk_drawing_context_get_window gdk_gl_context_get_window gdk_synthesize_window_state gdk_surface_get_window_type gdk_x11_display_set_window_scale gsk_renderer_new_for_window gsk_renderer_get_window gtk_text_view_buffer_to_window_coords gtk_tree_view_convert_widget_to_bin_window_coords gtk_tree_view_convert_tree_to_bin_window_coords The commands that generated this are: git sed -f g "GDK window" "GDK surface" git sed -f g window_impl surface_impl (cd gdk; git sed -f g impl_window impl_surface) git sed -f g WINDOW_IMPL SURFACE_IMPL git sed -f g GDK_MODE_WINDOW GDK_MODE_SURFACE git sed -f g gdk_draw_context_get_window gdk_draw_context_get_surface git sed -f g gdk_drawing_context_get_window gdk_drawing_context_get_surface git sed -f g gdk_gl_context_get_window gdk_gl_context_get_surface git sed -f g gsk_renderer_get_window gsk_renderer_get_surface git sed -f g gsk_renderer_new_for_window gsk_renderer_new_for_surface (cd gdk; git sed -f g window_type surface_type) git sed -f g gdk_surface_get_window_type gdk_surface_get_surface_type git sed -f g window_at_position surface_at_position git sed -f g event_window event_surface git sed -f g window_coord surface_coord git sed -f g window_state surface_state git sed -f g window_cursor surface_cursor git sed -f g window_scale surface_scale git sed -f g window_events surface_events git sed -f g monitor_at_window monitor_at_surface git sed -f g window_under_pointer surface_under_pointer (cd gdk; git sed -f g for_window for_surface) git sed -f g window_anchor surface_anchor git sed -f g WINDOW_IS_TOPLEVEL SURFACE_IS_TOPLEVEL git sed -f g native_window native_surface git sed -f g source_window source_surface git sed -f g dest_window dest_surface git sed -f g drag_window drag_surface git sed -f g input_window input_surface git checkout NEWS* po-properties po docs/reference/gtk/migrating-3to4.xml
2018-03-20 11:05:26 +00:00
_gdk_device_translate_surface_coord (GdkDevice *device,
GdkSurface *surface,
guint index_,
2020-07-24 20:32:16 +00:00
double value,
double *axis_value)
2010-05-25 22:38:44 +00:00
{
GdkAxisInfo axis_info;
GdkAxisInfo *axis_info_x, *axis_info_y;
2020-07-24 20:32:16 +00:00
double device_width, device_height;
double x_offset, y_offset;
double x_scale, y_scale;
double x_min, y_min;
double x_resolution, y_resolution;
double device_aspect;
2020-07-24 13:54:49 +00:00
int surface_width, surface_height;
2010-05-25 22:38:44 +00:00
if (index_ >= device->axes->len)
2010-05-25 22:38:44 +00:00
return FALSE;
axis_info = g_array_index (device->axes, GdkAxisInfo, index_);
2010-05-25 22:38:44 +00:00
if (axis_info.use != GDK_AXIS_X &&
axis_info.use != GDK_AXIS_Y)
return FALSE;
if (axis_info.use == GDK_AXIS_X)
{
axis_info_x = &axis_info;
axis_info_y = find_axis_info (device->axes, GDK_AXIS_Y);
2020-03-05 05:57:26 +00:00
if (axis_info_y == NULL)
return FALSE;
2010-05-25 22:38:44 +00:00
}
else
{
axis_info_x = find_axis_info (device->axes, GDK_AXIS_X);
2010-05-25 22:38:44 +00:00
axis_info_y = &axis_info;
2020-03-05 05:57:26 +00:00
if (axis_info_x == NULL)
return FALSE;
2010-05-25 22:38:44 +00:00
}
device_width = axis_info_x->max_value - axis_info_x->min_value;
device_height = axis_info_y->max_value - axis_info_y->min_value;
x_min = axis_info_x->min_value;
y_min = axis_info_y->min_value;
2010-05-25 22:38:44 +00:00
surface_width = gdk_surface_get_width (surface);
surface_height = gdk_surface_get_height (surface);
2010-05-25 22:38:44 +00:00
x_resolution = axis_info_x->resolution;
y_resolution = axis_info_y->resolution;
/*
* Some drivers incorrectly report the resolution of the device
* as zero (in partiular linuxwacom < 0.5.3 with usb tablets).
* This causes the device_aspect to become NaN and totally
* breaks windowed mode. If this is the case, the best we can
* do is to assume the resolution is non-zero is equal in both
* directions (which is true for many devices). The absolute
* value of the resolution doesn't matter since we only use the
* ratio.
*/
if (x_resolution == 0 || y_resolution == 0)
{
x_resolution = 1;
y_resolution = 1;
}
device_aspect = (device_height * y_resolution) /
(device_width * x_resolution);
if (device_aspect * surface_width >= surface_height)
2010-05-25 22:38:44 +00:00
{
/* device taller than surface */
x_scale = surface_width / device_width;
2010-05-25 22:38:44 +00:00
y_scale = (x_scale * x_resolution) / y_resolution;
x_offset = 0;
y_offset = - (device_height * y_scale - surface_height) / 2;
2010-05-25 22:38:44 +00:00
}
else
{
/* surface taller than device */
y_scale = surface_height / device_height;
2010-05-25 22:38:44 +00:00
x_scale = (y_scale * y_resolution) / x_resolution;
y_offset = 0;
x_offset = - (device_width * x_scale - surface_width) / 2;
2010-05-25 22:38:44 +00:00
}
if (axis_value)
{
if (axis_info.use == GDK_AXIS_X)
*axis_value = x_offset + x_scale * (value - x_min);
else
*axis_value = y_offset + y_scale * (value - y_min);
}
return TRUE;
}
gboolean
_gdk_device_translate_screen_coord (GdkDevice *device,
GdkSurface *surface,
2020-07-24 20:32:16 +00:00
double surface_root_x,
double surface_root_y,
double screen_width,
double screen_height,
2010-05-25 22:38:44 +00:00
guint index_,
2020-07-24 20:32:16 +00:00
double value,
double *axis_value)
2010-05-25 22:38:44 +00:00
{
GdkAxisInfo axis_info;
2020-07-24 20:32:16 +00:00
double axis_width, scale, offset;
2010-05-25 22:38:44 +00:00
if (index_ >= device->axes->len)
2010-05-25 22:38:44 +00:00
return FALSE;
axis_info = g_array_index (device->axes, GdkAxisInfo, index_);
2010-05-25 22:38:44 +00:00
if (axis_info.use != GDK_AXIS_X &&
axis_info.use != GDK_AXIS_Y)
return FALSE;
axis_width = axis_info.max_value - axis_info.min_value;
if (axis_info.use == GDK_AXIS_X)
{
if (axis_width > 0)
scale = screen_width / axis_width;
2010-05-25 22:38:44 +00:00
else
scale = 1;
offset = - surface_root_x;
2010-05-25 22:38:44 +00:00
}
else
{
if (axis_width > 0)
scale = screen_height / axis_width;
2010-05-25 22:38:44 +00:00
else
scale = 1;
offset = - surface_root_y;
2010-05-25 22:38:44 +00:00
}
if (axis_value)
*axis_value = offset + scale * (value - axis_info.min_value);
return TRUE;
}
gboolean
_gdk_device_translate_axis (GdkDevice *device,
guint index_,
2020-07-24 20:32:16 +00:00
double value,
double *axis_value)
2010-05-25 22:38:44 +00:00
{
GdkAxisInfo axis_info;
2020-07-24 20:32:16 +00:00
double axis_width, out;
2010-05-25 22:38:44 +00:00
if (index_ >= device->axes->len)
2010-05-25 22:38:44 +00:00
return FALSE;
axis_info = g_array_index (device->axes, GdkAxisInfo, index_);
2010-05-25 22:38:44 +00:00
if (axis_info.use == GDK_AXIS_X ||
axis_info.use == GDK_AXIS_Y)
return FALSE;
axis_width = axis_info.max_value - axis_info.min_value;
out = (axis_info.max_axis * (value - axis_info.min_value) +
axis_info.min_axis * (axis_info.max_value - value)) / axis_width;
if (axis_value)
*axis_value = out;
return TRUE;
}
void
_gdk_device_query_state (GdkDevice *device,
GdkSurface *surface,
GdkSurface **child_surface,
2020-07-24 20:32:16 +00:00
double *win_x,
double *win_y,
GdkModifierType *mask)
{
GDK_DEVICE_GET_CLASS (device)->query_state (device,
surface,
child_surface,
win_x,
win_y,
mask);
}
GdkWindow -> GdkSurface initial type rename This renames the GdkWindow class and related classes (impl, backend subclasses) to surface. Additionally it renames related types: GdkWindowAttr, GdkWindowPaint, GdkWindowWindowClass, GdkWindowType, GdkWindowTypeHint, GdkWindowHints, GdkWindowState, GdkWindowEdge This is an automatic conversion using the below commands: git sed -f g GdkWindowWindowClass GdkSurfaceSurfaceClass git sed -f g GdkWindow GdkSurface git sed -f g "gdk_window\([ _\(\),;]\|$\)" "gdk_surface\1" # Avoid hitting gdk_windowing git sed -f g "GDK_WINDOW\([ _\(]\|$\)" "GDK_SURFACE\1" # Avoid hitting GDK_WINDOWING git sed "GDK_\([A-Z]*\)IS_WINDOW\([_ (]\|$\)" "GDK_\1IS_SURFACE\2" git sed GDK_TYPE_WINDOW GDK_TYPE_SURFACE git sed -f g GdkPointerWindowInfo GdkPointerSurfaceInfo git sed -f g "BROADWAY_WINDOW" "BROADWAY_SURFACE" git sed -f g "broadway_window" "broadway_surface" git sed -f g "BroadwayWindow" "BroadwaySurface" git sed -f g "WAYLAND_WINDOW" "WAYLAND_SURFACE" git sed -f g "wayland_window" "wayland_surface" git sed -f g "WaylandWindow" "WaylandSurface" git sed -f g "X11_WINDOW" "X11_SURFACE" git sed -f g "x11_window" "x11_surface" git sed -f g "X11Window" "X11Surface" git sed -f g "WIN32_WINDOW" "WIN32_SURFACE" git sed -f g "win32_window" "win32_surface" git sed -f g "Win32Window" "Win32Surface" git sed -f g "QUARTZ_WINDOW" "QUARTZ_SURFACE" git sed -f g "quartz_window" "quartz_surface" git sed -f g "QuartzWindow" "QuartzSurface" git checkout NEWS* po-properties
2018-03-20 10:40:08 +00:00
GdkSurface *
_gdk_device_surface_at_position (GdkDevice *device,
2020-07-24 20:32:16 +00:00
double *win_x,
double *win_y,
GdkModifierType *mask)
{
GdkSurface: Rename various functions and variables This is an automatic rename of various things related to the window->surface rename. Public symbols changed by this is: GDK_MODE_WINDOW gdk_device_get_window_at_position gdk_device_get_window_at_position_double gdk_device_get_last_event_window gdk_display_get_monitor_at_window gdk_drag_context_get_source_window gdk_drag_context_get_dest_window gdk_drag_context_get_drag_window gdk_draw_context_get_window gdk_drawing_context_get_window gdk_gl_context_get_window gdk_synthesize_window_state gdk_surface_get_window_type gdk_x11_display_set_window_scale gsk_renderer_new_for_window gsk_renderer_get_window gtk_text_view_buffer_to_window_coords gtk_tree_view_convert_widget_to_bin_window_coords gtk_tree_view_convert_tree_to_bin_window_coords The commands that generated this are: git sed -f g "GDK window" "GDK surface" git sed -f g window_impl surface_impl (cd gdk; git sed -f g impl_window impl_surface) git sed -f g WINDOW_IMPL SURFACE_IMPL git sed -f g GDK_MODE_WINDOW GDK_MODE_SURFACE git sed -f g gdk_draw_context_get_window gdk_draw_context_get_surface git sed -f g gdk_drawing_context_get_window gdk_drawing_context_get_surface git sed -f g gdk_gl_context_get_window gdk_gl_context_get_surface git sed -f g gsk_renderer_get_window gsk_renderer_get_surface git sed -f g gsk_renderer_new_for_window gsk_renderer_new_for_surface (cd gdk; git sed -f g window_type surface_type) git sed -f g gdk_surface_get_window_type gdk_surface_get_surface_type git sed -f g window_at_position surface_at_position git sed -f g event_window event_surface git sed -f g window_coord surface_coord git sed -f g window_state surface_state git sed -f g window_cursor surface_cursor git sed -f g window_scale surface_scale git sed -f g window_events surface_events git sed -f g monitor_at_window monitor_at_surface git sed -f g window_under_pointer surface_under_pointer (cd gdk; git sed -f g for_window for_surface) git sed -f g window_anchor surface_anchor git sed -f g WINDOW_IS_TOPLEVEL SURFACE_IS_TOPLEVEL git sed -f g native_window native_surface git sed -f g source_window source_surface git sed -f g dest_window dest_surface git sed -f g drag_window drag_surface git sed -f g input_window input_surface git checkout NEWS* po-properties po docs/reference/gtk/migrating-3to4.xml
2018-03-20 11:05:26 +00:00
return GDK_DEVICE_GET_CLASS (device)->surface_at_position (device,
win_x,
win_y,
mask);
}
/**
* gdk_device_get_vendor_id:
* @device: a physical #GdkDevice
*
* Returns the vendor ID of this device, or %NULL if this information couldn't
* be obtained. This ID is retrieved from the device, and is thus constant for
* it.
*
* This function, together with gdk_device_get_product_id(), can be used to eg.
* compose #GSettings paths to store settings for this device.
*
* |[<!-- language="C" -->
* static GSettings *
* get_device_settings (GdkDevice *device)
* {
2020-07-24 18:40:36 +00:00
* const char *vendor, *product;
* GSettings *settings;
* GdkDevice *device;
2020-07-24 18:40:36 +00:00
* char *path;
*
* vendor = gdk_device_get_vendor_id (device);
* product = gdk_device_get_product_id (device);
*
* path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product);
* settings = g_settings_new_with_path (DEVICE_SCHEMA, path);
* g_free (path);
*
* return settings;
* }
* ]|
*
* Returns: (nullable): the vendor ID, or %NULL
*/
2020-07-24 18:40:36 +00:00
const char *
gdk_device_get_vendor_id (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return device->vendor_id;
}
/**
* gdk_device_get_product_id:
* @device: a physical #GdkDevice
*
* Returns the product ID of this device, or %NULL if this information couldn't
* be obtained. This ID is retrieved from the device, and is thus constant for
* it. See gdk_device_get_vendor_id() for more information.
*
* Returns: (nullable): the product ID, or %NULL
*/
2020-07-24 18:40:36 +00:00
const char *
gdk_device_get_product_id (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return device->product_id;
}
void
gdk_device_set_seat (GdkDevice *device,
GdkSeat *seat)
{
g_return_if_fail (GDK_IS_DEVICE (device));
g_return_if_fail (!seat || GDK_IS_SEAT (seat));
if (device->seat == seat)
return;
device->seat = seat;
g_object_notify (G_OBJECT (device), "seat");
}
/**
* gdk_device_get_seat:
* @device: A #GdkDevice
*
* Returns the #GdkSeat the device belongs to.
*
* Returns: (transfer none): A #GdkSeat. This memory is owned by GTK+ and
* must not be freed.
**/
GdkSeat *
gdk_device_get_seat (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return device->seat;
}
void
gdk_device_update_tool (GdkDevice *device,
GdkDeviceTool *tool)
{
g_return_if_fail (GDK_IS_DEVICE (device));
if (g_set_object (&device->last_tool, tool))
{
g_object_notify (G_OBJECT (device), "tool");
g_signal_emit (device, signals[TOOL_CHANGED], 0, tool);
}
}
2020-02-26 10:23:15 +00:00
/**
* gdk_device_get_num_touches:
* @device: a #GdkDevice
*
* Retrieves the number of touch points associated to @device.
*
* Returns: the number of touch points
*/
guint
gdk_device_get_num_touches (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
return device->num_touches;
}
2020-02-26 10:23:15 +00:00
/**
* gdk_device_get_device_tool:
* @device: a #GdkDevice
*
* Retrieves the #GdkDeviceTool associated to @device.
*
* Returns: (transfer none): the #GdkDeviceTool
*/
GdkDeviceTool *
gdk_device_get_device_tool (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return device->last_tool;
}
/**
* gdk_device_get_caps_lock_state:
* @device: a #GdkDevice
*
* Retrieves whether the Caps Lock modifier of the
* keyboard is locked, if @device is a keyboard device.
*
* Returns: %TRUE if Caps Lock is on for @device
*/
gboolean
gdk_device_get_caps_lock_state (GdkDevice *device)
{
GdkKeymap *keymap = gdk_display_get_keymap (device->display);
if (device->source == GDK_SOURCE_KEYBOARD)
return gdk_keymap_get_caps_lock_state (keymap);
return FALSE;
}
/**
* gdk_device_get_num_lock_state:
* @device: a #GdkDevice
*
* Retrieves whether the Num Lock modifier of the
* keyboard is locked, if @device is a keyboard device.
*
* Returns: %TRUE if Num Lock is on for @device
*/
gboolean
gdk_device_get_num_lock_state (GdkDevice *device)
{
GdkKeymap *keymap = gdk_display_get_keymap (device->display);
if (device->source == GDK_SOURCE_KEYBOARD)
return gdk_keymap_get_num_lock_state (keymap);
return FALSE;
}
/**
* gdk_device_get_scroll_lock_state:
* @device: a #GdkDevice
*
* Retrieves whether the Scroll Lock modifier of the
* keyboard is locked, if @device is a keyboard device.
*
* Returns: %TRUE if Scroll Lock is on for @device
*/
gboolean
gdk_device_get_scroll_lock_state (GdkDevice *device)
{
GdkKeymap *keymap = gdk_display_get_keymap (device->display);
if (device->source == GDK_SOURCE_KEYBOARD)
return gdk_keymap_get_scroll_lock_state (keymap);
return FALSE;
}
/**
* gdk_device_get_modifier_state:
* @device: a #GdkDevice
*
* Retrieves the current modifier state of the keyboard,
* if @device is a keyboard device.
*
* Returns: the current modifier state
*/
GdkModifierType
gdk_device_get_modifier_state (GdkDevice *device)
{
GdkKeymap *keymap = gdk_display_get_keymap (device->display);
if (device->source == GDK_SOURCE_KEYBOARD)
return gdk_keymap_get_modifier_state (keymap);
return 0;
}
/**
* gdk_device_get_direction:
* @device: a #GdkDevice
*
* Returns the direction of effective layout of the keyboard,
* if @device is a keyboard device.
*
* The direction of a layout is the direction of the majority
* of its symbols. See pango_unichar_direction().
*
* Returns: %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL
* if it can determine the direction. %PANGO_DIRECTION_NEUTRAL
* otherwise
*/
PangoDirection
gdk_device_get_direction (GdkDevice *device)
{
GdkKeymap *keymap = gdk_display_get_keymap (device->display);
if (device->source == GDK_SOURCE_KEYBOARD)
return gdk_keymap_get_direction (keymap);
return PANGO_DIRECTION_NEUTRAL;
}
/**
* gdk_device_has_bidi_layouts:
* @device: a #GdkDevice
*
* Determines if keyboard layouts for both right-to-left and
* left-to-right languages are in use on the keyboard, if
* @device is a keyboard device.
*
* Returns: %TRUE if there are layouts with both directions,
* %FALSE otherwise
*/
gboolean
gdk_device_has_bidi_layouts (GdkDevice *device)
{
GdkKeymap *keymap = gdk_display_get_keymap (device->display);
if (device->source == GDK_SOURCE_KEYBOARD)
return gdk_keymap_have_bidi_layouts (keymap);
return FALSE;
}