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 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;
}
}
/* Insert a new node to the tree. The position is specified through the
* parent-sibling notation, as explained in the introduction above. */
int
clip_GTK_CTREEINSERTNODE(ClipMachine * cm)
{
C_widget *cctree = _fetch_cw_arg(cm);
C_object *cparent = _fetch_cobject(cm,_clip_spar(cm,2));
C_object *csibling = _fetch_cobject(cm,_clip_spar(cm,3));
ClipVar *cvtext = _clip_spar(cm,4);
guint8 spacing = _clip_parni(cm,5);
C_widget *cclosed = _fetch_cwidget(cm,_clip_spar(cm,6));
C_widget *copened = _fetch_cwidget(cm,_clip_spar(cm,7));
gboolean is_leaf = _clip_parl(cm,8);
gboolean expanded = _clip_parl(cm,9);
GtkCTreeNode *new_node, *parent=NULL, *sibling=NULL;
GdkPixmap *pxm_closed=NULL, *pxm_opened=NULL;
GdkBitmap *mask_closed=NULL, *mask_opened=NULL;
C_object *cnew_node;
int i;
gchar * * columns = NULL;
int ncolumns;
CHECKCWID(cctree,GTK_IS_CTREE);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cparent,cparent->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(3,MAP_t,NUMERIC_t); CHECKCOBJOPT(csibling,csibling->type==GTK_TYPE_CTREE_NODE);
CHECKOPT2(4,ARRAY_t,CHARACTER_t); CHECKOPT(5,NUMERIC_t);
CHECKOPT2(6,MAP_t,NUMERIC_t); CHECKCWIDOPT(cclosed,GTK_IS_PIXMAP);
CHECKOPT2(7,MAP_t,NUMERIC_t); CHECKCWIDOPT(copened,GTK_IS_PIXMAP);
CHECKOPT(8,LOGICAL_t); CHECKOPT(9,LOGICAL_t);
if (cparent) parent = GTK_CTREE_NODE(cparent->object);
if (csibling) sibling = GTK_CTREE_NODE(csibling->object);
if (cclosed)
{
pxm_closed=GTK_PIXMAP(cclosed->widget)->pixmap;
mask_closed=GTK_PIXMAP(cclosed->widget)->mask;
}
if (copened)
{
pxm_opened=GTK_PIXMAP(copened->widget)->pixmap;
mask_opened=GTK_PIXMAP(copened->widget)->mask;
}
if (_clip_parinfo(cm,8)==UNDEF_t) is_leaf = TRUE;
if (_clip_parinfo(cm,9)==UNDEF_t) expanded = FALSE;
ncolumns = GTK_CLIST(cctree->widget)->columns;
columns = (gchar**)calloc(sizeof(columns),ncolumns);
for(i=0; i < ncolumns; i++ ) columns[i] = "";
if (cvtext->t.type==ARRAY_t)
{
ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext);
for(i=0; i < acol->count; i++ )
if ( i < acol->count && acol->items[i].t.type == CHARACTER_t )
{
columns[i] = acol->items[i].s.str.buf;
LOCALE_TO_UTF(columns[i]);
}
}
if (cvtext->t.type==CHARACTER_t)
{
columns[0] = _clip_parc(cm,2);
LOCALE_TO_UTF(columns[0]);
}
new_node = gtk_ctree_insert_node(GTK_CTREE(cctree->widget),
parent,sibling,columns,spacing,pxm_closed,mask_closed,
pxm_opened,mask_opened,is_leaf,expanded);
if (new_node)
{
cnew_node = _register_object(cm,new_node,GTK_TYPE_CTREE_NODE,NULL,NULL);
if (cnew_node) _clip_mclone(cm,RETPTR(cm),&cnew_node->obj);
gtk_ctree_node_set_row_data_full(GTK_CTREE(cctree->widget),
new_node,cnew_node,(GtkDestroyNotify)destroy_c_object);
}
#ifdef OS_CYGWIN
if (cvtext->t.type==ARRAY_t)
{
ClipArrVar *acol = (ClipArrVar*)_clip_vptr(cvtext);
for(i=0; i < acol->count; i++ )
if ( i < acol->count && acol->items[i].t.type == CHARACTER_t )
FREE_TEXT(columns[i]);
}
if (cvtext->t.type==CHARACTER_t)
FREE_TEXT(columns[0]);
#endif
if (columns) free(columns);
return 0;
err:
return 1;
}
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;
}
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;
}
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;
}
}
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;
}
