Event.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.Gdk.Unions.Event
    ( 

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


 -- * Methods
-- ** eventCopy
    EventCopyMethodInfo                     ,
    eventCopy                               ,


-- ** eventFree
    EventFreeMethodInfo                     ,
    eventFree                               ,


-- ** eventGet
    eventGet                                ,


-- ** eventGetAxis
    EventGetAxisMethodInfo                  ,
    eventGetAxis                            ,


-- ** eventGetButton
    EventGetButtonMethodInfo                ,
    eventGetButton                          ,


-- ** eventGetClickCount
    EventGetClickCountMethodInfo            ,
    eventGetClickCount                      ,


-- ** eventGetCoords
    EventGetCoordsMethodInfo                ,
    eventGetCoords                          ,


-- ** eventGetDevice
    EventGetDeviceMethodInfo                ,
    eventGetDevice                          ,


-- ** eventGetEventSequence
    EventGetEventSequenceMethodInfo         ,
    eventGetEventSequence                   ,


-- ** eventGetEventType
    EventGetEventTypeMethodInfo             ,
    eventGetEventType                       ,


-- ** eventGetKeycode
    EventGetKeycodeMethodInfo               ,
    eventGetKeycode                         ,


-- ** eventGetKeyval
    EventGetKeyvalMethodInfo                ,
    eventGetKeyval                          ,


-- ** eventGetRootCoords
    EventGetRootCoordsMethodInfo            ,
    eventGetRootCoords                      ,


-- ** eventGetScreen
    EventGetScreenMethodInfo                ,
    eventGetScreen                          ,


-- ** eventGetScrollDeltas
    EventGetScrollDeltasMethodInfo          ,
    eventGetScrollDeltas                    ,


-- ** eventGetScrollDirection
    EventGetScrollDirectionMethodInfo       ,
    eventGetScrollDirection                 ,


-- ** eventGetSourceDevice
    EventGetSourceDeviceMethodInfo          ,
    eventGetSourceDevice                    ,


-- ** eventGetState
    EventGetStateMethodInfo                 ,
    eventGetState                           ,


-- ** eventGetTime
    EventGetTimeMethodInfo                  ,
    eventGetTime                            ,


-- ** eventGetWindow
    EventGetWindowMethodInfo                ,
    eventGetWindow                          ,


-- ** eventHandlerSet
    eventHandlerSet                         ,


-- ** eventNew
    eventNew                                ,


-- ** eventPeek
    eventPeek                               ,


-- ** eventPut
    EventPutMethodInfo                      ,
    eventPut                                ,


-- ** eventRequestMotions
    eventRequestMotions                     ,


-- ** eventSetDevice
    EventSetDeviceMethodInfo                ,
    eventSetDevice                          ,


-- ** eventSetScreen
    EventSetScreenMethodInfo                ,
    eventSetScreen                          ,


-- ** eventSetSourceDevice
    EventSetSourceDeviceMethodInfo          ,
    eventSetSourceDevice                    ,


-- ** eventTriggersContextMenu
    EventTriggersContextMenuMethodInfo      ,
    eventTriggersContextMenu                ,




 -- * Properties
-- ** Any
    eventReadAny                            ,


-- ** Button
    eventReadButton                         ,


-- ** Configure
    eventReadConfigure                      ,


-- ** Crossing
    eventReadCrossing                       ,


-- ** Dnd
    eventReadDnd                            ,


-- ** Expose
    eventReadExpose                         ,


-- ** FocusChange
    eventReadFocusChange                    ,


-- ** GrabBroken
    eventReadGrabBroken                     ,


-- ** Key
    eventReadKey                            ,


-- ** Motion
    eventReadMotion                         ,


-- ** OwnerChange
    eventReadOwnerChange                    ,


-- ** Property
    eventReadProperty                       ,


-- ** Proximity
    eventReadProximity                      ,


-- ** Scroll
    eventReadScroll                         ,


-- ** Selection
    eventReadSelection                      ,


-- ** Setting
    eventReadSetting                        ,


-- ** Touch
    eventReadTouch                          ,


-- ** TouchpadPinch
    eventReadTouchpadPinch                  ,


-- ** TouchpadSwipe
    eventReadTouchpadSwipe                  ,


-- ** Type
    eventReadType                           ,


-- ** Visibility
    eventReadVisibility                     ,


-- ** WindowState
    eventReadWindowState                    ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.Gdk.Types
import GI.Gdk.Callbacks
import qualified GI.GLib as GLib

newtype Event = Event (ForeignPtr Event)
foreign import ccall "gdk_event_get_type" c_gdk_event_get_type :: 
    IO GType

instance BoxedObject Event where
    boxedType _ = c_gdk_event_get_type

-- | Construct a `Event` struct initialized to zero.
newZeroEvent :: MonadIO m => m Event
newZeroEvent = liftIO $ callocBoxedBytes 104 >>= wrapBoxed Event

noEvent :: Maybe Event
noEvent = Nothing

eventReadType :: Event -> IO EventType
eventReadType s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

eventReadAny :: Event -> IO EventAny
eventReadAny s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventAny)
    val' <- (newPtr 24 EventAny) val
    return val'

