{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.GLib.Structs.Node.Node' struct represents one node in a [n-ary tree][glib-N-ary-Trees].

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

module GI.GLib.Structs.Node
    ( 

-- * Exported types
    Node(..)                                ,
    newZeroNode                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [childIndex]("GI.GLib.Structs.Node#g:method:childIndex"), [childPosition]("GI.GLib.Structs.Node#g:method:childPosition"), [depth]("GI.GLib.Structs.Node#g:method:depth"), [destroy]("GI.GLib.Structs.Node#g:method:destroy"), [isAncestor]("GI.GLib.Structs.Node#g:method:isAncestor"), [maxHeight]("GI.GLib.Structs.Node#g:method:maxHeight"), [nChildren]("GI.GLib.Structs.Node#g:method:nChildren"), [nNodes]("GI.GLib.Structs.Node#g:method:nNodes"), [reverseChildren]("GI.GLib.Structs.Node#g:method:reverseChildren"), [unlink]("GI.GLib.Structs.Node#g:method:unlink").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveNodeMethod                       ,
#endif

-- ** childIndex #method:childIndex#

#if defined(ENABLE_OVERLOADING)
    NodeChildIndexMethodInfo                ,
#endif
    nodeChildIndex                          ,


-- ** childPosition #method:childPosition#

#if defined(ENABLE_OVERLOADING)
    NodeChildPositionMethodInfo             ,
#endif
    nodeChildPosition                       ,


-- ** depth #method:depth#

#if defined(ENABLE_OVERLOADING)
    NodeDepthMethodInfo                     ,
#endif
    nodeDepth                               ,


-- ** destroy #method:destroy#

#if defined(ENABLE_OVERLOADING)
    NodeDestroyMethodInfo                   ,
#endif
    nodeDestroy                             ,


-- ** isAncestor #method:isAncestor#

#if defined(ENABLE_OVERLOADING)
    NodeIsAncestorMethodInfo                ,
#endif
    nodeIsAncestor                          ,


-- ** maxHeight #method:maxHeight#

#if defined(ENABLE_OVERLOADING)
    NodeMaxHeightMethodInfo                 ,
#endif
    nodeMaxHeight                           ,


-- ** nChildren #method:nChildren#

#if defined(ENABLE_OVERLOADING)
    NodeNChildrenMethodInfo                 ,
#endif
    nodeNChildren                           ,


-- ** nNodes #method:nNodes#

#if defined(ENABLE_OVERLOADING)
    NodeNNodesMethodInfo                    ,
#endif
    nodeNNodes                              ,


-- ** reverseChildren #method:reverseChildren#

#if defined(ENABLE_OVERLOADING)
    NodeReverseChildrenMethodInfo           ,
#endif
    nodeReverseChildren                     ,


-- ** unlink #method:unlink#

#if defined(ENABLE_OVERLOADING)
    NodeUnlinkMethodInfo                    ,
#endif
    nodeUnlink                              ,




 -- * Properties


-- ** children #attr:children#
-- | points to the first child of the t'GI.GLib.Structs.Node.Node'.  The other
--            children are accessed by using the /@next@/ pointer of each
--            child.

    clearNodeChildren                       ,
    getNodeChildren                         ,
#if defined(ENABLE_OVERLOADING)
    node_children                           ,
#endif
    setNodeChildren                         ,


-- ** data #attr:data#
-- | contains the actual data of the node.

    clearNodeData                           ,
    getNodeData                             ,
#if defined(ENABLE_OVERLOADING)
    node_data                               ,
#endif
    setNodeData                             ,


-- ** next #attr:next#
-- | points to the node\'s next sibling (a sibling is another
--        t'GI.GLib.Structs.Node.Node' with the same parent).

    clearNodeNext                           ,
    getNodeNext                             ,
#if defined(ENABLE_OVERLOADING)
    node_next                               ,
#endif
    setNodeNext                             ,


-- ** parent #attr:parent#
-- | points to the parent of the t'GI.GLib.Structs.Node.Node', or is 'P.Nothing' if the
--          t'GI.GLib.Structs.Node.Node' is the root of the tree.

    clearNodeParent                         ,
    getNodeParent                           ,
#if defined(ENABLE_OVERLOADING)
    node_parent                             ,
#endif
    setNodeParent                           ,


-- ** prev #attr:prev#
-- | points to the node\'s previous sibling.

    clearNodePrev                           ,
    getNodePrev                             ,
#if defined(ENABLE_OVERLOADING)
    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.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 {-# SOURCE #-} qualified GI.GLib.Flags as GLib.Flags

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

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

instance BoxedPtr Node where
    boxedPtrCopy :: Node -> IO Node
boxedPtrCopy = \Node
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Node
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
20 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr Node -> Node
Node)
    boxedPtrFree :: Node -> IO ()
boxedPtrFree = \Node
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Node
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Node where
    boxedPtrCalloc :: IO (Ptr Node)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
20


-- | Construct a `Node` struct initialized to zero.
newZeroNode :: MonadIO m => m Node
newZeroNode :: forall (m :: * -> *). MonadIO m => m Node
newZeroNode = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Node -> Node
Node

instance tag ~ 'AttrSet => Constructible Node tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Node -> Node) -> [AttrOp Node tag] -> m Node
new ManagedPtr Node -> Node
_ [AttrOp Node tag]
attrs = do
        Node
o <- forall (m :: * -> *). MonadIO m => m Node
newZeroNode
        forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Node
o [AttrOp Node tag]
attrs
        forall (m :: * -> *) a. Monad m => a -> m a
return Node
o


-- | Get the value of the “@data@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' node #data
-- @
getNodeData :: MonadIO m => Node -> m (Ptr ())
getNodeData :: forall (m :: * -> *). MonadIO m => Node -> m (Ptr ())
getNodeData Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr ())
    forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val

