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 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 ) );
}
/* Expand one node. */
int
clip_GTK_CTREEEXPAND(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_expand(GTK_CTREE(cctree->widget),
GTK_CTREE_NODE(cnode->object));
return 0;
err:
return 1;
}
/* Expands the directory tree entry of the given directory. If any of its
* ancestor directory entries are not expanded, then they are expanded
* as well */
void
dirtree_entry_expand( GNode *dnode )
{
GNode *up_node;
g_assert( NODE_IS_DIR(dnode) );
block_colexp_handlers( );
up_node = dnode;
while (NODE_IS_DIR(up_node)) {
if (!dirtree_entry_expanded( up_node ))
gtk_ctree_expand( GTK_CTREE(dir_ctree_w), DIR_NODE_DESC(up_node)->ctnode );
up_node = up_node->parent;
}
unblock_colexp_handlers( );
}
static void source_ctree_enable_master_group (GtkWidget *ctree, struct master *m, int expand) {
GtkCTreeNode *node;
GtkCTreeNode *sibling = NULL;
char cfgkey[128];
GSList *list;
int expanded;
if (!m->isgroup)
return;
node = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, m);
if (node != NULL) {
if (expand)
gtk_ctree_expand (GTK_CTREE (ctree), node);
return;
}
g_snprintf (cfgkey, 128, "/" CONFIG_FILE "/Source Tree/%s node collapsed=false", m->name);
if (expand)
config_set_bool (cfgkey, expanded = TRUE);
else
expanded = TRUE - config_get_bool (cfgkey);
/* Find the place to insert new master group */
list = g_slist_nth (master_groups, m->type);
if (list)
list = list->next;
while (!sibling && list) {
sibling = gtk_ctree_find_by_row_data (GTK_CTREE (ctree), NULL, (struct master *) list->data);
list = list->next;
}
node = gtk_ctree_insert_node (GTK_CTREE (ctree), NULL, sibling, NULL, 4, NULL, NULL, NULL, NULL, FALSE, expanded);
gtk_ctree_node_set_row_data (GTK_CTREE (ctree), node, m);
source_ctree_show_node_status (ctree, m);
}
GtkWidget *create_dir_browser(gchar * title, gchar * current_path, GtkSelectionMode mode, void (*handler) (gchar *))
{
GtkWidget *window, *scroll_win, *tree, *vbox, *bbox, *ok, *cancel,
*sep;
gchar *root_text = "/", *node_text = "dummy";
gchar *currentdir, *pos, *tpath, *tpathnew;
GtkCTreeNode *root_node, *node, *nextnode;
DirNode *dirnode;
gboolean leaf;
#ifdef _GTK2
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
// gtk_window_set_decorated(GTK_WINDOW(window), TRUE);
#else
window = gtk_window_new(GTK_WINDOW_DIALOG);
#endif
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_container_border_width(GTK_CONTAINER(window), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(window), vbox);
scroll_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_usize(scroll_win, 250, 200);
gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0);
gtk_widget_show(scroll_win);
gtk_widget_realize(window);
if (!folder_pixmap)
{
folder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &folder_mask, NULL, folder);
ofolder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &ofolder_mask, NULL, ofolder);
}
tree = gtk_ctree_new(1, 0);
gtk_clist_set_column_auto_resize(GTK_CLIST(tree), 0, TRUE);
gtk_clist_set_selection_mode(GTK_CLIST(tree), mode);
gtk_ctree_set_line_style(GTK_CTREE(tree), GTK_CTREE_LINES_DOTTED);
gtk_signal_connect(GTK_OBJECT(tree), "tree_expand", GTK_SIGNAL_FUNC(expand_cb), NULL);
gtk_signal_connect(GTK_OBJECT(tree), "select_row", GTK_SIGNAL_FUNC(select_row_cb), NULL);
gtk_container_add(GTK_CONTAINER(scroll_win), tree);
gtk_object_set_user_data(GTK_OBJECT(tree), (gpointer) handler);
root_node = gtk_ctree_insert_node(GTK_CTREE(tree), NULL, NULL, &root_text, 4, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, FALSE);
dirnode = g_malloc0(sizeof (DirNode));
dirnode->path = g_strdup("/");
gtk_ctree_node_set_row_data_full(GTK_CTREE(tree), root_node, dirnode, destroy_cb);
node = gtk_ctree_insert_node(GTK_CTREE(tree), root_node, NULL, &node_text, 4, NULL, NULL, NULL, NULL, TRUE, TRUE);
gtk_ctree_expand(GTK_CTREE(tree), root_node);
gtk_widget_show(tree);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
gtk_widget_show(sep);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
ok = gtk_button_new_with_label(tr("Ok"));
gtk_object_set_user_data(GTK_OBJECT(ok), window);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(window), ok);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(ok_clicked), tree);
gtk_widget_show(ok);
cancel = gtk_button_new_with_label(tr("Cancel"));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window));
gtk_widget_show(cancel);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
gtk_widget_show(vbox);
if (current_path && *current_path)
{
currentdir = g_strdup(current_path);
tpath = g_strdup("/");
pos = strtok(currentdir, "/");
node = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), NULL, "/", filetreeent_compare_func);
do
{
tpathnew = g_strconcat(tpath, pos, "/", NULL);
g_free(tpath);
tpath = tpathnew;
nextnode = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), node, tpath, filetreeent_compare_func);
if (!nextnode)
break;
node = nextnode;
pos = strtok(NULL, "/");
gtk_ctree_get_node_info(GTK_CTREE(tree), node, NULL, NULL, NULL, NULL, NULL, NULL, &leaf, NULL);
if (!leaf && pos)
gtk_ctree_expand(GTK_CTREE(tree), node);
else
{
gtk_ctree_select(GTK_CTREE(tree), node);
break;
}
}
while (pos);
g_free(tpath);
g_free(currentdir);
}
else
gtk_ctree_select(GTK_CTREE(tree), root_node);
return window;
}
/*
* Create a node that will contain all provider information.
*/
static void
gdisp_createProviderNode(Kernel_T *kernel,
GtkWidget *parent,
GtkWidget *tree,
Provider_T *provider,
GtkCTreeNode **providerNode,
GtkCTreeNode **sampledSymbolNode)
{
gchar *pNames [GD_TREE_NB_COLUMNS] = { (gchar*)NULL, (gchar*)NULL };
GtkCTreeNode *iNode = (GtkCTreeNode*)NULL;
GtkCTreeNode *sNode = (GtkCTreeNode*)NULL;
Pixmap_T *pPixmap = (Pixmap_T*)NULL;
/*
* The name of the node is the URL of the provider.
* Get back provider pixmap according to its identity.
*/
pNames[0] = provider->pUrl->str;
pPixmap = gdisp_getProviderIdPixmap(kernel,
parent,
provider->pIdentity);
provider->pNode = gtk_ctree_insert_node(GTK_CTREE(tree),
(GtkCTreeNode*)NULL, /* parent */
(GtkCTreeNode*)NULL, /* sibling */
pNames,
GD_TREE_SPACING,
pPixmap->pixmap,
pPixmap->mask,
pPixmap->pixmap,
pPixmap->mask,
FALSE, /* is a leave */
TRUE); /* is expanded */
gtk_ctree_node_set_row_data(GTK_CTREE(tree),
provider->pNode,
(gpointer)provider);
gtk_ctree_node_set_selectable(GTK_CTREE(tree),
provider->pNode,
FALSE); /* not selectable */
/*
* Insert information node.
*/
pNames[0] = "Information";
pPixmap = gdisp_getPixmapById(kernel,
GD_PIX_info,
parent);
iNode = gtk_ctree_insert_node(GTK_CTREE(tree),
provider->pNode, /* provider is the parent */
(GtkCTreeNode*)NULL, /* no sibling node */
pNames,
GD_TREE_SPACING,
pPixmap->pixmap,
pPixmap->mask,
pPixmap->pixmap,
pPixmap->mask,
/* FIXME for the moment */ TRUE, /* is a leave */
FALSE); /* is expanded */
gtk_ctree_node_set_selectable(GTK_CTREE(tree),
iNode,
FALSE); /* not selectable */
/*
* Insert sampled symbol node.
*/
pNames[0] = "Sampled Symbols";
sNode = gtk_ctree_insert_node(GTK_CTREE(tree),
provider->pNode, /* provider is the parent */
(GtkCTreeNode*)NULL, /* no sibling node */
pNames,
GD_TREE_SPACING,
kernel->widgets.collapsedNodePixmap->pixmap,
kernel->widgets.collapsedNodePixmap->mask,
kernel->widgets.expandedNodePixmap->pixmap,
kernel->widgets.expandedNodePixmap->mask,
FALSE, /* is a leave */
FALSE); /* is expanded */
gtk_ctree_node_set_row_data(GTK_CTREE(tree),
sNode,
(gpointer)"sAnchor");
gtk_ctree_node_set_text(GTK_CTREE(tree),
sNode,
0, /* column */
pNames[0]);
gtk_ctree_node_set_selectable(GTK_CTREE(tree),
sNode,
FALSE); /* not selectable */
if (gdisp_getProviderNumber(kernel) == 1) {
/*
* Expand that node if there is only one provider.
*/
gtk_ctree_expand(GTK_CTREE(tree),sNode);
}
/*
* Return.
*/
*providerNode = provider->pNode;
*sampledSymbolNode = sNode;
}
GtkWidget * create_PlayList( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * scrolledwindow1;
GtkWidget * vbox2;
GtkWidget * scrolledwindow2;
GtkWidget * scrolledwindow3;
GtkWidget * hbuttonbox1;
GtkAccelGroup * accel_group;
GdkColor transparent = { 0,0,0,0 };
gchar * root = "/";
gchar * dummy = "dummy";
DirNodeType * DirNode;
accel_group=gtk_accel_group_new();
PlayList=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_object_set_data( GTK_OBJECT( PlayList ),"PlayList",PlayList );
gtk_widget_set_usize( PlayList,512,384 );
gtk_window_set_title( GTK_WINDOW( PlayList ),MSGTR_PlayList );
gtk_window_set_position( GTK_WINDOW( PlayList ),GTK_WIN_POS_CENTER );
// gtk_window_set_policy( GTK_WINDOW( PlayList ),FALSE,FALSE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( PlayList ),"Playlist","MPlayer" );
gtk_widget_realize( PlayList );
gtkAddIcon( PlayList );
vbox1=AddVBox( AddDialogFrame( PlayList ),0 );
hbox1=AddHBox( NULL,1 );
gtk_box_pack_start( GTK_BOX( vbox1 ),hbox1,TRUE,TRUE,0 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow1 );
gtk_container_add( GTK_CONTAINER(
AddFrame( NULL,0,hbox1,1 ) ),scrolledwindow1 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CTDirTree=gtk_ctree_new( 1,0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"tree_expand",GTK_SIGNAL_FUNC( plCTree ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"select_row",GTK_SIGNAL_FUNC( plCTRow ),(void *)0 );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),CTDirTree );
gtk_clist_set_column_auto_resize( GTK_CLIST( CTDirTree ),0,TRUE );
gtk_clist_set_column_width( GTK_CLIST( CTDirTree ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CTDirTree ),GTK_SELECTION_SINGLE );
gtk_ctree_set_line_style( GTK_CTREE( CTDirTree ),GTK_CTREE_LINES_SOLID );
gtk_clist_column_titles_show( GTK_CLIST( CTDirTree ) );
gtk_clist_set_shadow_type( GTK_CLIST( CTDirTree ),GTK_SHADOW_NONE );
if ( !pxOpenedBook ) pxOpenedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msOpenedBook,&transparent,(gchar **)dir2_xpm );
if ( !pxClosedBook ) pxClosedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msClosedBook,&transparent,(gchar **)open2_xpm );
parent=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),NULL,NULL,&root,4,pxOpenedBook,msOpenedBook,pxClosedBook,msClosedBook,FALSE,FALSE );
DirNode=malloc( sizeof( DirNodeType ) );
DirNode->scaned=0; DirNode->path=strdup( root );
gtk_ctree_node_set_row_data_full(GTK_CTREE( CTDirTree ),parent,DirNode,NULL );
sibling=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),parent,NULL,&dummy,4,NULL,NULL,NULL,NULL,TRUE,TRUE );
gtk_ctree_expand( GTK_CTREE( CTDirTree ),parent );
gtk_widget_show( CTDirTree );
if ( fsHistory[0] ) old_path = g_filename_from_utf8( fsHistory[0], -1, NULL, NULL, NULL );
gtk_clist_set_column_widget( GTK_CLIST( CTDirTree ),0,
AddLabel( MSGTR_PLAYLIST_DirectoryTree,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CTDirTree ),0 );
vbox2=AddVBox(
AddFrame( NULL,1,hbox1,1 ),0 );
scrolledwindow2=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow2 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow2,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow2 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLFiles=gtk_clist_new( 1 );
gtk_widget_show( CLFiles );
gtk_container_add( GTK_CONTAINER( scrolledwindow2 ),CLFiles );
gtk_clist_set_column_width( GTK_CLIST( CLFiles ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CLFiles ),GTK_SELECTION_EXTENDED );
gtk_clist_column_titles_show( GTK_CLIST( CLFiles ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLFiles ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLFiles ),0,
AddLabel( MSGTR_PLAYLIST_Files,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CLFiles ),0 );
AddHSeparator( vbox2 );
scrolledwindow3=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow3 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow3,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow3 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLSelected=gtk_clist_new( 2 );
gtk_widget_show( CLSelected );
gtk_container_add( GTK_CONTAINER( scrolledwindow3 ),CLSelected );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),0,295 );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),1,295 );
gtk_clist_set_selection_mode( GTK_CLIST( CLSelected ),GTK_SELECTION_MULTIPLE );
gtk_clist_column_titles_show( GTK_CLIST( CLSelected ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLSelected ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),0,
AddLabel( MSGTR_PLAYLIST_Selected,NULL ) );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),1,
AddLabel( MSGTR_PLAYLIST_Path,NULL ) );
gtk_clist_column_title_passive( GTK_CLIST( CLSelected ),0 );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 );
Add=AddButton( MSGTR_Add,hbuttonbox1 );
Remove=AddButton( MSGTR_Remove,hbuttonbox1 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( PlayList ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&PlayList );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)0 );
sigSel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void*)1 );
sigUnsel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void*)1 );
sigEvent=gtk_signal_connect( GTK_OBJECT( CLSelected ),"event",GTK_SIGNAL_FUNC( plEvent ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( CLSelected ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Add ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( Add ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( Remove ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( Remove ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( Ok ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Ok ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"released",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"key_release_event",GTK_SIGNAL_FUNC( plKeyReleased ),(void*)0 );
gtk_window_add_accel_group( GTK_WINDOW( PlayList ),accel_group );
return PlayList;
}
gint
gtk_dir_tree_open_dir(GtkDirTree *dir_tree, const gchar *path)
{
GtkCTreeNode *root_node, *node;
GtkDirTreeNode *dir_node;
DIR *dir;
gchar *c;
gchar *folder;
gint nlen;
gint new_path, new_node;
gchar *text;
gchar root[5], root1[5], root2[5], root3[5], root4[5];
gchar *aux_path, *real_path;
if((dir=opendir(path)) == NULL) return FALSE;
closedir(dir);
/* GET ABSOLUTE PATH */
sprintf(root,"%s",G_DIR_SEPARATOR_S);
sprintf(root1,"%s.",G_DIR_SEPARATOR_S);
sprintf(root2,"%s..",G_DIR_SEPARATOR_S);
sprintf(root3,"%s..%s",G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
sprintf(root4,"%s.%s",G_DIR_SEPARATOR_S,G_DIR_SEPARATOR_S);
if(path){
gint length;
aux_path = g_strdup(path);
length = strlen(aux_path);
if(strcmp(aux_path + length - 2, root1) == 0){
if(length == 2) {
g_free(aux_path);
aux_path = g_strdup(root);
} else {
aux_path[length - 1] = '\0';
}
} else if(strcmp(aux_path + length - 3, root2) == 0){
if(length == 3) {
g_free(aux_path);
aux_path = g_strdup(root);
} else {
gint i = length - 4;
while(i >= 0){
if(aux_path[i] == root[0]){
aux_path[i+1] = '\0';
break;
}
i--;
}
}
} else if(strcmp(aux_path + length - 4, root3) == 0){
if(length == 4) {
g_free(aux_path);
aux_path = g_strdup(root);
} else {
gint i = length - 5;
while(i >= 0){
if(aux_path[i] == root[0]){
aux_path[i+1] = '\0';
break;
}
i--;
}
}
} else if(strcmp(aux_path + length - 3, root4) == 0){
if(length == 3) {
g_free(aux_path);
aux_path = g_strdup(root);
} else {
aux_path[length - 2] = '\0';
}
}
}
else
aux_path = g_strdup(G_DIR_SEPARATOR_S);
real_path = g_strdup(aux_path);
g_free(aux_path);
c = (gchar *)real_path;
folder = NULL;
nlen = 0;
root_node = gtk_ctree_node_nth(GTK_CTREE(dir_tree), 1);
gtk_ctree_expand(GTK_CTREE(dir_tree), root_node);
new_path = FALSE;
new_node = TRUE;
while(*c != '\0' && *c != '\n' && c != NULL){
nlen++;
folder = (char *)g_realloc(folder, (nlen+1)*sizeof(char));
folder[nlen-1] = *c;
folder[nlen]='\0';
if(*c == G_DIR_SEPARATOR){
if(new_path){
node = GTK_CTREE_ROW(root_node)->children;
while(node){
dir_node = gtk_ctree_node_get_row_data(GTK_CTREE(dir_tree), node);
text = dir_node->path;
if(strcmp(text, folder) == 0){
gtk_ctree_expand(GTK_CTREE(dir_tree), node);
root_node = node;
break;
}
node = GTK_CTREE_NODE_NEXT(node);
}
}
else
{
new_path = TRUE;
}
new_node = FALSE;
} else {
new_node = TRUE;
}
c++;
}
if(new_node){
nlen++;
folder = (char *)g_realloc(folder, (nlen+1)*sizeof(char));
folder[nlen-1] = G_DIR_SEPARATOR;
folder[nlen]='\0';
node = GTK_CTREE_ROW(root_node)->children;
while(node){
dir_node = gtk_ctree_node_get_row_data(GTK_CTREE(dir_tree), node);
text = dir_node->path;
if(strcmp(text, folder) == 0){
gtk_ctree_expand(GTK_CTREE(dir_tree), node);
root_node = node;
break;
}
node = GTK_CTREE_NODE_NEXT(node);
}
}
g_free(folder);
if (gtk_ctree_node_is_visible(GTK_CTREE(dir_tree), root_node) !=
GTK_VISIBILITY_FULL) {
gtk_widget_map(GTK_WIDGET(dir_tree));
gtk_ctree_node_moveto(GTK_CTREE(dir_tree), root_node, 0, 0.5, 0.5);
}
gtk_ctree_select(GTK_CTREE(dir_tree), root_node);
return TRUE;
}
static void
gtk_dir_tree_init (GtkDirTree *dir_tree)
{
GtkCTreeNode *root_node,*mypc_node,*node;
GtkDirTreeNode *dirnode;
gchar *root_text=G_DIR_SEPARATOR_S,*node_text="dummy";
gchar localhost[MAXHOSTNAMELEN];
GtkWidget *widget;
GdkColormap *colormap;
#ifdef G_OS_WIN32
gchar drives[128];
gchar* drive;
#endif
widget = GTK_WIDGET(dir_tree);
colormap = gdk_colormap_get_system();
dir_tree->show_hidden = TRUE;
/* Get the local hostname. */
#ifndef G_OS_WIN32
if ((gethostname (localhost, MAXHOSTNAMELEN) != 0) &&
(getdomainname (localhost, MAXHOSTNAMELEN) != 0))
strcpy (localhost, "LocalHost");
#else
strcpy (localhost, "My PC");
#endif
dir_tree->local_hostname = g_strdup(localhost);
gtk_ctree_construct(GTK_CTREE(dir_tree), 1, 0, NULL);
gtk_clist_set_row_height (GTK_CLIST (dir_tree), 18);
dir_tree->my_pc=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap,
&dir_tree->my_pc_mask,
NULL,mypc_xpm);
dir_tree->folder=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap,
&dir_tree->folder_mask,
NULL,folder_xpm);
dir_tree->ofolder=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap,
&dir_tree->ofolder_mask,
NULL,ofolder_xpm);
dir_tree->dennied=gdk_pixmap_colormap_create_from_xpm_d(NULL, colormap,
&dir_tree->dennied_mask,
NULL,dennied_xpm);
gtk_clist_set_column_auto_resize(GTK_CLIST(dir_tree),0,TRUE);
gtk_clist_set_selection_mode(GTK_CLIST(dir_tree),GTK_SELECTION_SINGLE);
gtk_ctree_set_line_style(GTK_CTREE(dir_tree),GTK_CTREE_LINES_DOTTED);
gtk_signal_connect(GTK_OBJECT(dir_tree),"tree_expand",GTK_SIGNAL_FUNC(expand_tree), NULL);
mypc_node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),NULL,NULL,&dir_tree->local_hostname,4,dir_tree->my_pc,dir_tree->my_pc_mask,dir_tree->my_pc,dir_tree->my_pc_mask,FALSE,FALSE);
dirnode=g_malloc0(sizeof(GtkDirTreeNode));
dirnode->path = dir_tree->local_hostname;
gtk_ctree_node_set_row_data_full(GTK_CTREE(dir_tree),mypc_node,dirnode,destroy_tree);
#ifndef G_OS_WIN32
root_node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),mypc_node,NULL,&root_text,4,dir_tree->folder,dir_tree->folder_mask,dir_tree->ofolder,dir_tree->ofolder_mask,FALSE,FALSE);
dirnode=g_malloc0(sizeof(GtkDirTreeNode));
dirnode->path=g_strdup(G_DIR_SEPARATOR_S);
gtk_ctree_node_set_row_data_full(GTK_CTREE(dir_tree),root_node,dirnode,destroy_tree);
node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),root_node,NULL,&node_text,4,NULL,NULL,NULL,NULL,TRUE,TRUE);
gtk_ctree_expand(GTK_CTREE(dir_tree),mypc_node);
gtk_ctree_select(GTK_CTREE(dir_tree),root_node);
#else
/* On Windoze there isn't one unique root directory "/" but instead
* there are logical drives a:, c: ... . Insert them into the dir_tree.
*/
/* Get the Drives string */
GetLogicalDriveStrings(sizeof(drives), drives);
drive = drives;
/* add an entry for every existing drive */
while (*drive != '\0')
{
root_node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),mypc_node,NULL,&drive,4,dir_tree->folder,dir_tree->folder_mask,dir_tree->ofolder,dir_tree->ofolder_mask,FALSE,FALSE);
dirnode = g_malloc0(sizeof(GtkDirTreeNode));
dirnode->path = g_strdup(drive);
gtk_ctree_node_set_row_data_full(GTK_CTREE(dir_tree),root_node,dirnode,destroy_tree);
node=gtk_ctree_insert_node(GTK_CTREE(dir_tree),root_node,NULL,&node_text, 4,NULL,NULL,NULL,NULL,TRUE,TRUE);
drive += (strlen(drive) + 1);
}
gtk_ctree_expand(GTK_CTREE(dir_tree),mypc_node);
gtk_ctree_select(GTK_CTREE(dir_tree),mypc_node);
#endif
}
static void
tree_expand_node (DirTree * dt, GtkCTreeNode * node, gboolean expand)
{
GtkCTreeNode *child;
DirTreeNode *parent_node;
DirTreeNode *child_node;
DIR *dir;
struct stat stat_buff;
struct dirent *entry;
gboolean has_subdirs, has_link, has_access;
char *old_path;
char *subdir = "?";
char *file_name;
GtkWidget *top = gtk_widget_get_toplevel (GTK_WIDGET (dt));
old_path = g_get_current_dir ();
if (!old_path)
return;
parent_node = gtk_ctree_node_get_row_data (GTK_CTREE (dt), node);
if (chdir (parent_node->path))
{
g_free (old_path);
return;
}
dir = opendir (".");
if (!dir)
{
chdir (old_path);
g_free (old_path);
return;
}
dirtree_set_cursor (top, GDK_WATCH);
gtk_clist_freeze (GTK_CLIST (dt));
tree_collapse (GTK_CTREE (dt), node);
child = NULL;
while ((entry = readdir (dir)))
{
if (!stat (entry->d_name, &stat_buff) && S_ISDIR (stat_buff.st_mode)
&& tree_is_dotfile (entry->d_name, dt->show_dotfile))
{
child_node = g_malloc0 (sizeof (DirTreeNode));
child_node->path =
g_strconcat (parent_node->path, "/", entry->d_name, NULL);
has_link = islink (entry->d_name);
has_access = access (entry->d_name, X_OK);
file_name = entry->d_name;
if (has_access)
{
child = gtk_ctree_insert_node (GTK_CTREE (dt),
node, child,
&file_name,
CTREE_SPACING,
lckfolder_pixmap,
lckfolder_mask, NULL,
NULL, 1, 0);
has_subdirs = FALSE;
}
else if (!strcmp (entry->d_name, "."))
{
child = gtk_ctree_insert_node (GTK_CTREE (dt),
node, child,
&file_name,
CTREE_SPACING,
gofolder_pixmap,
gofolder_mask, NULL,
NULL, 1, 0);
has_subdirs = FALSE;
}
else if (!strcmp (entry->d_name, ".."))
{
child = gtk_ctree_insert_node (GTK_CTREE (dt),
node, child,
&file_name,
CTREE_SPACING,
upfolder_pixmap,
upfolder_mask, NULL,
NULL, 1, 0);
has_subdirs = FALSE;
}
else
{
if (dt->check_dir)
{
if (dt->check_hlinks)
{
if (stat_buff.st_nlink == 2 && dt->show_dotfile)
has_subdirs = TRUE;
else if (stat_buff.st_nlink > 2)
has_subdirs = TRUE;
else if (stat_buff.st_nlink == 1)
has_subdirs =
tree_is_subdirs (entry->d_name,
dt->show_dotfile);
else
has_subdirs = FALSE;
}
else
has_subdirs =
tree_is_subdirs (entry->d_name, dt->show_dotfile);
}
else
has_subdirs = TRUE;
if (access (entry->d_name, X_OK) != 0)
{
has_subdirs = FALSE;
}
if (has_link)
child = gtk_ctree_insert_node (GTK_CTREE (dt),
node, child,
&file_name,
CTREE_SPACING,
lfolder_pixmap,
lfolder_mask,
lofolder_pixmap,
lofolder_mask,
!has_subdirs, 0);
else
child = gtk_ctree_insert_node (GTK_CTREE (dt),
node, child,
&file_name,
CTREE_SPACING,
folder_pixmap,
folder_mask,
ofolder_pixmap,
ofolder_mask,
!has_subdirs, 0);
}
if (child)
{
gtk_ctree_node_set_row_data_full (GTK_CTREE (dt), child,
child_node,
dirtree_destroy_tree);
if (has_subdirs)
gtk_ctree_insert_node (GTK_CTREE (dt),
child, NULL,
&subdir,
CTREE_SPACING,
NULL, NULL, NULL, NULL, 0, 0);
}
}
if (dt->check_events)
while (gtk_events_pending ())
gtk_main_iteration ();
}
closedir (dir);
chdir (old_path);
g_free (old_path);
gtk_ctree_sort_node (GTK_CTREE (dt), node);
if (expand == TRUE)
gtk_ctree_expand (GTK_CTREE (dt), node);
gtk_clist_thaw (GTK_CLIST (dt));
dirtree_set_cursor (top, -1);
}
GtkWidget *
dirtree_new (GtkWidget * win, const gchar * start_path, gboolean check_dir,
gboolean check_hlinks, gboolean show_dotfile, gint line_style,
gint expander_style)
{
GtkWidget *widget;
DirTree *dt;
DirTreeNode *dt_node;
GtkCTreeNode *node = NULL;
char *root = "/", *rp, *tmp;
widget = gtk_type_new (dirtree_get_type ());
#ifndef USE_GTK2
gtk_ctree_construct (GTK_CTREE (widget), 1, 0, NULL);
#endif
dt = DIRTREE (widget);
dt->collapse = FALSE;
dt->check_dir = check_dir;
dt->check_hlinks = check_hlinks;
dt->show_dotfile = show_dotfile;
dt->expander_style = expander_style;
dt->line_style = line_style;
dt->check_events = TRUE;
lock = FALSE;
gtk_clist_set_column_auto_resize (GTK_CLIST (dt), 0, TRUE);
gtk_clist_set_selection_mode (GTK_CLIST (dt), GTK_SELECTION_BROWSE);
gtk_clist_set_row_height (GTK_CLIST (dt), 18);
gtk_ctree_set_expander_style (GTK_CTREE (dt), expander_style);
gtk_ctree_set_line_style (GTK_CTREE (dt), line_style);
folder_pixmap =
gdk_pixmap_create_from_xpm_d (win->window, &folder_mask, NULL,
folder_xpm);
ofolder_pixmap =
gdk_pixmap_create_from_xpm_d (win->window, &ofolder_mask, NULL,
folder_open_xpm);
lfolder_pixmap =
gdk_pixmap_create_from_xpm_d (win->window, &lfolder_mask, NULL,
folder_link_xpm);
lofolder_pixmap =
gdk_pixmap_create_from_xpm_d (win->window, &lofolder_mask, NULL,
folder_link_open_xpm);
lckfolder_pixmap =
gdk_pixmap_create_from_xpm_d (win->window, &lckfolder_mask, NULL,
folder_lock_xpm);
gofolder_pixmap =
gdk_pixmap_create_from_xpm_d (win->window, &gofolder_mask, NULL,
folder_go_xpm);
upfolder_pixmap =
gdk_pixmap_create_from_xpm_d (win->window, &upfolder_mask, NULL,
folder_up_xpm);
node = gtk_ctree_insert_node (GTK_CTREE (dt),
NULL, NULL,
&root, CTREE_SPACING,
folder_pixmap, folder_mask, ofolder_pixmap,
ofolder_mask, FALSE, TRUE);
dt_node = g_malloc0 (sizeof (DirTreeNode));
dt_node->path = g_strdup ("/");
dt_node->scanned = TRUE;
gtk_ctree_node_set_row_data_full (GTK_CTREE (dt), node, dt_node,
dirtree_destroy_tree);
tree_expand_node (dt, node, FALSE);
rp = g_strdup (start_path);
tmp = strtok (rp, "/");
while (tmp)
{
node = dirtree_find_file (dt, node, tmp);
if (!node)
break;
gtk_ctree_expand (GTK_CTREE (dt), node);
gtk_ctree_select (GTK_CTREE (dt), node);
GTK_CLIST (dt)->focus_row =
GTK_CLIST (dt)->rows - g_list_length ((GList *) node);
tmp = strtok (NULL, "/");
}
g_free (rp);
return widget;
}
