{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

The 'GI.Gdk.Objects.Device.Device' object represents a single input device, such
as a keyboard, a mouse, a touchpad, etc.

See the 'GI.Gdk.Objects.DeviceManager.DeviceManager' documentation for more information
about the various kinds of master and slave devices, and their
relationships.
-}

module GI.Gdk.Objects.Device
    ( 

-- * Exported types
    Device(..)                              ,
    IsDevice                                ,
    toDevice                                ,
    noDevice                                ,


 -- * Methods
-- ** getAssociatedDevice #method:getAssociatedDevice#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetAssociatedDeviceMethodInfo     ,
#endif
    deviceGetAssociatedDevice               ,


-- ** getAxes #method:getAxes#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetAxesMethodInfo                 ,
#endif
    deviceGetAxes                           ,


-- ** getAxisUse #method:getAxisUse#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetAxisUseMethodInfo              ,
#endif
    deviceGetAxisUse                        ,


-- ** getDeviceType #method:getDeviceType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetDeviceTypeMethodInfo           ,
#endif
    deviceGetDeviceType                     ,


-- ** getDisplay #method:getDisplay#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetDisplayMethodInfo              ,
#endif
    deviceGetDisplay                        ,


-- ** getHasCursor #method:getHasCursor#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetHasCursorMethodInfo            ,
#endif
    deviceGetHasCursor                      ,


-- ** getKey #method:getKey#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetKeyMethodInfo                  ,
#endif
    deviceGetKey                            ,


-- ** getLastEventWindow #method:getLastEventWindow#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetLastEventWindowMethodInfo      ,
#endif
    deviceGetLastEventWindow                ,


-- ** getMode #method:getMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetModeMethodInfo                 ,
#endif
    deviceGetMode                           ,


-- ** getNAxes #method:getNAxes#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetNAxesMethodInfo                ,
#endif
    deviceGetNAxes                          ,


-- ** getNKeys #method:getNKeys#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetNKeysMethodInfo                ,
#endif
    deviceGetNKeys                          ,


-- ** getName #method:getName#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetNameMethodInfo                 ,
#endif
    deviceGetName                           ,


-- ** getPosition #method:getPosition#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetPositionMethodInfo             ,
#endif
    deviceGetPosition                       ,


-- ** getPositionDouble #method:getPositionDouble#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetPositionDoubleMethodInfo       ,
#endif
    deviceGetPositionDouble                 ,


-- ** getProductId #method:getProductId#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetProductIdMethodInfo            ,
#endif
    deviceGetProductId                      ,


-- ** getSeat #method:getSeat#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetSeatMethodInfo                 ,
#endif
    deviceGetSeat                           ,


-- ** getSource #method:getSource#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetSourceMethodInfo               ,
#endif
    deviceGetSource                         ,


-- ** getVendorId #method:getVendorId#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetVendorIdMethodInfo             ,
#endif
    deviceGetVendorId                       ,


-- ** getWindowAtPosition #method:getWindowAtPosition#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetWindowAtPositionMethodInfo     ,
#endif
    deviceGetWindowAtPosition               ,


-- ** getWindowAtPositionDouble #method:getWindowAtPositionDouble#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGetWindowAtPositionDoubleMethodInfo,
#endif
    deviceGetWindowAtPositionDouble         ,


-- ** grab #method:grab#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceGrabMethodInfo                    ,
#endif
    deviceGrab                              ,


-- ** grabInfoLibgtkOnly #method:grabInfoLibgtkOnly#
    deviceGrabInfoLibgtkOnly                ,


-- ** listAxes #method:listAxes#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceListAxesMethodInfo                ,
#endif
    deviceListAxes                          ,


-- ** listSlaveDevices #method:listSlaveDevices#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceListSlaveDevicesMethodInfo        ,
#endif
    deviceListSlaveDevices                  ,


-- ** setAxisUse #method:setAxisUse#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceSetAxisUseMethodInfo              ,
#endif
    deviceSetAxisUse                        ,


-- ** setKey #method:setKey#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceSetKeyMethodInfo                  ,
#endif
    deviceSetKey                            ,


-- ** setMode #method:setMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceSetModeMethodInfo                 ,
#endif
    deviceSetMode                           ,


-- ** ungrab #method:ungrab#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceUngrabMethodInfo                  ,
#endif
    deviceUngrab                            ,


-- ** warp #method:warp#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceWarpMethodInfo                    ,
#endif
    deviceWarp                              ,




 -- * Properties
-- ** associatedDevice #attr:associatedDevice#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceAssociatedDevicePropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceAssociatedDevice                  ,
#endif
    getDeviceAssociatedDevice               ,


-- ** axes #attr:axes#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceAxesPropertyInfo                  ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceAxes                              ,
#endif
    getDeviceAxes                           ,


-- ** deviceManager #attr:deviceManager#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceDeviceManagerPropertyInfo         ,
#endif
    constructDeviceDeviceManager            ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceDeviceManager                     ,
#endif
    getDeviceDeviceManager                  ,


-- ** display #attr:display#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceDisplayPropertyInfo               ,
#endif
    constructDeviceDisplay                  ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceDisplay                           ,
#endif
    getDeviceDisplay                        ,


-- ** hasCursor #attr:hasCursor#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceHasCursorPropertyInfo             ,
#endif
    constructDeviceHasCursor                ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceHasCursor                         ,
#endif
    getDeviceHasCursor                      ,


-- ** inputMode #attr:inputMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceInputModePropertyInfo             ,
#endif
    constructDeviceInputMode                ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceInputMode                         ,
#endif
    getDeviceInputMode                      ,
    setDeviceInputMode                      ,


-- ** inputSource #attr:inputSource#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceInputSourcePropertyInfo           ,
#endif
    constructDeviceInputSource              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceInputSource                       ,
#endif
    getDeviceInputSource                    ,


-- ** nAxes #attr:nAxes#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceNAxesPropertyInfo                 ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceNAxes                             ,
#endif
    getDeviceNAxes                          ,


-- ** name #attr:name#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceNamePropertyInfo                  ,
#endif
    constructDeviceName                     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceName                              ,
#endif
    getDeviceName                           ,


-- ** numTouches #attr:numTouches#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceNumTouchesPropertyInfo            ,
#endif
    constructDeviceNumTouches               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceNumTouches                        ,
#endif
    getDeviceNumTouches                     ,


-- ** productId #attr:productId#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceProductIdPropertyInfo             ,
#endif
    constructDeviceProductId                ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceProductId                         ,
#endif
    getDeviceProductId                      ,


-- ** seat #attr:seat#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceSeatPropertyInfo                  ,
#endif
    clearDeviceSeat                         ,
    constructDeviceSeat                     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceSeat                              ,
#endif
    getDeviceSeat                           ,
    setDeviceSeat                           ,


-- ** tool #attr:tool#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceToolPropertyInfo                  ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceTool                              ,
#endif
    getDeviceTool                           ,


-- ** type #attr:type#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceTypePropertyInfo                  ,
#endif
    constructDeviceType                     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceType                              ,
#endif
    getDeviceType                           ,


-- ** vendorId #attr:vendorId#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceVendorIdPropertyInfo              ,
#endif
    constructDeviceVendorId                 ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    deviceVendorId                          ,
#endif
    getDeviceVendorId                       ,




 -- * Signals
-- ** changed #signal:changed#
    C_DeviceChangedCallback                 ,
    DeviceChangedCallback                   ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceChangedSignalInfo                 ,
#endif
    afterDeviceChanged                      ,
    genClosure_DeviceChanged                ,
    mk_DeviceChangedCallback                ,
    noDeviceChangedCallback                 ,
    onDeviceChanged                         ,
    wrap_DeviceChangedCallback              ,


-- ** toolChanged #signal:toolChanged#
    C_DeviceToolChangedCallback             ,
    DeviceToolChangedCallback               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DeviceToolChangedSignalInfo             ,
#endif
    afterDeviceToolChanged                  ,
    genClosure_DeviceToolChanged            ,
    mk_DeviceToolChangedCallback            ,
    noDeviceToolChangedCallback             ,
    onDeviceToolChanged                     ,
    wrap_DeviceToolChangedCallback          ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceManager as Gdk.DeviceManager
import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceTool as Gdk.DeviceTool
import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
import {-# SOURCE #-} qualified GI.Gdk.Objects.Screen as Gdk.Screen
import {-# SOURCE #-} qualified GI.Gdk.Objects.Seat as Gdk.Seat
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
import {-# SOURCE #-} qualified GI.Gdk.Structs.Atom as Gdk.Atom

newtype Device = Device (ManagedPtr Device)
foreign import ccall "gdk_device_get_type"
    c_gdk_device_get_type :: IO GType

instance GObject Device where
    gobjectType _ = c_gdk_device_get_type
    

class GObject o => IsDevice o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Device a) =>
    IsDevice a
#endif
instance IsDevice Device
instance GObject.Object.IsObject Device

toDevice :: (MonadIO m, IsDevice o) => o -> m Device
toDevice = liftIO . unsafeCastTo Device

noDevice :: Maybe Device
noDevice = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveDeviceMethod (t :: Symbol) (o :: *) :: * where
    ResolveDeviceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDeviceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDeviceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDeviceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDeviceMethod "grab" o = DeviceGrabMethodInfo
    ResolveDeviceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDeviceMethod "listAxes" o = DeviceListAxesMethodInfo
    ResolveDeviceMethod "listSlaveDevices" o = DeviceListSlaveDevicesMethodInfo
    ResolveDeviceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDeviceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDeviceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDeviceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDeviceMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDeviceMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDeviceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDeviceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDeviceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDeviceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDeviceMethod "ungrab" o = DeviceUngrabMethodInfo
    ResolveDeviceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDeviceMethod "warp" o = DeviceWarpMethodInfo
    ResolveDeviceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDeviceMethod "getAssociatedDevice" o = DeviceGetAssociatedDeviceMethodInfo
    ResolveDeviceMethod "getAxes" o = DeviceGetAxesMethodInfo
    ResolveDeviceMethod "getAxisUse" o = DeviceGetAxisUseMethodInfo
    ResolveDeviceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDeviceMethod "getDeviceType" o = DeviceGetDeviceTypeMethodInfo
    ResolveDeviceMethod "getDisplay" o = DeviceGetDisplayMethodInfo
    ResolveDeviceMethod "getHasCursor" o = DeviceGetHasCursorMethodInfo
    ResolveDeviceMethod "getKey" o = DeviceGetKeyMethodInfo
    ResolveDeviceMethod "getLastEventWindow" o = DeviceGetLastEventWindowMethodInfo
    ResolveDeviceMethod "getMode" o = DeviceGetModeMethodInfo
    ResolveDeviceMethod "getNAxes" o = DeviceGetNAxesMethodInfo
    ResolveDeviceMethod "getNKeys" o = DeviceGetNKeysMethodInfo
    ResolveDeviceMethod "getName" o = DeviceGetNameMethodInfo
    ResolveDeviceMethod "getPosition" o = DeviceGetPositionMethodInfo
    ResolveDeviceMethod "getPositionDouble" o = DeviceGetPositionDoubleMethodInfo
    ResolveDeviceMethod "getProductId" o = DeviceGetProductIdMethodInfo
    ResolveDeviceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDeviceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDeviceMethod "getSeat" o = DeviceGetSeatMethodInfo
    ResolveDeviceMethod "getSource" o = DeviceGetSourceMethodInfo
    ResolveDeviceMethod "getVendorId" o = DeviceGetVendorIdMethodInfo
    ResolveDeviceMethod "getWindowAtPosition" o = DeviceGetWindowAtPositionMethodInfo
    ResolveDeviceMethod "getWindowAtPositionDouble" o = DeviceGetWindowAtPositionDoubleMethodInfo
    ResolveDeviceMethod "setAxisUse" o = DeviceSetAxisUseMethodInfo
    ResolveDeviceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDeviceMethod "setKey" o = DeviceSetKeyMethodInfo
    ResolveDeviceMethod "setMode" o = DeviceSetModeMethodInfo
    ResolveDeviceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDeviceMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDeviceMethod t Device, O.MethodInfo info Device p) => O.IsLabelProxy t (Device -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDeviceMethod t Device, O.MethodInfo info Device p) => O.IsLabel t (Device -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal Device::changed
type DeviceChangedCallback =
    IO ()

noDeviceChangedCallback :: Maybe DeviceChangedCallback
noDeviceChangedCallback = Nothing

type C_DeviceChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_DeviceChangedCallback :: C_DeviceChangedCallback -> IO (FunPtr C_DeviceChangedCallback)

genClosure_DeviceChanged :: DeviceChangedCallback -> IO Closure
genClosure_DeviceChanged cb = do
    let cb' = wrap_DeviceChangedCallback cb
    mk_DeviceChangedCallback cb' >>= newCClosure


wrap_DeviceChangedCallback ::
    DeviceChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_DeviceChangedCallback _cb _ _ = do
    _cb 


onDeviceChanged :: (IsDevice a, MonadIO m) => a -> DeviceChangedCallback -> m SignalHandlerId
onDeviceChanged obj cb = liftIO $ do
    let cb' = wrap_DeviceChangedCallback cb
    cb'' <- mk_DeviceChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectBefore

afterDeviceChanged :: (IsDevice a, MonadIO m) => a -> DeviceChangedCallback -> m SignalHandlerId
afterDeviceChanged obj cb = liftIO $ do
    let cb' = wrap_DeviceChangedCallback cb
    cb'' <- mk_DeviceChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectAfter


-- signal Device::tool-changed
type DeviceToolChangedCallback =
    Gdk.DeviceTool.DeviceTool ->
    IO ()

noDeviceToolChangedCallback :: Maybe DeviceToolChangedCallback
noDeviceToolChangedCallback = Nothing

type C_DeviceToolChangedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DeviceTool.DeviceTool ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_DeviceToolChangedCallback :: C_DeviceToolChangedCallback -> IO (FunPtr C_DeviceToolChangedCallback)

genClosure_DeviceToolChanged :: DeviceToolChangedCallback -> IO Closure
genClosure_DeviceToolChanged cb = do
    let cb' = wrap_DeviceToolChangedCallback cb
    mk_DeviceToolChangedCallback cb' >>= newCClosure


wrap_DeviceToolChangedCallback ::
    DeviceToolChangedCallback ->
    Ptr () ->
    Ptr Gdk.DeviceTool.DeviceTool ->
    Ptr () ->
    IO ()
wrap_DeviceToolChangedCallback _cb _ tool _ = do
    tool' <- (newObject Gdk.DeviceTool.DeviceTool) tool
    _cb  tool'


onDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> DeviceToolChangedCallback -> m SignalHandlerId
onDeviceToolChanged obj cb = liftIO $ do
    let cb' = wrap_DeviceToolChangedCallback cb
    cb'' <- mk_DeviceToolChangedCallback cb'
    connectSignalFunPtr obj "tool-changed" cb'' SignalConnectBefore

afterDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> DeviceToolChangedCallback -> m SignalHandlerId
afterDeviceToolChanged obj cb = liftIO $ do
    let cb' = wrap_DeviceToolChangedCallback cb
    cb'' <- mk_DeviceToolChangedCallback cb'
    connectSignalFunPtr obj "tool-changed" cb'' SignalConnectAfter


-- VVV Prop "associated-device"
   -- Type: TInterface (Name {namespace = "Gdk", name = "Device"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

getDeviceAssociatedDevice :: (MonadIO m, IsDevice o) => o -> m (Maybe Device)
getDeviceAssociatedDevice obj = liftIO $ getObjectPropertyObject obj "associated-device" Device

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceAssociatedDevicePropertyInfo
instance AttrInfo DeviceAssociatedDevicePropertyInfo where
    type AttrAllowedOps DeviceAssociatedDevicePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceAssociatedDevicePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DeviceAssociatedDevicePropertyInfo = IsDevice
    type AttrGetType DeviceAssociatedDevicePropertyInfo = (Maybe Device)
    type AttrLabel DeviceAssociatedDevicePropertyInfo = "associated-device"
    type AttrOrigin DeviceAssociatedDevicePropertyInfo = Device
    attrGet _ = getDeviceAssociatedDevice
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "axes"
   -- Type: TInterface (Name {namespace = "Gdk", name = "AxisFlags"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDeviceAxes :: (MonadIO m, IsDevice o) => o -> m [Gdk.Flags.AxisFlags]
getDeviceAxes obj = liftIO $ getObjectPropertyFlags obj "axes"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceAxesPropertyInfo
instance AttrInfo DeviceAxesPropertyInfo where
    type AttrAllowedOps DeviceAxesPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DeviceAxesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DeviceAxesPropertyInfo = IsDevice
    type AttrGetType DeviceAxesPropertyInfo = [Gdk.Flags.AxisFlags]
    type AttrLabel DeviceAxesPropertyInfo = "axes"
    type AttrOrigin DeviceAxesPropertyInfo = Device
    attrGet _ = getDeviceAxes
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "device-manager"
   -- Type: TInterface (Name {namespace = "Gdk", name = "DeviceManager"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getDeviceDeviceManager :: (MonadIO m, IsDevice o) => o -> m (Maybe Gdk.DeviceManager.DeviceManager)
getDeviceDeviceManager obj = liftIO $ getObjectPropertyObject obj "device-manager" Gdk.DeviceManager.DeviceManager

constructDeviceDeviceManager :: (IsDevice o, Gdk.DeviceManager.IsDeviceManager a) => a -> IO (GValueConstruct o)
constructDeviceDeviceManager val = constructObjectPropertyObject "device-manager" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceDeviceManagerPropertyInfo
instance AttrInfo DeviceDeviceManagerPropertyInfo where
    type AttrAllowedOps DeviceDeviceManagerPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceDeviceManagerPropertyInfo = Gdk.DeviceManager.IsDeviceManager
    type AttrBaseTypeConstraint DeviceDeviceManagerPropertyInfo = IsDevice
    type AttrGetType DeviceDeviceManagerPropertyInfo = (Maybe Gdk.DeviceManager.DeviceManager)
    type AttrLabel DeviceDeviceManagerPropertyInfo = "device-manager"
    type AttrOrigin DeviceDeviceManagerPropertyInfo = Device
    attrGet _ = getDeviceDeviceManager
    attrSet _ = undefined
    attrConstruct _ = constructDeviceDeviceManager
    attrClear _ = undefined
#endif

-- VVV Prop "display"
   -- Type: TInterface (Name {namespace = "Gdk", name = "Display"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getDeviceDisplay :: (MonadIO m, IsDevice o) => o -> m Gdk.Display.Display
getDeviceDisplay obj = liftIO $ checkUnexpectedNothing "getDeviceDisplay" $ getObjectPropertyObject obj "display" Gdk.Display.Display

constructDeviceDisplay :: (IsDevice o, Gdk.Display.IsDisplay a) => a -> IO (GValueConstruct o)
constructDeviceDisplay val = constructObjectPropertyObject "display" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceDisplayPropertyInfo
instance AttrInfo DeviceDisplayPropertyInfo where
    type AttrAllowedOps DeviceDisplayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceDisplayPropertyInfo = Gdk.Display.IsDisplay
    type AttrBaseTypeConstraint DeviceDisplayPropertyInfo = IsDevice
    type AttrGetType DeviceDisplayPropertyInfo = Gdk.Display.Display
    type AttrLabel DeviceDisplayPropertyInfo = "display"
    type AttrOrigin DeviceDisplayPropertyInfo = Device
    attrGet _ = getDeviceDisplay
    attrSet _ = undefined
    attrConstruct _ = constructDeviceDisplay
    attrClear _ = undefined
#endif

-- VVV Prop "has-cursor"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getDeviceHasCursor :: (MonadIO m, IsDevice o) => o -> m Bool
getDeviceHasCursor obj = liftIO $ getObjectPropertyBool obj "has-cursor"

constructDeviceHasCursor :: (IsDevice o) => Bool -> IO (GValueConstruct o)
constructDeviceHasCursor val = constructObjectPropertyBool "has-cursor" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceHasCursorPropertyInfo
instance AttrInfo DeviceHasCursorPropertyInfo where
    type AttrAllowedOps DeviceHasCursorPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DeviceHasCursorPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DeviceHasCursorPropertyInfo = IsDevice
    type AttrGetType DeviceHasCursorPropertyInfo = Bool
    type AttrLabel DeviceHasCursorPropertyInfo = "has-cursor"
    type AttrOrigin DeviceHasCursorPropertyInfo = Device
    attrGet _ = getDeviceHasCursor
    attrSet _ = undefined
    attrConstruct _ = constructDeviceHasCursor
    attrClear _ = undefined
#endif

-- VVV Prop "input-mode"
   -- Type: TInterface (Name {namespace = "Gdk", name = "InputMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getDeviceInputMode :: (MonadIO m, IsDevice o) => o -> m Gdk.Enums.InputMode
getDeviceInputMode obj = liftIO $ getObjectPropertyEnum obj "input-mode"

setDeviceInputMode :: (MonadIO m, IsDevice o) => o -> Gdk.Enums.InputMode -> m ()
setDeviceInputMode obj val = liftIO $ setObjectPropertyEnum obj "input-mode" val

constructDeviceInputMode :: (IsDevice o) => Gdk.Enums.InputMode -> IO (GValueConstruct o)
constructDeviceInputMode val = constructObjectPropertyEnum "input-mode" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceInputModePropertyInfo
instance AttrInfo DeviceInputModePropertyInfo where
    type AttrAllowedOps DeviceInputModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DeviceInputModePropertyInfo = (~) Gdk.Enums.InputMode
    type AttrBaseTypeConstraint DeviceInputModePropertyInfo = IsDevice
    type AttrGetType DeviceInputModePropertyInfo = Gdk.Enums.InputMode
    type AttrLabel DeviceInputModePropertyInfo = "input-mode"
    type AttrOrigin DeviceInputModePropertyInfo = Device
    attrGet _ = getDeviceInputMode
    attrSet _ = setDeviceInputMode
    attrConstruct _ = constructDeviceInputMode
    attrClear _ = undefined
#endif

-- VVV Prop "input-source"
   -- Type: TInterface (Name {namespace = "Gdk", name = "InputSource"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getDeviceInputSource :: (MonadIO m, IsDevice o) => o -> m Gdk.Enums.InputSource
getDeviceInputSource obj = liftIO $ getObjectPropertyEnum obj "input-source"

constructDeviceInputSource :: (IsDevice o) => Gdk.Enums.InputSource -> IO (GValueConstruct o)
constructDeviceInputSource val = constructObjectPropertyEnum "input-source" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceInputSourcePropertyInfo
instance AttrInfo DeviceInputSourcePropertyInfo where
    type AttrAllowedOps DeviceInputSourcePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DeviceInputSourcePropertyInfo = (~) Gdk.Enums.InputSource
    type AttrBaseTypeConstraint DeviceInputSourcePropertyInfo = IsDevice
    type AttrGetType DeviceInputSourcePropertyInfo = Gdk.Enums.InputSource
    type AttrLabel DeviceInputSourcePropertyInfo = "input-source"
    type AttrOrigin DeviceInputSourcePropertyInfo = Device
    attrGet _ = getDeviceInputSource
    attrSet _ = undefined
    attrConstruct _ = constructDeviceInputSource
    attrClear _ = undefined
#endif

-- VVV Prop "n-axes"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDeviceNAxes :: (MonadIO m, IsDevice o) => o -> m Word32
getDeviceNAxes obj = liftIO $ getObjectPropertyUInt32 obj "n-axes"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceNAxesPropertyInfo
instance AttrInfo DeviceNAxesPropertyInfo where
    type AttrAllowedOps DeviceNAxesPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DeviceNAxesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DeviceNAxesPropertyInfo = IsDevice
    type AttrGetType DeviceNAxesPropertyInfo = Word32
    type AttrLabel DeviceNAxesPropertyInfo = "n-axes"
    type AttrOrigin DeviceNAxesPropertyInfo = Device
    attrGet _ = getDeviceNAxes
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getDeviceName :: (MonadIO m, IsDevice o) => o -> m T.Text
getDeviceName obj = liftIO $ checkUnexpectedNothing "getDeviceName" $ getObjectPropertyString obj "name"

constructDeviceName :: (IsDevice o) => T.Text -> IO (GValueConstruct o)
constructDeviceName val = constructObjectPropertyString "name" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceNamePropertyInfo
instance AttrInfo DeviceNamePropertyInfo where
    type AttrAllowedOps DeviceNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DeviceNamePropertyInfo = IsDevice
    type AttrGetType DeviceNamePropertyInfo = T.Text
    type AttrLabel DeviceNamePropertyInfo = "name"
    type AttrOrigin DeviceNamePropertyInfo = Device
    attrGet _ = getDeviceName
    attrSet _ = undefined
    attrConstruct _ = constructDeviceName
    attrClear _ = undefined
#endif

-- VVV Prop "num-touches"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getDeviceNumTouches :: (MonadIO m, IsDevice o) => o -> m Word32
getDeviceNumTouches obj = liftIO $ getObjectPropertyUInt32 obj "num-touches"

constructDeviceNumTouches :: (IsDevice o) => Word32 -> IO (GValueConstruct o)
constructDeviceNumTouches val = constructObjectPropertyUInt32 "num-touches" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceNumTouchesPropertyInfo
instance AttrInfo DeviceNumTouchesPropertyInfo where
    type AttrAllowedOps DeviceNumTouchesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DeviceNumTouchesPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint DeviceNumTouchesPropertyInfo = IsDevice
    type AttrGetType DeviceNumTouchesPropertyInfo = Word32
    type AttrLabel DeviceNumTouchesPropertyInfo = "num-touches"
    type AttrOrigin DeviceNumTouchesPropertyInfo = Device
    attrGet _ = getDeviceNumTouches
    attrSet _ = undefined
    attrConstruct _ = constructDeviceNumTouches
    attrClear _ = undefined
#endif

-- VVV Prop "product-id"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

getDeviceProductId :: (MonadIO m, IsDevice o) => o -> m (Maybe T.Text)
getDeviceProductId obj = liftIO $ getObjectPropertyString obj "product-id"

constructDeviceProductId :: (IsDevice o) => T.Text -> IO (GValueConstruct o)
constructDeviceProductId val = constructObjectPropertyString "product-id" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceProductIdPropertyInfo
instance AttrInfo DeviceProductIdPropertyInfo where
    type AttrAllowedOps DeviceProductIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceProductIdPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DeviceProductIdPropertyInfo = IsDevice
    type AttrGetType DeviceProductIdPropertyInfo = (Maybe T.Text)
    type AttrLabel DeviceProductIdPropertyInfo = "product-id"
    type AttrOrigin DeviceProductIdPropertyInfo = Device
    attrGet _ = getDeviceProductId
    attrSet _ = undefined
    attrConstruct _ = constructDeviceProductId
    attrClear _ = undefined
#endif

-- VVV Prop "seat"
   -- Type: TInterface (Name {namespace = "Gdk", name = "Seat"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

getDeviceSeat :: (MonadIO m, IsDevice o) => o -> m Gdk.Seat.Seat
getDeviceSeat obj = liftIO $ checkUnexpectedNothing "getDeviceSeat" $ getObjectPropertyObject obj "seat" Gdk.Seat.Seat

setDeviceSeat :: (MonadIO m, IsDevice o, Gdk.Seat.IsSeat a) => o -> a -> m ()
setDeviceSeat obj val = liftIO $ setObjectPropertyObject obj "seat" (Just val)

constructDeviceSeat :: (IsDevice o, Gdk.Seat.IsSeat a) => a -> IO (GValueConstruct o)
constructDeviceSeat val = constructObjectPropertyObject "seat" (Just val)

clearDeviceSeat :: (MonadIO m, IsDevice o) => o -> m ()
clearDeviceSeat obj = liftIO $ setObjectPropertyObject obj "seat" (Nothing :: Maybe Gdk.Seat.Seat)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceSeatPropertyInfo
instance AttrInfo DeviceSeatPropertyInfo where
    type AttrAllowedOps DeviceSeatPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceSeatPropertyInfo = Gdk.Seat.IsSeat
    type AttrBaseTypeConstraint DeviceSeatPropertyInfo = IsDevice
    type AttrGetType DeviceSeatPropertyInfo = Gdk.Seat.Seat
    type AttrLabel DeviceSeatPropertyInfo = "seat"
    type AttrOrigin DeviceSeatPropertyInfo = Device
    attrGet _ = getDeviceSeat
    attrSet _ = setDeviceSeat
    attrConstruct _ = constructDeviceSeat
    attrClear _ = clearDeviceSeat
#endif

-- VVV Prop "tool"
   -- Type: TInterface (Name {namespace = "Gdk", name = "DeviceTool"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDeviceTool :: (MonadIO m, IsDevice o) => o -> m (Maybe Gdk.DeviceTool.DeviceTool)
getDeviceTool obj = liftIO $ getObjectPropertyObject obj "tool" Gdk.DeviceTool.DeviceTool

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceToolPropertyInfo
instance AttrInfo DeviceToolPropertyInfo where
    type AttrAllowedOps DeviceToolPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceToolPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DeviceToolPropertyInfo = IsDevice
    type AttrGetType DeviceToolPropertyInfo = (Maybe Gdk.DeviceTool.DeviceTool)
    type AttrLabel DeviceToolPropertyInfo = "tool"
    type AttrOrigin DeviceToolPropertyInfo = Device
    attrGet _ = getDeviceTool
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "type"
   -- Type: TInterface (Name {namespace = "Gdk", name = "DeviceType"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getDeviceType :: (MonadIO m, IsDevice o) => o -> m Gdk.Enums.DeviceType
getDeviceType obj = liftIO $ getObjectPropertyEnum obj "type"

constructDeviceType :: (IsDevice o) => Gdk.Enums.DeviceType -> IO (GValueConstruct o)
constructDeviceType val = constructObjectPropertyEnum "type" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceTypePropertyInfo
instance AttrInfo DeviceTypePropertyInfo where
    type AttrAllowedOps DeviceTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DeviceTypePropertyInfo = (~) Gdk.Enums.DeviceType
    type AttrBaseTypeConstraint DeviceTypePropertyInfo = IsDevice
    type AttrGetType DeviceTypePropertyInfo = Gdk.Enums.DeviceType
    type AttrLabel DeviceTypePropertyInfo = "type"
    type AttrOrigin DeviceTypePropertyInfo = Device
    attrGet _ = getDeviceType
    attrSet _ = undefined
    attrConstruct _ = constructDeviceType
    attrClear _ = undefined
#endif

-- VVV Prop "vendor-id"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

getDeviceVendorId :: (MonadIO m, IsDevice o) => o -> m (Maybe T.Text)
getDeviceVendorId obj = liftIO $ getObjectPropertyString obj "vendor-id"

constructDeviceVendorId :: (IsDevice o) => T.Text -> IO (GValueConstruct o)
constructDeviceVendorId val = constructObjectPropertyString "vendor-id" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceVendorIdPropertyInfo
instance AttrInfo DeviceVendorIdPropertyInfo where
    type AttrAllowedOps DeviceVendorIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DeviceVendorIdPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DeviceVendorIdPropertyInfo = IsDevice
    type AttrGetType DeviceVendorIdPropertyInfo = (Maybe T.Text)
    type AttrLabel DeviceVendorIdPropertyInfo = "vendor-id"
    type AttrOrigin DeviceVendorIdPropertyInfo = Device
    attrGet _ = getDeviceVendorId
    attrSet _ = undefined
    attrConstruct _ = constructDeviceVendorId
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList Device
type instance O.AttributeList Device = DeviceAttributeList
type DeviceAttributeList = ('[ '("associatedDevice", DeviceAssociatedDevicePropertyInfo), '("axes", DeviceAxesPropertyInfo), '("deviceManager", DeviceDeviceManagerPropertyInfo), '("display", DeviceDisplayPropertyInfo), '("hasCursor", DeviceHasCursorPropertyInfo), '("inputMode", DeviceInputModePropertyInfo), '("inputSource", DeviceInputSourcePropertyInfo), '("nAxes", DeviceNAxesPropertyInfo), '("name", DeviceNamePropertyInfo), '("numTouches", DeviceNumTouchesPropertyInfo), '("productId", DeviceProductIdPropertyInfo), '("seat", DeviceSeatPropertyInfo), '("tool", DeviceToolPropertyInfo), '("type", DeviceTypePropertyInfo), '("vendorId", DeviceVendorIdPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
deviceAssociatedDevice :: AttrLabelProxy "associatedDevice"
deviceAssociatedDevice = AttrLabelProxy

deviceAxes :: AttrLabelProxy "axes"
deviceAxes = AttrLabelProxy

deviceDeviceManager :: AttrLabelProxy "deviceManager"
deviceDeviceManager = AttrLabelProxy

deviceDisplay :: AttrLabelProxy "display"
deviceDisplay = AttrLabelProxy

deviceHasCursor :: AttrLabelProxy "hasCursor"
deviceHasCursor = AttrLabelProxy

deviceInputMode :: AttrLabelProxy "inputMode"
deviceInputMode = AttrLabelProxy

deviceInputSource :: AttrLabelProxy "inputSource"
deviceInputSource = AttrLabelProxy

deviceNAxes :: AttrLabelProxy "nAxes"
deviceNAxes = AttrLabelProxy

deviceName :: AttrLabelProxy "name"
deviceName = AttrLabelProxy

deviceNumTouches :: AttrLabelProxy "numTouches"
deviceNumTouches = AttrLabelProxy

deviceProductId :: AttrLabelProxy "productId"
deviceProductId = AttrLabelProxy

deviceSeat :: AttrLabelProxy "seat"
deviceSeat = AttrLabelProxy

deviceTool :: AttrLabelProxy "tool"
deviceTool = AttrLabelProxy

deviceType :: AttrLabelProxy "type"
deviceType = AttrLabelProxy

deviceVendorId :: AttrLabelProxy "vendorId"
deviceVendorId = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceChangedSignalInfo
instance SignalInfo DeviceChangedSignalInfo where
    type HaskellCallbackType DeviceChangedSignalInfo = DeviceChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DeviceChangedCallback cb
        cb'' <- mk_DeviceChangedCallback cb'
        connectSignalFunPtr obj "changed" cb'' connectMode

data DeviceToolChangedSignalInfo
instance SignalInfo DeviceToolChangedSignalInfo where
    type HaskellCallbackType DeviceToolChangedSignalInfo = DeviceToolChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DeviceToolChangedCallback cb
        cb'' <- mk_DeviceToolChangedCallback cb'
        connectSignalFunPtr obj "tool-changed" cb'' connectMode

type instance O.SignalList Device = DeviceSignalList
type DeviceSignalList = ('[ '("changed", DeviceChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("toolChanged", DeviceToolChangedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Device::get_associated_device
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Device"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_associated_device" gdk_device_get_associated_device :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO (Ptr Device)

{- |
Returns the associated device to /@device@/, if /@device@/ is of type
'GI.Gdk.Enums.DeviceTypeMaster', it will return the paired pointer or
keyboard.

If /@device@/ is of type 'GI.Gdk.Enums.DeviceTypeSlave', it will return
the master device to which /@device@/ is attached to.

If /@device@/ is of type 'GI.Gdk.Enums.DeviceTypeFloating', 'Nothing' will be
returned, as there is no associated device.

@since 3.0
-}
deviceGetAssociatedDevice ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m (Maybe Device)
    {- ^ __Returns:__ The associated device, or
  'Nothing' -}
deviceGetAssociatedDevice device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_associated_device device'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Device) result'
        return result''
    touchManagedPtr device
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetAssociatedDeviceMethodInfo
instance (signature ~ (m (Maybe Device)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetAssociatedDeviceMethodInfo a signature where
    overloadedMethod _ = deviceGetAssociatedDevice

#endif

-- method Device::get_axes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "AxisFlags"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_axes" gdk_device_get_axes :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CUInt

{- |
Returns the axes currently available on the device.

@since 3.22
-}
deviceGetAxes ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m [Gdk.Flags.AxisFlags]
deviceGetAxes device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_axes device'
    let result' = wordToGFlags result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetAxesMethodInfo
instance (signature ~ (m [Gdk.Flags.AxisFlags]), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetAxesMethodInfo a signature where
    overloadedMethod _ = deviceGetAxes

#endif

-- method Device::get_axis_use
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the axis.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "AxisUse"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_axis_use" gdk_device_get_axis_use :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Word32 ->                               -- index_ : TBasicType TUInt
    IO CUInt

{- |
Returns the axis use for /@index_@/.

@since 2.20
-}
deviceGetAxisUse ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device'. -}
    -> Word32
    {- ^ /@index_@/: the index of the axis. -}
    -> m Gdk.Enums.AxisUse
    {- ^ __Returns:__ a 'GI.Gdk.Enums.AxisUse' specifying how the axis is used. -}
deviceGetAxisUse device index_ = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_axis_use device' index_
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetAxisUseMethodInfo
instance (signature ~ (Word32 -> m Gdk.Enums.AxisUse), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetAxisUseMethodInfo a signature where
    overloadedMethod _ = deviceGetAxisUse

#endif

-- method Device::get_device_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "DeviceType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_device_type" gdk_device_get_device_type :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CUInt

{- |
Returns the device type for /@device@/.

@since 3.0
-}
deviceGetDeviceType ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Gdk.Enums.DeviceType
    {- ^ __Returns:__ the 'GI.Gdk.Enums.DeviceType' for /@device@/. -}
deviceGetDeviceType device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_device_type device'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetDeviceTypeMethodInfo
instance (signature ~ (m Gdk.Enums.DeviceType), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetDeviceTypeMethodInfo a signature where
    overloadedMethod _ = deviceGetDeviceType

#endif

-- method Device::get_display
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Display"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_display" gdk_device_get_display :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO (Ptr Gdk.Display.Display)

{- |
Returns the 'GI.Gdk.Objects.Display.Display' to which /@device@/ pertains.

@since 3.0
-}
deviceGetDisplay ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Gdk.Display.Display
    {- ^ __Returns:__ a 'GI.Gdk.Objects.Display.Display'. This memory is owned
         by GTK+, and must not be freed or unreffed. -}
deviceGetDisplay device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_display device'
    checkUnexpectedReturnNULL "deviceGetDisplay" result
    result' <- (newObject Gdk.Display.Display) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetDisplayMethodInfo
instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetDisplayMethodInfo a signature where
    overloadedMethod _ = deviceGetDisplay

#endif

-- method Device::get_has_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_has_cursor" gdk_device_get_has_cursor :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CInt

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

@since 2.20
-}
deviceGetHasCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the pointer follows device motion -}
deviceGetHasCursor device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_has_cursor device'
    let result' = (/= 0) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetHasCursorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetHasCursorMethodInfo a signature where
    overloadedMethod _ = deviceGetHasCursor

#endif

-- method Device::get_key
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the macro button to get.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyval", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the keyval.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "modifiers", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for modifiers.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_key" gdk_device_get_key :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Word32 ->                               -- index_ : TBasicType TUInt
    Ptr Word32 ->                           -- keyval : TBasicType TUInt
    Ptr CUInt ->                            -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO CInt

{- |
If /@index_@/ has a valid keyval, this function will return 'True'
and fill in /@keyval@/ and /@modifiers@/ with the keyval settings.

@since 2.20
-}
deviceGetKey ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device'. -}
    -> Word32
    {- ^ /@index_@/: the index of the macro button to get. -}
    -> m ((Bool, Word32, [Gdk.Flags.ModifierType]))
    {- ^ __Returns:__ 'True' if keyval is set for /@index@/. -}
deviceGetKey device index_ = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    keyval <- allocMem :: IO (Ptr Word32)
    modifiers <- allocMem :: IO (Ptr CUInt)
    result <- gdk_device_get_key device' index_ keyval modifiers
    let result' = (/= 0) result
    keyval' <- peek keyval
    modifiers' <- peek modifiers
    let modifiers'' = wordToGFlags modifiers'
    touchManagedPtr device
    freeMem keyval
    freeMem modifiers
    return (result', keyval', modifiers'')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetKeyMethodInfo
instance (signature ~ (Word32 -> m ((Bool, Word32, [Gdk.Flags.ModifierType]))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetKeyMethodInfo a signature where
    overloadedMethod _ = deviceGetKey

#endif

-- method Device::get_last_event_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice, with a source other than %GDK_SOURCE_KEYBOARD", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_last_event_window" gdk_device_get_last_event_window :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO (Ptr Gdk.Window.Window)

{- |
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
-}
deviceGetLastEventWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device', with a source other than 'GI.Gdk.Enums.InputSourceKeyboard' -}
    -> m (Maybe Gdk.Window.Window)
    {- ^ __Returns:__ the last window the device -}
deviceGetLastEventWindow device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_last_event_window device'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Window.Window) result'
        return result''
    touchManagedPtr device
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetLastEventWindowMethodInfo
instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetLastEventWindowMethodInfo a signature where
    overloadedMethod _ = deviceGetLastEventWindow

#endif

-- method Device::get_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "InputMode"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_mode" gdk_device_get_mode :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CUInt

{- |
Determines the mode of the device.

@since 2.20
-}
deviceGetMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Gdk.Enums.InputMode
    {- ^ __Returns:__ a 'GI.Gdk.Enums.InputSource' -}
deviceGetMode device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_mode device'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetModeMethodInfo
instance (signature ~ (m Gdk.Enums.InputMode), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetModeMethodInfo a signature where
    overloadedMethod _ = deviceGetMode

#endif

-- method Device::get_n_axes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_n_axes" gdk_device_get_n_axes :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO Int32

{- |
Returns the number of axes the device currently has.

@since 3.0
-}
deviceGetNAxes ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device' -}
    -> m Int32
    {- ^ __Returns:__ the number of axes. -}
deviceGetNAxes device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_n_axes device'
    touchManagedPtr device
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetNAxesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetNAxesMethodInfo a signature where
    overloadedMethod _ = deviceGetNAxes

#endif

-- method Device::get_n_keys
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_n_keys" gdk_device_get_n_keys :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO Int32

{- |
Returns the number of keys the device currently has.

@since 2.24
-}
deviceGetNKeys ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Int32
    {- ^ __Returns:__ the number of keys. -}
deviceGetNKeys device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_n_keys device'
    touchManagedPtr device
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetNKeysMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetNKeysMethodInfo a signature where
    overloadedMethod _ = deviceGetNKeys

#endif

-- method Device::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_name" gdk_device_get_name :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CString

{- |
Determines the name of the device.

@since 2.20
-}
deviceGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m T.Text
    {- ^ __Returns:__ a name -}
deviceGetName device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_name device'
    checkUnexpectedReturnNULL "deviceGetName" result
    result' <- cstringToText result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetNameMethodInfo a signature where
    overloadedMethod _ = deviceGetName

#endif

-- method Device::get_position
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer device to query status about.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the #GdkScreen\n         the @device is on, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window X coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window Y coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_position" gdk_device_get_position :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Ptr (Ptr Gdk.Screen.Screen) ->          -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
    Ptr Int32 ->                            -- x : TBasicType TInt
    Ptr Int32 ->                            -- y : TBasicType TInt
    IO ()

{- |
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 'GI.Gdk.Enums.DeviceTypeSlave',
unless there is an ongoing grab on them, see 'GI.Gdk.Objects.Device.deviceGrab'.

@since 3.0
-}
deviceGetPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: pointer device to query status about. -}
    -> m ((Gdk.Screen.Screen, Int32, Int32))
deviceGetPosition device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    screen <- allocMem :: IO (Ptr (Ptr Gdk.Screen.Screen))
    x <- allocMem :: IO (Ptr Int32)
    y <- allocMem :: IO (Ptr Int32)
    gdk_device_get_position device' screen x y
    screen' <- peek screen
    screen'' <- (newObject Gdk.Screen.Screen) screen'
    x' <- peek x
    y' <- peek y
    touchManagedPtr device
    freeMem screen
    freeMem x
    freeMem y
    return (screen'', x', y')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetPositionMethodInfo
instance (signature ~ (m ((Gdk.Screen.Screen, Int32, Int32))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetPositionMethodInfo a signature where
    overloadedMethod _ = deviceGetPosition

#endif

-- method Device::get_position_double
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer device to query status about.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the #GdkScreen\n         the @device is on, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window X coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window Y coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_position_double" gdk_device_get_position_double :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Ptr (Ptr Gdk.Screen.Screen) ->          -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
    Ptr CDouble ->                          -- x : TBasicType TDouble
    Ptr CDouble ->                          -- y : TBasicType TDouble
    IO ()

{- |
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 'GI.Gdk.Enums.DeviceTypeSlave',
unless there is an ongoing grab on them. See 'GI.Gdk.Objects.Device.deviceGrab'.

@since 3.10
-}
deviceGetPositionDouble ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: pointer device to query status about. -}
    -> m ((Gdk.Screen.Screen, Double, Double))
deviceGetPositionDouble device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    screen <- allocMem :: IO (Ptr (Ptr Gdk.Screen.Screen))
    x <- allocMem :: IO (Ptr CDouble)
    y <- allocMem :: IO (Ptr CDouble)
    gdk_device_get_position_double device' screen x y
    screen' <- peek screen
    screen'' <- (newObject Gdk.Screen.Screen) screen'
    x' <- peek x
    let x'' = realToFrac x'
    y' <- peek y
    let y'' = realToFrac y'
    touchManagedPtr device
    freeMem screen
    freeMem x
    freeMem y
    return (screen'', x'', y'')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetPositionDoubleMethodInfo
instance (signature ~ (m ((Gdk.Screen.Screen, Double, Double))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetPositionDoubleMethodInfo a signature where
    overloadedMethod _ = deviceGetPositionDouble

#endif

-- method Device::get_product_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a slave #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_product_id" gdk_device_get_product_id :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CString

{- |
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 'GI.Gdk.Objects.Device.deviceGetVendorId' for more information.

@since 3.16
-}
deviceGetProductId ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a slave 'GI.Gdk.Objects.Device.Device' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the product ID, or 'Nothing' -}
deviceGetProductId device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_product_id device'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr device
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetProductIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetProductIdMethodInfo a signature where
    overloadedMethod _ = deviceGetProductId

#endif

-- method Device::get_seat
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Seat"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_seat" gdk_device_get_seat :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO (Ptr Gdk.Seat.Seat)

{- |
Returns the 'GI.Gdk.Objects.Seat.Seat' the device belongs to.

@since 3.20
-}
deviceGetSeat ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: A 'GI.Gdk.Objects.Device.Device' -}
    -> m Gdk.Seat.Seat
    {- ^ __Returns:__ A 'GI.Gdk.Objects.Seat.Seat'. This memory is owned by GTK+ and
         must not be freed. -}
deviceGetSeat device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_seat device'
    checkUnexpectedReturnNULL "deviceGetSeat" result
    result' <- (newObject Gdk.Seat.Seat) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetSeatMethodInfo
instance (signature ~ (m Gdk.Seat.Seat), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetSeatMethodInfo a signature where
    overloadedMethod _ = deviceGetSeat

#endif

-- method Device::get_source
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "InputSource"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_source" gdk_device_get_source :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CUInt

{- |
Determines the type of the device.

@since 2.20
-}
deviceGetSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Gdk.Enums.InputSource
    {- ^ __Returns:__ a 'GI.Gdk.Enums.InputSource' -}
deviceGetSource device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_source device'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetSourceMethodInfo
instance (signature ~ (m Gdk.Enums.InputSource), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetSourceMethodInfo a signature where
    overloadedMethod _ = deviceGetSource

#endif

-- method Device::get_vendor_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a slave #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_vendor_id" gdk_device_get_vendor_id :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CString

{- |
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 'GI.Gdk.Objects.Device.deviceGetProductId', can be used to eg.
compose 'GI.Gio.Objects.Settings.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
-}
deviceGetVendorId ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a slave 'GI.Gdk.Objects.Device.Device' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the vendor ID, or 'Nothing' -}
deviceGetVendorId device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_get_vendor_id device'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr device
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetVendorIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetVendorIdMethodInfo a signature where
    overloadedMethod _ = deviceGetVendorId

#endif

-- method Device::get_window_at_position
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer #GdkDevice to query info to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "win_x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "win_y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the Y coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_window_at_position" gdk_device_get_window_at_position :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Ptr Int32 ->                            -- win_x : TBasicType TInt
    Ptr Int32 ->                            -- win_y : TBasicType TInt
    IO (Ptr Gdk.Window.Window)

{- |
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 'GI.Gdk.Enums.DeviceTypeSlave',
unless there is an ongoing grab on them, see 'GI.Gdk.Objects.Device.deviceGrab'.

@since 3.0
-}
deviceGetWindowAtPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: pointer 'GI.Gdk.Objects.Device.Device' to query info to. -}
    -> m ((Maybe Gdk.Window.Window, Int32, Int32))
    {- ^ __Returns:__ the 'GI.Gdk.Objects.Window.Window' under the
device position, or 'Nothing'. -}
deviceGetWindowAtPosition device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    winX <- allocMem :: IO (Ptr Int32)
    winY <- allocMem :: IO (Ptr Int32)
    result <- gdk_device_get_window_at_position device' winX winY
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Window.Window) result'
        return result''
    winX' <- peek winX
    winY' <- peek winY
    touchManagedPtr device
    freeMem winX
    freeMem winY
    return (maybeResult, winX', winY')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetWindowAtPositionMethodInfo
instance (signature ~ (m ((Maybe Gdk.Window.Window, Int32, Int32))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetWindowAtPositionMethodInfo a signature where
    overloadedMethod _ = deviceGetWindowAtPosition

#endif

-- method Device::get_window_at_position_double
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer #GdkDevice to query info to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "win_x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "win_y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the Y coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_get_window_at_position_double" gdk_device_get_window_at_position_double :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Ptr CDouble ->                          -- win_x : TBasicType TDouble
    Ptr CDouble ->                          -- win_y : TBasicType TDouble
    IO (Ptr Gdk.Window.Window)

{- |
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 'GI.Gdk.Enums.DeviceTypeSlave',
unless there is an ongoing grab on them, see 'GI.Gdk.Objects.Device.deviceGrab'.

@since 3.0
-}
deviceGetWindowAtPositionDouble ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: pointer 'GI.Gdk.Objects.Device.Device' to query info to. -}
    -> m ((Maybe Gdk.Window.Window, Double, Double))
    {- ^ __Returns:__ the 'GI.Gdk.Objects.Window.Window' under the
  device position, or 'Nothing'. -}
deviceGetWindowAtPositionDouble device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    winX <- allocMem :: IO (Ptr CDouble)
    winY <- allocMem :: IO (Ptr CDouble)
    result <- gdk_device_get_window_at_position_double device' winX winY
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Window.Window) result'
        return result''
    winX' <- peek winX
    let winX'' = realToFrac winX'
    winY' <- peek winY
    let winY'' = realToFrac winY'
    touchManagedPtr device
    freeMem winX
    freeMem winY
    return (maybeResult, winX'', winY'')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGetWindowAtPositionDoubleMethodInfo
instance (signature ~ (m ((Maybe Gdk.Window.Window, Double, Double))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetWindowAtPositionDoubleMethodInfo a signature where
    overloadedMethod _ = deviceGetWindowAtPositionDouble

#endif

-- method Device::grab
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice. To get the device you can use gtk_get_current_event_device()\n  or gdk_event_get_device() if the grab is in reaction to an event. Also, you can use\n  gdk_device_manager_get_client_pointer() but only in code that isn\8217t triggered by a\n  #GdkEvent and there aren\8217t other means to get a meaningful #GdkDevice to operate on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkWindow which will own the grab (the grab window)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "grab_ownership", argType = TInterface (Name {namespace = "Gdk", name = "GrabOwnership"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies the grab ownership.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner_events", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %FALSE then all device events are reported with respect to\n               @window and are only reported if selected by @event_mask. If\n               %TRUE then pointer events for this application are reported\n               as normal, but pointer events outside this application are\n               reported with respect to @window and only if selected by\n               @event_mask. In either mode, unreported events are discarded.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event_mask", argType = TInterface (Name {namespace = "Gdk", name = "EventMask"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies the event mask, which is used in accordance with\n             @owner_events.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor", argType = TInterface (Name {namespace = "Gdk", name = "Cursor"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the cursor to display while the grab is active if the device is\n         a pointer. If this is %NULL then the normal cursors are used for\n         @window and its descendants, and the cursor for @window is used\n         elsewhere.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timestamp of the event which led to this pointer grab. This\n        usually comes from the #GdkEvent struct, though %GDK_CURRENT_TIME\n        can be used if the time isn\8217t known.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "GrabStatus"}))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_grab" gdk_device_grab :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
    CUInt ->                                -- grab_ownership : TInterface (Name {namespace = "Gdk", name = "GrabOwnership"})
    CInt ->                                 -- owner_events : TBasicType TBoolean
    CUInt ->                                -- event_mask : TInterface (Name {namespace = "Gdk", name = "EventMask"})
    Ptr Gdk.Cursor.Cursor ->                -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
    Word32 ->                               -- time_ : TBasicType TUInt32
    IO CUInt

{-# DEPRECATED deviceGrab ["(Since version 3.20.)","Use 'GI.Gdk.Objects.Seat.seatGrab' instead."] #-}
{- |
Grabs the device so that all events coming from this device are passed to
this application until the device is ungrabbed with 'GI.Gdk.Objects.Device.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 'GI.Gdk.Structs.EventGrabBroken.EventGrabBroken'
events that are emitted when the grab ends unvoluntarily.

@since 3.0
-}
deviceGrab ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a, Gdk.Window.IsWindow b, Gdk.Cursor.IsCursor c) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device'. To get the device you can use @/gtk_get_current_event_device()/@
  or 'GI.Gdk.Unions.Event.eventGetDevice' if the grab is in reaction to an event. Also, you can use
  'GI.Gdk.Objects.DeviceManager.deviceManagerGetClientPointer' but only in code that isn’t triggered by a
  'GI.Gdk.Unions.Event.Event' and there aren’t other means to get a meaningful 'GI.Gdk.Objects.Device.Device' to operate on. -}
    -> b
    {- ^ /@window@/: the 'GI.Gdk.Objects.Window.Window' which will own the grab (the grab window) -}
    -> Gdk.Enums.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. -}
    -> [Gdk.Flags.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 'GI.Gdk.Unions.Event.Event' struct, though 'GI.Gdk.Constants.CURRENT_TIME'
        can be used if the time isn’t known. -}
    -> m Gdk.Enums.GrabStatus
    {- ^ __Returns:__ 'GI.Gdk.Enums.GrabStatusSuccess' if the grab was successful. -}
deviceGrab device window grabOwnership ownerEvents eventMask cursor time_ = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    window' <- unsafeManagedPtrCastPtr window
    let grabOwnership' = (fromIntegral . fromEnum) grabOwnership
    let ownerEvents' = (fromIntegral . fromEnum) ownerEvents
    let eventMask' = gflagsToWord eventMask
    maybeCursor <- case cursor of
        Nothing -> return nullPtr
        Just jCursor -> do
            jCursor' <- unsafeManagedPtrCastPtr jCursor
            return jCursor'
    result <- gdk_device_grab device' window' grabOwnership' ownerEvents' eventMask' maybeCursor time_
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr device
    touchManagedPtr window
    whenJust cursor touchManagedPtr
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceGrabMethodInfo
instance (signature ~ (b -> Gdk.Enums.GrabOwnership -> Bool -> [Gdk.Flags.EventMask] -> Maybe (c) -> Word32 -> m Gdk.Enums.GrabStatus), MonadIO m, IsDevice a, Gdk.Window.IsWindow b, Gdk.Cursor.IsCursor c) => O.MethodInfo DeviceGrabMethodInfo a signature where
    overloadedMethod _ = deviceGrab

#endif

-- method Device::list_axes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Atom"})))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_list_axes" gdk_device_list_axes :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO (Ptr (GList (Ptr Gdk.Atom.Atom)))

{- |
Returns a 'GI.GLib.Structs.List.List' of @/GdkAtoms/@, containing the labels for
the axes that /@device@/ currently has.

@since 3.0
-}
deviceListAxes ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device' -}
    -> m [Gdk.Atom.Atom]
    {- ^ __Returns:__ 
    A 'GI.GLib.Structs.List.List' of @/GdkAtoms/@, free with @/g_list_free()/@. -}
deviceListAxes device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_list_axes device'
    result' <- unpackGList result
    result'' <- mapM (newPtr Gdk.Atom.Atom) result'
    g_list_free result
    touchManagedPtr device
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceListAxesMethodInfo
instance (signature ~ (m [Gdk.Atom.Atom]), MonadIO m, IsDevice a) => O.MethodInfo DeviceListAxesMethodInfo a signature where
    overloadedMethod _ = deviceListAxes

#endif

-- method Device::list_slave_devices
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Device"})))
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_list_slave_devices" gdk_device_list_slave_devices :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO (Ptr (GList (Ptr Device)))

{- |
If the device if of type 'GI.Gdk.Enums.DeviceTypeMaster', it will return
the list of slave devices attached to it, otherwise it will return
'Nothing'
-}
deviceListSlaveDevices ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.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. -}
deviceListSlaveDevices device = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    result <- gdk_device_list_slave_devices device'
    result' <- unpackGList result
    result'' <- mapM (newObject Device) result'
    g_list_free result
    touchManagedPtr device
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceListSlaveDevicesMethodInfo
instance (signature ~ (m [Device]), MonadIO m, IsDevice a) => O.MethodInfo DeviceListSlaveDevicesMethodInfo a signature where
    overloadedMethod _ = deviceListSlaveDevices

#endif

-- method Device::set_axis_use
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the axis", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use", argType = TInterface (Name {namespace = "Gdk", name = "AxisUse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies how the axis is used", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_set_axis_use" gdk_device_set_axis_use :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Word32 ->                               -- index_ : TBasicType TUInt
    CUInt ->                                -- use : TInterface (Name {namespace = "Gdk", name = "AxisUse"})
    IO ()

{- |
Specifies how an axis of a device is used.
-}
deviceSetAxisUse ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device' -}
    -> Word32
    {- ^ /@index_@/: the index of the axis -}
    -> Gdk.Enums.AxisUse
    {- ^ /@use@/: specifies how the axis is used -}
    -> m ()
deviceSetAxisUse device index_ use = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    let use' = (fromIntegral . fromEnum) use
    gdk_device_set_axis_use device' index_ use'
    touchManagedPtr device
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceSetAxisUseMethodInfo
instance (signature ~ (Word32 -> Gdk.Enums.AxisUse -> m ()), MonadIO m, IsDevice a) => O.MethodInfo DeviceSetAxisUseMethodInfo a signature where
    overloadedMethod _ = deviceSetAxisUse

#endif

-- method Device::set_key
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the macro button to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyval", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the keyval to generate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modifiers", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the modifiers to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_set_key" gdk_device_set_key :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Word32 ->                               -- index_ : TBasicType TUInt
    Word32 ->                               -- keyval : TBasicType TUInt
    CUInt ->                                -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO ()

{- |
Specifies the X key event to generate when a macro button of a device
is pressed.
-}
deviceSetKey ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> Word32
    {- ^ /@index_@/: the index of the macro button to set -}
    -> Word32
    {- ^ /@keyval@/: the keyval to generate -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@modifiers@/: the modifiers to set -}
    -> m ()
deviceSetKey device index_ keyval modifiers = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    let modifiers' = gflagsToWord modifiers
    gdk_device_set_key device' index_ keyval modifiers'
    touchManagedPtr device
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceSetKeyMethodInfo
instance (signature ~ (Word32 -> Word32 -> [Gdk.Flags.ModifierType] -> m ()), MonadIO m, IsDevice a) => O.MethodInfo DeviceSetKeyMethodInfo a signature where
    overloadedMethod _ = deviceSetKey

#endif

-- method Device::set_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gdk", name = "InputMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the input mode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_set_mode" gdk_device_set_mode :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Gdk", name = "InputMode"})
    IO CInt

{- |
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.
-}
deviceSetMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device'. -}
    -> Gdk.Enums.InputMode
    {- ^ /@mode@/: the input mode. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the mode was successfully changed. -}
deviceSetMode device mode = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    let mode' = (fromIntegral . fromEnum) mode
    result <- gdk_device_set_mode device' mode'
    let result' = (/= 0) result
    touchManagedPtr device
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceSetModeMethodInfo
instance (signature ~ (Gdk.Enums.InputMode -> m Bool), MonadIO m, IsDevice a) => O.MethodInfo DeviceSetModeMethodInfo a signature where
    overloadedMethod _ = deviceSetMode

#endif

-- method Device::ungrab
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timestap (e.g. %GDK_CURRENT_TIME).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_ungrab" gdk_device_ungrab :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Word32 ->                               -- time_ : TBasicType TUInt32
    IO ()

{-# DEPRECATED deviceUngrab ["(Since version 3.20.)","Use 'GI.Gdk.Objects.Seat.seatUngrab' instead."] #-}
{- |
Release any grab on /@device@/.

@since 3.0
-}
deviceUngrab ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
    a
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> Word32
    {- ^ /@time_@/: a timestap (e.g. 'GI.Gdk.Constants.CURRENT_TIME'). -}
    -> m ()
deviceUngrab device time_ = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    gdk_device_ungrab device' time_
    touchManagedPtr device
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceUngrabMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDevice a) => O.MethodInfo DeviceUngrabMethodInfo a signature where
    overloadedMethod _ = deviceUngrab

#endif

-- method Device::warp
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the device to warp.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the screen to warp @device to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X coordinate of the destination.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the Y coordinate of the destination.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_warp" gdk_device_warp :: 
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Ptr Gdk.Screen.Screen ->                -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    IO ()

{- |
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
-}
deviceWarp ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevice a, Gdk.Screen.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 ()
deviceWarp device screen x y = liftIO $ do
    device' <- unsafeManagedPtrCastPtr device
    screen' <- unsafeManagedPtrCastPtr screen
    gdk_device_warp device' screen' x y
    touchManagedPtr device
    touchManagedPtr screen
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DeviceWarpMethodInfo
instance (signature ~ (b -> Int32 -> Int32 -> m ()), MonadIO m, IsDevice a, Gdk.Screen.IsScreen b) => O.MethodInfo DeviceWarpMethodInfo a signature where
    overloadedMethod _ = deviceWarp

#endif

-- method Device::grab_info_libgtk_only
-- method type : MemberFunction
-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the display for which to get the grab information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "device to get the grab information from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "grab_window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store current grab window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner_events", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store boolean indicating whether\n  the @owner_events flag to gdk_keyboard_grab() or\n  gdk_pointer_grab() was %TRUE.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_device_grab_info_libgtk_only" gdk_device_grab_info_libgtk_only :: 
    Ptr Gdk.Display.Display ->              -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
    Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    Ptr (Ptr Gdk.Window.Window) ->          -- grab_window : TInterface (Name {namespace = "Gdk", name = "Window"})
    Ptr CInt ->                             -- owner_events : TBasicType TBoolean
    IO CInt

{-# DEPRECATED deviceGrabInfoLibgtkOnly ["(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.
-}
deviceGrabInfoLibgtkOnly ::
    (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.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, Gdk.Window.Window, Bool))
    {- ^ __Returns:__ 'True' if this application currently has the
 keyboard grabbed. -}
deviceGrabInfoLibgtkOnly display device = liftIO $ do
    display' <- unsafeManagedPtrCastPtr display
    device' <- unsafeManagedPtrCastPtr device
    grabWindow <- allocMem :: IO (Ptr (Ptr Gdk.Window.Window))
    ownerEvents <- allocMem :: IO (Ptr CInt)
    result <- gdk_device_grab_info_libgtk_only display' device' grabWindow ownerEvents
    let result' = (/= 0) result
    grabWindow' <- peek grabWindow
    grabWindow'' <- (newObject Gdk.Window.Window) grabWindow'
    ownerEvents' <- peek ownerEvents
    let ownerEvents'' = (/= 0) ownerEvents'
    touchManagedPtr display
    touchManagedPtr device
    freeMem grabWindow
    freeMem ownerEvents
    return (result', grabWindow'', ownerEvents'')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif