gi-gdk-0.3.18.13: GI/Gdk/Structs/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(..)                       ,
    newZeroEventCrossing                    ,
    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)
-- | Construct a `EventCrossing` struct initialized to zero.
newZeroEventCrossing :: MonadIO m => m EventCrossing
newZeroEventCrossing = liftIO $ callocBytes 88 >>= wrapPtr 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'

type family ResolveEventCrossingMethod (t :: Symbol) (o :: *) :: * where
    ResolveEventCrossingMethod l o = MethodResolutionFailed l o

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

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