ptk-file-task.c

台湾人开发的Linux下的文件管理器

/*
*  C Implementation: ptk-file-task
*
* Description: 
*
*
* Author: Hong Jen Yee (PCMan) <pcman.tw (AT) gmail.com>, (C) 2006
*
* Copyright: See COPYING file that comes with this distribution
*
*/

#include <glib.h>
#include <glib/gi18n.h>
#include "glib-mem.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>

#include "ptk-file-task.h"
#include "ptk-utils.h"

static gboolean open_up_progress_dlg( PtkFileTask* task );

static void on_vfs_file_task_progress_cb( VFSFileTask* task,
                                          int percent,
                                          const char* src_file,
                                          const char* dest_file,
                                          gpointer user_data );

static gboolean on_vfs_file_task_state_cb( VFSFileTask* task,
                                           VFSFileTaskState state,
                                           gpointer state_data,
                                           gpointer user_data );

static gboolean query_overwrite( PtkFileTask* task, char** new_dest );

PtkFileTask* ptk_file_task_new( VFSFileTaskType type,
                                GList* src_files,
                                const char* dest_dir,
                                GtkWindow* parent_window )
{
    PtkFileTask * task = g_slice_new0( PtkFileTask );
    task->task = vfs_task_new( type, src_files, dest_dir );
    vfs_file_task_set_progress_callback( task->task,
                                         on_vfs_file_task_progress_cb,
                                         task );
    vfs_file_task_set_state_callback( task->task,
                                      on_vfs_file_task_state_cb, task );
    task->parent_window = parent_window;
    return task;
}

void ptk_file_task_destroy( PtkFileTask* task )
{
    if ( task->task )
        vfs_file_task_free( task->task );
    if ( task->progress_dlg )
        gtk_widget_destroy( task->progress_dlg );
    if ( task->timeout )
        g_source_remove( task->timeout );
    g_slice_free( PtkFileTask, task );
}

void ptk_file_task_set_complete_notify( PtkFileTask* task,
                                        GFunc callback,
                                        gpointer user_data )
{
    task->complete_notify = callback;
    task->user_data = user_data;
}

void ptk_file_task_run( PtkFileTask* task )
{
    task->timeout = g_timeout_add( 500,
                                   ( GSourceFunc ) open_up_progress_dlg, task );
    vfs_file_task_run( task->task );
}

void ptk_file_task_cancel( PtkFileTask* task )
{
    vfs_file_task_abort( task->task );
}

void on_progress_dlg_response( GtkDialog* dlg, int response, PtkFileTask* task )
{
    switch ( response )
    {
    case GTK_RESPONSE_CANCEL:
    case GTK_RESPONSE_NONE:
        vfs_file_task_try_abort( task->task );
        break;
    }
}

