mainwindow.cpp

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

				for (size_t j=0; j<exts.size(); j++) {
					if (exts[j] == fi.extension() ) {
						QProcess proc;
                        proc.setWorkingDirectory(item->Path());
						proc.addArgument(ext_prog[1]);
						proc.addArgument(item->Name());
						textBrowser->append(ext_prog[1] + " " + item->Name());
						proc.start();
						return;
					}
				}
			}

            show_View(*item); //can be here if action not found

		}

	}
}

void C_MainWindow::colorizeDirsList(QListViewItem *dir_item)
{
	C_NumSortedFileListItem *curr_item = dynamic_cast<C_NumSortedFileListItem*>(list_files->firstChild());
	while (curr_item) {
		C_DirViewItem *item = dynamic_cast<C_DirViewItem*>(dir_item->firstChild());
		while (item) {
			//cout << EsvnLVI::getFullPath(item) << " " <<  EsvnLVI::getFullPath(curr_item) << endl;
			if (item->FullPath() == curr_item->FullPath()) {
				item->setPixmap(0, *curr_item->pixmap(0));
				break;
			}
			item = dynamic_cast<C_DirViewItem*>(item->nextSibling());
		}
		curr_item = dynamic_cast<C_NumSortedFileListItem*>(curr_item->nextSibling());
	}
}


void C_MainWindow::modifyUpdateAction_activated()
{
	sendToOutput("update");

	in_timer_now_ = true;

    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "update: No selection available" << std::endl;
        return;
    }

    svn_commands_->update(selection);

	in_timer_now_ = false;
}

void C_MainWindow::modifyUpdate_revision_Action_activated() {

	sendToOutput("update revision");

	if (dlg_update_->exec() == QDialog::Accepted) {
		QString rev;
		if (dlg_update_->rb_revision->isChecked())
			rev = (dlg_update_->le_revision->text());
		else
			rev	= "{" + dlg_update_->le_date->text() + "}";

        PathSelection selection;

        getSelectedPaths(selection);

        if (selection.empty()) {
            std::cout << "update revision: No selection available" << std::endl;
            return;
        }

		svn_commands_->update(selection, rev);
	}
}


void C_MainWindow::modifyRevertAction_activated()
{
	revert(false);
}

void C_MainWindow::modifyRevert_recursiveAction_activated()
{
	revert(true);
}

void C_MainWindow::revert(bool is_recursive)
{
    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "revert: No selection available" << std::endl;
        return;
    }

    QString text_string ="You are about to revert the following items:\n\n";
    for (size_t i=0; i< selection.size(); i++)
        text_string = text_string + selection[i].Name() + "\n";

    QMessageBox mb( "Confirmation",text_string,
        QMessageBox::Question,
        QMessageBox::Yes | QMessageBox::Default,
        QMessageBox::No  | QMessageBox::Escape,
        QMessageBox::NoButton );

    if ( mb.exec() == QMessageBox::Yes )
        svn_commands_->revert(selection, is_recursive);
}

void C_MainWindow::modifyResolveAction_activated()
{
    // Get current view
    QListView* current_view = is_selected_dir_?list_dirs:list_files;
    QListViewItem* item = EsvnLVI::getFirstSelectedItem(current_view);

    const C_Path* sel_path = dynamic_cast<C_Path*>(item);

    if (!sel_path) {
        std::cout << "modifyResolveAction_activated: No path available" << std::endl;
        return;
    }

    QMessageBox mb( "Confirmation",
					"You are about to resolve the following item:\n\n" + sel_path->Name() +"\n",
					QMessageBox::Question,
					QMessageBox::Yes | QMessageBox::Default,
					QMessageBox::No  | QMessageBox::Escape,
					QMessageBox::NoButton );

	if ( mb.exec() == QMessageBox::Yes )
		svn_commands_->resolve(*sel_path);
}


void C_MainWindow::modifyCommitAction_activated() {
    // Get current view
    //QListView* current_view = is_selected_dir_?list_dirs:list_files;
    //QListViewItem* item = EsvnLVI::getFirstSelectedItem(current_view);
    const C_DirPath *sel_path = dynamic_cast<C_DirPath*>(EsvnLVI::getFirstSelectedItem(list_dirs));
    if (!sel_path) {
		QMessageBox::information(this, "Commit rejected", "No directory selection available");
        return;
    }
    QString currwd = sel_path->FullPath();

	if (dlg_options_->ch_disable_cotag->isChecked() && getUrlOnline(*sel_path).find("/tags/") != -1) {
		QMessageBox::information(this, "Commit rejected", "Can't commit to tag");
		return;
	}

	if (dlg_options_->ch_hide_commit->isChecked())
		dlg_commit_->gr_files->hide();
	else
		dlg_commit_->gr_files->show();

    vector<QString> selected_files;

	int commit_res = -1;
        if( is_selected_dir_ ) {
            dlg_commit_->setCommitPath( *sel_path, !dlg_options_->ch_hide_commit->isChecked());
        }
        else {
            getSelectedFiles(selected_files);
            dlg_commit_->setCommitFiles( selected_files );
        }

	if (dlg_commit_->exec() == QDialog::Accepted) {

        selected_files = dlg_commit_->commitList();

        // user may have accepted no files to commit, so check if list is empty
        if (!selected_files.empty())
            commit_res = svn_commands_->commit(currwd, selected_files, dlg_commit_->msgEdit->text());
    }
}

void C_MainWindow::modifyEditAction_activated()
{
    // Check if there is any selection in file list
    if (!list_files->currentItem()) {
        //QMessageBox::information(this, "Edit action rejected", "Can not edit directory ");
        return;
    }

    // Get list of all selected paths
    PathSelection selection;
    if (!getSelectedFiles(selection)) {
        QMessageBox::information(this, "Edit action rejected", "No selection");
        return;
    }

    for (PathSelection::const_iterator it = selection.begin(); it != selection.end(); ++it) {
        const C_Path& path = *it;
        if (!path.isDir()) {
            QProcess proc;
            proc.setWorkingDirectory(path.Path());
            proc.addArgument(editor_set_);
            proc.addArgument(path.Name());
            proc.start();
        } else {
            std::cout << "Cannot edit directory" << path.Name() << std::endl;
        }
    }
}

void C_MainWindow::modifyCleanupAction_activated() {
    PathSelection selection;
    if (!getSelectedPaths(selection)) {
        QMessageBox::information(this, "Cleanup action rejected", "No selection");
        return;
    }

    // Better extract directories then call cleanup on list
    for (PathSelection::const_iterator it = selection.begin(); it != selection.end(); ++it) {
        const C_Path& path = *it;
        if (path.isDir()) {
            svn_commands_->cleanup(path);
        } else {
            std::cout << "Cannot cleanup non-directory" << path.Name() << std::endl;
        }
    }
}


void C_MainWindow::modifyAddAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "modifyAddAction_activated: No selection available" << std::endl;
        return;
    }

    svn_commands_->add(selection, false);
}

void C_MainWindow::modifyAdd_recursiveAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "modifyAdd_recursiveAction_activated: No selection available" << std::endl;
        return;
    }

    svn_commands_->add(selection, true);
}

void C_MainWindow::modifyDeleteAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "modifyDeleteAction_activated: No selection available" << std::endl;
        return;
    }

    // note that for file selection working directory is also available in each selection item
    // though it should refer to sel_path that we already extracted from dir selection
    svn_commands_->del(selection);
}

void C_MainWindow::modifyCopyAction_activated()
{
    // current working directory is stored in dlg_copy_->lb_url

    if (dlg_copy_->exec() == QDialog::Accepted) {
		QString rev = "";
		if (dlg_copy_->rb_revision->isChecked())
			rev = (dlg_copy_->le_revision->text());
		else
			rev	= "{" + dlg_copy_->le_date->text() + "}";

		QStringList files = QStringList::split(';', dlg_copy_->le_source->text());

        QString currwd = dlg_copy_->lb_url->text();

        for (size_t i=0; i<files.size(); i++)
			svn_commands_->copy(currwd, files[i], dlg_copy_->le_dest->text(), dlg_copy_->te_msg->text(), rev);
	}
}

