/* * Run default action of specified file. * Full path of the file is required by this function. */ gboolean vfs_file_info_open_file( VFSFileInfo* fi, const char* file_path, GError** err ) { VFSMimeType * mime_type; char* app_name; VFSAppDesktop* app; GList* files = NULL; gboolean ret = FALSE; char* argv[ 2 ]; if ( vfs_file_info_is_executable( fi, file_path ) ) { argv[ 0 ] = (char *) file_path; argv[ 1 ] = '\0'; ret = g_spawn_async( NULL, argv, NULL, G_SPAWN_STDOUT_TO_DEV_NULL| G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, err ); } else { mime_type = vfs_file_info_get_mime_type( fi ); app_name = vfs_mime_type_get_default_action( mime_type ); if ( app_name ) { app = vfs_app_desktop_new( app_name ); if ( ! vfs_app_desktop_get_exec( app ) ) app->exec = g_strdup( app_name ); /* FIXME: app->exec */ files = g_list_prepend( files, (gpointer) file_path ); /* FIXME: working dir is needed */ ret = vfs_app_desktop_open_files( gdk_screen_get_default(), NULL, app, files, err ); g_list_free( files ); vfs_app_desktop_unref( app ); g_free( app_name ); } vfs_mime_type_unref( mime_type ); } return ret; }
void on_dlg_response ( GtkDialog *dialog, gint response_id, gpointer user_data ) { FilePropertiesDialogData * data; PtkFileTask* task; gboolean mod_change; uid_t uid = -1; gid_t gid = -1; const char* owner_name; const char* group_name; int i; GList* l; GList* file_list; char* file_path; GtkWidget* ask_recursive; VFSFileInfo* file; GtkAllocation allocation; gtk_widget_get_allocation ( GTK_WIDGET( dialog ), &allocation ); int width = allocation.width; int height = allocation.height; if ( width && height ) { char* str = g_strdup_printf( "%d", width ); xset_set( "app_dlg", "s", str ); g_free( str ); str = g_strdup_printf( "%d", height ); xset_set( "app_dlg", "z", str ); g_free( str ); } data = ( FilePropertiesDialogData* ) g_object_get_data( G_OBJECT( dialog ), "DialogData" ); if ( data ) { if ( data->update_label_timer ) g_source_remove( data->update_label_timer ); data->cancel = TRUE; if ( data->calc_size_thread ) g_thread_join( data->calc_size_thread ); if ( response_id == GTK_RESPONSE_OK ) { GtkWidget* open_with; /* Set default action for mimetype */ if( ( open_with = (GtkWidget*)g_object_get_data( G_OBJECT(dialog), "open_with" ) ) ) { GtkTreeModel* model = gtk_combo_box_get_model( GTK_COMBO_BOX(open_with) ); GtkTreeIter it; if( model && gtk_combo_box_get_active_iter( GTK_COMBO_BOX(open_with), &it ) ) { char* action; gtk_tree_model_get( model, &it, 2, &action, -1 ); if( action ) { file = ( VFSFileInfo* ) data->file_list->data; VFSMimeType* mime = vfs_file_info_get_mime_type( file ); vfs_mime_type_set_default_action( mime, action ); vfs_mime_type_unref( mime ); g_free( action ); } } } /* Check if we need chown */ owner_name = gtk_entry_get_text( data->owner ); if ( owner_name && *owner_name && (!data->owner_name || strcmp( owner_name, data->owner_name ) ) ) { uid = uid_from_name( owner_name ); if ( uid == -1 ) { ptk_show_error( GTK_WINDOW( dialog ), _("Error"), _( "Invalid User" ) ); return ; } } group_name = gtk_entry_get_text( data->group ); if ( group_name && *group_name && (!data->group_name || strcmp( group_name, data->group_name ) ) ) { gid = gid_from_name( group_name ); if ( gid == -1 ) { ptk_show_error( GTK_WINDOW( dialog ), _("Error"), _( "Invalid Group" ) ); return ; } } for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { if ( gtk_toggle_button_get_inconsistent( data->chmod_btns[ i ] ) ) { data->chmod_states[ i ] = 2; /* Don't touch this bit */ } else if ( data->chmod_states[ i ] != gtk_toggle_button_get_active( data->chmod_btns[ i ] ) ) { mod_change = TRUE; data->chmod_states[ i ] = gtk_toggle_button_get_active( data->chmod_btns[ i ] ); } else /* Don't change this bit */ { data->chmod_states[ i ] = 2; } } if ( uid != -1 || gid != -1 || mod_change ) { file_list = NULL; for ( l = data->file_list; l; l = l->next ) { file = ( VFSFileInfo* ) l->data; file_path = g_build_filename( data->dir_path, vfs_file_info_get_name( file ), NULL ); file_list = g_list_prepend( file_list, file_path ); } task = ptk_file_task_new( VFS_FILE_TASK_CHMOD_CHOWN, file_list, NULL, GTK_WINDOW(gtk_widget_get_parent( GTK_WIDGET( dialog ) )), NULL ); //MOD ptk_file_task_set_recursive( task, gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( data->recurse ) ) ); /* for ( l = data->file_list; l; l = l->next ) { file = ( VFSFileInfo* ) l->data; if ( vfs_file_info_is_dir( file ) ) { ask_recursive = gtk_message_dialog_new( GTK_WINDOW( data->dlg ), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _( "Do you want to recursively apply these changes to all files and sub-folders?" ) ); ptk_file_task_set_recursive( task, ( GTK_RESPONSE_YES == gtk_dialog_run( GTK_DIALOG( ask_recursive ) ) ) ); gtk_widget_destroy( ask_recursive ); break; } } */ if ( mod_change ) { /* If the permissions of file has been changed by the user */ ptk_file_task_set_chmod( task, data->chmod_states ); } /* For chown */ ptk_file_task_set_chown( task, uid, gid ); ptk_file_task_run( task ); /* * This file list will be freed by file operation, so we don't * need to do this. Just set the pointer to NULL. */ data->file_list = NULL; } } g_free( data->owner_name ); g_free( data->group_name ); /* *NOTE: File operation chmod/chown will free the list when it's done, *and we only need to free it when there is no file operation applyed. */ g_slice_free( FilePropertiesDialogData, data ); } gtk_widget_destroy( GTK_WIDGET( dialog ) ); }
GtkWidget* file_properties_dlg_new( GtkWindow* parent, const char* dir_path, GList* sel_files, int page ) { GtkBuilder* builder = _gtk_builder_new_from_file( PACKAGE_UI_DIR "/file_properties.ui", NULL ); GtkWidget * dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" ); GtkNotebook* notebook = (GtkNotebook*)gtk_builder_get_object( builder, "notebook" ); FilePropertiesDialogData* data; gboolean need_calc_size = TRUE; VFSFileInfo *file, *file2; VFSMimeType* mime; const char* multiple_files = _( "( multiple files )" ); const char* calculating; GtkWidget* name = (GtkWidget*)gtk_builder_get_object( builder, "file_name" ); GtkWidget* location = (GtkWidget*)gtk_builder_get_object( builder, "location" ); gtk_editable_set_editable ( GTK_EDITABLE( location ), FALSE ); GtkWidget* mime_type = (GtkWidget*)gtk_builder_get_object( builder, "mime_type" ); GtkWidget* open_with = (GtkWidget*)gtk_builder_get_object( builder, "open_with" ); GtkWidget* mtime = (GtkWidget*)gtk_builder_get_object( builder, "mtime" ); GtkWidget* atime = (GtkWidget*)gtk_builder_get_object( builder, "atime" ); char buf[ 64 ]; char buf2[ 32 ]; const char* time_format = "%Y-%m-%d %H:%M"; gchar* disp_path; gchar* file_type; int i; GList* l; gboolean same_type = TRUE; gboolean is_dirs = FALSE; char *owner_group, *tmp; gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 ); ptk_dialog_fit_small_screen( GTK_DIALOG(dlg) ); int width = xset_get_int( "app_dlg", "s" ); int height = xset_get_int( "app_dlg", "z" ); if ( width && height ) gtk_window_set_default_size( GTK_WINDOW( dlg ), width, height ); data = g_slice_new0( FilePropertiesDialogData ); /* FIXME: When will the data be freed??? */ g_object_set_data( G_OBJECT( dlg ), "DialogData", data ); data->file_list = sel_files; data->dlg = dlg; data->dir_path = g_strdup( dir_path ); disp_path = g_filename_display_name( dir_path ); //gtk_label_set_text( GTK_LABEL( location ), disp_path ); gtk_entry_set_text( GTK_ENTRY( location ), disp_path ); g_free( disp_path ); data->total_size_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "total_size" ) ); data->size_on_disk_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "size_on_disk" ) ); data->count_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "count" ) ); data->owner = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "owner" ) ); data->group = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "group" ) ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { data->chmod_btns[ i ] = GTK_TOGGLE_BUTTON( (GtkWidget*)gtk_builder_get_object( builder, chmod_names[ i ] ) ); } //MOD VFSMimeType* type; VFSMimeType* type2 = NULL; for ( l = sel_files; l ; l = l->next ) { file = ( VFSFileInfo* ) l->data; type = vfs_file_info_get_mime_type( file ); if ( !type2 ) type2 = vfs_file_info_get_mime_type( file ); if ( vfs_file_info_is_dir( file ) ) is_dirs = TRUE; if ( type != type2 ) same_type = FALSE; vfs_mime_type_unref( type ); if ( is_dirs && !same_type ) break; } if ( type2 ) vfs_mime_type_unref( type2 ); data->recurse = (GtkWidget*)gtk_builder_get_object( builder, "recursive" ); gtk_widget_set_sensitive( data->recurse, is_dirs ); /* //MOD for ( l = sel_files; l && l->next; l = l->next ) { VFSMimeType *type, *type2; file = ( VFSFileInfo* ) l->data; file2 = ( VFSFileInfo* ) l->next->data; type = vfs_file_info_get_mime_type( file ); type2 = vfs_file_info_get_mime_type( file2 ); if ( type != type2 ) { vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); same_type = FALSE; break; } vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); } */ file = ( VFSFileInfo* ) sel_files->data; if ( same_type ) { mime = vfs_file_info_get_mime_type( file ); file_type = g_strdup_printf( "%s ( %s )", vfs_mime_type_get_description( mime ), vfs_mime_type_get_type( mime ) ); gtk_label_set_text( GTK_LABEL( mime_type ), file_type ); g_free( file_type ); vfs_mime_type_unref( mime ); } else { gtk_label_set_text( GTK_LABEL( mime_type ), _( "( multiple types )" ) ); } /* Open with... * Don't show this option menu if files of different types are selected, * ,the selected file is a folder, or its type is unknown. */ if( ! same_type || vfs_file_info_is_dir( file ) || vfs_file_info_is_desktop_entry( file ) || vfs_file_info_is_unknown_type( file ) || vfs_file_info_is_executable( file, NULL ) ) { /* if open with shouldn't show, destroy it. */ gtk_widget_destroy( open_with ); open_with = NULL; gtk_widget_destroy( (GtkWidget*)gtk_builder_get_object( builder, "open_with_label" ) ); } else /* Add available actions to the option menu */ { GtkTreeIter it; char **action, **actions; mime = vfs_file_info_get_mime_type( file ); actions = vfs_mime_type_get_actions( mime ); GtkCellRenderer* renderer; GtkListStore* model; gtk_cell_layout_clear( GTK_CELL_LAYOUT(open_with) ); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, FALSE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with), renderer, "pixbuf", 0, NULL ); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, TRUE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with),renderer, "text", 1, NULL ); model = gtk_list_store_new( 3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); if( actions ) { for( action = actions; *action; ++action ) { VFSAppDesktop* desktop; GdkPixbuf* icon; desktop = vfs_app_desktop_new( *action ); gtk_list_store_append( model, &it ); icon = vfs_app_desktop_get_icon(desktop, 20, TRUE); gtk_list_store_set( model, &it, 0, icon, 1, vfs_app_desktop_get_disp_name(desktop), 2, *action, -1 ); if( icon ) g_object_unref( icon ); vfs_app_desktop_unref( desktop ); } } else { g_object_set_data( G_OBJECT(open_with), "prev_sel", GINT_TO_POINTER(-1) ); } /* separator */ gtk_list_store_append( model, &it ); gtk_list_store_append( model, &it ); gtk_list_store_set( model, &it, 0, NULL, 1, _("Choose..."), -1 ); gtk_combo_box_set_model( GTK_COMBO_BOX(open_with), GTK_TREE_MODEL(model) ); gtk_combo_box_set_row_separator_func( GTK_COMBO_BOX(open_with), combo_sep, NULL, NULL ); gtk_combo_box_set_active(GTK_COMBO_BOX(open_with), 0); g_signal_connect( open_with, "changed", G_CALLBACK(on_combo_change), mime ); /* vfs_mime_type_unref( mime ); */ /* We can unref mime when combo box gets destroyed */ g_object_weak_ref( G_OBJECT(open_with), (GWeakNotify)vfs_mime_type_unref, mime ); } g_object_set_data( G_OBJECT(dlg), "open_with", open_with ); /* Multiple files are selected */ if ( sel_files && sel_files->next ) { gtk_widget_set_sensitive( name, FALSE ); gtk_entry_set_text( GTK_ENTRY( name ), multiple_files ); gtk_label_set_text( GTK_LABEL( mtime ), "-" ); gtk_label_set_text( GTK_LABEL( atime ), "-" ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { gtk_toggle_button_set_inconsistent ( data->chmod_btns[ i ], TRUE ); data->chmod_states[ i ] = 2; /* Don't touch this bit */ g_signal_connect( G_OBJECT( data->chmod_btns[ i ] ), "toggled", G_CALLBACK( on_chmod_btn_toggled ), data ); } } else { /* special processing for files with special display names */ if( vfs_file_info_is_desktop_entry( file ) ) { char* disp_name = g_filename_display_name( file->name ); gtk_entry_set_text( GTK_ENTRY( name ), disp_name ); g_free( disp_name ); } else gtk_entry_set_text( GTK_ENTRY( name ), vfs_file_info_get_disp_name( file ) ); gtk_editable_set_editable ( GTK_EDITABLE( name ), FALSE ); if ( ! vfs_file_info_is_dir( file ) ) { /* Only single "file" is selected, so we don't need to caculate total file size */ need_calc_size = FALSE; sprintf( buf, _("%s ( %llu bytes )"), vfs_file_info_get_disp_size( file ), ( guint64 ) vfs_file_info_get_size( file ) ); gtk_label_set_text( data->total_size_label, buf ); vfs_file_size_to_string( buf2, vfs_file_info_get_blocks( file ) * 512 ); sprintf( buf, _("%s ( %llu bytes )"), buf2, ( guint64 ) vfs_file_info_get_blocks( file ) * 512 ); gtk_label_set_text( data->size_on_disk_label, buf ); gtk_label_set_text( data->count_label, _("1 file") ); } gtk_label_set_text( GTK_LABEL( mtime ), vfs_file_info_get_disp_mtime( file ) ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_atime( file ) ) ); gtk_label_set_text( GTK_LABEL( atime ), buf ); owner_group = (char *) vfs_file_info_get_disp_owner( file ); tmp = strchr( owner_group, ':' ); data->owner_name = g_strndup( owner_group, tmp - owner_group ); gtk_entry_set_text( GTK_ENTRY( data->owner ), data->owner_name ); data->group_name = g_strdup( tmp + 1 ); gtk_entry_set_text( GTK_ENTRY( data->group ), data->group_name ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { if ( data->chmod_states[ i ] != 2 ) /* allow to touch this bit */ { data->chmod_states[ i ] = ( vfs_file_info_get_mode( file ) & chmod_flags[ i ] ? 1 : 0 ); gtk_toggle_button_set_active( data->chmod_btns[ i ], data->chmod_states[ i ] ); } } } if ( need_calc_size ) { /* The total file size displayed in "File Properties" is not completely calculated yet. So "Calculating..." is displayed. */ calculating = _( "Calculating..." ); gtk_label_set_text( data->total_size_label, calculating ); gtk_label_set_text( data->size_on_disk_label, calculating ); g_object_set_data( G_OBJECT( dlg ), "calc_size", data ); data->calc_size_thread = g_thread_create ( ( GThreadFunc ) calc_size, data, TRUE, NULL ); data->update_label_timer = g_timeout_add( 250, ( GSourceFunc ) on_update_labels, data ); } g_signal_connect( dlg, "response", G_CALLBACK(on_dlg_response), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "ok_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "cancel_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_object_unref( builder ); gtk_notebook_set_current_page( notebook, page ); gtk_window_set_transient_for( GTK_WINDOW( dlg ), parent ); return dlg; }