-- | Set the value of the “@data@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' node [ #data 'Data.GI.Base.Attributes.:=' value ]
-- @
setNodeData :: MonadIO m => Node -> Ptr () -> m ()
setNodeData :: forall (m :: * -> *). MonadIO m => Node -> Ptr () -> m ()
setNodeData Node
s Ptr ()
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr ()
val :: Ptr ())

-- | Set the value of the “@data@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #data
-- @
clearNodeData :: MonadIO m => Node -> m ()
clearNodeData :: forall (m :: * -> *). MonadIO m => Node -> m ()
clearNodeData Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: Ptr ())

#if defined(ENABLE_OVERLOADING)
data NodeDataFieldInfo
instance AttrInfo NodeDataFieldInfo where
    type AttrBaseTypeConstraint NodeDataFieldInfo = (~) Node
    type AttrAllowedOps NodeDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeDataFieldInfo = (~) (Ptr ())
    type AttrTransferTypeConstraint NodeDataFieldInfo = (~)(Ptr ())
    type AttrTransferType NodeDataFieldInfo = (Ptr ())
    type AttrGetType NodeDataFieldInfo = Ptr ()
    type AttrLabel NodeDataFieldInfo = "data"
    type AttrOrigin NodeDataFieldInfo = Node
    attrGet = getNodeData
    attrSet = setNodeData
    attrConstruct = undefined
    attrClear = clearNodeData
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.data"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#g:attr:data"
        })

node_data :: AttrLabelProxy "data"
node_data = AttrLabelProxy

#endif


-- | Get the value of the “@next@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' node #next
-- @
getNodeNext :: MonadIO m => Node -> m (Maybe Node)
getNodeNext :: forall (m :: * -> *). MonadIO m => Node -> m (Maybe Node)
getNodeNext Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    Ptr Node
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (Ptr Node)
    Maybe Node
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Node
val forall a b. (a -> b) -> a -> b
$ \Ptr Node
val' -> do
        Node
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Node -> Node
Node) Ptr Node
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return Node
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
result

-- | Set the value of the “@next@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' node [ #next 'Data.GI.Base.Attributes.:=' value ]
-- @
setNodeNext :: MonadIO m => Node -> Ptr Node -> m ()
setNodeNext :: forall (m :: * -> *). MonadIO m => Node -> Ptr Node -> m ()
setNodeNext Node
s Ptr Node
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr Node
val :: Ptr Node)

-- | Set the value of the “@next@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #next
-- @
clearNodeNext :: MonadIO m => Node -> m ()
clearNodeNext :: forall (m :: * -> *). MonadIO m => Node -> m ()
clearNodeNext Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: Ptr Node)

#if defined(ENABLE_OVERLOADING)
data NodeNextFieldInfo
instance AttrInfo NodeNextFieldInfo where
    type AttrBaseTypeConstraint NodeNextFieldInfo = (~) Node
    type AttrAllowedOps NodeNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeNextFieldInfo = (~) (Ptr Node)
    type AttrTransferTypeConstraint NodeNextFieldInfo = (~)(Ptr Node)
    type AttrTransferType NodeNextFieldInfo = (Ptr Node)
    type AttrGetType NodeNextFieldInfo = Maybe Node
    type AttrLabel NodeNextFieldInfo = "next"
    type AttrOrigin NodeNextFieldInfo = Node
    attrGet = getNodeNext
    attrSet = setNodeNext
    attrConstruct = undefined
    attrClear = clearNodeNext
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.next"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#g:attr:next"
        })

node_next :: AttrLabelProxy "next"
node_next = AttrLabelProxy

#endif


-- | Get the value of the “@prev@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' node #prev
-- @
getNodePrev :: MonadIO m => Node -> m (Maybe Node)
getNodePrev :: forall (m :: * -> *). MonadIO m => Node -> m (Maybe Node)
getNodePrev Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    Ptr Node
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr Node)
    Maybe Node
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Node
val forall a b. (a -> b) -> a -> b
$ \Ptr Node
val' -> do
        Node
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Node -> Node
Node) Ptr Node
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return Node
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
result

-- | Set the value of the “@prev@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' node [ #prev 'Data.GI.Base.Attributes.:=' value ]
-- @
setNodePrev :: MonadIO m => Node -> Ptr Node -> m ()
setNodePrev :: forall (m :: * -> *). MonadIO m => Node -> Ptr Node -> m ()
setNodePrev Node
s Ptr Node
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr Node
val :: Ptr Node)

-- | Set the value of the “@prev@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #prev
-- @
clearNodePrev :: MonadIO m => Node -> m ()
clearNodePrev :: forall (m :: * -> *). MonadIO m => Node -> m ()
clearNodePrev Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: Ptr Node)

#if defined(ENABLE_OVERLOADING)
data NodePrevFieldInfo
instance AttrInfo NodePrevFieldInfo where
    type AttrBaseTypeConstraint NodePrevFieldInfo = (~) Node
    type AttrAllowedOps NodePrevFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodePrevFieldInfo = (~) (Ptr Node)
    type AttrTransferTypeConstraint NodePrevFieldInfo = (~)(Ptr Node)
    type AttrTransferType NodePrevFieldInfo = (Ptr Node)
    type AttrGetType NodePrevFieldInfo = Maybe Node
    type AttrLabel NodePrevFieldInfo = "prev"
    type AttrOrigin NodePrevFieldInfo = Node
    attrGet = getNodePrev
    attrSet = setNodePrev
    attrConstruct = undefined
    attrClear = clearNodePrev
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.prev"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#g:attr:prev"
        })

node_prev :: AttrLabelProxy "prev"
node_prev = AttrLabelProxy

#endif


-- | Get the value of the “@parent@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' node #parent
-- @
getNodeParent :: MonadIO m => Node -> m (Maybe Node)
getNodeParent :: forall (m :: * -> *). MonadIO m => Node -> m (Maybe Node)
getNodeParent Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    Ptr Node
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (Ptr Node)
    Maybe Node
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Node
val forall a b. (a -> b) -> a -> b
$ \Ptr Node
val' -> do
        Node
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Node -> Node
Node) Ptr Node
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return Node
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
result

-- | Set the value of the “@parent@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' node [ #parent 'Data.GI.Base.Attributes.:=' value ]
-- @
setNodeParent :: MonadIO m => Node -> Ptr Node -> m ()
setNodeParent :: forall (m :: * -> *). MonadIO m => Node -> Ptr Node -> m ()
setNodeParent Node
s Ptr Node
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Ptr Node
val :: Ptr Node)

-- | Set the value of the “@parent@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #parent
-- @
clearNodeParent :: MonadIO m => Node -> m ()
clearNodeParent :: forall (m :: * -> *). MonadIO m => Node -> m ()
clearNodeParent Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. Ptr a
FP.nullPtr :: Ptr Node)

#if defined(ENABLE_OVERLOADING)
data NodeParentFieldInfo
instance AttrInfo NodeParentFieldInfo where
    type AttrBaseTypeConstraint NodeParentFieldInfo = (~) Node
    type AttrAllowedOps NodeParentFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeParentFieldInfo = (~) (Ptr Node)
    type AttrTransferTypeConstraint NodeParentFieldInfo = (~)(Ptr Node)
    type AttrTransferType NodeParentFieldInfo = (Ptr Node)
    type AttrGetType NodeParentFieldInfo = Maybe Node
    type AttrLabel NodeParentFieldInfo = "parent"
    type AttrOrigin NodeParentFieldInfo = Node
    attrGet = getNodeParent
    attrSet = setNodeParent
    attrConstruct = undefined
    attrClear = clearNodeParent
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.parent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#g:attr:parent"
        })

node_parent :: AttrLabelProxy "parent"
node_parent = AttrLabelProxy

#endif


-- | Get the value of the “@children@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' node #children
-- @
getNodeChildren :: MonadIO m => Node -> m (Maybe Node)
getNodeChildren :: forall (m :: * -> *). MonadIO m => Node -> m (Maybe Node)
getNodeChildren Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    Ptr Node
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Node)
    Maybe Node
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Node
val forall a b. (a -> b) -> a -> b
$ \Ptr Node
val' -> do
        Node
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Node -> Node
Node) Ptr Node
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return Node
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
result

-- | Set the value of the “@children@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' node [ #children 'Data.GI.Base.Attributes.:=' value ]
-- @
setNodeChildren :: MonadIO m => Node -> Ptr Node -> m ()
setNodeChildren :: forall (m :: * -> *). MonadIO m => Node -> Ptr Node -> m ()
setNodeChildren Node
s Ptr Node
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Node
val :: Ptr Node)

-- | Set the value of the “@children@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #children
-- @
clearNodeChildren :: MonadIO m => Node -> m ()
clearNodeChildren :: forall (m :: * -> *). MonadIO m => Node -> m ()
clearNodeChildren Node
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Node
s forall a b. (a -> b) -> a -> b
$ \Ptr Node
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Node
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: Ptr Node)

#if defined(ENABLE_OVERLOADING)
data NodeChildrenFieldInfo
instance AttrInfo NodeChildrenFieldInfo where
    type AttrBaseTypeConstraint NodeChildrenFieldInfo = (~) Node
    type AttrAllowedOps NodeChildrenFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint NodeChildrenFieldInfo = (~) (Ptr Node)
    type AttrTransferTypeConstraint NodeChildrenFieldInfo = (~)(Ptr Node)
    type AttrTransferType NodeChildrenFieldInfo = (Ptr Node)
    type AttrGetType NodeChildrenFieldInfo = Maybe Node
    type AttrLabel NodeChildrenFieldInfo = "children"
    type AttrOrigin NodeChildrenFieldInfo = Node
    attrGet = getNodeChildren
    attrSet = setNodeChildren
    attrConstruct = undefined
    attrClear = clearNodeChildren
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.children"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#g:attr:children"
        })

