transfer_view.py

CoralFTP是一款用Python语言编写的工作在GTK2环境下的FTP客户端软件

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Copyright (C) 1994  Ling Li
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


import gobject, gtk, gtk.gdk
from gtk import *
from gtk import gdk

import string, re, os
from os import path
from urllib import unquote
from threading import Lock
from urlparse import urlsplit

from confirm_file_replace import *
from transfer_queue import *
from ftp_engine import *
from utils import *

class TransferView:

    COL_DIRECTION = 0          # An image used to show transfer direction
    COL_ICON = 1               # An image used to the type of the item
    COL_NAME = 2               # The name of the item
    COL_TARGET = 3             # The target place of the item
    COL_SIZE = 4               # The size of the item
    COL_REMARK = 5
    COL_DATA_DIRECTION = 6     # Should be DIRECTION_DOWN or DIRECTION_UP
    COL_DATA_SOURCE = 7        # The source url of the item
    COL_DATA_TARGET = 8        # The destination url of the item
    COL_DATA_SIZE = 9          # Store size in bytes
    COL_DATA_STATUS = 10       # Transfer status
    COL_DATA_SOURCE_SITE = 11
    COL_DATA_TARGET_SITE = 12
    
    DIRECTION_DOWN = 1         # Download, used in COL_DATA_DIRECTION
    DIRECTION_UP = 2           # Upload, used in COL_DATA_DIRECTION

    TRANSFER_STATUS_READY = 1  # The item is ready for transfer
    TRANSFER_STATUS_FAILED = 2 # The item is failed to transfer
    TRANSFER_STATUS_DOING = 3  # The item is being transfered now
    TRANSFER_STATUS_FINISHED = 4 # The transfer is finished
    TRANSFER_STATUS_SKIPPED = 5 # The item is skipped, the transfer continue
    
    __lock = Lock()
    trans_iter = None          # This point to item being transfering
    
    local_need_refresh = 0     # This means the local view should be
                               # refreshed after transfer
    remote_need_refresh = 0    # This means the remote view should be
                               # refreshed after transfer

    __selections = []
    __selected_count = 0

    __use_custom_queue_font = False
                               # whether use custom queue font
    __queue_font = ''          # custom font name and size
    __text_renderers = []

    def __init__(self, main_window):
        
        ACTIONS = {
            'transfer' : { 'update' : self.on_transfer_action_update,
                           'execute' : self.on_transfer_action_execute },
            'gotodir' : { 'update' : self.on_gotodir_action_update,
                          'execute' : self.on_gotodir_action_execute },
            'move_up' : { 'sensitive' : TRUE,
                          'execute' : self.on_moveup_action_execute },
            'move_down' : { 'sensitive' : TRUE,
                            'execute' : self.on_movedown_action_execute },
            'move_top' : { 'sensitive' : TRUE,
                           'execute' : self.on_movetop_action_execute },
            'move_bottom' : { 'sensitive' : TRUE,
                              'execute' : self.on_movebottom_action_execute},
            'save_queue' : { 'execute' : self.on_save_queue_action_execute},
            'load_queue' : { 'execute' : self.on_load_queue_action_execute},
            'restore_queue' : { 'sensitive' : FALSE },
            'delete' : { 'sensitive' : TRUE,
                         'execute' : self.on_delete_action_execute },
            'edit' : { 'sensitive' : FALSE },
            'queueinfo' : { 'sensitive' : FALSE },
            'clearqueue' : { 'sensitive' : TRUE,
                             'update' : self.on_clearqueue_action_update ,
                             'execute' : self.on_clearqueue_action_execute },
            'freset' : {  'sensitive' : TRUE,
                         'execute' : self.on_freset_action_execute },
            'fresetall' : { 'sensitive' : TRUE,
                            'execute' : self.on_fresetall_action_execute },
            'fclearall' : { 'sensitive' : TRUE,
                            'execute' : self.on_fclearall_action_execute },
            'fmark' : { 'sensitive' : TRUE,
                        'execute' : self.on_fmark_action_execute },
            }

        MENU_ACTIONS = {
            'mi_transfer' : 'transfer',
            'mi_go_to_directory' : 'gotodir',
            'mi_edit' : 'edit',
            'mi_delete' : 'delete',
            'mi_move_up' : 'move_up',
            'mi_move_down' : 'move_down',
            'mi_move_to_top' : 'move_top',
            'mi_move_to_bottom' : 'move_bottom',
            'mi_failed_reset_selected' : 'freset',
            'mi_failed_reset_all' : 'fresetall',
            'mi_clear_all_failed' : 'fclearall',
            'mi_mark_as_failed' : 'fmark',
            'mi_queue_info' : 'queueinfo',
            'mi_restore_queue' : 'restore_queue',
            'mi_load_queue' : 'load_queue',
            'mi_save_queue' : 'save_queue',
            'mi_clear_queue' : 'clearqueue'
            }
        
        self.__main_window = main_window
        self.__config = main_window.coralftp.config
        self.__xml = main_window.xml
        self.__menu_xml = get_glade_xml('transfer_list_menu')
        self.__menu = self.__menu_xml.get_widget('transfer_list_menu')
        self.actions = ActionList(ACTIONS)
        
        self.__model = ListStore(gdk.Pixbuf,
                                 gdk.Pixbuf,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_INT,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_STRING,
                                 gobject.TYPE_ULONG,
                                 gobject.TYPE_INT,
                                 gobject.TYPE_PYOBJECT,
                                 gobject.TYPE_PYOBJECT)
        self.__list = self.__xml.get_widget('tv_transfer_list')
        self.__list.set_model(self.__model)
        self.__list.connect('button-press-event',
                            self.on_list_button_press)
        self.__list.connect('button-release-event',
                            self.on_list_button_release)

        column = TreeViewColumn(_("Name"))
        renderer = CellRendererPixbuf()
        column.pack_start(renderer, expand=FALSE)
        column.add_attribute(renderer, 'pixbuf', self.COL_DIRECTION)
        renderer = CellRendererPixbuf()
        column.pack_start(renderer, expand=FALSE)
        column.add_attribute(renderer, 'pixbuf', self.COL_ICON)
        renderer = CellRendererText()
        self.__text_renderers.append(renderer)
        column.pack_start(renderer, expand=TRUE)
        column.add_attribute(renderer, 'text', self.COL_NAME)
        column.set_resizable(TRUE)
        self.__list.append_column(column)

        renderer = CellRendererText()
        self.__text_renderers.append(renderer)
        column = TreeViewColumn(_("Target"), renderer, text=self.COL_TARGET)
        column.set_resizable(TRUE)
        self.__list.append_column(column)

        renderer = CellRendererText()
        self.__text_renderers.append(renderer)
        renderer.set_property('xalign', 1)
        column = TreeViewColumn(_("Size"), renderer, text=self.COL_SIZE)
        column.set_resizable(TRUE)
        self.__list.append_column(column)

        renderer = CellRendererText()
        self.__text_renderers.append(renderer)
        column = TreeViewColumn(_("Remark"), renderer, text=self.COL_REMARK)
        column.set_resizable(TRUE)
        self.__list.append_column(column)

        # setup fonts
        self.__use_custom_queue_font = config_value(
            self.__config, 'display', 'use_custom_queue_font')
        self.__queue_font = config_value(
            self.__config, 'display', 'queue_font')
        self.__change_font()
        self.__config.notify_add(
            config_key('display', 'use_custom_queue_font'),
            self.on_use_custom_queue_font_change)
        self.__config.notify_add(
            config_key('display', 'queue_font'),
            self.on_queue_font_change)

        # rules hint
        self.__list.set_property('rules-hint',
                                 config_value(self.__config, 'display',
                                              'rules_hint'))
        self.__config.notify_add(
            config_key('display', 'rules_hint'),
            lambda config, id, entry, *args: \
                self.__list.set_property( \
                    'rules-hint', entry.value.get_bool()))

        # connect menu items with actions
        for widget_name, action_name in MENU_ACTIONS.items():
            widget = self.__menu_xml.get_widget(widget_name)
            self.actions[action_name].attach(widget)
        return

    def __count_selection(self, treemodel, path, iter, data):
        data.append(iter)

    def on_list_button_press(self, obj, event):
        self.__selections = []
        selection = self.__list.get_selection()
        selection.selected_foreach(self.__count_selection, self.__selections)
        self.__selected_count = len(self.__selections)
        return
        
    def on_list_button_release(self, obj, event):
        self.__selections = []
        selection = self.__list.get_selection()
        selection.selected_foreach(
            self.__count_selection, self.__selections)
        self.__selected_count = len(self.__selections)
        
        if event.button == 3:
            self.__menu.popup(None, None, None, 0, 0)
        return

    def add_to_queue(self, direction, source, target, size, source_site, \
                     target_site, iter=None):
        """Add new item to the transfer view. Remote path should in URL
        form.  size should be in bytes form. When finished, the iter of
        the new record is return."""

        if iter:
            iter = self.__model.insert_after(iter)
        else:
            iter = self.__model.append()
        self.__model.set_value(iter, self.COL_SIZE, size)
        if direction == TransferView.DIRECTION_UP:
            pixbuf = gdk.pixbuf_new_from_file(
                os.path.join(coralftp_datadir, 'put_arrow.png'))
        elif direction == TransferView.DIRECTION_DOWN:
            pixbuf = gdk.pixbuf_new_from_file(
                os.path.join(coralftp_datadir, 'get_arrow.png'))
        else:
            pixbuf = None
        self.__model.set_value(iter, self.COL_DIRECTION, pixbuf)
        self.__model.set_value(iter, self.COL_DATA_DIRECTION, direction)
        self.__model.set_value(iter, self.COL_DATA_SOURCE, source)
        self.__model.set_value(iter, self.COL_DATA_TARGET, target)
        self.__model.set_value(iter, self.COL_DATA_SIZE, size)
        self.__model.set_value(iter, self.COL_DATA_STATUS,
                               TransferView.TRANSFER_STATUS_READY)
        self.__model.set_value(iter, self.COL_DATA_SOURCE_SITE, source_site)
        self.__model.set_value(iter, self.COL_DATA_TARGET_SITE, target_site)
        if direction == self.DIRECTION_DOWN:
            (scheme, location, path, query, fragment) = urlsplit(source)
            path = string.replace(unquote(path), '//', '/')
            self.__model.set_value(iter, self.COL_NAME, path)
            self.__model.set_value(iter, self.COL_TARGET, target)
            self.__model.set_value(iter, self.COL_REMARK,
                                   'Download from %s' % location)
            self.__model.set_value(iter, self.COL_NAME, path)
        elif direction == self.DIRECTION_UP:
            (scheme, location, path, query, fragment) = urlsplit(target)
            path = string.replace(unquote(path), '//', '/')
            self.__model.set_value(iter, self.COL_NAME, source)
            self.__model.set_value(iter, self.COL_TARGET, path)
            self.__model.set_value(iter, self.COL_REMARK,
                                   'Upload to %s' % location)
        return iter

    def remove_from_queue(self, iter):
        self.__model.remove(iter)
        return

    def get_next(self):
        return self.__model.get_iter_first()

    def start_transfer(self, obj, data):
        """In this method, transfer_next is added to gtk idle sequence."""
        from main import MainWindow

        if self.__main_window.mode == MainWindow.MODE_FTP:
            self.orig_local_path = self.__main_window.local_view.current_path
            self.orig_remote_path = self.__main_window.remote_view.current_path
        self.trans_iter = self.__model.get_iter_first()