module GI.Gdk.Objects.DeviceManager
(
DeviceManager(..) ,
IsDeviceManager ,
toDeviceManager ,
noDeviceManager ,
DeviceManagerGetClientPointerMethodInfo ,
deviceManagerGetClientPointer ,
DeviceManagerGetDisplayMethodInfo ,
deviceManagerGetDisplay ,
DeviceManagerListDevicesMethodInfo ,
deviceManagerListDevices ,
DeviceManagerDisplayPropertyInfo ,
constructDeviceManagerDisplay ,
deviceManagerDisplay ,
getDeviceManagerDisplay ,
C_DeviceManagerDeviceAddedCallback ,
DeviceManagerDeviceAddedCallback ,
DeviceManagerDeviceAddedSignalInfo ,
afterDeviceManagerDeviceAdded ,
genClosure_DeviceManagerDeviceAdded ,
mk_DeviceManagerDeviceAddedCallback ,
noDeviceManagerDeviceAddedCallback ,
onDeviceManagerDeviceAdded ,
wrap_DeviceManagerDeviceAddedCallback ,
C_DeviceManagerDeviceChangedCallback ,
DeviceManagerDeviceChangedCallback ,
DeviceManagerDeviceChangedSignalInfo ,
afterDeviceManagerDeviceChanged ,
genClosure_DeviceManagerDeviceChanged ,
mk_DeviceManagerDeviceChangedCallback ,
noDeviceManagerDeviceChangedCallback ,
onDeviceManagerDeviceChanged ,
wrap_DeviceManagerDeviceChangedCallback ,
C_DeviceManagerDeviceRemovedCallback ,
DeviceManagerDeviceRemovedCallback ,
DeviceManagerDeviceRemovedSignalInfo ,
afterDeviceManagerDeviceRemoved ,
genClosure_DeviceManagerDeviceRemoved ,
mk_DeviceManagerDeviceRemovedCallback ,
noDeviceManagerDeviceRemovedCallback ,
onDeviceManagerDeviceRemoved ,
wrap_DeviceManagerDeviceRemovedCallback ,
) 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 qualified GI.Gdk.Enums as Gdk.Enums
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
newtype DeviceManager = DeviceManager (ManagedPtr DeviceManager)
foreign import ccall "gdk_device_manager_get_type"
c_gdk_device_manager_get_type :: IO GType
instance GObject DeviceManager where
gobjectType _ = c_gdk_device_manager_get_type
class GObject o => IsDeviceManager o
#if MIN_VERSION_base(4,9,0)
instance (GObject a, O.UnknownAncestorError DeviceManager a) =>
IsDeviceManager a
#endif
instance IsDeviceManager DeviceManager
instance GObject.Object.IsObject DeviceManager
toDeviceManager :: IsDeviceManager o => o -> IO DeviceManager
toDeviceManager = unsafeCastTo DeviceManager
noDeviceManager :: Maybe DeviceManager
noDeviceManager = Nothing
type family ResolveDeviceManagerMethod (t :: Symbol) (o :: *) :: * where
ResolveDeviceManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDeviceManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDeviceManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDeviceManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDeviceManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDeviceManagerMethod "listDevices" o = DeviceManagerListDevicesMethodInfo
ResolveDeviceManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDeviceManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDeviceManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDeviceManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDeviceManagerMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
ResolveDeviceManagerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
ResolveDeviceManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDeviceManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDeviceManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDeviceManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDeviceManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDeviceManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDeviceManagerMethod "getClientPointer" o = DeviceManagerGetClientPointerMethodInfo
ResolveDeviceManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDeviceManagerMethod "getDisplay" o = DeviceManagerGetDisplayMethodInfo
ResolveDeviceManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDeviceManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDeviceManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDeviceManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDeviceManagerMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDeviceManagerMethod t DeviceManager, O.MethodInfo info DeviceManager p) => O.IsLabelProxy t (DeviceManager -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDeviceManagerMethod t DeviceManager, O.MethodInfo info DeviceManager p) => O.IsLabel t (DeviceManager -> p) where
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
type DeviceManagerDeviceAddedCallback =
Gdk.Device.Device ->
IO ()
noDeviceManagerDeviceAddedCallback :: Maybe DeviceManagerDeviceAddedCallback
noDeviceManagerDeviceAddedCallback = Nothing
type C_DeviceManagerDeviceAddedCallback =
Ptr () ->
Ptr Gdk.Device.Device ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DeviceManagerDeviceAddedCallback :: C_DeviceManagerDeviceAddedCallback -> IO (FunPtr C_DeviceManagerDeviceAddedCallback)
genClosure_DeviceManagerDeviceAdded :: DeviceManagerDeviceAddedCallback -> IO Closure
genClosure_DeviceManagerDeviceAdded cb = do
let cb' = wrap_DeviceManagerDeviceAddedCallback cb
mk_DeviceManagerDeviceAddedCallback cb' >>= newCClosure
wrap_DeviceManagerDeviceAddedCallback ::
DeviceManagerDeviceAddedCallback ->
Ptr () ->
Ptr Gdk.Device.Device ->
Ptr () ->
IO ()
wrap_DeviceManagerDeviceAddedCallback _cb _ device _ = do
device' <- (newObject Gdk.Device.Device) device
_cb device'
onDeviceManagerDeviceAdded :: (GObject a, MonadIO m) => a -> DeviceManagerDeviceAddedCallback -> m SignalHandlerId
onDeviceManagerDeviceAdded obj cb = liftIO $ connectDeviceManagerDeviceAdded obj cb SignalConnectBefore
afterDeviceManagerDeviceAdded :: (GObject a, MonadIO m) => a -> DeviceManagerDeviceAddedCallback -> m SignalHandlerId
afterDeviceManagerDeviceAdded obj cb = connectDeviceManagerDeviceAdded obj cb SignalConnectAfter
connectDeviceManagerDeviceAdded :: (GObject a, MonadIO m) =>
a -> DeviceManagerDeviceAddedCallback -> SignalConnectMode -> m SignalHandlerId
connectDeviceManagerDeviceAdded obj cb after = liftIO $ do
let cb' = wrap_DeviceManagerDeviceAddedCallback cb
cb'' <- mk_DeviceManagerDeviceAddedCallback cb'
connectSignalFunPtr obj "device-added" cb'' after
type DeviceManagerDeviceChangedCallback =
Gdk.Device.Device ->
IO ()
noDeviceManagerDeviceChangedCallback :: Maybe DeviceManagerDeviceChangedCallback
noDeviceManagerDeviceChangedCallback = Nothing
type C_DeviceManagerDeviceChangedCallback =
Ptr () ->
Ptr Gdk.Device.Device ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DeviceManagerDeviceChangedCallback :: C_DeviceManagerDeviceChangedCallback -> IO (FunPtr C_DeviceManagerDeviceChangedCallback)
genClosure_DeviceManagerDeviceChanged :: DeviceManagerDeviceChangedCallback -> IO Closure
genClosure_DeviceManagerDeviceChanged cb = do
let cb' = wrap_DeviceManagerDeviceChangedCallback cb
mk_DeviceManagerDeviceChangedCallback cb' >>= newCClosure
wrap_DeviceManagerDeviceChangedCallback ::
DeviceManagerDeviceChangedCallback ->
Ptr () ->
Ptr Gdk.Device.Device ->
Ptr () ->
IO ()
wrap_DeviceManagerDeviceChangedCallback _cb _ device _ = do
device' <- (newObject Gdk.Device.Device) device
_cb device'
onDeviceManagerDeviceChanged :: (GObject a, MonadIO m) => a -> DeviceManagerDeviceChangedCallback -> m SignalHandlerId
onDeviceManagerDeviceChanged obj cb = liftIO $ connectDeviceManagerDeviceChanged obj cb SignalConnectBefore
afterDeviceManagerDeviceChanged :: (GObject a, MonadIO m) => a -> DeviceManagerDeviceChangedCallback -> m SignalHandlerId
afterDeviceManagerDeviceChanged obj cb = connectDeviceManagerDeviceChanged obj cb SignalConnectAfter
connectDeviceManagerDeviceChanged :: (GObject a, MonadIO m) =>
a -> DeviceManagerDeviceChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectDeviceManagerDeviceChanged obj cb after = liftIO $ do
let cb' = wrap_DeviceManagerDeviceChangedCallback cb
cb'' <- mk_DeviceManagerDeviceChangedCallback cb'
connectSignalFunPtr obj "device-changed" cb'' after
type DeviceManagerDeviceRemovedCallback =
Gdk.Device.Device ->
IO ()
noDeviceManagerDeviceRemovedCallback :: Maybe DeviceManagerDeviceRemovedCallback
noDeviceManagerDeviceRemovedCallback = Nothing
type C_DeviceManagerDeviceRemovedCallback =
Ptr () ->
Ptr Gdk.Device.Device ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DeviceManagerDeviceRemovedCallback :: C_DeviceManagerDeviceRemovedCallback -> IO (FunPtr C_DeviceManagerDeviceRemovedCallback)
genClosure_DeviceManagerDeviceRemoved :: DeviceManagerDeviceRemovedCallback -> IO Closure
genClosure_DeviceManagerDeviceRemoved cb = do
let cb' = wrap_DeviceManagerDeviceRemovedCallback cb
mk_DeviceManagerDeviceRemovedCallback cb' >>= newCClosure
wrap_DeviceManagerDeviceRemovedCallback ::
DeviceManagerDeviceRemovedCallback ->
Ptr () ->
Ptr Gdk.Device.Device ->
Ptr () ->
IO ()
wrap_DeviceManagerDeviceRemovedCallback _cb _ device _ = do
device' <- (newObject Gdk.Device.Device) device
_cb device'
onDeviceManagerDeviceRemoved :: (GObject a, MonadIO m) => a -> DeviceManagerDeviceRemovedCallback -> m SignalHandlerId
onDeviceManagerDeviceRemoved obj cb = liftIO $ connectDeviceManagerDeviceRemoved obj cb SignalConnectBefore
afterDeviceManagerDeviceRemoved :: (GObject a, MonadIO m) => a -> DeviceManagerDeviceRemovedCallback -> m SignalHandlerId
afterDeviceManagerDeviceRemoved obj cb = connectDeviceManagerDeviceRemoved obj cb SignalConnectAfter
connectDeviceManagerDeviceRemoved :: (GObject a, MonadIO m) =>
a -> DeviceManagerDeviceRemovedCallback -> SignalConnectMode -> m SignalHandlerId
connectDeviceManagerDeviceRemoved obj cb after = liftIO $ do
let cb' = wrap_DeviceManagerDeviceRemovedCallback cb
cb'' <- mk_DeviceManagerDeviceRemovedCallback cb'
connectSignalFunPtr obj "device-removed" cb'' after
getDeviceManagerDisplay :: (MonadIO m, IsDeviceManager o) => o -> m (Maybe Gdk.Display.Display)
getDeviceManagerDisplay obj = liftIO $ getObjectPropertyObject obj "display" Gdk.Display.Display
constructDeviceManagerDisplay :: (IsDeviceManager o, Gdk.Display.IsDisplay a) => a -> IO (GValueConstruct o)
constructDeviceManagerDisplay val = constructObjectPropertyObject "display" (Just val)
data DeviceManagerDisplayPropertyInfo
instance AttrInfo DeviceManagerDisplayPropertyInfo where
type AttrAllowedOps DeviceManagerDisplayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DeviceManagerDisplayPropertyInfo = Gdk.Display.IsDisplay
type AttrBaseTypeConstraint DeviceManagerDisplayPropertyInfo = IsDeviceManager
type AttrGetType DeviceManagerDisplayPropertyInfo = (Maybe Gdk.Display.Display)
type AttrLabel DeviceManagerDisplayPropertyInfo = "display"
type AttrOrigin DeviceManagerDisplayPropertyInfo = DeviceManager
attrGet _ = getDeviceManagerDisplay
attrSet _ = undefined
attrConstruct _ = constructDeviceManagerDisplay
attrClear _ = undefined
instance O.HasAttributeList DeviceManager
type instance O.AttributeList DeviceManager = DeviceManagerAttributeList
type DeviceManagerAttributeList = ('[ '("display", DeviceManagerDisplayPropertyInfo)] :: [(Symbol, *)])
deviceManagerDisplay :: AttrLabelProxy "display"
deviceManagerDisplay = AttrLabelProxy
data DeviceManagerDeviceAddedSignalInfo
instance SignalInfo DeviceManagerDeviceAddedSignalInfo where
type HaskellCallbackType DeviceManagerDeviceAddedSignalInfo = DeviceManagerDeviceAddedCallback
connectSignal _ = connectDeviceManagerDeviceAdded
data DeviceManagerDeviceChangedSignalInfo
instance SignalInfo DeviceManagerDeviceChangedSignalInfo where
type HaskellCallbackType DeviceManagerDeviceChangedSignalInfo = DeviceManagerDeviceChangedCallback
connectSignal _ = connectDeviceManagerDeviceChanged
data DeviceManagerDeviceRemovedSignalInfo
instance SignalInfo DeviceManagerDeviceRemovedSignalInfo where
type HaskellCallbackType DeviceManagerDeviceRemovedSignalInfo = DeviceManagerDeviceRemovedCallback
connectSignal _ = connectDeviceManagerDeviceRemoved
type instance O.SignalList DeviceManager = DeviceManagerSignalList
type DeviceManagerSignalList = ('[ '("deviceAdded", DeviceManagerDeviceAddedSignalInfo), '("deviceChanged", DeviceManagerDeviceChangedSignalInfo), '("deviceRemoved", DeviceManagerDeviceRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
foreign import ccall "gdk_device_manager_get_client_pointer" gdk_device_manager_get_client_pointer ::
Ptr DeviceManager ->
IO (Ptr Gdk.Device.Device)
deviceManagerGetClientPointer ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceManager a) =>
a
-> m Gdk.Device.Device
deviceManagerGetClientPointer deviceManager = liftIO $ do
deviceManager' <- unsafeManagedPtrCastPtr deviceManager
result <- gdk_device_manager_get_client_pointer deviceManager'
checkUnexpectedReturnNULL "deviceManagerGetClientPointer" result
result' <- (newObject Gdk.Device.Device) result
touchManagedPtr deviceManager
return result'
data DeviceManagerGetClientPointerMethodInfo
instance (signature ~ (m Gdk.Device.Device), MonadIO m, IsDeviceManager a) => O.MethodInfo DeviceManagerGetClientPointerMethodInfo a signature where
overloadedMethod _ = deviceManagerGetClientPointer
foreign import ccall "gdk_device_manager_get_display" gdk_device_manager_get_display ::
Ptr DeviceManager ->
IO (Ptr Gdk.Display.Display)
deviceManagerGetDisplay ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceManager a) =>
a
-> m (Maybe Gdk.Display.Display)
deviceManagerGetDisplay deviceManager = liftIO $ do
deviceManager' <- unsafeManagedPtrCastPtr deviceManager
result <- gdk_device_manager_get_display deviceManager'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Gdk.Display.Display) result'
return result''
touchManagedPtr deviceManager
return maybeResult
data DeviceManagerGetDisplayMethodInfo
instance (signature ~ (m (Maybe Gdk.Display.Display)), MonadIO m, IsDeviceManager a) => O.MethodInfo DeviceManagerGetDisplayMethodInfo a signature where
overloadedMethod _ = deviceManagerGetDisplay
foreign import ccall "gdk_device_manager_list_devices" gdk_device_manager_list_devices ::
Ptr DeviceManager ->
CUInt ->
IO (Ptr (GList (Ptr Gdk.Device.Device)))
deviceManagerListDevices ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceManager a) =>
a
-> Gdk.Enums.DeviceType
-> m [Gdk.Device.Device]
deviceManagerListDevices deviceManager type_ = liftIO $ do
deviceManager' <- unsafeManagedPtrCastPtr deviceManager
let type_' = (fromIntegral . fromEnum) type_
result <- gdk_device_manager_list_devices deviceManager' type_'
result' <- unpackGList result
result'' <- mapM (newObject Gdk.Device.Device) result'
g_list_free result
touchManagedPtr deviceManager
return result''
data DeviceManagerListDevicesMethodInfo
instance (signature ~ (Gdk.Enums.DeviceType -> m [Gdk.Device.Device]), MonadIO m, IsDeviceManager a) => O.MethodInfo DeviceManagerListDevicesMethodInfo a signature where
overloadedMethod _ = deviceManagerListDevices