transfer_view.py

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

                    # check exsiting
                    rmodel = rview.model
                    riter = rmodel.get_iter_first()
                    found = False
                    name1 = path.basename(
                        model.get_value(iter, TransferView.COL_TARGET))
                    while riter:
                        if name1 == rmodel.get_value(riter,
                                                     RemoteView.COL_NAME):
                            found = True
                            break
                        riter = rmodel.iter_next(riter)
                    if found:
                        if self.__show_upload_confirm_dialog:
                            info1 = rmodel.get_value(riter,
                                                     RemoteView.COL_INFO)
                            size1 = info1.size
                            date1 = rmodel.get_value(riter,
                                                     RemoteView.COL_DATE)
                            lmodel = lview.model
                            liter = lmodel.get_iter_first()
                            name2 = path.basename(
                                model.get_value(iter, self.COL_NAME))
                            while liter:
                                if name2 == lmodel.get_value(
                                    liter, LocalView.COL_FILENAME):
                                    break
                                liter = lmodel.iter_next(liter)
                                info2 = lmodel.get_value(
                                    liter, LocalView.COL_INFO)
                                size2 = info2.size
                                date2 = lmodel.get_value(
                                    liter, LocalView.COL_FILEMTIME)

                            # show a dialog box let user choose what to do
                            # with existing file
                            confirm_file_replace = ConfirmFileReplaceDialog(
                                self.__main_window.coralftp,
                                self.DIRECTION_UP,
                                name1, size1, date1, size2, date2)
                            confirm_file_replace.connect('response', step2)
                            confirm_file_replace.run()
                            return
                        else:
                            resp = self.__action_for_upload_conflict
                            step2(None, resp)
                    else:
                        step3(1)
                    return
                # end of on_list_succeeded

                # main part start
                local_target = target

                # change local view dir
                if lview.current_path != path.dirname(source):
                    lview.set_path(path.dirname(source))

                # for remote view, both server and path should be confirmed


                # change rview's path
                if rview.current_path != path.dirname(target): 
                    ids.append(rview.ftp_engine.connect(
                        'list-succeeded',
                        lambda *args: idle_add(on_list_succeeded, *args)))
                    rview.ftp_cd_path(path.dirname(target))
                else:
                    on_list_succeeded(None)

            # Download
            elif direction == self.DIRECTION_DOWN:
                ids = []

                def step3(transfer_option):
                    if transfer_option > 0:
                        self.__model.set_value(
                            self.trans_iter,
                            TransferView.COL_DATA_STATUS,
                            TransferView.TRANSFER_STATUS_DOING)
                        if transfer_option == 1:
                            # overwrite
                            rview.ftp_engine.get(
                                source, local_target, 'b', FALSE,
                                TransferRunningUpdater(self))
                        elif transfer_option == 2:
                            # resume
                            rview.ftp_engine.get(
                                source, local_target, 'b', TRUE,
                                TransferRunningUpdater(self))
                        self.local_need_refresh = 1
                    elif transfer_option == 0:
                        gtk.idle_add(self.transfer_next)
                    else:
                        self.finish_transfer()
                    self.__lock.release()
                    return

                def step2(obj, resp, *args):
                    if obj:
                        if not obj.ask_again:
                            self.__show_download_confirm_dialog = False
                            self.__action_for_download_conflict = resp
                        obj.destroy()
                    if resp == RESPONSE_CANCEL:
                        transfer_option = -1
                    elif resp == RESPONSE_CLOSE:
                        # close is considered as cancel
                        transfer_option = -1
                    elif resp == RESPONSE_OVERWRITE:
                        transfer_option = 1
                    elif resp == RESPONSE_SKIP:
                        transfer_option = 0
                        self.__model.set_value(
                            self.trans_iter,
                            TransferView.COL_DATA_STATUS,
                            TransferView.TRANSFER_STATUS_SKIPPED)
                    elif resp == RESPONSE_RESUME:
                        transfer_option = 2
                    elif resp == RESPONSE_RENAME:
                        p = self.__model.get_value(
                            self.trans_iter, TransferView.COL_TARGET)
                        p = '%s/%s' % (path.dirname(p),
                                       confirm_file_replace.new_name)
                        self.__model.set_value(
                            self.trans_iter, TransferView.COL_TARGET, p)
                        local_target = utf8_to_unicode(p)
                        transfer_option = 0
                    step3(transfer_option)
                    return
                    
                def on_list_succeeded(*args):
                    for id in ids:
                        rview.ftp_engine.disconnect(id)
                    transfer_option = 1
                    # check exsiting
                    lmodel = lview.model
                    liter = lmodel.get_iter_first()
                    found = 0
                    name1 = path.basename(
                        model.get_value(iter, TransferView.COL_TARGET))
                    while liter:
                        if name1 == lmodel.get_value(liter,
                                                     LocalView.COL_FILENAME):
                            found = 1
                            break
                        liter = lmodel.iter_next(liter)
                    if found:
                        if self.__show_download_confirm_dialog:
                            info1 = lmodel.get_value(liter,
                                                     LocalView.COL_INFO)
                            size1 = info1.size
                            date1 = lmodel.get_value(liter,
                                                     LocalView.COL_FILEMTIME)
                            rmodel = rview.model
                            riter = rmodel.get_iter_first()
                            name2 = path.basename(
                                model.get_value(iter, self.COL_NAME))
                            size2 = 0
                            date2 = None
                            while riter:
                                if name2 == rmodel.get_value(
                                    riter, RemoteView.COL_NAME):
                                    break
                                riter = rmodel.iter_next(riter)
                                info2 = rmodel.get_value(riter,
                                                         RemoteView.COL_INFO)
                                size2 = info2.size
                                date2 = rmodel.get_value(riter,
                                                         RemoteView.COL_DATE)
                                
                            # show a dialog box let user choose what to do
                            # with existing file
                            confirm_file_replace = ConfirmFileReplaceDialog(
                                self.__main_window.coralftp,
                                self.DIRECTION_DOWN,
                                name1, size1, date1, size2, date2)
                            confirm_file_replace.connect('response', step2)
                            confirm_file_replace.run()
                        else:
                            resp = self.__action_for_download_conflict
                            step2(None, resp)
                    else:
                        step3(1)
                    return
                # end of on_list_succeeded
                            
                # main part start
                local_target = target
                # change dir
                if lview.current_path != path.dirname(target):
                    lview.set_path(path.dirname(target))
                if rview.current_path != path.dirname(source):
                    ids.append(rview.ftp_engine.connect(
                        'list-succeeded',
                        lambda *args: idle_add(on_list_succeeded, *args)))
                    rview.ftp_cd_path(path.dirname(source))
                else:
                    on_list_succeeded()

            # other direction
            else:
                self.__lock.release()

        return FALSE

    def on_transfer_succeeded(self, obj):
        from main import MainWindow
        self.model.set_value(self.trans_iter,
                             TransferView.COL_DATA_STATUS,
                             TransferView.TRANSFER_STATUS_FINISHED)
        gtk.idle_add(self.transfer_next)
        return

    def on_transfer_failed(self, obj, errno, errmsg):
        self.model.set_value(self.trans_iter,
                             TransferView.COL_DATA_STATUS,
                             TransferView.TRANSFER_STATUS_FAILED)
        if errno == ERRNO_ABORT:
            gtk.idle_add(self.finish_transfer)
        else:
            gtk.idle_add(self.transfer_next)
        return

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

    def on_transfer_action_update(self, obj):
        obj.set_property('sensitive', self.__model.iter_n_children(None) > 0)
        return

    def on_transfer_action_execute(self, obj, *args):
        self.start_transfer(obj, None)
        return

    def on_gotodir_action_update(self, obj):
        obj.set_property(
            'sensitive', self.__selected_count == 1 \
            and self.__main_window.left_view.is_ready() \
            and (self.__main_window.right_view.is_ready() \
                 or self.__main_window.right_view.ftp_engine == None))
        return

    def on_gotodir_action_execute(self, obj, *args):
        iter = self.__selections[0]
        direction = self.__model.get_value(iter,
                                           TransferView.COL_DATA_DIRECTION)
        source = self.__model.get_value(iter, TransferView.COL_DATA_SOURCE)
        target = self.__model.get_value(iter, TransferView.COL_DATA_TARGET)
        source_site = self.__model.get_value(
            iter, TransferView.COL_DATA_SOURCE_SITE)
        target_site = self.__model.get_value(
            iter, TransferView.COL_DATA_TARGET_SITE)
        if direction == TransferView.DIRECTION_UP:
            self.__main_window.local_view.set_path(os.path.dirname(source))
            if self.__main_window.remote_view.site_info != target_site:
                self.__main_window.remote_view.connect_site(target_site)
            m = ftpurl_parse(target)
            remote_path = None
            if m != None:
                username, password, server, port, path = m
                if path and len(path) > 0:
                    if path[-1] == '/':
                        remote_path = path
                    else:
                        pos = string.rfind('/')
                        if pos >= 0:
                            remote_path = path[:pos]
            if remote_path:
                self.__main_window.remote_view.ftp_cd_path(remote_path)
        elif direction == TransferView.DIRECTION_DOWN:
            self.__main_window.local_view.set_path(os.path.dirname(target))
            if self.__main_window.remote_view.site_info != source_site:
                self.__main_window.remote_view.connect_site(source_site)
            m = ftpurl_parse(source)
            remote_path = None
            if m != None:
                username, password, server, port, path = m
                if path and len(path) > 0:
                    if path[-1] == '/':
                        remote_path = path
                    else:
                        pos = string.rfind('/')
                        if pos >= 0:
                            remote_path = path[:pos]
            if remote_path:
                self.__main_window.remote_view.ftp_cd_path(remote_path)
        return

    def on_moveup_action_execute(self, obj, *args):
        if self.__selected_count == 0: return
        selected_path = []
        for iter in self.__selections:
            (path,) = self.__model.get_path(iter)
            selected_path.append(path)
        selected_path.sort()