{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Generic event wrapper.
-- 
-- /Since: 0.2/

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

module GI.Clutter.Unions.Event
    ( 

-- * Exported types
    Event(..)                               ,
    newZeroEvent                            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Clutter.Unions.Event#g:method:copy"), [free]("GI.Clutter.Unions.Event#g:method:free"), [hasControlModifier]("GI.Clutter.Unions.Event#g:method:hasControlModifier"), [hasShiftModifier]("GI.Clutter.Unions.Event#g:method:hasShiftModifier"), [isPointerEmulated]("GI.Clutter.Unions.Event#g:method:isPointerEmulated"), [put]("GI.Clutter.Unions.Event#g:method:put"), [type]("GI.Clutter.Unions.Event#g:method:type").
-- 
-- ==== Getters
-- [getAngle]("GI.Clutter.Unions.Event#g:method:getAngle"), [getAxes]("GI.Clutter.Unions.Event#g:method:getAxes"), [getButton]("GI.Clutter.Unions.Event#g:method:getButton"), [getClickCount]("GI.Clutter.Unions.Event#g:method:getClickCount"), [getCoords]("GI.Clutter.Unions.Event#g:method:getCoords"), [getDevice]("GI.Clutter.Unions.Event#g:method:getDevice"), [getDeviceId]("GI.Clutter.Unions.Event#g:method:getDeviceId"), [getDeviceType]("GI.Clutter.Unions.Event#g:method:getDeviceType"), [getDistance]("GI.Clutter.Unions.Event#g:method:getDistance"), [getEventSequence]("GI.Clutter.Unions.Event#g:method:getEventSequence"), [getFlags]("GI.Clutter.Unions.Event#g:method:getFlags"), [getGestureMotionDelta]("GI.Clutter.Unions.Event#g:method:getGestureMotionDelta"), [getGesturePhase]("GI.Clutter.Unions.Event#g:method:getGesturePhase"), [getGesturePinchAngleDelta]("GI.Clutter.Unions.Event#g:method:getGesturePinchAngleDelta"), [getGesturePinchScale]("GI.Clutter.Unions.Event#g:method:getGesturePinchScale"), [getGestureSwipeFingerCount]("GI.Clutter.Unions.Event#g:method:getGestureSwipeFingerCount"), [getKeyCode]("GI.Clutter.Unions.Event#g:method:getKeyCode"), [getKeySymbol]("GI.Clutter.Unions.Event#g:method:getKeySymbol"), [getKeyUnicode]("GI.Clutter.Unions.Event#g:method:getKeyUnicode"), [getPosition]("GI.Clutter.Unions.Event#g:method:getPosition"), [getRelated]("GI.Clutter.Unions.Event#g:method:getRelated"), [getScrollDelta]("GI.Clutter.Unions.Event#g:method:getScrollDelta"), [getScrollDirection]("GI.Clutter.Unions.Event#g:method:getScrollDirection"), [getSource]("GI.Clutter.Unions.Event#g:method:getSource"), [getSourceDevice]("GI.Clutter.Unions.Event#g:method:getSourceDevice"), [getStage]("GI.Clutter.Unions.Event#g:method:getStage"), [getState]("GI.Clutter.Unions.Event#g:method:getState"), [getStateFull]("GI.Clutter.Unions.Event#g:method:getStateFull"), [getTime]("GI.Clutter.Unions.Event#g:method:getTime").
-- 
-- ==== Setters
-- [setButton]("GI.Clutter.Unions.Event#g:method:setButton"), [setCoords]("GI.Clutter.Unions.Event#g:method:setCoords"), [setDevice]("GI.Clutter.Unions.Event#g:method:setDevice"), [setFlags]("GI.Clutter.Unions.Event#g:method:setFlags"), [setKeyCode]("GI.Clutter.Unions.Event#g:method:setKeyCode"), [setKeySymbol]("GI.Clutter.Unions.Event#g:method:setKeySymbol"), [setKeyUnicode]("GI.Clutter.Unions.Event#g:method:setKeyUnicode"), [setRelated]("GI.Clutter.Unions.Event#g:method:setRelated"), [setScrollDelta]("GI.Clutter.Unions.Event#g:method:setScrollDelta"), [setScrollDirection]("GI.Clutter.Unions.Event#g:method:setScrollDirection"), [setSource]("GI.Clutter.Unions.Event#g:method:setSource"), [setSourceDevice]("GI.Clutter.Unions.Event#g:method:setSourceDevice"), [setStage]("GI.Clutter.Unions.Event#g:method:setStage"), [setState]("GI.Clutter.Unions.Event#g:method:setState"), [setTime]("GI.Clutter.Unions.Event#g:method:setTime").

#if defined(ENABLE_OVERLOADING)
    ResolveEventMethod                      ,
#endif

-- ** addFilter #method:addFilter#

    eventAddFilter                          ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    EventCopyMethodInfo                     ,
#endif
    eventCopy                               ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    EventFreeMethodInfo                     ,
#endif
    eventFree                               ,


-- ** get #method:get#

    eventGet                                ,


-- ** getAngle #method:getAngle#

#if defined(ENABLE_OVERLOADING)
    EventGetAngleMethodInfo                 ,
#endif
    eventGetAngle                           ,


-- ** getAxes #method:getAxes#

#if defined(ENABLE_OVERLOADING)
    EventGetAxesMethodInfo                  ,
#endif
    eventGetAxes                            ,


-- ** getButton #method:getButton#

#if defined(ENABLE_OVERLOADING)
    EventGetButtonMethodInfo                ,
#endif
    eventGetButton                          ,


-- ** getClickCount #method:getClickCount#

#if defined(ENABLE_OVERLOADING)
    EventGetClickCountMethodInfo            ,
#endif
    eventGetClickCount                      ,


-- ** getCoords #method:getCoords#

#if defined(ENABLE_OVERLOADING)
    EventGetCoordsMethodInfo                ,
#endif
    eventGetCoords                          ,


-- ** getDevice #method:getDevice#

#if defined(ENABLE_OVERLOADING)
    EventGetDeviceMethodInfo                ,
#endif
    eventGetDevice                          ,


-- ** getDeviceId #method:getDeviceId#

#if defined(ENABLE_OVERLOADING)
    EventGetDeviceIdMethodInfo              ,
#endif
    eventGetDeviceId                        ,


-- ** getDeviceType #method:getDeviceType#

#if defined(ENABLE_OVERLOADING)
    EventGetDeviceTypeMethodInfo            ,
#endif
    eventGetDeviceType                      ,


-- ** getDistance #method:getDistance#

#if defined(ENABLE_OVERLOADING)
    EventGetDistanceMethodInfo              ,
#endif
    eventGetDistance                        ,


-- ** getEventSequence #method:getEventSequence#

#if defined(ENABLE_OVERLOADING)
    EventGetEventSequenceMethodInfo         ,
#endif
    eventGetEventSequence                   ,


-- ** getFlags #method:getFlags#

#if defined(ENABLE_OVERLOADING)
    EventGetFlagsMethodInfo                 ,
#endif
    eventGetFlags                           ,


-- ** getGestureMotionDelta #method:getGestureMotionDelta#

#if defined(ENABLE_OVERLOADING)
    EventGetGestureMotionDeltaMethodInfo    ,
#endif
    eventGetGestureMotionDelta              ,


-- ** getGesturePhase #method:getGesturePhase#

#if defined(ENABLE_OVERLOADING)
    EventGetGesturePhaseMethodInfo          ,
#endif
    eventGetGesturePhase                    ,


-- ** getGesturePinchAngleDelta #method:getGesturePinchAngleDelta#

#if defined(ENABLE_OVERLOADING)
    EventGetGesturePinchAngleDeltaMethodInfo,
#endif
    eventGetGesturePinchAngleDelta          ,


-- ** getGesturePinchScale #method:getGesturePinchScale#

#if defined(ENABLE_OVERLOADING)
    EventGetGesturePinchScaleMethodInfo     ,
#endif
    eventGetGesturePinchScale               ,


-- ** getGestureSwipeFingerCount #method:getGestureSwipeFingerCount#

#if defined(ENABLE_OVERLOADING)
    EventGetGestureSwipeFingerCountMethodInfo,
#endif
    eventGetGestureSwipeFingerCount         ,


-- ** getKeyCode #method:getKeyCode#

#if defined(ENABLE_OVERLOADING)
    EventGetKeyCodeMethodInfo               ,
#endif
    eventGetKeyCode                         ,


-- ** getKeySymbol #method:getKeySymbol#

#if defined(ENABLE_OVERLOADING)
    EventGetKeySymbolMethodInfo             ,
#endif
    eventGetKeySymbol                       ,


-- ** getKeyUnicode #method:getKeyUnicode#

#if defined(ENABLE_OVERLOADING)
    EventGetKeyUnicodeMethodInfo            ,
#endif
    eventGetKeyUnicode                      ,


-- ** getPosition #method:getPosition#

#if defined(ENABLE_OVERLOADING)
    EventGetPositionMethodInfo              ,
#endif
    eventGetPosition                        ,


-- ** getRelated #method:getRelated#

#if defined(ENABLE_OVERLOADING)
    EventGetRelatedMethodInfo               ,
#endif
    eventGetRelated                         ,


-- ** getScrollDelta #method:getScrollDelta#

#if defined(ENABLE_OVERLOADING)
    EventGetScrollDeltaMethodInfo           ,
#endif
    eventGetScrollDelta                     ,


-- ** getScrollDirection #method:getScrollDirection#

#if defined(ENABLE_OVERLOADING)
    EventGetScrollDirectionMethodInfo       ,
#endif
    eventGetScrollDirection                 ,


-- ** getSource #method:getSource#

#if defined(ENABLE_OVERLOADING)
    EventGetSourceMethodInfo                ,
#endif
    eventGetSource                          ,


-- ** getSourceDevice #method:getSourceDevice#

#if defined(ENABLE_OVERLOADING)
    EventGetSourceDeviceMethodInfo          ,
#endif
    eventGetSourceDevice                    ,


-- ** getStage #method:getStage#

#if defined(ENABLE_OVERLOADING)
    EventGetStageMethodInfo                 ,
#endif
    eventGetStage                           ,


-- ** getState #method:getState#

#if defined(ENABLE_OVERLOADING)
    EventGetStateMethodInfo                 ,
#endif
    eventGetState                           ,


-- ** getStateFull #method:getStateFull#

#if defined(ENABLE_OVERLOADING)
    EventGetStateFullMethodInfo             ,
#endif
    eventGetStateFull                       ,


-- ** getTime #method:getTime#

#if defined(ENABLE_OVERLOADING)
    EventGetTimeMethodInfo                  ,
#endif
    eventGetTime                            ,


-- ** hasControlModifier #method:hasControlModifier#

#if defined(ENABLE_OVERLOADING)
    EventHasControlModifierMethodInfo       ,
#endif
    eventHasControlModifier                 ,


-- ** hasShiftModifier #method:hasShiftModifier#

#if defined(ENABLE_OVERLOADING)
    EventHasShiftModifierMethodInfo         ,
#endif
    eventHasShiftModifier                   ,


-- ** isPointerEmulated #method:isPointerEmulated#

#if defined(ENABLE_OVERLOADING)
    EventIsPointerEmulatedMethodInfo        ,
#endif
    eventIsPointerEmulated                  ,


-- ** new #method:new#

    eventNew                                ,


-- ** peek #method:peek#

    eventPeek                               ,


-- ** put #method:put#

#if defined(ENABLE_OVERLOADING)
    EventPutMethodInfo                      ,
#endif
    eventPut                                ,


-- ** removeFilter #method:removeFilter#

    eventRemoveFilter                       ,


-- ** setButton #method:setButton#

#if defined(ENABLE_OVERLOADING)
    EventSetButtonMethodInfo                ,
#endif
    eventSetButton                          ,


-- ** setCoords #method:setCoords#

#if defined(ENABLE_OVERLOADING)
    EventSetCoordsMethodInfo                ,
#endif
    eventSetCoords                          ,


-- ** setDevice #method:setDevice#

#if defined(ENABLE_OVERLOADING)
    EventSetDeviceMethodInfo                ,
#endif
    eventSetDevice                          ,


-- ** setFlags #method:setFlags#

#if defined(ENABLE_OVERLOADING)
    EventSetFlagsMethodInfo                 ,
#endif
    eventSetFlags                           ,


-- ** setKeyCode #method:setKeyCode#

#if defined(ENABLE_OVERLOADING)
    EventSetKeyCodeMethodInfo               ,
#endif
    eventSetKeyCode                         ,


-- ** setKeySymbol #method:setKeySymbol#

#if defined(ENABLE_OVERLOADING)
    EventSetKeySymbolMethodInfo             ,
#endif
    eventSetKeySymbol                       ,


-- ** setKeyUnicode #method:setKeyUnicode#

#if defined(ENABLE_OVERLOADING)
    EventSetKeyUnicodeMethodInfo            ,
#endif
    eventSetKeyUnicode                      ,


-- ** setRelated #method:setRelated#

#if defined(ENABLE_OVERLOADING)
    EventSetRelatedMethodInfo               ,
#endif
    eventSetRelated                         ,


-- ** setScrollDelta #method:setScrollDelta#

#if defined(ENABLE_OVERLOADING)
    EventSetScrollDeltaMethodInfo           ,
#endif
    eventSetScrollDelta                     ,


-- ** setScrollDirection #method:setScrollDirection#

#if defined(ENABLE_OVERLOADING)
    EventSetScrollDirectionMethodInfo       ,
#endif
    eventSetScrollDirection                 ,


-- ** setSource #method:setSource#

#if defined(ENABLE_OVERLOADING)
    EventSetSourceMethodInfo                ,
#endif
    eventSetSource                          ,


-- ** setSourceDevice #method:setSourceDevice#

#if defined(ENABLE_OVERLOADING)
    EventSetSourceDeviceMethodInfo          ,
#endif
    eventSetSourceDevice                    ,


-- ** setStage #method:setStage#

#if defined(ENABLE_OVERLOADING)
    EventSetStageMethodInfo                 ,
#endif
    eventSetStage                           ,


-- ** setState #method:setState#

#if defined(ENABLE_OVERLOADING)
    EventSetStateMethodInfo                 ,
#endif
    eventSetState                           ,


-- ** setTime #method:setTime#

#if defined(ENABLE_OVERLOADING)
    EventSetTimeMethodInfo                  ,
#endif
    eventSetTime                            ,


-- ** type #method:type#

#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.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import 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

-- | Memory-managed wrapper type.
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

-- | Convert 'Event' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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
        
    

-- | Construct a `Event` struct initialized to zero.
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, DK.Type)])
#endif

