{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GskRenderNode@ is the basic block in a scene graph to be
-- rendered using t'GI.Gsk.Objects.Renderer.Renderer'.
-- 
-- Each node has a parent, except the top-level node; each node may have
-- children nodes.
-- 
-- Each node has an associated drawing surface, which has the size of
-- the rectangle set when creating it.
-- 
-- Render nodes are meant to be transient; once they have been associated
-- to a t'GI.Gsk.Objects.Renderer.Renderer' it\'s safe to release any reference you have on
-- them. All t'GI.Gsk.Objects.RenderNode.RenderNode's are immutable, you can only specify their
-- properties during construction.

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

module GI.Gsk.Objects.RenderNode
    ( 
#if defined(ENABLE_OVERLOADING)
    RenderNodeDeserializeMethodInfo         ,
#endif

-- * Exported types
    RenderNode(..)                          ,
    IsRenderNode                            ,
    toRenderNode                            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [draw]("GI.Gsk.Objects.RenderNode#g:method:draw"), [ref]("GI.Gsk.Objects.RenderNode#g:method:ref"), [serialize]("GI.Gsk.Objects.RenderNode#g:method:serialize"), [unref]("GI.Gsk.Objects.RenderNode#g:method:unref"), [writeToFile]("GI.Gsk.Objects.RenderNode#g:method:writeToFile").
-- 
-- ==== Getters
-- [getBounds]("GI.Gsk.Objects.RenderNode#g:method:getBounds"), [getNodeType]("GI.Gsk.Objects.RenderNode#g:method:getNodeType").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveRenderNodeMethod                 ,
#endif

-- ** draw #method:draw#

#if defined(ENABLE_OVERLOADING)
    RenderNodeDrawMethodInfo                ,
#endif
    renderNodeDraw                          ,


-- ** getBounds #method:getBounds#

#if defined(ENABLE_OVERLOADING)
    RenderNodeGetBoundsMethodInfo           ,
#endif
    renderNodeGetBounds                     ,


-- ** getNodeType #method:getNodeType#

#if defined(ENABLE_OVERLOADING)
    RenderNodeGetNodeTypeMethodInfo         ,
#endif
    renderNodeGetNodeType                   ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    RenderNodeRefMethodInfo                 ,
#endif
    renderNodeRef                           ,


-- ** serialize #method:serialize#

#if defined(ENABLE_OVERLOADING)
    RenderNodeSerializeMethodInfo           ,
#endif
    renderNodeSerialize                     ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    RenderNodeUnrefMethodInfo               ,
#endif
    renderNodeUnref                         ,


-- ** writeToFile #method:writeToFile#

#if defined(ENABLE_OVERLOADING)
    RenderNodeWriteToFileMethodInfo         ,
#endif
    renderNodeWriteToFile                   ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.Graphene.Structs.Rect as Graphene.Rect
import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums

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

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

foreign import ccall "gsk_render_node_get_type"
    c_gsk_render_node_get_type :: IO B.Types.GType

instance B.Types.TypedObject RenderNode where
    glibType :: IO GType
glibType = IO GType
c_gsk_render_node_get_type

-- | Type class for types which can be safely cast to `RenderNode`, for instance with `toRenderNode`.
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf RenderNode o) => IsRenderNode o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf RenderNode o) => IsRenderNode o

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

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

foreign import ccall "gsk_value_get_render_node" gv_get_gsk_value_get_render_node ::
    FP.Ptr B.GValue.GValue -> IO (FP.Ptr RenderNode)

foreign import ccall "gsk_value_set_render_node" gv_set_gsk_value_set_render_node ::
    FP.Ptr B.GValue.GValue -> FP.Ptr RenderNode -> IO ()

-- | Convert 'RenderNode' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe RenderNode) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gsk_render_node_get_type
    gvalueSet_ :: Ptr GValue -> Maybe RenderNode -> IO ()
gvalueSet_ Ptr GValue
gv Maybe RenderNode
P.Nothing = Ptr GValue -> Ptr RenderNode -> IO ()
gv_set_gsk_value_set_render_node Ptr GValue
gv (Ptr RenderNode
forall a. Ptr a
FP.nullPtr :: FP.Ptr RenderNode)
    gvalueSet_ Ptr GValue
gv (P.Just RenderNode
obj) = RenderNode -> (Ptr RenderNode -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RenderNode
obj (Ptr GValue -> Ptr RenderNode -> IO ()
gv_set_gsk_value_set_render_node Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe RenderNode)
gvalueGet_ Ptr GValue
gv = do
        Ptr RenderNode
ptr <- Ptr GValue -> IO (Ptr RenderNode)
gv_get_gsk_value_get_render_node Ptr GValue
gv :: IO (FP.Ptr RenderNode)
        if Ptr RenderNode
ptr Ptr RenderNode -> Ptr RenderNode -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr RenderNode
forall a. Ptr a
FP.nullPtr
        then RenderNode -> Maybe RenderNode
forall a. a -> Maybe a
P.Just (RenderNode -> Maybe RenderNode)
-> IO RenderNode -> IO (Maybe RenderNode)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newPtr ManagedPtr RenderNode -> RenderNode
RenderNode Ptr RenderNode
ptr
        else Maybe RenderNode -> IO (Maybe RenderNode)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe RenderNode
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveRenderNodeMethod (t :: Symbol) (o :: *) :: * where
    ResolveRenderNodeMethod "draw" o = RenderNodeDrawMethodInfo
    ResolveRenderNodeMethod "ref" o = RenderNodeRefMethodInfo
    ResolveRenderNodeMethod "serialize" o = RenderNodeSerializeMethodInfo
    ResolveRenderNodeMethod "unref" o = RenderNodeUnrefMethodInfo
    ResolveRenderNodeMethod "writeToFile" o = RenderNodeWriteToFileMethodInfo
    ResolveRenderNodeMethod "getBounds" o = RenderNodeGetBoundsMethodInfo
    ResolveRenderNodeMethod "getNodeType" o = RenderNodeGetNodeTypeMethodInfo
    ResolveRenderNodeMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

#endif

foreign import ccall "gsk_render_node_ref" _RenderNode_copy_gsk_render_node_ref :: Ptr a -> IO (Ptr a)

foreign import ccall "gsk_render_node_unref" _RenderNode_free_gsk_render_node_unref :: Ptr a -> IO ()

instance BoxedPtr RenderNode where
    boxedPtrCopy :: RenderNode -> IO RenderNode
boxedPtrCopy = \RenderNode
p -> RenderNode -> (Ptr RenderNode -> IO RenderNode) -> IO RenderNode
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RenderNode
p (Ptr RenderNode -> IO (Ptr RenderNode)
forall a. Ptr a -> IO (Ptr a)
_RenderNode_copy_gsk_render_node_ref (Ptr RenderNode -> IO (Ptr RenderNode))
-> (Ptr RenderNode -> IO RenderNode)
-> Ptr RenderNode
-> IO RenderNode
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr RenderNode -> RenderNode
RenderNode)
    boxedPtrFree :: RenderNode -> IO ()
boxedPtrFree = \RenderNode
p -> RenderNode -> (Ptr RenderNode -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RenderNode
p Ptr RenderNode -> IO ()
forall a. Ptr a -> IO ()
_RenderNode_free_gsk_render_node_unref


-- method RenderNode::draw
-- method type : OrdinaryMethod
-- 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
--           }
--       , Arg
--           { argCName = "cr"
--           , argType =
--               TInterface Name { namespace = "cairo" , name = "Context" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "cairo context to draw to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Draw the contents of /@node@/ to the given cairo context.
-- 
-- Typically, you\'ll use this function to implement fallback rendering
-- of @GskRenderNode@s on an intermediate Cairo context, instead of using
-- the drawing context associated to a t'GI.Gdk.Objects.Surface.Surface'\'s rendering buffer.
-- 
-- For advanced nodes that cannot be supported using Cairo, in particular
-- for nodes doing 3D operations, this function may fail.
renderNodeDraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
    a
    -- ^ /@node@/: a @GskRenderNode@
    -> Cairo.Context.Context
    -- ^ /@cr@/: cairo context to draw to
    -> m ()
renderNodeDraw :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRenderNode a) =>
a -> Context -> m ()
renderNodeDraw a
node Context
cr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- a -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    Ptr Context
cr' <- Context -> IO (Ptr Context)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Context
cr
    Ptr RenderNode -> Ptr Context -> IO ()
gsk_render_node_draw Ptr RenderNode
node' Ptr Context
cr'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    Context -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Context
cr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RenderNodeDrawMethodInfo
instance (signature ~ (Cairo.Context.Context -> m ()), MonadIO m, IsRenderNode a) => O.OverloadedMethod RenderNodeDrawMethodInfo a signature where
    overloadedMethod = renderNodeDraw

instance O.OverloadedMethodInfo RenderNodeDrawMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Objects.RenderNode.renderNodeDraw",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-RenderNode.html#v:renderNodeDraw"
        })


#endif

-- method RenderNode::get_bounds
-- method type : OrdinaryMethod
-- 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
--           }
--       , Arg
--           { argCName = "bounds"
--           , argType =
--               TInterface Name { namespace = "Graphene" , name = "Rect" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the boundaries"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Retrieves the boundaries of the /@node@/.
-- 
-- The node will not draw outside of its boundaries.
renderNodeGetBounds ::
    (B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
    a
    -- ^ /@node@/: a @GskRenderNode@
    -> m (Graphene.Rect.Rect)
renderNodeGetBounds :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRenderNode a) =>
a -> m Rect
renderNodeGetBounds a
node = IO Rect -> m Rect
forall a. IO a -> m a
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' <- a -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    Ptr Rect
bounds <- Int -> IO (Ptr Rect)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
16 :: IO (Ptr Graphene.Rect.Rect)
    Ptr RenderNode -> Ptr Rect -> IO ()
gsk_render_node_get_bounds Ptr RenderNode
node' Ptr Rect
bounds
    Rect
bounds' <- ((ManagedPtr Rect -> Rect) -> Ptr Rect -> IO Rect
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Graphene.Rect.Rect) Ptr Rect
bounds
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    Rect -> IO Rect
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rect
bounds'

#if defined(ENABLE_OVERLOADING)
data RenderNodeGetBoundsMethodInfo
instance (signature ~ (m (Graphene.Rect.Rect)), MonadIO m, IsRenderNode a) => O.OverloadedMethod RenderNodeGetBoundsMethodInfo a signature where
    overloadedMethod = renderNodeGetBounds

instance O.OverloadedMethodInfo RenderNodeGetBoundsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Objects.RenderNode.renderNodeGetBounds",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-RenderNode.html#v:renderNodeGetBounds"
        })


#endif

-- method RenderNode::get_node_type
-- method type : OrdinaryMethod
-- 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 = "Gsk" , name = "RenderNodeType" })
-- throws : False
-- Skip return : False

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

-- | Returns the type of the /@node@/.
renderNodeGetNodeType ::
    (B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
    a
    -- ^ /@node@/: a @GskRenderNode@
    -> m Gsk.Enums.RenderNodeType
    -- ^ __Returns:__ the type of the @GskRenderNode@
renderNodeGetNodeType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRenderNode a) =>
a -> m RenderNodeType
renderNodeGetNodeType a
node = IO RenderNodeType -> m RenderNodeType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RenderNodeType -> m RenderNodeType)
-> IO RenderNodeType -> m RenderNodeType
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- a -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    CUInt
result <- Ptr RenderNode -> IO CUInt
gsk_render_node_get_node_type Ptr RenderNode
node'
    let result' :: RenderNodeType
result' = (Int -> RenderNodeType
forall a. Enum a => Int -> a
toEnum (Int -> RenderNodeType)
-> (CUInt -> Int) -> CUInt -> RenderNodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    RenderNodeType -> IO RenderNodeType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNodeType
result'

#if defined(ENABLE_OVERLOADING)
data RenderNodeGetNodeTypeMethodInfo
instance (signature ~ (m Gsk.Enums.RenderNodeType), MonadIO m, IsRenderNode a) => O.OverloadedMethod RenderNodeGetNodeTypeMethodInfo a signature where
    overloadedMethod = renderNodeGetNodeType

instance O.OverloadedMethodInfo RenderNodeGetNodeTypeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Objects.RenderNode.renderNodeGetNodeType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-RenderNode.html#v:renderNodeGetNodeType"
        })


#endif

-- method RenderNode::ref
-- method type : OrdinaryMethod
-- 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 = "Gsk" , name = "RenderNode" })
-- throws : False
-- Skip return : False

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

-- | Acquires a reference on the given @GskRenderNode@.
renderNodeRef ::
    (B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
    a
    -- ^ /@node@/: a @GskRenderNode@
    -> m RenderNode
    -- ^ __Returns:__ the @GskRenderNode@ with an additional reference
renderNodeRef :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRenderNode a) =>
a -> m RenderNode
renderNodeRef a
node = IO RenderNode -> m RenderNode
forall a. IO a -> m a
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' <- a -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    Ptr RenderNode
result <- Ptr RenderNode -> IO (Ptr RenderNode)
gsk_render_node_ref Ptr RenderNode
node'
    Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"renderNodeRef" Ptr RenderNode
result
    RenderNode
result' <- ((ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr RenderNode -> RenderNode
RenderNode) Ptr RenderNode
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    RenderNode -> IO RenderNode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RenderNode
result'

#if defined(ENABLE_OVERLOADING)
data RenderNodeRefMethodInfo
instance (signature ~ (m RenderNode), MonadIO m, IsRenderNode a) => O.OverloadedMethod RenderNodeRefMethodInfo a signature where
    overloadedMethod = renderNodeRef

instance O.OverloadedMethodInfo RenderNodeRefMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Objects.RenderNode.renderNodeRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-RenderNode.html#v:renderNodeRef"
        })


#endif

-- method RenderNode::serialize
-- method type : OrdinaryMethod
-- 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 = "GLib" , name = "Bytes" })
-- throws : False
-- Skip return : False

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

-- | Serializes the /@node@/ for later deserialization via
-- 'GI.Gsk.Objects.RenderNode.renderNodeDeserialize'. No guarantees are made about the format
-- used other than that the same version of GTK will be able to deserialize
-- the result of a call to 'GI.Gsk.Objects.RenderNode.renderNodeSerialize' and
-- 'GI.Gsk.Objects.RenderNode.renderNodeDeserialize' will correctly reject files it cannot open
-- that were created with previous versions of GTK.
-- 
-- The intended use of this functions is testing, benchmarking and debugging.
-- The format is not meant as a permanent storage format.
renderNodeSerialize ::
    (B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
    a
    -- ^ /@node@/: a @GskRenderNode@
    -> m GLib.Bytes.Bytes
    -- ^ __Returns:__ a @GBytes@ representing the node.
renderNodeSerialize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRenderNode a) =>
a -> m Bytes
renderNodeSerialize a
node = IO Bytes -> m Bytes
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bytes -> m Bytes) -> IO Bytes -> m Bytes
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- a -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    Ptr Bytes
result <- Ptr RenderNode -> IO (Ptr Bytes)
gsk_render_node_serialize Ptr RenderNode
node'
    Text -> Ptr Bytes -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"renderNodeSerialize" Ptr Bytes
result
    Bytes
result' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    Bytes -> IO Bytes
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result'

#if defined(ENABLE_OVERLOADING)
data RenderNodeSerializeMethodInfo
instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m, IsRenderNode a) => O.OverloadedMethod RenderNodeSerializeMethodInfo a signature where
    overloadedMethod = renderNodeSerialize

instance O.OverloadedMethodInfo RenderNodeSerializeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Objects.RenderNode.renderNodeSerialize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-RenderNode.html#v:renderNodeSerialize"
        })


#endif

-- method RenderNode::unref
-- method type : OrdinaryMethod
-- 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 = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Releases a reference on the given @GskRenderNode@.
-- 
-- If the reference was the last, the resources associated to the /@node@/ are
-- freed.
renderNodeUnref ::
    (B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
    a
    -- ^ /@node@/: a @GskRenderNode@
    -> m ()
renderNodeUnref :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRenderNode a) =>
a -> m ()
renderNodeUnref a
node = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- a -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
B.ManagedPtr.disownManagedPtr a
node
    Ptr RenderNode -> IO ()
gsk_render_node_unref Ptr RenderNode
node'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RenderNodeUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRenderNode a) => O.OverloadedMethod RenderNodeUnrefMethodInfo a signature where
    overloadedMethod = renderNodeUnref

instance O.OverloadedMethodInfo RenderNodeUnrefMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Objects.RenderNode.renderNodeUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-RenderNode.html#v:renderNodeUnref"
        })


#endif

-- method RenderNode::write_to_file
-- method type : OrdinaryMethod
-- 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
--           }
--       , Arg
--           { argCName = "filename"
--           , argType = TBasicType TFileName
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the file to save it to."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "gsk_render_node_write_to_file" gsk_render_node_write_to_file :: 
    Ptr RenderNode ->                       -- node : TInterface (Name {namespace = "Gsk", name = "RenderNode"})
    CString ->                              -- filename : TBasicType TFileName
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function is equivalent to calling 'GI.Gsk.Objects.RenderNode.renderNodeSerialize'
-- followed by 'GI.GLib.Functions.fileSetContents'.
-- 
-- See those two functions for details on the arguments.
-- 
-- It is mostly intended for use inside a debugger to quickly dump a render
-- node to a file for later inspection.
renderNodeWriteToFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
    a
    -- ^ /@node@/: a @GskRenderNode@
    -> [Char]
    -- ^ /@filename@/: the file to save it to.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
renderNodeWriteToFile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRenderNode a) =>
a -> [Char] -> m ()
renderNodeWriteToFile a
node [Char]
filename = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr RenderNode
node' <- a -> IO (Ptr RenderNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
    CString
filename' <- [Char] -> IO CString
stringToCString [Char]
filename
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr RenderNode -> CString -> Ptr (Ptr GError) -> IO CInt
gsk_render_node_write_to_file Ptr RenderNode
node' CString
filename'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
     )

#if defined(ENABLE_OVERLOADING)
data RenderNodeWriteToFileMethodInfo
instance (signature ~ ([Char] -> m ()), MonadIO m, IsRenderNode a) => O.OverloadedMethod RenderNodeWriteToFileMethodInfo a signature where
    overloadedMethod = renderNodeWriteToFile

instance O.OverloadedMethodInfo RenderNodeWriteToFileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gsk.Objects.RenderNode.renderNodeWriteToFile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.5/docs/GI-Gsk-Objects-RenderNode.html#v:renderNodeWriteToFile"
        })


#endif

-- XXX Could not generate method RenderNode::deserialize
{-  Bad introspection data: Closure not found! 
    Closure: 1
    c2cm: fromList
      [ ( 2
        , Arg
            { argCName = "error_func"
            , argType =
                TInterface Name { namespace = "Gsk" , name = "ParseErrorFunc" }
            , direction = DirectionIn
            , mayBeNull = True
            , argDoc =
                Documentation
                  { rawDocText = Just "Callback on parsing errors"
                  , sinceVersion = Nothing
                  }
            , argScope = ScopeTypeCall
            , argClosure = 2
            , argDestroy = -1
            , argCallerAllocates = False
            , transfer = TransferNothing
            }
        )
      ]
    callable: Callable
      { returnType =
          Just (TInterface Name { namespace = "Gsk" , name = "RenderNode" })
      , returnMayBeNull = True
      , returnTransfer = TransferEverything
      , returnDocumentation =
          Documentation
            { rawDocText = Just "a new `GskRenderNode`"
            , sinceVersion = Nothing
            }
      , args =
          [ Arg
              { argCName = "bytes"
              , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
              , direction = DirectionIn
              , mayBeNull = False
              , argDoc =
                  Documentation
                    { rawDocText = Just "the bytes containing the data"
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeInvalid
              , argClosure = -1
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "error_func"
              , argType =
                  TInterface Name { namespace = "Gsk" , name = "ParseErrorFunc" }
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText = Just "Callback on parsing errors"
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeCall
              , argClosure = 2
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          , Arg
              { argCName = "user_data"
              , argType = TBasicType TPtr
              , direction = DirectionIn
              , mayBeNull = True
              , argDoc =
                  Documentation
                    { rawDocText = Just "user_data for @error_func"
                    , sinceVersion = Nothing
                    }
              , argScope = ScopeTypeInvalid
              , argClosure = 1
              , argDestroy = -1
              , argCallerAllocates = False
              , transfer = TransferNothing
              }
          ]
      , skipReturn = False
      , callableThrows = False
      , callableDeprecated = Nothing
      , callableDocumentation =
          Documentation
            { rawDocText =
                Just
                  "Loads data previously created via [method@Gsk.RenderNode.serialize].\n\nFor a discussion of the supported format, see that function."
            , sinceVersion = Nothing
            }
      , callableResolvable = Just True
      }
-}
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RenderNodeDeserializeMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "deserialize" RenderNode) => O.OverloadedMethod RenderNodeDeserializeMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "deserialize" RenderNode) => O.OverloadedMethodInfo RenderNodeDeserializeMethodInfo o where
    overloadedMethodInfo = undefined

#endif