local_view.py

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

            self.set_path(os.getcwd())
        return

    def __getattr__(self, name):
        if name == 'model':
            return self.__model
        elif name == 'current_path':
            return self.__current_path
        elif name == 'main_window':
            return self.__main_window
        else:
            raise AttributeError, name

    def __count_selection(self, treemodel, path, iter, data):
        info = self.__model.get_value(iter, LocalView.COL_INFO)
        if info.name != '..':
            data.append(iter)
        return

    def __select_func(self, *args):
        return self.__change_selection_now

    def on_list_button_press(self, obj, event):
        """In this function, double click of left button is processed.
        The basic action is:
        If only one item is selected and it is a folder, enter that
        directory.
        If multiple items are selected and another view is remote
        view, transfer them."""

        if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1:
            self.__change_selection_now = True
        if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
            self.__change_selection_now = False

        self.__main_window.set_active_view(self)
        
        selection = self.__list.get_selection()
        self.__selections = []
        selection.selected_foreach(self.__count_selection, self.__selections)
        self.__selected_count = len(self.__selections)
        self.__update_status1()
        
        if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:

            # if selection is parent directory
            if selection.count_selected_rows() == 1 and self.__selected_count == 0:
                file_path = os.path.dirname(self.__current_path)
                self.set_path(file_path)
            
            # if only one item is selected and it is a folder
            if self.__selected_count == 1:
                info = self.__model.get_value(self.__selections[0], LocalView.COL_INFO)
                file_path = os.path.join(self.__current_path, info.name)
                if os.path.isdir(file_path):
                    # for directory, enter it
                    self.set_path(file_path)
                else:
                    # the default action for double click is transfer
                    pass
        return

    def on_list_button_release(self, obj, event):
        """The right cilck is processed in this method. By default,
        a popup menu is showed."""
        
        selection = self.__list.get_selection()
        self.__selected_count = selection.count_selected_rows()
        self.__selections = []
        selection.selected_foreach(self.__count_selection, self.__selections)
        self.__update_status1()
        
        if event.button == 3:
            self.__menu.popup(None, None, None, 0, 0)
        return

    def on_cmb_dir_changed(self, obj, *args):
        iter = self.__cmb_dir.get_active_iter()
        if iter == None: return
        v = self.__cmb_dir.get_model().get_value(iter, 0)
        if v != self.__current_path:
            self.set_path(v)
        return
    
    def set_active_view(self, active=FALSE):
        if active:
            self.active_indicator.set_name('active_view_indicator')
        else:
            self.active_indicator.set_name('')
        return

    def set_path(self, new_path):
        """Set the current directory of the view. After set, the view will be
        refreshed."""
        if isinstance(new_path, unicode):
            self.__current_path = new_path
        else:
            self.__current_path = utf8_to_unicode(new_path)
        self.__cmb_dir.child.set_text(self.__current_path)
        self.__status2.set_text(self.__current_path)
        self.refresh()
        # display status1
        self.__update_status1()
        
        model = self.__cmb_dir.get_model()
        iter = model.get_iter_first()
        found = False
        while iter != None:
            v = model.get_value(iter, 0)
            if v == new_path:
                found = True
                break
            iter = model.iter_next(iter)
        if not found:
            model.append((new_path,))
        return

    def __update_status1(self):
        display_file_size_as = config_value(self.__config, 'display',
                                            'display_file_size_as')
        if self.__folder_count > 1:
            text = _("%d Folders") % self.__folder_count
        else:
            text = _("%d Folder") % self.__folder_count
        if self.__file_count > 1:
            text = _("%s, %d Files") % (text, self.__file_count)
        else:
            text = _("%s, %d File") % (text, self.__file_count)
        total = self.__folder_count + self.__file_count
        text = _("%s, %d Total") % (text, total)
        if self.__selected_count != 0:
            size = 0
            for iter in self.__selections:
                info = self.__model.get_value(iter, LocalView.COL_INFO)
                if not info.is_dir():
                    size = size + info.size
            size = format_size(display_file_size_as, size)
            if size[-1] != 'B': size = size + _(" bytes")
            text = text + _(", %d Selected(%s)") % (self.__selected_count, size)
        else:
            iter = self.__model.get_iter_first()
            size = 0
            while iter:
                info = self.__model.get_value(iter, LocalView.COL_INFO)
                if not info.is_dir():
                    size = size + info.size
                iter = self.__model.iter_next(iter)
            size = format_size(display_file_size_as, size)
            text = text + '(%s)' % (size)
        self.__status1.set_text(text)
        return

    def refresh(self):
        self.__folder_count = 0
        self.__file_count = 0
        self.__selected_count = 0
        self.__selections = []
        self.__model.clear()
        display_file_size_as = config_value(self.__config, 'display',
                                            'display_file_size_as')
        #dir = vfs.DirectoryHandle(unicode_to_utf8(self.__current_path))
        dir = ['..']
        dir.extend(os.listdir(self.__current_path))
        for filename in dir:
            if file.name == '.': continue
            
            iter = self.__model.append()
            info = LocalFileInfo(os.path.join(self.__current_path, filename))
            self.__model.set_value(iter, LocalView.COL_INFO, info)
            
            if info.name == '..':
                image = gdk.pixbuf_new_from_file(
                    os.path.join(coralftp_datadir, 'parent_dir.png'))
                self.__model.set_value(iter, LocalView.COL_ICON, image)
                self.__model.set_value(iter, LocalView.COL_FILENAME,
                                       _("Parent Directory"))
                continue

            self.__model.set_value(iter, LocalView.COL_FILENAME, info.name)
            if info.is_dir():
                self.__folder_count = self.__folder_count + 1
                self.__model.set_value(iter, LocalView.COL_FILETYPE,
                                       _("Folder"))
            elif info.is_regular():
                self.__file_count = self.__file_count + 1
                mime_type = vfs.get_mime_type(
                    os.path.join(self.__current_path, info.name))
                try:
                    desc = vfs.mime_get_description(mime_type)
                except ValueError:
                    desc = _("Unknown type")
                self.__model.set_value(iter, LocalView.COL_FILETYPE, desc)
                    
            self.__model.set_value(iter, LocalView.COL_FILESIZE,
                                   format_size(display_file_size_as,
                                               info.size))
            fmtime = locale_to_unicode(
                time.strftime('%F %r', time.gmtime(info.mtime)))
            self.__model.set_value(iter, LocalView.COL_FILEMTIME, fmtime)
            
            if info.is_dir():
                pixbuf = gdk.pixbuf_new_from_file(
                    os.path.join(coralftp_datadir, 'folder.png'))
                self.__model.set_value(iter, LocalView.COL_ICON, pixbuf)
        return

    def add_to_queue(self, treemodel, path, iter, data):
        if self.__main_window.mode == self.__main_window.MODE_FTP:
            direction = TransferView.DIRECTION_UP
            info = treemodel.get_value(iter, LocalView.COL_INFO)
            source = u'%s/%s' % (self.__cmb_dir.child.get_text(), info.name)
            remote_view = self.__main_window.remote_view
            if data == None:
                target = u'ftp://%s@%s%s/%s' \
                         % (remote_view.site_info['username'],
                            remote_view.site_info['server_addr'],
                            remote_view.current_path, info.name)
            else:
                target = u'ftp://%s@%s%s/%s' \
                         % (remote_view.site_info['username'],
                            remote_view.site_info['server_addr'],
                            remote_view.current_path, data)
            if info.is_dir():
                source = source + '/'
                target = target + '/'
            self.__main_window.transfer_view.add_to_queue(
                direction, source, target, info.size,
                None, remote_view.site_info)
        return

    def add_all_to_queue(self, trans_iter, target_path):
        """
        Add all the item in the list to the transfer queue.
        """
        tview = self.__main_window.transfer_view
        remote_view = self.__main_window.remote_view
        direction = TransferView.DIRECTION_UP
        iter = self.__model.get_iter_first()
        while iter:
            info = self.__model.get_value(iter, LocalView.COL_INFO)
            if info.name != '..':
                source = u'%s/%s' % (self.__cmb_dir.child.get_text(),
                                    info.name)
                target = u'%s%s' % (target_path, info.name)
                if info.is_dir():
                    source = source + '/'
                    target = target + '/'
                trans_iter = tview.add_to_queue(
                    direction, source, target, info.size,
                    None, remote_view.site_info, trans_iter)
            iter = self.__model.iter_next(iter)
        return
        
    def filelist_sort(self, treemodel, iter1, iter2, *arg):
        sort_folder_on_top = config_value(self.__config, 'display',
                                          'sort_folder_on_top')
        col, order = treemodel.get_sort_column_id()
        if order == SORT_ASCENDING:
            parent_weight = 1
            if sort_folder_on_top:
                dir_weight = 2
            else:
                dir_weight = 3
            file_weight = 3
        else:
            parent_weight = 3
            if sort_folder_on_top:
                dir_weight = 2
            else:
                dir_weight = 1
            file_weight = 1

        item1 = treemodel.get_value(iter1, LocalView.COL_INFO)
        item2 = treemodel.get_value(iter2, LocalView.COL_INFO)

        if col == LocalView.COL_FILENAME:
            weight1 = item1.name
        elif col == LocalView.COL_FILESIZE:
            weight1 = item1.size
        elif col == LocalView.COL_FILETYPE:
            weight1 = treemodel.get_value(iter1, LocalView.COL_FILETYPE)
        elif col == LocalView.COL_FILEMTIME:
            weight1 = item1.mtime
            
        if item1.name == '..':
            weight1 = (parent_weight, weight1)
        elif item1.is_dir():
            weight1 = (dir_weight, weight1)
        else:
            weight1 = (file_weight, weight1)
            
        if col == LocalView.COL_FILENAME:
            weight2 = item2.name
        elif col == LocalView.COL_FILESIZE:
            weight2 = item2.size
        elif col == LocalView.COL_FILETYPE:
            weight2 = treemodel.get_value(iter2, LocalView.COL_FILETYPE)
        elif col == LocalView.COL_FILEMTIME:
            weight2 = item2.mtime
            
        if item2.name == '..':
            weight2 = (parent_weight, weight2)
        elif item2.is_dir():
            weight2 = (dir_weight, weight2)
        else:
            weight2 = (file_weight, weight2)
            
        if weight1 > weight2:
            return 1
        elif weight1 < weight2:
            return -1
        else:
            return 0