remote_view.py

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

            if resp == RESPONSE_OK and v != '':
                if value[-1] != '/':
                    v = v + '/'
                if value != self.current_path + '/':
                    self.ftp_cd_path(v)
            return
            
        d = GeneralInputDialog(_("Change Folder"), _("Name of Folder"),
                               self.current_path + '/')
        d.connect('response', on_dialog_response)
        d.run()
        return

    def on_updir_action_update(self, obj):
        obj.set_property('sensitive', self.__ftp_engine != None and self.__ftp_engine.is_idle)
        return

    def on_updir_action_execute(self, obj, *args):
        self.ftp_cd_path('..')

    def ftp_open(self):

        def on_open_finished(*args):
            logging.debug('on_open_finished runs in %s' \
                          % self.main_window.coralftp.get_thread_name())
            # be CONNECTING or NONE
            if self.__ftp_engine.status == STATUS_IDLE:
                # display site name in caption
                display_site_name_in_caption = config_value(
                    self.__config, 'display', 'display_site_name_in_caption')
                if display_site_name_in_caption:
                    self.main_window.widget.set_title(
                        'CoralFTP: %s' % self.__site_info['site_name'])
                else:
                    self.main_window.widget.set_title('CoralFTP')
                
                if self.__ftp_engine.welcome_message != None:
                    dlg_xml = get_glade_xml('welcome_message_dialog')
                    dlg = dlg_xml.get_widget('welcome_message_dialog')
                    textview = dlg_xml.get_widget('tv_welcome_message')
                    buffer = textview.get_buffer()
                    buffer.set_text(self.__ftp_engine.welcome_message)
                    dlg.connect('response', lambda obj, *args: obj.destroy())
                    dlg.show()
                    dlg.set_modal(TRUE)
                    
                remote_path = self.__site_info['remote_path']
                if remote_path and remote_path != '':
                    self.ftp_cd_path(remote_path)
                else:
                    self.ftp_refresh()
                local_path = self.__site_info['local_path']
                if local_path and local_path != '':
                    self.__main_window.local_view.set_path(local_path)
            return
        # end of on_open_finished

        # start of ftp_open
        if self.__ftp_engine and self.__ftp_engine.status != STATUS_NONE:
            self.ftp_close()
            self.__ftp_close_event.wait()
            
        if self.__ftp_engine == None:
            self.__ftp_engine = FTPEngine(self)
            self.__ftp_engine.connect('quit', self.on_ftp_engine_quit)
            self.__ftp_engine.connect(
                'idle', lambda *args: idle_add(self.on_ftp_idle, *args))
            self.__ftp_engine.connect(
                'delay', lambda *args: idle_add(self.on_ftp_delay, *args))
            self.__cd_succeeded_hids.append(self.__ftp_engine.connect(
                'cd-succeeded', self.ftp_refresh))
            self.__ftp_engine.connect(
                'put-succeeded',
                self.__main_window.transfer_view.on_transfer_succeeded)
            self.__ftp_engine.connect(
                'put-failed',
                self.__main_window.transfer_view.on_transfer_failed)
            self.__ftp_engine.connect(
                'get-succeeded',
                self.__main_window.transfer_view.on_transfer_succeeded)
            self.__ftp_engine.connect(
                'get-failed',
                self.__main_window.transfer_view.on_transfer_failed)
            self.__ftp_engine.connect(
                'log-message', self.__main_window.log_view)
            self.__ftp_engine.start()
            self.__ftp_engine.is_idle_event.wait()

            # if remote path specified, cd into it after open succeeded.
            self.__ftp_engine.connect(
                'open-succeeded', on_open_finished)
            self.__ftp_engine.connect(
                'open-failed', on_open_finished)

        self.__ftp_engine.open(self.__site_info)
        return
        
    def ftp_close(self):
        self.__ftp_close_event.clear()
        if self.__ftp_engine:
            self.__ftp_engine.quit()
        return

    def ftp_refresh(self, clear_cache=False):
        self.__model.clear()
        self.folder_count = 0
        self.file_count = 0
        self.__selected_count = 0
        self.__selections = []
        self.__ftp_engine.pwd(PwdUpdater(self))
        self.__ftp_engine.list(updater=ListUpdater(self),
                               clear_cache=clear_cache)

    def ftp_delete_selected(self):
        def on_delete_succeeded(obj, hids, names):
            if len(names) > 0:
                isdir, name = names.pop()
                idle_add(self.__ftp_engine.delete, name, isdir)
                return FALSE
            if len(names) == 0:
                while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
                idle_add(self.ftp_refresh, True)
                return TRUE
        def on_delete_failed(obj, errno, errmsg, hids, names):
            if errno != '550' and len(names) > 0: # Permission denied
                isdir, name = names.pop()
                idle_add(self.__ftp_engine.delete, name, isdir)
                return FALSE
            if len(names) == 0:
                while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
                idle_add(self.ftp_refresh, True)
                return TRUE
        def on_cci_finish(names):
            hids = []
            hids.append(self.__ftp_engine.connect('delete-succeeded',
                                                  on_delete_succeeded,
                                                  hids, names))
            hids.append(self.__ftp_engine.connect('delete-failed',
                                                  on_delete_failed,
                                                  hids, names))
            if len(names) > 0:
                isdir, name = names.pop()
                self.__ftp_engine.delete(name, isdir)
            return
            
        dirs = []
        names = []
        for iter in self.__selections:
            name = utf8_to_unicode(self.__model.get_value(iter, self.COL_NAME))
            isdir = self.__model.get_value(iter, self.COL_ATTR)[0] == 'd'
            if isdir:
                dirs.append(name)
            else:
                names.append((False, u'%s/%s' % (self.current_path, name)))
        self.ftp_collect_children_information(dirs, names, on_cci_finish)
        return False

    def ftp_collect_children_information(self, dirs, names, func,\
                                         clear_cache=False):
        class ChildCollectUpdater:
            items = []
            def __call__(self, filelist):
                if len(filelist) > 0: self.items.extend(filelist)
                return gtk.FALSE
            
        def on_leave_success(obj, *args):
            while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
            next()
            return

        def on_leave_failed(obj, *args):
            while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
            next()
            return
 
        def on_list_success(obj, dirname, *args):
            while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
            while len(collection.items) > 0:
                attr, childnum, owner, group, size, month, day, year_or_day, name \
                          = collection.items.pop()
                if name in ('.', '..'): continue
                isdir = attr[0] == 'd'
                if isdir:
                    dirs.append(dirname + '/' + name)
                    logging.debug('add directory %s / %s' % (dirname, name))
                else:
                    names.append((False, '%s/%s' % (dirname, name)))
                    logging.debug('add file %s / %s' % (dirname, name))
            hid = self.__ftp_engine.connect('cd-succeeded', on_leave_success)
            hids.append(hid)
            hid = self.__ftp_engine.connect('cd-failed', on_leave_failed)
            hids.append(hid)
            self.__ftp_engine.cd(self.current_path)
            return

        def on_list_failed(obj, *args):
            while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
            names.pop()
            next()
            return

        def on_enter_success(obj, dirname, *args):
            while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
            hid = self.__ftp_engine.connect('list-succeeded', on_list_success, dirname, collection)
            hids.append(hid)
            hid = self.__ftp_engine.connect('list-failed', on_list_failed)
            hids.append(hid)
            self.__ftp_engine.list(updater=collection, clear_cache=clear_cache)
            return

        def on_enter_failed(obj, *args):
            while len(hids) > 0: self.__ftp_engine.disconnect(hids.pop())
            names.pop()
            next()
            return

        def next():
            if len(dirs) > 0:
                dirname = dirs.pop()
                names.append((True, dirname))
                hid = self.__ftp_engine.connect('cd-succeeded', on_enter_success, dirname)
                hids.append(hid)
                hid = self.__ftp_engine.connect('cd-failed', on_enter_failed)
                hids.append(hid)
                self.__ftp_engine.cd(dirname)
            else:
                finish()
            return

        def start():
            for hid in self.__cd_succeeded_hids:
                self.__ftp_engine.handler_block(hid)
            next()
            return

        def finish():
            for hid in self.__cd_succeeded_hids:
                self.__ftp_engine.handler_unblock(hid)
            func(names)
            return
            
        hids = []
        collection = ChildCollectUpdater()
        start()
        return

    def ftp_move_each(self, treemodel, path, iter, data):
        name = treemodel.get_value(iter, RemoteView.COL_NAME)
        self.__ftp_engine.move(utf8_to_unicode(name),
                               utf8_to_unicode('%s%s' % (data, name)))
        return

    def ftp_rename(self, old_name, new_name):
        self.__ftp_engine.move(utf8_to_unicode(old_name),
                               utf8_to_unicode(new_name))
        return

    def ftp_mkdir(self, name):
        self.__ftp_engine.mkdir(utf8_to_unicode(name))
        return

    def on_ftp_engine_quit(self, obj, *args):
        logging.debug('remote_view.on_ftp_engine_quit begin')
        self.__ftp_engine = None
        self.__model.clear()
        self.__ftp_close_event.set()
        logging.debug('remote_view.on_ftp_engine_quit finish')
        idle_add(logging.debug, 'last idle_add messag')
        return

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

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

    def on_list_button_release(self, obj, event):
        # count selection
        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.button == 3:
            self.__menu.popup(None, None, None, 0, 0)
        return
    
    def on_list_button_press(self, obj, event):
        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)

        # count selection
        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.count_selected_rows() == 1 and self.__selected_count == 0:
                self.ftp_cd_path('..')
                
            if self.__selected_count == 1:
                info = self.__model.get_value(self.__selections[0],
                                              RemoteView.COL_INFO)
                if info.isdir():
                    self.ftp_cd_path(info.name)
                else:
                    # transfer file
                    pass
        return

    def set_active_view(self, active=FALSE):
        if active:
            self.active_indicator.set_name('active_view_indicator')
        else:
            self.active_indicator.set_name('')

    def ftp_cd_path(self, new_path):
        if not isinstance(new_path, unicode):
            new_path = utf8_to_unicode(new_path)
        self.__ftp_engine.cd(new_path)
        return

    def on_ftp_idle(self, obj, t):
        if not self.__show_idle_time or t < 0:
            s = ''
        else:
            s = 'Idle: %d' % t
        if self == self.__main_window.right_view:
            self.__main_window.status2.set_text(s)