## GdkDevice

GdkDevice — Object representing an input device

## Functions

const gchar * | gdk_device_get_name ()
const gchar * | gdk_device_get_vendor_id ()
const gchar * | gdk_device_get_product_id ()
GdkInputSource | gdk_device_get_source ()
gboolean | gdk_device_set_mode ()
GdkInputMode | gdk_device_get_mode ()
void | gdk_device_set_key ()
gboolean | gdk_device_get_key ()
void | gdk_device_set_axis_use ()
GdkAxisUse | gdk_device_get_axis_use ()
GdkDevice * | gdk_device_get_associated_device ()
GList * | gdk_device_list_slave_devices ()
GdkDeviceType | gdk_device_get_device_type ()
GdkDisplay * | gdk_device_get_display ()
gboolean | gdk_device_get_has_cursor ()
gint | gdk_device_get_n_axes ()
gint | gdk_device_get_n_keys ()
void | gdk_device_warp ()
GdkGrabStatus | gdk_device_grab ()
void | gdk_device_ungrab ()
void | gdk_device_get_state ()
void | gdk_device_get_position ()
void | gdk_device_get_position_double ()
GdkWindow * | gdk_device_get_window_at_position ()
GdkWindow * | gdk_device_get_window_at_position_double ()
gboolean | gdk_device_get_history ()
void | gdk_device_free_history ()
gboolean | gdk_device_get_axis ()
GList * | gdk_device_list_axes ()
gboolean | gdk_device_get_axis_value ()
GdkWindow * | gdk_device_get_last_event_window ()

## Properties

GdkDevice * | associated-device | Read
GdkDeviceManager * | device-manager | Read / Write / Construct Only
GdkDisplay * | display | Read / Write / Construct Only
gboolean | has-cursor | Read / Write / Construct Only
GdkInputMode | input-mode | Read / Write
GdkInputSource | input-source | Read / Write / Construct Only
guint | n-axes | Read
gchar * | name | Read / Write / Construct Only
gchar * | product-id | Read / Write / Construct Only
GdkDeviceType | type | Read / Write / Construct Only
gchar * | vendor-id | Read / Write / Construct Only

## Signals

void | changed | Run Last

## Types and Values

| GdkDevice
enum | GdkInputSource
enum | GdkInputMode
enum | GdkAxisUse
enum | GdkDeviceType
enum | GdkGrabOwnership
struct | GdkTimeCoord

## Object Hierarchy

        GObject
        ╰── GdkDevice

## Includes

    #include <gdk/gdk.h>

## Description

The GdkDevice object represents a single input device, such as a keyboard, a mouse, a touchpad, etc.

See the GdkDeviceManager documentation for more information about the various kinds of master and slave devices, and their relationships.

## Functions

### gdk_device_get_name ()

    const gchar *
    gdk_device_get_name (GdkDevice *device);

Determines the name of the device.

#### Parameters

device | a GdkDevice |

#### Returns

a name

Since 2.20

### gdk_device_get_vendor_id ()

    const gchar *
    gdk_device_get_vendor_id (GdkDevice *device);

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.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    static GSettings *
    get_device_settings (GdkDevice *device)
    {
      const gchar *vendor, *product;
      GSettings *settings;
      GdkDevice *device;
      gchar *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;
    }

#### Parameters

device | a slave GdkDevice |

#### Returns

the vendor ID, or `NULL`.

[nullable]

Since 3.16

### gdk_device_get_product_id ()

    const gchar *
    gdk_device_get_product_id (GdkDevice *device);

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.

#### Parameters

device | a slave GdkDevice |

#### Returns

the product ID, or `NULL`.

[nullable]

Since 3.16

### gdk_device_get_source ()

    GdkInputSource
    gdk_device_get_source (GdkDevice *device);

Determines the type of the device.

#### Parameters

device | a GdkDevice |

#### Returns

a GdkInputSource

Since 2.20

### gdk_device_set_mode ()

    gboolean
    gdk_device_set_mode (GdkDevice *device,
                         GdkInputMode mode);

Sets a the mode of an input device. The mode controls if the device is active and whether the device’s range is mapped to the entire screen or to a single window.

Note: This is only meaningful for floating devices, master devices (and slaves connected to these) drive the pointer cursor, which is not limited by the input mode.

#### Parameters

device | a GdkDevice. |
mode | the input mode. |

#### Returns

`TRUE` if the mode was successfully changed.

### gdk_device_get_mode ()

    GdkInputMode
    gdk_device_get_mode (GdkDevice *device);

Determines the mode of the device.

#### Parameters

device | a GdkDevice |

#### Returns

a GdkInputSource

Since 2.20

### gdk_device_set_key ()

    void
    gdk_device_set_key (GdkDevice *device,
                        guint index_,
                        guint keyval,
                        GdkModifierType modifiers);

Specifies the X key event to generate when a macro button of a device is pressed.

#### Parameters

device | a GdkDevice |
index_ | the index of the macro button to set |
keyval | the keyval to generate |
modifiers | the modifiers to set |

### gdk_device_get_key ()

    gboolean
    gdk_device_get_key (GdkDevice *device,
                        guint index_,
                        guint *keyval,
                        GdkModifierType *modifiers);

If `index_` has a valid keyval, this function will return `TRUE` and fill in `keyval` and `modifiers` with the keyval settings.

#### Parameters

device | a GdkDevice. |
index_ | the index of the macro button to get. |
keyval | return value for the keyval. | [out]
modifiers | return value for modifiers. | [out]

#### Returns

`TRUE` if keyval is set for `index` .

Since 2.20

### gdk_device_set_axis_use ()

    void
    gdk_device_set_axis_use (GdkDevice *device,
                             guint index_,
                             GdkAxisUse use);

Specifies how an axis of a device is used.

#### Parameters

device | a pointer GdkDevice |
index_ | the index of the axis |
use | specifies how the axis is used |

### gdk_device_get_axis_use ()

    GdkAxisUse
    gdk_device_get_axis_use (GdkDevice *device,
                             guint index_);

Returns the axis use for `index_` .

#### Parameters

device | a pointer GdkDevice. |
index_ | the index of the axis. |

#### Returns

a GdkAxisUse specifying how the axis is used.

Since 2.20

### gdk_device_get_associated_device ()

    GdkDevice *
    gdk_device_get_associated_device (GdkDevice *device);

Returns the associated device to `device` , if `device` is of type `GDK_DEVICE_TYPE_MASTER`, it will return the paired pointer or keyboard.

If `device` is of type `GDK_DEVICE_TYPE_SLAVE`, it will return the master device to which `device` is attached to.

If `device` is of type `GDK_DEVICE_TYPE_FLOATING`, `NULL` will be returned, as there is no associated device.

#### Parameters

device | a GdkDevice |

#### Returns

The associated device, or `NULL`.

[nullable][transfer none]

Since 3.0

### gdk_device_list_slave_devices ()

    GList *
    gdk_device_list_slave_devices (GdkDevice *device);

If the device if of type `GDK_DEVICE_TYPE_MASTER`, it will return the list of slave devices attached to it, otherwise it will return `NULL`

#### Parameters

device | a GdkDevice |

#### Returns

the list of slave devices, or `NULL`. The list must be freed with `g_list_free()`, the contents of the list are owned by GTK+ and should not be freed.

[nullable][transfer container][element-type GdkDevice]

### gdk_device_get_device_type ()

    GdkDeviceType
    gdk_device_get_device_type (GdkDevice *device);

Returns the device type for `device` .

#### Parameters

device | a GdkDevice |

#### Returns

the GdkDeviceType for `device` .

Since 3.0

### gdk_device_get_display ()

    GdkDisplay *
    gdk_device_get_display (GdkDevice *device);

Returns the GdkDisplay to which `device` pertains.

#### Parameters

device | a GdkDevice |

#### Returns

a GdkDisplay. This memory is owned by GTK+, and must not be freed or unreffed.

[transfer none]

Since 3.0

### gdk_device_get_has_cursor ()

    gboolean
    gdk_device_get_has_cursor (GdkDevice *device);

Determines whether the pointer follows device motion. This is not meaningful for keyboard devices, which don't have a pointer.

#### Parameters

device | a GdkDevice |

#### Returns

`TRUE` if the pointer follows device motion

Since 2.20

### gdk_device_get_n_axes ()

    gint
    gdk_device_get_n_axes (GdkDevice *device);