eventReadExpose :: Event -> IO EventExpose
eventReadExpose s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventExpose)
    val' <- (newPtr 56 EventExpose) val
    return val'

eventReadVisibility :: Event -> IO EventVisibility
eventReadVisibility s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventVisibility)
    val' <- (newPtr 24 EventVisibility) val
    return val'

eventReadMotion :: Event -> IO EventMotion
eventReadMotion s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventMotion)
    val' <- (newPtr 80 EventMotion) val
    return val'

eventReadButton :: Event -> IO EventButton
eventReadButton s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventButton)
    val' <- (newPtr 80 EventButton) val
    return val'

eventReadTouch :: Event -> IO EventTouch
eventReadTouch s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventTouch)
    val' <- (newPtr 96 EventTouch) val
    return val'

eventReadScroll :: Event -> IO EventScroll
eventReadScroll s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventScroll)
    val' <- (newPtr 88 EventScroll) val
    return val'

eventReadKey :: Event -> IO EventKey
eventReadKey s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventKey)
    val' <- (newPtr 56 EventKey) val
    return val'

eventReadCrossing :: Event -> IO EventCrossing
eventReadCrossing s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventCrossing)
    val' <- (newPtr 88 EventCrossing) val
    return val'

eventReadFocusChange :: Event -> IO EventFocus
eventReadFocusChange s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventFocus)
    val' <- (newPtr 24 EventFocus) val
    return val'

eventReadConfigure :: Event -> IO EventConfigure
eventReadConfigure s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventConfigure)
    val' <- (newPtr 40 EventConfigure) val
    return val'

eventReadProperty :: Event -> IO EventProperty
eventReadProperty s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventProperty)
    val' <- (newPtr 40 EventProperty) val
    return val'

eventReadSelection :: Event -> IO EventSelection
eventReadSelection s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventSelection)
    val' <- (newPtr 64 EventSelection) val
    return val'

eventReadOwnerChange :: Event -> IO EventOwnerChange
eventReadOwnerChange s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventOwnerChange)
    val' <- (newPtr 56 EventOwnerChange) val
    return val'

eventReadProximity :: Event -> IO EventProximity
eventReadProximity s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventProximity)
    val' <- (newPtr 32 EventProximity) val
    return val'

eventReadDnd :: Event -> IO EventDND
eventReadDnd s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventDND)
    val' <- (newPtr 40 EventDND) val
    return val'

eventReadWindowState :: Event -> IO EventWindowState
eventReadWindowState s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventWindowState)
    val' <- (newPtr 32 EventWindowState) val
    return val'

eventReadSetting :: Event -> IO EventSetting
eventReadSetting s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventSetting)
    val' <- (newPtr 32 EventSetting) val
    return val'

eventReadGrabBroken :: Event -> IO EventGrabBroken
eventReadGrabBroken s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventGrabBroken)
    val' <- (newPtr 40 EventGrabBroken) val
    return val'

eventReadTouchpadSwipe :: Event -> IO EventTouchpadSwipe
eventReadTouchpadSwipe s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventTouchpadSwipe)
    val' <- (newPtr 88 EventTouchpadSwipe) val
    return val'

eventReadTouchpadPinch :: Event -> IO EventTouchpadPinch
eventReadTouchpadPinch s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr EventTouchpadPinch)
    val' <- (newPtr 104 EventTouchpadPinch) val
    return val'

-- method Event::new
-- method type : Constructor
-- Args : [Arg {argCName = "type", argType = TInterface "Gdk" "EventType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "Event"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_new" gdk_event_new :: 
    CUInt ->                                -- type : TInterface "Gdk" "EventType"
    IO (Ptr Event)


eventNew ::
    (MonadIO m) =>
    EventType                               -- type_
    -> m Event                              -- result
eventNew type_ = liftIO $ do
    let type_' = (fromIntegral . fromEnum) type_
    result <- gdk_event_new type_'
    checkUnexpectedReturnNULL "gdk_event_new" result
    result' <- (wrapBoxed Event) result
    return result'

-- method Event::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "Event"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_copy" gdk_event_copy :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO (Ptr Event)


eventCopy ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m Event                              -- result
eventCopy _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_copy _obj'
    checkUnexpectedReturnNULL "gdk_event_copy" result
    result' <- (wrapBoxed Event) result
    touchManagedPtr _obj
    return result'

data EventCopyMethodInfo
instance (signature ~ (m Event), MonadIO m) => MethodInfo EventCopyMethodInfo Event signature where
    overloadedMethod _ = eventCopy

-- method Event::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_free" gdk_event_free :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO ()


eventFree ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m ()                                 -- result
eventFree _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    gdk_event_free _obj'
    touchManagedPtr _obj
    return ()

data EventFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => MethodInfo EventFreeMethodInfo Event signature where
    overloadedMethod _ = eventFree

-- method Event::get_axis
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "axis_use", argType = TInterface "Gdk" "AxisUse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_axis" gdk_event_get_axis :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    CUInt ->                                -- axis_use : TInterface "Gdk" "AxisUse"
    Ptr CDouble ->                          -- value : TBasicType TDouble
    IO CInt


eventGetAxis ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> AxisUse                              -- axisUse
    -> m (Bool,Double)                      -- result
eventGetAxis _obj axisUse = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    let axisUse' = (fromIntegral . fromEnum) axisUse
    value <- allocMem :: IO (Ptr CDouble)
    result <- gdk_event_get_axis _obj' axisUse' value
    let result' = (/= 0) result
    value' <- peek value
    let value'' = realToFrac value'
    touchManagedPtr _obj
    freeMem value
    return (result', value'')

data EventGetAxisMethodInfo
instance (signature ~ (AxisUse -> m (Bool,Double)), MonadIO m) => MethodInfo EventGetAxisMethodInfo Event signature where
    overloadedMethod _ = eventGetAxis

-- method Event::get_button
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "button", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_button" gdk_event_get_button :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr Word32 ->                           -- button : TBasicType TUInt32
    IO CInt


eventGetButton ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,Word32)                      -- result
eventGetButton _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    button <- allocMem :: IO (Ptr Word32)
    result <- gdk_event_get_button _obj' button
    let result' = (/= 0) result
    button' <- peek button
    touchManagedPtr _obj
    freeMem button
    return (result', button')

data EventGetButtonMethodInfo
instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo EventGetButtonMethodInfo Event signature where
    overloadedMethod _ = eventGetButton

-- method Event::get_click_count
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "click_count", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_click_count" gdk_event_get_click_count :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr Word32 ->                           -- click_count : TBasicType TUInt32
    IO CInt


eventGetClickCount ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,Word32)                      -- result
eventGetClickCount _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    clickCount <- allocMem :: IO (Ptr Word32)
    result <- gdk_event_get_click_count _obj' clickCount
    let result' = (/= 0) result
    clickCount' <- peek clickCount
    touchManagedPtr _obj
    freeMem clickCount
    return (result', clickCount')

data EventGetClickCountMethodInfo
instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo EventGetClickCountMethodInfo Event signature where
    overloadedMethod _ = eventGetClickCount

-- method Event::get_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_win", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y_win", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_coords" gdk_event_get_coords :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr CDouble ->                          -- x_win : TBasicType TDouble
    Ptr CDouble ->                          -- y_win : TBasicType TDouble
    IO CInt


eventGetCoords ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,Double,Double)               -- result
eventGetCoords _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    xWin <- allocMem :: IO (Ptr CDouble)
    yWin <- allocMem :: IO (Ptr CDouble)
    result <- gdk_event_get_coords _obj' xWin yWin
    let result' = (/= 0) result
    xWin' <- peek xWin
    let xWin'' = realToFrac xWin'
    yWin' <- peek yWin
    let yWin'' = realToFrac yWin'
    touchManagedPtr _obj
    freeMem xWin
    freeMem yWin
    return (result', xWin'', yWin'')

data EventGetCoordsMethodInfo
instance (signature ~ (m (Bool,Double,Double)), MonadIO m) => MethodInfo EventGetCoordsMethodInfo Event signature where
    overloadedMethod _ = eventGetCoords

-- method Event::get_device
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "Device"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_device" gdk_event_get_device :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO (Ptr Device)


eventGetDevice ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m Device                             -- result
eventGetDevice _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_get_device _obj'
    checkUnexpectedReturnNULL "gdk_event_get_device" result
    result' <- (newObject Device) result
    touchManagedPtr _obj
    return result'

data EventGetDeviceMethodInfo
instance (signature ~ (m Device), MonadIO m) => MethodInfo EventGetDeviceMethodInfo Event signature where
    overloadedMethod _ = eventGetDevice

-- method Event::get_event_sequence
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "EventSequence"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_event_sequence" gdk_event_get_event_sequence :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO (Ptr EventSequence)


eventGetEventSequence ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m EventSequence                      -- result
eventGetEventSequence _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_get_event_sequence _obj'
    checkUnexpectedReturnNULL "gdk_event_get_event_sequence" result
    result' <- (newBoxed EventSequence) result
    touchManagedPtr _obj
    return result'

data EventGetEventSequenceMethodInfo
instance (signature ~ (m EventSequence), MonadIO m) => MethodInfo EventGetEventSequenceMethodInfo Event signature where
    overloadedMethod _ = eventGetEventSequence

-- method Event::get_event_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "EventType"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_event_type" gdk_event_get_event_type :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO CUInt


eventGetEventType ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m EventType                          -- result
eventGetEventType _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_get_event_type _obj'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr _obj
    return result'

data EventGetEventTypeMethodInfo
instance (signature ~ (m EventType), MonadIO m) => MethodInfo EventGetEventTypeMethodInfo Event signature where
    overloadedMethod _ = eventGetEventType

-- method Event::get_keycode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keycode", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_keycode" gdk_event_get_keycode :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr Word16 ->                           -- keycode : TBasicType TUInt16
    IO CInt


eventGetKeycode ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,Word16)                      -- result
eventGetKeycode _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    keycode <- allocMem :: IO (Ptr Word16)
    result <- gdk_event_get_keycode _obj' keycode
    let result' = (/= 0) result
    keycode' <- peek keycode
    touchManagedPtr _obj
    freeMem keycode
    return (result', keycode')

