-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.Gsk.Functions
    ( 

 -- * Methods
-- ** blendNodeGetBlendMode #method:blendNodeGetBlendMode#

    blendNodeGetBlendMode                   ,


-- ** blendNodeGetBottomChild #method:blendNodeGetBottomChild#

    blendNodeGetBottomChild                 ,


-- ** blendNodeGetTopChild #method:blendNodeGetTopChild#

    blendNodeGetTopChild                    ,


-- ** blendNodeNew #method:blendNodeNew#

    blendNodeNew                            ,


-- ** blurNodeGetChild #method:blurNodeGetChild#

    blurNodeGetChild                        ,


-- ** blurNodeGetRadius #method:blurNodeGetRadius#

    blurNodeGetRadius                       ,


-- ** blurNodeNew #method:blurNodeNew#

    blurNodeNew                             ,


-- ** borderNodeNew #method:borderNodeNew#

    borderNodeNew                           ,


-- ** borderNodePeekColors #method:borderNodePeekColors#

    borderNodePeekColors                    ,


-- ** borderNodePeekOutline #method:borderNodePeekOutline#

    borderNodePeekOutline                   ,


-- ** borderNodePeekWidths #method:borderNodePeekWidths#

    borderNodePeekWidths                    ,


-- ** cairoNodeGetDrawContext #method:cairoNodeGetDrawContext#

    cairoNodeGetDrawContext                 ,


-- ** cairoNodeNew #method:cairoNodeNew#

    cairoNodeNew                            ,


-- ** cairoNodePeekSurface #method:cairoNodePeekSurface#

    cairoNodePeekSurface                    ,


-- ** clipNodeGetChild #method:clipNodeGetChild#

    clipNodeGetChild                        ,


-- ** clipNodeNew #method:clipNodeNew#

    clipNodeNew                             ,


-- ** clipNodePeekClip #method:clipNodePeekClip#

    clipNodePeekClip                        ,


-- ** colorMatrixNodeGetChild #method:colorMatrixNodeGetChild#

    colorMatrixNodeGetChild                 ,


-- ** colorMatrixNodeNew #method:colorMatrixNodeNew#

    colorMatrixNodeNew                      ,


-- ** colorMatrixNodePeekColorMatrix #method:colorMatrixNodePeekColorMatrix#

    colorMatrixNodePeekColorMatrix          ,


-- ** colorMatrixNodePeekColorOffset #method:colorMatrixNodePeekColorOffset#

    colorMatrixNodePeekColorOffset          ,


-- ** colorNodeNew #method:colorNodeNew#

    colorNodeNew                            ,


-- ** colorNodePeekColor #method:colorNodePeekColor#

    colorNodePeekColor                      ,


-- ** containerNodeGetChild #method:containerNodeGetChild#

    containerNodeGetChild                   ,


-- ** containerNodeGetNChildren #method:containerNodeGetNChildren#

    containerNodeGetNChildren               ,


-- ** containerNodeNew #method:containerNodeNew#

    containerNodeNew                        ,


-- ** crossFadeNodeGetEndChild #method:crossFadeNodeGetEndChild#

    crossFadeNodeGetEndChild                ,


-- ** crossFadeNodeGetProgress #method:crossFadeNodeGetProgress#

    crossFadeNodeGetProgress                ,


-- ** crossFadeNodeGetStartChild #method:crossFadeNodeGetStartChild#

    crossFadeNodeGetStartChild              ,


-- ** crossFadeNodeNew #method:crossFadeNodeNew#

    crossFadeNodeNew                        ,


-- ** debugNodeGetChild #method:debugNodeGetChild#

    debugNodeGetChild                       ,


-- ** debugNodeGetMessage #method:debugNodeGetMessage#

    debugNodeGetMessage                     ,


-- ** debugNodeNew #method:debugNodeNew#

    debugNodeNew                            ,


-- ** insetShadowNodeGetBlurRadius #method:insetShadowNodeGetBlurRadius#

    insetShadowNodeGetBlurRadius            ,


-- ** insetShadowNodeGetDx #method:insetShadowNodeGetDx#

    insetShadowNodeGetDx                    ,


-- ** insetShadowNodeGetDy #method:insetShadowNodeGetDy#

    insetShadowNodeGetDy                    ,


-- ** insetShadowNodeGetSpread #method:insetShadowNodeGetSpread#

    insetShadowNodeGetSpread                ,


-- ** insetShadowNodeNew #method:insetShadowNodeNew#

    insetShadowNodeNew                      ,


-- ** insetShadowNodePeekColor #method:insetShadowNodePeekColor#

    insetShadowNodePeekColor                ,


-- ** insetShadowNodePeekOutline #method:insetShadowNodePeekOutline#

    insetShadowNodePeekOutline              ,


-- ** linearGradientNodeGetNColorStops #method:linearGradientNodeGetNColorStops#

    linearGradientNodeGetNColorStops        ,


-- ** linearGradientNodeNew #method:linearGradientNodeNew#

    linearGradientNodeNew                   ,


-- ** linearGradientNodePeekColorStops #method:linearGradientNodePeekColorStops#

    linearGradientNodePeekColorStops        ,


-- ** linearGradientNodePeekEnd #method:linearGradientNodePeekEnd#

    linearGradientNodePeekEnd               ,


-- ** linearGradientNodePeekStart #method:linearGradientNodePeekStart#

    linearGradientNodePeekStart             ,


-- ** opacityNodeGetChild #method:opacityNodeGetChild#

    opacityNodeGetChild                     ,


-- ** opacityNodeGetOpacity #method:opacityNodeGetOpacity#

    opacityNodeGetOpacity                   ,


-- ** opacityNodeNew #method:opacityNodeNew#

    opacityNodeNew                          ,


-- ** outsetShadowNodeGetBlurRadius #method:outsetShadowNodeGetBlurRadius#

    outsetShadowNodeGetBlurRadius           ,


-- ** outsetShadowNodeGetDx #method:outsetShadowNodeGetDx#

    outsetShadowNodeGetDx                   ,


-- ** outsetShadowNodeGetDy #method:outsetShadowNodeGetDy#

    outsetShadowNodeGetDy                   ,


-- ** outsetShadowNodeGetSpread #method:outsetShadowNodeGetSpread#

    outsetShadowNodeGetSpread               ,


-- ** outsetShadowNodeNew #method:outsetShadowNodeNew#

    outsetShadowNodeNew                     ,


-- ** outsetShadowNodePeekColor #method:outsetShadowNodePeekColor#

    outsetShadowNodePeekColor               ,


-- ** outsetShadowNodePeekOutline #method:outsetShadowNodePeekOutline#

    outsetShadowNodePeekOutline             ,


-- ** repeatNodeGetChild #method:repeatNodeGetChild#

    repeatNodeGetChild                      ,


-- ** repeatNodeNew #method:repeatNodeNew#

    repeatNodeNew                           ,


-- ** repeatNodePeekChildBounds #method:repeatNodePeekChildBounds#

    repeatNodePeekChildBounds               ,


-- ** repeatingLinearGradientNodeNew #method:repeatingLinearGradientNodeNew#

    repeatingLinearGradientNodeNew          ,


-- ** roundedClipNodeGetChild #method:roundedClipNodeGetChild#

    roundedClipNodeGetChild                 ,


-- ** roundedClipNodeNew #method:roundedClipNodeNew#

    roundedClipNodeNew                      ,


-- ** roundedClipNodePeekClip #method:roundedClipNodePeekClip#

    roundedClipNodePeekClip                 ,


-- ** textNodeGetNumGlyphs #method:textNodeGetNumGlyphs#

    textNodeGetNumGlyphs                    ,


-- ** textNodeGetX #method:textNodeGetX#

    textNodeGetX                            ,


-- ** textNodeGetY #method:textNodeGetY#

    textNodeGetY                            ,


-- ** textNodeNew #method:textNodeNew#

    textNodeNew                             ,


-- ** textNodePeekColor #method:textNodePeekColor#

    textNodePeekColor                       ,


-- ** textNodePeekFont #method:textNodePeekFont#

    textNodePeekFont                        ,


-- ** textNodePeekGlyphs #method:textNodePeekGlyphs#

    textNodePeekGlyphs                      ,


-- ** textureNodeGetTexture #method:textureNodeGetTexture#

    textureNodeGetTexture                   ,


-- ** textureNodeNew #method:textureNodeNew#

    textureNodeNew                          ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
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 GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.Gdk.Objects.Texture as Gdk.Texture
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
import qualified GI.Graphene.Structs.Point as Graphene.Point
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4
import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums
import {-# SOURCE #-} qualified GI.Gsk.Structs.ColorStop as Gsk.ColorStop
import {-# SOURCE #-} qualified GI.Gsk.Structs.RenderNode as Gsk.RenderNode
import {-# SOURCE #-} qualified GI.Gsk.Structs.RoundedRect as Gsk.RoundedRect
import qualified GI.Pango.Objects.Font as Pango.Font
import qualified GI.Pango.Structs.GlyphInfo as Pango.GlyphInfo
import qualified GI.Pango.Structs.GlyphString as Pango.GlyphString

-- function gsk_texture_node_new
-- Args: [ Arg
--           { argCName = "texture"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Texture" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GdkTexture" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rectangle to render the texture into"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_texture_node_new" gsk_texture_node_new :: 
    Ptr Gdk.Texture.Texture ->              -- texture : TInterface (Name {namespace = "Gdk", name = "Texture"})
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will render the given
-- /@texture@/ into the area given by /@bounds@/.
textureNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gdk.Texture.IsTexture a) =>
    a
    -- ^ /@texture@/: the t'GI.Gdk.Objects.Texture.Texture'
    -> Graphene.Rect.Rect
    -- ^ /@bounds@/: the rectangle to render the texture into
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
textureNodeNew :: a -> Rect -> m RenderNode
textureNodeNew texture :: a
texture bounds :: Rect
bounds = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Texture
texture' <- a -> IO (Ptr Texture)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
texture
    Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
    Ptr RenderNode
result <- Ptr Texture -> Ptr Rect -> IO (Ptr RenderNode)
gsk_texture_node_new Ptr Texture
texture' Ptr Rect
bounds'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "textureNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
texture
    Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_texture_node_get_texture
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GskRenderNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Texture" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_texture_node_get_texture" gsk_texture_node_get_texture :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gdk.Texture.Texture)

-- | /No description available in the introspection data./
textureNodeGetTexture ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a t'GI.Gsk.Structs.RenderNode.RenderNode'
    -> m Gdk.Texture.Texture
    -- ^ __Returns:__ the t'GI.Gdk.Objects.Texture.Texture'
textureNodeGetTexture :: RenderNode -> m Texture
textureNodeGetTexture node :: RenderNode
node = IO Texture -> m Texture
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Texture -> m Texture) -> IO Texture -> m Texture
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Texture
result <- Ptr RenderNode -> IO (Ptr Texture)
gsk_texture_node_get_texture Ptr RenderNode
node'
    Text -> Ptr Texture -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "textureNodeGetTexture" Ptr Texture
result
    Texture
result' <- ((ManagedPtr Texture -> Texture) -> Ptr Texture -> IO Texture
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Texture -> Texture
Gdk.Texture.Texture) Ptr Texture
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Texture -> IO Texture
forall (m :: * -> *) a. Monad m => a -> m a
return Texture
result'


-- function gsk_text_node_peek_glyphs
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "GlyphInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_text_node_peek_glyphs" gsk_text_node_peek_glyphs :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Pango.GlyphInfo.GlyphInfo)

-- | /No description available in the introspection data./
textNodePeekGlyphs ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Pango.GlyphInfo.GlyphInfo
textNodePeekGlyphs :: RenderNode -> m GlyphInfo
textNodePeekGlyphs node :: RenderNode
node = IO GlyphInfo -> m GlyphInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GlyphInfo -> m GlyphInfo) -> IO GlyphInfo -> m GlyphInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr GlyphInfo
result <- Ptr RenderNode -> IO (Ptr GlyphInfo)
gsk_text_node_peek_glyphs Ptr RenderNode
node'
    Text -> Ptr GlyphInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "textNodePeekGlyphs" Ptr GlyphInfo
result
    GlyphInfo
result' <- ((ManagedPtr GlyphInfo -> GlyphInfo)
-> Ptr GlyphInfo -> IO GlyphInfo
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr GlyphInfo -> GlyphInfo
Pango.GlyphInfo.GlyphInfo) Ptr GlyphInfo
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    GlyphInfo -> IO GlyphInfo
forall (m :: * -> *) a. Monad m => a -> m a
return GlyphInfo
result'


-- function gsk_text_node_peek_font
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Font" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_text_node_peek_font" gsk_text_node_peek_font :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Pango.Font.Font)

-- | /No description available in the introspection data./
textNodePeekFont ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Pango.Font.Font
textNodePeekFont :: RenderNode -> m Font
textNodePeekFont node :: RenderNode
node = IO Font -> m Font
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Font -> m Font) -> IO Font -> m Font
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Font
result <- Ptr RenderNode -> IO (Ptr Font)
gsk_text_node_peek_font Ptr RenderNode
node'
    Text -> Ptr Font -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "textNodePeekFont" Ptr Font
result
    Font
result' <- ((ManagedPtr Font -> Font) -> Ptr Font -> IO Font
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Font -> Font
Pango.Font.Font) Ptr Font
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Font -> IO Font
forall (m :: * -> *) a. Monad m => a -> m a
return Font
result'


-- function gsk_text_node_peek_color
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "RGBA" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_text_node_peek_color" gsk_text_node_peek_color :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gdk.RGBA.RGBA)

-- | /No description available in the introspection data./
textNodePeekColor ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gdk.RGBA.RGBA
textNodePeekColor :: RenderNode -> m RGBA
textNodePeekColor node :: RenderNode
node = IO RGBA -> m RGBA
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RGBA
result <- Ptr RenderNode -> IO (Ptr RGBA)
gsk_text_node_peek_color Ptr RenderNode
node'
    Text -> Ptr RGBA -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "textNodePeekColor" Ptr RGBA
result
    RGBA
result' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RGBA -> IO RGBA
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
result'


-- function gsk_text_node_new
-- Args: [ Arg
--           { argCName = "font"
--           , argType = TInterface Name { namespace = "Pango" , name = "Font" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #PangoFont containing the glyphs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "glyphs"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "GlyphString" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #PangoGlyphString to render"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the foreground color to render with"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the x coordinate at which to put the baseline"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the y coordinate at wihch to put the baseline"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_text_node_new" gsk_text_node_new :: 
    Ptr Pango.Font.Font ->                  -- font : TInterface (Name {namespace = "Pango", name = "Font"})
    Ptr Pango.GlyphString.GlyphString ->    -- glyphs : TInterface (Name {namespace = "Pango", name = "GlyphString"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    CFloat ->                               -- x : TBasicType TFloat
    CFloat ->                               -- y : TBasicType TFloat
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a render node that renders the given glyphs,
-- Note that /@color@/ may not be used if the font contains
-- color glyphs.
textNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m, Pango.Font.IsFont a) =>
    a
    -- ^ /@font@/: the t'GI.Pango.Objects.Font.Font' containing the glyphs
    -> Pango.GlyphString.GlyphString
    -- ^ /@glyphs@/: the t'GI.Pango.Structs.GlyphString.GlyphString' to render
    -> Gdk.RGBA.RGBA
    -- ^ /@color@/: the foreground color to render with
    -> Float
    -- ^ /@x@/: the x coordinate at which to put the baseline
    -> Float
    -- ^ /@y@/: the y coordinate at wihch to put the baseline
    -> m (Maybe Gsk.RenderNode.RenderNode)
    -- ^ __Returns:__ a new text node, or 'P.Nothing'
textNodeNew :: a -> GlyphString -> RGBA -> Float -> Float -> m (Maybe RenderNode)
textNodeNew font :: a
font glyphs :: GlyphString
glyphs color :: RGBA
color x :: Float
x y :: Float
y = IO (Maybe RenderNode) -> m (Maybe RenderNode)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe RenderNode) -> m (Maybe RenderNode))
-> IO (Maybe RenderNode) -> m (Maybe RenderNode)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Font
font' <- a -> IO (Ptr Font)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
font
    Ptr GlyphString
glyphs' <- GlyphString -> IO (Ptr GlyphString)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GlyphString
glyphs
    Ptr RGBA
color' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
color
    let x' :: CFloat
x' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x
    let y' :: CFloat
y' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y
    Ptr RenderNode
result <- Ptr Font
-> Ptr GlyphString
-> Ptr RGBA
-> CFloat
-> CFloat
-> IO (Ptr RenderNode)
gsk_text_node_new Ptr Font
font' Ptr GlyphString
glyphs' Ptr RGBA
color' CFloat
x' CFloat
y'
    Maybe RenderNode
maybeResult <- Ptr RenderNode
-> (Ptr RenderNode -> IO RenderNode) -> IO (Maybe RenderNode)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr RenderNode
result ((Ptr RenderNode -> IO RenderNode) -> IO (Maybe RenderNode))
-> (Ptr RenderNode -> IO RenderNode) -> IO (Maybe RenderNode)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr RenderNode
result' -> do
        RenderNode
result'' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result'
        RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
font
    GlyphString -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GlyphString
glyphs
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
color
    Maybe RenderNode -> IO (Maybe RenderNode)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe RenderNode
maybeResult


-- function gsk_text_node_get_y
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_text_node_get_y" gsk_text_node_get_y :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
textNodeGetY ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
textNodeGetY :: RenderNode -> m Float
textNodeGetY node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_text_node_get_y Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_text_node_get_x
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_text_node_get_x" gsk_text_node_get_x :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
textNodeGetX ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
textNodeGetX :: RenderNode -> m Float
textNodeGetX node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_text_node_get_x Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_text_node_get_num_glyphs
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_text_node_get_num_glyphs" gsk_text_node_get_num_glyphs :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO Word32

-- | /No description available in the introspection data./
textNodeGetNumGlyphs ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Word32
textNodeGetNumGlyphs :: RenderNode -> m Word32
textNodeGetNumGlyphs node :: RenderNode
node = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Word32
result <- Ptr RenderNode -> IO Word32
gsk_text_node_get_num_glyphs Ptr RenderNode
node'
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result


-- function gsk_rounded_clip_node_peek_clip
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RoundedRect" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_rounded_clip_node_peek_clip" gsk_rounded_clip_node_peek_clip :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RoundedRect.RoundedRect)

-- | /No description available in the introspection data./
roundedClipNodePeekClip ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RoundedRect.RoundedRect
roundedClipNodePeekClip :: RenderNode -> m RoundedRect
roundedClipNodePeekClip node :: RenderNode
node = IO RoundedRect -> m RoundedRect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RoundedRect -> m RoundedRect)
-> IO RoundedRect -> m RoundedRect
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RoundedRect
result <- Ptr RenderNode -> IO (Ptr RoundedRect)
gsk_rounded_clip_node_peek_clip Ptr RenderNode
node'
    Text -> Ptr RoundedRect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "roundedClipNodePeekClip" Ptr RoundedRect
result
    RoundedRect
result' <- ((ManagedPtr RoundedRect -> RoundedRect)
-> Ptr RoundedRect -> IO RoundedRect
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr RoundedRect -> RoundedRect
Gsk.RoundedRect.RoundedRect) Ptr RoundedRect
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RoundedRect -> IO RoundedRect
forall (m :: * -> *) a. Monad m => a -> m a
return RoundedRect
result'


-- function gsk_rounded_clip_node_new
-- Args: [ Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The node to draw" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clip"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RoundedRect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The clip to apply" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_rounded_clip_node_new" gsk_rounded_clip_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- child : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    Ptr Gsk.RoundedRect.RoundedRect ->      -- clip : TInterface (Name {namespace = "Gsk", name = "RoundedRect"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will clip the /@child@/ to the area
-- given by /@clip@/.
roundedClipNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@child@/: The node to draw
    -> Gsk.RoundedRect.RoundedRect
    -- ^ /@clip@/: The clip to apply
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
roundedClipNodeNew :: RenderNode -> RoundedRect -> m RenderNode
roundedClipNodeNew child :: RenderNode
child clip :: RoundedRect
clip = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
    Ptr RoundedRect
clip' <- RoundedRect -> IO (Ptr RoundedRect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RoundedRect
clip
    Ptr RenderNode
result <- Ptr RenderNode -> Ptr RoundedRect -> IO (Ptr RenderNode)
gsk_rounded_clip_node_new Ptr RenderNode
child' Ptr RoundedRect
clip'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "roundedClipNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
    RoundedRect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RoundedRect
clip
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_rounded_clip_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clip @GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_rounded_clip_node_get_child" gsk_rounded_clip_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Gets the child node that is getting clipped by the given /@node@/.
roundedClipNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a clip /@gskRenderNode@/
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ The child that is getting clipped
roundedClipNodeGetChild :: RenderNode -> m RenderNode
roundedClipNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_rounded_clip_node_get_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "roundedClipNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_repeating_linear_gradient_node_new
-- Args: [ Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the rectangle to render the linear gradient into"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the point at which the linear gradient will begin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the point at which the linear gradient will finish"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color_stops"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 4
--                 (TInterface Name { namespace = "Gsk" , name = "ColorStop" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a pointer to an array of #GskColorStop defining the gradient"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_color_stops"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of elements in @color_stops"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_color_stops"
--              , argType = TBasicType TUInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of elements in @color_stops"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_repeating_linear_gradient_node_new" gsk_repeating_linear_gradient_node_new :: 
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- start : TInterface (Name {namespace = "Graphene", name = "Point"})
    Ptr Graphene.Point.Point ->             -- end : TInterface (Name {namespace = "Graphene", name = "Point"})
    Ptr Gsk.ColorStop.ColorStop ->          -- color_stops : TCArray False (-1) 4 (TInterface (Name {namespace = "Gsk", name = "ColorStop"}))
    Word64 ->                               -- n_color_stops : TBasicType TUInt64
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will create a repeating linear gradient
-- from the given points and color stops, and render that into the area
-- given by /@bounds@/.
repeatingLinearGradientNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Graphene.Rect.Rect
    -- ^ /@bounds@/: the rectangle to render the linear gradient into
    -> Graphene.Point.Point
    -- ^ /@start@/: the point at which the linear gradient will begin
    -> Graphene.Point.Point
    -- ^ /@end@/: the point at which the linear gradient will finish
    -> [Gsk.ColorStop.ColorStop]
    -- ^ /@colorStops@/: a pointer to an array of t'GI.Gsk.Structs.ColorStop.ColorStop' defining the gradient
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
repeatingLinearGradientNodeNew :: Rect -> Point -> Point -> [ColorStop] -> m RenderNode
repeatingLinearGradientNodeNew bounds :: Rect
bounds start :: Point
start end :: Point
end colorStops :: [ColorStop]
colorStops = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    let nColorStops :: Word64
nColorStops = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ [ColorStop] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ColorStop]
colorStops
    Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
    Ptr Point
start' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
start
    Ptr Point
end' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
end
    [Ptr ColorStop]
colorStops' <- (ColorStop -> IO (Ptr ColorStop))
-> [ColorStop] -> IO [Ptr ColorStop]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ColorStop -> IO (Ptr ColorStop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [ColorStop]
colorStops
    Ptr ColorStop
colorStops'' <- Int -> [Ptr ColorStop] -> IO (Ptr ColorStop)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray 40 [Ptr ColorStop]
colorStops'
    Ptr RenderNode
result <- Ptr Rect
-> Ptr Point
-> Ptr Point
-> Ptr ColorStop
-> Word64
-> IO (Ptr RenderNode)
gsk_repeating_linear_gradient_node_new Ptr Rect
bounds' Ptr Point
start' Ptr Point
end' Ptr ColorStop
colorStops'' Word64
nColorStops
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "repeatingLinearGradientNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
    Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
start
    Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
end
    (ColorStop -> IO ()) -> [ColorStop] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ColorStop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [ColorStop]
colorStops
    Ptr ColorStop -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr ColorStop
colorStops''
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_repeat_node_peek_child_bounds
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_repeat_node_peek_child_bounds" gsk_repeat_node_peek_child_bounds :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Graphene.Rect.Rect)

-- | /No description available in the introspection data./
repeatNodePeekChildBounds ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Graphene.Rect.Rect
repeatNodePeekChildBounds :: RenderNode -> m Rect
repeatNodePeekChildBounds node :: RenderNode
node = IO Rect -> m Rect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Rect
result <- Ptr RenderNode -> IO (Ptr Rect)
gsk_repeat_node_peek_child_bounds Ptr RenderNode
node'
    Text -> Ptr Rect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "repeatNodePeekChildBounds" Ptr Rect
result
    Rect
result' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Rect -> Rect
Graphene.Rect.Rect) Ptr Rect
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Rect -> IO Rect
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
result'


-- function gsk_repeat_node_new
-- Args: [ Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The bounds of the area to be painted"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The child to repeat"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child_bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The area of the child to repeat or %NULL to\n    use the child's bounds"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_repeat_node_new" gsk_repeat_node_new :: 
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Gsk.RenderNode.RenderNode ->        -- child : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    Ptr Graphene.Rect.Rect ->               -- child_bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will repeat the drawing of /@child@/ across
-- the given /@bounds@/.
repeatNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Graphene.Rect.Rect
    -- ^ /@bounds@/: The bounds of the area to be painted
    -> Gsk.RenderNode.RenderNode
    -- ^ /@child@/: The child to repeat
    -> Maybe (Graphene.Rect.Rect)
    -- ^ /@childBounds@/: The area of the child to repeat or 'P.Nothing' to
    --     use the child\'s bounds
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
repeatNodeNew :: Rect -> RenderNode -> Maybe Rect -> m RenderNode
repeatNodeNew bounds :: Rect
bounds child :: RenderNode
child childBounds :: Maybe Rect
childBounds = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
    Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
    Ptr Rect
maybeChildBounds <- case Maybe Rect
childBounds of
        Nothing -> Ptr Rect -> IO (Ptr Rect)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rect
forall a. Ptr a
nullPtr
        Just jChildBounds :: Rect
jChildBounds -> do
            Ptr Rect
jChildBounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
jChildBounds
            Ptr Rect -> IO (Ptr Rect)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Rect
jChildBounds'
    Ptr RenderNode
result <- Ptr Rect -> Ptr RenderNode -> Ptr Rect -> IO (Ptr RenderNode)
gsk_repeat_node_new Ptr Rect
bounds' Ptr RenderNode
child' Ptr Rect
maybeChildBounds
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "repeatNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
    Maybe Rect -> (Rect -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Rect
childBounds Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_repeat_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_repeat_node_get_child" gsk_repeat_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | /No description available in the introspection data./
repeatNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RenderNode.RenderNode
repeatNodeGetChild :: RenderNode -> m RenderNode
repeatNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_repeat_node_get_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "repeatNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_outset_shadow_node_peek_outline
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RoundedRect" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_peek_outline" gsk_outset_shadow_node_peek_outline :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RoundedRect.RoundedRect)

-- | /No description available in the introspection data./
outsetShadowNodePeekOutline ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RoundedRect.RoundedRect
outsetShadowNodePeekOutline :: RenderNode -> m RoundedRect
outsetShadowNodePeekOutline node :: RenderNode
node = IO RoundedRect -> m RoundedRect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RoundedRect -> m RoundedRect)
-> IO RoundedRect -> m RoundedRect
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RoundedRect
result <- Ptr RenderNode -> IO (Ptr RoundedRect)
gsk_outset_shadow_node_peek_outline Ptr RenderNode
node'
    Text -> Ptr RoundedRect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "outsetShadowNodePeekOutline" Ptr RoundedRect
result
    RoundedRect
result' <- ((ManagedPtr RoundedRect -> RoundedRect)
-> Ptr RoundedRect -> IO RoundedRect
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr RoundedRect -> RoundedRect
Gsk.RoundedRect.RoundedRect) Ptr RoundedRect
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RoundedRect -> IO RoundedRect
forall (m :: * -> *) a. Monad m => a -> m a
return RoundedRect
result'


-- function gsk_outset_shadow_node_peek_color
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "RGBA" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_peek_color" gsk_outset_shadow_node_peek_color :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gdk.RGBA.RGBA)

-- | /No description available in the introspection data./
outsetShadowNodePeekColor ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gdk.RGBA.RGBA
outsetShadowNodePeekColor :: RenderNode -> m RGBA
outsetShadowNodePeekColor node :: RenderNode
node = IO RGBA -> m RGBA
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RGBA
result <- Ptr RenderNode -> IO (Ptr RGBA)
gsk_outset_shadow_node_peek_color Ptr RenderNode
node'
    Text -> Ptr RGBA -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "outsetShadowNodePeekColor" Ptr RGBA
result
    RGBA
result' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RGBA -> IO RGBA
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
result'


-- function gsk_outset_shadow_node_new
-- Args: [ Arg
--           { argCName = "outline"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RoundedRect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "outline of the region surrounded by shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "color of the shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dx"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "horizontal offset of shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dy"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "vertical offset of shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spread"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how far the shadow spreads towards the inside"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "blur_radius"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how much blur to apply to the shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_new" gsk_outset_shadow_node_new :: 
    Ptr Gsk.RoundedRect.RoundedRect ->      -- outline : TInterface (Name {namespace = "Gsk", name = "RoundedRect"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    CFloat ->                               -- dx : TBasicType TFloat
    CFloat ->                               -- dy : TBasicType TFloat
    CFloat ->                               -- spread : TBasicType TFloat
    CFloat ->                               -- blur_radius : TBasicType TFloat
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will render an outset shadow
-- around the box given by /@outline@/.
outsetShadowNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RoundedRect.RoundedRect
    -- ^ /@outline@/: outline of the region surrounded by shadow
    -> Gdk.RGBA.RGBA
    -- ^ /@color@/: color of the shadow
    -> Float
    -- ^ /@dx@/: horizontal offset of shadow
    -> Float
    -- ^ /@dy@/: vertical offset of shadow
    -> Float
    -- ^ /@spread@/: how far the shadow spreads towards the inside
    -> Float
    -- ^ /@blurRadius@/: how much blur to apply to the shadow
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
outsetShadowNodeNew :: RoundedRect
-> RGBA -> Float -> Float -> Float -> Float -> m RenderNode
outsetShadowNodeNew outline :: RoundedRect
outline color :: RGBA
color dx :: Float
dx dy :: Float
dy spread :: Float
spread blurRadius :: Float
blurRadius = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RoundedRect
outline' <- RoundedRect -> IO (Ptr RoundedRect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RoundedRect
outline
    Ptr RGBA
color' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
color
    let dx' :: CFloat
dx' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dx
    let dy' :: CFloat
dy' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dy
    let spread' :: CFloat
spread' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
spread
    let blurRadius' :: CFloat
blurRadius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blurRadius
    Ptr RenderNode
result <- Ptr RoundedRect
-> Ptr RGBA
-> CFloat
-> CFloat
-> CFloat
-> CFloat
-> IO (Ptr RenderNode)
gsk_outset_shadow_node_new Ptr RoundedRect
outline' Ptr RGBA
color' CFloat
dx' CFloat
dy' CFloat
spread' CFloat
blurRadius'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "outsetShadowNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RoundedRect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RoundedRect
outline
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
color
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_outset_shadow_node_get_spread
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_spread" gsk_outset_shadow_node_get_spread :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
outsetShadowNodeGetSpread ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
outsetShadowNodeGetSpread :: RenderNode -> m Float
outsetShadowNodeGetSpread node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_outset_shadow_node_get_spread Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_outset_shadow_node_get_dy
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_dy" gsk_outset_shadow_node_get_dy :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
outsetShadowNodeGetDy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
outsetShadowNodeGetDy :: RenderNode -> m Float
outsetShadowNodeGetDy node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_outset_shadow_node_get_dy Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_outset_shadow_node_get_dx
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_dx" gsk_outset_shadow_node_get_dx :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
outsetShadowNodeGetDx ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
outsetShadowNodeGetDx :: RenderNode -> m Float
outsetShadowNodeGetDx node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_outset_shadow_node_get_dx Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_outset_shadow_node_get_blur_radius
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_outset_shadow_node_get_blur_radius" gsk_outset_shadow_node_get_blur_radius :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
outsetShadowNodeGetBlurRadius ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
outsetShadowNodeGetBlurRadius :: RenderNode -> m Float
outsetShadowNodeGetBlurRadius node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_outset_shadow_node_get_blur_radius Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_opacity_node_new
-- Args: [ Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The node to draw" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "opacity"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The opacity to apply"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_opacity_node_new" gsk_opacity_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- child : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    CDouble ->                              -- opacity : TBasicType TDouble
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will drawn the /@child@/ with reduced
-- /@opacity@/.
opacityNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@child@/: The node to draw
    -> Double
    -- ^ /@opacity@/: The opacity to apply
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
opacityNodeNew :: RenderNode -> Double -> m RenderNode
opacityNodeNew child :: RenderNode
child opacity :: Double
opacity = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
    let opacity' :: CDouble
opacity' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
opacity
    Ptr RenderNode
result <- Ptr RenderNode -> CDouble -> IO (Ptr RenderNode)
gsk_opacity_node_new Ptr RenderNode
child' CDouble
opacity'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "opacityNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_opacity_node_get_opacity
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_opacity_node_get_opacity" gsk_opacity_node_get_opacity :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CDouble

-- | /No description available in the introspection data./
opacityNodeGetOpacity ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Double
opacityNodeGetOpacity :: RenderNode -> m Double
opacityNodeGetOpacity node :: RenderNode
node = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CDouble
result <- Ptr RenderNode -> IO CDouble
gsk_opacity_node_get_opacity Ptr RenderNode
node'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'


-- function gsk_opacity_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a opacity @GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_opacity_node_get_child" gsk_opacity_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Gets the child node that is getting opacityed by the given /@node@/.
opacityNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a opacity /@gskRenderNode@/
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ The child that is getting opacityed
opacityNodeGetChild :: RenderNode -> m RenderNode
opacityNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_opacity_node_get_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "opacityNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_linear_gradient_node_peek_start
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Point" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_linear_gradient_node_peek_start" gsk_linear_gradient_node_peek_start :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Graphene.Point.Point)

-- | /No description available in the introspection data./
linearGradientNodePeekStart ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Graphene.Point.Point
linearGradientNodePeekStart :: RenderNode -> m Point
linearGradientNodePeekStart node :: RenderNode
node = IO Point -> m Point
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Point
result <- Ptr RenderNode -> IO (Ptr Point)
gsk_linear_gradient_node_peek_start Ptr RenderNode
node'
    Text -> Ptr Point -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "linearGradientNodePeekStart" Ptr Point
result
    Point
result' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Graphene.Point.Point) Ptr Point
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Point -> IO Point
forall (m :: * -> *) a. Monad m => a -> m a
return Point
result'


-- function gsk_linear_gradient_node_peek_end
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Point" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_linear_gradient_node_peek_end" gsk_linear_gradient_node_peek_end :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Graphene.Point.Point)

-- | /No description available in the introspection data./
linearGradientNodePeekEnd ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Graphene.Point.Point
linearGradientNodePeekEnd :: RenderNode -> m Point
linearGradientNodePeekEnd node :: RenderNode
node = IO Point -> m Point
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Point
result <- Ptr RenderNode -> IO (Ptr Point)
gsk_linear_gradient_node_peek_end Ptr RenderNode
node'
    Text -> Ptr Point -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "linearGradientNodePeekEnd" Ptr Point
result
    Point
result' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Graphene.Point.Point) Ptr Point
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Point -> IO Point
forall (m :: * -> *) a. Monad m => a -> m a
return Point
result'


-- function gsk_linear_gradient_node_peek_color_stops
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "ColorStop" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_linear_gradient_node_peek_color_stops" gsk_linear_gradient_node_peek_color_stops :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.ColorStop.ColorStop)

-- | /No description available in the introspection data./
linearGradientNodePeekColorStops ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.ColorStop.ColorStop
linearGradientNodePeekColorStops :: RenderNode -> m ColorStop
linearGradientNodePeekColorStops node :: RenderNode
node = IO ColorStop -> m ColorStop
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ColorStop -> m ColorStop) -> IO ColorStop -> m ColorStop
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr ColorStop
result <- Ptr RenderNode -> IO (Ptr ColorStop)
gsk_linear_gradient_node_peek_color_stops Ptr RenderNode
node'
    Text -> Ptr ColorStop -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "linearGradientNodePeekColorStops" Ptr ColorStop
result
    ColorStop
result' <- ((ManagedPtr ColorStop -> ColorStop)
-> Ptr ColorStop -> IO ColorStop
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ColorStop -> ColorStop
Gsk.ColorStop.ColorStop) Ptr ColorStop
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    ColorStop -> IO ColorStop
forall (m :: * -> *) a. Monad m => a -> m a
return ColorStop
result'


-- function gsk_linear_gradient_node_new
-- Args: [ Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the rectangle to render the linear gradient into"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the point at which the linear gradient will begin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Point" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the point at which the linear gradient will finish"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color_stops"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 4
--                 (TInterface Name { namespace = "Gsk" , name = "ColorStop" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a pointer to an array of #GskColorStop defining the gradient"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_color_stops"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of elements in @color_stops"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_color_stops"
--              , argType = TBasicType TUInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the number of elements in @color_stops"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_linear_gradient_node_new" gsk_linear_gradient_node_new :: 
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    Ptr Graphene.Point.Point ->             -- start : TInterface (Name {namespace = "Graphene", name = "Point"})
    Ptr Graphene.Point.Point ->             -- end : TInterface (Name {namespace = "Graphene", name = "Point"})
    Ptr Gsk.ColorStop.ColorStop ->          -- color_stops : TCArray False (-1) 4 (TInterface (Name {namespace = "Gsk", name = "ColorStop"}))
    Word64 ->                               -- n_color_stops : TBasicType TUInt64
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will create a linear gradient from the given
-- points and color stops, and render that into the area given by /@bounds@/.
linearGradientNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Graphene.Rect.Rect
    -- ^ /@bounds@/: the rectangle to render the linear gradient into
    -> Graphene.Point.Point
    -- ^ /@start@/: the point at which the linear gradient will begin
    -> Graphene.Point.Point
    -- ^ /@end@/: the point at which the linear gradient will finish
    -> [Gsk.ColorStop.ColorStop]
    -- ^ /@colorStops@/: a pointer to an array of t'GI.Gsk.Structs.ColorStop.ColorStop' defining the gradient
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
linearGradientNodeNew :: Rect -> Point -> Point -> [ColorStop] -> m RenderNode
linearGradientNodeNew bounds :: Rect
bounds start :: Point
start end :: Point
end colorStops :: [ColorStop]
colorStops = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    let nColorStops :: Word64
nColorStops = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ [ColorStop] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ColorStop]
colorStops
    Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
    Ptr Point
start' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
start
    Ptr Point
end' <- Point -> IO (Ptr Point)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Point
end
    [Ptr ColorStop]
colorStops' <- (ColorStop -> IO (Ptr ColorStop))
-> [ColorStop] -> IO [Ptr ColorStop]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ColorStop -> IO (Ptr ColorStop)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [ColorStop]
colorStops
    Ptr ColorStop
colorStops'' <- Int -> [Ptr ColorStop] -> IO (Ptr ColorStop)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray 40 [Ptr ColorStop]
colorStops'
    Ptr RenderNode
result <- Ptr Rect
-> Ptr Point
-> Ptr Point
-> Ptr ColorStop
-> Word64
-> IO (Ptr RenderNode)
gsk_linear_gradient_node_new Ptr Rect
bounds' Ptr Point
start' Ptr Point
end' Ptr ColorStop
colorStops'' Word64
nColorStops
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "linearGradientNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
    Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
start
    Point -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Point
end
    (ColorStop -> IO ()) -> [ColorStop] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ColorStop -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [ColorStop]
colorStops
    Ptr ColorStop -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr ColorStop
colorStops''
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_linear_gradient_node_get_n_color_stops
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_linear_gradient_node_get_n_color_stops" gsk_linear_gradient_node_get_n_color_stops :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO Word64

-- | /No description available in the introspection data./
linearGradientNodeGetNColorStops ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Word64
linearGradientNodeGetNColorStops :: RenderNode -> m Word64
linearGradientNodeGetNColorStops node :: RenderNode
node = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Word64
result <- Ptr RenderNode -> IO Word64
gsk_linear_gradient_node_get_n_color_stops Ptr RenderNode
node'
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result


-- function gsk_inset_shadow_node_peek_outline
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RoundedRect" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_inset_shadow_node_peek_outline" gsk_inset_shadow_node_peek_outline :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RoundedRect.RoundedRect)

-- | /No description available in the introspection data./
insetShadowNodePeekOutline ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RoundedRect.RoundedRect
insetShadowNodePeekOutline :: RenderNode -> m RoundedRect
insetShadowNodePeekOutline node :: RenderNode
node = IO RoundedRect -> m RoundedRect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RoundedRect -> m RoundedRect)
-> IO RoundedRect -> m RoundedRect
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RoundedRect
result <- Ptr RenderNode -> IO (Ptr RoundedRect)
gsk_inset_shadow_node_peek_outline Ptr RenderNode
node'
    Text -> Ptr RoundedRect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "insetShadowNodePeekOutline" Ptr RoundedRect
result
    RoundedRect
result' <- ((ManagedPtr RoundedRect -> RoundedRect)
-> Ptr RoundedRect -> IO RoundedRect
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr RoundedRect -> RoundedRect
Gsk.RoundedRect.RoundedRect) Ptr RoundedRect
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RoundedRect -> IO RoundedRect
forall (m :: * -> *) a. Monad m => a -> m a
return RoundedRect
result'


-- function gsk_inset_shadow_node_peek_color
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "RGBA" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_inset_shadow_node_peek_color" gsk_inset_shadow_node_peek_color :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gdk.RGBA.RGBA)

-- | /No description available in the introspection data./
insetShadowNodePeekColor ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gdk.RGBA.RGBA
insetShadowNodePeekColor :: RenderNode -> m RGBA
insetShadowNodePeekColor node :: RenderNode
node = IO RGBA -> m RGBA
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RGBA
result <- Ptr RenderNode -> IO (Ptr RGBA)
gsk_inset_shadow_node_peek_color Ptr RenderNode
node'
    Text -> Ptr RGBA -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "insetShadowNodePeekColor" Ptr RGBA
result
    RGBA
result' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RGBA -> IO RGBA
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
result'


-- function gsk_inset_shadow_node_new
-- Args: [ Arg
--           { argCName = "outline"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RoundedRect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "outline of the region containing the shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "color of the shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dx"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "horizontal offset of shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dy"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "vertical offset of shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spread"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how far the shadow spreads towards the inside"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "blur_radius"
--           , argType = TBasicType TFloat
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "how much blur to apply to the shadow"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_inset_shadow_node_new" gsk_inset_shadow_node_new :: 
    Ptr Gsk.RoundedRect.RoundedRect ->      -- outline : TInterface (Name {namespace = "Gsk", name = "RoundedRect"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    CFloat ->                               -- dx : TBasicType TFloat
    CFloat ->                               -- dy : TBasicType TFloat
    CFloat ->                               -- spread : TBasicType TFloat
    CFloat ->                               -- blur_radius : TBasicType TFloat
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will render an inset shadow
-- into the box given by /@outline@/.
insetShadowNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RoundedRect.RoundedRect
    -- ^ /@outline@/: outline of the region containing the shadow
    -> Gdk.RGBA.RGBA
    -- ^ /@color@/: color of the shadow
    -> Float
    -- ^ /@dx@/: horizontal offset of shadow
    -> Float
    -- ^ /@dy@/: vertical offset of shadow
    -> Float
    -- ^ /@spread@/: how far the shadow spreads towards the inside
    -> Float
    -- ^ /@blurRadius@/: how much blur to apply to the shadow
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
insetShadowNodeNew :: RoundedRect
-> RGBA -> Float -> Float -> Float -> Float -> m RenderNode
insetShadowNodeNew outline :: RoundedRect
outline color :: RGBA
color dx :: Float
dx dy :: Float
dy spread :: Float
spread blurRadius :: Float
blurRadius = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RoundedRect
outline' <- RoundedRect -> IO (Ptr RoundedRect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RoundedRect
outline
    Ptr RGBA
color' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
color
    let dx' :: CFloat
dx' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dx
    let dy' :: CFloat
dy' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
dy
    let spread' :: CFloat
spread' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
spread
    let blurRadius' :: CFloat
blurRadius' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
blurRadius
    Ptr RenderNode
result <- Ptr RoundedRect
-> Ptr RGBA
-> CFloat
-> CFloat
-> CFloat
-> CFloat
-> IO (Ptr RenderNode)
gsk_inset_shadow_node_new Ptr RoundedRect
outline' Ptr RGBA
color' CFloat
dx' CFloat
dy' CFloat
spread' CFloat
blurRadius'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "insetShadowNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RoundedRect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RoundedRect
outline
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
color
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_inset_shadow_node_get_spread
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_inset_shadow_node_get_spread" gsk_inset_shadow_node_get_spread :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
insetShadowNodeGetSpread ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
insetShadowNodeGetSpread :: RenderNode -> m Float
insetShadowNodeGetSpread node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_inset_shadow_node_get_spread Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_inset_shadow_node_get_dy
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_inset_shadow_node_get_dy" gsk_inset_shadow_node_get_dy :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
insetShadowNodeGetDy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
insetShadowNodeGetDy :: RenderNode -> m Float
insetShadowNodeGetDy node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_inset_shadow_node_get_dy Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_inset_shadow_node_get_dx
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_inset_shadow_node_get_dx" gsk_inset_shadow_node_get_dx :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
insetShadowNodeGetDx ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
insetShadowNodeGetDx :: RenderNode -> m Float
insetShadowNodeGetDx node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_inset_shadow_node_get_dx Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_inset_shadow_node_get_blur_radius
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_inset_shadow_node_get_blur_radius" gsk_inset_shadow_node_get_blur_radius :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
insetShadowNodeGetBlurRadius ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
insetShadowNodeGetBlurRadius :: RenderNode -> m Float
insetShadowNodeGetBlurRadius node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_inset_shadow_node_get_blur_radius Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_debug_node_new
-- Args: [ Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The child to add debug info for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "message"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The debug message" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_debug_node_new" gsk_debug_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- child : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    CString ->                              -- message : TBasicType TUTF8
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will add debug information about
-- the given /@child@/.
-- 
-- Adding this node has no visual effect.
debugNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@child@/: The child to add debug info for
    -> T.Text
    -- ^ /@message@/: The debug message
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
debugNodeNew :: RenderNode -> Text -> m RenderNode
debugNodeNew child :: RenderNode
child message :: Text
message = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
    CString
message' <- Text -> IO CString
textToCString Text
message
    Ptr RenderNode
result <- Ptr RenderNode -> CString -> IO (Ptr RenderNode)
gsk_debug_node_new Ptr RenderNode
child' CString
message'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "debugNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_debug_node_get_message
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a debug #GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_debug_node_get_message" gsk_debug_node_get_message :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CString

-- | Gets the debug message that was set on this node
debugNodeGetMessage ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a debug t'GI.Gsk.Structs.RenderNode.RenderNode'
    -> m T.Text
    -- ^ __Returns:__ The debug message
debugNodeGetMessage :: RenderNode -> m Text
debugNodeGetMessage node :: RenderNode
node = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CString
result <- Ptr RenderNode -> IO CString
gsk_debug_node_get_message Ptr RenderNode
node'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "debugNodeGetMessage" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'


-- function gsk_debug_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a debug @GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_debug_node_get_child" gsk_debug_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Gets the child node that is getting debug by the given /@node@/.
debugNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a debug /@gskRenderNode@/
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ The child that is getting debug
debugNodeGetChild :: RenderNode -> m RenderNode
debugNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_debug_node_get_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "debugNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_cross_fade_node_new
-- Args: [ Arg
--           { argCName = "start"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The start node to be drawn"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The node to be cross_fadeed onto the @start node"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "progress"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "How far the fade has progressed from start to end. The value will\n    be clamped to the range [0 ... 1]"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_cross_fade_node_new" gsk_cross_fade_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- start : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    Ptr Gsk.RenderNode.RenderNode ->        -- end : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    CDouble ->                              -- progress : TBasicType TDouble
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will do a cross-fade between /@start@/ and /@end@/.
crossFadeNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@start@/: The start node to be drawn
    -> Gsk.RenderNode.RenderNode
    -- ^ /@end@/: The node to be cross_fadeed onto the /@start@/ node
    -> Double
    -- ^ /@progress@/: How far the fade has progressed from start to end. The value will
    --     be clamped to the range [0 ... 1]
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
crossFadeNodeNew :: RenderNode -> RenderNode -> Double -> m RenderNode
crossFadeNodeNew start :: RenderNode
start end :: RenderNode
end progress :: Double
progress = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
start' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
start
    Ptr RenderNode
end' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
end
    let progress' :: CDouble
progress' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
progress
    Ptr RenderNode
result <- Ptr RenderNode -> Ptr RenderNode -> CDouble -> IO (Ptr RenderNode)
gsk_cross_fade_node_new Ptr RenderNode
start' Ptr RenderNode
end' CDouble
progress'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "crossFadeNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
start
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
end
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_cross_fade_node_get_start_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_cross_fade_node_get_start_child" gsk_cross_fade_node_get_start_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | /No description available in the introspection data./
crossFadeNodeGetStartChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RenderNode.RenderNode
crossFadeNodeGetStartChild :: RenderNode -> m RenderNode
crossFadeNodeGetStartChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_cross_fade_node_get_start_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "crossFadeNodeGetStartChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_cross_fade_node_get_progress
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_cross_fade_node_get_progress" gsk_cross_fade_node_get_progress :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CDouble

-- | /No description available in the introspection data./
crossFadeNodeGetProgress ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Double
crossFadeNodeGetProgress :: RenderNode -> m Double
crossFadeNodeGetProgress node :: RenderNode
node = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CDouble
result <- Ptr RenderNode -> IO CDouble
gsk_cross_fade_node_get_progress Ptr RenderNode
node'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'


-- function gsk_cross_fade_node_get_end_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_cross_fade_node_get_end_child" gsk_cross_fade_node_get_end_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | /No description available in the introspection data./
crossFadeNodeGetEndChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RenderNode.RenderNode
crossFadeNodeGetEndChild :: RenderNode -> m RenderNode
crossFadeNodeGetEndChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_cross_fade_node_get_end_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "crossFadeNodeGetEndChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_container_node_new
-- Args: [ Arg
--           { argCName = "children"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 1
--                 (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The children of the node"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_children"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Number of children in the @children array"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_children"
--              , argType = TBasicType TUInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "Number of children in the @children array"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_container_node_new" gsk_container_node_new :: 
    Ptr (Ptr Gsk.RenderNode.RenderNode) ->  -- children : TCArray False (-1) 1 (TInterface (Name {namespace = "Gsk", name = "RenderNode"}))
    Word32 ->                               -- n_children : TBasicType TUInt
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a new t'GI.Gsk.Structs.RenderNode.RenderNode' instance for holding the given /@children@/.
-- The new node will acquire a reference to each of the children.
containerNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    [Gsk.RenderNode.RenderNode]
    -- ^ /@children@/: The children of the node
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ the new t'GI.Gsk.Structs.RenderNode.RenderNode'
containerNodeNew :: [RenderNode] -> m RenderNode
containerNodeNew children :: [RenderNode]
children = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    let nChildren :: Word32
nChildren = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [RenderNode] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [RenderNode]
children
    [Ptr RenderNode]
children' <- (RenderNode -> IO (Ptr RenderNode))
-> [RenderNode] -> IO [Ptr RenderNode]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [RenderNode]
children
    Ptr (Ptr RenderNode)
children'' <- [Ptr RenderNode] -> IO (Ptr (Ptr RenderNode))
forall a. [Ptr a] -> IO (Ptr (Ptr a))
packPtrArray [Ptr RenderNode]
children'
    Ptr RenderNode
result <- Ptr (Ptr RenderNode) -> Word32 -> IO (Ptr RenderNode)
gsk_container_node_new Ptr (Ptr RenderNode)
children'' Word32
nChildren
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "containerNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    (RenderNode -> IO ()) -> [RenderNode] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [RenderNode]
children
    Ptr (Ptr RenderNode) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr RenderNode)
children''
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_container_node_get_n_children
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a container #GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_container_node_get_n_children" gsk_container_node_get_n_children :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO Word32

-- | Retrieves the number of direct children of /@node@/.
containerNodeGetNChildren ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a container t'GI.Gsk.Structs.RenderNode.RenderNode'
    -> m Word32
    -- ^ __Returns:__ the number of children of the t'GI.Gsk.Structs.RenderNode.RenderNode'
containerNodeGetNChildren :: RenderNode -> m Word32
containerNodeGetNChildren node :: RenderNode
node = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Word32
result <- Ptr RenderNode -> IO Word32
gsk_container_node_get_n_children Ptr RenderNode
node'
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result


-- function gsk_container_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a container #GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "idx"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position of the child to get"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_container_node_get_child" gsk_container_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    Word32 ->                               -- idx : TBasicType TUInt
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Gets one of the children of /@container@/.
containerNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a container t'GI.Gsk.Structs.RenderNode.RenderNode'
    -> Word32
    -- ^ /@idx@/: the position of the child to get
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ the /@idx@/\'th child of /@container@/
containerNodeGetChild :: RenderNode -> Word32 -> m RenderNode
containerNodeGetChild node :: RenderNode
node idx :: Word32
idx = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> Word32 -> IO (Ptr RenderNode)
gsk_container_node_get_child Ptr RenderNode
node' Word32
idx
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "containerNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_color_node_peek_color
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "RGBA" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_color_node_peek_color" gsk_color_node_peek_color :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gdk.RGBA.RGBA)

-- | /No description available in the introspection data./
colorNodePeekColor ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gdk.RGBA.RGBA
colorNodePeekColor :: RenderNode -> m RGBA
colorNodePeekColor node :: RenderNode
node = IO RGBA -> m RGBA
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RGBA
result <- Ptr RenderNode -> IO (Ptr RGBA)
gsk_color_node_peek_color Ptr RenderNode
node'
    Text -> Ptr RGBA -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "colorNodePeekColor" Ptr RGBA
result
    RGBA
result' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RGBA -> IO RGBA
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
result'


-- function gsk_color_node_new
-- Args: [ Arg
--           { argCName = "rgba"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkRGBA specifying a color"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rectangle to render the color into"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_color_node_new" gsk_color_node_new :: 
    Ptr Gdk.RGBA.RGBA ->                    -- rgba : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will render the color specified by /@rgba@/ into
-- the area given by /@bounds@/.
colorNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gdk.RGBA.RGBA
    -- ^ /@rgba@/: a t'GI.Gdk.Structs.RGBA.RGBA' specifying a color
    -> Graphene.Rect.Rect
    -- ^ /@bounds@/: the rectangle to render the color into
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
colorNodeNew :: RGBA -> Rect -> m RenderNode
colorNodeNew rgba :: RGBA
rgba bounds :: Rect
bounds = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RGBA
rgba' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
rgba
    Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
    Ptr RenderNode
result <- Ptr RGBA -> Ptr Rect -> IO (Ptr RenderNode)
gsk_color_node_new Ptr RGBA
rgba' Ptr Rect
bounds'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "colorNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RGBA
rgba
    Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_color_matrix_node_peek_color_offset
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Vec4" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_color_matrix_node_peek_color_offset" gsk_color_matrix_node_peek_color_offset :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Graphene.Vec4.Vec4)

-- | /No description available in the introspection data./
colorMatrixNodePeekColorOffset ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Graphene.Vec4.Vec4
colorMatrixNodePeekColorOffset :: RenderNode -> m Vec4
colorMatrixNodePeekColorOffset node :: RenderNode
node = IO Vec4 -> m Vec4
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Vec4 -> m Vec4) -> IO Vec4 -> m Vec4
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Vec4
result <- Ptr RenderNode -> IO (Ptr Vec4)
gsk_color_matrix_node_peek_color_offset Ptr RenderNode
node'
    Text -> Ptr Vec4 -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "colorMatrixNodePeekColorOffset" Ptr Vec4
result
    Vec4
result' <- ((ManagedPtr Vec4 -> Vec4) -> Ptr Vec4 -> IO Vec4
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Vec4 -> Vec4
Graphene.Vec4.Vec4) Ptr Vec4
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Vec4 -> IO Vec4
forall (m :: * -> *) a. Monad m => a -> m a
return Vec4
result'


-- function gsk_color_matrix_node_peek_color_matrix
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Matrix" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_color_matrix_node_peek_color_matrix" gsk_color_matrix_node_peek_color_matrix :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Graphene.Matrix.Matrix)

-- | /No description available in the introspection data./
colorMatrixNodePeekColorMatrix ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Graphene.Matrix.Matrix
colorMatrixNodePeekColorMatrix :: RenderNode -> m Matrix
colorMatrixNodePeekColorMatrix node :: RenderNode
node = IO Matrix -> m Matrix
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Matrix
result <- Ptr RenderNode -> IO (Ptr Matrix)
gsk_color_matrix_node_peek_color_matrix Ptr RenderNode
node'
    Text -> Ptr Matrix -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "colorMatrixNodePeekColorMatrix" Ptr Matrix
result
    Matrix
result' <- ((ManagedPtr Matrix -> Matrix) -> Ptr Matrix -> IO Matrix
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Matrix -> Matrix
Graphene.Matrix.Matrix) Ptr Matrix
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Matrix -> IO Matrix
forall (m :: * -> *) a. Monad m => a -> m a
return Matrix
result'


-- function gsk_color_matrix_node_new
-- Args: [ Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The node to draw" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color_matrix"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Matrix" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The matrix to apply"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color_offset"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Vec4" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Values to add to the color"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_color_matrix_node_new" gsk_color_matrix_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- child : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    Ptr Graphene.Matrix.Matrix ->           -- color_matrix : TInterface (Name {namespace = "Graphene", name = "Matrix"})
    Ptr Graphene.Vec4.Vec4 ->               -- color_offset : TInterface (Name {namespace = "Graphene", name = "Vec4"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will drawn the /@child@/ with reduced
-- /@colorMatrix@/.
-- 
-- In particular, the node will transform the operation
--   pixel = color_matrix * pixel + color_offset
-- for every pixel.
colorMatrixNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@child@/: The node to draw
    -> Graphene.Matrix.Matrix
    -- ^ /@colorMatrix@/: The matrix to apply
    -> Graphene.Vec4.Vec4
    -- ^ /@colorOffset@/: Values to add to the color
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
colorMatrixNodeNew :: RenderNode -> Matrix -> Vec4 -> m RenderNode
colorMatrixNodeNew child :: RenderNode
child colorMatrix :: Matrix
colorMatrix colorOffset :: Vec4
colorOffset = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
    Ptr Matrix
colorMatrix' <- Matrix -> IO (Ptr Matrix)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Matrix
colorMatrix
    Ptr Vec4
colorOffset' <- Vec4 -> IO (Ptr Vec4)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Vec4
colorOffset
    Ptr RenderNode
result <- Ptr RenderNode -> Ptr Matrix -> Ptr Vec4 -> IO (Ptr RenderNode)
gsk_color_matrix_node_new Ptr RenderNode
child' Ptr Matrix
colorMatrix' Ptr Vec4
colorOffset'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "colorMatrixNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
    Matrix -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Matrix
colorMatrix
    Vec4 -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Vec4
colorOffset
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_color_matrix_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a color matrix @GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_color_matrix_node_get_child" gsk_color_matrix_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Gets the child node that is getting its colors modified by the given /@node@/.
colorMatrixNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a color matrix /@gskRenderNode@/
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ The child that is getting its colors modified
colorMatrixNodeGetChild :: RenderNode -> m RenderNode
colorMatrixNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_color_matrix_node_get_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "colorMatrixNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_clip_node_peek_clip
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Rect" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_clip_node_peek_clip" gsk_clip_node_peek_clip :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Graphene.Rect.Rect)

-- | /No description available in the introspection data./
clipNodePeekClip ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Graphene.Rect.Rect
clipNodePeekClip :: RenderNode -> m Rect
clipNodePeekClip node :: RenderNode
node = IO Rect -> m Rect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Rect
result <- Ptr RenderNode -> IO (Ptr Rect)
gsk_clip_node_peek_clip Ptr RenderNode
node'
    Text -> Ptr Rect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "clipNodePeekClip" Ptr Rect
result
    Rect
result' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Rect -> Rect
Graphene.Rect.Rect) Ptr Rect
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Rect -> IO Rect
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
result'


-- function gsk_clip_node_new
-- Args: [ Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The node to draw" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "clip"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The clip to apply" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_clip_node_new" gsk_clip_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- child : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    Ptr Graphene.Rect.Rect ->               -- clip : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will clip the /@child@/ to the area
-- given by /@clip@/.
clipNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@child@/: The node to draw
    -> Graphene.Rect.Rect
    -- ^ /@clip@/: The clip to apply
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
clipNodeNew :: RenderNode -> Rect -> m RenderNode
clipNodeNew child :: RenderNode
child clip :: Rect
clip = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
    Ptr Rect
clip' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
clip
    Ptr RenderNode
result <- Ptr RenderNode -> Ptr Rect -> IO (Ptr RenderNode)
gsk_clip_node_new Ptr RenderNode
child' Ptr Rect
clip'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "clipNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
    Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
clip
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_clip_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a clip @GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_clip_node_get_child" gsk_clip_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Gets the child node that is getting clipped by the given /@node@/.
clipNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a clip /@gskRenderNode@/
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ The child that is getting clipped
clipNodeGetChild :: RenderNode -> m RenderNode
clipNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_clip_node_get_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "clipNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_cairo_node_peek_surface
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "cairo" , name = "Surface" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_cairo_node_peek_surface" gsk_cairo_node_peek_surface :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Cairo.Surface.Surface)

-- | /No description available in the introspection data./
cairoNodePeekSurface ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Cairo.Surface.Surface
cairoNodePeekSurface :: RenderNode -> m Surface
cairoNodePeekSurface node :: RenderNode
node = IO Surface -> m Surface
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Surface -> m Surface) -> IO Surface -> m Surface
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Surface
result <- Ptr RenderNode -> IO (Ptr Surface)
gsk_cairo_node_peek_surface Ptr RenderNode
node'
    Text -> Ptr Surface -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "cairoNodePeekSurface" Ptr Surface
result
    Surface
result' <- ((ManagedPtr Surface -> Surface) -> Ptr Surface -> IO Surface
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Surface -> Surface
Cairo.Surface.Surface) Ptr Surface
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Surface -> IO Surface
forall (m :: * -> *) a. Monad m => a -> m a
return Surface
result'


-- function gsk_cairo_node_new
-- Args: [ Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rectangle to render to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_cairo_node_new" gsk_cairo_node_new :: 
    Ptr Graphene.Rect.Rect ->               -- bounds : TInterface (Name {namespace = "Graphene", name = "Rect"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will render a cairo surface
-- into the area given by /@bounds@/. You can draw to the cairo
-- surface using 'GI.Gsk.Functions.cairoNodeGetDrawContext'
cairoNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Graphene.Rect.Rect
    -- ^ /@bounds@/: the rectangle to render to
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
cairoNodeNew :: Rect -> m RenderNode
cairoNodeNew bounds :: Rect
bounds = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Rect
bounds' <- Rect -> IO (Ptr Rect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rect
bounds
    Ptr RenderNode
result <- Ptr Rect -> IO (Ptr RenderNode)
gsk_cairo_node_new Ptr Rect
bounds'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "cairoNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    Rect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rect
bounds
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_cairo_node_get_draw_context
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a cairo #GskRenderNode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "cairo" , name = "Context" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_cairo_node_get_draw_context" gsk_cairo_node_get_draw_context :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Cairo.Context.Context)

-- | Creates a Cairo context for drawing using the surface associated
-- to the render node.
-- If no surface exists yet, a surface will be created optimized for
-- rendering to /@renderer@/.
cairoNodeGetDrawContext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@node@/: a cairo t'GI.Gsk.Structs.RenderNode.RenderNode'
    -> m Cairo.Context.Context
    -- ^ __Returns:__ a Cairo context used for drawing; use
    --   @/cairo_destroy()/@ when done drawing
cairoNodeGetDrawContext :: RenderNode -> m Context
cairoNodeGetDrawContext node :: RenderNode
node = IO Context -> m Context
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Context -> m Context) -> IO Context -> m Context
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr Context
result <- Ptr RenderNode -> IO (Ptr Context)
gsk_cairo_node_get_draw_context Ptr RenderNode
node'
    Text -> Ptr Context -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "cairoNodeGetDrawContext" Ptr Context
result
    Context
result' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Context -> Context
Cairo.Context.Context) Ptr Context
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Context -> IO Context
forall (m :: * -> *) a. Monad m => a -> m a
return Context
result'


-- function gsk_border_node_peek_widths
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_border_node_peek_widths" gsk_border_node_peek_widths :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CFloat

-- | /No description available in the introspection data./
borderNodePeekWidths ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Float
borderNodePeekWidths :: RenderNode -> m Float
borderNodePeekWidths node :: RenderNode
node = IO Float -> m Float
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 RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CFloat
result <- Ptr RenderNode -> IO CFloat
gsk_border_node_peek_widths Ptr RenderNode
node'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'


-- function gsk_border_node_peek_outline
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RoundedRect" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_border_node_peek_outline" gsk_border_node_peek_outline :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RoundedRect.RoundedRect)

-- | /No description available in the introspection data./
borderNodePeekOutline ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RoundedRect.RoundedRect
borderNodePeekOutline :: RenderNode -> m RoundedRect
borderNodePeekOutline node :: RenderNode
node = IO RoundedRect -> m RoundedRect
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RoundedRect -> m RoundedRect)
-> IO RoundedRect -> m RoundedRect
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RoundedRect
result <- Ptr RenderNode -> IO (Ptr RoundedRect)
gsk_border_node_peek_outline Ptr RenderNode
node'
    Text -> Ptr RoundedRect -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "borderNodePeekOutline" Ptr RoundedRect
result
    RoundedRect
result' <- ((ManagedPtr RoundedRect -> RoundedRect)
-> Ptr RoundedRect -> IO RoundedRect
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr RoundedRect -> RoundedRect
Gsk.RoundedRect.RoundedRect) Ptr RoundedRect
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RoundedRect -> IO RoundedRect
forall (m :: * -> *) a. Monad m => a -> m a
return RoundedRect
result'


-- function gsk_border_node_peek_colors
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "RGBA" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_border_node_peek_colors" gsk_border_node_peek_colors :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gdk.RGBA.RGBA)

-- | /No description available in the introspection data./
borderNodePeekColors ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gdk.RGBA.RGBA
borderNodePeekColors :: RenderNode -> m RGBA
borderNodePeekColors node :: RenderNode
node = IO RGBA -> m RGBA
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RGBA
result <- Ptr RenderNode -> IO (Ptr RGBA)
gsk_border_node_peek_colors Ptr RenderNode
node'
    Text -> Ptr RGBA -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "borderNodePeekColors" Ptr RGBA
result
    RGBA
result' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RGBA -> IO RGBA
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
result'


-- function gsk_border_node_new
-- Args: [ Arg
--           { argCName = "outline"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RoundedRect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GskRoundedRect describing the outline of the border"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "border_width"
--           , argType = TCArray False 4 (-1) (TBasicType TFloat)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the stroke width of the border on\n    the top, right, bottom and left side respectively."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "border_color"
--           , argType =
--               TCArray
--                 False
--                 4
--                 (-1)
--                 (TInterface Name { namespace = "Gdk" , name = "RGBA" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the color used on the top, right,\n    bottom and left side."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_border_node_new" gsk_border_node_new :: 
    Ptr Gsk.RoundedRect.RoundedRect ->      -- outline : TInterface (Name {namespace = "Gsk", name = "RoundedRect"})
    Ptr CFloat ->                           -- border_width : TCArray False 4 (-1) (TBasicType TFloat)
    Ptr Gdk.RGBA.RGBA ->                    -- border_color : TCArray False 4 (-1) (TInterface (Name {namespace = "Gdk", name = "RGBA"}))
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will stroke a border rectangle inside the
-- given /@outline@/. The 4 sides of the border can have different widths and
-- colors.
borderNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RoundedRect.RoundedRect
    -- ^ /@outline@/: a t'GI.Gsk.Structs.RoundedRect.RoundedRect' describing the outline of the border
    -> [Float]
    -- ^ /@borderWidth@/: the stroke width of the border on
    --     the top, right, bottom and left side respectively.
    -> [Gdk.RGBA.RGBA]
    -- ^ /@borderColor@/: the color used on the top, right,
    --     bottom and left side.
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
borderNodeNew :: RoundedRect -> [Float] -> [RGBA] -> m RenderNode
borderNodeNew outline :: RoundedRect
outline borderWidth :: [Float]
borderWidth borderColor :: [RGBA]
borderColor = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RoundedRect
outline' <- RoundedRect -> IO (Ptr RoundedRect)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RoundedRect
outline
    Ptr CFloat
borderWidth' <- ((Float -> CFloat) -> [Float] -> IO (Ptr CFloat)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac) [Float]
borderWidth
    [Ptr RGBA]
borderColor' <- (RGBA -> IO (Ptr RGBA)) -> [RGBA] -> IO [Ptr RGBA]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [RGBA]
borderColor
    Ptr RGBA
borderColor'' <- Int -> [Ptr RGBA] -> IO (Ptr RGBA)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray 32 [Ptr RGBA]
borderColor'
    Ptr RenderNode
result <- Ptr RoundedRect -> Ptr CFloat -> Ptr RGBA -> IO (Ptr RenderNode)
gsk_border_node_new Ptr RoundedRect
outline' Ptr CFloat
borderWidth' Ptr RGBA
borderColor''
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "borderNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RoundedRect -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RoundedRect
outline
    (RGBA -> IO ()) -> [RGBA] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [RGBA]
borderColor
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
borderWidth'
    Ptr RGBA -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr RGBA
borderColor''
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_blur_node_new
-- Args: [ Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child node to blur"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "radius"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the blur radius" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_blur_node_new" gsk_blur_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- child : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    CDouble ->                              -- radius : TBasicType TDouble
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a render node that blurs the child.
blurNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@child@/: the child node to blur
    -> Double
    -- ^ /@radius@/: the blur radius
    -> m Gsk.RenderNode.RenderNode
blurNodeNew :: RenderNode -> Double -> m RenderNode
blurNodeNew child :: RenderNode
child radius :: Double
radius = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
child' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
child
    let radius' :: CDouble
radius' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
radius
    Ptr RenderNode
result <- Ptr RenderNode -> CDouble -> IO (Ptr RenderNode)
gsk_blur_node_new Ptr RenderNode
child' CDouble
radius'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "blurNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
child
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_blur_node_get_radius
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gsk_blur_node_get_radius" gsk_blur_node_get_radius :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CDouble

-- | /No description available in the introspection data./
blurNodeGetRadius ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Double
blurNodeGetRadius :: RenderNode -> m Double
blurNodeGetRadius node :: RenderNode
node = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CDouble
result <- Ptr RenderNode -> IO CDouble
gsk_blur_node_get_radius Ptr RenderNode
node'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'


-- function gsk_blur_node_get_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_blur_node_get_child" gsk_blur_node_get_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | /No description available in the introspection data./
blurNodeGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RenderNode.RenderNode
blurNodeGetChild :: RenderNode -> m RenderNode
blurNodeGetChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_blur_node_get_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "blurNodeGetChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_blend_node_new
-- Args: [ Arg
--           { argCName = "bottom"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The bottom node to be drawn"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "top"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The node to be blended onto the @bottom node"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "blend_mode"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "BlendMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The blend mode to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_blend_node_new" gsk_blend_node_new :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- bottom : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    Ptr Gsk.RenderNode.RenderNode ->        -- top : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    CUInt ->                                -- blend_mode : TInterface (Name {namespace = "Gsk", name = "BlendMode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | Creates a t'GI.Gsk.Structs.RenderNode.RenderNode' that will use /@blendMode@/ to blend the /@top@/
-- node onto the /@bottom@/ node.
blendNodeNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -- ^ /@bottom@/: The bottom node to be drawn
    -> Gsk.RenderNode.RenderNode
    -- ^ /@top@/: The node to be blended onto the /@bottom@/ node
    -> Gsk.Enums.BlendMode
    -- ^ /@blendMode@/: The blend mode to use
    -> m Gsk.RenderNode.RenderNode
    -- ^ __Returns:__ A new t'GI.Gsk.Structs.RenderNode.RenderNode'
blendNodeNew :: RenderNode -> RenderNode -> BlendMode -> m RenderNode
blendNodeNew bottom :: RenderNode
bottom top :: RenderNode
top blendMode :: BlendMode
blendMode = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
bottom' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
bottom
    Ptr RenderNode
top' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
top
    let blendMode' :: CUInt
blendMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (BlendMode -> Int) -> BlendMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlendMode -> Int
forall a. Enum a => a -> Int
fromEnum) BlendMode
blendMode
    Ptr RenderNode
result <- Ptr RenderNode -> Ptr RenderNode -> CUInt -> IO (Ptr RenderNode)
gsk_blend_node_new Ptr RenderNode
bottom' Ptr RenderNode
top' CUInt
blendMode'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "blendNodeNew" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
bottom
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
top
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_blend_node_get_top_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_blend_node_get_top_child" gsk_blend_node_get_top_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | /No description available in the introspection data./
blendNodeGetTopChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RenderNode.RenderNode
blendNodeGetTopChild :: RenderNode -> m RenderNode
blendNodeGetTopChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_blend_node_get_top_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "blendNodeGetTopChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_blend_node_get_bottom_child
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_blend_node_get_bottom_child" gsk_blend_node_get_bottom_child :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO (Ptr Gsk.RenderNode.RenderNode)

-- | /No description available in the introspection data./
blendNodeGetBottomChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.RenderNode.RenderNode
blendNodeGetBottomChild :: RenderNode -> m RenderNode
blendNodeGetBottomChild node :: RenderNode
node = IO RenderNode -> m RenderNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNode -> m RenderNode) -> IO RenderNode -> m RenderNode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_blend_node_get_bottom_child Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "blendNodeGetBottomChild" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RenderNode -> RenderNode
Gsk.RenderNode.RenderNode) Ptr RenderNode
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    RenderNode -> IO RenderNode
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'


-- function gsk_blend_node_get_blend_mode
-- Args: [ Arg
--           { argCName = "node"
--           , argType =
--               TInterface Name { namespace = "Gsk" , name = "RenderNode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gsk" , name = "BlendMode" })
-- throws : False
-- Skip return : False

foreign import ccall "gsk_blend_node_get_blend_mode" gsk_blend_node_get_blend_mode :: 
    Ptr Gsk.RenderNode.RenderNode ->        -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    IO CUInt

-- | /No description available in the introspection data./
blendNodeGetBlendMode ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gsk.RenderNode.RenderNode
    -> m Gsk.Enums.BlendMode
blendNodeGetBlendMode :: RenderNode -> m BlendMode
blendNodeGetBlendMode node :: RenderNode
node = IO BlendMode -> m BlendMode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BlendMode -> m BlendMode) -> IO BlendMode -> m BlendMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
    CUInt
result <- Ptr RenderNode -> IO CUInt
gsk_blend_node_get_blend_mode Ptr RenderNode
node'
    let result' :: BlendMode
result' = (Int -> BlendMode
forall a. Enum a => Int -> a
toEnum (Int -> BlendMode) -> (CUInt -> Int) -> CUInt -> BlendMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
    BlendMode -> IO BlendMode
forall (m :: * -> *) a. Monad m => a -> m a
return BlendMode
result'