gi-gdk-0.3.18.13: GI/Gdk/Structs/EventTouch.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)

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(..)                          ,
    newZeroEventTouch                       ,
    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)
-- | Construct a `EventTouch` struct initialized to zero.
newZeroEventTouch :: MonadIO m => m EventTouch
newZeroEventTouch = liftIO $ callocBytes 96 >>= wrapPtr 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'

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

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

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