data EventGetKeycodeMethodInfo
instance (signature ~ (m (Bool,Word16)), MonadIO m) => MethodInfo EventGetKeycodeMethodInfo Event signature where
    overloadedMethod _ = eventGetKeycode

-- method Event::get_keyval
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyval", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_keyval" gdk_event_get_keyval :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr Word32 ->                           -- keyval : TBasicType TUInt32
    IO CInt


eventGetKeyval ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,Word32)                      -- result
eventGetKeyval _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    keyval <- allocMem :: IO (Ptr Word32)
    result <- gdk_event_get_keyval _obj' keyval
    let result' = (/= 0) result
    keyval' <- peek keyval
    touchManagedPtr _obj
    freeMem keyval
    return (result', keyval')

data EventGetKeyvalMethodInfo
instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo EventGetKeyvalMethodInfo Event signature where
    overloadedMethod _ = eventGetKeyval

-- method Event::get_root_coords
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_root", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y_root", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_root_coords" gdk_event_get_root_coords :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr CDouble ->                          -- x_root : TBasicType TDouble
    Ptr CDouble ->                          -- y_root : TBasicType TDouble
    IO CInt


eventGetRootCoords ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,Double,Double)               -- result
eventGetRootCoords _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    xRoot <- allocMem :: IO (Ptr CDouble)
    yRoot <- allocMem :: IO (Ptr CDouble)
    result <- gdk_event_get_root_coords _obj' xRoot yRoot
    let result' = (/= 0) result
    xRoot' <- peek xRoot
    let xRoot'' = realToFrac xRoot'
    yRoot' <- peek yRoot
    let yRoot'' = realToFrac yRoot'
    touchManagedPtr _obj
    freeMem xRoot
    freeMem yRoot
    return (result', xRoot'', yRoot'')

data EventGetRootCoordsMethodInfo
instance (signature ~ (m (Bool,Double,Double)), MonadIO m) => MethodInfo EventGetRootCoordsMethodInfo Event signature where
    overloadedMethod _ = eventGetRootCoords

-- method Event::get_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "Screen"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_screen" gdk_event_get_screen :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO (Ptr Screen)


eventGetScreen ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m Screen                             -- result
eventGetScreen _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_get_screen _obj'
    checkUnexpectedReturnNULL "gdk_event_get_screen" result
    result' <- (newObject Screen) result
    touchManagedPtr _obj
    return result'

data EventGetScreenMethodInfo
instance (signature ~ (m Screen), MonadIO m) => MethodInfo EventGetScreenMethodInfo Event signature where
    overloadedMethod _ = eventGetScreen

-- method Event::get_scroll_deltas
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "delta_y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_scroll_deltas" gdk_event_get_scroll_deltas :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr CDouble ->                          -- delta_x : TBasicType TDouble
    Ptr CDouble ->                          -- delta_y : TBasicType TDouble
    IO CInt


eventGetScrollDeltas ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,Double,Double)               -- result
eventGetScrollDeltas _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    deltaX <- allocMem :: IO (Ptr CDouble)
    deltaY <- allocMem :: IO (Ptr CDouble)
    result <- gdk_event_get_scroll_deltas _obj' deltaX deltaY
    let result' = (/= 0) result
    deltaX' <- peek deltaX
    let deltaX'' = realToFrac deltaX'
    deltaY' <- peek deltaY
    let deltaY'' = realToFrac deltaY'
    touchManagedPtr _obj
    freeMem deltaX
    freeMem deltaY
    return (result', deltaX'', deltaY'')

data EventGetScrollDeltasMethodInfo
instance (signature ~ (m (Bool,Double,Double)), MonadIO m) => MethodInfo EventGetScrollDeltasMethodInfo Event signature where
    overloadedMethod _ = eventGetScrollDeltas

-- method Event::get_scroll_direction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gdk" "ScrollDirection", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_scroll_direction" gdk_event_get_scroll_direction :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr CUInt ->                            -- direction : TInterface "Gdk" "ScrollDirection"
    IO CInt


eventGetScrollDirection ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,ScrollDirection)             -- result
eventGetScrollDirection _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    direction <- allocMem :: IO (Ptr CUInt)
    result <- gdk_event_get_scroll_direction _obj' direction
    let result' = (/= 0) result
    direction' <- peek direction
    let direction'' = (toEnum . fromIntegral) direction'
    touchManagedPtr _obj
    freeMem direction
    return (result', direction'')

data EventGetScrollDirectionMethodInfo
instance (signature ~ (m (Bool,ScrollDirection)), MonadIO m) => MethodInfo EventGetScrollDirectionMethodInfo Event signature where
    overloadedMethod _ = eventGetScrollDirection

-- method Event::get_source_device
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "Device"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_source_device" gdk_event_get_source_device :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO (Ptr Device)


eventGetSourceDevice ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m Device                             -- result
eventGetSourceDevice _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_get_source_device _obj'
    checkUnexpectedReturnNULL "gdk_event_get_source_device" result
    result' <- (newObject Device) result
    touchManagedPtr _obj
    return result'

data EventGetSourceDeviceMethodInfo
instance (signature ~ (m Device), MonadIO m) => MethodInfo EventGetSourceDeviceMethodInfo Event signature where
    overloadedMethod _ = eventGetSourceDevice

-- method Event::get_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gdk" "ModifierType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_state" gdk_event_get_state :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr CUInt ->                            -- state : TInterface "Gdk" "ModifierType"
    IO CInt


eventGetState ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m (Bool,[ModifierType])              -- result
eventGetState _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    state <- allocMem :: IO (Ptr CUInt)
    result <- gdk_event_get_state _obj' state
    let result' = (/= 0) result
    state' <- peek state
    let state'' = wordToGFlags state'
    touchManagedPtr _obj
    freeMem state
    return (result', state'')

data EventGetStateMethodInfo
instance (signature ~ (m (Bool,[ModifierType])), MonadIO m) => MethodInfo EventGetStateMethodInfo Event signature where
    overloadedMethod _ = eventGetState

-- method Event::get_time
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TUInt32
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_time" gdk_event_get_time :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO Word32


eventGetTime ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m Word32                             -- result
eventGetTime _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_get_time _obj'
    touchManagedPtr _obj
    return result

data EventGetTimeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => MethodInfo EventGetTimeMethodInfo Event signature where
    overloadedMethod _ = eventGetTime

-- method Event::get_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "Gdk" "Window"
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_get_window" gdk_event_get_window :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO (Ptr Window)


eventGetWindow ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m Window                             -- result
eventGetWindow _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_get_window _obj'
    checkUnexpectedReturnNULL "gdk_event_get_window" result
    result' <- (newObject Window) result
    touchManagedPtr _obj
    return result'

data EventGetWindowMethodInfo
instance (signature ~ (m Window), MonadIO m) => MethodInfo EventGetWindowMethodInfo Event signature where
    overloadedMethod _ = eventGetWindow

-- method Event::put
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_put" gdk_event_put :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO ()


eventPut ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m ()                                 -- result
eventPut _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    gdk_event_put _obj'
    touchManagedPtr _obj
    return ()

data EventPutMethodInfo
instance (signature ~ (m ()), MonadIO m) => MethodInfo EventPutMethodInfo Event signature where
    overloadedMethod _ = eventPut

-- method Event::set_device
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_set_device" gdk_event_set_device :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr Device ->                           -- device : TInterface "Gdk" "Device"
    IO ()


eventSetDevice ::
    (MonadIO m, DeviceK a) =>
    Event                                   -- _obj
    -> a                                    -- device
    -> m ()                                 -- result
eventSetDevice _obj device = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    let device' = unsafeManagedPtrCastPtr device
    gdk_event_set_device _obj' device'
    touchManagedPtr _obj
    touchManagedPtr device
    return ()

data EventSetDeviceMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, DeviceK a) => MethodInfo EventSetDeviceMethodInfo Event signature where
    overloadedMethod _ = eventSetDevice

-- method Event::set_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_set_screen" gdk_event_set_screen :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr Screen ->                           -- screen : TInterface "Gdk" "Screen"
    IO ()


eventSetScreen ::
    (MonadIO m, ScreenK a) =>
    Event                                   -- _obj
    -> a                                    -- screen
    -> m ()                                 -- result
eventSetScreen _obj screen = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    let screen' = unsafeManagedPtrCastPtr screen
    gdk_event_set_screen _obj' screen'
    touchManagedPtr _obj
    touchManagedPtr screen
    return ()

data EventSetScreenMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, ScreenK a) => MethodInfo EventSetScreenMethodInfo Event signature where
    overloadedMethod _ = eventSetScreen

