    {-# LINE 1 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE EmptyDataDecls #-}

    {-# LINE 4 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    {-# LANGUAGE FlexibleContexts #-}

    {-# LINE 6 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    -- -*-haskell-*-

    --  GIMP Toolkit (GTK) GDK Event information in a Monad
    --
    --  Author : Axel Simon
    --
    --  Created 12 October 2008
    --
    --  Copyright (C) 2008 Axel Simon
    --
    --  This library is free software; you can redistribute it and/or
    --  modify it under the terms of the GNU Lesser General Public
    --  License as published by the Free Software Foundation; either
    --  version 2.1 of the License, or (at your option) any later version.
    --
    --  This library is distributed in the hope that it will be useful,
    --  but WITHOUT ANY WARRANTY; without even the implied warranty of
    --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    --  Lesser General Public License for more details.
    --
    -- #prune

    -- |
    -- Maintainer  : gtk2hs-users\@lists.sourceforge.net
    -- Stability   : provisional
    -- Portability : portable (depends on GHC)
    --
    -- Types and accessors to examine information in events.
    --
    module Graphics.UI.Gtk.Gdk.EventM (
    -- * Detail
    --
    -- | This modules provides a monad that encapsulates the information in an
    --   event.
    --
    --   The events a widget can receive are defined in
    --   "Graphics.UI.Gtk.Abstract.Widget#7". Every event carries additional
    --   information which is accessible through functions in the 'EventM' monad.
    --   For instance, every event is associated with a
    --   'Graphics.UI.Gtk.Gdk.DrawWindow.DrawWindow' which is accessed using the
    --   'eventWindow' accessor function. Other information is only available in
    --   one specific event. For example, the
    --   area that has to be redrawn, accessed by 'eventArea' is only available in
    --   the 'Graphics.UI.Gtk.Abstract.Widget.exposeEvent'. Indeed, you can only
    --   call 'eventArea' if the first type parameter of 'EventM' is the phantom
    --   type 'EExpose'. (A phantom type is a type for which no values exist and
    --   which is only used to enforce certain constraints on the usage of
    --   functions such as 'eventArea'.) Some information is available in several
    --   but not all events. In order to express these constraints the module
    --   defines type classes whose names start with @Has...@ but which are not
    --   exported, implying that no new instance can be created. (They could be
    --   called phantom type classes.) For instance, the mouse pointer coordinates
    --   can be retrieved using the function 'eventCoordinates' which requires
    --   that the first type parameter of 'EventM' is in the class
    --   'HasCoordinates'. The module supplies instance of class 'HasCoordinates'
    --   for the types 'EButton', 'ECrossing', 'EMotion' and 'EScroll'. Thus for
    --   all events that require an 'EventM' action with one of the types above,
    --   the accessor function 'eventCoordinates' may be used.
    --
    --   Note that an event handler must always returns @True@ if the event
    --   was handled or @False@ if the event should be dealt with by another
    --   event handler. For instance, a handler for a key press should return
    --   @False@ if the pressed key is not one of those that the widget reacts
    --   to. In this case the event is passed to the parent widgets. This
    --   ensures that pressing, say, @Alt-F@ opens the file menu even if the
    --   current input focus is in a text entry widget. In order to facilitate
    --   writing handlers that may abort handling an event, this module provides
    --   the function 'tryEvent'. This function catches pattern match exceptions
    --   and returns @False@. If the signal successfully runs to its end, it
    --   returns @True@. A typical use is as follows:
    --
    --   > widget `on` keyPressEvent $ tryEvent $ do
    --   >   [Control] <- eventModifier
    --   >   "Return" <- eventKeyName
    --   >   liftIO $ putStrLn "Ctrl-Return pressed"
    --
    --   The rationale is that the action will throw an exception if the
    --   two event functions 'eventModifier' and 'eventKeyName' return something
    --   else than what is stated in
    --   the pattern. When no exception is thrown, execution continues to
    --   the last statement where the event is processed, here we merely
    --   print a message. Note that the return
    --   value of this statement must be @()@ since 'tryEvent' always
    --   assumes that the
    --   function handled the event if no exception is thrown. A handler
    --   wrapped by 'tryEvent' can also indicate that it cannot handle the
    --   given event by calling 'stopEvent'.
    --
    --   Finally, not that the 'EventM' monad wraps the @IO@ monad. As such
    --   you can (and usually have to) use @liftIO@ to execute @IO@ functions.
    --

    -- * Classes

      HasCoordinates,
      HasRootCoordinates,
      HasModifier,
      HasTime,

    -- * Event monad and type tags
      EventM,
      EAny,
      EKey,
      EButton,
      EScroll,
      EMotion,
      EExpose,
      EVisibility,
      ECrossing,
      EFocus,
      EConfigure,
      EProperty,
      EProximity,
      EWindowState,

    {-# LINE 124 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      EOwnerChange,

    {-# LINE 126 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 127 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      EGrabBroken,

    {-# LINE 129 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- * Accessor functions for event information
      eventWindow,
      eventSent,
      eventCoordinates,
      eventRootCoordinates,
      eventModifier,
      eventModifierAll,
      eventModifierMouse,
      eventTime,
      eventKeyVal,
      eventKeyName,
      eventHardwareKeycode,
      eventKeyboardGroup,
      MouseButton(..),
      eventButton,
      Click(..),
      eventClick,
      ScrollDirection(..),
      eventScrollDirection,
      eventIsHint,

    {-# LINE 151 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      eventRequestMotions,

    {-# LINE 153 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      eventArea,

    {-# LINE 157 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      VisibilityState(..),
      eventVisibilityState,
      CrossingMode(..),
      eventCrossingMode,
      NotifyType(..),
      eventNotifyType,
      eventCrossingFocus,
      eventFocusIn,
      eventPosition,
      eventSize,
      eventProperty,
      WindowState(..),
      eventWindowStateChanged,
      eventWindowState,

    {-# LINE 172 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      OwnerChange(..),
      eventChangeReason,
      eventSelection,
      eventSelectionTime,

    {-# LINE 177 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 178 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      eventKeyboardGrab,
      eventImplicit,
      eventGrabWindow,

    {-# LINE 182 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- * Auxiliary Definitions
      Modifier(..),         -- a mask of control keys
      TimeStamp,
      currentTime,
      tryEvent,
      stopEvent,
      ) where

    import Prelude hiding (catch)
    import System.Glib.FFI
    import System.Glib.UTFString
    import System.Glib.Flags
    import System.Glib.GObject ( makeNewGObject )
    import Graphics.UI.Gtk.Gdk.Keys         (KeyVal, KeyCode, keyName)

    {-# LINE 200 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    import Graphics.UI.Gtk.Gdk.Enums        (Modifier(..), VisibilityState(..),
      CrossingMode(..), NotifyType(..), WindowState(..), ScrollDirection(..),

    {-# LINE 203 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      OwnerChange(..)

    {-# LINE 205 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      )
    import Graphics.UI.Gtk.General.Enums    (MouseButton(..), Click(..))
    import Graphics.UI.Gtk.General.Structs  (Rectangle(..))
    import Graphics.UI.Gtk.General.DNDTypes (Atom(..), SelectionTag)
    import Graphics.UI.Gtk.Types ( DrawWindow, mkDrawWindow )

    import Data.List (isPrefixOf)
    import Control.Monad.Reader ( ReaderT, ask, runReaderT )
    import Control.Monad.Trans ( liftIO )
    import Control.Monad ( liftM )

    {-# LINE 216 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    import Control.Exception ( Handler(..)
                             , PatternMatchFail(..)
                             , catches, throw )
    import System.IO.Error (isUserError, ioeGetErrorString)

    {-# LINE 224 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | A monad providing access to data in an event.
    --
    type EventM t = ReaderT (Ptr t) IO

    -- | A tag for events that do not carry any event-specific information.
    data EAny

    -- | A tag for /key/ events.
    data EKey

    -- | A tag for /Button/ events.
    data EButton

    -- | A tag for /Scroll/ events.
    data EScroll

    -- | A tag for /Motion/ events.
    data EMotion

    -- | A tag for /Expose/ events.
    data EExpose

    -- | A tag for /Visibility/ events.
    data EVisibility

    -- | A tag for /Crossing/ events.
    data ECrossing

    -- | A tag for /Focus/ events.
    data EFocus

    -- | A tag for /Configure/ events.
    data EConfigure

    -- | A tag for /Property/ events.
    data EProperty

    -- | A tag for /Proximity/ events.
    data EProximity

    -- | A tag for /WindowState/ event.
    data EWindowState

    {-# LINE 270 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    -- | A tag for /OwnerChange/ events.
    data EOwnerChange

    {-# LINE 273 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 276 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    -- | A tag for /GrabBroken/ events.
    data EGrabBroken

    {-# LINE 279 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Retrieve the 'Graphics.UI.Gtk.Gdk.DrawWindow.DrawWindow' that this
    --   event relates to.
    eventWindow :: EventM any DrawWindow
    eventWindow :: forall any. EventM any DrawWindow
    eventWindow = do
      ptr <- ReaderT (Ptr any) IO (Ptr any)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ makeNewGObject mkDrawWindow ((\Ptr any
    hsc_ptr -> Ptr any -> Int -> IO (Ptr DrawWindow)
    forall b. Ptr b -> Int -> IO (Ptr DrawWindow)
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr any
    hsc_ptr Int
    8) ptr)
    {-# LINE 286 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query if this event was sent sent explicitly by the application
    --   (rather than being generated by human interaction).
    eventSent :: EventM any Bool
    eventSent :: forall any. EventM any Bool
    eventSent = do
      ptr <- ReaderT (Ptr any) IO (Ptr any)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ (\Ptr any
    hsc_ptr -> Ptr any -> Int -> IO Bool
    forall b. Ptr b -> Int -> IO Bool
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr any
    hsc_ptr Int
    16) ptr
    {-# LINE 293 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    class HasCoordinates a
    instance HasCoordinates EButton
    instance HasCoordinates EScroll
    instance HasCoordinates EMotion
    instance HasCoordinates ECrossing

    -- | Retrieve the @(x,y)@ coordinates of the mouse.
    eventCoordinates :: HasCoordinates t => EventM t (Double, Double)
    eventCoordinates :: forall t. HasCoordinates t => EventM t (Double, Double)
    eventCoordinates = do
      ptr <- ReaderT (Ptr t) IO (Ptr t)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ do
        (ty :: Int32) <- peek (castPtr ptr)
    {-# LINE 306 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
        if ty `elem` [ 4,
    {-# LINE 307 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       5,
    {-# LINE 308 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       6,
    {-# LINE 309 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       7] then do
    {-# LINE 310 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 311 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 312 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else if ty `elem` [ 31 ] then do
    {-# LINE 314 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 315 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 316 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else if ty `elem` [ 3 ] then do
    {-# LINE 318 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 319 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 320 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else if ty `elem` [ 10,
    {-# LINE 322 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                              11] then do
    {-# LINE 323 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 40) ptr
    {-# LINE 324 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 48) ptr
    {-# LINE 325 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else error ("eventCoordinates: none for event type "++show ty)

    class HasRootCoordinates a
    instance HasRootCoordinates EButton
    instance HasRootCoordinates EScroll
    instance HasRootCoordinates EMotion
    instance HasRootCoordinates ECrossing

    -- | Retrieve the @(x,y)@ coordinates of the mouse relative to the
    --   root (origin) of the screen.
    eventRootCoordinates :: HasRootCoordinates t => EventM t (Double, Double)
    eventRootCoordinates :: forall t. HasRootCoordinates t => EventM t (Double, Double)
    eventRootCoordinates = do
      ptr <- ReaderT (Ptr t) IO (Ptr t)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ do
        (ty :: Int32) <- peek (castPtr ptr)
    {-# LINE 341 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
        if ty `elem` [ 4,
    {-# LINE 342 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       5,
    {-# LINE 343 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       6,
    {-# LINE 344 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       7] then do
    {-# LINE 345 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 64) ptr
    {-# LINE 346 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 72) ptr
    {-# LINE 347 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else if ty `elem` [ 31 ] then do
    {-# LINE 349 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 56) ptr
    {-# LINE 350 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 64) ptr
    {-# LINE 351 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else if ty `elem` [ 3 ] then do
    {-# LINE 353 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 64) ptr
    {-# LINE 354 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 72) ptr
    {-# LINE 355 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else if ty `elem` [ 10,
    {-# LINE 357 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                              11] then do
    {-# LINE 358 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (x :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 56) ptr
    {-# LINE 359 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (y :: Double) <- (\hsc_ptr -> peekByteOff hsc_ptr 64) ptr
    {-# LINE 360 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (realToFrac x, realToFrac y)
          else error ("eventRootCoordinates: none for event type "++show ty)

    class HasModifier a
    instance HasModifier EKey
    instance HasModifier EButton
    instance HasModifier EScroll
    instance HasModifier EMotion
    instance HasModifier ECrossing

    -- | Query the modifier keys that were depressed when the event happened.
    --   Sticky modifiers such as CapsLock are omitted in the return value.
    --   Use 'eventModifierAll' your application requires all modifiers.
    --   Use 'eventModifierMouse' if you just need the mouse buttons.
    --
    eventModifier :: HasModifier t => EventM t [Modifier]
    eventModifier :: forall t. HasModifier t => EventM t [Modifier]
    eventModifier = Word32 -> ReaderT (Ptr t) IO [Modifier]
    forall {m :: * -> *} {b} {a}.
    (MonadReader (Ptr b) m, MonadIO m, Flags a) =>
    Word32 -> m [a]
    eM Word32
    defModMask

    -- | Query the modifier keys that were depressed when the event happened.
    --   The result includes sticky modifiers such as CapsLock. Normally,
    --   'eventModifier' is more appropriate in applications.
    --
    eventModifierAll :: HasModifier t => EventM t [Modifier]
    eventModifierAll :: forall t. HasModifier t => EventM t [Modifier]
    eventModifierAll = Word32 -> ReaderT (Ptr t) IO [Modifier]
    forall {m :: * -> *} {b} {a}.
    (MonadReader (Ptr b) m, MonadIO m, Flags a) =>
    Word32 -> m [a]
    eM Word32
    allModMask

    -- | Query the mouse buttons that were depressed when the event happened.
    --
    eventModifierMouse :: HasModifier t => EventM t [Modifier]
    eventModifierMouse :: forall t. HasModifier t => EventM t [Modifier]
    eventModifierMouse = Word32 -> ReaderT (Ptr t) IO [Modifier]
    forall {m :: * -> *} {b} {a}.
    (MonadReader (Ptr b) m, MonadIO m, Flags a) =>
    Word32 -> m [a]
    eM Word32
    mouseModMask

    allModMask :: Word32
    allModMask = -Word32
    1

    foreign import ccall safe "gtk_accelerator_get_default_mod_mask"
      defModMask :: Word32
    {-# LINE 394 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    mouseModMask :: Word32
    mouseModMask = Word32
    256
    {-# LINE 396 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
               Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    512
    {-# LINE 397 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
               Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    1024
    {-# LINE 398 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
               Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    2048
    {-# LINE 399 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
               Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    4096
    {-# LINE 400 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    eM :: Word32 -> m [a]
    eM Word32
    mask = do
      ptr <- m (Ptr b)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ do
        (ty :: Int32) <- peek (castPtr ptr)
    {-# LINE 405 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
        if ty `elem` [ 8,
    {-# LINE 406 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       9] then do
    {-# LINE 407 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (modif ::Word32)    <- (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 408 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (toFlags (fromIntegral (modif .&. mask)))
          else if ty `elem` [ 4,
    {-# LINE 410 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       5,
    {-# LINE 411 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       6,
    {-# LINE 412 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       7] then do
    {-# LINE 413 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (modif ::Word32)    <- (\hsc_ptr -> peekByteOff hsc_ptr 48) ptr
    {-# LINE 414 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (toFlags (fromIntegral (modif .&. mask)))
          else if ty `elem` [ 31 ] then do
    {-# LINE 416 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (modif ::Word32)    <- (\hsc_ptr -> peekByteOff hsc_ptr 40) ptr
    {-# LINE 417 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (toFlags (fromIntegral (modif .&. mask)))
          else if ty `elem` [ 3 ] then do
    {-# LINE 419 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (modif ::Word32)    <- (\hsc_ptr -> peekByteOff hsc_ptr 48) ptr
    {-# LINE 420 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (toFlags (fromIntegral (modif .&. mask)))
          else if ty `elem` [ 10,
    {-# LINE 422 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                              11] then do
    {-# LINE 423 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (modif ::Word32)    <- (\hsc_ptr -> peekByteOff hsc_ptr 84) ptr
    {-# LINE 424 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (toFlags (fromIntegral (modif .&. mask)))
          else error ("eventModifiers: none for event type "++show ty)

    class HasTime a
    instance HasTime EKey
    instance HasTime EButton
    instance HasTime EScroll
    instance HasTime EMotion
    instance HasTime ECrossing
    instance HasTime EProperty
    instance HasTime EProximity

    {-# LINE 436 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    instance HasTime EOwnerChange

    {-# LINE 438 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | The time (in milliseconds) when an event happened. This is used mostly
    -- for ordering events and responses to events.
    --
    type TimeStamp = Word32
    -- TODO: make this a newtype

    -- | Represents the current time, and can be used anywhere a time is expected.
    currentTime :: TimeStamp
    currentTime :: Word32
    currentTime = Word32
    0
    {-# LINE 448 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query the time when the event occurred.
    eventTime :: HasTime t => EventM t TimeStamp
    eventTime :: forall t. HasTime t => EventM t Word32
    eventTime = do
      ptr <- ReaderT (Ptr t) IO (Ptr t)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ do
        (ty :: Int32) <- peek (castPtr ptr)
    {-# LINE 455 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
        if ty `elem` [ 8,
    {-# LINE 456 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       9] then do
    {-# LINE 457 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 20) ptr
    {-# LINE 458 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)
          else if ty `elem` [ 4,
    {-# LINE 460 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       5,
    {-# LINE 461 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       6,
    {-# LINE 462 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                       7] then do
    {-# LINE 463 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 20) ptr
    {-# LINE 464 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)
          else if ty `elem` [ 31 ] then do
    {-# LINE 466 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 20) ptr
    {-# LINE 467 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)
          else if ty `elem` [ 3 ] then do
    {-# LINE 469 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 20) ptr
    {-# LINE 470 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)
          else if ty `elem` [ 10,
    {-# LINE 472 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                              11] then do
    {-# LINE 473 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 474 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)
          else if ty `elem` [ 16 ] then do
    {-# LINE 476 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 477 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)
          else if ty `elem` [ 20,
    {-# LINE 479 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
                              21] then do
    {-# LINE 480 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 20) ptr
    {-# LINE 481 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)

    {-# LINE 483 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
          else if ty `elem` [ 34 ] then do
    {-# LINE 484 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            (time :: Word32) <- (\hsc_ptr -> peekByteOff hsc_ptr 48) ptr
    {-# LINE 485 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
            return (fromIntegral time)

    {-# LINE 487 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
          else error ("eventModifiers: none for event type "++show ty)

    -- | The key value. See 'Graphics.UI.Gtk.Gdk.Keys.KeyVal'.
    eventKeyVal :: EventM EKey KeyVal
    eventKeyVal :: EventM EKey Word32
    eventKeyVal = ReaderT (Ptr EKey) IO (Ptr EKey)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EKey) IO (Ptr EKey)
    -> (Ptr EKey -> EventM EKey Word32) -> EventM EKey Word32
    forall a b.
    ReaderT (Ptr EKey) IO a
    -> (a -> ReaderT (Ptr EKey) IO b) -> ReaderT (Ptr EKey) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EKey
    ptr -> IO Word32 -> EventM EKey Word32
    forall a. IO a -> ReaderT (Ptr EKey) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> EventM EKey Word32)
    -> IO Word32 -> EventM EKey Word32
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> Word32) -> IO Word32 -> IO Word32
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Word32 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral
      ((\Ptr EKey
    hsc_ptr -> Ptr EKey -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EKey
    hsc_ptr Int
    28) Ptr EKey
    ptr :: IO Word32)
    {-# LINE 493 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | The key value as a string. See 'Graphics.UI.Gtk.Gdk.Keys.KeyVal'.
    eventKeyName :: EventM EKey DefaultGlibString
    eventKeyName :: EventM EKey DefaultGlibString
    eventKeyName = (Word32 -> DefaultGlibString)
    -> EventM EKey Word32 -> EventM EKey DefaultGlibString
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Word32 -> DefaultGlibString
    keyName (EventM EKey Word32 -> EventM EKey DefaultGlibString)
    -> EventM EKey Word32 -> EventM EKey DefaultGlibString
    forall a b. (a -> b) -> a -> b
    $ EventM EKey Word32
    eventKeyVal

    -- | The hardware key code.
    eventHardwareKeycode :: EventM EKey KeyCode
    eventHardwareKeycode :: EventM EKey Word16
    eventHardwareKeycode = ReaderT (Ptr EKey) IO (Ptr EKey)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EKey) IO (Ptr EKey)
    -> (Ptr EKey -> EventM EKey Word16) -> EventM EKey Word16
    forall a b.
    ReaderT (Ptr EKey) IO a
    -> (a -> ReaderT (Ptr EKey) IO b) -> ReaderT (Ptr EKey) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EKey
    ptr -> IO Word16 -> EventM EKey Word16
    forall a. IO a -> ReaderT (Ptr EKey) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word16 -> EventM EKey Word16)
    -> IO Word16 -> EventM EKey Word16
    forall a b. (a -> b) -> a -> b
    $ (Word16 -> Word16) -> IO Word16 -> IO Word16
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Word16 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral
      ((\Ptr EKey
    hsc_ptr -> Ptr EKey -> Int -> IO Word16
    forall b. Ptr b -> Int -> IO Word16
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EKey
    hsc_ptr Int
    48) Ptr EKey
    ptr :: IO Word16)
    {-# LINE 502 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | The keyboard group.
    eventKeyboardGroup :: EventM EKey Word8
    eventKeyboardGroup :: EventM EKey Word8
    eventKeyboardGroup = ReaderT (Ptr EKey) IO (Ptr EKey)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EKey) IO (Ptr EKey)
    -> (Ptr EKey -> EventM EKey Word8) -> EventM EKey Word8
    forall a b.
    ReaderT (Ptr EKey) IO a
    -> (a -> ReaderT (Ptr EKey) IO b) -> ReaderT (Ptr EKey) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EKey
    ptr -> IO Word8 -> EventM EKey Word8
    forall a. IO a -> ReaderT (Ptr EKey) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word8 -> EventM EKey Word8) -> IO Word8 -> EventM EKey Word8
    forall a b. (a -> b) -> a -> b
    $ (Word8 -> Word8) -> IO Word8 -> IO Word8
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Word8 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral
      ((\Ptr EKey
    hsc_ptr -> Ptr EKey -> Int -> IO Word8
    forall b. Ptr b -> Int -> IO Word8
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EKey
    hsc_ptr Int
    50) Ptr EKey
    ptr :: IO Word8)
    {-# LINE 507 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query the mouse buttons.
    eventButton :: EventM EButton MouseButton
    eventButton :: EventM EButton MouseButton
    eventButton = ReaderT (Ptr EButton) IO (Ptr EButton)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EButton) IO (Ptr EButton)
    -> (Ptr EButton -> EventM EButton MouseButton)
    -> EventM EButton MouseButton
    forall a b.
    ReaderT (Ptr EButton) IO a
    -> (a -> ReaderT (Ptr EButton) IO b) -> ReaderT (Ptr EButton) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EButton
    ptr -> IO MouseButton -> EventM EButton MouseButton
    forall a. IO a -> ReaderT (Ptr EButton) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO MouseButton -> EventM EButton MouseButton)
    -> IO MouseButton -> EventM EButton MouseButton
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> MouseButton) -> IO Word32 -> IO MouseButton
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> MouseButton
    forall a. Enum a => Int -> a
    toEnum (Int -> MouseButton) -> (Word32 -> Int) -> Word32 -> MouseButton
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr EButton
    hsc_ptr -> Ptr EButton -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EButton
    hsc_ptr Int
    52) Ptr EButton
    ptr :: IO Word32)
    {-# LINE 512 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    --- | Query the mouse click.
    eventClick :: EventM EButton Click
    eventClick :: EventM EButton Click
    eventClick = do
      ptr <- ReaderT (Ptr EButton) IO (Ptr EButton)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ do
        (ty :: Int32) <- peek (castPtr ptr)
    {-# LINE 519 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
        case ty of
          4 -> return SingleClick
    {-# LINE 521 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
          5 -> return DoubleClick
    {-# LINE 522 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
          6 -> return TripleClick
    {-# LINE 523 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
          7 -> return ReleaseClick
    {-# LINE 524 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
          _ -> error ("eventClick: non for event type "++show ty)

    -- | Query the direction of scrolling.
    eventScrollDirection :: EventM EScroll ScrollDirection
    eventScrollDirection :: EventM EScroll ScrollDirection
    eventScrollDirection = ReaderT (Ptr EScroll) IO (Ptr EScroll)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EScroll) IO (Ptr EScroll)
    -> (Ptr EScroll -> EventM EScroll ScrollDirection)
    -> EventM EScroll ScrollDirection
    forall a b.
    ReaderT (Ptr EScroll) IO a
    -> (a -> ReaderT (Ptr EScroll) IO b) -> ReaderT (Ptr EScroll) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EScroll
    ptr -> IO ScrollDirection -> EventM EScroll ScrollDirection
    forall a. IO a -> ReaderT (Ptr EScroll) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ScrollDirection -> EventM EScroll ScrollDirection)
    -> IO ScrollDirection -> EventM EScroll ScrollDirection
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> ScrollDirection) -> IO Word32 -> IO ScrollDirection
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> ScrollDirection
    forall a. Enum a => Int -> a
    toEnum (Int -> ScrollDirection)
    -> (Word32 -> Int) -> Word32 -> ScrollDirection
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr EScroll
    hsc_ptr -> Ptr EScroll -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EScroll
    hsc_ptr Int
    44) Ptr EScroll
    ptr :: IO Word32)
    {-# LINE 530 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Check if the motion event is only a hint rather than the full mouse
    --   movement information.
    eventIsHint :: EventM EMotion Bool
    eventIsHint :: EventM EMotion Bool
    eventIsHint = ReaderT (Ptr EMotion) IO (Ptr EMotion)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EMotion) IO (Ptr EMotion)
    -> (Ptr EMotion -> EventM EMotion Bool) -> EventM EMotion Bool
    forall a b.
    ReaderT (Ptr EMotion) IO a
    -> (a -> ReaderT (Ptr EMotion) IO b) -> ReaderT (Ptr EMotion) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EMotion
    ptr -> IO Bool -> EventM EMotion Bool
    forall a. IO a -> ReaderT (Ptr EMotion) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> EventM EMotion Bool) -> IO Bool -> EventM EMotion Bool
    forall a b. (a -> b) -> a -> b
    $ (Int16 -> Bool) -> IO Int16 -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Int16 -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool
      ((\Ptr EMotion
    hsc_ptr -> Ptr EMotion -> Int -> IO Int16
    forall b. Ptr b -> Int -> IO Int16
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EMotion
    hsc_ptr Int
    52) Ptr EMotion
    ptr :: IO Int16)
    {-# LINE 536 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 538 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    -- | Request more motion notifies if this event is a motion notify hint event.
    --
    -- This action should be used instead of 'drawWindowGetPointer' to request
    -- further motion notifies, because it also works for extension events where
    -- motion notifies are provided for devices other than the core pointer.
    --
    -- Coordinate extraction, processing and requesting more motion events from a
    -- 'motionNotifyEvent' usually works like this:
    --
    -- > on widget motionNotifyEvent $ do
    -- >   (x, y) <- eventCoordinates
    -- >   -- handle the x,y motion:
    -- >   ...
    -- >   -- finally, notify that we are ready to get more motion events:
    -- >   eventRequestMotions
    --
    eventRequestMotions :: EventM EMotion ()
    eventRequestMotions :: EventM EMotion ()
    eventRequestMotions = ReaderT (Ptr EMotion) IO (Ptr EMotion)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EMotion) IO (Ptr EMotion)
    -> (Ptr EMotion -> EventM EMotion ()) -> EventM EMotion ()
    forall a b.
    ReaderT (Ptr EMotion) IO a
    -> (a -> ReaderT (Ptr EMotion) IO b) -> ReaderT (Ptr EMotion) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EMotion
    ptr -> IO () -> EventM EMotion ()
    forall a. IO a -> ReaderT (Ptr EMotion) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> EventM EMotion ()) -> IO () -> EventM EMotion ()
    forall a b. (a -> b) -> a -> b
    $
      Ptr EMotion -> IO ()
    gdk_event_request_motions Ptr EMotion
    ptr

    foreign import ccall "gdk_event_request_motions"
      gdk_event_request_motions :: Ptr EMotion -> IO ()

    {-# LINE 561 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query a bounding box of the region that needs to be updated.
    eventArea :: EventM EExpose Rectangle
    eventArea :: EventM EExpose Rectangle
    eventArea = ReaderT (Ptr EExpose) IO (Ptr EExpose)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EExpose) IO (Ptr EExpose)
    -> (Ptr EExpose -> EventM EExpose Rectangle)
    -> EventM EExpose Rectangle
    forall a b.
    ReaderT (Ptr EExpose) IO a
    -> (a -> ReaderT (Ptr EExpose) IO b) -> ReaderT (Ptr EExpose) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EExpose
    ptr -> IO Rectangle -> EventM EExpose Rectangle
    forall a. IO a -> ReaderT (Ptr EExpose) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Rectangle -> EventM EExpose Rectangle)
    -> IO Rectangle -> EventM EExpose Rectangle
    forall a b. (a -> b) -> a -> b
    $
      ((\Ptr EExpose
    hsc_ptr -> Ptr EExpose -> Int -> IO Rectangle
    forall b. Ptr b -> Int -> IO Rectangle
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EExpose
    hsc_ptr Int
    20) Ptr EExpose
    ptr :: IO Rectangle)
    {-# LINE 566 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 579 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Get the visibility status of a window.
    eventVisibilityState :: EventM EVisibility VisibilityState
    eventVisibilityState :: EventM EVisibility VisibilityState
    eventVisibilityState = ReaderT (Ptr EVisibility) IO (Ptr EVisibility)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EVisibility) IO (Ptr EVisibility)
    -> (Ptr EVisibility -> EventM EVisibility VisibilityState)
    -> EventM EVisibility VisibilityState
    forall a b.
    ReaderT (Ptr EVisibility) IO a
    -> (a -> ReaderT (Ptr EVisibility) IO b)
    -> ReaderT (Ptr EVisibility) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EVisibility
    ptr -> IO VisibilityState -> EventM EVisibility VisibilityState
    forall a. IO a -> ReaderT (Ptr EVisibility) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO VisibilityState -> EventM EVisibility VisibilityState)
    -> IO VisibilityState -> EventM EVisibility VisibilityState
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> VisibilityState) -> IO Word32 -> IO VisibilityState
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> VisibilityState
    forall a. Enum a => Int -> a
    toEnum (Int -> VisibilityState)
    -> (Word32 -> Int) -> Word32 -> VisibilityState
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr EVisibility
    hsc_ptr -> Ptr EVisibility -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EVisibility
    hsc_ptr Int
    20) Ptr EVisibility
    ptr :: IO Word32)
    {-# LINE 584 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Get the mode of the mouse cursor crossing a window.
    eventCrossingMode :: EventM ECrossing CrossingMode
    eventCrossingMode :: EventM ECrossing CrossingMode
    eventCrossingMode = ReaderT (Ptr ECrossing) IO (Ptr ECrossing)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr ECrossing) IO (Ptr ECrossing)
    -> (Ptr ECrossing -> EventM ECrossing CrossingMode)
    -> EventM ECrossing CrossingMode
    forall a b.
    ReaderT (Ptr ECrossing) IO a
    -> (a -> ReaderT (Ptr ECrossing) IO b)
    -> ReaderT (Ptr ECrossing) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr ECrossing
    ptr -> IO CrossingMode -> EventM ECrossing CrossingMode
    forall a. IO a -> ReaderT (Ptr ECrossing) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CrossingMode -> EventM ECrossing CrossingMode)
    -> IO CrossingMode -> EventM ECrossing CrossingMode
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> CrossingMode) -> IO Word32 -> IO CrossingMode
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> CrossingMode
    forall a. Enum a => Int -> a
    toEnum (Int -> CrossingMode) -> (Word32 -> Int) -> Word32 -> CrossingMode
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr ECrossing
    hsc_ptr -> Ptr ECrossing -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr ECrossing
    hsc_ptr Int
    72) Ptr ECrossing
    ptr :: IO Word32)
    {-# LINE 589 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Get the notify type of the mouse cursor crossing a window.
    eventNotifyType :: EventM ECrossing NotifyType
    eventNotifyType :: EventM ECrossing NotifyType
    eventNotifyType = ReaderT (Ptr ECrossing) IO (Ptr ECrossing)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr ECrossing) IO (Ptr ECrossing)
    -> (Ptr ECrossing -> EventM ECrossing NotifyType)
    -> EventM ECrossing NotifyType
    forall a b.
    ReaderT (Ptr ECrossing) IO a
    -> (a -> ReaderT (Ptr ECrossing) IO b)
    -> ReaderT (Ptr ECrossing) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr ECrossing
    ptr -> IO NotifyType -> EventM ECrossing NotifyType
    forall a. IO a -> ReaderT (Ptr ECrossing) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO NotifyType -> EventM ECrossing NotifyType)
    -> IO NotifyType -> EventM ECrossing NotifyType
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> NotifyType) -> IO Word32 -> IO NotifyType
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> NotifyType
    forall a. Enum a => Int -> a
    toEnum (Int -> NotifyType) -> (Word32 -> Int) -> Word32 -> NotifyType
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr ECrossing
    hsc_ptr -> Ptr ECrossing -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr ECrossing
    hsc_ptr Int
    76) Ptr ECrossing
    ptr :: IO Word32)
    {-# LINE 594 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query if the window has the focus or is an inferior window.
    eventCrossingFocus :: EventM ECrossing Bool
    eventCrossingFocus :: EventM ECrossing Bool
    eventCrossingFocus = ReaderT (Ptr ECrossing) IO (Ptr ECrossing)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr ECrossing) IO (Ptr ECrossing)
    -> (Ptr ECrossing -> EventM ECrossing Bool)
    -> EventM ECrossing Bool
    forall a b.
    ReaderT (Ptr ECrossing) IO a
    -> (a -> ReaderT (Ptr ECrossing) IO b)
    -> ReaderT (Ptr ECrossing) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr ECrossing
    ptr -> IO Bool -> EventM ECrossing Bool
    forall a. IO a -> ReaderT (Ptr ECrossing) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> EventM ECrossing Bool)
    -> IO Bool -> EventM ECrossing Bool
    forall a b. (a -> b) -> a -> b
    $ (Int32 -> Bool) -> IO Int32 -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Int32 -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool
      ((\Ptr ECrossing
    hsc_ptr -> Ptr ECrossing -> Int -> IO Int32
    forall b. Ptr b -> Int -> IO Int32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr ECrossing
    hsc_ptr Int
    80) Ptr ECrossing
    ptr :: IO Int32)
    {-# LINE 599 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query if a window gained focus (@True@) or lost the focus (@False@).
    eventFocusIn :: EventM EFocus Bool
    eventFocusIn :: EventM EFocus Bool
    eventFocusIn = ReaderT (Ptr EFocus) IO (Ptr EFocus)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EFocus) IO (Ptr EFocus)
    -> (Ptr EFocus -> EventM EFocus Bool) -> EventM EFocus Bool
    forall a b.
    ReaderT (Ptr EFocus) IO a
    -> (a -> ReaderT (Ptr EFocus) IO b) -> ReaderT (Ptr EFocus) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EFocus
    ptr -> IO Bool -> EventM EFocus Bool
    forall a. IO a -> ReaderT (Ptr EFocus) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> EventM EFocus Bool) -> IO Bool -> EventM EFocus Bool
    forall a b. (a -> b) -> a -> b
    $ (Int16 -> Bool) -> IO Int16 -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Int16 -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool
      ((\Ptr EFocus
    hsc_ptr -> Ptr EFocus -> Int -> IO Int16
    forall b. Ptr b -> Int -> IO Int16
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EFocus
    hsc_ptr Int
    18) Ptr EFocus
    ptr :: IO Int16)
    {-# LINE 604 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Get the @(x,y)@ position of the window within the parent window.
    eventPosition :: EventM EConfigure (Int,Int)
    eventPosition :: EventM EConfigure (Int, Int)
    eventPosition = ReaderT (Ptr EConfigure) IO (Ptr EConfigure)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EConfigure) IO (Ptr EConfigure)
    -> (Ptr EConfigure -> EventM EConfigure (Int, Int))
    -> EventM EConfigure (Int, Int)
    forall a b.
    ReaderT (Ptr EConfigure) IO a
    -> (a -> ReaderT (Ptr EConfigure) IO b)
    -> ReaderT (Ptr EConfigure) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EConfigure
    ptr -> IO (Int, Int) -> EventM EConfigure (Int, Int)
    forall a. IO a -> ReaderT (Ptr EConfigure) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int, Int) -> EventM EConfigure (Int, Int))
    -> IO (Int, Int) -> EventM EConfigure (Int, Int)
    forall a b. (a -> b) -> a -> b
    $ do
      (x :: Int32)    <- (\Ptr EConfigure
    hsc_ptr -> Ptr EConfigure -> Int -> IO Int32
    forall b. Ptr b -> Int -> IO Int32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EConfigure
    hsc_ptr Int
    20) Ptr EConfigure
    ptr
    {-# LINE 609 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      (y :: Int32)    <- (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
    {-# LINE 610 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      return (fromIntegral x, fromIntegral y)

    -- | Get the new size of the window as @(width,height)@.
    eventSize :: EventM EConfigure (Int,Int)
    eventSize :: EventM EConfigure (Int, Int)
    eventSize = ReaderT (Ptr EConfigure) IO (Ptr EConfigure)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EConfigure) IO (Ptr EConfigure)
    -> (Ptr EConfigure -> EventM EConfigure (Int, Int))
    -> EventM EConfigure (Int, Int)
    forall a b.
    ReaderT (Ptr EConfigure) IO a
    -> (a -> ReaderT (Ptr EConfigure) IO b)
    -> ReaderT (Ptr EConfigure) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EConfigure
    ptr -> IO (Int, Int) -> EventM EConfigure (Int, Int)
    forall a. IO a -> ReaderT (Ptr EConfigure) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int, Int) -> EventM EConfigure (Int, Int))
    -> IO (Int, Int) -> EventM EConfigure (Int, Int)
    forall a b. (a -> b) -> a -> b
    $ do
      (x :: Int32)    <- (\Ptr EConfigure
    hsc_ptr -> Ptr EConfigure -> Int -> IO Int32
    forall b. Ptr b -> Int -> IO Int32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EConfigure
    hsc_ptr Int
    28) Ptr EConfigure
    ptr
    {-# LINE 616 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      (y :: Int32)    <- (\hsc_ptr -> peekByteOff hsc_ptr 32) ptr
    {-# LINE 617 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
      return (fromIntegral x, fromIntegral y)

    eventProperty :: EventM EProperty Atom
    eventProperty :: EventM EProperty Atom
    eventProperty = ReaderT (Ptr EProperty) IO (Ptr EProperty)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EProperty) IO (Ptr EProperty)
    -> (Ptr EProperty -> EventM EProperty Atom)
    -> EventM EProperty Atom
    forall a b.
    ReaderT (Ptr EProperty) IO a
    -> (a -> ReaderT (Ptr EProperty) IO b)
    -> ReaderT (Ptr EProperty) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EProperty
    ptr -> IO Atom -> EventM EProperty Atom
    forall a. IO a -> ReaderT (Ptr EProperty) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Atom -> EventM EProperty Atom)
    -> IO Atom -> EventM EProperty Atom
    forall a b. (a -> b) -> a -> b
    $ (Ptr () -> Atom) -> IO (Ptr ()) -> IO Atom
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Ptr () -> Atom
    Atom
      ((\Ptr EProperty
    hsc_ptr -> Ptr EProperty -> Int -> IO (Ptr ())
    forall b. Ptr b -> Int -> IO (Ptr ())
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EProperty
    hsc_ptr Int
    24) Ptr EProperty
    ptr :: IO (Ptr ()))
    {-# LINE 622 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query which window state bits have changed.
    eventWindowStateChanged :: EventM EWindowState [WindowState]
    eventWindowStateChanged :: EventM EWindowState [WindowState]
    eventWindowStateChanged = ReaderT (Ptr EWindowState) IO (Ptr EWindowState)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EWindowState) IO (Ptr EWindowState)
    -> (Ptr EWindowState -> EventM EWindowState [WindowState])
    -> EventM EWindowState [WindowState]
    forall a b.
    ReaderT (Ptr EWindowState) IO a
    -> (a -> ReaderT (Ptr EWindowState) IO b)
    -> ReaderT (Ptr EWindowState) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EWindowState
    ptr -> IO [WindowState] -> EventM EWindowState [WindowState]
    forall a. IO a -> ReaderT (Ptr EWindowState) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [WindowState] -> EventM EWindowState [WindowState])
    -> IO [WindowState] -> EventM EWindowState [WindowState]
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> [WindowState]) -> IO Word32 -> IO [WindowState]
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> [WindowState]
    forall a. Flags a => Int -> [a]
    toFlags (Int -> [WindowState])
    -> (Word32 -> Int) -> Word32 -> [WindowState]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr EWindowState
    hsc_ptr -> Ptr EWindowState -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EWindowState
    hsc_ptr Int
    20) Ptr EWindowState
    ptr :: IO Word32)
    {-# LINE 627 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query the new window state.
    eventWindowState :: EventM EWindowState [WindowState]
    eventWindowState :: EventM EWindowState [WindowState]
    eventWindowState = ReaderT (Ptr EWindowState) IO (Ptr EWindowState)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EWindowState) IO (Ptr EWindowState)
    -> (Ptr EWindowState -> EventM EWindowState [WindowState])
    -> EventM EWindowState [WindowState]
    forall a b.
    ReaderT (Ptr EWindowState) IO a
    -> (a -> ReaderT (Ptr EWindowState) IO b)
    -> ReaderT (Ptr EWindowState) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EWindowState
    ptr -> IO [WindowState] -> EventM EWindowState [WindowState]
    forall a. IO a -> ReaderT (Ptr EWindowState) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [WindowState] -> EventM EWindowState [WindowState])
    -> IO [WindowState] -> EventM EWindowState [WindowState]
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> [WindowState]) -> IO Word32 -> IO [WindowState]
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> [WindowState]
    forall a. Flags a => Int -> [a]
    toFlags (Int -> [WindowState])
    -> (Word32 -> Int) -> Word32 -> [WindowState]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr EWindowState
    hsc_ptr -> Ptr EWindowState -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EWindowState
    hsc_ptr Int
    24) Ptr EWindowState
    ptr :: IO Word32)
    {-# LINE 632 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 634 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    -- | Query why a seleciton changed its owner.
    eventChangeReason :: EventM EOwnerChange OwnerChange
    eventChangeReason :: EventM EOwnerChange OwnerChange
    eventChangeReason = ReaderT (Ptr EOwnerChange) IO (Ptr EOwnerChange)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EOwnerChange) IO (Ptr EOwnerChange)
    -> (Ptr EOwnerChange -> EventM EOwnerChange OwnerChange)
    -> EventM EOwnerChange OwnerChange
    forall a b.
    ReaderT (Ptr EOwnerChange) IO a
    -> (a -> ReaderT (Ptr EOwnerChange) IO b)
    -> ReaderT (Ptr EOwnerChange) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EOwnerChange
    ptr -> IO OwnerChange -> EventM EOwnerChange OwnerChange
    forall a. IO a -> ReaderT (Ptr EOwnerChange) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO OwnerChange -> EventM EOwnerChange OwnerChange)
    -> IO OwnerChange -> EventM EOwnerChange OwnerChange
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> OwnerChange) -> IO Word32 -> IO OwnerChange
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> OwnerChange
    forall a. Enum a => Int -> a
    toEnum (Int -> OwnerChange) -> (Word32 -> Int) -> Word32 -> OwnerChange
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
      ((\Ptr EOwnerChange
    hsc_ptr -> Ptr EOwnerChange -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EOwnerChange
    hsc_ptr Int
    32) Ptr EOwnerChange
    ptr :: IO Word32)
    {-# LINE 638 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query what selection changed its owner.
    eventSelection :: EventM EOwnerChange SelectionTag
    eventSelection :: EventM EOwnerChange Atom
    eventSelection = ReaderT (Ptr EOwnerChange) IO (Ptr EOwnerChange)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EOwnerChange) IO (Ptr EOwnerChange)
    -> (Ptr EOwnerChange -> EventM EOwnerChange Atom)
    -> EventM EOwnerChange Atom
    forall a b.
    ReaderT (Ptr EOwnerChange) IO a
    -> (a -> ReaderT (Ptr EOwnerChange) IO b)
    -> ReaderT (Ptr EOwnerChange) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EOwnerChange
    ptr -> IO Atom -> EventM EOwnerChange Atom
    forall a. IO a -> ReaderT (Ptr EOwnerChange) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Atom -> EventM EOwnerChange Atom)
    -> IO Atom -> EventM EOwnerChange Atom
    forall a b. (a -> b) -> a -> b
    $ (Ptr () -> Atom) -> IO (Ptr ()) -> IO Atom
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Ptr () -> Atom
    Atom
      ((\Ptr EOwnerChange
    hsc_ptr -> Ptr EOwnerChange -> Int -> IO (Ptr ())
    forall b. Ptr b -> Int -> IO (Ptr ())
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EOwnerChange
    hsc_ptr Int
    40) Ptr EOwnerChange
    ptr :: IO (Ptr ()))
    {-# LINE 643 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Query the time when the selection was taken over.
    eventSelectionTime :: EventM EOwnerChange TimeStamp
    eventSelectionTime :: EventM EOwnerChange Word32
    eventSelectionTime = ReaderT (Ptr EOwnerChange) IO (Ptr EOwnerChange)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EOwnerChange) IO (Ptr EOwnerChange)
    -> (Ptr EOwnerChange -> EventM EOwnerChange Word32)
    -> EventM EOwnerChange Word32
    forall a b.
    ReaderT (Ptr EOwnerChange) IO a
    -> (a -> ReaderT (Ptr EOwnerChange) IO b)
    -> ReaderT (Ptr EOwnerChange) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EOwnerChange
    ptr -> IO Word32 -> EventM EOwnerChange Word32
    forall a. IO a -> ReaderT (Ptr EOwnerChange) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> EventM EOwnerChange Word32)
    -> IO Word32 -> EventM EOwnerChange Word32
    forall a b. (a -> b) -> a -> b
    $ (Word32 -> Word32) -> IO Word32 -> IO Word32
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Word32 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral
      ((\Ptr EOwnerChange
    hsc_ptr -> Ptr EOwnerChange -> Int -> IO Word32
    forall b. Ptr b -> Int -> IO Word32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EOwnerChange
    hsc_ptr Int
    52) Ptr EOwnerChange
    ptr :: IO (Word32))
    {-# LINE 648 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 649 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 651 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
    -- | Check if a keyboard (@True@) or a mouse pointer grap (@False@) was
    --   broken.
    eventKeyboardGrab :: EventM EGrabBroken Bool
    eventKeyboardGrab :: EventM EGrabBroken Bool
    eventKeyboardGrab = ReaderT (Ptr EGrabBroken) IO (Ptr EGrabBroken)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EGrabBroken) IO (Ptr EGrabBroken)
    -> (Ptr EGrabBroken -> EventM EGrabBroken Bool)
    -> EventM EGrabBroken Bool
    forall a b.
    ReaderT (Ptr EGrabBroken) IO a
    -> (a -> ReaderT (Ptr EGrabBroken) IO b)
    -> ReaderT (Ptr EGrabBroken) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EGrabBroken
    ptr -> IO Bool -> EventM EGrabBroken Bool
    forall a. IO a -> ReaderT (Ptr EGrabBroken) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> EventM EGrabBroken Bool)
    -> IO Bool -> EventM EGrabBroken Bool
    forall a b. (a -> b) -> a -> b
    $ (Int32 -> Bool) -> IO Int32 -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Int32 -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool
      ((\Ptr EGrabBroken
    hsc_ptr -> Ptr EGrabBroken -> Int -> IO Int32
    forall b. Ptr b -> Int -> IO Int32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EGrabBroken
    hsc_ptr Int
    20) Ptr EGrabBroken
    ptr :: IO Int32)
    {-# LINE 656 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Check if a grab was broken implicitly.
    eventImplicit :: EventM EGrabBroken Bool
    eventImplicit :: EventM EGrabBroken Bool
    eventImplicit = ReaderT (Ptr EGrabBroken) IO (Ptr EGrabBroken)
    forall r (m :: * -> *). MonadReader r m => m r
    ask ReaderT (Ptr EGrabBroken) IO (Ptr EGrabBroken)
    -> (Ptr EGrabBroken -> EventM EGrabBroken Bool)
    -> EventM EGrabBroken Bool
    forall a b.
    ReaderT (Ptr EGrabBroken) IO a
    -> (a -> ReaderT (Ptr EGrabBroken) IO b)
    -> ReaderT (Ptr EGrabBroken) IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Ptr EGrabBroken
    ptr -> IO Bool -> EventM EGrabBroken Bool
    forall a. IO a -> ReaderT (Ptr EGrabBroken) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> EventM EGrabBroken Bool)
    -> IO Bool -> EventM EGrabBroken Bool
    forall a b. (a -> b) -> a -> b
    $ (Int32 -> Bool) -> IO Int32 -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Int32 -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool
      ((\Ptr EGrabBroken
    hsc_ptr -> Ptr EGrabBroken -> Int -> IO Int32
    forall b. Ptr b -> Int -> IO Int32
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EGrabBroken
    hsc_ptr Int
    24) Ptr EGrabBroken
    ptr :: IO Int32)
    {-# LINE 661 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Get the new window that owns the grab or @Nothing@ if the window
    --   is not part of this application.
    eventGrabWindow :: EventM EGrabBroken (Maybe DrawWindow)
    eventGrabWindow :: EventM EGrabBroken (Maybe DrawWindow)
    eventGrabWindow = do
      ptr <- ReaderT (Ptr EGrabBroken) IO (Ptr EGrabBroken)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ maybeNull (makeNewGObject mkDrawWindow) ((\Ptr EGrabBroken
    hsc_ptr -> Ptr EGrabBroken -> Int -> IO (Ptr DrawWindow)
    forall b. Ptr b -> Int -> IO (Ptr DrawWindow)
    forall a b. Storable a => Ptr b -> Int -> IO a
    peekByteOff Ptr EGrabBroken
    hsc_ptr Int
    8) ptr)
    {-# LINE 668 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    {-# LINE 669 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Execute an event handler and assume it handled the event unless it
    --   threw a pattern match exception or calls mzero (e.g. via guard).
    tryEvent :: EventM any () -> EventM any Bool
    tryEvent :: forall any. EventM any () -> EventM any Bool
    tryEvent EventM any ()
    act = do
      ptr <- ReaderT (Ptr any) IO (Ptr any)
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      liftIO $ (runReaderT (act >> return True) ptr)

    {-# LINE 678 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}
        `catches` [ Handler (\ (PatternMatchFail [Char]
    _) -> Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    False)
                  , Handler (\ IOError
    e -> if IOError -> Bool
    isUserError IOError
    e Bool -> Bool -> Bool
    &&
                                       ([Char]
    "Pattern" [Char] -> [Char] -> Bool
    forall a. Eq a => [a] -> [a] -> Bool
    `isPrefixOf` IOError -> [Char]
    ioeGetErrorString IOError
    e Bool -> Bool -> Bool
    ||
                                        [Char]
    "mzero" [Char] -> [Char] -> Bool
    forall a. Eq a => a -> a -> Bool
    == IOError -> [Char]
    ioeGetErrorString IOError
    e)
                                    then Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    False
                                    else IOError -> IO Bool
    forall a e. (HasCallStack, Exception e) => e -> a
    throw IOError
    e) ]

    {-# LINE 694 "Graphics/UI/Gtk/Gdk/EventM.hsc" #-}

    -- | Explicitly stop the handling of an event. This function should only be
    --   called inside a handler that is wrapped with 'tryEvent'. (It merely
    --   throws a bogus pattern matching error which 'tryEvent' interprets as if
    --   the handler does not handle the event.)
    stopEvent :: EventM any ()
    stopEvent :: forall any. EventM any ()
    stopEvent =
      IO () -> ReaderT (Ptr any) IO ()
    forall a. IO a -> ReaderT (Ptr any) IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> ReaderT (Ptr any) IO ())
    -> IO () -> ReaderT (Ptr any) IO ()
    forall a b. (a -> b) -> a -> b
    $ PatternMatchFail -> IO ()
    forall a e. (HasCallStack, Exception e) => e -> a
    throw ([Char] -> PatternMatchFail
    PatternMatchFail [Char]
    "EventM.stopEvent called explicitly")