    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Contains the parameters that define a colorstate with cicp parameters.
    --
    -- Cicp parameters are specified in the ITU-T H.273
    -- <https://www.itu.int/rec/T-REC-H.273/en specification>.
    --
    -- See the documentation of individual properties for supported values.
    --
    -- The \'unspecified\' value (2) is not treated in any special way, and
    -- must be replaced by a different value before creating a color state.
    --
    -- @GdkCicpParams@ can be used as a builder object to construct a color
    -- state from Cicp data with 'GI.Gdk.Objects.CicpParams.cicpParamsBuildColorState'.
    -- The function will return an error if the given parameters are not
    -- supported.
    --
    -- You can obtain a @GdkCicpParams@ object from a color state with
    -- 'GI.Gdk.Structs.ColorState.colorStateCreateCicpParams'. This can be used to
    -- create a variant of a color state, by changing just one of the cicp
    -- parameters, or just to obtain information about the color state.
    --
    -- /Since: 4.16/

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gdk.Objects.CicpParams
        (

    -- * Exported types
        CicpParams(..)                          ,
        IsCicpParams                            ,
        toCicpParams                            ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [buildColorState]("GI.Gdk.Objects.CicpParams#g:method:buildColorState"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getColorPrimaries]("GI.Gdk.Objects.CicpParams#g:method:getColorPrimaries"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getMatrixCoefficients]("GI.Gdk.Objects.CicpParams#g:method:getMatrixCoefficients"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRange]("GI.Gdk.Objects.CicpParams#g:method:getRange"), [getTransferFunction]("GI.Gdk.Objects.CicpParams#g:method:getTransferFunction").
    --
    -- ==== Setters
    -- [setColorPrimaries]("GI.Gdk.Objects.CicpParams#g:method:setColorPrimaries"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setMatrixCoefficients]("GI.Gdk.Objects.CicpParams#g:method:setMatrixCoefficients"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRange]("GI.Gdk.Objects.CicpParams#g:method:setRange"), [setTransferFunction]("GI.Gdk.Objects.CicpParams#g:method:setTransferFunction").

    #if defined(ENABLE_OVERLOADING)
        ResolveCicpParamsMethod                 ,
    #endif

    -- ** buildColorState #method:buildColorState#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsBuildColorStateMethodInfo     ,
    #endif
        cicpParamsBuildColorState               ,

    -- ** getColorPrimaries #method:getColorPrimaries#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsGetColorPrimariesMethodInfo   ,
    #endif
        cicpParamsGetColorPrimaries             ,

    -- ** getMatrixCoefficients #method:getMatrixCoefficients#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsGetMatrixCoefficientsMethodInfo,
    #endif
        cicpParamsGetMatrixCoefficients         ,

    -- ** getRange #method:getRange#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsGetRangeMethodInfo            ,
    #endif
        cicpParamsGetRange                      ,

    -- ** getTransferFunction #method:getTransferFunction#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsGetTransferFunctionMethodInfo ,
    #endif
        cicpParamsGetTransferFunction           ,

    -- ** new #method:new#

        cicpParamsNew                           ,

    -- ** setColorPrimaries #method:setColorPrimaries#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsSetColorPrimariesMethodInfo   ,
    #endif
        cicpParamsSetColorPrimaries             ,

    -- ** setMatrixCoefficients #method:setMatrixCoefficients#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsSetMatrixCoefficientsMethodInfo,
    #endif
        cicpParamsSetMatrixCoefficients         ,

    -- ** setRange #method:setRange#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsSetRangeMethodInfo            ,
    #endif
        cicpParamsSetRange                      ,

    -- ** setTransferFunction #method:setTransferFunction#

    #if defined(ENABLE_OVERLOADING)
        CicpParamsSetTransferFunctionMethodInfo ,
    #endif
        cicpParamsSetTransferFunction           ,

     -- * Properties

    -- ** colorPrimaries #attr:colorPrimaries#
    -- | The color primaries to use.
    --
    -- Supported values:
    --
    -- * 1: BT.709 \/ sRGB
    -- * 2: unspecified
    -- * 5: PAL
    -- * 6,7: BT.601 \/ NTSC
    -- * 9: BT.2020
    -- * 12: Display P3
    --
    --
    -- /Since: 4.16/

    #if defined(ENABLE_OVERLOADING)
        CicpParamsColorPrimariesPropertyInfo    ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cicpParamsColorPrimaries                ,
    #endif
        constructCicpParamsColorPrimaries       ,
        getCicpParamsColorPrimaries             ,
        setCicpParamsColorPrimaries             ,

    -- ** matrixCoefficients #attr:matrixCoefficients#
    -- | The matrix coefficients (for YUV to RGB conversion).
    --
    -- Supported values:
    --
    -- * 0: RGB
    -- * 1: BT.709
    -- * 2: unspecified
    -- * 5,6: BT.601
    -- * 9: BT.2020
    --
    --
    -- /Since: 4.16/

    #if defined(ENABLE_OVERLOADING)
        CicpParamsMatrixCoefficientsPropertyInfo,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cicpParamsMatrixCoefficients            ,
    #endif
        constructCicpParamsMatrixCoefficients   ,
        getCicpParamsMatrixCoefficients         ,
        setCicpParamsMatrixCoefficients         ,

    -- ** range #attr:range#
    -- | Whether the data is using the full range of values.
    --
    -- The range of the data.
    --
    -- /Since: 4.16/

    #if defined(ENABLE_OVERLOADING)
        CicpParamsRangePropertyInfo             ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cicpParamsRange                         ,
    #endif
        constructCicpParamsRange                ,
        getCicpParamsRange                      ,
        setCicpParamsRange                      ,

    -- ** transferFunction #attr:transferFunction#
    -- | The transfer function to use.
    --
    -- Supported values:
    --
    -- * 1,6,14,15: BT.709, BT.601, BT.2020
    -- * 2: unspecified
    -- * 4: gamma 2.2
    -- * 5: gamma 2.8
    -- * 8: linear
    -- * 13: sRGB
    -- * 16: BT.2100 PQ
    -- * 18: BT.2100 HLG
    --
    --
    -- /Since: 4.16/

    #if defined(ENABLE_OVERLOADING)
        CicpParamsTransferFunctionPropertyInfo  ,
    #endif
    #if defined(ENABLE_OVERLOADING)
        cicpParamsTransferFunction              ,
    #endif
        constructCicpParamsTransferFunction     ,
        getCicpParamsTransferFunction           ,
        setCicpParamsTransferFunction           ,

        ) 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.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    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.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    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 qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Structs.ColorState as Gdk.ColorState

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Structs.ColorState as Gdk.ColorState

    #endif

    -- | Memory-managed wrapper type.
    newtype CicpParams = CicpParams (SP.ManagedPtr CicpParams)
        deriving (CicpParams -> CicpParams -> Bool
    (CicpParams -> CicpParams -> Bool)
    -> (CicpParams -> CicpParams -> Bool) -> Eq CicpParams
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CicpParams -> CicpParams -> Bool
    == :: CicpParams -> CicpParams -> Bool
    $c/= :: CicpParams -> CicpParams -> Bool
    /= :: CicpParams -> CicpParams -> Bool
    Eq)

    instance SP.ManagedPtrNewtype CicpParams where
        toManagedPtr :: CicpParams -> ManagedPtr CicpParams
    toManagedPtr (CicpParams ManagedPtr CicpParams
    p) = ManagedPtr CicpParams
    p

    foreign import ccall "gdk_cicp_params_get_type"
        c_gdk_cicp_params_get_type :: IO B.Types.GType

    instance B.Types.TypedObject CicpParams where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_cicp_params_get_type

    instance B.Types.GObject CicpParams

    -- | Type class for types which can be safely cast to t'CicpParams', for instance with `toCicpParams`.
    class (SP.GObject o, O.IsDescendantOf CicpParams o) => IsCicpParams o
    instance (SP.GObject o, O.IsDescendantOf CicpParams o) => IsCicpParams o

    instance O.HasParentTypes CicpParams
    type instance O.ParentTypes CicpParams = '[GObject.Object.Object]

    -- | Cast to t'CicpParams', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
    toCicpParams :: (MIO.MonadIO m, IsCicpParams o) => o -> m CicpParams
    toCicpParams :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> m CicpParams
    toCicpParams = IO CicpParams -> m CicpParams
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO CicpParams -> m CicpParams)
    -> (o -> IO CicpParams) -> o -> m CicpParams
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr CicpParams -> CicpParams) -> o -> IO CicpParams
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    B.ManagedPtr.unsafeCastTo ManagedPtr CicpParams -> CicpParams
    CicpParams

    -- | Convert t'CicpParams' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe CicpParams) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gdk_cicp_params_get_type
        gvalueSet_ :: Ptr GValue -> Maybe CicpParams -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe CicpParams
    P.Nothing = Ptr GValue -> Ptr CicpParams -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr CicpParams
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr CicpParams)
        gvalueSet_ Ptr GValue
    gv (P.Just CicpParams
    obj) = CicpParams -> (Ptr CicpParams -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr CicpParams
    obj (Ptr GValue -> Ptr CicpParams -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe CicpParams)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr CicpParams)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr CicpParams)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject CicpParams ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveCicpParamsMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveCicpParamsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveCicpParamsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveCicpParamsMethod "buildColorState" o = CicpParamsBuildColorStateMethodInfo
        ResolveCicpParamsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveCicpParamsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveCicpParamsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveCicpParamsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveCicpParamsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveCicpParamsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveCicpParamsMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveCicpParamsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveCicpParamsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveCicpParamsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveCicpParamsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveCicpParamsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveCicpParamsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveCicpParamsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveCicpParamsMethod "getColorPrimaries" o = CicpParamsGetColorPrimariesMethodInfo
        ResolveCicpParamsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveCicpParamsMethod "getMatrixCoefficients" o = CicpParamsGetMatrixCoefficientsMethodInfo
        ResolveCicpParamsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveCicpParamsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveCicpParamsMethod "getRange" o = CicpParamsGetRangeMethodInfo
        ResolveCicpParamsMethod "getTransferFunction" o = CicpParamsGetTransferFunctionMethodInfo
        ResolveCicpParamsMethod "setColorPrimaries" o = CicpParamsSetColorPrimariesMethodInfo
        ResolveCicpParamsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveCicpParamsMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveCicpParamsMethod "setMatrixCoefficients" o = CicpParamsSetMatrixCoefficientsMethodInfo
        ResolveCicpParamsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveCicpParamsMethod "setRange" o = CicpParamsSetRangeMethodInfo
        ResolveCicpParamsMethod "setTransferFunction" o = CicpParamsSetTransferFunctionMethodInfo
        ResolveCicpParamsMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveCicpParamsMethod t CicpParams, O.OverloadedMethod info CicpParams p) => OL.IsLabel t (CicpParams -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveCicpParamsMethod t CicpParams, O.OverloadedMethod info CicpParams p, R.HasField t CicpParams p) => R.HasField t CicpParams p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveCicpParamsMethod t CicpParams, O.OverloadedMethodInfo info CicpParams) => OL.IsLabel t (O.MethodProxy info CicpParams) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif

    -- VVV Prop "color-primaries"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@color-primaries@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' cicpParams #colorPrimaries
    -- @
    getCicpParamsColorPrimaries :: (MonadIO m, IsCicpParams o) => o -> m Word32
    getCicpParamsColorPrimaries :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> m Word32
    getCicpParamsColorPrimaries o
    obj = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Word32
    forall a. GObject a => a -> String -> IO Word32
    B.Properties.getObjectPropertyUInt32 o
    obj String
    "color-primaries"

    -- | Set the value of the “@color-primaries@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' cicpParams [ #colorPrimaries 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCicpParamsColorPrimaries :: (MonadIO m, IsCicpParams o) => o -> Word32 -> m ()
    setCicpParamsColorPrimaries :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> Word32 -> m ()
    setCicpParamsColorPrimaries o
    obj Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "color-primaries" Word32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@color-primaries@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructCicpParamsColorPrimaries :: (IsCicpParams o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
    constructCicpParamsColorPrimaries :: forall o (m :: * -> *).
    (IsCicpParams o, MonadIO m) =>
    Word32 -> m (GValueConstruct o)
    constructCicpParamsColorPrimaries Word32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Word32 -> IO (GValueConstruct o)
    forall o. String -> Word32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyUInt32 String
    "color-primaries" Word32
    val

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsColorPrimariesPropertyInfo
    instance AttrInfo CicpParamsColorPrimariesPropertyInfo where
        type AttrAllowedOps CicpParamsColorPrimariesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CicpParamsColorPrimariesPropertyInfo = IsCicpParams
        type AttrSetTypeConstraint CicpParamsColorPrimariesPropertyInfo = (~) Word32
        type AttrTransferTypeConstraint CicpParamsColorPrimariesPropertyInfo = (~) Word32
        type AttrTransferType CicpParamsColorPrimariesPropertyInfo = Word32
        type AttrGetType CicpParamsColorPrimariesPropertyInfo = Word32
        type AttrLabel CicpParamsColorPrimariesPropertyInfo = "color-primaries"
        type AttrOrigin CicpParamsColorPrimariesPropertyInfo = CicpParams
        attrGet = getCicpParamsColorPrimaries
        attrSet = setCicpParamsColorPrimaries
        attrPut = setCicpParamsColorPrimaries
        attrTransfer _ v = do
            return v
        attrConstruct = constructCicpParamsColorPrimaries
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.colorPrimaries"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#g:attr:colorPrimaries"
            })
    #endif

    -- VVV Prop "matrix-coefficients"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@matrix-coefficients@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' cicpParams #matrixCoefficients
    -- @
    getCicpParamsMatrixCoefficients :: (MonadIO m, IsCicpParams o) => o -> m Word32
    getCicpParamsMatrixCoefficients :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> m Word32
    getCicpParamsMatrixCoefficients o
    obj = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Word32
    forall a. GObject a => a -> String -> IO Word32
    B.Properties.getObjectPropertyUInt32 o
    obj String
    "matrix-coefficients"

    -- | Set the value of the “@matrix-coefficients@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' cicpParams [ #matrixCoefficients 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCicpParamsMatrixCoefficients :: (MonadIO m, IsCicpParams o) => o -> Word32 -> m ()
    setCicpParamsMatrixCoefficients :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> Word32 -> m ()
    setCicpParamsMatrixCoefficients o
    obj Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "matrix-coefficients" Word32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@matrix-coefficients@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructCicpParamsMatrixCoefficients :: (IsCicpParams o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
    constructCicpParamsMatrixCoefficients :: forall o (m :: * -> *).
    (IsCicpParams o, MonadIO m) =>
    Word32 -> m (GValueConstruct o)
    constructCicpParamsMatrixCoefficients Word32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Word32 -> IO (GValueConstruct o)
    forall o. String -> Word32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyUInt32 String
    "matrix-coefficients" Word32
    val

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsMatrixCoefficientsPropertyInfo
    instance AttrInfo CicpParamsMatrixCoefficientsPropertyInfo where
        type AttrAllowedOps CicpParamsMatrixCoefficientsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CicpParamsMatrixCoefficientsPropertyInfo = IsCicpParams
        type AttrSetTypeConstraint CicpParamsMatrixCoefficientsPropertyInfo = (~) Word32
        type AttrTransferTypeConstraint CicpParamsMatrixCoefficientsPropertyInfo = (~) Word32
        type AttrTransferType CicpParamsMatrixCoefficientsPropertyInfo = Word32
        type AttrGetType CicpParamsMatrixCoefficientsPropertyInfo = Word32
        type AttrLabel CicpParamsMatrixCoefficientsPropertyInfo = "matrix-coefficients"
        type AttrOrigin CicpParamsMatrixCoefficientsPropertyInfo = CicpParams
        attrGet = getCicpParamsMatrixCoefficients
        attrSet = setCicpParamsMatrixCoefficients
        attrPut = setCicpParamsMatrixCoefficients
        attrTransfer _ v = do
            return v
        attrConstruct = constructCicpParamsMatrixCoefficients
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.matrixCoefficients"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#g:attr:matrixCoefficients"
            })
    #endif

    -- VVV Prop "range"
       -- Type: TInterface (Name {namespace = "Gdk", name = "CicpRange"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@range@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' cicpParams #range
    -- @
    getCicpParamsRange :: (MonadIO m, IsCicpParams o) => o -> m Gdk.Enums.CicpRange
    getCicpParamsRange :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> m CicpRange
    getCicpParamsRange o
    obj = IO CicpRange -> m CicpRange
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO CicpRange -> m CicpRange) -> IO CicpRange -> m CicpRange
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO CicpRange
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj String
    "range"

    -- | Set the value of the “@range@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' cicpParams [ #range 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCicpParamsRange :: (MonadIO m, IsCicpParams o) => o -> Gdk.Enums.CicpRange -> m ()
    setCicpParamsRange :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> CicpRange -> m ()
    setCicpParamsRange o
    obj CicpRange
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> CicpRange -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "range" CicpRange
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@range@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructCicpParamsRange :: (IsCicpParams o, MIO.MonadIO m) => Gdk.Enums.CicpRange -> m (GValueConstruct o)
    constructCicpParamsRange :: forall o (m :: * -> *).
    (IsCicpParams o, MonadIO m) =>
    CicpRange -> m (GValueConstruct o)
    constructCicpParamsRange CicpRange
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> CicpRange -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "range" CicpRange
    val

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsRangePropertyInfo
    instance AttrInfo CicpParamsRangePropertyInfo where
        type AttrAllowedOps CicpParamsRangePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CicpParamsRangePropertyInfo = IsCicpParams
        type AttrSetTypeConstraint CicpParamsRangePropertyInfo = (~) Gdk.Enums.CicpRange
        type AttrTransferTypeConstraint CicpParamsRangePropertyInfo = (~) Gdk.Enums.CicpRange
        type AttrTransferType CicpParamsRangePropertyInfo = Gdk.Enums.CicpRange
        type AttrGetType CicpParamsRangePropertyInfo = Gdk.Enums.CicpRange
        type AttrLabel CicpParamsRangePropertyInfo = "range"
        type AttrOrigin CicpParamsRangePropertyInfo = CicpParams
        attrGet = getCicpParamsRange
        attrSet = setCicpParamsRange
        attrPut = setCicpParamsRange
        attrTransfer _ v = do
            return v
        attrConstruct = constructCicpParamsRange
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.range"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#g:attr:range"
            })
    #endif

    -- VVV Prop "transfer-function"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@transfer-function@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' cicpParams #transferFunction
    -- @
    getCicpParamsTransferFunction :: (MonadIO m, IsCicpParams o) => o -> m Word32
    getCicpParamsTransferFunction :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> m Word32
    getCicpParamsTransferFunction o
    obj = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Word32
    forall a. GObject a => a -> String -> IO Word32
    B.Properties.getObjectPropertyUInt32 o
    obj String
    "transfer-function"

    -- | Set the value of the “@transfer-function@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' cicpParams [ #transferFunction 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setCicpParamsTransferFunction :: (MonadIO m, IsCicpParams o) => o -> Word32 -> m ()
    setCicpParamsTransferFunction :: forall (m :: * -> *) o.
    (MonadIO m, IsCicpParams o) =>
    o -> Word32 -> m ()
    setCicpParamsTransferFunction o
    obj Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "transfer-function" Word32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@transfer-function@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructCicpParamsTransferFunction :: (IsCicpParams o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
    constructCicpParamsTransferFunction :: forall o (m :: * -> *).
    (IsCicpParams o, MonadIO m) =>
    Word32 -> m (GValueConstruct o)
    constructCicpParamsTransferFunction Word32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Word32 -> IO (GValueConstruct o)
    forall o. String -> Word32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyUInt32 String
    "transfer-function" Word32
    val

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsTransferFunctionPropertyInfo
    instance AttrInfo CicpParamsTransferFunctionPropertyInfo where
        type AttrAllowedOps CicpParamsTransferFunctionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint CicpParamsTransferFunctionPropertyInfo = IsCicpParams
        type AttrSetTypeConstraint CicpParamsTransferFunctionPropertyInfo = (~) Word32
        type AttrTransferTypeConstraint CicpParamsTransferFunctionPropertyInfo = (~) Word32
        type AttrTransferType CicpParamsTransferFunctionPropertyInfo = Word32
        type AttrGetType CicpParamsTransferFunctionPropertyInfo = Word32
        type AttrLabel CicpParamsTransferFunctionPropertyInfo = "transfer-function"
        type AttrOrigin CicpParamsTransferFunctionPropertyInfo = CicpParams
        attrGet = getCicpParamsTransferFunction
        attrSet = setCicpParamsTransferFunction
        attrPut = setCicpParamsTransferFunction
        attrTransfer _ v = do
            return v
        attrConstruct = constructCicpParamsTransferFunction
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.transferFunction"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#g:attr:transferFunction"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList CicpParams
    type instance O.AttributeList CicpParams = CicpParamsAttributeList
    type CicpParamsAttributeList = ('[ '("colorPrimaries", CicpParamsColorPrimariesPropertyInfo), '("matrixCoefficients", CicpParamsMatrixCoefficientsPropertyInfo), '("range", CicpParamsRangePropertyInfo), '("transferFunction", CicpParamsTransferFunctionPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    cicpParamsColorPrimaries :: AttrLabelProxy "colorPrimaries"
    cicpParamsColorPrimaries = AttrLabelProxy

    cicpParamsMatrixCoefficients :: AttrLabelProxy "matrixCoefficients"
    cicpParamsMatrixCoefficients = AttrLabelProxy

    cicpParamsRange :: AttrLabelProxy "range"
    cicpParamsRange = AttrLabelProxy

    cicpParamsTransferFunction :: AttrLabelProxy "transferFunction"
    cicpParamsTransferFunction = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList CicpParams = CicpParamsSignalList
    type CicpParamsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method CicpParams::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "CicpParams" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_new" gdk_cicp_params_new ::
        IO (Ptr CicpParams)

    -- | Creates a new @GdkCicpParams@ object.
    --
    -- The initial values of the properties are the values for \"undefined\"
    -- and need to be set before a color state object can be built.
    --
    -- /Since: 4.16/
    cicpParamsNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m CicpParams
        -- ^ __Returns:__ a new @GdkCicpParams@
    cicpParamsNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m CicpParams
    cicpParamsNew  = IO CicpParams -> m CicpParams
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CicpParams -> m CicpParams) -> IO CicpParams -> m CicpParams
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr CicpParams)
    gdk_cicp_params_new
        checkUnexpectedReturnNULL "cicpParamsNew" result
        result' <- (wrapObject CicpParams) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method CicpParams::build_color_state
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCicpParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "ColorState" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_build_color_state" gdk_cicp_params_build_color_state ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gdk.ColorState.ColorState)

    -- | Creates a new @GdkColorState@ object for the cicp parameters in /@self@/.
    --
    -- Note that this may fail if the cicp parameters in /@self@/ are not
    -- supported by GTK. In that case, @NULL@ is returned, and /@error@/ is set
    -- with an error message that can be presented to the user.
    --
    -- /Since: 4.16/
    cicpParamsBuildColorState ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCicpParams@
        -> m Gdk.ColorState.ColorState
        -- ^ __Returns:__ A newly allocated @GdkColorState@ /(Can throw 'Data.GI.Base.GError.GError')/
    cicpParamsBuildColorState :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> m ColorState
    cicpParamsBuildColorState a
    self = IO ColorState -> m ColorState
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ColorState -> m ColorState) -> IO ColorState -> m ColorState
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        onException (do
            result <- propagateGError $ gdk_cicp_params_build_color_state self'
            checkUnexpectedReturnNULL "cicpParamsBuildColorState" result
            result' <- (wrapBoxed Gdk.ColorState.ColorState) result
            touchManagedPtr self
            return result'
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsBuildColorStateMethodInfo
    instance (signature ~ (m Gdk.ColorState.ColorState), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsBuildColorStateMethodInfo a signature where
        overloadedMethod = cicpParamsBuildColorState

    instance O.OverloadedMethodInfo CicpParamsBuildColorStateMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsBuildColorState",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsBuildColorState"
            })

    #endif

    -- method CicpParams::get_color_primaries
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCicpParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_get_color_primaries" gdk_cicp_params_get_color_primaries ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        IO Word32

    -- | Returns the value of the color-primaries property
    -- of /@self@/.
    --
    -- /Since: 4.16/
    cicpParamsGetColorPrimaries ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCicpParams@
        -> m Word32
        -- ^ __Returns:__ the color-primaries value
    cicpParamsGetColorPrimaries :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> m Word32
    cicpParamsGetColorPrimaries a
    self = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gdk_cicp_params_get_color_primaries self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsGetColorPrimariesMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsGetColorPrimariesMethodInfo a signature where
        overloadedMethod = cicpParamsGetColorPrimaries

    instance O.OverloadedMethodInfo CicpParamsGetColorPrimariesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsGetColorPrimaries",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsGetColorPrimaries"
            })

    #endif

    -- method CicpParams::get_matrix_coefficients
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCicpParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_get_matrix_coefficients" gdk_cicp_params_get_matrix_coefficients ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        IO Word32

    -- | Gets the matrix-coefficients property of /@self@/.
    --
    -- /Since: 4.16/
    cicpParamsGetMatrixCoefficients ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCicpParams@
        -> m Word32
        -- ^ __Returns:__ the matrix-coefficients value
    cicpParamsGetMatrixCoefficients :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> m Word32
    cicpParamsGetMatrixCoefficients a
    self = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gdk_cicp_params_get_matrix_coefficients self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsGetMatrixCoefficientsMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsGetMatrixCoefficientsMethodInfo a signature where
        overloadedMethod = cicpParamsGetMatrixCoefficients

    instance O.OverloadedMethodInfo CicpParamsGetMatrixCoefficientsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsGetMatrixCoefficients",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsGetMatrixCoefficients"
            })

    #endif

    -- method CicpParams::get_range
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCicpParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "CicpRange" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_get_range" gdk_cicp_params_get_range ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        IO CUInt

    -- | Gets the range property of /@self@/.
    --
    -- /Since: 4.16/
    cicpParamsGetRange ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCicpParams@
        -> m Gdk.Enums.CicpRange
        -- ^ __Returns:__ the range value
    cicpParamsGetRange :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> m CicpRange
    cicpParamsGetRange a
    self = IO CicpRange -> m CicpRange
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CicpRange -> m CicpRange) -> IO CicpRange -> m CicpRange
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gdk_cicp_params_get_range self'
        let result' = (Int -> CicpRange
    forall a. Enum a => Int -> a
    toEnum (Int -> CicpRange) -> (CUInt -> Int) -> CUInt -> CicpRange
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsGetRangeMethodInfo
    instance (signature ~ (m Gdk.Enums.CicpRange), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsGetRangeMethodInfo a signature where
        overloadedMethod = cicpParamsGetRange

    instance O.OverloadedMethodInfo CicpParamsGetRangeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsGetRange",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsGetRange"
            })

    #endif

    -- method CicpParams::get_transfer_function
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCicpParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_get_transfer_function" gdk_cicp_params_get_transfer_function ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        IO Word32

    -- | Gets the transfer-function property of /@self@/.
    --
    -- /Since: 4.16/
    cicpParamsGetTransferFunction ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCicpParams@
        -> m Word32
        -- ^ __Returns:__ the transfer-function value
    cicpParamsGetTransferFunction :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> m Word32
    cicpParamsGetTransferFunction a
    self = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gdk_cicp_params_get_transfer_function self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsGetTransferFunctionMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsGetTransferFunctionMethodInfo a signature where
        overloadedMethod = cicpParamsGetTransferFunction

    instance O.OverloadedMethodInfo CicpParamsGetTransferFunctionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsGetTransferFunction",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsGetTransferFunction"
            })

    #endif

    -- method CicpParams::set_color_primaries
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCicpParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "color_primaries"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new color primaries value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_set_color_primaries" gdk_cicp_params_set_color_primaries ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        Word32 ->                               -- color_primaries : TBasicType TUInt
        IO ()

    -- | Sets the color-primaries property of /@self@/.
    --
    -- /Since: 4.16/
    cicpParamsSetColorPrimaries ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCicpParams@
        -> Word32
        -- ^ /@colorPrimaries@/: the new color primaries value
        -> m ()
    cicpParamsSetColorPrimaries :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> Word32 -> m ()
    cicpParamsSetColorPrimaries a
    self Word32
    colorPrimaries = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gdk_cicp_params_set_color_primaries self' colorPrimaries
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsSetColorPrimariesMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsSetColorPrimariesMethodInfo a signature where
        overloadedMethod = cicpParamsSetColorPrimaries

    instance O.OverloadedMethodInfo CicpParamsSetColorPrimariesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsSetColorPrimaries",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsSetColorPrimaries"
            })

    #endif

    -- method CicpParams::set_matrix_coefficients
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "matrix_coefficients"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new matrix-coefficients value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_set_matrix_coefficients" gdk_cicp_params_set_matrix_coefficients ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        Word32 ->                               -- matrix_coefficients : TBasicType TUInt
        IO ()

    -- | /@self@/ a @GdkCicpParams@
    -- Sets the matrix-coefficients property of /@self@/.
    --
    -- /Since: 4.16/
    cicpParamsSetMatrixCoefficients ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -> Word32
        -- ^ /@matrixCoefficients@/: the new matrix-coefficients value
        -> m ()
    cicpParamsSetMatrixCoefficients :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> Word32 -> m ()
    cicpParamsSetMatrixCoefficients a
    self Word32
    matrixCoefficients = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gdk_cicp_params_set_matrix_coefficients self' matrixCoefficients
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsSetMatrixCoefficientsMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsSetMatrixCoefficientsMethodInfo a signature where
        overloadedMethod = cicpParamsSetMatrixCoefficients

    instance O.OverloadedMethodInfo CicpParamsSetMatrixCoefficientsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsSetMatrixCoefficients",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsSetMatrixCoefficients"
            })

    #endif

    -- method CicpParams::set_range
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCipParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "range"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpRange" }
    --           , argCType = Just "GdkCicpRange"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the range value" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_set_range" gdk_cicp_params_set_range ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        CUInt ->                                -- range : TInterface (Name {namespace = "Gdk", name = "CicpRange"})
        IO ()

    -- | Sets the range property of /@self@/
    --
    -- /Since: 4.16/
    cicpParamsSetRange ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCipParams@
        -> Gdk.Enums.CicpRange
        -- ^ /@range@/: the range value
        -> m ()
    cicpParamsSetRange :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> CicpRange -> m ()
    cicpParamsSetRange a
    self CicpRange
    range = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let range' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (CicpRange -> Int) -> CicpRange -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CicpRange -> Int
    forall a. Enum a => a -> Int
    fromEnum) CicpRange
    range
        gdk_cicp_params_set_range self' range'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsSetRangeMethodInfo
    instance (signature ~ (Gdk.Enums.CicpRange -> m ()), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsSetRangeMethodInfo a signature where
        overloadedMethod = cicpParamsSetRange

    instance O.OverloadedMethodInfo CicpParamsSetRangeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsSetRange",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsSetRange"
            })

    #endif

    -- method CicpParams::set_transfer_function
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "CicpParams" }
    --           , argCType = Just "GdkCicpParams*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `GdkCicpParams`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "transfer_function"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "guint"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new transfer-function value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_cicp_params_set_transfer_function" gdk_cicp_params_set_transfer_function ::
        Ptr CicpParams ->                       -- self : TInterface (Name {namespace = "Gdk", name = "CicpParams"})
        Word32 ->                               -- transfer_function : TBasicType TUInt
        IO ()

    -- | Sets the transfer-function property of /@self@/.
    --
    -- /Since: 4.16/
    cicpParamsSetTransferFunction ::
        (B.CallStack.HasCallStack, MonadIO m, IsCicpParams a) =>
        a
        -- ^ /@self@/: a @GdkCicpParams@
        -> Word32
        -- ^ /@transferFunction@/: the new transfer-function value
        -> m ()
    cicpParamsSetTransferFunction :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCicpParams a) =>
    a -> Word32 -> m ()
    cicpParamsSetTransferFunction a
    self Word32
    transferFunction = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr CicpParams)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gdk_cicp_params_set_transfer_function self' transferFunction
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data CicpParamsSetTransferFunctionMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsCicpParams a) => O.OverloadedMethod CicpParamsSetTransferFunctionMethodInfo a signature where
        overloadedMethod = cicpParamsSetTransferFunction

    instance O.OverloadedMethodInfo CicpParamsSetTransferFunctionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Objects.CicpParams.cicpParamsSetTransferFunction",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Objects-CicpParams.html#v:cicpParamsSetTransferFunction"
            })

    #endif