{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Used for touch events.
-- /@type@/ field will be one of 'GI.Gdk.Enums.EventTypeTouchBegin', 'GI.Gdk.Enums.EventTypeTouchUpdate',
-- 'GI.Gdk.Enums.EventTypeTouchEnd' or 'GI.Gdk.Enums.EventTypeTouchCancel'.
-- 
-- Touch events are grouped into sequences by means of the /@sequence@/
-- field, which can also be obtained with 'GI.Gdk.Unions.Event.eventGetEventSequence'.
-- Each sequence begins with a 'GI.Gdk.Enums.EventTypeTouchBegin' event, followed by
-- any number of 'GI.Gdk.Enums.EventTypeTouchUpdate' events, and ends with a 'GI.Gdk.Enums.EventTypeTouchEnd'
-- (or 'GI.Gdk.Enums.EventTypeTouchCancel') event. With multitouch devices, there may be
-- several active sequences at the same time.

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

module GI.Gdk.Structs.EventTouch
    ( 

-- * Exported types
    EventTouch(..)                          ,
    newZeroEventTouch                       ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveEventTouchMethod                 ,
#endif



 -- * Properties


-- ** axes #attr:axes#
-- | /@x@/, /@y@/ translated to the axes of /@device@/, or 'P.Nothing' if /@device@/ is
--   the mouse

#if defined(ENABLE_OVERLOADING)
    eventTouch_axes                         ,
#endif
    getEventTouchAxes                       ,
    setEventTouchAxes                       ,


-- ** device #attr:device#
-- | the master device that the event originated from. Use
-- 'GI.Gdk.Unions.Event.eventGetSourceDevice' to get the slave device.

    clearEventTouchDevice                   ,
#if defined(ENABLE_OVERLOADING)
    eventTouch_device                       ,
#endif
    getEventTouchDevice                     ,
    setEventTouchDevice                     ,


-- ** emulatingPointer #attr:emulatingPointer#
-- | whether the event should be used for emulating
--   pointer event

#if defined(ENABLE_OVERLOADING)
    eventTouch_emulatingPointer             ,
#endif
    getEventTouchEmulatingPointer           ,
    setEventTouchEmulatingPointer           ,


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

#if defined(ENABLE_OVERLOADING)
    eventTouch_sendEvent                    ,
#endif
    getEventTouchSendEvent                  ,
    setEventTouchSendEvent                  ,


-- ** sequence #attr:sequence#
-- | the event sequence that the event belongs to

    clearEventTouchSequence                 ,
#if defined(ENABLE_OVERLOADING)
    eventTouch_sequence                     ,
#endif
    getEventTouchSequence                   ,
    setEventTouchSequence                   ,


-- ** state #attr:state#
-- | a bit-mask representing the state of
--   the modifier keys (e.g. Control, Shift and Alt) and the pointer
--   buttons. See t'GI.Gdk.Flags.ModifierType'

#if defined(ENABLE_OVERLOADING)
    eventTouch_state                        ,
#endif
    getEventTouchState                      ,
    setEventTouchState                      ,


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

#if defined(ENABLE_OVERLOADING)
    eventTouch_time                         ,
#endif
    getEventTouchTime                       ,
    setEventTouchTime                       ,


-- ** type #attr:type#
-- | the type of the event ('GI.Gdk.Enums.EventTypeTouchBegin', 'GI.Gdk.Enums.EventTypeTouchUpdate',
--   'GI.Gdk.Enums.EventTypeTouchEnd', 'GI.Gdk.Enums.EventTypeTouchCancel')

#if defined(ENABLE_OVERLOADING)
    eventTouch_type                         ,
#endif
    getEventTouchType                       ,
    setEventTouchType                       ,


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

    clearEventTouchWindow                   ,
#if defined(ENABLE_OVERLOADING)
    eventTouch_window                       ,
#endif
    getEventTouchWindow                     ,
    setEventTouchWindow                     ,


-- ** x #attr:x#
-- | the x coordinate of the pointer relative to the window

#if defined(ENABLE_OVERLOADING)
    eventTouch_x                            ,
#endif
    getEventTouchX                          ,
    setEventTouchX                          ,


-- ** xRoot #attr:xRoot#
-- | the x coordinate of the pointer relative to the root of the
--   screen

#if defined(ENABLE_OVERLOADING)
    eventTouch_xRoot                        ,
#endif
    getEventTouchXRoot                      ,
    setEventTouchXRoot                      ,


-- ** y #attr:y#
-- | the y coordinate of the pointer relative to the window

#if defined(ENABLE_OVERLOADING)
    eventTouch_y                            ,
#endif
    getEventTouchY                          ,
    setEventTouchY                          ,


-- ** yRoot #attr:yRoot#
-- | the y coordinate of the pointer relative to the root of the
--   screen

#if defined(ENABLE_OVERLOADING)
    eventTouch_yRoot                        ,
#endif
    getEventTouchYRoot                      ,
    setEventTouchYRoot                      ,




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

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

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

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


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

instance tag ~ 'AttrSet => Constructible EventTouch tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr EventTouch -> EventTouch)
-> [AttrOp EventTouch tag] -> m EventTouch
new ManagedPtr EventTouch -> EventTouch
_ [AttrOp EventTouch tag]
attrs = do
        EventTouch
o <- forall (m :: * -> *). MonadIO m => m EventTouch
newZeroEventTouch
        forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set EventTouch
o [AttrOp EventTouch tag]
attrs
        forall (m :: * -> *) a. Monad m => a -> m a
return EventTouch
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' eventTouch #type
-- @
getEventTouchType :: MonadIO m => EventTouch -> m Gdk.Enums.EventType
getEventTouchType :: forall (m :: * -> *). MonadIO m => EventTouch -> m EventType
getEventTouchType EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CInt
    let val' :: EventType
val' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
val
    forall (m :: * -> *) a. Monad m => a -> m a
return EventType
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' eventTouch [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchType :: MonadIO m => EventTouch -> Gdk.Enums.EventType -> m ()
setEventTouchType :: forall (m :: * -> *). MonadIO m => EventTouch -> EventType -> m ()
setEventTouchType EventTouch
s EventType
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CInt
val' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) EventType
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)

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

eventTouch_type :: AttrLabelProxy "type"
eventTouch_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' eventTouch #window
-- @
getEventTouchWindow :: MonadIO m => EventTouch -> m (Maybe Gdk.Window.Window)
getEventTouchWindow :: forall (m :: * -> *). MonadIO m => EventTouch -> m (Maybe Window)
getEventTouchWindow EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    Ptr Window
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (Ptr Gdk.Window.Window)
    Maybe Window
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Window
val forall a b. (a -> b) -> a -> b
$ \Ptr Window
val' -> do
        Window
val'' <- (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'
        forall (m :: * -> *) a. Monad m => a -> m a
return Window
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Window
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' eventTouch [ #window 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchWindow :: MonadIO m => EventTouch -> Ptr Gdk.Window.Window -> m ()
setEventTouchWindow :: forall (m :: * -> *). MonadIO m => EventTouch -> Ptr Window -> m ()
setEventTouchWindow EventTouch
s Ptr Window
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (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
-- @
clearEventTouchWindow :: MonadIO m => EventTouch -> m ()
clearEventTouchWindow :: forall (m :: * -> *). MonadIO m => EventTouch -> m ()
clearEventTouchWindow EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: Ptr Gdk.Window.Window)

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

eventTouch_window :: AttrLabelProxy "window"
eventTouch_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' eventTouch #sendEvent
-- @
getEventTouchSendEvent :: MonadIO m => EventTouch -> m Int8
getEventTouchSendEvent :: forall (m :: * -> *). MonadIO m => EventTouch -> m Int8
getEventTouchSendEvent EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    Int8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int8
    forall (m :: * -> *) a. Monad m => a -> m a
return Int8
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' eventTouch [ #sendEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchSendEvent :: MonadIO m => EventTouch -> Int8 -> m ()
setEventTouchSendEvent :: forall (m :: * -> *). MonadIO m => EventTouch -> Int8 -> m ()
setEventTouchSendEvent EventTouch
s Int8
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int8
val :: Int8)

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

eventTouch_sendEvent :: AttrLabelProxy "sendEvent"
eventTouch_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' eventTouch #time
-- @
getEventTouchTime :: MonadIO m => EventTouch -> m Word32
getEventTouchTime :: forall (m :: * -> *). MonadIO m => EventTouch -> m Word32
getEventTouchTime EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
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' eventTouch [ #time 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchTime :: MonadIO m => EventTouch -> Word32 -> m ()
setEventTouchTime :: forall (m :: * -> *). MonadIO m => EventTouch -> Word32 -> m ()
setEventTouchTime EventTouch
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)

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

eventTouch_time :: AttrLabelProxy "time"
eventTouch_time = AttrLabelProxy

#endif


-- | Get the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #x
-- @
getEventTouchX :: MonadIO m => EventTouch -> m Double
getEventTouchX :: forall (m :: * -> *). MonadIO m => EventTouch -> m Double
getEventTouchX EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CDouble
    let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@x@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #x 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchX :: MonadIO m => EventTouch -> Double -> m ()
setEventTouchX :: forall (m :: * -> *). MonadIO m => EventTouch -> Double -> m ()
setEventTouchX EventTouch
s Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CDouble
val' :: CDouble)

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

eventTouch_x :: AttrLabelProxy "x"
eventTouch_x = AttrLabelProxy

#endif


-- | Get the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #y
-- @
getEventTouchY :: MonadIO m => EventTouch -> m Double
getEventTouchY :: forall (m :: * -> *). MonadIO m => EventTouch -> m Double
getEventTouchY EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CDouble
    let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@y@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #y 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchY :: MonadIO m => EventTouch -> Double -> m ()
setEventTouchY :: forall (m :: * -> *). MonadIO m => EventTouch -> Double -> m ()
setEventTouchY EventTouch
s Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CDouble
val' :: CDouble)

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

eventTouch_y :: AttrLabelProxy "y"
eventTouch_y = AttrLabelProxy

#endif


-- | Get the value of the “@axes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #axes
-- @
getEventTouchAxes :: MonadIO m => EventTouch -> m Double
getEventTouchAxes :: forall (m :: * -> *). MonadIO m => EventTouch -> m Double
getEventTouchAxes EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CDouble
    let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@axes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #axes 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchAxes :: MonadIO m => EventTouch -> Double -> m ()
setEventTouchAxes :: forall (m :: * -> *). MonadIO m => EventTouch -> Double -> m ()
setEventTouchAxes EventTouch
s Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CDouble
val' :: CDouble)

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

eventTouch_axes :: AttrLabelProxy "axes"
eventTouch_axes = AttrLabelProxy

#endif


-- | Get the value of the “@state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #state
-- @
getEventTouchState :: MonadIO m => EventTouch -> m [Gdk.Flags.ModifierType]
getEventTouchState :: forall (m :: * -> *). MonadIO m => EventTouch -> m [ModifierType]
getEventTouchState EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CUInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO CUInt
    let val' :: [ModifierType]
val' = forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    forall (m :: * -> *) a. Monad m => a -> m a
return [ModifierType]
val'

-- | Set the value of the “@state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #state 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchState :: MonadIO m => EventTouch -> [Gdk.Flags.ModifierType] -> m ()
setEventTouchState :: forall (m :: * -> *).
MonadIO m =>
EventTouch -> [ModifierType] -> m ()
setEventTouchState EventTouch
s [ModifierType]
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CUInt
val' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (CUInt
val' :: CUInt)

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

eventTouch_state :: AttrLabelProxy "state"
eventTouch_state = AttrLabelProxy

#endif


-- | Get the value of the “@sequence@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #sequence
-- @
getEventTouchSequence :: MonadIO m => EventTouch -> m (Maybe Gdk.EventSequence.EventSequence)
getEventTouchSequence :: forall (m :: * -> *).
MonadIO m =>
EventTouch -> m (Maybe EventSequence)
getEventTouchSequence EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    Ptr EventSequence
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO (Ptr Gdk.EventSequence.EventSequence)
    Maybe EventSequence
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr EventSequence
val forall a b. (a -> b) -> a -> b
$ \Ptr EventSequence
val' -> do
        EventSequence
val'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr EventSequence -> EventSequence
Gdk.EventSequence.EventSequence) Ptr EventSequence
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return EventSequence
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe EventSequence
result

-- | Set the value of the “@sequence@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #sequence 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchSequence :: MonadIO m => EventTouch -> Ptr Gdk.EventSequence.EventSequence -> m ()
setEventTouchSequence :: forall (m :: * -> *).
MonadIO m =>
EventTouch -> Ptr EventSequence -> m ()
setEventTouchSequence EventTouch
s Ptr EventSequence
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Ptr EventSequence
val :: Ptr Gdk.EventSequence.EventSequence)

-- | Set the value of the “@sequence@” 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' #sequence
-- @
clearEventTouchSequence :: MonadIO m => EventTouch -> m ()
clearEventTouchSequence :: forall (m :: * -> *). MonadIO m => EventTouch -> m ()
clearEventTouchSequence EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (forall a. Ptr a
FP.nullPtr :: Ptr Gdk.EventSequence.EventSequence)

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

eventTouch_sequence :: AttrLabelProxy "sequence"
eventTouch_sequence = AttrLabelProxy

#endif


-- | Get the value of the “@emulating_pointer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #emulatingPointer
-- @
getEventTouchEmulatingPointer :: MonadIO m => EventTouch -> m Bool
getEventTouchEmulatingPointer :: forall (m :: * -> *). MonadIO m => EventTouch -> m Bool
getEventTouchEmulatingPointer EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) :: IO CInt
    let val' :: Bool
val' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'

-- | Set the value of the “@emulating_pointer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #emulatingPointer 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchEmulatingPointer :: MonadIO m => EventTouch -> Bool -> m ()
setEventTouchEmulatingPointer :: forall (m :: * -> *). MonadIO m => EventTouch -> Bool -> m ()
setEventTouchEmulatingPointer EventTouch
s Bool
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CInt
val' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) (CInt
val' :: CInt)

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

eventTouch_emulatingPointer :: AttrLabelProxy "emulatingPointer"
eventTouch_emulatingPointer = AttrLabelProxy

#endif


-- | Get the value of the “@device@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #device
-- @
getEventTouchDevice :: MonadIO m => EventTouch -> m (Maybe Gdk.Device.Device)
getEventTouchDevice :: forall (m :: * -> *). MonadIO m => EventTouch -> m (Maybe Device)
getEventTouchDevice EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    Ptr Device
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO (Ptr Gdk.Device.Device)
    Maybe Device
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Device
val forall a b. (a -> b) -> a -> b
$ \Ptr Device
val' -> do
        Device
val'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Device -> Device
Gdk.Device.Device) Ptr Device
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return Device
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Device
result

-- | Set the value of the “@device@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #device 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchDevice :: MonadIO m => EventTouch -> Ptr Gdk.Device.Device -> m ()
setEventTouchDevice :: forall (m :: * -> *). MonadIO m => EventTouch -> Ptr Device -> m ()
setEventTouchDevice EventTouch
s Ptr Device
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Ptr Device
val :: Ptr Gdk.Device.Device)

-- | Set the value of the “@device@” 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' #device
-- @
clearEventTouchDevice :: MonadIO m => EventTouch -> m ()
clearEventTouchDevice :: forall (m :: * -> *). MonadIO m => EventTouch -> m ()
clearEventTouchDevice EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (forall a. Ptr a
FP.nullPtr :: Ptr Gdk.Device.Device)

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

eventTouch_device :: AttrLabelProxy "device"
eventTouch_device = AttrLabelProxy

#endif


-- | Get the value of the “@x_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #xRoot
-- @
getEventTouchXRoot :: MonadIO m => EventTouch -> m Double
getEventTouchXRoot :: forall (m :: * -> *). MonadIO m => EventTouch -> m Double
getEventTouchXRoot EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52) :: IO CDouble
    let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@x_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #xRoot 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchXRoot :: MonadIO m => EventTouch -> Double -> m ()
setEventTouchXRoot :: forall (m :: * -> *). MonadIO m => EventTouch -> Double -> m ()
setEventTouchXRoot EventTouch
s Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52) (CDouble
val' :: CDouble)

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

eventTouch_xRoot :: AttrLabelProxy "xRoot"
eventTouch_xRoot = AttrLabelProxy

#endif


-- | Get the value of the “@y_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventTouch #yRoot
-- @
getEventTouchYRoot :: MonadIO m => EventTouch -> m Double
getEventTouchYRoot :: forall (m :: * -> *). MonadIO m => EventTouch -> m Double
getEventTouchYRoot EventTouch
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60) :: IO CDouble
    let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@y_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventTouch [ #yRoot 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventTouchYRoot :: MonadIO m => EventTouch -> Double -> m ()
setEventTouchYRoot :: forall (m :: * -> *). MonadIO m => EventTouch -> Double -> m ()
setEventTouchYRoot EventTouch
s Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventTouch
s forall a b. (a -> b) -> a -> b
$ \Ptr EventTouch
ptr -> do
    let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventTouch
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60) (CDouble
val' :: CDouble)

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

eventTouch_yRoot :: AttrLabelProxy "yRoot"
eventTouch_yRoot = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventTouch
type instance O.AttributeList EventTouch = EventTouchAttributeList
type EventTouchAttributeList = ('[ '("type", EventTouchTypeFieldInfo), '("window", EventTouchWindowFieldInfo), '("sendEvent", EventTouchSendEventFieldInfo), '("time", EventTouchTimeFieldInfo), '("x", EventTouchXFieldInfo), '("y", EventTouchYFieldInfo), '("axes", EventTouchAxesFieldInfo), '("state", EventTouchStateFieldInfo), '("sequence", EventTouchSequenceFieldInfo), '("emulatingPointer", EventTouchEmulatingPointerFieldInfo), '("device", EventTouchDeviceFieldInfo), '("xRoot", EventTouchXRootFieldInfo), '("yRoot", EventTouchYRootFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

instance (info ~ ResolveEventTouchMethod t EventTouch, O.OverloadedMethod info EventTouch p) => OL.IsLabel t (EventTouch -> 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 ~ ResolveEventTouchMethod t EventTouch, O.OverloadedMethod info EventTouch p, R.HasField t EventTouch p) => R.HasField t EventTouch p where
    getField = O.overloadedMethod @info

#endif

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

#endif