ptk-location-view.c

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

{
    GtkTreeIter it;
    GtkTreeSelection* tree_sel;
    GtkTreePath* tree_path;
    char* real_path = NULL;
    int i;
    VFSVolume* vol;

    tree_sel = gtk_tree_view_get_selection( location_view );
    if ( gtk_tree_selection_get_selected( tree_sel, NULL, &it ) )
    {
        gtk_tree_model_get( model, &it, COL_PATH, &real_path, -1 );

        if( ! real_path )
        {
            tree_path = gtk_tree_model_get_path( model, &it );
            i = gtk_tree_path_get_indices( tree_path )[0];
            gtk_tree_path_free( tree_path );
            if( i >= 2 && i < (2 + n_vols) ) /* volume */
            {
                gtk_tree_model_get( model, &it, COL_DATA, &vol, -1 );
                if( ! vfs_volume_is_mounted( vol ) )
                    try_mount( location_view, vol );

                real_path = (char*)vfs_volume_get_mount_point( vol );
                gtk_list_store_set( GTK_LIST_STORE(model), &it, COL_PATH, real_path, -1 );
                return g_strdup(real_path);
            }
        }
    }
    return real_path;
}

void on_volume_event ( VFSVolume* vol, VFSVolumeState state, gpointer user_data )
{
    switch ( state )
    {
    case VFS_VOLUME_ADDED:
        add_volume( vol, TRUE );
        vfs_volume_mount( vol );
        break;
    case VFS_VOLUME_REMOVED:
        remove_volume( vol );
        break;
    case VFS_VOLUME_CHANGED:
        update_volume( vol );
        break;
    /* FIXME:
        VFS_VOLUME_MOUNTED VFS_VOLUME_UNMOUNTED not handled */
    default:
        break;
    }
}

void add_volume( VFSVolume* vol, gboolean set_icon )
{
    GtkIconTheme * icon_theme;
    GdkPixbuf* icon;
    GtkTreeIter it;
    int pos;
    const char* mnt;

    if ( vfs_volume_is_removable( vol ) )
        pos = 2;
    else
        pos = 2 + n_vols;

    mnt = vfs_volume_get_mount_point( vol );
    if( mnt && !*mnt )
        mnt = NULL;
    /* FIXME: Volumes should be sorted */
    gtk_list_store_insert_with_values( GTK_LIST_STORE( model ), &it, pos,
                                       COL_NAME,
                                       vfs_volume_get_disp_name( vol ),
                                       COL_PATH,
                                       mnt,
                                       COL_DATA, vol, -1 );
    if( set_icon )
    {
        icon_theme = gtk_icon_theme_get_default();
        icon = gtk_icon_theme_load_icon ( icon_theme,
                                          vfs_volume_get_icon( vol ),
                                          20, 0, NULL );
        gtk_list_store_set( GTK_LIST_STORE( model ), &it, COL_ICON, icon, -1 );
        if ( icon )
            gdk_pixbuf_unref( icon );
    }
    ++n_vols;
}

void remove_volume( VFSVolume* vol )
{
    GtkTreeIter it;
    VFSVolume* v = NULL;

    gtk_tree_model_get_iter_first( model, &it );
    do
    {
        gtk_tree_model_get( model, &it, COL_DATA, &v, -1 );
    }
    while ( v != vol && gtk_tree_model_iter_next( model, &it ) );
    if ( v != vol )
        return ;
    gtk_list_store_remove( GTK_LIST_STORE( model ), &it );
    --n_vols;
}

void update_volume( VFSVolume* vol )
{
    GtkIconTheme * icon_theme;
    GdkPixbuf* icon;
    GtkTreeIter it;
    VFSVolume* v = NULL;

    gtk_tree_model_get_iter_first( model, &it );
    do
    {
        gtk_tree_model_get( model, &it, COL_DATA, &v, -1 );
    }
    while ( v != vol && gtk_tree_model_iter_next( model, &it ) );
    if ( v != vol )
        return ;

    icon_theme = gtk_icon_theme_get_default();
    icon = gtk_icon_theme_load_icon ( icon_theme,
                                      vfs_volume_get_icon( vol ),
                                      20, 0, NULL );
    gtk_list_store_set( GTK_LIST_STORE( model ), &it,
                        COL_ICON,
                        icon,
                        COL_NAME,
                        vfs_volume_get_disp_name( vol ),
                        COL_PATH,
                        vfs_volume_get_mount_point( vol ), -1 );
    if ( icon )
        gdk_pixbuf_unref( icon );
}

void on_row_activated( GtkTreeView* view, GtkTreePath* tree_path,
                       GtkTreeViewColumn *col, gpointer user_data )
{
    int i;
    VFSVolume* vol;
    GtkTreeIter it;
    GtkWidget* toplevel;
    GdkCursor* cursor;

#if 0
    i = gtk_tree_path_get_indices( tree_path ) [ 0 ];
    if ( i >= 2 && i < ( 2 + n_vols ) )   /* Volume */
    {
        if ( ! gtk_tree_model_get_iter( model, &it, tree_path ) )
            return ;
        gtk_tree_model_get( model, &it, COL_DATA, &vol, -1 );

        if ( ! vfs_volume_is_mounted( vol ) )
        {
            toplevel = gtk_widget_get_toplevel( GTK_WIDGET(view) );
            cursor = gdk_cursor_new_for_display( gdk_display_get_default(), GDK_WATCH );
            gdk_window_set_cursor( toplevel->window, cursor );
            gdk_cursor_unref( cursor );

            if ( ! vfs_volume_mount( vol ) )
            {
                ptk_show_error( GTK_WINDOW( toplevel ),
                                _( "Unable to mount device" ) );
            }
            gdk_window_set_cursor( toplevel->window, NULL );
            if( vfs_volume_get_mount_point( vol ) )
            {
                gtk_list_store_set( GTK_LIST_STORE( model ), &it,
                                    COL_PATH, vfs_volume_get_mount_point( vol ), -1 );
            }
        }
    }
#endif
}

static void on_mount( GtkMenuItem* item, VFSVolume* vol )
{
    if( ! vfs_volume_mount( vol ) )
        ptk_show_error( NULL, _("Unable to mount device") );
}

static void on_umount( GtkMenuItem* item, VFSVolume* vol )
{
    if( ! vfs_volume_umount( vol ) )
        ptk_show_error( NULL, _("Unable to unmount device") );
}

static void on_eject( GtkMenuItem* item, VFSVolume* vol )
{
    if( vfs_volume_is_mounted( vol ) )
        on_umount( item, vol );
    if( ! vfs_volume_eject( vol ) )
        ptk_show_error( NULL, _("Unable to eject device") );
}

gboolean ptk_location_view_is_item_bookmark( GtkTreeView* location_view,
                                             GtkTreeIter* it )
{
    int pos;
    GtkTreePath* tree_path;

    tree_path = gtk_tree_model_get_path( model, it );
    if( ! tree_path )
        return FALSE;

    pos = gtk_tree_path_get_indices( tree_path ) [ 0 ];
    gtk_tree_path_free( tree_path );

    return (pos > ( 2 + n_vols ));
}