-- method Event::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "type"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "EventType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The type of event." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Event" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_new" clutter_event_new :: 
    CUInt ->                                -- type : TInterface (Name {namespace = "Clutter", name = "EventType"})
    IO (Ptr Event)

-- | Creates a new t'GI.Clutter.Unions.Event.Event' of the specified type.
eventNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Clutter.Enums.EventType
    -- ^ /@type@/: The type of event.
    -> m Event
    -- ^ __Returns:__ A newly allocated t'GI.Clutter.Unions.Event.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

-- method Event::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterEvent." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Event" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_copy" clutter_event_copy :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO (Ptr Event)

-- | Copies /@event@/.
eventCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: A t'GI.Clutter.Unions.Event.Event'.
    -> m Event
    -- ^ __Returns:__ A newly allocated t'GI.Clutter.Unions.Event.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.5/docs/GI-Clutter-Unions-Event.html#v:eventCopy"
        })


#endif

-- method Event::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterEvent." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_free" clutter_event_free :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO ()

-- | Frees all resources used by /@event@/.
eventFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: A t'GI.Clutter.Unions.Event.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.5/docs/GI-Clutter-Unions-Event.html#v:eventFree"
        })


#endif

-- method Event::get_angle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_angle" clutter_event_get_angle :: 
    Ptr Event ->                            -- source : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Event ->                            -- target : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CDouble

