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;
}
