{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Scroll wheel (or similar device) event
-- 
-- /Since: 0.2/

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

module GI.Clutter.Structs.ScrollEvent
    ( 

-- * Exported types
    ScrollEvent(..)                         ,
    newZeroScrollEvent                      ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveScrollEventMethod                ,
#endif



 -- * Properties


-- ** axes #attr:axes#
-- | reserved for future use

    getScrollEventAxes                      ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_axes                        ,
#endif
    setScrollEventAxes                      ,


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

    clearScrollEventDevice                  ,
    getScrollEventDevice                    ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_device                      ,
#endif
    setScrollEventDevice                    ,


-- ** direction #attr:direction#
-- | direction of the scrolling

    getScrollEventDirection                 ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_direction                   ,
#endif
    setScrollEventDirection                 ,


-- ** finishFlags #attr:finishFlags#
-- | the axes that were stopped in this event. This field is available since 1.26

    getScrollEventFinishFlags               ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_finishFlags                 ,
#endif
    setScrollEventFinishFlags               ,


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

    getScrollEventFlags                     ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_flags                       ,
#endif
    setScrollEventFlags                     ,


-- ** modifierState #attr:modifierState#
-- | button modifiers

    getScrollEventModifierState             ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_modifierState               ,
#endif
    setScrollEventModifierState             ,


-- ** scrollSource #attr:scrollSource#
-- | the source of scroll events. This field is available since 1.26

    getScrollEventScrollSource              ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_scrollSource                ,
#endif
    setScrollEventScrollSource              ,


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

    clearScrollEventSource                  ,
    getScrollEventSource                    ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_source                      ,
#endif
    setScrollEventSource                    ,


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

    clearScrollEventStage                   ,
    getScrollEventStage                     ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_stage                       ,
#endif
    setScrollEventStage                     ,


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

    getScrollEventTime                      ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_time                        ,
#endif
    setScrollEventTime                      ,


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

    getScrollEventType                      ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_type                        ,
#endif
    setScrollEventType                      ,


-- ** x #attr:x#
-- | event X coordinate

    getScrollEventX                         ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_x                           ,
#endif
    setScrollEventX                         ,


-- ** y #attr:y#
-- | event Y coordinate

    getScrollEventY                         ,
#if defined(ENABLE_OVERLOADING)
    scrollEvent_y                           ,
#endif
    setScrollEventY                         ,




    ) 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

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

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

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


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

instance tag ~ 'AttrSet => Constructible ScrollEvent tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ScrollEvent -> ScrollEvent)
-> [AttrOp ScrollEvent tag] -> m ScrollEvent
new ManagedPtr ScrollEvent -> ScrollEvent
_ [AttrOp ScrollEvent tag]
attrs = do
        ScrollEvent
o <- m ScrollEvent
forall (m :: * -> *). MonadIO m => m ScrollEvent
newZeroScrollEvent
        ScrollEvent -> [AttrOp ScrollEvent 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ScrollEvent
o [AttrOp ScrollEvent tag]
[AttrOp ScrollEvent 'AttrSet]
attrs
        ScrollEvent -> m ScrollEvent
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ScrollEvent
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' scrollEvent #type
-- @
getScrollEventType :: MonadIO m => ScrollEvent -> m Clutter.Enums.EventType
getScrollEventType :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m EventType
getScrollEventType ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO EventType) -> IO EventType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO EventType) -> IO EventType)
-> (Ptr ScrollEvent -> IO EventType) -> IO EventType
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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' scrollEvent [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventType :: MonadIO m => ScrollEvent -> Clutter.Enums.EventType -> m ()
setScrollEventType :: forall (m :: * -> *). MonadIO m => ScrollEvent -> EventType -> m ()
setScrollEventType ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
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 ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CUInt
val' :: CUInt)

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

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

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

scrollEvent_time :: AttrLabelProxy "time"
scrollEvent_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' scrollEvent #flags
-- @
getScrollEventFlags :: MonadIO m => ScrollEvent -> m [Clutter.Flags.EventFlags]
getScrollEventFlags :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m [EventFlags]
getScrollEventFlags ScrollEvent
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
$ ScrollEvent
-> (Ptr ScrollEvent -> IO [EventFlags]) -> IO [EventFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO [EventFlags]) -> IO [EventFlags])
-> (Ptr ScrollEvent -> IO [EventFlags]) -> IO [EventFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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' scrollEvent [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventFlags :: MonadIO m => ScrollEvent -> [Clutter.Flags.EventFlags] -> m ()
setScrollEventFlags :: forall (m :: * -> *).
MonadIO m =>
ScrollEvent -> [EventFlags] -> m ()
setScrollEventFlags ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
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 ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)

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

scrollEvent_flags :: AttrLabelProxy "flags"
scrollEvent_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' scrollEvent #stage
-- @
getScrollEventStage :: MonadIO m => ScrollEvent -> m (Maybe Clutter.Stage.Stage)
getScrollEventStage :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m (Maybe Stage)
getScrollEventStage ScrollEvent
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
$ ScrollEvent
-> (Ptr ScrollEvent -> IO (Maybe Stage)) -> IO (Maybe Stage)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO (Maybe Stage)) -> IO (Maybe Stage))
-> (Ptr ScrollEvent -> IO (Maybe Stage)) -> IO (Maybe Stage)
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr Stage
val <- Ptr (Ptr Stage) -> IO (Ptr Stage)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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' scrollEvent [ #stage 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventStage :: MonadIO m => ScrollEvent -> Ptr Clutter.Stage.Stage -> m ()
setScrollEventStage :: forall (m :: * -> *). MonadIO m => ScrollEvent -> Ptr Stage -> m ()
setScrollEventStage ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr (Ptr Stage) -> Ptr Stage -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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
-- @
clearScrollEventStage :: MonadIO m => ScrollEvent -> m ()
clearScrollEventStage :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m ()
clearScrollEventStage ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr (Ptr Stage) -> Ptr Stage -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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 ScrollEventStageFieldInfo
instance AttrInfo ScrollEventStageFieldInfo where
    type AttrBaseTypeConstraint ScrollEventStageFieldInfo = (~) ScrollEvent
    type AttrAllowedOps ScrollEventStageFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ScrollEventStageFieldInfo = (~) (Ptr Clutter.Stage.Stage)
    type AttrTransferTypeConstraint ScrollEventStageFieldInfo = (~)(Ptr Clutter.Stage.Stage)
    type AttrTransferType ScrollEventStageFieldInfo = (Ptr Clutter.Stage.Stage)
    type AttrGetType ScrollEventStageFieldInfo = Maybe Clutter.Stage.Stage
    type AttrLabel ScrollEventStageFieldInfo = "stage"
    type AttrOrigin ScrollEventStageFieldInfo = ScrollEvent
    attrGet = getScrollEventStage
    attrSet = setScrollEventStage
    attrConstruct = undefined
    attrClear = clearScrollEventStage
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ScrollEvent.stage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-ScrollEvent.html#g:attr:stage"
        })

scrollEvent_stage :: AttrLabelProxy "stage"
scrollEvent_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' scrollEvent #source
-- @
getScrollEventSource :: MonadIO m => ScrollEvent -> m (Maybe Clutter.Actor.Actor)
getScrollEventSource :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m (Maybe Actor)
getScrollEventSource ScrollEvent
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
$ ScrollEvent
-> (Ptr ScrollEvent -> IO (Maybe Actor)) -> IO (Maybe Actor)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO (Maybe Actor)) -> IO (Maybe Actor))
-> (Ptr ScrollEvent -> IO (Maybe Actor)) -> IO (Maybe Actor)
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr Actor
val <- Ptr (Ptr Actor) -> IO (Ptr Actor)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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' scrollEvent [ #source 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventSource :: MonadIO m => ScrollEvent -> Ptr Clutter.Actor.Actor -> m ()
setScrollEventSource :: forall (m :: * -> *). MonadIO m => ScrollEvent -> Ptr Actor -> m ()
setScrollEventSource ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr (Ptr Actor) -> Ptr Actor -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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
-- @
clearScrollEventSource :: MonadIO m => ScrollEvent -> m ()
clearScrollEventSource :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m ()
clearScrollEventSource ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr (Ptr Actor) -> Ptr Actor -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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 ScrollEventSourceFieldInfo
instance AttrInfo ScrollEventSourceFieldInfo where
    type AttrBaseTypeConstraint ScrollEventSourceFieldInfo = (~) ScrollEvent
    type AttrAllowedOps ScrollEventSourceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ScrollEventSourceFieldInfo = (~) (Ptr Clutter.Actor.Actor)
    type AttrTransferTypeConstraint ScrollEventSourceFieldInfo = (~)(Ptr Clutter.Actor.Actor)
    type AttrTransferType ScrollEventSourceFieldInfo = (Ptr Clutter.Actor.Actor)
    type AttrGetType ScrollEventSourceFieldInfo = Maybe Clutter.Actor.Actor
    type AttrLabel ScrollEventSourceFieldInfo = "source"
    type AttrOrigin ScrollEventSourceFieldInfo = ScrollEvent
    attrGet = getScrollEventSource
    attrSet = setScrollEventSource
    attrConstruct = undefined
    attrClear = clearScrollEventSource
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.ScrollEvent.source"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-ScrollEvent.html#g:attr:source"
        })

scrollEvent_source :: AttrLabelProxy "source"
scrollEvent_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' scrollEvent #x
-- @
getScrollEventX :: MonadIO m => ScrollEvent -> m Float
getScrollEventX :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m Float
getScrollEventX ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO Float) -> IO Float)
-> (Ptr ScrollEvent -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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' scrollEvent [ #x 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventX :: MonadIO m => ScrollEvent -> Float -> m ()
setScrollEventX :: forall (m :: * -> *). MonadIO m => ScrollEvent -> Float -> m ()
setScrollEventX ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
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 ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CFloat
val' :: CFloat)

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

scrollEvent_x :: AttrLabelProxy "x"
scrollEvent_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' scrollEvent #y
-- @
getScrollEventY :: MonadIO m => ScrollEvent -> m Float
getScrollEventY :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m Float
getScrollEventY ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO Float) -> IO Float)
-> (Ptr ScrollEvent -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> 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' scrollEvent [ #y 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventY :: MonadIO m => ScrollEvent -> Float -> m ()
setScrollEventY :: forall (m :: * -> *). MonadIO m => ScrollEvent -> Float -> m ()
setScrollEventY ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
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 ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (CFloat
val' :: CFloat)

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

scrollEvent_y :: AttrLabelProxy "y"
scrollEvent_y = AttrLabelProxy

#endif


-- | Get the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' scrollEvent #direction
-- @
getScrollEventDirection :: MonadIO m => ScrollEvent -> m Clutter.Enums.ScrollDirection
getScrollEventDirection :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m ScrollDirection
getScrollEventDirection ScrollEvent
s = IO ScrollDirection -> m ScrollDirection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScrollDirection -> m ScrollDirection)
-> IO ScrollDirection -> m ScrollDirection
forall a b. (a -> b) -> a -> b
$ ScrollEvent
-> (Ptr ScrollEvent -> IO ScrollDirection) -> IO ScrollDirection
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ScrollDirection) -> IO ScrollDirection)
-> (Ptr ScrollEvent -> IO ScrollDirection) -> IO ScrollDirection
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO CUInt
    let val' :: ScrollDirection
val' = (Int -> ScrollDirection
forall a. Enum a => Int -> a
toEnum (Int -> ScrollDirection)
-> (CUInt -> Int) -> CUInt -> ScrollDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    ScrollDirection -> IO ScrollDirection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScrollDirection
val'

-- | Set the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' scrollEvent [ #direction 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventDirection :: MonadIO m => ScrollEvent -> Clutter.Enums.ScrollDirection -> m ()
setScrollEventDirection :: forall (m :: * -> *).
MonadIO m =>
ScrollEvent -> ScrollDirection -> m ()
setScrollEventDirection ScrollEvent
s ScrollDirection
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (ScrollDirection -> Int) -> ScrollDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScrollDirection -> Int
forall a. Enum a => a -> Int
fromEnum) ScrollDirection
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CUInt
val' :: CUInt)

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

scrollEvent_direction :: AttrLabelProxy "direction"
scrollEvent_direction = 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' scrollEvent #modifierState
-- @
getScrollEventModifierState :: MonadIO m => ScrollEvent -> m [Clutter.Flags.ModifierType]
getScrollEventModifierState :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m [ModifierType]
getScrollEventModifierState ScrollEvent
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
$ ScrollEvent
-> (Ptr ScrollEvent -> IO [ModifierType]) -> IO [ModifierType]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO [ModifierType]) -> IO [ModifierType])
-> (Ptr ScrollEvent -> IO [ModifierType]) -> IO [ModifierType]
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) :: 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' scrollEvent [ #modifierState 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventModifierState :: MonadIO m => ScrollEvent -> [Clutter.Flags.ModifierType] -> m ()
setScrollEventModifierState :: forall (m :: * -> *).
MonadIO m =>
ScrollEvent -> [ModifierType] -> m ()
setScrollEventModifierState ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
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 ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) (CUInt
val' :: CUInt)

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

scrollEvent_modifierState :: AttrLabelProxy "modifierState"
scrollEvent_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' scrollEvent #axes
-- @
getScrollEventAxes :: MonadIO m => ScrollEvent -> m Double
getScrollEventAxes :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m Double
getScrollEventAxes ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO Double) -> IO Double)
-> (Ptr ScrollEvent -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: 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' scrollEvent [ #axes 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventAxes :: MonadIO m => ScrollEvent -> Double -> m ()
setScrollEventAxes :: forall (m :: * -> *). MonadIO m => ScrollEvent -> Double -> m ()
setScrollEventAxes ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
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 ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CDouble
val' :: CDouble)

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

scrollEvent_axes :: AttrLabelProxy "axes"
scrollEvent_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' scrollEvent #device
-- @
getScrollEventDevice :: MonadIO m => ScrollEvent -> m (Maybe Clutter.InputDevice.InputDevice)
getScrollEventDevice :: forall (m :: * -> *).
MonadIO m =>
ScrollEvent -> m (Maybe InputDevice)
getScrollEventDevice ScrollEvent
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
$ ScrollEvent
-> (Ptr ScrollEvent -> IO (Maybe InputDevice))
-> IO (Maybe InputDevice)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO (Maybe InputDevice))
 -> IO (Maybe InputDevice))
