{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gsk.Structs.RenderNode
(
RenderNode(..) ,
noRenderNode ,
#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.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.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 (ManagedPtr RenderNode)
deriving (RenderNode -> RenderNode -> Bool
(RenderNode -> RenderNode -> Bool)
-> (RenderNode -> RenderNode -> Bool) -> Eq RenderNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RenderNode -> RenderNode -> Bool
$c/= :: RenderNode -> RenderNode -> Bool
== :: RenderNode -> RenderNode -> Bool
$c== :: RenderNode -> RenderNode -> Bool
Eq)
foreign import ccall "gsk_render_node_get_type" c_gsk_render_node_get_type ::
IO GType
instance BoxedObject RenderNode where
boxedType :: RenderNode -> IO GType
boxedType _ = IO GType
c_gsk_render_node_get_type
instance B.GValue.IsGValue RenderNode where
toGValue :: RenderNode -> IO GValue
toGValue o :: RenderNode
o = do
GType
gtype <- IO GType
c_gsk_render_node_get_type
RenderNode -> (Ptr RenderNode -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RenderNode
o (GType
-> (GValue -> Ptr RenderNode -> IO ())
-> Ptr RenderNode
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr RenderNode -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO RenderNode
fromGValue gv :: GValue
gv = do
Ptr RenderNode
ptr <- GValue -> IO (Ptr RenderNode)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr RenderNode)
(ManagedPtr RenderNode -> RenderNode)
-> Ptr RenderNode -> IO RenderNode
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr RenderNode -> RenderNode
RenderNode Ptr RenderNode
ptr
noRenderNode :: Maybe RenderNode
noRenderNode :: Maybe RenderNode
noRenderNode = Maybe RenderNode
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RenderNode
type instance O.AttributeList RenderNode = RenderNodeAttributeList
type RenderNodeAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gsk_render_node_draw" gsk_render_node_draw ::
Ptr RenderNode ->
Ptr Cairo.Context.Context ->
IO ()
renderNodeDraw ::
(B.CallStack.HasCallStack, MonadIO m) =>
RenderNode
-> Cairo.Context.Context
-> m ()
renderNodeDraw :: RenderNode -> Context -> m ()
renderNodeDraw node :: RenderNode
node cr :: Context
cr = IO () -> m ()
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' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
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'
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
Context -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Context
cr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RenderNodeDrawMethodInfo
instance (signature ~ (Cairo.Context.Context -> m ()), MonadIO m) => O.MethodInfo RenderNodeDrawMethodInfo RenderNode signature where
overloadedMethod = 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) =>
RenderNode
-> m (Graphene.Rect.Rect)
renderNodeGetBounds :: RenderNode -> m Rect
renderNodeGetBounds 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
bounds <- Int -> IO (Ptr Rect)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 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, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Rect -> Rect
Graphene.Rect.Rect) Ptr Rect
bounds
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
Rect -> IO Rect
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) => O.MethodInfo RenderNodeGetBoundsMethodInfo RenderNode signature where
overloadedMethod = 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) =>
RenderNode
-> m Gsk.Enums.RenderNodeType
renderNodeGetNodeType :: RenderNode -> m RenderNodeType
renderNodeGetNodeType node :: RenderNode
node = IO RenderNodeType -> m RenderNodeType
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' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
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
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
RenderNodeType -> IO RenderNodeType
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) => O.MethodInfo RenderNodeGetNodeTypeMethodInfo RenderNode signature where
overloadedMethod = renderNodeGetNodeType
#endif
foreign import ccall "gsk_render_node_ref" gsk_render_node_ref ::
Ptr RenderNode ->
IO (Ptr RenderNode)
renderNodeRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
RenderNode
-> m RenderNode
renderNodeRef :: RenderNode -> m RenderNode
renderNodeRef 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_render_node_ref Ptr RenderNode
node'
Text -> Ptr RenderNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "renderNodeRef" 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
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'
#if defined(ENABLE_OVERLOADING)
data RenderNodeRefMethodInfo
instance (signature ~ (m RenderNode), MonadIO m) => O.MethodInfo RenderNodeRefMethodInfo RenderNode signature where
overloadedMethod = 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) =>
RenderNode
-> m GLib.Bytes.Bytes
renderNodeSerialize :: RenderNode -> m Bytes
renderNodeSerialize node :: RenderNode
node = IO Bytes -> m Bytes
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' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
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 "renderNodeSerialize" Ptr Bytes
result
Bytes
result' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
Bytes -> IO Bytes
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) => O.MethodInfo RenderNodeSerializeMethodInfo RenderNode signature where
overloadedMethod = renderNodeSerialize
#endif
foreign import ccall "gsk_render_node_unref" gsk_render_node_unref ::
Ptr RenderNode ->
IO ()
renderNodeUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
RenderNode
-> m ()
renderNodeUnref :: RenderNode -> m ()
renderNodeUnref node :: RenderNode
node = IO () -> m ()
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' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
Ptr RenderNode -> IO ()
gsk_render_node_unref Ptr RenderNode
node'
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RenderNodeUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RenderNodeUnrefMethodInfo RenderNode signature where
overloadedMethod = 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) =>
RenderNode
-> T.Text
-> m ()
renderNodeWriteToFile :: RenderNode -> Text -> m ()
renderNodeWriteToFile node :: RenderNode
node filename :: Text
filename = IO () -> m ()
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' <- RenderNode -> IO (Ptr RenderNode)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RenderNode
node
CString
filename' <- Text -> IO CString
textToCString Text
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'
RenderNode -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RenderNode
node
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
() -> IO ()
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 ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo RenderNodeWriteToFileMethodInfo RenderNode signature where
overloadedMethod = renderNodeWriteToFile
#endif
#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.MethodInfo 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
#endif