-- | Retrieves the angle relative from /@source@/ to /@target@/.
-- 
-- The direction of the angle is from the position X axis towards
-- the positive Y axis.
-- 
-- /Since: 1.12/
eventGetAngle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@source@/: a t'GI.Clutter.Unions.Event.Event'
    -> Event
    -- ^ /@target@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Double
    -- ^ __Returns:__ the angle between two t'GI.Clutter.Unions.Event.Event'
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetAngle"
        })


#endif

-- method Event::get_axes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_axes"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the number of axes returned"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_axes" clutter_event_get_axes :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Word32 ->                           -- n_axes : TBasicType TUInt
    IO CDouble

-- | Retrieves the array of axes values attached to the event.
-- 
-- /Since: 1.6/
eventGetAxes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m ((Double, Word32))
    -- ^ __Returns:__ an array of axis values
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetAxes"
        })


#endif

-- method Event::get_button
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_BUTTON_PRESS or\n  of type %CLUTTER_BUTTON_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_button" clutter_event_get_button :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO Word32

-- | Retrieves the button number of /@event@/
-- 
-- /Since: 1.0/
eventGetButton ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeButtonPress' or
    --   of type 'GI.Clutter.Enums.EventTypeButtonRelease'
    -> m Word32
    -- ^ __Returns:__ the button number
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetButton"
        })


#endif

-- method Event::get_click_count
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_BUTTON_PRESS or\n  of type %CLUTTER_BUTTON_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_click_count" clutter_event_get_click_count :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO Word32

-- | Retrieves the number of clicks of /@event@/
-- 
-- /Since: 1.0/
eventGetClickCount ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeButtonPress' or
    --   of type 'GI.Clutter.Enums.EventTypeButtonRelease'
    -> m Word32
    -- ^ __Returns:__ the click count
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetClickCount"
        })


#endif

-- method Event::get_coords
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the X coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the Y coordinate, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_coords" clutter_event_get_coords :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr CFloat ->                           -- x : TBasicType TFloat
    Ptr CFloat ->                           -- y : TBasicType TFloat
    IO ()

-- | Retrieves the coordinates of /@event@/ and puts them into /@x@/ and /@y@/.
-- 
-- /Since: 0.4/
eventGetCoords ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetCoords"
        })


#endif

-- method Event::get_device
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "InputDevice" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_device" clutter_event_get_device :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO (Ptr Clutter.InputDevice.InputDevice)

-- | Retrieves the t'GI.Clutter.Objects.InputDevice.InputDevice' for the event.
-- If you want the physical device the event originated from, use
-- 'GI.Clutter.Unions.Event.eventGetSourceDevice'.
-- 
-- The t'GI.Clutter.Objects.InputDevice.InputDevice' structure is completely opaque and should
-- be cast to the platform-specific implementation.
-- 
-- /Since: 1.0/
eventGetDevice ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Clutter.InputDevice.InputDevice
    -- ^ __Returns:__ the t'GI.Clutter.Objects.InputDevice.InputDevice' or 'P.Nothing'. The
    --   returned device is owned by the t'GI.Clutter.Unions.Event.Event' and it should not
    --   be unreferenced
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetDevice"
        })


#endif

-- method Event::get_device_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clutter event" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_device_id" clutter_event_get_device_id :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO Int32

-- | Retrieves the events device id if set.
eventGetDeviceId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a clutter event
    -> m Int32
    -- ^ __Returns:__ A unique identifier for the device or -1 if the event has
    --   no specific device set.
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetDeviceId"
        })


#endif

-- method Event::get_device_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "InputDeviceType" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_device_type" clutter_event_get_device_type :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CUInt

-- | Retrieves the type of the device for /@event@/
-- 
-- /Since: 1.0/
eventGetDeviceType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Clutter.Enums.InputDeviceType
    -- ^ __Returns:__ the t'GI.Clutter.Enums.InputDeviceType' for the device, if
    --   any is set
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetDeviceType"
        })


#endif

-- method Event::get_distance
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_distance" clutter_event_get_distance :: 
    Ptr Event ->                            -- source : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Event ->                            -- target : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CFloat

-- | Retrieves the distance between two events, a /@source@/ and a /@target@/.
-- 
-- /Since: 1.12/
eventGetDistance ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@source@/: a t'GI.Clutter.Unions.Event.Event'
    -> Event
    -- ^ /@target@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Float
    -- ^ __Returns:__ the distance between two t'GI.Clutter.Unions.Event.Event'
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetDistance"
        })


#endif

-- method Event::get_event_sequence
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_TOUCH_BEGIN,\n  %CLUTTER_TOUCH_UPDATE, %CLUTTER_TOUCH_END, or\n  %CLUTTER_TOUCH_CANCEL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "EventSequence" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_event_sequence" clutter_event_get_event_sequence :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO (Ptr Clutter.EventSequence.EventSequence)

-- | Retrieves the t'GI.Clutter.Structs.EventSequence.EventSequence' of /@event@/.
-- 
-- /Since: 1.10/
eventGetEventSequence ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeTouchBegin',
    --   'GI.Clutter.Enums.EventTypeTouchUpdate', 'GI.Clutter.Enums.EventTypeTouchEnd', or
    --   'GI.Clutter.Enums.EventTypeTouchCancel'
    -> m Clutter.EventSequence.EventSequence
    -- ^ __Returns:__ the event sequence, or 'P.Nothing'
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetEventSequence"
        })


#endif

-- method Event::get_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "EventFlags" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_flags" clutter_event_get_flags :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CUInt

-- | Retrieves the t'GI.Clutter.Flags.EventFlags' of /@event@/
-- 
-- /Since: 1.0/
eventGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m [Clutter.Flags.EventFlags]
    -- ^ __Returns:__ the event flags
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetFlags"
        })


#endif

-- method Event::get_gesture_motion_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A clutter touchpad gesture event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dx"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the displacement relative to the pointer\n     position in the X axis, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "dy"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the displacement relative to the pointer\n     position in the Y axis, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_gesture_motion_delta" clutter_event_get_gesture_motion_delta :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr CDouble ->                          -- dx : TBasicType TDouble
    Ptr CDouble ->                          -- dy : TBasicType TDouble
    IO ()

-- | Returns the gesture motion deltas relative to the current pointer
-- position.
-- 
-- /Since: 1.24/
eventGetGestureMotionDelta ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: A clutter touchpad gesture 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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetGestureMotionDelta"
        })


#endif

-- method Event::get_gesture_phase
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a touchpad gesture event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "TouchpadGesturePhase" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_gesture_phase" clutter_event_get_gesture_phase :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CUInt

-- | Returns the phase of the event, See t'GI.Clutter.Enums.TouchpadGesturePhase'.
eventGetGesturePhase ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a touchpad gesture event
    -> m Clutter.Enums.TouchpadGesturePhase
    -- ^ __Returns:__ the phase of the gesture event.
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetGesturePhase"
        })


#endif

-- method Event::get_gesture_pinch_angle_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a touchpad pinch event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_gesture_pinch_angle_delta" clutter_event_get_gesture_pinch_angle_delta :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CDouble

-- | Returns the angle delta reported by this specific event.
-- 
-- /Since: 1.24/
eventGetGesturePinchAngleDelta ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a touchpad pinch event
    -> m Double
    -- ^ __Returns:__ The angle delta relative to the previous event.
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetGesturePinchAngleDelta"
        })


#endif

-- method Event::get_gesture_pinch_scale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a touchpad pinch event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_gesture_pinch_scale" clutter_event_get_gesture_pinch_scale :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CDouble

-- | Returns the current scale as reported by /@event@/, 1.0 being the original
-- distance at the time the corresponding event with phase
-- 'GI.Clutter.Enums.TouchpadGesturePhaseBegin' is received.
-- is received.
-- 
-- /Since: 1.24/
eventGetGesturePinchScale ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a touchpad pinch event
    -> m Double
    -- ^ __Returns:__ the current pinch gesture scale
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetGesturePinchScale"
        })


#endif

-- method Event::get_gesture_swipe_finger_count
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a touchpad swipe event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_gesture_swipe_finger_count" clutter_event_get_gesture_swipe_finger_count :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO Word32

-- | Returns the number of fingers that is triggering the touchpad gesture.
-- 
-- /Since: 1.24/
eventGetGestureSwipeFingerCount ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a touchpad swipe event
    -> m Word32
    -- ^ __Returns:__ the number of fingers swiping.
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetGestureSwipeFingerCount"
        })


#endif

-- method Event::get_key_code
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_KEY_PRESS or\n   of type %CLUTTER_KEY_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt16)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_key_code" clutter_event_get_key_code :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO Word16

-- | Retrieves the keycode of the key that caused /@event@/
-- 
-- /Since: 1.0/
eventGetKeyCode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeKeyPress' or
    --    of type 'GI.Clutter.Enums.EventTypeKeyRelease'
    -> m Word16
    -- ^ __Returns:__ The keycode representing the key
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetKeyCode"
        })


#endif

-- method Event::get_key_symbol
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_KEY_PRESS or\n  of type %CLUTTER_KEY_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_key_symbol" clutter_event_get_key_symbol :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO Word32

-- | Retrieves the key symbol of /@event@/
-- 
-- /Since: 1.0/
eventGetKeySymbol ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeKeyPress' or
    --   of type 'GI.Clutter.Enums.EventTypeKeyRelease'
    -> m Word32
    -- ^ __Returns:__ the key symbol representing the key
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetKeySymbol"
        })


#endif

-- method Event::get_key_unicode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_KEY_PRESS\n  or %CLUTTER_KEY_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUniChar)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_key_unicode" clutter_event_get_key_unicode :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CInt

-- | Retrieves the unicode value for the key that caused /@keyev@/.
eventGetKeyUnicode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeKeyPress'
    --   or 'GI.Clutter.Enums.EventTypeKeyRelease'
    -> m Char
    -- ^ __Returns:__ The unicode value representing the key
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetKeyUnicode"
        })


#endif

-- method Event::get_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Point" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPoint" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_position" clutter_event_get_position :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Clutter.Point.Point ->              -- position : TInterface (Name {namespace = "Clutter", name = "Point"})
    IO ()

-- | Retrieves the event coordinates as a t'GI.Clutter.Structs.Point.Point'.
-- 
-- /Since: 1.12/
eventGetPosition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Clutter.Point.Point
    -- ^ /@position@/: a t'GI.Clutter.Structs.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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetPosition"
        })


#endif

-- method Event::get_related
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_ENTER or of\n  type %CLUTTER_LEAVE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_related" clutter_event_get_related :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO (Ptr Clutter.Actor.Actor)

-- | Retrieves the related actor of a crossing event.
-- 
-- /Since: 1.0/
eventGetRelated ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeEnter' or of
    --   type 'GI.Clutter.Enums.EventTypeLeave'
    -> m Clutter.Actor.Actor
    -- ^ __Returns:__ the related t'GI.Clutter.Objects.Actor.Actor', or 'P.Nothing'
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetRelated"
        })


#endif

-- method Event::get_scroll_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent of type %CLUTTER_SCROLL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dx"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the delta on the horizontal axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "dy"
--           , argType = TBasicType TDouble
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the delta on the vertical axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_scroll_delta" clutter_event_get_scroll_delta :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr CDouble ->                          -- dx : TBasicType TDouble
    Ptr CDouble ->                          -- dy : TBasicType TDouble
    IO ()

-- | Retrieves the precise scrolling information of /@event@/.
-- 
-- The /@event@/ has to have a t'GI.Clutter.Structs.ScrollEvent.ScrollEvent'.@/direction/@ value
-- of 'GI.Clutter.Enums.ScrollDirectionSmooth'.
-- 
-- /Since: 1.10/
eventGetScrollDelta ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeScroll'
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetScrollDelta"
        })


#endif

-- method Event::get_scroll_direction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent of type %CLUTTER_SCROLL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Clutter" , name = "ScrollDirection" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_scroll_direction" clutter_event_get_scroll_direction :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CUInt

-- | Retrieves the direction of the scrolling of /@event@/
-- 
-- /Since: 1.0/
eventGetScrollDirection ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeScroll'
    -> m Clutter.Enums.ScrollDirection
    -- ^ __Returns:__ the scrolling direction
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetScrollDirection"
        })


#endif

-- XXX Could not generate method Event::get_scroll_finish_flags
-- Bad introspection data: Could not resolve the symbol “clutter_event_get_scroll_finish_flags” in the “Clutter” namespace, ignoring.
-- XXX Could not generate method Event::get_scroll_source
-- Bad introspection data: Could not resolve the symbol “clutter_event_get_scroll_source” in the “Clutter” namespace, ignoring.
-- method Event::get_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Actor" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_source" clutter_event_get_source :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO (Ptr Clutter.Actor.Actor)

-- | Retrieves the source t'GI.Clutter.Objects.Actor.Actor' the event originated from, or
-- NULL if the event has no source.
-- 
-- /Since: 0.6/
eventGetSource ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Clutter.Actor.Actor
    -- ^ __Returns:__ a t'GI.Clutter.Objects.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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetSource"
        })


#endif

-- method Event::get_source_device
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "InputDevice" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_source_device" clutter_event_get_source_device :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO (Ptr Clutter.InputDevice.InputDevice)

-- | Retrieves the hardware device that originated the event.
-- 
-- If you need the virtual device, use 'GI.Clutter.Unions.Event.eventGetDevice'.
-- 
-- If no hardware device originated this event, this function will
-- return the same device as 'GI.Clutter.Unions.Event.eventGetDevice'.
-- 
-- /Since: 1.6/
eventGetSourceDevice ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Clutter.InputDevice.InputDevice
    -- ^ __Returns:__ a pointer to a t'GI.Clutter.Objects.InputDevice.InputDevice'
    --   or 'P.Nothing'
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetSourceDevice"
        })


#endif

-- method Event::get_stage
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Stage" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_stage" clutter_event_get_stage :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO (Ptr Clutter.Stage.Stage)

-- | Retrieves the source t'GI.Clutter.Objects.Stage.Stage' the event originated for, or
-- 'P.Nothing' if the event has no stage.
-- 
-- /Since: 0.8/
eventGetStage ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Clutter.Stage.Stage
    -- ^ __Returns:__ a t'GI.Clutter.Objects.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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetStage"
        })


#endif

-- method Event::get_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "ModifierType" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_state" clutter_event_get_state :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CUInt

-- | Retrieves the modifier state of the event. In case the window system
-- supports reporting latched and locked modifiers, this function returns
-- the effective state.
-- 
-- /Since: 0.4/
eventGetState ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m [Clutter.Flags.ModifierType]
    -- ^ __Returns:__ the modifier state parameter, or 0
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetState"
        })


#endif

-- method Event::get_state_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "button_state"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ModifierType" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pressed buttons as a mask"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "base_state"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ModifierType" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the regular pressed modifier keys"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "latched_state"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ModifierType" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the latched modifier keys (currently released but still valid for one key press/release)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "locked_state"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ModifierType" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the locked modifier keys (valid until the lock key is pressed and released again)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "effective_state"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ModifierType" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the logical OR of all the state bits above"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_state_full" clutter_event_get_state_full :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr CUInt ->                            -- button_state : TInterface (Name {namespace = "Clutter", name = "ModifierType"})
    Ptr CUInt ->                            -- base_state : TInterface (Name {namespace = "Clutter", name = "ModifierType"})
    Ptr CUInt ->                            -- latched_state : TInterface (Name {namespace = "Clutter", name = "ModifierType"})
    Ptr CUInt ->                            -- locked_state : TInterface (Name {namespace = "Clutter", name = "ModifierType"})
    Ptr CUInt ->                            -- effective_state : TInterface (Name {namespace = "Clutter", name = "ModifierType"})
    IO ()

-- | Retrieves the decomposition of the keyboard state into button, base,
-- latched, locked and effective. This can be used to transmit to other
-- applications, for example when implementing a wayland compositor.
-- 
-- /Since: 1.16/
eventGetStateFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetStateFull"
        })


#endif

-- method Event::get_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get_time" clutter_event_get_time :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO Word32

-- | Retrieves the time of the event.
-- 
-- /Since: 0.4/
eventGetTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Word32
    -- ^ __Returns:__ the time of the event, or 'GI.Clutter.Constants.CURRENT_TIME'
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.5/docs/GI-Clutter-Unions-Event.html#v:eventGetTime"
        })


#endif

-- method Event::has_control_modifier
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_has_control_modifier" clutter_event_has_control_modifier :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CInt

-- | Checks whether /@event@/ has the Control modifier mask set.
-- 
-- /Since: 1.12/
eventHasControlModifier ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the event has the Control modifier mask set
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.5/docs/GI-Clutter-Unions-Event.html#v:eventHasControlModifier"
        })


#endif

-- method Event::has_shift_modifier
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_has_shift_modifier" clutter_event_has_shift_modifier :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CInt

-- | Checks whether /@event@/ has the Shift modifier mask set.
-- 
-- /Since: 1.12/
eventHasShiftModifier ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the event has the Shift modifier mask set
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.5/docs/GI-Clutter-Unions-Event.html#v:eventHasShiftModifier"
        })


#endif

-- method Event::is_pointer_emulated
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_is_pointer_emulated" clutter_event_is_pointer_emulated :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CInt

-- | Checks whether a pointer /@event@/ has been generated by the windowing
-- system. The returned value can be used to distinguish between events
-- synthesized by the windowing system itself (as opposed by Clutter).
-- 
-- /Since: 1.12/
eventIsPointerEmulated ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the event is pointer emulated
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.5/docs/GI-Clutter-Unions-Event.html#v:eventIsPointerEmulated"
        })


#endif

-- method Event::put
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_put" clutter_event_put :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO ()

-- | Puts a copy of the event on the back of the event queue. The event will
-- have the 'GI.Clutter.Flags.EventFlagsFlagSynthetic' flag set. If the source is set
-- event signals will be emitted for this source and capture\/bubbling for
-- its ancestors. If the source is not set it will be generated by picking
-- or use the actor that currently has keyboard focus
-- 
-- /Since: 0.6/
eventPut ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.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.5/docs/GI-Clutter-Unions-Event.html#v:eventPut"
        })


#endif

-- method Event::set_button
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent or type %CLUTTER_BUTTON_PRESS or\n  of type %CLUTTER_BUTTON_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "button"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the button number" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_button" clutter_event_set_button :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Word32 ->                               -- button : TBasicType TUInt32
    IO ()

-- | Sets the button number of /@event@/
-- 
-- /Since: 1.8/
eventSetButton ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' or type 'GI.Clutter.Enums.EventTypeButtonPress' or
    --   of type 'GI.Clutter.Enums.EventTypeButtonRelease'
    -> Word32
    -- ^ /@button@/: the button number
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetButton"
        })


#endif

-- method Event::set_coords
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the X coordinate of the event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Y coordinate of the event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_coords" clutter_event_set_coords :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO ()

-- | Sets the coordinates of the /@event@/.
-- 
-- /Since: 1.8/
eventSetCoords ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Float
    -- ^ /@x@/: the X coordinate of the event
    -> Float
    -- ^ /@y@/: the Y coordinate of the event
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetCoords"
        })


#endif

-- method Event::set_device
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "device"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "InputDevice" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterInputDevice, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_device" clutter_event_set_device :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Clutter.InputDevice.InputDevice ->  -- device : TInterface (Name {namespace = "Clutter", name = "InputDevice"})
    IO ()

-- | Sets the device for /@event@/.
-- 
-- /Since: 1.6/
eventSetDevice ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.InputDevice.IsInputDevice a) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Maybe (a)
    -- ^ /@device@/: a t'GI.Clutter.Objects.InputDevice.InputDevice', or 'P.Nothing'
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetDevice"
        })


#endif

-- method Event::set_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "EventFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a binary OR of #ClutterEventFlags values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_flags" clutter_event_set_flags :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Clutter", name = "EventFlags"})
    IO ()

-- | Sets the t'GI.Clutter.Flags.EventFlags' of /@event@/
-- 
-- /Since: 1.8/
eventSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> [Clutter.Flags.EventFlags]
    -- ^ /@flags@/: a binary OR of t'GI.Clutter.Flags.EventFlags' values
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetFlags"
        })


#endif

-- method Event::set_key_code
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_KEY_PRESS\n  or %CLUTTER_KEY_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_code"
--           , argType = TBasicType TUInt16
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the keycode representing the key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_key_code" clutter_event_set_key_code :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Word16 ->                               -- key_code : TBasicType TUInt16
    IO ()

-- | Sets the keycode of the /@event@/.
-- 
-- /Since: 1.8/
eventSetKeyCode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeKeyPress'
    --   or 'GI.Clutter.Enums.EventTypeKeyRelease'
    -> Word16
    -- ^ /@keyCode@/: the keycode representing the key
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetKeyCode"
        })


#endif

-- method Event::set_key_symbol
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_KEY_PRESS\n  or %CLUTTER_KEY_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_sym"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the key symbol representing the key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_key_symbol" clutter_event_set_key_symbol :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Word32 ->                               -- key_sym : TBasicType TUInt
    IO ()

-- | Sets the key symbol of /@event@/.
-- 
-- /Since: 1.8/
eventSetKeySymbol ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeKeyPress'
    --   or 'GI.Clutter.Enums.EventTypeKeyRelease'
    -> Word32
    -- ^ /@keySym@/: the key symbol representing the key
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetKeySymbol"
        })


#endif

-- method Event::set_key_unicode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #ClutterEvent of type %CLUTTER_KEY_PRESS\n  or %CLUTTER_KEY_RELEASE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_unicode"
--           , argType = TBasicType TUniChar
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Unicode value representing the key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_key_unicode" clutter_event_set_key_unicode :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    CInt ->                                 -- key_unicode : TBasicType TUniChar
    IO ()

-- | Sets the Unicode value of /@event@/.
-- 
-- /Since: 1.8/
eventSetKeyUnicode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeKeyPress'
    --   or 'GI.Clutter.Enums.EventTypeKeyRelease'
    -> Char
    -- ^ /@keyUnicode@/: the Unicode value representing the key
    -> 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
P.fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
SP.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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetKeyUnicode"
        })


#endif

-- method Event::set_related
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #ClutterEvent of type %CLUTTER_ENTER or %CLUTTER_LEAVE"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_related" clutter_event_set_related :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Clutter.Actor.Actor ->              -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Sets the related actor of a crossing event
-- 
-- /Since: 1.8/
eventSetRelated ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.Actor.IsActor a) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeEnter' or 'GI.Clutter.Enums.EventTypeLeave'
    -> Maybe (a)
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor' or 'P.Nothing'
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetRelated"
        })


#endif

-- method Event::set_scroll_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent of type %CLUTTER_SCROLL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dx"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "delta on the horizontal axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dy"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "delta on the vertical axis"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_scroll_delta" clutter_event_set_scroll_delta :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    CDouble ->                              -- dx : TBasicType TDouble
    CDouble ->                              -- dy : TBasicType TDouble
    IO ()

-- | Sets the precise scrolling information of /@event@/.
-- 
-- /Since: 1.10/
eventSetScrollDelta ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event' of type 'GI.Clutter.Enums.EventTypeScroll'
    -> Double
    -- ^ /@dx@/: delta on the horizontal axis
    -> Double
    -- ^ /@dy@/: delta on the vertical axis
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetScrollDelta"
        })


#endif

-- method Event::set_scroll_direction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "direction"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "ScrollDirection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the scrolling direction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_scroll_direction" clutter_event_set_scroll_direction :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Clutter", name = "ScrollDirection"})
    IO ()

-- | Sets the direction of the scrolling of /@event@/
-- 
-- /Since: 1.8/
eventSetScrollDirection ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Clutter.Enums.ScrollDirection
    -- ^ /@direction@/: the scrolling direction
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetScrollDirection"
        })


#endif

