{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Provides information to interpret colors and pixels in a variety of ways.
-- 
-- They are also known as
-- <https://en.wikipedia.org/wiki/Color_space *color spaces*>.
-- 
-- Crucially, GTK knows how to convert colors from one color
-- state to another.
-- 
-- @GdkColorState@ objects are immutable and therefore threadsafe.
-- 
-- /Since: 4.16/

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

module GI.Gdk.Structs.ColorState
    ( 

-- * Exported types
    ColorState(..)                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [createCicpParams]("GI.Gdk.Structs.ColorState#g:method:createCicpParams"), [equal]("GI.Gdk.Structs.ColorState#g:method:equal"), [equivalent]("GI.Gdk.Structs.ColorState#g:method:equivalent"), [ref]("GI.Gdk.Structs.ColorState#g:method:ref"), [unref]("GI.Gdk.Structs.ColorState#g:method:unref").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveColorStateMethod                 ,
#endif

-- ** createCicpParams #method:createCicpParams#

#if defined(ENABLE_OVERLOADING)
    ColorStateCreateCicpParamsMethodInfo    ,
#endif
    colorStateCreateCicpParams              ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    ColorStateEqualMethodInfo               ,
#endif
    colorStateEqual                         ,


-- ** equivalent #method:equivalent#

#if defined(ENABLE_OVERLOADING)
    ColorStateEquivalentMethodInfo          ,
#endif
    colorStateEquivalent                    ,


-- ** getOklab #method:getOklab#

    colorStateGetOklab                      ,


-- ** getOklch #method:getOklch#

    colorStateGetOklch                      ,


-- ** getRec2100Linear #method:getRec2100Linear#

    colorStateGetRec2100Linear              ,


-- ** getRec2100Pq #method:getRec2100Pq#

    colorStateGetRec2100Pq                  ,


-- ** getSrgb #method:getSrgb#

    colorStateGetSrgb                       ,


-- ** getSrgbLinear #method:getSrgbLinear#

    colorStateGetSrgbLinear                 ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    ColorStateRefMethodInfo                 ,
#endif
    colorStateRef                           ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    ColorStateUnrefMethodInfo               ,
#endif
    colorStateUnref                         ,




    ) 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.Objects.CicpParams as Gdk.CicpParams

#else
import {-# SOURCE #-} qualified GI.Gdk.Objects.CicpParams as Gdk.CicpParams

#endif

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

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

foreign import ccall "gdk_color_state_get_type" c_gdk_color_state_get_type :: 
    IO GType

type instance O.ParentTypes ColorState = '[]
instance O.HasParentTypes ColorState

instance B.Types.TypedObject ColorState where
    glibType :: IO GType
glibType = IO GType
c_gdk_color_state_get_type

instance B.Types.GBoxed ColorState

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


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ColorState
type instance O.AttributeList ColorState = ColorStateAttributeList
type ColorStateAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

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

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

-- | Create a t'GI.Gdk.Objects.CicpParams.CicpParams' representing the colorstate.
-- 
-- It is not guaranteed that every @GdkColorState@ can be
-- represented with Cicp parameters. If that is the case,
-- this function returns @NULL@.
-- 
-- /Since: 4.16/
colorStateCreateCicpParams ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ColorState
    -- ^ /@self@/: a @GdkColorState@
    -> m (Maybe Gdk.CicpParams.CicpParams)
    -- ^ __Returns:__ A new t'GI.Gdk.Objects.CicpParams.CicpParams'
colorStateCreateCicpParams :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ColorState -> m (Maybe CicpParams)
colorStateCreateCicpParams ColorState
self = IO (Maybe CicpParams) -> m (Maybe CicpParams)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe CicpParams) -> m (Maybe CicpParams))
-> IO (Maybe CicpParams) -> m (Maybe CicpParams)
forall a b. (a -> b) -> a -> b
$ do
    self' <- ColorState -> IO (Ptr ColorState)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ColorState
self
    result <- gdk_color_state_create_cicp_params self'
    maybeResult <- convertIfNonNull result $ \Ptr CicpParams
result' -> do
        result'' <- ((ManagedPtr CicpParams -> CicpParams)
-> Ptr CicpParams -> IO CicpParams
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr CicpParams -> CicpParams
Gdk.CicpParams.CicpParams) Ptr CicpParams
result'
        return result''
    touchManagedPtr self
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data ColorStateCreateCicpParamsMethodInfo
instance (signature ~ (m (Maybe Gdk.CicpParams.CicpParams)), MonadIO m) => O.OverloadedMethod ColorStateCreateCicpParamsMethodInfo ColorState signature where
    overloadedMethod = colorStateCreateCicpParams

instance O.OverloadedMethodInfo ColorStateCreateCicpParamsMethodInfo ColorState where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.ColorState.colorStateCreateCicpParams",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Structs-ColorState.html#v:colorStateCreateCicpParams"
        })


#endif

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

foreign import ccall "gdk_color_state_equal" gdk_color_state_equal :: 
    Ptr ColorState ->                       -- self : TInterface (Name {namespace = "Gdk", name = "ColorState"})
    Ptr ColorState ->                       -- other : TInterface (Name {namespace = "Gdk", name = "ColorState"})
    IO CInt

-- | Compares two @GdkColorStates@ for equality.
-- 
-- Note that this function is not guaranteed to be perfect and two objects
-- describing the same color state may compare not equal. However, different
-- color states will never compare equal.
-- 
-- /Since: 4.16/
colorStateEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ColorState
    -- ^ /@self@/: a @GdkColorState@
    -> ColorState
    -- ^ /@other@/: another @GdkColorStatee@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the two color states compare equal
colorStateEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ColorState -> ColorState -> m Bool
colorStateEqual ColorState
self ColorState
other = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    self' <- ColorState -> IO (Ptr ColorState)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ColorState
self
    other' <- unsafeManagedPtrGetPtr other
    result <- gdk_color_state_equal self' other'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr self
    touchManagedPtr other
    return result'

#if defined(ENABLE_OVERLOADING)
data ColorStateEqualMethodInfo
instance (signature ~ (ColorState -> m Bool), MonadIO m) => O.OverloadedMethod ColorStateEqualMethodInfo ColorState signature where
    overloadedMethod = colorStateEqual

instance O.OverloadedMethodInfo ColorStateEqualMethodInfo ColorState where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.ColorState.colorStateEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Structs-ColorState.html#v:colorStateEqual"
        })


#endif

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

foreign import ccall "gdk_color_state_equivalent" gdk_color_state_equivalent :: 
    Ptr ColorState ->                       -- self : TInterface (Name {namespace = "Gdk", name = "ColorState"})
    Ptr ColorState ->                       -- other : TInterface (Name {namespace = "Gdk", name = "ColorState"})
    IO CInt

-- | Compares two @GdkColorStates@ for equivalence.
-- 
-- Two objects that represent the same color state should be equivalent,
-- even though they may not be equal in the sense of 'GI.Gdk.Structs.ColorState.colorStateEqual'.
-- 
-- /Since: 4.20/
colorStateEquivalent ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ColorState
    -- ^ /@self@/: a @GdkColorState@
    -> ColorState
    -- ^ /@other@/: another @GdkColorStatee@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the two color states are equivalent
colorStateEquivalent :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ColorState -> ColorState -> m Bool
colorStateEquivalent ColorState
self ColorState
other = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    self' <- ColorState -> IO (Ptr ColorState)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ColorState
self
    other' <- unsafeManagedPtrGetPtr other
    result <- gdk_color_state_equivalent self' other'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr self
    touchManagedPtr other
    return result'

#if defined(ENABLE_OVERLOADING)
data ColorStateEquivalentMethodInfo
instance (signature ~ (ColorState -> m Bool), MonadIO m) => O.OverloadedMethod ColorStateEquivalentMethodInfo ColorState signature where
    overloadedMethod = colorStateEquivalent

instance O.OverloadedMethodInfo ColorStateEquivalentMethodInfo ColorState where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.ColorState.colorStateEquivalent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Structs-ColorState.html#v:colorStateEquivalent"
        })


#endif

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

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

-- | Increase the reference count of /@self@/.
-- 
-- /Since: 4.16/
colorStateRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ColorState
    -- ^ /@self@/: a @GdkColorState@
    -> m ColorState
    -- ^ __Returns:__ the object that was passed in
colorStateRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ColorState -> m ColorState
colorStateRef ColorState
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' <- ColorState -> IO (Ptr ColorState)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ColorState
self
    result <- gdk_color_state_ref self'
    checkUnexpectedReturnNULL "colorStateRef" result
    result' <- (wrapBoxed ColorState) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data ColorStateRefMethodInfo
instance (signature ~ (m ColorState), MonadIO m) => O.OverloadedMethod ColorStateRefMethodInfo ColorState signature where
    overloadedMethod = colorStateRef

instance O.OverloadedMethodInfo ColorStateRefMethodInfo ColorState where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.ColorState.colorStateRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Structs-ColorState.html#v:colorStateRef"
        })


#endif

-- method ColorState::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ColorState" }
--           , argCType = Just "GdkColorState*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GdkColorState`" , 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_color_state_unref" gdk_color_state_unref :: 
    Ptr ColorState ->                       -- self : TInterface (Name {namespace = "Gdk", name = "ColorState"})
    IO ()

-- | Decrease the reference count of /@self@/.
-- 
-- Unless /@self@/ is static, it will be freed
-- when the reference count reaches zero.
-- 
-- /Since: 4.16/
colorStateUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ColorState
    -- ^ /@self@/: a @GdkColorState@
    -> m ()
colorStateUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ColorState -> m ()
colorStateUnref ColorState
self = 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' <- ColorState -> IO (Ptr ColorState)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ColorState
self
    gdk_color_state_unref self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data ColorStateUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ColorStateUnrefMethodInfo ColorState signature where
    overloadedMethod = colorStateUnref

instance O.OverloadedMethodInfo ColorStateUnrefMethodInfo ColorState where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.ColorState.colorStateUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk4-4.0.10/docs/GI-Gdk-Structs-ColorState.html#v:colorStateUnref"
        })


#endif

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

foreign import ccall "gdk_color_state_get_oklab" gdk_color_state_get_oklab :: 
    IO (Ptr ColorState)

-- | Returns the color state object representing the oklab color space.
-- 
-- This is a perceptually uniform color state.
-- 
-- /Since: 4.18/
colorStateGetOklab ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ColorState
    -- ^ __Returns:__ the color state object for oklab
colorStateGetOklab :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ColorState
colorStateGetOklab  = 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
    result <- IO (Ptr ColorState)
gdk_color_state_get_oklab
    checkUnexpectedReturnNULL "colorStateGetOklab" result
    result' <- (wrapBoxed ColorState) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gdk_color_state_get_oklch" gdk_color_state_get_oklch :: 
    IO (Ptr ColorState)

-- | Returns the color state object representing the oklch color space.
-- 
-- This is the polar variant of oklab, in which the hue is encoded as
-- a polar coordinate.
-- 
-- /Since: 4.18/
colorStateGetOklch ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ColorState
    -- ^ __Returns:__ the color state object for oklch
colorStateGetOklch :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ColorState
colorStateGetOklch  = 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
    result <- IO (Ptr ColorState)
gdk_color_state_get_oklch
    checkUnexpectedReturnNULL "colorStateGetOklch" result
    result' <- (wrapBoxed ColorState) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gdk_color_state_get_rec2100_linear" gdk_color_state_get_rec2100_linear :: 
    IO (Ptr ColorState)

-- | Returns the color state object representing the linear rec2100 color space.
-- 
-- This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and a linear
-- transfer function.
-- 
-- It is equivalent to the <http://developer.gnome.org/gdk/stable/class.CicpParams.html Cicp> tuple 9\/8\/0\/1.
-- 
-- See e.g. <https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-linear the CSS HDR Module>
-- for details about this colorstate.
-- 
-- /Since: 4.16/
colorStateGetRec2100Linear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ColorState
    -- ^ __Returns:__ the color state object for linearized rec2100
colorStateGetRec2100Linear :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ColorState
colorStateGetRec2100Linear  = 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
    result <- IO (Ptr ColorState)
