Fuel

#-------------------------------------------------
# Fuel
#-------------------------------------------------

QT    = core gui webkit

contains(QT_VERSION, ^5\\..*) {
	QT += widgets webkitwidgets
	QT -= quick multimediawidgets opengl printsupport qml multimedia positioning sensors
}

TARGET = Fuel
TEMPLATE = app

win32 {
	RC_FILE = rsrc/fuel.rc

INCLUDEPATH += src

SOURCES += src/main.cpp\
	src/MainWindow.cpp \
	src/CommitDialog.cpp \
	src/FileActionDialog.cpp \
	src/SettingsDialog.cpp \
	src/FslSettingsDialog.cpp \
	src/CloneDialog.cpp \
	src/RevisionDialog.cpp \
	src/Utils.cpp \
	src/FileTableView.cpp \

	src/LoggedProcess.cpp \
	src/BrowserWidget.cpp \
	src/CustomWebView.cpp \
	src/Fossil.cpp \
	src/Workspace.cpp \
	src/SearchBox.cpp \
	src/Settings.cpp

HEADERS  += src/MainWindow.h \
	src/CommitDialog.h \
	src/FileActionDialog.h \
	src/SettingsDialog.h \
	src/FslSettingsDialog.h \
	src/CloneDialog.h \
	src/RevisionDialog.h \
	src/Utils.h \
	src/FileTableView.h \

	src/LoggedProcess.h \
	src/BrowserWidget.h \
	src/CustomWebView.h \
	src/Fossil.h \
	src/Workspace.h \
	src/SearchBox.h \
	src/Settings.h

FORMS    += ui/MainWindow.ui \
	ui/CommitDialog.ui \
	ui/FileActionDialog.ui \
	ui/SettingsDialog.ui \
	ui/FslSettingsDialog.ui \
	ui/CloneDialog.ui \
	ui/BrowserWidget.ui \
	ui/RevisionDialog.ui

RESOURCES += \
	rsrc/resources.qrc

CODECFORTR = UTF-8

TRANSLATIONS += \

<RCC>
  <qresource prefix="/icons">
	<file>icons/Address Book-01.png</file>
	<file>icons/Adobe Illustrator CS3 Document-01.png</file>
	<file>icons/Adobe PDF Document-01.png</file>
	<file>icons/Adobe Photoshop CS3 Document-01.png</file>
	<file alias="icon-application">icons/Battery-01.png</file>
	<file>icons/Binoculars-01.png</file>
	<file alias="icon-item-tag">icons/Book-01.png</file>
	<file>icons/Briefcase-01.png</file>
	<file alias="icon-item-added">icons/Button Add-01.png</file>
	<file>icons/Button Blank Blue-01.png</file>
	<file alias="icon-item-unknown">icons/Button Blank Gray-01.png</file>
	<file alias="icon-item-unchanged">icons/Button Blank Green-01.png</file>
	<file alias="icon-item-conflicted">icons/Button Blank Red-01.png</file>
	<file alias="icon-item-edited">icons/Button Blank Yellow-01.png</file>
	<file>icons/Button Cancel-01.png</file>
	<file alias="icon-item-deleted">icons/Button Close-01.png</file>
	<file alias="icon-action-tag-delete">icons/Button Close-01.png</file>
	<file alias="icon-action-stop">icons/Button Close-01.png</file>
	<file>icons/Button Delete-01.png</file>
	<file alias="icon-action-pull">icons/Button Download-01.png</file>
	<file>icons/Button Favorite-01.png</file>
	<file>icons/Button Forward-01.png</file>
	<file alias="icon-item-missing">icons/Button Help-01.png</file>
	<file>icons/Button Info-01.png</file>
	<file>icons/Button Log Off-01.png</file>
	<file alias="icon-action-next">icons/Button Next-01.png</file>
	<file>icons/Button Pause-01.png</file>
	<file alias="icon-action-update">icons/Button Play-01.png</file>
	<file alias="icon-action-previous">icons/Button Previous-01.png</file>
	<file alias="icon-action-refresh">icons/Button Refresh-01.png</file>
	<file alias="icon-action-undo">icons/Button Reload-01.png</file>
	<file alias="icon-item-renamed">icons/Button Reload-01.png</file>
	<file>icons/Button Reminder-01.png</file>
	<file alias="icon-action-revert">icons/Button Rewind-01.png</file>
	<file>icons/Button Talk Balloon-01.png</file>
	<file alias="icon-action-quit">icons/Button Turn Off-01.png</file>
	<file>icons/Button Turn On-01.png</file>
	<file alias="icon-action-push">icons/Button Upload-01.png</file>
	<file>icons/Button Warning-01.png</file>
	<file>icons/Calculator-01.png</file>
	<file>icons/Calendar Blue-01.png</file>
	<file>icons/Calendar Green-01.png</file>
	<file>icons/Calendar Red-01.png</file>
	<file>icons/Clipboard-01.png</file>
	<file>icons/Clipboard Paste-01.png</file>
	<file alias="icon-action-timeline">icons/Clock-01.png</file>
	<file>icons/Coin-01.png</file>
	<file>icons/Compressed File RAR-01.png</file>
	<file>icons/Compressed File SIT-01.png</file>
	<file>icons/Compressed File Zip-01.png</file>
	<file>icons/Computer Monitor-01.png</file>
	<file>icons/Computer Network-01.png</file>
	<file alias="icon-item-file">icons/Document-01.png</file>
	<file>icons/Document Attach-01.png</file>
	<file alias="icon-action-repo-new">icons/Document Blank-01.png</file>
	<file>icons/Document Chart-01.png</file>
	<file alias="icon-item-diff">icons/Document Copy-01.png</file>
	<file alias="icon-action-merge">icons/Document Flow Chart-01.png</file>
	<file>icons/Document Gant Chart-01.png</file>
	<file>icons/Document Help-01.png</file>
	<file>icons/Document Line Chart-01.png</file>
	<file>icons/Document Microsoft Excel-01.png</file>
	<file>icons/Document Microsoft PowerPoint-01.png</file>
	<file>icons/Document Microsoft Word-01.png</file>
	<file alias="icon-item-branch">icons/Document Organization Chart-01.png</file>
	<file>icons/Document Preview-01.png</file>
	<file alias="icon-item-revert">icons/Document-Revert-icon.png</file>
	<file>icons/Document Text-01.png</file>
	<file>icons/Edit Document-01.png</file>
	<file>icons/Email-01.png</file>
	<file>icons/Email Attachment-01.png</file>
	<file>icons/Email Delete-01.png</file>
	<file>icons/Email Download-01.png</file>
	<file>icons/Email Forward-01.png</file>
	<file>icons/Email Inbox-01.png</file>
	<file>icons/Email Reply-01.png</file>
	<file>icons/File Audio-01.png</file>
	<file>icons/File Audio AIFF-01.png</file>
	<file>icons/File Audio MP3-01.png</file>
	<file>icons/File Audio WAV-01.png</file>
	<file>icons/File Audio WMA-01.png</file>
	<file alias="icon-item-delete">icons/File Delete-01.png</file>
	<file alias="icon-item-history">icons/File History-01.png</file>
	<file alias="icon-item-add">icons/File New-01.png</file>
	<file alias="icon-item-rename">icons/File Open-01.png</file>
	<file>icons/File Video 3GP-01.png</file>
	<file>icons/File Video-01.png</file>
	<file>icons/File Video AVI-01.png</file>
	<file>icons/File Video MOV-01.png</file>
	<file>icons/File Video MPEG-01.png</file>
	<file>icons/File Video WMV-01.png</file>
	<file alias="icon-item-folder">icons/Folder-01.png</file>
	<file alias="icon-action-stash-new">icons/Folder Add-01.png</file>
	<file alias="icon-action-stash-apply">icons/Folder Compressed-01.png</file>
	<file alias="icon-action-stash-delete">icons/Folder Delete-01.png</file>
	<file alias="icon-action-stash-diff">icons/Folder Explorer-01.png</file>
	<file alias="icon-action-folder-explore">icons/Folder Explorer-01.png</file>
	<file>icons/Folder Generic Blue-01.png</file>
	<file>icons/Folder Generic Green-01.png</file>
	<file>icons/Folder Generic Red-01.png</file>
	<file>icons/Folder Generic Silver-01.png</file>
	<file alias="icon-action-folder-rename">icons/Folder Open-01.png</file>
	<file>icons/Folder RAR-01.png</file>
	<file>icons/Games-01.png</file>
	<file alias="icon-action-settings">icons/Gear-01.png</file>
	<file>icons/Highlighter Blue-01.png</file>
	<file>icons/Highlighter Green-01.png</file>
	<file alias="icon-action-tag-new">icons/Highlighter Yellow-01.png</file>
	<file>icons/Image BMP-01.png</file>
	<file>icons/Image GIF-01.png</file>
	<file>icons/Image JPEG-01.png</file>
	<file>icons/Image PNG-01.png</file>
	<file>icons/Image TIFF-01.png</file>
	<file>icons/Lock Lock-01.png</file>
	<file>icons/Lock Unlock-01.png</file>
	<file alias="icon-action-repo-open">icons/My Documents-01.png</file>
	<file>icons/My Ebooks-01.png</file>
	<file>icons/My Music-01.png</file>
	<file>icons/My Pictures.png</file>
	<file>icons/My Videos-01.png</file>
	<file alias="icon-action-repo-clone">icons/My Websites-01.png</file>
	<file>icons/Network Firewall-01.png</file>
	<file alias="icon-webview">icons/Network MAC-01.png</file>
	<file alias="icon-item-remote" >icons/Network PC-01.png</file>
	<file>icons/Network Refresh-01.png</file>
	<file>icons/Pen Blue-01.png</file>
	<file>icons/Pen Green-01.png</file>
	<file>icons/Pen Red-01.png</file>
	<file alias="icon-action-commit">icons/Save-01.png</file>
	<file alias="icon-clear-log">icons/Text Edit.png</file>
	<file>icons/USB-01.png</file>
	<file>icons/User Administrator Blue-01.png</file>
	<file>icons/User Administrator Green-01.png</file>
	<file>icons/User Administrator Red-01.png</file>
	<file>icons/User Chat-01.png</file>
	<file>icons/User Clients-01.png</file>
	<file>icons/User Coat Blue-01.png</file>
	<file>icons/User Coat Green-01.png</file>
	<file>icons/User Coat Red-01.png</file>
	<file>icons/User Executive Blue-01.png</file>
	<file>icons/User Executive Green-01.png</file>
	<file>icons/User Executive Red-01.png</file>
	<file>icons/User Group-01.png</file>
	<file>icons/User Preppy Blue-01.png</file>
	<file>icons/User Preppy Green-01.png</file>
	<file>icons/User Preppy Red-01.png</file>
	<file>icons/Web HTML-01.png</file>
	<file>icons/Web XML-01.png</file>
	<file>icons/Window-01.png</file>
	<file>icons/Window Refresh-01.png</file>
	<file>icons/Windows-01.png</file>
	<file>icons/Windows Cascade-01.png</file>
	<file>icons/Zoom-01.png</file>
	<file>icons/Zoom In-01.png</file>
	<file>icons/Zoom Out-01.png</file>
  </qresource>
  <qresource prefix="/intl">
	<file>intl/el_GR.qm</file>
	<file>intl/de_DE.qm</file>
	<file>intl/es_ES.qm</file>
	<file>intl/fr_FR.qm</file>
	<file>intl/ru_RU.qm</file>
	<file>intl/pt_PT.qm</file>
  </qresource>
</RCC>

#include "CommitDialog.h"
#include <QPushButton>
#include <QShortcut>
#include "ui_CommitDialog.h"
#include "MainWindow.h" // Ugly. I know.

CommitDialog::CommitDialog(QWidget *parent, const QString &title, QStringList &files, const QStringList *history, bool stashMode) :
	QDialog(parent, Qt::Sheet),
	ui(new Ui::CommitDialog)
{
	ui->setupUi(this);
	ui->plainTextEdit->clear();
	ui->listView->setModel(&itemModel);

	setWindowTitle(title);

	// Activate the appropriate control based on mode
	ui->plainTextEdit->setVisible(!stashMode);
	ui->lineEdit->setVisible(stashMode);

	// Activate the checkbox if we have some text
	ui->chkRevertFiles->setVisible(stashMode);


	ui->widgetBranchOptions->setVisible(!stashMode);



	// Activate the combo if we have history
	ui->comboBox->setVisible(history!=0);
	if(history)
	{
		// Generate the history combo
		foreach(const QString msg, *history)

//------------------------------------------------------------------------------
CommitDialog::~CommitDialog()
{
	delete ui;
}

//------------------------------------------------------------------------------
bool CommitDialog::runCommit(QWidget* parent, QStringList& files, QString& commitMsg, const QStringList& commitMsgHistory, QString &branchName, bool &privateBranch)
{
	CommitDialog dlg(parent, tr("Commit Changes"), files, &commitMsgHistory, false);
	int res = dlg.exec();




	commitMsg = dlg.ui->plainTextEdit->toPlainText();


	if(res!=QDialog::Accepted)
		return false;

	files.clear();
	for(int i=0; i<dlg.itemModel.rowCount(); ++i)
	{
		QStandardItem *si = dlg.itemModel.item(i);
		if(si->checkState()!=Qt::Checked)
			continue;
		files.append(si->text());
	}

	branchName.clear();
	if(dlg.ui->chkNewBranch->isChecked())
	{
		branchName = dlg.ui->lineBranchName->text().trimmed();
		privateBranch = dlg.ui->chkPrivateBranch->isChecked();
	}

	return true;
}

//------------------------------------------------------------------------------
bool CommitDialog::runStashNew(QWidget* parent, QStringList& stashedFiles, QString& stashName, bool& revertFiles)
{
	CommitDialog dlg(parent, tr("Stash Changes"), stashedFiles, NULL, true);
	int res = dlg.exec();

	stashName = dlg.ui->lineEdit->text();

	if(res!=QDialog::Accepted)
		return false;

	stashedFiles.clear();
	for(int i=0; i<dlg.itemModel.rowCount(); ++i)
	{
		QStandardItem *si = dlg.itemModel.item(i);
		if(si->checkState()!=Qt::Checked)
			continue;
		stashedFiles.append(si->text());
	}

	revertFiles = dlg.ui->chkRevertFiles->checkState() == Qt::Checked;
	return true;
}

//------------------------------------------------------------------------------
void CommitDialog::on_comboBox_activated(int index)
{
	Q_ASSERT(index < commitMessages.length());

		QStandardItem *si = itemModel.item(i);
		if(si->checkState()==Qt::Checked)
			++num_selected;
	}

	ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(num_selected>0);
}

//------------------------------------------------------------------------------
void CommitDialog::on_chkNewBranch_toggled(bool checked)
{
	ui->chkPrivateBranch->setEnabled(checked);
	ui->lineBranchName->setEnabled(checked);
}

#ifndef COMMITDIALOG_H
#define COMMITDIALOG_H

#include <QDialog>
#include <QStandardItemModel>

namespace Ui {
	class CommitDialog;
}

class CommitDialog : public QDialog
{
	Q_OBJECT

public:
	explicit CommitDialog(QWidget *parent, const QString &title, QStringList &files, const QStringList *history, bool stashMode);
	~CommitDialog();

	static bool runStashNew(QWidget* parent, QStringList& stashedFiles, QString& stashName, bool &revertFiles);
	static bool runCommit(QWidget* parent, QStringList& files, QString& commitMsg, const QStringList &commitMsgHistory, QString& branchName, bool& privateBranch);

private slots:
	void on_comboBox_activated(int index);
	void on_listView_doubleClicked(const QModelIndex &index);
	void on_listView_clicked(const QModelIndex &index);
	void on_chkNewBranch_toggled(bool checked);

private:
	Ui::CommitDialog *ui;
	QStandardItemModel	itemModel;
	QStringList commitMessages;
};

#endif // COMMITDIALOG_H

#include "Fossil.h"
#include <QStringList>
#include <QCoreApplication>

#include <QTextCodec>
#include <QDebug>
#include <QDir>
#include <QTemporaryFile>
#include <QUrl>
#include "Utils.h"

static const unsigned char		UTF8_BOM[] = { 0xEF, 0xBB, 0xBF };

// 19: [5c46757d4b9765] on 2012-04-22 04:41:15
static const QRegExp			REGEX_STASH("\\s*(\\d+):\\s+\\[(.*)\\] on (\\d+)-(\\d+)-(\\d+) (\\d+):(\\d+):(\\d+)", Qt::CaseInsensitive);

// Listening for HTTP requests on TCP port 8081
static const QRegExp			REGEX_PORT(".*TCP port ([0-9]+)\\n", Qt::CaseSensitive);

///////////////////////////////////////////////////////////////////////////////
RepoStatus Fossil::getRepoStatus()
{
	QStringList res;
	int exit_code = EXIT_FAILURE;

	// We need to determine the reason why fossil has failed

		if(run_ok)
		{
			if(key=="project-name")
				projectName = value;
			else if(key=="repository")
				repositoryFile = value;
			else if(key=="checkout")
			{
				// f2121dad5e4565f55ed9ef882484dd5934af565f 2015-04-26 17:27:39 UTC
				QStringList tokens = value.split(' ', QString::SkipEmptyParts);
				Q_ASSERT(tokens.length()>0);
				currentRevision = tokens[0].trimmed();
			}
			else if(key=="tags")
			{
				currentTags.clear();
				QStringList tokens = value.split(',', QString::SkipEmptyParts);
				foreach(const QString &tag, tokens)
					currentTags.append(tag);
				currentTags.sort();
			}
		}
	}

	return run_ok ? REPO_OK : REPO_NOT_FOUND;
}

//------------------------------------------------------------------------------

}

//------------------------------------------------------------------------------
bool Fossil::listFiles(QStringList &files)
{
	return runFossil(QStringList() << "ls" << "-l", &files, RUNFLAGS_SILENT_ALL);
}

//------------------------------------------------------------------------------
bool Fossil::status(QStringList &result)
{
	return runFossil(QStringList() << "status", &result, RUNFLAGS_SILENT_ALL);
}

//------------------------------------------------------------------------------
bool Fossil::pushRepository()
{
	return runFossil(QStringList() << "push");
}

bool Fossil::diffFile(const QString &repoFile)
{
	// Run the diff detached
	return runFossil(QStringList() << "gdiff" << QuotePath(repoFile), 0, RUNFLAGS_DETACHED);
}

//------------------------------------------------------------------------------
bool Fossil::commitFiles(const QStringList& fileList, const QString& comment, const QString &newBranchName, bool isPrivateBranch)
{
	// Do commit
	QString comment_fname;
	{
		QTemporaryFile temp_file;
		if(!temp_file.open())
			return false;

	// Write Comment
	comment_file.write(comment.toUtf8());
	comment_file.close();

	// Generate fossil parameters.
	QStringList params;
	params << "commit" << "--message-file" << QuotePath(comment_fname);

	// Commit to new branch
	if(!newBranchName.isEmpty())
	{
		params << "--branch" << newBranchName.trimmed();

		// Private branches are not synced with remotes
		if(isPrivateBranch)
			params << "--private";
	}

	params << QuotePaths(fileList);

	runFossil(params);
	QFile::remove(comment_fname);
	return true;
}

		params << "--explain";

	result.clear();
	return runFossil(params, &result);
}

//------------------------------------------------------------------------------
bool Fossil::updateRepository(QStringList &result, const QString &revision, bool explainOnly)
{
	QStringList params;
	params << "update";

	if(explainOnly)
		params << "--nochange";

	if(revision.isEmpty())
		params << "--latest";
	else
		params << revision;


	result.clear();
	return runFossil(params, &result);
}

//------------------------------------------------------------------------------
bool Fossil::getFossilSettings(QStringList &result)

}

//------------------------------------------------------------------------------
bool Fossil::stashDiff(const QString& name)
{
	return runFossil(QStringList() << "stash" << "diff" << name, 0);
}

//------------------------------------------------------------------------------
bool Fossil::tagList(QStringMap& tags)
{
	tags.clear();
	QStringList tagnames;

	if(!runFossil(QStringList() << "tag" << "ls", &tagnames, RUNFLAGS_SILENT_ALL))
		return false;

	QStringList info;
	foreach(const QString &line, tagnames)
	{
		QString tag = line.trimmed();

		if(tag.isEmpty())
			continue;

		info.clear();

		if(!runFossil(QStringList() << "info" << "tag:"+tag, &info, RUNFLAGS_SILENT_ALL))
			return false;

		QStringMap props;
		ParseProperties(props, info, ':');
		Q_ASSERT(props.contains("uuid"));

		// uuid:         0e29a46f036d2e0cc89727190ad34c2dfdc5737c 2015-04-27 15:41:45 UTC
		QStringList uuid = props["uuid"].trimmed().split(' ');
		Q_ASSERT(uuid.length()>0);

		QString revision = uuid[0].trimmed();
		tags.insert(tag, revision);
	}
	return true;
}

//------------------------------------------------------------------------------
bool Fossil::tagNew(const QString& name, const QString& revision)
{
	QStringList res;

	if(!runFossil(QStringList() << "tag" << "add" << name << revision, &res))
		return false;
	return true;
}

//------------------------------------------------------------------------------
bool Fossil::tagDelete(const QString& name, const QString &revision)
{
	QStringList res;

	if(!runFossil(QStringList() << "tag" << "cancel" << "tag:"+name << revision, &res))
		return false;

	return true;
}

//------------------------------------------------------------------------------
bool Fossil::branchList(QStringList& branches, QStringList& activeBranches)
{
	branches.clear();
	activeBranches.clear();
	QStringList res;

	if(!runFossil(QStringList() << "branch" , &res, RUNFLAGS_SILENT_ALL))
		return false;

	foreach(const QString &line, res)
	{
		QString name = line.trimmed();

		if(name.isEmpty())
			continue;

		// Active branches start with a start
		int active_index = name.indexOf('*');
		bool is_active = (active_index != -1) && active_index==0;

		// Strip
		if(is_active)
		{
			name = name.mid(is_active+1).trimmed();
			activeBranches.append(name);
		}
		else
			branches.append(name);
	}

	branches.sort();
	activeBranches.sort();
	return true;
}

//------------------------------------------------------------------------------
bool Fossil::branchNew(const QString& name, const QString& revisionBasis, bool isPrivate)
{
	QStringList params;

	params <<"branch"  << "new" << name << revisionBasis;

	if(isPrivate)
		params << "--private";

	QStringList res;

	if(!runFossil(params, &res))
		return false;
	return true;
}

//------------------------------------------------------------------------------
bool Fossil::branchMerge(QStringList &res, const QString& revision, bool integrate, bool force, bool testOnly)
{
	QStringList params;

	params <<"merge";

	if(integrate)
		params << "--integrate";

	if(force)
		params << "--force";

	if(testOnly)
		params << "--dry-run";

	params << revision;

	if(!runFossil(params, &res))
		return false;
	return true;
}

//------------------------------------------------------------------------------
static QString ParseFossilQuery(QString line)
{
	// Extract question
	int qend = line.lastIndexOf('(');
	if(qend == -1)

			break;
		}

		QByteArray input;
		process.getLogAndClear(input);

		#ifdef QT_DEBUG // Log fossil output in debug builds
		if(!input.isEmpty() && (runFlags & RUNFLAGS_DEBUG) )
			qDebug() << "[" << ++input_index << "] '" << input.data() << "'\n";
		#endif

		buffer += decoder->toUnicode(input);
#if 0 // Keep this for now to simulate bad parses
		if(runFlags & RUNFLAGS_DEBUG)
		{
			static int debug=1;
			if(debug==1)
			{
				buffer = "     4: [df2233aabe09ef] on 2013-02-03 02:51:33\n"
						 "     History\n"
						 "     5: [df2233aabe09ef] on 2013-02-15 03:55:37\n"
						 "     ";
				debug++;
			}
			else if(debug==2)
			{
				buffer = " Diff\n"
						 " ";
				debug++;
			}
			else
				buffer="";
		}
#endif
		#ifdef QT_DEBUG // breakpoint
		//if(buffer.indexOf("SQLITE_CANTOPEN")!=-1)
		//	qDebug() << "Breakpoint\n";
		#endif

		QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);

		if(buffer.isEmpty())
			continue;

		// Normalize line endings

		{
			last_line = buffer.mid(last_line_start+1); // Including the EOL

			// Detect previous line
			if(last_line_start>0)
			{
				int before_last_line_start = buffer.lastIndexOf(EOL_MARK, last_line_start-1);

				// No new-line before ?
				if(before_last_line_start==-1)
					before_last_line_start = 0; // Use entire line
				else
					++before_last_line_start; // Skip new-line

				// Extract previous line
				before_last_line = buffer.mid(before_last_line_start, last_line_start-before_last_line_start);
			}
		}
		else
			last_line = buffer;

		bool have_query = ends_qmark && (have_yn_query || have_yna_query || have_an_query || have_acyn_query);

		// Flush all complete lines to the log and output
		QStringList log_lines = buffer.left(last_line_start).split(EOL_MARK);
		for(int l=0; l<log_lines.length(); ++l)
		{
			// Skip last line if we have a query. This will be handled manually further down
			if(have_query && l==log_lines.length()-1)
				continue;

			QString line = log_lines[l].trimmed();

		#ifdef QT_DEBUG
			if(runFlags & RUNFLAGS_DEBUG)
			{
				qDebug() << "LINE: " << line << "\n";
			}
		#endif

			if(line.isEmpty())
				continue;

			if(output)
				output->append(line);

	fossilUI.setProcessChannelMode(QProcess::MergedChannels);
	fossilUI.setWorkingDirectory(getCurrentWorkspace());

	log("<b>&gt; fossil ui</b><br>", true);
	log(QObject::tr("Starting Fossil browser UI. Please wait.")+"\n");
	QString fossil = getFossilPath();

	QStringList params;
	params << "server" << "--localauth";

	if(!httpPort.isEmpty())
		params << "-P" << httpPort;

	fossilUI.start(getFossilPath(), params);

	if(!fossilUI.waitForStarted() || fossilUI.state()!=QProcess::Running)
	{
		log(QObject::tr("Could not start Fossil executable '%s'").arg(fossil)+"\n");
		return false;
	}

#ifdef Q_OS_WIN
	QTextCodec *codec = QTextCodec::codecForName("UTF-8");
#else
	QTextCodec *codec = QTextCodec::codecForLocale();
#endif

	Q_ASSERT(codec);
	QTextDecoder *decoder = codec->makeDecoder();
	Q_ASSERT(decoder);

	fossilUIPort.clear();

	// Wait for fossil to report the http port
	QString buffer;
	while(true)
	{
		QProcess::ProcessState state = fossilUI.state();
		qint64 bytes_avail = fossilUI.logBytesAvailable();

		if(state!=QProcess::Running && bytes_avail<1)
			break;

		QByteArray input;
		fossilUI.getLogAndClear(input);

		buffer += decoder->toUnicode(input);

		// Normalize line endings
		buffer = buffer.replace("\r\n", "\n");
		buffer = buffer.replace("\r", "\n");

		int index = REGEX_PORT.indexIn(buffer);
		if(index==-1)
		{
			QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
			continue;
		}

		// Extract port
		fossilUIPort = REGEX_PORT.cap(1).trimmed();

		// Done parsing
		break;
	}
	return true;
}

//------------------------------------------------------------------------------
void Fossil::stopUI()
{
	if(uiRunning())
	{
#ifdef Q_WS_WIN
		fossilUI.kill(); // QT on windows cannot terminate console processes with QProcess::terminate
#else
		fossilUI.terminate();
#endif
	}
	fossilUI.close();
	fossilUIPort.clear();
}

//------------------------------------------------------------------------------
QString Fossil::getUIHttpAddress() const
{
	if(fossilUIPort.isEmpty())
		return QString();
	return "http://127.0.0.1:"+fossilUIPort;
}

#ifndef FOSSIL_H
#define FOSSIL_H

class QStringList;
#include <QString>
#include <QStringList>
#include <QObject>
#include "LoggedProcess.h"
#include "Utils.h"

typedef QMap<QString, QString> stashmap_t;

#define PATH_SEPARATOR		"/"

enum RunFlags
{
	RUNFLAGS_NONE			= 0<<0,
	RUNFLAGS_SILENT_INPUT	= 1<<0,
	RUNFLAGS_SILENT_OUTPUT	= 1<<1,
	RUNFLAGS_SILENT_ALL		= RUNFLAGS_SILENT_INPUT | RUNFLAGS_SILENT_OUTPUT,
	RUNFLAGS_DETACHED		= 1<<2,
	RUNFLAGS_DEBUG			= 1<<3,
};

enum RepoStatus
{
	REPO_OK,
	REPO_NOT_FOUND,
	REPO_OLD_SCHEMA

	bool openRepository(const QString &repositoryPath, const QString& workspacePath);
	bool newRepository(const QString &repositoryPath);
	bool closeRepository();
	bool pushRepository();
	bool pullRepository();
	bool cloneRepository(const QString &repository, const QUrl &url, const QUrl &proxyUrl);
	bool undoRepository(QStringList& result, bool explainOnly);
	bool updateRepository(QStringList& result, const QString& revision, bool explainOnly);
	bool getFossilVersion(QString &version);

	bool uiRunning() const;
	bool startUI(const QString &httpPort);
	void stopUI();

	bool listFiles(QStringList &files);
	bool status(QStringList& result);

	bool diffFile(const QString &repoFile);
	bool commitFiles(const QStringList &fileList, const QString &comment, const QString& newBranchName, bool isPrivateBranch);
	bool addFiles(const QStringList& fileList);
	bool removeFiles(const QStringList& fileList, bool deleteLocal);
	bool revertFiles(const QStringList& fileList);
	bool renameFile(const QString& beforePath, const QString& afterPath, bool renameLocal);
	bool getFossilSettings(QStringList& result);
	bool setFossilSetting(const QString &name, const QString &value, bool global);
	bool setRemoteUrl(const QString &url);
	bool getRemoteUrl(QString &url);

	bool stashNew(const QStringList& fileList, const QString& name, bool revert);
	bool stashList(stashmap_t &stashes);
	bool stashApply(const QString& name);
	bool stashDrop(const QString& name);
	bool stashDiff(const QString& name);

	void abortOperation() { operationAborted = true; }

	bool tagList(QStringMap& tags);
	bool tagNew(const QString& name, const QString& revision);
	bool tagDelete(const QString& name, const QString& revision);

	bool branchList(QStringList& branches, QStringList& activeBranches);
	bool branchNew(const QString& name, const QString& revisionBasis, bool isPrivate=false);
	bool branchMerge(QStringList& res, const QString& revision, bool integrate, bool force, bool testOnly);

	const QString &getCurrentRevision() const { return currentRevision; }
	const QStringList &getCurrentTags() const { return currentTags; }

	const QString &getUIHttpPort() const { return fossilUIPort; }
	QString getUIHttpAddress() const;

private:
	void log(const QString &text, bool isHTML=false)
	{
		if(uiCallback)
			uiCallback->logText(text, isHTML);
	}

	QString	getFossilPath();

	bool				operationAborted;
	UICallback			*uiCallback;
	QString				currentWorkspace;
	QString				fossilPath;		// The value from the settings
	QString				repositoryFile;
	QString				projectName;
	QString				currentRevision;
	QStringList			currentTags;
	LoggedProcess		fossilUI;
	QString				fossilUIPort;
};


#endif // FOSSIL_H

#include "FslSettingsDialog.h"
#include "ui_FslSettingsDialog.h"
#include "Utils.h"

#include <QDir>

///////////////////////////////////////////////////////////////////////////////
FslSettingsDialog::FslSettingsDialog(QWidget *parent, Settings &_settings) :
	QDialog(parent, Qt::Sheet),
	ui(new Ui::FslSettingsDialog),
	settings(&_settings)
{
	ui->setupUi(this);

	ui->lineUIPort->setText(settings->GetValue(FOSSIL_SETTING_HTTP_PORT).toString());

	// Global Settings
	ui->lineGDiffCommand->setText(settings->GetFossilValue(FOSSIL_SETTING_GDIFF_CMD).toString());
	ui->lineGMergeCommand->setText(settings->GetFossilValue(FOSSIL_SETTING_GMERGE_CMD).toString());
	ui->lineProxy->setText(settings->GetFossilValue(FOSSIL_SETTING_PROXY_URL).toString());

	// Repository Settings
	ui->lineRemoteURL->setText(settings->GetFossilValue(FOSSIL_SETTING_REMOTE_URL).toString());
	ui->lineIgnore->setText(settings->GetFossilValue(FOSSIL_SETTING_IGNORE_GLOB).toString());
	ui->lineIgnoreCRNL->setText(settings->GetFossilValue(FOSSIL_SETTING_CRNL_GLOB).toString());
}

//-----------------------------------------------------------------------------
FslSettingsDialog::~FslSettingsDialog()
{
	delete ui;
}

//-----------------------------------------------------------------------------
bool FslSettingsDialog::run(QWidget *parent, Settings &settings)
{
	FslSettingsDialog dlg(parent, settings);
	return dlg.exec() == QDialog::Accepted;
}

//-----------------------------------------------------------------------------
void FslSettingsDialog::on_buttonBox_accepted()
{
	settings->SetValue(FOSSIL_SETTING_HTTP_PORT, ui->lineUIPort->text());

	settings->SetFossilValue(FOSSIL_SETTING_GDIFF_CMD, ui->lineGDiffCommand->text());
	settings->SetFossilValue(FOSSIL_SETTING_GMERGE_CMD, ui->lineGMergeCommand->text());
	settings->SetFossilValue(FOSSIL_SETTING_PROXY_URL, ui->lineProxy->text());

	settings->SetFossilValue(FOSSIL_SETTING_REMOTE_URL, ui->lineRemoteURL->text());
	settings->SetFossilValue(FOSSIL_SETTING_IGNORE_GLOB, ui->lineIgnore->text());
	settings->SetFossilValue(FOSSIL_SETTING_CRNL_GLOB, ui->lineIgnoreCRNL->text());

	settings->ApplyEnvironment();
}

//-----------------------------------------------------------------------------
void FslSettingsDialog::on_btnSelectFossilGDiff_clicked()
{
	QString path = SelectExe(this, tr("Select Graphical Diff application"));
	if(!path.isEmpty())
		ui->lineGDiffCommand->setText(QDir::toNativeSeparators(path));
}

//-----------------------------------------------------------------------------
void FslSettingsDialog::on_btnSelectGMerge_clicked()
{
	QString path = SelectExe(this, tr("Select Graphical Merge application"));
	if(!path.isEmpty())
		ui->lineGMergeCommand->setText(path);
}

#ifndef FSLSETTINGSDIALOG_H
#define FSLSETTINGSDIALOG_H

#include <QDialog>
#include "Settings.h"

namespace Ui {
	class FslSettingsDialog;
}

class FslSettingsDialog : public QDialog
{
	Q_OBJECT

public:
	explicit FslSettingsDialog(QWidget *parent, Settings &_settings);
	~FslSettingsDialog();

	static bool run(QWidget *parent, Settings &_settings);


private slots:
	void on_buttonBox_accepted();
	void on_btnSelectFossilGDiff_clicked();
	void on_btnSelectGMerge_clicked();

private:

	Ui::FslSettingsDialog *ui;
	Settings *settings;
};

#endif // FSLSETTINGSDIALOG_H

#include "MainWindow.h"
#include "ui_MainWindow.h"
#include <QDateTime>
#include <QDebug>
#include <QDesktopServices>
#include <QDrag>
#include <QDragEnterEvent>
#include <QFileDialog>

#include <QInputDialog>
#include <QMimeData>
#include <QProgressBar>
#include <QLabel>
#include <QSettings>
#include <QShortcut>
#include "SettingsDialog.h"
#include "FslSettingsDialog.h"
#include "SearchBox.h"
#include "CommitDialog.h"
#include "FileActionDialog.h"
#include "CloneDialog.h"
#include "RevisionDialog.h"
#include "Utils.h"

#define REVISION_LATEST "Latest revision"

//-----------------------------------------------------------------------------
enum
{
	COLUMN_STATUS,
	COLUMN_FILENAME,
	COLUMN_EXTENSION,
	COLUMN_MODIFIED,
	COLUMN_PATH
};

enum
{
	TAB_LOG,
	TAB_BROWSER
};

enum
{
	ROLE_WORKSPACE_ITEM = Qt::UserRole+1
};

struct WorkspaceItem
{
	enum
	{
		TYPE_UNKNOWN,
		TYPE_WORKSPACE,
		TYPE_FOLDER,
		TYPE_STASHES,
		TYPE_STASH,
		TYPE_BRANCHES,
		TYPE_BRANCH,
		TYPE_TAGS,
		TYPE_TAG,
		TYPE_REMOTES,
		TYPE_SETTINGS
	};

	WorkspaceItem()
	: Type(TYPE_UNKNOWN)
	{
	}

	WorkspaceItem(int type, const QString &value)
	: Type(type), Value(value)
	{
	}

	WorkspaceItem(const WorkspaceItem &other)
	{
		Type = other.Type;
		Value = other.Value;
	}

	int Type;
	QString Value;

	operator QVariant() const
	{
		return QVariant::fromValue(*this);
	}
};
Q_DECLARE_METATYPE(WorkspaceItem)



























///////////////////////////////////////////////////////////////////////////////
MainWindow::MainWindow(Settings &_settings, QWidget *parent, QString *workspacePath) :
	QMainWindow(parent),
	ui(new Ui::MainWindow),
	settings(_settings)
{

	ui->fileTableView->horizontalHeader()->setMovable(true);
#else
	ui->fileTableView->horizontalHeader()->setSectionsMovable(true);
#endif
	ui->fileTableView->horizontalHeader()->setStretchLastSection(true);

	// workspaceTreeView
	ui->workspaceTreeView->setModel(&getWorkspace().getTreeModel());

	header.clear();
	header << tr("Workspace");
	getWorkspace().getTreeModel().setHorizontalHeaderLabels(header);

	connect( ui->workspaceTreeView->selectionModel(),
		SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection &) ),
		SLOT( onWorkspaceTreeViewSelectionChanged(const QItemSelection &, const QItemSelection &) ),
		Qt::DirectConnection );

	// Workspace Menus
	menuWorkspace = new QMenu(this);
	menuWorkspace->addAction(ui->actionCommit);
	menuWorkspace->addAction(ui->actionOpenFolder);
	menuWorkspace->addAction(ui->actionAdd);
	menuWorkspace->addAction(ui->actionRevert);
	menuWorkspace->addAction(ui->actionDelete);
	menuWorkspace->addAction(separator);
	menuWorkspace->addAction(ui->actionRenameFolder);
	menuWorkspace->addAction(ui->actionOpenFolder);

	// StashMenu
	menuStashes = new QMenu(this);
	menuStashes->addAction(ui->actionCreateStash);
	menuStashes->addAction(separator);
	menuStashes->addAction(ui->actionApplyStash);
	menuStashes->addAction(ui->actionDiffStash);
	menuStashes->addAction(ui->actionDeleteStash);

	// TagsMenu
	menuTags = new QMenu(this);
	menuTags->addAction(ui->actionCreateTag);
	menuTags->addAction(separator);
	menuTags->addAction(ui->actionDeleteTag);
	menuTags->addAction(ui->actionUpdate);

	// BranchesMenu
	menuBranches = new QMenu(this);
	menuBranches->addAction(ui->actionCreateBranch);
	menuBranches->addAction(separator);
	menuBranches->addAction(ui->actionMergeBranch);
	menuBranches->addAction(ui->actionUpdate);

	// Recent Workspaces
	// Locate a sequence of two separator actions in file menu
	QList<QAction*> file_actions = ui->menuFile->actions();
	QAction *recent_sep=0;
	for(int i=0; i<file_actions.size(); ++i)
	{

		recentWorkspaceActs[i]->setVisible(false);
		connect(recentWorkspaceActs[i], SIGNAL(triggered()), this, SLOT(onOpenRecent()));
		ui->menuFile->insertAction(recent_sep, recentWorkspaceActs[i]);
	}

	// TabWidget
	ui->tabWidget->setCurrentIndex(TAB_LOG);

	lblRevision = new QLabel();
	ui->statusBar->insertPermanentWidget(0, lblRevision);
	lblRevision->setVisible(true);

	lblTags = new QLabel();
	ui->statusBar->insertPermanentWidget(1, lblTags);
	lblTags->setVisible(true);


	// Construct ProgressBar
	progressBar = new QProgressBar();
	progressBar->setMinimum(0);
	progressBar->setMaximum(0);
	progressBar->setMaximumSize(170, 16);
	progressBar->setAlignment(Qt::AlignCenter);
	progressBar->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
	ui->statusBar->insertPermanentWidget(2, progressBar);
	progressBar->setVisible(false);


#ifdef Q_OS_MACX
	// Native applications on OSX don't have menu icons
	foreach(QAction *a, ui->menuBar->actions())
		a->setIconVisibleInMenu(false);
	foreach(QAction *a, ui->menuFile->actions())
		a->setIconVisibleInMenu(false);
#endif

	abortShortcut = new QShortcut(QKeySequence("Escape"), this);
	abortShortcut->setContext(Qt::ApplicationShortcut);
	abortShortcut->setEnabled(false);
	connect(abortShortcut, SIGNAL(activated()), this, SLOT(onAbort()));

	// Searchbox
	// Add spacer to pad to right
	QWidget* spacer = new QWidget();
	spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
	ui->mainToolBar->addWidget(spacer);

	// Search shortcut
	searchShortcut = new QShortcut(QKeySequence(QKeySequence::Find), this);
	searchShortcut->setContext(Qt::ApplicationShortcut);
	searchShortcut->setEnabled(true);
	connect(searchShortcut, SIGNAL(activated()), this, SLOT(onSearch()));


	// Create SearchBox
	searchBox = new SearchBox(this);
	searchBox->setPlaceholderText(tr("Find (%0)").arg(searchShortcut->key().toString()));
	searchBox->setMaximumWidth(450);
	ui->mainToolBar->addWidget(searchBox);

	connect( searchBox,
		SIGNAL( textChanged(const QString&)),
		SLOT( onSearchBoxTextChanged(const QString&)),
		Qt::DirectConnection );

	viewMode = VIEWMODE_TREE;

	uiCallback.init(this);
	// Need to be before applySettings which sets the last workspace
	fossil().Init(&uiCallback);

	applySettings();

		workspaceHistory.removeAll(path);
		rebuildRecent();
		return false;
	}

	// Select the Root of the tree to update the file view
	selectRootDir();
	searchBox->clear();
	return true;
}

//------------------------------------------------------------------------------
void MainWindow::on_actionOpenRepository_triggered()
{
	QString filter(tr("Fossil Files") + QString(" (*." FOSSIL_EXT  " " FOSSIL_CHECKOUT1 " " FOSSIL_CHECKOUT2 ")" ));

	openWorkspace(workspace);
}


//------------------------------------------------------------------------------
void MainWindow::enableActions(bool on)
{
	QAction *actions[] = {
		ui->actionCommit,
		ui->actionDiff,
		ui->actionAdd,
		ui->actionDelete,
		ui->actionPush,
		ui->actionPull,
		ui->actionRename,
		ui->actionHistory,
		ui->actionFossilUI,
		ui->actionRevert,
		ui->actionTimeline,
		ui->actionOpenFile,
		ui->actionOpenContaining,
		ui->actionUndo,
		ui->actionUpdate,
		ui->actionOpenFolder,
		ui->actionRenameFolder,
		ui->actionCreateStash,
		ui->actionDeleteStash,
		ui->actionDiffStash,
		ui->actionApplyStash,
		ui->actionDeleteStash,
		ui->actionCreateTag,
		ui->actionDeleteTag,
		ui->actionCreateBranch,
		ui->actionMergeBranch,
	};

	for(size_t i=0; i<COUNTOF(actions); ++i)
		actions[i]->setEnabled(on);

}
//------------------------------------------------------------------------------
bool MainWindow::refresh()
{
	QString title = "Fuel";

	// Load repository info
	RepoStatus st = fossil().getRepoStatus();

	if(st==REPO_NOT_FOUND)
	{
		setStatus(tr("No workspace detected."));
		enableActions(false);
		getWorkspace().getFileModel().removeRows(0, getWorkspace().getFileModel().rowCount());
		getWorkspace().getTreeModel().removeRows(0, getWorkspace().getFileModel().rowCount());
		setWindowTitle(title);
		return false;
	}
	else if(st==REPO_OLD_SCHEMA)
	{
		setStatus(tr("Old repository schema detected. Consider running 'fossil rebuild'"));
		enableActions(false);
		getWorkspace().getFileModel().removeRows(0, getWorkspace().getFileModel().rowCount());
		getWorkspace().getTreeModel().removeRows(0, getWorkspace().getFileModel().rowCount());
		setWindowTitle(title);
		return true;
	}

	loadFossilSettings();
	scanWorkspace();
	setStatus("");

							ui->actionViewIgnored->isChecked(),
							ui->actionViewModified->isChecked(),
							ui->actionViewUnchanged->isChecked(),
							settings.GetFossilValue(FOSSIL_SETTING_IGNORE_GLOB).toString(),
							uiCallback,
							operationAborted
							);
	updateWorkspaceView();
	updateFileView();

	// Build default versions list
	versionList.clear();
	versionList += getWorkspace().getBranches();
	versionList += getWorkspace().getTags().keys();

	selectedTags.clear();
	selectedBranches.clear();

	setBusy(false);
	setStatus("");
	lblRevision->setText(tr("Revision: %0").arg(fossil().getCurrentRevision()));
	lblRevision->setVisible(true);

	lblTags->setText(tr("Tags: %0").arg(fossil().getCurrentTags().join(' ')));
	lblTags->setVisible(true);
}

//------------------------------------------------------------------------------
static void addPathToTree(QStandardItem &root, const QString &path, const QIcon &folderIcon)
{
	QStringList dirs = path.split('/');
	QStandardItem *parent = &root;

	QString fullpath;
	for(QStringList::iterator it = dirs.begin(); it!=dirs.end(); ++it)
	{

				parent = child;
				found = true;
			}
		}

		if(!found) // Generate it
		{
			QStandardItem *child = new QStandardItem(folderIcon, dir);
			child->setData(WorkspaceItem(WorkspaceItem::TYPE_FOLDER, fullpath), ROLE_WORKSPACE_ITEM);
			parent->appendRow(child);
			parent = child;
		}
		fullpath += '/';
	}
}

//------------------------------------------------------------------------------
void MainWindow::updateWorkspaceView()
{
	// Record expanded tree-node names, and selection
	name_modelindex_map_t name_map;
	BuildNameToModelIndex(name_map, getWorkspace().getTreeModel());
	stringset_t expanded_items;
	stringset_t selected_items;

	const QItemSelection selection = ui->workspaceTreeView->selectionModel()->selection();

	for(name_modelindex_map_t::const_iterator it=name_map.begin(); it!=name_map.end(); ++it)
	{
		const QModelIndex mi = it.value();
		if(ui->workspaceTreeView->isExpanded(mi))
			expanded_items.insert(it.key());

		if(selection.contains(mi))
			selected_items.insert(it.key());
	}

	// Clear content except headers
	getWorkspace().getTreeModel().removeRows(0, getWorkspace().getTreeModel().rowCount());

	QStandardItem *workspace = new QStandardItem(getInternalIcon(":icons/icon-item-folder"), tr("Files") );
	workspace->setData(WorkspaceItem(WorkspaceItem::TYPE_WORKSPACE, ""), ROLE_WORKSPACE_ITEM);
	workspace->setEditable(false);

	getWorkspace().getTreeModel().appendRow(workspace);
	if(viewMode == VIEWMODE_TREE)
	{
		for(stringset_t::iterator it = getWorkspace().getPaths().begin(); it!=getWorkspace().getPaths().end(); ++it)
		{
			const QString &dir = *it;
			if(dir.isEmpty())
				continue;

			addPathToTree(*workspace, dir, getInternalIcon(":icons/icon-item-folder"));
		}

		// Expand root folder
		ui->workspaceTreeView->setExpanded(workspace->index(), true);
	}

	// Branches
	QStandardItem *branches = new QStandardItem(getInternalIcon(":icons/icon-item-branch"), tr("Branches"));
	branches->setData(WorkspaceItem(WorkspaceItem::TYPE_BRANCHES, ""), ROLE_WORKSPACE_ITEM);
	branches->setEditable(false);
	getWorkspace().getTreeModel().appendRow(branches);
	foreach(const QString &branch_name, getWorkspace().getBranches())
	{
		QStandardItem *branch = new QStandardItem(getInternalIcon(":icons/icon-item-branch"), branch_name);
		branch->setData(WorkspaceItem(WorkspaceItem::TYPE_BRANCH, branch_name), ROLE_WORKSPACE_ITEM);

		bool active = fossil().getCurrentTags().contains(branch_name);
		if(active)
		{
			QFont font = branch->font();
			font.setBold(true);
			branch->setFont(font);
		}
		branches->appendRow(branch);
	}

	// Tags
	QStandardItem *tags = new QStandardItem(getInternalIcon(":icons/icon-item-tag"), tr("Tags"));
	tags->setData(WorkspaceItem(WorkspaceItem::TYPE_TAGS, ""), ROLE_WORKSPACE_ITEM);
	tags->setEditable(false);
	getWorkspace().getTreeModel().appendRow(tags);
	for(QStringMap::const_iterator it=getWorkspace().getTags().begin(); it!=getWorkspace().getTags().end(); ++it)
	{
		const QString &tag_name = it.key();


		QStandardItem *tag = new QStandardItem(getInternalIcon(":icons/icon-item-tag"), tag_name);
		tag->setData(WorkspaceItem(WorkspaceItem::TYPE_TAG, tag_name), ROLE_WORKSPACE_ITEM);

		bool active = fossil().getCurrentTags().contains(tag_name);
		if(active)
		{
			QFont font = tag->font();
			font.setBold(true);
			tag->setFont(font);
		}
		tags->appendRow(tag);
	}

	// FIXME: Unique Icon name
	// Stashes
	QStandardItem *stashes = new QStandardItem(getInternalIcon(":icons/icon-action-repo-open"), tr("Stashes"));
	stashes->setData(WorkspaceItem(WorkspaceItem::TYPE_STASHES, ""), ROLE_WORKSPACE_ITEM);
	stashes->setEditable(false);
	getWorkspace().getTreeModel().appendRow(stashes);
	for(stashmap_t::const_iterator it= getWorkspace().getStashes().begin(); it!=getWorkspace().getStashes().end(); ++it)
	{
		QStandardItem *stash = new QStandardItem(getInternalIcon(":icons/icon-action-repo-open"), it.key());
		stash->setData(WorkspaceItem(WorkspaceItem::TYPE_STASH, it.value()), ROLE_WORKSPACE_ITEM);
		stashes->appendRow(stash);
	}

#if 0
	// Remotes
	QStandardItem *remotes = new QStandardItem(getInternalIcon(":icons/icon-item-remote"), tr("Remotes"));
	remotes->setData(WorkspaceItem(WorkspaceItem::TYPE_REMOTES, ""), ROLE_WORKSPACE_ITEM);
	remotes->setEditable(false);
	getWorkspace().getTreeModel().appendRow(remotes);
#endif

#if 0 // Unimplemented for now
	// Settings
	QStandardItem *settings = new QStandardItem(getInternalIcon(":icons/icon-action-settings"), tr("Settings"));
	settings->setData(WorkspaceItem(WorkspaceItem::TYPE_SETTINGS, ""), ROLE_WORKSPACE_ITEM);
	settings->setEditable(false);
	getWorkspace().getTreeModel().appendRow(settings);
#endif

	// Expand previously selected nodes
	name_map.clear();
	BuildNameToModelIndex(name_map, getWorkspace().getTreeModel());

	for(stringset_t::const_iterator it=expanded_items.begin(); it!=expanded_items.end(); ++it)
	{
		name_modelindex_map_t::const_iterator mi_it = name_map.find(*it);
		if(mi_it!=name_map.end())
			ui->workspaceTreeView->setExpanded(mi_it.value(), true);
	}

	// Select previous selected item
	for(stringset_t::const_iterator it=selected_items.begin(); it!=selected_items.end(); ++it)
	{
		name_modelindex_map_t::const_iterator mi_it = name_map.find(*it);
		if(mi_it!=name_map.end())
		{
			const QModelIndex &mi = mi_it.value();
			ui->workspaceTreeView->selectionModel()->select(mi, QItemSelectionModel::Select);
		}
	}
}

