No OneTemporary
Actions

Size

110 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/BasicMainWindow.cpp b/src/BasicMainWindow.cpp
	index 6de4388..7624e90 100644
	--- a/src/BasicMainWindow.cpp
	+++ b/src/BasicMainWindow.cpp
	@@ -1,2988 +1,3007 @@

	#include "ApplicationGlobal.h"
	#include "BasicMainWindow.h"
	#include "CheckoutDialog.h"
	#include "CloneDialog.h"
	#include "CommitDialog.h"
	#include "CommitExploreWindow.h"
	#include "CommitViewWindow.h"
	#include "CreateRepositoryDialog.h"
	#include "DeleteBranchDialog.h"
	#include "DoYouWantToInitDialog.h"
	#include "FileHistoryWindow.h"
	#include "FilePropertyDialog.h"
	#include "FileUtil.h"
	#include "Git.h"
	#include "GitDiff.h"
	#include "MemoryReader.h"
	#include "MySettings.h"
	#include "PushDialog.h"
	#include "RepositoryPropertyDialog.h"
	#include "SelectCommandDialog.h"
	#include "SetGlobalUserDialog.h"
	#include "SetUserDialog.h"
	#include "SettingsDialog.h"
	#include "Terminal.h"
	#include "TextEditDialog.h"
	#include "UserEvent.h"
	#include "WelcomeWizardDialog.h"
	#include "common/joinpath.h"
	#include "common/misc.h"
	#include "SubmoduleAddDialog.h"
	#include "gpg.h"
	#include "gunzip.h"
	#include "platform.h"
	#include "webclient.h"
	#include <QDesktopServices>
	#include <QDir>
	#include <QDirIterator>
	#include <QEvent>
	#include <QFileIconProvider>
	#include <QListWidget>
	#include <QMenu>
	#include <QMessageBox>
	#include <QStandardPaths>
	#include <QTreeWidgetItem>
	#include <functional>
	#include <memory>

	class AsyncExecGitThread_ : public QThread {
	private:
	GitPtr g;
	std::function<void(GitPtr g)> callback;
	public:
	AsyncExecGitThread_(GitPtr const &g, std::function<void(GitPtr const &g)> const &callback)
	: g(g)
	, callback(callback)
	{
	}
	protected:
	void run() override
	{
	callback(g);
	}
	};

	//

	struct BasicMainWindow::Private {
	ApplicationSettings appsettings;

	QIcon repository_icon;
	QIcon folder_icon;
	QIcon signature_good_icon;
	QIcon signature_dubious_icon;
	QIcon signature_bad_icon;
	QPixmap transparent_pixmap;

	QString starting_dir;
	Git::Context gcx;
	RepositoryItem current_repo;

	QList<RepositoryItem> repos;
	Git::CommitItemList logs;
	QList<Git::Diff> diff_result;

	QStringList added;
	QStringList remotes;
	QString current_remote_name;
	Git::Branch current_branch;
	unsigned int temp_file_counter = 0;

	std::string ssh_passphrase_user;
	std::string ssh_passphrase_pass;

	std::string http_uid;
	std::string http_pwd;

	std::map<QString, GitHubAPI::User> committer_map; // key is email

	PtyProcess pty_process;
	bool pty_process_ok = false;
	PtyCondition pty_condition = PtyCondition::None;

	WebContext webcx;

	AvatarLoader avatar_loader;
	int update_files_list_counter = 0;
	int update_commit_table_counter = 0;

	bool interaction_canceled = false;
	InteractionMode interaction_mode = InteractionMode::None;

	QString repository_filter_text;
	bool uncommited_changes = false;

	std::map<QString, QList<Git::Branch>> branch_map;
	std::map<QString, QList<Git::Tag>> tag_map;
	std::map<int, QList<Label>> label_map;
	std::map<QString, Git::Diff> diff_cache;
	GitObjectCache objcache;

	bool remote_changed = false;

	ServerType server_type = ServerType::Standard;
	GitHubRepositoryInfo github;

	QString head_id;
	bool force_fetch = false;

	RepositoryItem temp_repo_for_clone_complete;
	QVariant pty_process_completion_data;
	};

	BasicMainWindow::BasicMainWindow(QWidget *parent)
	: QMainWindow(parent)
	, m(new Private)
	{
	- SettingsDialog::loadSettings(&m->appsettings);
	+ loadApplicationSettings();
	m->starting_dir = QDir::current().absolutePath();

	{ // load graphic resources
	QFileIconProvider icons;
	m->folder_icon = icons.icon(QFileIconProvider::Folder);
	m->repository_icon = QIcon(":/image/repository.png");
	m->signature_good_icon = QIcon(":/image/signature-good.png");
	m->signature_bad_icon = QIcon(":/image/signature-bad.png");
	m->signature_dubious_icon = QIcon(":/image/signature-dubious.png");
	m->transparent_pixmap = QPixmap(":/image/transparent.png");
	}
	}

	BasicMainWindow::~BasicMainWindow()
	{
	setRemoteMonitoringEnabled(false);
	deleteTempFiles();
	delete m;
	}

	ApplicationSettings *BasicMainWindow::appsettings()
	{
	return &m->appsettings;
	}

	const ApplicationSettings *BasicMainWindow::appsettings() const
	{
	return &m->appsettings;
	}

	WebContext *BasicMainWindow::webContext()
	{
	return &m->webcx;
	}

	QString BasicMainWindow::gitCommand() const
	{
	return m->gcx.git_command;
	}

	namespace {

	} // namespace

	bool BasicMainWindow::event(QEvent *event)
	{
	if (event->type() == (QEvent::Type)EventUserFunction) {
	if (auto e = (UserFunctionEvent )event) {
	e->func(e->var);
	return true;
	}
	}
	return QMainWindow::event(event);
	}

	void BasicMainWindow::postUserFunctionEvent(const std::function<void(QVariant const &)> &fn, QVariant const &v)
	{
	qApp->postEvent(this, new UserFunctionEvent(fn, v));
	}

	void BasicMainWindow::autoOpenRepository(QString dir)
	{
	auto Open = [&](RepositoryItem const &item){
	setCurrentRepository(item, true);
	openRepository(false, true);
	};

	RepositoryItem const *repo = findRegisteredRepository(&dir);
	if (repo) {
	Open(*repo);
	return;
	}

	RepositoryItem newitem;
	GitPtr g = git(dir);
	if (isValidWorkingCopy(g)) {
	ushort const *left = dir.utf16();
	ushort const *right = left + dir.size();
	if (right[-1] == '/' \|\| right[-1] == '\\') {
	right--;
	}
	ushort const *p = right;
	while (left + 1 < p && !(p[-1] == '/' \|\| p[-1] == '\\')) p--;
	if (p < right) {
	newitem.local_dir = dir;
	newitem.name = QString::fromUtf16(p, right - p);
	saveRepositoryBookmark(newitem);
	Open(newitem);
	return;
	}
	} else {
	DoYouWantToInitDialog dlg(this, dir);
	if (dlg.exec() == QDialog::Accepted) {
	createRepository(dir);
	}
	}
	}

	GitPtr BasicMainWindow::git(QString const &dir, QString const &sshkey) const
	{
	GitPtr g = std::make_shared<Git>(m->gcx, dir, sshkey);
	if (g && QFileInfo(g->gitCommand()).isExecutable()) {
	g->setLogCallback(git_callback, (void *)this);
	return g;
	} else {
	QString text = tr("git command not specified") + '\n';
	const_cast<BasicMainWindow *>(this)->writeLog(text);
	return GitPtr();
	}
	}

	GitPtr BasicMainWindow::git()
	{
	RepositoryItem const &item = currentRepository();
	// return git(currentWorkingCopyDir());
	return git(item.local_dir, item.ssh_key);
	}

	QPixmap BasicMainWindow::getTransparentPixmap()
	{
	return m->transparent_pixmap;
	}

	QIcon BasicMainWindow::committerIcon(int row) const
	{
	QIcon icon;
	if (isAvatarEnabled() && isOnlineMode()) {
	auto const &logs = getLogs();
	if (row >= 0 && row < (int)logs.size()) {
	Git::CommitItem const &commit = logs[row];
	if (commit.email.indexOf('@') > 0) {
	std::string email = commit.email.toStdString();
	icon = getAvatarLoader()->fetch(email, true); // from gavatar
	}
	}
	}
	return icon;
	}

	Git::CommitItem const *BasicMainWindow::commitItem(int row) const
	{
	auto const &logs = getLogs();
	if (row >= 0 && row < (int)logs.size()) {
	return &logs[row];
	}
	return nullptr;
	}

	QIcon BasicMainWindow::verifiedIcon(char s) const
	{
	Git::SignatureGrade g = Git::evaluateSignature(s);
	switch (g) {
	case Git::SignatureGrade::Good:
	return m->signature_good_icon;
	case Git::SignatureGrade::Bad:
	return m->signature_bad_icon;
	case Git::SignatureGrade::Unknown:
	case Git::SignatureGrade::Dubious:
	case Git::SignatureGrade::Missing:
	return m->signature_dubious_icon;
	}
	return QIcon();
	}

	QString BasicMainWindow::currentWorkingCopyDir() const
	{
	return m->current_repo.local_dir;
	}

	bool BasicMainWindow::isRepositoryOpened() const
	{
	return Git::isValidWorkingCopy(currentWorkingCopyDir());
	}

	QList<BasicMainWindow::Label> const *BasicMainWindow::label(int row) const
	{
	auto it = getLabelMap()->find(row);
	if (it != getLabelMap()->end()) {
	return &it->second;
	}
	return nullptr;
	}

	QList<BasicMainWindow::Label> BasicMainWindow::sortedLabels(int row) const
	{
	QList<BasicMainWindow::Label> list;
	auto const p = const_cast<BasicMainWindow >(this)->label(row);
	if (p && !p->empty()) {
	list = *p;
	std::sort(list.begin(), list.end(), [](BasicMainWindow::Label const &l, BasicMainWindow::Label const &r){
	auto Compare = [](BasicMainWindow::Label const &l, BasicMainWindow::Label const &r){
	if (l.kind < r.kind) return -1;
	if (l.kind > r.kind) return 1;
	if (l.text < r.text) return -1;
	if (l.text > r.text) return 1;
	return 0;
	};
	return Compare(l, r) < 0;
	});
	}
	return list;
	}

	bool BasicMainWindow::saveAs(QString const &id, QString const &dstpath)
	{
	if (id.startsWith(PATH_PREFIX)) {
	return saveFileAs(id.mid(1), dstpath);
	} else {
	return saveBlobAs(id, dstpath);
	}
	}

	bool BasicMainWindow::testRemoteRepositoryValidity(QString const &url, QString const &sshkey)
	{
	bool ok;
	{
	OverrideWaitCursor;
	ok = isValidRemoteURL(url, sshkey);
	}

	QString pass = tr("The URL is a valid repository");
	QString fail = tr("Failed to access the URL");

	QString text = "%1\n\n%2";
	text = text.arg(url).arg(ok ? pass : fail);

	QString title = tr("Remote Repository");

	if (ok) {
	QMessageBox::information(this, title, text);
	} else {
	QMessageBox::critical(this, title, text);
	}

	return ok;
	}

	void BasicMainWindow::addWorkingCopyDir(QString const &dir, bool open)
	{
	addWorkingCopyDir(dir, QString(), open);
	}

	bool BasicMainWindow::queryCommit(QString const &id, Git::CommitItem *out)
	{
	*out = Git::CommitItem();
	GitPtr g = git();
	return g->queryCommit(id, out);
	}

	QAction BasicMainWindow::addMenuActionProperty(QMenu menu)
	{
	return menu->addAction(tr("&Property"));
	}

	void BasicMainWindow::checkout(QWidget parent, Git::CommitItem const commit, std::function<void()> accepted_callback)
	{
	if (!commit) return;

	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QStringList tags;
	QStringList all_local_branches;
	QStringList local_branches;
	QStringList remote_branches;
	{
	NamedCommitList named_commits = namedCommitItems(Branches \| Tags \| Remotes);
	for (NamedCommitItem const &item : named_commits) {
	QString name = item.name;
	if (item.id == commit->commit_id) {
	if (item.type == NamedCommitItem::Type::Tag) {
	tags.push_back(name);
	} else if (item.type == NamedCommitItem::Type::BranchLocal \|\| item.type == NamedCommitItem::Type::BranchRemote) {
	int i = name.lastIndexOf('/');
	if (i < 0 && name == "HEAD") continue;
	if (i > 0 && name.mid(i + 1) == "HEAD") continue;
	if (item.type == NamedCommitItem::Type::BranchLocal) {
	local_branches.push_back(name);
	} else if (item.type == NamedCommitItem::Type::BranchRemote) {
	remote_branches.push_back(name);
	}
	}
	}
	if (item.type == NamedCommitItem::Type::BranchLocal) {
	all_local_branches.push_back(name);
	}
	}
	}

	CheckoutDialog dlg(parent, tags, all_local_branches, local_branches, remote_branches);
	if (dlg.exec() == QDialog::Accepted) {
	if (accepted_callback) {
	accepted_callback();
	}
	CheckoutDialog::Operation op = dlg.operation();
	QString name = dlg.branchName();
	QString id = commit->commit_id;
	if (id.isEmpty() && !commit->parent_ids.isEmpty()) {
	id = commit->parent_ids.front();
	}
	bool ok = false;
	setLogEnabled(g, true);
	if (op == CheckoutDialog::Operation::HeadDetached) {
	if (!id.isEmpty()) {
	ok = g->git(QString("checkout \"%1\"").arg(id), true);
	}
	} else if (op == CheckoutDialog::Operation::CreateLocalBranch) {
	if (!name.isEmpty() && !id.isEmpty()) {
	ok = g->git(QString("checkout -b \"%1\" \"%2\"").arg(name).arg(id), true);
	}
	} else if (op == CheckoutDialog::Operation::ExistingLocalBranch) {
	if (!name.isEmpty()) {
	ok = g->git(QString("checkout \"%1\"").arg(name), true);
	}
	}
	if (ok) {
	openRepository(true);
	}
	}
	}

	void BasicMainWindow::jumpToCommit(QString id)
	{
	GitPtr g = git();
	id = g->rev_parse(id);
	if (!id.isEmpty()) {
	int row = rowFromCommitId(id);
	setCurrentLogRow(row);
	}
	}

	void BasicMainWindow::execCommitViewWindow(Git::CommitItem const *commit)
	{
	CommitViewWindow win(this, commit);
	win.exec();
	}

	void BasicMainWindow::execCommitExploreWindow(QWidget parent, Git::CommitItem const commit)
	{
	CommitExploreWindow win(parent, this, getObjCache(), commit);
	win.exec();
	}

	void BasicMainWindow::execFileHistory(QString const &path)
	{
	if (path.isEmpty()) return;

	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	FileHistoryWindow dlg(this);
	dlg.prepare(g, path);
	dlg.exec();
	}

	void BasicMainWindow::execFilePropertyDialog(QListWidgetItem *item)
	{
	if (item) {
	QString path = getFilePath(item);
	QString id = getObjectID(item);
	FilePropertyDialog dlg(this);
	dlg.exec(this, path, id);
	}
	}

	QString BasicMainWindow::selectGitCommand(bool save)
	{
	char const *exe = GIT_COMMAND;

	QString path = gitCommand();

	auto fn = [&](QString const &path){
	setGitCommand(path, save);
	};

	QStringList list = whichCommand_(exe);
	#ifdef Q_OS_WIN
	{
	QStringList newlist;
	QString suffix1 = "\\bin\\" GIT_COMMAND;
	QString suffix2 = "\\cmd\\" GIT_COMMAND;
	for (QString const &s : list) {
	newlist.push_back(s);
	auto DoIt = [&](QString const &suffix){
	if (s.endsWith(suffix)) {
	QString t = s.mid(0, s.size() - suffix.size());
	QString t1 = t + "\\mingw64\\bin\\" GIT_COMMAND;
	if (misc::isExecutable(t1)) newlist.push_back(t1);
	QString t2 = t + "\\mingw\\bin\\" GIT_COMMAND;
	if (misc::isExecutable(t2)) newlist.push_back(t2);
	}
	};
	DoIt(suffix1);
	DoIt(suffix2);
	}
	std::sort(newlist.begin(), newlist.end());
	auto end = std::unique(newlist.begin(), newlist.end());
	list.clear();
	for (auto it = newlist.begin(); it != end; it++) {
	list.push_back(*it);
	}
	}
	#endif
	return selectCommand_("Git", exe, list, path, fn);
	}

	QString BasicMainWindow::selectFileCommand(bool save)
	{
	char const *exe = FILE_COMMAND;

	QString path = global->file_command;

	auto fn = [&](QString const &path){
	setFileCommand(path, save);
	};

	QStringList list = whichCommand_(exe);

	#ifdef Q_OS_WIN
	QString dir = misc::getApplicationDir();
	QString path1 = dir / FILE_COMMAND;
	QString path2;
	int i = dir.lastIndexOf('/');
	int j = dir.lastIndexOf('\\');
	if (i < j) i = j;
	if (i > 0) {
	path2 = dir.mid(0, i) / FILE_COMMAND;
	}
	path1 = misc::normalizePathSeparator(path1);
	path2 = misc::normalizePathSeparator(path2);
	if (misc::isExecutable(path1)) list.push_back(path1);
	if (misc::isExecutable(path2)) list.push_back(path2);
	#endif

	return selectCommand_("File", exe, list, path, fn);
	}

	QString BasicMainWindow::selectGpgCommand(bool save)
	{
	QString path = global->gpg_command;

	auto fn = [&](QString const &path){
	setGpgCommand(path, save);
	};

	QStringList list = whichCommand_(GPG_COMMAND, GPG2_COMMAND);

	QStringList cmdlist;
	cmdlist.push_back(GPG_COMMAND);
	cmdlist.push_back(GPG2_COMMAND);
	return selectCommand_("GPG", cmdlist, list, path, fn);
	}

	QString BasicMainWindow::selectSshCommand(bool save)
	{
	QString path = m->gcx.ssh_command;

	auto fn = [&](QString const &path){
	setSshCommand(path, save);
	};

	QStringList list = whichCommand_(SSH_COMMAND);

	QStringList cmdlist;
	cmdlist.push_back(SSH_COMMAND);
	return selectCommand_("ssh", cmdlist, list, path, fn);
	}

	Git::Branch const &BasicMainWindow::currentBranch() const
	{
	return m->current_branch;
	}

	void BasicMainWindow::setCurrentBranch(Git::Branch const &b)
	{
	m->current_branch = b;
	}

	RepositoryItem const &BasicMainWindow::currentRepository() const
	{
	return m->current_repo;
	}

	QString BasicMainWindow::currentRepositoryName() const
	{
	return currentRepository().name;
	}

	QString BasicMainWindow::currentRemoteName() const
	{
	return m->current_remote_name;
	}

	QString BasicMainWindow::currentBranchName() const
	{
	return currentBranch().name;
	}

	bool BasicMainWindow::isValidWorkingCopy(const GitPtr &g) const
	{
	return g && g->isValidWorkingCopy();
	}

	QString BasicMainWindow::determinFileType_(QString const &path, bool mime, std::function<void (QString const &, QByteArray *)> const &callback) const
	{
	const_cast<BasicMainWindow *>(this)->checkFileCommand();
	return misc::determinFileType(global->file_command, path, mime, callback);
	}

	QString BasicMainWindow::determinFileType(QString const &path, bool mime)
	{
	return determinFileType_(path, mime, [](QString const &cmd, QByteArray *ba){
	misc2::runCommand(cmd, ba);
	});
	}

	QString BasicMainWindow::determinFileType(QByteArray in, bool mime)
	{
	if (in.isEmpty()) return QString();

	if (in.size() > 10) {
	if (memcmp(in.data(), "\x1f\x8b\x08", 3) == 0) { // gzip
	QBuffer buf;
	MemoryReader reader(in.data(), in.size());
	reader.open(MemoryReader::ReadOnly);
	buf.open(QBuffer::WriteOnly);
	gunzip z;
	z.set_maximul_size(100000);
	z.decode(&reader, &buf);
	in = buf.buffer();
	}
	}

	// ファイル名を "-" にすると、リダイレクトで標準入力へ流し込める。
	return determinFileType_("-", mime, [&](QString const &cmd, QByteArray *ba){
	int r = misc2::runCommand(cmd, &in, ba);
	if (r != 0) {
	ba->clear();
	}
	});
	}

	QList<Git::Tag> BasicMainWindow::queryTagList()
	{
	QList<Git::Tag> list;
	Git::CommitItem const *commit = selectedCommitItem();
	if (commit && Git::isValidID(commit->commit_id)) {
	list = findTag(commit->commit_id);
	}
	return list;
	}

	int BasicMainWindow::limitLogCount() const
	{
	int n = appsettings()->maximum_number_of_commit_item_acquisitions;
	return (n >= 1 && n <= 100000) ? n : 10000;
	}

	TextEditorThemePtr BasicMainWindow::themeForTextEditor()
	{
	return global->theme->text_editor_theme;
	}

	Git::Object BasicMainWindow::cat_file_(GitPtr const &g, QString const &id)
	{
	if (isValidWorkingCopy(g)) {
	QString path_prefix = PATH_PREFIX;
	if (id.startsWith(path_prefix)) {
	QString path = g->workingRepositoryDir();
	path = path / id.mid(path_prefix.size());
	QFile file(path);
	if (file.open(QFile::ReadOnly)) {
	Git::Object obj;
	obj.content = file.readAll();
	return obj;
	}
	} else if (Git::isValidID(id)) {
	return getObjCache()->catFile(id);;
	}
	}
	return Git::Object();
	}

	Git::Object BasicMainWindow::cat_file(QString const &id)
	{
	return cat_file_(git(), id);
	}

	QString BasicMainWindow::newTempFilePath()
	{
	QString tmpdir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
	QString path = tmpdir / tempfileHeader() + QString::number(m->temp_file_counter);
	m->temp_file_counter++;
	return path;
	}

	QString BasicMainWindow::findFileID(QString const &commit_id, QString const &file)
	{
	return lookupFileID(getObjCache(), commit_id, file);
	}

	void BasicMainWindow::updateFilesList(QString const &id, QList<Git::Diff> diff_list, QListWidget listwidget)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	listwidget->clear();

	auto AddItem = [&](QString const &filename, QString header, int idiff){
	if (header.isEmpty()) {
	header = "(??\?) "; // damn trigraph
	}
	QListWidgetItem *item = new QListWidgetItem(filename);
	item->setData(FilePathRole, filename);
	item->setData(DiffIndexRole, idiff);
	item->setData(HunkIndexRole, -1);
	item->setData(HeaderRole, header);
	listwidget->addItem(item);
	};

	GitDiff dm(getObjCache());
	if (!dm.diff(id, diff_list)) return;

	addDiffItems(diff_list, AddItem);
	}

	void BasicMainWindow::setAppSettings(const ApplicationSettings &appsettings)
	{
	m->appsettings = appsettings;
	}

	QPixmap BasicMainWindow::getTransparentPixmap() const
	{
	return m->transparent_pixmap;
	}

	QIcon BasicMainWindow::getSignatureBadIcon() const
	{
	return m->signature_bad_icon;
	}

	QIcon BasicMainWindow::getSignatureDubiousIcon() const
	{
	return m->signature_dubious_icon;
	}

	QIcon BasicMainWindow::getSignatureGoodIcon() const
	{
	return m->signature_good_icon;
	}

	QIcon BasicMainWindow::getFolderIcon() const
	{
	return m->folder_icon;
	}

	QIcon BasicMainWindow::getRepositoryIcon() const
	{
	return m->repository_icon;
	}

	const Git::CommitItemList &BasicMainWindow::getLogs() const
	{
	return m->logs;
	}

	Git::CommitItem const *BasicMainWindow::getLog(int index) const
	{
	return (index >= 0 && index < (int)m->logs.size()) ? &m->logs[index] : nullptr;
	}

	Git::CommitItemList *BasicMainWindow::getLogsPtr()
	{
	return &m->logs;
	}

	void BasicMainWindow::setLogs(const Git::CommitItemList &logs)
	{
	m->logs = logs;
	}

	void BasicMainWindow::clearLogs()
	{
	m->logs.clear();
	}

	BasicMainWindow::PtyCondition BasicMainWindow::getPtyCondition()
	{
	return m->pty_condition;
	}

	void BasicMainWindow::setPtyUserData(QVariant const &userdata)
	{
	m->pty_process.setVariant(userdata);
	}

	void BasicMainWindow::setPtyCondition(const PtyCondition &ptyCondition)
	{
	m->pty_condition = ptyCondition;
	}


	PtyProcess *BasicMainWindow::getPtyProcess()
	{
	return &m->pty_process;
	}

	bool BasicMainWindow::getPtyProcessOk() const
	{
	return m->pty_process_ok;
	}

	void BasicMainWindow::setPtyProcessOk(bool pty_process_ok)
	{
	m->pty_process_ok = pty_process_ok;
	}

	const QList<RepositoryItem> &BasicMainWindow::getRepos() const
	{
	return m->repos;
	}

	QList<RepositoryItem> *BasicMainWindow::getReposPtr()
	{
	return &m->repos;
	}

	void BasicMainWindow::setCurrentRemoteName(QString const &name)
	{
	m->current_remote_name = name;
	}

	AvatarLoader *BasicMainWindow::getAvatarLoader()
	{
	return &m->avatar_loader;
	}

	AvatarLoader const *BasicMainWindow::getAvatarLoader() const
	{
	return &m->avatar_loader;
	}

	int *BasicMainWindow::ptrUpdateFilesListCounter()
	{
	return &m->update_files_list_counter;
	}

	int *BasicMainWindow::ptrUpdateCommitTableCounter()
	{
	return &m->update_commit_table_counter;
	}

	bool BasicMainWindow::interactionCanceled() const
	{
	return m->interaction_canceled;
	}

	void BasicMainWindow::setInteractionCanceled(bool canceled)
	{
	m->interaction_canceled = canceled;
	}

	BasicMainWindow::InteractionMode BasicMainWindow::interactionMode() const
	{
	return m->interaction_mode;
	}

	void BasicMainWindow::setInteractionMode(const InteractionMode &im)
	{
	m->interaction_mode = im;
	}

	QString BasicMainWindow::getRepositoryFilterText() const
	{
	return m->repository_filter_text;
	}

	void BasicMainWindow::setRepositoryFilterText(QString const &text)
	{
	m->repository_filter_text = text;
	}

	void BasicMainWindow::setUncommitedChanges(bool uncommited_changes)
	{
	m->uncommited_changes = uncommited_changes;
	}

	QList<Git::Diff> *BasicMainWindow::diffResult()
	{
	return &m->diff_result;
	}

	std::map<QString, Git::Diff> *BasicMainWindow::getDiffCacheMap()
	{
	return &m->diff_cache;
	}

	bool BasicMainWindow::getRemoteChanged() const
	{
	return m->remote_changed;
	}

	void BasicMainWindow::setRemoteChanged(bool remote_changed)
	{
	m->remote_changed = remote_changed;
	}

	void BasicMainWindow::setServerType(const ServerType &server_type)
	{
	m->server_type = server_type;
	}

	GitHubRepositoryInfo *BasicMainWindow::ptrGitHub()
	{
	return &m->github;
	}

	std::map<int, QList<BasicMainWindow::Label>> *BasicMainWindow::getLabelMap()
	{
	return &m->label_map;
	}

	std::map<int, QList<BasicMainWindow::Label>> const *BasicMainWindow::getLabelMap() const
	{
	return &m->label_map;
	}

	void BasicMainWindow::clearLabelMap()
	{
	m->label_map.clear();
	}

	GitObjectCache *BasicMainWindow::getObjCache()
	{
	return &m->objcache;
	}

	bool BasicMainWindow::getForceFetch() const
	{
	return m->force_fetch;
	}

	void BasicMainWindow::setForceFetch(bool force_fetch)
	{
	m->force_fetch = force_fetch;
	}

	std::map<QString, QList<Git::Tag>> *BasicMainWindow::ptrTagMap()
	{
	return &m->tag_map;
	}

	QString BasicMainWindow::getHeadId() const
	{
	return m->head_id;
	}

	void BasicMainWindow::setHeadId(QString const &head_id)
	{
	m->head_id = head_id;
	}

	void BasicMainWindow::setPtyProcessCompletionData(QVariant const &value)
	{
	m->pty_process_completion_data = value;
	}

	QVariant const &BasicMainWindow::getTempRepoForCloneCompleteV() const
	{
	return m->pty_process_completion_data;
	}

	void BasicMainWindow::updateCommitGraph()
	{
	auto const &logs = getLogs();
	auto *logsp = getLogsPtr();


	const size_t LogCount = logs.size();
	// 樹形図情報を構築する
	if (LogCount > 0) {
	auto LogItem = [&](size_t i)->Git::CommitItem &{ return logsp->at(i); };
	enum { // 有向グラフを構築するあいだ CommitItem::marker_depth をフラグとして使用する
	UNKNOWN = 0,
	KNOWN = 1,
	};
	for (Git::CommitItem &item : *logsp) {
	item.marker_depth = UNKNOWN;
	}
	// コミットハッシュを検索して、親コミットのインデックスを求める
	for (size_t i = 0; i < LogCount; i++) {
	Git::CommitItem *item = &LogItem(i);
	item->parent_lines.clear();
	if (item->parent_ids.empty()) {
	item->resolved = true;
	} else {
	for (int j = 0; j < item->parent_ids.size(); j++) { // 親の数だけループ
	QString const &parent_id = item->parent_ids[j]; // 親のハッシュ値
	for (size_t k = i + 1; k < LogCount; k++) { // 親を探す
	if (LogItem(k).commit_id == parent_id) { // ハッシュ値が一致したらそれが親
	item->parent_lines.emplace_back(k); // インデックス値を記憶
	LogItem(k).has_child = true;
	LogItem(k).marker_depth = KNOWN;
	item->resolved = true;
	break;
	}
	}
	}
	}
	}
	std::vector<Element> elements; // 線分リスト
	{ // 線分リストを作成する
	std::deque<Task> tasks; // 未処理タスクリスト
	{
	for (size_t i = 0; i < LogCount; i++) {
	Git::CommitItem *item = &LogItem(i);
	if (item->marker_depth == UNKNOWN) {
	int n = item->parent_lines.size(); // 最初のコミットアイテム
	for (int j = 0; j < n; j++) {
	tasks.emplace_back(i, j); // タスクを追加
	}
	}
	item->marker_depth = UNKNOWN;
	}
	}
	while (!tasks.empty()) { // タスクが残っているならループ
	Element e;
	Task task;
	{ // 最初のタスクを取り出す
	task = tasks.front();
	tasks.pop_front();
	}
	e.indexes.push_back(task.index); // 先頭のインデックスを追加
	int index = LogItem(task.index).parent_lines[task.parent].index; // 開始インデックス
	while (index > 0 && (size_t)index < LogCount) { // 最後に到達するまでループ
	e.indexes.push_back(index); // インデックスを追加
	int n = LogItem(index).parent_lines.size(); // 親の数
	if (n == 0) break; // 親がないなら終了
	Git::CommitItem *item = &LogItem(index);
	if (item->marker_depth == KNOWN) break; // 既知のアイテムに到達したら終了
	item->marker_depth = KNOWN; // 既知のアイテムにする
	for (int i = 1; i < n; i++) {
	tasks.emplace_back(index, i); // タスク追加
	}
	index = LogItem(index).parent_lines[0].index; // 次の親（親リストの先頭の要素）
	}
	if (e.indexes.size() >= 2) {
	elements.push_back(e);
	}
	}
	}
	// 線情報をクリア
	for (Git::CommitItem &item : *logsp) {
	item.marker_depth = -1;
	item.parent_lines.clear();
	}
	// マークと線の深さを決める
	if (!elements.empty()) {
	{ // 優先順位を調整する
	std::sort(elements.begin(), elements.end(), [](Element const &left, Element const &right){
	int i = 0;
	{ // 長いものを優先して左へ
	int l = left.indexes.back() - left.indexes.front();
	int r = right.indexes.back() - right.indexes.front();
	i = r - l; // 降順
	}
	if (i == 0) {
	// コミットが新しいものを優先して左へ
	int l = left.indexes.front();
	int r = right.indexes.front();
	i = l - r; // 昇順
	}
	return i < 0;
	});
	// 子の無いブランチ（タグ等）が複数連続しているとき、古いコミットを右に寄せる
	{
	for (size_t i = 0; i + 1 < elements.size(); i++) {
	Element *e = &elements[i];
	int index1 = e->indexes.front();
	if (index1 > 0 && !LogItem(index1).has_child) { // 子がない
	// 新しいコミットを探す
	for (size_t j = i + 1; j < elements.size(); j++) { // 現在位置より後ろを探す
	Element *f = &elements[j];
	int index2 = f->indexes.front();
	if (index1 == index2 + 1) { // 一つだけ新しいコミット
	Element t = std::move(*f);
	elements.erase(elements.begin() + j); // 移動元を削除
	elements.insert(elements.begin() + i, std::move(t)); // 現在位置に挿入
	}
	}
	// 古いコミットを探す
	size_t j = 0;
	while (j < i) { // 現在位置より前を探す
	Element *f = &elements[j];
	int index2 = f->indexes.front();
	if (index1 + 1 == index2) { // 一つだけ古いコミット
	Element t = std::move(*f);
	elements.erase(elements.begin() + j); // 移動元を削除
	elements.insert(elements.begin() + i, std::move(t)); // 現在位置の次に挿入
	index1 = index2;
	f = e;
	} else {
	j++;
	}
	}
	}
	}
	}
	}
	{ // 最初の線は深さを0にする
	Element *e = &elements.front();
	for (size_t i = 0; i < e->indexes.size(); i++) {
	int index = e->indexes[i];
	LogItem(index).marker_depth = 0; // マークの深さを設定
	e->depth = 0; // 線の深さを設定
	}
	}
	// 最初以外の線分の深さを決める
	for (size_t i = 1; i < elements.size(); i++) { // 最初以外をループ
	Element *e = &elements[i];
	int depth = 1;
	while (1) { // 失敗したら繰り返し
	for (size_t j = 0; j < i; j++) { // 既に処理済みの線を調べる
	Element const *f = &elements[j]; // 検査対象
	if (e->indexes.size() == 2) { // 二つしかない場合
	int from = e->indexes[0]; // 始点
	int to = e->indexes[1]; // 終点
	if (LogItem(from).has_child) {
	for (size_t k = 0; k + 1 < f->indexes.size(); k++) { // 検査対象の全ての線分を調べる
	int curr = f->indexes[k];
	int next = f->indexes[k + 1];
	if (from > curr && to == next) { // 決定済みの線に直結できるか判定
	e->indexes.back() = from + 1; // 現在の一行下に直結する
	e->depth = elements[j].depth; // 接続先の深さ
	goto DONE; // 決定
	}
	}
	}
	}
	if (depth == f->depth) { // 同じ深さ
	if (e->indexes.back() > f->indexes.front() && e->indexes.front() < f->indexes.back()) { // 重なっている
	goto FAIL; // この深さには線を置けないのでやりなおし
	}
	}
	}
	for (size_t j = 0; j < e->indexes.size(); j++) {
	int index = e->indexes[j];
	Git::CommitItem *item = &LogItem(index);
	if (j == 0 && item->has_child) { // 最初のポイントで子がある場合
	// nop
	} else if ((j > 0 && j + 1 < e->indexes.size()) \|\| item->marker_depth < 0) { // 最初と最後以外、または、未確定の場合
	item->marker_depth = depth; // マークの深さを設定
	}
	}
	e->depth = depth; // 深さを決定
	goto DONE; // 決定
	FAIL:;
	depth++; // 一段深くして再挑戦
	}
	DONE:;
	}
	// 線情報を生成する
	for (auto &e : elements) {
	auto ColorNumber = [&](){ return e.depth; };
	size_t count = e.indexes.size();
	for (size_t i = 0; i + 1 < count; i++) {
	int curr = e.indexes[i];
	int next = e.indexes[i + 1];
	TreeLine line(next, e.depth);
	line.color_number = ColorNumber();
	line.bend_early = (i + 2 < count \|\| !LogItem(next).resolved);
	if (i + 2 == count) {
	int join = false;
	if (count > 2) { // 直結ではない
	join = true;
	} else if (!LogItem(curr).has_child) { // 子がない
	join = true;
	int d = LogItem(curr).marker_depth; // 開始点の深さ
	for (int j = curr + 1; j < next; j++) {
	Git::CommitItem *item = &LogItem(j);
	if (item->marker_depth == d) { // 衝突する
	join = false; // 迂回する
	break;
	}
	}
	}
	if (join) {
	line.depth = LogItem(next).marker_depth; // 合流する先のアイテムの深さと同じにする
	}
	}
	LogItem(curr).parent_lines.push_back(line); // 線を追加
	}
	}
	} else {
	if (LogCount == 1) { // コミットが一つだけ
	LogItem(0).marker_depth = 0;
	}
	}
	}
	}

	bool BasicMainWindow::fetch(GitPtr const &g, bool prune)
	{
	setPtyCondition(PtyCondition::Fetch);
	setPtyProcessOk(true);
	g->fetch(getPtyProcess(), prune);
	while (1) {
	if (getPtyProcess()->wait(1)) break;
	QApplication::processEvents();
	}
	return getPtyProcessOk();
	}

	bool BasicMainWindow::fetch_tags_f(GitPtr const &g)
	{
	setPtyCondition(PtyCondition::Fetch);
	setPtyProcessOk(true);
	g->fetch_tags_f(getPtyProcess());
	while (1) {
	if (getPtyProcess()->wait(1)) break;
	QApplication::processEvents();
	}
	return getPtyProcessOk();
	}

	bool BasicMainWindow::git_callback(void cookie, const char ptr, int len)
	{
	auto mw = (BasicMainWindow )cookie;
	mw->emitWriteLog(QByteArray(ptr, len));
	return true;
	}

	QString BasicMainWindow::selectCommand_(QString const &cmdname, QStringList const &cmdfiles, QStringList const &list, QString path, std::function<void (QString const &)> const &callback)
	{
	QString window_title = tr("Select %1 command");
	window_title = window_title.arg(cmdfiles.front());

	SelectCommandDialog dlg(this, cmdname, cmdfiles, path, list);
	dlg.setWindowTitle(window_title);
	if (dlg.exec() == QDialog::Accepted) {
	path = dlg.selectedFile();
	path = misc::normalizePathSeparator(path);
	QFileInfo info(path);
	if (info.isExecutable()) {
	callback(path);
	return path;
	}
	}
	return QString();
	}

	QString BasicMainWindow::selectCommand_(QString const &cmdname, QString const &cmdfile, QStringList const &list, QString const &path, std::function<void (QString const &)> const &callback)
	{
	QStringList cmdfiles;
	cmdfiles.push_back(cmdfile);
	return selectCommand_(cmdname, cmdfiles, list, path, callback);
	}

	bool BasicMainWindow::checkGitCommand()
	{
	while (1) {
	if (misc::isExecutable(gitCommand())) {
	return true;
	}
	if (selectGitCommand(true).isEmpty()) {
	close();
	return false;
	}
	}
	}

	bool BasicMainWindow::checkFileCommand()
	{
	while (1) {
	if (misc::isExecutable(global->file_command)) {
	return true;
	}
	if (selectFileCommand(true).isEmpty()) {
	close();
	return false;
	}
	}
	}

	bool BasicMainWindow::checkExecutable(QString const &path)
	{
	if (QFileInfo(path).isExecutable()) {
	return true;
	}
	QString text = "The specified program '%1' is not executable.\n";
	text = text.arg(path);
	writeLog(text);
	return false;
	}

	-void BasicMainWindow::internalSetCommand(QString const &path, bool save, QString const &name, QString *out)
	+void BasicMainWindow::internalSaveCommandPath(QString const &path, bool save, QString const &name)
	{
	- if (!path.isEmpty() && checkExecutable(path)) {
	+ if (checkExecutable(path)) {
	if (save) {
	MySettings s;
	s.beginGroup("Global");
	s.setValue(name, path);
	s.endGroup();
	}
	- *out = path;
	- } else {
	- *out = QString();
	}
	}

	QStringList BasicMainWindow::whichCommand_(QString const &cmdfile1, QString const &cmdfile2)
	{
	QStringList list;

	if (!cmdfile1.isEmpty()){
	std::vector<std::string> vec;
	FileUtil::qwhich(cmdfile1.toStdString(), &vec);
	for (std::string const &s : vec) {
	list.push_back(QString::fromStdString(s));
	}
	}
	if (!cmdfile2.isEmpty()){
	std::vector<std::string> vec;
	FileUtil::qwhich(cmdfile2.toStdString(), &vec);
	for (std::string const &s : vec) {
	list.push_back(QString::fromStdString(s));
	}
	}

	return list;
	}

	void BasicMainWindow::setWindowTitle_(Git::User const &user)
	{
	if (user.name.isEmpty() && user.email.isEmpty()) {
	setWindowTitle(qApp->applicationName());
	} else {
	setWindowTitle(QString("%1 : %2 <%3>")
	.arg(qApp->applicationName())
	.arg(user.name)
	.arg(user.email)
	);
	}
	}

	bool BasicMainWindow::execSetGlobalUserDialog()
	{
	SetGlobalUserDialog dlg(this);
	if (dlg.exec() == QDialog::Accepted) {
	GitPtr g = git();
	Git::User user = dlg.user();
	g->setUser(user, true);
	updateWindowTitle(g);
	return true;
	}
	return false;
	}

	bool BasicMainWindow::saveByteArrayAs(const QByteArray &ba, QString const &dstpath)
	{
	QFile file(dstpath);
	if (file.open(QFile::WriteOnly)) {
	file.write(ba);
	file.close();
	return true;
	}
	QString msg = "Failed to open the file '%1' for write";
	msg = msg.arg(dstpath);
	qDebug() << msg;
	return false;
	}

	bool BasicMainWindow::saveFileAs(QString const &srcpath, QString const &dstpath)
	{
	QFile f(srcpath);
	if (f.open(QFile::ReadOnly)) {
	QByteArray ba = f.readAll();
	if (saveByteArrayAs(ba, dstpath)) {
	return true;
	}
	} else {
	QString msg = "Failed to open the file '%1' for read";
	msg = msg.arg(srcpath);
	qDebug() << msg;
	}
	return false;
	}

	bool BasicMainWindow::saveBlobAs(QString const &id, QString const &dstpath)
	{
	Git::Object obj = cat_file(id);
	if (!obj.content.isEmpty()) {
	if (saveByteArrayAs(obj.content, dstpath)) {
	return true;
	}
	} else {
	QString msg = "Failed to get the content of the object '%1'";
	msg = msg.arg(id);
	qDebug() << msg;
	}
	return false;
	}

	void BasicMainWindow::revertAllFiles()
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QString cmd = "git reset --hard HEAD";
	if (askAreYouSureYouWantToRun(tr("Revert all files"), "> " + cmd)) {
	g->resetAllFiles();
	openRepository(true);
	}
	}

	void BasicMainWindow::deleteTags(Git::CommitItem const &commit)
	{
	auto it = ptrTagMap()->find(commit.commit_id);
	if (it != ptrTagMap()->end()) {
	QStringList names;
	QList<Git::Tag> const &tags = it->second;
	for (Git::Tag const &tag : tags) {
	names.push_back(tag.name);
	}
	deleteTags(names);
	}
	}

	bool BasicMainWindow::isAvatarEnabled() const
	{
	return appsettings()->get_committer_icon;
	}

	bool BasicMainWindow::isGitHub() const
	{
	return m->server_type == ServerType::GitHub;
	}

	QStringList BasicMainWindow::remotes() const
	{
	return m->remotes;
	}

	QList<Git::Branch> BasicMainWindow::findBranch(QString const &id)
	{
	auto it = branchMapRef().find(id);
	if (it != branchMapRef().end()) {
	return it->second;
	}
	return QList<Git::Branch>();
	}

	QString BasicMainWindow::saveAsTemp(QString const &id)
	{
	QString path = newTempFilePath();
	saveAs(id, path);
	return path;
	}

	QString BasicMainWindow::tempfileHeader() const
	{
	QString name = "jp_soramimi_Guitar_%1_";
	return name.arg(QApplication::applicationPid());
	}

	void BasicMainWindow::deleteTempFiles()
	{
	QString dir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
	QString name = tempfileHeader();
	QDirIterator it(dir, { name + "*" });
	while (it.hasNext()) {
	QString path = it.next();
	QFile::remove(path);
	}
	}

	QString BasicMainWindow::getCommitIdFromTag(QString const &tag)
	{
	return getObjCache()->getCommitIdFromTag(tag);
	}

	bool BasicMainWindow::isValidRemoteURL(QString const &url, QString const &sshkey)
	{
	if (url.indexOf('\"') >= 0) {
	return false;
	}
	stopPtyProcess();
	GitPtr g = git(QString(), sshkey);
	QString cmd = "ls-remote \"%1\" HEAD";
	cmd = cmd.arg(url);
	bool f = g->git(cmd, false, false, getPtyProcess());
	{
	QTime time;
	time.start();
	while (!getPtyProcess()->wait(10)) {
	if (time.elapsed() > 10000) {
	f = false;
	break;
	}
	QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
	}
	stopPtyProcess();
	}
	if (f) {
	f = (getPtyProcess()->getExitCode() == 0);
	}
	QString line;
	{
	std::vector<char> v;
	getPtyProcess()->readResult(&v);
	if (!v.empty()) {
	line = QString::fromUtf8(&v[0], v.size()).trimmed();
	}
	}
	if (f) {
	qDebug() << "This is a valid repository.";
	int i = -1;
	for (int j = 0; j < line.size(); j++) {
	ushort c = line.utf16()[j];
	if (QChar(c).isSpace()) {
	i = j;
	break;
	}
	}
	QString head;
	if (i == GIT_ID_LENGTH) {
	QString id = line.mid(0, i);
	QString name = line.mid(i + 1).trimmed();
	qDebug() << id << name;
	if (name == "HEAD" && Git::isValidID(id)) {
	head = id;
	}
	}
	if (head.isEmpty()) {
	qDebug() << "But HEAD not found";
	}
	return true;
	}
	qDebug() << "This is not a repository.";
	return false;
	}

	QString BasicMainWindow::getObjectID(QListWidgetItem *item)
	{
	int i = indexOfDiff(item);
	if (i >= 0 && i < diffResult()->size()) {
	Git::Diff const &diff = diffResult()->at(i);
	return diff.blob.a_id;
	}
	return QString();
	}

	void BasicMainWindow::addWorkingCopyDir(QString dir, QString name, bool open)
	{
	if (dir.endsWith(".git")) {
	int i = dir.size();
	if (i > 4) {
	ushort c = dir.utf16()[i - 5];
	if (c == '/' \|\| c == '\\') {
	dir = dir.mid(0, i - 5);
	}
	}
	}

	if (!Git::isValidWorkingCopy(dir)) {
	if (QFileInfo(dir).isDir()) {
	QString text;
	text += tr("The folder is not a valid git repository.") + '\n';
	text += '\n';
	text += dir + '\n';
	text += '\n';
	text += tr("Do you want to initialize it as a git repository ?") + '\n';
	int r = QMessageBox::information(this, tr("Initialize Repository") , text, QMessageBox::Yes, QMessageBox::No);
	if (r == QMessageBox::Yes) {
	createRepository(dir);
	}
	}
	return;
	}

	if (name.isEmpty()) {
	name = makeRepositoryName(dir);
	}

	RepositoryItem item;
	item.local_dir = dir;
	item.name = name;
	saveRepositoryBookmark(item);

	if (open) {
	setCurrentRepository(item, true);
	GitPtr g = git(item.local_dir);
	openRepository_(g);
	}
	}

	QString BasicMainWindow::makeRepositoryName(QString const &loc)
	{
	int i = loc.lastIndexOf('/');
	int j = loc.lastIndexOf('\\');
	if (i < j) i = j;
	if (i >= 0) {
	i++;
	j = loc.size();
	if (loc.endsWith(".git")) {
	j -= 4;
	}
	return loc.mid(i, j - i);
	}
	return QString();
	}

	void BasicMainWindow::clearAuthentication()
	{
	clearSshAuthentication();
	m->http_uid.clear();
	m->http_pwd.clear();
	}

	void BasicMainWindow::onAvatarUpdated()
	{
	updateCommitTableLater();
	}

	QStringList BasicMainWindow::findGitObject(const QString &id) const
	{
	QStringList list;
	std::set<QString> set;
	if (Git::isValidID(id)) {
	{
	QString a = id.mid(0, 2);
	QString b = id.mid(2);
	QString dir = m->current_repo.local_dir / ".git/objects" / a;
	QDirIterator it(dir);
	while (it.hasNext()) {
	it.next();
	QFileInfo info = it.fileInfo();
	if (info.isFile()) {
	QString c = info.fileName();
	if (c.startsWith(b)) {
	set.insert(set.end(), a + c);
	}
	}
	}
	}
	{
	QString dir = m->current_repo.local_dir / ".git/objects/pack";
	QDirIterator it(dir);
	while (it.hasNext()) {
	it.next();
	QFileInfo info = it.fileInfo();
	if (info.isFile() && info.fileName().startsWith("pack-") && info.fileName().endsWith(".idx")) {
	GitPackIdxV2 idx;
	idx.parse(info.absoluteFilePath());
	idx.each([&](GitPackIdxItem const *item){
	if (item->id.startsWith(id)) {
	set.insert(item->id);
	}
	return true;
	});
	}
	}
	}
	for (QString const &s : set) {
	list.push_back(s);
	}
	}
	return list;
	}

	void BasicMainWindow::writeLog(const char *ptr, int len)
	{
	internalWriteLog(ptr, len);
	}

	void BasicMainWindow::writeLog(const QString &str)
	{
	std::string s = str.toStdString();
	writeLog(s.c_str(), s.size());
	}

	void BasicMainWindow::emitWriteLog(QByteArray const &ba)
	{
	emit signalWriteLog(ba);
	}

	void BasicMainWindow::writeLog_(QByteArray ba)
	{
	if (!ba.isEmpty()) {
	writeLog(ba.data(), ba.size());
	}
	}

	void BasicMainWindow::queryRemotes(GitPtr const &g)
	{
	if (!g) return;
	m->remotes = g->getRemotes();
	std::sort(m->remotes.begin(), m->remotes.end());
	}

	void BasicMainWindow::msgNoRepositorySelected()
	{
	QMessageBox::warning(this, qApp->applicationName(), tr("No repository selected"));
	}

	bool BasicMainWindow::runOnRepositoryDir(std::function<void (QString)> const &callback, RepositoryItem const *repo)
	{
	if (!repo) {
	repo = &m->current_repo;
	}
	QString dir = repo->local_dir;
	dir.replace('\\', '/');
	if (QFileInfo(dir).isDir()) {
	callback(dir);
	return true;
	}
	msgNoRepositorySelected();
	return false;
	}

	void BasicMainWindow::clearSshAuthentication()
	{
	m->ssh_passphrase_user.clear();
	m->ssh_passphrase_pass.clear();
	}



	QString BasicMainWindow::getFilePath(QListWidgetItem *item)
	{
	if (!item) return QString();
	return item->data(FilePathRole).toString();
	}

	bool BasicMainWindow::isGroupItem(QTreeWidgetItem *item)
	{
	if (item) {
	int index = item->data(0, IndexRole).toInt();
	if (index == GroupItem) {
	return true;
	}
	}
	return false;
	}

	int BasicMainWindow::indexOfLog(QListWidgetItem *item)
	{
	if (!item) return -1;
	return item->data(IndexRole).toInt();
	}

	int BasicMainWindow::indexOfDiff(QListWidgetItem *item)
	{
	if (!item) return -1;
	return item->data(DiffIndexRole).toInt();
	}

	int BasicMainWindow::getHunkIndex(QListWidgetItem *item)
	{
	if (!item) return -1;
	return item->data(HunkIndexRole).toInt();
	}

	void BasicMainWindow::initNetworking()
	{
	std::string http_proxy;
	std::string https_proxy;
	if (appsettings()->proxy_type == "auto") {
	#ifdef Q_OS_WIN
	http_proxy = misc::makeProxyServerURL(getWin32HttpProxy().toStdString());
	#else
	auto getienv = [](std::string const &name)->char const *{
	char **p = environ;
	while (*p) {
	if (strncasecmp(*p, name.c_str(), name.size()) == 0) {
	char const e = p + name.size();
	if (*e == '=') {
	return e + 1;
	}
	}
	p++;
	}
	return nullptr;
	};
	char const *p;
	p = getienv("http_proxy");
	if (p) {
	http_proxy = misc::makeProxyServerURL(std::string(p));
	}
	p = getienv("https_proxy");
	if (p) {
	https_proxy = misc::makeProxyServerURL(std::string(p));
	}
	#endif
	} else if (appsettings()->proxy_type == "manual") {
	http_proxy = appsettings()->proxy_server.toStdString();
	}
	webContext()->set_http_proxy(http_proxy);
	webContext()->set_https_proxy(https_proxy);
	}

	QString BasicMainWindow::abbrevCommitID(Git::CommitItem const &commit)
	{
	return commit.commit_id.mid(0, 7);
	}

	bool BasicMainWindow::saveRepositoryBookmarks() const
	{
	QString path = getBookmarksFilePath();
	return RepositoryBookmark::save(path, &getRepos());
	}

	QString BasicMainWindow::getBookmarksFilePath() const
	{
	return global->app_config_dir / "bookmarks.xml";
	}

	void BasicMainWindow::stopPtyProcess()
	{
	getPtyProcess()->stop();
	QDir::setCurrent(m->starting_dir);
	}

	void BasicMainWindow::abortPtyProcess()
	{
	stopPtyProcess();
	setPtyProcessOk(false);
	setInteractionCanceled(true);
	}

	void BasicMainWindow::saveApplicationSettings()
	{
	SettingsDialog::saveSettings(&m->appsettings);
	}

	+void BasicMainWindow::loadApplicationSettings()
	+{
	+ SettingsDialog::loadSettings(&m->appsettings);
	+}
	+
	bool BasicMainWindow::execWelcomeWizardDialog()
	{
	WelcomeWizardDialog dlg(this);
	dlg.set_git_command_path(appsettings()->git_command);
	dlg.set_file_command_path(appsettings()->file_command);
	dlg.set_default_working_folder(appsettings()->default_working_dir);
	if (misc::isExecutable(appsettings()->git_command)) {
	gitCommand() = appsettings()->git_command;
	Git g(m->gcx, {}, {});
	Git::User user = g.getUser(Git::Source::Global);
	dlg.set_user_name(user.name);
	dlg.set_user_email(user.email);
	}
	if (dlg.exec() == QDialog::Accepted) {
	- appsettings()->git_command = gitCommand() = dlg.git_command_path();
	- appsettings()->file_command = global->file_command = dlg.file_command_path();
	+ setGitCommand(dlg.git_command_path(), false);
	+ setFileCommand(dlg.file_command_path(), false);
	+// appsettings()->git_command = dlg.git_command_path();
	+ appsettings()->file_command = dlg.file_command_path();
	+// m->gcx.git_command = appsettings()->git_command;
	+ global->file_command = appsettings()->file_command;
	appsettings()->default_working_dir = dlg.default_working_folder();
	saveApplicationSettings();

	if (misc::isExecutable(appsettings()->git_command)) {
	GitPtr g = git();
	Git::User user;
	user.name = dlg.user_name();
	user.email = dlg.user_email();
	g->setUser(user, true);
	}

	return true;
	}
	return false;
	}

	void BasicMainWindow::execRepositoryPropertyDialog(RepositoryItem const &repo, bool open_repository_menu)
	{
	QString workdir = repo.local_dir;

	if (workdir.isEmpty()) {
	workdir = currentWorkingCopyDir();
	}
	QString name = repo.name;
	if (name.isEmpty()) {
	name = makeRepositoryName(workdir);
	}
	GitPtr g = git(workdir, repo.ssh_key);
	RepositoryPropertyDialog dlg(this, &m->gcx, g, repo, open_repository_menu);
	dlg.exec();
	if (dlg.isRemoteChanged()) {
	emit remoteInfoChanged();
	}
	}

	void BasicMainWindow::execSetUserDialog(Git::User const &global_user, Git::User const &repo_user, QString const &reponame)
	{
	SetUserDialog dlg(this, global_user, repo_user, reponame);
	if (dlg.exec() == QDialog::Accepted) {
	GitPtr g = git();
	Git::User user = dlg.user();
	if (dlg.isGlobalChecked()) {
	g->setUser(user, true);
	}
	if (dlg.isRepositoryChecked()) {
	g->setUser(user, false);
	}
	updateWindowTitle(g);
	}
	}

	-void BasicMainWindow::setGitCommand(QString const &path, bool save)
	+QString BasicMainWindow::executableOrEmpty(QString const &path)
	{
	- internalSetCommand(path, save, "GitCommand", &m->gcx.git_command);
	+ return checkExecutable(path) ? path : QString();
	}

	-void BasicMainWindow::setFileCommand(QString const &path, bool save)
	+void BasicMainWindow::setGitCommand(QString path, bool save)
	{
	- internalSetCommand(path, save, "FileCommand", &global->file_command);
	+ appsettings()->git_command = m->gcx.git_command = executableOrEmpty(path);
	+
	+ internalSaveCommandPath(path, save, "GitCommand");
	}

	-void BasicMainWindow::setGpgCommand(QString const &path, bool save)
	+void BasicMainWindow::setFileCommand(QString path, bool save)
	{
	- internalSetCommand(path, save, "GpgCommand", &global->gpg_command);
	+ appsettings()->file_command = global->file_command = executableOrEmpty(path);
	+
	+ internalSaveCommandPath(path, save, "FileCommand");
	+}
	+
	+void BasicMainWindow::setGpgCommand(QString path, bool save)
	+{
	+ appsettings()->gpg_command = global->gpg_command = executableOrEmpty(path);
	+
	+ internalSaveCommandPath(path, save, "GpgCommand");
	if (!global->gpg_command.isEmpty()) {
	GitPtr g = git();
	g->configGpgProgram(global->gpg_command, true);
	}
	}

	-void BasicMainWindow::setSshCommand(QString const &path, bool save)
	+void BasicMainWindow::setSshCommand(QString path, bool save)
	{
	- internalSetCommand(path, save, "SshCommand", &m->gcx.ssh_command);
	+ appsettings()->ssh_command = executableOrEmpty(path);
	+
	+ internalSaveCommandPath(path, save, "SshCommand");
	}

	void BasicMainWindow::logGitVersion()
	{
	GitPtr g = git();
	QString s = g->version();
	if (!s.isEmpty()) {
	s += '\n';
	writeLog(s);
	}
	}

	void BasicMainWindow::setUnknownRepositoryInfo()
	{
	setRepositoryInfo("---", "");

	Git g(m->gcx, {}, {});
	Git::User user = g.getUser(Git::Source::Global);
	setWindowTitle_(user);
	}

	void BasicMainWindow::internalClearRepositoryInfo()
	{
	setHeadId(QString());
	setCurrentBranch(Git::Branch());
	setServerType(ServerType::Standard);
	m->github = GitHubRepositoryInfo();
	}

	void BasicMainWindow::checkUser()
	{
	Git g(m->gcx, {}, {});
	while (1) {
	Git::User user = g.getUser(Git::Source::Global);
	if (!user.name.isEmpty() && !user.email.isEmpty()) {
	return; // ok
	}
	if (!execSetGlobalUserDialog()) {
	return;
	}
	}
	}

	void BasicMainWindow::openRepository(bool validate, bool waitcursor, bool keep_selection)
	{
	if (validate) {
	QString dir = currentWorkingCopyDir();
	if (!QFileInfo(dir).isDir()) {
	int r = QMessageBox::warning(this, tr("Open Repository"), dir + "\n\n" + tr("No such folder") + "\n\n" + tr("Remove from bookmark ?"), QMessageBox::Ok, QMessageBox::Cancel);
	if (r == QMessageBox::Ok) {
	removeSelectedRepositoryFromBookmark(false);
	}
	return;
	}
	if (!Git::isValidWorkingCopy(dir)) {
	QMessageBox::warning(this, tr("Open Repository"), tr("Not a valid git repository") + "\n\n" + dir);
	return;
	}
	}

	if (waitcursor) {
	OverrideWaitCursor;
	openRepository(false, false, keep_selection);
	return;
	}

	GitPtr g = git(); // ポインタの有効性チェックはしない（nullptrでも続行）
	openRepository_(g, keep_selection);
	}

	void BasicMainWindow::updateRepository()
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	OverrideWaitCursor;
	openRepository_(g);
	}

	void BasicMainWindow::reopenRepository(bool log, std::function<void(GitPtr const &)> const &callback)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	setRemoteMonitoringEnabled(false);

	OverrideWaitCursor;
	if (log) {
	setLogEnabled(g, true);
	AsyncExecGitThread_ th(g, callback);
	th.start();
	while (1) {
	if (th.wait(1)) break;
	QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
	}
	setLogEnabled(g, false);
	} else {
	callback(g);
	}
	openRepository_(g);

	setRemoteMonitoringEnabled(true);
	}

	void BasicMainWindow::openSelectedRepository()
	{
	RepositoryItem const *repo = selectedRepositoryItem();
	if (repo) {
	setCurrentRepository(*repo, true);
	openRepository(true);
	}
	}

	//void BasicMainWindow::checkRemoteUpdate()
	//{
	// if (getPtyProcess()->isRunning()) return;

	// emit signalCheckRemoteUpdate();
	//}

	bool BasicMainWindow::isThereUncommitedChanges() const
	{
	return m->uncommited_changes;
	}

	bool BasicMainWindow::makeDiff(QString id, QList<Git::Diff> *out)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return false;

	Git::FileStatusList list = g->status_s();
	setUncommitedChanges(!list.empty());

	if (id.isEmpty() && !isThereUncommitedChanges()) {
	id = getObjCache()->revParse("HEAD");
	}

	bool uncommited = (id.isEmpty() && isThereUncommitedChanges());

	GitDiff dm(getObjCache());
	if (uncommited) {
	dm.diff_uncommited(out);
	} else {
	dm.diff(id, out);
	}

	return true; // success
	}

	void BasicMainWindow::addDiffItems(const QList<Git::Diff> *diff_list, const std::function<void (QString const &, QString, int)> &add_item)
	{
	for (int idiff = 0; idiff < diff_list->size(); idiff++) {
	Git::Diff const &diff = diff_list->at(idiff);
	QString header;

	switch (diff.type) {
	case Git::Diff::Type::Modify: header = "(chg) "; break;
	case Git::Diff::Type::Copy: header = "(cpy) "; break;
	case Git::Diff::Type::Rename: header = "(ren) "; break;
	case Git::Diff::Type::Create: header = "(add) "; break;
	case Git::Diff::Type::Delete: header = "(del) "; break;
	case Git::Diff::Type::ChType: header = "(chg) "; break;
	case Git::Diff::Type::Unmerged: header = "(unmerged) "; break;
	}

	add_item(diff.path, header, idiff);
	}
	}

	Git::CommitItemList BasicMainWindow::retrieveCommitLog(GitPtr const &g)
	{
	Git::CommitItemList list = g->log(limitLogCount());

	// 親子関係を調べて、順番が狂っていたら、修正する。

	std::set<QString> set;

	const size_t count = list.size();
	size_t limit = count;

	size_t i = 0;
	while (i < count) {
	size_t newpos = -1;
	for (QString const &parent : list[i].parent_ids) {
	if (set.find(parent) != set.end()) {
	for (size_t j = 0; j < i; j++) {
	if (parent == list[j].commit_id) {
	if (newpos == (size_t)-1 \|\| j < newpos) {
	newpos = j;
	}
	qDebug() << "fix commit order" << list[i].commit_id;
	break;
	}
	}
	}
	}
	set.insert(set.end(), list[i].commit_id);
	if (newpos != (size_t)-1) {
	if (limit == 0) break; // まず無いと思うが、もし、無限ループに陥ったら
	Git::CommitItem t = list[i];
	t.strange_date = true;
	list.erase(list.begin() + i);
	list.insert(list.begin() + newpos, t);
	i = newpos;
	limit--;
	}
	i++;
	}

	return list;
	}

	void BasicMainWindow::queryBranches(GitPtr const &g)
	{
	Q_ASSERT(g);
	m->branch_map.clear();
	QList<Git::Branch> branches = g->branches();
	for (Git::Branch const &b : branches) {
	if (b.isCurrent()) {
	setCurrentBranch(b);
	}
	branchMapRef()[b.id].append(b);
	}
	}

	std::map<QString, QList<Git::Branch>> &BasicMainWindow::branchMapRef()
	{
	return m->branch_map;
	}

	void BasicMainWindow::updateCommitTableLater()
	{
	*ptrUpdateCommitTableCounter() = 200;
	}

	void BasicMainWindow::updateRemoteInfo()
	{
	queryRemotes(git());

	m->current_remote_name = QString();
	{
	Git::Branch const &r = currentBranch();
	m->current_remote_name = r.remote;
	}
	if (m->current_remote_name.isEmpty()) {
	if (m->remotes.size() == 1) {
	m->current_remote_name = m->remotes[0];
	}
	}

	emit remoteInfoChanged();
	}

	void BasicMainWindow::updateWindowTitle(GitPtr const &g)
	{
	if (isValidWorkingCopy(g)) {
	Git::User user = g->getUser(Git::Source::Default);
	setWindowTitle_(user);
	} else {
	setUnknownRepositoryInfo();
	}
	}

	QString BasicMainWindow::makeCommitInfoText(int row, QList<BasicMainWindow::Label> *label_list)
	{
	QString message_ex;
	Git::CommitItem const *commit = &getLogs()[row];
	{ // branch
	if (label_list) {
	if (commit->commit_id == getHeadId()) {
	Label label(Label::Head);
	label.text = "HEAD";
	label_list->push_back(label);
	}
	}
	QList<Git::Branch> list = findBranch(commit->commit_id);
	for (Git::Branch const &b : list) {
	if (b.flags & Git::Branch::HeadDetachedAt) continue;
	if (b.flags & Git::Branch::HeadDetachedFrom) continue;
	Label label(Label::LocalBranch);
	label.text = b.name;
	if (!b.remote.isEmpty()) {
	label.kind = Label::RemoteBranch;
	label.text = "remotes" / b.remote / label.text;
	}
	if (b.ahead > 0) {
	label.info += tr(", %1 ahead").arg(b.ahead);
	}
	if (b.behind > 0) {
	label.info += tr(", %1 behind").arg(b.behind);
	}
	message_ex += " {" + label.text + label.info + '}';
	if (label_list) label_list->push_back(label);
	}
	}
	{ // tag
	QList<Git::Tag> list = findTag(commit->commit_id);
	for (Git::Tag const &t : list) {
	Label label(Label::Tag);
	label.text = t.name;
	message_ex += QString(" {#%1}").arg(label.text);
	if (label_list) label_list->push_back(label);
	}
	}
	return message_ex;
	}

	void BasicMainWindow::removeRepositoryFromBookmark(int index, bool ask)
	{
	if (ask) {
	int r = QMessageBox::warning(this, tr("Confirm Remove"), tr("Are you sure you want to remove the repository from bookmarks ?") + '\n' + tr("(Files will NOT be deleted)"), QMessageBox::Ok, QMessageBox::Cancel);
	if (r != QMessageBox::Ok) return;
	}
	auto *repos = getReposPtr();
	if (index >= 0 && index < repos->size()) {
	repos->erase(repos->begin() + index);
	saveRepositoryBookmarks();
	updateRepositoriesList();
	}
	}

	void BasicMainWindow::clone(QString url, QString dir)
	{
	if (!isOnlineMode()) return;

	if (dir.isEmpty()) {
	dir = defaultWorkingDir();
	}

	while (1) {
	QString ssh_key;
	CloneDialog dlg(this, url, dir, &m->gcx);
	if (dlg.exec() != QDialog::Accepted) {
	return;
	}
	const CloneDialog::Action action = dlg.action();
	url = dlg.url();
	dir = dlg.dir();
	ssh_key = dlg.overridedSshKey();

	RepositoryItem repos_item_data;
	repos_item_data.local_dir = dir;
	repos_item_data.local_dir.replace('\\', '/');
	repos_item_data.name = makeRepositoryName(dir);
	repos_item_data.ssh_key = ssh_key;

	// クローン先ディレクトリを求める

	Git::CloneData clone_data = Git::preclone(url, dir);

	if (action == CloneDialog::Action::Clone) {
	// 既存チェック

	QFileInfo info(dir);
	if (info.isFile()) {
	QString msg = dir + "\n\n" + tr("A file with same name already exists");
	QMessageBox::warning(this, tr("Clone"), msg);
	continue;
	}
	if (info.isDir()) {
	QString msg = dir + "\n\n" + tr("A folder with same name already exists");
	QMessageBox::warning(this, tr("Clone"), msg);
	continue;
	}

	// クローン先ディレクトリの存在チェック

	QString basedir = misc::normalizePathSeparator(clone_data.basedir);
	if (!QFileInfo(basedir).isDir()) {
	int i = basedir.indexOf('/');
	int j = basedir.indexOf('\\');
	if (i < j) i = j;
	if (i < 0) {
	QString msg = basedir + "\n\n" + tr("Invalid folder");
	QMessageBox::warning(this, tr("Clone"), msg);
	continue;
	}

	QString msg = basedir + "\n\n" + tr("No such folder. Create it now ?");
	if (QMessageBox::warning(this, tr("Clone"), msg, QMessageBox::Ok, QMessageBox::Cancel) != QMessageBox::Ok) {
	continue;
	}

	// ディレクトリを作成

	QString base = basedir.mid(0, i + 1);
	QString sub = basedir.mid(i + 1);
	QDir(base).mkpath(sub);
	}

	GitPtr g = git(QString(), repos_item_data.ssh_key);
	setPtyUserData(QVariant::fromValue<RepositoryItem>(repos_item_data));
	setPtyCondition(PtyCondition::Clone);
	setPtyProcessOk(true);
	g->clone(clone_data, getPtyProcess());
	} else if (action == CloneDialog::Action::AddExisting) {
	addWorkingCopyDir(dir, true);
	}

	return; // done
	}
	}

	void BasicMainWindow::submodule_add(QString url, QString dir)
	{
	if (!isOnlineMode()) return;

	if (dir.isEmpty()) {
	dir = defaultWorkingDir();
	}

	while (1) {
	SubmoduleAddDialog dlg(this, url, dir, &m->gcx);
	if (dlg.exec() != QDialog::Accepted) {
	return;
	}
	url = dlg.url();
	dir = dlg.dir();
	const QString ssh_key = dlg.overridedSshKey();

	RepositoryItem repos_item_data;
	repos_item_data.local_dir = dir;
	repos_item_data.local_dir.replace('\\', '/');
	repos_item_data.name = makeRepositoryName(dir);
	repos_item_data.ssh_key = ssh_key;

	// クローン先ディレクトリを求める

	Git::CloneData clone_data = Git::preclone(url, dir);

	GitPtr g = git(QString(), repos_item_data.ssh_key);
	g->submodule_add(clone_data, getPtyProcess());

	return; // done
	}
	}

	void BasicMainWindow::checkout()
	{
	checkout(this, selectedCommitItem());
	}

	void BasicMainWindow::commit(bool amend)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QString message;
	QString previousMessage;

	if (amend) {
	message = getLogs()[0].message;
	} else {
	QString id = g->getCherryPicking();
	if (Git::isValidID(id)) {
	message = g->getMessage(id);
	} else {
	for (Git::CommitItem const &item : getLogs()) {
	if (!item.commit_id.isEmpty()) {
	previousMessage = item.message;
	break;
	}
	}
	}
	}

	while (1) {
	Git::User user = g->getUser(Git::Source::Default);
	QString sign_id = g->signingKey(Git::Source::Default);
	gpg::Data key;
	{
	QList<gpg::Data> keys;
	gpg::listKeys(global->gpg_command, &keys);
	for (gpg::Data const &k : keys) {
	if (k.id == sign_id) {
	key = k;
	}
	}
	}
	CommitDialog dlg(this, currentRepositoryName(), user, key, previousMessage);
	dlg.setText(message);
	if (dlg.exec() == QDialog::Accepted) {
	QString text = dlg.text();
	if (text.isEmpty()) {
	QMessageBox::warning(this, tr("Commit"), tr("Commit message can not be omitted."));
	continue;
	}
	bool sign = dlg.isSigningEnabled();
	bool ok;
	if (amend \|\| dlg.isAmend()) {
	ok = g->commit_amend_m(text, sign, getPtyProcess());
	} else {
	ok = g->commit(text, sign, getPtyProcess());
	}
	if (ok) {
	setForceFetch(true);
	updateStatusBarText();
	openRepository(true);
	} else {
	QString err = g->errorMessage().trimmed();
	err += "\n*** ";
	err += tr("Failed to commit");
	err += " ***\n";
	writeLog(err);
	}
	}
	break;
	}
	}

	void BasicMainWindow::commitAmend()
	{
	commit(true);
	}

	void BasicMainWindow::pushSetUpstream(QString const &remote, QString const &branch)
	{
	if (remote.isEmpty()) return;
	if (branch.isEmpty()) return;

	int exitcode = 0;
	QString errormsg;

	reopenRepository(true, [&](GitPtr g){
	g->push_u(remote, branch, getPtyProcess());
	while (1) {
	if (getPtyProcess()->wait(1)) break;
	QApplication::processEvents();
	}
	exitcode = getPtyProcess()->getExitCode();
	errormsg = getPtyProcess()->getMessage();
	});

	if (exitcode == 128) {
	if (errormsg.indexOf("Connection refused") >= 0) {
	QMessageBox::critical(this, qApp->applicationName(), tr("Connection refused."));
	return;
	}
	}

	updateRemoteInfo();
	}

	bool BasicMainWindow::pushSetUpstream(bool testonly)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return false;
	QStringList remotes = g->getRemotes();

	QString current_branch = currentBranchName();

	QStringList branches;
	for (Git::Branch const &b : g->branches()) {
	branches.push_back(b.name);
	}

	if (remotes.isEmpty() \|\| branches.isEmpty()) {
	return false;
	}

	if (testonly) {
	return true;
	}

	PushDialog dlg(this, remotes, branches, PushDialog::RemoteBranch(QString(), current_branch));
	if (dlg.exec() == QDialog::Accepted) {
	PushDialog::Action a = dlg.action();
	if (a == PushDialog::PushSimple) {
	push();
	} else if (a == PushDialog::PushSetUpstream) {
	QString remote = dlg.remote();
	QString branch = dlg.branch();
	pushSetUpstream(remote, branch);
	}
	return true;
	}

	return false;
	}

	void BasicMainWindow::push()
	{
	if (!isOnlineMode()) return;

	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	if (g->getRemotes().isEmpty()) {
	QMessageBox::warning(this, qApp->applicationName(), tr("No remote repository is registered."));
	RepositoryItem const &repo = currentRepository();
	execRepositoryPropertyDialog(repo, true);
	return;
	}

	int exitcode = 0;
	QString errormsg;

	reopenRepository(true, [&](GitPtr g){
	g->push(false, getPtyProcess());
	while (1) {
	if (getPtyProcess()->wait(1)) break;
	QApplication::processEvents();
	}
	exitcode = getPtyProcess()->getExitCode();
	errormsg = getPtyProcess()->getMessage();
	});

	if (exitcode == 128) {
	if (errormsg.indexOf("no upstream branch") >= 0) {
	QString brname = currentBranchName();

	QString msg = tr("The current branch %1 has no upstream branch.");
	msg = msg.arg(brname);
	msg += '\n';
	msg += tr("You try push --set-upstream");
	QMessageBox::warning(this, qApp->applicationName(), msg);
	pushSetUpstream(false);
	return;
	}
	if (errormsg.indexOf("Connection refused") >= 0) {
	QMessageBox::critical(this, qApp->applicationName(), tr("Connection refused."));
	return;
	}
	}
	}

	#ifdef Q_OS_MAC
	namespace {

	bool isValidDir(QString const &dir)
	{
	if (dir.indexOf('\"') >= 0 \|\| dir.indexOf('\\') >= 0) return false;
	return QFileInfo(dir).isDir();
	}

	}

	#include <QProcess>
	#endif

	void BasicMainWindow::openTerminal(RepositoryItem const *repo)
	{
	runOnRepositoryDir([](QString dir){
	#ifdef Q_OS_MAC
	if (!isValidDir(dir)) return;
	QString cmd = "open -n -a /Applications/Utilities/Terminal.app --args \"%1\"";
	cmd = cmd.arg(dir);
	QProcess::execute(cmd);
	#else
	Terminal::open(dir);
	#endif
	}, repo);
	}

	void BasicMainWindow::openExplorer(RepositoryItem const *repo)
	{
	runOnRepositoryDir([](QString dir){
	#ifdef Q_OS_MAC
	if (!isValidDir(dir)) return;
	QString cmd = "open \"%1\"";
	cmd = cmd.arg(dir);
	QProcess::execute(cmd);
	#else
	QDesktopServices::openUrl(dir);
	#endif
	}, repo);
	}

	Git::CommitItem const *BasicMainWindow::selectedCommitItem() const
	{
	int i = selectedLogIndex();
	return commitItem(i);
	}

	void BasicMainWindow::deleteBranch(Git::CommitItem const *commit)
	{
	if (!commit) return;

	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QStringList all_branch_names;
	QStringList current_local_branch_names;
	{
	NamedCommitList named_commits = namedCommitItems(Branches);
	for (NamedCommitItem const &item : named_commits) {
	if (item.name == "HEAD") continue;
	if (item.id == commit->commit_id) {
	current_local_branch_names.push_back(item.name);
	}
	all_branch_names.push_back(item.name);
	}
	}

	DeleteBranchDialog dlg(this, false, all_branch_names, current_local_branch_names);
	if (dlg.exec() == QDialog::Accepted) {
	setLogEnabled(g, true);
	QStringList names = dlg.selectedBranchNames();
	int count = 0;
	for (QString const &name : names) {
	if (g->git(QString("branch -D \"%1\"").arg(name))) {
	count++;
	} else {
	writeLog(tr("Failed to delete the branch '%1'").arg(name) + '\n');
	}
	}
	if (count > 0) {
	openRepository(true, true, true);
	}
	}
	}

	void BasicMainWindow::deleteBranch()
	{
	deleteBranch(selectedCommitItem());
	}

	QStringList MainWindow::remoteBranches(QString const &id, QStringList *all)
	{
	if (all) all->clear();

	QStringList list;

	GitPtr g = git();
	if (isValidWorkingCopy(g)) {
	NamedCommitList named_commits = namedCommitItems(Branches \| Remotes);
	for (NamedCommitItem const &item : named_commits) {
	if (item.id == id && !item.remote.isEmpty()) {
	list.push_back(item.remote / item.name);
	}
	if (all && !item.remote.isEmpty() && item.name != "HEAD") {
	all->push_back(item.remote / item.name);
	}
	}
	}

	return list;
	}

	void MainWindow::deleteRemoteBranch(Git::CommitItem const *commit)
	{
	if (!commit) return;

	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QStringList all_branches;
	QStringList remote_branches = remoteBranches(commit->commit_id, &all_branches);
	if (remote_branches.isEmpty()) return;

	DeleteBranchDialog dlg(this, true, all_branches, remote_branches);
	if (dlg.exec() == QDialog::Accepted) {
	setLogEnabled(g, true);
	QStringList names = dlg.selectedBranchNames();
	for (QString const &name : names) {
	int i = name.indexOf('/');
	if (i > 0) {
	QString remote = name.mid(0, i);
	QString branch = ':' + name.mid(i + 1);
	pushSetUpstream(remote, branch);
	}
	}
	}
	}

	bool BasicMainWindow::askAreYouSureYouWantToRun(QString const &title, QString const &command)
	{
	QString message = tr("Are you sure you want to run the following command ?");
	QString text = "%1\n\n%2";
	text = text.arg(message).arg(command);
	return QMessageBox::warning(this, title, text, QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok;
	}

	bool BasicMainWindow::editFile(QString const &path, QString const &title)
	{
	return TextEditDialog::editFile(this, path, title);
	}

	void BasicMainWindow::resetFile(QStringList const &paths)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	if (paths.isEmpty()) {
	// nop
	} else {
	QString cmd = "git checkout -- \"%1\"";
	cmd = cmd.arg(paths[0]);
	if (askAreYouSureYouWantToRun(tr("Reset a file"), "> " + cmd)) {
	for (QString const &path : paths) {
	g->resetFile(path);
	}
	openRepository(true);
	}
	}
	}

	void BasicMainWindow::saveRepositoryBookmark(RepositoryItem item)
	{
	if (item.local_dir.isEmpty()) return;

	if (item.name.isEmpty()) {
	item.name = tr("Unnamed");
	}

	auto *repos = getReposPtr();

	bool done = false;
	for (auto &repo : *repos) {
	RepositoryItem *p = &repo;
	if (item.local_dir == p->local_dir) {
	*p = item;
	done = true;
	break;
	}
	}
	if (!done) {
	repos->push_back(item);
	}
	saveRepositoryBookmarks();
	updateRepositoriesList();
	}

	void BasicMainWindow::setCurrentRepository(RepositoryItem const &repo, bool clear_authentication)
	{
	if (clear_authentication) {
	clearAuthentication();
	}
	m->current_repo = repo;
	}

	void BasicMainWindow::internalDeleteTags(QStringList const &tagnames)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	if (!tagnames.isEmpty()) {
	reopenRepository(false, [&](GitPtr g){
	for (QString const &name : tagnames) {
	g->delete_tag(name, true);
	}
	});
	}
	}

	bool BasicMainWindow::internalAddTag(QString const &name)
	{
	if (name.isEmpty()) return false;

	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return false;

	QString commit_id;

	Git::CommitItem const *commit = selectedCommitItem();
	if (commit && !commit->commit_id.isEmpty()) {
	commit_id = commit->commit_id;
	}

	if (!Git::isValidID(commit_id)) return false;

	bool ok = false;
	reopenRepository(false, [&](GitPtr g){
	ok = g->tag(name, commit_id);
	});

	return ok;
	}

	NamedCommitList BasicMainWindow::namedCommitItems(int flags)
	{
	NamedCommitList items;
	if (flags & Branches) {
	for (auto const &pair: branchMapRef()) {
	QList<Git::Branch> const &list = pair.second;
	for (Git::Branch const &b : list) {
	if (b.isHeadDetached()) continue;
	if (flags & NamedCommitFlag::Remotes) {
	// nop
	} else {
	if (!b.remote.isEmpty()) continue;
	}
	NamedCommitItem item;
	if (b.remote.isEmpty()) {
	if (b.name == "HEAD") {
	item.type = NamedCommitItem::Type::None;
	} else {
	item.type = NamedCommitItem::Type::BranchLocal;
	}
	} else {
	item.type = NamedCommitItem::Type::BranchRemote;
	item.remote = b.remote;
	}
	item.name = b.name;
	item.id = b.id;
	items.push_back(item);
	}
	}
	}
	if (flags & Tags) {
	for (auto const &pair: *ptrTagMap()) {
	QList<Git::Tag> const &list = pair.second;
	for (Git::Tag const &t : list) {
	NamedCommitItem item;
	item.type = NamedCommitItem::Type::Tag;
	item.name = t.name;
	item.id = t.id;
	if (item.name.startsWith("refs/tags/")) {
	item.name = item.name.mid(10);
	}
	items.push_back(item);
	}
	}
	}
	return items;
	}

	int BasicMainWindow::rowFromCommitId(QString const &id)
	{
	auto const &logs = getLogs();
	for (size_t i = 0; i < logs.size(); i++) {
	Git::CommitItem const &item = logs[i];
	if (item.commit_id == id) {
	return (int)i;
	}
	}
	return -1;
	}

	void BasicMainWindow::createRepository(QString const &dir)
	{
	CreateRepositoryDialog dlg(this, dir);
	if (dlg.exec() == QDialog::Accepted) {
	QString path = dlg.path();
	if (QFileInfo(path).isDir()) {
	if (Git::isValidWorkingCopy(path)) {
	// A valid git repository already exists there.
	} else {
	GitPtr g = git(path);
	if (g->init()) {
	QString name = dlg.name();
	if (!name.isEmpty()) {
	addWorkingCopyDir(path, name, true);
	}
	QString remote_name = dlg.remoteName();
	QString remote_url = dlg.remoteURL();
	if (!remote_name.isEmpty() && !remote_url.isEmpty()) {
	Git::Remote r;
	r.name = remote_name;
	r.url = remote_url;
	g->addRemoteURL(r);
	}
	}
	}
	} else {
	// not dir
	}
	}
	}

	void BasicMainWindow::setLogEnabled(GitPtr const &g, bool f)
	{
	if (f) {
	g->setLogCallback(git_callback, this);
	} else {
	g->setLogCallback(nullptr, nullptr);
	}
	}

	QList<Git::Tag> BasicMainWindow::findTag(QString const &id)
	{
	auto it = ptrTagMap()->find(id);
	if (it != ptrTagMap()->end()) {
	return it->second;
	}
	return QList<Git::Tag>();
	}

	void BasicMainWindow::sshSetPassphrase(std::string const &user, std::string const &pass)
	{
	m->ssh_passphrase_user = user;
	m->ssh_passphrase_pass = pass;
	}

	std::string BasicMainWindow::sshPassphraseUser() const
	{
	return m->ssh_passphrase_user;
	}

	std::string BasicMainWindow::sshPassphrasePass() const
	{
	return m->ssh_passphrase_pass;
	}

	void BasicMainWindow::httpSetAuthentication(std::string const &user, std::string const &pass)
	{
	m->http_uid = user;
	m->http_pwd = pass;
	}

	std::string BasicMainWindow::httpAuthenticationUser() const
	{
	return m->http_uid;
	}

	std::string BasicMainWindow::httpAuthenticationPass() const
	{
	return m->http_pwd;
	}

	void BasicMainWindow::doGitCommand(std::function<void(GitPtr g)> const &callback)
	{
	GitPtr g = git();
	if (isValidWorkingCopy(g)) {
	OverrideWaitCursor;
	callback(g);
	openRepository(false, false);
	}
	}







	diff --git a/src/BasicMainWindow.h b/src/BasicMainWindow.h
	index bf2d32b..4404d21 100644
	--- a/src/BasicMainWindow.h
	+++ b/src/BasicMainWindow.h
	@@ -1,398 +1,400 @@
	#ifndef BASICMAINWINDOW_H
	#define BASICMAINWINDOW_H

	#include "Git.h"
	#include "GitObjectManager.h"
	#include "MyProcess.h"
	#include "RepositoryData.h"
	#include "TextEditorTheme.h"
	#include <QMainWindow>
	#include <functional>

	class ApplicationSettings;
	class AvatarLoader;
	class QListWidget;
	class QListWidgetItem;
	class QTreeWidgetItem;
	class WebContext;

	struct GitHubRepositoryInfo {
	QString owner_account_name;
	QString repository_name;
	};

	#define PATH_PREFIX "*"

	class BasicMainWindow : public QMainWindow {
	Q_OBJECT
	friend class RepositoryPropertyDialog;
	public:
	struct Label {
	enum {
	Head,
	LocalBranch,
	RemoteBranch,
	Tag,
	};
	int kind;
	QString text;
	QString info;
	Label(int kind = LocalBranch)
	: kind(kind)
	{

	}
	};
	enum {
	IndexRole = Qt::UserRole,
	FilePathRole,
	DiffIndexRole,
	HunkIndexRole,
	HeaderRole,
	};
	enum CloneOperation {
	Clone,
	SubmoduleAdd,
	};

	protected:

	enum class PtyCondition {
	None,
	Clone,
	Fetch,
	Pull,
	Push,
	};

	enum InteractionMode {
	None,
	Busy,
	};

	enum NamedCommitFlag {
	Branches = 0x0001,
	Tags = 0x0002,
	Remotes = 0x0100,
	};

	enum class FilesListType {
	SingleList,
	SideBySide,
	};

	struct Task {
	int index = 0;
	int parent = 0;
	Task() = default;
	Task(int index, int parent)
	: index(index)
	, parent(parent)
	{
	}
	};

	struct Element {
	int depth = 0;
	std::vector<int> indexes;
	};


	enum {
	GroupItem = -1,
	};

	struct Private;
	Private *m;
	private:
	static bool git_callback(void cookie, const char ptr, int len);

	QString selectCommand_(QString const &cmdname, QStringList const &cmdfiles, QStringList const &list, QString path, std::function<void (QString const &)> const &callback);
	QString selectCommand_(QString const &cmdname, QString const &cmdfile, QStringList const &list, QString const &path, std::function<void (QString const &)> const &callback);

	bool checkGitCommand();
	bool checkFileCommand();
	bool checkExecutable(QString const &path);
	- void internalSetCommand(QString const &path, bool save, QString const &name, QString *out);
	+ void internalSaveCommandPath(QString const &path, bool save, QString const &name);
	QStringList whichCommand_(QString const &cmdfile1, QString const &cmdfile2 = QString());

	void setWindowTitle_(Git::User const &user);
	bool execSetGlobalUserDialog();

	bool saveByteArrayAs(const QByteArray &ba, QString const &dstpath);
	bool saveFileAs(QString const &srcpath, QString const &dstpath);
	bool saveBlobAs(QString const &id, QString const &dstpath);

	void updateFilesList(Git::CommitItem const &commit, bool wait);

	void revertAllFiles();

	void setCurrentRemoteName(QString const &name);

	void deleteTags(Git::CommitItem const &commit);

	bool isAvatarEnabled() const;
	bool isGitHub() const;
	QStringList remotes() const;
	QList<Git::Branch> findBranch(QString const &id);
	QString saveAsTemp(QString const &id);
	QString tempfileHeader() const;
	void deleteTempFiles();
	QString getCommitIdFromTag(QString const &tag);
	bool isValidRemoteURL(QString const &url, const QString &sshkey);
	QString getObjectID(QListWidgetItem *item);
	void addWorkingCopyDir(QString dir, QString name, bool open);
	static QString makeRepositoryName(QString const &loc);
	void clearAuthentication();
	RepositoryItem const findRegisteredRepository(QString workdir) const;
	void queryRemotes(const GitPtr &g);
	bool runOnRepositoryDir(std::function<void (QString)> const &callback, RepositoryItem const *repo);
	void clearSshAuthentication();
	+ QString executableOrEmpty(const QString &path);
	protected:
	static QString getFilePath(QListWidgetItem *item);
	static bool isGroupItem(QTreeWidgetItem *item);
	static int indexOfLog(QListWidgetItem *item);
	static int indexOfDiff(QListWidgetItem *item);
	static int getHunkIndex(QListWidgetItem *item);

	void initNetworking();
	bool saveRepositoryBookmarks() const;
	QString getBookmarksFilePath() const;

	void stopPtyProcess();
	void abortPtyProcess();

	bool execWelcomeWizardDialog();
	void execRepositoryPropertyDialog(const RepositoryItem &repo, bool open_repository_menu = false);
	void execSetUserDialog(Git::User const &global_user, Git::User const &repo_user, QString const &reponame);
	- void setGitCommand(QString const &path, bool save);
	- void setFileCommand(QString const &path, bool save);
	- void setGpgCommand(QString const &path, bool save);
	- void setSshCommand(QString const &path, bool save);
	+ void setGitCommand(QString path, bool save);
	+ void setFileCommand(QString path, bool save);
	+ void setGpgCommand(QString path, bool save);
	+ void setSshCommand(QString path, bool save);
	void logGitVersion();
	void setUnknownRepositoryInfo();
	void internalClearRepositoryInfo();
	void checkUser();
	void openRepository(bool validate, bool waitcursor = true, bool keep_selection = false);
	void updateRepository();
	void reopenRepository(bool log, const std::function<void(GitPtr const &)> &callback);
	void openSelectedRepository();
	// void checkRemoteUpdate();
	bool isThereUncommitedChanges() const;
	bool makeDiff(QString id, QList<Git::Diff> *out);
	void addDiffItems(const QList<Git::Diff> *diff_list, const std::function<void (QString const &, QString, int)> &add_item);
	Git::CommitItemList retrieveCommitLog(const GitPtr &g);

	void queryBranches(const GitPtr &g);
	std::map<QString, QList<Git::Branch>> &branchMapRef();

	void updateCommitTableLater();
	void updateRemoteInfo();
	void updateWindowTitle(const GitPtr &g);
	QString makeCommitInfoText(int row, QList<Label> *label_list);
	void removeRepositoryFromBookmark(int index, bool ask);

	void clone(QString url = {}, QString dir = {});
	void submodule_add(QString url = {}, QString dir = {});
	void checkout();
	void commit(bool amend = false);
	void commitAmend();
	void pushSetUpstream(QString const &remote, QString const &branch);
	bool pushSetUpstream(bool testonly);
	void push();

	void openTerminal(RepositoryItem const *repo);
	void openExplorer(RepositoryItem const *repo);
	Git::CommitItem const *selectedCommitItem() const;
	void deleteBranch(Git::CommitItem const *commit);
	void deleteBranch();
	bool askAreYouSureYouWantToRun(QString const &title, QString const &command);
	bool editFile(QString const &path, QString const &title);
	void resetFile(QStringList const &paths);
	void saveRepositoryBookmark(RepositoryItem item);
	void setCurrentRepository(RepositoryItem const &repo, bool clear_authentication);
	void internalDeleteTags(QStringList const &tagnames);
	bool internalAddTag(QString const &name);
	NamedCommitList namedCommitItems(int flags);
	int rowFromCommitId(QString const &id);
	void createRepository(QString const &dir);
	void setLogEnabled(const GitPtr &g, bool f);
	QList<Git::Tag> findTag(QString const &id);
	void sshSetPassphrase(std::string const &user, std::string const &pass);
	std::string sshPassphraseUser() const;
	std::string sshPassphrasePass() const;
	void httpSetAuthentication(std::string const &user, std::string const &pass);
	std::string httpAuthenticationUser() const;
	std::string httpAuthenticationPass() const;
	public:
	Git::CommitItemList const &getLogs() const;
	Git::CommitItem const *getLog(int index) const;
	protected:
	bool event(QEvent *event) override;
	void postUserFunctionEvent(const std::function<void(QVariant const &)> &fn, QVariant const &v = QVariant());

	void doGitCommand(std::function<void(GitPtr)> const &callback);

	Git::CommitItemList *getLogsPtr();
	void setLogs(const Git::CommitItemList &logs);
	void clearLogs();

	PtyProcess *getPtyProcess();
	PtyCondition getPtyCondition();
	bool getPtyProcessOk() const;
	void setPtyProcessOk(bool pty_process_ok);
	void setPtyUserData(QVariant const &userdata);
	void setPtyCondition(const PtyCondition &ptyCondition);

	QList<RepositoryItem> const &getRepos() const;
	QList<RepositoryItem> *getReposPtr();

	QString getCurrentRemoteName() const;

	AvatarLoader *getAvatarLoader();
	const AvatarLoader *getAvatarLoader() const;

	int *ptrUpdateFilesListCounter();
	int *ptrUpdateCommitTableCounter();

	bool interactionCanceled() const;
	void setInteractionCanceled(bool canceled);

	InteractionMode interactionMode() const;
	void setInteractionMode(const InteractionMode &im);

	QString getRepositoryFilterText() const;
	void setRepositoryFilterText(QString const &text);

	void setUncommitedChanges(bool uncommited_changes);

	QList<Git::Diff> *diffResult();
	std::map<QString, Git::Diff> *getDiffCacheMap();

	bool getRemoteChanged() const;
	void setRemoteChanged(bool remote_changed);

	void setServerType(const ServerType &server_type);

	GitHubRepositoryInfo *ptrGitHub();

	std::map<int, QList<Label>> *getLabelMap();
	const std::map<int, QList<Label>> *getLabelMap() const;
	void clearLabelMap();

	GitObjectCache *getObjCache();

	bool getForceFetch() const;
	void setForceFetch(bool force_fetch);

	std::map<QString, QList<Git::Tag>> *ptrTagMap();

	QString getHeadId() const;
	void setHeadId(QString const &head_id);

	void setPtyProcessCompletionData(QVariant const &value);
	QVariant const &getTempRepoForCloneCompleteV() const;

	void updateCommitGraph();
	bool fetch(const GitPtr &g, bool prune);
	bool fetch_tags_f(const GitPtr &g);

	protected:
	virtual void setCurrentLogRow(int row) = 0;
	virtual void updateFilesList(QString id, bool wait) = 0;
	virtual void setRepositoryInfo(QString const &reponame, QString const &brname) = 0;
	virtual void deleteTags(QStringList const &tagnames) = 0;
	virtual void internalWriteLog(const char *ptr, int len) = 0;
	virtual void removeSelectedRepositoryFromBookmark(bool ask) = 0;
	virtual void openRepository_(GitPtr g, bool keep_selection = false) = 0;
	virtual void updateRepositoriesList() = 0;
	virtual void clearFileList() = 0;
	virtual RepositoryItem const *selectedRepositoryItem() const = 0;
	virtual void setRemoteMonitoringEnabled(bool enable) { (void)enable; }
	virtual void updateStatusBarText() {}
	void msgNoRepositorySelected();
	bool isRepositoryOpened() const;
	public:
	explicit BasicMainWindow(QWidget *parent = nullptr);
	~BasicMainWindow() override;
	ApplicationSettings *appsettings();
	const ApplicationSettings *appsettings() const;
	WebContext *webContext();
	QString gitCommand() const;
	void autoOpenRepository(QString dir);
	GitPtr git(QString const &dir, const QString &sshkey = {}) const;
	GitPtr git();
	QPixmap getTransparentPixmap();
	QIcon committerIcon(int row) const;
	Git::CommitItem const *commitItem(int row) const;
	QIcon verifiedIcon(char s) const;
	virtual QString currentWorkingCopyDir() const;
	const QList<Label> *label(int row) const;
	bool saveAs(QString const &id, QString const &dstpath);
	bool testRemoteRepositoryValidity(QString const &url, const QString &sshkey);
	QString defaultWorkingDir() const;
	void addWorkingCopyDir(const QString &dir, bool open);
	bool queryCommit(QString const &id, Git::CommitItem *out);
	QAction addMenuActionProperty(QMenu menu);
	void checkout(QWidget parent, Git::CommitItem const commit, std::function<void()> accepted_callback = nullptr);
	void jumpToCommit(QString id);
	void execCommitViewWindow(Git::CommitItem const *commit);
	void execCommitExploreWindow(QWidget parent, Git::CommitItem const commit);
	void execCommitPropertyDialog(QWidget parent, Git::CommitItem const commit);
	void execFileHistory(QString const &path);
	void execFileHistory(QListWidgetItem *item);
	void execFilePropertyDialog(QListWidgetItem *item);
	QString selectGitCommand(bool save);
	QString selectFileCommand(bool save);
	QString selectGpgCommand(bool save);
	QString selectSshCommand(bool save);
	Git::Branch const &currentBranch() const;
	void setCurrentBranch(Git::Branch const &b);
	const RepositoryItem &currentRepository() const;
	QString currentRepositoryName() const;
	QString currentRemoteName() const;
	QString currentBranchName() const;
	bool isValidWorkingCopy(const GitPtr &g) const;
	QString determinFileType_(QString const &path, bool mime, std::function<void (QString const &, QByteArray *)> const &callback) const;
	QString determinFileType(QString const &path, bool mime);
	QString determinFileType(QByteArray in, bool mime);
	QList<Git::Tag> queryTagList();
	int limitLogCount() const;
	TextEditorThemePtr themeForTextEditor();
	Git::Object cat_file_(const GitPtr &g, QString const &id);
	Git::Object cat_file(QString const &id);
	QString newTempFilePath();
	QString findFileID(QString const &commit_id, QString const &file);
	void updateFilesList(QString const &id, QList<Git::Diff> diff_list, QListWidget listwidget);
	void setAppSettings(const ApplicationSettings &appsettings);

	QIcon getRepositoryIcon() const;
	QIcon getFolderIcon() const;
	QIcon getSignatureGoodIcon() const;
	QIcon getSignatureDubiousIcon() const;
	QIcon getSignatureBadIcon() const;
	QPixmap getTransparentPixmap() const;

	static QString abbrevCommitID(Git::CommitItem const &commit);
	QStringList findGitObject(const QString &id) const;

	void writeLog(const char *ptr, int len);
	void writeLog(QString const &str);
	void emitWriteLog(const QByteArray &ba);
	QList<Label> sortedLabels(int row) const;

	virtual bool isOnlineMode() const = 0;
	virtual int selectedLogIndex() const = 0;
	void changeSshKey(const QString &localdir, const QString &sshkey);
	void saveApplicationSettings();
	+ void loadApplicationSettings();
	protected slots:
	void onAvatarUpdated();
	public slots:
	void writeLog_(QByteArray ba);
	signals:
	void signalWriteLog(QByteArray ba);
	void remoteInfoChanged();
	// void signalCheckRemoteUpdate();
	};

	#endif // BASICMAINWINDOW_H
	diff --git a/src/WelcomeWizardDialog.cpp b/src/WelcomeWizardDialog.cpp
	index 739cf87..aaed083 100644
	--- a/src/WelcomeWizardDialog.cpp
	+++ b/src/WelcomeWizardDialog.cpp
	@@ -1,198 +1,216 @@
	#include "WelcomeWizardDialog.h"
	#include "ui_WelcomeWizardDialog.h"
	#include <QFileDialog>
	#include "MainWindow.h"
	#include "common/misc.h"
	#include "Git.h"

	WelcomeWizardDialog::WelcomeWizardDialog(BasicMainWindow *parent)
	: QDialog(parent)
	, ui(new Ui::WelcomeWizardDialog)
	{
	ui->setupUi(this);
	Qt::WindowFlags flags = windowFlags();
	flags &= ~Qt::WindowContextHelpButtonHint;
	setWindowFlags(flags);

	mainwindow_ = parent;

	pages_.push_back(ui->page_helper_tools);
	pages_.push_back(ui->page_global_user_information);
	pages_.push_back(ui->page_default_working_folder);
	pages_.push_back(ui->page_finish);
	ui->stackedWidget->setCurrentWidget(pages_[0]);
	on_stackedWidget_currentChanged(0);

	avatar_loader_.start(mainwindow_);
	connect(&avatar_loader_, &AvatarLoader::updated, [&](){
	QString email = ui->lineEdit_user_email->text();
	QIcon icon = avatar_loader_.fetch(email.toStdString(), false);
	setAvatar(icon);
	});

	ui->stackedWidget->setCurrentWidget(ui->page_helper_tools);
	}

	WelcomeWizardDialog::~WelcomeWizardDialog()
	{
	avatar_loader_.stop();
	delete ui;
	}

	void WelcomeWizardDialog::set_user_name(QString const &v)
	{
	ui->lineEdit_user_name->setText(v);
	}

	void WelcomeWizardDialog::set_user_email(QString const &v)
	{
	ui->lineEdit_user_email->setText(v);
	}

	void WelcomeWizardDialog::set_default_working_folder(QString const &v)
	{
	ui->lineEdit_default_working_folder->setText(v);

	}

	void WelcomeWizardDialog::set_git_command_path(QString const &v)
	{
	ui->lineEdit_git->setText(v);
	}

	void WelcomeWizardDialog::set_file_command_path(QString const &v)
	{
	ui->lineEdit_file->setText(v);
	}

	QString WelcomeWizardDialog::user_name() const
	{
	return ui->lineEdit_user_name->text();
	}

	QString WelcomeWizardDialog::user_email() const
	{
	return ui->lineEdit_user_email->text();
	}

	QString WelcomeWizardDialog::default_working_folder() const
	{
	return ui->lineEdit_default_working_folder->text();
	}

	QString WelcomeWizardDialog::git_command_path() const
	{
	return ui->lineEdit_git->text();
	}

	QString WelcomeWizardDialog::file_command_path() const
	{
	return ui->lineEdit_file->text();
	}

	void WelcomeWizardDialog::on_pushButton_prev_clicked()
	{
	int i = pages_.indexOf(ui->stackedWidget->currentWidget());
	if (i == 0) {
	done(QDialog::Rejected);
	return;
	}
	if (i > 0) {
	i--;
	QWidget *w = pages_[i];
	ui->stackedWidget->setCurrentWidget(w);
	}
	}

	void WelcomeWizardDialog::on_pushButton_next_clicked()
	{
	if (ui->stackedWidget->currentWidget() == ui->page_finish) {
	done(QDialog::Accepted);
	}
	int i = pages_.indexOf(ui->stackedWidget->currentWidget());
	if (i + 1 < pages_.size()) {
	i++;
	QWidget *w = pages_[i];
	ui->stackedWidget->setCurrentWidget(w);
	}
	}

	void WelcomeWizardDialog::on_stackedWidget_currentChanged(int /arg1/)
	{
	QString prev_text;
	QString next_text;
	QWidget *w = ui->stackedWidget->currentWidget();
	if (w == ui->page_helper_tools) {
	prev_text = tr("Cancel");
	ui->lineEdit_git->setFocus();
	} else if (w == ui->page_global_user_information) {
	if (user_name().isEmpty() && user_email().isEmpty()) {
	Git::Context gcx;
	gcx.git_command = git_command_path();
	Git g(gcx, {}, {});
	Git::User user = g.getUser(Git::Source::Global);
	set_user_name(user.name);
	set_user_email(user.email);
	}
	if (user_name().isEmpty()) {
	ui->lineEdit_user_name->setFocus();
	} else if (user_email().isEmpty()) {
	ui->lineEdit_user_email->setFocus();
	} else {
	ui->pushButton_next->setFocus();
	}
	} else if (w == ui->page_default_working_folder) {
	ui->lineEdit_default_working_folder->setFocus();
	} else if (w == ui->page_finish) {
	ui->lineEdit_preview_user->setText(ui->lineEdit_user_name->text());
	ui->lineEdit_preview_email->setText(ui->lineEdit_user_email->text());
	ui->lineEdit_preview_folder->setText(ui->lineEdit_default_working_folder->text());
	ui->lineEdit_preview_git->setText(ui->lineEdit_git->text());
	ui->lineEdit_preview_file->setText(ui->lineEdit_file->text());
	next_text = tr("Finish");
	ui->pushButton_next->setFocus();
	}
	ui->pushButton_prev->setText(prev_text.isEmpty() ? tr("<< Prev") : prev_text);
	ui->pushButton_next->setText(next_text.isEmpty() ? tr("Next >>") : next_text);
	ui->pushButton_next->setDefault(true);
	}

	void WelcomeWizardDialog::on_pushButton_browse_default_workiing_folder_clicked()
	{
	QString s = ui->lineEdit_default_working_folder->text();
	s = QFileDialog::getExistingDirectory(this, tr("Default Working Folder"), s);
	s = misc::normalizePathSeparator(s);
	ui->lineEdit_default_working_folder->setText(s);
	}


	void WelcomeWizardDialog::on_pushButton_browse_git_clicked()
	{
	QString s = mainwindow_->selectGitCommand(false);
	ui->lineEdit_git->setText(s);
	}

	void WelcomeWizardDialog::on_pushButton_browse_file_clicked()
	{
	QString s = mainwindow_->selectFileCommand(false);
	ui->lineEdit_file->setText(s);
	}

	void WelcomeWizardDialog::setAvatar(QIcon const &icon)
	{
	QPixmap pm = icon.pixmap(QSize(64, 64));
	ui->label_avatar->setPixmap(pm);
	}

	void WelcomeWizardDialog::on_pushButton_get_icon_clicked()
	{
	ui->label_avatar->setPixmap(QPixmap());
	QString email = ui->lineEdit_user_email->text();
	if (email.indexOf('@') > 0) {
	QIcon icon = avatar_loader_.fetch(email.toStdString(), true);
	if (!icon.isNull()) {
	setAvatar(icon);
	}
	}
	}

	+
	+void WelcomeWizardDialog::on_lineEdit_git_textChanged(const QString &arg1)
	+{
	+ QString ss;
	+ if (!misc::isExecutable(arg1)) {
	+ ss = "* { background-color: #ffc0c0; }";
	+ }
	+ ui->lineEdit_git->setStyleSheet(ss);
	+}
	+
	+void WelcomeWizardDialog::on_lineEdit_file_textChanged(const QString &arg1)
	+{
	+ QString ss;
	+ if (!misc::isExecutable(arg1)) {
	+ ss = "* { background-color: #ffc0c0; }";
	+ }
	+ ui->lineEdit_file->setStyleSheet(ss);
	+}
	diff --git a/src/WelcomeWizardDialog.h b/src/WelcomeWizardDialog.h
	index a6d8774..69e951b 100644
	--- a/src/WelcomeWizardDialog.h
	+++ b/src/WelcomeWizardDialog.h
	@@ -1,48 +1,52 @@
	#ifndef WELCOMEWIZARDDIALOG_H
	#define WELCOMEWIZARDDIALOG_H

	#include "AvatarLoader.h"

	#include <QDialog>

	class BasicMainWindow;

	namespace Ui {
	class WelcomeWizardDialog;
	}

	class WelcomeWizardDialog : public QDialog {
	Q_OBJECT
	private:
	BasicMainWindow *mainwindow_;
	AvatarLoader avatar_loader_;
	QList<QWidget *> pages_;
	public:
	explicit WelcomeWizardDialog(BasicMainWindow *parent = nullptr);
	~WelcomeWizardDialog() override;

	void set_user_name(QString const &v);
	void set_user_email(QString const &v);
	void set_default_working_folder(QString const &v);
	void set_git_command_path(QString const &v);
	void set_file_command_path(QString const &v);

	QString user_name() const;
	QString user_email() const;
	QString default_working_folder() const;
	QString git_command_path() const;
	QString file_command_path() const;
	private slots:
	void on_stackedWidget_currentChanged(int arg1);
	void on_pushButton_browse_default_workiing_folder_clicked();
	void on_pushButton_browse_git_clicked();
	void on_pushButton_browse_file_clicked();
	void on_pushButton_get_icon_clicked();
	void on_pushButton_prev_clicked();
	void on_pushButton_next_clicked();
	+ void on_lineEdit_git_textChanged(const QString &arg1);
	+
	+ void on_lineEdit_file_textChanged(const QString &arg1);
	+
	private:
	Ui::WelcomeWizardDialog *ui;
	void setAvatar(const QIcon &icon);
	};

	#endif // WELCOMEWIZARDDIALOG_H
	diff --git a/src/WelcomeWizardDialog.ui b/src/WelcomeWizardDialog.ui
	index 727bffa..a017d1d 100644
	--- a/src/WelcomeWizardDialog.ui
	+++ b/src/WelcomeWizardDialog.ui
	@@ -1,450 +1,450 @@
	<?xml version="1.0" encoding="UTF-8"?>
	<ui version="4.0">
	<class>WelcomeWizardDialog</class>
	<widget class="QDialog" name="WelcomeWizardDialog">
	<property name="geometry">
	<rect>
	<x>0</x>
	<y>0</y>
	<width>400</width>
	<height>295</height>
	</rect>
	</property>
	<property name="windowTitle">
	<string>Welcome to the Guitar Wizard</string>
	</property>
	<layout class="QVBoxLayout" name="verticalLayout">
	<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="QStackedWidget" name="stackedWidget">
	<property name="currentIndex">
	- <number>1</number>
	+ <number>0</number>
	</property>
	<widget class="QWidget" name="page_helper_tools">
	<layout class="QVBoxLayout" name="verticalLayout_4">
	<item>
	<widget class="QLabel" name="label_5">
	<property name="font">
	<font>
	<weight>75</weight>
	<bold>true</bold>
	</font>
	</property>
	<property name="text">
	<string>Helper Tools</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="Line" name="line_3">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QGridLayout" name="gridLayout_2">
	<item row="0" column="0">
	<widget class="QLabel" name="label_6">
	<property name="text">
	<string>git</string>
	</property>
	</widget>
	</item>
	<item row="0" column="1">
	<widget class="QLineEdit" name="lineEdit_git"/>
	</item>
	<item row="0" column="2">
	<widget class="QPushButton" name="pushButton_browse_git">
	<property name="text">
	<string>Browse</string>
	</property>
	</widget>
	</item>
	<item row="1" column="0">
	<widget class="QLabel" name="label_7">
	<property name="text">
	<string>file</string>
	</property>
	</widget>
	</item>
	<item row="1" column="1">
	<widget class="QLineEdit" name="lineEdit_file"/>
	</item>
	<item row="1" column="2">
	<widget class="QPushButton" name="pushButton_browse_file">
	<property name="text">
	<string>Browse</string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer_3">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>161</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	<widget class="QWidget" name="page_global_user_information">
	<layout class="QVBoxLayout" name="verticalLayout_6">
	<item>
	<widget class="QLabel" name="label">
	<property name="font">
	<font>
	<weight>75</weight>
	<bold>true</bold>
	</font>
	</property>
	<property name="text">
	<string>Global User Information</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="Line" name="line">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QFormLayout" name="formLayout">
	<property name="labelAlignment">
	<set>Qt::AlignLeading\|Qt::AlignLeft\|Qt::AlignVCenter</set>
	</property>
	<property name="formAlignment">
	<set>Qt::AlignLeading\|Qt::AlignLeft\|Qt::AlignTop</set>
	</property>
	<item row="0" column="0">
	<widget class="QLabel" name="label_2">
	<property name="text">
	<string>git config --global user.name</string>
	</property>
	</widget>
	</item>
	<item row="0" column="1">
	<widget class="QLineEdit" name="lineEdit_user_name"/>
	</item>
	<item row="1" column="0">
	<widget class="QLabel" name="label_3">
	<property name="text">
	<string>git config --global user.email</string>
	</property>
	</widget>
	</item>
	<item row="1" column="1">
	<widget class="QLineEdit" name="lineEdit_user_email"/>
	</item>
	</layout>
	</item>
	<item>
	<layout class="QVBoxLayout" name="verticalLayout_2">
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_2">
	<item>
	<widget class="QPushButton" name="pushButton_get_icon">
	<property name="text">
	<string>Get icon from Gravatar</string>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="horizontalSpacer_5">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</item>
	<item>
	<widget class="QLabel" name="label_avatar">
	<property name="text">
	<string/>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>167</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	<widget class="QWidget" name="page_default_working_folder">
	<layout class="QVBoxLayout" name="verticalLayout_3">
	<item>
	<widget class="QLabel" name="label_4">
	<property name="font">
	<font>
	<weight>75</weight>
	<bold>true</bold>
	</font>
	</property>
	<property name="text">
	<string>Default Working Folder</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="Line" name="line_2">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QGridLayout" name="gridLayout_3">
	<item row="0" column="0">
	<widget class="QLabel" name="label_14">
	<property name="text">
	<string>folder</string>
	</property>
	</widget>
	</item>
	<item row="0" column="1">
	<widget class="QLineEdit" name="lineEdit_default_working_folder"/>
	</item>
	<item row="0" column="2">
	<widget class="QPushButton" name="pushButton_browse_default_workiing_folder">
	<property name="text">
	<string>Browse</string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer_2">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>190</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	<widget class="QWidget" name="page_finish">
	<layout class="QVBoxLayout" name="verticalLayout_5">
	<item>
	<widget class="QLabel" name="label_8">
	<property name="font">
	<font>
	<weight>75</weight>
	<bold>true</bold>
	</font>
	</property>
	<property name="text">
	<string>Ready to play the Guitar !</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="Line" name="line_4">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QGridLayout" name="gridLayout">
	<item row="0" column="0">
	<widget class="QLabel" name="label_9">
	<property name="text">
	<string>user</string>
	</property>
	</widget>
	</item>
	<item row="0" column="1">
	<widget class="ReadOnlyLineEdit" name="lineEdit_preview_user">
	<property name="readOnly">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item row="1" column="0">
	<widget class="QLabel" name="label_10">
	<property name="text">
	<string>email</string>
	</property>
	</widget>
	</item>
	<item row="1" column="1">
	<widget class="ReadOnlyLineEdit" name="lineEdit_preview_email">
	<property name="readOnly">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item row="3" column="0">
	<widget class="QLabel" name="label_13">
	<property name="text">
	<string>folder</string>
	</property>
	</widget>
	</item>
	<item row="3" column="1">
	<widget class="ReadOnlyLineEdit" name="lineEdit_preview_folder">
	<property name="readOnly">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item row="5" column="0">
	<widget class="QLabel" name="label_11">
	<property name="text">
	<string>git</string>
	</property>
	</widget>
	</item>
	<item row="5" column="1">
	<widget class="ReadOnlyLineEdit" name="lineEdit_preview_git">
	<property name="readOnly">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item row="6" column="0">
	<widget class="QLabel" name="label_12">
	<property name="text">
	<string>file</string>
	</property>
	</widget>
	</item>
	<item row="6" column="1">
	<widget class="ReadOnlyLineEdit" name="lineEdit_preview_file">
	<property name="readOnly">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item row="2" column="0" colspan="2">
	<widget class="Line" name="line_5">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	</widget>
	</item>
	<item row="4" column="0" colspan="2">
	<widget class="Line" name="line_7">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer_4">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>71</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	</widget>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_6">
	<property name="leftMargin">
	<number>9</number>
	</property>
	<property name="topMargin">
	<number>0</number>
	</property>
	<property name="rightMargin">
	<number>9</number>
	</property>
	<property name="bottomMargin">
	<number>9</number>
	</property>
	<item>
	<spacer name="horizontalSpacer_6">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QPushButton" name="pushButton_prev">
	<property name="text">
	<string><< Prev</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QPushButton" name="pushButton_next">
	<property name="text">
	<string>Next >></string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	</layout>
	</widget>
	<customwidgets>
	<customwidget>
	<class>ReadOnlyLineEdit</class>
	<extends>QLineEdit</extends>
	<header>ReadOnlyLineEdit.h</header>
	</customwidget>
	</customwidgets>
	<resources/>
	<connections/>
	</ui>

File Metadata

Mime Type: text/x-diff
Expires: Sat, Feb 7, 8:51 AM (1 d, 58 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55929
Default Alt Text: (110 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions