Fuel

	ui->mainToolBar->addWidget(spacer);

	viewMode = VIEWMODE_TREE;

	uiCallback.init(this);

	// Need to be before applySettings which sets the last workspace
	getWorkspace().fossil().Init(&uiCallback, settings.GetValue(FUEL_SETTING_FOSSIL_PATH).toString());
	getWorkspace().Init(&uiCallback, settings.GetValue(FUEL_SETTING_FOSSIL_PATH).toString());

	applySettings();

	// Apply any explicit workspace path if available
	if(workspacePath && !workspacePath->isEmpty())
		openWorkspace(*workspacePath);

							wkspace);

				if(wkspace.isEmpty() || !QDir(wkspace).exists())
					return false;
			}

			// Ok open the repository file
			if(!getWorkspace().fossil().createWorkspace(fi.absoluteFilePath(), wkspace))
			if(!getWorkspace().createWorkspace(fi.absoluteFilePath(), wkspace))
			{
				QMessageBox::critical(this, tr("Error"), tr("Could not open repository."), QMessageBox::Ok );
				return false;
			}

		}
		else

	stopUI();
	on_actionClearLog_triggered();

	// Create repository
	QString repo_abs_path = repo_path_info.absoluteFilePath();

	if(!getWorkspace().fossil().createRepository(repo_abs_path))
	if(!getWorkspace().createRepository(repo_abs_path))
	{
		QMessageBox::critical(this, tr("Error"), tr("Could not create repository."), QMessageBox::Ok );
		return;
	}

	if(!getWorkspace().fossil().createWorkspace(repo_abs_path, wkdir))
	if(!getWorkspace().createWorkspace(repo_abs_path, wkdir))
	{
		QMessageBox::critical(this, tr("Error"), tr("Could not open repository."), QMessageBox::Ok );
		return;
	}

	// Disable unknown file filter
	if(!ui->actionViewUnknown->isChecked())
		ui->actionViewUnknown->setChecked(true);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionCloseRepository_triggered()
{
	if(getWorkspace().fossil().getWorkspaceState()!=Fossil::WORKSPACE_STATE_OK)
	if(getWorkspace().getWorkspaceState()!=Fossil::WORKSPACE_STATE_OK)
		return;

	if(QMessageBox::Yes !=DialogQuery(this, tr("Close Workspace"), tr("Are you sure you want to close this workspace?")))
		return;

	// Close Repo
	if(!getWorkspace().fossil().closeWorkspace())
	if(!getWorkspace().closeWorkspace())
	{
		QMessageBox::critical(this, tr("Error"), tr("Cannot close the workspace.\nAre there still uncommitted changes available?"), QMessageBox::Ok );
		return;
	}

	stopUI();
	setCurrentWorkspace("");

	QString repository;

	if(!CloneDialog::run(this, url, repository, url_proxy))
		return;

	stopUI();

	if(!getWorkspace().fossil().cloneRepository(repository, url, url_proxy))
	if(!getWorkspace().cloneRepository(repository, url, url_proxy))
	{
		QMessageBox::critical(this, tr("Error"), tr("Could not clone the repository"), QMessageBox::Ok);
		return;
	}

	if(!openWorkspace(repository))
		return;

//------------------------------------------------------------------------------
bool MainWindow::scanWorkspace()
{
	setBusy(true);
	bool valid = true;

	// Load repository info
	Fossil::WorkspaceState st = getWorkspace().fossil().getWorkspaceState();
	Fossil::WorkspaceState st = getWorkspace().getWorkspaceState();
	QString status;

	if(st==Fossil::WORKSPACE_STATE_NOTFOUND)
	{
		status = tr("No workspace detected.");
		valid = false;
	}

	}
}
//------------------------------------------------------------------------------
bool MainWindow::diffFile(const QString &repoFile)
{
	const QString &gdiff = settings.GetFossilValue(FOSSIL_SETTING_GDIFF_CMD).toString();
	if(!gdiff.isEmpty())
		return getWorkspace().fossil().diffFile(repoFile, true);
		return getWorkspace().diffFile(repoFile, true);
	else
		return getWorkspace().fossil().diffFile(repoFile, false);
		return getWorkspace().diffFile(repoFile, false);
}

//------------------------------------------------------------------------------
void MainWindow::on_actionDiff_triggered()
{
	QStringList selection;
	getSelectionFilenames(selection, WorkspaceFile::TYPE_REPO);

	// a partial commit which is not permitted.
	QStringList all_modified_files;
	getAllFilenames(all_modified_files, WorkspaceFile::TYPE_MODIFIED);

	if(commit_files.size() != all_modified_files.size())
		files = commit_files;

	if(!getWorkspace().fossil().commitFiles(files, msg, branch_name, private_branch))
	if(!getWorkspace().commitFiles(files, msg, branch_name, private_branch))
		QMessageBox::critical(this, tr("Error"), tr("Could not commit changes."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionAdd_triggered()
{
	// Get unknown files only
	QStringList selection;
	getSelectionFilenames(selection, WorkspaceFile::TYPE_UNKNOWN);

	if(selection.empty())
		return;

	if(!FileActionDialog::run(this, tr("Add files"), tr("The following files will be added.")+"\n"+tr("Are you sure?"), selection))
		return;

	// Do Add
	if(!getWorkspace().fossil().addFiles(selection))
	if(!getWorkspace().addFiles(selection))
		QMessageBox::critical(this, tr("Error"), tr("Could not add files."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionDelete_triggered()

	if(!FileActionDialog::run(this, tr("Remove files"), tr("The following files will be removed from the repository.")+"\n"+tr("Are you sure?"), all_files, tr("Also delete the local files"), &remove_local ))
		return;

	// Remove repository files
	if(!repo_files.empty())
	{
		if(!getWorkspace().fossil().removeFiles(repo_files, remove_local))
		if(!getWorkspace().removeFiles(repo_files, remove_local))
			QMessageBox::critical(this, tr("Error"), tr("Could not remove files."), QMessageBox::Ok);
	}

	// Remove unknown local files if selected
	if(remove_local)
	{
		for(int i=0; i<unknown_files.size(); ++i)

	if(modified_files.empty())
		return;

	if(!FileActionDialog::run(this, tr("Revert files"), tr("The following files will be reverted.")+"\n"+tr("Are you sure?"), modified_files))
		return;

	// Do Revert
	if(!getWorkspace().fossil().revertFiles(modified_files))
	if(!getWorkspace().revertFiles(modified_files))
		QMessageBox::critical(this, tr("Error"), tr("Could not revert files."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionRename_triggered()

	if(fi_after.exists())
	{
		QMessageBox::critical(this, tr("Error"), tr("File '%0' already exists.\nRename aborted.").arg(new_name), QMessageBox::Ok );
		return;
	}

	// Do Rename
	if(!getWorkspace().fossil().renameFile(fi_before.filePath(), fi_after.filePath(), true))
	if(!getWorkspace().renameFile(fi_before.filePath(), fi_after.filePath(), true))
		QMessageBox::critical(this, tr("Error"), tr("Could not rename file '%0' to '%1'").arg(fi_before.filePath(), fi_after.filePath()), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionOpenContaining_triggered()

//------------------------------------------------------------------------------
void MainWindow::on_actionUndo_triggered()
{
	// Gather Undo actions
	QStringList res;

	// Do test Undo
	if(!getWorkspace().fossil().undoWorkspace(res, true))
	if(!getWorkspace().undoWorkspace(res, true))
		QMessageBox::critical(this, tr("Error"), tr("Could not undo changes."), QMessageBox::Ok);

	if(res.length()>0 && res[0]=="No undo or redo is available")
		return;

	if(!FileActionDialog::run(this, tr("Undo"), tr("The following actions will be undone.")+"\n"+tr("Are you sure?"), res))
		return;

	// Do Undo
	if(!getWorkspace().fossil().undoWorkspace(res, false))
	if(!getWorkspace().undoWorkspace(res, false))
		QMessageBox::critical(this, tr("Error"), tr("Could not undo changes."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionAbout_triggered()
{
	QString fossil_ver;
	getWorkspace().fossil().getExeVersion(fossil_ver);
	QString version;
	getWorkspace().getInterfaceVersion(version);

	AboutDialog dlg(this, fossil_ver);
	AboutDialog dlg(this, version);
	dlg.exec();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionUpdate_triggered()
{
	QStringList selected = selectedBranches + selectedTags;

	// Rename files in fossil
	Q_ASSERT(files_to_move.length() == new_paths.length());
	for(int i=0; i<files_to_move.length(); ++i)
	{
		WorkspaceFile *r = files_to_move[i];
		const QString &new_file_path = new_paths[i] + PATH_SEPARATOR + r->getFilename();

		if(!getWorkspace().fossil().renameFile(r->getFilePath(), new_file_path, false))
		if(!getWorkspace().renameFile(r->getFilePath(), new_file_path, false))
		{
			log(tr("Move aborted due to errors")+"\n");
			goto _exit;
		}
	}

	if(!move_local)

		{
			QMessageBox::critical(this, tr("Error"), tr("This stash already exists"));
			return;
		}
	}

	// Do Stash
	if(!getWorkspace().fossil().stashNew(stashed_files, stash_name, revert))
	if(!getWorkspace().stashNew(stashed_files, stash_name, revert))
		QMessageBox::critical(this, tr("Error"), tr("Could not create stash."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionApplyStash_triggered()

	// Apply stashes
	for(QStringList::iterator it=stashes.begin(); it!=stashes.end(); ++it)
	{
		stashmap_t::iterator id_it = getWorkspace().getStashes().find(*it);
		Q_ASSERT(id_it!=getWorkspace().getStashes().end());

		if(!getWorkspace().fossil().stashApply(*id_it))
		if(!getWorkspace().stashApply(*id_it))
		{
			log(tr("Stash application aborted due to errors")+"\n");
			QMessageBox::critical(this, tr("Error"), tr("Could not apply stash."), QMessageBox::Ok);
			return;
		}
	}

	// Delete stashes
	for(QStringList::iterator it=stashes.begin(); delete_stashes && it!=stashes.end(); ++it)
	{
		stashmap_t::iterator id_it = getWorkspace().getStashes().find(*it);
		Q_ASSERT(id_it!=getWorkspace().getStashes().end());

		if(!getWorkspace().fossil().stashDrop(*id_it))
		if(!getWorkspace().stashDrop(*id_it))
		{
			log(tr("Stash deletion aborted due to errors")+"\n");
			QMessageBox::critical(this, tr("Error"), tr("Could not delete stash."), QMessageBox::Ok);
			return;
		}
	}

	// Delete stashes
	for(QStringList::iterator it=stashes.begin(); it!=stashes.end(); ++it)
	{
		stashmap_t::iterator id_it = getWorkspace().getStashes().find(*it);
		Q_ASSERT(id_it!=getWorkspace().getStashes().end());

		if(!getWorkspace().fossil().stashDrop(*id_it))
		if(!getWorkspace().stashDrop(*id_it))
		{
			log(tr("Stash deletion aborted due to errors")+"\n");
			QMessageBox::critical(this, tr("Error"), tr("Could not delete stash."), QMessageBox::Ok);
			return;
		}
	}

	if(stashes.length() != 1)
		return;

	stashmap_t::iterator id_it = getWorkspace().getStashes().find(*stashes.begin());
	Q_ASSERT(id_it!=getWorkspace().getStashes().end());

	// Run diff
	if(!getWorkspace().fossil().stashDiff(*id_it))
	if(!getWorkspace().stashDiff(*id_it))
		QMessageBox::critical(this, tr("Error"), tr("Could not diff stash."), QMessageBox::Ok);
}

//------------------------------------------------------------------------------
void MainWindow::onFileViewDragOut()
{
	QStringList filenames;

		// Any files to add?
		if(!newfiles.empty())
		{
			if(!FileActionDialog::run(this, tr("Add files"), tr("The following files will be added.")+"\n"+tr("Are you sure?"), newfiles))
				return;

			// Do Add
			if(!getWorkspace().fossil().addFiles(newfiles))
			if(!getWorkspace().addFiles(newfiles))
				QMessageBox::critical(this, tr("Error"), tr("Could not add files."), QMessageBox::Ok);

			refresh();
		}
	}
}

		return;
	else if(selected_revision == latest)
		selected_revision = ""; // Empty revision is "latest"

	QStringList res;

	// Do test update
	if(!getWorkspace().fossil().updateWorkspace(res, selected_revision, true))
	if(!getWorkspace().updateWorkspace(res, selected_revision, true))
	{
		QMessageBox::critical(this, tr("Error"), tr("Could not update the repository."), QMessageBox::Ok);
		return;
	}

	if(res.length()==0)
		return;

	QStringMap kv;
	ParseProperties(kv, res, ':');

	// If no changes exit
	if(kv.contains("changes") && kv["changes"].indexOf("None.")!=-1)
		return;

	if(!FileActionDialog::run(this, tr("Update"), tr("The following files will be updated.")+"\n"+tr("Are you sure?"), res))
		return;

	// Do update
	if(!getWorkspace().fossil().updateWorkspace(res, selected_revision, false))
	if(!getWorkspace().updateWorkspace(res, selected_revision, false))
		QMessageBox::critical(this, tr("Error"), tr("Could not update the repository."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionCreateTag_triggered()

	if(name.isEmpty() || getWorkspace().getTags().contains(name) || getWorkspace().getBranches().contains(name))
	{
		QMessageBox::critical(this, tr("Error"), tr("Invalid name."), QMessageBox::Ok);
		return;
	}

	if(!getWorkspace().fossil().tagNew(name, revision))
	if(!getWorkspace().tagNew(name, revision))
		QMessageBox::critical(this, tr("Error"), tr("Could not create tag."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionDeleteTag_triggered()
{
	if(selectedTags.size()!=1)
		return;

	const QString &tagname = selectedTags.first();

	if(QMessageBox::Yes != DialogQuery(this, tr("Delete Tag"), tr("Are you sure want to delete the tag '%0' ?").arg(tagname)))
		return;

	Q_ASSERT(getWorkspace().getTags().contains(tagname));

	const QString &revision = getWorkspace().getTags()[tagname];

	if(!getWorkspace().fossil().tagDelete(tagname, revision))
	if(!getWorkspace().tagDelete(tagname, revision))
		QMessageBox::critical(this, tr("Error"), tr("Could not delete tag."), QMessageBox::Ok);

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionCreateBranch_triggered()

	if(branch_name.isEmpty() || getWorkspace().getTags().contains(branch_name) || getWorkspace().getBranches().contains(branch_name))
	{
		QMessageBox::critical(this, tr("Error"), tr("Invalid name."), QMessageBox::Ok);
		return;
	}

	if(!getWorkspace().fossil().branchNew(branch_name, revision, false))
	if(!getWorkspace().branchNew(branch_name, revision, false))
	{
		QMessageBox::critical(this, tr("Error"), tr("Could not create branch."), QMessageBox::Ok);
		return;
	}

	// Update to this branch.
	updateRevision(branch_name);

	bool force = false;
	revision = RevisionDialog::runMerge(this, tr("Merge Branch"), versionList, revision, integrate, force);

	if(revision.isEmpty())
		return;

	// Do test merge
	if(!getWorkspace().fossil().branchMerge(res, revision, integrate, force, true))
	if(!getWorkspace().branchMerge(res, revision, integrate, force, true))
	{
		QMessageBox::critical(this, tr("Error"), tr("Merge failed."), QMessageBox::Ok);
		return;
	}

	if(!FileActionDialog::run(this, tr("Merge"), tr("The following changes will be applied.")+"\n"+tr("Are you sure?"), res))
		return;

	// Do update
	if(!getWorkspace().fossil().branchMerge(res, revision, integrate, force, false))
	if(!getWorkspace().branchMerge(res, revision, integrate, force, false))
		QMessageBox::critical(this, tr("Error"), tr("Merge failed."), QMessageBox::Ok);
	else
		log(tr("Merge completed. Don't forget to commit!")+"\n");

	refresh();
}

	QUrl url(remotes.first());

	// Retrieve password from keychain
	if(!url.isLocalFile())
		KeychainGet(this, url, *settings.GetStore());

	if(!getWorkspace().fossil().pushWorkspace(url))
	if(!getWorkspace().pushWorkspace(url))
		QMessageBox::critical(this, tr("Error"), tr("Could not push to the remote repository."), QMessageBox::Ok);
}

//------------------------------------------------------------------------------
void MainWindow::on_actionPullRemote_triggered()
{
	QStringList remotes;
	getSelectionRemotes(remotes);
	if(remotes.empty())
		return;

	QUrl url(remotes.first());

	// Retrieve password from keychain
	if(!url.isLocalFile())
		KeychainGet(this, url, *settings.GetStore());

	if(!getWorkspace().fossil().pullWorkspace(url))
	if(!getWorkspace().pullWorkspace(url))
		QMessageBox::critical(this, tr("Error"), tr("Could not pull from the remote repository."), QMessageBox::Ok);
}

//------------------------------------------------------------------------------
void MainWindow::on_actionPush_triggered()
{
	QUrl url = getWorkspace().getRemoteDefault();

	if(url.isEmpty())
	{
		QMessageBox::critical(this, tr("Error"), tr("A default remote repository has not been specified."), QMessageBox::Ok);
		return;
	}

	// Retrieve password from keychain
	if(!url.isLocalFile())
		KeychainGet(this, url, *settings.GetStore());

	if(!getWorkspace().fossil().pushWorkspace(url))
	if(!getWorkspace().pushWorkspace(url))
		QMessageBox::critical(this, tr("Error"), tr("Could not push to the remote repository."), QMessageBox::Ok);
}

//------------------------------------------------------------------------------
void MainWindow::on_actionPull_triggered()
{
	QUrl url = getWorkspace().getRemoteDefault();

	if(url.isEmpty())
	{
		QMessageBox::critical(this, tr("Error"), tr("A default remote repository has not been specified."), QMessageBox::Ok);
		return;
	}

	// Retrieve password from keychain
	if(!url.isLocalFile())
		KeychainGet(this, url, *settings.GetStore());

	if(!getWorkspace().fossil().pullWorkspace(url))
	if(!getWorkspace().pullWorkspace(url))
		QMessageBox::critical(this, tr("Error"), tr("Could not pull from the remote repository."), QMessageBox::Ok);
}

//------------------------------------------------------------------------------
void MainWindow::on_actionSetDefaultRemote_triggered()
{
	QStringList remotes;

			KeychainGet(this, url, *settings.GetStore());

		// FIXME: Fossil currently ignores the password in "remote-url"
		// which breaks commits due to a missing password when autosync is enabled
		// so only set the remote url when there is no password set
		if(url.password().isEmpty())
		{
			if(!getWorkspace().fossil().setRemoteUrl(url))
			if(!getWorkspace().setDefaultRemoteUrl(url))
				QMessageBox::critical(this, tr("Error"), tr("Could not set the remote repository."), QMessageBox::Ok);
		}
	}

	updateWorkspaceView();
}