EventCrossing.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)

Generated when the pointer enters or leaves a window.
-}

module GI.Gdk.Structs.EventCrossing
    ( 

-- * Exported types
    EventCrossing(..)                       ,
    noEventCrossing                         ,


 -- * Properties
-- ** Detail
    eventCrossingReadDetail                 ,


-- ** Focus
    eventCrossingReadFocus                  ,


-- ** Mode
    eventCrossingReadMode                   ,


-- ** SendEvent
    eventCrossingReadSendEvent              ,


-- ** State
    eventCrossingReadState                  ,


-- ** Subwindow
    eventCrossingReadSubwindow              ,


-- ** Time
    eventCrossingReadTime                   ,


-- ** Type
    eventCrossingReadType                   ,


-- ** Window
    eventCrossingReadWindow                 ,


-- ** X
    eventCrossingReadX                      ,


-- ** XRoot
    eventCrossingReadXRoot                  ,


-- ** Y
    eventCrossingReadY                      ,


-- ** YRoot
    eventCrossingReadYRoot                  ,




    ) 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

newtype EventCrossing = EventCrossing (ForeignPtr EventCrossing)
noEventCrossing :: Maybe EventCrossing
noEventCrossing = Nothing

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

eventCrossingReadWindow :: EventCrossing -> IO Window
eventCrossingReadWindow s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Window)
    val' <- (newObject Window) val
    return val'

eventCrossingReadSendEvent :: EventCrossing -> IO Int8
eventCrossingReadSendEvent s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Int8
    return val

eventCrossingReadSubwindow :: EventCrossing -> IO Window
eventCrossingReadSubwindow s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO (Ptr Window)
    val' <- (newObject Window) val
    return val'

eventCrossingReadTime :: EventCrossing -> IO Word32
eventCrossingReadTime s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word32
    return val

eventCrossingReadX :: EventCrossing -> IO Double
eventCrossingReadX s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO CDouble
    let val' = realToFrac val
    return val'

eventCrossingReadY :: EventCrossing -> IO Double
eventCrossingReadY s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO CDouble
    let val' = realToFrac val
    return val'

eventCrossingReadXRoot :: EventCrossing -> IO Double
eventCrossingReadXRoot s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO CDouble
    let val' = realToFrac val
    return val'

eventCrossingReadYRoot :: EventCrossing -> IO Double
eventCrossingReadYRoot s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 64) :: IO CDouble
    let val' = realToFrac val
    return val'

eventCrossingReadMode :: EventCrossing -> IO CrossingMode
eventCrossingReadMode s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 72) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

eventCrossingReadDetail :: EventCrossing -> IO NotifyType
eventCrossingReadDetail s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 76) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

eventCrossingReadFocus :: EventCrossing -> IO Bool
eventCrossingReadFocus s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 80) :: IO CInt
    let val' = (/= 0) val
    return val'

eventCrossingReadState :: EventCrossing -> IO [ModifierType]
eventCrossingReadState s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 84) :: IO CUInt
    let val' = wordToGFlags val
    return val'