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 source_ctree_add_master (GtkWidget *ctree, struct master *m) {
GtkCTreeNode *node;
GtkCTreeNode *parent = NULL;
struct master *group = NULL;
if (m->isgroup)
return;
// If set to display only configured games, and game is not configured,
// and it's not the 'Favorites' master, just return so the display
// isn't updated with the game type and masters.
if (!(games[m->type].cmd) && default_show_only_configured_games && m != favorites)
return;
if (m->type != UNKNOWN_SERVER) {
group = (struct master *) g_slist_nth_data (master_groups, m->type);
source_ctree_enable_master_group (ctree, group, TRUE);
}
node = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, m);
if (!node) {
if (group) {
parent = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, group);
}
node = gtk_ctree_insert_node (GTK_CTREE (ctree), parent, NULL, NULL, 4, NULL, NULL, NULL, NULL, TRUE, FALSE);
gtk_ctree_node_set_row_data (GTK_CTREE (ctree), node, m);
}
source_ctree_show_node_status (ctree, m);
}
static 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
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);
}
static void fill_source_ctree (GtkWidget *ctree) {
GSList *list;
GSList *list2;
GtkCTreeNode *node;
GtkCTreeNode *parent;
struct master *group;
struct master *m;
source_ctree_add_master (ctree, favorites);
for (list = master_groups; list; list = list->next) {
group = (struct master *) list->data;
if (group->masters) {
// If set to display only configured games, and game is not configured,
// don't update the display with the master.
if (games[group->type].cmd || !default_show_only_configured_games) {
source_ctree_enable_master_group (ctree, group, FALSE);
parent = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, group);
for (list2 = group->masters; list2; list2 = list2->next) {
m = (struct master *) list2->data;
node = gtk_ctree_insert_node (GTK_CTREE (ctree), parent, NULL, NULL, 4, NULL, NULL, NULL, NULL, TRUE, FALSE);
gtk_ctree_node_set_row_data (GTK_CTREE (ctree), node, m);
source_ctree_show_node_status (ctree, m);
}
}
}
}
}
void
gftpui_add_file_to_transfer (gftp_transfer * tdata, GList * curfle)
{
gftpui_common_curtrans_data * transdata;
char *text[2];
gftp_file * fle;
fle = curfle->data;
text[0] = gftpui_gtk_get_utf8_file_pos (fle);
if (fle->transfer_action == GFTP_TRANS_ACTION_SKIP)
text[1] = _("Skipped");
else
text[1] = _("Waiting...");
fle->user_data = gtk_ctree_insert_node (GTK_CTREE (dlwdw),
tdata->user_data, NULL, text, 5,
NULL, NULL, NULL, NULL,
FALSE, FALSE);
transdata = g_malloc0 (sizeof (*transdata));
transdata->transfer = tdata;
transdata->curfle = curfle;
gtk_ctree_node_set_row_data (GTK_CTREE (dlwdw), fle->user_data, transdata);
}
/*
* Popup Menu Handler.
* Expand or Collapse the whole hierarchical tree.
*/
static void
gdisp_popupMenuHandler ( Kernel_T *kernel,
PopupMenu_T *menu,
gpointer menuData, /* cTree */
gpointer itemData )
{
GtkWidget *cTree = (GtkWidget*)menuData;
guint action = GPOINTER_TO_UINT(itemData);
/*
* itemData : 0-collapse, 1-expand
*/
if (action == 1 /* expand */) {
gtk_ctree_expand_recursive(GTK_CTREE(cTree),
(GtkCTreeNode*)NULL);
}
else {
gtk_ctree_collapse_recursive(GTK_CTREE(cTree),
(GtkCTreeNode*)NULL);
}
}
static void icon_selected (MimeView *mimeview, gint num, MimeInfo *partinfo)
{
GtkCTreeNode *node;
node = gtk_ctree_find_by_row_data(GTK_CTREE(mimeview->ctree), NULL, partinfo);
if (node)
gtk_ctree_select(GTK_CTREE(mimeview->ctree), node);
}
GtkWidget *create_cwidget (GtkWidget *scrollwin, struct clist_def *cldef) {
GtkWidget *alignment;
GtkWidget *label;
GtkWidget *clist;
char buf[256];
int i;
switch (cldef->type) {
case CWIDGET_CLIST:
clist = gtk_clist_new (cldef->columns);
break;
case CWIDGET_CTREE:
clist = gtk_ctree_new (cldef->columns, 0);
gtk_ctree_set_line_style (GTK_CTREE (clist), GTK_CTREE_LINES_NONE);
gtk_ctree_set_expander_style (GTK_CTREE (clist), GTK_CTREE_EXPANDER_TRIANGLE);
gtk_ctree_set_indent (GTK_CTREE (clist), 10);
break;
default:
return NULL;
}
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GTK_CLIST_SET_FLAG (GTK_CLIST (clist), CLIST_SHOW_TITLES);
gtk_container_add (GTK_CONTAINER (scrollwin), clist);
gtk_clist_set_selection_mode (GTK_CLIST (clist), cldef->mode);
for (i = 0; i < cldef->columns; i++) {
g_snprintf (buf, 256, "/" CONFIG_FILE "/%s Geometry/%s=%d",
cldef->name, cldef->cols[i].name, cldef->cols[i].width);
gtk_clist_set_column_width (GTK_CLIST (clist), i, config_get_int (buf));
if (cldef->cols[i].justify != GTK_JUSTIFY_LEFT) {
gtk_clist_set_column_justification (GTK_CLIST (clist), i, cldef->cols[i].justify);
}
alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
label = gtk_label_new (_(cldef->cols[i].name));
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_container_add (GTK_CONTAINER (alignment), label);
gtk_widget_show (label);
cldef->cols[i].widget = label;
gtk_clist_set_column_widget (GTK_CLIST (clist), i, alignment);
gtk_widget_show (alignment);
}
gtk_clist_set_sort_column (GTK_CLIST (clist), cldef->sort_column);
gtk_clist_set_sort_type (GTK_CLIST (clist), cldef->sort_type);
clist_column_set_title (GTK_CLIST (clist), cldef, TRUE);
return clist;
}
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);
}
//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);
}
}
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 source_ctree_select_source (struct master *m) {
GtkCTreeNode *node;
GtkVisibility vis;
node = gtk_ctree_find_by_row_data (GTK_CTREE (source_ctree), NULL, m);
gtk_ctree_unselect_recursive (GTK_CTREE (source_ctree), NULL);
gtk_ctree_select (GTK_CTREE (source_ctree), node);
vis = gtk_ctree_node_is_visible (GTK_CTREE (source_ctree), node);
if (vis != GTK_VISIBILITY_FULL)
gtk_ctree_node_moveto (GTK_CTREE (source_ctree), node, 0, 0.2, 0.0);
}
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;
}
int add_a_site_to_the_tree(struct site *a_site, gint operation)
{
struct ctree_attachment *info_to_add;
gchar *tmp, *node_label[1];
tmp = getAppropriateTreeLabel(a_site);
node_label[0] = tmp;
site_item = gtk_ctree_insert_node(GTK_CTREE(the_tree), NULL, NULL, node_label,
0, NULL, NULL, NULL, NULL, FALSE, FALSE);
g_free (tmp);
info_to_add = malloc(sizeof(struct ctree_attachment));
info_to_add->file_or_site = IS_A_SITE;
info_to_add->info_struct = (void *) a_site;
gtk_ctree_node_set_row_data(GTK_CTREE(the_tree), site_item,
(gpointer) info_to_add);
/* Read site info */
if (site_readfiles(a_site) != SITE_OK)
/* We effectively have no info file, so just read the stored state. */
site_read_local_state(a_site);
/* Catchup or init, if that's required */
if (operation == 1)
{
site_initialize(a_site);
printf("Initialised site\n");
}
else if (operation == 2)
{
site_catchup(a_site);
printf("Caught-up new site.\n");
}
/* As far as I can tell, this doesn't need to be done.
* Not sure why it's in here*/
site_write_stored_state(a_site);
if (operation != 3)
{
gtk_clist_freeze(GTK_CLIST(the_tree));
populate_site_node(GTK_CTREE_NODE(site_item), a_site);
gtk_clist_thaw(GTK_CLIST(the_tree));
}
return 0;
}
static GtkCTreeNode *mimeview_append_part(MimeView *mimeview,
MimeInfo *partinfo,
GtkCTreeNode *parent)
{
GtkCTree *ctree = GTK_CTREE(mimeview->ctree);
GtkCTreeNode *node;
static gchar content_type[64];
gchar *str[N_MIMEVIEW_COLS];
if (partinfo->type != MIMETYPE_UNKNOWN && partinfo->subtype) {
g_snprintf(content_type, 64, "%s/%s", procmime_get_media_type_str(partinfo->type), partinfo->subtype);
} else {
g_snprintf(content_type, 64, "UNKNOWN");
}
str[COL_MIMETYPE] = content_type;
str[COL_SIZE] = to_human_readable(partinfo->length);
if (prefs_common.attach_desc)
str[COL_NAME] = (gchar *) get_part_description(partinfo);
else
str[COL_NAME] = (gchar *) get_part_name(partinfo);
node = gtk_ctree_insert_node(ctree, parent, NULL, str, 0,
NULL, NULL, NULL, NULL,
FALSE, TRUE);
gtk_ctree_node_set_row_data(ctree, node, partinfo);
return node;
}
void 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);
}
}
static void
create_transfer (gftp_transfer * tdata)
{
if (tdata->fromreq->stopable)
return;
if (GFTP_IS_SAME_HOST_START_TRANS ((gftp_window_data *) tdata->fromwdata,
tdata->fromreq))
{
gftp_swap_socks (tdata->fromreq,
((gftp_window_data *) tdata->fromwdata)->request);
update_window (tdata->fromwdata);
}
if (GFTP_IS_SAME_HOST_START_TRANS ((gftp_window_data *) tdata->towdata,
tdata->toreq))
{
gftp_swap_socks (tdata->toreq,
((gftp_window_data *) tdata->towdata)->request);
update_window (tdata->towdata);
}
num_transfers_in_progress++;
tdata->started = 1;
tdata->stalled = 1;
gtk_ctree_node_set_text (GTK_CTREE (dlwdw), tdata->user_data, 1,
_("Connecting..."));
if (tdata->thread_id == NULL)
tdata->thread_id = g_malloc0 (sizeof (pthread_t));
pthread_create (tdata->thread_id, NULL, _gftpui_transfer_files, tdata);
}
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;
}
int
clip_GTK_CTREENODEGETPIXMAP(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
gint column = _clip_parni(cm,3);
GdkPixmap *pixmap;
GdkBitmap *mask;
C_widget *cpixmap;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKOPT(3,NUMERIC_t);
if (_clip_parinfo(cm,3)==UNDEF_t) column = 1;
if (gtk_ctree_node_get_pixmap(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object),column-1,&pixmap,&mask))
{
if (pixmap)
{
cpixmap = _list_get_cwidget_by_data(cm,pixmap);
if (!cpixmap) cpixmap = _register_widget(cm,gtk_pixmap_new(pixmap,mask),NULL);
if (cpixmap) _clip_mclone(cm,RETPTR(cm),&cpixmap->obj);
}
}
return 0;
err:
return 1;
}
/* Set the pixmap in a node. */
int
clip_GTK_CTREENODESETPIXTEXT(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
gint column = _clip_parni(cm,3);
gchar *text = _clip_parc(cm,4);
gint spacing = _clip_parni(cm,5);
C_widget *cpixmap = _fetch_cwidget(cm,_clip_spar(cm,6));
GdkPixmap *pixmap=NULL; GdkBitmap *mask=NULL;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKOPT(3,NUMERIC_t); CHECKOPT(4,CHARACTER_t); CHECKOPT(5,NUMERIC_t);
CHECKOPT2(6,MAP_t,NUMERIC_t); CHECKCWIDOPT(cpixmap,GTK_IS_PIXMAP);
if (_clip_parinfo(cm,3)==UNDEF_t) column = 1;
if (_clip_parinfo(cm,4)==UNDEF_t) text = "";
if (cpixmap)
{
pixmap = GTK_PIXMAP(cpixmap->widget)->pixmap;
mask = GTK_PIXMAP(cpixmap->widget)->mask;
}
LOCALE_TO_UTF(text);
gtk_ctree_node_set_pixtext(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object), column-1,
text,spacing,pixmap,mask);
FREE_TEXT(text);
return 0;
err:
return 1;
}
/*
* Finalise hierarchical tree.
*/
static void
gdisp_finaliseHierarchicalTree ( Kernel_T *kernel,
GtkWidget *cTree )
{
guint optimalWidth = 0;
/*
* Change tree global aspect.
*/
gtk_clist_set_row_height(GTK_CLIST(cTree), /* CLIST, and not CTREE !! */
15);
gtk_ctree_set_indent(GTK_CTREE(cTree),
16);
/*
* Compute first column optimal length.
*/
optimalWidth = gtk_clist_optimal_column_width(GTK_CLIST(cTree),
0 /* first column */);
gtk_clist_set_column_width(GTK_CLIST(cTree),
0, /* first column */
optimalWidth);
}
static void
selected_row_changed(GtkCTree *ctree)
{
int row;
if (selected_record) {
search_gui_unref_record(selected_record);
selected_record = NULL;
}
row = clist_get_cursor_row(GTK_CLIST(ctree));
if (row >= 0) {
GtkCTreeNode *node;
node = gtk_ctree_node_nth(GTK_CTREE(ctree), row);
selected_record = search_gui_get_record(ctree, GTK_CTREE_NODE(node));
if (selected_record) {
search_gui_ref_record(selected_record);
}
}
if (row_selected_ev) {
cq_resched(row_selected_ev, ROW_SELECT_TIMEOUT);
} else {
row_selected_ev = cq_main_insert(ROW_SELECT_TIMEOUT,
row_selected_expire, NULL);
}
}
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 );
}
/* Recursively collapses the directory tree entry of the given directory */
void
dirtree_entry_collapse_recursive( GNode *dnode )
{
g_assert( NODE_IS_DIR(dnode) );
block_colexp_handlers( );
gtk_ctree_collapse_recursive( GTK_CTREE(dir_ctree_w), DIR_NODE_DESC(dnode)->ctnode );
unblock_colexp_handlers( );
}
/* Set the style of a row. */
int
clip_GTK_CTREENODESETROWSTYLE (ClipMachine *cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2));
ClipVar *mstyle = _clip_spar(cm,3);
GtkStyle *style;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE);
CHECKARG(3,MAP_t);
style = gtk_ctree_node_get_row_style (GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object));
_map_to_style(cm, mstyle, style);
gtk_ctree_node_set_row_style (GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object), style);
return 0;
err:
return 1;
}
GtkWidget *create_source_ctree (GtkWidget *scrollwin) {
char *titles[1] = { _("Source") };
GtkWidget *ctree;
/* gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
*/
ctree = gtk_ctree_new_with_titles (1, 0, titles);
gtk_container_add (GTK_CONTAINER (scrollwin), ctree);
gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
gtk_ctree_set_line_style (GTK_CTREE (ctree), GTK_CTREE_LINES_NONE);
gtk_ctree_set_expander_style (GTK_CTREE (ctree), GTK_CTREE_EXPANDER_TRIANGLE);
gtk_ctree_set_indent (GTK_CTREE (ctree), 10);
fill_source_ctree (ctree);
return ctree;
}
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 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);
}
}
}