gi-gdk-3.0.28: Gdk bindings

Copyright | Will Thompson and Iñaki García Etxebarria
License | LGPL-2.1
Maintainer | Iñaki García Etxebarria
Safe Haskell | Safe-Inferred
Language | Haskell2010

GI.Gdk.Objects.Device

Contents

- Exported types
- Methods
  - getAssociatedDevice
  - getAxes
  - getAxisUse
  - getDeviceType
  - getDisplay
  - getHasCursor
  - getKey
  - getLastEventWindow
  - getMode
  - getNAxes
  - getNKeys
  - getName
  - getPosition
  - getPositionDouble
  - getProductId
  - getSeat
  - getSource
  - getVendorId
  - getWindowAtPosition
  - getWindowAtPositionDouble
  - grab
  - grabInfoLibgtkOnly
  - listAxes
  - listSlaveDevices
  - setAxisUse
  - setKey
  - setMode
  - ungrab
  - warp
- Properties
  - associatedDevice
  - axes
  - deviceManager
  - display
  - hasCursor
  - inputMode
  - inputSource
  - nAxes
  - name
  - numTouches
  - productId
  - seat
  - tool
  - type
  - vendorId
- Signals
  - changed
  - toolChanged

Description

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

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

Synopsis

- newtype Device = Device (ManagedPtr Device)
- class (GObject o, IsDescendantOf Device o) => IsDevice o
- toDevice :: (MonadIO m, IsDevice o) => o -> m Device
- deviceGetAssociatedDevice :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Maybe Device)
- deviceGetAxes :: (HasCallStack, MonadIO m, IsDevice a) => a -> m [AxisFlags]
- deviceGetAxisUse :: (HasCallStack, MonadIO m, IsDevice a) => a -> Word32 -> m AxisUse
- deviceGetDeviceType :: (HasCallStack, MonadIO m, IsDevice a) => a -> m DeviceType
- deviceGetDisplay :: (HasCallStack, MonadIO m, IsDevice a) => a -> m Display
- deviceGetHasCursor :: (HasCallStack, MonadIO m, IsDevice a) => a -> m Bool
- deviceGetKey :: (HasCallStack, MonadIO m, IsDevice a) => a -> Word32 -> m (Bool, Word32, [ModifierType])
- deviceGetLastEventWindow :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Maybe Window)
- deviceGetMode :: (HasCallStack, MonadIO m, IsDevice a) => a -> m InputMode
- deviceGetNAxes :: (HasCallStack, MonadIO m, IsDevice a) => a -> m Int32
- deviceGetNKeys :: (HasCallStack, MonadIO m, IsDevice a) => a -> m Int32
- deviceGetName :: (HasCallStack, MonadIO m, IsDevice a) => a -> m Text
- deviceGetPosition :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Screen, Int32, Int32)
- deviceGetPositionDouble :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Screen, Double, Double)
- deviceGetProductId :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Maybe Text)
- deviceGetSeat :: (HasCallStack, MonadIO m, IsDevice a) => a -> m Seat
- deviceGetSource :: (HasCallStack, MonadIO m, IsDevice a) => a -> m InputSource
- deviceGetVendorId :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Maybe Text)
- deviceGetWindowAtPosition :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Maybe Window, Int32, Int32)
- deviceGetWindowAtPositionDouble :: (HasCallStack, MonadIO m, IsDevice a) => a -> m (Maybe Window, Double, Double)
- deviceGrab :: (HasCallStack, MonadIO m, IsDevice a, IsWindow b, IsCursor c) => a -> b -> GrabOwnership -> Bool -> [EventMask] -> Maybe c -> Word32 -> m GrabStatus
- deviceGrabInfoLibgtkOnly :: (HasCallStack, MonadIO m, IsDisplay a, IsDevice b) => a -> b -> m (Bool, Window, Bool)
- deviceListAxes :: (HasCallStack, MonadIO m, IsDevice a) => a -> m [Atom]
- deviceListSlaveDevices :: (HasCallStack, MonadIO m, IsDevice a) => a -> m [Device]
- deviceSetAxisUse :: (HasCallStack, MonadIO m, IsDevice a) => a -> Word32 -> AxisUse -> m ()
- deviceSetKey :: (HasCallStack, MonadIO m, IsDevice a) => a -> Word32 -> Word32 -> [ModifierType] -> m ()
- deviceSetMode :: (HasCallStack, MonadIO m, IsDevice a) => a -> InputMode -> m Bool
- deviceUngrab :: (HasCallStack, MonadIO m, IsDevice a) => a -> Word32 -> m ()
- deviceWarp :: (HasCallStack, MonadIO m, IsDevice a, IsScreen b) => a -> b -> Int32 -> Int32 -> m ()
- getDeviceAssociatedDevice :: (MonadIO m, IsDevice o) => o -> m (Maybe Device)
- getDeviceAxes :: (MonadIO m, IsDevice o) => o -> m [AxisFlags]
- constructDeviceDeviceManager :: (IsDevice o, MonadIO m, IsDeviceManager a) => a -> m (GValueConstruct o)
- getDeviceDeviceManager :: (MonadIO m, IsDevice o) => o -> m (Maybe DeviceManager)
- constructDeviceDisplay :: (IsDevice o, MonadIO m, IsDisplay a) => a -> m (GValueConstruct o)
- getDeviceDisplay :: (MonadIO m, IsDevice o) => o -> m Display
- constructDeviceHasCursor :: (IsDevice o, MonadIO m) => Bool -> m (GValueConstruct o)
- getDeviceHasCursor :: (MonadIO m, IsDevice o) => o -> m Bool
- constructDeviceInputMode :: (IsDevice o, MonadIO m) => InputMode -> m (GValueConstruct o)
- getDeviceInputMode :: (MonadIO m, IsDevice o) => o -> m InputMode
- setDeviceInputMode :: (MonadIO m, IsDevice o) => o -> InputMode -> m ()
- constructDeviceInputSource :: (IsDevice o, MonadIO m) => InputSource -> m (GValueConstruct o)
- getDeviceInputSource :: (MonadIO m, IsDevice o) => o -> m InputSource
- getDeviceNAxes :: (MonadIO m, IsDevice o) => o -> m Word32
- constructDeviceName :: (IsDevice o, MonadIO m) => Text -> m (GValueConstruct o)
- getDeviceName :: (MonadIO m, IsDevice o) => o -> m Text
- constructDeviceNumTouches :: (IsDevice o, MonadIO m) => Word32 -> m (GValueConstruct o)
- getDeviceNumTouches :: (MonadIO m, IsDevice o) => o -> m Word32
- constructDeviceProductId :: (IsDevice o, MonadIO m) => Text -> m (GValueConstruct o)
- getDeviceProductId :: (MonadIO m, IsDevice o) => o -> m (Maybe Text)
- clearDeviceSeat :: (MonadIO m, IsDevice o) => o -> m ()
- constructDeviceSeat :: (IsDevice o, MonadIO m, IsSeat a) => a -> m (GValueConstruct o)
- getDeviceSeat :: (MonadIO m, IsDevice o) => o -> m Seat
- setDeviceSeat :: (MonadIO m, IsDevice o, IsSeat a) => o -> a -> m ()
- getDeviceTool :: (MonadIO m, IsDevice o) => o -> m (Maybe DeviceTool)
- constructDeviceType :: (IsDevice o, MonadIO m) => DeviceType -> m (GValueConstruct o)
- getDeviceType :: (MonadIO m, IsDevice o) => o -> m DeviceType
- constructDeviceVendorId :: (IsDevice o, MonadIO m) => Text -> m (GValueConstruct o)
- getDeviceVendorId :: (MonadIO m, IsDevice o) => o -> m (Maybe Text)
- type DeviceChangedCallback = IO ()
- afterDeviceChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceChangedCallback) -> m SignalHandlerId
- onDeviceChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceChangedCallback) -> m SignalHandlerId
- type DeviceToolChangedCallback = DeviceTool -> IO ()
- afterDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceToolChangedCallback) -> m SignalHandlerId
- onDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceToolChangedCallback) -> m SignalHandlerId

# Exported types

newtype Device Source #

Memory-managed wrapper type.

Constructors

Device (ManagedPtr Device) |

#### Instances

Instances details

Eq Device Source # |
Instance details Defined in GI.Gdk.Objects.Device Methods (==) :: Device -> Device -> Bool Source # (/=) :: Device -> Device -> Bool Source #
GObject Device Source # |
Instance details Defined in GI.Gdk.Objects.Device
ManagedPtrNewtype Device Source # |
Instance details Defined in GI.Gdk.Objects.Device Methods toManagedPtr :: Device -> ManagedPtr Device Source #
TypedObject Device Source # |
Instance details Defined in GI.Gdk.Objects.Device Methods glibType :: IO GType Source #
HasParentTypes Device Source # |
Instance details Defined in GI.Gdk.Objects.Device
IsGValue (Maybe Device) Source # | Convert `Device` to and from `GValue`. See `toGValue` and `fromGValue`.
Instance details Defined in GI.Gdk.Objects.Device Methods gvalueGType_ :: IO GType Source # gvalueSet_ :: Ptr GValue -> Maybe Device -> IO () Source # gvalueGet_ :: Ptr GValue -> IO (Maybe Device) Source #
type ParentTypes Device Source # |
Instance details Defined in GI.Gdk.Objects.Device type ParentTypes Device = '[Object]

class (GObject o, IsDescendantOf Device o) => IsDevice o Source #

Type class for types which can be safely cast to `Device`, for instance with `toDevice`.

#### Instances

Instances details

(GObject o, IsDescendantOf Device o) => IsDevice o Source # |
Instance details Defined in GI.Gdk.Objects.Device

toDevice :: (MonadIO m, IsDevice o) => o -> m Device Source #

Cast to `Device`, for types for which this is known to be safe. For general casts, use `castTo`.

# Methods

### Click to display all available methods, including inherited ones

Expand

#### Methods

bindProperty, bindPropertyFull, forceFloating, freezeNotify, getv, grab, isFloating, listAxes, listSlaveDevices, notify, notifyByPspec, ref, refSink, runDispose, stealData, stealQdata, thawNotify, ungrab, unref, warp, watchClosure.

#### Getters

getAssociatedDevice, getAxes, getAxisUse, getData, getDeviceType, getDisplay, getHasCursor, getKey, getLastEventWindow, getMode, getNAxes, getNKeys, getName, getPosition, getPositionDouble, getProductId, getProperty, getQdata, getSeat, getSource, getVendorId, getWindowAtPosition, getWindowAtPositionDouble.

#### Setters

setAxisUse, setData, setDataFull, setKey, setMode, setProperty.

## getAssociatedDevice

deviceGetAssociatedDevice Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m (Maybe Device) | Returns: The associated device, or `Nothing`

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

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

If `device` is of type `DeviceTypeFloating`, `Nothing` will be returned, as there is no associated device.

Since: 3.0

## getAxes

deviceGetAxes Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m [AxisFlags] |

Returns the axes currently available on the device.

Since: 3.22

## getAxisUse

deviceGetAxisUse Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a pointer `Device`.
-> Word32 | `index_`: the index of the axis.
-> m AxisUse | Returns: a `AxisUse` specifying how the axis is used.

Returns the axis use for `index_`.

Since: 2.20

## getDeviceType

deviceGetDeviceType Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m DeviceType | Returns: the `DeviceType` for `device`.

Returns the device type for `device`.

Since: 3.0

## getDisplay

deviceGetDisplay Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m Display | Returns: a `Display`. This memory is owned by GTK+, and must not be freed or unreffed.

Returns the `Display` to which `device` pertains.

Since: 3.0

## getHasCursor

deviceGetHasCursor Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m Bool | Returns: `True` if the pointer follows device motion

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

Since: 2.20

## getKey