-> (Ptr ScrollEvent -> IO (Maybe InputDevice))
-> IO (Maybe InputDevice)
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr InputDevice
val <- Ptr (Ptr InputDevice) -> IO (Ptr InputDevice)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: 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' scrollEvent [ #device 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventDevice :: MonadIO m => ScrollEvent -> Ptr Clutter.InputDevice.InputDevice -> m ()
setScrollEventDevice :: forall (m :: * -> *).
MonadIO m =>
ScrollEvent -> Ptr InputDevice -> m ()
setScrollEventDevice ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr (Ptr InputDevice) -> Ptr InputDevice -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (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
-- @
clearScrollEventDevice :: MonadIO m => ScrollEvent -> m ()
clearScrollEventDevice :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m ()
clearScrollEventDevice ScrollEvent
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    Ptr (Ptr InputDevice) -> Ptr InputDevice -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr (Ptr InputDevice)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (Ptr InputDevice
forall a. Ptr a
FP.nullPtr :: Ptr Clutter.InputDevice.InputDevice)

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

scrollEvent_device :: AttrLabelProxy "device"
scrollEvent_device = AttrLabelProxy

#endif


-- | Get the value of the “@scroll_source@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' scrollEvent #scrollSource
-- @
getScrollEventScrollSource :: MonadIO m => ScrollEvent -> m Clutter.Enums.ScrollSource
getScrollEventScrollSource :: forall (m :: * -> *). MonadIO m => ScrollEvent -> m ScrollSource
getScrollEventScrollSource ScrollEvent
s = IO ScrollSource -> m ScrollSource
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScrollSource -> m ScrollSource)
-> IO ScrollSource -> m ScrollSource
forall a b. (a -> b) -> a -> b
$ ScrollEvent
-> (Ptr ScrollEvent -> IO ScrollSource) -> IO ScrollSource
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ScrollSource) -> IO ScrollSource)
-> (Ptr ScrollEvent -> IO ScrollSource) -> IO ScrollSource
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO CUInt
    let val' :: ScrollSource
val' = (Int -> ScrollSource
forall a. Enum a => Int -> a
toEnum (Int -> ScrollSource) -> (CUInt -> Int) -> CUInt -> ScrollSource
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    ScrollSource -> IO ScrollSource
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScrollSource
val'

-- | Set the value of the “@scroll_source@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' scrollEvent [ #scrollSource 'Data.GI.Base.Attributes.:=' value ]
-- @
setScrollEventScrollSource :: MonadIO m => ScrollEvent -> Clutter.Enums.ScrollSource -> m ()
setScrollEventScrollSource :: forall (m :: * -> *).
MonadIO m =>
ScrollEvent -> ScrollSource -> m ()
setScrollEventScrollSource ScrollEvent
s ScrollSource
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
$ ScrollEvent -> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ScrollEvent
s ((Ptr ScrollEvent -> IO ()) -> IO ())
-> (Ptr ScrollEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ScrollEvent
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ScrollSource -> Int) -> ScrollSource -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScrollSource -> Int
forall a. Enum a => a -> Int
fromEnum) ScrollSource
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ScrollEvent
ptr Ptr ScrollEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (CUInt
val' :: CUInt)

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

scrollEvent_scrollSource :: AttrLabelProxy "scrollSource"
scrollEvent_scrollSource = AttrLabelProxy

#endif


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

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

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

scrollEvent_finishFlags :: AttrLabelProxy "finishFlags"
scrollEvent_finishFlags = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ScrollEvent
type instance O.AttributeList ScrollEvent = ScrollEventAttributeList
type ScrollEventAttributeList = ('[ '("type", ScrollEventTypeFieldInfo), '("time", ScrollEventTimeFieldInfo), '("flags", ScrollEventFlagsFieldInfo), '("stage", ScrollEventStageFieldInfo), '("source", ScrollEventSourceFieldInfo), '("x", ScrollEventXFieldInfo), '("y", ScrollEventYFieldInfo), '("direction", ScrollEventDirectionFieldInfo), '("modifierState", ScrollEventModifierStateFieldInfo), '("axes", ScrollEventAxesFieldInfo), '("device", ScrollEventDeviceFieldInfo), '("scrollSource", ScrollEventScrollSourceFieldInfo), '("finishFlags", ScrollEventFinishFlagsFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif

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

#endif