/* * Copyright (C) 2009 - 2011 Vivien Malerba * Copyright (C) 2010 David King * Copyright (C) 2011 Murray Cumming * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ #include #include "gda-tree-node.h" #include "gda-tree-manager.h" #include #include struct _GdaTreeNodePrivate { GSList *children; /* list of GdaTreeNodesList */ GdaTreeNode *parent; }; /* * The GdaTreeNodesList stores the list of children nodes created by a GdaTreeManager object */ typedef struct { GdaTreeManager *mgr; /* which created @nodes */ GSList *nodes; /* list of GdaTreeNode */ gint length; /* length of @nodes */ } GdaTreeNodesList; #define GDA_TREE_NODES_LIST(x) ((GdaTreeNodesList*)(x)) void _gda_nodes_list_free (GdaTreeNodesList *nl); /* * GObject functions */ static void gda_tree_node_class_init (GdaTreeNodeClass *klass); static void gda_tree_node_init (GdaTreeNode *tnode, GdaTreeNodeClass *klass); static void gda_tree_node_dispose (GObject *object); static void gda_tree_node_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec); static void gda_tree_node_get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec); /* default virtual methods */ static gchar *gda_tree_node_dump_header (GdaTreeNode *node); static void gda_tree_node_dump_children (GdaTreeNode *node, const gchar *prefix, GString *in_string); enum { NODE_CHANGED, NODE_INSERTED, NODE_HAS_CHILD_TOGGLED, NODE_DELETED, LAST_SIGNAL }; static gint gda_tree_node_signals[LAST_SIGNAL] = { 0, 0, 0, 0 }; /* properties */ enum { PROP_0, PROP_NAME }; static GObjectClass *parent_class = NULL; GdaAttributesManager *_gda_tree_node_attributes_manager; static void m_node_changed (GdaTreeNode *reporting, GdaTreeNode *node); static void m_node_inserted (GdaTreeNode *reporting, GdaTreeNode *node); static void m_node_has_child_toggled (GdaTreeNode *reporting, GdaTreeNode *node); static void m_node_deleted (GdaTreeNode *reporting, const gchar *relative_path); /* * GdaTreeNode class implementation * @klass: */ static void gda_tree_node_class_init (GdaTreeNodeClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); parent_class = g_type_class_peek_parent (klass); /* signals */ /** * GdaTreeNode::node-changed: * @reporting: the #GdaTreeNode which emits the signal (may be a parent of @node, or @node itself) * @node: the #GdaTreeNode which has changed * * Gets emitted when a @node has changed * * Since: 4.2 */ gda_tree_node_signals[NODE_CHANGED] = g_signal_new ("node_changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GdaTreeNodeClass, node_changed), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GDA_TYPE_TREE_NODE); /** * GdaTreeNode::node-inserted: * @reporting: the #GdaTreeNode which emits the signal (may be a parent of @node, or @node itself) * @node: the #GdaTreeNode which has been inserted * * Gets emitted when a @node has been inserted * * Since: 4.2 */ gda_tree_node_signals[NODE_INSERTED] = g_signal_new ("node_inserted", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GdaTreeNodeClass, node_inserted), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GDA_TYPE_TREE_NODE); /** * GdaTreeNode::node-has-child-toggled: * @reporting: the #GdaTreeNode which emits the signal (may be a parent of @node, or @node itself) * @node: the #GdaTreeNode which changed from having children to being a * leaf or the other way around * * Gets emitted when a @node has has a child when it did not have any or when it * does not have a ny children anymore when it had some * * Since: 4.2 */ gda_tree_node_signals[NODE_HAS_CHILD_TOGGLED] = g_signal_new ("node-has-child-toggled", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GdaTreeNodeClass, node_has_child_toggled), NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GDA_TYPE_TREE_NODE); /** * GdaTreeNode::node-deleted: * @reporting: the #GdaTreeNode which emits the signal (a parent of the removed node) * @relative_path: the path the node held, relative to @reporting * * Gets emitted when a @node has been removed * * Since: 4.2 */ gda_tree_node_signals[NODE_DELETED] = g_signal_new ("node_deleted", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GdaTreeNodeClass, node_deleted), NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING); klass->node_changed = m_node_changed; klass->node_inserted = m_node_inserted; klass->node_has_child_toggled = m_node_has_child_toggled; klass->node_deleted = m_node_deleted; /* virtual methods */ klass->dump_header = gda_tree_node_dump_header; klass->dump_children = gda_tree_node_dump_children; /* Properties */ object_class->set_property = gda_tree_node_set_property; object_class->get_property = gda_tree_node_get_property; g_object_class_install_property (object_class, PROP_NAME, g_param_spec_string ("name", NULL, "Node's name attribute", NULL, G_PARAM_WRITABLE | G_PARAM_READABLE)); object_class->dispose = gda_tree_node_dispose; /* extra */ _gda_tree_node_attributes_manager = gda_attributes_manager_new (TRUE, NULL, NULL); } static void m_node_changed (GdaTreeNode *reporting, GdaTreeNode *node) { if (reporting->priv->parent) g_signal_emit (reporting->priv->parent, gda_tree_node_signals[NODE_CHANGED], 0, node); } static void m_node_inserted (GdaTreeNode *reporting, GdaTreeNode *node) { if (reporting->priv->parent) g_signal_emit (reporting->priv->parent, gda_tree_node_signals[NODE_INSERTED], 0, node); } static void m_node_has_child_toggled (GdaTreeNode *reporting, GdaTreeNode *node) { if (reporting->priv->parent) g_signal_emit (reporting->priv->parent, gda_tree_node_signals[NODE_HAS_CHILD_TOGGLED], 0, node); } /* * Get child's position * * Returns: the requested position, or -1 if child not found */ static gint _get_child_pos (GdaTreeNode *node, GdaTreeNode *child) { gint pos = 0; g_return_val_if_fail (GDA_IS_TREE_NODE (node), -1); if (node->priv->children) { GSList *parts; for (parts = node->priv->children; parts; parts = parts->next) { GdaTreeNodesList *tn = GDA_TREE_NODES_LIST (parts->data); GSList *sl; for (sl = tn->nodes; sl; sl = sl->next) { if (sl->data == child) return pos; else pos++; } } } return -1; } static void m_node_deleted (GdaTreeNode *reporting, const gchar *relative_path) { if (reporting->priv->parent) { gint pos; gchar *path; pos = _get_child_pos (reporting->priv->parent, reporting); g_assert (pos >= 0); path = g_strdup_printf ("%d:%s", pos, relative_path); g_signal_emit (reporting->priv->parent, gda_tree_node_signals[NODE_DELETED], 0, path); g_free (path); } } static void gda_tree_node_init (GdaTreeNode *tnode, G_GNUC_UNUSED GdaTreeNodeClass *klass) { g_return_if_fail (GDA_IS_TREE_NODE (tnode)); tnode->priv = g_new0 (GdaTreeNodePrivate, 1); tnode->priv->children = NULL; } static void gda_tree_node_dispose (GObject *object) { GdaTreeNode *tnode = (GdaTreeNode *) object; g_return_if_fail (GDA_IS_TREE_NODE (tnode)); if (tnode->priv) { if (tnode->priv->children) { g_slist_foreach (tnode->priv->children, (GFunc) _gda_nodes_list_free, NULL); g_slist_free (tnode->priv->children); } g_free (tnode->priv); tnode->priv = NULL; } /* chain to parent class */ parent_class->dispose (object); } /* module error */ GQuark gda_tree_node_error_quark (void) { static GQuark quark; if (!quark) quark = g_quark_from_static_string ("gda_tree_node_error"); return quark; } /** * gda_tree_node_get_type: * * Registers the #GdaTreeNode class on the GLib type system. * * Returns: the GType identifying the class. */ GType gda_tree_node_get_type (void) { static GType type = 0; if (G_UNLIKELY (type == 0)) { static GMutex registering; static const GTypeInfo info = { sizeof (GdaTreeNodeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gda_tree_node_class_init, NULL, NULL, sizeof (GdaTreeNode), 0, (GInstanceInitFunc) gda_tree_node_init, 0 }; g_mutex_lock (®istering); if (type == 0) type = g_type_register_static (G_TYPE_OBJECT, "GdaTreeNode", &info, 0); g_mutex_unlock (®istering); } return type; } static void gda_tree_node_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec) { GdaTreeNode *tnode; tnode = GDA_TREE_NODE (object); if (tnode->priv) { switch (param_id) { case PROP_NAME: gda_attributes_manager_set (_gda_tree_node_attributes_manager, tnode, GDA_ATTRIBUTE_NAME, value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; } } } static void gda_tree_node_get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec) { GdaTreeNode *tnode; tnode = GDA_TREE_NODE (object); if (tnode->priv) { switch (param_id) { case PROP_NAME: { const GValue *cvalue = gda_attributes_manager_get (_gda_tree_node_attributes_manager, tnode, GDA_ATTRIBUTE_NAME); g_value_set_string (value, cvalue ? g_value_get_string (cvalue): NULL); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; } } } static void attributes_foreach_func (const gchar *att_name, const GValue *value, GString *string) { gchar *str = gda_value_stringify (value); g_string_append_printf (string, " %s=%s", att_name, str); g_free (str); } static gchar * gda_tree_node_dump_header (GdaTreeNode *node) { const GValue *cvalue; cvalue = gda_attributes_manager_get (_gda_tree_node_attributes_manager, node, GDA_ATTRIBUTE_NAME); if (g_getenv ("GDA_TREE_DUMP_ALL_ATTRIBUTES")) { GString *string; string = g_string_new (""); if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING)) g_string_append (string, g_value_get_string (cvalue)); else g_string_append (string, "Unnamed node"); g_string_append_c (string, ':'); gda_attributes_manager_foreach (_gda_tree_node_attributes_manager, node, (GdaAttributesManagerFunc) attributes_foreach_func, string); return g_string_free (string, FALSE); } else { if (cvalue) return g_strdup (g_value_get_string (cvalue)); else return g_strdup_printf ("Unnamed node"); } } static void gda_tree_node_dump_children (GdaTreeNode *node, const gchar *prefix, GString *in_string) { gchar *prefix2 = "|-- "; GdaTreeNodeClass *klass; GSList *parts; for (parts = node->priv->children; parts; parts = parts->next) { GSList *list; GdaTreeNodesList *tn = GDA_TREE_NODES_LIST (parts->data); for (list = tn->nodes; list; list = list->next) { GdaTreeNode *child_node = GDA_TREE_NODE (list->data); klass = (GdaTreeNodeClass*) G_OBJECT_GET_CLASS (child_node); /* header */ if ((!list->next) && (!parts->next)) prefix2 = "`-- "; if (klass->dump_header) { gchar *tmp = klass->dump_header (child_node); g_string_append_printf (in_string, "%s%s%s\n", prefix, prefix2, tmp); g_free (tmp); } else g_string_append_printf (in_string, "%s%sGdaTreeNode (%s) %p\n", prefix, prefix2, G_OBJECT_TYPE_NAME(child_node), child_node); /* contents */ gchar *ch_prefix; if (list->next || parts->next) ch_prefix = g_strdup_printf ("%s| ", prefix); else ch_prefix = g_strdup_printf ("%s ", prefix); if (klass->dump_children) klass->dump_children (child_node, ch_prefix, in_string); else gda_tree_node_dump_children (child_node, ch_prefix, in_string); g_free (ch_prefix); } } } /** * gda_tree_node_new: * @name: (allow-none): a name, or %NULL * * Creates a new #GdaTreeNode object * * Returns: (transfer full): a new #GdaTreeNode * * Since: 4.2 */ GdaTreeNode * gda_tree_node_new (const gchar *name) { return (GdaTreeNode*) g_object_new (GDA_TYPE_TREE_NODE, "name", name, NULL); } /* * _gda_tree_node_add_children: * @node: a #GdaTreeNode * @mgr: a #GdaTreeManager object * @childen: (allow-none): a list of #GdaTreeNode objects, or %NULL * * Requests that @node take the list of nodes in @children as its children. The children list * may be a new list of children, or may be an update of a list of children which previously existed. * * @node steals the ownership of each #GdaTreeNode object listed in @children. */ void _gda_tree_node_add_children (GdaTreeNode *node, GdaTreeManager *mgr, const GSList *children) { GSList *list; const GSList *clist; GdaTreeNodesList *etn; gint pos, nb_before_etn = 0; gint n_children = 0; g_return_if_fail (GDA_IS_TREE_NODE (node)); g_return_if_fail (GDA_IS_TREE_MANAGER (mgr)); /* find existing GdaTreeNodesList */ for (etn = NULL, pos = 0, list = node->priv->children; list; list = list->next, pos++) { if (GDA_TREE_NODES_LIST (list->data)->mgr == mgr) { etn = GDA_TREE_NODES_LIST (list->data); nb_before_etn = n_children; n_children += GDA_TREE_NODES_LIST (list->data)->length; } else n_children += GDA_TREE_NODES_LIST (list->data)->length; } /* prepare new GdaTreeNodesList */ for (clist = children; clist; clist = clist->next) { GdaTreeNode *child = GDA_TREE_NODE (clist->data); child->priv->parent = node; } if (!etn) { /* create new GdaTreeNodesList */ etn = g_new0 (GdaTreeNodesList, 1); etn->mgr = g_object_ref (mgr); node->priv->children = g_slist_append (node->priv->children, etn); /* fill it */ for (clist = children; clist; clist = clist->next) { etn->nodes = g_slist_append (etn->nodes, clist->data); etn->length ++; n_children ++; g_signal_emit (node, gda_tree_node_signals [NODE_INSERTED], 0, clist->data); if (n_children == 1) g_signal_emit (node, gda_tree_node_signals [NODE_HAS_CHILD_TOGGLED], 0, node); } } else { GSList *enodes; for (clist = children, enodes = etn->nodes, pos = nb_before_etn; clist; clist = clist->next, pos ++) { if (enodes) { if (clist->data == enodes->data) { /* signal a change */ g_signal_emit (node, gda_tree_node_signals [NODE_CHANGED], 0, (gpointer) clist->data); g_object_unref (G_OBJECT (clist->data)); /* loose 1 reference */ enodes = enodes->next; } else { gchar *rpath = g_strdup_printf ("%d", pos); for (; enodes; ) { if (clist->data != enodes->data) { /* signal deletion */ GSList *next = enodes->next; g_object_unref (G_OBJECT (enodes->data)); etn->nodes = g_slist_delete_link (etn->nodes, enodes); etn->length --; n_children --; enodes = next; g_signal_emit (node, gda_tree_node_signals [NODE_DELETED], 0, rpath); if (n_children == 0) g_signal_emit (node, gda_tree_node_signals [NODE_HAS_CHILD_TOGGLED], 0, node); } else break; } g_free (rpath); if (enodes) { /* signal a change */ g_signal_emit (node, gda_tree_node_signals [NODE_CHANGED], 0, (gpointer) clist->data); g_object_unref (G_OBJECT (clist->data)); /* loose 1 reference */ enodes = enodes->next; } else { /* signal an insertion */ etn->nodes = g_slist_append (etn->nodes, clist->data); etn->length ++; n_children ++; g_signal_emit (node, gda_tree_node_signals [NODE_INSERTED], 0, (gpointer) clist->data); if (n_children == 1) g_signal_emit (node, gda_tree_node_signals [NODE_HAS_CHILD_TOGGLED], 0, node); } } } else { /* signal an insertion */ etn->nodes = g_slist_append (etn->nodes, clist->data); etn->length ++; n_children ++; g_signal_emit (node, gda_tree_node_signals [NODE_INSERTED], 0, (gpointer) clist->data); if (n_children == 1) g_signal_emit (node, gda_tree_node_signals [NODE_HAS_CHILD_TOGGLED], 0, node); } } if (enodes) { gchar *rpath; rpath = g_strdup_printf ("%d", pos); for (; enodes; ) { /* signal deletion */ GSList *next = enodes->next; g_object_unref (G_OBJECT (enodes->data)); etn->nodes = g_slist_delete_link (etn->nodes, enodes); etn->length --; n_children --; enodes = next; g_signal_emit (node, gda_tree_node_signals [NODE_DELETED], 0, rpath); if (n_children == 0) g_signal_emit (node, gda_tree_node_signals [NODE_HAS_CHILD_TOGGLED], 0, node); } g_free (rpath); } } } /* * _gda_tree_node_get_children_for_manager: * @node: a #GdaTreeNode * @manager: a #GdaTreeManager * * Get the list of #GdaTreeNode objects which have already bee created by @mgr. * * Returns: a list (which must not be modified), or %NULL */ const GSList * _gda_tree_node_get_children_for_manager (GdaTreeNode *node, GdaTreeManager *mgr) { GSList *list; g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); g_return_val_if_fail (GDA_IS_TREE_MANAGER (mgr), NULL); for (list = node->priv->children; list; list = list->next) { if (GDA_TREE_NODES_LIST (list->data)->mgr == mgr) return GDA_TREE_NODES_LIST (list->data)->nodes; } return NULL; } /* * _gda_tree_node_get_managers_for_children: */ GSList * _gda_tree_node_get_managers_for_children (GdaTreeNode *node) { GSList *list, *mgrlist = NULL; g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); for (list = node->priv->children; list; list = list->next) mgrlist = g_slist_prepend (mgrlist, GDA_TREE_NODES_LIST (list->data)->mgr); return g_slist_reverse (mgrlist); } /* * _gda_tree_node_get_manager_for_child: */ GdaTreeManager * _gda_tree_node_get_manager_for_child (GdaTreeNode *node, GdaTreeNode *child) { GSList *list; g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); g_return_val_if_fail (GDA_IS_TREE_NODE (child), NULL); g_return_val_if_fail (child->priv->parent == node, NULL); for (list = node->priv->children; list; list = list->next) if (g_slist_find (GDA_TREE_NODES_LIST (list->data)->nodes, child)) return GDA_TREE_NODES_LIST (list->data)->mgr; return NULL; } /** * gda_tree_node_fetch_attribute: * @node: a #GdaTreeNode * @attribute: attribute name as a string * * Get the value associated to the attribute named @attribute for @node. If the attribute is not set, * then @node's parents is queries (recursively up to the top level node). * * Attributes can have any name, but Libgda proposes some default names, * see this section. * * Returns: (transfer none): a read-only #GValue, or %NULL if not attribute named @attribute has been set for @node * * Since: 4.2 */ const GValue * gda_tree_node_fetch_attribute (GdaTreeNode *node, const gchar *attribute) { const GValue *cvalue; g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); cvalue = gda_attributes_manager_get (_gda_tree_node_attributes_manager, node, attribute); if (!cvalue && node->priv->parent) cvalue = gda_tree_node_fetch_attribute (node->priv->parent, attribute); return cvalue; } /** * gda_tree_node_get_node_attribute: * @node: a #GdaTreeNode * @attribute: attribute name as a string * * Get the value associated to the attribute named @attribute for @node. The difference with gda_tree_node_fetch_attribute() * is that gda_tree_node_fetch_attribute() will also query @node's parents (recursively up to the top level node) if * the attribute is not set for @node. * * Attributes can have any name, but Libgda proposes some default names, * see this section. * * Returns: (transfer none): a read-only #GValue, or %NULL if not attribute named @attribute has been set for @node * * Since: 4.2 */ const GValue * gda_tree_node_get_node_attribute (GdaTreeNode *node, const gchar *attribute) { g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); return gda_attributes_manager_get (_gda_tree_node_attributes_manager, node, attribute); } /** * gda_tree_node_set_node_attribute: * @node: a #GdaTreeNode * @attribute: attribute name * @value: (transfer none) (allow-none): a #GValue, or %NULL * @destroy: a function to be called when @attribute is not needed anymore, or %NULL * * Set the value associated to a named attribute. The @attribute string is used AS IT IS by this method (eg. * no copy of it is made), and * the memory it uses will be freed using the @destroy function when no longer needed (if @destroy is %NULL, * then the string will not be freed at all). * * Attributes can have any name, but Libgda proposes some default names, * see this section. * * For example one would use it as: * * * gda_tree_node_set_node_attribute (node, g_strdup (my_attribute), my_value, g_free); * gda_tree_node_set_node_attribute (node, GDA_ATTRIBUTE_NAME, my_value, NULL); * * * If there is already an attribute named @attribute set, then its value is replaced with the new value (@value is * copied), except if @value is %NULL, in which case the attribute is removed. * * Since: 4.2 */ void gda_tree_node_set_node_attribute (GdaTreeNode *node, const gchar *attribute, const GValue *value, GDestroyNotify destroy) { const GValue *cvalue; g_return_if_fail (GDA_IS_TREE_NODE (node)); g_return_if_fail (attribute); cvalue = gda_attributes_manager_get (_gda_tree_node_attributes_manager, node, attribute); if ((value && cvalue && !gda_value_differ (cvalue, value)) || (!value && !cvalue)) return; if (!strcmp (attribute, GDA_ATTRIBUTE_TREE_NODE_UNKNOWN_CHILDREN) && (!value || (G_VALUE_TYPE (value) == G_TYPE_BOOLEAN))) { gboolean ouc = FALSE; gboolean nuc = FALSE; if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_BOOLEAN) && g_value_get_boolean (cvalue)) ouc = TRUE; if (value && g_value_get_boolean (value)) nuc = TRUE; if (ouc != nuc) { gda_attributes_manager_set_full (_gda_tree_node_attributes_manager, node, attribute, value, destroy); g_signal_emit (node, gda_tree_node_signals[NODE_HAS_CHILD_TOGGLED], 0, node); g_signal_emit (node, gda_tree_node_signals[NODE_CHANGED], 0, node); return; } } gda_attributes_manager_set_full (_gda_tree_node_attributes_manager, node, attribute, value, destroy); g_signal_emit (node, gda_tree_node_signals[NODE_CHANGED], 0, node); } /** * gda_tree_node_get_parent: * @node: a #GdaTreeNode object * * Get the #GdaTreeNode parent of @node in the #GdaTree node belongs to. If @node is at the top level, * then this method return %NULL. * * Returns: (transfer none): the parent #GdaTreeNode * * Since: 4.2 */ GdaTreeNode * gda_tree_node_get_parent (GdaTreeNode *node) { GdaTreeNode *parent; g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); parent = node->priv->parent; if (parent && !parent->priv->parent) return NULL; /* avoid returning the private GdaTree's ROOT node */ else return parent; } /** * gda_tree_node_get_children: * @node: a #GdaTreeNode object * * Get a list of all @node's children, free it with g_slist_free() after usage * * Returns: (transfer container) (element-type GdaTreeNode): a new #GSList of #GdaTreeNode objects, or %NULL if @node does not have any child * * Since: 4.2 */ GSList * gda_tree_node_get_children (GdaTreeNode *node) { g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); if (node->priv->children) { GSList *parts, *list = NULL; for (parts = node->priv->children; parts; parts = parts->next) { if (GDA_TREE_NODES_LIST (parts->data)->nodes) list = g_slist_concat (list, g_slist_copy (GDA_TREE_NODES_LIST (parts->data)->nodes)); } return list; } else return NULL; } /** * gda_tree_node_get_child_index: * @node: a #GdaTreeNode object * @index: a index * * Get the #GdaTreeNode child of @node at position @index (starting at 0). * * Returns: (transfer none): the #GdaTreeNode, or %NULL if not found * * Since: 4.2 */ GdaTreeNode * gda_tree_node_get_child_index (GdaTreeNode *node, gint index) { g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); g_return_val_if_fail (index >= 0, NULL); if (node->priv->children) { gint i = index; GSList *parts; for (parts = node->priv->children; parts; parts = parts->next) { GdaTreeNodesList *tn = GDA_TREE_NODES_LIST (parts->data); if (i < tn->length) return g_slist_nth_data (tn->nodes, i); i -= tn->length; } return NULL; } else return NULL; } /** * gda_tree_node_get_child_name: * @node: a #GdaTreeNode object * @name: requested node's name * * Get the #GdaTreeNode child of @node which has the #GDA_ATTRIBUTE_NAME set to @name * * Returns: (transfer none): the #GdaTreeNode, or %NULL if not found * * Since: 4.2 */ GdaTreeNode * gda_tree_node_get_child_name (GdaTreeNode *node, const gchar *name) { g_return_val_if_fail (GDA_IS_TREE_NODE (node), NULL); g_return_val_if_fail (name, NULL); if (node->priv->children) { GSList *parts; for (parts = node->priv->children; parts; parts = parts->next) { GdaTreeNodesList *tn = GDA_TREE_NODES_LIST (parts->data); GSList *list; for (list = tn->nodes; list; list = list->next) { const GValue *cvalue; cvalue = gda_attributes_manager_get (_gda_tree_node_attributes_manager, list->data, GDA_ATTRIBUTE_NAME); if (cvalue) { const gchar *cname = g_value_get_string (cvalue); if (cname && !strcmp (name, cname)) return (GdaTreeNode*) list->data; } } } } return NULL; } void _gda_nodes_list_free (GdaTreeNodesList *nl) { if (nl->nodes) { g_slist_foreach (nl->nodes, (GFunc) g_object_unref, NULL); g_slist_free (nl->nodes); } g_object_unref (nl->mgr); g_free (nl); }