gi-gst-1.0.18: GI/Gst/Structs/FormatDefinition.hs

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

A format definition
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Gst.Structs.FormatDefinition
    ( 

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


 -- * Properties
-- ** description #attr:description#
{- | A longer description of the format
-}
    clearFormatDefinitionDescription        ,
#if ENABLE_OVERLOADING
    formatDefinition_description            ,
#endif
    getFormatDefinitionDescription          ,
    setFormatDefinitionDescription          ,


-- ** nick #attr:nick#
{- | A short nick of the format
-}
    clearFormatDefinitionNick               ,
#if ENABLE_OVERLOADING
    formatDefinition_nick                   ,
#endif
    getFormatDefinitionNick                 ,
    setFormatDefinitionNick                 ,


-- ** quark #attr:quark#
{- | A quark for the nick
-}
#if ENABLE_OVERLOADING
    formatDefinition_quark                  ,
#endif
    getFormatDefinitionQuark                ,
    setFormatDefinitionQuark                ,


-- ** value #attr:value#
{- | The unique id of this format
-}
#if ENABLE_OVERLOADING
    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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
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 qualified GHC.OverloadedLabels as OL

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

-- | Memory-managed wrapper type.
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


-- | A convenience alias for `Nothing` :: `Maybe` `FormatDefinition`.
noFormatDefinition :: Maybe FormatDefinition
noFormatDefinition = Nothing

{- |
Get the value of the “@value@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' formatDefinition #value
@
-}
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'

{- |
Set the value of the “@value@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' formatDefinition [ #value 'Data.GI.Base.Attributes.:=' value ]
@
-}
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 ENABLE_OVERLOADING
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


{- |
Get the value of the “@nick@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' formatDefinition #nick
@
-}
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

{- |
Set the value of the “@nick@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' formatDefinition [ #nick 'Data.GI.Base.Attributes.:=' value ]
@
-}
setFormatDefinitionNick :: MonadIO m => FormatDefinition -> CString -> m ()
setFormatDefinitionNick s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: CString)

{- |
Set the value of the “@nick@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #nick
@
-}
clearFormatDefinitionNick :: MonadIO m => FormatDefinition -> m ()
clearFormatDefinitionNick s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
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


{- |
Get the value of the “@description@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' formatDefinition #description
@
-}
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

{- |
Set the value of the “@description@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' formatDefinition [ #description 'Data.GI.Base.Attributes.:=' value ]
@
-}
setFormatDefinitionDescription :: MonadIO m => FormatDefinition -> CString -> m ()
setFormatDefinitionDescription s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: CString)

{- |
Set the value of the “@description@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #description
@
-}
clearFormatDefinitionDescription :: MonadIO m => FormatDefinition -> m ()
clearFormatDefinitionDescription s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
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


{- |
Get the value of the “@quark@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' formatDefinition #quark
@
-}
getFormatDefinitionQuark :: MonadIO m => FormatDefinition -> m Word32
getFormatDefinitionQuark s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

{- |
Set the value of the “@quark@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' formatDefinition [ #quark 'Data.GI.Base.Attributes.:=' value ]
@
-}
setFormatDefinitionQuark :: MonadIO m => FormatDefinition -> Word32 -> m ()
setFormatDefinitionQuark s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

#if ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
instance O.HasAttributeList FormatDefinition
type instance O.AttributeList FormatDefinition = FormatDefinitionAttributeList
type FormatDefinitionAttributeList = ('[ '("value", FormatDefinitionValueFieldInfo), '("nick", FormatDefinitionNickFieldInfo), '("description", FormatDefinitionDescriptionFieldInfo), '("quark", FormatDefinitionQuarkFieldInfo)] :: [(Symbol, *)])
#endif

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

instance (info ~ ResolveFormatDefinitionMethod t FormatDefinition, O.MethodInfo info FormatDefinition p) => OL.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