-- method Event::set_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "actor"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Actor" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterActor, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_source" clutter_event_set_source :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Clutter.Actor.Actor ->              -- actor : TInterface (Name {namespace = "Clutter", name = "Actor"})
    IO ()

-- | Sets the source t'GI.Clutter.Objects.Actor.Actor' of /@event@/.
-- 
-- /Since: 1.8/
eventSetSource ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.Actor.IsActor a) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Maybe (a)
    -- ^ /@actor@/: a t'GI.Clutter.Objects.Actor.Actor', or 'P.Nothing'
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetSource"
        })


#endif

-- method Event::set_source_device
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "device"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "InputDevice" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterInputDevice"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_source_device" clutter_event_set_source_device :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Clutter.InputDevice.InputDevice ->  -- device : TInterface (Name {namespace = "Clutter", name = "InputDevice"})
    IO ()

-- | Sets the source t'GI.Clutter.Objects.InputDevice.InputDevice' for /@event@/.
-- 
-- The t'GI.Clutter.Unions.Event.Event' must have been created using 'GI.Clutter.Unions.Event.eventNew'.
-- 
-- /Since: 1.8/
eventSetSourceDevice ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.InputDevice.IsInputDevice a) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Maybe (a)
    -- ^ /@device@/: a t'GI.Clutter.Objects.InputDevice.InputDevice'
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetSourceDevice"
        })


#endif

-- method Event::set_stage
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterStage, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_stage" clutter_event_set_stage :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Ptr Clutter.Stage.Stage ->              -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    IO ()

-- | Sets the source t'GI.Clutter.Objects.Stage.Stage' of the event.
-- 
-- /Since: 1.8/
eventSetStage ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.Stage.IsStage a) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Maybe (a)
    -- ^ /@stage@/: a t'GI.Clutter.Objects.Stage.Stage', or 'P.Nothing'
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetStage"
        })


#endif

-- method Event::set_state
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "ModifierType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the modifier state to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_state" clutter_event_set_state :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Clutter", name = "ModifierType"})
    IO ()

-- | Sets the modifier state of the event.
-- 
-- /Since: 1.8/
eventSetState ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> [Clutter.Flags.ModifierType]
    -- ^ /@state@/: the modifier state to set
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetState"
        })


#endif

-- method Event::set_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "time_"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the time of the event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_set_time" clutter_event_set_time :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    Word32 ->                               -- time_ : TBasicType TUInt32
    IO ()

-- | Sets the time of the event.
-- 
-- /Since: 1.8/
eventSetTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> Word32
    -- ^ /@time_@/: the time of the event
    -> 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.5/docs/GI-Clutter-Unions-Event.html#v:eventSetTime"
        })


#endif

-- method Event::type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Event" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "EventType" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_type" clutter_event_type :: 
    Ptr Event ->                            -- event : TInterface (Name {namespace = "Clutter", name = "Event"})
    IO CUInt

-- | Retrieves the type of the event.
eventType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Event
    -- ^ /@event@/: a t'GI.Clutter.Unions.Event.Event'
    -> m Clutter.Enums.EventType
    -- ^ __Returns:__ a t'GI.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.5/docs/GI-Clutter-Unions-Event.html#v:eventType"
        })


#endif

-- method Event::add_filter
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "stage"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "Stage" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #ClutterStage to capture events for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "Clutter" , name = "EventFilterFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The callback function which will be passed all events."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 3
--           , argDestroy = 2
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "notify"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDestroyNotify" , sinceVersion = Nothing }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A data pointer to pass to the function."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_add_filter" clutter_event_add_filter :: 
    Ptr Clutter.Stage.Stage ->              -- stage : TInterface (Name {namespace = "Clutter", name = "Stage"})
    FunPtr Clutter.Callbacks.C_EventFilterFunc -> -- func : TInterface (Name {namespace = "Clutter", name = "EventFilterFunc"})
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO Word32

-- | Adds a function which will be called for all events that Clutter
-- processes. The function will be called before any signals are
-- emitted for the event and it will take precedence over any grabs.
-- 
-- /Since: 1.18/
eventAddFilter ::
    (B.CallStack.HasCallStack, MonadIO m, Clutter.Stage.IsStage a) =>
    Maybe (a)
    -- ^ /@stage@/: The t'GI.Clutter.Objects.Stage.Stage' to capture events for
    -> Clutter.Callbacks.EventFilterFunc
    -- ^ /@func@/: The callback function which will be passed all events.
    -> m Word32
    -- ^ __Returns:__ an identifier for the event filter, to be used
    --   with 'GI.Clutter.Functions.eventRemoveFilter'.
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

-- method Event::get
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Event" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_get" clutter_event_get :: 
    IO (Ptr Event)

-- | Pops an event off the event queue. Applications should not need to call
-- this.
-- 
-- /Since: 0.4/
eventGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Event
    -- ^ __Returns:__ A t'GI.Clutter.Unions.Event.Event' or NULL if queue empty
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

-- method Event::peek
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "Event" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_peek" clutter_event_peek :: 
    IO (Ptr Event)

-- | Returns a pointer to the first event from the event queue but
-- does not remove it.
-- 
-- /Since: 0.4/
eventPeek ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Event
    -- ^ __Returns:__ A t'GI.Clutter.Unions.Event.Event' or NULL if queue empty.
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

-- method Event::remove_filter
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "id"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The ID of the event filter, as returned from clutter_event_add_filter()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_event_remove_filter" clutter_event_remove_filter :: 
    Word32 ->                               -- id : TBasicType TUInt
    IO ()

-- | Removes an event filter that was previously added with
-- 'GI.Clutter.Functions.eventAddFilter'.
-- 
-- /Since: 1.18/
eventRemoveFilter ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    -- ^ /@id@/: The ID of the event filter, as returned from 'GI.Clutter.Functions.eventAddFilter'
    -> 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 :: DK.Type) :: DK.Type 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