static void test_getChildInDirectory_DirectoryIsEmpty() {
before();
GNode *tree = single_folder(TRUE, TRUE);
// THIS IS THE STRUCTURE:
//
// test-dir (7 children)
// ├─ .apa.png
// ├─ .depa.gif
// ├─ bepa.png
// ├─ cepa.jpg
// ├─ epa.png
// ├─┬dir_one (3 children)
// │ ├─ .three.png
// │ ├─ two.jpg
// │ └─┬.secrets (1 children)
// │ └─ img.jpg
// └─┬dir_two (7 children)
// ├─ apa.png
// ├─ bepa.png
// ├─ cepa.png
// ├─┬sub_dir_four (2 children)
// │ ├──subsub (0 children)
// │ └──subsub2 (0 children)
// ├─┬sub_dir_one (3 children)
// │ ├─ img0.png
// │ ├─ img1.png
// │ └─ img2.png
// ├──sub_dir_three (0 children)
// └─┬sub_dir_two (3 children)
// ├─ img0.png
// ├─ img1.png
// ├─ img2.png
// └─ img3.png
char *path0 = get_absolute_path(testdir_path, "/dir_two/sub_dir_four/subsub");
char *path1 = get_absolute_path(testdir_path, "/dir_two/sub_dir_four/subsub/apa.jpg");
GNode *child = get_root_node(tree);
child = g_node_last_child(child);
child = g_node_first_child(child);
child = g_node_next_sibling(child);
child = g_node_next_sibling(child);
child = g_node_next_sibling(child);
child = g_node_first_child(child);
assert_child_is_equal("Get child in directory ─ Last child is subsub", child, path0);
child = get_child_in_directory(child, path1);
assert_tree_is_null("Get child in directory ─ Directory is empty", child);
free(path0);
free(path1);
free_whole_tree(tree);
after();
}
static GNode*
find_stat_node(GNode *parent_stat_node, header_field_info *needle_hfinfo)
{
GNode *needle_stat_node, *up_parent_stat_node;
header_field_info *hfinfo;
ph_stats_node_t *stats;
/* Look down the tree */
needle_stat_node = g_node_first_child(parent_stat_node);
while (needle_stat_node) {
hfinfo = STAT_NODE_HFINFO(needle_stat_node);
if (hfinfo && hfinfo->id == needle_hfinfo->id) {
return needle_stat_node;
}
needle_stat_node = g_node_next_sibling(needle_stat_node);
}
/* Look up the tree */
up_parent_stat_node = parent_stat_node;
while (up_parent_stat_node && up_parent_stat_node->parent)
{
needle_stat_node = g_node_first_child(up_parent_stat_node->parent);
while (needle_stat_node) {
hfinfo = STAT_NODE_HFINFO(needle_stat_node);
if (hfinfo && hfinfo->id == needle_hfinfo->id) {
return needle_stat_node;
}
needle_stat_node = g_node_next_sibling(needle_stat_node);
}
up_parent_stat_node = up_parent_stat_node->parent;
}
/* None found. Create one. */
stats = g_new(ph_stats_node_t, 1);
/* Intialize counters */
stats->hfinfo = needle_hfinfo;
stats->num_pkts_total = 0;
stats->num_pkts_last = 0;
stats->num_bytes_total = 0;
stats->num_bytes_last = 0;
needle_stat_node = g_node_new(stats);
g_node_append(parent_stat_node, needle_stat_node);
return needle_stat_node;
}
static struct lua_cmd_entry *lua_cmd_find(gchar **argv, gint *offp)
{
gchar **argp;
GNode *node;
if (main_tree == NULL)
return NULL;
node = main_tree;
argp = argv;
for (;;) {
node = g_node_first_child(node);
if (G_NODE_IS_LEAF(node)) {
struct lua_cmd_entry *entry;
entry = (struct lua_cmd_entry *) node->data;
*offp = argp - argv - 1;
return entry;
}
if (*argp == NULL)
return NULL;
for (; node != NULL; node = g_node_next_sibling(node))
if (! strcmp(*argp, node->data))
break;
if (node == NULL)
return NULL;
argp++;
}
}
void gnode_to_gui(GNode * root,
GtkCTreeNode * a_node)
{
GNode *tmp;
GtkCTreeNode *new_node;
NE_DEBUG(DEBUG_GNOME, "Building GUI tree from GNode hierarchy... \n");
if (!root)
return;
tmp = g_node_first_child(root);
while (tmp) {
new_node = add_file(name(tmp),
file(tmp),
a_node);
gnode_to_gui(tmp, new_node);
tmp = g_node_next_sibling(tmp);
}
gnode_to_gui(tmp, a_node);
}
void mk_key_value_write_lines(const gchar* prefix,
const GNode* root,
GIOChannel* chan)
{
GNode* n = g_node_first_child(root);
for(; n != NULL; n = g_node_next_sibling(n)) {
MkNodeInfo* info = (MkNodeInfo*)(n->data);
gchar* prefix2;
if (prefix != NULL) {
prefix2 = g_strconcat(prefix, ".", info->name, NULL);
} else {
prefix2 = g_strdup(info->name);
}
if (info->name != NULL) {
if (prefix != NULL) {
g_io_channel_write_chars(chan, prefix, -1, NULL, NULL);
g_io_channel_write_chars(chan, ".", -1, NULL, NULL);
}
g_io_channel_write_chars(chan, info->name, -1, NULL, NULL);
g_io_channel_write_chars(chan, "=", -1, NULL, NULL);
if (info->value != NULL)
g_io_channel_write_chars(chan, info->value, -1, NULL, NULL);
g_io_channel_write_chars(chan, "\n", -1, NULL, NULL);
}
mk_key_value_write_lines(prefix2, n, chan);
g_free(prefix2);
}
}
/*
* Mark children as invisible, if needed.
*/
static void gopt_set_children_visible(struct gopt_job_view *gjv,
struct fio_option *parent,
gboolean visible)
{
GNode *child, *node;
if (parent->hide_on_set)
visible = !visible;
node = g_node_find(gopt_dep_tree, G_IN_ORDER, G_TRAVERSE_ALL, parent);
child = g_node_first_child(node);
while (child) {
struct fio_option *o = child->data;
struct gopt *g = o->gui_data;
GtkWidget *widget = g->box;
/*
* Recurse into child, if it also has children
*/
if (g_node_n_children(child))
gopt_set_children_visible(gjv, o, visible);
gtk_widget_set_sensitive(widget, visible);
child = g_node_next_sibling(child);
}
}
/**
* get_next_sibling_node(GNode * cur_node)
* @brief Gets next sibling node, or wraps around if NULL
* @param cur_node
* @return GNode of sibling next, or wrapped around
*/
GNode *get_next_sibling_node(GNode * cur_node)
{
GNode *tmp_node = NULL;
if ((tmp_node = g_node_next_sibling(cur_node)) == NULL) {
return g_node_first_sibling(cur_node);
}
return tmp_node;
}
GNode *search_node_by_name(GNode *directory, char *name)
{
GNode *file_ptr;
for (file_ptr = g_node_first_child(directory); file_ptr != NULL;
file_ptr = g_node_next_sibling(file_ptr)) {
if (!strcmp(FILE(file_ptr)->name, name))
return file_ptr;
}
return NULL;
}
static void
print_child_nodes (GNode *node,
gint depth)
{
GNode *child;
for (child = g_node_first_child (node); child != NULL; child = g_node_next_sibling (child))
{
g_node_traverse (child, G_PRE_ORDER, G_TRAVERSE_ALL, 1,
(GNodeTraverseFunc) print_node, GINT_TO_POINTER (depth+2));
}
}
static void ls_print_tree(GNode *node, gboolean deep)
{
__extension__
void node_walk(GNode *node, guint off, gboolean deep)
{
node = g_node_first_child(node);
for (; node != NULL; node = g_node_next_sibling(node)) {
if (G_NODE_IS_LEAF(node))
continue;
g_print("%*s%s\n", off, "", (gchar *) node->data);
if (deep) node_walk(node, off + 2, deep);
}
}
GNode *node_find_child(GNode* node, const gchar* data) {
GNode* child;
if (! node) {
return NULL;
}
child = g_node_first_child(node);
while (child) {
if (g_strcmp0(child->data, data) == 0) {
return child;
}
child = g_node_next_sibling(child);
}
return NULL;
}
static void
book_tree_populate_tree (DhBookTree *tree)
{
g_return_if_fail (tree != NULL);
g_return_if_fail (DH_IS_BOOK_TREE (tree));
DhBookTreePriv *priv = tree->priv;
int i = 0;
GNode *node = g_node_first_child (*priv->link_tree);
for (; node; node = g_node_next_sibling (node)) {
book_tree_insert_node (tree, node, NULL);
i++;
}
dbg(2, "n_nodes=%i", i);
}
void dirs_set_size(AGlActor* actor)
{
DirectoriesView* view = (DirectoriesView*)actor;
#define N_ROWS_VISIBLE(A) (agl_actor__height(((AGlActor*)A)) / row_height)
view->cache.n_rows_visible = N_ROWS_VISIBLE(actor);
if(!view->cache.n_rows){
GNode* node = g_node_first_child (samplecat.model->dir_tree);
for(; node; node = g_node_next_sibling(node)){
view->cache.n_rows++;
}
agl_actor__invalidate(actor);
}
actor->region.y2 = MIN(actor->region.y2, actor->region.y1 + (view->cache.n_rows + 1) * row_height);
}
static GNode* se_modemap_search_next_level(se_modemap *map, GNode *node, se_key key)
{
g_assert( map && node );
/* se_debug( "search for %s", se_key_to_string(key) ); */
GNode *np = g_node_first_child ( node );
while ( np ) {
se_modemap_data *data = np->data;
if ( se_key_is_equal(data->key, key) ) {
/* se_debug( "find %s at level %d", se_key_to_string(key), g_node_depth(np) ); */
return np;
}
np = g_node_next_sibling( np );
}
return NULL;
}
void dump_g_node(GNode * tree)
{
struct site_node_data *tmp;
GNode *tmp2 = tree;
GNode *tmp3;
while (tmp2) {
tmp = tmp2->data;
printf("%s has siblings:\n", tmp->name);
tmp3 = tmp2;
for (; g_node_next_sibling(tmp3); tmp3 = tmp3->next) {
printf(" %s ", ((struct site_node_data *) tmp3->data)->name);
}
printf("\n");
tmp2 = g_node_first_child(tmp2);
}
}
/**
* recursive_menu_dump(GNode * node, uint8_t level)
*/
static void recursive_menu_dump(GNode * node, uint8_t level)
{
uint8_t level_tmp = level;
if (node->children) {
GNode *tmp = g_node_first_child(node);
while (tmp != NULL) {
dump_menu_item((menu_item_t *) tmp->data, level_tmp++);
if (tmp->children) {
recursive_menu_dump(tmp, level_tmp++);
}
tmp = g_node_next_sibling(tmp);
}
} else {
dump_menu_item((menu_item_t *) node->data, level);
}
}
void remmina_file_manager_free_group_tree(GNode* node)
{
RemminaGroupData* data;
GNode* child;
if (!node)
return;
data = (RemminaGroupData*) node->data;
if (data)
{
g_free(data->name);
g_free(data->group);
g_free(data);
node->data = NULL;
}
for (child = g_node_first_child(node); child; child = g_node_next_sibling(child))
{
remmina_file_manager_free_group_tree(child);
}
g_node_unlink(node);
}
static void
book_tree_insert_node (DhBookTree *tree, GNode *node, GtkTreeIter *parent_iter)
{
DhBookTreePriv *priv;
GtkTreeIter iter;
DhLink *link;
GNode *child;
g_return_if_fail (DH_IS_BOOK_TREE (tree));
g_return_if_fail (node != NULL);
priv = tree->priv;
link = (DhLink *) node->data;
gtk_tree_store_append (priv->store, &iter, parent_iter);
if (link->type == DH_LINK_TYPE_BOOK) {
//printf("book_tree_insert_node(): DH_LINK_TYPE_BOOK: %s\n", link->name);
gtk_tree_store_set (priv->store, &iter,
COL_OPEN_PIXBUF, priv->pixbufs->pixbuf_opened,
COL_CLOSED_PIXBUF, priv->pixbufs->pixbuf_closed,
COL_TITLE, link->name,
COL_LINK, link,
-1);
} else {
//printf("book_tree_insert_node(): not book. %s %p\n", link->name, link);
gtk_tree_store_set (priv->store, &iter,
COL_OPEN_PIXBUF, priv->pixbufs->pixbuf_helpdoc,
COL_CLOSED_PIXBUF, priv->pixbufs->pixbuf_helpdoc,
COL_TITLE, link->name,
COL_LINK, link,
-1);
}
for (child = g_node_first_child (node);
child;
child = g_node_next_sibling (child)) {
book_tree_insert_node (tree, child, &iter);
}
}
static gboolean remmina_main_load_file_tree_traverse(GNode *node, GtkTreeStore *store, GtkTreeIter *parent)
{
GtkTreeIter *iter;
RemminaGroupData *data;
GNode *child;
iter = NULL;
if (node->data)
{
data = (RemminaGroupData*) node->data;
iter = g_new0(GtkTreeIter, 1);
gtk_tree_store_append(store, iter, parent);
gtk_tree_store_set(store, iter, PROTOCOL_COLUMN, GTK_STOCK_DIRECTORY, NAME_COLUMN, data->name, GROUP_COLUMN,
data->group, FILENAME_COLUMN, NULL, -1);
}
for (child = g_node_first_child(node); child; child = g_node_next_sibling(child))
{
remmina_main_load_file_tree_traverse(child, store, iter);
}
g_free(iter);
return FALSE;
}
GNode *cloud_config_find(GNode* node, gchar** path) {
GNode* child;
if (!path) {
if (g_node_depth(node) == 0) {
return NULL;
}
/* reached the end of our search, so return this node as value */
return g_node_first_child(node);
}
child = g_node_first_child(node);
while (child) {
if (g_strcmp0(child->data, path[0]) == 0) {
/* recurse */
return cloud_config_find(child, (gchar**)path[1]);
}
child = g_node_next_sibling(child);
}
return NULL;
}
AGlActor*
directories_view(WaveformActor* _)
{
instance_count++;
_init();
bool dirs_paint(AGlActor* actor)
{
DirectoriesView* view = (DirectoriesView*)actor;
agl_enable_stencil(0, 0, actor->region.x2, actor->region.y2);
int i = 0;
GNode* node = g_node_first_child (samplecat.model->dir_tree);
for(; node && i < view->cache.n_rows; node = g_node_next_sibling(node)){
DhLink* link = (DhLink*)node->data;
if(i == view->selection/* - view->scroll_offset*/){
agl->shaders.plain->uniform.colour = 0x6677ff77;
agl_use_program((AGlShader*)agl->shaders.plain);
agl_rect_((AGlRect){0, i * row_height - 2, agl_actor__width(actor), row_height});
}
agl_print(0, i * row_height, 0, 0xffffffff, strlen(link->uri) ? link->uri : link->name);
gboolean node_open = false;
if(node_open){
// recurse children
}
i++;
}
agl_disable_stencil();
return true;
}
static char *generator(const char *text, int state)
{
static GNode *node;
static int len;
char *data;
if (!state) {
node = g_node_first_child(head_node);
len = strlen(text);
}
if (node == NULL || G_NODE_IS_LEAF(node))
return NULL;
while (node != NULL) {
data = (char *) node->data;
node = g_node_next_sibling(node);
if (!strncmp(text, data, len))
return g_strdup(data);
}
return NULL;
}
/*!
* find and call the spec handler for each child of GNode
*
* \param [in] root \c GNode
* \param[in,out] config \ref cc_oci_config.
* \param spec_handlers Array of \ref spec_handler's.
*
* \return \c false if a spec handler fails, else \c true.
*/
gboolean
cc_oci_process_config (GNode *root, struct cc_oci_config *config,
struct spec_handler **spec_handlers)
{
GNode* node;
for (node = g_node_first_child(root); node; node = g_node_next_sibling(node)) {
if (! node->data) {
continue;
}
if (node->children) {
if (g_strcmp0 (node->data, "ociVersion") == 0) {
config->oci.oci_version = g_strdup (node->children->data);
}
if (g_strcmp0 (node->data, "hostname") == 0) {
config->oci.hostname = g_strdup (node->children->data);
}
}
/* looking for right spec handler */
for (struct spec_handler** i=spec_handlers; (*i); ++i) {
if (g_strcmp0((*i)->name, node->data) == 0) {
/* run spec handler */
if (! (*i)->handle_section(node, config)) {
g_critical("failed spec handler: %s", (*i)->name);
return false;
}
break;
}
}
}
return true;
}
static void
ltable_insert(LTable* lt, const gchar* where, Listener* l)
{
gchar** dirnames;
guint i;
GNode* cur;
GNode* found = NULL;
LTableEntry* lte;
const gchar* noroot_where = where + 1;
g_return_if_fail(mateconf_valid_key(where, NULL));
if (lt->tree == NULL)
{
lte = ltable_entry_new(NULL, 0);
lt->tree = g_node_new(lte);
lte = NULL; /* paranoia */
}
/* Add to the tree */
dirnames = g_strsplit(noroot_where, "/", -1);
cur = lt->tree;
i = 0;
while (dirnames[i])
{
LTableEntry* ne;
GNode* across;
/* Find this dirname on this level, or add it. */
g_assert (cur != NULL);
found = NULL;
across = cur->children;
while (across != NULL)
{
int cmp;
lte = across->data;
cmp = strcmp(lte->name, dirnames[i]);
if (cmp == 0)
{
found = across;
break;
}
else if (cmp > 0)
{
/* Past it */
break;
}
else
{
across = g_node_next_sibling(across);
}
}
if (found == NULL)
{
ne = ltable_entry_new(dirnames, i);
if (across != NULL) /* Across is at the one past */
found = g_node_insert_data_before(cur, across, ne);
else /* Never went past, append - could speed this up by saving last visited */
found = g_node_append_data(cur, ne);
}
g_assert(found != NULL);
cur = found;
++i;
}
/* cur is still the root node ("/") if where was "/" since nothing
was returned from g_strsplit */
lte = cur->data;
lte->listeners = g_list_prepend(lte->listeners, l);
g_strfreev(dirnames);
/* Add tree node to the flat table */
g_ptr_array_set_size(lt->listeners, MAX(CNXN_ID_INDEX(lt->next_cnxn), CNXN_ID_INDEX(l->cnxn)));
g_ptr_array_index(lt->listeners, CNXN_ID_INDEX(l->cnxn)) = cur;
lt->active_listeners += 1;
#ifdef DEBUG_LISTENERS
g_print ("Added %u at %s, spewing:\n",
l->cnxn, where);
ltable_spew(lt);
#endif
}
static void remmina_file_manager_add_group(GNode* node, const gchar* group)
{
gint cmp;
gchar* p1;
gchar* p2;
GNode* child;
gboolean found;
RemminaGroupData* data;
if (group == NULL || group[0] == '\0')
return;
p1 = g_strdup(group);
p2 = strchr(p1, '/');
if (p2)
*p2++ = '\0';
found = FALSE;
for (child = g_node_first_child(node); child; child = g_node_next_sibling(child))
{
cmp = g_strcmp0(((RemminaGroupData*) child->data)->name, p1);
if (cmp == 0)
{
found = TRUE;
break;
}
if (cmp > 0)
break;
}
if (!found)
{
data = g_new0(RemminaGroupData, 1);
data->name = p1;
if (node->data)
{
data->group = g_strdup_printf("%s/%s", ((RemminaGroupData*) node->data)->group, p1);
}
else
{
data->group = g_strdup(p1);
}
if (child)
{
child = g_node_insert_data_before(node, child, data);
}
else
{
child = g_node_append_data(node, data);
}
}
remmina_file_manager_add_group(child, p2);
if (found)
{
g_free(p1);
}
}
static void
ltable_notify(LTable* lt, const gchar* key,
MateConfListenersCallback callback, gpointer user_data)
{
gchar** dirs;
guint i;
const gchar* noroot_key;
GNode* cur;
GList *to_notify;
noroot_key = key + 1;
g_return_if_fail(*key == '/');
g_return_if_fail(mateconf_valid_key(key, NULL));
if (lt->tree == NULL)
return; /* no one to notify */
/* we build a list "to_notify" to be safe against tree
* modifications during the notification.
*/
/* Notify "/" listeners */
to_notify = g_list_copy (((LTableEntry*)lt->tree->data)->listeners);
dirs = g_strsplit (noroot_key, "/", -1);
cur = lt->tree;
i = 0;
while (dirs[i] && cur)
{
GNode* child = cur->children;
while (child != NULL)
{
LTableEntry* lte = child->data;
if (strcmp(lte->name, dirs[i]) == 0)
{
GList *copy = g_list_copy (lte->listeners);
to_notify = g_list_concat (to_notify, copy);
break;
}
child = g_node_next_sibling(child);
}
if (child != NULL) /* we found a child, scan below it */
cur = child;
else /* end of the line */
cur = NULL;
++i;
}
g_strfreev(dirs);
g_list_foreach (to_notify, (GFunc) listener_ref, NULL);
notify_listener_list ((MateConfListeners*)lt,
to_notify, key,
callback, user_data);
g_list_foreach (to_notify, (GFunc) listener_unref, NULL);
g_list_free (to_notify);
}
GNode*
ada_gnode_next_sibling (GNode * node)
{
return g_node_next_sibling (node);
}
plist_t plist_get_next_sibling(plist_t node)
{
return (plist_t) g_node_next_sibling((GNode *) node);
}