gboolean on_button_press_event( GtkTreeView* view, GdkEventButton* evt,
                                gpointer user_data )
{
    GtkTreeIter it;
    GtkTreeSelection* tree_sel;
    GtkTreePath* tree_path;
    int pos;
    GtkMenu* popup;
    GtkWidget* item;
    VFSVolume* vol;

    if( evt->button != 2 && evt->button != 3 )
        return FALSE;

    gtk_tree_view_get_path_at_pos( view, evt->x, evt->y, &tree_path, NULL, NULL, NULL );
    if( !tree_path )
        return FALSE;
    tree_sel = gtk_tree_view_get_selection( view );
    gtk_tree_model_get_iter( model, &it, tree_path );
    pos = gtk_tree_path_get_indices( tree_path ) [ 0 ];
    gtk_tree_path_free( tree_path );
    gtk_tree_selection_select_iter( tree_sel, &it );

    if ( evt->button == 3 )
    {
        if ( pos >= 2 )
        {
            if( pos < ( 2 + n_vols ) )  /* volume */
            {
                popup = GTK_MENU(gtk_menu_new());
                gtk_tree_model_get( model, &it, COL_DATA, &vol, -1 );

                item = gtk_menu_item_new_with_mnemonic( _( "_Mount File System" ) );
                g_signal_connect( item, "activate", G_CALLBACK(on_mount), vol );
                if( vfs_volume_is_mounted( vol ) )
                    gtk_widget_set_sensitive( item, FALSE );

                gtk_menu_shell_append( GTK_MENU_SHELL( popup ), item );

                if( vfs_volume_requires_eject( vol ) )
                {
                    item = gtk_menu_item_new_with_mnemonic( _( "_Eject" ) );
                    g_signal_connect( item, "activate", G_CALLBACK(on_eject), vol );
                }
                else
                {
                    item = gtk_menu_item_new_with_mnemonic( _( "_Unmount File System" ) );
                    g_signal_connect( item, "activate", G_CALLBACK(on_umount), vol );
                }
                if( ! vfs_volume_is_mounted( vol ) )
                    gtk_widget_set_sensitive( item, FALSE );
                gtk_menu_shell_append( GTK_MENU_SHELL( popup ), item );

                gtk_widget_show_all( GTK_WIDGET(popup) );
                g_signal_connect( popup, "selection-done",
                                  G_CALLBACK( gtk_widget_destroy ), NULL );
                gtk_menu_popup( popup, NULL, NULL, NULL, NULL, evt->button, evt->time );
            }
        }
    }

    return FALSE;
}

void ptk_location_view_rename_selected_bookmark( GtkTreeView* location_view )
{
    GtkTreeIter it;
    GtkTreePath* tree_path;
    GtkTreeSelection* tree_sel;
    int pos;
    GtkTreeViewColumn* col;
    char *name, *path;
    GList *l, *renderers;

    tree_sel = gtk_tree_view_get_selection( location_view );
    if( gtk_tree_selection_get_selected( tree_sel, NULL, &it ) )
    {
        tree_path = gtk_tree_model_get_path( model, &it );
        pos = gtk_tree_path_get_indices( tree_path ) [ 0 ];
        if( pos > (2 + n_vols) )
        {
            col = gtk_tree_view_get_column( location_view, 0 );
            renderers = gtk_tree_view_column_get_cell_renderers( col );
            for( l = renderers; l; l = l->next )
            {
                if( GTK_IS_CELL_RENDERER_TEXT(l->data) )
                {
                    g_object_set( G_OBJECT(l->data), "editable", TRUE, NULL );
                    gtk_tree_view_set_cursor_on_cell( location_view, tree_path,
                                                      col,
                                                      GTK_CELL_RENDERER( l->data ),
                                                      TRUE );
                    g_object_set( G_OBJECT(l->data), "editable", FALSE, NULL );
                    break;
                }
            }
            g_list_free( renderers );
        }
        gtk_tree_path_free( tree_path );
    }
}


gboolean ptk_location_view_is_item_volume(  GtkTreeView* location_view, GtkTreeIter* it )
{
    int pos;
    GtkTreePath* tree_path;

    if( n_vols == 0 )
        return FALSE;

    tree_path = gtk_tree_model_get_path( model, it );
    if( ! tree_path )
        return FALSE;

    pos = gtk_tree_path_get_indices( tree_path ) [ 0 ];
    gtk_tree_path_free( tree_path );

    return ( pos > 2 && pos < ( 2 + n_vols ));
}

VFSVolume* ptk_location_view_get_volume(  GtkTreeView* location_view, GtkTreeIter* it )
{
    VFSVolume* vol = NULL;
    gtk_tree_model_get( model, it, COL_DATA, &vol, -1 );
    return vol;
}