mainwindow.cpp

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

	dlg_merge_->setFileDirUrl(*sel_path, getUrlOnline(*sel_path));

	if (dlg_merge_->exec() == QDialog::Accepted) {
		QString first = "";
		QString second= "";

		if (dlg_merge_->rb_revision->isChecked()) {
			first = dlg_merge_->le_rev1->text();
			second= dlg_merge_->le_rev2->text();
		}
		else {
			first = dlg_merge_->le_url1->text();
			second= dlg_merge_->le_url2->text();
		}

        QString file_url = sel_path->Name();
		if (dlg_merge_->le_file->text() != "")
			file_url = dlg_merge_->le_file->text();

        QString wcpath;
        if (dlg_merge_->le_wcpath->text() != "") {
            wcpath = dlg_merge_->le_wcpath->text();
        }
        else if (sel_path->isDir()) {
            // Provide correct working path for selected directories
            wcpath = sel_path->Name();
        }

        svn_commands_->merge(sel_path->Path(),
                             file_url, first, second, wcpath,
							 dlg_merge_->rb_revision->isChecked(),
							 dlg_merge_->ch_nonrecursive->isChecked(),
							 dlg_merge_->ch_dryrun->isChecked());
	}
}

void C_MainWindow::modifyMake_directory_Action_activated()
{
    QListViewItem* item = EsvnLVI::getFirstSelectedItem(list_dirs);
    const C_Path* sel_path = dynamic_cast<C_Path*>(item);

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

    bool ok;
    QString text = QInputDialog::getText("Make directory",
            "Enter directory name:", QLineEdit::Normal,
            QString::null, &ok, this );

	if ( ok && !text.isEmpty() )
		svn_commands_->mkdir(sel_path->FullPath(), text);
}

///------------------- VIEW actions -------------------------------------------------

void C_MainWindow::refreshList()
{
	auto_refresh_disable_ = true;

	int saved_pos =  list_files->contentsY(); // ist_files->verticalScrollBar()->value();

    //QString sel_path = list_dirs->selectedItem() ? list_dirs->selectedItem()->text(EsvnLVI::ITEM_FULL_PATH) : workspace_;

    const C_Path *sel_path = NULL;

    // Try dir selection first, then revert to workspace
    if (list_dirs->selectedItem()) {
        sel_path = dynamic_cast<C_Path*>(list_dirs->selectedItem());
    }
    if (!sel_path || sel_path->FullPath().isEmpty()) {
        sel_path = &workspace_;
    }

	if (sel_path->FullPath().isEmpty()) {
		sendToOutput("refresh: invalid path");
		list_files->clear();
		auto_refresh_disable_ = false;
		return;
	} else {
		sendToOutput("refresh: " +  sel_path->FullPath() );
	}

	vector<QString> selected_files;
	getSelectedFiles(selected_files);

	//for (map<QString, S_StatusInfo>::iterator iter_i =svn_status_->getData()->begin(); iter_i != svn_status_->getData()->end(); iter_i++) {
	//	cout << "***" << iter_i->first << " " << iter_i->second.status_ << endl;
	//}

    {
        C_FilesList file_list;
        file_list.load(*sel_path, list_files, hide_unknown_, show_flat_view_, show_changed_items_only_, dlg_options_->ch_showdir->isChecked(), svn_status_);
    }

	//restore selection

	QListViewItem *item = list_files->firstChild();
	while (item != 0) {
		for (size_t i=0; i<selected_files.size(); i++) {
			if (item->text(0) == selected_files[i]) {
				item->setSelected(true);
				list_files->setCurrentItem(item);
				break;
			}
		}
		item = item->itemBelow() ;
	}

	//list_files->verticalScrollBar()->setValue(saved_pos); //restore scrool
	//scroll_pos_ = saved_pos;

	if (saved_pos)
		list_files->setContentsPos (0,  saved_pos);

	//cout << "restored:" << list_files->verticalScrollBar()->value() << endl;

	time_t now; time(&now);
	last_refresh_ = now;

	getFilesAndSize(*sel_path, last_files_and_size_);

	auto_refresh_disable_ = false;
}

void C_MainWindow::viewRefresh_localAction_activated()
{
	QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );

	time(&last_refresh_);
	if (dlg_options_->rb_online->isChecked())
		fillSvnStatus(svn_status_);


	refreshList();
	QApplication::restoreOverrideCursor();
}

void C_MainWindow::viewRefresh_onlineAction_activated()
{
	QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );

	fillSvnStatus(svn_status_);
	refreshList();

	QApplication::restoreOverrideCursor();
}

void C_MainWindow::viewHide_unknownAction_toggled(bool hide) {
	//cout <<"hide:" << hide << endl;
	hide_unknown_ = hide;
	dirs_list_->setHide(hide);
	viewRefresh_localAction_activated();
}

void C_MainWindow::viewRefresh_workspaceAction_activated()
{

	QSettings settings_;
	settings_.setPath("umputun.com", "esvn", QSettings::User);
	settings_.beginGroup("/esvn");

	QString ws_name = settings_.readEntry("/state/active_workspace", "");
	if (ws_name.isEmpty()) {
		loadWorkspace(workspace_);
	}
	else {
		dir_refresh_disable_ = false;
		loadWS(ws_name);
	}

	settings_.endGroup();

}



