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

A format definition
-}

module GI.Gst.Structs.FormatDefinition
    ( 

-- * Exported types
    FormatDefinition(..)                    ,
    newZeroFormatDefinition                 ,
    noFormatDefinition                      ,


 -- * Properties
-- ** description #attr:description#
    clearFormatDefinitionDescription        ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    formatDefinition_description            ,
#endif
    getFormatDefinitionDescription          ,
    setFormatDefinitionDescription          ,


-- ** nick #attr:nick#
    clearFormatDefinitionNick               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    formatDefinition_nick                   ,
#endif
    getFormatDefinitionNick                 ,
    setFormatDefinitionNick                 ,


-- ** quark #attr:quark#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    formatDefinition_quark                  ,
#endif
    getFormatDefinitionQuark                ,
    setFormatDefinitionQuark                ,


-- ** value #attr:value#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    formatDefinition_value                  ,
#endif
    getFormatDefinitionValue                ,
    setFormatDefinitionValue                ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums

newtype FormatDefinition = FormatDefinition (ManagedPtr FormatDefinition)
instance WrappedPtr FormatDefinition where
    wrappedPtrCalloc = callocBytes 32
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr FormatDefinition)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `FormatDefinition` struct initialized to zero.
newZeroFormatDefinition :: MonadIO m => m FormatDefinition
newZeroFormatDefinition = liftIO $ wrappedPtrCalloc >>= wrapPtr FormatDefinition

instance tag ~ 'AttrSet => Constructible FormatDefinition tag where
    new _ attrs = do
        o <- newZeroFormatDefinition
        GI.Attributes.set o attrs
        return o


noFormatDefinition :: Maybe FormatDefinition
noFormatDefinition = Nothing

getFormatDefinitionValue :: MonadIO m => FormatDefinition -> m Gst.Enums.Format
getFormatDefinitionValue s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

setFormatDefinitionValue :: MonadIO m => FormatDefinition -> Gst.Enums.Format -> m ()
setFormatDefinitionValue s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 0) (val' :: CUInt)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FormatDefinitionValueFieldInfo
instance AttrInfo FormatDefinitionValueFieldInfo where
    type AttrAllowedOps FormatDefinitionValueFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FormatDefinitionValueFieldInfo = (~) Gst.Enums.Format
    type AttrBaseTypeConstraint FormatDefinitionValueFieldInfo = (~) FormatDefinition
    type AttrGetType FormatDefinitionValueFieldInfo = Gst.Enums.Format
    type AttrLabel FormatDefinitionValueFieldInfo = "value"
    type AttrOrigin FormatDefinitionValueFieldInfo = FormatDefinition
    attrGet _ = getFormatDefinitionValue
    attrSet _ = setFormatDefinitionValue
    attrConstruct = undefined
    attrClear _ = undefined

formatDefinition_value :: AttrLabelProxy "value"
formatDefinition_value = AttrLabelProxy

#endif


getFormatDefinitionNick :: MonadIO m => FormatDefinition -> m (Maybe T.Text)
getFormatDefinitionNick s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setFormatDefinitionNick :: MonadIO m => FormatDefinition -> CString -> m ()
setFormatDefinitionNick s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: CString)

clearFormatDefinitionNick :: MonadIO m => FormatDefinition -> m ()
clearFormatDefinitionNick s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FormatDefinitionNickFieldInfo
instance AttrInfo FormatDefinitionNickFieldInfo where
    type AttrAllowedOps FormatDefinitionNickFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FormatDefinitionNickFieldInfo = (~) CString
    type AttrBaseTypeConstraint FormatDefinitionNickFieldInfo = (~) FormatDefinition
    type AttrGetType FormatDefinitionNickFieldInfo = Maybe T.Text
    type AttrLabel FormatDefinitionNickFieldInfo = "nick"
    type AttrOrigin FormatDefinitionNickFieldInfo = FormatDefinition
    attrGet _ = getFormatDefinitionNick
    attrSet _ = setFormatDefinitionNick
    attrConstruct = undefined
    attrClear _ = clearFormatDefinitionNick

formatDefinition_nick :: AttrLabelProxy "nick"
formatDefinition_nick = AttrLabelProxy

#endif


getFormatDefinitionDescription :: MonadIO m => FormatDefinition -> m (Maybe T.Text)
getFormatDefinitionDescription s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setFormatDefinitionDescription :: MonadIO m => FormatDefinition -> CString -> m ()
setFormatDefinitionDescription s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: CString)

clearFormatDefinitionDescription :: MonadIO m => FormatDefinition -> m ()
clearFormatDefinitionDescription s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FormatDefinitionDescriptionFieldInfo
instance AttrInfo FormatDefinitionDescriptionFieldInfo where
    type AttrAllowedOps FormatDefinitionDescriptionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FormatDefinitionDescriptionFieldInfo = (~) CString
    type AttrBaseTypeConstraint FormatDefinitionDescriptionFieldInfo = (~) FormatDefinition
    type AttrGetType FormatDefinitionDescriptionFieldInfo = Maybe T.Text
    type AttrLabel FormatDefinitionDescriptionFieldInfo = "description"
    type AttrOrigin FormatDefinitionDescriptionFieldInfo = FormatDefinition
    attrGet _ = getFormatDefinitionDescription
    attrSet _ = setFormatDefinitionDescription
    attrConstruct = undefined
    attrClear _ = clearFormatDefinitionDescription

formatDefinition_description :: AttrLabelProxy "description"
formatDefinition_description = AttrLabelProxy

#endif


getFormatDefinitionQuark :: MonadIO m => FormatDefinition -> m Word32
getFormatDefinitionQuark s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

setFormatDefinitionQuark :: MonadIO m => FormatDefinition -> Word32 -> m ()
setFormatDefinitionQuark s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FormatDefinitionQuarkFieldInfo
instance AttrInfo FormatDefinitionQuarkFieldInfo where
    type AttrAllowedOps FormatDefinitionQuarkFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FormatDefinitionQuarkFieldInfo = (~) Word32
    type AttrBaseTypeConstraint FormatDefinitionQuarkFieldInfo = (~) FormatDefinition
    type AttrGetType FormatDefinitionQuarkFieldInfo = Word32
    type AttrLabel FormatDefinitionQuarkFieldInfo = "quark"
    type AttrOrigin FormatDefinitionQuarkFieldInfo = FormatDefinition
    attrGet _ = getFormatDefinitionQuark
    attrSet _ = setFormatDefinitionQuark
    attrConstruct = undefined
    attrClear _ = undefined

formatDefinition_quark :: AttrLabelProxy "quark"
formatDefinition_quark = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList FormatDefinition
type instance O.AttributeList FormatDefinition = FormatDefinitionAttributeList
type FormatDefinitionAttributeList = ('[ '("value", FormatDefinitionValueFieldInfo), '("nick", FormatDefinitionNickFieldInfo), '("description", FormatDefinitionDescriptionFieldInfo), '("quark", FormatDefinitionQuarkFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveFormatDefinitionMethod (t :: Symbol) (o :: *) :: * where
    ResolveFormatDefinitionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFormatDefinitionMethod t FormatDefinition, O.MethodInfo info FormatDefinition p) => O.IsLabelProxy t (FormatDefinition -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveFormatDefinitionMethod t FormatDefinition, O.MethodInfo info FormatDefinition p) => O.IsLabel t (FormatDefinition -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif