{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Structs.ScrollEvent
(
ScrollEvent(..) ,
newZeroScrollEvent ,
#if defined(ENABLE_OVERLOADING)
ResolveScrollEventMethod ,
#endif
getScrollEventAxes ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_axes ,
#endif
setScrollEventAxes ,
clearScrollEventDevice ,
getScrollEventDevice ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_device ,
#endif
setScrollEventDevice ,
getScrollEventDirection ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_direction ,
#endif
setScrollEventDirection ,
getScrollEventFinishFlags ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_finishFlags ,
#endif
setScrollEventFinishFlags ,
getScrollEventFlags ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_flags ,
#endif
setScrollEventFlags ,
getScrollEventModifierState ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_modifierState ,
#endif
setScrollEventModifierState ,
getScrollEventScrollSource ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_scrollSource ,
#endif
setScrollEventScrollSource ,
clearScrollEventSource ,
getScrollEventSource ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_source ,
#endif
setScrollEventSource ,
clearScrollEventStage ,
getScrollEventStage ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_stage ,
#endif
setScrollEventStage ,
getScrollEventTime ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_time ,
#endif
setScrollEventTime ,
getScrollEventType ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_type ,
#endif
setScrollEventType ,
getScrollEventX ,
#if defined(ENABLE_OVERLOADING)
scrollEvent_x ,
#endif
setScrollEventX ,
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
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
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
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'
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
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
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
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'
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
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
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)
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
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
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)
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
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'
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
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'
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
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'
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
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'
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
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'
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
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
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)
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
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'
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
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'
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