DevicePad.hs


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

'GI.Gdk.Interfaces.DevicePad.DevicePad' is an interface implemented by devices of type
'GI.Gdk.Enums.InputSourceTabletPad', it allows querying the features provided
by the pad device.

Tablet pads may contain one or more groups, each containing a subset
of the buttons\/rings\/strips available. 'GI.Gdk.Interfaces.DevicePad.devicePadGetNGroups'
can be used to obtain the number of groups, 'GI.Gdk.Interfaces.DevicePad.devicePadGetNFeatures'
and 'GI.Gdk.Interfaces.DevicePad.devicePadGetFeatureGroup' can be combined to find out the
number of buttons\/rings\/strips the device has, and how are they grouped.

Each of those groups have different modes, which may be used to map
each individual pad feature to multiple actions. Only one mode is
effective (current) for each given group, different groups may have
different current modes. The number of available modes in a group can
be found out through 'GI.Gdk.Interfaces.DevicePad.devicePadGetGroupNModes', and the current
mode for a given group will be notified through the 'GI.Gdk.Structs.EventPadGroupMode.EventPadGroupMode'
event.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Gdk.Interfaces.DevicePad
    ( 

-- * Exported types
    DevicePad(..)                           ,
    noDevicePad                             ,
    IsDevicePad                             ,
    toDevicePad                             ,


 -- * Methods
-- ** getFeatureGroup #method:getFeatureGroup#

#if ENABLE_OVERLOADING
    DevicePadGetFeatureGroupMethodInfo      ,
#endif
    devicePadGetFeatureGroup                ,


-- ** getGroupNModes #method:getGroupNModes#

#if ENABLE_OVERLOADING
    DevicePadGetGroupNModesMethodInfo       ,
#endif
    devicePadGetGroupNModes                 ,


-- ** getNFeatures #method:getNFeatures#

#if ENABLE_OVERLOADING
    DevicePadGetNFeaturesMethodInfo         ,
#endif
    devicePadGetNFeatures                   ,


-- ** getNGroups #method:getNGroups#

#if ENABLE_OVERLOADING
    DevicePadGetNGroupsMethodInfo           ,
#endif
    devicePadGetNGroups                     ,




    ) 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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
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 GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Objects.Device as Gdk.Device

-- interface DevicePad 
-- | Memory-managed wrapper type.
newtype DevicePad = DevicePad (ManagedPtr DevicePad)
-- | A convenience alias for `Nothing` :: `Maybe` `DevicePad`.
noDevicePad :: Maybe DevicePad
noDevicePad = Nothing

#if ENABLE_OVERLOADING
type instance O.SignalList DevicePad = DevicePadSignalList
type DevicePadSignalList = ('[ '("changed", Gdk.Device.DeviceChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("toolChanged", Gdk.Device.DeviceToolChangedSignalInfo)] :: [(Symbol, *)])

#endif

foreign import ccall "gdk_device_pad_get_type"
    c_gdk_device_pad_get_type :: IO GType

instance GObject DevicePad where
    gobjectType = c_gdk_device_pad_get_type
    

-- | Type class for types which can be safely cast to `DevicePad`, for instance with `toDevicePad`.
class (GObject o, O.IsDescendantOf DevicePad o) => IsDevicePad o
instance (GObject o, O.IsDescendantOf DevicePad o) => IsDevicePad o

instance O.HasParentTypes DevicePad
type instance O.ParentTypes DevicePad = '[Gdk.Device.Device, GObject.Object.Object]

-- | Cast to `DevicePad`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDevicePad :: (MonadIO m, IsDevicePad o) => o -> m DevicePad
toDevicePad = liftIO . unsafeCastTo DevicePad

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

#if ENABLE_OVERLOADING
#endif

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

instance (info ~ ResolveDevicePadMethod t DevicePad, O.MethodInfo info DevicePad p) => OL.IsLabel t (DevicePad -> 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

-- method DevicePad::get_feature_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gdk", name = "DevicePad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevicePad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface (Name {namespace = "Gdk", name = "DevicePadFeature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the feature type to get the group from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature_idx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the feature to get the group from", 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_pad_get_feature_group" gdk_device_pad_get_feature_group :: 
    Ptr DevicePad ->                        -- pad : TInterface (Name {namespace = "Gdk", name = "DevicePad"})
    CUInt ->                                -- feature : TInterface (Name {namespace = "Gdk", name = "DevicePadFeature"})
    Int32 ->                                -- feature_idx : TBasicType TInt
    IO Int32

{- |
Returns the group the given /@feature@/ and /@idx@/ belong to,
or -1 if feature\/index do not exist in /@pad@/.

/Since: 3.22/
-}
devicePadGetFeatureGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevicePad a) =>
    a
    {- ^ /@pad@/: a 'GI.Gdk.Interfaces.DevicePad.DevicePad' -}
    -> Gdk.Enums.DevicePadFeature
    {- ^ /@feature@/: the feature type to get the group from -}
    -> Int32
    {- ^ /@featureIdx@/: the index of the feature to get the group from -}
    -> m Int32
    {- ^ __Returns:__ The group number of the queried pad feature. -}
devicePadGetFeatureGroup pad feature featureIdx = liftIO $ do
    pad' <- unsafeManagedPtrCastPtr pad
    let feature' = (fromIntegral . fromEnum) feature
    result <- gdk_device_pad_get_feature_group pad' feature' featureIdx
    touchManagedPtr pad
    return result

#if ENABLE_OVERLOADING
data DevicePadGetFeatureGroupMethodInfo
instance (signature ~ (Gdk.Enums.DevicePadFeature -> Int32 -> m Int32), MonadIO m, IsDevicePad a) => O.MethodInfo DevicePadGetFeatureGroupMethodInfo a signature where
    overloadedMethod _ = devicePadGetFeatureGroup

#endif

-- method DevicePad::get_group_n_modes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gdk", name = "DevicePad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevicePad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_idx", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "group to get the number of available modes from", 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_pad_get_group_n_modes" gdk_device_pad_get_group_n_modes :: 
    Ptr DevicePad ->                        -- pad : TInterface (Name {namespace = "Gdk", name = "DevicePad"})
    Int32 ->                                -- group_idx : TBasicType TInt
    IO Int32

{- |
Returns the number of modes that /@group@/ may have.

/Since: 3.22/
-}
devicePadGetGroupNModes ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevicePad a) =>
    a
    {- ^ /@pad@/: a 'GI.Gdk.Interfaces.DevicePad.DevicePad' -}
    -> Int32
    {- ^ /@groupIdx@/: group to get the number of available modes from -}
    -> m Int32
    {- ^ __Returns:__ The number of modes available in /@group@/. -}
devicePadGetGroupNModes pad groupIdx = liftIO $ do
    pad' <- unsafeManagedPtrCastPtr pad
    result <- gdk_device_pad_get_group_n_modes pad' groupIdx
    touchManagedPtr pad
    return result

#if ENABLE_OVERLOADING
data DevicePadGetGroupNModesMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsDevicePad a) => O.MethodInfo DevicePadGetGroupNModesMethodInfo a signature where
    overloadedMethod _ = devicePadGetGroupNModes

#endif

-- method DevicePad::get_n_features
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gdk", name = "DevicePad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevicePad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface (Name {namespace = "Gdk", name = "DevicePadFeature"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pad feature", 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_pad_get_n_features" gdk_device_pad_get_n_features :: 
    Ptr DevicePad ->                        -- pad : TInterface (Name {namespace = "Gdk", name = "DevicePad"})
    CUInt ->                                -- feature : TInterface (Name {namespace = "Gdk", name = "DevicePadFeature"})
    IO Int32

{- |
Returns the number of features a tablet pad has.

/Since: 3.22/
-}
devicePadGetNFeatures ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevicePad a) =>
    a
    {- ^ /@pad@/: a 'GI.Gdk.Interfaces.DevicePad.DevicePad' -}
    -> Gdk.Enums.DevicePadFeature
    {- ^ /@feature@/: a pad feature -}
    -> m Int32
    {- ^ __Returns:__ The amount of elements of type /@feature@/ that this pad has. -}
devicePadGetNFeatures pad feature = liftIO $ do
    pad' <- unsafeManagedPtrCastPtr pad
    let feature' = (fromIntegral . fromEnum) feature
    result <- gdk_device_pad_get_n_features pad' feature'
    touchManagedPtr pad
    return result

#if ENABLE_OVERLOADING
data DevicePadGetNFeaturesMethodInfo
instance (signature ~ (Gdk.Enums.DevicePadFeature -> m Int32), MonadIO m, IsDevicePad a) => O.MethodInfo DevicePadGetNFeaturesMethodInfo a signature where
    overloadedMethod _ = devicePadGetNFeatures

#endif

-- method DevicePad::get_n_groups
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gdk", name = "DevicePad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevicePad", 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_pad_get_n_groups" gdk_device_pad_get_n_groups :: 
    Ptr DevicePad ->                        -- pad : TInterface (Name {namespace = "Gdk", name = "DevicePad"})
    IO Int32

{- |
Returns the number of groups this pad device has. Pads have
at least one group. A pad group is a subcollection of
buttons\/strip\/rings that is affected collectively by a same
current mode.

/Since: 3.22/
-}
devicePadGetNGroups ::
    (B.CallStack.HasCallStack, MonadIO m, IsDevicePad a) =>
    a
    {- ^ /@pad@/: a 'GI.Gdk.Interfaces.DevicePad.DevicePad' -}
    -> m Int32
    {- ^ __Returns:__ The number of button\/ring\/strip groups in the pad. -}
devicePadGetNGroups pad = liftIO $ do
    pad' <- unsafeManagedPtrCastPtr pad
    result <- gdk_device_pad_get_n_groups pad'
    touchManagedPtr pad
    return result

#if ENABLE_OVERLOADING
data DevicePadGetNGroupsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsDevicePad a) => O.MethodInfo DevicePadGetNGroupsMethodInfo a signature where
    overloadedMethod _ = devicePadGetNGroups

#endif