gdk_color_state_get_rec2100_linear
    checkUnexpectedReturnNULL "colorStateGetRec2100Linear" result
    result' <- (wrapBoxed ColorState) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gdk_color_state_get_rec2100_pq" gdk_color_state_get_rec2100_pq :: 
    IO (Ptr ColorState)

-- | Returns the color state object representing the rec2100-pq color space.
-- 
-- This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and the transfer
-- function defined by SMPTE ST 2084 and BT.2100-2.
-- 
-- It is equivalent to the <http://developer.gnome.org/gdk/stable/class.CicpParams.html Cicp> tuple 9\/16\/0\/1.
-- 
-- See e.g. <https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-pq the CSS HDR Module>
-- for details about this colorstate.
-- 
-- /Since: 4.16/
colorStateGetRec2100Pq ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ColorState
    -- ^ __Returns:__ the color state object for rec2100-pq
colorStateGetRec2100Pq :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ColorState
colorStateGetRec2100Pq  = 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
    result <- IO (Ptr ColorState)
gdk_color_state_get_rec2100_pq
    checkUnexpectedReturnNULL "colorStateGetRec2100Pq" result
    result' <- (wrapBoxed ColorState) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gdk_color_state_get_srgb" gdk_color_state_get_srgb :: 
    IO (Ptr ColorState)

-- | Returns the color state object representing the sRGB color space.
-- 
-- This color state uses the primaries defined by BT.709-6 and the transfer function
-- defined by IEC 61966-2-1.
-- 
-- It is equivalent to the <http://developer.gnome.org/gdk/stable/class.CicpParams.html Cicp> tuple 1\/13\/0\/1.
-- 
-- See e.g. <https://www.w3.org/TR/css-color-4/#predefined-sRGB the CSS Color Module>
-- for details about this colorstate.
-- 
-- /Since: 4.16/
colorStateGetSrgb ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ColorState
    -- ^ __Returns:__ the color state object for sRGB
colorStateGetSrgb :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ColorState
colorStateGetSrgb  = 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
    result <- IO (Ptr ColorState)
gdk_color_state_get_srgb
    checkUnexpectedReturnNULL "colorStateGetSrgb" result
    result' <- (wrapBoxed ColorState) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gdk_color_state_get_srgb_linear" gdk_color_state_get_srgb_linear :: 
    IO (Ptr ColorState)

-- | Returns the color state object representing the linearized sRGB color space.
-- 
-- This color state uses the primaries defined by BT.709-6 and a linear transfer function.
-- 
-- It is equivalent to the <http://developer.gnome.org/gdk/stable/class.CicpParams.html Cicp> tuple 1\/8\/0\/1.
-- 
-- See e.g. <https://www.w3.org/TR/css-color-4/#predefined-sRGB-linear the CSS Color Module>
-- for details about this colorstate.
-- 
-- /Since: 4.16/
colorStateGetSrgbLinear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ColorState
    -- ^ __Returns:__ the color state object for linearized sRGB
colorStateGetSrgbLinear :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ColorState
colorStateGetSrgbLinear  = 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
    result <- IO (Ptr ColorState)
gdk_color_state_get_srgb_linear
    checkUnexpectedReturnNULL "colorStateGetSrgbLinear" result
    result' <- (wrapBoxed ColorState) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveColorStateMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveColorStateMethod "createCicpParams" o = ColorStateCreateCicpParamsMethodInfo
    ResolveColorStateMethod "equal" o = ColorStateEqualMethodInfo
    ResolveColorStateMethod "equivalent" o = ColorStateEquivalentMethodInfo
    ResolveColorStateMethod "ref" o = ColorStateRefMethodInfo
    ResolveColorStateMethod "unref" o = ColorStateUnrefMethodInfo
    ResolveColorStateMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveColorStateMethod t ColorState, O.OverloadedMethod info ColorState p) => OL.IsLabel t (ColorState -> 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 ~ ResolveColorStateMethod t ColorState, O.OverloadedMethod info ColorState p, R.HasField t ColorState p) => R.HasField t ColorState p where
    getField = O.overloadedMethod @info

#endif

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

#endif