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 delete_selected(gint button_number)
{
struct site *tmp, *tmp2;
extern GtkCTree *the_tree;
extern GtkCTreeNode *current_site_node;
extern gboolean rcfile_saved;
if (button_number != GNOME_YES)
return;
if ((selected_site != NULL) && (all_sites != NULL)) {
if (strcmp(all_sites->name, selected_site->name) == 0) {
all_sites = all_sites->next;
} else {
tmp = find_prev_site(selected_site);
if (tmp->next != NULL) {
tmp2 = tmp->next;
tmp->next = tmp2->next;
}
}
gtk_ctree_remove_node(GTK_CTREE(the_tree),
GTK_CTREE_NODE(current_site_node));
selected_site = NULL;
current_site_node = NULL;
} else {
gnome_error_dialog("I've detected no site is selected, but one should be selected in order to get here. Oh dear.");
}
clear_main_area();
rcfile_saved = false;
}
//static void source_ctree_remove_master_group (GtkWidget *ctree,
void source_ctree_remove_master_group (GtkWidget *ctree, struct master *m) {
GtkCTreeNode *node;
if (!m->isgroup)
return;
node = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, m);
if (node) {
gtk_ctree_remove_node (GTK_CTREE (ctree), node);
}
}
/* Remove the node and all nodes underneath it from the tree. */
int
clip_GTK_CTREEREMOVENODE(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
gtk_ctree_remove_node(GTK_CTREE(cctree->widget),GTK_CTREE_NODE(cnode->object));
return 0;
err:
return 1;
}
/** Does the equivalent of what refresh_selected used to do;
* looks at each file in a site and rebuilds the tree accordingly.
*/
void rebuild_node_files(GtkCTreeNode * site_node)
{
/* Get rid of all the files first */
while (GTK_CTREE_ROW(site_node)->children) {
gtk_ctree_remove_node(GTK_CTREE(the_tree),
GTK_CTREE_NODE(GTK_CTREE_ROW(site_node)->children));
}
NE_DEBUG(DEBUG_GNOME, "Removed all children, freezing CTree...\n");
gtk_clist_freeze(GTK_CLIST(the_tree));
populate_site_node(site_node, selected_site);
gtk_clist_thaw(GTK_CLIST(the_tree));
NE_DEBUG(DEBUG_GNOME, "Repopulation complete, CTree thawed.\n");
}
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 );
}
static void Init (void)
{
GtkTextIter begin;
GtkTextIter end;
/* blow away the tree if there is one */
if (rootDevice != NULL) {
gtk_ctree_remove_node (GTK_CTREE(treeUSB), GTK_CTREE_NODE(rootDevice->leaf));
}
/* clean out the text box */
gtk_text_buffer_get_start_iter(textDescriptionBuffer,&begin);
gtk_text_buffer_get_end_iter(textDescriptionBuffer,&end);
gtk_text_buffer_delete (textDescriptionBuffer, &begin, &end);
return;
}
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;
}
}
void source_ctree_delete_master (GtkWidget *ctree, struct master *m) {
GtkCTreeNode *node;
struct master *group;
node = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, m);
if (!node)
return;
gtk_ctree_remove_node (GTK_CTREE (ctree), node);
/* Remove empty master group from the tree */
if (m->type != UNKNOWN_SERVER) {
group = (struct master *) g_slist_nth_data (master_groups, m->type);
if (group && (group->masters == NULL || (g_slist_length (group->masters) == 1 && group->masters->data == m))) {
source_ctree_remove_master_group (ctree, group);
}
}
}
static void
tree_collapse (GtkCTree * tree, GtkCTreeNode * node)
{
GtkCTreeNode *child;
DIRTREE (tree)->collapse = TRUE;
gtk_clist_freeze (GTK_CLIST (tree));
child = GTK_CTREE_ROW (node)->children;
while (child)
{
gtk_ctree_remove_node (GTK_CTREE (tree), child);
child = GTK_CTREE_ROW (node)->children;
}
gtk_clist_thaw (GTK_CLIST (tree));
DIRTREE (tree)->collapse = FALSE;
}
/*
* Graphically show the status of all sampled symbols.
*/
static void
gdisp_poolSampledSymbolList ( Kernel_T *kernel )
{
GtkWidget *cTree = (GtkWidget*)NULL;
GString *messageString = (GString*)NULL;
GList *providerItem = (GList*)NULL;
Provider_T *provider = (Provider_T*)NULL;
Symbol_T *symbol = (Symbol_T*)NULL;
GtkCTreeNode *pSymbolAnchor = (GtkCTreeNode*)NULL;
GtkCTreeNode *pNode = (GtkCTreeNode*)NULL;
GtkCTreeNode *sNode = (GtkCTreeNode*)NULL;
gint pSampleCpt = 0;
SampleList_T *pSampleList = (SampleList_T*)NULL;
guint pSampleMax = 0;
#define GD_SAMPLE_PGI_AS_STRING_LENGTH 10
gchar samplePGIasStringBuffer[GD_SAMPLE_PGI_AS_STRING_LENGTH];
gchar *samplePGIasString = (gchar*)NULL;
TSP_sample_symbol_info_t *symbolInfo = (TSP_sample_symbol_info_t*)NULL;
/* ------------------------ PER PROVIDER ---------------------- */
cTree = kernel->widgets.sampledSymbolHTree;
/*
* When removing a node, GTK main loop activate the "unselect"
* callback, that performs a post recursive action on a node
* that has been destroyed.
* Avoid that shame by temporarily blocking the signal emission.
*/
gtk_clist_freeze(GTK_CLIST(cTree));
gtk_signal_handler_block_by_func(GTK_OBJECT(cTree),
gdisp_treeUnselectRowCallback,
(gpointer)kernel);
/*
* Loop over all providers.
*/
providerItem = g_list_first(kernel->providerList);
while (providerItem != (GList*)NULL) {
provider = (Provider_T*)providerItem->data;
/*
* Look for symbol anchor.
*/
if (provider->pNode != (GtkCTreeNode*)NULL) {
pSymbolAnchor = gdisp_getChildAccordingToItsName(kernel,
provider->pNode,
"sAnchor");
if (pSymbolAnchor == (GtkCTreeNode*)NULL) {
/* should never happen, because I did create this node !! */
messageString = g_string_new((gchar*)NULL);
g_string_sprintf(messageString,
"%s provider has no anchor for symbols.",
provider->pUrl->str);
(*kernel->outputFunc)(kernel,messageString,GD_ERROR);
}
else {
/* --------------------- PER SAMPLED SYMBOLS ---------------- */
/*
* Loop over all sampled symbol of the current provider.
*/
pSampleList = &provider->pSampleList;
pSampleMax = pSampleList->TSP_sample_symbol_info_list_t_len;
symbolInfo = pSampleList->TSP_sample_symbol_info_list_t_val;
for (pSampleCpt=0;
pSampleCpt<pSampleMax;
pSampleCpt++, symbolInfo++) {
/*
* Get in touch with the symbol through the global index.
*/
if (symbolInfo->provider_global_index >= 0) {
#if defined(GD_LOAD_CONFIGURATION_WITH_ALL_SYMBOLS)
symbol =
&provider->pSymbolList[symbolInfo->provider_global_index];
#else
/*
* Convert PGI as an unsigned integer to a string.
*/
samplePGIasStringBuffer[GD_SAMPLE_PGI_AS_STRING_LENGTH-1] = '\0';
samplePGIasString =
gdisp_uIntToStr(symbolInfo->provider_global_index,
&samplePGIasStringBuffer[GD_SAMPLE_PGI_AS_STRING_LENGTH-1]);
/*
* Retreive target symbol.
*/
if (provider->pSymbolHashTablePGI == (hash_t*)NULL) {
symbol = (Symbol_T*)NULL;
}
else {
symbol = (Symbol_T*)
hash_get(provider->pSymbolHashTablePGI,samplePGIasString);
}
#endif
/*
* If referenced... ie, used by graphic plots...
*/
if (symbol != (Symbol_T*)NULL) {
if (symbol->sReference > 0) {
/*
* Create the hierarchy for that symbol, if not already done.
*/
if (symbol->sNode == (GtkCTreeNode*)NULL) {
gdisp_createSymbolNode(kernel,
kernel->widgets.sampledSymbolScrolledWindow,
cTree,
pSymbolAnchor,
symbol);
}
else {
gdisp_updateSymbolNode(kernel,
cTree,
symbol);
}
} /* sReference > 0 */
else {
if (symbol->sNode != (GtkCTreeNode*)NULL) {
gtk_ctree_remove_node(GTK_CTREE(cTree),
symbol->sNode);
symbol->sNode = (GtkCTreeNode*)NULL;
}
} /* sReference == 0 */
} /* symbol not null */
} /* if (index >= 0) */
} /* loop over sampled symbols */
} /* found sAnchor */
} /* pNode is not null */
else {
/*
* Create a node that will contain all provider information.
*/
gdisp_createProviderNode(kernel,
kernel->widgets.sampledSymbolScrolledWindow,
cTree,
provider,
&pNode,
&sNode);
}
/*
* Next provider.
*/
providerItem = g_list_next(providerItem);
} /* loop over all providers */
/*
* Finalise.
*/
gdisp_finaliseHierarchicalTree(kernel,
cTree);
/*
* Activate again the unselect handler.
*/
gtk_signal_handler_unblock_by_func(GTK_OBJECT(cTree),
gdisp_treeUnselectRowCallback,
(gpointer)kernel);
gtk_clist_thaw(GTK_CLIST(cTree));
}
/*
* Refresh provider graphic list.
*/
void
gdisp_refreshSampledSymbolList ( Kernel_T *kernel )
{
GList *providerItem = (GList*)NULL;
Provider_T *provider = (Provider_T*)NULL;
GtkWidget *cTree = (GtkWidget*)NULL;
GList *cTreeList = (GList*)NULL;
GtkCTreeRow *cTreeRow = (GtkCTreeRow*)NULL;
GtkCTreeNode *cTreeNode = (GtkCTreeNode*)NULL;
guint cTreeLength = 0;
guint cTreeCpt = 0;
/* ------------------------ PER PROVIDER ---------------------- */
cTree = kernel->widgets.sampledSymbolHTree;
/*
* When removing a node, GTK main loop activate the "unselect"
* callback, that performs a post recursive action on a node
* that has been destroyed.
* Avoid that shame by temporarily blocking the signal emission.
*/
gtk_clist_freeze(GTK_CLIST(cTree));
gtk_signal_handler_block_by_func(GTK_OBJECT(cTree),
gdisp_treeUnselectRowCallback,
(gpointer)kernel);
/*
* Remove all top-level node, those that have no parent.
* First step : build top-level list.
*/
cTreeLength = g_list_length(GTK_CTREE(cTree)->clist.row_list);
for (cTreeCpt=0; cTreeCpt<cTreeLength; cTreeCpt++) {
cTreeNode = gtk_ctree_node_nth(GTK_CTREE(cTree),cTreeCpt);
if (cTreeNode != (GtkCTreeNode*)NULL) {
cTreeRow = GTK_CTREE_ROW(cTreeNode);
if (cTreeRow->parent == (GtkCTreeNode*)NULL) {
cTreeList = g_list_append(cTreeList,(gpointer)cTreeNode);
} /* node is top-level, ie without parent */
} /* node exists */
} /* loop over all rows */
/*
* Second step : remove all top_level nodes.
*/
cTreeList = g_list_first(cTreeList);
while (cTreeList != (GList*)NULL) {
gtk_ctree_remove_node(GTK_CTREE(cTree),
(GtkCTreeNode*)cTreeList->data);
cTreeList = g_list_next(cTreeList);
}
/*
* Loop over all providers. Forget tree node address.
*/
providerItem = g_list_first(kernel->providerList);
while (providerItem != (GList*)NULL) {
provider = (Provider_T*)providerItem->data;
provider->pNode = (GtkCTreeNode*)NULL;
providerItem = g_list_next(providerItem);
}
/*
* Finalise.
*/
gdisp_finaliseHierarchicalTree(kernel,
cTree);
/*
* Activate again the unselect handler.
*/
gtk_signal_handler_unblock_by_func(GTK_OBJECT(cTree),
gdisp_treeUnselectRowCallback,
(gpointer)kernel);
gtk_clist_thaw(GTK_CLIST(cTree));
}
static void
transfer_done (GList * node)
{
gftpui_common_curtrans_data * transdata;
gftp_transfer * tdata;
gftp_file * tempfle;
GList * templist;
tdata = node->data;
if (tdata->started)
{
if (GFTP_IS_SAME_HOST_STOP_TRANS ((gftp_window_data *) tdata->fromwdata,
tdata->fromreq))
{
gftp_copy_param_options (((gftp_window_data *) tdata->fromwdata)->request, tdata->fromreq);
gftp_swap_socks (((gftp_window_data *) tdata->fromwdata)->request,
tdata->fromreq);
}
else
gftp_disconnect (tdata->fromreq);
if (GFTP_IS_SAME_HOST_STOP_TRANS ((gftp_window_data *) tdata->towdata,
tdata->toreq))
{
gftp_copy_param_options (((gftp_window_data *) tdata->towdata)->request, tdata->toreq);
gftp_swap_socks (((gftp_window_data *) tdata->towdata)->request,
tdata->toreq);
}
else
gftp_disconnect (tdata->toreq);
if (tdata->towdata != NULL && compare_request (tdata->toreq,
((gftp_window_data *) tdata->towdata)->request, 1))
gftpui_refresh (tdata->towdata, 1);
num_transfers_in_progress--;
}
if ((!tdata->show && tdata->started) ||
(tdata->done && !tdata->started))
{
transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw),
tdata->user_data);
if (transdata != NULL)
g_free (transdata);
for (templist = tdata->files; templist != NULL; templist = templist->next)
{
tempfle = templist->data;
transdata = gtk_ctree_node_get_row_data (GTK_CTREE (dlwdw),
tempfle->user_data);
if (transdata != NULL)
g_free (transdata);
}
gtk_ctree_remove_node (GTK_CTREE (dlwdw), tdata->user_data);
}
g_static_mutex_lock (&gftpui_common_transfer_mutex);
gftp_file_transfers = g_list_remove_link (gftp_file_transfers, node);
g_static_mutex_unlock (&gftpui_common_transfer_mutex);
gdk_window_set_title (gtk_widget_get_parent_window (GTK_WIDGET(dlwdw)),
gftp_version);
free_tdata (tdata);
}
static void
expand_tree(GtkCTree *ctree,GtkCTreeNode *parent_node, gpointer data)
{
DIR *dir;
struct dirent *dirent;
gchar *path,*text,*dummy="dummy";
struct stat statbuf;
GtkCTreeNode *node,*sub_node;
GtkDirTreeNode *parent_dirnode,*dirnode;
gboolean has_subdir=FALSE;
gboolean show_hidden;
gboolean stat_subdirs=TRUE;
gboolean can_open_subdir;
GtkDirTree *dir_tree;
GtkWidget *widget;
widget = GTK_WIDGET(ctree);
dir_tree = GTK_DIR_TREE(widget);
show_hidden = dir_tree->show_hidden;
parent_dirnode=gtk_ctree_node_get_row_data(GTK_CTREE(widget),parent_node);
if(parent_dirnode->path == dir_tree->local_hostname) return;
if(!parent_dirnode->scanned)
{
gtk_clist_freeze(GTK_CLIST(widget));
node=gtk_ctree_find_by_row_data(GTK_CTREE(widget),parent_node,NULL);
gtk_ctree_remove_node(GTK_CTREE(widget),node);
if((dir=opendir(parent_dirnode->path))!=NULL)
{
if(!check_dir_extra(parent_dirnode->path,&statbuf,&stat_subdirs))
{
closedir(dir);
gtk_clist_thaw(GTK_CLIST(widget));
return;
}
while((dirent=readdir(dir))!=NULL)
{
path=g_strconcat(parent_dirnode->path,dirent->d_name,NULL);
if (stat_subdirs)
{
if(0!=stat(path,&statbuf))
{
g_free(path);
continue;
}
}
if(((!stat_subdirs)&&accept_dirname(dirent->d_name,show_hidden)) ||
(S_ISDIR(statbuf.st_mode)&&accept_dirname(dirent->d_name,show_hidden)))
{
DIR *dir_sub;
dirnode=g_malloc0(sizeof(GtkDirTreeNode));
dirnode->path=g_strconcat(path,G_DIR_SEPARATOR_S,NULL);
text=dirent->d_name;
if (stat_subdirs)
{
if(check_for_subdir(dirnode->path,show_hidden))
has_subdir=TRUE;
else
has_subdir=FALSE;
dir_sub = opendir(dirnode->path);
if( dir_sub != NULL )
{
closedir(dir_sub);
can_open_subdir=TRUE;
}
else
{
can_open_subdir=FALSE;
}
}
else
{
has_subdir=TRUE;
can_open_subdir=TRUE;
}
if(can_open_subdir)
{
node=gtk_ctree_insert_node(GTK_CTREE(widget),parent_node,NULL,&text,4,dir_tree->folder,dir_tree->folder_mask,dir_tree->ofolder,dir_tree->ofolder_mask,!has_subdir,FALSE);
}
else
{
node=gtk_ctree_insert_node(GTK_CTREE(widget),parent_node,NULL,&text,4,dir_tree->dennied,dir_tree->dennied_mask,dir_tree->dennied,dir_tree->dennied_mask,!has_subdir,FALSE);
}
gtk_ctree_node_set_row_data_full(GTK_CTREE(widget),node,dirnode,destroy_tree);
if(has_subdir)
sub_node=gtk_ctree_insert_node(GTK_CTREE(widget),node,NULL,&dummy,4,NULL,NULL,NULL,NULL,FALSE,FALSE);
}
g_free(path);
}
closedir(dir);
gtk_ctree_sort_node(GTK_CTREE(widget),parent_node);
}
gtk_clist_thaw(GTK_CLIST(widget));
parent_dirnode->scanned=TRUE;
}
}
