module GI.GLib.Structs.Node
(
Node(..) ,
newZeroNode ,
noNode ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeChildIndexMethodInfo ,
#endif
nodeChildIndex ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeChildPositionMethodInfo ,
#endif
nodeChildPosition ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeDepthMethodInfo ,
#endif
nodeDepth ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeDestroyMethodInfo ,
#endif
nodeDestroy ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeIsAncestorMethodInfo ,
#endif
nodeIsAncestor ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeMaxHeightMethodInfo ,
#endif
nodeMaxHeight ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeNChildrenMethodInfo ,
#endif
nodeNChildren ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeNNodesMethodInfo ,
#endif
nodeNNodes ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeReverseChildrenMethodInfo ,
#endif
nodeReverseChildren ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
NodeUnlinkMethodInfo ,
#endif
nodeUnlink ,
clearNodeChildren ,
getNodeChildren ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
node_children ,
#endif
setNodeChildren ,
clearNodeData ,
getNodeData ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
node_data ,
#endif
setNodeData ,
clearNodeNext ,
getNodeNext ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
node_next ,
#endif
setNodeNext ,
clearNodeParent ,
getNodeParent ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
node_parent ,
#endif
setNodeParent ,
clearNodePrev ,
getNodePrev ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
node_prev ,
#endif
setNodePrev ,
) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GLib.Flags as GLib.Flags
newtype Node = Node (ManagedPtr Node)
instance WrappedPtr Node where
wrappedPtrCalloc = callocBytes 40
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 40 >=> wrapPtr Node)
wrappedPtrFree = Just ptr_to_g_free
newZeroNode :: MonadIO m => m Node
newZeroNode = liftIO $ wrappedPtrCalloc >>= wrapPtr Node
instance tag ~ 'AttrSet => Constructible Node tag where
new _ attrs = do
o <- newZeroNode
GI.Attributes.set o attrs
return o
noNode :: Maybe Node
noNode = Nothing
getNodeData :: MonadIO m => Node -> m (Ptr ())
getNodeData s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
return val
setNodeData :: MonadIO m => Node -> Ptr () -> m ()
setNodeData s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (val :: Ptr ())
clearNodeData :: MonadIO m => Node -> m ()
clearNodeData s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeDataFieldInfo
instance AttrInfo NodeDataFieldInfo where
type AttrAllowedOps NodeDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint NodeDataFieldInfo = (~) (Ptr ())
type AttrBaseTypeConstraint NodeDataFieldInfo = (~) Node
type AttrGetType NodeDataFieldInfo = Ptr ()
type AttrLabel NodeDataFieldInfo = "data"
type AttrOrigin NodeDataFieldInfo = Node
attrGet _ = getNodeData
attrSet _ = setNodeData
attrConstruct = undefined
attrClear _ = clearNodeData
node_data :: AttrLabelProxy "data"
node_data = AttrLabelProxy
#endif
getNodeNext :: MonadIO m => Node -> m (Maybe Node)
getNodeNext s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 8) :: IO (Ptr Node)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newPtr Node) val'
return val''
return result
setNodeNext :: MonadIO m => Node -> Ptr Node -> m ()
setNodeNext s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (val :: Ptr Node)
clearNodeNext :: MonadIO m => Node -> m ()
clearNodeNext s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Node)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeNextFieldInfo
instance AttrInfo NodeNextFieldInfo where
type AttrAllowedOps NodeNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint NodeNextFieldInfo = (~) (Ptr Node)
type AttrBaseTypeConstraint NodeNextFieldInfo = (~) Node
type AttrGetType NodeNextFieldInfo = Maybe Node
type AttrLabel NodeNextFieldInfo = "next"
type AttrOrigin NodeNextFieldInfo = Node
attrGet _ = getNodeNext
attrSet _ = setNodeNext
attrConstruct = undefined
attrClear _ = clearNodeNext
node_next :: AttrLabelProxy "next"
node_next = AttrLabelProxy
#endif
getNodePrev :: MonadIO m => Node -> m (Maybe Node)
getNodePrev s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 16) :: IO (Ptr Node)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newPtr Node) val'
return val''
return result
setNodePrev :: MonadIO m => Node -> Ptr Node -> m ()
setNodePrev s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (val :: Ptr Node)
clearNodePrev :: MonadIO m => Node -> m ()
clearNodePrev s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Node)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodePrevFieldInfo
instance AttrInfo NodePrevFieldInfo where
type AttrAllowedOps NodePrevFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint NodePrevFieldInfo = (~) (Ptr Node)
type AttrBaseTypeConstraint NodePrevFieldInfo = (~) Node
type AttrGetType NodePrevFieldInfo = Maybe Node
type AttrLabel NodePrevFieldInfo = "prev"
type AttrOrigin NodePrevFieldInfo = Node
attrGet _ = getNodePrev
attrSet _ = setNodePrev
attrConstruct = undefined
attrClear _ = clearNodePrev
node_prev :: AttrLabelProxy "prev"
node_prev = AttrLabelProxy
#endif
getNodeParent :: MonadIO m => Node -> m (Maybe Node)
getNodeParent s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 24) :: IO (Ptr Node)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newPtr Node) val'
return val''
return result
setNodeParent :: MonadIO m => Node -> Ptr Node -> m ()
setNodeParent s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 24) (val :: Ptr Node)
clearNodeParent :: MonadIO m => Node -> m ()
clearNodeParent s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr Node)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeParentFieldInfo
instance AttrInfo NodeParentFieldInfo where
type AttrAllowedOps NodeParentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint NodeParentFieldInfo = (~) (Ptr Node)
type AttrBaseTypeConstraint NodeParentFieldInfo = (~) Node
type AttrGetType NodeParentFieldInfo = Maybe Node
type AttrLabel NodeParentFieldInfo = "parent"
type AttrOrigin NodeParentFieldInfo = Node
attrGet _ = getNodeParent
attrSet _ = setNodeParent
attrConstruct = undefined
attrClear _ = clearNodeParent
node_parent :: AttrLabelProxy "parent"
node_parent = AttrLabelProxy
#endif
getNodeChildren :: MonadIO m => Node -> m (Maybe Node)
getNodeChildren s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 32) :: IO (Ptr Node)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newPtr Node) val'
return val''
return result
setNodeChildren :: MonadIO m => Node -> Ptr Node -> m ()
setNodeChildren s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 32) (val :: Ptr Node)
clearNodeChildren :: MonadIO m => Node -> m ()
clearNodeChildren s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Node)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeChildrenFieldInfo
instance AttrInfo NodeChildrenFieldInfo where
type AttrAllowedOps NodeChildrenFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint NodeChildrenFieldInfo = (~) (Ptr Node)
type AttrBaseTypeConstraint NodeChildrenFieldInfo = (~) Node
type AttrGetType NodeChildrenFieldInfo = Maybe Node
type AttrLabel NodeChildrenFieldInfo = "children"
type AttrOrigin NodeChildrenFieldInfo = Node
attrGet _ = getNodeChildren
attrSet _ = setNodeChildren
attrConstruct = undefined
attrClear _ = clearNodeChildren
node_children :: AttrLabelProxy "children"
node_children = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList Node
type instance O.AttributeList Node = NodeAttributeList
type NodeAttributeList = ('[ '("data", NodeDataFieldInfo), '("next", NodeNextFieldInfo), '("prev", NodePrevFieldInfo), '("parent", NodeParentFieldInfo), '("children", NodeChildrenFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_node_child_index" g_node_child_index ::
Ptr Node ->
Ptr () ->
IO Int32
nodeChildIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> Ptr ()
-> m Int32
nodeChildIndex node data_ = liftIO $ do
node' <- unsafeManagedPtrGetPtr node
result <- g_node_child_index node' data_
touchManagedPtr node
return result
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeChildIndexMethodInfo
instance (signature ~ (Ptr () -> m Int32), MonadIO m) => O.MethodInfo NodeChildIndexMethodInfo Node signature where
overloadedMethod _ = nodeChildIndex
#endif
foreign import ccall "g_node_child_position" g_node_child_position ::
Ptr Node ->
Ptr Node ->
IO Int32
nodeChildPosition ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> Node
-> m Int32
nodeChildPosition node child = liftIO $ do
node' <- unsafeManagedPtrGetPtr node
child' <- unsafeManagedPtrGetPtr child
result <- g_node_child_position node' child'
touchManagedPtr node
touchManagedPtr child
return result
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeChildPositionMethodInfo
instance (signature ~ (Node -> m Int32), MonadIO m) => O.MethodInfo NodeChildPositionMethodInfo Node signature where
overloadedMethod _ = nodeChildPosition
#endif
foreign import ccall "g_node_depth" g_node_depth ::
Ptr Node ->
IO Word32
nodeDepth ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> m Word32
nodeDepth node = liftIO $ do
node' <- unsafeManagedPtrGetPtr node
result <- g_node_depth node'
touchManagedPtr node
return result
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeDepthMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NodeDepthMethodInfo Node signature where
overloadedMethod _ = nodeDepth
#endif
foreign import ccall "g_node_destroy" g_node_destroy ::
Ptr Node ->
IO ()
nodeDestroy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> m ()
nodeDestroy root = liftIO $ do
root' <- unsafeManagedPtrGetPtr root
g_node_destroy root'
touchManagedPtr root
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NodeDestroyMethodInfo Node signature where
overloadedMethod _ = nodeDestroy
#endif
foreign import ccall "g_node_is_ancestor" g_node_is_ancestor ::
Ptr Node ->
Ptr Node ->
IO CInt
nodeIsAncestor ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> Node
-> m Bool
nodeIsAncestor node descendant = liftIO $ do
node' <- unsafeManagedPtrGetPtr node
descendant' <- unsafeManagedPtrGetPtr descendant
result <- g_node_is_ancestor node' descendant'
let result' = (/= 0) result
touchManagedPtr node
touchManagedPtr descendant
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeIsAncestorMethodInfo
instance (signature ~ (Node -> m Bool), MonadIO m) => O.MethodInfo NodeIsAncestorMethodInfo Node signature where
overloadedMethod _ = nodeIsAncestor
#endif
foreign import ccall "g_node_max_height" g_node_max_height ::
Ptr Node ->
IO Word32
nodeMaxHeight ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> m Word32
nodeMaxHeight root = liftIO $ do
root' <- unsafeManagedPtrGetPtr root
result <- g_node_max_height root'
touchManagedPtr root
return result
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeMaxHeightMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NodeMaxHeightMethodInfo Node signature where
overloadedMethod _ = nodeMaxHeight
#endif
foreign import ccall "g_node_n_children" g_node_n_children ::
Ptr Node ->
IO Word32
nodeNChildren ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> m Word32
nodeNChildren node = liftIO $ do
node' <- unsafeManagedPtrGetPtr node
result <- g_node_n_children node'
touchManagedPtr node
return result
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeNChildrenMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo NodeNChildrenMethodInfo Node signature where
overloadedMethod _ = nodeNChildren
#endif
foreign import ccall "g_node_n_nodes" g_node_n_nodes ::
Ptr Node ->
CUInt ->
IO Word32
nodeNNodes ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> [GLib.Flags.TraverseFlags]
-> m Word32
nodeNNodes root flags = liftIO $ do
root' <- unsafeManagedPtrGetPtr root
let flags' = gflagsToWord flags
result <- g_node_n_nodes root' flags'
touchManagedPtr root
return result
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeNNodesMethodInfo
instance (signature ~ ([GLib.Flags.TraverseFlags] -> m Word32), MonadIO m) => O.MethodInfo NodeNNodesMethodInfo Node signature where
overloadedMethod _ = nodeNNodes
#endif
foreign import ccall "g_node_reverse_children" g_node_reverse_children ::
Ptr Node ->
IO ()
nodeReverseChildren ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> m ()
nodeReverseChildren node = liftIO $ do
node' <- unsafeManagedPtrGetPtr node
g_node_reverse_children node'
touchManagedPtr node
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeReverseChildrenMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NodeReverseChildrenMethodInfo Node signature where
overloadedMethod _ = nodeReverseChildren
#endif
foreign import ccall "g_node_unlink" g_node_unlink ::
Ptr Node ->
IO ()
nodeUnlink ::
(B.CallStack.HasCallStack, MonadIO m) =>
Node
-> m ()
nodeUnlink node = liftIO $ do
node' <- unsafeManagedPtrGetPtr node
g_node_unlink node'
touchManagedPtr node
return ()
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data NodeUnlinkMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo NodeUnlinkMethodInfo Node signature where
overloadedMethod _ = nodeUnlink
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveNodeMethod (t :: Symbol) (o :: *) :: * where
ResolveNodeMethod "childIndex" o = NodeChildIndexMethodInfo
ResolveNodeMethod "childPosition" o = NodeChildPositionMethodInfo
ResolveNodeMethod "depth" o = NodeDepthMethodInfo
ResolveNodeMethod "destroy" o = NodeDestroyMethodInfo
ResolveNodeMethod "isAncestor" o = NodeIsAncestorMethodInfo
ResolveNodeMethod "maxHeight" o = NodeMaxHeightMethodInfo
ResolveNodeMethod "nChildren" o = NodeNChildrenMethodInfo
ResolveNodeMethod "nNodes" o = NodeNNodesMethodInfo
ResolveNodeMethod "reverseChildren" o = NodeReverseChildrenMethodInfo
ResolveNodeMethod "unlink" o = NodeUnlinkMethodInfo
ResolveNodeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveNodeMethod t Node, O.MethodInfo info Node p) => O.IsLabelProxy t (Node -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveNodeMethod t Node, O.MethodInfo info Node p) => O.IsLabel t (Node -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#endif