-- method Event::set_source_device
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_set_source_device" gdk_event_set_source_device :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    Ptr Device ->                           -- device : TInterface "Gdk" "Device"
    IO ()


eventSetSourceDevice ::
    (MonadIO m, DeviceK a) =>
    Event                                   -- _obj
    -> a                                    -- device
    -> m ()                                 -- result
eventSetSourceDevice _obj device = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    let device' = unsafeManagedPtrCastPtr device
    gdk_event_set_source_device _obj' device'
    touchManagedPtr _obj
    touchManagedPtr device
    return ()

data EventSetSourceDeviceMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, DeviceK a) => MethodInfo EventSetSourceDeviceMethodInfo Event signature where
    overloadedMethod _ = eventSetSourceDevice

-- method Event::triggers_context_menu
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_triggers_context_menu" gdk_event_triggers_context_menu :: 
    Ptr Event ->                            -- _obj : TInterface "Gdk" "Event"
    IO CInt


eventTriggersContextMenu ::
    (MonadIO m) =>
    Event                                   -- _obj
    -> m Bool                               -- result
eventTriggersContextMenu _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gdk_event_triggers_context_menu _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

data EventTriggersContextMenuMethodInfo
instance (signature ~ (m Bool), MonadIO m) => MethodInfo EventTriggersContextMenuMethodInfo Event signature where
    overloadedMethod _ = eventTriggersContextMenu

