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

'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.
-}

module GI.Gdk.Interfaces.DevicePad
    ( 

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


 -- * Methods
-- ** getFeatureGroup #method:getFeatureGroup#
    DevicePadGetFeatureGroupMethodInfo      ,
    devicePadGetFeatureGroup                ,


-- ** getGroupNModes #method:getGroupNModes#
    DevicePadGetGroupNModesMethodInfo       ,
    devicePadGetGroupNModes                 ,


-- ** getNFeatures #method:getNFeatures#
    DevicePadGetNFeaturesMethodInfo         ,
    devicePadGetNFeatures                   ,


-- ** getNGroups #method:getNGroups#
    DevicePadGetNGroupsMethodInfo           ,
    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.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.Objects.Device as Gdk.Device

-- interface DevicePad 
newtype DevicePad = DevicePad (ManagedPtr DevicePad)
noDevicePad :: Maybe DevicePad
noDevicePad = Nothing

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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDevicePadMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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) => O.IsLabelProxy t (DevicePad -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

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, *)])

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

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
    

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

toDevicePad :: IsDevicePad o => o -> IO DevicePad
toDevicePad = unsafeCastTo DevicePad

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

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

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

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

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

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

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

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