svn_commands.h

linux 下的 图形化的 SVN 相当于 VSS

        if (user != "") {
            proc->addArgument("--username");
            proc->addArgument(user);
        }

        if (passw != "") {
            proc->addArgument("--password");
            proc->addArgument(passw);
        }

        if (rev != "") {
            proc->addArgument("-r");
            proc->addArgument(rev);
        }
        if (non_recursive)
            proc->addArgument("--non-recursive");

        proc->addArgument("--non-interactive");

        return execCommand(currwd, SC_REFRESH | SC_WAIT);
    }

    int export_cmd(const QString& currwd, const QString& url, const QString& local_path, const QString &rev) {
        proc->clearArguments();
        proc->addArgument(svn_); proc->addArgument("export");

        proc->addArgument(url);
        proc->addArgument(local_path);

        if (rev != "") {
            proc->addArgument("-r");
            proc->addArgument(rev);
        }

        return execCommand(currwd, SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
    }

    int import(const QString& currwd, const QString& url, const QString& local_path, QString msg,  bool non_recursive) {
        proc->clearArguments();
        proc->addArgument(svn_); proc->addArgument("import");

        proc->addArgument(local_path);
        proc->addArgument(url);



        if (msg == "")  msg = "nomsg";
        proc->addArgument("-m"); 
        proc->addArgument(msg);

        if (non_recursive)
            proc->addArgument("--non-recursive");

        return execCommand(currwd, SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
    }

    int mkdir(const QString& currwd, const QString& dir) {
        proc->clearArguments();
        proc->addArgument(svn_); proc->addArgument("mkdir");
        proc->addArgument(dir);

        return execCommand(currwd, SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
    }

    int proplist(const C_Path& file_dir_name, const QString& rev, QStringList& out_txt) {
        proc->clearArguments();
        proc->addArgument(svn_); proc->addArgument("proplist");
        proc->addArgument(file_dir_name.Name());

        proc->addArgument("--verbose");

        if (!rev.isEmpty()) {
            proc->addArgument("-r");
            proc->addArgument(rev);
        }


        return execCommand(file_dir_name.Path(), SC_WAIT | SC_APPEND_USER_PASS, &out_txt);
    }

    int propset(const C_Path& file_dir_name, const QString& rev, const QString& key, const QString &value) {
        proc->clearArguments();
        proc->addArgument(svn_); proc->addArgument("propset");
        proc->addArgument(key); proc->addArgument(value);


        proc->addArgument(file_dir_name.Name());

        if (rev != "") {
            proc->addArgument("-r");
            proc->addArgument(rev);
        }

        return execCommand(file_dir_name.Path(), SC_WAIT | SC_APPEND_USER_PASS);
    }

    int propdel(const C_Path& file_dir_name, const QString& rev, const QString& key) {
        proc->clearArguments();
        proc->addArgument(svn_); proc->addArgument("propdel");
        proc->addArgument(key);  proc->addArgument(file_dir_name.Name());

        if (rev != "") {
            proc->addArgument("-r");
            proc->addArgument(rev);
        }
        return execCommand(file_dir_name.Path(), SC_WAIT | SC_APPEND_USER_PASS);
    }

    int list(const QString& currwd, const QString& url, const QString& rev, QStringList& out_txt, bool is_hide=false, bool recursive = true, bool dont_change_cursor = false) {

        //cout << "list:" << (url.isEmpty() ? "current" : url.ascii()) << " curs:" << dont_change_cursor << endl;

        proc->clearArguments();
        proc->addArgument(svn_); proc->addArgument("list");
        proc->addArgument(url);

        if (recursive)
            proc->addArgument("--recursive");

        proc->addArgument("--verbose");

        if (rev != "") {
            proc->addArgument("-r");
            proc->addArgument(rev);
        }
        return execCommand(currwd, SC_WAIT | SC_APPEND_USER_PASS | (dont_change_cursor ? SC_DISABLE_CURSOR_CHANGE : 0) | (is_hide ? SC_HIDE : 0), &out_txt);
    }

    int command(const QString& currwd, QStringList cmd) {
        proc->clearArguments();

        for (size_t i=0; i<cmd.size(); i++)
            proc->addArgument(cmd[i]);

        return execCommand(currwd, 0);
    }


    void setSvn(QString svn) {
        svn_ = svn;
    }

public slots:
    void readFromStdout() {
        while (proc->canReadLineStdout()) {
            QString src_msg = proc->readLineStdout();
            QString str = QTextCodec::codecForLocale()->toUnicode(src_msg);

            if(!str.isNull()){
                if (show_enable_)
                    out_win_->append(QString("<font color=black>") + str + QString("</font>") );
                out_text_.push_back(str);
            }
        }
    }

    void readFromStderr() {     
        while (proc->canReadLineStderr()) {
            QString str = QTextCodec::codecForLocale()->toUnicode(proc->readLineStderr());

            //if (!is_hide_all_)
            out_win_->append(QString("<font color=red>") + str + QString("</font>") );

            if (!disable_cursor_change_) 
                QApplication::restoreOverrideCursor();
/*
            //auth 
            if (str.find("Username:") != -1) {
                proc->writeToStdin(dlg_auth_->le_user->text() + "\n");
                out_win_->append(dlg_auth_->le_user->text());
            }

            if (str.find("Password for ") != -1) {
                proc->writeToStdin(dlg_auth_->le_passw->text() + "\n");
                out_win_->append(dlg_auth_->le_user->text());
            }

            if (str.find("Authentication realm:") != -1) {
                cout << "auth:" << str << endl;
                proc->writeToStdin("");
                //sleep(2); 
                dlg_auth_->exec();
                qApp->processEvents();
            }
*/
        }
        
    }

    void procFinished() {
        //cout << "proc finished" << endl;

        parent_->blockSignals(false);   

        if (!disable_cursor_change_) 
            QApplication::restoreOverrideCursor();

        dlg_busy_->close();

        if (!is_hide_all_) {
            int ret_code = proc->exitStatus();
            char ret_code_buff[64];
            if (ret_code == 0)
                sprintf(ret_code_buff, "<font color=darkgreen>successfully (%d)</font>", ret_code);
            else
                sprintf(ret_code_buff, "<font color=darkred>error (%d)</font>", ret_code);

            out_win_->append(ret_code_buff);
        }

        if (is_refreshable_command_)
            needs_refresh_ = true;

        is_ready_for_last_command_ = true;        
    }

public:
    bool needs_refresh_;

    void setUserPassw(const QString& user,const QString& passw) {
        user_ = user;
        passw_ = passw;
    }

    bool isRunning() {
        return proc->isRunning();
    }

    QString getLastCommand() {
        if (is_ready_for_last_command_) {
            QStringList args = proc->arguments();
            if (args.empty())
                return "";
            else {
                is_ready_for_last_command_ = false;
                return args[1];
            }
        }
        else
            return "";
    }

private:
//  int execCommand(bool is_refreshable_command, QStringList* out_list=NULL, 
//                  bool wait=false, bool append_user_passw = true, 
//                  bool hide=false, bool disable_cursor_change = false ) {

// de
//  enum {SC_WAIT = 0x0001, SC_APPEND_USER_PASS=0x0002, SC_HIDE=0x0004, 
          //SC_DISABLE_CURSOR_CHANGE=0x0008, SC_REFRESH = 0x0010};

     int execCommand(const QString& currwd, unsigned int flags, QStringList* out_list=NULL) {

        disable_cursor_change_ = (flags & SC_DISABLE_CURSOR_CHANGE);

        if (!disable_cursor_change_) 
            QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );

        is_refreshable_command_ = (flags & SC_REFRESH);

        if (flags & SC_APPEND_USER_PASS) {
            if (!user_.isEmpty()) {
                proc->addArgument("--username");
                proc->addArgument(user_);
            }
            if (!passw_.isEmpty()) {
                proc->addArgument("--password");
                proc->addArgument(passw_);
            }
            proc->addArgument("--non-interactive");
        }

        is_hide_all_ = (flags & SC_HIDE) && !isVerbouse();

        if (!is_hide_all_ ) {
            QString svn_cmd = showCommand();
            dlg_busy_->lb_command->setText(svn_cmd);
            //dlg_busy_->show();
        }

        show_enable_ = (!out_list && !is_hide_all_ && !isVerbouse());
        

        out_text_.clear();
        qApp->processEvents();

        // set correct working directory for spawned process,
        // as most of provided file paths are relative to this directory
        if (currwd.isEmpty()) {
            abort();
        }

        proc->setWorkingDirectory(currwd);

        if (!proc->start()) {
            out_text_.append("can't fork the process");

            if (!disable_cursor_change_) 
                QApplication::restoreOverrideCursor();

            return 1;
        }

        parent_->blockSignals(true);
        if (out_list || (flags & SC_WAIT) ) {
//          if (parent_) parent_->setDisabled(true);

            while (proc->isRunning()) {
                //cout <<"running " << proc->processIdentifier() << endl; //sleep(1);
                qApp->processEvents(QEventLoop::ExcludeUserInput);

#if ( _WINDOWS || ESVN_WIN )
                Sleep(1000);
#else
                usleep(1000);
#endif
            }

            if (!disable_cursor_change_) 
                QApplication::restoreOverrideCursor();

//          if (parent_) parent_->setDisabled(false);
        }

        if (out_list)
            *out_list = out_text_;

        show_enable_ = true;

        int ret_code = proc->exitStatus();
        return ret_code;
    }

    QString showCommand() {

        QStringList args = proc->arguments();
        QStringList::Iterator it = args.begin();
        QString out_str = "<font color=navy>";
        QString curr_str, prev_arg;
        int arg_num =0;
        while ( it != args.end() ) {
            if (arg_num && prev_arg == QString("--password") )
                curr_str = "******";
            else
                curr_str = (*it);
                
            if (arg_num++ == 1)
                out_str = out_str + curr_str + "</font> ";
            else
                out_str = out_str + curr_str + " ";
            ++it;
            
            prev_arg = curr_str;
        }
        out_win_->append(out_str);
        return out_str;
    }

    bool isVerbouse() {
        //cout << "verb:" << C_Options::instance()->dlgOptions()->rb_log_verb->isChecked() << endl;
        return C_Options::instance()->dlgOptions()->rb_log_verb->isChecked();
    }

private:
    QProcess *proc;

    dlg_busy *dlg_busy_;
    QTextBrowser* out_win_;
    QStringList out_text_;
    bool show_enable_, is_hide_all_;
    bool is_refreshable_command_, is_ready_for_last_command_;

    QString svn_;
    dlg_auth *dlg_auth_;
    QString user_, passw_;
    QWidget *parent_;

    QString diff_cmd_;

    bool disable_cursor_change_;
};

#endif