gboolean open_up_progress_dlg( PtkFileTask* task )
{
    GtkLabel * action;
    GtkLabel* from;
    GtkLabel* to;
    GtkLabel* cur;
    GtkTable* table;
    GtkLabel* label;

    const char * actions[] =
        {
            N_( "Move: " ),
            N_( "Copy: " ),
            N_( "Delete: " ),
            N_( "Link: " ),
            N_( "Change Properties: " )
        };
    const char* titles[] =
        {
            N_( "Moving..." ),
            N_( "Copying..." ),
            N_( "Deleting..." ),
            N_( "Linking..." ),
            N_( "Changing Properties" )
        };

    gdk_threads_enter();

    g_source_remove( task->timeout );
    task->timeout = 0;

    task->progress_dlg = gtk_dialog_new_with_buttons(
                             _( titles[ task->task->type ] ),
                             task->parent_window,
                             0, GTK_STOCK_CANCEL,
                             GTK_RESPONSE_CANCEL, NULL );

    table = GTK_TABLE(gtk_table_new( 4, 2, FALSE ));
    gtk_container_set_border_width( GTK_CONTAINER ( table ), 4 );
    gtk_table_set_row_spacings( table, 4 );
    gtk_table_set_col_spacings( table, 4 );

    /* From: */
    label = GTK_LABEL(gtk_label_new( _( actions[ task->task->type ] ) ));
    gtk_misc_set_alignment( GTK_MISC ( label ), 0, 0.5 );
    gtk_table_attach( table,
                      GTK_WIDGET(label),
                      0, 1, 0, 1, GTK_FILL, 0, 0, 0 );
    task->from = GTK_LABEL(gtk_label_new( task->task->current_file ));
    gtk_misc_set_alignment( GTK_MISC ( task->from ), 0, 0.5 );
    gtk_label_set_ellipsize( task->from, PANGO_ELLIPSIZE_MIDDLE );
    gtk_table_attach( table,
                      GTK_WIDGET( task->from ),
                      1, 2, 0, 1, GTK_FILL, 0, 0, 0 );

    /* To: */
    if ( task->task->dest_dir )
    {
        /* To: <Destination folder>
        ex. Copy file to..., Move file to...etc. */
        label = GTK_LABEL(gtk_label_new( _( "To:" ) ));
        gtk_misc_set_alignment( GTK_MISC ( label ), 0, 0.5 );
        gtk_table_attach( table,
                          GTK_WIDGET(label),
                          0, 1, 1, 2, GTK_FILL, 0, 0, 0 );
        task->to = GTK_LABEL(gtk_label_new( task->task->dest_dir ));
        gtk_misc_set_alignment( GTK_MISC ( task->to ), 0, 0.5 );
        gtk_label_set_ellipsize( task->to, PANGO_ELLIPSIZE_MIDDLE );
        gtk_table_attach( table,
                          GTK_WIDGET( task->to ),
                          1, 2, 1, 2, GTK_FILL, 0, 0, 0 );
    }

    /* Processing: */
    /* Processing: <Name of currently proccesed file> */
    label = GTK_LABEL(gtk_label_new( _( "Processing:" ) ));
    gtk_misc_set_alignment( GTK_MISC ( label ), 0, 0.5 );
    gtk_table_attach( table,
                      GTK_WIDGET(label),
                      0, 1, 2, 3, GTK_FILL, 0, 0, 0 );

    /* Preparing to do some file operation (Copy, Move, Delete...) */
    task->current = GTK_LABEL(gtk_label_new( _( "Preparing..." ) ));
    gtk_label_set_ellipsize( task->current, PANGO_ELLIPSIZE_MIDDLE );
    gtk_misc_set_alignment( GTK_MISC ( task->current ), 0, 0.5 );
    gtk_table_attach( table,
                      GTK_WIDGET( task->current ),
                      1, 2, 2, 3, GTK_FILL, 0, 0, 0 );

    /* Progress: */
    label = GTK_LABEL(gtk_label_new( _( "Progress:" ) ));
    gtk_misc_set_alignment( GTK_MISC ( label ), 0, 0.5 );
    gtk_table_attach( table,
                      GTK_WIDGET(label),
                      0, 1, 3, 4, GTK_FILL, 0, 0, 0 );
    task->progress = GTK_PROGRESS_BAR(gtk_progress_bar_new());
    gtk_table_attach( table,
                      GTK_WIDGET( task->progress ),
                      1, 2, 3, 4, GTK_FILL | GTK_EXPAND, 0, 0, 0 );

    gtk_box_pack_start( GTK_BOX( GTK_DIALOG( task->progress_dlg ) ->vbox ),
                        GTK_WIDGET( table ),
                        TRUE, TRUE, 0 );

    gtk_window_set_default_size( GTK_WINDOW( task->progress_dlg ),
                                 400, -1 );
    gtk_button_box_set_layout ( GTK_BUTTON_BOX ( GTK_DIALOG( task->progress_dlg ) ->action_area ),
                                GTK_BUTTONBOX_END );
    gtk_window_set_type_hint ( GTK_WINDOW ( task->progress_dlg ),
                               GDK_WINDOW_TYPE_HINT_DIALOG );
    gtk_window_set_gravity ( GTK_WINDOW ( task->progress_dlg ),
                             GDK_GRAVITY_NORTH_EAST );

    g_signal_connect( task->progress_dlg, "response",
                      G_CALLBACK( on_progress_dlg_response ), task );
    gtk_widget_show_all( task->progress_dlg );

    gdk_threads_leave();

    return TRUE;
}

void ptk_file_task_set_chmod( PtkFileTask* task,
                              guchar* chmod_actions )
{
    vfs_file_task_set_chmod( task->task, chmod_actions );
}

void ptk_file_task_set_chown( PtkFileTask* task,
                              uid_t uid, gid_t gid )
{
    vfs_file_task_set_chown( task->task, uid, gid );
}

void ptk_file_task_set_recursive( PtkFileTask* task, gboolean recursive )
{
    vfs_file_task_set_recursive( task->task, recursive );
}

void on_vfs_file_task_progress_cb( VFSFileTask* task,
                                   int percent,
                                   const char* src_file,
                                   const char* dest_file,
                                   gpointer user_data )
{
    PtkFileTask * data = ( PtkFileTask* ) user_data;
    char* ufile_path;
    char percent_str[ 16 ];

    if ( ! data->progress_dlg )
        return ;

    gdk_threads_enter();

    /* update current src file */
    if ( data->old_src_file != src_file )
    {
        data->old_src_file = src_file;
        ufile_path = g_filename_display_name( src_file );
        gtk_label_set_text( data->current, ufile_path );
        g_free( ufile_path );
    }

    /* update current dest file */
    if ( data->old_dest_file != dest_file )