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

All pending timeouts or periodic notifies are converted into
an entry.
Note that GstClockEntry should be treated as an opaque structure. It must
not be extended or allocated using a custom allocator.
-}

module GI.Gst.Structs.ClockEntry
    ( 

-- * Exported types
    ClockEntry(..)                          ,
    newZeroClockEntry                       ,
    noClockEntry                            ,


 -- * Properties
-- ** Clock
    clockEntryReadClock                     ,


-- ** Interval
    clockEntryReadInterval                  ,


-- ** Refcount
    clockEntryReadRefcount                  ,


-- ** Status
    clockEntryReadStatus                    ,


-- ** Time
    clockEntryReadTime                      ,


-- ** Type
    clockEntryReadType                      ,


-- ** Unscheduled
    clockEntryReadUnscheduled               ,


-- ** UserData
    clockEntryReadUserData                  ,


-- ** WokenUp
    clockEntryReadWokenUp                   ,




    ) 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.Gst.Types
import GI.Gst.Callbacks

newtype ClockEntry = ClockEntry (ForeignPtr ClockEntry)
-- | Construct a `ClockEntry` struct initialized to zero.
newZeroClockEntry :: MonadIO m => m ClockEntry
newZeroClockEntry = liftIO $ callocBytes 112 >>= wrapPtr ClockEntry

noClockEntry :: Maybe ClockEntry
noClockEntry = Nothing

clockEntryReadRefcount :: ClockEntry -> IO Int32
clockEntryReadRefcount s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

clockEntryReadClock :: ClockEntry -> IO Clock
clockEntryReadClock s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Clock)
    val' <- (newObject Clock) val
    return val'

clockEntryReadType :: ClockEntry -> IO ClockEntryType
clockEntryReadType s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

clockEntryReadTime :: ClockEntry -> IO Word64
clockEntryReadTime s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word64
    return val

clockEntryReadInterval :: ClockEntry -> IO Word64
clockEntryReadInterval s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word64
    return val

clockEntryReadStatus :: ClockEntry -> IO ClockReturn
clockEntryReadStatus s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

-- XXX Skipped getter for "ClockEntry:func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"

clockEntryReadUserData :: ClockEntry -> IO (Ptr ())
clockEntryReadUserData s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO (Ptr ())
    return val

-- XXX Skipped getter for "ClockEntry:destroy_data" :: Not implemented: "Wrapping foreign callbacks is not supported yet"

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

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

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

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

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