source: appstream-generator/build/girepo/glib/Node.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 11.7 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module glib.Node;
22
23private import gi.glib;
24public  import gi.glibtypes;
25private import glib.ConstructionException;
26
27
28/**
29 * The #GNode struct represents one node in a [n-ary tree][glib-N-ary-Trees].
30 */
31public class Node
32{
33        /** the main Gtk struct */
34        protected GNode* gNode;
35        protected bool ownedRef;
36
37        /** Get the main Gtk struct */
38        public GNode* getNodeStruct()
39        {
40                return gNode;
41        }
42
43        /** the main Gtk struct as a void* */
44        protected void* getStruct()
45        {
46                return cast(void*)gNode;
47        }
48
49        /**
50         * Sets our main struct and passes it to the parent class.
51         */
52        public this (GNode* gNode, bool ownedRef = false)
53        {
54                this.gNode = gNode;
55                this.ownedRef = ownedRef;
56        }
57
58
59        /**
60         * Gets the position of the first child of a #GNode
61         * which contains the given data.
62         *
63         * Params:
64         *     data = the data to find
65         *
66         * Returns: the index of the child of @node which contains
67         *     @data, or -1 if the data is not found
68         */
69        public int childIndex(void* data)
70        {
71                return g_node_child_index(gNode, data);
72        }
73
74        /**
75         * Gets the position of a #GNode with respect to its siblings.
76         * @child must be a child of @node. The first child is numbered 0,
77         * the second 1, and so on.
78         *
79         * Params:
80         *     child = a child of @node
81         *
82         * Returns: the position of @child with respect to its siblings
83         */
84        public int childPosition(Node child)
85        {
86                return g_node_child_position(gNode, (child is null) ? null : child.getNodeStruct());
87        }
88
89        /**
90         * Calls a function for each of the children of a #GNode.
91         * Note that it doesn't descend beneath the child nodes.
92         *
93         * Params:
94         *     flags = which types of children are to be visited, one of
95         *         %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
96         *     func = the function to call for each visited node
97         *     data = user data to pass to the function
98         */
99        public void childrenForeach(GTraverseFlags flags, GNodeForeachFunc func, void* data)
100        {
101                g_node_children_foreach(gNode, flags, func, data);
102        }
103
104        /**
105         * Recursively copies a #GNode (but does not deep-copy the data inside the
106         * nodes, see g_node_copy_deep() if you need that).
107         *
108         * Returns: a new #GNode containing the same data pointers
109         */
110        public Node copy()
111        {
112                auto p = g_node_copy(gNode);
113               
114                if(p is null)
115                {
116                        return null;
117                }
118               
119                return new Node(cast(GNode*) p);
120        }
121
122        /**
123         * Recursively copies a #GNode and its data.
124         *
125         * Params:
126         *     copyFunc = the function which is called to copy the data inside each node,
127         *         or %NULL to use the original data.
128         *     data = data to pass to @copy_func
129         *
130         * Returns: a new #GNode containing copies of the data in @node.
131         *
132         * Since: 2.4
133         */
134        public Node copyDeep(GCopyFunc copyFunc, void* data)
135        {
136                auto p = g_node_copy_deep(gNode, copyFunc, data);
137               
138                if(p is null)
139                {
140                        return null;
141                }
142               
143                return new Node(cast(GNode*) p);
144        }
145
146        /**
147         * Gets the depth of a #GNode.
148         *
149         * If @node is %NULL the depth is 0. The root node has a depth of 1.
150         * For the children of the root node the depth is 2. And so on.
151         *
152         * Returns: the depth of the #GNode
153         */
154        public uint depth()
155        {
156                return g_node_depth(gNode);
157        }
158
159        /**
160         * Removes @root and its children from the tree, freeing any memory
161         * allocated.
162         */
163        public void destroy()
164        {
165                g_node_destroy(gNode);
166        }
167
168        /**
169         * Finds a #GNode in a tree.
170         *
171         * Params:
172         *     order = the order in which nodes are visited - %G_IN_ORDER,
173         *         %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER
174         *     flags = which types of children are to be searched, one of
175         *         %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
176         *     data = the data to find
177         *
178         * Returns: the found #GNode, or %NULL if the data is not found
179         */
180        public Node find(GTraverseType order, GTraverseFlags flags, void* data)
181        {
182                auto p = g_node_find(gNode, order, flags, data);
183               
184                if(p is null)
185                {
186                        return null;
187                }
188               
189                return new Node(cast(GNode*) p);
190        }
191
192        /**
193         * Finds the first child of a #GNode with the given data.
194         *
195         * Params:
196         *     flags = which types of children are to be searched, one of
197         *         %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
198         *     data = the data to find
199         *
200         * Returns: the found child #GNode, or %NULL if the data is not found
201         */
202        public Node findChild(GTraverseFlags flags, void* data)
203        {
204                auto p = g_node_find_child(gNode, flags, data);
205               
206                if(p is null)
207                {
208                        return null;
209                }
210               
211                return new Node(cast(GNode*) p);
212        }
213
214        /**
215         * Gets the first sibling of a #GNode.
216         * This could possibly be the node itself.
217         *
218         * Returns: the first sibling of @node
219         */
220        public Node firstSibling()
221        {
222                auto p = g_node_first_sibling(gNode);
223               
224                if(p is null)
225                {
226                        return null;
227                }
228               
229                return new Node(cast(GNode*) p);
230        }
231
232        /**
233         * Gets the root of a tree.
234         *
235         * Returns: the root of the tree
236         */
237        public Node getRoot()
238        {
239                auto p = g_node_get_root(gNode);
240               
241                if(p is null)
242                {
243                        return null;
244                }
245               
246                return new Node(cast(GNode*) p);
247        }
248
249        /**
250         * Inserts a #GNode beneath the parent at the given position.
251         *
252         * Params:
253         *     position = the position to place @node at, with respect to its siblings
254         *         If position is -1, @node is inserted as the last child of @parent
255         *     node = the #GNode to insert
256         *
257         * Returns: the inserted #GNode
258         */
259        public Node insert(int position, Node node)
260        {
261                auto p = g_node_insert(gNode, position, (node is null) ? null : node.getNodeStruct());
262               
263                if(p is null)
264                {
265                        return null;
266                }
267               
268                return new Node(cast(GNode*) p);
269        }
270
271        /**
272         * Inserts a #GNode beneath the parent after the given sibling.
273         *
274         * Params:
275         *     sibling = the sibling #GNode to place @node after.
276         *         If sibling is %NULL, the node is inserted as the first child of @parent.
277         *     node = the #GNode to insert
278         *
279         * Returns: the inserted #GNode
280         */
281        public Node insertAfter(Node sibling, Node node)
282        {
283                auto p = g_node_insert_after(gNode, (sibling is null) ? null : sibling.getNodeStruct(), (node is null) ? null : node.getNodeStruct());
284               
285                if(p is null)
286                {
287                        return null;
288                }
289               
290                return new Node(cast(GNode*) p);
291        }
292
293        /**
294         * Inserts a #GNode beneath the parent before the given sibling.
295         *
296         * Params:
297         *     sibling = the sibling #GNode to place @node before.
298         *         If sibling is %NULL, the node is inserted as the last child of @parent.
299         *     node = the #GNode to insert
300         *
301         * Returns: the inserted #GNode
302         */
303        public Node insertBefore(Node sibling, Node node)
304        {
305                auto p = g_node_insert_before(gNode, (sibling is null) ? null : sibling.getNodeStruct(), (node is null) ? null : node.getNodeStruct());
306               
307                if(p is null)
308                {
309                        return null;
310                }
311               
312                return new Node(cast(GNode*) p);
313        }
314
315        /**
316         * Returns %TRUE if @node is an ancestor of @descendant.
317         * This is true if node is the parent of @descendant,
318         * or if node is the grandparent of @descendant etc.
319         *
320         * Params:
321         *     descendant = a #GNode
322         *
323         * Returns: %TRUE if @node is an ancestor of @descendant
324         */
325        public bool isAncestor(Node descendant)
326        {
327                return g_node_is_ancestor(gNode, (descendant is null) ? null : descendant.getNodeStruct()) != 0;
328        }
329
330        /**
331         * Gets the last child of a #GNode.
332         *
333         * Returns: the last child of @node, or %NULL if @node has no children
334         */
335        public Node lastChild()
336        {
337                auto p = g_node_last_child(gNode);
338               
339                if(p is null)
340                {
341                        return null;
342                }
343               
344                return new Node(cast(GNode*) p);
345        }
346
347        /**
348         * Gets the last sibling of a #GNode.
349         * This could possibly be the node itself.
350         *
351         * Returns: the last sibling of @node
352         */
353        public Node lastSibling()
354        {
355                auto p = g_node_last_sibling(gNode);
356               
357                if(p is null)
358                {
359                        return null;
360                }
361               
362                return new Node(cast(GNode*) p);
363        }
364
365        /**
366         * Gets the maximum height of all branches beneath a #GNode.
367         * This is the maximum distance from the #GNode to all leaf nodes.
368         *
369         * If @root is %NULL, 0 is returned. If @root has no children,
370         * 1 is returned. If @root has children, 2 is returned. And so on.
371         *
372         * Returns: the maximum height of the tree beneath @root
373         */
374        public uint maxHeight()
375        {
376                return g_node_max_height(gNode);
377        }
378
379        /**
380         * Gets the number of children of a #GNode.
381         *
382         * Returns: the number of children of @node
383         */
384        public uint nChildren()
385        {
386                return g_node_n_children(gNode);
387        }
388
389        /**
390         * Gets the number of nodes in a tree.
391         *
392         * Params:
393         *     flags = which types of children are to be counted, one of
394         *         %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
395         *
396         * Returns: the number of nodes in the tree
397         */
398        public uint nNodes(GTraverseFlags flags)
399        {
400                return g_node_n_nodes(gNode, flags);
401        }
402
403        /**
404         * Gets a child of a #GNode, using the given index.
405         * The first child is at index 0. If the index is
406         * too big, %NULL is returned.
407         *
408         * Params:
409         *     n = the index of the desired child
410         *
411         * Returns: the child of @node at index @n
412         */
413        public Node nthChild(uint n)
414        {
415                auto p = g_node_nth_child(gNode, n);
416               
417                if(p is null)
418                {
419                        return null;
420                }
421               
422                return new Node(cast(GNode*) p);
423        }
424
425        /**
426         * Inserts a #GNode as the first child of the given parent.
427         *
428         * Params:
429         *     node = the #GNode to insert
430         *
431         * Returns: the inserted #GNode
432         */
433        public Node prepend(Node node)
434        {
435                auto p = g_node_prepend(gNode, (node is null) ? null : node.getNodeStruct());
436               
437                if(p is null)
438                {
439                        return null;
440                }
441               
442                return new Node(cast(GNode*) p);
443        }
444
445        /**
446         * Reverses the order of the children of a #GNode.
447         * (It doesn't change the order of the grandchildren.)
448         */
449        public void reverseChildren()
450        {
451                g_node_reverse_children(gNode);
452        }
453
454        /**
455         * Traverses a tree starting at the given root #GNode.
456         * It calls the given function for each node visited.
457         * The traversal can be halted at any point by returning %TRUE from @func.
458         *
459         * Params:
460         *     order = the order in which nodes are visited - %G_IN_ORDER,
461         *         %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER.
462         *     flags = which types of children are to be visited, one of
463         *         %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
464         *     maxDepth = the maximum depth of the traversal. Nodes below this
465         *         depth will not be visited. If max_depth is -1 all nodes in
466         *         the tree are visited. If depth is 1, only the root is visited.
467         *         If depth is 2, the root and its children are visited. And so on.
468         *     func = the function to call for each visited #GNode
469         *     data = user data to pass to the function
470         */
471        public void traverse(GTraverseType order, GTraverseFlags flags, int maxDepth, GNodeTraverseFunc func, void* data)
472        {
473                g_node_traverse(gNode, order, flags, maxDepth, func, data);
474        }
475
476        /**
477         * Unlinks a #GNode from a tree, resulting in two separate trees.
478         */
479        public void unlink()
480        {
481                g_node_unlink(gNode);
482        }
483
484        /**
485         * Creates a new #GNode containing the given data.
486         * Used to create the first node in a tree.
487         *
488         * Params:
489         *     data = the data of the new node
490         *
491         * Returns: a new #GNode
492         *
493         * Throws: ConstructionException GTK+ fails to create the object.
494         */
495        public this(void* data)
496        {
497                auto p = g_node_new(data);
498               
499                if(p is null)
500                {
501                        throw new ConstructionException("null returned by new");
502                }
503               
504                this(cast(GNode*) p);
505        }
506}
Note: See TracBrowser for help on using the repository browser.