void C_MainWindow::modifyCopy_remote_Action_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "modifyCopy_remote_Action_activated: No path selected" << std::endl;
        return;
    }

	dlg_copy_->lb_url->hide();
	dlg_copy_->setCaption("Copy (remote)");
	dlg_copy_->lb_url->setText(getUrlOnline(selection[0]));

	dlg_copy_->tb_src->setText("U");
	dlg_copy_->tb_dst->setText("U");

    QString sel_names;
    for (size_t i=0; i<selection.size(); i++) {
        QString url = getUrlOnline(selection[i]);
        sel_names = sel_names + url;
        if (i != selection.size()-1)
            sel_names = sel_names + ';';
    }
	dlg_copy_->le_source->setText(sel_names);
	//dlg_copy_->le_dest->setText(sel_names);

	modifyCopyAction_activated();
}

void C_MainWindow::modifyCopy_current_Action_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "modifyCopy_current_Action_activated: No selection available" << std::endl;
        return;
    }

	dlg_copy_->lb_url->hide();
	dlg_copy_->setCaption("Copy (local)");
	dlg_copy_->lb_url->setText(selection[0].Path());

	dlg_copy_->tb_src->setText("...");
	dlg_copy_->tb_dst->setText("...");

    QString sel_names;
    for (size_t i=0; i<selection.size(); i++) {
        sel_names = sel_names + selection[i].Name();
        if (i != selection.size()-1)
            sel_names = sel_names + ';';
    }
    dlg_copy_->le_source->setText(sel_names);

	modifyCopyAction_activated();
}

void C_MainWindow::modifyMoveAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

    if (selection.empty()) {
        std::cout << "modifyDeleteAction_activated: No selection available" << std::endl;
        return;
    }

    dlg_copy_->setCaption("Move");

    // Prepare list of selected names
	dlg_copy_->tb_src->setText("...");
	dlg_copy_->tb_dst->setText("...");

    dlg_copy_->le_source->setText("");
    QString sel_names;
    for (size_t i=0; i<selection.size(); i++) {
        sel_names = sel_names + selection[i].Name();
        if (i != selection.size()-1)
            sel_names = sel_names + ';';
    }
    dlg_copy_->le_source->setText(sel_names);

	if (dlg_copy_->exec() == QDialog::Accepted) {
		QString rev = "";
		if (dlg_copy_->rb_revision->isChecked())
			rev = (dlg_copy_->le_revision->text());
		else
			rev	= "{" + dlg_copy_->le_date->text() + "}";

		QStringList files = QStringList::split(';', dlg_copy_->le_source->text());

		for (size_t i=0; i<files.size(); i++)
			svn_commands_->move(selection[0].Path(), files[i], dlg_copy_->le_dest->text(),dlg_copy_->te_msg->text(), rev);
	}
}


void C_MainWindow::modifySwitchAction_activated() {

    // Get current view
    QListView* current_view = is_selected_dir_?list_dirs:list_files;
    QListViewItem* item = EsvnLVI::getFirstSelectedItem(current_view);
    const C_Path* path = dynamic_cast<C_Path*>(item);
    if (!path) {
        std::cout << "modifySwitchAction_activated: No path available" << std::endl;
        return;
    }

	QString url = getUrlOnline(*path);
	dlg_switch_->le_url->setText(url);

	if (dlg_switch_->exec() == QDialog::Accepted) {
		QString rev = "";
		if (dlg_switch_->rb_revision->isChecked())
			rev = (dlg_switch_->le_revision->text());
		else
			rev	= "{" + dlg_switch_->le_date->text() + "}";

		svn_commands_->switch_cmd(*path, dlg_switch_->le_url->text(), rev, dlg_switch_->ch_recur->isChecked());
	}
}


void C_MainWindow::modifyMegreAction_activated()
{
    // Get current view
    QListView* current_view = is_selected_dir_?list_dirs:list_files;
    QListViewItem* item = EsvnLVI::getFirstSelectedItem(current_view);

    const C_Path* sel_path = dynamic_cast<C_Path*>(item);

    if (!sel_path) {
        std::cout << "modifyMergeAction_activated: No path available" << std::endl;
        return;
    }