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

Used for touch events.
@type field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,
%GDK_TOUCH_END or %GDK_TOUCH_CANCEL.

Touch events are grouped into sequences by means of the @sequence
field, which can also be obtained with gdk_event_get_event_sequence().
Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by
any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END
(or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be
several active sequences at the same time.
-}

module GI.Gdk.Structs.EventTouch
    ( 

-- * Exported types
    EventTouch(..)                          ,
    noEventTouch                            ,


 -- * Properties
-- ** Axes
    eventTouchReadAxes                      ,


-- ** Device
    eventTouchReadDevice                    ,


-- ** EmulatingPointer
    eventTouchReadEmulatingPointer          ,


-- ** SendEvent
    eventTouchReadSendEvent                 ,


-- ** Sequence
    eventTouchReadSequence                  ,


-- ** State
    eventTouchReadState                     ,


-- ** Time
    eventTouchReadTime                      ,


-- ** Type
    eventTouchReadType                      ,


-- ** Window
    eventTouchReadWindow                    ,


-- ** X
    eventTouchReadX                         ,


-- ** XRoot
    eventTouchReadXRoot                     ,


-- ** Y
    eventTouchReadY                         ,


-- ** YRoot
    eventTouchReadYRoot                     ,




    ) 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 EventTouch = EventTouch (ForeignPtr EventTouch)
noEventTouch :: Maybe EventTouch
noEventTouch = Nothing

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

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

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

eventTouchReadTime :: EventTouch -> IO Word32
eventTouchReadTime s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 20) :: IO Word32
    return val

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

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

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

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

eventTouchReadSequence :: EventTouch -> IO EventSequence
eventTouchReadSequence s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO (Ptr EventSequence)
    val' <- (newBoxed EventSequence) val
    return val'

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

eventTouchReadDevice :: EventTouch -> IO Device
eventTouchReadDevice s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 72) :: IO (Ptr Device)
    val' <- (newObject Device) val
    return val'

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

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