Returns the number of axes the device currently has.

#### Parameters

device | a pointer GdkDevice |

#### Returns

the number of axes.

Since 3.0

### gdk_device_get_n_keys ()

    gint
    gdk_device_get_n_keys (GdkDevice *device);

Returns the number of keys the device currently has.

#### Parameters

device | a GdkDevice |

#### Returns

the number of keys.

Since 2.24

### gdk_device_warp ()

    void
    gdk_device_warp (GdkDevice *device,
                     GdkScreen *screen,
                     gint x,
                     gint y);

Warps `device` in `display` to the point `x` ,`y` on the screen `screen` , unless the device is confined to a window by a grab, in which case it will be moved as far as allowed by the grab. Warping the pointer creates events as if the user had moved the mouse instantaneously to the destination.

Note that the pointer should normally be under the control of the user. This function was added to cover some rare use cases like keyboard navigation support for the color picker in the GtkColorSelectionDialog.

#### Parameters

device | the device to warp. |
screen | the screen to warp `device` to. |
x | the X coordinate of the destination. |
y | the Y coordinate of the destination. |

Since 3.0

### gdk_device_grab ()

    GdkGrabStatus
    gdk_device_grab (GdkDevice *device,
                     GdkWindow *window,
                     GdkGrabOwnership grab_ownership,
                     gboolean owner_events,
                     GdkEventMask event_mask,
                     GdkCursor *cursor,
                     guint32 time_);

Grabs the device so that all events coming from this device are passed to this application until the device is ungrabbed with `gdk_device_ungrab()`, or the window becomes unviewable. This overrides any previous grab on the device by this client.

Note that `device` and `window` need to be on the same display.

Device grabs are used for operations which need complete control over the given device events (either pointer or keyboard). For example in GTK+ this is used for Drag and Drop operations, popup menus and such.

Note that if the event mask of an X window has selected both button press and button release events, then a button press event will cause an automatic pointer grab until the button is released. X does this automatically since most applications expect to receive button press and release events in pairs. It is equivalent to a pointer grab on the window with `owner_events` set to `TRUE`.

If you set up anything at the time you take the grab that needs to be cleaned up when the grab ends, you should handle the GdkEventGrabBroken events that are emitted when the grab ends unvoluntarily.

#### Parameters

device | a GdkDevice. To get the device you can use `gtk_get_current_event_device()` or `gdk_event_get_device()` if the grab is in reaction to an event. Also, you can use `gdk_device_manager_get_client_pointer()` but only in code that isn’t triggered by a GdkEvent and there aren’t other means to get a meaningful GdkDevice to operate on. |
window | the GdkWindow which will own the grab (the grab window) |
grab_ownership | specifies the grab ownership. |
owner_events | if `FALSE` then all device events are reported with respect to `window` and are only reported if selected by `event_mask` . If `TRUE` then pointer events for this application are reported as normal, but pointer events outside this application are reported with respect to `window` and only if selected by `event_mask` . In either mode, unreported events are discarded. |
event_mask | specifies the event mask, which is used in accordance with `owner_events` . |
cursor | the cursor to display while the grab is active if the device is a pointer. If this is `NULL` then the normal cursors are used for `window` and its descendants, and the cursor for `window` is used elsewhere. | [allow-none]
time_ | the timestamp of the event which led to this pointer grab. This usually comes from the GdkEvent struct, though `GDK_CURRENT_TIME` can be used if the time isn’t known. |

#### Returns

`GDK_GRAB_SUCCESS` if the grab was successful.

Since 3.0

### gdk_device_ungrab ()

    void
    gdk_device_ungrab (GdkDevice *device,
                       guint32 time_);

Release any grab on `device` .

#### Parameters

device | a GdkDevice |
time_ | a timestap (e.g. `GDK_CURRENT_TIME`). |

Since 3.0

### gdk_device_get_state ()

    void
    gdk_device_get_state (GdkDevice *device,
                          GdkWindow *window,
                          gdouble *axes,
                          GdkModifierType *mask);

Gets the current state of a pointer device relative to `window` . As a slave device’s coordinates are those of its master pointer, this function may not be called on devices of type `GDK_DEVICE_TYPE_SLAVE`, unless there is an ongoing grab on them. See `gdk_device_grab()`.