node_children :: AttrLabelProxy "children"
node_children = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Node
type instance O.AttributeList Node = NodeAttributeList
type NodeAttributeList = ('[ '("data", NodeDataFieldInfo), '("next", NodeNextFieldInfo), '("prev", NodePrevFieldInfo), '("parent", NodeParentFieldInfo), '("children", NodeChildrenFieldInfo)] :: [(Symbol, *)])
#endif

-- method Node::child_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to find" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_child_index" g_node_child_index :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO Int32

-- | Gets the position of the first child of a t'GI.GLib.Structs.Node.Node'
-- which contains the given data.
nodeChildIndex ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@node@/: a t'GI.GLib.Structs.Node.Node'
    -> Ptr ()
    -- ^ /@data@/: the data to find
    -> m Int32
    -- ^ __Returns:__ the index of the child of /@node@/ which contains
    --     /@data@/, or -1 if the data is not found
nodeChildIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Node -> Ptr () -> m Int32
nodeChildIndex Node
node Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
node' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
    Int32
result <- Ptr Node -> Ptr () -> IO Int32
g_node_child_index Ptr Node
node' Ptr ()
data_
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data NodeChildIndexMethodInfo
instance (signature ~ (Ptr () -> m Int32), MonadIO m) => O.OverloadedMethod NodeChildIndexMethodInfo Node signature where
    overloadedMethod = nodeChildIndex

instance O.OverloadedMethodInfo NodeChildIndexMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeChildIndex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeChildIndex"
        })


#endif

-- method Node::child_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @node" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_child_position" g_node_child_position :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    Ptr Node ->                             -- child : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Int32

-- | Gets the position of a t'GI.GLib.Structs.Node.Node' with respect to its siblings.
-- /@child@/ must be a child of /@node@/. The first child is numbered 0,
-- the second 1, and so on.
nodeChildPosition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@node@/: a t'GI.GLib.Structs.Node.Node'
    -> Node
    -- ^ /@child@/: a child of /@node@/
    -> m Int32
    -- ^ __Returns:__ the position of /@child@/ with respect to its siblings
nodeChildPosition :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Node -> Node -> m Int32
nodeChildPosition Node
node Node
child = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
node' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
    Ptr Node
child' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
child
    Int32
result <- Ptr Node -> Ptr Node -> IO Int32
g_node_child_position Ptr Node
node' Ptr Node
child'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
child
    forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data NodeChildPositionMethodInfo
instance (signature ~ (Node -> m Int32), MonadIO m) => O.OverloadedMethod NodeChildPositionMethodInfo Node signature where
    overloadedMethod = nodeChildPosition

instance O.OverloadedMethodInfo NodeChildPositionMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeChildPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeChildPosition"
        })


#endif

-- method Node::depth
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_depth" g_node_depth :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Word32

-- | Gets the depth of a t'GI.GLib.Structs.Node.Node'.
-- 
-- If /@node@/ is 'P.Nothing' the depth is 0. The root node has a depth of 1.
-- For the children of the root node the depth is 2. And so on.
nodeDepth ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@node@/: a t'GI.GLib.Structs.Node.Node'
    -> m Word32
    -- ^ __Returns:__ the depth of the t'GI.GLib.Structs.Node.Node'
nodeDepth :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Node -> m Word32
nodeDepth Node
node = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
node' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
    Word32
result <- Ptr Node -> IO Word32
g_node_depth Ptr Node
node'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data NodeDepthMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod NodeDepthMethodInfo Node signature where
    overloadedMethod = nodeDepth

instance O.OverloadedMethodInfo NodeDepthMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeDepth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeDepth"
        })


#endif