void C_MainWindow::le_cmd_returnPressed()
{
    QListViewItem* item = EsvnLVI::getFirstSelectedItem(list_dirs);
    const C_Path* sel_path = dynamic_cast<C_Path*>(item);

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

    QString cmd = cmd_LineEdit->text();
	cmd_LineEdit->setText("");

	QStringList elems = QStringList::split(' ', cmd);

	svn_commands_->command(sel_path->FullPath(), elems);
}

void C_MainWindow::show_Log(const C_Path& pathname, bool show_changed_paths)
{
	dlg_log_->setFileDir(pathname);
	dlg_log_->load(show_changed_paths);
	dlg_log_->show();
}

void C_MainWindow::show_Log(const C_Path& pathname)
{
    bool show_changed_paths = dlg_options_->ch_showchp->isChecked();
    show_Log(pathname, show_changed_paths);
}

void C_MainWindow::queryLogAction_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 << "modifyCopy_remote_Action_activated: No path available" << std::endl;
        return;
    }

    show_Log(*sel_path);
}

void C_MainWindow::queryStatusAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

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

    svn_commands_->status(selection);
}

void C_MainWindow::show_View(const C_Path& pathname)
{
    QStringList cat;
	bool res = svn_commands_->cat(pathname,"", cat);
	if (res == 0) {
		dlg_view_->tb_view->clear();
		for (size_t i=0; i<cat.size(); i++) {
			if (cat[i].isEmpty())
				dlg_view_->tb_view->append(" ");
			else
				dlg_view_->tb_view->append(cat[i]);
		}

		dlg_view_->tb_view->verticalScrollBar()->setValue(0);

		dlg_view_->setCaption("View");
		dlg_view_->show();
	}
}

void C_MainWindow::queryViewAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

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

    show_View(selection[0]);
}

void C_MainWindow::queryBlameAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

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

	QMessageBox mb( "Confirmation",
					"You are about to execute \"blame\" command for the following item. \n"
                    "It may take a while!\n\n" + selection[0].Name() +"\n",
					QMessageBox::Question,
					QMessageBox::Yes | QMessageBox::Default,
					QMessageBox::No  | QMessageBox::Escape,
					QMessageBox::NoButton );

	if ( mb.exec() != QMessageBox::Yes )
		return;


	QStringList blame;
	bool res = svn_commands_->blame(selection[0],"", blame);
	if (res == 0) {
		dlg_view_->tb_view->clear();
		for (size_t i=0; i<blame.size(); i++)
			dlg_view_->tb_view->append(blame[i]);

		dlg_view_->tb_view->verticalScrollBar()->setValue(0);

		dlg_view_->setCaption("Blame");
		dlg_view_->show();
	}
}



void C_MainWindow::queryInfoAction_activated()
{
    bool res = false;
	//cout << "info" << endl;

    PathSelection selection;

    getSelectedPaths(selection);

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

	QStringList info;
    res = svn_commands_->info(selection, info);

	if (res == 0) {
		dlg_info_->text_info->clear();
		for (size_t i=0; i<info.size(); i++)
			dlg_info_->text_info->append(info[i]);

		dlg_info_->show();
	}
}


void C_MainWindow::queryDiffAction_activated()
{
    PathSelection selection;

    getSelectedPaths(selection);

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

    for (size_t i = 0; i < selection.size(); ++i) {
        const C_Path& current = selection[i];

        dlg_diff_setup_->lb_url->hide();
        QString url = getUrlOnline(current);
        dlg_diff_setup_->lb_url->setText(url);

        dlg_diff_setup_->le_url1->setText(current.Name());

        dlg_diff_setup_->setFileDir(current);

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

            QString first = dlg_diff_setup_->le_url1->text();


            if (first.isEmpty())
                first = current.Name();


            if (!dlg_diff_setup_->ch_extdiff->isChecked())
                internalDiff(current.Path(),
                    first, dlg_diff_setup_->le_url2->text(), rev,
                    dlg_diff_setup_->ch_nonrecursive->isChecked(), dlg_diff_setup_->ch_noticea->isChecked(),
                    dlg_diff_setup_->le_ext->text());
            else {
                QStringList out;
                svn_commands_->diff(current.Path(),
                    first, dlg_diff_setup_->le_url2->text(), rev, true,
                    dlg_diff_setup_->ch_nonrecursive->isChecked(), dlg_diff_setup_->ch_noticea->isChecked(),
                    dlg_diff_setup_->le_ext->text(), out);
            }
        }
    }
}



void C_MainWindow::query3_Way_DiffAction_activated()
{
    PathSelection selection;
    getSelectedFiles(selection);

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

    for (PathSelection::const_iterator it = selection.begin(); it != selection.end(); ++it)
    {
		const C_Path& path = *it;
		if (path.isDir()) {
			QString text = "Diff3: " + path.Name() + " is a directory";
			textBrowser->append(text);
			continue;
		}

		// Need to load entries for each selected item current directory
		QString full_path = path.FullPath();
		C_DirPath file_level;

		// Descend to file current directory

		int pos = full_path.findRev('/');

		if (pos == -1)
		{
			file_level.SetPath("");
			file_level.SetName(full_path);
		}
		else
		{
			file_level.SetPath(full_path.left(pos));
			file_level.SetName(full_path.mid(pos+1));
		}

		// Load entries

		C_SvnEntries svn_entries;
		C_DirPath currwd;
		currwd.SetPath(file_level.Path());
		svn_entries.setDir(currwd, false);