#### Parameters

device | a GdkDevice. |
window | a GdkWindow. |
axes | an array of doubles to store the values of the axes of `device` in, or `NULL`. | [nullable][array]
mask | location to store the modifiers, or `NULL`. | [optional][out]

### gdk_device_get_position ()

    void
    gdk_device_get_position (GdkDevice *device,
                             GdkScreen **screen,
                             gint *x,
                             gint *y);

Gets the current location of `device` . As a slave device coordinates are those of its master pointer, This function may not be called on devices of type `GDK_DEVICE_TYPE_SLAVE`, unless there is an ongoing grab on them, see `gdk_device_grab()`.

#### Parameters

device | pointer device to query status about. |
screen | location to store the GdkScreen the `device` is on, or `NULL`. | [out][transfer none][allow-none]
x | location to store root window X coordinate of `device` , or `NULL`. | [out][allow-none]
y | location to store root window Y coordinate of `device` , or `NULL`. | [out][allow-none]

Since 3.0

### gdk_device_get_position_double ()

    void
    gdk_device_get_position_double (GdkDevice *device,
                                    GdkScreen **screen,
                                    gdouble *x,
                                    gdouble *y);

Gets the current location of `device` in double precision. As a slave device's coordinates are those of its master pointer, this function may not be called on devices of type `GDK_DEVICE_TYPE_SLAVE`, unless there is an ongoing grab on them. See `gdk_device_grab()`.

#### Parameters

device | pointer device to query status about. |
screen | location to store the GdkScreen the `device` is on, or `NULL`. | [out][transfer none][allow-none]
x | location to store root window X coordinate of `device` , or `NULL`. | [out][allow-none]
y | location to store root window Y coordinate of `device` , or `NULL`. | [out][allow-none]

Since 3.10

### gdk_device_get_window_at_position ()

    GdkWindow *
    gdk_device_get_window_at_position (GdkDevice *device,
                                       gint *win_x,
                                       gint *win_y);

Obtains the window underneath `device` , returning the location of the device in `win_x` and `win_y` . Returns `NULL` if the window tree under `device` is not known to GDK (for example, belongs to another application).

As a slave device coordinates are those of its master pointer, This function may not be called on devices of type `GDK_DEVICE_TYPE_SLAVE`, unless there is an ongoing grab on them, see `gdk_device_grab()`.

#### Parameters

device | pointer GdkDevice to query info to. |
win_x | return location for the X coordinate of the device location, relative to the window origin, or `NULL`. | [out][allow-none]
win_y | return location for the Y coordinate of the device location, relative to the window origin, or `NULL`. | [out][allow-none]

#### Returns

the GdkWindow under the device position, or `NULL`.

[nullable][transfer none]

Since 3.0

### gdk_device_get_window_at_position_double ()

    GdkWindow *
    gdk_device_get_window_at_position_double
                                   (GdkDevice *device,
                                    gdouble *win_x,
                                    gdouble *win_y);

Obtains the window underneath `device` , returning the location of the device in `win_x` and `win_y` in double precision. Returns `NULL` if the window tree under `device` is not known to GDK (for example, belongs to another application).

As a slave device coordinates are those of its master pointer, This function may not be called on devices of type `GDK_DEVICE_TYPE_SLAVE`, unless there is an ongoing grab on them, see `gdk_device_grab()`.

#### Parameters

device | pointer GdkDevice to query info to. |
win_x | return location for the X coordinate of the device location, relative to the window origin, or `NULL`. | [out][allow-none]
win_y | return location for the Y coordinate of the device location, relative to the window origin, or `NULL`. | [out][allow-none]

#### Returns

the GdkWindow under the device position, or `NULL`.

[nullable][transfer none]

Since 3.0

### gdk_device_get_history ()

    gboolean
    gdk_device_get_history (GdkDevice *device,
                            GdkWindow *window,
                            guint32 start,
                            guint32 stop,
                            GdkTimeCoord ***events,
                            gint *n_events);

Obtains the motion history for a pointer 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.)

Note that there is also `gdk_window_set_event_compression()` to get more motion events delivered directly, independent of the windowing system.