//------------------------------------------------------------------------------
void MainWindow::updateFileView()
{
	// Clear content except headers
	getWorkspace().getFileModel().removeRows(0, getWorkspace().getFileModel().rowCount());

	struct { WorkspaceFile::Type type; QString text; const char *icon; }
	stats[] =
	{
		{   WorkspaceFile::TYPE_EDITTED, tr("Edited"), ":icons/icon-item-edited" },
		{   WorkspaceFile::TYPE_UNCHANGED, tr("Unchanged"), ":icons/icon-item-unchanged" },
		{   WorkspaceFile::TYPE_ADDED, tr("Added"), ":icons/icon-item-added" },
		{   WorkspaceFile::TYPE_DELETED, tr("Deleted"), ":icons/icon-item-deleted" },
		{   WorkspaceFile::TYPE_RENAMED, tr("Renamed"), ":icons/icon-item-renamed" },
		{   WorkspaceFile::TYPE_MISSING, tr("Missing"), ":icons/icon-item-missing" },
		{   WorkspaceFile::TYPE_CONFLICTED, tr("Conflicted"), ":icons/icon-item-conflicted" },
		{   WorkspaceFile::TYPE_MERGED, tr("Merged"), ":icons/icon-item-edited" },
	};



	bool display_path = viewMode==VIEWMODE_LIST || selectedDirs.count() > 1;

	const QString &status_unknown = QString(tr("Unknown"));
	const QString &search_text = searchBox->text();

	size_t item_id=0;
	for(Workspace::filemap_t::iterator it = getWorkspace().getFiles().begin(); it!=getWorkspace().getFiles().end(); ++it)
	{
		const WorkspaceFile &e = *it.value();
		const QString &path = e.getPath();
		const QString &file_path = e.getFilePath();
		QString native_file_path = QDir::toNativeSeparators(file_path);

		// Apply filter if available
		if(!search_text.isEmpty() && !native_file_path.contains(search_text, Qt::CaseInsensitive))
			continue;

		// In Tree mode, filter all items not included in the current dir
		if(viewMode==VIEWMODE_TREE && !selectedDirs.contains(path))
			continue;

		// Status Column
		const QString *status_text = &status_unknown;
		const char *status_icon_path= ":icons/icon-item-unknown"; // Default icon

		for(size_t t=0; t<COUNTOF(stats); ++t)
		{
			if(e.getType() == stats[t].type)
			{
				status_text = &stats[t].text;
				status_icon_path = stats[t].icon;
				break;
			}
		}

		QStandardItem *status = new QStandardItem(getInternalIcon(status_icon_path), *status_text);
		status->setToolTip(*status_text);
		getWorkspace().getFileModel().setItem(item_id, COLUMN_STATUS, status);

		QFileInfo finfo = e.getFileInfo();
		QString icon_type = iconProvider.type(finfo);

		if(!iconCache.contains(icon_type))
			iconCache.insert(icon_type, iconProvider.icon(finfo));

		const QIcon *icon = &iconCache[icon_type];

		QStandardItem *filename_item = 0;
		getWorkspace().getFileModel().setItem(item_id, COLUMN_PATH, new QStandardItem(path));

		if(display_path)
			filename_item = new QStandardItem(*icon, native_file_path);
		else
			filename_item = new QStandardItem(*icon, e.getFilename());

		Q_ASSERT(filename_item);
		// Keep the path in the user data
		filename_item->setData(file_path);
		getWorkspace().getFileModel().setItem(item_id, COLUMN_FILENAME, filename_item);

		getWorkspace().getFileModel().setItem(item_id, COLUMN_EXTENSION, new QStandardItem(finfo.suffix()));
		getWorkspace().getFileModel().setItem(item_id, COLUMN_MODIFIED, new QStandardItem(finfo.lastModified().toString(Qt::SystemLocaleShortDate)));

		++item_id;
	}

	ui->fileTableView->resizeRowsToContents();
}




















//------------------------------------------------------------------------------
void MainWindow::log(const QString &text, bool isHTML)
{
	QTextCursor c = ui->textBrowser->textCursor();
	c.movePosition(QTextCursor::End);
	ui->textBrowser->setTextCursor(c);

	if(store->contains("ViewUnchanged"))
		ui->actionViewUnchanged->setChecked(store->value("ViewUnchanged").toBool());
	if(store->contains("ViewIgnored"))
		ui->actionViewIgnored->setChecked(store->value("ViewIgnored").toBool());
	if(store->contains("ViewAsList"))
	{
		ui->actionViewAsList->setChecked(store->value("ViewAsList").toBool());
		ui->actionViewAsFolders->setChecked(!store->value("ViewAsList").toBool());
		viewMode = store->value("ViewAsList").toBool()? VIEWMODE_LIST : VIEWMODE_TREE;
	}
	//ui->workspaceTreeView->setVisible(viewMode == VIEWMODE_TREE);





}

//------------------------------------------------------------------------------
void MainWindow::updateSettings()
{
	QSettings *store = settings.GetStore();

	store->setValue("WindowWidth", width());
	store->setValue("WindowHeight", height());
	store->setValue("ViewUnknown", ui->actionViewUnknown->isChecked());
	store->setValue("ViewModified", ui->actionViewModified->isChecked());
	store->setValue("ViewUnchanged", ui->actionViewUnchanged->isChecked());
	store->setValue("ViewIgnored", ui->actionViewIgnored->isChecked());
	store->setValue("ViewAsList", ui->actionViewAsList->isChecked());

}

//------------------------------------------------------------------------------
void MainWindow::selectRootDir()
{
	// FIXME: KKK
	if(viewMode==VIEWMODE_TREE)
	{
		QModelIndex root_index = ui->workspaceTreeView->model()->index(0, 0);
		ui->workspaceTreeView->selectionModel()->select(root_index, QItemSelectionModel::Select);
	}
}

//------------------------------------------------------------------------------
void MainWindow::fossilBrowse(const QString &fossilUrl)
{
	if(!uiRunning())
		ui->actionFossilUI->activate(QAction::Trigger);

	bool use_internal = settings.GetValue(FUEL_SETTING_WEB_BROWSER).toInt() == 1;

	QUrl url = QUrl(fossil().getUIHttpAddress()+fossilUrl);

	if(use_internal)
	{
		ui->webView->load(url);
		ui->tabWidget->setCurrentIndex(TAB_BROWSER);
	}
	else

}

//------------------------------------------------------------------------------
void MainWindow::getSelectionPaths(stringset_t &paths)
{
	// Determine the directories selected
	QModelIndexList selection = ui->workspaceTreeView->selectionModel()->selectedIndexes();
	foreach(const QModelIndex &mi, selection)
	{
		QVariant data = mi.model()->data(mi, ROLE_WORKSPACE_ITEM);
		Q_ASSERT(data.isValid());

		WorkspaceItem tv = data.value<WorkspaceItem>();
		if(tv.Type != WorkspaceItem::TYPE_FOLDER)
			continue;

		paths.insert(tv.Value);
	}
}
//------------------------------------------------------------------------------
// Select all workspace files that match the includeMask
void MainWindow::getAllFilenames(QStringList &filenames, int includeMask)
{
	for(Workspace::filemap_t::iterator it=getWorkspace().getFiles().begin(); it!=getWorkspace().getFiles().end(); ++it)

		if(!(includeMask & e.getType()))
			continue;

		filenames.append(filename);
	}
}
//------------------------------------------------------------------------------
void MainWindow::getSelectionStashes(QStringList &stashNames)
{
	QModelIndexList selection = ui->workspaceTreeView->selectionModel()->selectedIndexes();



	foreach(const QModelIndex &mi, selection)


	{

		QVariant data = mi.model()->data(mi, ROLE_WORKSPACE_ITEM);
		Q_ASSERT(data.isValid());
		WorkspaceItem tv = data.value<WorkspaceItem>();


		if(tv.Type != WorkspaceItem::TYPE_STASH)

			continue;

		QString name = mi.model()->data(mi, Qt::DisplayRole).toString();
		stashNames.append(name);
	}

}

//------------------------------------------------------------------------------
bool MainWindow::diffFile(const QString &repoFile)
{
	return fossil().diffFile(repoFile);
}

		if(!diffFile(*it))
			return;
}

//------------------------------------------------------------------------------
bool MainWindow::startUI()
{

	bool started = fossil().startUI("");
	ui->actionFossilUI->setChecked(started);
	return started;
}
//------------------------------------------------------------------------------
void MainWindow::stopUI()
{
	fossil().stopUI();

//------------------------------------------------------------------------------
void MainWindow::on_actionCommit_triggered()
{
	QStringList commit_files;
	getSelectionFilenames(commit_files, WorkspaceFile::TYPE_MODIFIED, true);

	if(commit_files.empty() && !getWorkspace().otherChanges())
		return;

	QStringList commit_msgs = settings.GetValue(FUEL_SETTING_COMMIT_MSG).toStringList();

	QString msg;
	QString branch_name="";
	bool private_branch = false;
	bool aborted = !CommitDialog::runCommit(this, commit_files, msg, commit_msgs, branch_name, private_branch);

	// Aborted or not we always keep the commit messages.
	// (This has saved me way too many times on TortoiseSVN)
	if(commit_msgs.indexOf(msg)==-1)
	{
		commit_msgs.push_front(msg);
		settings.SetValue(FUEL_SETTING_COMMIT_MSG, commit_msgs);
	}

	if(aborted)
		return;

	// Since via the commit dialog the user can deselect all files
	if(commit_files.empty() && !getWorkspace().otherChanges())
		return;

	// Do commit
	QStringList files;

	// When a subset of files has been selected, explicitely specify each file.
	// Otherwise all files will be implicitly committed by fossil. This is necessary
	// when committing after a merge where fossil thinks that we are trying to do
	// 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;

	fossil().commitFiles(files, msg, branch_name, private_branch);
	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionAdd_triggered()
{
	// Get unknown files only

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionRevert_triggered()
{
	QStringList modified_files;
	getSelectionFilenames(modified_files, WorkspaceFile::TYPE_MODIFIED);

	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;

							"emansije: pt_PT\n"
					   );
}

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




	QString revision;

	if(!selected.isEmpty())


		revision = selected.first();



	updateRevision(revision);



}

//------------------------------------------------------------------------------
void MainWindow::loadFossilSettings()
{
	// Also retrieve the fossil global settings
	QStringList out;

	if(!fossil().getFossilSettings(out))
		return;

	QStringMap kv;
	ParseProperties(kv, out);

	for(Settings::mappings_t::iterator it=settings.GetMappings().begin(); it!=settings.GetMappings().end(); ++it)
	{
		const QString &name = it.key();
		Settings::Setting::SettingType type = it->Type;

		// Command types we issue directly on fossil

		}
	}
}

//------------------------------------------------------------------------------
void MainWindow::on_actionSettings_triggered()
{
	// Run the dialog
	if(!SettingsDialog::run(this, settings))
		return;
}

//------------------------------------------------------------------------------
void MainWindow::on_actionFossilSettings_triggered()
{
	loadFossilSettings();

	// Run the dialog
	if(!FslSettingsDialog::run(this, settings))
		return;

	// Apply settings
	for(Settings::mappings_t::iterator it=settings.GetMappings().begin(); it!=settings.GetMappings().end(); ++it)
	{
		const QString &name = it.key();
		Settings::Setting::SettingType type = it.value().Type;

		}

		Q_ASSERT(type == Settings::Setting::TYPE_FOSSIL_GLOBAL || type == Settings::Setting::TYPE_FOSSIL_LOCAL);

		QString value = it.value().Value.toString();
		fossil().setFossilSetting(name, value, type == Settings::Setting::TYPE_FOSSIL_GLOBAL);
	}

}

//------------------------------------------------------------------------------
void MainWindow::on_actionViewModified_triggered()
{
	refresh();
}

}

//------------------------------------------------------------------------------
void MainWindow::on_actionViewIgnored_triggered()
{
	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionViewAll_triggered()
{
	ui->actionViewModified->setChecked(true);
	ui->actionViewUnchanged->setChecked(true);
	ui->actionViewUnknown->setChecked(true);
	ui->actionViewIgnored->setChecked(true);
	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionViewAsList_triggered()
{
	ui->actionViewAsFolders->setChecked(!ui->actionViewAsList->isChecked());
	viewMode = ui->actionViewAsList->isChecked() ? VIEWMODE_LIST : VIEWMODE_TREE;

	updateWorkspaceView();
	updateFileView();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionViewAsFolders_triggered()
{
	ui->actionViewAsList->setChecked(!ui->actionViewAsFolders->isChecked());
	viewMode = ui->actionViewAsList->isChecked() ? VIEWMODE_LIST : VIEWMODE_TREE;
	updateWorkspaceView();
	updateFileView();
}

//------------------------------------------------------------------------------
void MainWindow::onWorkspaceTreeViewSelectionChanged(const QItemSelection &/*selected*/, const QItemSelection &/*deselected*/)
{
	QModelIndexList indices = ui->workspaceTreeView->selectionModel()->selectedIndexes();


	// Do not modify the selection if nothing is selected
	if(indices.empty())
		return;

	stringset_t new_dirs;
	selectedTags.clear();
	selectedBranches.clear();


	foreach(const QModelIndex &id, indices)
	{
		QVariant data = id.model()->data(id, ROLE_WORKSPACE_ITEM);
		Q_ASSERT(data.isValid());
		WorkspaceItem tv = data.value<WorkspaceItem>();

		if(tv.Type == WorkspaceItem::TYPE_FOLDER || tv.Type == WorkspaceItem::TYPE_WORKSPACE)
			new_dirs.insert(tv.Value);
		else if(tv.Type == WorkspaceItem::TYPE_TAG)
			selectedTags.append(tv.Value);
		else if(tv.Type == WorkspaceItem::TYPE_BRANCH)
			selectedBranches.append(tv.Value);
	}

	// Update the selection if we have any new folders
	if(!new_dirs.empty() && viewMode == VIEWMODE_TREE)
	{
		selectedDirs = new_dirs;
		updateFileView();
	}
}

//------------------------------------------------------------------------------
void MainWindow::on_actionOpenFolder_triggered()
{
	const QItemSelection &selection =  ui->workspaceTreeView->selectionModel()->selection();

	if(selection.indexes().count()!=1)
		return;

	QModelIndex index = selection.indexes().at(0);
	on_workspaceTreeView_doubleClicked(index);
}

//------------------------------------------------------------------------------
void MainWindow::on_workspaceTreeView_doubleClicked(const QModelIndex &index)
{
	QVariant data = index.model()->data(index, ROLE_WORKSPACE_ITEM);
	Q_ASSERT(data.isValid());
	WorkspaceItem tv = data.value<WorkspaceItem>();

	if(tv.Type!=WorkspaceItem::TYPE_FOLDER && tv.Type!=WorkspaceItem::TYPE_WORKSPACE)
		return;

	QString target = getCurrentWorkspace() + PATH_SEPARATOR + tv.Value;

	QUrl url = QUrl::fromLocalFile(target);
	QDesktopServices::openUrl(url);
}

//------------------------------------------------------------------------------
void MainWindow::on_actionRenameFolder_triggered()

//------------------------------------------------------------------------------
QMenu * MainWindow::createPopupMenu()
{
	return NULL;
}

//------------------------------------------------------------------------------
const QIcon &MainWindow::getInternalIcon(const char* name)
{
	if(iconCache.contains(name))
		return iconCache[name];

	iconCache.insert(name, QIcon(name));
	return iconCache[name];
}

//------------------------------------------------------------------------------
void MainWindow::on_actionCreateStash_triggered()
{
	QStringList stashed_files;
	getSelectionFilenames(stashed_files, WorkspaceFile::TYPE_MODIFIED, true);

	if(stashed_files.empty())
		return;

	QString stash_name;
	bool revert = false;

	if(!CommitDialog::runStashNew(this, stashed_files, stash_name, revert) || stashed_files.empty())
		return;

	stash_name = stash_name.trimmed();

	if(stash_name.indexOf("\"")!=-1 || stash_name.isEmpty())
	{
		QMessageBox::critical(this, tr("Error"), tr("Invalid stash name"));

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionApplyStash_triggered()
{
	QStringList stashes;
	getSelectionStashes(stashes);

	if(stashes.empty())
		return;

	bool delete_stashes = false;
	if(!FileActionDialog::run(this, tr("Apply Stash"), tr("The following stashes will be applied.")+"\n"+tr("Are you sure?"), stashes, tr("Delete after applying"), &delete_stashes))
		return;

	// Apply stashes
	for(QStringList::iterator it=stashes.begin(); it!=stashes.end(); ++it)

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionDeleteStash_triggered()
{
	QStringList stashes;
	getSelectionStashes(stashes);

	if(stashes.empty())
		return;

	if(!FileActionDialog::run(this, tr("Delete Stashes"), tr("The following stashes will be deleted.")+"\n"+tr("Are you sure?"), stashes))
		return;

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionDiffStash_triggered()
{
	QStringList stashes;
	getSelectionStashes(stashes);

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

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

	menu->addAction(ui->actionClearLog);
	menu->popup(ui->textBrowser->mapToGlobal(pos));
}

//------------------------------------------------------------------------------
void MainWindow::on_fileTableView_customContextMenuRequested(const QPoint &pos)
{
	QPoint gpos = QCursor::pos() + QPoint(1, 1);
#ifdef Q_OS_WIN
	if(qApp->keyboardModifiers() & Qt::SHIFT)
	{
		ui->fileTableView->selectionModel()->select(ui->fileTableView->indexAt(pos), QItemSelectionModel::ClearAndSelect|QItemSelectionModel::Rows);
		QStringList fnames;
		getSelectionFilenames(fnames);

		if(fnames.size()==1)
		{
			QString fname = getCurrentWorkspace() + PATH_SEPARATOR + fnames[0];
			fname = QDir::toNativeSeparators(fname);
			if(ShowExplorerMenu((HWND)winId(), fname, gpos))
				refresh();
		}
	}
	else
#else
	Q_UNUSED(pos);
#endif
	{
		QMenu *menu = new QMenu(this);
		menu->addActions(ui->fileTableView->actions());
		menu->popup(gpos);
	}

}

//------------------------------------------------------------------------------
void MainWindow::on_workspaceTreeView_customContextMenuRequested(const QPoint &)
{
	QModelIndexList indices = ui->workspaceTreeView->selectionModel()->selectedIndexes();

	if(indices.empty())
		return;

	QMenu *menu = 0;

	// Get first selected item
	const QModelIndex &mi = indices.first();
	QVariant data = getWorkspace().getTreeModel().data(mi, ROLE_WORKSPACE_ITEM);
	Q_ASSERT(data.isValid());
	WorkspaceItem tv = data.value<WorkspaceItem>();

	if(tv.Type == WorkspaceItem::TYPE_FOLDER ||  tv.Type == WorkspaceItem::TYPE_WORKSPACE)
		menu = menuWorkspace;
	else if (tv.Type == WorkspaceItem::TYPE_STASH || tv.Type == WorkspaceItem::TYPE_STASHES)
		menu = menuStashes;
	else if (tv.Type == WorkspaceItem::TYPE_TAG || tv.Type == WorkspaceItem::TYPE_TAGS)
		menu = menuTags;
	else if (tv.Type == WorkspaceItem::TYPE_BRANCH || tv.Type == WorkspaceItem::TYPE_BRANCHES)
		menu = menuBranches;

	if(menu)
	{
		QPoint pos = QCursor::pos() + QPoint(1, 1);
		menu->popup(pos);
	}
}

//------------------------------------------------------------------------------
void MainWindow::dragEnterEvent(QDragEnterEvent *event)
{
	// Ignore drops from the same window
	if(event->source() != this)
		event->acceptProposedAction();

}

//------------------------------------------------------------------------------
void MainWindow::MainWinUICallback::beginProcess(const QString& text)
{
	Q_ASSERT(mainWindow);
	mainWindow->ui->statusBar->showMessage(text);
	mainWindow->lblTags->setHidden(true);
	mainWindow->lblRevision->setHidden(true);
	mainWindow->progressBar->setHidden(false);
	QCoreApplication::processEvents();
}

//------------------------------------------------------------------------------
void MainWindow::MainWinUICallback::updateProcess(const QString& text)
{
	Q_ASSERT(mainWindow);
	mainWindow->ui->statusBar->showMessage(text);
	QCoreApplication::processEvents();
}

//------------------------------------------------------------------------------
void MainWindow::MainWinUICallback::endProcess()
{
	Q_ASSERT(mainWindow);
	mainWindow->ui->statusBar->clearMessage();
	mainWindow->lblTags->setHidden(false);
	mainWindow->lblRevision->setHidden(false);
	mainWindow->progressBar->setHidden(true);
	QCoreApplication::processEvents();
}

//------------------------------------------------------------------------------
QMessageBox::StandardButton MainWindow::MainWinUICallback::Query(const QString &title, const QString &query, QMessageBox::StandardButtons buttons)
{
	return DialogQuery(mainWindow, title, query, buttons);
}

//------------------------------------------------------------------------------
void MainWindow::updateRevision(const QString &revision)
{
	const QString latest = tr(REVISION_LATEST);
	QString defaultval = latest;

	if(!revision.isEmpty())
		defaultval = revision;

	QString selected_revision = RevisionDialog::runUpdate(this, tr("Update workspace"), versionList, defaultval).trimmed();

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

	QStringList res;

	// Do test update
	if(!fossil().updateRepository(res, selected_revision, true))
		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
	fossil().updateRepository(res, selected_revision, false);
	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionCreateTag_triggered()
{
	// Default to current revision
	QString revision = fossil().getCurrentRevision();

	QString name;
	if(!RevisionDialog::runNewTag(this, tr("Create Tag"), versionList, revision, revision, name))
		return;

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

	fossil().tagNew(name, revision);
	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];

	fossil().tagDelete(tagname, revision);
	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionCreateBranch_triggered()
{
	// Default to current revision
	QString revision = fossil().getCurrentRevision();

	QString branch_name;
	if(!RevisionDialog::runNewTag(this, tr("Create Branch"), versionList, revision, revision, branch_name))
		return;

	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(!fossil().branchNew(branch_name, revision, false))
		return;

	// Update to this branch.
	updateRevision(branch_name);
}
//------------------------------------------------------------------------------
void MainWindow::MergeRevision(const QString &defaultRevision)
{
	QStringList res;
	QString revision = defaultRevision;

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

	if(revision.isEmpty())
		return;

	// Do test merge
	if(!fossil().branchMerge(res, revision, integrate, force, true))
		return;

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

	// Do update
	fossil().branchMerge(res, revision, integrate, force, false);

	log(tr("Merge completed. Don't forget to commit!")+"\n");

	refresh();
}

//------------------------------------------------------------------------------
void MainWindow::on_actionMergeBranch_triggered()
{
	QString revision;

	if(!selectedBranches.isEmpty())
		revision = selectedBranches.first();
	MergeRevision(revision);
}

//------------------------------------------------------------------------------
void MainWindow::onSearchBoxTextChanged(const QString &)
{
	updateFileView();
}

//------------------------------------------------------------------------------
void MainWindow::onSearch()
{
	searchBox->selectAll();
	searchBox->setFocus();
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QStringList>
#include <QFileIconProvider>
#include "Settings.h"
#include "Workspace.h"

namespace Ui {
	class MainWindow;
}

//////////////////////////////////////////////////////////////////////////

	void fullRefresh();

private:
	bool refresh();
	void scanWorkspace();
	void applySettings();
	void updateSettings();
	void updateRevision(const QString& revision);
	const QString &getCurrentWorkspace();
	void setCurrentWorkspace(const QString &workspace);
	void log(const QString &text, bool isHTML=false);
	void setStatus(const QString &text);
	bool uiRunning() const;
	void getSelectionFilenames(QStringList &filenames, int includeMask=WorkspaceFile::TYPE_ALL, bool allIfEmpty=false);
	void getFileViewSelection(QStringList &filenames, int includeMask=WorkspaceFile::TYPE_ALL, bool allIfEmpty=false);
	void getDirViewSelection(QStringList &filenames, int includeMask=WorkspaceFile::TYPE_ALL, bool allIfEmpty=false);
	void getSelectionStashes(QStringList &stashNames);
	void getSelectionPaths(stringset_t &paths);
	void getAllFilenames(QStringList &filenames, int includeMask=WorkspaceFile::TYPE_ALL);
	bool startUI();
	void stopUI();
	void enableActions(bool on);
	void addWorkspace(const QString &dir);
	void rebuildRecent();
	bool openWorkspace(const QString &path);
	void loadFossilSettings();

	void updateWorkspaceView();
	void updateFileView();

	void selectRootDir();
	void MergeRevision(const QString& defaultRevision);

	void fossilBrowse(const QString &fossilUrl);
	void dragEnterEvent(class QDragEnterEvent *event);
	void dropEvent(class QDropEvent *event);
	void setBusy(bool busy);
	virtual QMenu *createPopupMenu();
	const QIcon& getInternalIcon(const char *name);

	enum ViewMode
	{
		VIEWMODE_LIST,
		VIEWMODE_TREE
	};

private slots:
	// Manual slots.
	// Use a different naming scheme to prevent warnings from Qt's automatic signaling
	void onOpenRecent();
	void onWorkspaceTreeViewSelectionChanged(const class QItemSelection &selected, const class QItemSelection &deselected);
	void onFileViewDragOut();
	void onAbort();
	void onSearchBoxTextChanged(const QString &text);
	void onSearch();

	// Designer slots
	void on_actionRefresh_triggered();
	void on_actionDiff_triggered();
	void on_actionFossilUI_triggered();
	void on_actionQuit_triggered();
	void on_actionTimeline_triggered();

	void on_actionRevert_triggered();
	void on_actionOpenContaining_triggered();
	void on_actionRename_triggered();
	void on_actionUndo_triggered();
	void on_actionAbout_triggered();
	void on_actionUpdate_triggered();
	void on_actionSettings_triggered();
	void on_actionFossilSettings_triggered();
	void on_actionViewUnchanged_triggered();
	void on_actionViewModified_triggered();
	void on_actionViewUnknown_triggered();
	void on_actionViewIgnored_triggered();
	void on_actionViewAll_triggered();
	void on_actionViewAsList_triggered();
	void on_actionViewAsFolders_triggered();
	void on_actionOpenFolder_triggered();
	void on_actionRenameFolder_triggered();
	void on_actionNewRepository_triggered();
	void on_actionOpenRepository_triggered();
	void on_actionCloseRepository_triggered();
	void on_actionCloneRepository_triggered();

	void on_actionCreateStash_triggered();
	void on_actionApplyStash_triggered();
	void on_actionDeleteStash_triggered();
	void on_actionDiffStash_triggered();
	void on_textBrowser_customContextMenuRequested(const QPoint &pos);
	void on_fileTableView_customContextMenuRequested(const QPoint &pos);
	void on_workspaceTreeView_customContextMenuRequested(const QPoint &pos);
	void on_actionCreateTag_triggered();
	void on_actionDeleteTag_triggered();
	void on_actionCreateBranch_triggered();
	void on_actionMergeBranch_triggered();

private:
	class MainWinUICallback : public UICallback
	{
	public:
		MainWinUICallback() : mainWindow(0)
		{}

	friend class MainWinUICallback;

	enum
	{
		MAX_RECENT=5
	};

	typedef QMap<QString, QIcon> icon_map_t;

	Ui::MainWindow		*ui;
	QFileIconProvider	iconProvider;
	icon_map_t			iconCache;
	class QAction		*recentWorkspaceActs[MAX_RECENT];
	class QProgressBar	*progressBar;
	class QLabel		*lblRevision;
	class QLabel		*lblTags;
	class QShortcut		*abortShortcut;
	class SearchBox		*searchBox;
	class QShortcut		*searchShortcut;
	QMenu				*menuWorkspace;
	QMenu				*menuStashes;
	QMenu				*menuTags;
	QMenu				*menuBranches;

	bool				operationAborted;
	stringset_t			selectedDirs;	// The directory selected in the tree
	QStringList			selectedTags;
	QStringList			selectedBranches;
	QStringList			versionList;

	Workspace			workspace;
	Workspace &			getWorkspace() { return workspace; }

	Fossil &			fossil() { return workspace.fossil(); }
	const Fossil &		fossil() const { return workspace.fossil(); }

#include "RevisionDialog.h"
#include "ui_RevisionDialog.h"
#include "Utils.h"

//-----------------------------------------------------------------------------
RevisionDialog::RevisionDialog(QWidget *parent, const QStringList &completions, const QString &defaultValue) :
	QDialog(parent),
	ui(new Ui::RevisionDialog),
	completer(completions, parent)
{
	ui->setupUi(this);
	ui->cmbRevision->setCompleter(&completer);

	ui->cmbRevision->addItems(completions);

	if(!defaultValue.isEmpty())
		ui->cmbRevision->setCurrentText(defaultValue);
}

//-----------------------------------------------------------------------------
RevisionDialog::~RevisionDialog()
{
	delete ui;
}

//-----------------------------------------------------------------------------
QString RevisionDialog::runUpdate(QWidget *parent, const QString &title, const QStringList &completions, const QString &defaultValue)
{
	RevisionDialog dlg(parent, completions, defaultValue);
	dlg.setWindowTitle(title);
	dlg.ui->lblName->setVisible(false);
	dlg.ui->lineName->setVisible(false);
	dlg.ui->lblIntegrate->setVisible(false);
	dlg.ui->chkIntegrate->setVisible(false);
	dlg.ui->lblForce->setVisible(false);
	dlg.ui->chkForce->setVisible(false);

	dlg.adjustSize();

	if(dlg.exec() != QDialog::Accepted)
		return QString("");
	return dlg.ui->cmbRevision->currentText().trimmed();
}

//-----------------------------------------------------------------------------
QString RevisionDialog::runMerge(QWidget *parent, const QString &title, const QStringList &completions, const QString &defaultValue, bool &integrate, bool &force)
{
	RevisionDialog dlg(parent, completions, defaultValue);
	dlg.setWindowTitle(title);
	dlg.ui->lblName->setVisible(false);
	dlg.ui->lineName->setVisible(false);
	dlg.ui->lblIntegrate->setVisible(true);
	dlg.ui->chkIntegrate->setVisible(true);
	dlg.ui->chkIntegrate->setChecked(integrate);
	dlg.ui->lblForce->setVisible(true);
	dlg.ui->chkForce->setVisible(true);
	dlg.ui->chkForce->setChecked(force);

	dlg.adjustSize();

	if(dlg.exec() != QDialog::Accepted)
		return QString("");

	integrate = dlg.ui->chkIntegrate->checkState() == Qt::Checked;
	force = dlg.ui->chkForce->checkState() == Qt::Checked;

	return dlg.ui->cmbRevision->currentText().trimmed();
}


//-----------------------------------------------------------------------------
bool RevisionDialog::runNewTag(QWidget *parent, const QString &title, const QStringList &completions, const QString &defaultValue, QString &revision, QString &name)
{
	RevisionDialog dlg(parent, completions, defaultValue);
	dlg.setWindowTitle(title);

	dlg.ui->lblName->setVisible(true);
	dlg.ui->lineName->setVisible(true);
	dlg.ui->lblIntegrate->setVisible(false);
	dlg.ui->chkIntegrate->setVisible(false);
	dlg.ui->lblForce->setVisible(false);
	dlg.ui->chkForce->setVisible(false);

	dlg.adjustSize();

	if(dlg.exec() != QDialog::Accepted)
		return false;

	revision = dlg.ui->cmbRevision->currentText().trimmed();
	name = dlg.ui->lineName->text().trimmed();
	return true;
}

#ifndef REVISIONDIALOG_H
#define REVISIONDIALOG_H

#include <QDialog>
#include <QCompleter>

namespace Ui {
	class RevisionDialog;
}

class RevisionDialog : public QDialog
{
	Q_OBJECT

public:
	explicit RevisionDialog(QWidget *parent, const QStringList &completions, const QString &defaultValue);
	~RevisionDialog();

	static QString runUpdate(QWidget *parent, const QString &title, const QStringList &completions, const QString &defaultValue);
	static QString runMerge(QWidget* parent, const QString& title, const QStringList& completions, const QString& defaultValue, bool& integrate, bool& force);
	static bool runNewTag(QWidget *parent, const QString &title, const QStringList &completions, const QString &defaultValue, QString &revision, QString &name);

private:
	Ui::RevisionDialog *ui;
	QCompleter	completer;
};

#endif // REVISIONDIALOG_H

#include "SearchBox.h"
#include <QKeyEvent>

SearchBox::SearchBox(QWidget *parent) : QLineEdit(parent)
{
}

SearchBox::~SearchBox()
{

}

void SearchBox::keyPressEvent(QKeyEvent *event)
{
	// Clear text on escape
	if(event->key() == Qt::Key_Escape)
	{
		setText("");
		clearFocus();
	}
	else
		QLineEdit::keyPressEvent(event);
}

#ifndef SEARCHBOX_H
#define SEARCHBOX_H

#include <QLineEdit>

class SearchBox : public QLineEdit
{
	Q_OBJECT
public:
	explicit SearchBox(QWidget* parent=0);
	~SearchBox();

signals:

public slots:

protected:
	void keyPressEvent(QKeyEvent *event);

};


#endif // SEARCHBOX_H

#include "Settings.h"

#include <QSettings>
#include <QCoreApplication>
#include <QDir>
#include <QTranslator>
#include <QResource>
#include <QTextCodec>

///////////////////////////////////////////////////////////////////////////////
Settings::Settings(bool portableMode) : store(0)
{
	Mappings.insert(FOSSIL_SETTING_GDIFF_CMD, Setting("", Setting::TYPE_FOSSIL_GLOBAL));
	Mappings.insert(FOSSIL_SETTING_GMERGE_CMD, Setting("", Setting::TYPE_FOSSIL_GLOBAL));
	Mappings.insert(FOSSIL_SETTING_PROXY_URL, Setting("", Setting::TYPE_FOSSIL_GLOBAL));
	Mappings.insert(FOSSIL_SETTING_HTTP_PORT, Setting("", Setting::TYPE_FOSSIL_GLOBAL));

	Mappings.insert(FOSSIL_SETTING_IGNORE_GLOB, Setting("", Setting::TYPE_FOSSIL_LOCAL));
	Mappings.insert(FOSSIL_SETTING_CRNL_GLOB, Setting("", Setting::TYPE_FOSSIL_LOCAL));
	Mappings.insert(FOSSIL_SETTING_REMOTE_URL, Setting("off", Setting::TYPE_FOSSIL_COMMAND));

	// Go into portable mode when explicitly requested or if a config file exists next to the executable
	QString ini_path = QDir::toNativeSeparators(QCoreApplication::applicationDirPath() + QDir::separator() + QCoreApplication::applicationName() + ".ini");
	if( portableMode || QFile::exists(ini_path))
		store = new QSettings(ini_path, QSettings::IniFormat);
	else
	{
		// Linux: ~/.config/organizationName/applicationName.conf
		// Windows: HKEY_CURRENT_USER\Software\organizationName\Fuel
		store = new QSettings(QSettings::UserScope, QCoreApplication::organizationName(), QCoreApplication::applicationName());
	}
	Q_ASSERT(store);

	if(!HasValue(FUEL_SETTING_FILE_DBLCLICK))
		SetValue(FUEL_SETTING_FILE_DBLCLICK, 0);
	if(!HasValue(FUEL_SETTING_LANGUAGE) && SupportsLang(QLocale::system().name()))
		SetValue(FUEL_SETTING_LANGUAGE, QLocale::system().name());
	if(!HasValue(FUEL_SETTING_WEB_BROWSER))
		SetValue(FUEL_SETTING_WEB_BROWSER, 0);

	ApplyEnvironment();
}

//-----------------------------------------------------------------------------
Settings::~Settings()
{
	Q_ASSERT(store);
	delete store;
}

//-----------------------------------------------------------------------------
void Settings::ApplyEnvironment()
{
	QString lang_id = GetValue(FUEL_SETTING_LANGUAGE).toString();
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
	QTextCodec::setCodecForTr(QTextCodec::codecForName("utf8"));
#endif
	if(!InstallLang(lang_id))
		SetValue(FUEL_SETTING_LANGUAGE, "en_US");
}

//-----------------------------------------------------------------------------
bool Settings::InstallLang(const QString &langId)
{
	if(langId == "en_US")
	{
		QCoreApplication::instance()->removeTranslator(&translator);
		return true;
	}

	QString locale_path = QString(":intl/intl/%0.qm").arg(langId);
	if(!translator.load(locale_path))
		return false;

	Q_ASSERT(!translator.isEmpty());
	QCoreApplication::instance()->installTranslator(&translator);


	return true;
}

//-----------------------------------------------------------------------------
bool Settings::HasValue(const QString &name) const
{
	return store->contains(name);
}

//-----------------------------------------------------------------------------
const QVariant Settings::GetValue(const QString &name)
{
	if(!HasValue(name))
		return QVariant();
	return store->value(name);
}

//-----------------------------------------------------------------------------
void Settings::SetValue(const QString &name, const QVariant &value)
{
	store->setValue(name, value);
}

//-----------------------------------------------------------------------------
QVariant &Settings::GetFossilValue(const QString &name)
{
	mappings_t::iterator it=Mappings.find(name);
	Q_ASSERT(it!=Mappings.end());
	return it.value().Value;
}

//-----------------------------------------------------------------------------
void Settings::SetFossilValue(const QString &name, const QVariant &value)
{
	mappings_t::iterator it=Mappings.find(name);
	Q_ASSERT(it!=Mappings.end());
	it->Value = value;
}

//-----------------------------------------------------------------------------
bool Settings::SupportsLang(const QString &langId) const
{
	QString locale_path = QString(":intl/intl/%0.qm").arg(langId);
	QResource res(locale_path);
	return res.isValid();
}

#ifndef SETTINGS_H
#define SETTINGS_H

#include <QMap>
#include <QVariant>
#include <QTranslator>

#define FUEL_SETTING_FOSSIL_PATH			"FossilPath"
#define FUEL_SETTING_COMMIT_MSG				"CommitMsgHistory"
#define FUEL_SETTING_FILE_DBLCLICK			"FileDblClickAction"
#define FUEL_SETTING_LANGUAGE				"Language"
#define FUEL_SETTING_WEB_BROWSER			"WebBrowser"

#define FOSSIL_SETTING_GDIFF_CMD			"gdiff-command"
#define FOSSIL_SETTING_GMERGE_CMD			"gmerge-command"
#define FOSSIL_SETTING_PROXY_URL			"proxy"
#define FOSSIL_SETTING_IGNORE_GLOB			"ignore-glob"
#define FOSSIL_SETTING_CRNL_GLOB			"crnl-glob"
#define FOSSIL_SETTING_REMOTE_URL			"remote-url"
#define FOSSIL_SETTING_HTTP_PORT			"http-port"


enum FileDblClickAction
{
	FILE_DLBCLICK_ACTION_DIFF,
	FILE_DLBCLICK_ACTION_OPEN,
	FILE_DLBCLICK_ACTION_OPENCONTAINING,
	FILE_DLBCLICK_ACTION_MAX
};

struct Settings
{
	struct Setting
	{
		enum SettingType
		{
			TYPE_FOSSIL_GLOBAL,
			TYPE_FOSSIL_LOCAL,
			TYPE_FOSSIL_COMMAND
		};

		Setting(QVariant value, SettingType type) : Value(value), Type(type)
		{}
		QVariant Value;
		SettingType Type;
	};
	typedef QMap<QString, Setting> mappings_t;


	Settings(bool portableMode = false);
	~Settings();

	void				ApplyEnvironment();

	// App configuration access
	class QSettings *	GetStore() { return store; }
	bool				HasValue(const QString &name) const; // store->contains(FUEL_SETTING_FOSSIL_PATH)
	const QVariant		GetValue(const QString &name); // settings.store->value
	void				SetValue(const QString &name, const QVariant &value); // settings.store->value

	// Fossil configuration access
	QVariant &		GetFossilValue(const QString &name);
	void			SetFossilValue(const QString &name, const QVariant &value);
	mappings_t &	GetMappings() { return Mappings; }

	bool			SupportsLang(const QString &langId) const;
	bool			InstallLang(const QString &langId);
private:
	mappings_t		Mappings;
	class QSettings	*store;
	QTranslator		translator;
};


#endif // SETTINGS_H

#include "SettingsDialog.h"
#include "ui_SettingsDialog.h"

#include "Utils.h"



#include <QDir>



























///////////////////////////////////////////////////////////////////////////////
SettingsDialog::SettingsDialog(QWidget *parent, Settings &_settings) :
	QDialog(parent, Qt::Sheet),
	ui(new Ui::SettingsDialog),
	settings(&_settings)
{

	ui->cmbFossilBrowser->addItem(tr("System"));
	ui->cmbFossilBrowser->addItem(tr("Internal"));

	// App Settings
	ui->lineFossilPath->setText(QDir::toNativeSeparators(settings->GetValue(FUEL_SETTING_FOSSIL_PATH).toString()));
	ui->cmbDoubleClickAction->setCurrentIndex(settings->GetValue(FUEL_SETTING_FILE_DBLCLICK).toInt());
	ui->cmbFossilBrowser->setCurrentIndex(settings->GetValue(FUEL_SETTING_WEB_BROWSER).toInt());


	// Initialize language combo
	foreach(const LangMap &m, langMap)
		ui->cmbActiveLanguage->addItem(m.name);

	QString lang = settings->GetValue(FUEL_SETTING_LANGUAGE).toString();
	// Select current language
	ui->cmbActiveLanguage->setCurrentIndex(
				ui->cmbActiveLanguage->findText(
					LangIdToName(lang)));










}

//-----------------------------------------------------------------------------
SettingsDialog::~SettingsDialog()
{
	delete ui;
}

//-----------------------------------------------------------------------------
void SettingsDialog::on_buttonBox_accepted()
{
	settings->SetValue(FUEL_SETTING_FOSSIL_PATH, QDir::fromNativeSeparators(ui->lineFossilPath->text()));
	Q_ASSERT(ui->cmbDoubleClickAction->currentIndex()>=FILE_DLBCLICK_ACTION_DIFF && ui->cmbDoubleClickAction->currentIndex()<FILE_DLBCLICK_ACTION_MAX);
	settings->SetValue(FUEL_SETTING_FILE_DBLCLICK, ui->cmbDoubleClickAction->currentIndex());
	settings->SetValue(FUEL_SETTING_WEB_BROWSER, ui->cmbFossilBrowser->currentIndex());


	Q_ASSERT(settings->HasValue(FUEL_SETTING_LANGUAGE));
	QString curr_langid = settings->GetValue(FUEL_SETTING_LANGUAGE).toString();
	QString new_langid = LangNameToId(ui->cmbActiveLanguage->currentText());
	Q_ASSERT(!new_langid.isEmpty());
	settings->SetValue(FUEL_SETTING_LANGUAGE, new_langid);

	if(curr_langid != new_langid)
		QMessageBox::information(this, tr("Restart required"), tr("The language change will take effect after restarting the application"), QMessageBox::Ok);










	settings->ApplyEnvironment();
}

//-----------------------------------------------------------------------------
void SettingsDialog::on_btnSelectFossil_clicked()
{
	QString path = SelectExe(this, tr("Select Fossil executable"));
	if(!path.isEmpty())
		ui->lineFossilPath->setText(QDir::toNativeSeparators(path));
}

















//-----------------------------------------------------------------------------
void SettingsDialog::on_btnClearMessageHistory_clicked()
{
	if(DialogQuery(this, tr("Clear Commit Message History"), tr("Are you sure you want to clear the commit message history?"))==QMessageBox::Yes)
		settings->SetValue(FUEL_SETTING_COMMIT_MSG, QStringList());
}

	{
		if(m.name == name)
			return m.id;
	}

	return "";
}

#ifndef SETTINGSDIALOG_H
#define SETTINGSDIALOG_H

#include <QDialog>
#include "Settings.h"




namespace Ui {
	class SettingsDialog;
}




































































class SettingsDialog : public QDialog
{
	Q_OBJECT

public:
	explicit SettingsDialog(QWidget *parent, Settings &_settings);
	~SettingsDialog();

	static bool run(QWidget *parent, Settings &_settings);


private slots:
	void on_btnSelectFossil_clicked();
	void on_buttonBox_accepted();


	void on_btnClearMessageHistory_clicked();

private:

	QString LangIdToName(const QString &id);
	QString LangNameToId(const QString &name);
	void CreateLangMap();

	struct LangMap
	{
		LangMap(const QString &_id, const QString &_name)

#include "Utils.h"
#include <QMessageBox>
#include <QDialogButtonBox>
#include <QFileDialog>

///////////////////////////////////////////////////////////////////////////////
QMessageBox::StandardButton DialogQuery(QWidget *parent, const QString &title, const QString &query, QMessageBox::StandardButtons buttons)
{
	QMessageBox mb(QMessageBox::Question, title, query, buttons, parent, Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint | Qt::Sheet );
	mb.setDefaultButton(QMessageBox::No);
	mb.setWindowModality(Qt::WindowModal);

{
	QStringList res;
	for(int i=0; i<paths.size(); ++i)
		res.append(QuotePath(paths[i]));
	return res;
}

//-----------------------------------------------------------------------------
QString SelectExe(QWidget *parent, const QString &description)
{
	QString filter(QObject::tr("Applications"));
#ifdef Q_OS_WIN
	filter += " (*.exe)";
#else
	filter += " (*)";
#endif
	QString path = QFileDialog::getOpenFileName(
				parent,
				description,
				QString(),
				filter,
				&filter);

	if(!QFile::exists(path))
		return QString();

	return path;
}
//-----------------------------------------------------------------------------
#if 0 // Unused
#include <QInputDialog>

static bool DialogQueryText(QWidget *parent, const QString &title, const QString &query, QString &text, bool isPassword=false)
{
	QInputDialog dlg(parent, Qt::Sheet);

	pMalloc->Release ();

	return bResult;
}

#endif

//-----------------------------------------------------------------------------
void ParseProperties(QStringMap &properties, const QStringList &lines, QChar separator)
{
	properties.clear();
	foreach(QString l, lines)
	{
		l = l.trimmed();
		int index = l.indexOf(separator);

		QString key;
		QString value;
		if(index!=-1)
		{
			key = l.left(index).trimmed();
			value = l.mid(index+1).trimmed();
		}
		else
			key = l;

		properties.insert(key, value);
	}
}


//------------------------------------------------------------------------------
void GetStandardItemTextRecursive(QString &name, const QStandardItem &item, const QChar &separator)
{
	if(item.parent())
	{
		GetStandardItemTextRecursive(name, *item.parent());
		name.append(separator);
	}

	name.append(item.data(Qt::DisplayRole).toString());
}

//------------------------------------------------------------------------------
void BuildNameToModelIndex(name_modelindex_map_t &map, const QStandardItem &item)
{
	QString name;
	GetStandardItemTextRecursive(name, item);
	map.insert(name, item.index());

	for(int i=0; i<item.rowCount(); ++i)
	{
		const QStandardItem *child = item.child(i);
		Q_ASSERT(child);
		BuildNameToModelIndex(map, *child);
	}
}

//------------------------------------------------------------------------------
void BuildNameToModelIndex(name_modelindex_map_t &map, const QStandardItemModel &model)
{
	for(int i=0; i<model.rowCount(); ++i)
	{
		const QStandardItem *item = model.item(i);
		Q_ASSERT(item);
		BuildNameToModelIndex(map, *item);
	}
}

#ifndef UTILS_H
#define UTILS_H

#include <QString>
#include <QMessageBox>
#include <QMap>
#include <QStandardItem>

#define COUNTOF(array)			(sizeof(array)/sizeof(array[0]))
#define FOSSIL_CHECKOUT1	"_FOSSIL_"
#define FOSSIL_CHECKOUT2	".fslckout"
#define FOSSIL_EXT			"fossil"


QMessageBox::StandardButton DialogQuery(QWidget *parent, const QString &title, const QString &query, QMessageBox::StandardButtons buttons = QMessageBox::Yes|QMessageBox::No);
QString						QuotePath(const QString &path);
QStringList					QuotePaths(const QStringList &paths);
QString						SelectExe(QWidget *parent, const QString &description);


typedef QMap<QString, QModelIndex> name_modelindex_map_t;
void						GetStandardItemTextRecursive(QString &name, const QStandardItem &item, const QChar &separator='/');
void						BuildNameToModelIndex(name_modelindex_map_t &map, const QStandardItem &item);
void						BuildNameToModelIndex(name_modelindex_map_t &map, const QStandardItemModel &model);


typedef QMap<QString, QString> QStringMap;
void						ParseProperties(QStringMap &properties, const QStringList &lines, QChar separator=' ');

#ifdef Q_OS_WIN
	bool ShowExplorerMenu(HWND hwnd, const QString &path, const QPoint &qpoint);
#endif

class UICallback
{

{
	// Dispose RepoFiles
	foreach(WorkspaceFile *r, getFiles())
		delete r;

	getFiles().clear();
	getPaths().clear();
	stashMap.clear();
	branchList.clear();
	tags.clear();
	isIntegrated = false;
}

//------------------------------------------------------------------------------
bool Workspace::scanDirectory(QFileInfoList &entries, const QString& dirPath, const QString &baseDir, const QString ignoreSpec, const bool &abort, UICallback &uiCallback)
{
	QDir dir(dirPath);

	for(QStringList::iterator line_it=res.begin(); line_it!=res.end(); ++line_it)
	{
		QString line = (*line_it).trimmed();
		if(line.length()==0)
			continue;

		int space_index = line.indexOf(' ');
		if(space_index==-1)
			continue;

		QString status_text = line.left(space_index);
		QString fname = line.right(line.length() - space_index).trimmed();
		WorkspaceFile::Type type = WorkspaceFile::TYPE_UNKNOWN;

		// Generate a RepoFile for all non-existant fossil files
		// or for all files if we skipped scanning the workspace
		bool add_missing = !scan_files;

		if(status_text=="EDITED")

		}
		else if(status_text=="RENAMED")
			type = WorkspaceFile::TYPE_RENAMED;
		else if(status_text=="UNCHANGED")
			type = WorkspaceFile::TYPE_UNCHANGED;
		else if(status_text=="CONFLICT")
			type = WorkspaceFile::TYPE_CONFLICTED;
		else if(status_text=="UPDATED_BY_MERGE" || status_text=="ADDED_BY_MERGE" || status_text=="ADDED_BY_INTEGRATE" || status_text=="UPDATED_BY_INTEGRATE")
			type = WorkspaceFile::TYPE_MERGED;

		// Filter unwanted file types
		if( ((type & WorkspaceFile::TYPE_MODIFIED) && !scanModified) ||
			((type & WorkspaceFile::TYPE_UNCHANGED) && !scanUnchanged))
		{
			getFiles().remove(fname);
			continue;

		rf->setType(type);

		QString path = rf->getPath();
		getPaths().insert(path);
	}

	// Check if the repository needs integration
	res.clear();
	fossil().status(res);
	isIntegrated = false;
	foreach(const QString &l, res)
	{
		if(l.trimmed().indexOf("INTEGRATE")==0)
		{
			isIntegrated = true;
			break;
		}
	}

	// Load the stashes, branches and tags
	fossil().stashList(getStashes());

	fossil().branchList(branchList, branchList);

	fossil().tagList(tags);
	// Fossil includes the branches in the tag list
	// So remove them
	foreach(const QString &name, branchList)
		tags.remove(name);

_done:
	uiCallback.endProcess();
}

#ifndef WORKSPACE_H
#define WORKSPACE_H

#include <QStandardItemModel>
#include <QFileInfo>
#include <QDir>
#include <QSet>
#include <QMap>
#include "Utils.h"
#include "Fossil.h"

//////////////////////////////////////////////////////////////////////////
// WorkspaceFile
//////////////////////////////////////////////////////////////////////////
struct WorkspaceFile
{
	enum Type
	{
		TYPE_UNKNOWN		= 1<<0,
		TYPE_UNCHANGED		= 1<<1,
		TYPE_EDITTED		= 1<<2,
		TYPE_ADDED			= 1<<3,
		TYPE_DELETED		= 1<<4,
		TYPE_MISSING		= 1<<5,
		TYPE_RENAMED		= 1<<6,
		TYPE_CONFLICTED		= 1<<7,
		TYPE_MERGED			= 1<<8,
		TYPE_MODIFIED		= TYPE_EDITTED|TYPE_ADDED|TYPE_DELETED|TYPE_MISSING|TYPE_RENAMED|TYPE_CONFLICTED|TYPE_MERGED,
		TYPE_REPO			= TYPE_UNCHANGED|TYPE_MODIFIED,
		TYPE_ALL			= TYPE_UNKNOWN|TYPE_REPO
	};

	WorkspaceFile(const QFileInfo &info, Type type, const QString &repoPath)
	{
		FileInfo = info;

	QString		FilePath;
	QString		Path;
};


typedef QSet<QString> stringset_t;

//////////////////////////////////////////////////////////////////////////
// Workspace
//////////////////////////////////////////////////////////////////////////

class Workspace
{
public:
	~Workspace();

	typedef QList<WorkspaceFile*> filelist_t;
	typedef QMap<QString, WorkspaceFile*> filemap_t;

	void				clearState();

	Fossil &			fossil() { return bridge; }
	const Fossil &		fossil() const { return bridge; }

	static bool			scanDirectory(QFileInfoList &entries, const QString& dirPath, const QString &baseDir, const QString ignoreSpec, const bool& abort, UICallback &uiCallback);
	void				scanWorkspace(bool scanLocal, bool scanIgnored, bool scanModified, bool scanUnchanged, const QString &ignoreGlob, UICallback &uiCallback, bool &operationAborted);

	QStandardItemModel	&getFileModel() { return repoFileModel; }
	QStandardItemModel	&getTreeModel() { return repoTreeModel; }

	filemap_t			&getFiles() { return workspaceFiles; }
	stringset_t			&getPaths() { return pathSet; }
	stashmap_t			&getStashes() { return stashMap; }
	QStringMap			&getTags() { return tags; }
	QStringList			&getBranches() { return branchList; }
	bool				otherChanges() const { return isIntegrated; }

private:
	Fossil				bridge;
	filemap_t			workspaceFiles;
	stringset_t			pathSet;
	stashmap_t			stashMap;
	QStringList			branchList;
	QStringMap			tags;
	bool				isIntegrated;

	QStandardItemModel	repoFileModel;
	QStandardItemModel	repoTreeModel;

};

#endif // WORKSPACE_H

#include <QApplication>
#include "MainWindow.h"

int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	app.setApplicationName("Fuel");
	app.setApplicationVersion("2.0.0");
	app.setOrganizationDomain("fuel-scm.org");
	app.setOrganizationName("Fuel-SCM");


	#ifdef Q_OS_MACX
		// Native OSX applications don't have menu icons
		app.setAttribute(Qt::AA_DontShowIconsInMenus);
	#endif

    <height>300</height>
   </rect>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout">
   <property name="spacing">
    <number>0</number>
   </property>
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item>
    <widget class="QToolBar" name="toolBar">
     <property name="windowTitle">
      <string/>
     </property>

   <item>
    <widget class="CustomWebView" name="webView" native="true"/>
   </item>
  </layout>
  <action name="actionBrowserBack">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-previous</normaloff>:/icons/icon-action-previous</iconset>
   </property>
   <property name="text">
    <string>Back</string>
   </property>
   <property name="toolTip">
    <string>Back</string>
   </property>
  </action>
  <action name="actionBrowserForward">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-next</normaloff>:/icons/icon-action-next</iconset>
   </property>
   <property name="text">
    <string>Forward</string>
   </property>
   <property name="toolTip">
    <string>Forward</string>
   </property>
  </action>
  <action name="actionBrowserRefresh">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-refresh</normaloff>:/icons/icon-action-refresh</iconset>
   </property>
   <property name="text">
    <string>Refresh</string>
   </property>
   <property name="toolTip">
    <string>Refresh</string>
   </property>
  </action>
  <action name="actionBrowserStop">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-stop</normaloff>:/icons/icon-action-stop</iconset>
   </property>
   <property name="text">
    <string>Stop</string>
   </property>
  </action>
 </widget>
 <customwidgets>

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>CommitDialog</class>
 <widget class="QDialog" name="CommitDialog">
  <property name="windowModality">
   <enum>Qt::WindowModal</enum>
  </property>
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>394</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Commit</string>
  </property>
  <property name="modal">
   <bool>true</bool>

      <property name="selectionBehavior">
       <enum>QAbstractItemView::SelectRows</enum>
      </property>
     </widget>
    </widget>
   </item>
   <item>
    <widget class="QWidget" name="widgetBranchOptions" native="true">
     <layout class="QFormLayout" name="formLayout">
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="label_2">
        <property name="text">
         <string>New branch</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QCheckBox" name="chkNewBranch">
        <property name="text">
         <string/>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QCheckBox" name="chkPrivateBranch">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="text">
         <string/>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
       <widget class="QLineEdit" name="lineBranchName">
        <property name="enabled">
         <bool>false</bool>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Branch name</string>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="label_3">
        <property name="text">
         <string>Private branch</string>
        </property>
       </widget>
      </item>
     </layout>
    </widget>
   </item>
   <item>
    <widget class="QCheckBox" name="chkRevertFiles">
     <property name="text">
      <string>Revert stashed files</string>
     </property>
    </widget>
   </item>
   <item>
    <widget class="QDialogButtonBox" name="buttonBox">
     <property name="orientation">
      <enum>Qt::Horizontal</enum>

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>FslSettingsDialog</class>
 <widget class="QDialog" name="FslSettingsDialog">
  <property name="windowModality">
   <enum>Qt::WindowModal</enum>
  </property>
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>457</width>
    <height>266</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Fossil Settings</string>
  </property>
  <property name="windowIcon">
   <iconset resource="../rsrc/resources.qrc">
    <normaloff>:/icons/icon-application</normaloff>:/icons/icon-application</iconset>
  </property>
  <property name="modal">
   <bool>true</bool>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout">
   <item>
    <widget class="QWidget" name="widget" native="true">
     <layout class="QFormLayout" name="formLayout">
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="label_2">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Graphical Diff </string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <layout class="QHBoxLayout" name="horizontalLayout_9">
        <item>
         <widget class="QLineEdit" name="lineGDiffCommand">
          <property name="toolTip">
           <string>Path to graphical diff tool</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="btnSelectFossilGDiff">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>24</width>
            <height>24</height>
           </size>
          </property>
          <property name="text">
           <string>...</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="label_3">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Graphical Merge</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <layout class="QHBoxLayout" name="horizontalLayout_10">
        <item>
         <widget class="QLineEdit" name="lineGMergeCommand">
          <property name="toolTip">
           <string>Path to the graphical merge tool</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="btnSelectGMerge">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>24</width>
            <height>24</height>
           </size>
          </property>
          <property name="text">
           <string>...</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="label_44">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>HTTP Proxy</string>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
       <widget class="QLineEdit" name="lineProxy">
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>0</height>
         </size>
        </property>
        <property name="toolTip">
         <string>The URL of the HTTP proxy</string>
        </property>
       </widget>
      </item>
      <item row="3" column="0">
       <widget class="QLabel" name="uILanguageLabel_3">
        <property name="text">
         <string>HTTP Port</string>
        </property>
       </widget>
      </item>
      <item row="3" column="1">
       <widget class="QLineEdit" name="lineUIPort">
        <property name="toolTip">
         <string>HTTP port to use for the Fossil web interface</string>
        </property>
       </widget>
      </item>
      <item row="4" column="1">
       <widget class="QLineEdit" name="lineIgnoreCRNL">
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>0</height>
         </size>
        </property>
        <property name="toolTip">
         <string>A comma separated list of glob-style file patterns to exclude from Fossil's CR/NL consistency checking</string>
        </property>
       </widget>
      </item>
      <item row="4" column="0">
       <widget class="QLabel" name="label_7">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Ignore CR/NL</string>
        </property>
       </widget>
      </item>
      <item row="5" column="1">
       <widget class="QLineEdit" name="lineIgnore">
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>0</height>
         </size>
        </property>
        <property name="toolTip">
         <string>A comma separated list of glob-style file/path patterns ignored in Fossil file operations</string>
        </property>
       </widget>
      </item>
      <item row="5" column="0">
       <widget class="QLabel" name="label_4">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Ignore List</string>
        </property>
       </widget>
      </item>
      <item row="6" column="1">
       <widget class="QLineEdit" name="lineRemoteURL">
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>0</height>
         </size>
        </property>
        <property name="toolTip">
         <string>The remote url used to push/pull changes.
URL style user names and passwords are also supported.
For example http://username:password@server.com/fossil</string>
        </property>
       </widget>
      </item>
      <item row="6" column="0">
       <widget class="QLabel" name="label_5">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Remote Url</string>
        </property>
       </widget>
      </item>
     </layout>
    </widget>
   </item>
   <item>
    <widget class="QDialogButtonBox" name="buttonBox">
     <property name="orientation">
      <enum>Qt::Horizontal</enum>
     </property>
     <property name="standardButtons">
      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <resources>
  <include location="../rsrc/resources.qrc"/>
 </resources>
 <connections>
  <connection>
   <sender>buttonBox</sender>
   <signal>accepted()</signal>
   <receiver>FslSettingsDialog</receiver>
   <slot>accept()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>248</x>
     <y>254</y>
    </hint>
    <hint type="destinationlabel">
     <x>157</x>
     <y>274</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>buttonBox</sender>
   <signal>rejected()</signal>
   <receiver>FslSettingsDialog</receiver>
   <slot>reject()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>316</x>
     <y>260</y>
    </hint>
    <hint type="destinationlabel">
     <x>286</x>
     <y>274</y>
    </hint>
   </hints>
  </connection>
 </connections>
</ui>

  <property name="acceptDrops">
   <bool>true</bool>
  </property>
  <property name="windowTitle">
   <string>Fuel</string>
  </property>
  <property name="windowIcon">
   <iconset resource="../rsrc/resources.qrc">
    <normaloff>:/icons/icon-application</normaloff>:/icons/icon-application</iconset>
  </property>
  <property name="unifiedTitleAndToolBarOnMac">
   <bool>true</bool>
  </property>
  <widget class="QWidget" name="centralWidget">
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="leftMargin">

        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
          <horstretch>20</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="contextMenuPolicy">
         <enum>Qt::CustomContextMenu</enum>
        </property>
        <property name="editTriggers">
         <set>QAbstractItemView::NoEditTriggers</set>
        </property>
        <property name="selectionMode">
         <enum>QAbstractItemView::ExtendedSelection</enum>
        </property>
        <property name="selectionBehavior">
         <enum>QAbstractItemView::SelectItems</enum>
        </property>
        <property name="sortingEnabled">
         <bool>false</bool>
        </property>



        <attribute name="headerShowSortIndicator" stdset="0">
         <bool>false</bool>
        </attribute>
       </widget>
       <widget class="FileTableView" name="fileTableView">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Expanding">

        <attribute name="verticalHeaderVisible">
         <bool>false</bool>
        </attribute>
        <attribute name="verticalHeaderDefaultSectionSize">
         <number>30</number>
        </attribute>
       </widget>






































      </widget>
      <widget class="QTabWidget" name="tabWidget">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
         <horstretch>0</horstretch>
         <verstretch>8</verstretch>
        </sizepolicy>
       </property>
       <property name="tabPosition">
        <enum>QTabWidget::South</enum>
       </property>
       <property name="currentIndex">
        <number>0</number>
       </property>
       <widget class="QWidget" name="tabLog">
        <attribute name="title">
         <string>Log</string>
        </attribute>
        <layout class="QVBoxLayout" name="verticalLayout_2">
         <property name="leftMargin">

  </widget>
  <widget class="QMenuBar" name="menuBar">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>865</width>
     <height>23</height>
    </rect>
   </property>
   <widget class="QMenu" name="menuFile">
    <property name="title">
     <string>&amp;File</string>
    </property>
    <addaction name="actionNewRepository"/>

    <property name="title">
     <string>&amp;View</string>
    </property>
    <addaction name="actionViewModified"/>
    <addaction name="actionViewUnchanged"/>
    <addaction name="actionViewUnknown"/>
    <addaction name="actionViewIgnored"/>
    <addaction name="actionViewAll"/>
    <addaction name="separator"/>
    <addaction name="actionViewAsList"/>
    <addaction name="actionViewAsFolders"/>
   </widget>
   <widget class="QMenu" name="menuWorkspace">
    <property name="title">
     <string>&amp;Workspace</string>
    </property>
    <addaction name="actionRefresh"/>
    <addaction name="separator"/>
    <addaction name="actionCommit"/>
    <addaction name="actionUpdate"/>
    <addaction name="separator"/>
    <addaction name="actionPush"/>
    <addaction name="actionPull"/>
    <addaction name="separator"/>
    <addaction name="actionUndo"/>
    <addaction name="separator"/>
    <addaction name="actionCreateBranch"/>
    <addaction name="actionCreateTag"/>
    <addaction name="actionCreateStash"/>
    <addaction name="separator"/>
    <addaction name="actionFossilSettings"/>
   </widget>
   <addaction name="menuFile"/>
   <addaction name="menuView"/>
   <addaction name="menuWorkspace"/>
   <addaction name="menuHelp"/>
  </widget>
  <widget class="QToolBar" name="mainToolBar">
   <property name="windowTitle">
    <string>Main Toolbar</string>
   </property>
   <property name="movable">

   <addaction name="separator"/>
   <addaction name="actionUndo"/>
   <addaction name="separator"/>
   <addaction name="actionAdd"/>
   <addaction name="actionRevert"/>
   <addaction name="actionDelete"/>
   <addaction name="separator"/>


   <addaction name="actionDiff"/>
   <addaction name="actionHistory"/>
   <addaction name="separator"/>
   <addaction name="actionFossilUI"/>
   <addaction name="actionTimeline"/>
   <addaction name="separator"/>
   <addaction name="actionOpenContaining"/>
  </widget>
  <widget class="QStatusBar" name="statusBar"/>
  <action name="actionRefresh">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-refresh</normaloff>:/icons/icon-action-refresh</iconset>
   </property>
   <property name="text">
    <string>&amp;Refresh</string>
   </property>
   <property name="toolTip">
    <string>Refresh the views</string>
   </property>
   <property name="statusTip">
    <string>Refresh the views</string>
   </property>
   <property name="shortcut">
    <string>F5</string>
   </property>
  </action>
  <action name="actionCommit">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-commit</normaloff>:/icons/icon-action-commit</iconset>
   </property>
   <property name="text">
    <string>&amp;Commit</string>
   </property>
   <property name="toolTip">
    <string>Commit modifications</string>
   </property>
   <property name="statusTip">
    <string>Commit modifications</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+M</string>
   </property>
  </action>
  <action name="actionDiff">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-diff</normaloff>:/icons/icon-item-diff</iconset>
   </property>
   <property name="text">
    <string>Diff</string>
   </property>
   <property name="toolTip">
    <string>Display the differences between the current and last committed version</string>
   </property>
   <property name="statusTip">
    <string>Display the differences between the current and last committed version</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+D</string>
   </property>
  </action>
  <action name="actionAdd">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-add</normaloff>:/icons/icon-item-add</iconset>
   </property>
   <property name="text">
    <string>Add</string>
   </property>
   <property name="toolTip">
    <string>Add files to the repository</string>
   </property>
   <property name="statusTip">
    <string>Add files to the repository</string>
   </property>
   <property name="shortcut">
    <string>Ctrl++</string>
   </property>
  </action>
  <action name="actionDelete">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-delete</normaloff>:/icons/icon-item-delete</iconset>
   </property>
   <property name="text">
    <string>Delete</string>
   </property>
   <property name="toolTip">
    <string>Delete files from the repository</string>
   </property>
   <property name="statusTip">
    <string>Delete files from the repository</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+-</string>
   </property>
  </action>
  <action name="actionNewRepository">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-repo-new</normaloff>:/icons/icon-action-repo-new</iconset>
   </property>
   <property name="text">
    <string>&amp;New...</string>
   </property>
   <property name="toolTip">
    <string>Make a new Fossil repository</string>
   </property>
   <property name="statusTip">
    <string>Make a new Fossil repository</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+N</string>
   </property>
  </action>
  <action name="actionOpenRepository">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-repo-open</normaloff>:/icons/icon-action-repo-open</iconset>
   </property>
   <property name="text">
    <string>&amp;Open...</string>
   </property>
   <property name="toolTip">
    <string>Open a Fossil repository or workspace folder</string>
   </property>

   </property>
   <property name="statusTip">
    <string>Close the current workspace</string>
   </property>
  </action>
  <action name="actionCloneRepository">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-repo-clone</normaloff>:/icons/icon-action-repo-clone</iconset>
   </property>
   <property name="text">
    <string>C&amp;lone...</string>
   </property>
   <property name="statusTip">
    <string>Clone a remote repository</string>
   </property>
  </action>
  <action name="actionPush">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-push</normaloff>:/icons/icon-action-push</iconset>
   </property>
   <property name="text">
    <string>&amp;Push</string>
   </property>
   <property name="toolTip">
    <string>Push changes to the remote repository</string>
   </property>
   <property name="statusTip">
    <string>Push changes to the remote repository</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+P</string>
   </property>
  </action>
  <action name="actionPull">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-pull</normaloff>:/icons/icon-action-pull</iconset>
   </property>
   <property name="text">
    <string>Pu&amp;ll</string>
   </property>
   <property name="toolTip">
    <string>Pull changes from the remote repository</string>
   </property>
   <property name="statusTip">
    <string>Pull changes from the remote repository</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+L</string>
   </property>
  </action>
  <action name="actionRename">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-rename</normaloff>:/icons/icon-item-rename</iconset>
   </property>
   <property name="text">
    <string>Rename</string>
   </property>
   <property name="toolTip">
    <string>Rename the selected file</string>
   </property>
   <property name="statusTip">
    <string>Rename the selected file</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+R</string>
   </property>
  </action>
  <action name="actionQuit">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-quit</normaloff>:/icons/icon-action-quit</iconset>
   </property>
   <property name="text">
    <string>&amp;Quit</string>
   </property>
   <property name="statusTip">
    <string>Quit</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+Q</string>
   </property>
   <property name="menuRole">
    <enum>QAction::QuitRole</enum>
   </property>
   <property name="iconVisibleInMenu">
    <bool>true</bool>
   </property>
  </action>
  <action name="actionHistory">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-history</normaloff>:/icons/icon-item-history</iconset>
   </property>
   <property name="text">
    <string>History</string>
   </property>
   <property name="toolTip">
    <string>Display the version history of a file via the Fossil UI</string>
   </property>
   <property name="statusTip">
    <string>Display the version history of a file via the Fossil UI</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+H</string>
   </property>
  </action>
  <action name="actionFossilUI">
   <property name="checkable">
    <bool>true</bool>
   </property>
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-webview</normaloff>:/icons/icon-webview</iconset>
   </property>
   <property name="text">
    <string>Fossil UI</string>
   </property>
   <property name="toolTip">
    <string>Starts the Fossil UI in the Web Browser</string>
   </property>
   <property name="statusTip">
    <string>Starts the Fossil UI in the Web Browser</string>
   </property>
  </action>
  <action name="actionRevert">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-revert</normaloff>:/icons/icon-item-revert</iconset>
   </property>
   <property name="text">
    <string>Revert</string>
   </property>
   <property name="toolTip">
    <string>Revert files to the last commited version</string>
   </property>
   <property name="statusTip">
    <string>Revert files to the last commited version</string>
   </property>
  </action>
  <action name="actionClearLog">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-clear-log</normaloff>:/icons/icon-clear-log</iconset>
   </property>
   <property name="text">
    <string>Clear Log</string>
   </property>
   <property name="toolTip">
    <string>Clears the log</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+K</string>
   </property>
  </action>
  <action name="actionTimeline">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-timeline</normaloff>:/icons/icon-action-timeline</iconset>
   </property>
   <property name="text">
    <string>Timeline</string>
   </property>
   <property name="toolTip">
    <string>Display the change history of the Fossil repository</string>
   </property>
   <property name="statusTip">
    <string>Display the change history of the Fossil repository</string>
   </property>
  </action>
  <action name="actionOpenFile">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-file</normaloff>:/icons/icon-item-file</iconset>
   </property>
   <property name="text">
    <string>Open File</string>
   </property>
   <property name="toolTip">
    <string>Open the selected file</string>
   </property>
   <property name="statusTip">
    <string>Open the selected file</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+Return</string>
   </property>
  </action>
  <action name="actionOpenContaining">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-folder-explore</normaloff>:/icons/icon-action-folder-explore</iconset>
   </property>
   <property name="text">
    <string>Open Containing</string>
   </property>
   <property name="toolTip">
    <string>Open the folder containing the selected file</string>
   </property>
   <property name="statusTip">
    <string>Open the folder containing the selected file</string>
   </property>
   <property name="shortcut">
    <string>Alt+Return</string>
   </property>
  </action>
  <action name="actionUndo">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-undo</normaloff>:/icons/icon-action-undo</iconset>
   </property>
   <property name="text">
    <string>U&amp;ndo</string>
   </property>
   <property name="toolTip">
    <string>Undo the last Fossil action</string>
   </property>
   <property name="statusTip">
    <string>Undo the last Fossil action</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+Z</string>
   </property>
  </action>
  <action name="actionAbout">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-application</normaloff>:/icons/icon-application</iconset>
   </property>
   <property name="text">
    <string>&amp;About...</string>
   </property>
   <property name="statusTip">
    <string>About Fuel</string>
   </property>
   <property name="menuRole">
    <enum>QAction::AboutRole</enum>
   </property>
  </action>
  <action name="actionUpdate">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-update</normaloff>:/icons/icon-action-update</iconset>
   </property>
   <property name="text">
    <string>&amp;Update</string>
   </property>
   <property name="toolTip">
    <string>Update the workspace to a revision</string>
   </property>
   <property name="statusTip">
    <string>Update the workspace to the latest version</string>
   </property>
   <property name="shortcut">
    <string>Ctrl+U</string>
   </property>
  </action>
  <action name="actionSettings">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-settings</normaloff>:/icons/icon-action-settings</iconset>
   </property>
   <property name="text">
    <string>&amp;Preferences...</string>
   </property>
   <property name="toolTip">
    <string>Fuel Preferences</string>
   </property>

   </property>
   <property name="statusTip">
    <string>View the workspace as a list of files</string>
   </property>
  </action>
  <action name="actionOpenFolder">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-folder</normaloff>:/icons/icon-item-folder</iconset>
   </property>
   <property name="text">
    <string>Open Folder</string>
   </property>
   <property name="toolTip">
    <string>Open the selected folder</string>
   </property>
   <property name="statusTip">
    <string>Open the selected folder</string>
   </property>
  </action>
  <action name="actionRenameFolder">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-folder-rename</normaloff>:/icons/icon-action-folder-rename</iconset>
   </property>
   <property name="text">
    <string>Rename Folder</string>
   </property>
   <property name="toolTip">
    <string>Rename the selected folder</string>
   </property>
   <property name="statusTip">
    <string>Rename the selected folder</string>
   </property>
  </action>
  <action name="actionCreateStash">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-stash-new</normaloff>:/icons/icon-action-stash-new</iconset>
   </property>
   <property name="text">
    <string>&amp;Stash Changes</string>
   </property>
   <property name="statusTip">
    <string>Stash changes</string>
   </property>
  </action>
  <action name="actionApplyStash">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-stash-apply</normaloff>:/icons/icon-action-stash-apply</iconset>
   </property>
   <property name="text">
    <string>Apply Stash</string>
   </property>
   <property name="iconText">
    <string>Apply stashed changes</string>
   </property>
   <property name="toolTip">
    <string>Apply stashed changes</string>
   </property>
  </action>

















  <action name="actionDeleteStash">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-stash-delete</normaloff>:/icons/icon-action-stash-delete</iconset>
   </property>
   <property name="text">
    <string>Delete Stash</string>
   </property>
  </action>
  <action name="actionDiffStash">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-stash-diff</normaloff>:/icons/icon-action-stash-diff</iconset>
   </property>
   <property name="text">
    <string>Diff Stash</string>
   </property>
  </action>
  <action name="actionCreateTag">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-tag-new</normaloff>:/icons/icon-action-tag-new</iconset>
   </property>
   <property name="text">
    <string>Create &amp;Tag</string>
   </property>
   <property name="toolTip">
    <string>Create a tag for a revision</string>
   </property>
   <property name="statusTip">
    <string>Create a tag for a revision</string>
   </property>
  </action>
  <action name="actionDeleteTag">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-tag-delete</normaloff>:/icons/icon-action-tag-delete</iconset>
   </property>
   <property name="text">
    <string>Delete Tag</string>
   </property>
   <property name="toolTip">
    <string>Delete Tag</string>
   </property>
  </action>
  <action name="actionCreateBranch">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-item-branch</normaloff>:/icons/icon-item-branch</iconset>
   </property>
   <property name="text">
    <string>Create &amp;Branch</string>
   </property>
   <property name="toolTip">
    <string>Create a branch from a revision</string>
   </property>
   <property name="statusTip">
    <string>Create a branch from a revision</string>
   </property>
  </action>
  <action name="actionMergeBranch">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-merge</normaloff>:/icons/icon-action-merge</iconset>
   </property>
   <property name="text">
    <string>Merge Branch</string>
   </property>
   <property name="toolTip">
    <string>Merge with a branch</string>
   </property>
   <property name="statusTip">
    <string>Merge with a branch</string>
   </property>
  </action>
  <action name="actionViewAsFolders">
   <property name="checkable">
    <bool>true</bool>
   </property>
   <property name="text">
    <string>Files and F&amp;olders</string>
   </property>
   <property name="toolTip">
    <string>View files and folders</string>
   </property>
   <property name="statusTip">
    <string>View the workspace as files and folders</string>
   </property>
  </action>
  <action name="actionViewAll">
   <property name="text">
    <string>&amp;All</string>
   </property>
   <property name="statusTip">
    <string>Show all files</string>
   </property>
  </action>
  <action name="actionFossilSettings">
   <property name="icon">
    <iconset resource="../rsrc/resources.qrc">
     <normaloff>:/icons/icon-action-settings</normaloff>:/icons/icon-action-settings</iconset>
   </property>
   <property name="text">
    <string>F&amp;ossil Settings</string>
   </property>
  </action>
 </widget>
 <layoutdefault spacing="6" margin="11"/>
 <customwidgets>
  <customwidget>
   <class>FileTableView</class>
   <extends>QTableView</extends>
   <header>FileTableView.h</header>
  </customwidget>
  <customwidget>
   <class>BrowserWidget</class>
   <extends>QWidget</extends>
   <header>BrowserWidget.h</header>
   <container>1</container>
  </customwidget>
 </customwidgets>
 <resources>
  <include location="../rsrc/resources.qrc"/>
 </resources>
 <connections/>
</ui>

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>RevisionDialog</class>
 <widget class="QDialog" name="RevisionDialog">
  <property name="windowModality">
   <enum>Qt::WindowModal</enum>
  </property>
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>478</width>
    <height>177</height>
   </rect>
  </property>
  <property name="minimumSize">
   <size>
    <width>400</width>
    <height>0</height>
   </size>
  </property>
  <property name="modal">
   <bool>true</bool>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout">
   <item>
    <layout class="QFormLayout" name="formLayout">
     <item row="0" column="0">
      <widget class="QLabel" name="lblRevision">
       <property name="text">
        <string>Revision</string>
       </property>
      </widget>
     </item>
     <item row="0" column="1">
      <widget class="QComboBox" name="cmbRevision">
       <property name="editable">
        <bool>true</bool>
       </property>
      </widget>
     </item>
     <item row="1" column="0">
      <widget class="QLabel" name="lblName">
       <property name="text">
        <string>Name</string>
       </property>
      </widget>
     </item>
     <item row="1" column="1">
      <widget class="QLineEdit" name="lineName"/>
     </item>
     <item row="2" column="0">
      <widget class="QLabel" name="lblIntegrate">
       <property name="text">
        <string>Integrate</string>
       </property>
      </widget>
     </item>
     <item row="3" column="0">
      <widget class="QLabel" name="lblForce">
       <property name="text">
        <string>Force</string>
       </property>
      </widget>
     </item>
     <item row="2" column="1">
      <widget class="QCheckBox" name="chkIntegrate">
       <property name="text">
        <string/>
       </property>
      </widget>
     </item>
     <item row="3" column="1">
      <widget class="QCheckBox" name="chkForce">
       <property name="text">
        <string/>
       </property>
      </widget>
     </item>
    </layout>
   </item>
   <item>
    <widget class="QDialogButtonBox" name="buttonBox">
     <property name="orientation">
      <enum>Qt::Horizontal</enum>
     </property>
     <property name="standardButtons">
      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <resources/>
 <connections>
  <connection>
   <sender>buttonBox</sender>
   <signal>accepted()</signal>
   <receiver>RevisionDialog</receiver>
   <slot>accept()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>248</x>
     <y>254</y>
    </hint>
    <hint type="destinationlabel">
     <x>157</x>
     <y>274</y>
    </hint>
   </hints>
  </connection>
  <connection>
   <sender>buttonBox</sender>
   <signal>rejected()</signal>
   <receiver>RevisionDialog</receiver>
   <slot>reject()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>316</x>
     <y>260</y>
    </hint>
    <hint type="destinationlabel">
     <x>286</x>
     <y>274</y>
    </hint>
   </hints>
  </connection>
 </connections>
</ui>

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>SettingsDialog</class>
 <widget class="QDialog" name="SettingsDialog">
  <property name="windowModality">
   <enum>Qt::WindowModal</enum>
  </property>
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>457</width>
    <height>204</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Settings</string>
  </property>
  <property name="windowIcon">
   <iconset resource="../rsrc/resources.qrc">
    <normaloff>:/icons/icon-application</normaloff>:/icons/icon-application</iconset>
  </property>
  <property name="modal">
   <bool>true</bool>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout">
   <item>
    <widget class="QWidget" name="widget" native="true">
     <layout class="QFormLayout" name="formLayout">
      <property name="leftMargin">
       <number>0</number>
      </property>

      <property name="topMargin">
       <number>0</number>

      </property>
      <property name="rightMargin">

       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="label">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Fossil Path</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <layout class="QHBoxLayout" name="horizontalLayout_8">
        <item>
         <widget class="QLineEdit" name="lineFossilPath">
          <property name="toolTip">
           <string>Path to the Fossil executable. Leave blank to use the default Fossil</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QPushButton" name="btnSelectFossil">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>24</width>
            <height>24</height>
           </size>
          </property>
          <property name="text">
           <string>...</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item row="1" column="0">






























































































































       <widget class="QLabel" name="label_6">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Commit Messages</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QPushButton" name="btnClearMessageHistory">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Clear the commit message history</string>
        </property>
        <property name="text">
         <string>Clear</string>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="uILanguageLabel_2">
        <property name="text">
         <string>Web Browser</string>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
       <widget class="QComboBox" name="cmbFossilBrowser">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Web browser to use for the Fossil web interface</string>
        </property>
       </widget>
      </item>
      <item row="3" column="0">
       <widget class="QLabel" name="label_8">
        <property name="minimumSize">
         <size>
          <width>100</width>
          <height>0</height>
         </size>
        </property>
        <property name="text">
         <string>Double-click Action</string>
        </property>
       </widget>
      </item>
      <item row="3" column="1">
       <widget class="QComboBox" name="cmbDoubleClickAction">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Action to perfom when double-clicking a file</string>
        </property>
        <property name="currentIndex">
         <number>-1</number>
        </property>
       </widget>
      </item>
      <item row="4" column="0">
       <widget class="QLabel" name="uILanguageLabel">
        <property name="text">
         <string>Language</string>
        </property>
       </widget>
      </item>
      <item row="4" column="1">
       <widget class="QComboBox" name="cmbActiveLanguage">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Language for the user interface</string>
        </property>
       </widget>
      </item>
     </layout>


































































































    </widget>
   </item>
   <item>
    <widget class="QDialogButtonBox" name="buttonBox">
     <property name="orientation">
      <enum>Qt::Horizontal</enum>
     </property>