static void dirtree_collapse (GtkCTree * tree, GtkCTreeNode * node) { GtkCTreeNode *node_sel; DirTreeNode *parent_node; DirTreeNode *sel_node; gchar *ret = NULL; if (DIRTREE (tree)->collapse == FALSE) { node_sel = GTK_CLIST (tree)->selection->data; sel_node = gtk_ctree_node_get_row_data (tree, node_sel); parent_node = gtk_ctree_node_get_row_data (tree, node); ret = g_strdup (strstr (sel_node->path, parent_node->path)); if (ret != NULL) { GTK_CLIST (tree)->focus_row = GTK_CLIST (tree)->rows - g_list_length ((GList *) node); gtk_ctree_select (tree, node); } } if (parent_class->tree_collapse) (*parent_class->tree_collapse) (tree, node); }
static void ssl_manager_delete_cb(GtkWidget *widget, gpointer data) { SSLCertificate *cert; GList *rowlist; int val; rowlist = GTK_CLIST(manager.certlist)->selection; if (!rowlist) return; cert = gtk_ctree_node_get_row_data (GTK_CTREE(manager.certlist), GTK_CTREE_NODE(rowlist->data)); if (!cert) return; val = alertpanel(_("Delete certificate"), _("Do you really want to delete this certificate?"), _("Yes"), _("+No"), NULL); if (val != G_ALERTDEFAULT) return; ssl_certificate_delete_from_disk(cert); ssl_certificate_destroy(cert); gtk_ctree_remove_node(GTK_CTREE(manager.certlist), GTK_CTREE_NODE(rowlist->data)); }
void remove_file_transfer (gpointer data) { gftpui_common_curtrans_data * transdata; GtkCTreeNode * node; gftp_file * curfle; if (GTK_CLIST (dlwdw)->selection == NULL) { ftp_log (gftp_logging_error, NULL, _("There are no file transfers selected\n")); return; } node = GTK_CLIST (dlwdw)->selection->data; transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); if (transdata->curfle == NULL || transdata->curfle->data == NULL) return; curfle = transdata->curfle->data; gftpui_common_skip_file_transfer (transdata->transfer, curfle); gtk_ctree_node_set_text (GTK_CTREE (dlwdw), curfle->user_data, 1, _("Skipped")); }
void ShowPlayList( void ) { if ( PlayList ) gtkActive( PlayList ); else PlayList=create_PlayList(); if ( old_path && *old_path ) { char * currentdir = strdup( old_path ); char * tpath,* pos; GtkCTreeNode * node,* nextnode; gboolean leaf; tpath=strdup( "/" ); pos=strtok( currentdir,"/" ); node=gtk_ctree_find_by_row_data_custom( GTK_CTREE( CTDirTree ),NULL,"/",compare_func ); do { char * tpathnew = g_strconcat( tpath,pos,"/",NULL ); free( tpath ); tpath=tpathnew; nextnode=gtk_ctree_find_by_row_data_custom( GTK_CTREE( CTDirTree ),node,tpath,compare_func ); if ( !nextnode ) break; node=nextnode; pos=strtok( NULL,"/" ); gtk_ctree_get_node_info( GTK_CTREE( CTDirTree ),node,NULL,NULL,NULL,NULL,NULL,NULL,&leaf,NULL ); if ( !leaf && pos ) gtk_ctree_expand( GTK_CTREE( CTDirTree ),node ); else { DirNodeType * DirNode; gtk_ctree_select( GTK_CTREE( CTDirTree ),node ); DirNode=gtk_ctree_node_get_row_data( GTK_CTREE( CTDirTree ),node ); current_path=DirNode->path; scan_dir( DirNode->path ); if ( CLFileSelected ) free( CLFileSelected ); CLFileSelected=calloc( 1,NrOfEntrys * sizeof( int ) ); break; } } while( pos ); free( tpath ); free( currentdir ); } else gtk_ctree_select( GTK_CTREE( CTDirTree ),parent ); gtk_clist_freeze( GTK_CLIST( CLSelected ) ); gtk_clist_clear( GTK_CLIST( CLSelected ) ); if ( plList ) { plItem * next = plList; while ( next || next->next ) { char * text[1][3]; text[0][2]=""; text[0][0]=next->name; text[0][1]=next->path; gtk_clist_append( GTK_CLIST( CLSelected ),text[0] ); NrOfSelected++; if ( next->next ) next=next->next; else break; } CLListSelected=calloc( 1,NrOfSelected * sizeof( int ) ); } gtk_clist_thaw( GTK_CLIST( CLSelected ) ); gtk_widget_show( PlayList ); }
static void dirtree_expand (GtkCTree * tree, GtkCTreeNode * node) { GtkAdjustment *h_adjustment; gfloat row_align; DirTreeNode *dt_node; dt_node = gtk_ctree_node_get_row_data (tree, node); if (dt_node->scanned == FALSE) { tree_expand_node (DIRTREE (tree), node, FALSE); dt_node->scanned = TRUE; } if (parent_class->tree_expand) (*parent_class->tree_expand) (tree, node); h_adjustment = gtk_clist_get_hadjustment (GTK_CLIST (tree)); if (h_adjustment && h_adjustment->upper != 0.0) { row_align = (float) (tree->tree_indent * GTK_CTREE_ROW (node)->level) / h_adjustment->upper; gtk_ctree_node_moveto (tree, node, tree->tree_column, 0, row_align); } }
void mimeview_show_message(MimeView *mimeview, MimeInfo *mimeinfo, const gchar *file) { GtkCTree *ctree = GTK_CTREE(mimeview->ctree); GtkCTreeNode *node; mimeview_clear(mimeview); g_return_if_fail(file != NULL); g_return_if_fail(mimeinfo != NULL); mimeview->mimeinfo = mimeinfo; mimeview->file = g_strdup(file); gtk_signal_handler_block_by_func(GTK_OBJECT(ctree), mimeview_selected, mimeview); mimeview_set_multipart_tree(mimeview, mimeinfo, NULL); icon_list_create(mimeview, mimeinfo); gtk_signal_handler_unblock_by_func(GTK_OBJECT(ctree), mimeview_selected, mimeview); node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list); if (node) { gtk_ctree_select(ctree, node); icon_list_toggle_by_mime_info (mimeview, gtk_ctree_node_get_row_data(ctree, node)); gtkut_ctree_set_focus_row(ctree, node); } }
void dirtree_refresh_node (DirTree * dt, GtkCTreeNode * node) { DirTreeNode *dirnode = NULL; gint has_subdirs; gboolean expanded; dirnode = gtk_ctree_node_get_row_data (GTK_CTREE (dt), node); has_subdirs = tree_is_subdirs (dirnode->path, dt->show_dotfile); if (has_subdirs && GTK_CTREE_ROW (node)->expanded == 1) expanded = TRUE; else expanded = FALSE; if (has_subdirs) gtk_ctree_set_node_info (GTK_CTREE (dt), node, g_basename (dirnode->path), CTREE_SPACING, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, expanded); else gtk_ctree_set_node_info (GTK_CTREE (dt), node, g_basename (dirnode->path), CTREE_SPACING, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, TRUE, expanded); }
void move_transfer_down (gpointer data) { GList * firstentry, * secentry, * lastentry; gftpui_common_curtrans_data * transdata; GtkCTreeNode * node; if (GTK_CLIST (dlwdw)->selection == NULL) { ftp_log (gftp_logging_error, NULL, _("There are no file transfers selected\n")); return; } node = GTK_CLIST (dlwdw)->selection->data; transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); if (transdata->curfle == NULL) return; g_static_mutex_lock (&transdata->transfer->structmutex); if (transdata->curfle->next != NULL && (!transdata->transfer->started || (transdata->transfer->curfle != transdata->curfle && transdata->transfer->curfle != transdata->curfle->next))) { if (transdata->curfle->prev == NULL) { firstentry = transdata->curfle->next; lastentry = transdata->curfle->next->next; transdata->transfer->files = firstentry; transdata->transfer->files->prev = NULL; transdata->transfer->files->next = transdata->curfle; transdata->curfle->prev = transdata->transfer->files; transdata->curfle->next = lastentry; if (lastentry != NULL) lastentry->prev = transdata->curfle; } else { firstentry = transdata->curfle->prev; secentry = transdata->curfle->next; lastentry = transdata->curfle->next->next; firstentry->next = secentry; secentry->prev = firstentry; secentry->next = transdata->curfle; transdata->curfle->prev = secentry; transdata->curfle->next = lastentry; if (lastentry != NULL) lastentry->prev = transdata->curfle; } gtk_ctree_move (GTK_CTREE (dlwdw), ((gftp_file *) transdata->curfle->data)->user_data, transdata->transfer->user_data, transdata->curfle->next != NULL ? ((gftp_file *) transdata->curfle->next->data)->user_data: NULL); } g_static_mutex_unlock (&transdata->transfer->structmutex); }
/* Callback for expand of a directory tree entry */ static void dirtree_expand_cb( GtkWidget *ctree_w, GtkCTreeNode *ctnode ) { GNode *dnode; if (globals.fsv_mode == FSV_SPLASH) return; dnode = (GNode *)gtk_ctree_node_get_row_data( GTK_CTREE(ctree_w), ctnode ); colexp( dnode, COLEXP_EXPAND ); }
/* Callback for collapse of a directory tree entry */ static void dirtree_collapse_cb( GtkWidget *ctree_w, GtkCTreeNode *ctnode ) { GNode *dnode; if (globals.fsv_mode == FSV_SPLASH) return; dnode = (GNode *)gtk_ctree_node_get_row_data( GTK_CTREE(ctree_w), ctnode ); colexp( dnode, COLEXP_COLLAPSE_RECURSIVE ); }
static void plCTRow(GtkWidget * widget, gint row, gint column, GdkEventButton * bevent, gpointer data) { DirNodeType * DirNode; GtkCTreeNode * node; node=gtk_ctree_node_nth( GTK_CTREE( widget ),row ); DirNode=gtk_ctree_node_get_row_data( GTK_CTREE( widget ),node ); current_path=DirNode->path; gtk_ctree_expand( GTK_CTREE( widget ),node ); scan_dir( DirNode->path ); if ( CLFileSelected ) free( CLFileSelected ); CLFileSelected=calloc( 1,NrOfEntrys * sizeof( int ) ); }
int putmail (GtkWidget * widget) { synopsis *s; GtkCTreeNode *n; GtkWidget *from, *subj, *date, *recipt, *body; char *shtuff; if (widget != NULL) { n = gtk_ctree_node_nth (GTK_CTREE (widget), (&(GTK_CTREE (widget)->clist))->focus_row); s = (synopsis *) gtk_ctree_node_get_row_data (GTK_CTREE (widget), n); if (s) shtuff = (char *) db_read_body (s->id); else { printf ("synopsis for row %d is NULL!\n", (&(GTK_CTREE (widget)->clist))->focus_row); return FALSE; } } else { s = (synopsis *) malloc (sizeof (synopsis)); s->sender = strdup (" "); s->subject = strdup (" "); s->date = strdup (" "); s->sender = strdup (" "); shtuff = strdup (" "); } from = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (gems), "entry1"); date = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (gems), "entry2"); subj = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (gems), "entry3"); recipt = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (gems), "entry4"); body = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (gems), "text1"); gtk_entry_set_text (GTK_ENTRY (from), s->sender); gtk_entry_set_text (GTK_ENTRY (subj), s->subject); gtk_entry_set_text (GTK_ENTRY (date), s->date); gtk_text_freeze (GTK_TEXT (body)); gtk_text_set_point (GTK_TEXT (body), 0); gtk_text_forward_delete (GTK_TEXT (body), gtk_text_get_length (GTK_TEXT (body))); gtk_text_insert (GTK_TEXT (body), NULL, NULL, NULL, shtuff, -1); gtk_text_thaw (GTK_TEXT (body)); if (widget == NULL) { free (s); free (shtuff); } return TRUE; }
void on_toolbar_reply_clicked (GtkButton * UNUSED(button), gpointer UNUSED(user_data)) { synopsis *s; GtkCTreeNode *n; GtkWidget *from, *subj, *date, *recipt, *body, *comp, *widget; char *shtuff, buf[1024]; if ((widget = lookup_widget (gems, "mailbox")) == NULL) return; comp = create_compose (); from = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry1"); /* to = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry5"); */ date = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry2"); subj = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry6"); recipt = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry4"); body = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "text2"); n = gtk_ctree_node_nth (GTK_CTREE (widget), (&(GTK_CTREE (widget)->clist))->focus_row); s = (synopsis *) gtk_ctree_node_get_row_data (GTK_CTREE (widget), n); shtuff = replyify (s, (char *)db_read_body (s->id)); gtk_entry_set_text (GTK_ENTRY (from), s->sender); /* * if(!strncasecmp("re: ", s->subject, 4)) */ if (tolower (s->subject[0]) == 'r' && tolower (s->subject[1]) == 'e' && s->subject[2] == ':' && s->subject[3] == ' ') sprintf (buf, "%s", s->subject); else sprintf (buf, "Re: %s", s->subject); gtk_entry_set_text (GTK_ENTRY (subj), buf); gtk_entry_set_text (GTK_ENTRY (date), s->date); gtk_text_freeze (GTK_TEXT (body)); gtk_text_set_point (GTK_TEXT (body), 0); gtk_text_forward_delete (GTK_TEXT (body), gtk_text_get_length (GTK_TEXT (body))); gtk_text_insert (GTK_TEXT (body), NULL, NULL, NULL, shtuff, -1); gtk_text_thaw (GTK_TEXT (body)); if (widget == NULL) { free (s); free (shtuff); } gtk_text_set_editable (GTK_TEXT (body), TRUE); gtk_widget_show (comp); return; }
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 ); }
/** * Request host browsing for the selected entries. */ void search_gui_browse_selected(void) { search_t *search; GtkCTree *ctree; GList *selected; GList *l;; search = search_gui_get_current_search(); g_assert(search != NULL); ctree = GTK_CTREE(search->tree); selected = GTK_CLIST(ctree)->selection; if (selected == NULL) { statusbar_gui_message(15, "*** No search result selected! ***"); return; } search_gui_option_menu_searches_freeze(); for (l = selected; l != NULL; l = g_list_next(l)) { GtkCTreeNode *node = l->data; gui_record_t *grc; results_set_t *rs; record_t *rc; guint32 flags = 0; if (node == NULL) break; grc = gtk_ctree_node_get_row_data(ctree, node); rc = grc->shared_record; if (!rc) continue; rs = rc->results_set; flags |= 0 != (rs->status & ST_FIREWALL) ? SOCK_F_PUSH : 0; flags |= 0 != (rs->status & ST_TLS) ? SOCK_F_TLS : 0; flags |= ((rs->status & ST_G2) && T_GTKG != rs->vendor) ? SOCK_F_G2 : 0; (void) search_gui_new_browse_host( rs->hostname, rs->addr, rs->port, rs->guid, rs->proxies, flags); } search_gui_option_menu_searches_thaw(); }
void on_delete1_activate (GtkMenuItem * UNUSED(menuitem), gpointer UNUSED(user_data)) { GtkWidget *w; GtkCTree *ctree; GtkCTreeNode *n; mboxs *m; ctree = GTK_CTREE (lookup_widget (gems, "mailboxlist")); n = gtk_ctree_node_nth (ctree, (&(ctree->clist))->focus_row); m = (mboxs *) gtk_ctree_node_get_row_data (ctree, n); w = create_delete_mbox (); gtk_widget_show (w); gtk_object_set_user_data (GTK_OBJECT (w), m); }
void stop_transfer (gpointer data) { gftpui_common_curtrans_data * transdata; GtkCTreeNode * node; if (GTK_CLIST (dlwdw)->selection == NULL) { ftp_log (gftp_logging_error, NULL, _("There are no file transfers selected\n")); return; } node = GTK_CLIST (dlwdw)->selection->data; transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); gftpui_common_cancel_file_transfer (transdata->transfer); }
/* * Get a child node according to its name. */ static GtkCTreeNode* gdisp_getChildAccordingToItsName ( Kernel_T *kernel, GtkCTreeNode *parentNode, gchar *requestedChildName ) { GtkWidget *cTree = (GtkWidget*)NULL; GtkCTreeRow *parentNodeRow = (GtkCTreeRow*)NULL; GtkCTreeNode *parentChild = (GtkCTreeNode*)NULL; GtkCTreeNode *requestedChild = (GtkCTreeNode*)NULL; gchar *childName = (gchar*)NULL; /* * Deduce node row from node. */ cTree = kernel->widgets.sampledSymbolHTree; parentNodeRow = GTK_CTREE_ROW(parentNode); /* * Loop over all children. */ parentChild = parentNodeRow->children; while (requestedChild == (GtkCTreeNode*)NULL && parentChild != (GtkCTreeNode*)NULL ) { childName = (gchar*)gtk_ctree_node_get_row_data(GTK_CTREE(cTree), parentChild); if (childName != (gchar*)NULL && strcmp(childName,requestedChildName) == 0) { requestedChild = parentChild; } else { parentChild = GTK_CTREE_NODE_NEXT(parentChild); } } return requestedChild; }
record_t * search_gui_get_record(GtkCTree *ctree, GtkCTreeNode *node) { gui_record_t *grc; /* * Rows with NULL data can appear when inserting new rows * because the selection is resynced and the row data cannot * be set until insertion and therefore also selection syncing * is done. * -- Richard, 20/06/2002 * * Can this really happen??? * -- Richard, 18/04/2004 */ grc = node ? gtk_ctree_node_get_row_data(ctree, node) : NULL; return grc ? grc->shared_record : NULL; }
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; } }
static void select_row_cb(GtkWidget * widget, gint row, gint column, GdkEventButton * bevent, gpointer data) { DirNode *dirnode; GtkCTreeNode *node; void (*handler) (gchar *); if (bevent) { if (bevent->type == GDK_2BUTTON_PRESS) { node = gtk_ctree_node_nth(GTK_CTREE(widget), row); dirnode = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node); handler = (void (*)(gchar *)) gtk_object_get_user_data(GTK_OBJECT(widget)); if (handler) handler(dirnode->path); } } }
void start_transfer (gpointer data) { gftpui_common_curtrans_data * transdata; GtkCTreeNode * node; if (GTK_CLIST (dlwdw)->selection == NULL) { ftp_log (gftp_logging_error, NULL, _("There are no file transfers selected\n")); return; } node = GTK_CLIST (dlwdw)->selection->data; transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw), node); g_static_mutex_lock (&transdata->transfer->structmutex); if (!transdata->transfer->started) create_transfer (transdata->transfer); g_static_mutex_unlock (&transdata->transfer->structmutex); }
/** * Given a GList of GtkCTreeNodes, return a new list pointing to the shared * record contained by the row data. * List will have to be freed later on. */ GSList * search_cb_collect_ctree_data(GtkCTree *ctree, GList *node_list, GCompareFunc cfn) { GSList *data_list = NULL; gui_record_t *grc; record_t *rc; for (/* empty */; node_list != NULL; node_list = g_list_next(node_list)) { if (node_list->data != NULL) { grc = gtk_ctree_node_get_row_data(ctree, node_list->data); rc = grc->shared_record; if (!cfn || NULL == g_slist_find_custom(data_list, rc, cfn)) data_list = g_slist_prepend(data_list, rc); } } return g_slist_reverse(data_list); }
static void ssl_manager_view_cb(GtkWidget *widget, gpointer data) { SSLCertificate *cert; GList *rowlist; rowlist = GTK_CLIST(manager.certlist)->selection; if (!rowlist) return; cert = gtk_ctree_node_get_row_data (GTK_CTREE(manager.certlist), GTK_CTREE_NODE(rowlist->data)); if (!cert) return; sslcertwindow_show_cert(cert); }
static void mime_toggle_button_cb (GtkWidget *button, MimeView *mimeview) { gtk_widget_ref(button); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) { gtk_arrow_set(GTK_ARROW(GTK_BIN(button)->child), GTK_ARROW_RIGHT, GTK_SHADOW_NONE); gtk_widget_hide(mimeview->icon_mainbox); gtk_widget_show(mimeview->ctree_mainbox); gtk_paned_set_position(GTK_PANED(mimeview->paned), mimeview->oldsize); gtkut_container_remove(GTK_CONTAINER(mimeview->icon_mainbox), button); gtk_box_pack_end(GTK_BOX(mimeview->ctree_mainbox), button, FALSE, FALSE, 0); gtk_paned_set_gutter_size(GTK_PANED(mimeview->paned), 6); } else { gtk_arrow_set(GTK_ARROW(GTK_BIN(button)->child), GTK_ARROW_LEFT, GTK_SHADOW_NONE); mimeview->oldsize = mimeview->ctree_mainbox->allocation.height; gtk_widget_hide(mimeview->ctree_mainbox); gtk_widget_show(mimeview->icon_mainbox); gtk_paned_set_position(GTK_PANED(mimeview->paned), 0); gtkut_container_remove(GTK_CONTAINER(mimeview->ctree_mainbox), button); gtk_box_pack_start(GTK_BOX(mimeview->icon_mainbox), button, FALSE, FALSE, 0); gtk_box_reorder_child(GTK_BOX(button->parent), button, 0); if (mimeview->opened) icon_list_toggle_by_mime_info (mimeview, gtk_ctree_node_get_row_data(GTK_CTREE(mimeview->ctree), mimeview->opened)); gtk_paned_set_gutter_size(GTK_PANED(mimeview->paned), 0); } gtk_widget_grab_focus(button); gtk_widget_unref(button); }
static void dirtree_select_row (GtkCTree * tree, GtkCTreeNode * node, gint column) { DirTree *dt; DirTreeNode *dt_node = NULL; if (parent_class->tree_select_row) (*parent_class->tree_select_row) (tree, node, column); if (lock) return; dt = DIRTREE (tree); dt_node = gtk_ctree_node_get_row_data (tree, node); if (dt_node != NULL) chdir (dt_node->path); gtk_signal_emit_by_name (GTK_OBJECT (dt), "select_file", g_get_current_dir ()); }
static void mimeview_selected(GtkCTree *ctree, GtkCTreeNode *node, gint column, MimeView *mimeview) { MimeInfo *partinfo; if (mimeview->opened == node) return; mimeview->opened = node; gtk_ctree_node_moveto(ctree, node, -1, 0.5, 0); partinfo = gtk_ctree_node_get_row_data(ctree, node); if (!partinfo) return; /* ungrab the mouse event */ if (GTK_WIDGET_HAS_GRAB(ctree)) { gtk_grab_remove(GTK_WIDGET(ctree)); if (gdk_pointer_is_grabbed()) gdk_pointer_ungrab(GDK_CURRENT_TIME); } mimeview->textview->default_text = FALSE; update_signature_info(mimeview, partinfo); if (!mimeview_show_part(mimeview, partinfo)) { switch (partinfo->type) { case MIMETYPE_TEXT: case MIMETYPE_MESSAGE: case MIMETYPE_MULTIPART: mimeview_show_message_part(mimeview, partinfo); break; default: mimeview->textview->default_text = TRUE; mimeview_change_view_type(mimeview, MIMEVIEW_TEXT); textview_show_mime_part(mimeview->textview, partinfo); break; } } }
static void ok_clicked(GtkWidget * widget, GtkWidget * tree) { GtkCTreeNode *node; DirNode *dirnode; GList *list_node; GtkWidget *window; void (*handler) (gchar *); window = gtk_object_get_user_data(GTK_OBJECT(widget)); gtk_widget_hide(window); list_node = GTK_CLIST(tree)->selection; while (list_node) { node = list_node->data; dirnode = gtk_ctree_node_get_row_data(GTK_CTREE(tree), node); handler = (void (*)(gchar *)) gtk_object_get_user_data(GTK_OBJECT(tree)); if (handler) handler(dirnode->path); list_node = g_list_next(list_node); } gtk_widget_destroy(window); }
static void cb_decrypt(GtkWidget *w, gpointer p) { GtkWidget *pass_entry; GtkWidget *warn_w; FILE *pgpin; FILE *pgpout; FILE *pgperr; static gchar sys_buf[] = "pgpv -qzd +batchmode +force -o - %s"; gchar tmpbuf[1024]; gchar *tmpfname; gchar *tmpcmd; note_data *note; pid_t pgp_pid; gint fd; g_return_if_fail(p != NULL); g_return_if_fail(GNOME_IS_DIALOG(p)); if (selected_node == NULL) { warn_w = gnome_warning_dialog_parented( _("Select a note first!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } ask_commit_changes(); note = (note_data *) gtk_ctree_node_get_row_data( GTK_CTREE(note_tree), GTK_CTREE_NODE(selected_node)); if (!note->text || !strlen(note->text)) { warn_w = gnome_warning_dialog_parented(_("Nothing to decrypt!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } tmpfname = tmpnam(NULL); if (tmpfname == NULL) { warn_w = gnome_warning_dialog_parented(_("Can't create tmp filename!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } fd = safe_open(tmpfname, O_CREAT | O_EXCL | O_WRONLY); if (fd == -1) { warn_w = gnome_warning_dialog_parented(_("Can't open tmp file!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } write(fd, note->text, strlen(note->text)); close(fd); tmpcmd = g_strdup_printf(sys_buf, tmpfname); pass_entry = gtk_object_get_user_data(GTK_OBJECT(p)); setenv("PGPPASSFD", "0", 1); pgp_pid = run_pgp(tmpcmd, &pgpin, &pgpout, &pgperr); if (pgp_pid == -1) { warn_w = gnome_warning_dialog_parented(_("Error while running pgp!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); unsetenv("PGPPASSFD"); unlink(tmpfname); g_free(tmpcmd); return; } if (pgpin && pgpout) { fprintf(pgpin, "%s\n", gtk_entry_get_text(GTK_ENTRY(pass_entry))); fwrite(note->text, sizeof (gchar), strlen(note->text), pgpin); fclose(pgpin); gtk_text_freeze(GTK_TEXT(text_entry)); gtk_editable_delete_text(GTK_EDITABLE(text_entry), 0, gtk_text_get_length(GTK_TEXT(text_entry))); do { fgets(tmpbuf, sizeof (tmpbuf), pgpout); if (!feof(pgpout)) { gtk_text_insert(GTK_TEXT(text_entry), NULL, NULL, NULL, tmpbuf, strlen(tmpbuf)); } } while (!feof(pgpout)); gtk_text_thaw(GTK_TEXT(text_entry)); fclose(pgpout); fclose(pgperr); if ((gtk_text_get_length(GTK_TEXT(text_entry)) == 0) && note->text) { warn_w = gnome_warning_dialog_parented(_("Pgp didn't return any\ text. Maybe your're using the wrong password?"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); gtk_text_insert(GTK_TEXT(text_entry), NULL, NULL, NULL, note->text, strlen(note->text)); }
GtkWidget * gw_notebook_managment_create ( GtkWindow * window) { GtkWidget *vb_tabbed_pane = NULL; GtkWidget *hb_control; GtkWidget *frm_new_disk_control; GtkWidget *vb_new_disk_control; GtkWidget *hb_disk_selection; GtkWidget *lbl_disk_selection; GtkWidget *cmb_disk_selection; GtkWidget *entry_cmb_disk_selection; GtkWidget *hseparator; GtkWidget *hb_number_archive; GtkWidget *lbl_number_archive; GtkWidget *entry_number_archive; GtkWidget *hb_disk_name; GtkWidget *lbl_disk_name; GtkWidget *entry_disk_name; GtkHBox *cmb_categories; GtkWidget *hb_device_file; GtkWidget *lbl_device_file; GtkWidget *hb_device_type; GtkWidget *lbl_device_type; #ifdef HAVE_MOUNT_SYSTEM GtkWidget *hb_device_ismounted; GtkWidget *lbl_device_ismounted; #endif GtkWidget *hb_device_volume_name; GtkWidget *lbl_device_volume_name; GtkWidget *hb_device_serial_number; GtkWidget *lbl_device_serial_number; GtkWidget *hb_device_capacity; GtkWidget *lbl_device_capacity; GtkWidget *hb_device_free_space; GtkWidget *lbl_device_free_space; GtkWidget *frm_options; GtkWidget *vb_options; GtkWidget *chk_display_device_info; #ifdef HAVE_MOUNT_SYSTEM GtkWidget *chk_automount_device; #endif GtkWidget *chk_explore_tree_structure; GtkWidget *chk_explore_archive_files; GtkWidget *chk_auto_eject_device; GtkWidget *chk_category_recursively; GtkWidget *chk_auto_make_description; GtkWidget *chk_use_disk_label; GtkWidget *chk_use_pattern; GtkWidget *bt_start_device_scan; GtkTooltips *tooltips_group; GtkCTree *tree = NULL; GtkCTreeNode *root = NULL; gchar *text_utf8 = NULL; #ifdef GW_DEBUG_GUI_COMPONENT g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__); #endif if ( window != NULL ) { tree = gw_gui_manager_main_interface_get_tree ( ); root = gw_gui_manager_main_interface_get_tree_root ( ); /* Inits tooltips group */ tooltips_group = gtk_tooltips_new ( ); /* Vertical box of the managment tabbed pane. */ vb_tabbed_pane = gtk_vbox_new ( FALSE, 0); /* Horizontal box for controls (text field, checks buttons, ...). */ hb_control = gtk_hbox_new ( TRUE, 0); gtk_box_pack_start ( GTK_BOX ( vb_tabbed_pane), hb_control, TRUE, TRUE, 0); /* Frame of new disk control */ g_strdup_to_gtk_text ( _( "New disk"), text_utf8); frm_new_disk_control = gtk_frame_new ( text_utf8); g_free ( text_utf8); gtk_container_set_border_width ( GTK_CONTAINER ( frm_new_disk_control), 10); gtk_box_pack_start ( GTK_BOX ( hb_control), frm_new_disk_control, FALSE, TRUE, 0); /* Vertical box for new disk control */ vb_new_disk_control = gtk_vbox_new ( FALSE, 0); gtk_container_add ( GTK_CONTAINER ( frm_new_disk_control), vb_new_disk_control); /* Horizontal box for media selection */ hb_disk_selection = gtk_hbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_disk_selection), 10); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_disk_selection, TRUE, TRUE, 0); g_strdup_to_gtk_text ( _( "Select the media that will be added as a disk to your catalog."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_disk_selection, text_utf8, NULL); g_free ( text_utf8); /* Label for media selection */ g_strdup_to_gtk_text ( _( "Select media : "), text_utf8); lbl_disk_selection = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_box_pack_start ( GTK_BOX ( hb_disk_selection), lbl_disk_selection, FALSE, FALSE, 0); /* ComboBox to select media */ cmb_disk_selection = gtk_combo_new ( ); gtk_widget_ref ( cmb_disk_selection); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_COMBO_BOX_DEVICE, cmb_disk_selection, (GtkDestroyNotify) gtk_widget_unref); gtk_combo_set_use_arrows_always ( GTK_COMBO ( cmb_disk_selection), TRUE); gtk_entry_set_editable ( GTK_ENTRY ( GTK_COMBO ( cmb_disk_selection)->entry), FALSE); /* Loads the list of devices */ gw_notebook_managment_load_device_list ( window); /* To fix : when user click on combo's button, the first item of the list is selected automaticaly. This emits the "changed" event!! */ gtk_signal_connect_after ( GTK_OBJECT ( GTK_ENTRY ( GTK_COMBO ( cmb_disk_selection)->entry)), "changed", GTK_SIGNAL_FUNC ( gw_notebook_managment_select_device), GTK_WINDOW ( window)); gtk_box_pack_start ( GTK_BOX ( hb_disk_selection), cmb_disk_selection, TRUE, TRUE, 0); /* Entry of ComboBox to select disk */ entry_cmb_disk_selection = GTK_COMBO ( cmb_disk_selection)->entry; gtk_widget_ref ( entry_cmb_disk_selection); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_COMBO_BOX_ENTRY_DEVICE_DIR, entry_cmb_disk_selection, (GtkDestroyNotify) gtk_widget_unref); /* Horizontal separator */ hseparator = gtk_hseparator_new ( ); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hseparator, TRUE, TRUE, 0); /* Horizontal box for number archive */ hb_number_archive = gtk_hbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_number_archive), 10); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_number_archive, TRUE, TRUE, 0); g_strdup_to_gtk_text ( _( "Enter the number of the new disk. This number can help you with the history of your catalog."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_number_archive, text_utf8, NULL); g_free ( text_utf8); /* Label for number archive */ g_strdup_to_gtk_text ( _( "Archive N# : "), text_utf8); lbl_number_archive = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_box_pack_start ( GTK_BOX ( hb_number_archive), lbl_number_archive, FALSE, FALSE, 0); /* Entry for number archive */ entry_number_archive = gtk_entry_new ( ); gtk_widget_ref ( entry_number_archive); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_ENTRY_DEVICE_NUMBER_ARCHIVE, entry_number_archive, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_number_archive), entry_number_archive, TRUE, TRUE, 0); /* Horizontal box for disk name */ hb_disk_name = gtk_hbox_new ( FALSE, 0); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_disk_name, TRUE, TRUE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_disk_name), 10); g_strdup_to_gtk_text ( _( "Enter the name of the new disk to identify it in your catalog."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_disk_name, text_utf8, NULL); g_free ( text_utf8); /* Label for disk name */ g_strdup_to_gtk_text ( _( "Name : "), text_utf8); lbl_disk_name = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_box_pack_start ( GTK_BOX ( hb_disk_name), lbl_disk_name, FALSE, FALSE, 0); /* Entry for disk name */ entry_disk_name = gtk_entry_new ( ); gtk_widget_ref ( entry_disk_name); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_ENTRY_DEVICE_NAME, entry_disk_name, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_disk_name), entry_disk_name, TRUE, TRUE, 0); gtk_signal_connect ( GTK_OBJECT ( entry_disk_name), "activate", GTK_SIGNAL_FUNC ( gw_notebook_managment_scan_click), window); /* Horizontal separator */ hseparator = gtk_hseparator_new ( ); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hseparator, TRUE, TRUE, 0); /* ComboBox for category selection */ /* It's not mandatory to encode to UTF-8 because gw_combo_box_categories_create() encodes itself. */ cmb_categories = gw_combo_box_categories_create ( window, _( "Category : "), gtk_ctree_node_get_row_data ( tree, root)); gtk_widget_ref ( GTK_WIDGET ( cmb_categories)); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_COMBO_BOX_CATEGORY, GTK_WIDGET ( cmb_categories), (GtkDestroyNotify) gtk_widget_unref); gw_combo_box_categories_load ( cmb_categories); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), GTK_WIDGET ( cmb_categories), TRUE, TRUE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( cmb_categories), 10); g_strdup_to_gtk_text ( _( "Select the category to apply to the disk which will be added (even if the option is selected)."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, GTK_WIDGET ( cmb_categories), text_utf8, NULL); g_free ( text_utf8); /* Horizontal separator */ hseparator = gtk_hseparator_new ( ); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hseparator, TRUE, TRUE, 0); /* Horizontal box for device file information */ hb_device_file = gtk_hbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_file), 5); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_file, TRUE, TRUE, 0); g_strdup_to_gtk_text ( _( "Give the device file of the selected media."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_device_file, text_utf8, NULL); g_free ( text_utf8); /* Device file information label */ g_strdup_to_gtk_text ( _( "Info : "), text_utf8); lbl_device_file = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( lbl_device_file); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_INFO, lbl_device_file, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_device_file), lbl_device_file, FALSE, FALSE, 0); /* Horizontal box for device type information */ hb_device_type = gtk_hbox_new ( FALSE, 0); gtk_widget_show ( hb_device_type); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_type, TRUE, TRUE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_type), 5); g_strdup_to_gtk_text ( _( "Give the type of the selected media (ex : ext2, ext3, vfat, ntfs, ...)."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_device_type, text_utf8, NULL); g_free ( text_utf8); /* Device type information label */ g_strdup_to_gtk_text ( _( "Type : "), text_utf8); lbl_device_type = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( lbl_device_type); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_TYPE, lbl_device_type, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_device_type), lbl_device_type, FALSE, FALSE, 0); #ifdef HAVE_MOUNT_SYSTEM /* Horizontal box for media mount state information */ hb_device_ismounted = gtk_hbox_new ( FALSE, 0); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_ismounted, TRUE, TRUE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_ismounted), 5); g_strdup_to_gtk_text ( _( "Display if the selected media is mounted or no."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_device_ismounted, text_utf8, NULL); g_free ( text_utf8); /* Media mount state information label */ g_strdup_to_gtk_text ( _( "Mounted : "), text_utf8); lbl_device_ismounted = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( lbl_device_ismounted); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_MOUNTED, lbl_device_ismounted, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_device_ismounted), lbl_device_ismounted, FALSE, FALSE, 0); #endif /* Horizontal box for media volume name information */ hb_device_volume_name = gtk_hbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_volume_name), 5); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_volume_name, TRUE, TRUE, 0); g_strdup_to_gtk_text ( _( "Give the volume name of the selected media (only if is mounted)."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_device_volume_name, text_utf8, NULL); g_free ( text_utf8); /* Media volume information label */ g_strdup_to_gtk_text ( _( "Volume : "), text_utf8); lbl_device_volume_name = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( lbl_device_volume_name); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_VOLUME, lbl_device_volume_name, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_device_volume_name), lbl_device_volume_name, FALSE, FALSE, 0); /* Horizontal box for media serial number information */ hb_device_serial_number = gtk_hbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_serial_number), 5); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_serial_number, TRUE, TRUE, 0); g_strdup_to_gtk_text ( _( "Give the serial number of the selected media (only if is mounted). This number is a manufacture number."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_device_serial_number, text_utf8, NULL); g_free ( text_utf8); /* Media serial number information label */ g_strdup_to_gtk_text ( _( "Serial N# : "), text_utf8); lbl_device_serial_number = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( lbl_device_serial_number); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_SERIAL_NUMBER, lbl_device_serial_number, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_device_serial_number), lbl_device_serial_number, FALSE, FALSE, 0); /* Horizontal box for media capacity information */ hb_device_capacity = gtk_hbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_capacity), 5); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_capacity, TRUE, TRUE, 0); g_strdup_to_gtk_text ( _( "Give the full space of the selected media (only if is mounted)."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_device_capacity, text_utf8, NULL); g_free ( text_utf8); /* Media capacity information label */ g_strdup_to_gtk_text ( _( "Capacity : "), text_utf8); lbl_device_capacity = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( lbl_device_capacity); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_CAPACITY, lbl_device_capacity, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_device_capacity), lbl_device_capacity, FALSE, FALSE, 0); /* Horizontal box for media free space information */ hb_device_free_space = gtk_hbox_new ( FALSE, 0); gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_free_space), 5); gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_free_space, TRUE, TRUE, 0); g_strdup_to_gtk_text ( _( "Give the free space of the selected media (only if is mounted)."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, hb_device_free_space, text_utf8, NULL); g_free ( text_utf8); /* Media free space information label */ g_strdup_to_gtk_text ( _( "Free space : "), text_utf8); lbl_device_free_space = gtk_label_new ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( lbl_device_free_space); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_FREE_SPACE, lbl_device_free_space, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hb_device_free_space), lbl_device_free_space, FALSE, FALSE, 0); /* Frame for scan options */ g_strdup_to_gtk_text ( _( "Options"), text_utf8); frm_options = gtk_frame_new ( text_utf8); g_free ( text_utf8); gtk_container_set_border_width ( GTK_CONTAINER ( frm_options), 10); gtk_box_pack_start ( GTK_BOX ( hb_control), frm_options, TRUE, TRUE, 0); /* Vertical box of the frame options */ vb_options = gtk_vbox_new ( FALSE, 0); gtk_container_add ( GTK_CONTAINER ( frm_options), vb_options); /* Check button for the displaying of media information */ g_strdup_to_gtk_text ( _( "Display info"), text_utf8); chk_display_device_info = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_display_device_info); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_DISPLAY_INFO, chk_display_device_info, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_display_device_info), "clicked", GTK_SIGNAL_FUNC ( gw_notebook_managment_refresh_info), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_display_device_info), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_display_device_info, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "Display information about the selected media, such as path, capacity, free space, label,..."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_display_device_info, text_utf8, NULL); g_free ( text_utf8); #ifdef HAVE_MOUNT_SYSTEM /* Check button for the automount */ g_strdup_to_gtk_text ( _("Automount"), text_utf8); chk_automount_device = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_automount_device); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_AUTO_MOUNT, chk_automount_device, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_automount_device), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_automount_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_automount_device), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_automount_device, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "Mount the media if it isn't already mounted. And unmount after scanning the media, even if it was mounted before the scan."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_automount_device, text_utf8, NULL); g_free ( text_utf8); #endif /* Check button for the exploring of tree structure */ g_strdup_to_gtk_text ( _( "Explore tree structure of the media."), text_utf8); chk_explore_tree_structure = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_explore_tree_structure); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_EXPLORE_TREE_STRUCTURE, chk_explore_tree_structure, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_explore_tree_structure), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_explore_tree_structure_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_explore_tree_structure), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_explore_tree_structure, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "Keep this option selected to scan all folders and files informations."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_explore_tree_structure, text_utf8, NULL); g_free ( text_utf8); /* Check button for the exploring of archive files */ g_strdup_to_gtk_text ( _( "Explore archive files (.tar, .gz, .zip, ...)"), text_utf8); chk_explore_archive_files = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_explore_archive_files); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_EXPLORE_ARCHIVE, chk_explore_archive_files, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_explore_archive_files), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_explore_archive_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_explore_archive_files), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_explore_archive_files, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "Not yet implemented!!\nExplore archives as if they were directories. Archives are tarred or gzipped files."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_explore_archive_files, text_utf8, NULL); g_free ( text_utf8); /* Check button for the auto eject */ g_strdup_to_gtk_text ( _( "Eject media if possible"), text_utf8); chk_auto_eject_device = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_auto_eject_device); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_EJECT, chk_auto_eject_device, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_auto_eject_device), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_eject_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_auto_eject_device), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_auto_eject_device, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "Eject the media if possible (CD-ROM...), even if the tray was closed. This is possible only if automount is enabled!!"), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_auto_eject_device, text_utf8, NULL); g_free ( text_utf8); /* Check button for setting category recursively */ g_strdup_to_gtk_text ( _( "Sets category recursive"), text_utf8); chk_category_recursively = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_category_recursively); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_CATEGORY_RECURSIVE, chk_category_recursively, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_category_recursively), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_category_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_category_recursively), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_category_recursively, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "Apply selected category to all items in the disk (disk, folders and files)."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_category_recursively, text_utf8, NULL); g_free ( text_utf8); /* Check button for the auto make description */ g_strdup_to_gtk_text ( _( "Auto make description"), text_utf8); chk_auto_make_description = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_auto_make_description); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_MAKE_DESCRIPTION, chk_auto_make_description, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_auto_make_description), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_description_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_auto_make_description), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_auto_make_description, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "Make auto description of file (file format description, image size for xmp or jpg, etc...)."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_auto_make_description, text_utf8, NULL); g_free ( text_utf8); /* Check button for the using a pattern to generate disk name */ g_strdup_to_gtk_text ( _( "Use an advanced pattern to generate disk name"), text_utf8); chk_use_pattern = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_use_pattern); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_USE_PATTERN, chk_use_pattern, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_use_pattern), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_use_pattern_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_use_pattern), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_use_pattern, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "You can fill extra tags to generate a disk name with disk information :\n- %% : %\n- %n : number archive (can use prefix to prefixed by 0 : %.4n give 0001, 0002, 0003, ..., 0091, ...\n- %l : media volume label\n- %t : media type\n- %s : serial number"), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_use_pattern, text_utf8, NULL); g_free ( text_utf8); /* Check button for the using media label */ g_strdup_to_gtk_text ( _( "Use media volume name as disk name (only when disk name is empty)"), text_utf8); chk_use_disk_label = gtk_check_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_widget_ref ( chk_use_disk_label); gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_USE_DISK_LABEL, chk_use_disk_label, (GtkDestroyNotify) gtk_widget_unref); gtk_signal_connect ( GTK_OBJECT ( chk_use_disk_label), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_use_disk_label_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( chk_use_disk_label), 5); gtk_box_pack_start ( GTK_BOX ( vb_options), chk_use_disk_label, FALSE, FALSE, 0); g_strdup_to_gtk_text ( _( "If you didn't enter disk name and if your selected media has a volume name, the media volume name will be applied as disk name."), text_utf8); gtk_tooltips_set_tip ( tooltips_group, chk_use_disk_label, text_utf8, NULL); g_free ( text_utf8); /* The add disk button to start the media scanning */ g_strdup_to_gtk_text ( _( "Add disk"), text_utf8); bt_start_device_scan = gtk_button_new_with_label ( text_utf8); g_free ( text_utf8); gtk_signal_connect ( GTK_OBJECT ( bt_start_device_scan), "clicked", GTK_SIGNAL_FUNC ( gw_notebook_managment_scan_click), window); gtk_container_set_border_width ( GTK_CONTAINER ( bt_start_device_scan), 5); gtk_box_pack_start ( GTK_BOX ( vb_tabbed_pane), bt_start_device_scan, FALSE, FALSE, 0); /* Loads the list of devices */ /* Do not still load device info at time. gw_notebook_managment_load_device_list ( window); */ /* Loads the list of categories */ gw_combo_box_categories_load ( cmb_categories); /* Fills the pattern to use for disk name */ if ( gw_am_get_settings_tol ( GW_VALUE_APP_DISK_SCAN_USE_PATTERN) == 1) { gw_notebook_managment_set_device_name ( window, gw_am_get_settings ( GW_VALUE_APP_DISK_SCAN_PATTERN)); } } return vb_tabbed_pane; }