{-# 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.
-- 
-- The /@type@/ field will be one of 'GI.Clutter.Enums.EventTypeTouchBegin', 'GI.Clutter.Enums.EventTypeTouchEnd',
-- 'GI.Clutter.Enums.EventTypeTouchUpdate', or 'GI.Clutter.Enums.EventTypeTouchCancel'.
-- 
-- Touch events are grouped into sequences; each touch sequence will begin
-- with a 'GI.Clutter.Enums.EventTypeTouchBegin' event, progress with 'GI.Clutter.Enums.EventTypeTouchUpdate'
-- events, and end either with a 'GI.Clutter.Enums.EventTypeTouchEnd' event or with a
-- 'GI.Clutter.Enums.EventTypeTouchCancel' event.
-- 
-- With multi-touch capable devices there can be multiple event sequence
-- running at the same time.
-- 
-- /Since: 1.10/

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

module GI.Clutter.Structs.TouchEvent
    ( 

-- * Exported types
    TouchEvent(..)                          ,
    newZeroTouchEvent                       ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveTouchEventMethod                 ,
#endif



 -- * Properties


-- ** axes #attr:axes#
-- | reserved

    getTouchEventAxes                       ,
    setTouchEventAxes                       ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_axes                         ,
#endif


-- ** device #attr:device#
-- | the device that originated the event. If you want the physical
-- device the event originated from, use 'GI.Clutter.Unions.Event.eventGetSourceDevice'

    clearTouchEventDevice                   ,
    getTouchEventDevice                     ,
    setTouchEventDevice                     ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_device                       ,
#endif


-- ** flags #attr:flags#
-- | event flags

    getTouchEventFlags                      ,
    setTouchEventFlags                      ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_flags                        ,
#endif


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

    getTouchEventModifierState              ,
    setTouchEventModifierState              ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_modifierState                ,
#endif


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

    clearTouchEventSequence                 ,
    getTouchEventSequence                   ,
    setTouchEventSequence                   ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_sequence                     ,
#endif


-- ** source #attr:source#
-- | event source actor (unused)

    clearTouchEventSource                   ,
    getTouchEventSource                     ,
    setTouchEventSource                     ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_source                       ,
#endif


-- ** stage #attr:stage#
-- | event source stage

    clearTouchEventStage                    ,
    getTouchEventStage                      ,
    setTouchEventStage                      ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_stage                        ,
#endif


-- ** time #attr:time#
-- | event time

    getTouchEventTime                       ,
    setTouchEventTime                       ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_time                         ,
#endif


-- ** type #attr:type#
-- | event type

    getTouchEventType                       ,
    setTouchEventType                       ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_type                         ,
#endif


-- ** x #attr:x#
-- | the X coordinate of the pointer, relative to the stage

    getTouchEventX                          ,
    setTouchEventX                          ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_x                            ,
#endif


-- ** y #attr:y#
-- | the Y coordinate of the pointer, relative to the stage

    getTouchEventY                          ,
    setTouchEventY                          ,
#if defined(ENABLE_OVERLOADING)
    touchEvent_y                            ,
#endif




    ) 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.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.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Structs.EventSequence as Clutter.EventSequence

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

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

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


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

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

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

touchEvent_type :: AttrLabelProxy "type"
touchEvent_type = 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' touchEvent #time
-- @
getTouchEventTime :: MonadIO m => TouchEvent -> m Word32
getTouchEventTime :: forall (m :: * -> *). MonadIO m => TouchEvent -> m Word32
getTouchEventTime TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO Word32) -> IO Word32)
-> (Ptr TouchEvent -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
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' touchEvent [ #time 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventTime :: MonadIO m => TouchEvent -> Word32 -> m ()
setTouchEventTime :: forall (m :: * -> *). MonadIO m => TouchEvent -> Word32 -> m ()
setTouchEventTime TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Word32
val :: Word32)

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

touchEvent_time :: AttrLabelProxy "time"
touchEvent_time = AttrLabelProxy

#endif


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

