{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Cogl.Structs.Color
(
Color(..) ,
newZeroColor ,
#if defined(ENABLE_OVERLOADING)
ResolveColorMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ColorCopyMethodInfo ,
#endif
colorCopy ,
colorEqual ,
#if defined(ENABLE_OVERLOADING)
ColorFreeMethodInfo ,
#endif
colorFree ,
#if defined(ENABLE_OVERLOADING)
ColorGetAlphaMethodInfo ,
#endif
colorGetAlpha ,
#if defined(ENABLE_OVERLOADING)
ColorGetAlphaByteMethodInfo ,
#endif
colorGetAlphaByte ,
#if defined(ENABLE_OVERLOADING)
ColorGetAlphaFloatMethodInfo ,
#endif
colorGetAlphaFloat ,
#if defined(ENABLE_OVERLOADING)
ColorGetBlueMethodInfo ,
#endif
colorGetBlue ,
#if defined(ENABLE_OVERLOADING)
ColorGetBlueByteMethodInfo ,
#endif
colorGetBlueByte ,
#if defined(ENABLE_OVERLOADING)
ColorGetBlueFloatMethodInfo ,
#endif
colorGetBlueFloat ,
#if defined(ENABLE_OVERLOADING)
ColorGetGreenMethodInfo ,
#endif
colorGetGreen ,
#if defined(ENABLE_OVERLOADING)
ColorGetGreenByteMethodInfo ,
#endif
colorGetGreenByte ,
#if defined(ENABLE_OVERLOADING)
ColorGetGreenFloatMethodInfo ,
#endif
colorGetGreenFloat ,
#if defined(ENABLE_OVERLOADING)
ColorGetRedMethodInfo ,
#endif
colorGetRed ,
#if defined(ENABLE_OVERLOADING)
ColorGetRedByteMethodInfo ,
#endif
colorGetRedByte ,
#if defined(ENABLE_OVERLOADING)
ColorGetRedFloatMethodInfo ,
#endif
colorGetRedFloat ,
#if defined(ENABLE_OVERLOADING)
ColorInitFrom4fMethodInfo ,
#endif
colorInitFrom4f ,
#if defined(ENABLE_OVERLOADING)
ColorInitFrom4fvMethodInfo ,
#endif
colorInitFrom4fv ,
#if defined(ENABLE_OVERLOADING)
ColorInitFrom4ubMethodInfo ,
#endif
colorInitFrom4ub ,
colorInitFromHsl ,
colorNew ,
#if defined(ENABLE_OVERLOADING)
ColorPremultiplyMethodInfo ,
#endif
colorPremultiply ,
#if defined(ENABLE_OVERLOADING)
ColorSetAlphaMethodInfo ,
#endif
colorSetAlpha ,
#if defined(ENABLE_OVERLOADING)
ColorSetAlphaByteMethodInfo ,
#endif
colorSetAlphaByte ,
#if defined(ENABLE_OVERLOADING)
ColorSetAlphaFloatMethodInfo ,
#endif
colorSetAlphaFloat ,
#if defined(ENABLE_OVERLOADING)
ColorSetBlueMethodInfo ,
#endif
colorSetBlue ,
#if defined(ENABLE_OVERLOADING)
ColorSetBlueByteMethodInfo ,
#endif
colorSetBlueByte ,
#if defined(ENABLE_OVERLOADING)
ColorSetBlueFloatMethodInfo ,
#endif
colorSetBlueFloat ,
#if defined(ENABLE_OVERLOADING)
ColorSetFrom4fMethodInfo ,
#endif
colorSetFrom4f ,
#if defined(ENABLE_OVERLOADING)
ColorSetFrom4ubMethodInfo ,
#endif
colorSetFrom4ub ,
#if defined(ENABLE_OVERLOADING)
ColorSetGreenMethodInfo ,
#endif
colorSetGreen ,
#if defined(ENABLE_OVERLOADING)
ColorSetGreenByteMethodInfo ,
#endif
colorSetGreenByte ,
#if defined(ENABLE_OVERLOADING)
ColorSetGreenFloatMethodInfo ,
#endif
colorSetGreenFloat ,
#if defined(ENABLE_OVERLOADING)
ColorSetRedMethodInfo ,
#endif
colorSetRed ,
#if defined(ENABLE_OVERLOADING)
ColorSetRedByteMethodInfo ,
#endif
colorSetRedByte ,
#if defined(ENABLE_OVERLOADING)
ColorSetRedFloatMethodInfo ,
#endif
colorSetRedFloat ,
#if defined(ENABLE_OVERLOADING)
ColorToHslMethodInfo ,
#endif
colorToHsl ,
#if defined(ENABLE_OVERLOADING)
ColorUnpremultiplyMethodInfo ,
#endif
colorUnpremultiply ,
) 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.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
newtype Color = Color (SP.ManagedPtr Color)
deriving (Color -> Color -> Bool
(Color -> Color -> Bool) -> (Color -> Color -> Bool) -> Eq Color
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Color -> Color -> Bool
== :: Color -> Color -> Bool
$c/= :: Color -> Color -> Bool
/= :: Color -> Color -> Bool
Eq)
instance SP.ManagedPtrNewtype Color where
toManagedPtr :: Color -> ManagedPtr Color
toManagedPtr (Color ManagedPtr Color
p) = ManagedPtr Color
p
foreign import ccall "cogl_color_get_gtype" c_cogl_color_get_gtype ::
IO GType
type instance O.ParentTypes Color = '[]
instance O.HasParentTypes Color
instance B.Types.TypedObject Color where
glibType :: IO GType
glibType = IO GType
c_cogl_color_get_gtype
instance B.Types.GBoxed Color
instance B.GValue.IsGValue (Maybe Color) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_cogl_color_get_gtype
gvalueSet_ :: Ptr GValue -> Maybe Color -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Color
P.Nothing = Ptr GValue -> Ptr Color -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Color
forall a. Ptr a
FP.nullPtr :: FP.Ptr Color)
gvalueSet_ Ptr GValue
gv (P.Just Color
obj) = Color -> (Ptr Color -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Color
obj (Ptr GValue -> Ptr Color -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Color)
gvalueGet_ Ptr GValue
gv = do
Ptr Color
ptr <- Ptr GValue -> IO (Ptr Color)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Color)
if Ptr Color
ptr Ptr Color -> Ptr Color -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Color
forall a. Ptr a
FP.nullPtr
then Color -> Maybe Color
forall a. a -> Maybe a
P.Just (Color -> Maybe Color) -> IO Color -> IO (Maybe Color)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Color -> Color
Color Ptr Color
ptr
else Maybe Color -> IO (Maybe Color)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Color
forall a. Maybe a
P.Nothing
newZeroColor :: MonadIO m => m Color
newZeroColor :: forall (m :: * -> *). MonadIO m => m Color
newZeroColor = IO Color -> m Color
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 IO (Ptr Color) -> (Ptr Color -> IO Color) -> IO Color
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Color
instance tag ~ 'AttrSet => Constructible Color tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Color -> Color) -> [AttrOp Color tag] -> m Color
new ManagedPtr Color -> Color
_ [AttrOp Color tag]
attrs = do
Color
o <- m Color
forall (m :: * -> *). MonadIO m => m Color
newZeroColor
Color -> [AttrOp Color 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Color
o [AttrOp Color tag]
[AttrOp Color 'AttrSet]
attrs
Color -> m Color
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Color
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Color
type instance O.AttributeList Color = ColorAttributeList
type ColorAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "cogl_color_new" cogl_color_new ::
IO (Ptr Color)
colorNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Color
colorNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Color
colorNew = IO Color -> m Color
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
result <- IO (Ptr Color)
cogl_color_new
Text -> Ptr Color -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"colorNew" Ptr Color
result
Color
result' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Color) Ptr Color
result
Color -> IO Color
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Color
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "cogl_color_copy" cogl_color_copy ::
Ptr Color ->
IO (Ptr Color)
colorCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Color
colorCopy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Color
colorCopy Color
color = IO Color -> m Color
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color
result <- Ptr Color -> IO (Ptr Color)
cogl_color_copy Ptr Color
color'
Text -> Ptr Color -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"colorCopy" Ptr Color
result
Color
result' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Color) Ptr Color
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Color -> IO Color
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Color
result'
#if defined(ENABLE_OVERLOADING)
data ColorCopyMethodInfo
instance (signature ~ (m Color), MonadIO m) => O.OverloadedMethod ColorCopyMethodInfo Color signature where
overloadedMethod = colorCopy
instance O.OverloadedMethodInfo ColorCopyMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorCopy"
})
#endif
foreign import ccall "cogl_color_free" cogl_color_free ::
Ptr Color ->
IO ()
colorFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m ()
colorFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m ()
colorFree Color
color = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> IO ()
cogl_color_free Ptr Color
color'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ColorFreeMethodInfo Color signature where
overloadedMethod = colorFree
instance O.OverloadedMethodInfo ColorFreeMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorFree"
})
#endif
foreign import ccall "cogl_color_get_alpha" cogl_color_get_alpha ::
Ptr Color ->
IO CFloat
colorGetAlpha ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetAlpha :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetAlpha Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_alpha Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetAlphaMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetAlphaMethodInfo Color signature where
overloadedMethod = colorGetAlpha
instance O.OverloadedMethodInfo ColorGetAlphaMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetAlpha",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetAlpha"
})
#endif
foreign import ccall "cogl_color_get_alpha_byte" cogl_color_get_alpha_byte ::
Ptr Color ->
IO Word8
colorGetAlphaByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Word8
colorGetAlphaByte :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Word8
colorGetAlphaByte Color
color = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Word8
result <- Ptr Color -> IO Word8
cogl_color_get_alpha_byte Ptr Color
color'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
data ColorGetAlphaByteMethodInfo
instance (signature ~ (m Word8), MonadIO m) => O.OverloadedMethod ColorGetAlphaByteMethodInfo Color signature where
overloadedMethod = colorGetAlphaByte
instance O.OverloadedMethodInfo ColorGetAlphaByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetAlphaByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetAlphaByte"
})
#endif
foreign import ccall "cogl_color_get_alpha_float" cogl_color_get_alpha_float ::
Ptr Color ->
IO CFloat
colorGetAlphaFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetAlphaFloat :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetAlphaFloat Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_alpha_float Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetAlphaFloatMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetAlphaFloatMethodInfo Color signature where
overloadedMethod = colorGetAlphaFloat
instance O.OverloadedMethodInfo ColorGetAlphaFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetAlphaFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetAlphaFloat"
})
#endif
foreign import ccall "cogl_color_get_blue" cogl_color_get_blue ::
Ptr Color ->
IO CFloat
colorGetBlue ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetBlue :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetBlue Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_blue Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetBlueMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetBlueMethodInfo Color signature where
overloadedMethod = colorGetBlue
instance O.OverloadedMethodInfo ColorGetBlueMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetBlue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetBlue"
})
#endif
foreign import ccall "cogl_color_get_blue_byte" cogl_color_get_blue_byte ::
Ptr Color ->
IO Word8
colorGetBlueByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Word8
colorGetBlueByte :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Word8
colorGetBlueByte Color
color = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Word8
result <- Ptr Color -> IO Word8
cogl_color_get_blue_byte Ptr Color
color'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
data ColorGetBlueByteMethodInfo
instance (signature ~ (m Word8), MonadIO m) => O.OverloadedMethod ColorGetBlueByteMethodInfo Color signature where
overloadedMethod = colorGetBlueByte
instance O.OverloadedMethodInfo ColorGetBlueByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetBlueByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetBlueByte"
})
#endif
foreign import ccall "cogl_color_get_blue_float" cogl_color_get_blue_float ::
Ptr Color ->
IO CFloat
colorGetBlueFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetBlueFloat :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetBlueFloat Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_blue_float Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetBlueFloatMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetBlueFloatMethodInfo Color signature where
overloadedMethod = colorGetBlueFloat
instance O.OverloadedMethodInfo ColorGetBlueFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetBlueFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetBlueFloat"
})
#endif
foreign import ccall "cogl_color_get_green" cogl_color_get_green ::
Ptr Color ->
IO CFloat
colorGetGreen ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetGreen :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetGreen Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_green Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetGreenMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetGreenMethodInfo Color signature where
overloadedMethod = colorGetGreen
instance O.OverloadedMethodInfo ColorGetGreenMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetGreen",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetGreen"
})
#endif
foreign import ccall "cogl_color_get_green_byte" cogl_color_get_green_byte ::
Ptr Color ->
IO Word8
colorGetGreenByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Word8
colorGetGreenByte :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Word8
colorGetGreenByte Color
color = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Word8
result <- Ptr Color -> IO Word8
cogl_color_get_green_byte Ptr Color
color'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
data ColorGetGreenByteMethodInfo
instance (signature ~ (m Word8), MonadIO m) => O.OverloadedMethod ColorGetGreenByteMethodInfo Color signature where
overloadedMethod = colorGetGreenByte
instance O.OverloadedMethodInfo ColorGetGreenByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetGreenByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetGreenByte"
})
#endif
foreign import ccall "cogl_color_get_green_float" cogl_color_get_green_float ::
Ptr Color ->
IO CFloat
colorGetGreenFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetGreenFloat :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetGreenFloat Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_green_float Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetGreenFloatMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetGreenFloatMethodInfo Color signature where
overloadedMethod = colorGetGreenFloat
instance O.OverloadedMethodInfo ColorGetGreenFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetGreenFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetGreenFloat"
})
#endif
foreign import ccall "cogl_color_get_red" cogl_color_get_red ::
Ptr Color ->
IO CFloat
colorGetRed ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetRed :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetRed Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_red Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetRedMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetRedMethodInfo Color signature where
overloadedMethod = colorGetRed
instance O.OverloadedMethodInfo ColorGetRedMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetRed",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetRed"
})
#endif
foreign import ccall "cogl_color_get_red_byte" cogl_color_get_red_byte ::
Ptr Color ->
IO Word8
colorGetRedByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Word8
colorGetRedByte :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Word8
colorGetRedByte Color
color = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Word8
result <- Ptr Color -> IO Word8
cogl_color_get_red_byte Ptr Color
color'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Word8 -> IO Word8
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
data ColorGetRedByteMethodInfo
instance (signature ~ (m Word8), MonadIO m) => O.OverloadedMethod ColorGetRedByteMethodInfo Color signature where
overloadedMethod = colorGetRedByte
instance O.OverloadedMethodInfo ColorGetRedByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetRedByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetRedByte"
})
#endif
foreign import ccall "cogl_color_get_red_float" cogl_color_get_red_float ::
Ptr Color ->
IO CFloat
colorGetRedFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m Float
colorGetRedFloat :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m Float
colorGetRedFloat Color
color = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
CFloat
result <- Ptr Color -> IO CFloat
cogl_color_get_red_float Ptr Color
color'
let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'
#if defined(ENABLE_OVERLOADING)
data ColorGetRedFloatMethodInfo
instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod ColorGetRedFloatMethodInfo Color signature where
overloadedMethod = colorGetRedFloat
instance O.OverloadedMethodInfo ColorGetRedFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorGetRedFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorGetRedFloat"
})
#endif
foreign import ccall "cogl_color_init_from_4f" cogl_color_init_from_4f ::
Ptr Color ->
CFloat ->
CFloat ->
CFloat ->
CFloat ->
IO ()
colorInitFrom4f ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> Float
-> Float
-> Float
-> m ()
colorInitFrom4f :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> Float -> Float -> Float -> m ()
colorInitFrom4f Color
color Float
red Float
green Float
blue Float
alpha = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let red' :: CFloat
red' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
red
let green' :: CFloat
green' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
green
let blue' :: CFloat
blue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blue
let alpha' :: CFloat
alpha' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
alpha
Ptr Color -> CFloat -> CFloat -> CFloat -> CFloat -> IO ()
cogl_color_init_from_4f Ptr Color
color' CFloat
red' CFloat
green' CFloat
blue' CFloat
alpha'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorInitFrom4fMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod ColorInitFrom4fMethodInfo Color signature where
overloadedMethod = colorInitFrom4f
instance O.OverloadedMethodInfo ColorInitFrom4fMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorInitFrom4f",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorInitFrom4f"
})
#endif
foreign import ccall "cogl_color_init_from_4fv" cogl_color_init_from_4fv ::
Ptr Color ->
CFloat ->
IO ()
colorInitFrom4fv ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorInitFrom4fv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorInitFrom4fv Color
color Float
colorArray = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let colorArray' :: CFloat
colorArray' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
colorArray
Ptr Color -> CFloat -> IO ()
cogl_color_init_from_4fv Ptr Color
color' CFloat
colorArray'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorInitFrom4fvMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorInitFrom4fvMethodInfo Color signature where
overloadedMethod = colorInitFrom4fv
instance O.OverloadedMethodInfo ColorInitFrom4fvMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorInitFrom4fv",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorInitFrom4fv"
})
#endif
foreign import ccall "cogl_color_init_from_4ub" cogl_color_init_from_4ub ::
Ptr Color ->
Word8 ->
Word8 ->
Word8 ->
Word8 ->
IO ()
colorInitFrom4ub ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Word8
-> Word8
-> Word8
-> Word8
-> m ()
colorInitFrom4ub :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Word8 -> Word8 -> Word8 -> Word8 -> m ()
colorInitFrom4ub Color
color Word8
red Word8
green Word8
blue Word8
alpha = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> Word8 -> Word8 -> Word8 -> Word8 -> IO ()
cogl_color_init_from_4ub Ptr Color
color' Word8
red Word8
green Word8
blue Word8
alpha
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorInitFrom4ubMethodInfo
instance (signature ~ (Word8 -> Word8 -> Word8 -> Word8 -> m ()), MonadIO m) => O.OverloadedMethod ColorInitFrom4ubMethodInfo Color signature where
overloadedMethod = colorInitFrom4ub
instance O.OverloadedMethodInfo ColorInitFrom4ubMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorInitFrom4ub",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorInitFrom4ub"
})
#endif
foreign import ccall "cogl_color_premultiply" cogl_color_premultiply ::
Ptr Color ->
IO ()
colorPremultiply ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m ()
colorPremultiply :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m ()
colorPremultiply Color
color = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> IO ()
cogl_color_premultiply Ptr Color
color'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorPremultiplyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ColorPremultiplyMethodInfo Color signature where
overloadedMethod = colorPremultiply
instance O.OverloadedMethodInfo ColorPremultiplyMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorPremultiply",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorPremultiply"
})
#endif
foreign import ccall "cogl_color_set_alpha" cogl_color_set_alpha ::
Ptr Color ->
CFloat ->
IO ()
colorSetAlpha ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetAlpha :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetAlpha Color
color Float
alpha = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let alpha' :: CFloat
alpha' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
alpha
Ptr Color -> CFloat -> IO ()
cogl_color_set_alpha Ptr Color
color' CFloat
alpha'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetAlphaMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetAlphaMethodInfo Color signature where
overloadedMethod = colorSetAlpha
instance O.OverloadedMethodInfo ColorSetAlphaMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetAlpha",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetAlpha"
})
#endif
foreign import ccall "cogl_color_set_alpha_byte" cogl_color_set_alpha_byte ::
Ptr Color ->
Word8 ->
IO ()
colorSetAlphaByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Word8
-> m ()
colorSetAlphaByte :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Word8 -> m ()
colorSetAlphaByte Color
color Word8
alpha = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> Word8 -> IO ()
cogl_color_set_alpha_byte Ptr Color
color' Word8
alpha
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetAlphaByteMethodInfo
instance (signature ~ (Word8 -> m ()), MonadIO m) => O.OverloadedMethod ColorSetAlphaByteMethodInfo Color signature where
overloadedMethod = colorSetAlphaByte
instance O.OverloadedMethodInfo ColorSetAlphaByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetAlphaByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetAlphaByte"
})
#endif
foreign import ccall "cogl_color_set_alpha_float" cogl_color_set_alpha_float ::
Ptr Color ->
CFloat ->
IO ()
colorSetAlphaFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetAlphaFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetAlphaFloat Color
color Float
alpha = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let alpha' :: CFloat
alpha' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
alpha
Ptr Color -> CFloat -> IO ()
cogl_color_set_alpha_float Ptr Color
color' CFloat
alpha'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetAlphaFloatMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetAlphaFloatMethodInfo Color signature where
overloadedMethod = colorSetAlphaFloat
instance O.OverloadedMethodInfo ColorSetAlphaFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetAlphaFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetAlphaFloat"
})
#endif
foreign import ccall "cogl_color_set_blue" cogl_color_set_blue ::
Ptr Color ->
CFloat ->
IO ()
colorSetBlue ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetBlue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetBlue Color
color Float
blue = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let blue' :: CFloat
blue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blue
Ptr Color -> CFloat -> IO ()
cogl_color_set_blue Ptr Color
color' CFloat
blue'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetBlueMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetBlueMethodInfo Color signature where
overloadedMethod = colorSetBlue
instance O.OverloadedMethodInfo ColorSetBlueMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetBlue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetBlue"
})
#endif
foreign import ccall "cogl_color_set_blue_byte" cogl_color_set_blue_byte ::
Ptr Color ->
Word8 ->
IO ()
colorSetBlueByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Word8
-> m ()
colorSetBlueByte :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Word8 -> m ()
colorSetBlueByte Color
color Word8
blue = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> Word8 -> IO ()
cogl_color_set_blue_byte Ptr Color
color' Word8
blue
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetBlueByteMethodInfo
instance (signature ~ (Word8 -> m ()), MonadIO m) => O.OverloadedMethod ColorSetBlueByteMethodInfo Color signature where
overloadedMethod = colorSetBlueByte
instance O.OverloadedMethodInfo ColorSetBlueByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetBlueByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetBlueByte"
})
#endif
foreign import ccall "cogl_color_set_blue_float" cogl_color_set_blue_float ::
Ptr Color ->
CFloat ->
IO ()
colorSetBlueFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetBlueFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetBlueFloat Color
color Float
blue = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let blue' :: CFloat
blue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blue
Ptr Color -> CFloat -> IO ()
cogl_color_set_blue_float Ptr Color
color' CFloat
blue'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetBlueFloatMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetBlueFloatMethodInfo Color signature where
overloadedMethod = colorSetBlueFloat
instance O.OverloadedMethodInfo ColorSetBlueFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetBlueFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetBlueFloat"
})
#endif
foreign import ccall "cogl_color_set_from_4f" cogl_color_set_from_4f ::
Ptr Color ->
CFloat ->
CFloat ->
CFloat ->
CFloat ->
IO ()
{-# DEPRECATED colorSetFrom4f ["(Since version 1.4)","Use cogl_color_init_from_4f instead."] #-}
colorSetFrom4f ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> Float
-> Float
-> Float
-> m ()
colorSetFrom4f :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> Float -> Float -> Float -> m ()
colorSetFrom4f Color
color Float
red Float
green Float
blue Float
alpha = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let red' :: CFloat
red' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
red
let green' :: CFloat
green' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
green
let blue' :: CFloat
blue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blue
let alpha' :: CFloat
alpha' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
alpha
Ptr Color -> CFloat -> CFloat -> CFloat -> CFloat -> IO ()
cogl_color_set_from_4f Ptr Color
color' CFloat
red' CFloat
green' CFloat
blue' CFloat
alpha'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetFrom4fMethodInfo
instance (signature ~ (Float -> Float -> Float -> Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetFrom4fMethodInfo Color signature where
overloadedMethod = colorSetFrom4f
instance O.OverloadedMethodInfo ColorSetFrom4fMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetFrom4f",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetFrom4f"
})
#endif
foreign import ccall "cogl_color_set_from_4ub" cogl_color_set_from_4ub ::
Ptr Color ->
Word8 ->
Word8 ->
Word8 ->
Word8 ->
IO ()
{-# DEPRECATED colorSetFrom4ub ["(Since version 1.4)","Use cogl_color_init_from_4ub instead."] #-}
colorSetFrom4ub ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Word8
-> Word8
-> Word8
-> Word8
-> m ()
colorSetFrom4ub :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Word8 -> Word8 -> Word8 -> Word8 -> m ()
colorSetFrom4ub Color
color Word8
red Word8
green Word8
blue Word8
alpha = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> Word8 -> Word8 -> Word8 -> Word8 -> IO ()
cogl_color_set_from_4ub Ptr Color
color' Word8
red Word8
green Word8
blue Word8
alpha
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetFrom4ubMethodInfo
instance (signature ~ (Word8 -> Word8 -> Word8 -> Word8 -> m ()), MonadIO m) => O.OverloadedMethod ColorSetFrom4ubMethodInfo Color signature where
overloadedMethod = colorSetFrom4ub
instance O.OverloadedMethodInfo ColorSetFrom4ubMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetFrom4ub",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetFrom4ub"
})
#endif
foreign import ccall "cogl_color_set_green" cogl_color_set_green ::
Ptr Color ->
CFloat ->
IO ()
colorSetGreen ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetGreen :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetGreen Color
color Float
green = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let green' :: CFloat
green' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
green
Ptr Color -> CFloat -> IO ()
cogl_color_set_green Ptr Color
color' CFloat
green'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetGreenMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetGreenMethodInfo Color signature where
overloadedMethod = colorSetGreen
instance O.OverloadedMethodInfo ColorSetGreenMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetGreen",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetGreen"
})
#endif
foreign import ccall "cogl_color_set_green_byte" cogl_color_set_green_byte ::
Ptr Color ->
Word8 ->
IO ()
colorSetGreenByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Word8
-> m ()
colorSetGreenByte :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Word8 -> m ()
colorSetGreenByte Color
color Word8
green = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> Word8 -> IO ()
cogl_color_set_green_byte Ptr Color
color' Word8
green
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetGreenByteMethodInfo
instance (signature ~ (Word8 -> m ()), MonadIO m) => O.OverloadedMethod ColorSetGreenByteMethodInfo Color signature where
overloadedMethod = colorSetGreenByte
instance O.OverloadedMethodInfo ColorSetGreenByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetGreenByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetGreenByte"
})
#endif
foreign import ccall "cogl_color_set_green_float" cogl_color_set_green_float ::
Ptr Color ->
CFloat ->
IO ()
colorSetGreenFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetGreenFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetGreenFloat Color
color Float
green = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let green' :: CFloat
green' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
green
Ptr Color -> CFloat -> IO ()
cogl_color_set_green_float Ptr Color
color' CFloat
green'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetGreenFloatMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetGreenFloatMethodInfo Color signature where
overloadedMethod = colorSetGreenFloat
instance O.OverloadedMethodInfo ColorSetGreenFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetGreenFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetGreenFloat"
})
#endif
foreign import ccall "cogl_color_set_red" cogl_color_set_red ::
Ptr Color ->
CFloat ->
IO ()
colorSetRed ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetRed :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetRed Color
color Float
red = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let red' :: CFloat
red' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
red
Ptr Color -> CFloat -> IO ()
cogl_color_set_red Ptr Color
color' CFloat
red'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetRedMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetRedMethodInfo Color signature where
overloadedMethod = colorSetRed
instance O.OverloadedMethodInfo ColorSetRedMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetRed",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetRed"
})
#endif
foreign import ccall "cogl_color_set_red_byte" cogl_color_set_red_byte ::
Ptr Color ->
Word8 ->
IO ()
colorSetRedByte ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Word8
-> m ()
colorSetRedByte :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Word8 -> m ()
colorSetRedByte Color
color Word8
red = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> Word8 -> IO ()
cogl_color_set_red_byte Ptr Color
color' Word8
red
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetRedByteMethodInfo
instance (signature ~ (Word8 -> m ()), MonadIO m) => O.OverloadedMethod ColorSetRedByteMethodInfo Color signature where
overloadedMethod = colorSetRedByte
instance O.OverloadedMethodInfo ColorSetRedByteMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetRedByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetRedByte"
})
#endif
foreign import ccall "cogl_color_set_red_float" cogl_color_set_red_float ::
Ptr Color ->
CFloat ->
IO ()
colorSetRedFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> Float
-> m ()
colorSetRedFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> Float -> m ()
colorSetRedFloat Color
color Float
red = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
let red' :: CFloat
red' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
red
Ptr Color -> CFloat -> IO ()
cogl_color_set_red_float Ptr Color
color' CFloat
red'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorSetRedFloatMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod ColorSetRedFloatMethodInfo Color signature where
overloadedMethod = colorSetRedFloat
instance O.OverloadedMethodInfo ColorSetRedFloatMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorSetRedFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorSetRedFloat"
})
#endif
foreign import ccall "cogl_color_to_hsl" cogl_color_to_hsl ::
Ptr Color ->
Ptr CFloat ->
Ptr CFloat ->
Ptr CFloat ->
IO ()
colorToHsl ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m ((Float, Float, Float))
colorToHsl :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Color -> m (Float, Float, Float)
colorToHsl Color
color = IO (Float, Float, Float) -> m (Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float) -> m (Float, Float, Float))
-> IO (Float, Float, Float) -> m (Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr CFloat
hue <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
saturation <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr CFloat
luminance <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
Ptr Color -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> IO ()
cogl_color_to_hsl Ptr Color
color' Ptr CFloat
hue Ptr CFloat
saturation Ptr CFloat
luminance
CFloat
hue' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
hue
let hue'' :: Float
hue'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
hue'
CFloat
saturation' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
saturation
let saturation'' :: Float
saturation'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
saturation'
CFloat
luminance' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
luminance
let luminance'' :: Float
luminance'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
luminance'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
hue
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
saturation
Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
luminance
(Float, Float, Float) -> IO (Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
hue'', Float
saturation'', Float
luminance'')
#if defined(ENABLE_OVERLOADING)
data ColorToHslMethodInfo
instance (signature ~ (m ((Float, Float, Float))), MonadIO m) => O.OverloadedMethod ColorToHslMethodInfo Color signature where
overloadedMethod = colorToHsl
instance O.OverloadedMethodInfo ColorToHslMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorToHsl",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorToHsl"
})
#endif
foreign import ccall "cogl_color_unpremultiply" cogl_color_unpremultiply ::
Ptr Color ->
IO ()
colorUnpremultiply ::
(B.CallStack.HasCallStack, MonadIO m) =>
Color
-> m ()
colorUnpremultiply :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Color -> m ()
colorUnpremultiply Color
color = 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
Ptr Color
color' <- Color -> IO (Ptr Color)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Color
color
Ptr Color -> IO ()
cogl_color_unpremultiply Ptr Color
color'
Color -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Color
color
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ColorUnpremultiplyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ColorUnpremultiplyMethodInfo Color signature where
overloadedMethod = colorUnpremultiply
instance O.OverloadedMethodInfo ColorUnpremultiplyMethodInfo Color where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Cogl.Structs.Color.colorUnpremultiply",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-cogl-1.0.3/docs/GI-Cogl-Structs-Color.html#v:colorUnpremultiply"
})
#endif
foreign import ccall "cogl_color_equal" cogl_color_equal ::
Ptr () ->
Ptr () ->
IO Int32
colorEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> Ptr ()
-> m Int32
colorEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Ptr () -> Ptr () -> m Int32
colorEqual Ptr ()
v1 Ptr ()
v2 = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Int32
result <- Ptr () -> Ptr () -> IO Int32
cogl_color_equal Ptr ()
v1 Ptr ()
v2
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "cogl_color_init_from_hsl" cogl_color_init_from_hsl ::
Ptr Color ->
CFloat ->
CFloat ->
CFloat ->
IO ()
colorInitFromHsl ::
(B.CallStack.HasCallStack, MonadIO m) =>
Float
-> Float
-> Float
-> m (Color)
colorInitFromHsl :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Float -> Float -> Float -> m Color
colorInitFromHsl Float
hue Float
saturation Float
luminance = IO Color -> m Color
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Color -> m Color) -> IO Color -> m Color
forall a b. (a -> b) -> a -> b
$ do
Ptr Color
color <- Int -> IO (Ptr Color)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Color)
let hue' :: CFloat
hue' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
hue
let saturation' :: CFloat
saturation' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
saturation
let luminance' :: CFloat
luminance' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
luminance
Ptr Color -> CFloat -> CFloat -> CFloat -> IO ()
cogl_color_init_from_hsl Ptr Color
color CFloat
hue' CFloat
saturation' CFloat
luminance'
Color
color' <- ((ManagedPtr Color -> Color) -> Ptr Color -> IO Color
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Color -> Color
Color) Ptr Color
color
Color -> IO Color
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Color
color'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveColorMethod (t :: Symbol) (o :: *) :: * where
ResolveColorMethod "copy" o = ColorCopyMethodInfo
ResolveColorMethod "free" o = ColorFreeMethodInfo
ResolveColorMethod "initFrom4f" o = ColorInitFrom4fMethodInfo
ResolveColorMethod "initFrom4fv" o = ColorInitFrom4fvMethodInfo
ResolveColorMethod "initFrom4ub" o = ColorInitFrom4ubMethodInfo
ResolveColorMethod "premultiply" o = ColorPremultiplyMethodInfo
ResolveColorMethod "toHsl" o = ColorToHslMethodInfo
ResolveColorMethod "unpremultiply" o = ColorUnpremultiplyMethodInfo
ResolveColorMethod "getAlpha" o = ColorGetAlphaMethodInfo
ResolveColorMethod "getAlphaByte" o = ColorGetAlphaByteMethodInfo
ResolveColorMethod "getAlphaFloat" o = ColorGetAlphaFloatMethodInfo
ResolveColorMethod "getBlue" o = ColorGetBlueMethodInfo
ResolveColorMethod "getBlueByte" o = ColorGetBlueByteMethodInfo
ResolveColorMethod "getBlueFloat" o = ColorGetBlueFloatMethodInfo
ResolveColorMethod "getGreen" o = ColorGetGreenMethodInfo
ResolveColorMethod "getGreenByte" o = ColorGetGreenByteMethodInfo
ResolveColorMethod "getGreenFloat" o = ColorGetGreenFloatMethodInfo
ResolveColorMethod "getRed" o = ColorGetRedMethodInfo
ResolveColorMethod "getRedByte" o = ColorGetRedByteMethodInfo
ResolveColorMethod "getRedFloat" o = ColorGetRedFloatMethodInfo
ResolveColorMethod "setAlpha" o = ColorSetAlphaMethodInfo
ResolveColorMethod "setAlphaByte" o = ColorSetAlphaByteMethodInfo
ResolveColorMethod "setAlphaFloat" o = ColorSetAlphaFloatMethodInfo
ResolveColorMethod "setBlue" o = ColorSetBlueMethodInfo
ResolveColorMethod "setBlueByte" o = ColorSetBlueByteMethodInfo
ResolveColorMethod "setBlueFloat" o = ColorSetBlueFloatMethodInfo
ResolveColorMethod "setFrom4f" o = ColorSetFrom4fMethodInfo
ResolveColorMethod "setFrom4ub" o = ColorSetFrom4ubMethodInfo
ResolveColorMethod "setGreen" o = ColorSetGreenMethodInfo
ResolveColorMethod "setGreenByte" o = ColorSetGreenByteMethodInfo
ResolveColorMethod "setGreenFloat" o = ColorSetGreenFloatMethodInfo
ResolveColorMethod "setRed" o = ColorSetRedMethodInfo
ResolveColorMethod "setRedByte" o = ColorSetRedByteMethodInfo
ResolveColorMethod "setRedFloat" o = ColorSetRedFloatMethodInfo
ResolveColorMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveColorMethod t Color, O.OverloadedMethod info Color p) => OL.IsLabel t (Color -> 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 ~ ResolveColorMethod t Color, O.OverloadedMethod info Color p, R.HasField t Color p) => R.HasField t Color p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveColorMethod t Color, O.OverloadedMethodInfo info Color) => OL.IsLabel t (O.MethodProxy info Color) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif