static void plCTree( GtkCTree * ctree,GtkCTreeNode * parent_node,gpointer user_data ) { GtkCTreeNode * node; DirNodeType * DirNode; gchar * text, * name = NULL; gchar * dummy = "dummy"; int subdir = 1; DIR * dir = NULL; struct dirent * dirent; gchar * path; struct stat statbuf; DirNode=gtk_ctree_node_get_row_data( ctree,parent_node ); if ( !DirNode->scaned ) { DirNode->scaned=1; current_path=DirNode->path; gtk_clist_freeze( GTK_CLIST( ctree ) ); node=gtk_ctree_find_by_row_data( ctree,parent_node,NULL ); gtk_ctree_remove_node( ctree,node ); if ( (dir=opendir( DirNode->path ) ) ) { while( (dirent=readdir( dir )) ) { path=calloc( 1,strlen( DirNode->path ) + strlen( dirent->d_name ) + 2 ); if ( !strcmp( current_path,"/" ) ) sprintf( path,"/%s",dirent->d_name ); else sprintf( path,"%s/%s",current_path,dirent->d_name ); text=dirent->d_name; g_free( name ); name=g_filename_to_utf8( text, -1, NULL, NULL, NULL ); if ( stat( path,&statbuf ) != -1 && S_ISDIR( statbuf.st_mode ) && dirent->d_name[0] != '.' ) { DirNode=malloc( sizeof( DirNodeType ) ); DirNode->scaned=0; DirNode->path=strdup( path ); subdir=check_for_subdir( path ); node=gtk_ctree_insert_node( ctree,parent_node,NULL,(name ? &name : &text ),4,pxOpenedBook,msOpenedBook,pxClosedBook,msClosedBook,!subdir,FALSE ); gtk_ctree_node_set_row_data_full( ctree,node,DirNode,NULL ); if ( subdir ) node=gtk_ctree_insert_node( ctree,node,NULL,&dummy,4,NULL,NULL,NULL,NULL,FALSE,FALSE ); } free( path ); path=NULL; } closedir( dir ); } gtk_ctree_sort_node( ctree,parent_node ); gtk_clist_thaw( GTK_CLIST( ctree ) ); } g_free( name ); }
void source_ctree_add_master (GtkWidget *ctree, struct master *m) { GtkCTreeNode *node; GtkCTreeNode *parent = NULL; struct master *group = NULL; if (m->isgroup) return; // If set to display only configured games, and game is not configured, // and it's not the 'Favorites' master, just return so the display // isn't updated with the game type and masters. if (!(games[m->type].cmd) && default_show_only_configured_games && m != favorites) return; if (m->type != UNKNOWN_SERVER) { group = (struct master *) g_slist_nth_data (master_groups, m->type); source_ctree_enable_master_group (ctree, group, TRUE); } node = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, m); if (!node) { if (group) { parent = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, group); } node = gtk_ctree_insert_node (GTK_CTREE (ctree), parent, NULL, NULL, 4, NULL, NULL, NULL, NULL, TRUE, FALSE); gtk_ctree_node_set_row_data (GTK_CTREE (ctree), node, m); } source_ctree_show_node_status (ctree, m); }
static GtkCTreeNode *mimeview_append_part(MimeView *mimeview, MimeInfo *partinfo, GtkCTreeNode *parent) { GtkCTree *ctree = GTK_CTREE(mimeview->ctree); GtkCTreeNode *node; static gchar content_type[64]; gchar *str[N_MIMEVIEW_COLS]; if (partinfo->type != MIMETYPE_UNKNOWN && partinfo->subtype) { g_snprintf(content_type, 64, "%s/%s", procmime_get_media_type_str(partinfo->type), partinfo->subtype); } else { g_snprintf(content_type, 64, "UNKNOWN"); } str[COL_MIMETYPE] = content_type; str[COL_SIZE] = to_human_readable(partinfo->length); if (prefs_common.attach_desc) str[COL_NAME] = (gchar *) get_part_description(partinfo); else str[COL_NAME] = (gchar *) get_part_name(partinfo); node = gtk_ctree_insert_node(ctree, parent, NULL, str, 0, NULL, NULL, NULL, NULL, FALSE, TRUE); gtk_ctree_node_set_row_data(ctree, node, partinfo); return node; }
void gftpui_add_file_to_transfer (gftp_transfer * tdata, GList * curfle) { gftpui_common_curtrans_data * transdata; char *text[2]; gftp_file * fle; fle = curfle->data; text[0] = gftpui_gtk_get_utf8_file_pos (fle); if (fle->transfer_action == GFTP_TRANS_ACTION_SKIP) text[1] = _("Skipped"); else text[1] = _("Waiting..."); fle->user_data = gtk_ctree_insert_node (GTK_CTREE (dlwdw), tdata->user_data, NULL, text, 5, NULL, NULL, NULL, NULL, FALSE, FALSE); transdata = g_malloc0 (sizeof (*transdata)); transdata->transfer = tdata; transdata->curfle = curfle; gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), fle->user_data, transdata); }
static void fill_source_ctree (GtkWidget *ctree) { GSList *list; GSList *list2; GtkCTreeNode *node; GtkCTreeNode *parent; struct master *group; struct master *m; source_ctree_add_master (ctree, favorites); for (list = master_groups; list; list = list->next) { group = (struct master *) list->data; if (group->masters) { // If set to display only configured games, and game is not configured, // don't update the display with the master. if (games[group->type].cmd || !default_show_only_configured_games) { source_ctree_enable_master_group (ctree, group, FALSE); parent = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, group); for (list2 = group->masters; list2; list2 = list2->next) { m = (struct master *) list2->data; node = gtk_ctree_insert_node (GTK_CTREE (ctree), parent, NULL, NULL, 4, NULL, NULL, NULL, NULL, TRUE, FALSE); gtk_ctree_node_set_row_data (GTK_CTREE (ctree), node, m); source_ctree_show_node_status (ctree, m); } } } } }
void variable_ctree_add_var(GtkCTree *ctree, gchar *name, v5d_var_info *vinfo) { GtkCTreeNode *node; gchar *nstr[1]; nstr[0] = name; node = gtk_ctree_insert_node(ctree,NULL,NULL,nstr,0,NULL,NULL,NULL,NULL,1,0); gtk_ctree_node_set_row_data(ctree,node,(gpointer) vinfo); }
static void expand_cb(GtkWidget * widget, GtkCTreeNode * parent_node) { DIR *dir; struct dirent *dirent; gchar *path, *text, *dummy = "dummy"; struct stat statbuf; GtkCTreeNode *node, *sub_node; DirNode *parent_dirnode, *dirnode; gboolean has_subdir = FALSE; parent_dirnode = gtk_ctree_node_get_row_data(GTK_CTREE(widget), parent_node); if (!parent_dirnode->scanned) { gtk_clist_freeze(GTK_CLIST(widget)); node = gtk_ctree_find_by_row_data(GTK_CTREE(widget), parent_node, NULL); gtk_ctree_remove_node(GTK_CTREE(widget), node); if ((dir = opendir(parent_dirnode->path)) != NULL) { while ((dirent = readdir(dir)) != NULL) { path = g_strconcat(parent_dirnode->path, dirent->d_name, NULL); if (stat(path, &statbuf) != -1 && S_ISDIR(statbuf.st_mode) && dirent->d_name[0] != '.') { dirnode = g_malloc0(sizeof (DirNode)); dirnode->path = g_strconcat(path, "/", NULL); text = dirent->d_name; if (check_for_subdir(dirnode->path)) has_subdir = TRUE; else has_subdir = FALSE; node = gtk_ctree_insert_node(GTK_CTREE(widget), parent_node, NULL, &text, 4, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, !has_subdir, FALSE); gtk_ctree_node_set_row_data_full(GTK_CTREE(widget), node, dirnode, destroy_cb); if (has_subdir) sub_node = gtk_ctree_insert_node(GTK_CTREE(widget), node, NULL, &dummy, 4, NULL, NULL, NULL, NULL, FALSE, FALSE); } g_free(path); } closedir(dir); gtk_ctree_sort_node(GTK_CTREE(widget), parent_node); } gtk_clist_thaw(GTK_CLIST(widget)); parent_dirnode->scanned = TRUE; } }
int add_a_site_to_the_tree(struct site *a_site, gint operation) { struct ctree_attachment *info_to_add; gchar *tmp, *node_label[1]; tmp = getAppropriateTreeLabel(a_site); node_label[0] = tmp; site_item = gtk_ctree_insert_node(GTK_CTREE(the_tree), NULL, NULL, node_label, 0, NULL, NULL, NULL, NULL, FALSE, FALSE); g_free (tmp); info_to_add = malloc(sizeof(struct ctree_attachment)); info_to_add->file_or_site = IS_A_SITE; info_to_add->info_struct = (void *) a_site; gtk_ctree_node_set_row_data(GTK_CTREE(the_tree), site_item, (gpointer) info_to_add); /* Read site info */ if (site_readfiles(a_site) != SITE_OK) /* We effectively have no info file, so just read the stored state. */ site_read_local_state(a_site); /* Catchup or init, if that's required */ if (operation == 1) { site_initialize(a_site); printf("Initialised site\n"); } else if (operation == 2) { site_catchup(a_site); printf("Caught-up new site.\n"); } /* As far as I can tell, this doesn't need to be done. * Not sure why it's in here*/ site_write_stored_state(a_site); if (operation != 3) { gtk_clist_freeze(GTK_CLIST(the_tree)); populate_site_node(GTK_CTREE_NODE(site_item), a_site); gtk_clist_thaw(GTK_CLIST(the_tree)); } return 0; }
static void source_ctree_enable_master_group (GtkWidget *ctree, struct master *m, int expand) { GtkCTreeNode *node; GtkCTreeNode *sibling = NULL; char cfgkey[128]; GSList *list; int expanded; if (!m->isgroup) return; node = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, m); if (node != NULL) { if (expand) gtk_ctree_expand (GTK_CTREE (ctree), node); return; } g_snprintf (cfgkey, 128, "/" CONFIG_FILE "/Source Tree/%s node collapsed=false", m->name); if (expand) config_set_bool (cfgkey, expanded = TRUE); else expanded = TRUE - config_get_bool (cfgkey); /* Find the place to insert new master group */ list = g_slist_nth (master_groups, m->type); if (list) list = list->next; while (!sibling && list) { sibling = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, (struct master *) list->data); list = list->next; } node = gtk_ctree_insert_node (GTK_CTREE (ctree), NULL, sibling, NULL, 4, NULL, NULL, NULL, NULL, FALSE, expanded); gtk_ctree_node_set_row_data (GTK_CTREE (ctree), node, m); source_ctree_show_node_status (ctree, m); }
GtkWidget *create_dir_browser(gchar * title, gchar * current_path, GtkSelectionMode mode, void (*handler) (gchar *)) { GtkWidget *window, *scroll_win, *tree, *vbox, *bbox, *ok, *cancel, *sep; gchar *root_text = "/", *node_text = "dummy"; gchar *currentdir, *pos, *tpath, *tpathnew; GtkCTreeNode *root_node, *node, *nextnode; DirNode *dirnode; gboolean leaf; #ifdef _GTK2 window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_modal(GTK_WINDOW(window), TRUE); // gtk_window_set_decorated(GTK_WINDOW(window), TRUE); #else window = gtk_window_new(GTK_WINDOW_DIALOG); #endif gtk_window_set_title(GTK_WINDOW(window), title); gtk_container_border_width(GTK_CONTAINER(window), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(window), vbox); scroll_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize(scroll_win, 250, 200); gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0); gtk_widget_show(scroll_win); gtk_widget_realize(window); if (!folder_pixmap) { folder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &folder_mask, NULL, folder); ofolder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &ofolder_mask, NULL, ofolder); } tree = gtk_ctree_new(1, 0); gtk_clist_set_column_auto_resize(GTK_CLIST(tree), 0, TRUE); gtk_clist_set_selection_mode(GTK_CLIST(tree), mode); gtk_ctree_set_line_style(GTK_CTREE(tree), GTK_CTREE_LINES_DOTTED); gtk_signal_connect(GTK_OBJECT(tree), "tree_expand", GTK_SIGNAL_FUNC(expand_cb), NULL); gtk_signal_connect(GTK_OBJECT(tree), "select_row", GTK_SIGNAL_FUNC(select_row_cb), NULL); gtk_container_add(GTK_CONTAINER(scroll_win), tree); gtk_object_set_user_data(GTK_OBJECT(tree), (gpointer) handler); root_node = gtk_ctree_insert_node(GTK_CTREE(tree), NULL, NULL, &root_text, 4, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, FALSE); dirnode = g_malloc0(sizeof (DirNode)); dirnode->path = g_strdup("/"); gtk_ctree_node_set_row_data_full(GTK_CTREE(tree), root_node, dirnode, destroy_cb); node = gtk_ctree_insert_node(GTK_CTREE(tree), root_node, NULL, &node_text, 4, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_expand(GTK_CTREE(tree), root_node); gtk_widget_show(tree); sep = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0); gtk_widget_show(sep); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); ok = gtk_button_new_with_label(tr("Ok")); gtk_object_set_user_data(GTK_OBJECT(ok), window); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(window), ok); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(ok_clicked), tree); gtk_widget_show(ok); cancel = gtk_button_new_with_label(tr("Cancel")); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window)); gtk_widget_show(cancel); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); gtk_widget_show(vbox); if (current_path && *current_path) { currentdir = g_strdup(current_path); tpath = g_strdup("/"); pos = strtok(currentdir, "/"); node = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), NULL, "/", filetreeent_compare_func); do { tpathnew = g_strconcat(tpath, pos, "/", NULL); g_free(tpath); tpath = tpathnew; nextnode = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), node, tpath, filetreeent_compare_func); if (!nextnode) break; node = nextnode; pos = strtok(NULL, "/"); gtk_ctree_get_node_info(GTK_CTREE(tree), node, NULL, NULL, NULL, NULL, NULL, NULL, &leaf, NULL); if (!leaf && pos) gtk_ctree_expand(GTK_CTREE(tree), node); else { gtk_ctree_select(GTK_CTREE(tree), node); break; } } while (pos); g_free(tpath); g_free(currentdir); } else gtk_ctree_select(GTK_CTREE(tree), root_node); return window; }
static GtkCTreeNode *maketree_nodes(GtkCTreeNode *subtree, struct tree *t2, GtkCTreeNode *sibling, int mode) { char *tmp, *tmp2, *tmp3; gchar *text [1]; GdkDrawable *pxm, *msk; if(t2->t_which >= 0) { if(GLOBALS->facs[t2->t_which]->vec_root) { if(GLOBALS->autocoalesce) { if(GLOBALS->facs[t2->t_which]->vec_root!=GLOBALS->facs[t2->t_which]) { return(NULL); } tmp2=makename_chain(GLOBALS->facs[t2->t_which]); tmp3=leastsig_hiername(tmp2); tmp=wave_alloca(strlen(tmp3)+4); strcpy(tmp, "[] "); strcpy(tmp+3, tmp3); free_2(tmp2); } else { tmp=wave_alloca(strlen(t2->name)+4); strcpy(tmp, "[] "); strcpy(tmp+3, t2->name); } } else { tmp=t2->name; } } else { if(t2->t_which == WAVE_T_WHICH_UNDEFINED_COMPNAME) { tmp=t2->name; } else { int thidx = -t2->t_which + WAVE_T_WHICH_COMPNAME_START; if((thidx >= 0) && (thidx < GLOBALS->comp_name_serial)) { char *sc = GLOBALS->comp_name_idx[thidx]; int tlen = strlen(t2->name) + 2 + 1 + strlen(sc) + 1 + 1; tmp = wave_alloca(tlen); if(!GLOBALS->is_vhdl_component_format) { sprintf(tmp, "%s (%s)", t2->name, sc); } else { sprintf(tmp, "%s : %s", t2->name, sc); } } else { tmp=t2->name; /* should never get a value out of range here! */ } } } text[0]=tmp; switch(mode) { case MAKETREE_FLATTEN: if(t2->child) { sibling = gtk_ctree_insert_node (GLOBALS->ctree_main, subtree, sibling, text, 3, NULL, NULL, NULL, NULL, FALSE, FALSE); gtk_ctree_node_set_row_data(GLOBALS->ctree_main, sibling, t2); maketree(sibling, t2->child); } else { sibling = gtk_ctree_insert_node (GLOBALS->ctree_main, subtree, sibling, text, 3, NULL, NULL, NULL, NULL, TRUE, FALSE); gtk_ctree_node_set_row_data(GLOBALS->ctree_main, sibling, t2); } break; default: switch(t2->kind) { case TREE_VCD_ST_MODULE: pxm = GLOBALS->hiericon_module_pixmap; msk = GLOBALS->hiericon_module_mask; break; case TREE_VCD_ST_TASK: pxm = GLOBALS->hiericon_task_pixmap; msk = GLOBALS->hiericon_task_mask; break; case TREE_VCD_ST_FUNCTION: pxm = GLOBALS->hiericon_function_pixmap; msk = GLOBALS->hiericon_function_mask; break; case TREE_VCD_ST_BEGIN: pxm = GLOBALS->hiericon_begin_pixmap; msk = GLOBALS->hiericon_begin_mask; break; case TREE_VCD_ST_FORK: pxm = GLOBALS->hiericon_fork_pixmap; msk = GLOBALS->hiericon_fork_mask; break; case TREE_VCD_ST_GENERATE: pxm = GLOBALS->hiericon_generatefor_pixmap; msk = GLOBALS->hiericon_generatefor_mask; break; /* same as TREE_VHDL_ST_GENFOR */ case TREE_VCD_ST_STRUCT: pxm = GLOBALS->hiericon_block_pixmap; msk = GLOBALS->hiericon_block_mask; break; /* same as TREE_VHDL_ST_BLOCK */ case TREE_VCD_ST_UNION: pxm = GLOBALS->hiericon_instance_pixmap; msk = GLOBALS->hiericon_instance_mask; break; /* same as TREE_VHDL_ST_INSTANCE */ case TREE_VCD_ST_CLASS: pxm = GLOBALS->hiericon_class_pixmap; msk = GLOBALS->hiericon_class_mask; break; case TREE_VCD_ST_INTERFACE: pxm = GLOBALS->hiericon_interface_pixmap; msk = GLOBALS->hiericon_interface_mask; break; case TREE_VCD_ST_PACKAGE: pxm = GLOBALS->hiericon_svpackage_pixmap; msk = GLOBALS->hiericon_svpackage_mask; break; case TREE_VCD_ST_PROGRAM: pxm = GLOBALS->hiericon_program_pixmap; msk = GLOBALS->hiericon_program_mask; break; case TREE_VHDL_ST_DESIGN: pxm = GLOBALS->hiericon_design_pixmap; msk = GLOBALS->hiericon_design_mask; break; case TREE_VHDL_ST_BLOCK: pxm = GLOBALS->hiericon_block_pixmap; msk = GLOBALS->hiericon_block_mask; break; case TREE_VHDL_ST_GENIF: pxm = GLOBALS->hiericon_generateif_pixmap; msk = GLOBALS->hiericon_generateif_mask; break; case TREE_VHDL_ST_GENFOR: pxm = GLOBALS->hiericon_generatefor_pixmap; msk = GLOBALS->hiericon_generatefor_mask; break; case TREE_VHDL_ST_INSTANCE: pxm = GLOBALS->hiericon_instance_pixmap; msk = GLOBALS->hiericon_instance_mask; break; case TREE_VHDL_ST_PACKAGE: pxm = GLOBALS->hiericon_package_pixmap; msk = GLOBALS->hiericon_package_mask; break; case TREE_VHDL_ST_SIGNAL: pxm = GLOBALS->hiericon_signal_pixmap; msk = GLOBALS->hiericon_signal_mask; break; case TREE_VHDL_ST_PORTIN: pxm = GLOBALS->hiericon_portin_pixmap; msk = GLOBALS->hiericon_portin_mask; break; case TREE_VHDL_ST_PORTOUT: pxm = GLOBALS->hiericon_portout_pixmap; msk = GLOBALS->hiericon_portout_mask; break; case TREE_VHDL_ST_PORTINOUT: pxm = GLOBALS->hiericon_portinout_pixmap; msk = GLOBALS->hiericon_portinout_mask; break; case TREE_VHDL_ST_BUFFER: pxm = GLOBALS->hiericon_buffer_pixmap; msk = GLOBALS->hiericon_buffer_mask; break; case TREE_VHDL_ST_LINKAGE: pxm = GLOBALS->hiericon_linkage_pixmap; msk = GLOBALS->hiericon_linkage_mask; break; case TREE_VHDL_ST_ARCHITECTURE: pxm = GLOBALS->hiericon_module_pixmap; msk = GLOBALS->hiericon_module_mask; break; /* same as TREE_VCD_ST_MODULE */ case TREE_VHDL_ST_FUNCTION: pxm = GLOBALS->hiericon_function_pixmap; msk = GLOBALS->hiericon_function_mask; break; /* same as TREE_VCD_ST_FUNCTION */ case TREE_VHDL_ST_PROCESS: pxm = GLOBALS->hiericon_task_pixmap; msk = GLOBALS->hiericon_task_mask; break; /* same as TREE_VCD_ST_TASK */ case TREE_VHDL_ST_PROCEDURE: pxm = GLOBALS->hiericon_class_pixmap; msk = GLOBALS->hiericon_class_mask; break; /* same as TREE_VCD_ST_CLASS */ case TREE_VHDL_ST_RECORD: pxm = GLOBALS->hiericon_record_pixmap; msk = GLOBALS->hiericon_record_mask; break; case TREE_VHDL_ST_GENERATE: pxm = GLOBALS->hiericon_generate_pixmap; msk = GLOBALS->hiericon_generate_mask; break; default: pxm = msk = NULL; break; } sibling = gtk_ctree_insert_node (GLOBALS->ctree_main, subtree, sibling, text, 3, pxm, msk, pxm, msk, (mode==MAKETREE_LEAF), FALSE); gtk_ctree_node_set_row_data(GLOBALS->ctree_main, sibling, t2); break; } return(sibling); }
/* * Create a node that will contain all sampled symbol information. */ static void gdisp_createSymbolNode(Kernel_T *kernel, GtkWidget *parent, GtkWidget *tree, GtkCTreeNode *sampledSymbolNode, Symbol_T *symbol) { GtkCTreeNode *iNode = (GtkCTreeNode*)NULL; GList *iExtInfoItem = (GList*)NULL; Pixmap_T *pPixmap = (Pixmap_T*)NULL; gchar *iNames [GD_TREE_NB_COLUMNS] = { (gchar*)NULL, (gchar*)NULL }; gchar iInfo [128]; gchar iMin [128]; gchar iMax [128]; /* * The name of the node is the name of the symbol. */ iNames[0] = symbol->sInfo.name; iNames[1] = iInfo; if (symbol->sInfo.dimension == 1) { sprintf(iNames[1], "Type %s", gdisp_getTypeAsString(symbol)); } else { sprintf(iNames[1], "Type %s [%d]", gdisp_getTypeAsString(symbol), symbol->sInfo.dimension); } symbol->sNode = gtk_ctree_insert_node(GTK_CTREE(tree), sampledSymbolNode, (GtkCTreeNode*)NULL, /* no sibling */ iNames, GD_TREE_SPACING, (GdkPixmap*)NULL, (GdkBitmap*)NULL, (GdkPixmap*)NULL, (GdkBitmap*)NULL, FALSE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_row_data(GTK_CTREE(tree), symbol->sNode, (gpointer)symbol); /* * Insert information node : PERIOD. */ iNames[0] = "Period"; iNames[1] = iInfo; sprintf(iNames[1],"%d",symbol->sInfo.period); iNode = gtk_ctree_insert_node(GTK_CTREE(tree), symbol->sNode, /* symbol node is the parent */ (GtkCTreeNode*)NULL, /* no sibling node */ iNames, GD_TREE_SPACING, (GdkPixmap*)NULL, (GdkBitmap*)NULL, (GdkPixmap*)NULL, (GdkBitmap*)NULL, TRUE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_selectable(GTK_CTREE(tree), iNode, FALSE); /* not selectable */ /* * Insert information node : PHASE. */ iNames[0] = "Phase"; iNames[1] = iInfo; sprintf(iNames[1],"%d",symbol->sInfo.phase); iNode = gtk_ctree_insert_node(GTK_CTREE(tree), symbol->sNode, /* symbol node is the parent */ (GtkCTreeNode*)NULL, /* no sibling node */ iNames, GD_TREE_SPACING, (GdkPixmap*)NULL, (GdkBitmap*)NULL, (GdkPixmap*)NULL, (GdkBitmap*)NULL, TRUE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_selectable(GTK_CTREE(tree), iNode, FALSE); /* not selectable */ /* * Insert information node : RANGE. */ iNames[0] = "Range"; iNames[1] = iInfo; if (symbol->sMinimum > (- G_MAXDOUBLE)) { sprintf(iMin,"%f",symbol->sMinimum); } else { sprintf(iMin,"n/a"); } if (symbol->sMaximum < (+ G_MAXDOUBLE)) { sprintf(iMax,"%f",symbol->sMaximum); } else { sprintf(iMax,"n/a"); } sprintf(iNames[1],"[ %s .. %s ]",iMin,iMax); iNode = gtk_ctree_insert_node(GTK_CTREE(tree), symbol->sNode, /* symbol node is the parent */ (GtkCTreeNode*)NULL, /* no sibling node */ iNames, GD_TREE_SPACING, (GdkPixmap*)NULL, (GdkBitmap*)NULL, (GdkPixmap*)NULL, (GdkBitmap*)NULL, TRUE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_selectable(GTK_CTREE(tree), iNode, FALSE); /* not selectable */ /* * Insert information node : REFERENCE. */ iNames[0] = "Reference"; iNames[1] = iInfo; sprintf(iNames[1],"%d",symbol->sReference); iNode = gtk_ctree_insert_node(GTK_CTREE(tree), symbol->sNode, /* symbol node is the parent */ (GtkCTreeNode*)NULL, /* no sibling node */ iNames, GD_TREE_SPACING, (GdkPixmap*)NULL, (GdkBitmap*)NULL, (GdkPixmap*)NULL, (GdkBitmap*)NULL, TRUE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_selectable(GTK_CTREE(tree), iNode, FALSE); /* not selectable */ gtk_ctree_node_set_row_data(GTK_CTREE(tree), iNode, (gpointer)"sReference"); /* * Insert extended information. */ pPixmap = gdisp_getPixmapById(kernel, GD_PIX_info, parent); iExtInfoItem = g_list_first(symbol->sExtInfoList); while (iExtInfoItem != (GList*)NULL) { iNames[0] = ((gchar**)(iExtInfoItem->data))[0]; iNames[1] = ((gchar**)(iExtInfoItem->data))[1]; iNode = gtk_ctree_insert_node(GTK_CTREE(tree), symbol->sNode, /* the parent */ (GtkCTreeNode*)NULL, /* no sibling node */ iNames, GD_TREE_SPACING, pPixmap->pixmap, pPixmap->mask, pPixmap->pixmap, pPixmap->mask, TRUE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_selectable(GTK_CTREE(tree), iNode, FALSE); /* not selectable */ iExtInfoItem = g_list_next(iExtInfoItem); } }
/* * Create a node that will contain all provider information. */ static void gdisp_createProviderNode(Kernel_T *kernel, GtkWidget *parent, GtkWidget *tree, Provider_T *provider, GtkCTreeNode **providerNode, GtkCTreeNode **sampledSymbolNode) { gchar *pNames [GD_TREE_NB_COLUMNS] = { (gchar*)NULL, (gchar*)NULL }; GtkCTreeNode *iNode = (GtkCTreeNode*)NULL; GtkCTreeNode *sNode = (GtkCTreeNode*)NULL; Pixmap_T *pPixmap = (Pixmap_T*)NULL; /* * The name of the node is the URL of the provider. * Get back provider pixmap according to its identity. */ pNames[0] = provider->pUrl->str; pPixmap = gdisp_getProviderIdPixmap(kernel, parent, provider->pIdentity); provider->pNode = gtk_ctree_insert_node(GTK_CTREE(tree), (GtkCTreeNode*)NULL, /* parent */ (GtkCTreeNode*)NULL, /* sibling */ pNames, GD_TREE_SPACING, pPixmap->pixmap, pPixmap->mask, pPixmap->pixmap, pPixmap->mask, FALSE, /* is a leave */ TRUE); /* is expanded */ gtk_ctree_node_set_row_data(GTK_CTREE(tree), provider->pNode, (gpointer)provider); gtk_ctree_node_set_selectable(GTK_CTREE(tree), provider->pNode, FALSE); /* not selectable */ /* * Insert information node. */ pNames[0] = "Information"; pPixmap = gdisp_getPixmapById(kernel, GD_PIX_info, parent); iNode = gtk_ctree_insert_node(GTK_CTREE(tree), provider->pNode, /* provider is the parent */ (GtkCTreeNode*)NULL, /* no sibling node */ pNames, GD_TREE_SPACING, pPixmap->pixmap, pPixmap->mask, pPixmap->pixmap, pPixmap->mask, /* FIXME for the moment */ TRUE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_selectable(GTK_CTREE(tree), iNode, FALSE); /* not selectable */ /* * Insert sampled symbol node. */ pNames[0] = "Sampled Symbols"; sNode = gtk_ctree_insert_node(GTK_CTREE(tree), provider->pNode, /* provider is the parent */ (GtkCTreeNode*)NULL, /* no sibling node */ pNames, GD_TREE_SPACING, kernel->widgets.collapsedNodePixmap->pixmap, kernel->widgets.collapsedNodePixmap->mask, kernel->widgets.expandedNodePixmap->pixmap, kernel->widgets.expandedNodePixmap->mask, FALSE, /* is a leave */ FALSE); /* is expanded */ gtk_ctree_node_set_row_data(GTK_CTREE(tree), sNode, (gpointer)"sAnchor"); gtk_ctree_node_set_text(GTK_CTREE(tree), sNode, 0, /* column */ pNames[0]); gtk_ctree_node_set_selectable(GTK_CTREE(tree), sNode, FALSE); /* not selectable */ if (gdisp_getProviderNumber(kernel) == 1) { /* * Expand that node if there is only one provider. */ gtk_ctree_expand(GTK_CTREE(tree),sNode); } /* * Return. */ *providerNode = provider->pNode; *sampledSymbolNode = sNode; }
GtkWidget * create_PlayList( void ) { GtkWidget * vbox1; GtkWidget * hbox1; GtkWidget * scrolledwindow1; GtkWidget * vbox2; GtkWidget * scrolledwindow2; GtkWidget * scrolledwindow3; GtkWidget * hbuttonbox1; GtkAccelGroup * accel_group; GdkColor transparent = { 0,0,0,0 }; gchar * root = "/"; gchar * dummy = "dummy"; DirNodeType * DirNode; accel_group=gtk_accel_group_new(); PlayList=gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_object_set_data( GTK_OBJECT( PlayList ),"PlayList",PlayList ); gtk_widget_set_usize( PlayList,512,384 ); gtk_window_set_title( GTK_WINDOW( PlayList ),MSGTR_PlayList ); gtk_window_set_position( GTK_WINDOW( PlayList ),GTK_WIN_POS_CENTER ); // gtk_window_set_policy( GTK_WINDOW( PlayList ),FALSE,FALSE,FALSE ); gtk_window_set_wmclass( GTK_WINDOW( PlayList ),"Playlist","MPlayer" ); gtk_widget_realize( PlayList ); gtkAddIcon( PlayList ); vbox1=AddVBox( AddDialogFrame( PlayList ),0 ); hbox1=AddHBox( NULL,1 ); gtk_box_pack_start( GTK_BOX( vbox1 ),hbox1,TRUE,TRUE,0 ); scrolledwindow1=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_show( scrolledwindow1 ); gtk_container_add( GTK_CONTAINER( AddFrame( NULL,0,hbox1,1 ) ),scrolledwindow1 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC ); CTDirTree=gtk_ctree_new( 1,0 ); gtk_signal_connect( GTK_OBJECT( CTDirTree ),"tree_expand",GTK_SIGNAL_FUNC( plCTree ),(void*)0 ); gtk_signal_connect( GTK_OBJECT( CTDirTree ),"select_row",GTK_SIGNAL_FUNC( plCTRow ),(void *)0 ); gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),CTDirTree ); gtk_clist_set_column_auto_resize( GTK_CLIST( CTDirTree ),0,TRUE ); gtk_clist_set_column_width( GTK_CLIST( CTDirTree ),0,80 ); gtk_clist_set_selection_mode( GTK_CLIST( CTDirTree ),GTK_SELECTION_SINGLE ); gtk_ctree_set_line_style( GTK_CTREE( CTDirTree ),GTK_CTREE_LINES_SOLID ); gtk_clist_column_titles_show( GTK_CLIST( CTDirTree ) ); gtk_clist_set_shadow_type( GTK_CLIST( CTDirTree ),GTK_SHADOW_NONE ); if ( !pxOpenedBook ) pxOpenedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msOpenedBook,&transparent,(gchar **)dir2_xpm ); if ( !pxClosedBook ) pxClosedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msClosedBook,&transparent,(gchar **)open2_xpm ); parent=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),NULL,NULL,&root,4,pxOpenedBook,msOpenedBook,pxClosedBook,msClosedBook,FALSE,FALSE ); DirNode=malloc( sizeof( DirNodeType ) ); DirNode->scaned=0; DirNode->path=strdup( root ); gtk_ctree_node_set_row_data_full(GTK_CTREE( CTDirTree ),parent,DirNode,NULL ); sibling=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),parent,NULL,&dummy,4,NULL,NULL,NULL,NULL,TRUE,TRUE ); gtk_ctree_expand( GTK_CTREE( CTDirTree ),parent ); gtk_widget_show( CTDirTree ); if ( fsHistory[0] ) old_path = g_filename_from_utf8( fsHistory[0], -1, NULL, NULL, NULL ); gtk_clist_set_column_widget( GTK_CLIST( CTDirTree ),0, AddLabel( MSGTR_PLAYLIST_DirectoryTree,NULL ) ); gtk_clist_column_title_passive( GTK_CLIST( CTDirTree ),0 ); vbox2=AddVBox( AddFrame( NULL,1,hbox1,1 ),0 ); scrolledwindow2=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_show( scrolledwindow2 ); gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow2,TRUE,TRUE,0 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow2 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC ); CLFiles=gtk_clist_new( 1 ); gtk_widget_show( CLFiles ); gtk_container_add( GTK_CONTAINER( scrolledwindow2 ),CLFiles ); gtk_clist_set_column_width( GTK_CLIST( CLFiles ),0,80 ); gtk_clist_set_selection_mode( GTK_CLIST( CLFiles ),GTK_SELECTION_EXTENDED ); gtk_clist_column_titles_show( GTK_CLIST( CLFiles ) ); gtk_clist_set_shadow_type( GTK_CLIST( CLFiles ),GTK_SHADOW_NONE ); gtk_clist_set_column_widget( GTK_CLIST( CLFiles ),0, AddLabel( MSGTR_PLAYLIST_Files,NULL ) ); gtk_clist_column_title_passive( GTK_CLIST( CLFiles ),0 ); AddHSeparator( vbox2 ); scrolledwindow3=gtk_scrolled_window_new( NULL,NULL ); gtk_widget_show( scrolledwindow3 ); gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow3,TRUE,TRUE,0 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow3 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC ); CLSelected=gtk_clist_new( 2 ); gtk_widget_show( CLSelected ); gtk_container_add( GTK_CONTAINER( scrolledwindow3 ),CLSelected ); gtk_clist_set_column_width( GTK_CLIST( CLSelected ),0,295 ); gtk_clist_set_column_width( GTK_CLIST( CLSelected ),1,295 ); gtk_clist_set_selection_mode( GTK_CLIST( CLSelected ),GTK_SELECTION_MULTIPLE ); gtk_clist_column_titles_show( GTK_CLIST( CLSelected ) ); gtk_clist_set_shadow_type( GTK_CLIST( CLSelected ),GTK_SHADOW_NONE ); gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),0, AddLabel( MSGTR_PLAYLIST_Selected,NULL ) ); gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),1, AddLabel( MSGTR_PLAYLIST_Path,NULL ) ); gtk_clist_column_title_passive( GTK_CLIST( CLSelected ),0 ); AddHSeparator( vbox1 ); hbuttonbox1=AddHButtonBox( vbox1 ); gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END ); gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 ); Add=AddButton( MSGTR_Add,hbuttonbox1 ); Remove=AddButton( MSGTR_Remove,hbuttonbox1 ); Ok=AddButton( MSGTR_Ok,hbuttonbox1 ); Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 ); gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE ); gtk_signal_connect( GTK_OBJECT( PlayList ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&PlayList ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void *)0 ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void *)0 ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)0 ); gtk_signal_connect( GTK_OBJECT( CLFiles ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)0 ); sigSel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void*)1 ); sigUnsel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void*)1 ); sigEvent=gtk_signal_connect( GTK_OBJECT( CLSelected ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)1 ); gtk_signal_connect( GTK_OBJECT( CLSelected ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)1 ); gtk_signal_connect( GTK_OBJECT( Add ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)3 ); gtk_signal_connect( GTK_OBJECT( Add ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)3 ); gtk_signal_connect( GTK_OBJECT( Remove ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)2 ); gtk_signal_connect( GTK_OBJECT( Remove ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)2 ); gtk_signal_connect( GTK_OBJECT( Ok ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)1 ); gtk_signal_connect( GTK_OBJECT( Ok ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)1 ); gtk_signal_connect( GTK_OBJECT( Cancel ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)0 ); gtk_signal_connect( GTK_OBJECT( Cancel ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)0 ); gtk_window_add_accel_group( GTK_WINDOW( PlayList ),accel_group ); return PlayList; }
static void tree_expand_node (DirTree * dt, GtkCTreeNode * node, gboolean expand) { GtkCTreeNode *child; DirTreeNode *parent_node; DirTreeNode *child_node; DIR *dir; struct stat stat_buff; struct dirent *entry; gboolean has_subdirs, has_link, has_access; char *old_path; char *subdir = "?"; char *file_name; GtkWidget *top = gtk_widget_get_toplevel (GTK_WIDGET (dt)); old_path = g_get_current_dir (); if (!old_path) return; parent_node = gtk_ctree_node_get_row_data (GTK_CTREE (dt), node); if (chdir (parent_node->path)) { g_free (old_path); return; } dir = opendir ("."); if (!dir) { chdir (old_path); g_free (old_path); return; } dirtree_set_cursor (top, GDK_WATCH); gtk_clist_freeze (GTK_CLIST (dt)); tree_collapse (GTK_CTREE (dt), node); child = NULL; while ((entry = readdir (dir))) { if (!stat (entry->d_name, &stat_buff) && S_ISDIR (stat_buff.st_mode) && tree_is_dotfile (entry->d_name, dt->show_dotfile)) { child_node = g_malloc0 (sizeof (DirTreeNode)); child_node->path = g_strconcat (parent_node->path, "/", entry->d_name, NULL); has_link = islink (entry->d_name); has_access = access (entry->d_name, X_OK); file_name = entry->d_name; if (has_access) { child = gtk_ctree_insert_node (GTK_CTREE (dt), node, child, &file_name, CTREE_SPACING, lckfolder_pixmap, lckfolder_mask, NULL, NULL, 1, 0); has_subdirs = FALSE; } else if (!strcmp (entry->d_name, ".")) { child = gtk_ctree_insert_node (GTK_CTREE (dt), node, child, &file_name, CTREE_SPACING, gofolder_pixmap, gofolder_mask, NULL, NULL, 1, 0); has_subdirs = FALSE; } else if (!strcmp (entry->d_name, "..")) { child = gtk_ctree_insert_node (GTK_CTREE (dt), node, child, &file_name, CTREE_SPACING, upfolder_pixmap, upfolder_mask, NULL, NULL, 1, 0); has_subdirs = FALSE; } else { if (dt->check_dir) { if (dt->check_hlinks) { if (stat_buff.st_nlink == 2 && dt->show_dotfile) has_subdirs = TRUE; else if (stat_buff.st_nlink > 2) has_subdirs = TRUE; else if (stat_buff.st_nlink == 1) has_subdirs = tree_is_subdirs (entry->d_name, dt->show_dotfile); else has_subdirs = FALSE; } else has_subdirs = tree_is_subdirs (entry->d_name, dt->show_dotfile); } else has_subdirs = TRUE; if (access (entry->d_name, X_OK) != 0) { has_subdirs = FALSE; } if (has_link) child = gtk_ctree_insert_node (GTK_CTREE (dt), node, child, &file_name, CTREE_SPACING, lfolder_pixmap, lfolder_mask, lofolder_pixmap, lofolder_mask, !has_subdirs, 0); else child = gtk_ctree_insert_node (GTK_CTREE (dt), node, child, &file_name, CTREE_SPACING, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, !has_subdirs, 0); } if (child) { gtk_ctree_node_set_row_data_full (GTK_CTREE (dt), child, child_node, dirtree_destroy_tree); if (has_subdirs) gtk_ctree_insert_node (GTK_CTREE (dt), child, NULL, &subdir, CTREE_SPACING, NULL, NULL, NULL, NULL, 0, 0); } } if (dt->check_events) while (gtk_events_pending ()) gtk_main_iteration (); } closedir (dir); chdir (old_path); g_free (old_path); gtk_ctree_sort_node (GTK_CTREE (dt), node); if (expand == TRUE) gtk_ctree_expand (GTK_CTREE (dt), node); gtk_clist_thaw (GTK_CLIST (dt)); dirtree_set_cursor (top, -1); }
static void show_transfer (gftp_transfer * tdata) { GdkPixmap * closedir_pixmap, * opendir_pixmap; GdkBitmap * closedir_bitmap, * opendir_bitmap; gftpui_common_curtrans_data * transdata; gftp_file * tempfle; GList * templist; char *text[2]; gftp_get_pixmap (dlwdw, "open_dir.xpm", &opendir_pixmap, &opendir_bitmap); gftp_get_pixmap (dlwdw, "dir.xpm", &closedir_pixmap, &closedir_bitmap); text[0] = tdata->fromreq->hostname; text[1] = _("Waiting..."); tdata->user_data = gtk_ctree_insert_node (GTK_CTREE (dlwdw), NULL, NULL, text, 5, closedir_pixmap, closedir_bitmap, opendir_pixmap, opendir_bitmap, FALSE, tdata->numdirs + tdata->numfiles < 50); transdata = g_malloc0 (sizeof (*transdata)); transdata->transfer = tdata; transdata->curfle = NULL; gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tdata->user_data, transdata); tdata->show = 0; tdata->curfle = tdata->updfle = tdata->files; tdata->total_bytes = 0; for (templist = tdata->files; templist != NULL; templist = templist->next) { tempfle = templist->data; text[0] = gftpui_gtk_get_utf8_file_pos (tempfle); if (tempfle->transfer_action == GFTP_TRANS_ACTION_SKIP) text[1] = _("Skipped"); else { tdata->total_bytes += tempfle->size; text[1] = _("Waiting..."); } tempfle->user_data = gtk_ctree_insert_node (GTK_CTREE (dlwdw), tdata->user_data, NULL, text, 5, NULL, NULL, NULL, NULL, FALSE, FALSE); transdata = g_malloc0 (sizeof (*transdata)); transdata->transfer = tdata; transdata->curfle = templist; gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), tempfle->user_data, transdata); } if (!tdata->toreq->stopable && gftp_need_password (tdata->toreq)) { tdata->toreq->stopable = 1; MakeEditDialog (_("Enter Password"), _("Please enter your password for this site"), NULL, 0, NULL, gftp_dialog_button_connect, get_trans_password, tdata->toreq, cancel_get_trans_password, tdata); } if (!tdata->fromreq->stopable && gftp_need_password (tdata->fromreq)) { tdata->fromreq->stopable = 1; MakeEditDialog (_("Enter Password"), _("Please enter your password for this site"), NULL, 0, NULL, gftp_dialog_button_connect, get_trans_password, tdata->fromreq, cancel_get_trans_password, tdata); } }
static void expand_tree(GtkCTree *ctree,GtkCTreeNode *parent_node, gpointer data) { DIR *dir; struct dirent *dirent; gchar *path,*text,*dummy="dummy"; struct stat statbuf; GtkCTreeNode *node,*sub_node; GtkDirTreeNode *parent_dirnode,*dirnode; gboolean has_subdir=FALSE; gboolean show_hidden; gboolean stat_subdirs=TRUE; gboolean can_open_subdir; GtkDirTree *dir_tree; GtkWidget *widget; widget = GTK_WIDGET(ctree); dir_tree = GTK_DIR_TREE(widget); show_hidden = dir_tree->show_hidden; parent_dirnode=gtk_ctree_node_get_row_data(GTK_CTREE(widget),parent_node); if(parent_dirnode->path == dir_tree->local_hostname) return; if(!parent_dirnode->scanned) { gtk_clist_freeze(GTK_CLIST(widget)); node=gtk_ctree_find_by_row_data(GTK_CTREE(widget),parent_node,NULL); gtk_ctree_remove_node(GTK_CTREE(widget),node); if((dir=opendir(parent_dirnode->path))!=NULL) { if(!check_dir_extra(parent_dirnode->path,&statbuf,&stat_subdirs)) { closedir(dir); gtk_clist_thaw(GTK_CLIST(widget)); return; } while((dirent=readdir(dir))!=NULL) { path=g_strconcat(parent_dirnode->path,dirent->d_name,NULL); if (stat_subdirs) { if(0!=stat(path,&statbuf)) { g_free(path); continue; } } if(((!stat_subdirs)&&accept_dirname(dirent->d_name,show_hidden)) || (S_ISDIR(statbuf.st_mode)&&accept_dirname(dirent->d_name,show_hidden))) { DIR *dir_sub; dirnode=g_malloc0(sizeof(GtkDirTreeNode)); dirnode->path=g_strconcat(path,G_DIR_SEPARATOR_S,NULL); text=dirent->d_name; if (stat_subdirs) { if(check_for_subdir(dirnode->path,show_hidden)) has_subdir=TRUE; else has_subdir=FALSE; dir_sub = opendir(dirnode->path); if( dir_sub != NULL ) { closedir(dir_sub); can_open_subdir=TRUE; } else { can_open_subdir=FALSE; } } else { has_subdir=TRUE; can_open_subdir=TRUE; } if(can_open_subdir) { node=gtk_ctree_insert_node(GTK_CTREE(widget),parent_node,NULL,&text,4,dir_tree->folder,dir_tree->folder_mask,dir_tree->ofolder,dir_tree->ofolder_mask,!has_subdir,FALSE); } else { node=gtk_ctree_insert_node(GTK_CTREE(widget),parent_node,NULL,&text,4,dir_tree->dennied,dir_tree->dennied_mask,dir_tree->dennied,dir_tree->dennied_mask,!has_subdir,FALSE); } gtk_ctree_node_set_row_data_full(GTK_CTREE(widget),node,dirnode,destroy_tree); if(has_subdir) sub_node=gtk_ctree_insert_node(GTK_CTREE(widget),node,NULL,&dummy,4,NULL,NULL,NULL,NULL,FALSE,FALSE); } g_free(path); } closedir(dir); gtk_ctree_sort_node(GTK_CTREE(widget),parent_node); } gtk_clist_thaw(GTK_CLIST(widget)); parent_dirnode->scanned=TRUE; } }
static void gtk_dir_tree_init (GtkDirTree *dir_tree) { GtkCTreeNode *root_node,*mypc_node,*node; GtkDirTreeNode *dirnode; gchar *root_text=G_DIR_SEPARATOR_S,*node_text="dummy"; gchar localhost[MAXHOSTNAMELEN]; GtkWidget *widget; GdkColormap *colormap; #ifdef G_OS_WIN32 gchar drives[128]; gchar* drive; #endif widget = GTK_WIDGET(dir_tree); colormap = gdk_colormap_get_system(); dir_tree->show_hidden = TRUE; /* Get the local hostname. */ #ifndef G_OS_WIN32 if ((gethostname (localhost, MAXHOSTNAMELEN) != 0) && (getdomainname (localhost, MAXHOSTNAMELEN) != 0)) strcpy (localhost, "LocalHost"); #else strcpy (localhost, "My PC"); #endif dir_tree->local_hostname = g_strdup(localhost); gtk_ctree_construct(GTK_CTREE(dir_tree), 1, 0, NULL); gtk_clist_set_row_height (GTK_CLIST (dir_tree), 18); dir_tree->my_pc=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &dir_tree->my_pc_mask, NULL,mypc_xpm); dir_tree->folder=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &dir_tree->folder_mask, NULL,folder_xpm); dir_tree->ofolder=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &dir_tree->ofolder_mask, NULL,ofolder_xpm); dir_tree->dennied=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap, &dir_tree->dennied_mask, NULL,dennied_xpm); gtk_clist_set_column_auto_resize(GTK_CLIST(dir_tree),0,TRUE); gtk_clist_set_selection_mode(GTK_CLIST(dir_tree),GTK_SELECTION_SINGLE); gtk_ctree_set_line_style(GTK_CTREE(dir_tree),GTK_CTREE_LINES_DOTTED); gtk_signal_connect(GTK_OBJECT(dir_tree),"tree_expand",GTK_SIGNAL_FUNC(expand_tree), NULL); mypc_node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),NULL,NULL,&dir_tree->local_hostname,4,dir_tree->my_pc,dir_tree->my_pc_mask,dir_tree->my_pc,dir_tree->my_pc_mask,FALSE,FALSE); dirnode=g_malloc0(sizeof(GtkDirTreeNode)); dirnode->path = dir_tree->local_hostname; gtk_ctree_node_set_row_data_full(GTK_CTREE(dir_tree),mypc_node,dirnode,destroy_tree); #ifndef G_OS_WIN32 root_node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),mypc_node,NULL,&root_text,4,dir_tree->folder,dir_tree->folder_mask,dir_tree->ofolder,dir_tree->ofolder_mask,FALSE,FALSE); dirnode=g_malloc0(sizeof(GtkDirTreeNode)); dirnode->path=g_strdup(G_DIR_SEPARATOR_S); gtk_ctree_node_set_row_data_full(GTK_CTREE(dir_tree),root_node,dirnode,destroy_tree); node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),root_node,NULL,&node_text,4,NULL,NULL,NULL,NULL,TRUE,TRUE); gtk_ctree_expand(GTK_CTREE(dir_tree),mypc_node); gtk_ctree_select(GTK_CTREE(dir_tree),root_node); #else /* On Windoze there isn't one unique root directory "/" but instead * there are logical drives a:, c: ... . Insert them into the dir_tree. */ /* Get the Drives string */ GetLogicalDriveStrings(sizeof(drives), drives); drive = drives; /* add an entry for every existing drive */ while (*drive != '\0') { root_node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),mypc_node,NULL,&drive,4,dir_tree->folder,dir_tree->folder_mask,dir_tree->ofolder,dir_tree->ofolder_mask,FALSE,FALSE); dirnode = g_malloc0(sizeof(GtkDirTreeNode)); dirnode->path = g_strdup(drive); gtk_ctree_node_set_row_data_full(GTK_CTREE(dir_tree),root_node,dirnode,destroy_tree); node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),root_node,NULL,&node_text, 4,NULL,NULL,NULL,NULL,TRUE,TRUE); drive += (strlen(drive) + 1); } gtk_ctree_expand(GTK_CTREE(dir_tree),mypc_node); gtk_ctree_select(GTK_CTREE(dir_tree),mypc_node); #endif }
GtkCTreeNode *add_file(char *name, struct site_file *a_file, GtkCTreeNode * parent) { /* External icons */ /* dir is closed, dir2 is open */ extern GdkPixmap *dir, *dir_new, *dir_changed, *dir_del; extern GdkPixmap *dir2, *dir2_new, *dir2_changed, *dir2_del; extern GdkPixmap *xsitecopy_file, *xsitecopy_file_new, *xsitecopy_file_changed, *xsitecopy_file_del, *xsitecopy_file_moved; extern GdkPixmap *symbolic_link, *symbolic_link_new, *symbolic_link_changed, *symbolic_link_del; /* Bitmaps */ extern GdkBitmap *dir_map, *dir_new_map, *dir_changed_map, *dir_del_map; extern GdkBitmap *dir2_map, *dir2_new_map, *dir2_changed_map, *dir2_del_map; extern GdkBitmap *xsitecopy_file_map, *xsitecopy_file_new_map, *xsitecopy_file_changed_map, *xsitecopy_file_del_map, *xsitecopy_file_moved_map; extern GdkBitmap *symbolic_link_map, *symbolic_link_new_map, *symbolic_link_changed_map, *symbolic_link_del_map; GtkCTreeNode *file_im_adding; struct ctree_attachment *file_info_to_add; gchar *node_label[1]; GdkPixmap *image, *image2 = NULL; GdkBitmap *mask, *mask2 = NULL; file_info_to_add = g_malloc0(sizeof(struct ctree_attachment)); file_info_to_add->file_or_site = IS_A_FILE; /* Pointer to this file */ file_info_to_add->info_struct = (gpointer) a_file; /* Check if this file is a symbolic_link or directory */ if (a_file->type == file_link) { if (a_file->diff != file_unchanged) { if (a_file->diff == file_changed) { image = symbolic_link_changed; mask = symbolic_link_changed_map; } else if (a_file->diff == file_deleted) { image = symbolic_link_del; mask = symbolic_link_del_map; } else { image = symbolic_link_new; mask = symbolic_link_new_map; } } else { image = symbolic_link; mask = symbolic_link_map; } } /* Check if it's actually a directory */ else if (a_file->type == file_dir) { if (a_file->diff != file_unchanged) { if (a_file->diff == file_changed) { image = dir_changed; mask = dir_changed_map; image2 = dir2_changed; mask2 = dir2_changed_map; } else if (a_file->diff == file_deleted) { image = dir_del; mask = dir_del_map; image2 = dir2_del; mask2 = dir2_del_map; } else { image = dir_new; mask = dir_new_map; image2 = dir2_new; mask2 = dir2_new_map; } } else { image = dir; mask = dir_map; image2 = dir2; mask2 = dir2_map; } } else { /* Set the image of this new file depending upon file status */ if (a_file->diff != file_unchanged) { if (a_file->diff == file_changed) { image = xsitecopy_file_changed; mask = xsitecopy_file_changed_map; } else if (a_file->diff == file_deleted) { image = xsitecopy_file_del; mask = xsitecopy_file_del_map; } else if (a_file->diff == file_moved) { image = xsitecopy_file_moved; mask = xsitecopy_file_moved_map; } else { image = xsitecopy_file_new; mask = xsitecopy_file_new_map; } } else { image = xsitecopy_file; mask = xsitecopy_file_map; } } /* Set the node's text label accordingly */ node_label[0] = name; /* Add the node */ file_im_adding = gtk_ctree_insert_node(GTK_CTREE(the_tree), GTK_CTREE_NODE(parent), NULL, node_label, 3, image, mask, a_file->type == file_dir ? image2 : image, a_file->type == file_dir ? mask2 : mask, FALSE, FALSE); gtk_ctree_node_set_row_data(GTK_CTREE(the_tree), file_im_adding, (gpointer) file_info_to_add); return file_im_adding; }
void set_mboxlist () { int x; mboxs **mboxlist; GtkCTree *tree; char *read, *unread, *marked, *all; mboxlist = (mboxs **) db_read_mboxlist (); tree = GTK_CTREE (lookup_widget (gems, "mailboxlist")); all = strdup ("all"); read = strdup ("read"); unread = strdup ("unread"); marked = strdup ("marked"); gtk_clist_freeze (>K_CTREE (tree)->clist); gtk_clist_clear (>K_CTREE (tree)->clist); x = 0; if(mboxlist) { while (mboxlist[x] != NULL) { GtkCTreeNode *node, *n; char *text; text = mboxlist[x]->name; node = gtk_ctree_insert_node (tree, NULL, NULL, &text, 5, NULL, NULL, NULL, NULL, FALSE, FALSE); gtk_ctree_node_set_row_data (tree, node, new_mboxview (mboxlist[x], default_mboxlistbehavior)); n = gtk_ctree_insert_node (tree, node, NULL, &all, 5, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_node_set_row_data (tree, n, new_mboxview (mboxlist[x], DB_ALL)); n = gtk_ctree_insert_node (tree, node, NULL, &unread, 5, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_node_set_row_data (tree, n, new_mboxview (mboxlist[x], DB_UNREAD)); n = gtk_ctree_insert_node (tree, node, NULL, &read, 5, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_node_set_row_data (tree, n, new_mboxview (mboxlist[x], DB_READ)); n = gtk_ctree_insert_node (tree, node, NULL, &marked, 5, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_node_set_row_data (tree, n, new_mboxview (mboxlist[x], DB_MARKED)); x++; } free (mboxlist); } /* * gtk_ctree_select(GTK_CTREE (tree), select_node); */ gtk_clist_thaw (>K_CTREE (tree)->clist); update_mboxlist (NULL); return; }
/* a mailbox was clicked * TODO: this is called twice on keypress... up and down? */ void on_mailboxlist_tree_select_row (GtkCTree * ctree, GList * UNUSED(node), gint UNUSED(column), gpointer UNUSED(user_data)) { GtkWidget *mailbox, *stat; GtkCTreeNode *n; GtkCList *clist; GtkWidget *appbar; gchar *text[3]; synopsis **syn; int x = 0, mboxcount; mboxview *m; n = gtk_ctree_node_nth (ctree, (&(ctree->clist))->focus_row); m = (mboxview *) gtk_ctree_node_get_row_data (ctree, n); if (m == NULL) { printf (_("Bad mbox (null)\n")); exit (-1); } stat = lookup_widget (gems, "appbar1"); mailbox = lookup_widget (gems, "mailbox"); appbar = lookup_widget (gems, "appbar1"); /*** TODO *** clear the mail things */ putmail (NULL); gnome_appbar_push (GNOME_APPBAR (stat), _("Reading synopsis")); while (gtk_events_pending ()) gtk_main_iteration (); syn = (synopsis **) db_read_synopsis (m->mailbox->id, m->status); gnome_appbar_pop (GNOME_APPBAR (stat)); gnome_appbar_push (GNOME_APPBAR (stat), _("Displaying mailbox")); while (gtk_events_pending ()) gtk_main_iteration (); clist = >K_CTREE (mailbox)->clist; gtk_clist_clear (clist); while (gtk_events_pending ()) gtk_main_iteration (); gtk_clist_freeze (clist); if(syn) { mboxcount = 0; while (syn[mboxcount] != NULL) mboxcount++; while (syn[x] != NULL) { GtkCTreeNode *n; text[0] = syn[x]->sender; text[1] = syn[x]->date; text[2] = syn[x]->subject; n = gtk_ctree_insert_node (GTK_CTREE (mailbox), NULL, NULL, text, 5, NULL, NULL, NULL, NULL, TRUE, TRUE); gtk_ctree_node_set_row_data (GTK_CTREE (mailbox), n, syn[x]); gnome_appbar_set_progress (GNOME_APPBAR (appbar), (float)x / (float)mboxcount); /* * pump the status bar */ if (gtk_events_pending ()) gtk_main_iteration (); x++; } free (syn); } gtk_clist_set_sort_column (clist, 1); gtk_clist_set_sort_type (clist, GTK_SORT_ASCENDING); gtk_clist_sort (clist); gtk_clist_thaw (clist); update_mboxlist (NULL); gnome_appbar_set_progress (GNOME_APPBAR (appbar), 0.0); gnome_appbar_pop (GNOME_APPBAR (stat)); /* * gtk_signal_handler_unblock(GTK_OBJECT(ctree), select_row); */ }
/* Insert a new node to the tree. The position is specified through the * parent-sibling notation, as explained in the introduction above. */ int clip_GTK_CTREEINSERTNODE(ClipMachine * cm) { C_widget *cctree = _fetch_cw_arg(cm); C_object *cparent = _fetch_cobject(cm,_clip_spar(cm,2)); C_object *csibling = _fetch_cobject(cm,_clip_spar(cm,3)); ClipVar *cvtext = _clip_spar(cm,4); guint8 spacing = _clip_parni(cm,5); C_widget *cclosed = _fetch_cwidget(cm,_clip_spar(cm,6)); C_widget *copened = _fetch_cwidget(cm,_clip_spar(cm,7)); gboolean is_leaf = _clip_parl(cm,8); gboolean expanded = _clip_parl(cm,9); GtkCTreeNode *new_node, *parent=NULL, *sibling=NULL; GdkPixmap *pxm_closed=NULL, *pxm_opened=NULL; GdkBitmap *mask_closed=NULL, *mask_opened=NULL; C_object *cnew_node; int i; gchar * * columns = NULL; int ncolumns; CHECKCWID(cctree,GTK_IS_CTREE); CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cparent,cparent->type==GTK_TYPE_CTREE_NODE); CHECKOPT2(3,MAP_t,NUMERIC_t); CHECKCOBJOPT(csibling,csibling->type==GTK_TYPE_CTREE_NODE); CHECKOPT2(4,ARRAY_t,CHARACTER_t); CHECKOPT(5,NUMERIC_t); CHECKOPT2(6,MAP_t,NUMERIC_t); CHECKCWIDOPT(cclosed,GTK_IS_PIXMAP); CHECKOPT2(7,MAP_t,NUMERIC_t); CHECKCWIDOPT(copened,GTK_IS_PIXMAP); CHECKOPT(8,LOGICAL_t); CHECKOPT(9,LOGICAL_t); if (cparent) parent = GTK_CTREE_NODE(cparent->object); if (csibling) sibling = GTK_CTREE_NODE(csibling->object); if (cclosed) { pxm_closed=GTK_PIXMAP(cclosed->widget)->pixmap; mask_closed=GTK_PIXMAP(cclosed->widget)->mask; } if (copened) { pxm_opened=GTK_PIXMAP(copened->widget)->pixmap; mask_opened=GTK_PIXMAP(copened->widget)->mask; } if (_clip_parinfo(cm,8)==UNDEF_t) is_leaf = TRUE; if (_clip_parinfo(cm,9)==UNDEF_t) expanded = FALSE; ncolumns = GTK_CLIST(cctree->widget)->columns; columns = (gchar**)calloc(sizeof(columns),ncolumns); for(i=0; i < ncolumns; i++ ) columns[i] = ""; if (cvtext->t.type==ARRAY_t) { ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext); for(i=0; i < acol->count; i++ ) if ( i < acol->count && acol->items[i].t.type == CHARACTER_t ) { columns[i] = acol->items[i].s.str.buf; LOCALE_TO_UTF(columns[i]); } } if (cvtext->t.type==CHARACTER_t) { columns[0] = _clip_parc(cm,2); LOCALE_TO_UTF(columns[0]); } new_node = gtk_ctree_insert_node(GTK_CTREE(cctree->widget), parent,sibling,columns,spacing,pxm_closed,mask_closed, pxm_opened,mask_opened,is_leaf,expanded); if (new_node) { cnew_node = _register_object(cm,new_node,GTK_TYPE_CTREE_NODE,NULL,NULL); if (cnew_node) _clip_mclone(cm,RETPTR(cm),&cnew_node->obj); gtk_ctree_node_set_row_data_full(GTK_CTREE(cctree->widget), new_node,cnew_node,(GtkDestroyNotify)destroy_c_object); } #ifdef OS_CYGWIN if (cvtext->t.type==ARRAY_t) { ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext); for(i=0; i < acol->count; i++ ) if ( i < acol->count && acol->items[i].t.type == CHARACTER_t ) FREE_TEXT(columns[i]); } if (cvtext->t.type==CHARACTER_t) FREE_TEXT(columns[0]); #endif if (columns) free(columns); return 0; err: return 1; }
GtkWidget * dirtree_new (GtkWidget * win, const gchar * start_path, gboolean check_dir, gboolean check_hlinks, gboolean show_dotfile, gint line_style, gint expander_style) { GtkWidget *widget; DirTree *dt; DirTreeNode *dt_node; GtkCTreeNode *node = NULL; char *root = "/", *rp, *tmp; widget = gtk_type_new (dirtree_get_type ()); #ifndef USE_GTK2 gtk_ctree_construct (GTK_CTREE (widget), 1, 0, NULL); #endif dt = DIRTREE (widget); dt->collapse = FALSE; dt->check_dir = check_dir; dt->check_hlinks = check_hlinks; dt->show_dotfile = show_dotfile; dt->expander_style = expander_style; dt->line_style = line_style; dt->check_events = TRUE; lock = FALSE; gtk_clist_set_column_auto_resize (GTK_CLIST (dt), 0, TRUE); gtk_clist_set_selection_mode (GTK_CLIST (dt), GTK_SELECTION_BROWSE); gtk_clist_set_row_height (GTK_CLIST (dt), 18); gtk_ctree_set_expander_style (GTK_CTREE (dt), expander_style); gtk_ctree_set_line_style (GTK_CTREE (dt), line_style); folder_pixmap = gdk_pixmap_create_from_xpm_d (win->window, &folder_mask, NULL, folder_xpm); ofolder_pixmap = gdk_pixmap_create_from_xpm_d (win->window, &ofolder_mask, NULL, folder_open_xpm); lfolder_pixmap = gdk_pixmap_create_from_xpm_d (win->window, &lfolder_mask, NULL, folder_link_xpm); lofolder_pixmap = gdk_pixmap_create_from_xpm_d (win->window, &lofolder_mask, NULL, folder_link_open_xpm); lckfolder_pixmap = gdk_pixmap_create_from_xpm_d (win->window, &lckfolder_mask, NULL, folder_lock_xpm); gofolder_pixmap = gdk_pixmap_create_from_xpm_d (win->window, &gofolder_mask, NULL, folder_go_xpm); upfolder_pixmap = gdk_pixmap_create_from_xpm_d (win->window, &upfolder_mask, NULL, folder_up_xpm); node = gtk_ctree_insert_node (GTK_CTREE (dt), NULL, NULL, &root, CTREE_SPACING, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, TRUE); dt_node = g_malloc0 (sizeof (DirTreeNode)); dt_node->path = g_strdup ("/"); dt_node->scanned = TRUE; gtk_ctree_node_set_row_data_full (GTK_CTREE (dt), node, dt_node, dirtree_destroy_tree); tree_expand_node (dt, node, FALSE); rp = g_strdup (start_path); tmp = strtok (rp, "/"); while (tmp) { node = dirtree_find_file (dt, node, tmp); if (!node) break; gtk_ctree_expand (GTK_CTREE (dt), node); gtk_ctree_select (GTK_CTREE (dt), node); GTK_CLIST (dt)->focus_row = GTK_CLIST (dt)->rows - g_list_length ((GList *) node); tmp = strtok (NULL, "/"); } g_free (rp); return widget; }