-- method Event::get
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : TInterface "Gdk" "Event"
-- throws : False
-- Skip return : False

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


eventGet ::
    (MonadIO m) =>
    m Event                                 -- result
eventGet  = liftIO $ do
    result <- gdk_event_get
    checkUnexpectedReturnNULL "gdk_event_get" result
    result' <- (wrapBoxed Event) result
    return result'

-- method Event::handler_set
-- method type : MemberFunction
-- Args : [Arg {argCName = "func", argType = TInterface "Gdk" "EventFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 1, argDestroy = 2, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_handler_set" gdk_event_handler_set :: 
    FunPtr EventFuncC ->                    -- func : TInterface "Gdk" "EventFunc"
    Ptr () ->                               -- data : TBasicType TVoid
    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
    IO ()


eventHandlerSet ::
    (MonadIO m) =>
    EventFunc                               -- func
    -> m ()                                 -- result
eventHandlerSet func = liftIO $ do
    func' <- mkEventFunc (eventFuncWrapper Nothing func)
    let data_ = castFunPtrToPtr func'
    let notify = safeFreeFunPtrPtr
    gdk_event_handler_set func' data_ notify
    return ()

-- method Event::peek
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : TInterface "Gdk" "Event"
-- throws : False
-- Skip return : False

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


eventPeek ::
    (MonadIO m) =>
    m Event                                 -- result
eventPeek  = liftIO $ do
    result <- gdk_event_peek
    checkUnexpectedReturnNULL "gdk_event_peek" result
    result' <- (wrapBoxed Event) result
    return result'

-- method Event::request_motions
-- method type : MemberFunction
-- Args : [Arg {argCName = "event", argType = TInterface "Gdk" "EventMotion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gdk_event_request_motions" gdk_event_request_motions :: 
    Ptr EventMotion ->                      -- event : TInterface "Gdk" "EventMotion"
    IO ()


eventRequestMotions ::
    (MonadIO m) =>
    EventMotion                             -- event
    -> m ()                                 -- result
eventRequestMotions event = liftIO $ do
    let event' = unsafeManagedPtrGetPtr event
    gdk_event_request_motions event'
    touchManagedPtr event
    return ()

type family ResolveEventMethod (t :: Symbol) (o :: *) :: * where
    ResolveEventMethod "copy" o = EventCopyMethodInfo
    ResolveEventMethod "free" o = EventFreeMethodInfo
    ResolveEventMethod "put" o = EventPutMethodInfo
    ResolveEventMethod "triggersContextMenu" o = EventTriggersContextMenuMethodInfo
    ResolveEventMethod "getAxis" o = EventGetAxisMethodInfo
    ResolveEventMethod "getButton" o = EventGetButtonMethodInfo
    ResolveEventMethod "getClickCount" o = EventGetClickCountMethodInfo
    ResolveEventMethod "getCoords" o = EventGetCoordsMethodInfo
    ResolveEventMethod "getDevice" o = EventGetDeviceMethodInfo
    ResolveEventMethod "getEventSequence" o = EventGetEventSequenceMethodInfo
    ResolveEventMethod "getEventType" o = EventGetEventTypeMethodInfo
    ResolveEventMethod "getKeycode" o = EventGetKeycodeMethodInfo
    ResolveEventMethod "getKeyval" o = EventGetKeyvalMethodInfo
    ResolveEventMethod "getRootCoords" o = EventGetRootCoordsMethodInfo
    ResolveEventMethod "getScreen" o = EventGetScreenMethodInfo
    ResolveEventMethod "getScrollDeltas" o = EventGetScrollDeltasMethodInfo
    ResolveEventMethod "getScrollDirection" o = EventGetScrollDirectionMethodInfo
    ResolveEventMethod "getSourceDevice" o = EventGetSourceDeviceMethodInfo
    ResolveEventMethod "getState" o = EventGetStateMethodInfo
    ResolveEventMethod "getTime" o = EventGetTimeMethodInfo
    ResolveEventMethod "getWindow" o = EventGetWindowMethodInfo
    ResolveEventMethod "setDevice" o = EventSetDeviceMethodInfo
    ResolveEventMethod "setScreen" o = EventSetScreenMethodInfo
    ResolveEventMethod "setSourceDevice" o = EventSetSourceDeviceMethodInfo
    ResolveEventMethod l o = MethodResolutionFailed l o

instance (info ~ ResolveEventMethod t Event, MethodInfo info Event p) => IsLabelProxy t (Event -> p) where
    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveEventMethod t Event, MethodInfo info Event p) => IsLabel t (Event -> p) where
    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
#endif