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

    Generated during 'GI.Gdk.Enums.InputSourceTabletPad' interaction with tactile sensors.

    /Since: 3.22/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gdk.Structs.EventPadAxis
        (

    -- * Exported types
        EventPadAxis(..)                        ,
        newZeroEventPadAxis                     ,
        noEventPadAxis                          ,

     -- * Properties
    -- ** group #attr:group#
    {- | the pad group the ring\/strip belongs to. A 'GI.Gdk.Enums.InputSourceTabletPad'
      device may have one or more groups containing a set of buttons\/rings\/strips
      each.
    -}
    #if ENABLE_OVERLOADING
        eventPadAxis_group                      ,
    #endif
        getEventPadAxisGroup                    ,
        setEventPadAxisGroup                    ,

    -- ** index #attr:index#
    {- | number of strip\/ring that was interacted. This number is 0-indexed.
    -}
    #if ENABLE_OVERLOADING
        eventPadAxis_index                      ,
    #endif
        getEventPadAxisIndex                    ,
        setEventPadAxisIndex                    ,

    -- ** mode #attr:mode#
    {- | The current mode of /@group@/. Different groups in a 'GI.Gdk.Enums.InputSourceTabletPad'
      device may have different current modes.
    -}
    #if ENABLE_OVERLOADING
        eventPadAxis_mode                       ,
    #endif
        getEventPadAxisMode                     ,
        setEventPadAxisMode                     ,

    -- ** sendEvent #attr:sendEvent#
    {- | 'True' if the event was sent explicitly.
    -}
    #if ENABLE_OVERLOADING
        eventPadAxis_sendEvent                  ,
    #endif
        getEventPadAxisSendEvent                ,
        setEventPadAxisSendEvent                ,

    -- ** time #attr:time#
    {- | the time of the event in milliseconds.
    -}
    #if ENABLE_OVERLOADING
        eventPadAxis_time                       ,
    #endif
        getEventPadAxisTime                     ,
        setEventPadAxisTime                     ,

    -- ** type #attr:type#
    {- | the type of the event ('GI.Gdk.Enums.EventTypePadRing' or 'GI.Gdk.Enums.EventTypePadStrip').
    -}
    #if ENABLE_OVERLOADING
        eventPadAxis_type                       ,
    #endif
        getEventPadAxisType                     ,
        setEventPadAxisType                     ,

    -- ** value #attr:value#
    {- | The current value for the given axis.
    -}
    #if ENABLE_OVERLOADING
        eventPadAxis_value                      ,
    #endif
        getEventPadAxisValue                    ,
        setEventPadAxisValue                    ,

    -- ** window #attr:window#
    {- | the window which received the event.
    -}
        clearEventPadAxisWindow                 ,
    #if ENABLE_OVERLOADING
        eventPadAxis_window                     ,
    #endif
        getEventPadAxisWindow                   ,
        setEventPadAxisWindow                   ,

        ) 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 {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window

    -- | Memory-managed wrapper type.
    newtype EventPadAxis = EventPadAxis (ManagedPtr EventPadAxis)
    instance WrappedPtr EventPadAxis where
        wrappedPtrCalloc = callocBytes 48
        wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 48 >=> wrapPtr EventPadAxis)
        wrappedPtrFree = Just ptr_to_g_free

    -- | Construct a `EventPadAxis` struct initialized to zero.
    newZeroEventPadAxis :: MonadIO m => m EventPadAxis
    newZeroEventPadAxis = liftIO $ wrappedPtrCalloc >>= wrapPtr EventPadAxis

    instance tag ~ 'AttrSet => Constructible EventPadAxis tag where
        new _ attrs = do
            o <- newZeroEventPadAxis
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `EventPadAxis`.
    noEventPadAxis :: Maybe EventPadAxis
    noEventPadAxis = Nothing

    {- |
    Get the value of the “@type@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #type
    @
    -}
    getEventPadAxisType :: MonadIO m => EventPadAxis -> m Gdk.Enums.EventType
    getEventPadAxisType s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 0) :: IO CInt
        let val' = (toEnum . fromIntegral) val
        return val'

    {- |
    Set the value of the “@type@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #type 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisType :: MonadIO m => EventPadAxis -> Gdk.Enums.EventType -> m ()
    setEventPadAxisType s val = liftIO $ withManagedPtr s $ \ptr -> do
        let val' = (fromIntegral . fromEnum) val
        poke (ptr `plusPtr` 0) (val' :: CInt)

    #if ENABLE_OVERLOADING
    data EventPadAxisTypeFieldInfo
    instance AttrInfo EventPadAxisTypeFieldInfo where
        type AttrAllowedOps EventPadAxisTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisTypeFieldInfo = (~) Gdk.Enums.EventType
        type AttrBaseTypeConstraint EventPadAxisTypeFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisTypeFieldInfo = Gdk.Enums.EventType
        type AttrLabel EventPadAxisTypeFieldInfo = "type"
        type AttrOrigin EventPadAxisTypeFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisType
        attrSet _ = setEventPadAxisType
        attrConstruct = undefined
        attrClear _ = undefined

    eventPadAxis_type :: AttrLabelProxy "type"
    eventPadAxis_type = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@window@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #window
    @
    -}
    getEventPadAxisWindow :: MonadIO m => EventPadAxis -> m (Maybe Gdk.Window.Window)
    getEventPadAxisWindow s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gdk.Window.Window)
        result <- SP.convertIfNonNull val $ \val' -> do
            val'' <- (newObject Gdk.Window.Window) val'
            return val''
        return result

    {- |
    Set the value of the “@window@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #window 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisWindow :: MonadIO m => EventPadAxis -> Ptr Gdk.Window.Window -> m ()
    setEventPadAxisWindow s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (val :: Ptr Gdk.Window.Window)

    {- |
    Set the value of the “@window@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #window
    @
    -}
    clearEventPadAxisWindow :: MonadIO m => EventPadAxis -> m ()
    clearEventPadAxisWindow s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gdk.Window.Window)

    #if ENABLE_OVERLOADING
    data EventPadAxisWindowFieldInfo
    instance AttrInfo EventPadAxisWindowFieldInfo where
        type AttrAllowedOps EventPadAxisWindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint EventPadAxisWindowFieldInfo = (~) (Ptr Gdk.Window.Window)
        type AttrBaseTypeConstraint EventPadAxisWindowFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisWindowFieldInfo = Maybe Gdk.Window.Window
        type AttrLabel EventPadAxisWindowFieldInfo = "window"
        type AttrOrigin EventPadAxisWindowFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisWindow
        attrSet _ = setEventPadAxisWindow
        attrConstruct = undefined
        attrClear _ = clearEventPadAxisWindow

    eventPadAxis_window :: AttrLabelProxy "window"
    eventPadAxis_window = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@send_event@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #sendEvent
    @
    -}
    getEventPadAxisSendEvent :: MonadIO m => EventPadAxis -> m Int8
    getEventPadAxisSendEvent s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 16) :: IO Int8
        return val

    {- |
    Set the value of the “@send_event@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #sendEvent 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisSendEvent :: MonadIO m => EventPadAxis -> Int8 -> m ()
    setEventPadAxisSendEvent s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (val :: Int8)

    #if ENABLE_OVERLOADING
    data EventPadAxisSendEventFieldInfo
    instance AttrInfo EventPadAxisSendEventFieldInfo where
        type AttrAllowedOps EventPadAxisSendEventFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisSendEventFieldInfo = (~) Int8
        type AttrBaseTypeConstraint EventPadAxisSendEventFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisSendEventFieldInfo = Int8
        type AttrLabel EventPadAxisSendEventFieldInfo = "send_event"
        type AttrOrigin EventPadAxisSendEventFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisSendEvent
        attrSet _ = setEventPadAxisSendEvent
        attrConstruct = undefined
        attrClear _ = undefined

    eventPadAxis_sendEvent :: AttrLabelProxy "sendEvent"
    eventPadAxis_sendEvent = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@time@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #time
    @
    -}
    getEventPadAxisTime :: MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisTime s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 20) :: IO Word32
        return val

    {- |
    Set the value of the “@time@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #time 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisTime :: MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisTime s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 20) (val :: Word32)

    #if ENABLE_OVERLOADING
    data EventPadAxisTimeFieldInfo
    instance AttrInfo EventPadAxisTimeFieldInfo where
        type AttrAllowedOps EventPadAxisTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisTimeFieldInfo = (~) Word32
        type AttrBaseTypeConstraint EventPadAxisTimeFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisTimeFieldInfo = Word32
        type AttrLabel EventPadAxisTimeFieldInfo = "time"
        type AttrOrigin EventPadAxisTimeFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisTime
        attrSet _ = setEventPadAxisTime
        attrConstruct = undefined
        attrClear _ = undefined

    eventPadAxis_time :: AttrLabelProxy "time"
    eventPadAxis_time = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@group@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #group
    @
    -}
    getEventPadAxisGroup :: MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisGroup s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 24) :: IO Word32
        return val

    {- |
    Set the value of the “@group@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #group 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisGroup :: MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisGroup s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 24) (val :: Word32)

    #if ENABLE_OVERLOADING
    data EventPadAxisGroupFieldInfo
    instance AttrInfo EventPadAxisGroupFieldInfo where
        type AttrAllowedOps EventPadAxisGroupFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisGroupFieldInfo = (~) Word32
        type AttrBaseTypeConstraint EventPadAxisGroupFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisGroupFieldInfo = Word32
        type AttrLabel EventPadAxisGroupFieldInfo = "group"
        type AttrOrigin EventPadAxisGroupFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisGroup
        attrSet _ = setEventPadAxisGroup
        attrConstruct = undefined
        attrClear _ = undefined

    eventPadAxis_group :: AttrLabelProxy "group"
    eventPadAxis_group = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@index@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #index
    @
    -}
    getEventPadAxisIndex :: MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisIndex s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 28) :: IO Word32
        return val

    {- |
    Set the value of the “@index@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #index 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisIndex :: MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisIndex s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 28) (val :: Word32)

    #if ENABLE_OVERLOADING
    data EventPadAxisIndexFieldInfo
    instance AttrInfo EventPadAxisIndexFieldInfo where
        type AttrAllowedOps EventPadAxisIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisIndexFieldInfo = (~) Word32
        type AttrBaseTypeConstraint EventPadAxisIndexFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisIndexFieldInfo = Word32
        type AttrLabel EventPadAxisIndexFieldInfo = "index"
        type AttrOrigin EventPadAxisIndexFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisIndex
        attrSet _ = setEventPadAxisIndex
        attrConstruct = undefined
        attrClear _ = undefined

    eventPadAxis_index :: AttrLabelProxy "index"
    eventPadAxis_index = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@mode@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #mode
    @
    -}
    getEventPadAxisMode :: MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisMode s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 32) :: IO Word32
        return val

    {- |
    Set the value of the “@mode@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #mode 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisMode :: MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisMode s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 32) (val :: Word32)

    #if ENABLE_OVERLOADING
    data EventPadAxisModeFieldInfo
    instance AttrInfo EventPadAxisModeFieldInfo where
        type AttrAllowedOps EventPadAxisModeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisModeFieldInfo = (~) Word32
        type AttrBaseTypeConstraint EventPadAxisModeFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisModeFieldInfo = Word32
        type AttrLabel EventPadAxisModeFieldInfo = "mode"
        type AttrOrigin EventPadAxisModeFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisMode
        attrSet _ = setEventPadAxisMode
        attrConstruct = undefined
        attrClear _ = undefined

    eventPadAxis_mode :: AttrLabelProxy "mode"
    eventPadAxis_mode = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@value@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' eventPadAxis #value
    @
    -}
    getEventPadAxisValue :: MonadIO m => EventPadAxis -> m Double
    getEventPadAxisValue s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 40) :: IO CDouble
        let val' = realToFrac val
        return val'

    {- |
    Set the value of the “@value@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' eventPadAxis [ #value 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setEventPadAxisValue :: MonadIO m => EventPadAxis -> Double -> m ()
    setEventPadAxisValue s val = liftIO $ withManagedPtr s $ \ptr -> do
        let val' = realToFrac val
        poke (ptr `plusPtr` 40) (val' :: CDouble)

    #if ENABLE_OVERLOADING
    data EventPadAxisValueFieldInfo
    instance AttrInfo EventPadAxisValueFieldInfo where
        type AttrAllowedOps EventPadAxisValueFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisValueFieldInfo = (~) Double
        type AttrBaseTypeConstraint EventPadAxisValueFieldInfo = (~) EventPadAxis
        type AttrGetType EventPadAxisValueFieldInfo = Double
        type AttrLabel EventPadAxisValueFieldInfo = "value"
        type AttrOrigin EventPadAxisValueFieldInfo = EventPadAxis
        attrGet _ = getEventPadAxisValue
        attrSet _ = setEventPadAxisValue
        attrConstruct = undefined
        attrClear _ = undefined

    eventPadAxis_value :: AttrLabelProxy "value"
    eventPadAxis_value = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList EventPadAxis
    type instance O.AttributeList EventPadAxis = EventPadAxisAttributeList
    type EventPadAxisAttributeList = ('[ '("type", EventPadAxisTypeFieldInfo), '("window", EventPadAxisWindowFieldInfo), '("sendEvent", EventPadAxisSendEventFieldInfo), '("time", EventPadAxisTimeFieldInfo), '("group", EventPadAxisGroupFieldInfo), '("index", EventPadAxisIndexFieldInfo), '("mode", EventPadAxisModeFieldInfo), '("value", EventPadAxisValueFieldInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    type family ResolveEventPadAxisMethod (t :: Symbol) (o :: *) :: * where
        ResolveEventPadAxisMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveEventPadAxisMethod t EventPadAxis, O.MethodInfo info EventPadAxis p) => O.IsLabel t (EventPadAxis -> 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