-- method Node::destroy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "root"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the root of the tree/subtree to destroy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_node_destroy" g_node_destroy :: 
    Ptr Node ->                             -- root : TInterface (Name {namespace = "GLib", name = "Node"})
    IO ()

-- | Removes /@root@/ and its children from the tree, freeing any memory
-- allocated.
nodeDestroy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@root@/: the root of the tree\/subtree to destroy
    -> m ()
nodeDestroy :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Node -> m ()
nodeDestroy Node
root = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
root' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
root
    Ptr Node -> IO ()
g_node_destroy Ptr Node
root'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
root
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data NodeDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod NodeDestroyMethodInfo Node signature where
    overloadedMethod = nodeDestroy

instance O.OverloadedMethodInfo NodeDestroyMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeDestroy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeDestroy"
        })


#endif

-- method Node::is_ancestor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "descendant"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_is_ancestor" g_node_is_ancestor :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    Ptr Node ->                             -- descendant : TInterface (Name {namespace = "GLib", name = "Node"})
    IO CInt

-- | Returns 'P.True' if /@node@/ is an ancestor of /@descendant@/.
-- This is true if node is the parent of /@descendant@/,
-- or if node is the grandparent of /@descendant@/ etc.
nodeIsAncestor ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@node@/: a t'GI.GLib.Structs.Node.Node'
    -> Node
    -- ^ /@descendant@/: a t'GI.GLib.Structs.Node.Node'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@node@/ is an ancestor of /@descendant@/
nodeIsAncestor :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Node -> Node -> m Bool
nodeIsAncestor Node
node Node
descendant = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
node' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
    Ptr Node
descendant' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
descendant
    CInt
result <- Ptr Node -> Ptr Node -> IO CInt
g_node_is_ancestor Ptr Node
node' Ptr Node
descendant'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
descendant
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data NodeIsAncestorMethodInfo
instance (signature ~ (Node -> m Bool), MonadIO m) => O.OverloadedMethod NodeIsAncestorMethodInfo Node signature where
    overloadedMethod = nodeIsAncestor

instance O.OverloadedMethodInfo NodeIsAncestorMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeIsAncestor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeIsAncestor"
        })


#endif

-- method Node::max_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "root"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_max_height" g_node_max_height :: 
    Ptr Node ->                             -- root : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Word32

-- | Gets the maximum height of all branches beneath a t'GI.GLib.Structs.Node.Node'.
-- This is the maximum distance from the t'GI.GLib.Structs.Node.Node' to all leaf nodes.
-- 
-- If /@root@/ is 'P.Nothing', 0 is returned. If /@root@/ has no children,
-- 1 is returned. If /@root@/ has children, 2 is returned. And so on.
nodeMaxHeight ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@root@/: a t'GI.GLib.Structs.Node.Node'
    -> m Word32
    -- ^ __Returns:__ the maximum height of the tree beneath /@root@/
nodeMaxHeight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Node -> m Word32
nodeMaxHeight Node
root = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
root' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
root
    Word32
result <- Ptr Node -> IO Word32
g_node_max_height Ptr Node
root'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
root
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data NodeMaxHeightMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod NodeMaxHeightMethodInfo Node signature where
    overloadedMethod = nodeMaxHeight

instance O.OverloadedMethodInfo NodeMaxHeightMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeMaxHeight",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeMaxHeight"
        })


#endif

-- method Node::n_children
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_n_children" g_node_n_children :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO Word32

-- | Gets the number of children of a t'GI.GLib.Structs.Node.Node'.
nodeNChildren ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@node@/: a t'GI.GLib.Structs.Node.Node'
    -> m Word32
    -- ^ __Returns:__ the number of children of /@node@/
nodeNChildren :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Node -> m Word32
nodeNChildren Node
node = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
node' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
    Word32
result <- Ptr Node -> IO Word32
g_node_n_children Ptr Node
node'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data NodeNChildrenMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod NodeNChildrenMethodInfo Node signature where
    overloadedMethod = nodeNChildren

instance O.OverloadedMethodInfo NodeNChildrenMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeNChildren",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeNChildren"
        })


#endif

-- method Node::n_nodes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "root"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "TraverseFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "which types of children are to be counted, one of\n    %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_node_n_nodes" g_node_n_nodes :: 
    Ptr Node ->                             -- root : TInterface (Name {namespace = "GLib", name = "Node"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "GLib", name = "TraverseFlags"})
    IO Word32

-- | Gets the number of nodes in a tree.
nodeNNodes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@root@/: a t'GI.GLib.Structs.Node.Node'
    -> [GLib.Flags.TraverseFlags]
    -- ^ /@flags@/: which types of children are to be counted, one of
    --     'GI.GLib.Flags.TraverseFlagsAll', 'GI.GLib.Flags.TraverseFlagsLeaves' and 'GI.GLib.Flags.TraverseFlagsNonLeaves'
    -> m Word32
    -- ^ __Returns:__ the number of nodes in the tree
nodeNNodes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Node -> [TraverseFlags] -> m Word32
nodeNNodes Node
root [TraverseFlags]
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
root' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
root
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TraverseFlags]
flags
    Word32
result <- Ptr Node -> CUInt -> IO Word32
g_node_n_nodes Ptr Node
root' CUInt
flags'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
root
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data NodeNNodesMethodInfo
instance (signature ~ ([GLib.Flags.TraverseFlags] -> m Word32), MonadIO m) => O.OverloadedMethod NodeNNodesMethodInfo Node signature where
    overloadedMethod = nodeNNodes

instance O.OverloadedMethodInfo NodeNNodesMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeNNodes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeNNodes"
        })


#endif

-- method Node::reverse_children
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GNode." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_node_reverse_children" g_node_reverse_children :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO ()

-- | Reverses the order of the children of a t'GI.GLib.Structs.Node.Node'.
-- (It doesn\'t change the order of the grandchildren.)
nodeReverseChildren ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@node@/: a t'GI.GLib.Structs.Node.Node'.
    -> m ()
nodeReverseChildren :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Node -> m ()
nodeReverseChildren Node
node = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
node' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
    Ptr Node -> IO ()
g_node_reverse_children Ptr Node
node'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data NodeReverseChildrenMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod NodeReverseChildrenMethodInfo Node signature where
    overloadedMethod = nodeReverseChildren

instance O.OverloadedMethodInfo NodeReverseChildrenMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeReverseChildren",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeReverseChildren"
        })


#endif

-- method Node::unlink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "GLib" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GNode to unlink, which becomes the root of a new tree"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_node_unlink" g_node_unlink :: 
    Ptr Node ->                             -- node : TInterface (Name {namespace = "GLib", name = "Node"})
    IO ()

-- | Unlinks a t'GI.GLib.Structs.Node.Node' from a tree, resulting in two separate trees.
nodeUnlink ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Node
    -- ^ /@node@/: the t'GI.GLib.Structs.Node.Node' to unlink, which becomes the root of a new tree
    -> m ()
nodeUnlink :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Node -> m ()
nodeUnlink Node
node = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Node
node' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Node
node
    Ptr Node -> IO ()
g_node_unlink Ptr Node
node'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data NodeUnlinkMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod NodeUnlinkMethodInfo Node signature where
    overloadedMethod = nodeUnlink

instance O.OverloadedMethodInfo NodeUnlinkMethodInfo Node where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GLib.Structs.Node.nodeUnlink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.27/docs/GI-GLib-Structs-Node.html#v:nodeUnlink"
        })


#endif

#if defined(ENABLE_OVERLOADING)
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.OverloadedMethod info Node p) => OL.IsLabel t (Node -> 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 ~ ResolveNodeMethod t Node, O.OverloadedMethod info Node p, R.HasField t Node p) => R.HasField t Node p where
    getField = O.overloadedMethod @info

#endif

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

#endif