-- | Set the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' touchEvent [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventFlags :: MonadIO m => TouchEvent -> [Clutter.Flags.EventFlags] -> m ()
setTouchEventFlags :: forall (m :: * -> *).
MonadIO m =>
TouchEvent -> [EventFlags] -> m ()
setTouchEventFlags TouchEvent
s [EventFlags]
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    let val' :: CUInt
val' = [EventFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [EventFlags]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data TouchEventFlagsFieldInfo
instance AttrInfo TouchEventFlagsFieldInfo where
    type AttrBaseTypeConstraint TouchEventFlagsFieldInfo = (~) TouchEvent
    type AttrAllowedOps TouchEventFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint TouchEventFlagsFieldInfo = (~) [Clutter.Flags.EventFlags]
    type AttrTransferTypeConstraint TouchEventFlagsFieldInfo = (~)[Clutter.Flags.EventFlags]
    type AttrTransferType TouchEventFlagsFieldInfo = [Clutter.Flags.EventFlags]
    type AttrGetType TouchEventFlagsFieldInfo = [Clutter.Flags.EventFlags]
    type AttrLabel TouchEventFlagsFieldInfo = "flags"
    type AttrOrigin TouchEventFlagsFieldInfo = TouchEvent
    attrGet = getTouchEventFlags
    attrSet = setTouchEventFlags
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.TouchEvent.flags"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-TouchEvent.html#g:attr:flags"
        })

touchEvent_flags :: AttrLabelProxy "flags"
touchEvent_flags = AttrLabelProxy

#endif


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

-- | Set the value of the “@stage@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' touchEvent [ #stage 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventStage :: MonadIO m => TouchEvent -> Ptr Clutter.Stage.Stage -> m ()
setTouchEventStage :: forall (m :: * -> *). MonadIO m => TouchEvent -> Ptr Stage -> m ()
setTouchEventStage TouchEvent
s Ptr Stage
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr Stage) -> Ptr Stage -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr Stage)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Stage
val :: Ptr Clutter.Stage.Stage)

-- | Set the value of the “@stage@” 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' #stage
-- @
clearTouchEventStage :: MonadIO m => TouchEvent -> m ()
clearTouchEventStage :: forall (m :: * -> *). MonadIO m => TouchEvent -> m ()
clearTouchEventStage TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr Stage) -> Ptr Stage -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr Stage)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Stage
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.Stage.Stage)

#if defined(ENABLE_OVERLOADING)
data TouchEventStageFieldInfo
instance AttrInfo TouchEventStageFieldInfo where
    type AttrBaseTypeConstraint TouchEventStageFieldInfo = (~) TouchEvent
    type AttrAllowedOps TouchEventStageFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TouchEventStageFieldInfo = (~) (Ptr Clutter.Stage.Stage)
    type AttrTransferTypeConstraint TouchEventStageFieldInfo = (~)(Ptr Clutter.Stage.Stage)
    type AttrTransferType TouchEventStageFieldInfo = (Ptr Clutter.Stage.Stage)
    type AttrGetType TouchEventStageFieldInfo = Maybe Clutter.Stage.Stage
    type AttrLabel TouchEventStageFieldInfo = "stage"
    type AttrOrigin TouchEventStageFieldInfo = TouchEvent
    attrGet = getTouchEventStage
    attrSet = setTouchEventStage
    attrConstruct = undefined
    attrClear = clearTouchEventStage
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.TouchEvent.stage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-TouchEvent.html#g:attr:stage"
        })

touchEvent_stage :: AttrLabelProxy "stage"
touchEvent_stage = AttrLabelProxy

#endif


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

-- | Set the value of the “@source@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' touchEvent [ #source 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventSource :: MonadIO m => TouchEvent -> Ptr Clutter.Actor.Actor -> m ()
setTouchEventSource :: forall (m :: * -> *). MonadIO m => TouchEvent -> Ptr Actor -> m ()
setTouchEventSource TouchEvent
s Ptr Actor
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr Actor) -> Ptr Actor -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr Actor)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr Actor
val :: Ptr Clutter.Actor.Actor)

-- | Set the value of the “@source@” 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' #source
-- @
clearTouchEventSource :: MonadIO m => TouchEvent -> m ()
clearTouchEventSource :: forall (m :: * -> *). MonadIO m => TouchEvent -> m ()
clearTouchEventSource TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr Actor) -> Ptr Actor -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr Actor)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Ptr Actor
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.Actor.Actor)

#if defined(ENABLE_OVERLOADING)
data TouchEventSourceFieldInfo
instance AttrInfo TouchEventSourceFieldInfo where
    type AttrBaseTypeConstraint TouchEventSourceFieldInfo = (~) TouchEvent
    type AttrAllowedOps TouchEventSourceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TouchEventSourceFieldInfo = (~) (Ptr Clutter.Actor.Actor)
    type AttrTransferTypeConstraint TouchEventSourceFieldInfo = (~)(Ptr Clutter.Actor.Actor)
    type AttrTransferType TouchEventSourceFieldInfo = (Ptr Clutter.Actor.Actor)
    type AttrGetType TouchEventSourceFieldInfo = Maybe Clutter.Actor.Actor
    type AttrLabel TouchEventSourceFieldInfo = "source"
    type AttrOrigin TouchEventSourceFieldInfo = TouchEvent
    attrGet = getTouchEventSource
    attrSet = setTouchEventSource
    attrConstruct = undefined
    attrClear = clearTouchEventSource
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.TouchEvent.source"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-TouchEvent.html#g:attr:source"
        })

touchEvent_source :: AttrLabelProxy "source"
touchEvent_source = 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' touchEvent #x
-- @
getTouchEventX :: MonadIO m => TouchEvent -> m Float
getTouchEventX :: forall (m :: * -> *). MonadIO m => TouchEvent -> m Float
getTouchEventX TouchEvent
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ TouchEvent -> (Ptr TouchEvent -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO Float) -> IO Float)
-> (Ptr TouchEvent -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
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' touchEvent [ #x 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventX :: MonadIO m => TouchEvent -> Float -> m ()
setTouchEventX :: forall (m :: * -> *). MonadIO m => TouchEvent -> Float -> m ()
setTouchEventX TouchEvent
s Float
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CFloat
val' :: CFloat)

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

touchEvent_x :: AttrLabelProxy "x"
touchEvent_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' touchEvent #y
-- @
getTouchEventY :: MonadIO m => TouchEvent -> m Float
getTouchEventY :: forall (m :: * -> *). MonadIO m => TouchEvent -> m Float
getTouchEventY TouchEvent
s = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ TouchEvent -> (Ptr TouchEvent -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO Float) -> IO Float)
-> (Ptr TouchEvent -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
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' touchEvent [ #y 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventY :: MonadIO m => TouchEvent -> Float -> m ()
setTouchEventY :: forall (m :: * -> *). MonadIO m => TouchEvent -> Float -> m ()
setTouchEventY TouchEvent
s Float
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (CFloat
val' :: CFloat)

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

touchEvent_y :: AttrLabelProxy "y"
touchEvent_y = 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' touchEvent #sequence
-- @
getTouchEventSequence :: MonadIO m => TouchEvent -> m (Maybe Clutter.EventSequence.EventSequence)
getTouchEventSequence :: forall (m :: * -> *).
MonadIO m =>
TouchEvent -> m (Maybe EventSequence)
getTouchEventSequence TouchEvent
s = IO (Maybe EventSequence) -> m (Maybe EventSequence)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe EventSequence) -> m (Maybe EventSequence))
-> IO (Maybe EventSequence) -> m (Maybe EventSequence)
forall a b. (a -> b) -> a -> b
$ TouchEvent
-> (Ptr TouchEvent -> IO (Maybe EventSequence))
-> IO (Maybe EventSequence)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO (Maybe EventSequence))
 -> IO (Maybe EventSequence))
-> (Ptr TouchEvent -> IO (Maybe EventSequence))
-> IO (Maybe EventSequence)
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr EventSequence
val <- Ptr (Ptr EventSequence) -> IO (Ptr EventSequence)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr EventSequence)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO (Ptr Clutter.EventSequence.EventSequence)
    Maybe EventSequence
result <- Ptr EventSequence
-> (Ptr EventSequence -> IO EventSequence)
-> IO (Maybe EventSequence)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr EventSequence
val ((Ptr EventSequence -> IO EventSequence)
 -> IO (Maybe EventSequence))
-> (Ptr EventSequence -> IO EventSequence)
-> IO (Maybe EventSequence)
forall a b. (a -> b) -> a -> b
$ \Ptr EventSequence
val' -> do
        EventSequence
val'' <- ((ManagedPtr EventSequence -> EventSequence)
-> Ptr EventSequence -> IO EventSequence
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr EventSequence -> EventSequence
Clutter.EventSequence.EventSequence) Ptr EventSequence
val'
        EventSequence -> IO EventSequence
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EventSequence
val''
    Maybe EventSequence -> IO (Maybe EventSequence)
forall a. a -> IO a
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' touchEvent [ #sequence 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventSequence :: MonadIO m => TouchEvent -> Ptr Clutter.EventSequence.EventSequence -> m ()
setTouchEventSequence :: forall (m :: * -> *).
MonadIO m =>
TouchEvent -> Ptr EventSequence -> m ()
setTouchEventSequence TouchEvent
s Ptr EventSequence
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr EventSequence) -> Ptr EventSequence -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr EventSequence)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Ptr EventSequence
val :: Ptr Clutter.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
-- @
clearTouchEventSequence :: MonadIO m => TouchEvent -> m ()
clearTouchEventSequence :: forall (m :: * -> *). MonadIO m => TouchEvent -> m ()
clearTouchEventSequence TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr EventSequence) -> Ptr EventSequence -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr EventSequence)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Ptr EventSequence
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.EventSequence.EventSequence)

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

touchEvent_sequence :: AttrLabelProxy "sequence"
touchEvent_sequence = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data TouchEventModifierStateFieldInfo
instance AttrInfo TouchEventModifierStateFieldInfo where
    type AttrBaseTypeConstraint TouchEventModifierStateFieldInfo = (~) TouchEvent
    type AttrAllowedOps TouchEventModifierStateFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint TouchEventModifierStateFieldInfo = (~) [Clutter.Flags.ModifierType]
    type AttrTransferTypeConstraint TouchEventModifierStateFieldInfo = (~)[Clutter.Flags.ModifierType]
    type AttrTransferType TouchEventModifierStateFieldInfo = [Clutter.Flags.ModifierType]
    type AttrGetType TouchEventModifierStateFieldInfo = [Clutter.Flags.ModifierType]
    type AttrLabel TouchEventModifierStateFieldInfo = "modifier_state"
    type AttrOrigin TouchEventModifierStateFieldInfo = TouchEvent
    attrGet = getTouchEventModifierState
    attrSet = setTouchEventModifierState
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.TouchEvent.modifierState"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-TouchEvent.html#g:attr:modifierState"
        })

touchEvent_modifierState :: AttrLabelProxy "modifierState"
touchEvent_modifierState = 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' touchEvent #axes
-- @
getTouchEventAxes :: MonadIO m => TouchEvent -> m Double
getTouchEventAxes :: forall (m :: * -> *). MonadIO m => TouchEvent -> m Double
getTouchEventAxes TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO Double) -> IO Double)
-> (Ptr TouchEvent -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
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' touchEvent [ #axes 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventAxes :: MonadIO m => TouchEvent -> Double -> m ()
setTouchEventAxes :: forall (m :: * -> *). MonadIO m => TouchEvent -> Double -> m ()
setTouchEventAxes TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
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 TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (CDouble
val' :: CDouble)

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

touchEvent_axes :: AttrLabelProxy "axes"
touchEvent_axes = 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' touchEvent #device
-- @
getTouchEventDevice :: MonadIO m => TouchEvent -> m (Maybe Clutter.InputDevice.InputDevice)
getTouchEventDevice :: forall (m :: * -> *).
MonadIO m =>
TouchEvent -> m (Maybe InputDevice)
getTouchEventDevice TouchEvent
s = IO (Maybe InputDevice) -> m (Maybe InputDevice)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputDevice) -> m (Maybe InputDevice))
-> IO (Maybe InputDevice) -> m (Maybe InputDevice)
forall a b. (a -> b) -> a -> b
$ TouchEvent
-> (Ptr TouchEvent -> IO (Maybe InputDevice))
-> IO (Maybe InputDevice)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO (Maybe InputDevice))
 -> IO (Maybe InputDevice))
-> (Ptr TouchEvent -> IO (Maybe InputDevice))
-> IO (Maybe InputDevice)
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr InputDevice
val <- Ptr (Ptr InputDevice) -> IO (Ptr InputDevice)
forall a. Storable a => Ptr a -> IO a
peek (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO (Ptr Clutter.InputDevice.InputDevice)
    Maybe InputDevice
result <- Ptr InputDevice
-> (Ptr InputDevice -> IO InputDevice) -> IO (Maybe InputDevice)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr InputDevice
val ((Ptr InputDevice -> IO InputDevice) -> IO (Maybe InputDevice))
-> (Ptr InputDevice -> IO InputDevice) -> IO (Maybe InputDevice)
forall a b. (a -> b) -> a -> b
$ \Ptr InputDevice
val' -> do
        InputDevice
val'' <- ((ManagedPtr InputDevice -> InputDevice)
-> Ptr InputDevice -> IO InputDevice
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr InputDevice -> InputDevice
Clutter.InputDevice.InputDevice) Ptr InputDevice
val'
        InputDevice -> IO InputDevice
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputDevice
val''
    Maybe InputDevice -> IO (Maybe InputDevice)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputDevice
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' touchEvent [ #device 'Data.GI.Base.Attributes.:=' value ]
-- @
setTouchEventDevice :: MonadIO m => TouchEvent -> Ptr Clutter.InputDevice.InputDevice -> m ()
setTouchEventDevice :: forall (m :: * -> *).
MonadIO m =>
TouchEvent -> Ptr InputDevice -> m ()
setTouchEventDevice TouchEvent
s Ptr InputDevice
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr InputDevice) -> Ptr InputDevice -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr InputDevice
val :: Ptr Clutter.InputDevice.InputDevice)

-- | 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
-- @
clearTouchEventDevice :: MonadIO m => TouchEvent -> m ()
clearTouchEventDevice :: forall (m :: * -> *). MonadIO m => TouchEvent -> m ()
clearTouchEventDevice TouchEvent
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
$ TouchEvent -> (Ptr TouchEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TouchEvent
s ((Ptr TouchEvent -> IO ()) -> IO ())
-> (Ptr TouchEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TouchEvent
ptr -> do
    Ptr (Ptr InputDevice) -> Ptr InputDevice -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TouchEvent
ptr Ptr TouchEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr InputDevice
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.InputDevice.InputDevice)

#if defined(ENABLE_OVERLOADING)
data TouchEventDeviceFieldInfo
instance AttrInfo TouchEventDeviceFieldInfo where
    type AttrBaseTypeConstraint TouchEventDeviceFieldInfo = (~) TouchEvent
    type AttrAllowedOps TouchEventDeviceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TouchEventDeviceFieldInfo = (~) (Ptr Clutter.InputDevice.InputDevice)
    type AttrTransferTypeConstraint TouchEventDeviceFieldInfo = (~)(Ptr Clutter.InputDevice.InputDevice)
    type AttrTransferType TouchEventDeviceFieldInfo = (Ptr Clutter.InputDevice.InputDevice)
    type AttrGetType TouchEventDeviceFieldInfo = Maybe Clutter.InputDevice.InputDevice
    type AttrLabel TouchEventDeviceFieldInfo = "device"
    type AttrOrigin TouchEventDeviceFieldInfo = TouchEvent
    attrGet = getTouchEventDevice
    attrSet = setTouchEventDevice
    attrConstruct = undefined
    attrClear = clearTouchEventDevice
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.TouchEvent.device"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-TouchEvent.html#g:attr:device"
        })

touchEvent_device :: AttrLabelProxy "device"
touchEvent_device = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TouchEvent
type instance O.AttributeList TouchEvent = TouchEventAttributeList
type TouchEventAttributeList = ('[ '("type", TouchEventTypeFieldInfo), '("time", TouchEventTimeFieldInfo), '("flags", TouchEventFlagsFieldInfo), '("stage", TouchEventStageFieldInfo), '("source", TouchEventSourceFieldInfo), '("x", TouchEventXFieldInfo), '("y", TouchEventYFieldInfo), '("sequence", TouchEventSequenceFieldInfo), '("modifierState", TouchEventModifierStateFieldInfo), '("axes", TouchEventAxesFieldInfo), '("device", TouchEventDeviceFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif

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

#endif