deviceGetKey Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`.
-> Word32 | `index_`: the index of the macro button to get.
-> m (Bool, Word32, [ModifierType]) | Returns: `True` if keyval is set for `index`.

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

Since: 2.20

## getLastEventWindow

deviceGetLastEventWindow Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`, with a source other than `InputSourceKeyboard`
-> m (Maybe Window) | Returns: the last window the 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`, `Nothing` may be returned even if the pointer is physically over one of this application's windows.

Since: 3.12

## getMode

deviceGetMode Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m InputMode | Returns: a `InputSource`

Determines the mode of the device.

Since: 2.20

## getNAxes

deviceGetNAxes Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a pointer `Device`
-> m Int32 | Returns: the number of axes.

Returns the number of axes the device currently has.

Since: 3.0

## getNKeys

deviceGetNKeys Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m Int32 | Returns: the number of keys.

Returns the number of keys the device currently has.

Since: 2.24

## getName

deviceGetName Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m Text | Returns: a name

Determines the name of the device.

Since: 2.20

## getPosition

deviceGetPosition Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: pointer device to query status about.
-> m (Screen, Int32, Int32) |

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 `DeviceTypeSlave`, unless there is an ongoing grab on them, see `deviceGrab`.

Since: 3.0

## getPositionDouble

deviceGetPositionDouble Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: pointer device to query status about.
-> m (Screen, Double, Double) |

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 `DeviceTypeSlave`, unless there is an ongoing grab on them. See `deviceGrab`.

Since: 3.10

## getProductId

deviceGetProductId Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a slave `Device`
-> m (Maybe Text) | Returns: the product ID, or `Nothing`

Returns the product ID of this device, or `Nothing` if this information couldn't be obtained. This ID is retrieved from the device, and is thus constant for it. See `deviceGetVendorId` for more information.

Since: 3.16

## getSeat

deviceGetSeat Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: A `Device`
-> m Seat | Returns: A `Seat`. This memory is owned by GTK+ and must not be freed.

Returns the `Seat` the device belongs to.

Since: 3.20

## getSource

deviceGetSource Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m InputSource | Returns: a `InputSource`

Determines the type of the device.

Since: 2.20

## getVendorId

deviceGetVendorId Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a slave `Device`
-> m (Maybe Text) | Returns: the vendor ID, or `Nothing`

Returns the vendor ID of this device, or `Nothing` if this information couldn't be obtained. This ID is retrieved from the device, and is thus constant for it.

This function, together with `deviceGetProductId`, can be used to eg. compose `Settings` paths to store settings for this device.

### C code

    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;
    }

Since: 3.16

## getWindowAtPosition

deviceGetWindowAtPosition Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: pointer `Device` to query info to.
-> m (Maybe Window, Int32, Int32) | Returns: the `Window` under the device position, or `Nothing`.

Obtains the window underneath `device`, returning the location of the device in `winX` and `winY`. Returns `Nothing` 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 `DeviceTypeSlave`, unless there is an ongoing grab on them, see `deviceGrab`.

Since: 3.0

## getWindowAtPositionDouble

deviceGetWindowAtPositionDouble Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: pointer `Device` to query info to.
-> m (Maybe Window, Double, Double) | Returns: the `Window` under the device position, or `Nothing`.

Obtains the window underneath `device`, returning the location of the device in `winX` and `winY` in double precision. Returns `Nothing` 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 `DeviceTypeSlave`, unless there is an ongoing grab on them, see `deviceGrab`.

Since: 3.0

## grab

deviceGrab Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a, IsWindow b, IsCursor c) |
=> a | `device`: a `Device`. To get the device you can use `gtk_get_current_event_device()` or `eventGetDevice` if the grab is in reaction to an event. Also, you can use `deviceManagerGetClientPointer` but only in code that isn’t triggered by a `Event` and there aren’t other means to get a meaningful `Device` to operate on.
-> b | `window`: the `Window` which will own the grab (the grab window)
-> GrabOwnership | `grabOwnership`: specifies the grab ownership.
-> Bool | `ownerEvents`: if `False` then all device events are reported with respect to `window` and are only reported if selected by `eventMask`. 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 `eventMask`. In either mode, unreported events are discarded.
-> [EventMask] | `eventMask`: specifies the event mask, which is used in accordance with `ownerEvents`.
-> Maybe c | `cursor`: the cursor to display while the grab is active if the device is a pointer. If this is `Nothing` then the normal cursors are used for `window` and its descendants, and the cursor for `window` is used elsewhere.
-> Word32 | `time_`: the timestamp of the event which led to this pointer grab. This usually comes from the `Event` struct, though `CURRENT_TIME` can be used if the time isn’t known.
-> m GrabStatus | Returns: `GrabStatusSuccess` if the grab was successful.

Deprecated: (Since version 3.20.)Use `seatGrab` instead.

Grabs the device so that all events coming from this device are passed to this application until the device is ungrabbed with `deviceUngrab`, 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 `ownerEvents` 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 `EventGrabBroken` events that are emitted when the grab ends unvoluntarily.

Since: 3.0

## grabInfoLibgtkOnly

deviceGrabInfoLibgtkOnly Source #

Arguments

:: (HasCallStack, MonadIO m, IsDisplay a, IsDevice b) |
=> a | `display`: the display for which to get the grab information
-> b | `device`: device to get the grab information from
-> m (Bool, Window, Bool) | Returns: `True` if this application currently has the keyboard grabbed.

Deprecated: (Since version 3.16)The symbol was never meant to be used outside of GTK+

Determines information about the current keyboard grab. This is not public API and must not be used by applications.

## listAxes

deviceListAxes Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a pointer `Device`
-> m [Atom] | Returns: A `List` of `GdkAtoms`, free with `g_list_free()`.

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

Since: 3.0

## listSlaveDevices

deviceListSlaveDevices Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> m [Device] | Returns: the list of slave devices, or `Nothing`. The list must be freed with `g_list_free()`, the contents of the list are owned by GTK+ and should not be freed.

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

## setAxisUse

deviceSetAxisUse Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a pointer `Device`
-> Word32 | `index_`: the index of the axis
-> AxisUse | `use`: specifies how the axis is used
-> m () |

Specifies how an axis of a device is used.

## setKey

deviceSetKey Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> Word32 | `index_`: the index of the macro button to set
-> Word32 | `keyval`: the keyval to generate
-> [ModifierType] | `modifiers`: the modifiers to set
-> m () |

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

## setMode

deviceSetMode Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`.
-> InputMode | `mode`: the input mode.
-> m Bool | Returns: `True` if the mode was successfully changed.

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.

## ungrab

deviceUngrab Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a) |
=> a | `device`: a `Device`
-> Word32 | `time_`: a timestap (e.g. `CURRENT_TIME`).
-> m () |

Deprecated: (Since version 3.20.)Use `seatUngrab` instead.

Release any grab on `device`.

Since: 3.0

## warp

deviceWarp Source #

Arguments

:: (HasCallStack, MonadIO m, IsDevice a, IsScreen b) |
=> a | `device`: the device to warp.
-> b | `screen`: the screen to warp `device` to.
-> Int32 | `x`: the X coordinate of the destination.
-> Int32 | `y`: the Y coordinate of the destination.
-> m () |

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`.

Since: 3.0

# Properties

## associatedDevice

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 `Nothing` associated device.

Since: 3.0

getDeviceAssociatedDevice :: (MonadIO m, IsDevice o) => o -> m (Maybe Device) Source #

Get the value of the “`associated-device`” property. When overloading is enabled, this is equivalent to

    get device #associatedDevice

## axes

The axes currently available for this device.

Since: 3.22

getDeviceAxes :: (MonadIO m, IsDevice o) => o -> m [AxisFlags] Source #

Get the value of the “`axes`” property. When overloading is enabled, this is equivalent to

    get device #axes

## deviceManager

The `DeviceManager` the `Device` pertains to.

Since: 3.0

constructDeviceDeviceManager :: (IsDevice o, MonadIO m, IsDeviceManager a) => a -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`device-manager`” property. This is rarely needed directly, but it is used by `new`.

getDeviceDeviceManager :: (MonadIO m, IsDevice o) => o -> m (Maybe DeviceManager) Source #

Get the value of the “`device-manager`” property. When overloading is enabled, this is equivalent to

    get device #deviceManager

## display

The `Display` the `Device` pertains to.

Since: 3.0

constructDeviceDisplay :: (IsDevice o, MonadIO m, IsDisplay a) => a -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`display`” property. This is rarely needed directly, but it is used by `new`.

getDeviceDisplay :: (MonadIO m, IsDevice o) => o -> m Display Source #

Get the value of the “`display`” property. When overloading is enabled, this is equivalent to

    get device #display

## hasCursor

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

Since: 3.0

constructDeviceHasCursor :: (IsDevice o, MonadIO m) => Bool -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`has-cursor`” property. This is rarely needed directly, but it is used by `new`.

getDeviceHasCursor :: (MonadIO m, IsDevice o) => o -> m Bool Source #

Get the value of the “`has-cursor`” property. When overloading is enabled, this is equivalent to

    get device #hasCursor

## inputMode

No description available in the introspection data.

constructDeviceInputMode :: (IsDevice o, MonadIO m) => InputMode -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`input-mode`” property. This is rarely needed directly, but it is used by `new`.

getDeviceInputMode :: (MonadIO m, IsDevice o) => o -> m InputMode Source #

Get the value of the “`input-mode`” property. When overloading is enabled, this is equivalent to

    get device #inputMode

setDeviceInputMode :: (MonadIO m, IsDevice o) => o -> InputMode -> m () Source #

Set the value of the “`input-mode`” property. When overloading is enabled, this is equivalent to

    set device [ #inputMode := value ]

## inputSource

Source type for the device.

Since: 3.0

constructDeviceInputSource :: (IsDevice o, MonadIO m) => InputSource -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`input-source`” property. This is rarely needed directly, but it is used by `new`.

getDeviceInputSource :: (MonadIO m, IsDevice o) => o -> m InputSource Source #

Get the value of the “`input-source`” property. When overloading is enabled, this is equivalent to

    get device #inputSource

## nAxes

Number of axes in the device.

Since: 3.0

getDeviceNAxes :: (MonadIO m, IsDevice o) => o -> m Word32 Source #

Get the value of the “`n-axes`” property. When overloading is enabled, this is equivalent to

    get device #nAxes

## name

The device name.

Since: 3.0

constructDeviceName :: (IsDevice o, MonadIO m) => Text -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`name`” property. This is rarely needed directly, but it is used by `new`.

getDeviceName :: (MonadIO m, IsDevice o) => o -> m Text Source #

Get the value of the “`name`” property. When overloading is enabled, this is equivalent to

    get device #name

## numTouches

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.

Since: 3.20

constructDeviceNumTouches :: (IsDevice o, MonadIO m) => Word32 -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`num-touches`” property. This is rarely needed directly, but it is used by `new`.

getDeviceNumTouches :: (MonadIO m, IsDevice o) => o -> m Word32 Source #

Get the value of the “`num-touches`” property. When overloading is enabled, this is equivalent to

    get device #numTouches

## productId

Product ID of this device, see `deviceGetProductId`.

Since: 3.16

constructDeviceProductId :: (IsDevice o, MonadIO m) => Text -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`product-id`” property. This is rarely needed directly, but it is used by `new`.

getDeviceProductId :: (MonadIO m, IsDevice o) => o -> m (Maybe Text) Source #

Get the value of the “`product-id`” property. When overloading is enabled, this is equivalent to

    get device #productId

## seat

`Seat` of this device.

Since: 3.20

clearDeviceSeat :: (MonadIO m, IsDevice o) => o -> m () Source #

Set the value of the “`seat`” property to `Nothing`. When overloading is enabled, this is equivalent to

    clear #seat

constructDeviceSeat :: (IsDevice o, MonadIO m, IsSeat a) => a -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`seat`” property. This is rarely needed directly, but it is used by `new`.

getDeviceSeat :: (MonadIO m, IsDevice o) => o -> m Seat Source #

Get the value of the “`seat`” property. When overloading is enabled, this is equivalent to

    get device #seat

setDeviceSeat :: (MonadIO m, IsDevice o, IsSeat a) => o -> a -> m () Source #

Set the value of the “`seat`” property. When overloading is enabled, this is equivalent to

    set device [ #seat := value ]

## tool

No description available in the introspection data.

getDeviceTool :: (MonadIO m, IsDevice o) => o -> m (Maybe DeviceTool) Source #

Get the value of the “`tool`” property. When overloading is enabled, this is equivalent to

    get device #tool

## type

Device role in the device manager.

Since: 3.0

constructDeviceType :: (IsDevice o, MonadIO m) => DeviceType -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`type`” property. This is rarely needed directly, but it is used by `new`.

getDeviceType :: (MonadIO m, IsDevice o) => o -> m DeviceType Source #

Get the value of the “`type`” property. When overloading is enabled, this is equivalent to

    get device #type

## vendorId

Vendor ID of this device, see `deviceGetVendorId`.

Since: 3.16

constructDeviceVendorId :: (IsDevice o, MonadIO m) => Text -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`vendor-id`” property. This is rarely needed directly, but it is used by `new`.

getDeviceVendorId :: (MonadIO m, IsDevice o) => o -> m (Maybe Text) Source #

Get the value of the “`vendor-id`” property. When overloading is enabled, this is equivalent to

    get device #vendorId

# Signals

## changed

type DeviceChangedCallback = IO () Source #

The changed signal is emitted either when the `Device` 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.

afterDeviceChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceChangedCallback) -> m SignalHandlerId Source #

Connect a signal handler for the changed signal, to be run after the default handler. When overloading is enabled, this is equivalent to

    after device #changed callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit `?self` parameter. Note that this requires activating the `ImplicitParams` GHC extension.

onDeviceChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceChangedCallback) -> m SignalHandlerId Source #

Connect a signal handler for the changed signal, to be run before the default handler. When overloading is enabled, this is equivalent to

    on device #changed callback

## toolChanged

type DeviceToolChangedCallback Source #

Arguments

= DeviceTool | `tool`: The new current tool
-> IO () |

The toolChanged signal is emitted on pen/eraser `GdkDevices` whenever tools enter or leave proximity.

Since: 3.22

afterDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceToolChangedCallback) -> m SignalHandlerId Source #

Connect a signal handler for the toolChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

    after device #toolChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit `?self` parameter. Note that this requires activating the `ImplicitParams` GHC extension.

onDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceToolChangedCallback) -> m SignalHandlerId Source #

Connect a signal handler for the toolChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to

    on device #toolChanged callback