{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Objects.PaintNode
(
PaintNode(..) ,
IsPaintNode ,
toPaintNode ,
#if defined(ENABLE_OVERLOADING)
ResolvePaintNodeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PaintNodeAddChildMethodInfo ,
#endif
paintNodeAddChild ,
#if defined(ENABLE_OVERLOADING)
PaintNodeAddRectangleMethodInfo ,
#endif
paintNodeAddRectangle ,
#if defined(ENABLE_OVERLOADING)
PaintNodeAddTextureRectangleMethodInfo ,
#endif
paintNodeAddTextureRectangle ,
#if defined(ENABLE_OVERLOADING)
PaintNodeRefMethodInfo ,
#endif
paintNodeRef ,
#if defined(ENABLE_OVERLOADING)
PaintNodeSetNameMethodInfo ,
#endif
paintNodeSetName ,
#if defined(ENABLE_OVERLOADING)
PaintNodeUnrefMethodInfo ,
#endif
paintNodeUnref ,
) 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.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 {-# SOURCE #-} qualified GI.Clutter.Structs.ActorBox as Clutter.ActorBox
newtype PaintNode = PaintNode (SP.ManagedPtr PaintNode)
deriving (PaintNode -> PaintNode -> Bool
(PaintNode -> PaintNode -> Bool)
-> (PaintNode -> PaintNode -> Bool) -> Eq PaintNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PaintNode -> PaintNode -> Bool
$c/= :: PaintNode -> PaintNode -> Bool
== :: PaintNode -> PaintNode -> Bool
$c== :: PaintNode -> PaintNode -> Bool
Eq)
instance SP.ManagedPtrNewtype PaintNode where
toManagedPtr :: PaintNode -> ManagedPtr PaintNode
toManagedPtr (PaintNode ManagedPtr PaintNode
p) = ManagedPtr PaintNode
p
foreign import ccall "clutter_paint_node_get_type"
c_clutter_paint_node_get_type :: IO B.Types.GType
instance B.Types.TypedObject PaintNode where
glibType :: IO GType
glibType = IO GType
c_clutter_paint_node_get_type
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf PaintNode o) => IsPaintNode o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf PaintNode o) => IsPaintNode o
instance O.HasParentTypes PaintNode
type instance O.ParentTypes PaintNode = '[]
toPaintNode :: (MIO.MonadIO m, IsPaintNode o) => o -> m PaintNode
toPaintNode :: forall (m :: * -> *) o.
(MonadIO m, IsPaintNode o) =>
o -> m PaintNode
toPaintNode = IO PaintNode -> m PaintNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO PaintNode -> m PaintNode)
-> (o -> IO PaintNode) -> o -> m PaintNode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr PaintNode -> PaintNode) -> o -> IO PaintNode
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr PaintNode -> PaintNode
PaintNode
foreign import ccall "clutter_value_get_paint_node" gv_get_clutter_value_get_paint_node ::
FP.Ptr B.GValue.GValue -> IO (FP.Ptr PaintNode)
foreign import ccall "clutter_value_set_paint_node" gv_set_clutter_value_set_paint_node ::
FP.Ptr B.GValue.GValue -> FP.Ptr PaintNode -> IO ()
instance B.GValue.IsGValue (Maybe PaintNode) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_paint_node_get_type
gvalueSet_ :: Ptr GValue -> Maybe PaintNode -> IO ()
gvalueSet_ Ptr GValue
gv Maybe PaintNode
P.Nothing = Ptr GValue -> Ptr PaintNode -> IO ()
gv_set_clutter_value_set_paint_node Ptr GValue
gv (Ptr PaintNode
forall a. Ptr a
FP.nullPtr :: FP.Ptr PaintNode)
gvalueSet_ Ptr GValue
gv (P.Just PaintNode
obj) = PaintNode -> (Ptr PaintNode -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PaintNode
obj (Ptr GValue -> Ptr PaintNode -> IO ()
gv_set_clutter_value_set_paint_node Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe PaintNode)
gvalueGet_ Ptr GValue
gv = do
Ptr PaintNode
ptr <- Ptr GValue -> IO (Ptr PaintNode)
gv_get_clutter_value_get_paint_node Ptr GValue
gv :: IO (FP.Ptr PaintNode)
if Ptr PaintNode
ptr Ptr PaintNode -> Ptr PaintNode -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr PaintNode
forall a. Ptr a
FP.nullPtr
then PaintNode -> Maybe PaintNode
forall a. a -> Maybe a
P.Just (PaintNode -> Maybe PaintNode)
-> IO PaintNode -> IO (Maybe PaintNode)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr PaintNode -> PaintNode)
-> Ptr PaintNode -> IO PaintNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newPtr ManagedPtr PaintNode -> PaintNode
PaintNode Ptr PaintNode
ptr
else Maybe PaintNode -> IO (Maybe PaintNode)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PaintNode
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolvePaintNodeMethod (t :: Symbol) (o :: *) :: * where
ResolvePaintNodeMethod "addChild" o = PaintNodeAddChildMethodInfo
ResolvePaintNodeMethod "addRectangle" o = PaintNodeAddRectangleMethodInfo
ResolvePaintNodeMethod "addTextureRectangle" o = PaintNodeAddTextureRectangleMethodInfo
ResolvePaintNodeMethod "ref" o = PaintNodeRefMethodInfo
ResolvePaintNodeMethod "unref" o = PaintNodeUnrefMethodInfo
ResolvePaintNodeMethod "setName" o = PaintNodeSetNameMethodInfo
ResolvePaintNodeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePaintNodeMethod t PaintNode, O.OverloadedMethod info PaintNode p) => OL.IsLabel t (PaintNode -> 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 ~ ResolvePaintNodeMethod t PaintNode, O.OverloadedMethod info PaintNode p, R.HasField t PaintNode p) => R.HasField t PaintNode p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolvePaintNodeMethod t PaintNode, O.OverloadedMethodInfo info PaintNode) => OL.IsLabel t (O.MethodProxy info PaintNode) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "clutter_paint_node_ref" _PaintNode_copy_clutter_paint_node_ref :: Ptr a -> IO (Ptr a)
foreign import ccall "clutter_paint_node_unref" _PaintNode_free_clutter_paint_node_unref :: Ptr a -> IO ()
instance BoxedPtr PaintNode where
boxedPtrCopy :: PaintNode -> IO PaintNode
boxedPtrCopy = \PaintNode
p -> PaintNode -> (Ptr PaintNode -> IO PaintNode) -> IO PaintNode
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PaintNode
p (Ptr PaintNode -> IO (Ptr PaintNode)
forall a. Ptr a -> IO (Ptr a)
_PaintNode_copy_clutter_paint_node_ref (Ptr PaintNode -> IO (Ptr PaintNode))
-> (Ptr PaintNode -> IO PaintNode) -> Ptr PaintNode -> IO PaintNode
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr PaintNode -> PaintNode)
-> Ptr PaintNode -> IO PaintNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr PaintNode -> PaintNode
PaintNode)
boxedPtrFree :: PaintNode -> IO ()
boxedPtrFree = \PaintNode
p -> PaintNode -> (Ptr PaintNode -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PaintNode
p Ptr PaintNode -> IO ()
forall a. Ptr a -> IO ()
_PaintNode_free_clutter_paint_node_unref
foreign import ccall "clutter_paint_node_add_child" clutter_paint_node_add_child ::
Ptr PaintNode ->
Ptr PaintNode ->
IO ()
paintNodeAddChild ::
(B.CallStack.HasCallStack, MonadIO m, IsPaintNode a, IsPaintNode b) =>
a
-> b
-> m ()
paintNodeAddChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPaintNode a, IsPaintNode b) =>
a -> b -> m ()
paintNodeAddChild a
node b
child = 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 PaintNode
node' <- a -> IO (Ptr PaintNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr PaintNode
child' <- b -> IO (Ptr PaintNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
Ptr PaintNode -> Ptr PaintNode -> IO ()
clutter_paint_node_add_child Ptr PaintNode
node' Ptr PaintNode
child'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PaintNodeAddChildMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsPaintNode a, IsPaintNode b) => O.OverloadedMethod PaintNodeAddChildMethodInfo a signature where
overloadedMethod = paintNodeAddChild
instance O.OverloadedMethodInfo PaintNodeAddChildMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.PaintNode.paintNodeAddChild",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-PaintNode.html#v:paintNodeAddChild"
})
#endif
foreign import ccall "clutter_paint_node_add_rectangle" clutter_paint_node_add_rectangle ::
Ptr PaintNode ->
Ptr Clutter.ActorBox.ActorBox ->
IO ()
paintNodeAddRectangle ::
(B.CallStack.HasCallStack, MonadIO m, IsPaintNode a) =>
a
-> Clutter.ActorBox.ActorBox
-> m ()
paintNodeAddRectangle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPaintNode a) =>
a -> ActorBox -> m ()
paintNodeAddRectangle a
node ActorBox
rect = 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 PaintNode
node' <- a -> IO (Ptr PaintNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr ActorBox
rect' <- ActorBox -> IO (Ptr ActorBox)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ActorBox
rect
Ptr PaintNode -> Ptr ActorBox -> IO ()
clutter_paint_node_add_rectangle Ptr PaintNode
node' Ptr ActorBox
rect'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
ActorBox -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ActorBox
rect
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PaintNodeAddRectangleMethodInfo
instance (signature ~ (Clutter.ActorBox.ActorBox -> m ()), MonadIO m, IsPaintNode a) => O.OverloadedMethod PaintNodeAddRectangleMethodInfo a signature where
overloadedMethod = paintNodeAddRectangle
instance O.OverloadedMethodInfo PaintNodeAddRectangleMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.PaintNode.paintNodeAddRectangle",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-PaintNode.html#v:paintNodeAddRectangle"
})
#endif
foreign import ccall "clutter_paint_node_add_texture_rectangle" clutter_paint_node_add_texture_rectangle ::
Ptr PaintNode ->
Ptr Clutter.ActorBox.ActorBox ->
CFloat ->
CFloat ->
CFloat ->
CFloat ->
IO ()
paintNodeAddTextureRectangle ::
(B.CallStack.HasCallStack, MonadIO m, IsPaintNode a) =>
a
-> Clutter.ActorBox.ActorBox
-> Float
-> Float
-> Float
-> Float
-> m ()
paintNodeAddTextureRectangle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPaintNode a) =>
a -> ActorBox -> Float -> Float -> Float -> Float -> m ()
paintNodeAddTextureRectangle a
node ActorBox
rect Float
x1 Float
y1 Float
x2 Float
y2 = 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 PaintNode
node' <- a -> IO (Ptr PaintNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr ActorBox
rect' <- ActorBox -> IO (Ptr ActorBox)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ActorBox
rect
let x1' :: CFloat
x1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x1
let y1' :: CFloat
y1' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y1
let x2' :: CFloat
x2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x2
let y2' :: CFloat
y2' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y2
Ptr PaintNode
-> Ptr ActorBox -> CFloat -> CFloat -> CFloat -> CFloat -> IO ()
clutter_paint_node_add_texture_rectangle Ptr PaintNode
node' Ptr ActorBox
rect' CFloat
x1' CFloat
y1' CFloat
x2' CFloat
y2'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
ActorBox -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ActorBox
rect
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PaintNodeAddTextureRectangleMethodInfo
instance (signature ~ (Clutter.ActorBox.ActorBox -> Float -> Float -> Float -> Float -> m ()), MonadIO m, IsPaintNode a) => O.OverloadedMethod PaintNodeAddTextureRectangleMethodInfo a signature where
overloadedMethod = paintNodeAddTextureRectangle
instance O.OverloadedMethodInfo PaintNodeAddTextureRectangleMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.PaintNode.paintNodeAddTextureRectangle",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-PaintNode.html#v:paintNodeAddTextureRectangle"
})
#endif
foreign import ccall "clutter_paint_node_ref" clutter_paint_node_ref ::
Ptr PaintNode ->
IO (Ptr PaintNode)
paintNodeRef ::
(B.CallStack.HasCallStack, MonadIO m, IsPaintNode a) =>
a
-> m PaintNode
paintNodeRef :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPaintNode a) =>
a -> m PaintNode
paintNodeRef a
node = IO PaintNode -> m PaintNode
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PaintNode -> m PaintNode) -> IO PaintNode -> m PaintNode
forall a b. (a -> b) -> a -> b
$ do
Ptr PaintNode
node' <- a -> IO (Ptr PaintNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr PaintNode
result <- Ptr PaintNode -> IO (Ptr PaintNode)
clutter_paint_node_ref Ptr PaintNode
node'
Text -> Ptr PaintNode -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"paintNodeRef" Ptr PaintNode
result
PaintNode
result' <- ((ManagedPtr PaintNode -> PaintNode)
-> Ptr PaintNode -> IO PaintNode
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr PaintNode -> PaintNode
PaintNode) Ptr PaintNode
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
PaintNode -> IO PaintNode
forall (m :: * -> *) a. Monad m => a -> m a
return PaintNode
result'
#if defined(ENABLE_OVERLOADING)
data PaintNodeRefMethodInfo
instance (signature ~ (m PaintNode), MonadIO m, IsPaintNode a) => O.OverloadedMethod PaintNodeRefMethodInfo a signature where
overloadedMethod = paintNodeRef
instance O.OverloadedMethodInfo PaintNodeRefMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.PaintNode.paintNodeRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-PaintNode.html#v:paintNodeRef"
})
#endif
foreign import ccall "clutter_paint_node_set_name" clutter_paint_node_set_name ::
Ptr PaintNode ->
CString ->
IO ()
paintNodeSetName ::
(B.CallStack.HasCallStack, MonadIO m, IsPaintNode a) =>
a
-> T.Text
-> m ()
paintNodeSetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPaintNode a) =>
a -> Text -> m ()
paintNodeSetName a
node Text
name = 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 PaintNode
node' <- a -> IO (Ptr PaintNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr PaintNode -> CString -> IO ()
clutter_paint_node_set_name Ptr PaintNode
node' CString
name'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PaintNodeSetNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsPaintNode a) => O.OverloadedMethod PaintNodeSetNameMethodInfo a signature where
overloadedMethod = paintNodeSetName
instance O.OverloadedMethodInfo PaintNodeSetNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.PaintNode.paintNodeSetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-PaintNode.html#v:paintNodeSetName"
})
#endif
foreign import ccall "clutter_paint_node_unref" clutter_paint_node_unref ::
Ptr PaintNode ->
IO ()
paintNodeUnref ::
(B.CallStack.HasCallStack, MonadIO m, IsPaintNode a) =>
a
-> m ()
paintNodeUnref :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPaintNode a) =>
a -> m ()
paintNodeUnref a
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 PaintNode
node' <- a -> IO (Ptr PaintNode)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
node
Ptr PaintNode -> IO ()
clutter_paint_node_unref Ptr PaintNode
node'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
node
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PaintNodeUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPaintNode a) => O.OverloadedMethod PaintNodeUnrefMethodInfo a signature where
overloadedMethod = paintNodeUnref
instance O.OverloadedMethodInfo PaintNodeUnrefMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Clutter.Objects.PaintNode.paintNodeUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.2/docs/GI-Clutter-Objects-PaintNode.html#v:paintNodeUnref"
})
#endif