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

    #define ENABLE_OVERLOADING \
           (!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.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.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
    -- | 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 => 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

    -- | 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) => 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
    #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

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