{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Unions.Event
(
Event(..) ,
newZeroEvent ,
#if defined(ENABLE_OVERLOADING)
ResolveEventMethod ,
#endif
eventAddFilter ,
#if defined(ENABLE_OVERLOADING)
EventCopyMethodInfo ,
#endif
eventCopy ,
#if defined(ENABLE_OVERLOADING)
EventFreeMethodInfo ,
#endif
eventFree ,
eventGet ,
#if defined(ENABLE_OVERLOADING)
EventGetAngleMethodInfo ,
#endif
eventGetAngle ,
#if defined(ENABLE_OVERLOADING)
EventGetAxesMethodInfo ,
#endif
eventGetAxes ,
#if defined(ENABLE_OVERLOADING)
EventGetButtonMethodInfo ,
#endif
eventGetButton ,
#if defined(ENABLE_OVERLOADING)
EventGetClickCountMethodInfo ,
#endif
eventGetClickCount ,
#if defined(ENABLE_OVERLOADING)
EventGetCoordsMethodInfo ,
#endif
eventGetCoords ,
#if defined(ENABLE_OVERLOADING)
EventGetDeviceMethodInfo ,
#endif
eventGetDevice ,
#if defined(ENABLE_OVERLOADING)
EventGetDeviceIdMethodInfo ,
#endif
eventGetDeviceId ,
#if defined(ENABLE_OVERLOADING)
EventGetDeviceTypeMethodInfo ,
#endif
eventGetDeviceType ,
#if defined(ENABLE_OVERLOADING)
EventGetDistanceMethodInfo ,
#endif
eventGetDistance ,
#if defined(ENABLE_OVERLOADING)
EventGetEventSequenceMethodInfo ,
#endif
eventGetEventSequence ,
#if defined(ENABLE_OVERLOADING)
EventGetFlagsMethodInfo ,
#endif
eventGetFlags ,
#if defined(ENABLE_OVERLOADING)
EventGetGestureMotionDeltaMethodInfo ,
#endif
eventGetGestureMotionDelta ,
#if defined(ENABLE_OVERLOADING)
EventGetGesturePhaseMethodInfo ,
#endif
eventGetGesturePhase ,
#if defined(ENABLE_OVERLOADING)
EventGetGesturePinchAngleDeltaMethodInfo,
#endif
eventGetGesturePinchAngleDelta ,
#if defined(ENABLE_OVERLOADING)
EventGetGesturePinchScaleMethodInfo ,
#endif
eventGetGesturePinchScale ,
#if defined(ENABLE_OVERLOADING)
EventGetGestureSwipeFingerCountMethodInfo,
#endif
eventGetGestureSwipeFingerCount ,
#if defined(ENABLE_OVERLOADING)
EventGetKeyCodeMethodInfo ,
#endif
eventGetKeyCode ,
#if defined(ENABLE_OVERLOADING)
EventGetKeySymbolMethodInfo ,
#endif
eventGetKeySymbol ,
#if defined(ENABLE_OVERLOADING)
EventGetKeyUnicodeMethodInfo ,
#endif
eventGetKeyUnicode ,
#if defined(ENABLE_OVERLOADING)
EventGetPositionMethodInfo ,
#endif
eventGetPosition ,
#if defined(ENABLE_OVERLOADING)
EventGetRelatedMethodInfo ,
#endif
eventGetRelated ,
#if defined(ENABLE_OVERLOADING)
EventGetScrollDeltaMethodInfo ,
#endif
eventGetScrollDelta ,
#if defined(ENABLE_OVERLOADING)
EventGetScrollDirectionMethodInfo ,
#endif
eventGetScrollDirection ,
#if defined(ENABLE_OVERLOADING)
EventGetSourceMethodInfo ,
#endif
eventGetSource ,
#if defined(ENABLE_OVERLOADING)
EventGetSourceDeviceMethodInfo ,
#endif
eventGetSourceDevice ,
#if defined(ENABLE_OVERLOADING)
EventGetStageMethodInfo ,
#endif
eventGetStage ,
#if defined(ENABLE_OVERLOADING)
EventGetStateMethodInfo ,
#endif
eventGetState ,
#if defined(ENABLE_OVERLOADING)
EventGetStateFullMethodInfo ,
#endif
eventGetStateFull ,
#if defined(ENABLE_OVERLOADING)
EventGetTimeMethodInfo ,
#endif
eventGetTime ,
#if defined(ENABLE_OVERLOADING)
EventHasControlModifierMethodInfo ,
#endif
eventHasControlModifier ,
#if defined(ENABLE_OVERLOADING)
EventHasShiftModifierMethodInfo ,
#endif
eventHasShiftModifier ,
#if defined(ENABLE_OVERLOADING)
EventIsPointerEmulatedMethodInfo ,
#endif
eventIsPointerEmulated ,
eventNew ,
eventPeek ,
#if defined(ENABLE_OVERLOADING)
EventPutMethodInfo ,
#endif
eventPut ,
eventRemoveFilter ,
#if defined(ENABLE_OVERLOADING)
EventSetButtonMethodInfo ,
#endif
eventSetButton ,
#if defined(ENABLE_OVERLOADING)
EventSetCoordsMethodInfo ,
#endif
eventSetCoords ,
#if defined(ENABLE_OVERLOADING)
EventSetDeviceMethodInfo ,
#endif
eventSetDevice ,
#if defined(ENABLE_OVERLOADING)
EventSetFlagsMethodInfo ,
#endif
eventSetFlags ,
#if defined(ENABLE_OVERLOADING)
EventSetKeyCodeMethodInfo ,
#endif
eventSetKeyCode ,
#if defined(ENABLE_OVERLOADING)
EventSetKeySymbolMethodInfo ,
#endif
eventSetKeySymbol ,
#if defined(ENABLE_OVERLOADING)
EventSetKeyUnicodeMethodInfo ,
#endif
eventSetKeyUnicode ,
#if defined(ENABLE_OVERLOADING)
EventSetRelatedMethodInfo ,
#endif
eventSetRelated ,
#if defined(ENABLE_OVERLOADING)
EventSetScrollDeltaMethodInfo ,
#endif
eventSetScrollDelta ,
#if defined(ENABLE_OVERLOADING)
EventSetScrollDirectionMethodInfo ,
#endif
eventSetScrollDirection ,
#if defined(ENABLE_OVERLOADING)
EventSetSourceMethodInfo ,
#endif
eventSetSource ,
#if defined(ENABLE_OVERLOADING)
EventSetSourceDeviceMethodInfo ,
#endif
eventSetSourceDevice ,
#if defined(ENABLE_OVERLOADING)
EventSetStageMethodInfo ,
#endif
eventSetStage ,
#if defined(ENABLE_OVERLOADING)
EventSetStateMethodInfo ,
#endif
eventSetState ,
#if defined(ENABLE_OVERLOADING)
EventSetTimeMethodInfo ,
#endif
eventSetTime ,
#if defined(ENABLE_OVERLOADING)
EventTypeMethodInfo ,
#endif
eventType ,
) 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 qualified GI.Clutter.Callbacks as Clutter.Callbacks
import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage
import {-# SOURCE #-} qualified GI.Clutter.Structs.EventSequence as Clutter.EventSequence
import {-# SOURCE #-} qualified GI.Clutter.Structs.Point as Clutter.Point
import qualified GI.GLib.Callbacks as GLib.Callbacks
newtype Event = Event (SP.ManagedPtr Event)
deriving (Event -> Event -> Bool
(Event -> Event -> Bool) -> (Event -> Event -> Bool) -> Eq Event
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Event -> Event -> Bool
== :: Event -> Event -> Bool
$c/= :: Event -> Event -> Bool
/= :: Event -> Event -> Bool
Eq)
instance SP.ManagedPtrNewtype Event where
toManagedPtr :: Event -> ManagedPtr Event
toManagedPtr (Event ManagedPtr Event
p) = ManagedPtr Event
p
foreign import ccall "clutter_event_get_type" c_clutter_event_get_type ::
IO GType
type instance O.ParentTypes Event = '[]
instance O.HasParentTypes Event
instance B.Types.TypedObject Event where
glibType :: IO GType
glibType = IO GType
c_clutter_event_get_type
instance B.Types.GBoxed Event
instance B.GValue.IsGValue (Maybe Event) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_event_get_type
gvalueSet_ :: Ptr GValue -> Maybe Event -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Event
P.Nothing = Ptr GValue -> Ptr Event -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Event
forall a. Ptr a
FP.nullPtr :: FP.Ptr Event)
gvalueSet_ Ptr GValue
gv (P.Just Event
obj) = Event -> (Ptr Event -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Event
obj (Ptr GValue -> Ptr Event -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Event)
gvalueGet_ Ptr GValue
gv = do
Ptr Event
ptr <- Ptr GValue -> IO (Ptr Event)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Event)
if Ptr Event
ptr Ptr Event -> Ptr Event -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Event
forall a. Ptr a
FP.nullPtr
then Event -> Maybe Event
forall a. a -> Maybe a
P.Just (Event -> Maybe Event) -> IO Event -> IO (Maybe Event)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Event -> Event
Event Ptr Event
ptr
else Maybe Event -> IO (Maybe Event)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Event
forall a. Maybe a
P.Nothing
newZeroEvent :: MonadIO m => m Event
newZeroEvent :: forall (m :: * -> *). MonadIO m => m Event
newZeroEvent = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Event)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
72 IO (Ptr Event) -> (Ptr Event -> IO Event) -> IO Event
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event
instance tag ~ 'AttrSet => Constructible Event tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Event -> Event) -> [AttrOp Event tag] -> m Event
new ManagedPtr Event -> Event
_ [AttrOp Event tag]
attrs = do
Event
o <- m Event
forall (m :: * -> *). MonadIO m => m Event
newZeroEvent
Event -> [AttrOp Event 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Event
o [AttrOp Event tag]
[AttrOp Event 'AttrSet]
attrs
Event -> m Event
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Event
type instance O.AttributeList Event = EventAttributeList
type EventAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "clutter_event_new" clutter_event_new ::
CUInt ->
IO (Ptr Event)
eventNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Clutter.Enums.EventType
-> m Event
eventNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
EventType -> m Event
eventNew EventType
type_ = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (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
type_
Ptr Event
result <- CUInt -> IO (Ptr Event)
clutter_event_new CUInt
type_'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNew" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_event_copy" clutter_event_copy ::
Ptr Event ->
IO (Ptr Event)
eventCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Event
eventCopy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Event
eventCopy Event
event = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event
result <- Ptr Event -> IO (Ptr Event)
clutter_event_copy Ptr Event
event'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventCopy" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
data EventCopyMethodInfo
instance (signature ~ (m Event), MonadIO m) => O.OverloadedMethod EventCopyMethodInfo Event signature where
overloadedMethod = eventCopy
instance O.OverloadedMethodInfo EventCopyMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventCopy"
})
#endif
foreign import ccall "clutter_event_free" clutter_event_free ::
Ptr Event ->
IO ()
eventFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ()
eventFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m ()
eventFree Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> IO ()
clutter_event_free Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod EventFreeMethodInfo Event signature where
overloadedMethod = eventFree
instance O.OverloadedMethodInfo EventFreeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventFree"
})
#endif
foreign import ccall "clutter_event_get_angle" clutter_event_get_angle ::
Ptr Event ->
Ptr Event ->
IO CDouble
eventGetAngle ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Event
-> m Double
eventGetAngle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Event -> m Double
eventGetAngle Event
source Event
target = 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
$ do
Ptr Event
source' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
source
Ptr Event
target' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
target
CDouble
result <- Ptr Event -> Ptr Event -> IO CDouble
clutter_event_get_angle Ptr Event
source' Ptr Event
target'
let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
source
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
target
Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'
#if defined(ENABLE_OVERLOADING)
data EventGetAngleMethodInfo
instance (signature ~ (Event -> m Double), MonadIO m) => O.OverloadedMethod EventGetAngleMethodInfo Event signature where
overloadedMethod = eventGetAngle
instance O.OverloadedMethodInfo EventGetAngleMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetAngle",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetAngle"
})
#endif
foreign import ccall "clutter_event_get_axes" clutter_event_get_axes ::
Ptr Event ->
Ptr Word32 ->
IO CDouble
eventGetAxes ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Double, Word32))
eventGetAxes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Double, Word32)
eventGetAxes Event
event = IO (Double, Word32) -> m (Double, Word32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Word32) -> m (Double, Word32))
-> IO (Double, Word32) -> m (Double, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Word32
nAxes <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CDouble
result <- Ptr Event -> Ptr Word32 -> IO CDouble
clutter_event_get_axes Ptr Event
event' Ptr Word32
nAxes
let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
Word32
nAxes' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
nAxes
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
nAxes
(Double, Word32) -> IO (Double, Word32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
result', Word32
nAxes')
#if defined(ENABLE_OVERLOADING)
data EventGetAxesMethodInfo
instance (signature ~ (m ((Double, Word32))), MonadIO m) => O.OverloadedMethod EventGetAxesMethodInfo Event signature where
overloadedMethod = eventGetAxes
instance O.OverloadedMethodInfo EventGetAxesMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetAxes",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetAxes"
})
#endif
foreign import ccall "clutter_event_get_button" clutter_event_get_button ::
Ptr Event ->
IO Word32
eventGetButton ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Word32
eventGetButton :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word32
eventGetButton Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Word32
result <- Ptr Event -> IO Word32
clutter_event_get_button Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data EventGetButtonMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod EventGetButtonMethodInfo Event signature where
overloadedMethod = eventGetButton
instance O.OverloadedMethodInfo EventGetButtonMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetButton",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetButton"
})
#endif
foreign import ccall "clutter_event_get_click_count" clutter_event_get_click_count ::
Ptr Event ->
IO Word32
eventGetClickCount ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Word32
eventGetClickCount :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word32
eventGetClickCount Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Word32
result <- Ptr Event -> IO Word32
clutter_event_get_click_count Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data EventGetClickCountMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod EventGetClickCountMethodInfo Event signature where
overloadedMethod = eventGetClickCount
instance O.OverloadedMethodInfo EventGetClickCountMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetClickCount",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetClickCount"
})
#endif
foreign import ccall "clutter_event_get_coords" clutter_event_get_coords ::
Ptr Event ->
Ptr CFloat ->
Ptr CFloat ->
IO ()
eventGetCoords ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Float, Float))
eventGetCoords :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Float, Float)
eventGetCoords Event
event = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CFloat
x <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
y <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr Event -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_event_get_coords Ptr Event
event' Ptr CFloat
x Ptr CFloat
y
CFloat
x' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
x
let x'' :: Float
x'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x'
CFloat
y' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
y
let y'' :: Float
y'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
x
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
y
(Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
x'', Float
y'')
#if defined(ENABLE_OVERLOADING)
data EventGetCoordsMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m) => O.OverloadedMethod EventGetCoordsMethodInfo Event signature where
overloadedMethod = eventGetCoords
instance O.OverloadedMethodInfo EventGetCoordsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetCoords",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetCoords"
})
#endif
foreign import ccall "clutter_event_get_device" clutter_event_get_device ::
Ptr Event ->
IO (Ptr Clutter.InputDevice.InputDevice)
eventGetDevice ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.InputDevice.InputDevice
eventGetDevice :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m InputDevice
eventGetDevice Event
event = IO InputDevice -> m InputDevice
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputDevice -> m InputDevice)
-> IO InputDevice -> m InputDevice
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr InputDevice
result <- Ptr Event -> IO (Ptr InputDevice)
clutter_event_get_device Ptr Event
event'
Text -> Ptr InputDevice -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventGetDevice" Ptr InputDevice
result
InputDevice
result' <- ((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
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
InputDevice -> IO InputDevice
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputDevice
result'
#if defined(ENABLE_OVERLOADING)
data EventGetDeviceMethodInfo
instance (signature ~ (m Clutter.InputDevice.InputDevice), MonadIO m) => O.OverloadedMethod EventGetDeviceMethodInfo Event signature where
overloadedMethod = eventGetDevice
instance O.OverloadedMethodInfo EventGetDeviceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetDevice",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetDevice"
})
#endif
foreign import ccall "clutter_event_get_device_id" clutter_event_get_device_id ::
Ptr Event ->
IO Int32
eventGetDeviceId ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Int32
eventGetDeviceId :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Int32
eventGetDeviceId Event
event = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Int32
result <- Ptr Event -> IO Int32
clutter_event_get_device_id Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data EventGetDeviceIdMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod EventGetDeviceIdMethodInfo Event signature where
overloadedMethod = eventGetDeviceId
instance O.OverloadedMethodInfo EventGetDeviceIdMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetDeviceId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetDeviceId"
})
#endif
foreign import ccall "clutter_event_get_device_type" clutter_event_get_device_type ::
Ptr Event ->
IO CUInt
eventGetDeviceType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.Enums.InputDeviceType
eventGetDeviceType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m InputDeviceType
eventGetDeviceType Event
event = IO InputDeviceType -> m InputDeviceType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputDeviceType -> m InputDeviceType)
-> IO InputDeviceType -> m InputDeviceType
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- Ptr Event -> IO CUInt
clutter_event_get_device_type Ptr Event
event'
let result' :: InputDeviceType
result' = (Int -> InputDeviceType
forall a. Enum a => Int -> a
toEnum (Int -> InputDeviceType)
-> (CUInt -> Int) -> CUInt -> InputDeviceType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
InputDeviceType -> IO InputDeviceType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputDeviceType
result'
#if defined(ENABLE_OVERLOADING)
data EventGetDeviceTypeMethodInfo
instance (signature ~ (m Clutter.Enums.InputDeviceType), MonadIO m) => O.OverloadedMethod EventGetDeviceTypeMethodInfo Event signature where
overloadedMethod = eventGetDeviceType
instance O.OverloadedMethodInfo EventGetDeviceTypeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetDeviceType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetDeviceType"
})
#endif
foreign import ccall "clutter_event_get_distance" clutter_event_get_distance ::
Ptr Event ->
Ptr Event ->
IO CFloat
eventGetDistance ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Event
-> m Float
eventGetDistance :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Event -> m Float
eventGetDistance Event
source Event
target = 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
$ do
Ptr Event
source' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
source
Ptr Event
target' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
target
CFloat
result <- Ptr Event -> Ptr Event -> IO CFloat
clutter_event_get_distance Ptr Event
source' Ptr Event
target'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
source
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
target
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data EventGetDistanceMethodInfo
instance (signature ~ (Event -> m Float), MonadIO m) => O.OverloadedMethod EventGetDistanceMethodInfo Event signature where
overloadedMethod = eventGetDistance
instance O.OverloadedMethodInfo EventGetDistanceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetDistance",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetDistance"
})
#endif
foreign import ccall "clutter_event_get_event_sequence" clutter_event_get_event_sequence ::
Ptr Event ->
IO (Ptr Clutter.EventSequence.EventSequence)
eventGetEventSequence ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.EventSequence.EventSequence
eventGetEventSequence :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m EventSequence
eventGetEventSequence Event
event = IO EventSequence -> m EventSequence
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EventSequence -> m EventSequence)
-> IO EventSequence -> m EventSequence
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr EventSequence
result <- Ptr Event -> IO (Ptr EventSequence)
clutter_event_get_event_sequence Ptr Event
event'
Text -> Ptr EventSequence -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventGetEventSequence" Ptr EventSequence
result
EventSequence
result' <- ((ManagedPtr EventSequence -> EventSequence)
-> Ptr EventSequence -> IO EventSequence
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr EventSequence -> EventSequence
Clutter.EventSequence.EventSequence) Ptr EventSequence
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
EventSequence -> IO EventSequence
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EventSequence
result'
#if defined(ENABLE_OVERLOADING)
data EventGetEventSequenceMethodInfo
instance (signature ~ (m Clutter.EventSequence.EventSequence), MonadIO m) => O.OverloadedMethod EventGetEventSequenceMethodInfo Event signature where
overloadedMethod = eventGetEventSequence
instance O.OverloadedMethodInfo EventGetEventSequenceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetEventSequence",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetEventSequence"
})
#endif
foreign import ccall "clutter_event_get_flags" clutter_event_get_flags ::
Ptr Event ->
IO CUInt
eventGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m [Clutter.Flags.EventFlags]
eventGetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m [EventFlags]
eventGetFlags Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- Ptr Event -> IO CUInt
clutter_event_get_flags Ptr Event
event'
let result' :: [EventFlags]
result' = CUInt -> [EventFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
[EventFlags] -> IO [EventFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [EventFlags]
result'
#if defined(ENABLE_OVERLOADING)
data EventGetFlagsMethodInfo
instance (signature ~ (m [Clutter.Flags.EventFlags]), MonadIO m) => O.OverloadedMethod EventGetFlagsMethodInfo Event signature where
overloadedMethod = eventGetFlags
instance O.OverloadedMethodInfo EventGetFlagsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetFlags"
})
#endif
foreign import ccall "clutter_event_get_gesture_motion_delta" clutter_event_get_gesture_motion_delta ::
Ptr Event ->
Ptr CDouble ->
Ptr CDouble ->
IO ()
eventGetGestureMotionDelta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Double, Double))
eventGetGestureMotionDelta :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Double, Double)
eventGetGestureMotionDelta Event
event = IO (Double, Double) -> m (Double, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Double) -> m (Double, Double))
-> IO (Double, Double) -> m (Double, Double)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CDouble
dx <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CDouble
dy <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr Event -> Ptr CDouble -> Ptr CDouble -> IO ()
clutter_event_get_gesture_motion_delta Ptr Event
event' Ptr CDouble
dx Ptr CDouble
dy
CDouble
dx' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
dx
let dx'' :: Double
dx'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
dx'
CDouble
dy' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
dy
let dy'' :: Double
dy'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
dy'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
dx
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
dy
(Double, Double) -> IO (Double, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
dx'', Double
dy'')
#if defined(ENABLE_OVERLOADING)
data EventGetGestureMotionDeltaMethodInfo
instance (signature ~ (m ((Double, Double))), MonadIO m) => O.OverloadedMethod EventGetGestureMotionDeltaMethodInfo Event signature where
overloadedMethod = eventGetGestureMotionDelta
instance O.OverloadedMethodInfo EventGetGestureMotionDeltaMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetGestureMotionDelta",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetGestureMotionDelta"
})
#endif
foreign import ccall "clutter_event_get_gesture_phase" clutter_event_get_gesture_phase ::
Ptr Event ->
IO CUInt
eventGetGesturePhase ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.Enums.TouchpadGesturePhase
eventGetGesturePhase :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m TouchpadGesturePhase
eventGetGesturePhase Event
event = IO TouchpadGesturePhase -> m TouchpadGesturePhase
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TouchpadGesturePhase -> m TouchpadGesturePhase)
-> IO TouchpadGesturePhase -> m TouchpadGesturePhase
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- Ptr Event -> IO CUInt
clutter_event_get_gesture_phase Ptr Event
event'
let result' :: TouchpadGesturePhase
result' = (Int -> TouchpadGesturePhase
forall a. Enum a => Int -> a
toEnum (Int -> TouchpadGesturePhase)
-> (CUInt -> Int) -> CUInt -> TouchpadGesturePhase
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
TouchpadGesturePhase -> IO TouchpadGesturePhase
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TouchpadGesturePhase
result'
#if defined(ENABLE_OVERLOADING)
data EventGetGesturePhaseMethodInfo
instance (signature ~ (m Clutter.Enums.TouchpadGesturePhase), MonadIO m) => O.OverloadedMethod EventGetGesturePhaseMethodInfo Event signature where
overloadedMethod = eventGetGesturePhase
instance O.OverloadedMethodInfo EventGetGesturePhaseMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetGesturePhase",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetGesturePhase"
})
#endif
foreign import ccall "clutter_event_get_gesture_pinch_angle_delta" clutter_event_get_gesture_pinch_angle_delta ::
Ptr Event ->
IO CDouble
eventGetGesturePinchAngleDelta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Double
eventGetGesturePinchAngleDelta :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Double
eventGetGesturePinchAngleDelta Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CDouble
result <- Ptr Event -> IO CDouble
clutter_event_get_gesture_pinch_angle_delta Ptr Event
event'
let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'
#if defined(ENABLE_OVERLOADING)
data EventGetGesturePinchAngleDeltaMethodInfo
instance (signature ~ (m Double), MonadIO m) => O.OverloadedMethod EventGetGesturePinchAngleDeltaMethodInfo Event signature where
overloadedMethod = eventGetGesturePinchAngleDelta
instance O.OverloadedMethodInfo EventGetGesturePinchAngleDeltaMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetGesturePinchAngleDelta",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetGesturePinchAngleDelta"
})
#endif
foreign import ccall "clutter_event_get_gesture_pinch_scale" clutter_event_get_gesture_pinch_scale ::
Ptr Event ->
IO CDouble
eventGetGesturePinchScale ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Double
eventGetGesturePinchScale :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Double
eventGetGesturePinchScale Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CDouble
result <- Ptr Event -> IO CDouble
clutter_event_get_gesture_pinch_scale Ptr Event
event'
let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'
#if defined(ENABLE_OVERLOADING)
data EventGetGesturePinchScaleMethodInfo
instance (signature ~ (m Double), MonadIO m) => O.OverloadedMethod EventGetGesturePinchScaleMethodInfo Event signature where
overloadedMethod = eventGetGesturePinchScale
instance O.OverloadedMethodInfo EventGetGesturePinchScaleMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetGesturePinchScale",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetGesturePinchScale"
})
#endif
foreign import ccall "clutter_event_get_gesture_swipe_finger_count" clutter_event_get_gesture_swipe_finger_count ::
Ptr Event ->
IO Word32
eventGetGestureSwipeFingerCount ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Word32
eventGetGestureSwipeFingerCount :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word32
eventGetGestureSwipeFingerCount Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Word32
result <- Ptr Event -> IO Word32
clutter_event_get_gesture_swipe_finger_count Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data EventGetGestureSwipeFingerCountMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod EventGetGestureSwipeFingerCountMethodInfo Event signature where
overloadedMethod = eventGetGestureSwipeFingerCount
instance O.OverloadedMethodInfo EventGetGestureSwipeFingerCountMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetGestureSwipeFingerCount",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetGestureSwipeFingerCount"
})
#endif
foreign import ccall "clutter_event_get_key_code" clutter_event_get_key_code ::
Ptr Event ->
IO Word16
eventGetKeyCode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Word16
eventGetKeyCode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word16
eventGetKeyCode Event
event = IO Word16 -> m Word16
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Word16
result <- Ptr Event -> IO Word16
clutter_event_get_key_code Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Word16 -> IO Word16
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
result
#if defined(ENABLE_OVERLOADING)
data EventGetKeyCodeMethodInfo
instance (signature ~ (m Word16), MonadIO m) => O.OverloadedMethod EventGetKeyCodeMethodInfo Event signature where
overloadedMethod = eventGetKeyCode
instance O.OverloadedMethodInfo EventGetKeyCodeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetKeyCode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetKeyCode"
})
#endif
foreign import ccall "clutter_event_get_key_symbol" clutter_event_get_key_symbol ::
Ptr Event ->
IO Word32
eventGetKeySymbol ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Word32
eventGetKeySymbol :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word32
eventGetKeySymbol Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Word32
result <- Ptr Event -> IO Word32
clutter_event_get_key_symbol Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data EventGetKeySymbolMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod EventGetKeySymbolMethodInfo Event signature where
overloadedMethod = eventGetKeySymbol
instance O.OverloadedMethodInfo EventGetKeySymbolMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetKeySymbol",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetKeySymbol"
})
#endif
foreign import ccall "clutter_event_get_key_unicode" clutter_event_get_key_unicode ::
Ptr Event ->
IO CInt
eventGetKeyUnicode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Char
eventGetKeyUnicode :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Char
eventGetKeyUnicode Event
event = IO Char -> m Char
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Char -> m Char) -> IO Char -> m Char
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr Event -> IO CInt
clutter_event_get_key_unicode Ptr Event
event'
let result' :: Char
result' = (Int -> Char
chr (Int -> Char) -> (CInt -> Int) -> CInt -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Char -> IO Char
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
result'
#if defined(ENABLE_OVERLOADING)
data EventGetKeyUnicodeMethodInfo
instance (signature ~ (m Char), MonadIO m) => O.OverloadedMethod EventGetKeyUnicodeMethodInfo Event signature where
overloadedMethod = eventGetKeyUnicode
instance O.OverloadedMethodInfo EventGetKeyUnicodeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetKeyUnicode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetKeyUnicode"
})
#endif
foreign import ccall "clutter_event_get_position" clutter_event_get_position ::
Ptr Event ->
Ptr Clutter.Point.Point ->
IO ()
eventGetPosition ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Clutter.Point.Point
-> m ()
eventGetPosition :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Point -> m ()
eventGetPosition Event
event Point
position = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Point
position' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
position
Ptr Event -> Ptr Point -> IO ()
clutter_event_get_position Ptr Event
event' Ptr Point
position'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
position
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventGetPositionMethodInfo
instance (signature ~ (Clutter.Point.Point -> m ()), MonadIO m) => O.OverloadedMethod EventGetPositionMethodInfo Event signature where
overloadedMethod = eventGetPosition
instance O.OverloadedMethodInfo EventGetPositionMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetPosition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetPosition"
})
#endif
foreign import ccall "clutter_event_get_related" clutter_event_get_related ::
Ptr Event ->
IO (Ptr Clutter.Actor.Actor)
eventGetRelated ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.Actor.Actor
eventGetRelated :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Actor
eventGetRelated Event
event = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Actor
result <- Ptr Event -> IO (Ptr Actor)
clutter_event_get_related Ptr Event
event'
Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventGetRelated" Ptr Actor
result
Actor
result' <- ((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
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'
#if defined(ENABLE_OVERLOADING)
data EventGetRelatedMethodInfo
instance (signature ~ (m Clutter.Actor.Actor), MonadIO m) => O.OverloadedMethod EventGetRelatedMethodInfo Event signature where
overloadedMethod = eventGetRelated
instance O.OverloadedMethodInfo EventGetRelatedMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetRelated",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetRelated"
})
#endif
foreign import ccall "clutter_event_get_scroll_delta" clutter_event_get_scroll_delta ::
Ptr Event ->
Ptr CDouble ->
Ptr CDouble ->
IO ()
eventGetScrollDelta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Double, Double))
eventGetScrollDelta :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Double, Double)
eventGetScrollDelta Event
event = IO (Double, Double) -> m (Double, Double)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Double) -> m (Double, Double))
-> IO (Double, Double) -> m (Double, Double)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CDouble
dx <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CDouble
dy <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr Event -> Ptr CDouble -> Ptr CDouble -> IO ()
clutter_event_get_scroll_delta Ptr Event
event' Ptr CDouble
dx Ptr CDouble
dy
CDouble
dx' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
dx
let dx'' :: Double
dx'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
dx'
CDouble
dy' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
dy
let dy'' :: Double
dy'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
dy'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
dx
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
dy
(Double, Double) -> IO (Double, Double)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
dx'', Double
dy'')
#if defined(ENABLE_OVERLOADING)
data EventGetScrollDeltaMethodInfo
instance (signature ~ (m ((Double, Double))), MonadIO m) => O.OverloadedMethod EventGetScrollDeltaMethodInfo Event signature where
overloadedMethod = eventGetScrollDelta
instance O.OverloadedMethodInfo EventGetScrollDeltaMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetScrollDelta",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetScrollDelta"
})
#endif
foreign import ccall "clutter_event_get_scroll_direction" clutter_event_get_scroll_direction ::
Ptr Event ->
IO CUInt
eventGetScrollDirection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.Enums.ScrollDirection
eventGetScrollDirection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m ScrollDirection
eventGetScrollDirection Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- Ptr Event -> IO CUInt
clutter_event_get_scroll_direction Ptr Event
event'
let result' :: ScrollDirection
result' = (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
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
ScrollDirection -> IO ScrollDirection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScrollDirection
result'
#if defined(ENABLE_OVERLOADING)
data EventGetScrollDirectionMethodInfo
instance (signature ~ (m Clutter.Enums.ScrollDirection), MonadIO m) => O.OverloadedMethod EventGetScrollDirectionMethodInfo Event signature where
overloadedMethod = eventGetScrollDirection
instance O.OverloadedMethodInfo EventGetScrollDirectionMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetScrollDirection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetScrollDirection"
})
#endif
foreign import ccall "clutter_event_get_source" clutter_event_get_source ::
Ptr Event ->
IO (Ptr Clutter.Actor.Actor)
eventGetSource ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.Actor.Actor
eventGetSource :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Actor
eventGetSource Event
event = IO Actor -> m Actor
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Actor -> m Actor) -> IO Actor -> m Actor
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Actor
result <- Ptr Event -> IO (Ptr Actor)
clutter_event_get_source Ptr Event
event'
Text -> Ptr Actor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventGetSource" Ptr Actor
result
Actor
result' <- ((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
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Actor -> IO Actor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Actor
result'
#if defined(ENABLE_OVERLOADING)
data EventGetSourceMethodInfo
instance (signature ~ (m Clutter.Actor.Actor), MonadIO m) => O.OverloadedMethod EventGetSourceMethodInfo Event signature where
overloadedMethod = eventGetSource
instance O.OverloadedMethodInfo EventGetSourceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetSource"
})
#endif
foreign import ccall "clutter_event_get_source_device" clutter_event_get_source_device ::
Ptr Event ->
IO (Ptr Clutter.InputDevice.InputDevice)
eventGetSourceDevice ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.InputDevice.InputDevice
eventGetSourceDevice :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m InputDevice
eventGetSourceDevice Event
event = IO InputDevice -> m InputDevice
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputDevice -> m InputDevice)
-> IO InputDevice -> m InputDevice
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr InputDevice
result <- Ptr Event -> IO (Ptr InputDevice)
clutter_event_get_source_device Ptr Event
event'
Text -> Ptr InputDevice -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventGetSourceDevice" Ptr InputDevice
result
InputDevice
result' <- ((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
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
InputDevice -> IO InputDevice
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputDevice
result'
#if defined(ENABLE_OVERLOADING)
data EventGetSourceDeviceMethodInfo
instance (signature ~ (m Clutter.InputDevice.InputDevice), MonadIO m) => O.OverloadedMethod EventGetSourceDeviceMethodInfo Event signature where
overloadedMethod = eventGetSourceDevice
instance O.OverloadedMethodInfo EventGetSourceDeviceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetSourceDevice",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetSourceDevice"
})
#endif
foreign import ccall "clutter_event_get_stage" clutter_event_get_stage ::
Ptr Event ->
IO (Ptr Clutter.Stage.Stage)
eventGetStage ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.Stage.Stage
eventGetStage :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Stage
eventGetStage Event
event = IO Stage -> m Stage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stage -> m Stage) -> IO Stage -> m Stage
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Stage
result <- Ptr Event -> IO (Ptr Stage)
clutter_event_get_stage Ptr Event
event'
Text -> Ptr Stage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventGetStage" Ptr Stage
result
Stage
result' <- ((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
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Stage -> IO Stage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Stage
result'
#if defined(ENABLE_OVERLOADING)
data EventGetStageMethodInfo
instance (signature ~ (m Clutter.Stage.Stage), MonadIO m) => O.OverloadedMethod EventGetStageMethodInfo Event signature where
overloadedMethod = eventGetStage
instance O.OverloadedMethodInfo EventGetStageMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetStage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetStage"
})
#endif
foreign import ccall "clutter_event_get_state" clutter_event_get_state ::
Ptr Event ->
IO CUInt
eventGetState ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m [Clutter.Flags.ModifierType]
eventGetState :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m [ModifierType]
eventGetState Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- Ptr Event -> IO CUInt
clutter_event_get_state Ptr Event
event'
let result' :: [ModifierType]
result' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
[ModifierType] -> IO [ModifierType]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ModifierType]
result'
#if defined(ENABLE_OVERLOADING)
data EventGetStateMethodInfo
instance (signature ~ (m [Clutter.Flags.ModifierType]), MonadIO m) => O.OverloadedMethod EventGetStateMethodInfo Event signature where
overloadedMethod = eventGetState
instance O.OverloadedMethodInfo EventGetStateMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetState"
})
#endif
foreign import ccall "clutter_event_get_state_full" clutter_event_get_state_full ::
Ptr Event ->
Ptr CUInt ->
Ptr CUInt ->
Ptr CUInt ->
Ptr CUInt ->
Ptr CUInt ->
IO ()
eventGetStateFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (([Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType]))
eventGetStateFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event
-> m ([ModifierType], [ModifierType], [ModifierType],
[ModifierType], [ModifierType])
eventGetStateFull Event
event = IO
([ModifierType], [ModifierType], [ModifierType], [ModifierType],
[ModifierType])
-> m ([ModifierType], [ModifierType], [ModifierType],
[ModifierType], [ModifierType])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO
([ModifierType], [ModifierType], [ModifierType], [ModifierType],
[ModifierType])
-> m ([ModifierType], [ModifierType], [ModifierType],
[ModifierType], [ModifierType]))
-> IO
([ModifierType], [ModifierType], [ModifierType], [ModifierType],
[ModifierType])
-> m ([ModifierType], [ModifierType], [ModifierType],
[ModifierType], [ModifierType])
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CUInt
buttonState <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
baseState <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
latchedState <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
lockedState <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
effectiveState <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Event
-> Ptr CUInt
-> Ptr CUInt
-> Ptr CUInt
-> Ptr CUInt
-> Ptr CUInt
-> IO ()
clutter_event_get_state_full Ptr Event
event' Ptr CUInt
buttonState Ptr CUInt
baseState Ptr CUInt
latchedState Ptr CUInt
lockedState Ptr CUInt
effectiveState
CUInt
buttonState' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
buttonState
let buttonState'' :: [ModifierType]
buttonState'' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
buttonState'
CUInt
baseState' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
baseState
let baseState'' :: [ModifierType]
baseState'' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
baseState'
CUInt
latchedState' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
latchedState
let latchedState'' :: [ModifierType]
latchedState'' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
latchedState'
CUInt
lockedState' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
lockedState
let lockedState'' :: [ModifierType]
lockedState'' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
lockedState'
CUInt
effectiveState' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
effectiveState
let effectiveState'' :: [ModifierType]
effectiveState'' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
effectiveState'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
buttonState
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
baseState
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
latchedState
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
lockedState
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
effectiveState
([ModifierType], [ModifierType], [ModifierType], [ModifierType],
[ModifierType])
-> IO
([ModifierType], [ModifierType], [ModifierType], [ModifierType],
[ModifierType])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ([ModifierType]
buttonState'', [ModifierType]
baseState'', [ModifierType]
latchedState'', [ModifierType]
lockedState'', [ModifierType]
effectiveState'')
#if defined(ENABLE_OVERLOADING)
data EventGetStateFullMethodInfo
instance (signature ~ (m (([Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType], [Clutter.Flags.ModifierType]))), MonadIO m) => O.OverloadedMethod EventGetStateFullMethodInfo Event signature where
overloadedMethod = eventGetStateFull
instance O.OverloadedMethodInfo EventGetStateFullMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetStateFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetStateFull"
})
#endif
foreign import ccall "clutter_event_get_time" clutter_event_get_time ::
Ptr Event ->
IO Word32
eventGetTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Word32
eventGetTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word32
eventGetTime Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Word32
result <- Ptr Event -> IO Word32
clutter_event_get_time Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data EventGetTimeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod EventGetTimeMethodInfo Event signature where
overloadedMethod = eventGetTime
instance O.OverloadedMethodInfo EventGetTimeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventGetTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventGetTime"
})
#endif
foreign import ccall "clutter_event_has_control_modifier" clutter_event_has_control_modifier ::
Ptr Event ->
IO CInt
eventHasControlModifier ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Bool
eventHasControlModifier :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Bool
eventHasControlModifier Event
event = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr Event -> IO CInt
clutter_event_has_control_modifier Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data EventHasControlModifierMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod EventHasControlModifierMethodInfo Event signature where
overloadedMethod = eventHasControlModifier
instance O.OverloadedMethodInfo EventHasControlModifierMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventHasControlModifier",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventHasControlModifier"
})
#endif
foreign import ccall "clutter_event_has_shift_modifier" clutter_event_has_shift_modifier ::
Ptr Event ->
IO CInt
eventHasShiftModifier ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Bool
eventHasShiftModifier :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Bool
eventHasShiftModifier Event
event = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr Event -> IO CInt
clutter_event_has_shift_modifier Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data EventHasShiftModifierMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod EventHasShiftModifierMethodInfo Event signature where
overloadedMethod = eventHasShiftModifier
instance O.OverloadedMethodInfo EventHasShiftModifierMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventHasShiftModifier",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventHasShiftModifier"
})
#endif
foreign import ccall "clutter_event_is_pointer_emulated" clutter_event_is_pointer_emulated ::
Ptr Event ->
IO CInt
eventIsPointerEmulated ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Bool
eventIsPointerEmulated :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Bool
eventIsPointerEmulated Event
event = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr Event -> IO CInt
clutter_event_is_pointer_emulated Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data EventIsPointerEmulatedMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod EventIsPointerEmulatedMethodInfo Event signature where
overloadedMethod = eventIsPointerEmulated
instance O.OverloadedMethodInfo EventIsPointerEmulatedMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventIsPointerEmulated",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventIsPointerEmulated"
})
#endif
foreign import ccall "clutter_event_put" clutter_event_put ::
Ptr Event ->
IO ()
eventPut ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ()
eventPut :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m ()
eventPut Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> IO ()
clutter_event_put Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventPutMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod EventPutMethodInfo Event signature where
overloadedMethod = eventPut
instance O.OverloadedMethodInfo EventPutMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventPut",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventPut"
})
#endif
foreign import ccall "clutter_event_set_button" clutter_event_set_button ::
Ptr Event ->
Word32 ->
IO ()
eventSetButton ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word32
-> m ()
eventSetButton :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word32 -> m ()
eventSetButton Event
event Word32
button = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Word32 -> IO ()
clutter_event_set_button Ptr Event
event' Word32
button
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetButtonMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod EventSetButtonMethodInfo Event signature where
overloadedMethod = eventSetButton
instance O.OverloadedMethodInfo EventSetButtonMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetButton",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetButton"
})
#endif
foreign import ccall "clutter_event_set_coords" clutter_event_set_coords ::
Ptr Event ->
CFloat ->
CFloat ->
IO ()
eventSetCoords ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Float
-> Float
-> m ()
eventSetCoords :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Float -> Float -> m ()
eventSetCoords Event
event Float
x Float
y = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
Ptr Event -> CFloat -> CFloat -> IO ()
clutter_event_set_coords Ptr Event
event' CFloat
x' CFloat
y'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetCoordsMethodInfo
instance (signature ~ (Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod EventSetCoordsMethodInfo Event signature where
overloadedMethod = eventSetCoords
instance O.OverloadedMethodInfo EventSetCoordsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetCoords",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetCoords"
})
#endif
foreign import ccall "clutter_event_set_device" clutter_event_set_device ::
Ptr Event ->
Ptr Clutter.InputDevice.InputDevice ->
IO ()
eventSetDevice ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.InputDevice.IsInputDevice a) =>
Event
-> Maybe (a)
-> m ()
eventSetDevice :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputDevice a) =>
Event -> Maybe a -> m ()
eventSetDevice Event
event Maybe a
device = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr InputDevice
maybeDevice <- case Maybe a
device of
Maybe a
Nothing -> Ptr InputDevice -> IO (Ptr InputDevice)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputDevice
forall a. Ptr a
nullPtr
Just a
jDevice -> do
Ptr InputDevice
jDevice' <- a -> IO (Ptr InputDevice)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jDevice
Ptr InputDevice -> IO (Ptr InputDevice)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputDevice
jDevice'
Ptr Event -> Ptr InputDevice -> IO ()
clutter_event_set_device Ptr Event
event' Ptr InputDevice
maybeDevice
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
device a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetDeviceMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Clutter.InputDevice.IsInputDevice a) => O.OverloadedMethod EventSetDeviceMethodInfo Event signature where
overloadedMethod = eventSetDevice
instance O.OverloadedMethodInfo EventSetDeviceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetDevice",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetDevice"
})
#endif
foreign import ccall "clutter_event_set_flags" clutter_event_set_flags ::
Ptr Event ->
CUInt ->
IO ()
eventSetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> [Clutter.Flags.EventFlags]
-> m ()
eventSetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> [EventFlags] -> m ()
eventSetFlags Event
event [EventFlags]
flags = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let flags' :: CUInt
flags' = [EventFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [EventFlags]
flags
Ptr Event -> CUInt -> IO ()
clutter_event_set_flags Ptr Event
event' CUInt
flags'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetFlagsMethodInfo
instance (signature ~ ([Clutter.Flags.EventFlags] -> m ()), MonadIO m) => O.OverloadedMethod EventSetFlagsMethodInfo Event signature where
overloadedMethod = eventSetFlags
instance O.OverloadedMethodInfo EventSetFlagsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetFlags"
})
#endif
foreign import ccall "clutter_event_set_key_code" clutter_event_set_key_code ::
Ptr Event ->
Word16 ->
IO ()
eventSetKeyCode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word16
-> m ()
eventSetKeyCode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word16 -> m ()
eventSetKeyCode Event
event Word16
keyCode = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Word16 -> IO ()
clutter_event_set_key_code Ptr Event
event' Word16
keyCode
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetKeyCodeMethodInfo
instance (signature ~ (Word16 -> m ()), MonadIO m) => O.OverloadedMethod EventSetKeyCodeMethodInfo Event signature where
overloadedMethod = eventSetKeyCode
instance O.OverloadedMethodInfo EventSetKeyCodeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetKeyCode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetKeyCode"
})
#endif
foreign import ccall "clutter_event_set_key_symbol" clutter_event_set_key_symbol ::
Ptr Event ->
Word32 ->
IO ()
eventSetKeySymbol ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word32
-> m ()
eventSetKeySymbol :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word32 -> m ()
eventSetKeySymbol Event
event Word32
keySym = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Word32 -> IO ()
clutter_event_set_key_symbol Ptr Event
event' Word32
keySym
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetKeySymbolMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod EventSetKeySymbolMethodInfo Event signature where
overloadedMethod = eventSetKeySymbol
instance O.OverloadedMethodInfo EventSetKeySymbolMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetKeySymbol",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetKeySymbol"
})
#endif
foreign import ccall "clutter_event_set_key_unicode" clutter_event_set_key_unicode ::
Ptr Event ->
CInt ->
IO ()
eventSetKeyUnicode ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Char
-> m ()
eventSetKeyUnicode :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Char -> m ()
eventSetKeyUnicode Event
event Char
keyUnicode = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let keyUnicode' :: CInt
keyUnicode' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord) Char
keyUnicode
Ptr Event -> CInt -> IO ()
clutter_event_set_key_unicode Ptr Event
event' CInt
keyUnicode'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetKeyUnicodeMethodInfo
instance (signature ~ (Char -> m ()), MonadIO m) => O.OverloadedMethod EventSetKeyUnicodeMethodInfo Event signature where
overloadedMethod = eventSetKeyUnicode
instance O.OverloadedMethodInfo EventSetKeyUnicodeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetKeyUnicode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetKeyUnicode"
})
#endif
foreign import ccall "clutter_event_set_related" clutter_event_set_related ::
Ptr Event ->
Ptr Clutter.Actor.Actor ->
IO ()
eventSetRelated ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.Actor.IsActor a) =>
Event
-> Maybe (a)
-> m ()
eventSetRelated :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
Event -> Maybe a -> m ()
eventSetRelated Event
event Maybe a
actor = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Actor
maybeActor <- case Maybe a
actor of
Maybe a
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
Just a
jActor -> do
Ptr Actor
jActor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jActor
Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jActor'
Ptr Event -> Ptr Actor -> IO ()
clutter_event_set_related Ptr Event
event' Ptr Actor
maybeActor
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
actor a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetRelatedMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Clutter.Actor.IsActor a) => O.OverloadedMethod EventSetRelatedMethodInfo Event signature where
overloadedMethod = eventSetRelated
instance O.OverloadedMethodInfo EventSetRelatedMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetRelated",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetRelated"
})
#endif
foreign import ccall "clutter_event_set_scroll_delta" clutter_event_set_scroll_delta ::
Ptr Event ->
CDouble ->
CDouble ->
IO ()
eventSetScrollDelta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Double
-> Double
-> m ()
eventSetScrollDelta :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Double -> Double -> m ()
eventSetScrollDelta Event
event Double
dx Double
dy = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let dx' :: CDouble
dx' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
dx
let dy' :: CDouble
dy' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
dy
Ptr Event -> CDouble -> CDouble -> IO ()
clutter_event_set_scroll_delta Ptr Event
event' CDouble
dx' CDouble
dy'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetScrollDeltaMethodInfo
instance (signature ~ (Double -> Double -> m ()), MonadIO m) => O.OverloadedMethod EventSetScrollDeltaMethodInfo Event signature where
overloadedMethod = eventSetScrollDelta
instance O.OverloadedMethodInfo EventSetScrollDeltaMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetScrollDelta",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetScrollDelta"
})
#endif
foreign import ccall "clutter_event_set_scroll_direction" clutter_event_set_scroll_direction ::
Ptr Event ->
CUInt ->
IO ()
eventSetScrollDirection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Clutter.Enums.ScrollDirection
-> m ()
eventSetScrollDirection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> ScrollDirection -> m ()
eventSetScrollDirection Event
event ScrollDirection
direction = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let direction' :: CUInt
direction' = (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
direction
Ptr Event -> CUInt -> IO ()
clutter_event_set_scroll_direction Ptr Event
event' CUInt
direction'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetScrollDirectionMethodInfo
instance (signature ~ (Clutter.Enums.ScrollDirection -> m ()), MonadIO m) => O.OverloadedMethod EventSetScrollDirectionMethodInfo Event signature where
overloadedMethod = eventSetScrollDirection
instance O.OverloadedMethodInfo EventSetScrollDirectionMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetScrollDirection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetScrollDirection"
})
#endif
foreign import ccall "clutter_event_set_source" clutter_event_set_source ::
Ptr Event ->
Ptr Clutter.Actor.Actor ->
IO ()
eventSetSource ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.Actor.IsActor a) =>
Event
-> Maybe (a)
-> m ()
eventSetSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActor a) =>
Event -> Maybe a -> m ()
eventSetSource Event
event Maybe a
actor = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Actor
maybeActor <- case Maybe a
actor of
Maybe a
Nothing -> Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
forall a. Ptr a
nullPtr
Just a
jActor -> do
Ptr Actor
jActor' <- a -> IO (Ptr Actor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jActor
Ptr Actor -> IO (Ptr Actor)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Actor
jActor'
Ptr Event -> Ptr Actor -> IO ()
clutter_event_set_source Ptr Event
event' Ptr Actor
maybeActor
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
actor a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetSourceMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Clutter.Actor.IsActor a) => O.OverloadedMethod EventSetSourceMethodInfo Event signature where
overloadedMethod = eventSetSource
instance O.OverloadedMethodInfo EventSetSourceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetSource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetSource"
})
#endif
foreign import ccall "clutter_event_set_source_device" clutter_event_set_source_device ::
Ptr Event ->
Ptr Clutter.InputDevice.InputDevice ->
IO ()
eventSetSourceDevice ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.InputDevice.IsInputDevice a) =>
Event
-> Maybe (a)
-> m ()
eventSetSourceDevice :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputDevice a) =>
Event -> Maybe a -> m ()
eventSetSourceDevice Event
event Maybe a
device = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr InputDevice
maybeDevice <- case Maybe a
device of
Maybe a
Nothing -> Ptr InputDevice -> IO (Ptr InputDevice)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputDevice
forall a. Ptr a
nullPtr
Just a
jDevice -> do
Ptr InputDevice
jDevice' <- a -> IO (Ptr InputDevice)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jDevice
Ptr InputDevice -> IO (Ptr InputDevice)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputDevice
jDevice'
Ptr Event -> Ptr InputDevice -> IO ()
clutter_event_set_source_device Ptr Event
event' Ptr InputDevice
maybeDevice
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
device a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetSourceDeviceMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Clutter.InputDevice.IsInputDevice a) => O.OverloadedMethod EventSetSourceDeviceMethodInfo Event signature where
overloadedMethod = eventSetSourceDevice
instance O.OverloadedMethodInfo EventSetSourceDeviceMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetSourceDevice",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetSourceDevice"
})
#endif
foreign import ccall "clutter_event_set_stage" clutter_event_set_stage ::
Ptr Event ->
Ptr Clutter.Stage.Stage ->
IO ()
eventSetStage ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.Stage.IsStage a) =>
Event
-> Maybe (a)
-> m ()
eventSetStage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
Event -> Maybe a -> m ()
eventSetStage Event
event Maybe a
stage = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Stage
maybeStage <- case Maybe a
stage of
Maybe a
Nothing -> Ptr Stage -> IO (Ptr Stage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Stage
forall a. Ptr a
nullPtr
Just a
jStage -> do
Ptr Stage
jStage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jStage
Ptr Stage -> IO (Ptr Stage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Stage
jStage'
Ptr Event -> Ptr Stage -> IO ()
clutter_event_set_stage Ptr Event
event' Ptr Stage
maybeStage
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
stage a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetStageMethodInfo
instance (signature ~ (Maybe (a) -> m ()), MonadIO m, Clutter.Stage.IsStage a) => O.OverloadedMethod EventSetStageMethodInfo Event signature where
overloadedMethod = eventSetStage
instance O.OverloadedMethodInfo EventSetStageMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetStage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetStage"
})
#endif
foreign import ccall "clutter_event_set_state" clutter_event_set_state ::
Ptr Event ->
CUInt ->
IO ()
eventSetState ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> [Clutter.Flags.ModifierType]
-> m ()
eventSetState :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> [ModifierType] -> m ()
eventSetState Event
event [ModifierType]
state = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let state' :: CUInt
state' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
state
Ptr Event -> CUInt -> IO ()
clutter_event_set_state Ptr Event
event' CUInt
state'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetStateMethodInfo
instance (signature ~ ([Clutter.Flags.ModifierType] -> m ()), MonadIO m) => O.OverloadedMethod EventSetStateMethodInfo Event signature where
overloadedMethod = eventSetState
instance O.OverloadedMethodInfo EventSetStateMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetState"
})
#endif
foreign import ccall "clutter_event_set_time" clutter_event_set_time ::
Ptr Event ->
Word32 ->
IO ()
eventSetTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word32
-> m ()
eventSetTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word32 -> m ()
eventSetTime Event
event Word32
time_ = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Word32 -> IO ()
clutter_event_set_time Ptr Event
event' Word32
time_
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetTimeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod EventSetTimeMethodInfo Event signature where
overloadedMethod = eventSetTime
instance O.OverloadedMethodInfo EventSetTimeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventSetTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventSetTime"
})
#endif
foreign import ccall "clutter_event_type" clutter_event_type ::
Ptr Event ->
IO CUInt
eventType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Clutter.Enums.EventType
eventType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m EventType
eventType Event
event = 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
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- Ptr Event -> IO CUInt
clutter_event_type Ptr Event
event'
let result' :: EventType
result' = (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
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
EventType -> IO EventType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EventType
result'
#if defined(ENABLE_OVERLOADING)
data EventTypeMethodInfo
instance (signature ~ (m Clutter.Enums.EventType), MonadIO m) => O.OverloadedMethod EventTypeMethodInfo Event signature where
overloadedMethod = eventType
instance O.OverloadedMethodInfo EventTypeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Unions.Event.eventType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Unions-Event.html#v:eventType"
})
#endif
foreign import ccall "clutter_event_add_filter" clutter_event_add_filter ::
Ptr Clutter.Stage.Stage ->
FunPtr Clutter.Callbacks.C_EventFilterFunc ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
Ptr () ->
IO Word32
eventAddFilter ::
(B.CallStack.HasCallStack, MonadIO m, Clutter.Stage.IsStage a) =>
Maybe (a)
-> Clutter.Callbacks.EventFilterFunc
-> m Word32
eventAddFilter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStage a) =>
Maybe a -> EventFilterFunc -> m Word32
eventAddFilter Maybe a
stage EventFilterFunc
func = 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
$ do
Ptr Stage
maybeStage <- case Maybe a
stage of
Maybe a
Nothing -> Ptr Stage -> IO (Ptr Stage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Stage
forall a. Ptr a
nullPtr
Just a
jStage -> do
Ptr Stage
jStage' <- a -> IO (Ptr Stage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jStage
Ptr Stage -> IO (Ptr Stage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Stage
jStage'
FunPtr C_EventFilterFunc
func' <- C_EventFilterFunc -> IO (FunPtr C_EventFilterFunc)
Clutter.Callbacks.mk_EventFilterFunc (Maybe (Ptr (FunPtr C_EventFilterFunc))
-> EventFilterFunc_WithClosures -> C_EventFilterFunc
Clutter.Callbacks.wrap_EventFilterFunc Maybe (Ptr (FunPtr C_EventFilterFunc))
forall a. Maybe a
Nothing (EventFilterFunc -> EventFilterFunc_WithClosures
Clutter.Callbacks.drop_closures_EventFilterFunc EventFilterFunc
func))
let userData :: Ptr ()
userData = FunPtr C_EventFilterFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_EventFilterFunc
func'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Word32
result <- Ptr Stage
-> FunPtr C_EventFilterFunc
-> FunPtr C_DestroyNotify
-> Ptr ()
-> IO Word32
clutter_event_add_filter Ptr Stage
maybeStage FunPtr C_EventFilterFunc
func' FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify Ptr ()
userData
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
stage a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_event_get" clutter_event_get ::
IO (Ptr Event)
eventGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Event
eventGet :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Event
eventGet = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- IO (Ptr Event)
clutter_event_get
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventGet" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_event_peek" clutter_event_peek ::
IO (Ptr Event)
eventPeek ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Event
eventPeek :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Event
eventPeek = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- IO (Ptr Event)
clutter_event_peek
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventPeek" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "clutter_event_remove_filter" clutter_event_remove_filter ::
Word32 ->
IO ()
eventRemoveFilter ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m ()
eventRemoveFilter :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Word32 -> m ()
eventRemoveFilter Word32
id = 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
$ do
Word32 -> IO ()
clutter_event_remove_filter Word32
id
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveEventMethod (t :: Symbol) (o :: *) :: * where
ResolveEventMethod "copy" o = EventCopyMethodInfo
ResolveEventMethod "free" o = EventFreeMethodInfo
ResolveEventMethod "hasControlModifier" o = EventHasControlModifierMethodInfo
ResolveEventMethod "hasShiftModifier" o = EventHasShiftModifierMethodInfo
ResolveEventMethod "isPointerEmulated" o = EventIsPointerEmulatedMethodInfo
ResolveEventMethod "put" o = EventPutMethodInfo
ResolveEventMethod "type" o = EventTypeMethodInfo
ResolveEventMethod "getAngle" o = EventGetAngleMethodInfo
ResolveEventMethod "getAxes" o = EventGetAxesMethodInfo
ResolveEventMethod "getButton" o = EventGetButtonMethodInfo
ResolveEventMethod "getClickCount" o = EventGetClickCountMethodInfo
ResolveEventMethod "getCoords" o = EventGetCoordsMethodInfo
ResolveEventMethod "getDevice" o = EventGetDeviceMethodInfo
ResolveEventMethod "getDeviceId" o = EventGetDeviceIdMethodInfo
ResolveEventMethod "getDeviceType" o = EventGetDeviceTypeMethodInfo
ResolveEventMethod "getDistance" o = EventGetDistanceMethodInfo
ResolveEventMethod "getEventSequence" o = EventGetEventSequenceMethodInfo
ResolveEventMethod "getFlags" o = EventGetFlagsMethodInfo
ResolveEventMethod "getGestureMotionDelta" o = EventGetGestureMotionDeltaMethodInfo
ResolveEventMethod "getGesturePhase" o = EventGetGesturePhaseMethodInfo
ResolveEventMethod "getGesturePinchAngleDelta" o = EventGetGesturePinchAngleDeltaMethodInfo
ResolveEventMethod "getGesturePinchScale" o = EventGetGesturePinchScaleMethodInfo
ResolveEventMethod "getGestureSwipeFingerCount" o = EventGetGestureSwipeFingerCountMethodInfo
ResolveEventMethod "getKeyCode" o = EventGetKeyCodeMethodInfo
ResolveEventMethod "getKeySymbol" o = EventGetKeySymbolMethodInfo
ResolveEventMethod "getKeyUnicode" o = EventGetKeyUnicodeMethodInfo
ResolveEventMethod "getPosition" o = EventGetPositionMethodInfo
ResolveEventMethod "getRelated" o = EventGetRelatedMethodInfo
ResolveEventMethod "getScrollDelta" o = EventGetScrollDeltaMethodInfo
ResolveEventMethod "getScrollDirection" o = EventGetScrollDirectionMethodInfo
ResolveEventMethod "getSource" o = EventGetSourceMethodInfo
ResolveEventMethod "getSourceDevice" o = EventGetSourceDeviceMethodInfo
ResolveEventMethod "getStage" o = EventGetStageMethodInfo
ResolveEventMethod "getState" o = EventGetStateMethodInfo
ResolveEventMethod "getStateFull" o = EventGetStateFullMethodInfo
ResolveEventMethod "getTime" o = EventGetTimeMethodInfo
ResolveEventMethod "setButton" o = EventSetButtonMethodInfo
ResolveEventMethod "setCoords" o = EventSetCoordsMethodInfo
ResolveEventMethod "setDevice" o = EventSetDeviceMethodInfo
ResolveEventMethod "setFlags" o = EventSetFlagsMethodInfo
ResolveEventMethod "setKeyCode" o = EventSetKeyCodeMethodInfo
ResolveEventMethod "setKeySymbol" o = EventSetKeySymbolMethodInfo
ResolveEventMethod "setKeyUnicode" o = EventSetKeyUnicodeMethodInfo
ResolveEventMethod "setRelated" o = EventSetRelatedMethodInfo
ResolveEventMethod "setScrollDelta" o = EventSetScrollDeltaMethodInfo
ResolveEventMethod "setScrollDirection" o = EventSetScrollDirectionMethodInfo
ResolveEventMethod "setSource" o = EventSetSourceMethodInfo
ResolveEventMethod "setSourceDevice" o = EventSetSourceDeviceMethodInfo
ResolveEventMethod "setStage" o = EventSetStageMethodInfo
ResolveEventMethod "setState" o = EventSetStateMethodInfo
ResolveEventMethod "setTime" o = EventSetTimeMethodInfo
ResolveEventMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEventMethod t Event, O.OverloadedMethod info Event p) => OL.IsLabel t (Event -> 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 ~ ResolveEventMethod t Event, O.OverloadedMethod info Event p, R.HasField t Event p) => R.HasField t Event p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEventMethod t Event, O.OverloadedMethodInfo info Event) => OL.IsLabel t (O.MethodProxy info Event) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif