{-# LANGUAGE TypeApplications #-}
#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
RenderNode(..) ,
IsRenderNode ,
toRenderNode ,
#if defined(ENABLE_OVERLOADING)
ResolveRenderNodeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RenderNodeDrawMethodInfo ,
#endif
renderNodeDraw ,
#if defined(ENABLE_OVERLOADING)
RenderNodeGetBoundsMethodInfo ,
#endif
renderNodeGetBounds ,
#if defined(ENABLE_OVERLOADING)
RenderNodeGetNodeTypeMethodInfo ,
#endif
renderNodeGetNodeType ,
#if defined(ENABLE_OVERLOADING)
RenderNodeRefMethodInfo ,
#endif
renderNodeRef ,
#if defined(ENABLE_OVERLOADING)
RenderNodeSerializeMethodInfo ,
#endif
renderNodeSerialize ,
#if defined(ENABLE_OVERLOADING)
RenderNodeUnrefMethodInfo ,
#endif
renderNodeUnref ,
#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
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
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 = '[]
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 ()
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
foreign import ccall "gsk_render_node_draw" gsk_render_node_draw ::
Ptr RenderNode ->
Ptr Cairo.Context.Context ->
IO ()
renderNodeDraw ::
(B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
a
-> Cairo.Context.Context
-> 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
foreign import ccall "gsk_render_node_get_bounds" gsk_render_node_get_bounds ::
Ptr RenderNode ->
Ptr Graphene.Rect.Rect ->
IO ()
renderNodeGetBounds ::
(B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
a
-> 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
foreign import ccall "gsk_render_node_get_node_type" gsk_render_node_get_node_type ::
Ptr RenderNode ->
IO CUInt
renderNodeGetNodeType ::
(B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
a
-> m Gsk.Enums.RenderNodeType
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
foreign import ccall "gsk_render_node_ref" gsk_render_node_ref ::
Ptr RenderNode ->
IO (Ptr RenderNode)
renderNodeRef ::
(B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
a
-> m RenderNode
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
foreign import ccall "gsk_render_node_serialize" gsk_render_node_serialize ::
Ptr RenderNode ->
IO (Ptr GLib.Bytes.Bytes)
renderNodeSerialize ::
(B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
a
-> m GLib.Bytes.Bytes
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
foreign import ccall "gsk_render_node_unref" gsk_render_node_unref ::
Ptr RenderNode ->
IO ()
renderNodeUnref ::
(B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
a
-> 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
foreign import ccall "gsk_render_node_write_to_file" gsk_render_node_write_to_file ::
Ptr RenderNode ->
CString ->
Ptr (Ptr GError) ->
IO CInt
renderNodeWriteToFile ::
(B.CallStack.HasCallStack, MonadIO m, IsRenderNode a) =>
a
-> [Char]
-> m ()
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
#if defined(ENABLE_OVERLOADING)
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