#### Parameters

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`. | [array length=n_events][out][transfer full][optional]
n_events | location to store the length of `events` , or `NULL`. | [out][optional]

#### Returns

`TRUE` if the windowing system supports motion history and at least one event was found.

### gdk_device_free_history ()

    void
    gdk_device_free_history (GdkTimeCoord **events,
                             gint n_events);

Frees an array of GdkTimeCoord that was returned by `gdk_device_get_history()`.

#### Parameters

events | an array of GdkTimeCoord. | [array length=n_events]
n_events | the length of the array. |

### gdk_device_get_axis ()

    gboolean
    gdk_device_get_axis (GdkDevice *device,
                         gdouble *axes,
                         GdkAxisUse use,
                         gdouble *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.

#### Parameters

device | a GdkDevice |
axes | pointer to an array of axes. | [array]
use | the use to look for |
value | location to store the found value. | [out]

#### Returns

`TRUE` if the given axis use was found, otherwise `FALSE`

### gdk_device_list_axes ()

    GList *
    gdk_device_list_axes (GdkDevice *device);

Returns a GList of GdkAtoms, containing the labels for the axes that `device` currently has.

#### Parameters

device | a pointer GdkDevice |

#### Returns

A GList of GdkAtoms, free with `g_list_free()`.

[transfer container][element-type GdkAtom]

Since 3.0

### gdk_device_get_axis_value ()

    gboolean
    gdk_device_get_axis_value (GdkDevice *device,
                               gdouble *axes,
                               GdkAtom axis_label,
                               gdouble *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_list_axes()`

#### Parameters

device | a pointer GdkDevice. |
axes | pointer to an array of axes. | [array]
axis_label | GdkAtom with the axis label. |
value | location to store the found value. | [out]

#### Returns

`TRUE` if the given axis use was found, otherwise `FALSE`.

Since 3.0

### gdk_device_get_last_event_window ()

    GdkWindow *
    gdk_device_get_last_event_window (GdkDevice *device);

Gets information about which window the given pointer device is in, based on events that have been received so far from the display server. If another application has a pointer grab, or this application has a grab with owner_events = `FALSE`, `NULL` may be returned even if the pointer is physically over one of this application's windows.

#### Parameters

device | a GdkDevice, with a source other than `GDK_SOURCE_KEYBOARD` |

#### Returns

the last window the device.

[transfer none][allow-none]

Since 3.12

## Types and Values

### GdkDevice

    typedef struct _GdkDevice GdkDevice;

### enum GdkInputSource

An enumeration describing the type of an input device in general terms.

#### Members

GDK_SOURCE_MOUSE | the device is a mouse. (This will be reported for the core pointer, even if it is something else, such as a trackball.) |
GDK_SOURCE_PEN | the device is a stylus of a graphics tablet or similar device. |
GDK_SOURCE_ERASER | the device is an eraser. Typically, this would be the other end of a stylus on a graphics tablet. |
GDK_SOURCE_CURSOR | the device is a graphics tablet “puck” or similar device. |
GDK_SOURCE_KEYBOARD | the device is a keyboard. |
GDK_SOURCE_TOUCHSCREEN | the device is a direct-input touch device, such as a touchscreen or tablet. This device type has been added in 3.4. |
GDK_SOURCE_TOUCHPAD | the device is an indirect touch device, such as a touchpad. This device type has been added in 3.4. |

### enum GdkInputMode

An enumeration that describes the mode of an input device.

#### Members

GDK_MODE_DISABLED | the device is disabled and will not report any events. |
GDK_MODE_SCREEN | the device is enabled. The device’s coordinate space maps to the entire screen. |
GDK_MODE_WINDOW | the device is enabled. The device’s coordinate space is mapped to a single window. The manner in which this window is chosen is undefined, but it will typically be the same way in which the focus window for key events is determined. |

### enum GdkAxisUse

An enumeration describing the way in which a device axis (valuator) maps onto the predefined valuator types that GTK+ understands.

#### Members

GDK_AXIS_IGNORE | the axis is ignored. |
GDK_AXIS_X | the axis is used as the x axis. |
GDK_AXIS_Y | the axis is used as the y axis. |
GDK_AXIS_PRESSURE | the axis is used for pressure information. |
GDK_AXIS_XTILT | the axis is used for x tilt information. |
GDK_AXIS_YTILT | the axis is used for y tilt information. |
GDK_AXIS_WHEEL | the axis is used for wheel information. |
GDK_AXIS_LAST | a constant equal to the numerically highest axis value. |

### enum GdkDeviceType

Indicates the device type. See above for more information about the meaning of these device types.

#### Members

GDK_DEVICE_TYPE_MASTER | Device is a master (or virtual) device. There will be an associated focus indicator on the screen. |
GDK_DEVICE_TYPE_SLAVE | Device is a slave (or physical) device. |
GDK_DEVICE_TYPE_FLOATING | Device is a physical device, currently not attached to any virtual device. |

### enum GdkGrabOwnership

Defines how device grabs interact with other devices.

#### Members

GDK_OWNERSHIP_NONE | All other devices’ events are allowed. |
GDK_OWNERSHIP_WINDOW | Other devices’ events are blocked for the grab window. |
GDK_OWNERSHIP_APPLICATION | Other devices’ events are blocked for the whole application. |

### struct GdkTimeCoord

    struct GdkTimeCoord {
      guint32 time;
      gdouble axes[GDK_MAX_TIMECOORD_AXES];
    };

A GdkTimeCoord stores a single event in a motion history.

#### Members

guint32 `time`; | The timestamp for this event. |
gdouble `axes`[GDK_MAX_TIMECOORD_AXES]; | the values of the device’s axes. |

## Property Details

### The `“associated-device”` property

      “associated-device”        GdkDevice *

Associated pointer or keyboard with this device, if any. Devices of type GDK_DEVICE_TYPE_MASTER always come in keyboard/pointer pairs. Other device types will have a `NULL` associated device.

Flags: Read

Since 3.0

### The `“device-manager”` property

      “device-manager”           GdkDeviceManager *

The GdkDeviceManager the GdkDevice pertains to.

Flags: Read / Write / Construct Only

Since 3.0

### The `“display”` property

      “display”                  GdkDisplay *

The GdkDisplay the GdkDevice pertains to.

Flags: Read / Write / Construct Only

Since 3.0

### The `“has-cursor”` property

      “has-cursor”               gboolean

Whether the device is represented by a cursor on the screen. Devices of type `GDK_DEVICE_TYPE_MASTER` will have `TRUE` here.

Flags: Read / Write / Construct Only

Default value: FALSE

Since 3.0

### The `“input-mode”` property

      “input-mode”               GdkInputMode

Input mode for the device.

Flags: Read / Write

Default value: GDK_MODE_DISABLED

Since 3.0

### The `“input-source”` property

      “input-source”             GdkInputSource

Source type for the device.

Flags: Read / Write / Construct Only

Default value: GDK_SOURCE_MOUSE

Since 3.0

### The `“n-axes”` property

      “n-axes”                   guint

Number of axes in the device.

Flags: Read

Default value: 0

Since 3.0

### The `“name”` property

      “name”                     gchar *

The device name.

Flags: Read / Write / Construct Only

Default value: NULL

Since 3.0

### The `“product-id”` property

      “product-id”               gchar *

Product ID of this device, see `gdk_device_get_product_id()`.

Flags: Read / Write / Construct Only

Default value: NULL

Since 3.16

### The `“type”` property

      “type”                     GdkDeviceType

Device role in the device manager.

Flags: Read / Write / Construct Only

Default value: GDK_DEVICE_TYPE_MASTER

Since 3.0

### The `“vendor-id”` property

      “vendor-id”                gchar *

Vendor ID of this device, see `gdk_device_get_vendor_id()`.

Flags: Read / Write / Construct Only

Default value: NULL

Since 3.16

## Signal Details

### The `“changed”` signal

    void
    user_function (GdkDevice *device,
                   gpointer   user_data)

The ::changed signal is emitted either when the GdkDevice has changed the number of either axes or keys. For example In X this will normally happen when the slave device routing events through the master device changes (for example, user switches from the USB mouse to a tablet), in that case the master device will change to reflect the new slave device axes and keys.

#### Parameters

device | the GdkDevice that changed. |
user_data | user data set when the signal handler was connected. |

Flags: Run Last

## See Also

GdkDeviceManager