    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Generated during 'GI.Gdk.Enums.InputSourceTabletPad' interaction with tactile sensors.
    --
    -- /Since: 3.22/

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gdk.Structs.EventPadAxis
        (

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

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveEventPadAxisMethod               ,
    #endif

     -- * 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 defined(ENABLE_OVERLOADING)
        eventPadAxis_group                      ,
    #endif
        getEventPadAxisGroup                    ,
        setEventPadAxisGroup                    ,

    -- ** index #attr:index#
    -- | number of strip\/ring that was interacted. This number is 0-indexed.

    #if defined(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 defined(ENABLE_OVERLOADING)
        eventPadAxis_mode                       ,
    #endif
        getEventPadAxisMode                     ,
        setEventPadAxisMode                     ,

    -- ** sendEvent #attr:sendEvent#
    -- | 'P.True' if the event was sent explicitly.

    #if defined(ENABLE_OVERLOADING)
        eventPadAxis_sendEvent                  ,
    #endif
        getEventPadAxisSendEvent                ,
        setEventPadAxisSendEvent                ,

    -- ** time #attr:time#
    -- | the time of the event in milliseconds.

    #if defined(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 defined(ENABLE_OVERLOADING)
        eventPadAxis_type                       ,
    #endif
        getEventPadAxisType                     ,
        setEventPadAxisType                     ,

    -- ** value #attr:value#
    -- | The current value for the given axis.

    #if defined(ENABLE_OVERLOADING)
        eventPadAxis_value                      ,
    #endif
        getEventPadAxisValue                    ,
        setEventPadAxisValue                    ,

    -- ** window #attr:window#
    -- | the window which received the event.

        clearEventPadAxisWindow                 ,
    #if defined(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.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    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.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    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 GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.Cairo.Enums as Cairo.Enums
    import qualified GI.Cairo.Structs.Context as Cairo.Context
    import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
    import qualified GI.Cairo.Structs.Pattern as Cairo.Pattern
    import qualified GI.Cairo.Structs.Region as Cairo.Region
    import qualified GI.Cairo.Structs.Surface as Cairo.Surface
    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Callbacks as Gdk.Callbacks
    import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
    import {-# SOURCE #-} qualified GI.Gdk.Objects.AppLaunchContext as Gdk.AppLaunchContext
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Device as Gdk.Device
    import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceManager as Gdk.DeviceManager
    import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceTool as Gdk.DeviceTool
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
    import {-# SOURCE #-} qualified GI.Gdk.Objects.DragContext as Gdk.DragContext
    import {-# SOURCE #-} qualified GI.Gdk.Objects.DrawingContext as Gdk.DrawingContext
    import {-# SOURCE #-} qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import {-# SOURCE #-} qualified GI.Gdk.Objects.GLContext as Gdk.GLContext
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Monitor as Gdk.Monitor
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Screen as Gdk.Screen
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Seat as Gdk.Seat
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Visual as Gdk.Visual
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
    import {-# SOURCE #-} qualified GI.Gdk.Structs.Atom as Gdk.Atom
    import {-# SOURCE #-} qualified GI.Gdk.Structs.Color as Gdk.Color
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventAny as Gdk.EventAny
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventButton as Gdk.EventButton
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventConfigure as Gdk.EventConfigure
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventCrossing as Gdk.EventCrossing
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventDND as Gdk.EventDND
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventExpose as Gdk.EventExpose
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventFocus as Gdk.EventFocus
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventGrabBroken as Gdk.EventGrabBroken
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventKey as Gdk.EventKey
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventMotion as Gdk.EventMotion
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventOwnerChange as Gdk.EventOwnerChange
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventPadButton as Gdk.EventPadButton
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventPadGroupMode as Gdk.EventPadGroupMode
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventProperty as Gdk.EventProperty
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventProximity as Gdk.EventProximity
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventScroll as Gdk.EventScroll
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventSelection as Gdk.EventSelection
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventSequence as Gdk.EventSequence
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventSetting as Gdk.EventSetting
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventTouch as Gdk.EventTouch
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventTouchpadPinch as Gdk.EventTouchpadPinch
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventTouchpadSwipe as Gdk.EventTouchpadSwipe
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventVisibility as Gdk.EventVisibility
    import {-# SOURCE #-} qualified GI.Gdk.Structs.EventWindowState as Gdk.EventWindowState
    import {-# SOURCE #-} qualified GI.Gdk.Structs.FrameTimings as Gdk.FrameTimings
    import {-# SOURCE #-} qualified GI.Gdk.Structs.Geometry as Gdk.Geometry
    import {-# SOURCE #-} qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import {-# SOURCE #-} qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
    import {-# SOURCE #-} qualified GI.Gdk.Structs.WindowAttr as Gdk.WindowAttr
    import {-# SOURCE #-} qualified GI.Gdk.Unions.Event as Gdk.Event
    import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
    import qualified GI.Gio.Interfaces.Icon as Gio.Icon
    import qualified GI.Gio.Objects.AppLaunchContext as Gio.AppLaunchContext

    #else
    import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window

    #endif

    -- | Memory-managed wrapper type.
    newtype EventPadAxis = EventPadAxis (SP.ManagedPtr EventPadAxis)
        deriving (EventPadAxis -> EventPadAxis -> Bool
    (EventPadAxis -> EventPadAxis -> Bool)
    -> (EventPadAxis -> EventPadAxis -> Bool) -> Eq EventPadAxis
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EventPadAxis -> EventPadAxis -> Bool
    == :: EventPadAxis -> EventPadAxis -> Bool
    $c/= :: EventPadAxis -> EventPadAxis -> Bool
    /= :: EventPadAxis -> EventPadAxis -> Bool
    Eq)

    instance SP.ManagedPtrNewtype EventPadAxis where
        toManagedPtr :: EventPadAxis -> ManagedPtr EventPadAxis
    toManagedPtr (EventPadAxis ManagedPtr EventPadAxis
    p) = ManagedPtr EventPadAxis
    p

    instance BoxedPtr EventPadAxis where
        boxedPtrCopy :: EventPadAxis -> IO EventPadAxis
    boxedPtrCopy = \EventPadAxis
    p -> EventPadAxis
    -> (Ptr EventPadAxis -> IO EventPadAxis) -> IO EventPadAxis
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr EventPadAxis
    p (Int -> Ptr EventPadAxis -> IO (Ptr EventPadAxis)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes Int
    48 (Ptr EventPadAxis -> IO (Ptr EventPadAxis))
    -> (Ptr EventPadAxis -> IO EventPadAxis)
    -> Ptr EventPadAxis
    -> IO EventPadAxis
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr EventPadAxis -> EventPadAxis)
    -> Ptr EventPadAxis -> IO EventPadAxis
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr EventPadAxis -> EventPadAxis
    EventPadAxis)
        boxedPtrFree :: EventPadAxis -> IO ()
    boxedPtrFree = \EventPadAxis
    x -> EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr EventPadAxis
    x Ptr EventPadAxis -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr EventPadAxis where
        boxedPtrCalloc :: IO (Ptr EventPadAxis)
    boxedPtrCalloc = Int -> IO (Ptr EventPadAxis)
    forall a. Int -> IO (Ptr a)
    callocBytes Int
    48

    -- | Construct a t'EventPadAxis' struct initialized to zero.
    newZeroEventPadAxis :: MonadIO m => m EventPadAxis
    newZeroEventPadAxis :: forall (m :: * -> *). MonadIO m => m EventPadAxis
    newZeroEventPadAxis = IO EventPadAxis -> m EventPadAxis
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO EventPadAxis -> m EventPadAxis)
    -> IO EventPadAxis -> m EventPadAxis
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr EventPadAxis)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr EventPadAxis)
    -> (Ptr EventPadAxis -> IO EventPadAxis) -> IO EventPadAxis
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr EventPadAxis -> EventPadAxis)
    -> Ptr EventPadAxis -> IO EventPadAxis
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr EventPadAxis -> EventPadAxis
    EventPadAxis

    instance tag ~ 'AttrSet => Constructible EventPadAxis tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr EventPadAxis -> EventPadAxis)
    -> [AttrOp EventPadAxis tag] -> m EventPadAxis
    new ManagedPtr EventPadAxis -> EventPadAxis
    _ [AttrOp EventPadAxis tag]
    attrs = do
            o <- m EventPadAxis
    forall (m :: * -> *). MonadIO m => m EventPadAxis
    newZeroEventPadAxis
            GI.Attributes.set o attrs
            return o

    -- | 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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m EventType
    getEventPadAxisType EventPadAxis
    s = IO EventType -> m EventType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO EventType -> m EventType) -> IO EventType -> m EventType
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO EventType) -> IO EventType
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO EventType) -> IO EventType)
    -> (Ptr EventPadAxis -> IO EventType) -> IO EventType
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr CInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO CInt
        let val' = (Int -> EventType
    forall a. Enum a => Int -> a
    toEnum (Int -> EventType) -> (CInt -> Int) -> CInt -> EventType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CInt
    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 :: forall (m :: * -> *).
    MonadIO m =>
    EventPadAxis -> EventType -> m ()
    setEventPadAxisType EventPadAxis
    s EventType
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        let val' :: CInt
    val' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (EventType -> Int) -> EventType -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EventType -> Int
    forall a. Enum a => a -> Int
    fromEnum) EventType
    val
        Ptr CInt -> CInt -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr CInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (CInt
    val' :: CInt)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisTypeFieldInfo
    instance AttrInfo EventPadAxisTypeFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisTypeFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisTypeFieldInfo = (~) Gdk.Enums.EventType
        type AttrTransferTypeConstraint EventPadAxisTypeFieldInfo = (~)Gdk.Enums.EventType
        type AttrTransferType EventPadAxisTypeFieldInfo = Gdk.Enums.EventType
        type AttrGetType EventPadAxisTypeFieldInfo = Gdk.Enums.EventType
        type AttrLabel EventPadAxisTypeFieldInfo = "type"
        type AttrOrigin EventPadAxisTypeFieldInfo = EventPadAxis
        attrGet = getEventPadAxisType
        attrSet = setEventPadAxisType
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.type"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:type"
            })

    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m (Maybe Window)
    getEventPadAxisWindow EventPadAxis
    s = IO (Maybe Window) -> m (Maybe Window)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Window) -> m (Maybe Window))
    -> IO (Maybe Window) -> m (Maybe Window)
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis
    -> (Ptr EventPadAxis -> IO (Maybe Window)) -> IO (Maybe Window)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO (Maybe Window)) -> IO (Maybe Window))
    -> (Ptr EventPadAxis -> IO (Maybe Window)) -> IO (Maybe Window)
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr (Ptr Window) -> IO (Ptr Window)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr (Ptr Window)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) :: IO (Ptr Gdk.Window.Window)
        result <- SP.convertIfNonNull val $ \Ptr Window
    val' -> do
            val'' <- ((ManagedPtr Window -> Window) -> Ptr Window -> IO Window
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Window -> Window
    Gdk.Window.Window) Ptr 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 :: forall (m :: * -> *).
    MonadIO m =>
    EventPadAxis -> Ptr Window -> m ()
    setEventPadAxisWindow EventPadAxis
    s Ptr Window
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        Ptr (Ptr Window) -> Ptr Window -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr (Ptr Window)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (Ptr Window
    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m ()
    clearEventPadAxisWindow EventPadAxis
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        Ptr (Ptr Window) -> Ptr Window -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr (Ptr Window)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (Ptr Window
    forall a. Ptr a
    FP.nullPtr :: Ptr Gdk.Window.Window)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisWindowFieldInfo
    instance AttrInfo EventPadAxisWindowFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisWindowFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisWindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint EventPadAxisWindowFieldInfo = (~) (Ptr Gdk.Window.Window)
        type AttrTransferTypeConstraint EventPadAxisWindowFieldInfo = (~)(Ptr Gdk.Window.Window)
        type AttrTransferType EventPadAxisWindowFieldInfo = (Ptr Gdk.Window.Window)
        type AttrGetType EventPadAxisWindowFieldInfo = Maybe Gdk.Window.Window
        type AttrLabel EventPadAxisWindowFieldInfo = "window"
        type AttrOrigin EventPadAxisWindowFieldInfo = EventPadAxis
        attrGet = getEventPadAxisWindow
        attrSet = setEventPadAxisWindow
        attrConstruct = undefined
        attrClear = clearEventPadAxisWindow
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.window"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:window"
            })

    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m Int8
    getEventPadAxisSendEvent EventPadAxis
    s = IO Int8 -> m Int8
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int8 -> m Int8) -> IO Int8 -> m Int8
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO Int8) -> IO Int8
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO Int8) -> IO Int8)
    -> (Ptr EventPadAxis -> IO Int8) -> IO Int8
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr Int8 -> IO Int8
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Int8
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> Int8 -> m ()
    setEventPadAxisSendEvent EventPadAxis
    s Int8
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        Ptr Int8 -> Int8 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Int8
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) (Int8
    val :: Int8)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisSendEventFieldInfo
    instance AttrInfo EventPadAxisSendEventFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisSendEventFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisSendEventFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisSendEventFieldInfo = (~) Int8
        type AttrTransferTypeConstraint EventPadAxisSendEventFieldInfo = (~)Int8
        type AttrTransferType EventPadAxisSendEventFieldInfo = Int8
        type AttrGetType EventPadAxisSendEventFieldInfo = Int8
        type AttrLabel EventPadAxisSendEventFieldInfo = "send_event"
        type AttrOrigin EventPadAxisSendEventFieldInfo = EventPadAxis
        attrGet = getEventPadAxisSendEvent
        attrSet = setEventPadAxisSendEvent
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.sendEvent"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:sendEvent"
            })

    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisTime EventPadAxis
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO Word32) -> IO Word32)
    -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisTime EventPadAxis
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    20) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisTimeFieldInfo
    instance AttrInfo EventPadAxisTimeFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisTimeFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisTimeFieldInfo = (~) Word32
        type AttrTransferTypeConstraint EventPadAxisTimeFieldInfo = (~)Word32
        type AttrTransferType EventPadAxisTimeFieldInfo = Word32
        type AttrGetType EventPadAxisTimeFieldInfo = Word32
        type AttrLabel EventPadAxisTimeFieldInfo = "time"
        type AttrOrigin EventPadAxisTimeFieldInfo = EventPadAxis
        attrGet = getEventPadAxisTime
        attrSet = setEventPadAxisTime
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.time"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:time"
            })

    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisGroup EventPadAxis
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO Word32) -> IO Word32)
    -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisGroup EventPadAxis
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisGroupFieldInfo
    instance AttrInfo EventPadAxisGroupFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisGroupFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisGroupFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisGroupFieldInfo = (~) Word32
        type AttrTransferTypeConstraint EventPadAxisGroupFieldInfo = (~)Word32
        type AttrTransferType EventPadAxisGroupFieldInfo = Word32
        type AttrGetType EventPadAxisGroupFieldInfo = Word32
        type AttrLabel EventPadAxisGroupFieldInfo = "group"
        type AttrOrigin EventPadAxisGroupFieldInfo = EventPadAxis
        attrGet = getEventPadAxisGroup
        attrSet = setEventPadAxisGroup
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.group"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:group"
            })

    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisIndex EventPadAxis
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO Word32) -> IO Word32)
    -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisIndex EventPadAxis
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    28) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisIndexFieldInfo
    instance AttrInfo EventPadAxisIndexFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisIndexFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisIndexFieldInfo = (~) Word32
        type AttrTransferTypeConstraint EventPadAxisIndexFieldInfo = (~)Word32
        type AttrTransferType EventPadAxisIndexFieldInfo = Word32
        type AttrGetType EventPadAxisIndexFieldInfo = Word32
        type AttrLabel EventPadAxisIndexFieldInfo = "index"
        type AttrOrigin EventPadAxisIndexFieldInfo = EventPadAxis
        attrGet = getEventPadAxisIndex
        attrSet = setEventPadAxisIndex
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.index"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:index"
            })

    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m Word32
    getEventPadAxisMode EventPadAxis
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO Word32) -> IO Word32)
    -> (Ptr EventPadAxis -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> Word32 -> m ()
    setEventPadAxisMode EventPadAxis
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisModeFieldInfo
    instance AttrInfo EventPadAxisModeFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisModeFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisModeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisModeFieldInfo = (~) Word32
        type AttrTransferTypeConstraint EventPadAxisModeFieldInfo = (~)Word32
        type AttrTransferType EventPadAxisModeFieldInfo = Word32
        type AttrGetType EventPadAxisModeFieldInfo = Word32
        type AttrLabel EventPadAxisModeFieldInfo = "mode"
        type AttrOrigin EventPadAxisModeFieldInfo = EventPadAxis
        attrGet = getEventPadAxisMode
        attrSet = setEventPadAxisMode
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.mode"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:mode"
            })

    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> m Double
    getEventPadAxisValue EventPadAxis
    s = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO Double) -> IO Double
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO Double) -> IO Double)
    -> (Ptr EventPadAxis -> IO Double) -> IO Double
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        val <- Ptr CDouble -> IO CDouble
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    40) :: IO CDouble
        let val' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    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 :: forall (m :: * -> *). MonadIO m => EventPadAxis -> Double -> m ()
    setEventPadAxisValue EventPadAxis
    s Double
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EventPadAxis -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EventPadAxis
    s ((Ptr EventPadAxis -> IO ()) -> IO ())
    -> (Ptr EventPadAxis -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr EventPadAxis
    ptr -> do
        let val' :: CDouble
    val' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    val
        Ptr CDouble -> CDouble -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EventPadAxis
    ptr Ptr EventPadAxis -> Int -> Ptr CDouble
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    40) (CDouble
    val' :: CDouble)

    #if defined(ENABLE_OVERLOADING)
    data EventPadAxisValueFieldInfo
    instance AttrInfo EventPadAxisValueFieldInfo where
        type AttrBaseTypeConstraint EventPadAxisValueFieldInfo = (~) EventPadAxis
        type AttrAllowedOps EventPadAxisValueFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EventPadAxisValueFieldInfo = (~) Double
        type AttrTransferTypeConstraint EventPadAxisValueFieldInfo = (~)Double
        type AttrTransferType EventPadAxisValueFieldInfo = Double
        type AttrGetType EventPadAxisValueFieldInfo = Double
        type AttrLabel EventPadAxisValueFieldInfo = "value"
        type AttrOrigin EventPadAxisValueFieldInfo = EventPadAxis
        attrGet = getEventPadAxisValue
        attrSet = setEventPadAxisValue
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.EventPadAxis.value"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.29/docs/GI-Gdk-Structs-EventPadAxis.html#g:attr:value"
            })

    eventPadAxis_value :: AttrLabelProxy "value"
    eventPadAxis_value = AttrLabelProxy

    #endif

    #if defined(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, DK.Type)])
    #endif

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

    instance (info ~ ResolveEventPadAxisMethod t EventPadAxis, O.OverloadedMethod info EventPadAxis p) => OL.IsLabel t (EventPadAxis -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveEventPadAxisMethod t EventPadAxis, O.OverloadedMethod info EventPadAxis p, R.HasField t EventPadAxis p) => R.HasField t EventPadAxis p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveEventPadAxisMethod t EventPadAxis, O.OverloadedMethodInfo info EventPadAxis) => OL.IsLabel t (O.MethodProxy info EventPadAxis) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif