Page MenuHomePhabricator (Chris)
Files F103441

No OneTemporary
Actions

Size
266 KB
Referenced Files
None
Subscribers
None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/src/AvatarLoader.cpp b/src/AvatarLoader.cpp
index 9f5eb38..394c364 100644
--- a/src/AvatarLoader.cpp
+++ b/src/AvatarLoader.cpp
@@ -1,161 +1,162 @@
#include "AvatarLoader.h"
#include "MainWindow.h"
#include "MemoryReader.h"
#include "webclient.h"
#include <QCryptographicHash>
#include <QDebug>
#include <QWaitCondition>
namespace {
const int MAX_CACHE_COUNT = 1000;
const int ICON_SIZE = 128;
}
using WebClientPtr = std::shared_ptr<WebClient>;
struct AvatarLoader::Private {
QMutex mutex;
QWaitCondition condition;
std::deque<RequestItem> requested;
std::deque<RequestItem> completed;
MainWindow *mainwindow = nullptr;
WebClientPtr web;
};
AvatarLoader::AvatarLoader()
: m(new Private)
{
}
AvatarLoader::~AvatarLoader()
{
delete m;
}
void AvatarLoader::start(MainWindow *mainwindow)
{
m->mainwindow = mainwindow;
QThread::start();
}
void AvatarLoader::run()
{
m->web = std::make_shared<WebClient>(m->mainwindow->webContext());
while (1) {
if (isInterruptionRequested()) return;
std::deque<RequestItem> requests;
{
QMutexLocker lock(&m->mutex);
if (m->requested.empty()) {
m->condition.wait(&m->mutex);
}
if (!m->requested.empty()) {
std::swap(requests, m->requested);
}
}
for (RequestItem &item : requests) {
if (isInterruptionRequested()) return;
if (strchr(item.email.c_str(), '@')) {
QString id;
{
QCryptographicHash hash(QCryptographicHash::Md5);
hash.addData(item.email.c_str(), item.email.size());
QByteArray ba = hash.result();
char tmp[100];
for (int i = 0; i < ba.size(); i++) {
sprintf(tmp + i * 2, "%02x", ba.data()[i] & 0xff);
}
id = tmp;
}
QString url = "https://www.gravatar.com/avatar/%1?s=%2";
url = url.arg(id).arg(ICON_SIZE);
if (m->web->get(WebClient::Request(url.toStdString())) == 200) {
if (!m->web->response().content.empty()) {
MemoryReader reader(m->web->response().content.data(), m->web->response().content.size());
reader.open(MemoryReader::ReadOnly);
QImage image;
image.load(&reader, nullptr);
int w = image.width();
int h = image.height();
if (w > 0 && h > 0) {
item.image = image;
{
QMutexLocker lock(&m->mutex);
size_t i = m->requested.size();
while (i > 0) {
i--;
if (m->requested[i].email == item.email) {
m->requested.erase(m->requested.begin() + i);
}
}
while (m->completed.size() >= MAX_CACHE_COUNT) {
m->completed.pop_back();
}
m->completed.push_front(item);
}
- emit updated();
+ emit updated(item.frame);
continue;
}
}
} else {
m->mainwindow->emitWriteLog(QString("Failed to fetch the avatar.\n").toUtf8());
QString msg = QString::fromStdString(m->web->error().message() + '\n');
m->mainwindow->emitWriteLog(msg.toUtf8());
}
}
}
}
}
-QIcon AvatarLoader::fetch(std::string const &email, bool request) const
+QIcon AvatarLoader::fetch(RepositoryWrapperFrame *frame, std::string const &email, bool request) const
{
QMutexLocker lock(&m->mutex);
RequestItem item;
+ item.frame = frame;
item.email = email;
for (size_t i = 0; i < m->completed.size(); i++) {
if (item.email == m->completed[i].email) {
item = m->completed[i];
m->completed.erase(m->completed.begin() + i);
m->completed.insert(m->completed.begin(), item);
return QIcon(QPixmap::fromImage(item.image));
}
}
if (request) {
bool waiting = false;
for (RequestItem const &r : m->requested) {
if (item.email == r.email) {
waiting = true;
break;
}
}
if (!waiting) {
m->requested.push_back(item);
m->condition.wakeOne();
}
}
return QIcon();
}
void AvatarLoader::stop()
{
{
QMutexLocker lock(&m->mutex);
requestInterruption();
m->requested.clear();
m->condition.wakeAll();
}
if (!wait(3000)) {
terminate();
}
if (m->web) {
m->web->close();
m->web.reset();
}
m->completed.clear();
}
diff --git a/src/AvatarLoader.h b/src/AvatarLoader.h
index b48f3aa..fe8e913 100644
--- a/src/AvatarLoader.h
+++ b/src/AvatarLoader.h
@@ -1,37 +1,39 @@
#ifndef AVATARLOADER_H
#define AVATARLOADER_H
#include "GitHubAPI.h"
+#include "RepositoryWrapperFrame.h"
#include <QIcon>
#include <QThread>
#include <QMutex>
#include <deque>
#include <set>
#include <string>
class MainWindow;
class WebContext;
class AvatarLoader : public QThread {
Q_OBJECT
private:
struct RequestItem {
+ RepositoryWrapperFrame *frame = nullptr;
std::string email;
QImage image;
};
struct Private;
Private *m;
protected:
void run() override;
public:
AvatarLoader();
~AvatarLoader() override;
- QIcon fetch(std::string const &email, bool request) const;
+ QIcon fetch(RepositoryWrapperFrame *frame, std::string const &email, bool request) const;
void stop();
void start(MainWindow *mainwindow);
signals:
- void updated();
+ void updated(RepositoryWrapperFrameP frame);
};
#endif // AVATARLOADER_H
diff --git a/src/BasicMainWindow.cpp b/src/BasicMainWindow.cpp
index 7259758..42b86d5 100644
--- a/src/BasicMainWindow.cpp
+++ b/src/BasicMainWindow.cpp
@@ -1,2854 +1,2824 @@
#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);
}
};
//
BasicMainWindow::BasicMainWindow(QWidget *parent)
: QMainWindow(parent)
// , m1(new Private1)
{
}
BasicMainWindow::~BasicMainWindow()
{
// delete m1;
}
ApplicationSettings *MainWindow::appsettings()
{
return &global->appsettings;
// return &m1->appsettings;
}
const ApplicationSettings *MainWindow::appsettings() const
{
return &global->appsettings;
// return &m1->appsettings;
}
WebContext *MainWindow::webContext()
{
return &m1->webcx;
}
QString MainWindow::gitCommand() const
{
return m1->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 MainWindow::postUserFunctionEvent(const std::function<void(QVariant const &)> &fn, QVariant const &v)
-{
- qApp->postEvent(this, new UserFunctionEvent(fn, v));
-}
-
void MainWindow::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 MainWindow::git(QString const &dir, QString const &sshkey) const
{
GitPtr g = std::make_shared<Git>(m1->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<MainWindow *>(this)->writeLog(text);
return GitPtr();
}
}
GitPtr MainWindow::git()
{
RepositoryItem const &item = currentRepository();
return git(item.local_dir, item.ssh_key);
}
GitPtr MainWindow::git(Git::SubmoduleItem const &submod)
{
if (!submod) return {};
RepositoryItem const &item = currentRepository();
return git(item.local_dir / submod.path, item.ssh_key);
}
QPixmap MainWindow::getTransparentPixmap()
{
return m1->transparent_pixmap;
}
-QIcon MainWindow::committerIcon(RepositoryWrapperFrame const *frame, int row) const
+QIcon MainWindow::committerIcon(RepositoryWrapperFrame *frame, int row) const
{
QIcon icon;
if (isAvatarEnabled() && isOnlineMode()) {
auto const &logs = getLogs(frame);
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
+ icon = getAvatarLoader()->fetch(frame, email, true); // from gavatar
}
}
}
return icon;
}
Git::CommitItem const *MainWindow::commitItem(RepositoryWrapperFrame *frame, int row) const
{
auto const &logs = getLogs(frame);
if (row >= 0 && row < (int)logs.size()) {
return &logs[row];
}
return nullptr;
}
QIcon MainWindow::verifiedIcon(char s) const
{
Git::SignatureGrade g = Git::evaluateSignature(s);
switch (g) {
case Git::SignatureGrade::Good:
return m1->signature_good_icon;
case Git::SignatureGrade::Bad:
return m1->signature_bad_icon;
case Git::SignatureGrade::Unknown:
case Git::SignatureGrade::Dubious:
case Git::SignatureGrade::Missing:
return m1->signature_dubious_icon;
}
return QIcon();
}
QString MainWindow::currentWorkingCopyDir() const
{
return m1->current_repo.local_dir;
}
bool MainWindow::isRepositoryOpened() const
{
return Git::isValidWorkingCopy(currentWorkingCopyDir());
}
QList<BranchLabel> const *MainWindow::label(int row) const
{
auto it = getLabelMap()->find(row);
if (it != getLabelMap()->end()) {
return &it->second;
}
return nullptr;
}
QList<BranchLabel> MainWindow::sortedLabels(int row) const
{
QList<BranchLabel> list;
auto const *p = const_cast<MainWindow *>(this)->label(row);
if (p && !p->empty()) {
list = *p;
std::sort(list.begin(), list.end(), [](BranchLabel const &l, BranchLabel const &r){
auto Compare = [](BranchLabel const &l, BranchLabel 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 MainWindow::saveAs(QString const &id, QString const &dstpath)
{
if (id.startsWith(PATH_PREFIX)) {
return saveFileAs(id.mid(1), dstpath);
} else {
return saveBlobAs(id, dstpath);
}
}
bool MainWindow::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 MainWindow::addWorkingCopyDir(QString const &dir, bool open)
{
addWorkingCopyDir(dir, QString(), open);
}
bool MainWindow::queryCommit(QString const &id, Git::CommitItem *out)
{
*out = Git::CommitItem();
GitPtr g = git();
return g->queryCommit(id, out);
}
QAction *MainWindow::addMenuActionProperty(QMenu *menu)
{
return menu->addAction(tr("&Property"));
}
-
-
void MainWindow::jumpToCommit(RepositoryWrapperFrame *frame, QString id)
{
GitPtr g = git();
id = g->rev_parse(id);
if (!id.isEmpty()) {
int row = rowFromCommitId(frame, id);
setCurrentLogRow(frame, row);
}
}
void MainWindow::execCommitViewWindow(Git::CommitItem const *commit)
{
CommitViewWindow win(this, commit);
win.exec();
}
void MainWindow::execCommitExploreWindow(QWidget *parent, Git::CommitItem const *commit)
{
CommitExploreWindow win(parent, this, getObjCache(), commit);
win.exec();
}
void MainWindow::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 MainWindow::execFilePropertyDialog(QListWidgetItem *item)
{
if (item) {
QString path = getFilePath(item);
QString id = getObjectID(item);
FilePropertyDialog dlg(this);
dlg.exec(this, path, id);
}
}
QString MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::selectSshCommand(bool save)
{
QString path = m1->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 &MainWindow::currentBranch() const
{
return m1->current_branch;
}
void MainWindow::setCurrentBranch(Git::Branch const &b)
{
m1->current_branch = b;
}
RepositoryItem const &MainWindow::currentRepository() const
{
return m1->current_repo;
}
QString MainWindow::currentRepositoryName() const
{
return currentRepository().name;
}
QString MainWindow::currentRemoteName() const
{
return m1->current_remote_name;
}
QString MainWindow::currentBranchName() const
{
return currentBranch().name;
}
bool MainWindow::isValidWorkingCopy(const GitPtr &g) const
{
return g && g->isValidWorkingCopy();
}
QString MainWindow::determinFileType_(QString const &path, bool mime, std::function<void (QString const &, QByteArray *)> const &callback) const
{
const_cast<MainWindow *>(this)->checkFileCommand();
return misc::determinFileType(global->file_command, path, mime, callback);
}
QString MainWindow::determinFileType(QString const &path, bool mime)
{
return determinFileType_(path, mime, [](QString const &cmd, QByteArray *ba){
misc2::runCommand(cmd, ba);
});
}
QString MainWindow::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> MainWindow::queryTagList(RepositoryWrapperFrame *frame)
{
QList<Git::Tag> list;
Git::CommitItem const *commit = selectedCommitItem(frame);
if (commit && Git::isValidID(commit->commit_id)) {
list = findTag(commit->commit_id);
}
return list;
}
int MainWindow::limitLogCount() const
{
int n = appsettings()->maximum_number_of_commit_item_acquisitions;
return (n >= 1 && n <= 100000) ? n : 10000;
}
TextEditorThemePtr MainWindow::themeForTextEditor()
{
return global->theme->text_editor_theme;
}
Git::Object MainWindow::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 MainWindow::cat_file(QString const &id)
{
return cat_file_(git(), id);
}
QString MainWindow::newTempFilePath()
{
QString tmpdir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
QString path = tmpdir / tempfileHeader() + QString::number(m1->temp_file_counter);
m1->temp_file_counter++;
return path;
}
QString MainWindow::findFileID(QString const &commit_id, QString const &file)
{
return lookupFileID(getObjCache(), commit_id, file);
}
void MainWindow::setAppSettings(const ApplicationSettings &appsettings)
{
global->appsettings = appsettings;
// m1->appsettings = appsettings;
}
QPixmap MainWindow::getTransparentPixmap() const
{
return m1->transparent_pixmap;
}
QIcon MainWindow::getSignatureBadIcon() const
{
return m1->signature_bad_icon;
}
QIcon MainWindow::getSignatureDubiousIcon() const
{
return m1->signature_dubious_icon;
}
QIcon MainWindow::getSignatureGoodIcon() const
{
return m1->signature_good_icon;
}
QIcon MainWindow::getFolderIcon() const
{
return m1->folder_icon;
}
QIcon MainWindow::getRepositoryIcon() const
{
return m1->repository_icon;
}
BasicMainWindow::PtyCondition MainWindow::getPtyCondition()
{
return m1->pty_condition;
}
void MainWindow::setPtyUserData(QVariant const &userdata)
{
m1->pty_process.setVariant(userdata);
}
void MainWindow::setPtyCondition(const PtyCondition &ptyCondition)
{
m1->pty_condition = ptyCondition;
}
PtyProcess *MainWindow::getPtyProcess()
{
return &m1->pty_process;
}
bool MainWindow::getPtyProcessOk() const
{
return m1->pty_process_ok;
}
void MainWindow::setPtyProcessOk(bool pty_process_ok)
{
m1->pty_process_ok = pty_process_ok;
}
const QList<RepositoryItem> &MainWindow::getRepos() const
{
return m1->repos;
}
QList<RepositoryItem> *MainWindow::getReposPtr()
{
return &m1->repos;
}
void MainWindow::setCurrentRemoteName(QString const &name)
{
m1->current_remote_name = name;
}
AvatarLoader *MainWindow::getAvatarLoader()
{
return &m1->avatar_loader;
}
AvatarLoader const *MainWindow::getAvatarLoader() const
{
return &m1->avatar_loader;
}
-int *MainWindow::ptrUpdateFilesListCounter()
-{
- return &m1->update_files_list_counter;
-}
+//int *MainWindow::ptrUpdateFilesListCounter()
+//{
+// return &m1->update_files_list_counter;
+//}
-int *MainWindow::ptrUpdateCommitTableCounter()
-{
- return &m1->update_commit_table_counter;
-}
+//int *MainWindow::ptrUpdateCommitTableCounter()
+//{
+// return &m1->update_commit_table_counter;
+//}
bool MainWindow::interactionCanceled() const
{
return m1->interaction_canceled;
}
void MainWindow::setInteractionCanceled(bool canceled)
{
m1->interaction_canceled = canceled;
}
BasicMainWindow::InteractionMode MainWindow::interactionMode() const
{
return m1->interaction_mode;
}
void MainWindow::setInteractionMode(const InteractionMode &im)
{
m1->interaction_mode = im;
}
QString MainWindow::getRepositoryFilterText() const
{
return m1->repository_filter_text;
}
void MainWindow::setRepositoryFilterText(QString const &text)
{
m1->repository_filter_text = text;
}
void MainWindow::setUncommitedChanges(bool uncommited_changes)
{
m1->uncommited_changes = uncommited_changes;
}
QList<Git::Diff> *MainWindow::diffResult()
{
return &m1->diff_result;
}
void MainWindow::setDiffResult(const QList<Git::Diff> &diffs)
{
m1->diff_result = diffs;
}
const QList<Git::SubmoduleItem> &MainWindow::submodules() const
{
return m1->submodules;
}
void MainWindow::setSubmodules(const QList<Git::SubmoduleItem> &submodules)
{
m1->submodules = submodules;
}
std::map<QString, Git::Diff> *MainWindow::getDiffCacheMap()
{
return &m1->diff_cache;
}
bool MainWindow::getRemoteChanged() const
{
return m1->remote_changed;
}
void MainWindow::setRemoteChanged(bool remote_changed)
{
m1->remote_changed = remote_changed;
}
void MainWindow::setServerType(const ServerType &server_type)
{
m1->server_type = server_type;
}
GitHubRepositoryInfo *MainWindow::ptrGitHub()
{
return &m1->github;
}
std::map<int, QList<BranchLabel>> *MainWindow::getLabelMap()
{
return &m1->label_map;
}
std::map<int, QList<BranchLabel>> const *MainWindow::getLabelMap() const
{
return &m1->label_map;
}
void MainWindow::clearLabelMap()
{
m1->label_map.clear();
}
GitObjectCache *MainWindow::getObjCache()
{
return &m1->objcache;
}
bool MainWindow::getForceFetch() const
{
return m1->force_fetch;
}
void MainWindow::setForceFetch(bool force_fetch)
{
m1->force_fetch = force_fetch;
}
std::map<QString, QList<Git::Tag>> *MainWindow::ptrTagMap()
{
return &m1->tag_map;
}
QString MainWindow::getHeadId() const
{
return m1->head_id;
}
void MainWindow::setHeadId(QString const &head_id)
{
m1->head_id = head_id;
}
void MainWindow::setPtyProcessCompletionData(QVariant const &value)
{
m1->pty_process_completion_data = value;
}
QVariant const &MainWindow::getTempRepoForCloneCompleteV() const
{
return m1->pty_process_completion_data;
}
void MainWindow::updateCommitGraph(RepositoryWrapperFrame *frame)
{
auto const &logs = getLogs(frame);
auto *logsp = getLogsPtr(frame);
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 MainWindow::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 MainWindow::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 MainWindow::git_callback(void *cookie, const char *ptr, int len)
{
auto *mw = (MainWindow *)cookie;
mw->emitWriteLog(QByteArray(ptr, len));
return true;
}
QString MainWindow::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 MainWindow::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 MainWindow::checkGitCommand()
{
while (1) {
if (misc::isExecutable(gitCommand())) {
return true;
}
if (selectGitCommand(true).isEmpty()) {
close();
return false;
}
}
}
bool MainWindow::checkFileCommand()
{
while (1) {
if (misc::isExecutable(global->file_command)) {
return true;
}
if (selectFileCommand(true).isEmpty()) {
close();
return false;
}
}
}
bool MainWindow::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 MainWindow::internalSaveCommandPath(QString const &path, bool save, QString const &name)
{
if (checkExecutable(path)) {
if (save) {
MySettings s;
s.beginGroup("Global");
s.setValue(name, path);
s.endGroup();
}
}
}
QStringList MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::deleteTags(RepositoryWrapperFrame *frame, 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(frame, names);
}
}
bool MainWindow::isAvatarEnabled() const
{
return appsettings()->get_committer_icon;
}
bool MainWindow::isGitHub() const
{
return m1->server_type == ServerType::GitHub;
}
QStringList MainWindow::remotes() const
{
return m1->remotes;
}
QList<Git::Branch> MainWindow::findBranch(QString const &id)
{
auto it = branchMapRef().find(id);
if (it != branchMapRef().end()) {
return it->second;
}
return QList<Git::Branch>();
}
QString MainWindow::saveAsTemp(QString const &id)
{
QString path = newTempFilePath();
saveAs(id, path);
return path;
}
QString MainWindow::tempfileHeader() const
{
QString name = "jp_soramimi_Guitar_%1_";
return name.arg(QApplication::applicationPid());
}
void MainWindow::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 MainWindow::getCommitIdFromTag(QString const &tag)
{
return getObjCache()->getCommitIdFromTag(tag);
}
bool MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::clearAuthentication()
{
clearSshAuthentication();
m1->http_uid.clear();
m1->http_pwd.clear();
}
-void MainWindow::onAvatarUpdated()
-{
- updateCommitTableLater();
-}
+
QStringList MainWindow::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 = m1->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 = m1->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 MainWindow::writeLog(const char *ptr, int len)
{
internalWriteLog(ptr, len);
}
void MainWindow::writeLog(const QString &str)
{
std::string s = str.toStdString();
writeLog(s.c_str(), s.size());
}
void MainWindow::emitWriteLog(QByteArray const &ba)
{
emit signalWriteLog(ba);
}
void MainWindow::writeLog_(QByteArray ba)
{
if (!ba.isEmpty()) {
writeLog(ba.data(), ba.size());
}
}
void MainWindow::queryRemotes(GitPtr const &g)
{
if (!g) return;
m1->remotes = g->getRemotes();
std::sort(m1->remotes.begin(), m1->remotes.end());
}
void MainWindow::msgNoRepositorySelected()
{
QMessageBox::warning(this, qApp->applicationName(), tr("No repository selected"));
}
bool MainWindow::runOnRepositoryDir(std::function<void (QString)> const &callback, RepositoryItem const *repo)
{
if (!repo) {
repo = &m1->current_repo;
}
QString dir = repo->local_dir;
dir.replace('\\', '/');
if (QFileInfo(dir).isDir()) {
callback(dir);
return true;
}
msgNoRepositorySelected();
return false;
}
void MainWindow::clearSshAuthentication()
{
m1->ssh_passphrase_user.clear();
m1->ssh_passphrase_pass.clear();
}
QString MainWindow::getFilePath(QListWidgetItem *item)
{
if (!item) return QString();
return item->data(FilePathRole).toString();
}
bool MainWindow::isGroupItem(QTreeWidgetItem *item)
{
if (item) {
int index = item->data(0, IndexRole).toInt();
if (index == GroupItem) {
return true;
}
}
return false;
}
int MainWindow::indexOfLog(QListWidgetItem *item)
{
if (!item) return -1;
return item->data(IndexRole).toInt();
}
int MainWindow::indexOfDiff(QListWidgetItem *item)
{
if (!item) return -1;
return item->data(DiffIndexRole).toInt();
}
int MainWindow::getHunkIndex(QListWidgetItem *item)
{
if (!item) return -1;
return item->data(HunkIndexRole).toInt();
}
void MainWindow::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 MainWindow::abbrevCommitID(Git::CommitItem const &commit)
{
return commit.commit_id.mid(0, 7);
}
bool MainWindow::saveRepositoryBookmarks() const
{
QString path = getBookmarksFilePath();
return RepositoryBookmark::save(path, &getRepos());
}
QString MainWindow::getBookmarksFilePath() const
{
return global->app_config_dir / "bookmarks.xml";
}
void MainWindow::stopPtyProcess()
{
getPtyProcess()->stop();
QDir::setCurrent(m1->starting_dir);
}
void MainWindow::abortPtyProcess()
{
stopPtyProcess();
setPtyProcessOk(false);
setInteractionCanceled(true);
}
void MainWindow::saveApplicationSettings()
{
SettingsDialog::saveSettings(appsettings());
// SettingsDialog::saveSettings(&m1->appsettings);
}
void MainWindow::loadApplicationSettings()
{
SettingsDialog::loadSettings(appsettings());
}
bool MainWindow::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(m1->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) {
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 MainWindow::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, &m1->gcx, g, repo, open_repository_menu);
dlg.exec();
if (dlg.isRemoteChanged()) {
emit remoteInfoChanged();
}
}
void MainWindow::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);
}
}
QString MainWindow::executableOrEmpty(QString const &path)
{
return checkExecutable(path) ? path : QString();
}
void MainWindow::setGitCommand(QString path, bool save)
{
appsettings()->git_command = m1->gcx.git_command = executableOrEmpty(path);
internalSaveCommandPath(path, save, "GitCommand");
}
void MainWindow::setFileCommand(QString path, bool save)
{
appsettings()->file_command = global->file_command = executableOrEmpty(path);
internalSaveCommandPath(path, save, "FileCommand");
}
void MainWindow::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 MainWindow::setSshCommand(QString path, bool save)
{
appsettings()->ssh_command = executableOrEmpty(path);
internalSaveCommandPath(path, save, "SshCommand");
}
void MainWindow::logGitVersion()
{
GitPtr g = git();
QString s = g->version();
if (!s.isEmpty()) {
s += '\n';
writeLog(s);
}
}
void MainWindow::setUnknownRepositoryInfo()
{
setRepositoryInfo("---", "");
Git g(m1->gcx, {}, {});
Git::User user = g.getUser(Git::Source::Global);
setWindowTitle_(user);
}
void MainWindow::internalClearRepositoryInfo()
{
setHeadId(QString());
setCurrentBranch(Git::Branch());
setServerType(ServerType::Standard);
m1->github = GitHubRepositoryInfo();
}
void MainWindow::checkUser()
{
Git g(m1->gcx, {}, {});
while (1) {
Git::User user = g.getUser(Git::Source::Global);
if (!user.name.isEmpty() && !user.email.isEmpty()) {
return; // ok
}
if (!execSetGlobalUserDialog()) {
return;
}
}
}
void MainWindow::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 MainWindow::updateRepository()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
OverrideWaitCursor;
openRepository_(g);
}
void MainWindow::reopenRepository(bool log, std::function<void(GitPtr const &)> const &callback)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
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);
}
void MainWindow::openSelectedRepository()
{
RepositoryItem const *repo = selectedRepositoryItem();
if (repo) {
setCurrentRepository(*repo, true);
openRepository(true);
}
}
bool MainWindow::isThereUncommitedChanges() const
{
return m1->uncommited_changes;
}
/**
* @brief コミットに対応する差分情報を作成
* @param id コミットID
* @param ok
* @return
*/
QList<Git::Diff> MainWindow::makeDiffs(QString id, bool *ok)
{
QList<Git::Diff> out;
GitPtr g = git();
if (!isValidWorkingCopy(g)) {
if (ok) *ok = false;
return {};
}
Git::FileStatusList list = g->status_s();
setUncommitedChanges(!list.empty());
if (id.isEmpty() && !isThereUncommitedChanges()) {
id = getObjCache()->revParse("HEAD");
}
QList<Git::SubmoduleItem> mods;
updateSubmodules(g, id, &mods);
setSubmodules(mods);
bool uncommited = (id.isEmpty() && isThereUncommitedChanges());
GitDiff dm(getObjCache());
if (uncommited) {
dm.diff_uncommited(submodules(), &out);
} else {
dm.diff(id, submodules(), &out);
}
if (ok) *ok = true;
return out;
}
/**
* @brief コミットログを取得する
* @param g
* @return
*/
Git::CommitItemList MainWindow::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 MainWindow::queryBranches(GitPtr const &g)
{
Q_ASSERT(g);
m1->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>> &MainWindow::branchMapRef()
{
return m1->branch_map;
}
-void MainWindow::updateCommitTableLater()
-{
- *ptrUpdateCommitTableCounter() = 200;
-}
-
void MainWindow::updateRemoteInfo()
{
queryRemotes(git());
m1->current_remote_name = QString();
{
Git::Branch const &r = currentBranch();
m1->current_remote_name = r.remote;
}
if (m1->current_remote_name.isEmpty()) {
if (m1->remotes.size() == 1) {
m1->current_remote_name = m1->remotes[0];
}
}
emit remoteInfoChanged();
}
void MainWindow::updateWindowTitle(GitPtr const &g)
{
if (isValidWorkingCopy(g)) {
Git::User user = g->getUser(Git::Source::Default);
setWindowTitle_(user);
} else {
setUnknownRepositoryInfo();
}
}
QString MainWindow::makeCommitInfoText(RepositoryWrapperFrame *frame, int row, QList<BranchLabel> *label_list)
{
QString message_ex;
Git::CommitItem const *commit = &getLogs(frame)[row];
{ // branch
if (label_list) {
if (commit->commit_id == getHeadId()) {
BranchLabel label(BranchLabel::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;
BranchLabel label(BranchLabel::LocalBranch);
label.text = b.name;
if (!b.remote.isEmpty()) {
label.kind = BranchLabel::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) {
BranchLabel label(BranchLabel::Tag);
label.text = t.name;
message_ex += QString(" {#%1}").arg(label.text);
if (label_list) label_list->push_back(label);
}
}
return message_ex;
}
void MainWindow::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 MainWindow::clone(QString url, QString dir)
{
if (!isOnlineMode()) return;
if (dir.isEmpty()) {
dir = defaultWorkingDir();
}
while (1) {
QString ssh_key;
CloneDialog dlg(this, url, dir, &m1->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 MainWindow::submodule_add(QString url, QString local_dir)
{
if (!isOnlineMode()) return;
if (local_dir.isEmpty()) return;
QString dir = local_dir;
while (1) {
SubmoduleAddDialog dlg(this, url, dir, &m1->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 data = Git::preclone(url, dir);
bool force = dlg.isForce();
GitPtr g = git(local_dir, repos_item_data.ssh_key);
auto callback = [&](GitPtr const &g){
g->submodule_add(data, force, getPtyProcess());
};
{
OverrideWaitCursor;
{
setLogEnabled(g, true);
AsyncExecGitThread_ th(g, callback);
th.start();
while (1) {
if (th.wait(1)) break;
QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
}
setLogEnabled(g, false);
}
openRepository_(g);
}
return; // done
}
}
void MainWindow::commit(RepositoryWrapperFrame *frame, bool amend)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
QString message;
QString previousMessage;
if (amend) {
message = getLogs(frame)[0].message;
} else {
QString id = g->getCherryPicking();
if (Git::isValidID(id)) {
message = g->getMessage(id);
} else {
for (Git::CommitItem const &item : getLogs(frame)) {
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(frame);
openRepository(true);
} else {
QString err = g->errorMessage().trimmed();
err += "\n*** ";
err += tr("Failed to commit");
err += " ***\n";
writeLog(err);
}
}
break;
}
}
void MainWindow::commitAmend(RepositoryWrapperFrame *frame)
{
commit(frame, true);
}
void MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::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 MainWindow::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 *MainWindow::selectedCommitItem(RepositoryWrapperFrame *frame) const
{
int i = selectedLogIndex(frame);
return commitItem(frame, i);
}
void MainWindow::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 MainWindow::deleteBranch(RepositoryWrapperFrame *frame)
{
deleteBranch(selectedCommitItem(frame));
}
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 MainWindow::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 MainWindow::editFile(QString const &path, QString const &title)
{
return TextEditDialog::editFile(this, path, title);
}
void MainWindow::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 MainWindow::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 MainWindow::setCurrentRepository(RepositoryItem const &repo, bool clear_authentication)
{
if (clear_authentication) {
clearAuthentication();
}
m1->current_repo = repo;
}
void MainWindow::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 MainWindow::internalAddTag(RepositoryWrapperFrame *frame, QString const &name)
{
if (name.isEmpty()) return false;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return false;
QString commit_id;
Git::CommitItem const *commit = selectedCommitItem(frame);
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 MainWindow::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 MainWindow::rowFromCommitId(RepositoryWrapperFrame *frame, QString const &id)
{
auto const &logs = getLogs(frame);
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 MainWindow::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 MainWindow::setLogEnabled(GitPtr const &g, bool f)
{
if (f) {
g->setLogCallback(git_callback, this);
} else {
g->setLogCallback(nullptr, nullptr);
}
}
QList<Git::Tag> MainWindow::findTag(QString const &id)
{
auto it = ptrTagMap()->find(id);
if (it != ptrTagMap()->end()) {
return it->second;
}
return QList<Git::Tag>();
}
void MainWindow::sshSetPassphrase(std::string const &user, std::string const &pass)
{
m1->ssh_passphrase_user = user;
m1->ssh_passphrase_pass = pass;
}
std::string MainWindow::sshPassphraseUser() const
{
return m1->ssh_passphrase_user;
}
std::string MainWindow::sshPassphrasePass() const
{
return m1->ssh_passphrase_pass;
}
void MainWindow::httpSetAuthentication(std::string const &user, std::string const &pass)
{
m1->http_uid = user;
m1->http_pwd = pass;
}
std::string MainWindow::httpAuthenticationUser() const
{
return m1->http_uid;
}
std::string MainWindow::httpAuthenticationPass() const
{
return m1->http_pwd;
}
void MainWindow::doGitCommand(std::function<void(GitPtr g)> const &callback)
{
GitPtr g = git();
if (isValidWorkingCopy(g)) {
OverrideWaitCursor;
callback(g);
openRepository(false, false);
}
}
diff --git a/src/BlameWindow.cpp b/src/BlameWindow.cpp
index 746a1d1..ec9dc82 100644
--- a/src/BlameWindow.cpp
+++ b/src/BlameWindow.cpp
@@ -1,248 +1,248 @@
#include "BlameWindow.h"
#include "ui_BlameWindow.h"
#include "common/misc.h"
#include "CommitPropertyDialog.h"
#include "Git.h"
#include "MainWindow.h"
#include <QMenu>
#include <QToolTip>
enum {
CommidIdRole = Qt::UserRole,
};
namespace {
struct CommitInfo {
QString datetime;
QString author;
QString email;
QString message;
};
}
struct BlameWindow::Private {
QList<BlameItem> list;
std::map<QString, CommitInfo> commit_cache;
};
BlameWindow::BlameWindow(MainWindow *parent, QString const &filename, const QList<BlameItem> &list)
: QDialog(parent)
, ui(new Ui::BlameWindow)
, m(new Private)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
{
QString s = "Blame : %1";
s = s.arg(filename);
setWindowTitle(s);
}
m->list = list;
int rows = 0;
for (BlameItem const &item : m->list) {
if (rows < item.line_number) {
rows = item.line_number;
}
}
int n = m->list.size();
if (rows < n) rows = n;
QStringList cols = {
"Commit",
"Time",
"Line",
"Text",
};
ui->tableWidget->setColumnCount(cols.size());
ui->tableWidget->setRowCount(rows);
for (int col = 0; col < cols.size(); col++) {
auto *item = new QTableWidgetItem(cols[col]);
ui->tableWidget->setHorizontalHeaderItem(col, item);
}
int row = 0;
for (BlameItem const &blame: m->list) {
QString id;
if (Git::isValidID(blame.commit_id)) {
id = blame.commit_id.mid(0, 8);
}
int col = 0;
auto NewItem = [](QString const &text){
return new QTableWidgetItem(text);
};
auto SetItem = [&](QTableWidgetItem *item){
ui->tableWidget->setItem(row, col, item);
col++;
};
QTableWidgetItem *item;
item = NewItem(id);
item->setData(CommidIdRole, blame.commit_id);
SetItem(item);
item = NewItem(misc::makeDateTimeString(blame.time));
SetItem(item);
item = NewItem(QString::number(blame.line_number));
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
SetItem(item);
item = NewItem(blame.text);
SetItem(item);
ui->tableWidget->setRowHeight(row, 24);
row++;
}
ui->tableWidget->resizeColumnsToContents();
ui->tableWidget->horizontalHeader()->stretchLastSection();
ui->tableWidget->selectRow(0);
}
BlameWindow::~BlameWindow()
{
delete m;
delete ui;
}
MainWindow *BlameWindow::mainwindow()
{
return qobject_cast<MainWindow *>(parent());
}
QList<BlameItem> BlameWindow::parseBlame(char const *begin, char const *end)
{
QList<BlameItem> list;
std::vector<std::string> lines;
misc::splitLines(begin, end, &lines, false);
BlameItem item;
for (std::string const &line : lines) {
if (line[0] == '\t') {
item.text = QString::fromUtf8(line.c_str() + 1);
list.push_back(item);
item.commit_id = QString();
item.text = QString();
} else {
char const *p = line.c_str();
char const *q = strchr(p, ' ');
if (q) {
QString label = QString::fromLatin1(p, q - p);
if (item.commit_id.isEmpty()) {
item.commit_id = label;
int a, b, c;
if (sscanf(q + 1, "%d %d %d", &a, &b, &c) >= 2) {
item.line_number = b;
}
} else {
auto Value = [&](){
return QString::fromLatin1(q + 1);
};
if (label == "author") {
item.author = Value();
} else if (label == "author-time") {
qint64 t = Value().toLong();
item.time = QDateTime::fromMSecsSinceEpoch(t * 1000);
}
}
}
}
}
return list;
}
QString BlameWindow::getCommitId(QTableWidgetItem *item) const
{
return item ? item->data(CommidIdRole).toString() : QString();
}
QString BlameWindow::currentCommitId() const
{
QString id;
int row = ui->tableWidget->currentRow();
if (row >= 0 && row < m->list.size()) {
QTableWidgetItem *item = ui->tableWidget->item(row, 0);
id = getCommitId(item);
}
return id;
}
void BlameWindow::on_tableWidget_itemDoubleClicked(QTableWidgetItem *)
{
QString id = currentCommitId();
if (Git::isValidID(id)) {
- CommitPropertyDialog dlg(this, mainwindow(), id);
+ CommitPropertyDialog dlg(this, mainwindow(), mainwindow()->frame(), id);
dlg.showCheckoutButton(false);
dlg.showJumpButton(true);
if (dlg.exec() == QDialog::Accepted) {
close();
}
}
}
void BlameWindow::on_tableWidget_customContextMenuRequested(const QPoint &pos)
{
(void)pos;
int row = ui->tableWidget->currentRow();
if (row < 0 || row >= m->list.size()) return;
Git::CommitItem commit;
BlameItem blame = m->list[row];
GitPtr g = mainwindow()->git();
if (!g->queryCommit(blame.commit_id, &commit)) return;
QMenu menu;
QAction *a_property = mainwindow()->addMenuActionProperty(&menu);
QAction *a = menu.exec(QCursor::pos() + QPoint(8, -8));
if (a) {
if (a == a_property) {
- mainwindow()->execCommitPropertyDialog(this, &commit);
+ mainwindow()->execCommitPropertyDialog(this, mainwindow()->frame(), &commit);
return;
}
}
}
void BlameWindow::on_tableWidget_currentItemChanged(QTableWidgetItem *current, QTableWidgetItem *previous)
{
(void)current;
(void)previous;
QString id = currentCommitId();
CommitInfo info;
if (Git::isValidID(id)) {
auto it = m->commit_cache.find(id);
if (it != m->commit_cache.end()) {
info = it->second;
} else {
GitPtr g = mainwindow()->git();
Git::CommitItem commit;
if (g->queryCommit(id, &commit)) {
info.datetime = misc::makeDateTimeString(commit.commit_date);
info.author = commit.author;
info.email = commit.email;
info.message = commit.message;
}
}
} else {
id = QString();
}
QString author = info.author;
if (!info.email.isEmpty()) {
author = author + " <" + info.email + '>';
}
ui->lineEdit_commit_id->setText(id);
ui->lineEdit_date->setText(info.datetime);
ui->lineEdit_author->setText(author);
ui->lineEdit_message->setText(info.message);
}
diff --git a/src/CommitPropertyDialog.cpp b/src/CommitPropertyDialog.cpp
index 06c2c88..30e522c 100644
--- a/src/CommitPropertyDialog.cpp
+++ b/src/CommitPropertyDialog.cpp
@@ -1,171 +1,171 @@
#include "CommitPropertyDialog.h"
#include "ui_CommitPropertyDialog.h"
#include "ApplicationGlobal.h"
#include "AvatarLoader.h"
#include "MainWindow.h"
#include "common/misc.h"
#include "gpg.h"
#include "main.h"
struct CommitPropertyDialog::Private {
MainWindow *mainwindow;
Git::CommitItem commit;
AvatarLoader avatar_loader;
};
-void CommitPropertyDialog::init(MainWindow *mw)
+void CommitPropertyDialog::init(MainWindow *mw, RepositoryWrapperFrame *frame)
{
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
ui->pushButton_jump->setVisible(false);
m->mainwindow = mw;
ui->lineEdit_message->setText(m->commit.message);
ui->lineEdit_commit_id->setText(m->commit.commit_id);
ui->lineEdit_date->setText(misc::makeDateTimeString(m->commit.commit_date));
ui->lineEdit_author->setText(m->commit.author);
ui->lineEdit_mail->setText(m->commit.email);
QString text;
for (QString const &id : m->commit.parent_ids) {
text += id + '\n';
}
ui->plainTextEdit_parent_ids->setPlainText(text);
gpg::Data key;
int n1 = m->commit.fingerprint.size();
if (n1 > 0) {
QList<gpg::Data> keys;
if (gpg::listKeys(global->gpg_command, &keys)) {
for (gpg::Data const &k : keys) {
int n2 = k.fingerprint.size();
if (n2 > 0) {
int n = std::min(n1, n2);
char const *p1 = m->commit.fingerprint.data() + n1 - n;
char const *p2 = k.fingerprint.data() + n2 - n;
if (memcmp(p1, p2, n) == 0) {
key = k;
break;
}
}
}
} else {
qDebug() << "Failed to get gpg keys";
}
if (key.id.isEmpty()) {
// gpgコマンドが登録されていないなど、keyidが取得できなかったとき
key.id = tr("<Unknown>");
}
}
if (key.id.isEmpty()) {
ui->frame_sign->setVisible(false);
} else {
{
int w = ui->label_signature_icon->width();
int h = ui->label_signature_icon->width();
QIcon icon = mainwindow()->verifiedIcon(m->commit.signature);
ui->label_signature_icon->setPixmap(icon.pixmap(w, h));
}
ui->lineEdit_sign_id->setText(key.id);
ui->lineEdit_sign_name->setText(key.name);
ui->lineEdit_sign_mail->setText(key.mail);
}
m->avatar_loader.start(mainwindow());
- connect(&m->avatar_loader, &AvatarLoader::updated, [&](){
- updateAvatar(false);
+ connect(&m->avatar_loader, &AvatarLoader::updated, [&](RepositoryWrapperFrameP frame){
+ updateAvatar(frame.pointer, false);
});
- updateAvatar(true);
+ updateAvatar(frame, true);
}
-void CommitPropertyDialog::updateAvatar(bool request)
+void CommitPropertyDialog::updateAvatar(RepositoryWrapperFrame *frame, bool request)
{
if (!mainwindow()->isOnlineMode()) return;
- auto SetAvatar = [&](QString const &email, QLabel *label){
+ auto SetAvatar = [&](RepositoryWrapperFrame *frame, QString const &email, QLabel *label){
if (mainwindow()->appsettings()->get_committer_icon) {
label->setFixedSize(QSize(48, 48));
- QIcon icon = m->avatar_loader.fetch(email.toStdString(), request);
+ QIcon icon = m->avatar_loader.fetch(frame, email.toStdString(), request);
setAvatar(icon, label);
} else {
label->setVisible(false);
}
};
- SetAvatar(ui->lineEdit_mail->text(), ui->label_user_avatar);
- SetAvatar(ui->lineEdit_sign_mail->text(), ui->label_sign_avatar);
+ SetAvatar(frame, ui->lineEdit_mail->text(), ui->label_user_avatar);
+ SetAvatar(frame, ui->lineEdit_sign_mail->text(), ui->label_sign_avatar);
}
-CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, MainWindow *mw, Git::CommitItem const *commit)
+CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, MainWindow *mw, RepositoryWrapperFrame *frame, Git::CommitItem const *commit)
: QDialog(parent)
, ui(new Ui::CommitPropertyDialog)
, m(new Private)
{
ui->setupUi(this);
m->commit = *commit;
- init(mw);
+ init(mw, frame);
}
-CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, MainWindow *mw, QString const &commit_id)
+CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, MainWindow *mw, RepositoryWrapperFrame *frame, QString const &commit_id)
: QDialog(parent)
, ui(new Ui::CommitPropertyDialog)
, m(new Private)
{
ui->setupUi(this);
mw->queryCommit(commit_id, &m->commit);
- init(mw);
+ init(mw, frame);
}
CommitPropertyDialog::~CommitPropertyDialog()
{
m->avatar_loader.stop();
delete m;
delete ui;
}
MainWindow *CommitPropertyDialog::mainwindow()
{
return m->mainwindow;
}
void CommitPropertyDialog::setAvatar(QIcon const &icon, QLabel *label)
{
QPixmap pm = icon.pixmap(label->size());
label->setPixmap(pm);
}
void CommitPropertyDialog::showCheckoutButton(bool f)
{
ui->pushButton_checkout->setVisible(f);
}
void CommitPropertyDialog::showJumpButton(bool f)
{
ui->pushButton_jump->setVisible(f);
}
void CommitPropertyDialog::on_pushButton_checkout_clicked()
{
mainwindow()->checkout(this, &m->commit, [&](){ hide(); });
done(QDialog::Rejected);
}
void CommitPropertyDialog::on_pushButton_jump_clicked()
{
mainwindow()->jumpToCommit(mainwindow()->frame(), m->commit.commit_id);
done(QDialog::Accepted);
}
void CommitPropertyDialog::on_pushButton_details_clicked()
{
mainwindow()->execCommitViewWindow(&m->commit);
}
void CommitPropertyDialog::on_pushButton_explorer_clicked()
{
mainwindow()->execCommitExploreWindow(this, &m->commit);
}
diff --git a/src/CommitPropertyDialog.h b/src/CommitPropertyDialog.h
index ae5860d..5e99fba 100644
--- a/src/CommitPropertyDialog.h
+++ b/src/CommitPropertyDialog.h
@@ -1,42 +1,43 @@
#ifndef COMMITPROPERTYDIALOG_H
#define COMMITPROPERTYDIALOG_H
#include <QDialog>
#include "Git.h"
class MainWindow;
+class RepositoryWrapperFrame;
class QLabel;
namespace Ui {
class CommitPropertyDialog;
}
class BasicMainWindow;
class CommitPropertyDialog : public QDialog {
Q_OBJECT
private:
struct Private;
Private *m;
public:
- explicit CommitPropertyDialog(QWidget *parent, MainWindow *mw, Git::CommitItem const *commit);
- explicit CommitPropertyDialog(QWidget *parent, MainWindow *mw, QString const &commit_id);
+ explicit CommitPropertyDialog(QWidget *parent, MainWindow *mw, RepositoryWrapperFrame *frame, Git::CommitItem const *commit);
+ explicit CommitPropertyDialog(QWidget *parent, MainWindow *mw, RepositoryWrapperFrame *frame, QString const &commit_id);
~CommitPropertyDialog() override;
void showCheckoutButton(bool f);
void showJumpButton(bool f);
private slots:
void on_pushButton_checkout_clicked();
void on_pushButton_details_clicked();
void on_pushButton_explorer_clicked();
void on_pushButton_jump_clicked();
private:
Ui::CommitPropertyDialog *ui;
- void init(MainWindow *mw);
+ void init(MainWindow *mw, RepositoryWrapperFrame *frame);
MainWindow *mainwindow();
void setAvatar(const QIcon &icon, QLabel *label);
- void updateAvatar(bool request);
+ void updateAvatar(RepositoryWrapperFrame *frame, bool request);
};
#endif // COMMITPROPERTYDIALOG_H
diff --git a/src/FileDiffWidget.h b/src/FileDiffWidget.h
index e2ac7df..23e2b3a 100644
--- a/src/FileDiffWidget.h
+++ b/src/FileDiffWidget.h
@@ -1,168 +1,176 @@
#ifndef FILEDIFFWIDGET_H
#define FILEDIFFWIDGET_H
#include "FileDiffSliderWidget.h"
#include "FileViewWidget.h"
#include "Git.h"
#include "MainWindow.h"
#include "texteditor/AbstractCharacterBasedApplication.h"
#include <QDialog>
#include <memory>
namespace Ui {
class FileDiffWidget;
}
enum class ViewType {
None,
Left,
Right
};
using TextDiffLine = Document::Line;
using TextDiffLineList = QList<Document::Line>;
struct ObjectContent {
QString id;
QString path;
QByteArray bytes;
TextDiffLineList lines;
};
using ObjectContentPtr = std::shared_ptr<ObjectContent>;
class QTableWidgetItem;
class FileDiffWidget : public QWidget {
Q_OBJECT
friend class BigDiffWindow;
public:
struct DiffData {
ObjectContentPtr left;
ObjectContentPtr right;
std::vector<std::string> original_lines;
DiffData()
{
clear();
}
void clear()
{
left = std::make_shared<ObjectContent>();
right = std::make_shared<ObjectContent>();
original_lines.clear();
}
};
- struct DrawData {
- int v_scroll_pos = 0;
- int h_scroll_pos = 0;
- int char_width = 0;
- int line_height = 0;
- QColor bgcolor_text;
- QColor bgcolor_add;
- QColor bgcolor_del;
- QColor bgcolor_add_dark;
- QColor bgcolor_del_dark;
- QColor bgcolor_gray;
- QWidget *forcus = nullptr;
- DrawData();
- };
+// struct DrawData {
+// int v_scroll_pos = 0;
+// int h_scroll_pos = 0;
+// int char_width = 0;
+// int line_height = 0;
+// QColor bgcolor_text;
+// QColor bgcolor_add;
+// QColor bgcolor_del;
+// QColor bgcolor_add_dark;
+// QColor bgcolor_del_dark;
+// QColor bgcolor_gray;
+// QWidget *forcus = nullptr;
+// DrawData()
+// {
+// bgcolor_text = QColor(255, 255, 255);
+// bgcolor_gray = QColor(224, 224, 224);
+// bgcolor_add = QColor(192, 240, 192);
+// bgcolor_del = QColor(255, 224, 224);
+// bgcolor_add_dark = QColor(64, 192, 64);
+// bgcolor_del_dark = QColor(240, 64, 64);
+// }
+// };
enum ViewStyle {
None,
SingleFile,
LeftOnly,
RightOnly,
SideBySideText,
SideBySideImage,
};
private:
Ui::FileDiffWidget *ui;
struct Private;
Private *m;
struct InitParam_ {
ViewStyle view_style = ViewStyle::None;
QByteArray bytes_a;
QByteArray bytes_b;
Git::Diff diff;
bool uncommited = false;
QString workingdir;
};
ViewStyle viewstyle() const;
GitPtr git();
Git::Object cat_file(const GitPtr &g, QString const &id);
int totalTextLines() const;
void resetScrollBarValue();
void updateSliderCursor();
int fileviewHeight() const;
void setDiffText(const Git::Diff &diff, TextDiffLineList const &left, TextDiffLineList const &right);
void setLeftOnly(QByteArray const &ba, const Git::Diff &diff);
void setRightOnly(QByteArray const &ba, const Git::Diff &diff);
void setSideBySide(QByteArray const &ba, const Git::Diff &diff, bool uncommited, QString const &workingdir);
void setSideBySide_(QByteArray const &ba_a, QByteArray const &ba_b, QString const &workingdir);
bool isValidID_(QString const &id);
FileViewType setupPreviewWidget();
void makeSideBySideDiffData(const Git::Diff &diff, const std::vector<std::string> &original_lines, TextDiffLineList *left_lines, TextDiffLineList *right_lines);
void onUpdateSliderBar();
void refrectScrollBar();
void setOriginalLines_(QByteArray const &ba, const Git::SubmoduleItem *submodule, const Git::CommitItem *submodule_commit);
QString diffObjects(const GitPtr &g, QString const &a_id, QString const &b_id);
MainWindow *mainwindow();
bool setSubmodule(const Git::Diff &diff);
protected:
void resizeEvent(QResizeEvent *) override;
void keyPressEvent(QKeyEvent *event) override;
public:
explicit FileDiffWidget(QWidget *parent = nullptr);
~FileDiffWidget() override;
void bind(MainWindow *mw);
void clearDiffView();
void setSingleFile(QByteArray const &ba, QString const &id, QString const &path);
void updateControls();
void scrollToBottom();
void updateDiffView(const Git::Diff &info, bool uncommited);
void updateDiffView(const QString &id_left, const QString &id_right, QString const &path = QString());
void setMaximizeButtonEnabled(bool f);
void setFocusAcceptable(Qt::FocusPolicy focuspolicy);
QPixmap makeDiffPixmap(DiffPane pane, int width, int height);
void setViewType(FileViewType type);
void setTextCodec(QTextCodec *codec);
void setTextCodec(char const *name);
private slots:
void onVerticalScrollValueChanged(int);
void onHorizontalScrollValueChanged(int);
void onDiffWidgetWheelScroll(int lines);
void onScrollValueChanged2(int value);
void onDiffWidgetResized();
void on_toolButton_fullscreen_clicked();
void scrollTo(int value);
void onMoved(int cur_row, int cur_col, int scr_row, int scr_col);
void on_toolButton_menu_clicked();
signals:
// void moveNextItem();
// void movePreviousItem();
void textcodecChanged();
};
#endif // FILEDIFFWIDGET_H
diff --git a/src/FileHistoryWindow.cpp b/src/FileHistoryWindow.cpp
index 38e0de2..c00928c 100644
--- a/src/FileHistoryWindow.cpp
+++ b/src/FileHistoryWindow.cpp
@@ -1,250 +1,250 @@
#include "FileHistoryWindow.h"
#include "MainWindow.h"
#include "FileDiffWidget.h"
#include "GitDiff.h"
#include "MyTableWidgetDelegate.h"
#include "common/joinpath.h"
#include "common/misc.h"
#include "ui_FileHistoryWindow.h"
#include <QMenu>
#include <QPainter>
#include <QStyledItemDelegate>
#include <QThread>
struct FileHistoryWindow::Private {
GitPtr g;
QString path;
Git::CommitItemList commit_item_list;
FileDiffWidget::DiffData diff_data;
- FileDiffWidget::DrawData draw_data;
+// FileDiffWidget::DrawData draw_data;
};
FileDiffWidget::DiffData *FileHistoryWindow::diffdata()
{
return &m->diff_data;
}
const FileDiffWidget::DiffData *FileHistoryWindow::diffdata() const
{
return &m->diff_data;
}
-FileDiffWidget::DrawData *FileHistoryWindow::drawdata()
-{
- return &m->draw_data;
-}
+//FileDiffWidget::DrawData *FileHistoryWindow::drawdata()
+//{
+// return &m->draw_data;
+//}
-const FileDiffWidget::DrawData *FileHistoryWindow::drawdata() const
-{
- return &m->draw_data;
-}
+//const FileDiffWidget::DrawData *FileHistoryWindow::drawdata() const
+//{
+// return &m->draw_data;
+//}
int FileHistoryWindow::totalTextLines() const
{
return diffdata()->left->lines.size();
}
-int FileHistoryWindow::fileviewScrollPos() const
-{
- return drawdata()->v_scroll_pos;
-}
+//int FileHistoryWindow::fileviewScrollPos() const
+//{
+// return drawdata()->v_scroll_pos;
+//}
FileHistoryWindow::FileHistoryWindow(BasicMainWindow *parent)
: QDialog(parent)
, ui(new Ui::FileHistoryWindow)
, m(new Private)
{
ui->setupUi(this);
ui->tableWidget_log->setItemDelegate(new MyTableWidgetDelegate(this));
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
flags |= Qt::WindowMaximizeButtonHint;
setWindowFlags(flags);
ui->splitter->setSizes({100, 200});
ui->widget_diff_view->bind(mainwindow());
// connect(ui->widget_diff_view, &FileDiffWidget::moveNextItem, this, &FileHistoryWindow::onMoveNextItem);
// connect(ui->widget_diff_view, &FileDiffWidget::movePreviousItem, this, &FileHistoryWindow::onMovePreviousItem);
}
FileHistoryWindow::~FileHistoryWindow()
{
delete m;
delete ui;
}
MainWindow *FileHistoryWindow::mainwindow()
{
return qobject_cast<MainWindow *>(parent());
}
void FileHistoryWindow::prepare(GitPtr const &g, QString const &path)
{
Q_ASSERT(g);
Q_ASSERT(g->isValidWorkingCopy());
this->m->g = g;
this->m->path = path;
QString reponame = mainwindow()->currentRepositoryName();
QString brname = mainwindow()->currentBranch().name;
QString text = "%1 (%2)";
text = text.arg(reponame).arg(brname);
ui->label_repo->setText(text);
ui->label_path->setText(path);
{
OverrideWaitCursor;
m->commit_item_list = m->g->log_all(m->path, mainwindow()->limitLogCount());
}
collectFileHistory();
updateDiffView();
}
void FileHistoryWindow::collectFileHistory()
{
QStringList cols = {
tr("Commit"),
tr("Date"),
tr("Author"),
tr("Message"),
};
int n = cols.size();
ui->tableWidget_log->setColumnCount(n);
ui->tableWidget_log->setRowCount(0);
for (int i = 0; i < n; i++) {
QString const &text = cols[i];
auto *item = new QTableWidgetItem(text);
ui->tableWidget_log->setHorizontalHeaderItem(i, item);
}
int count = m->commit_item_list.size();
ui->tableWidget_log->setRowCount(count);
for (int row = 0; row < count; row++) {
Git::CommitItem const &commit = m->commit_item_list[row];
int col = 0;
auto AddColumn = [&](QString const &text, QString const &tooltip){
auto *item = new QTableWidgetItem(text);
item->setToolTip(tooltip);
ui->tableWidget_log->setItem(row, col, item);
col++;
};
QString commit_id = MainWindow::abbrevCommitID(commit);
QString datetime = misc::makeDateTimeString(commit.commit_date);
AddColumn(commit_id, QString());
AddColumn(datetime, QString());
AddColumn(commit.author, QString());
AddColumn(commit.message, commit.message);
ui->tableWidget_log->setRowHeight(row, 24);
}
ui->tableWidget_log->resizeColumnsToContents();
ui->tableWidget_log->horizontalHeader()->setStretchLastSection(false);
ui->tableWidget_log->horizontalHeader()->setStretchLastSection(true);
ui->tableWidget_log->setFocus();
ui->tableWidget_log->setCurrentCell(0, 0);
}
class FindFileIdThread : public QThread {
private:
MainWindow *mainwindow;
GitPtr g;
QString commit_id;
QString file;
public:
QString result;
FindFileIdThread(MainWindow *mw, GitPtr const &g, QString const &commit_id, QString const &file)
{
this->mainwindow = mw;
this->g = g;
this->commit_id = commit_id;
this->file = file;
}
protected:
void run() override
{
result = mainwindow->findFileID(commit_id, file);
}
};
void FileHistoryWindow::updateDiffView()
{
Q_ASSERT(m->g);
Q_ASSERT(m->g->isValidWorkingCopy());
ui->widget_diff_view->clearDiffView();
int row = ui->tableWidget_log->currentRow();
if (row >= 0 && row + 1 < (int)m->commit_item_list.size()) {
Git::CommitItem const &commit_left = m->commit_item_list[row + 1]; // older
Git::CommitItem const &commit_right = m->commit_item_list[row]; // newer
FindFileIdThread left_thread(mainwindow(), m->g->dup(), commit_left.commit_id, m->path);
FindFileIdThread right_thread(mainwindow(), m->g->dup(), commit_right.commit_id, m->path);
left_thread.start();
right_thread.start();
left_thread.wait();
right_thread.wait();
QString id_left = left_thread.result;
QString id_right = right_thread.result;
ui->widget_diff_view->updateDiffView(id_left, id_right, m->path);
} else if (row >= 0 && row < (int)m->commit_item_list.size()) {
Git::CommitItem const &commit = m->commit_item_list[row]; // newer
QString id = mainwindow()->findFileID(commit.commit_id, m->path);
Git::Diff diff(id, m->path, QString());
ui->widget_diff_view->updateDiffView(diff, false);
}
}
void FileHistoryWindow::on_tableWidget_log_currentItemChanged(QTableWidgetItem * /*current*/, QTableWidgetItem * /*previous*/)
{
updateDiffView();
}
//void FileHistoryWindow::onMoveNextItem()
//{
// int row = ui->tableWidget_log->currentRow();
// int count = ui->tableWidget_log->rowCount();
// if (row + 1 < count) {
// ui->tableWidget_log->setCurrentCell(row + 1, 0, QItemSelectionModel::ClearAndSelect);
// }
//}
//void FileHistoryWindow::onMovePreviousItem()
//{
// int row = ui->tableWidget_log->currentRow();
// if (row > 0) {
// ui->tableWidget_log->setCurrentCell(row - 1, 0, QItemSelectionModel::ClearAndSelect);
// }
//}
void FileHistoryWindow::on_tableWidget_log_customContextMenuRequested(const QPoint &pos)
{
(void)pos;
Git::CommitItem const *commit = nullptr;
int row = ui->tableWidget_log->currentRow();
if (row >= 0 && row < (int)m->commit_item_list.size()) {
commit = &m->commit_item_list[row];
}
if (!commit) return;
QMenu menu;
QAction *a_property = mainwindow()->addMenuActionProperty(&menu);
QAction *a = menu.exec(QCursor::pos() + QPoint(8, -8));
if (a) {
if (a == a_property) {
- mainwindow()->execCommitPropertyDialog(this, commit);
+ mainwindow()->execCommitPropertyDialog(this, mainwindow()->frame(), commit);
return;
}
}
}
diff --git a/src/FileHistoryWindow.h b/src/FileHistoryWindow.h
index bb19c37..a8e36d3 100644
--- a/src/FileHistoryWindow.h
+++ b/src/FileHistoryWindow.h
@@ -1,48 +1,48 @@
#ifndef FILEHISTORYWINDOW_H
#define FILEHISTORYWINDOW_H
#include <QDialog>
#include "Git.h"
#include "BasicMainWindow.h"
#include "FileDiffWidget.h"
namespace Ui {
class FileHistoryWindow;
}
class BasicMainWindow;
class QTableWidgetItem;
class FileHistoryWindow : public QDialog {
Q_OBJECT
private:
struct Private;
Private *m;
FileDiffWidget::DiffData *diffdata();
FileDiffWidget::DiffData const *diffdata() const;
- FileDiffWidget::DrawData *drawdata();
- FileDiffWidget::DrawData const *drawdata() const;
+// FileDiffWidget::DrawData *drawdata();
+// FileDiffWidget::DrawData const *drawdata() const;
int totalTextLines() const;
- int fileviewScrollPos() const;
+// int fileviewScrollPos() const;
public:
explicit FileHistoryWindow(BasicMainWindow *parent);
~FileHistoryWindow() override;
void prepare(const GitPtr &g, QString const &path);
private slots:
void on_tableWidget_log_currentItemChanged(QTableWidgetItem *current, QTableWidgetItem *previous);
// void onMoveNextItem();
// void onMovePreviousItem();
void on_tableWidget_log_customContextMenuRequested(const QPoint &pos);
private:
Ui::FileHistoryWindow *ui;
void collectFileHistory();
void updateDiffView();
MainWindow *mainwindow();
};
#endif // FILEHISTORYWINDOW_H
diff --git a/src/ImageViewWidget.cpp b/src/ImageViewWidget.cpp
index 452cb04..373ee27 100644
--- a/src/ImageViewWidget.cpp
+++ b/src/ImageViewWidget.cpp
@@ -1,373 +1,373 @@
#include "ImageViewWidget.h"
#include "FileDiffSliderWidget.h"
#include "FileDiffWidget.h"
#include "MainWindow.h"
#include "MemoryReader.h"
#include "Photoshop.h"
#include "charvec.h"
#include "common/joinpath.h"
#include "common/misc.h"
#include <QBuffer>
#include <QDebug>
#include <QFileDialog>
#include <QMenu>
#include <QPainter>
#include <QSvgRenderer>
#include <QWheelEvent>
#include <cmath>
#include <functional>
#include <memory>
using SvgRendererPtr = std::shared_ptr<QSvgRenderer>;
struct ImageViewWidget::Private {
QMainWindow *mainwindow = nullptr;
FileDiffWidget *filediffwidget = nullptr;
- FileDiffWidget::DrawData *draw_data = nullptr;
+// FileDiffWidget::DrawData *draw_data = nullptr;
QScrollBar *v_scroll_bar = nullptr;
QScrollBar *h_scroll_bar = nullptr;
QString mime_type;
QPixmap pixmap;
SvgRendererPtr svg;
double image_scroll_x = 0;
double image_scroll_y = 0;
double image_scale = 1;
double scroll_origin_x = 0;
double scroll_origin_y = 0;
QPoint mouse_press_pos;
int wheel_delta = 0;
QPointF interest_pos;
int top_margin = 1;
int bottom_margin = 1;
bool draw_left_border = true;
#ifndef APP_GUITAR
QPixmap transparent_pixmap;
#endif
};
ImageViewWidget::ImageViewWidget(QWidget *parent)
: QWidget(parent)
, m(new Private)
{
#if defined(Q_OS_WIN32)
setFont(QFont("MS Gothic"));
#elif defined(Q_OS_LINUX)
setFont(QFont("Monospace"));
#elif defined(Q_OS_MAC)
setFont(QFont("Menlo"));
#endif
setContextMenuPolicy(Qt::DefaultContextMenu);
}
ImageViewWidget::~ImageViewWidget()
{
delete m;
}
void ImageViewWidget::bind(QMainWindow *mainwindow, FileDiffWidget *filediffwidget, QScrollBar *vsb, QScrollBar *hsb)
{
m->mainwindow = mainwindow;
m->filediffwidget = filediffwidget;
m->v_scroll_bar = vsb;
m->h_scroll_bar = hsb;
}
bool ImageViewWidget::hasFocus() const
{
QWidget *w = qApp->focusWidget();
return w && w != m->filediffwidget && w->isAncestorOf(this);
}
void ImageViewWidget::setLeftBorderVisible(bool f)
{
m->draw_left_border = f;
}
void ImageViewWidget::internalScrollImage(double x, double y)
{
m->image_scroll_x = x;
m->image_scroll_y = y;
QSizeF sz = imageScrollRange();
if (m->image_scroll_x < 0) m->image_scroll_x = 0;
if (m->image_scroll_y < 0) m->image_scroll_y = 0;
if (m->image_scroll_x > sz.width()) m->image_scroll_x = sz.width();
if (m->image_scroll_y > sz.height()) m->image_scroll_y = sz.height();
update();
}
void ImageViewWidget::scrollImage(double x, double y)
{
internalScrollImage(x, y);
if (m->h_scroll_bar) {
m->h_scroll_bar->blockSignals(true);
m->h_scroll_bar->setValue((int)m->image_scroll_x);
m->h_scroll_bar->blockSignals(false);
}
if (m->v_scroll_bar) {
m->v_scroll_bar->blockSignals(true);
m->v_scroll_bar->setValue((int)m->image_scroll_y);
m->v_scroll_bar->blockSignals(false);
}
}
void ImageViewWidget::refrectScrollBar()
{
double e = 0.75;
double x = m->h_scroll_bar->value();
double y = m->v_scroll_bar->value();
if (fabs(x - m->image_scroll_x) < e) x = m->image_scroll_x; // 差が小さいときは値を維持する
if (fabs(y - m->image_scroll_y) < e) y = m->image_scroll_y;
internalScrollImage(x, y);
}
void ImageViewWidget::clear()
{
m->mime_type = QString();
m->pixmap = QPixmap();
setMouseTracking(false);
update();
}
QString ImageViewWidget::formatText(Document::Line const &line)
{
QByteArray const &ba = line.text;
if (ba.isEmpty()) return QString();
std::vector<char> vec;
vec.reserve(ba.size() + 100);
char const *begin = ba.data();
char const *end = begin + ba.size();
char const *ptr = begin;
int x = 0;
while (ptr < end) {
if (*ptr == '\t') {
do {
vec.push_back(' ');
x++;
} while ((x % 4) != 0);
ptr++;
} else {
vec.push_back(*ptr);
ptr++;
x++;
}
}
return QString::fromUtf8(&vec[0], vec.size());
}
QSizeF ImageViewWidget::imageScrollRange() const
{
QSize sz = imageSize();
int w = int(sz.width() * m->image_scale);
int h = int(sz.height() * m->image_scale);
return QSize(w, h);
}
void ImageViewWidget::setScrollBarRange(QScrollBar *h, QScrollBar *v)
{
h->blockSignals(true);
v->blockSignals(true);
QSizeF sz = imageScrollRange();
h->setRange(0, (int)sz.width());
v->setRange(0, (int)sz.height());
h->setPageStep(width());
v->setPageStep(height());
h->blockSignals(false);
v->blockSignals(false);
}
void ImageViewWidget::updateScrollBarRange()
{
setScrollBarRange(m->h_scroll_bar, m->v_scroll_bar);
}
QMainWindow *ImageViewWidget::mainwindow()
{
return m->mainwindow;
}
QBrush ImageViewWidget::getTransparentBackgroundBrush()
{
#ifdef APP_GUITAR
return qobject_cast<MainWindow *>(mainwindow())->getTransparentPixmap();
#else
if (m->transparent_pixmap.isNull()) {
m->transparent_pixmap = QPixmap(":/image/transparent.png");
}
return m->transparent_pixmap;
#endif
}
bool ImageViewWidget::isValidImage() const
{
return !m->pixmap.isNull() || (m->svg && m->svg->isValid());
}
QSize ImageViewWidget::imageSize() const
{
if (!m->pixmap.isNull()) return m->pixmap.size();
if (m->svg && m->svg->isValid()) return m->svg->defaultSize();
return QSize();
}
void ImageViewWidget::paintEvent(QPaintEvent *)
{
QPainter pr(this);
QSize imagesize = imageSize();
if (imagesize.width() > 0 && imagesize.height() > 0) {
pr.save();
if (!m->draw_left_border) {
pr.setClipRect(1, 0, width() - 1, height());
}
double cx = width() / 2.0;
double cy = height() / 2.0;
double x = cx - m->image_scroll_x;
double y = cy - m->image_scroll_y;
QSizeF sz = imageScrollRange();
if (sz.width() > 0 && sz.height() > 0) {
QBrush br = getTransparentBackgroundBrush();
pr.setBrushOrigin((int)x, (int)y);
pr.fillRect((int)x, (int)y, (int)sz.width(), (int)sz.height(), br);
if (!m->pixmap.isNull()) {
pr.drawPixmap((int)x, (int)y, (int)sz.width(), (int)sz.height(), m->pixmap, 0, 0, imagesize.width(), imagesize.height());
} else if (m->svg && m->svg->isValid()) {
m->svg->render(&pr, QRectF(x, y, sz.width(), sz.height()));
}
}
misc::drawFrame(&pr, (int)x - 1, (int)y - 1, (int)sz.width() + 2, (int)sz.height() + 2, Qt::black);
pr.restore();
}
if (m->draw_left_border) {
pr.fillRect(0, 0, 1, height(), QColor(160, 160, 160));
}
if (hasFocus()) {
misc::drawFrame(&pr, 0, 0, width(), height(), QColor(0, 128, 255, 128));
misc::drawFrame(&pr, 1, 1, width() - 2, height() - 2, QColor(0, 128, 255, 64));
}
}
void ImageViewWidget::resizeEvent(QResizeEvent *)
{
updateScrollBarRange();
}
void ImageViewWidget::setImage(QString mimetype, QByteArray const &ba)
{
if (mimetype.isEmpty()) {
mimetype = "image/x-unknown";
}
setMouseTracking(true);
m->pixmap = QPixmap();
m->svg = SvgRendererPtr();
if (!ba.isEmpty()) {
if (misc::isSVG(mimetype)) {
m->svg = std::make_shared<QSvgRenderer>(ba);
} else if (misc::isPSD(mimetype)) {
if (!ba.isEmpty()) {
MemoryReader reader(ba.data(), ba.size());
if (reader.open(QIODevice::ReadOnly)) {
std::vector<char> jpeg;
photoshop::readThumbnail(&reader, &jpeg);
if (!jpeg.empty()) {
m->pixmap.loadFromData((uchar const *)&jpeg[0], jpeg.size());
}
}
}
} else {
m->pixmap.loadFromData(ba);
}
}
QSize sz = imageSize();
double sx = sz.width();
double sy = sz.height();
if (sx > 0 && sy > 0) {
sx = width() / sx;
sy = height() / sy;
m->image_scale = (sx < sy ? sx : sy) * 0.9;
}
updateScrollBarRange();
m->h_scroll_bar->blockSignals(true);
m->v_scroll_bar->blockSignals(true);
m->h_scroll_bar->setValue(m->h_scroll_bar->maximum() / 2);
m->v_scroll_bar->setValue(m->v_scroll_bar->maximum() / 2);
m->h_scroll_bar->blockSignals(false);
m->v_scroll_bar->blockSignals(false);
refrectScrollBar();
}
void ImageViewWidget::mousePressEvent(QMouseEvent *e)
{
if (e->button() == Qt::LeftButton) {
QPoint pos = mapFromGlobal(QCursor::pos());
m->mouse_press_pos = pos;
m->scroll_origin_x = m->image_scroll_x;
m->scroll_origin_y = m->image_scroll_y;
}
}
void ImageViewWidget::mouseMoveEvent(QMouseEvent *e)
{
if (isValidImage()) {
QPoint pos = mapFromGlobal(QCursor::pos());
if ((e->buttons() & Qt::LeftButton) && hasFocus()) {
int delta_x = pos.x() - m->mouse_press_pos.x();
int delta_y = pos.y() - m->mouse_press_pos.y();
scrollImage(m->scroll_origin_x - delta_x, m->scroll_origin_y - delta_y);
}
double cx = width() / 2.0;
double cy = height() / 2.0;
double x = (pos.x() + 0.5 - cx + m->image_scroll_x) / m->image_scale;
double y = (pos.y() + 0.5 - cy + m->image_scroll_y) / m->image_scale;
m->interest_pos = QPointF(x, y);
m->wheel_delta = 0;
}
}
void ImageViewWidget::setImageScale(double scale)
{
if (scale < 1 / 32.0) scale = 1 / 32.0;
if (scale > 32) scale = 32;
m->image_scale = scale;
}
void ImageViewWidget::wheelEvent(QWheelEvent *e)
{
if (isValidImage()) {
double scale = 1;
const double mul = 1.189207115; // sqrt(sqrt(2))
m->wheel_delta += e->delta();
while (m->wheel_delta >= 120) {
m->wheel_delta -= 120;
scale *= mul;
}
while (m->wheel_delta <= -120) {
m->wheel_delta += 120;
scale /= mul;
}
setImageScale(m->image_scale * scale);
updateScrollBarRange();
double cx = width() / 2.0;
double cy = height() / 2.0;
QPoint pos = mapFromGlobal(QCursor::pos());
double dx = m->interest_pos.x() * m->image_scale + cx - (pos.x() + 0.5);
double dy = m->interest_pos.y() * m->image_scale + cy - (pos.y() + 0.5);
scrollImage(dx, dy);
update();
}
}
diff --git a/src/LogTableWidget.cpp b/src/LogTableWidget.cpp
index e3eb1af..5448041 100644
--- a/src/LogTableWidget.cpp
+++ b/src/LogTableWidget.cpp
@@ -1,401 +1,406 @@
#include "LogTableWidget.h"
#include "MainWindow.h"
#include "MyTableWidgetDelegate.h"
#include "common/misc.h"
#include <QApplication>
#include <QDebug>
#include <QEvent>
#include <QPainter>
#include <QPainterPath>
#include <QProxyStyle>
#include <cmath>
#include <map>
#include "ApplicationGlobal.h"
#include "RepositoryWrapperFrame.h"
struct LogTableWidget::Private {
RepositoryWrapperFrame *frame = nullptr;
};
/**
* @brief コミットログを描画するためのdelegate
*/
class LogTableWidgetDelegate : public MyTableWidgetDelegate {
private:
RepositoryWrapperFrame *mainwindow() const
{
auto *w = dynamic_cast<LogTableWidget *>(QStyledItemDelegate::parent());
Q_ASSERT(w);
return w->frame();
}
static QColor hiliteColor(QColor const &color)
{
int r = color.red();
int g = color.green();
int b = color.blue();
r = 255 - (255 - r) / 2;
g = 255 - (255 - g) / 2;
b = 255 - (255 - b) / 2;
return QColor(r, g, b);
}
static QColor shadowColor(QColor const &color)
{
return QColor(color.red() / 2, color.green() / 2, color.blue() / 2);
}
void drawSignatureIcon(QPainter *painter, const QStyleOptionViewItem &opt, QModelIndex const &index) const
{
if (!opt.widget->isEnabled()) return;
Git::CommitItem const *commit = mainwindow()->commitItem(index.row());
if (commit) {
QIcon icon = mainwindow()->verifiedIcon(commit->signature);
if (!icon.isNull()) {
QRect r = opt.rect.adjusted(6, 3, 0, -3);
int h = r.height();
int w = h;
int x = r.x() + r.width() - w;
int y = r.y();
icon.paint(painter, x, y, w, h);
}
}
}
void drawAvatar(QPainter *painter, const QStyleOptionViewItem &opt, QModelIndex const &index) const
{
if (!opt.widget->isEnabled()) return;
int row = index.row();
QIcon icon = mainwindow()->committerIcon(row);
if (!icon.isNull()) {
int h = opt.rect.height();
int w = h;
int x = opt.rect.x() + opt.rect.width() - w;
int y = opt.rect.y();
painter->save();
painter->setOpacity(0.5); // 半透明で描画
icon.paint(painter, x, y, w, h);
painter->restore();
}
}
void drawLabels(QPainter *painter, const QStyleOptionViewItem &opt, QModelIndex const &index, QString const &current_branch) const
{
int row = index.row();
QList<BranchLabel> const *labels = mainwindow()->label(row);
if (labels) {
painter->save();
+ painter->setRenderHint(QPainter::Antialiasing);
- bool show = global->mainwindow->isLabelsVisible();
+ bool show = global->mainwindow->isLabelsVisible(); // ラベル透過モード
painter->setOpacity(show ? 1.0 : 0.0625);
- painter->setRenderHint(QPainter::Antialiasing);
- QFontMetrics fm = painter->fontMetrics();
const int space = 8;
int x = opt.rect.x() + opt.rect.width() - 3;
int x1 = x;
int y0 = opt.rect.y();
int y1 = y0 + opt.rect.height() - 1;
int i = labels->size();
while (i > 0) {
i--;
+
+ // ラベル
BranchLabel const &label = labels->at(i);
QString text = misc::abbrevBranchName(label.text + label.info);
- int w = fm.size(0, text).width() + space * 2; // 幅
- int x0 = x1 - w;
- QRect r(x0, y0, x1 - x0, y1 - y0);
+ // 現在のブランチ名と一致するなら太字
bool bold = false;
- if (text == current_branch) { // 現在のブランチ名と一致するなら太字
- bold = true;
+ if (text.startsWith(current_branch)) {
+ auto c = text.utf16()[current_branch.size()];
+ if (c == 0 || c == ',') {
+ bold = true;
+ }
}
+ // フォントの設定
+ QFont font = painter->font();
+ font.setBold(bold);
+ painter->setFont(font);
+
+ // ラベルの矩形
+ int w = painter->fontMetrics().size(0, text).width() + space * 2; // 幅
+ int x0 = x1 - w;
+ QRect r(x0, y0, x1 - x0, y1 - y0);
+
// ラベル枠の描画
auto DrawLabelFrame = [&](int dx, int dy, QColor color){
painter->setBrush(color);
painter->drawRoundedRect(r.adjusted(lround(dx + 3), lround(dy + 3), lround(dx - 3), lround(dy - 3)), 3, 3);
};
- QColor color = BranchLabel::color(label.kind);
- QColor hilite = hiliteColor(color);
- QColor shadow = shadowColor(color);
+ QColor color = BranchLabel::color(label.kind); // ラベル表面の色
+ QColor hilite = hiliteColor(color); // ハイライトの色
+ QColor shadow = shadowColor(color); // 陰の色
painter->setPen(Qt::NoPen);
DrawLabelFrame(-1, -1, hilite);
DrawLabelFrame(1, 1, shadow);
DrawLabelFrame(0, 0, color);
- // フォントの設定
- {
- QFont font = painter->font();
- font.setBold(bold);
- painter->setFont(font);
- }
-
// ラベルテキストの描画
painter->setPen(Qt::black);
painter->setBrush(Qt::NoBrush);
QApplication::style()->drawItemText(painter, r.adjusted(space, 0, 0, 0), opt.displayAlignment, opt.palette, true, text);
x1 = x0;
}
painter->restore();
}
}
public:
explicit LogTableWidgetDelegate(QObject *parent = Q_NULLPTR)
: MyTableWidgetDelegate(parent)
{
}
void paint(QPainter *painter, const QStyleOptionViewItem &option, QModelIndex const &index) const override
{
MyTableWidgetDelegate::paint(painter, option, index);
RepositoryWrapperFrame *mw = mainwindow();
enum {
Graph,
CommitId,
Date,
Author,
Message,
};
// signatureの描画
if (index.column() == CommitId) {
drawSignatureIcon(painter, option, index);
}
// コミット日時
if (index.column() == Date) {
Git::CommitItem const *commit = mw->commitItem(index.row());
if (commit && commit->strange_date) {
QColor color(255, 0, 0, 128);
QRect r = option.rect.adjusted(1, 1, -1, -2);
misc::drawFrame(painter, r.x(), r.y(), r.width(), r.height(), color, color);
}
}
// avatarの描画
if (index.column() == Author) {
drawAvatar(painter, option, index);
}
// ラベルの描画
if (index.column() == Message) {
QString current_branch = mw->currentBranchName();
drawLabels(painter, option, index, current_branch);
}
}
};
LogTableWidget::LogTableWidget(QWidget *parent)
: QTableWidget(parent)
, m(new Private)
{
setItemDelegate(new LogTableWidgetDelegate(this));
}
LogTableWidget::~LogTableWidget()
{
delete m;
}
void LogTableWidget::bind(RepositoryWrapperFrame *frame)
{
m->frame = frame;
}
RepositoryWrapperFrame *LogTableWidget::frame()
{
// auto *mw = qobject_cast<RepositoryWrapperFrame *>(window());
// Q_ASSERT(mw);
// return mw;
Q_ASSERT(m->frame);
return m->frame;
}
void drawBranch(QPainterPath *path, double x0, double y0, double x1, double y1, double r, bool bend_early)
{
const double k = 0.55228475; // 三次ベジェ曲線で円を近似するための定数
if (x0 == x1) {
path->moveTo(x0, y0);
path->lineTo(x1, y1);
} else {
double ym = bend_early ? (y0 + r) : (y1 - r);
double h = fabs(y1 - y0);
double w = fabs(x1 - x0);
if (r > h / 2) r = h / 2;
if (r > w / 2) r = w / 2;
double s = r;
if (x0 > x1) r = -r;
if (y0 > y1) s = -s;
if (0) {
path->moveTo(x0, y0);
path->lineTo(x0, ym - s);
path->cubicTo(x0, ym - s + s * k, x0 + r - r * k, ym, x0 + r, ym);
path->lineTo(x1 - r, ym);
path->cubicTo(x1 - r + r * k, ym, x1, ym + s - s * k, x1, ym + s);
path->lineTo(x1, y1);
} else {
if (bend_early) {
path->moveTo(x0, y0);
path->cubicTo(x0, ym, x1, ym, x1, ym + ym - y0);
path->lineTo(x1, y1);
} else {
path->moveTo(x0, y0);
path->lineTo(x0, ym + ym - y1);
path->cubicTo(x0, ym, x1, ym, x1, y1);
}
}
}
}
void LogTableWidget::paintEvent(QPaintEvent *e)
{
if (rowCount() < 1) return;
QTableWidget::paintEvent(e);
QPainter pr(viewport());
pr.setRenderHint(QPainter::Antialiasing);
pr.setBrush(QBrush(QColor(255, 255, 255)));
Git::CommitItemList const *list = &frame()->getLogs();
int indent_span = 16;
int line_width = 2;
int thick_line_width = 4;
auto ItemRect = [&](int row){
QRect r;
QTableWidgetItem *p = item(row, 0);
if (p) {
r = visualItemRect(p);
}
return r;
};
auto IsAncestor = [&](Git::CommitItem const &item){
return frame()->isAncestorCommit(item.commit_id);
};
auto ItemPoint = [&](int depth, QRect const &rect){
int h = rect.height();
double n = h / 2.0;
double x = floor(rect.x() + n + depth * indent_span);
double y = floor(rect.y() + n);
return QPointF(x, y);
};
auto SetPen = [&](QPainter *pr, int level, bool thick){
QColor c = frame()->color(level + 1);
Qt::PenStyle s = Qt::SolidLine;
pr->setPen(QPen(c, thick ? thick_line_width : line_width, s));
};
auto DrawLine = [&](size_t index, int itemrow){
QRect rc1;
if (index < list->size()) {
Git::CommitItem const &item1 = list->at(index);
rc1 = ItemRect(itemrow);
QPointF pt1 = ItemPoint(item1.marker_depth, rc1);
double halfheight = rc1.height() / 2.0;
for (TreeLine const &line : item1.parent_lines) {
if (line.depth >= 0) {
QPainterPath *path = nullptr;
Git::CommitItem const &item2 = list->at(line.index);
QRect rc2 = ItemRect(line.index);
if (index + 1 == (size_t)line.index || line.depth == item1.marker_depth || line.depth == item2.marker_depth) {
QPointF pt2 = ItemPoint(line.depth, rc2);
if (pt2.y() > 0) {
path = new QPainterPath();
drawBranch(path, pt1.x(), pt1.y(), pt2.x(), pt2.y(), halfheight, line.bend_early);
}
} else {
QPointF pt3 = ItemPoint(item2.marker_depth, rc2);
if (pt3.y() > 0) {
path = new QPainterPath();
QRect rc3 = ItemRect(itemrow + 1);
QPointF pt2 = ItemPoint(line.depth, rc3);
drawBranch(path, pt1.x(), pt1.y(), pt2.x(), pt2.y(), halfheight, true);
drawBranch(path, pt2.x(), pt2.y(), pt3.x(), pt3.y(), halfheight, false);
}
}
if (path) {
SetPen(&pr, line.color_number, IsAncestor(item1));
pr.drawPath(*path);
delete path;
}
}
}
}
return rc1.y();
};
auto DrawMark = [&](size_t index, int row){
double x, y;
y = 0;
if (index < list->size()) {
Git::CommitItem const &item = list->at(index);
QRect rc = ItemRect(row);
QPointF pt = ItemPoint(item.marker_depth, rc);
double r = 4;
x = pt.x() - r;
y = pt.y() - r;
if (item.resolved) {
// ◯
SetPen(&pr, item.marker_depth, IsAncestor(item));
pr.drawEllipse((int)x, (int)y, int(r * 2), int(r * 2));
} else {
// ▽
SetPen(&pr, item.marker_depth, false);
QPainterPath path;
path.moveTo(pt.x(), pt.y() + r);
path.lineTo(pt.x() - r, pt.y() - r);
path.lineTo(pt.x() + r, pt.y() - r);
path.lineTo(pt.x(), pt.y() + r);
pr.drawPath(path);
}
}
return y;
};
// draw lines
pr.setOpacity(0.5);
pr.setBrush(Qt::NoBrush);
for (size_t i = 0; i < list->size(); i++) {
double y = DrawLine(i, i);
if (y >= height()) break;
}
// draw marks
pr.setOpacity(1);
pr.setBrush(frame()->color(0));
for (size_t i = 0; i < list->size(); i++) {
double y = DrawMark(i, i);
if (y >= height()) break;
}
}
void LogTableWidget::resizeEvent(QResizeEvent *e)
{
frame()->updateAncestorCommitMap();
QTableWidget::resizeEvent(e);
}
void LogTableWidget::verticalScrollbarValueChanged(int value)
{
(void)value;
frame()->updateAncestorCommitMap();
}
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index c31753b..c779308 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -1,3344 +1,3427 @@
#include "MainWindow.h"
#include "ui_MainWindow.h"
#include "AboutDialog.h"
#include "ApplicationGlobal.h"
#include "AreYouSureYouWantToContinueConnectingDialog.h"
#include "BlameWindow.h"
#include "CheckoutDialog.h"
#include "CherryPickDialog.h"
#include "CloneFromGitHubDialog.h"
#include "CommitPropertyDialog.h"
#include "EditGitIgnoreDialog.h"
#include "EditTagsDialog.h"
#include "FindCommitDialog.h"
#include "GitDiff.h"
#include "JumpDialog.h"
#include "LineEditDialog.h"
#include "MergeDialog.h"
#include "MySettings.h"
#include "ObjectBrowserDialog.h"
#include "ReflogWindow.h"
#include "SetGpgSigningDialog.h"
#include "SettingsDialog.h"
#include "StatusLabel.h"
#include "SubmoduleUpdateDialog.h"
#include "SubmodulesDialog.h"
#include "TextEditDialog.h"
#include "UserEvent.h"
#include "SubmoduleMainWindow.h"
#include "common/misc.h"
#include <QClipboard>
#include <QDir>
#include <QElapsedTimer>
#include <QFileDialog>
#include <QFileIconProvider>
#include <QMessageBox>
#include <QMimeData>
#include <QPainter>
#include <QShortcut>
#include <QStandardPaths>
#include <QTimer>
#include <coloredit/ColorDialog.h>
-FileDiffWidget::DrawData::DrawData()
-{
- bgcolor_text = QColor(255, 255, 255);
- bgcolor_gray = QColor(224, 224, 224);
- bgcolor_add = QColor(192, 240, 192);
- bgcolor_del = QColor(255, 224, 224);
- bgcolor_add_dark = QColor(64, 192, 64);
- bgcolor_del_dark = QColor(240, 64, 64);
-}
+
+
+struct EventItem {
+ QObject *receiver = nullptr;
+ QEvent *event = nullptr;
+ QDateTime at;
+ EventItem(QObject *receiver, QEvent *event, QDateTime const &at)
+ : receiver(receiver)
+ , event(event)
+ , at(at)
+ {
+ }
+};
struct MainWindow::Private2 {
+ std::vector<EventItem> event_item_list;
+
bool is_online_mode = true;
QTimer interval_10ms_timer;
QImage graph_color;
QPixmap digits;
StatusLabel *status_bar_label;
QObject *last_focused_file_list = nullptr;
QListWidgetItem *last_selected_file_item = nullptr;
bool searching = false;
QString search_text;
int repos_panel_width = 0;
std::set<QString> ancestors;
QWidget *focused_widget = nullptr;
QList<int> splitter_h_sizes;
};
MainWindow::MainWindow(QWidget *parent)
: BasicMainWindow(parent)
, ui(new Ui::MainWindow)
, m1(new Private1)
, m2(new Private2)
{
ui->setupUi(this);
ui->frame_repository_wrapper->bind(this
, ui->tableWidget_log
, ui->listWidget_files
, ui->listWidget_unstaged
, ui->listWidget_staged
, ui->widget_diff_view
);
loadApplicationSettings();
m1->starting_dir = QDir::current().absolutePath();
{ // load graphic resources
QFileIconProvider icons;
m1->folder_icon = icons.icon(QFileIconProvider::Folder);
m1->repository_icon = QIcon(":/image/repository.png");
m1->signature_good_icon = QIcon(":/image/signature-good.png");
m1->signature_bad_icon = QIcon(":/image/signature-bad.png");
m1->signature_dubious_icon = QIcon(":/image/signature-dubious.png");
m1->transparent_pixmap = QPixmap(":/image/transparent.png");
}
#ifdef Q_OS_MACX
ui->action_about->setText("About Guitar...");
ui->action_edit_settings->setText("Settings...");
#endif
ui->splitter_v->setSizes({100, 400});
ui->splitter_h->setSizes({200, 100, 200});
m2->status_bar_label = new StatusLabel(this);
ui->statusBar->addWidget(m2->status_bar_label);
frame()->filediffwidget()->bind(this);
qApp->installEventFilter(this);
setShowLabels(appsettings()->show_labels, false);
ui->widget_log->setupForLogWidget(ui->verticalScrollBar_log, ui->horizontalScrollBar_log, themeForTextEditor());
onLogVisibilityChanged();
initNetworking();
showFileList(FilesListType::SingleList);
m2->digits.load(":/image/digits.png");
m2->graph_color = global->theme->graphColorMap();
prepareLogTableWidget();
#ifdef Q_OS_WIN
{
QFont font;
font = ui->label_repo_name->font();
font.setFamily("Meiryo");
ui->label_repo_name->setFont(font);
font = ui->label_branch_name->font();
font.setFamily("Meiryo");
ui->label_branch_name->setFont(font);
}
#endif
connect(this, &MainWindow::signalWriteLog, this, &MainWindow::writeLog_);
connect(ui->dockWidget_log, &QDockWidget::visibilityChanged, this, &MainWindow::onLogVisibilityChanged);
connect(ui->widget_log, &TextEditorWidget::idle, this, &MainWindow::onLogIdle);
connect(ui->treeWidget_repos, &RepositoriesTreeWidget::dropped, this, &MainWindow::onRepositoriesTreeDropped);
connect((AbstractPtyProcess *)getPtyProcess(), &AbstractPtyProcess::completed, this, &MainWindow::onPtyProcessCompleted);
connect(this, &MainWindow::remoteInfoChanged, [&](){
ui->lineEdit_remote->setText(currentRemoteName());
});
connect(this, &MainWindow::signalSetRemoteChanged, [&](bool f){
setRemoteChanged(f);
updateButton();
});
connect(new QShortcut(QKeySequence("Ctrl+T"), this), &QShortcut::activated, this, &MainWindow::test);
//
QString path = getBookmarksFilePath();
*getReposPtr() = RepositoryBookmark::load(path);
updateRepositoriesList();
- webContext()->set_keep_alive_enabled(true);
- getAvatarLoader()->start(this);
- connect(getAvatarLoader(), &AvatarLoader::updated, this, &MainWindow::onAvatarUpdated);
-
- *ptrUpdateFilesListCounter() = 0;
+ {
+ // アイコン取得機能
+ webContext()->set_keep_alive_enabled(true);
+ getAvatarLoader()->start(this);
+ connect(getAvatarLoader(), &AvatarLoader::updated, this, &MainWindow::onAvatarUpdated);
+ }
connect(frame()->filediffwidget(), &FileDiffWidget::textcodecChanged, [&](){ updateDiffView(frame()); });
if (!global->start_with_shift_key && appsettings()->remember_and_restore_window_position) {
Qt::WindowStates state = windowState();
MySettings settings;
settings.beginGroup("MainWindow");
bool maximized = settings.value("Maximized").toBool();
restoreGeometry(settings.value("Geometry").toByteArray());
settings.endGroup();
if (maximized) {
state |= Qt::WindowMaximized;
setWindowState(state);
}
}
ui->action_sidebar->setChecked(true);
startTimers();
}
MainWindow::~MainWindow()
{
+ cancelPendingUserEvents();
+
stopPtyProcess();
getAvatarLoader()->stop();
deleteTempFiles();
delete m2;
delete m1;
delete ui;
}
RepositoryWrapperFrame *MainWindow::frame()
{
return ui->frame_repository_wrapper;
}
RepositoryWrapperFrame const *MainWindow::frame() const
{
return ui->frame_repository_wrapper;
}
-void MainWindow::notifyRemoteChanged(bool f)
+/**
+ * @brief イベントをポストする
+ * @param receiver 宛先
+ * @param event イベント
+ * @param ms_later 遅延時間（0なら即座）
+ */
+void MainWindow::postEvent(QObject *receiver, QEvent *event, int ms_later)
{
- postUserFunctionEvent([&](QVariant const &v){
- setRemoteChanged(v.toBool());
- updateButton();
- }, QVariant(f));
+ if (ms_later <= 0) {
+ QApplication::postEvent(this, event);
+ } else {
+ auto at = QDateTime::currentDateTime().addMSecs(ms_later);
+ m2->event_item_list.emplace_back(receiver, event, at);
+ std::stable_sort(m2->event_item_list.begin(), m2->event_item_list.end(), [](EventItem const &l, EventItem const &r){
+ return l.at > r.at; // 降順
+ });
+ }
}
-void MainWindow::postStartEvent()
+/**
+ * @brief ユーザー関数イベントをポストする
+ * @param fn 関数
+ * @param v QVariant
+ * @param p ポインタ
+ * @param ms_later 遅延時間（0なら即座）
+ */
+void MainWindow::postUserFunctionEvent(const std::function<void (const QVariant &, void *ptr)> &fn, const QVariant &v, void *p, int ms_later)
{
- QTimer::singleShot(100, [&](){
- QApplication::postEvent(this, new StartEvent);
- });
+ postEvent(this, new UserFunctionEvent(fn, v, p), ms_later);
+}
+
+/**
+ * @brief 未送信のイベントをすべて削除する
+ */
+void MainWindow::cancelPendingUserEvents()
+{
+ for (auto &item : m2->event_item_list) {
+ delete item.event;
+ }
+ m2->event_item_list.clear();
+}
+
+/**
+ * @brief 開始イベントをポストする
+ */
+void MainWindow::postStartEvent(int ms_later)
+{
+ postEvent(this, new StartEvent, ms_later);
+}
+
+/**
+ * @brief インターバルタイマを開始する
+ */
+void MainWindow::startTimers()
+{
+ // タイマ開始
+ connect(&m2->interval_10ms_timer, &QTimer::timeout, this, &MainWindow::onInterval10ms);
+ m2->interval_10ms_timer.setInterval(10);
+ m2->interval_10ms_timer.start();
+}
+
+/**
+ * @brief 10ms間隔のインターバルタイマ
+ */
+void MainWindow::onInterval10ms()
+{
+ {
+ // ユーザーイベントの処理
+
+ std::vector<EventItem> items; // 処理するイベント
+
+ QDateTime now = QDateTime::currentDateTime(); // 現在時刻
+
+ size_t i = m2->event_item_list.size(); // 後ろから走査
+ while (i > 0) {
+ i--;
+ if (m2->event_item_list[i].at <= now) { // 予約時間を過ぎていたら
+ items.push_back(m2->event_item_list[i]); // 処理リストに追加
+ m2->event_item_list.erase(m2->event_item_list.begin() + i); // 処理待ちリストから削除
+ }
+ }
+
+ // イベントをポストする
+ for (auto it = items.rbegin(); it != items.rend(); it++) {
+ QApplication::postEvent(it->receiver, it->event);
+ }
+ }
+
+ {
+ // PTYプロセスの監視
+
+ bool running = getPtyProcess()->isRunning();
+ if (ui->toolButton_stop_process->isEnabled() != running) {
+ ui->toolButton_stop_process->setEnabled(running); // ボタンの状態を設定
+ ui->action_stop_process->setEnabled(running);
+ setNetworkingCommandsEnabled(!running);
+ }
+ if (!running) {
+ setInteractionMode(InteractionMode::None);
+ }
+
+ // PTYプロセスの出力をログに書き込む
+ while (1) {
+ char tmp[1024];
+ int len = getPtyProcess()->readOutput(tmp, sizeof(tmp));
+ if (len < 1) break;
+ writeLog(tmp, len);
+ }
+ }
}
bool MainWindow::shown()
{
m2->repos_panel_width = ui->stackedWidget_leftpanel->width();
ui->stackedWidget_leftpanel->setCurrentWidget(ui->page_repos);
ui->action_repositories_panel->setChecked(true);
{
MySettings settings;
{
settings.beginGroup("Remote");
bool f = settings.value("Online", true).toBool();
settings.endGroup();
setRemoteOnline(f, false);
}
{
settings.beginGroup("MainWindow");
int n = settings.value("FirstColumnWidth", 50).toInt();
if (n < 10) n = 50;
frame()->logtablewidget()->setColumnWidth(0, n);
settings.endGroup();
}
}
updateUI();
- postStartEvent(); // 開始イベント
+ postStartEvent(100); // 開始イベント（100ms後）
return true;
}
bool MainWindow::isUninitialized()
{
return !misc::isExecutable(appsettings()->git_command) || !misc::isExecutable(appsettings()->file_command);
}
void MainWindow::onStartEvent()
{
if (isUninitialized()) { // gitコマンドの有効性チェック
if (!execWelcomeWizardDialog()) { // ようこそダイアログを表示
close(); // キャンセルされたらプログラム終了
}
}
if (isUninitialized()) { // 正しく初期設定されたか
- postStartEvent(); // 初期設定されなかったら、もういちどようこそダイアログを出す。
+ postStartEvent(100); // 初期設定されなかったら、もういちどようこそダイアログを出す（100ms後）
} else {
// 外部コマンド登録
setGitCommand(appsettings()->git_command, false);
setFileCommand(appsettings()->file_command, false);
setGpgCommand(appsettings()->gpg_command, false);
setSshCommand(appsettings()->ssh_command, false);
// メインウィンドウのタイトルを設定
updateWindowTitle(git());
// プログラムバーション表示
writeLog(AboutDialog::appVersion() + '\n');
// gitコマンドバージョン表示
logGitVersion();
}
}
-void MainWindow::startTimers()
-{
- // interval 10ms
-
- connect(&m2->interval_10ms_timer, &QTimer::timeout, [&](){
- const int ms = 10;
- auto *p1 = ptrUpdateCommitTableCounter();
- if (*p1 > 0) {
- if (*p1 > ms) {
- *p1 -= ms;
- } else {
- *p1 = 0;
- frame()->logtablewidget()->viewport()->update();
- }
- }
- auto *p2 = ptrUpdateFilesListCounter();
- if (*p2 > 0) {
- if (*p2 > ms) {
- *p2 -= ms;
- } else {
- *p2 = 0;
- updateCurrentFilesList(frame());
- }
- }
- });
- m2->interval_10ms_timer.setInterval(10);
- m2->interval_10ms_timer.start();
-
- startTimer(10);
-}
-
void MainWindow::setCurrentLogRow(RepositoryWrapperFrame *frame, int row)
{
if (row >= 0 && row < frame->logtablewidget()->rowCount()) {
- frame->logtablewidget()->setCurrentCell(row, 2);
- frame->logtablewidget()->setFocus();
updateStatusBarText(frame);
+ frame->logtablewidget()->setFocus();
+ frame->logtablewidget()->setCurrentCell(row, 2);
}
}
bool MainWindow::eventFilter(QObject *watched, QEvent *event)
{
QEvent::Type et = event->type();
if (et == QEvent::KeyPress) {
if (QApplication::activeModalWidget()) {
// thru
} else {
auto *e = dynamic_cast<QKeyEvent *>(event);
Q_ASSERT(e);
int k = e->key();
if (k == Qt::Key_Escape) {
if (centralWidget()->isAncestorOf(qApp->focusWidget())) {
ui->treeWidget_repos->setFocus();
return true;
}
}
if (e->modifiers() & Qt::ControlModifier) {
if (k == Qt::Key_Up || k == Qt::Key_Down) {
int rows = frame()->logtablewidget()->rowCount();
int row = frame()->logtablewidget()->currentRow();
if (k == Qt::Key_Up) {
if (row > 0) {
row--;
}
} else if (k == Qt::Key_Down) {
if (row + 1 < rows) {
row++;
}
}
frame()->logtablewidget()->setCurrentCell(row, 0);
return true;
}
}
if (watched == ui->treeWidget_repos) {
if (k == Qt::Key_Enter || k == Qt::Key_Return) {
openSelectedRepository();
return true;
}
if (!(e->modifiers() & Qt::ControlModifier)) {
if (k >= 0 && k < 128 && QChar((uchar)k).isLetterOrNumber()) {
appendCharToRepoFilter(k);
return true;
}
if (k == Qt::Key_Backspace) {
backspaceRepoFilter();
return true;
}
if (k == Qt::Key_Escape) {
clearRepoFilter();
return true;
}
}
} else if (watched == frame()->logtablewidget()) {
if (k == Qt::Key_Home) {
setCurrentLogRow(frame(), 0);
return true;
}
if (k == Qt::Key_Escape) {
ui->treeWidget_repos->setFocus();
return true;
}
} else if (watched == frame()->fileslistwidget() || watched == frame()->unstagedFileslistwidget() || watched == frame()->stagedFileslistwidget()) {
if (k == Qt::Key_Escape) {
frame()->logtablewidget()->setFocus();
return true;
}
}
}
} else if (et == QEvent::FocusIn) {
auto SelectItem = [](QListWidget *w){
int row = w->currentRow();
if (row < 0) {
row = 0;
w->setCurrentRow(row);
}
w->setItemSelected(w->item(row), true);
w->viewport()->update();
};
// ファイルリストがフォーカスを得たとき、diffビューを更新する。（コンテキストメニュー対応）
if (watched == frame()->unstagedFileslistwidget()) {
m2->last_focused_file_list = watched;
updateStatusBarText(frame());
updateUnstagedFileCurrentItem(frame());
SelectItem(frame()->unstagedFileslistwidget());
return true;
}
if (watched == frame()->stagedFileslistwidget()) {
m2->last_focused_file_list = watched;
updateStatusBarText(frame());
updateStagedFileCurrentItem(frame());
SelectItem(frame()->stagedFileslistwidget());
return true;
}
if (watched == frame()->fileslistwidget()) {
m2->last_focused_file_list = watched;
SelectItem(frame()->fileslistwidget());
return true;
}
}
return false;
}
bool MainWindow::event(QEvent *event)
{
QEvent::Type et = event->type();
if (et == QEvent::KeyPress) {
auto *e = dynamic_cast<QKeyEvent *>(event);
Q_ASSERT(e);
int k = e->key();
if (k == Qt::Key_Escape) {
emit onEscapeKeyPressed();
} else if (k == Qt::Key_Delete) {
if (qApp->focusWidget() == ui->treeWidget_repos) {
removeSelectedRepositoryFromBookmark(true);
return true;
}
}
- } else if (et == (QEvent::Type)EventUserFunction) {
+ } else if (et == (QEvent::Type)UserEvent::UserFunction) {
if (auto *e = (UserFunctionEvent *)event) {
- e->func(e->var);
+ e->func(e->var, e->ptr);
return true;
}
}
return BasicMainWindow::event(event);
}
void MainWindow::customEvent(QEvent *e)
{
if (e->type() == (QEvent::Type)UserEvent::Start) {
onStartEvent();
return;
}
}
void MainWindow::closeEvent(QCloseEvent *event)
{
MySettings settings;
if (appsettings()->remember_and_restore_window_position) {
setWindowOpacity(0);
Qt::WindowStates state = windowState();
bool maximized = (state & Qt::WindowMaximized) != 0;
if (maximized) {
state &= ~Qt::WindowMaximized;
setWindowState(state);
}
{
settings.beginGroup("MainWindow");
settings.setValue("Maximized", maximized);
settings.setValue("Geometry", saveGeometry());
settings.endGroup();
}
}
{
settings.beginGroup("MainWindow");
settings.setValue("FirstColumnWidth", frame()->logtablewidget()->columnWidth(0));
settings.endGroup();
}
QMainWindow::closeEvent(event);
}
void MainWindow::setStatusBarText(QString const &text)
{
m2->status_bar_label->setText(text);
}
void MainWindow::clearStatusBarText()
{
setStatusBarText(QString());
}
void MainWindow::onLogVisibilityChanged()
{
ui->action_window_log->setChecked(ui->dockWidget_log->isVisible());
}
void MainWindow::internalWriteLog(char const *ptr, int len)
{
ui->widget_log->logicalMoveToBottom();
ui->widget_log->write(ptr, len, false);
ui->widget_log->setChanged(false);
setInteractionCanceled(false);
}
void MainWindow::buildRepoTree(QString const &group, QTreeWidgetItem *item, QList<RepositoryItem> *repos)
{
QString name = item->text(0);
if (isGroupItem(item)) {
int n = item->childCount();
for (int i = 0; i < n; i++) {
QTreeWidgetItem *child = item->child(i);
QString sub = group / name;
buildRepoTree(sub, child, repos);
}
} else {
RepositoryItem const *repo = repositoryItem(item);
if (repo) {
RepositoryItem newrepo = *repo;
newrepo.name = name;
newrepo.group = group;
item->setData(0, IndexRole, repos->size());
repos->push_back(newrepo);
}
}
}
void MainWindow::refrectRepositories()
{
QList<RepositoryItem> newrepos;
int n = ui->treeWidget_repos->topLevelItemCount();
for (int i = 0; i < n; i++) {
QTreeWidgetItem *item = ui->treeWidget_repos->topLevelItem(i);
buildRepoTree(QString(), item, &newrepos);
}
*getReposPtr() = std::move(newrepos);
saveRepositoryBookmarks();
}
void MainWindow::onRepositoriesTreeDropped()
{
refrectRepositories();
QTreeWidgetItem *item = ui->treeWidget_repos->currentItem();
if (item) item->setExpanded(true);
}
const QPixmap &MainWindow::digitsPixmap() const
{
return m2->digits;
}
int MainWindow::digitWidth() const
{
return 5;
}
int MainWindow::digitHeight() const
{
return 7;
}
void MainWindow::drawDigit(QPainter *pr, int x, int y, int n) const
{
int w = digitWidth();
int h = digitHeight();
pr->drawPixmap(x, y, w, h, m2->digits, n * w, 0, w, h);
}
QString MainWindow::defaultWorkingDir() const
{
return appsettings()->default_working_dir;
}
/**
* @brief サブモジュール情報を取得する
* @param path
* @param commit コミット情報を取得（nullptr可）
* @return
*/
Git::SubmoduleItem const *MainWindow::querySubmoduleByPath(const QString &path, Git::CommitItem *commit)
{
if (commit) *commit = {};
for (auto const &submod : m1->submodules) {
if (submod.path == path) {
if (commit) {
GitPtr g = git(submod);
g->queryCommit(submod.id, commit);
}
return &submod;
}
}
return nullptr;
}
QColor MainWindow::color(unsigned int i)
{
unsigned int n = m2->graph_color.width();
if (n > 0) {
n--;
if (i > n) i = n;
QRgb const *p = (QRgb const *)m2->graph_color.scanLine(0);
return QColor(qRed(p[i]), qGreen(p[i]), qBlue(p[i]));
}
return Qt::black;
}
//QString MainWindow::currentWorkingCopyDir() const
//{
// QString workdir = BasicMainWindow::currentWorkingCopyDir();
// if (workdir.isEmpty()) {
// RepositoryItem const *repo = selectedRepositoryItem();
// if (repo) {
// workdir = repo->local_dir;
// return workdir;
// }
// }
// return workdir;
//}
RepositoryItem const *MainWindow::findRegisteredRepository(QString *workdir) const
{
*workdir = QDir(*workdir).absolutePath();
workdir->replace('\\', '/');
if (Git::isValidWorkingCopy(*workdir)) {
for (RepositoryItem const &item : getRepos()) {
Qt::CaseSensitivity cs = Qt::CaseSensitive;
#ifdef Q_OS_WIN
cs = Qt::CaseInsensitive;
#endif
if (workdir->compare(item.local_dir, cs) == 0) {
return &item;
}
}
}
return nullptr;
}
int MainWindow::repositoryIndex_(QTreeWidgetItem const *item) const
{
if (item) {
int i = item->data(0, IndexRole).toInt();
if (i >= 0 && i < getRepos().size()) {
return i;
}
}
return -1;
}
RepositoryItem const *MainWindow::repositoryItem(QTreeWidgetItem const *item) const
{
int row = repositoryIndex_(item);
QList<RepositoryItem> const &repos = getRepos();
return (row >= 0 && row < repos.size()) ? &repos[row] : nullptr;
}
RepositoryItem const *MainWindow::selectedRepositoryItem() const
{
return repositoryItem(ui->treeWidget_repos->currentItem());
}
static QTreeWidgetItem *newQTreeWidgetItem()
{
auto *item = new QTreeWidgetItem;
item->setSizeHint(0, QSize(20, 20));
return item;
}
QTreeWidgetItem *MainWindow::newQTreeWidgetFolderItem(QString const &name)
{
QTreeWidgetItem *item = newQTreeWidgetItem();
item->setText(0, name);
item->setData(0, IndexRole, GroupItem);
item->setIcon(0, getFolderIcon());
item->setFlags(item->flags() | Qt::ItemIsEditable);
return item;
}
void MainWindow::updateRepositoriesList()
{
QString path = getBookmarksFilePath();
auto *repos = getReposPtr();
*repos = RepositoryBookmark::load(path);
QString filter = getRepositoryFilterText();
ui->treeWidget_repos->clear();
std::map<QString, QTreeWidgetItem *> parentmap;
for (int i = 0; i < repos->size(); i++) {
RepositoryItem const &repo = repos->at(i);
if (!filter.isEmpty() && repo.name.indexOf(filter, 0, Qt::CaseInsensitive) < 0) {
continue;
}
QTreeWidgetItem *parent = nullptr;
{
QString group = repo.group;
if (group.startsWith('/')) {
group = group.mid(1);
}
auto it = parentmap.find(group);
if (it != parentmap.end()) {
parent = it->second;
}
if (!parent) {
QStringList list = group.split('/', QString::SkipEmptyParts);
if (list.isEmpty()) {
list.push_back(tr("Default"));
}
for (QString const &name : list) {
if (name.isEmpty()) continue;
if (!parent) {
auto it = parentmap.find(name);
if (it != parentmap.end()) {
parent = it->second;
} else {
parent = newQTreeWidgetFolderItem(name);
ui->treeWidget_repos->addTopLevelItem(parent);
}
} else {
QTreeWidgetItem *child = newQTreeWidgetFolderItem(name);
parent->addChild(child);
parent = child;
}
parent->setExpanded(true);
}
Q_ASSERT(parent);
parentmap[group] = parent;
}
parent->setData(0, FilePathRole, "");
}
QTreeWidgetItem *child = newQTreeWidgetItem();
child->setText(0, repo.name);
child->setData(0, IndexRole, i);
child->setIcon(0, getRepositoryIcon());
child->setFlags(child->flags() & ~Qt::ItemIsDropEnabled);
parent->addChild(child);
parent->setExpanded(true);
}
}
void MainWindow::showFileList(FilesListType files_list_type)
{
switch (files_list_type) {
case FilesListType::SingleList:
ui->stackedWidget_filelist->setCurrentWidget(ui->page_files);
break;
case FilesListType::SideBySide:
ui->stackedWidget_filelist->setCurrentWidget(ui->page_uncommited);
break;
}
}
+/**
+ * @brief ファイルリストを消去
+ * @param frame
+ */
void MainWindow::clearFileList(RepositoryWrapperFrame *frame)
{
showFileList(FilesListType::SingleList);
frame->unstagedFileslistwidget()->clear();
frame->stagedFileslistwidget()->clear();
frame->fileslistwidget()->clear();
}
void MainWindow::clearDiffView(RepositoryWrapperFrame *frame)
{
frame->filediffwidget()->clearDiffView();
}
void MainWindow::clearRepositoryInfo()
{
internalClearRepositoryInfo();
ui->label_repo_name->setText(QString());
ui->label_branch_name->setText(QString());
}
void MainWindow::setRepositoryInfo(QString const &reponame, QString const &brname)
{
ui->label_repo_name->setText(reponame);
ui->label_branch_name->setText(brname);
}
/**
* @brief 指定のコミットにおけるサブモジュールリストを取得
* @param g
* @param id
* @param out
*/
void MainWindow::updateSubmodules(GitPtr g, QString const &id, QList<Git::SubmoduleItem> *out)
{
*out = {};
QList<Git::SubmoduleItem> submodules;
if (id.isEmpty()) {
submodules = g->submodules();
} else {
GitTreeItemList list;
GitObjectCache objcache;
objcache.setup(g);
// サブモジュールリストを取得する
{
GitCommit tree;
GitCommit::parseCommit(&objcache, id, &tree);
parseGitTreeObject(&objcache, tree.tree_id, {}, &list);
for (GitTreeItem const &item : list) {
if (item.type == GitTreeItem::Type::BLOB && item.name == ".gitmodules") {
Git::Object obj = objcache.catFile(item.id);
if (!obj.content.isEmpty()) {
parseGitSubModules(obj.content, &submodules);
}
}
}
}
// サブモジュールに対応するIDを求める
for (int i = 0; i < submodules.size(); i++) {
QStringList vars = submodules[i].path.split('/');
for (int j = 0; j < vars.size(); j++) {
for (int k = 0; k < list.size(); k++) {
if (list[k].name == vars[j]) {
if (list[k].type == GitTreeItem::Type::BLOB) {
if (j + 1 == vars.size()) {
submodules[i].id = list[k].id;
goto done;
}
} else if (list[k].type == GitTreeItem::Type::TREE) {
Git::Object obj = objcache.catFile(list[k].id);
parseGitTreeObject(obj.content, {}, &list);
break;
}
}
}
}
done:;
}
}
*out = submodules;
}
const Git::CommitItemList &MainWindow::getLogs(RepositoryWrapperFrame const *frame) const
{
// return m1->logs;
return frame->logs;
}
const Git::CommitItem *MainWindow::getLog(RepositoryWrapperFrame const *frame, int index) const
{
Git::CommitItemList const &logs = frame->logs;
return (index >= 0 && index < (int)logs.size()) ? &logs[index] : nullptr;
}
Git::CommitItemList *MainWindow::getLogsPtr(RepositoryWrapperFrame *frame)
{
return &frame->logs;
}
void MainWindow::setLogs(RepositoryWrapperFrame *frame, const Git::CommitItemList &logs)
{
frame->logs = logs;
}
void MainWindow::clearLogs(RepositoryWrapperFrame *frame)
{
frame->logs.clear();
}
/**
* @brief リストウィジェット用ファイルアイテムを作成する
* @param data
* @return
*/
QListWidgetItem *MainWindow::NewListWidgetFileItem(MainWindow::ObjectData const &data)
{
const bool issubmodule = data.submod; // サブモジュール
QString header = data.header; // ヘッダ（バッジ識別子）
if (header.isEmpty()) {
header = "(??\?) "; // damn trigraph
}
QString text = data.path; // テキスト
if (issubmodule) {
text += QString(" <%0> [%1] %2")
.arg(data.submod.id.mid(0, 7))
.arg(misc::makeDateTimeString(data.submod_commit.commit_date))
.arg(data.submod_commit.message)
;
}
QListWidgetItem *item = new QListWidgetItem(text);
item->setSizeHint(QSize(item->sizeHint().width(), 18));
item->setData(FilePathRole, data.path);
item->setData(DiffIndexRole, data.idiff);
item->setData(HunkIndexRole, -1);
item->setData(HeaderRole, header);
item->setData(IsSubmoduleRole, issubmodule);
if (issubmodule) {
item->setToolTip(text); // ツールチップ
}
return item;
}
/**
* @brief 差分リスト情報をもとにリストウィジェットへアイテムを追加する
* @param diff_list
* @param fn_add_item
*/
void MainWindow::addDiffItems(const QList<Git::Diff> *diff_list, const std::function<void (ObjectData const &data)> &fn_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;
}
ObjectData data;
data.id = diff.blob.b_id;
data.path = diff.path;
data.submod = diff.b_submodule.item;
data.submod_commit = diff.b_submodule.commit;
data.header = header;
data.idiff = idiff;
fn_add_item(data);
}
}
+/**
+ * @brief コミットログを更新（100ms遅延）
+ */
+void MainWindow::updateCommitLogTableLater(RepositoryWrapperFrame *frame, int ms_later)
+{
+ if (!frame) {
+ qDebug();
+ }
+ postUserFunctionEvent([&](QVariant const &, void *ptr){
+ if (ptr) {
+ RepositoryWrapperFrame *frame = reinterpret_cast<RepositoryWrapperFrame *>(ptr);
+ frame->logtablewidget()->viewport()->update();
+ }
+ }, {}, reinterpret_cast<void *>(frame), ms_later);
+}
+
/**
* @brief ファイルリストを更新
* @param id コミットID
* @param wait
*/
void MainWindow::updateFilesList(RepositoryWrapperFrame *frame, QString id, bool wait)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
if (!wait) return;
clearFileList(frame);
Git::FileStatusList stats = g->status_s();
setUncommitedChanges(!stats.empty());
FilesListType files_list_type = FilesListType::SingleList;
bool staged = false;
auto AddItem = [&](ObjectData const &data){
QListWidgetItem *item = NewListWidgetFileItem(data);
switch (files_list_type) {
case FilesListType::SingleList:
frame->fileslistwidget()->addItem(item);
break;
case FilesListType::SideBySide:
if (staged) {
frame->stagedFileslistwidget()->addItem(item);
} else {
frame->unstagedFileslistwidget()->addItem(item);
}
break;
}
};
if (id.isEmpty()) {
bool uncommited = isThereUncommitedChanges();
if (uncommited) {
files_list_type = FilesListType::SideBySide;
}
bool ok = false;
auto diffs = makeDiffs(uncommited ? QString() : id, &ok);
setDiffResult(diffs);
if (!ok) return;
std::map<QString, int> diffmap;
for (int idiff = 0; idiff < diffResult()->size(); idiff++) {
Git::Diff const &diff = diffResult()->at(idiff);
QString filename = diff.path;
if (!filename.isEmpty()) {
diffmap[filename] = idiff;
}
}
showFileList(files_list_type);
for (Git::FileStatus const &s : stats) {
staged = (s.isStaged() && s.code_y() == ' ');
int idiff = -1;
QString header;
auto it = diffmap.find(s.path1());
Git::Diff const *diff = nullptr;
if (it != diffmap.end()) {
idiff = it->second;
diff = &diffResult()->at(idiff);
}
QString path = s.path1();
if (s.code() == Git::FileStatusCode::Unknown) {
qDebug() << "something wrong...";
} else if (s.code() == Git::FileStatusCode::Untracked) {
// nop
} else if (s.isUnmerged()) {
header += "(unmerged) ";
} else if (s.code() == Git::FileStatusCode::AddedToIndex) {
header = "(add) ";
} else if (s.code_x() == 'D' || s.code_y() == 'D' || s.code() == Git::FileStatusCode::DeletedFromIndex) {
header = "(del) ";
} else if (s.code_x() == 'R' || s.code() == Git::FileStatusCode::RenamedInIndex) {
header = "(ren) ";
path = s.path2(); // renamed newer path
} else if (s.code_x() == 'M' || s.code_y() == 'M') {
header = "(chg) ";
}
ObjectData data;
data.path = path;
data.header = header;
data.idiff = idiff;
if (diff) {
data.submod = diff->b_submodule.item; // TODO:
if (data.submod) {
GitPtr g = git(data.submod);
g->queryCommit(data.submod.id, &data.submod_commit);
}
}
AddItem(data);
}
} else {
bool ok = false;
auto diffs = makeDiffs(id, &ok);
setDiffResult(diffs);
if (!ok) return;
showFileList(files_list_type);
addDiffItems(diffResult(), AddItem);
}
for (Git::Diff const &diff : *diffResult()) {
QString key = GitDiff::makeKey(diff);
(*getDiffCacheMap())[key] = diff;
}
}
/**
* @brief ファイルリストを更新
* @param id
* @param diff_list
* @param listwidget
*/
void MainWindow::updateFilesList2(QString const &id, QList<Git::Diff> *diff_list, QListWidget *listwidget)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
listwidget->clear();
auto AddItem = [&](ObjectData const &data){
QListWidgetItem *item = NewListWidgetFileItem(data);
listwidget->addItem(item);
};
GitDiff dm(getObjCache());
if (!dm.diff(id, submodules(), diff_list)) return;
addDiffItems(diff_list, AddItem);
}
void MainWindow::updateFilesList(RepositoryWrapperFrame *frame, Git::CommitItem const &commit, bool wait)
{
QString id;
if (Git::isUncommited(commit)) {
// empty id for uncommited changes
} else {
id = commit.commit_id;
}
updateFilesList(frame, id, wait);
}
void MainWindow::updateCurrentFilesList(RepositoryWrapperFrame *frame)
{
auto logs = getLogs(frame);
QTableWidgetItem *item = frame->logtablewidget()->item(selectedLogIndex(frame), 0);
if (!item) return;
int index = item->data(IndexRole).toInt();
int count = (int)logs.size();
if (index < count) {
updateFilesList(frame, logs[index], true);
}
}
void MainWindow::prepareLogTableWidget()
{
ui->frame_repository_wrapper->prepareLogTableWidget();
}
void MainWindow::detectGitServerType(GitPtr const &g)
{
setServerType(ServerType::Standard);
*ptrGitHub() = GitHubRepositoryInfo();
QString push_url;
QList<Git::Remote> remotes;
g->getRemoteURLs(&remotes);
for (Git::Remote const &r : remotes) {
if (r.purpose == "push") {
push_url = r.url;
}
}
auto Check = [&](QString const &s){
int i = push_url.indexOf(s);
if (i > 0) return i + s.size();
return 0;
};
// check GitHub
int pos = Check("@github.com:");
if (pos == 0) {
pos = Check("://github.com/");
}
if (pos > 0) {
int end = push_url.size();
{
QString s = ".git";
if (push_url.endsWith(s)) {
end -= s.size();
}
}
QString s = push_url.mid(pos, end - pos);
int i = s.indexOf('/');
if (i > 0) {
auto *p = ptrGitHub();
QString user = s.mid(0, i);
QString repo = s.mid(i + 1);
p->owner_account_name = user;
p->repository_name = repo;
}
setServerType(ServerType::GitHub);
}
}
void MainWindow::clearLog(RepositoryWrapperFrame *frame)
{
clearLogs(frame);
clearLabelMap();
setUncommitedChanges(false);
frame->clearLogContents();
}
void MainWindow::openRepository_(GitPtr g, bool keep_selection)
{
openRepository_(frame(), g, keep_selection);
}
void MainWindow::openRepository_(RepositoryWrapperFrame *frame, GitPtr g, bool keep_selection)
{
getObjCache()->setup(g);
int scroll_pos = -1;
int select_row = -1;
if (keep_selection) {
scroll_pos = frame->logtablewidget()->verticalScrollBar()->value();
select_row = frame->logtablewidget()->currentRow();
}
if (isValidWorkingCopy(g)) {
bool do_fetch = isOnlineMode() && (getForceFetch() || appsettings()->automatically_fetch_when_opening_the_repository);
setForceFetch(false);
if (do_fetch) {
if (!fetch(g, false)) {
return;
}
}
clearLog(frame);
clearRepositoryInfo();
detectGitServerType(g);
updateFilesList(frame, QString(), true);
bool canceled = false;
frame->logtablewidget()->setEnabled(false);
// ログを取得
setLogs(frame, retrieveCommitLog(g));
// ブランチを取得
queryBranches(g);
// タグを取得
ptrTagMap()->clear();
QList<Git::Tag> tags = g->tags();
for (Git::Tag const &tag : tags) {
Git::Tag t = tag;
t.id = getObjCache()->getCommitIdFromTag(t.id);
(*ptrTagMap())[t.id].push_back(t);
}
frame->logtablewidget()->setEnabled(true);
- updateCommitTableLater();
+ updateCommitLogTableLater(frame, 100); // ミコットログを更新（100ms後）
if (canceled) return;
QString branch_name;
if (currentBranch().flags & Git::Branch::HeadDetachedAt) {
branch_name += QString("(HEAD detached at %1)").arg(currentBranchName());
}
if (currentBranch().flags & Git::Branch::HeadDetachedFrom) {
branch_name += QString("(HEAD detached from %1)").arg(currentBranchName());
}
if (branch_name.isEmpty()) {
branch_name = currentBranchName();
}
QString repo_name = currentRepositoryName();
setRepositoryInfo(repo_name, branch_name);
} else {
clearLog(frame);
clearRepositoryInfo();
}
if (!g) return;
updateRemoteInfo();
updateWindowTitle(g);
setHeadId(getObjCache()->revParse("HEAD"));
if (isThereUncommitedChanges()) {
Git::CommitItem item;
item.parent_ids.push_back(currentBranch().id);
item.message = tr("Uncommited changes");
auto p = getLogsPtr(frame);
p->insert(p->begin(), item);
}
prepareLogTableWidget();
auto const &logs = getLogs(frame);
const int count = logs.size();
frame->logtablewidget()->setRowCount(count);
int selrow = 0;
for (int row = 0; row < count; row++) {
Git::CommitItem const *commit = &logs[row];
{
auto *item = new QTableWidgetItem;
item->setData(IndexRole, row);
frame->logtablewidget()->setItem(row, 0, item);
}
int col = 1; // カラム0はコミットグラフなので、その次から
auto AddColumn = [&](QString const &text, bool bold, QString const &tooltip){
auto *item = new QTableWidgetItem(text);
if (!tooltip.isEmpty()) {
QString tt = tooltip;
tt.replace('\n', ' ');
tt = tt.toHtmlEscaped();
tt = "<p style='white-space: pre'>" + tt + "</p>";
item->setToolTip(tt);
}
if (bold) {
QFont font = item->font();
font.setBold(true);
item->setFont(font);
}
frame->logtablewidget()->setItem(row, col, item);
col++;
};
QString commit_id;
QString datetime;
QString author;
QString message;
QString message_ex;
bool isHEAD = (commit->commit_id == getHeadId());
bool bold = false;
{
if (Git::isUncommited(*commit)) { // 未コミットの時
bold = true; // 太字
selrow = row;
} else {
if (isHEAD && !isThereUncommitedChanges()) { // HEADで、未コミットがないとき
bold = true; // 太字
selrow = row;
}
commit_id = abbrevCommitID(*commit);
}
datetime = misc::makeDateTimeString(commit->commit_date);
author = commit->author;
message = commit->message;
message_ex = makeCommitInfoText(frame, row, &(*getLabelMap())[row]);
}
AddColumn(commit_id, false, QString());
AddColumn(datetime, false, QString());
AddColumn(author, false, QString());
AddColumn(message, bold, message + message_ex);
frame->logtablewidget()->setRowHeight(row, 24);
}
int t = frame->logtablewidget()->columnWidth(0);
frame->logtablewidget()->resizeColumnsToContents();
frame->logtablewidget()->setColumnWidth(0, t);
frame->logtablewidget()->horizontalHeader()->setStretchLastSection(false);
frame->logtablewidget()->horizontalHeader()->setStretchLastSection(true);
m2->last_focused_file_list = nullptr;
frame->logtablewidget()->setFocus();
if (select_row < 0) {
setCurrentLogRow(frame, selrow);
} else {
setCurrentLogRow(frame, select_row);
frame->logtablewidget()->verticalScrollBar()->setValue(scroll_pos >= 0 ? scroll_pos : 0);
}
updateUI();
}
void MainWindow::removeSelectedRepositoryFromBookmark(bool ask)
{
int i = indexOfRepository(ui->treeWidget_repos->currentItem());
removeRepositoryFromBookmark(i, ask);
}
void MainWindow::setNetworkingCommandsEnabled(bool enabled)
{
ui->action_clone->setEnabled(enabled);
ui->toolButton_clone->setEnabled(enabled);
if (!Git::isValidWorkingCopy(currentWorkingCopyDir())) {
enabled = false;
}
bool opened = !currentRepository().name.isEmpty();
ui->action_fetch->setEnabled(enabled || opened);
ui->toolButton_fetch->setEnabled(enabled || opened);
if (isOnlineMode()) {
ui->action_fetch->setText(tr("Fetch"));
ui->toolButton_fetch->setText(tr("Fetch"));
} else {
ui->action_fetch->setText(tr("Update"));
ui->toolButton_fetch->setText(tr("Update"));
}
ui->action_fetch_prune->setEnabled(enabled);
ui->action_pull->setEnabled(enabled);
ui->action_push->setEnabled(enabled);
ui->action_push_u->setEnabled(enabled);
ui->action_push_all_tags->setEnabled(enabled);
ui->toolButton_pull->setEnabled(enabled);
ui->toolButton_push->setEnabled(enabled);
}
void MainWindow::updateUI()
{
setNetworkingCommandsEnabled(isOnlineMode());
ui->toolButton_fetch->setDot(getRemoteChanged());
Git::Branch b = currentBranch();
ui->toolButton_push->setNumber(b.ahead > 0 ? b.ahead : -1);
ui->toolButton_pull->setNumber(b.behind > 0 ? b.behind : -1);
{
bool f = isRepositoryOpened();
ui->toolButton_status->setEnabled(f);
ui->toolButton_terminal->setEnabled(f);
ui->toolButton_explorer->setEnabled(f);
ui->action_repository_status->setEnabled(f);
ui->action_terminal->setEnabled(f);
ui->action_explorer->setEnabled(f);
}
}
void MainWindow::updateStatusBarText(RepositoryWrapperFrame *frame)
{
QString text;
QWidget *w = qApp->focusWidget();
if (w == ui->treeWidget_repos) {
RepositoryItem const *repo = selectedRepositoryItem();
if (repo) {
text = QString("%1 : %2")
.arg(repo->name)
.arg(misc::normalizePathSeparator(repo->local_dir))
;
}
} else if (w == frame->logtablewidget()) {
QTableWidgetItem *item = frame->logtablewidget()->item(selectedLogIndex(frame), 0);
if (item) {
auto const &logs = getLogs(frame);
int row = item->data(IndexRole).toInt();
if (row < (int)logs.size()) {
Git::CommitItem const &commit = logs[row];
if (Git::isUncommited(commit)) {
text = tr("Uncommited changes");
} else {
QString id = commit.commit_id;
text = QString("%1 : %2%3")
.arg(id.mid(0, 7))
.arg(commit.message)
.arg(makeCommitInfoText(frame, row, nullptr))
;
}
}
}
}
setStatusBarText(text);
}
void MainWindow::mergeBranch(QString const &commit, Git::MergeFastForward ff)
{
if (commit.isEmpty()) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->mergeBranch(commit, ff);
openRepository(true);
}
void MainWindow::mergeBranch(Git::CommitItem const *commit, Git::MergeFastForward ff)
{
if (!commit) return;
mergeBranch(commit->commit_id, ff);
}
void MainWindow::rebaseBranch(Git::CommitItem const *commit)
{
if (!commit) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
QString text = tr("Are you sure you want to rebase the commit ?");
text += "\n\n";
text += "> git rebase " + commit->commit_id;
int r = QMessageBox::information(this, tr("Rebase"), text, QMessageBox::Ok, QMessageBox::Cancel);
if (r == QMessageBox::Ok) {
g->rebaseBranch(commit->commit_id);
openRepository(true);
}
}
void MainWindow::cherrypick(Git::CommitItem const *commit)
{
if (!commit) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
int n = commit->parent_ids.size();
if (n == 1) {
g->cherrypick(commit->commit_id);
} else if (n > 1) {
Git::CommitItem head;
Git::CommitItem pick;
g->queryCommit(g->rev_parse("HEAD"), &head);
g->queryCommit(commit->commit_id, &pick);
QList<Git::CommitItem> parents;
for (int i = 0; i < n; i++) {
QString id = commit->commit_id + QString("^%1").arg(i + 1);
id = g->rev_parse(id);
Git::CommitItem item;
g->queryCommit(id, &item);
parents.push_back(item);
}
CherryPickDialog dlg(this, head, pick, parents);
if (dlg.exec() == QDialog::Accepted) {
QString cmd = "-m %1 ";
cmd = cmd.arg(dlg.number());
if (dlg.allowEmpty()) {
cmd += "--allow-empty ";
}
cmd += commit->commit_id;
g->cherrypick(cmd);
} else {
return;
}
}
openRepository(true);
}
void MainWindow::merge(RepositoryWrapperFrame *frame, Git::CommitItem const *commit)
{
if (isThereUncommitedChanges()) return;
if (!commit) {
int row = selectedLogIndex(frame);
commit = commitItem(frame, row);
if (!commit) return;
}
if (!Git::isValidID(commit->commit_id)) return;
static const char MergeFastForward[] = "MergeFastForward";
QString fastforward;
{
MySettings s;
s.beginGroup("Behavior");
fastforward = s.value(MergeFastForward).toString();
s.endGroup();
}
std::vector<QString> labels;
{
int row = selectedLogIndex(frame);
QList<BranchLabel> const *v = label(row);
for (BranchLabel const &label : *v) {
if (label.kind == BranchLabel::LocalBranch || label.kind == BranchLabel::Tag) {
labels.push_back(label.text);
}
}
std::sort(labels.begin(), labels.end());
labels.erase(std::unique(labels.begin(), labels.end()), labels.end());
}
labels.push_back(commit->commit_id);
QString branch_name = currentBranchName();
MergeDialog dlg(fastforward, labels, branch_name, this);
if (dlg.exec() == QDialog::Accepted) {
fastforward = dlg.getFastForwardPolicy();
{
MySettings s;
s.beginGroup("Behavior");
s.setValue(MergeFastForward, fastforward);
s.endGroup();
}
QString from = dlg.mergeFrom();
mergeBranch(from, MergeDialog::ff(fastforward));
}
}
void MainWindow::showStatus()
{
auto g = git();
if (!g->isValidWorkingCopy()) {
msgNoRepositorySelected();
return;
}
QString s = g->status();
TextEditDialog dlg(this);
dlg.setWindowTitle(tr("Status"));
dlg.setText(s, true);
dlg.exec();
}
void MainWindow::on_action_commit_triggered()
{
commit(frame());
}
void MainWindow::on_action_fetch_triggered()
{
if (isOnlineMode()) {
reopenRepository(true, [&](GitPtr g){
fetch(g, false);
});
} else {
updateRepository();
}
}
void MainWindow::on_action_fetch_prune_triggered()
{
if (!isOnlineMode()) return;
reopenRepository(true, [&](GitPtr g){
fetch(g, true);
});
}
void MainWindow::on_action_push_triggered()
{
push();
}
void MainWindow::on_action_pull_triggered()
{
if (!isOnlineMode()) return;
reopenRepository(true, [&](GitPtr g){
setPtyCondition(PtyCondition::Pull);
setPtyProcessOk(true);
g->pull(getPtyProcess());
while (1) {
if (getPtyProcess()->wait(1)) break;
QApplication::processEvents();
}
});
}
void MainWindow::on_toolButton_push_clicked()
{
ui->action_push->trigger();
}
void MainWindow::on_toolButton_pull_clicked()
{
ui->action_pull->trigger();
}
void MainWindow::on_toolButton_status_clicked()
{
showStatus();
}
void MainWindow::on_action_repository_status_triggered()
{
showStatus();
}
void MainWindow::on_treeWidget_repos_currentItemChanged(QTreeWidgetItem * /*current*/, QTreeWidgetItem * /*previous*/)
{
updateStatusBarText(frame());
}
void MainWindow::on_treeWidget_repos_itemDoubleClicked(QTreeWidgetItem * /*item*/, int /*column*/)
{
openSelectedRepository();
}
-void MainWindow::execCommitPropertyDialog(QWidget *parent, Git::CommitItem const *commit)
+void MainWindow::execCommitPropertyDialog(QWidget *parent, RepositoryWrapperFrame *frame, Git::CommitItem const *commit)
{
- CommitPropertyDialog dlg(parent, this, commit);
+ CommitPropertyDialog dlg(parent, this, frame, commit);
dlg.exec();
}
int MainWindow::indexOfRepository(QTreeWidgetItem const *treeitem) const
{
if (!treeitem) return -1;
return treeitem->data(0, IndexRole).toInt();
}
void MainWindow::on_treeWidget_repos_customContextMenuRequested(const QPoint &pos)
{
QTreeWidgetItem *treeitem = ui->treeWidget_repos->currentItem();
if (!treeitem) return;
RepositoryItem const *repo = repositoryItem(treeitem);
int index = indexOfRepository(treeitem);
if (isGroupItem(treeitem)) { // group item
QMenu menu;
QAction *a_add_new_group = menu.addAction(tr("&Add new group"));
QAction *a_delete_group = menu.addAction(tr("&Delete group"));
QAction *a_rename_group = menu.addAction(tr("&Rename group"));
QPoint pt = ui->treeWidget_repos->mapToGlobal(pos);
QAction *a = menu.exec(pt + QPoint(8, -8));
if (a) {
if (a == a_add_new_group) {
QTreeWidgetItem *child = newQTreeWidgetFolderItem(tr("New group"));
treeitem->addChild(child);
child->setFlags(child->flags() | Qt::ItemIsEditable);
ui->treeWidget_repos->setCurrentItem(child);
return;
}
if (a == a_delete_group) {
QTreeWidgetItem *parent = treeitem->parent();
if (parent) {
int i = parent->indexOfChild(treeitem);
delete parent->takeChild(i);
} else {
int i = ui->treeWidget_repos->indexOfTopLevelItem(treeitem);
delete ui->treeWidget_repos->takeTopLevelItem(i);
}
refrectRepositories();
return;
}
if (a == a_rename_group) {
ui->treeWidget_repos->editItem(treeitem);
return;
}
}
} else if (repo) { // repository item
QString open_terminal = tr("Open &terminal");
QString open_commandprompt = tr("Open command promp&t");
QMenu menu;
QAction *a_open = menu.addAction(tr("&Open"));
menu.addSeparator();
#ifdef Q_OS_WIN
QAction *a_open_terminal = menu.addAction(open_commandprompt);
(void)open_terminal;
#else
QAction *a_open_terminal = menu.addAction(open_terminal);
(void)open_commandprompt;
#endif
a_open_terminal->setIcon(QIcon(":/image/terminal.svg"));
QAction *a_open_folder = menu.addAction(tr("Open &folder"));
a_open_folder->setIcon(QIcon(":/image/explorer.svg"));
menu.addSeparator();
QAction *a_remove = menu.addAction(tr("&Remove"));
menu.addSeparator();
QAction *a_properties = addMenuActionProperty(&menu);
QPoint pt = ui->treeWidget_repos->mapToGlobal(pos);
QAction *a = menu.exec(pt + QPoint(8, -8));
if (a) {
if (a == a_open) {
openSelectedRepository();
return;
}
if (a == a_open_folder) {
openExplorer(repo);
return;
}
if (a == a_open_terminal) {
openTerminal(repo);
return;
}
if (a == a_remove) {
removeRepositoryFromBookmark(index, true);
return;
}
if (a == a_properties) {
execRepositoryPropertyDialog(*repo);
return;
}
}
}
}
void MainWindow::on_tableWidget_log_customContextMenuRequested(const QPoint &pos)
{
int row = selectedLogIndex(frame());
Git::CommitItem const *commit = commitItem(frame(), row);
if (commit) {
bool is_valid_commit_id = Git::isValidID(commit->commit_id);
QMenu menu;
QAction *a_copy_id_7letters = is_valid_commit_id ? menu.addAction(tr("Copy commit id (7 letters)")) : nullptr;
QAction *a_copy_id_complete = is_valid_commit_id ? menu.addAction(tr("Copy commit id (completely)")) : nullptr;
std::set<QAction *> copy_label_actions;
{
QList<BranchLabel> v = sortedLabels(row);
if (!v.isEmpty()) {
auto *copy_lebel_menu = menu.addMenu("Copy label");
for (BranchLabel const &l : v) {
QAction *a = copy_lebel_menu->addAction(l.text);
copy_label_actions.insert(copy_label_actions.end(), a);
}
}
}
menu.addSeparator();
QAction *a_checkout = menu.addAction(tr("Checkout/Branch..."));
menu.addSeparator();
QAction *a_edit_message = nullptr;
auto canEditMessage = [&](){
if (commit->has_child) return false; // 子がないこと
if (Git::isUncommited(*commit)) return false; // 未コミットがないこと
bool is_head = false;
bool has_remote_branch = false;
QList<BranchLabel> const *labels = label(row);
for (const BranchLabel &label : *labels) {
if (label.kind == BranchLabel::Head) {
is_head = true;
} else if (label.kind == BranchLabel::RemoteBranch) {
has_remote_branch = true;
}
}
return is_head && !has_remote_branch; // HEAD && リモートブランチ無し
};
if (canEditMessage()) {
a_edit_message = menu.addAction(tr("Edit message..."));
}
QAction *a_merge = is_valid_commit_id ? menu.addAction(tr("Merge")) : nullptr;
QAction *a_rebase = is_valid_commit_id ? menu.addAction(tr("Rebase")) : nullptr;
QAction *a_cherrypick = is_valid_commit_id ? menu.addAction(tr("Cherry-pick")) : nullptr;
QAction *a_edit_tags = is_valid_commit_id ? menu.addAction(tr("Edit tags...")) : nullptr;
QAction *a_revert = is_valid_commit_id ? menu.addAction(tr("Revert")) : nullptr;
menu.addSeparator();
QAction *a_delbranch = is_valid_commit_id ? menu.addAction(tr("Delete branch...")) : nullptr;
QAction *a_delrembranch = remoteBranches(commit->commit_id, nullptr).isEmpty() ? nullptr : menu.addAction(tr("Delete remote branch..."));
menu.addSeparator();
QAction *a_explore = is_valid_commit_id ? menu.addAction(tr("Explore")) : nullptr;
QAction *a_properties = addMenuActionProperty(&menu);
QAction *a = menu.exec(frame()->logtablewidget()->viewport()->mapToGlobal(pos) + QPoint(8, -8));
if (a) {
if (a == a_copy_id_7letters) {
qApp->clipboard()->setText(commit->commit_id.mid(0, 7));
return;
}
if (a == a_copy_id_complete) {
qApp->clipboard()->setText(commit->commit_id);
return;
}
if (a == a_properties) {
- execCommitPropertyDialog(this, commit);
+ execCommitPropertyDialog(this, frame(), commit);
return;
}
if (a == a_edit_message) {
commitAmend(frame());
return;
}
if (a == a_checkout) {
checkout(this, commit);
return;
}
if (a == a_delbranch) {
deleteBranch(commit);
return;
}
if (a == a_delrembranch) {
deleteRemoteBranch(commit);
return;
}
if (a == a_merge) {
merge(frame(), commit);
return;
}
if (a == a_rebase) {
rebaseBranch(commit);
return;
}
if (a == a_cherrypick) {
cherrypick(commit);
return;
}
if (a == a_edit_tags) {
ui->action_edit_tags->trigger();
return;
}
if (a == a_revert) {
revertCommit(frame());
return;
}
if (a == a_explore) {
execCommitExploreWindow(this, commit);
return;
}
if (copy_label_actions.find(a) != copy_label_actions.end()) {
QString text = a->text();
QApplication::clipboard()->setText(text);
return;
}
}
}
}
void MainWindow::on_listWidget_files_customContextMenuRequested(const QPoint &pos)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
QMenu menu;
QAction *a_delete = menu.addAction(tr("Delete"));
QAction *a_untrack = menu.addAction(tr("Untrack"));
QAction *a_history = menu.addAction(tr("History"));
QAction *a_blame = menu.addAction(tr("Blame"));
QAction *a_properties = addMenuActionProperty(&menu);
QPoint pt = frame()->fileslistwidget()->mapToGlobal(pos) + QPoint(8, -8);
QAction *a = menu.exec(pt);
if (a) {
QListWidgetItem *item = frame()->fileslistwidget()->currentItem();
if (a == a_delete) {
if (askAreYouSureYouWantToRun("Delete", tr("Delete selected files."))) {
for_each_selected_files([&](QString const &path){
g->removeFile(path);
g->chdirexec([&](){
QFile(path).remove();
return true;
});
});
openRepository(false);
}
} else if (a == a_untrack) {
if (askAreYouSureYouWantToRun("Untrack", tr("rm --cached files"))) {
for_each_selected_files([&](QString const &path){
g->rm_cached(path);
});
openRepository(false);
}
} else if (a == a_history) {
execFileHistory(item);
} else if (a == a_blame) {
blame(item);
} else if (a == a_properties) {
execFilePropertyDialog(item);
}
}
}
void MainWindow::on_listWidget_unstaged_customContextMenuRequested(const QPoint &pos)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
QList<QListWidgetItem *> items = frame()->unstagedFileslistwidget()->selectedItems();
if (!items.isEmpty()) {
QMenu menu;
QAction *a_stage = menu.addAction(tr("Stage"));
QAction *a_reset_file = menu.addAction(tr("Reset"));
QAction *a_ignore = menu.addAction(tr("Ignore"));
QAction *a_delete = menu.addAction(tr("Delete"));
QAction *a_untrack = menu.addAction(tr("Untrack"));
QAction *a_history = menu.addAction(tr("History"));
QAction *a_blame = menu.addAction(tr("Blame"));
QAction *a_properties = addMenuActionProperty(&menu);
QPoint pt = frame()->unstagedFileslistwidget()->mapToGlobal(pos) + QPoint(8, -8);
QAction *a = menu.exec(pt);
if (a) {
QListWidgetItem *item = frame()->unstagedFileslistwidget()->currentItem();
if (a == a_stage) {
for_each_selected_files([&](QString const &path){
g->stage(path);
});
updateCurrentFilesList(frame());
return;
}
if (a == a_reset_file) {
QStringList paths;
for_each_selected_files([&](QString const &path){
paths.push_back(path);
});
resetFile(paths);
return;
}
if (a == a_ignore) {
QString gitignore_path = currentWorkingCopyDir() / ".gitignore";
if (items.size() == 1) {
QString file = getFilePath(items[0]);
EditGitIgnoreDialog dlg(this, gitignore_path, file);
if (dlg.exec() == QDialog::Accepted) {
QString appending = dlg.text();
if (!appending.isEmpty()) {
QString text;
QString path = gitignore_path;
path.replace('/', QDir::separator());
{
QFile file(path);
if (file.open(QFile::ReadOnly)) {
text += QString::fromUtf8(file.readAll());
}
}
size_t n = text.size();
if (n > 0 && text[(int)n - 1] != '\n') {
text += '\n'; // 最後に改行を追加
}
text += appending + '\n';
{
QFile file(path);
if (file.open(QFile::WriteOnly)) {
file.write(text.toUtf8());
}
}
updateCurrentFilesList(frame());
return;
}
} else {
return;
}
}
QString append;
for_each_selected_files([&](QString const &path){
if (path == ".gitignore") {
// skip
} else {
append += path + '\n';
}
});
if (TextEditDialog::editFile(this, gitignore_path, ".gitignore", append)) {
updateCurrentFilesList(frame());
}
return;
}
if (a == a_delete) {
if (askAreYouSureYouWantToRun("Delete", "Delete selected files.")) {
for_each_selected_files([&](QString const &path){
g->removeFile(path);
g->chdirexec([&](){
QFile(path).remove();
return true;
});
});
openRepository(false);
}
return;
}
if (a == a_untrack) {
if (askAreYouSureYouWantToRun("Untrack", "rm --cached")) {
for_each_selected_files([&](QString const &path){
g->rm_cached(path);
});
openRepository(false);
}
return;
}
if (a == a_history) {
execFileHistory(item);
return;
}
if (a == a_blame) {
blame(item);
return;
}
if (a == a_properties) {
execFilePropertyDialog(item);
return;
}
}
}
}
void MainWindow::on_listWidget_staged_customContextMenuRequested(const QPoint &pos)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
QListWidgetItem *item = frame()->stagedFileslistwidget()->currentItem();
if (item) {
QString path = getFilePath(item);
QString fullpath = currentWorkingCopyDir() / path;
if (QFileInfo(fullpath).isFile()) {
QMenu menu;
QAction *a_unstage = menu.addAction(tr("Unstage"));
QAction *a_history = menu.addAction(tr("History"));
QAction *a_blame = menu.addAction(tr("Blame"));
QAction *a_properties = addMenuActionProperty(&menu);
QPoint pt = frame()->stagedFileslistwidget()->mapToGlobal(pos) + QPoint(8, -8);
QAction *a = menu.exec(pt);
if (a) {
QListWidgetItem *item = frame()->unstagedFileslistwidget()->currentItem();
if (a == a_unstage) {
g->unstage(path);
openRepository(false);
} else if (a == a_history) {
execFileHistory(item);
} else if (a == a_blame) {
blame(item);
} else if (a == a_properties) {
execFilePropertyDialog(item);
}
}
}
}
}
QStringList MainWindow::selectedFiles_(QListWidget *listwidget) const
{
QStringList list;
QList<QListWidgetItem *> items = listwidget->selectedItems();
for (QListWidgetItem *item : items) {
QString path = getFilePath(item);
list.push_back(path);
}
return list;
}
QStringList MainWindow::selectedFiles() const
{
if (m2->last_focused_file_list == ui->listWidget_files) return selectedFiles_(ui->listWidget_files);
if (m2->last_focused_file_list == ui->listWidget_staged) return selectedFiles_(ui->listWidget_staged);
if (m2->last_focused_file_list == ui->listWidget_unstaged) return selectedFiles_(ui->listWidget_unstaged);
return QStringList();
}
void MainWindow::for_each_selected_files(std::function<void(QString const&)> const &fn)
{
for (QString const &path : selectedFiles()) {
fn(path);
}
}
void MainWindow::execFileHistory(QListWidgetItem *item)
{
if (item) {
QString path = getFilePath(item);
if (!path.isEmpty()) {
execFileHistory(path);
}
}
}
void MainWindow::checkout(QWidget *parent, const Git::CommitItem *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 MainWindow::checkout(RepositoryWrapperFrame *frame)
{
checkout(this, selectedCommitItem(frame));
}
/**
* @brief コミットログの選択が変化した
*/
void MainWindow::doLogCurrentItemChanged(RepositoryWrapperFrame *frame)
{
clearFileList(frame);
int row = selectedLogIndex(frame);
QTableWidgetItem *item = frame->logtablewidget()->item(row, 0);
if (item) {
auto const &logs = getLogs(frame);
int index = item->data(IndexRole).toInt();
if (index < (int)logs.size()) {
+ // ステータスバー更新
updateStatusBarText(frame);
- *ptrUpdateFilesListCounter() = 200;
+ // 少し待ってファイルリストを更新する
+ postUserFunctionEvent([&](QVariant const &, void *p){
+ RepositoryWrapperFrame *frame = reinterpret_cast<RepositoryWrapperFrame *>(p);
+ updateCurrentFilesList(frame);
+ }, {}, reinterpret_cast<void *>(frame), 300); // 300ms後（キーボードのオートリピート想定）
}
} else {
row = -1;
}
updateAncestorCommitMap(frame);
frame->logtablewidget()->viewport()->update();
}
void MainWindow::findNext(RepositoryWrapperFrame *frame)
{
if (m2->search_text.isEmpty()) {
return;
}
auto const &logs = getLogs(frame);
for (int pass = 0; pass < 2; pass++) {
int row = 0;
if (pass == 0) {
row = selectedLogIndex(frame);
if (row < 0) {
row = 0;
} else if (m2->searching) {
row++;
}
}
while (row < (int)logs.size()) {
Git::CommitItem const commit = logs[row];
if (!Git::isUncommited(commit)) {
if (commit.message.indexOf(m2->search_text, 0, Qt::CaseInsensitive) >= 0) {
bool b = frame->logtablewidget()->blockSignals(true);
setCurrentLogRow(frame, row);
frame->logtablewidget()->blockSignals(b);
m2->searching = true;
return;
}
}
row++;
}
}
}
void MainWindow::findText(QString const &text)
{
m2->search_text = text;
}
bool MainWindow::isAncestorCommit(QString const &id)
{
auto it = m2->ancestors.find(id);
return it != m2->ancestors.end();
}
void MainWindow::updateAncestorCommitMap(RepositoryWrapperFrame *frame)
{
m2->ancestors.clear();
auto const &logs = getLogs(frame);
const size_t LogCount = logs.size();
const size_t index = selectedLogIndex(frame);
if (index < LogCount) {
// ok
} else {
return;
}
auto *logsp = getLogsPtr(frame);
auto LogItem = [&](size_t i)->Git::CommitItem &{ return logsp->at(i); };
std::map<QString, size_t> commit_to_index_map;
size_t end = LogCount;
if (index < end) {
for (size_t i = index; i < end; i++) {
Git::CommitItem const &commit = LogItem(i);
commit_to_index_map[commit.commit_id] = i;
auto *item = frame->logtablewidget()->item(i, 0);
QRect r = frame->logtablewidget()->visualItemRect(item);
if (r.y() >= frame->logtablewidget()->height()) {
end = i + 1;
break;
}
}
}
Git::CommitItem *item = &LogItem(index);
if (item) {
m2->ancestors.insert(m2->ancestors.end(), item->commit_id);
}
for (size_t i = index; i < end; i++) {
Git::CommitItem *item = &LogItem(i);
if (isAncestorCommit(item->commit_id)) {
for (QString const &parent : item->parent_ids) {
m2->ancestors.insert(m2->ancestors.end(), parent);
}
}
}
}
void MainWindow::on_action_open_existing_working_copy_triggered()
{
QString dir = defaultWorkingDir();
dir = QFileDialog::getExistingDirectory(this, tr("Add existing working copy"), dir);
addWorkingCopyDir(dir, false);
}
void MainWindow::on_action_view_refresh_triggered()
{
openRepository(true);
}
void MainWindow::on_tableWidget_log_currentItemChanged(QTableWidgetItem * /*current*/, QTableWidgetItem * /*previous*/)
{
doLogCurrentItemChanged(frame());
m2->searching = false;
}
void MainWindow::on_toolButton_stage_clicked()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->stage(selectedFiles());
updateCurrentFilesList(frame());
}
void MainWindow::on_toolButton_unstage_clicked()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->unstage(selectedFiles());
updateCurrentFilesList(frame());
}
void MainWindow::on_toolButton_select_all_clicked()
{
if (frame()->unstagedFileslistwidget()->count() > 0) {
frame()->unstagedFileslistwidget()->setFocus();
frame()->unstagedFileslistwidget()->selectAll();
} else if (frame()->stagedFileslistwidget()->count() > 0) {
frame()->stagedFileslistwidget()->setFocus();
frame()->stagedFileslistwidget()->selectAll();
}
}
void MainWindow::on_toolButton_commit_clicked()
{
ui->action_commit->trigger();
}
void MainWindow::on_action_edit_global_gitconfig_triggered()
{
QString dir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
QString path = dir / ".gitconfig";
editFile(path, ".gitconfig");
}
void MainWindow::on_action_edit_git_config_triggered()
{
QString dir = currentWorkingCopyDir();
QString path = dir / ".git/config";
editFile(path, ".git/config");
}
void MainWindow::on_action_edit_gitignore_triggered()
{
QString dir = currentWorkingCopyDir();
QString path = dir / ".gitignore";
if (editFile(path, ".gitignore")) {
updateCurrentFilesList(frame());
}
}
int MainWindow::selectedLogIndex(RepositoryWrapperFrame *frame) const
{
auto const &logs = getLogs(frame);
int i = frame->logtablewidget()->currentRow();
if (i >= 0 && i < (int)logs.size()) {
return i;
}
return -1;
}
/**
* @brief ファイル差分表示を更新する
* @param item
*/
void MainWindow::updateDiffView(RepositoryWrapperFrame *frame, QListWidgetItem *item)
{
clearDiffView(frame);
m2->last_selected_file_item = item;
if (!item) return;
int idiff = indexOfDiff(item);
if (idiff >= 0 && idiff < diffResult()->size()) {
Git::Diff const &diff = diffResult()->at(idiff);
QString key = GitDiff::makeKey(diff);
auto it = getDiffCacheMap()->find(key);
if (it != getDiffCacheMap()->end()) {
auto const &logs = getLogs(frame);
int row = frame->logtablewidget()->currentRow();
bool uncommited = (row >= 0 && row < (int)logs.size() && Git::isUncommited(logs[row]));
frame->filediffwidget()->updateDiffView(it->second, uncommited);
}
}
}
void MainWindow::updateDiffView(RepositoryWrapperFrame *frame)
{
updateDiffView(frame, m2->last_selected_file_item);
}
void MainWindow::updateUnstagedFileCurrentItem(RepositoryWrapperFrame *frame)
{
updateDiffView(frame, frame->unstagedFileslistwidget()->currentItem());
}
void MainWindow::updateStagedFileCurrentItem(RepositoryWrapperFrame *frame)
{
updateDiffView(frame, frame->stagedFileslistwidget()->currentItem());
}
void MainWindow::on_listWidget_unstaged_currentRowChanged(int /*currentRow*/)
{
updateUnstagedFileCurrentItem(frame());
}
void MainWindow::on_listWidget_staged_currentRowChanged(int /*currentRow*/)
{
updateStagedFileCurrentItem(frame());
}
void MainWindow::on_listWidget_files_currentRowChanged(int /*currentRow*/)
{
updateDiffView(frame(), frame()->fileslistwidget()->currentItem());
}
void MainWindow::dragEnterEvent(QDragEnterEvent *event)
{
if (QApplication::modalWindow()) return;
if (event->mimeData()->hasUrls()) {
event->acceptProposedAction();
event->accept();
}
}
-void MainWindow::timerEvent(QTimerEvent *)
-{
- bool running = getPtyProcess()->isRunning();
- if (ui->toolButton_stop_process->isEnabled() != running) {
- ui->toolButton_stop_process->setEnabled(running);
- ui->action_stop_process->setEnabled(running);
- setNetworkingCommandsEnabled(!running);
- }
- if (!running) {
- setInteractionMode(InteractionMode::None);
- }
-
- while (1) {
- char tmp[1024];
- int len = getPtyProcess()->readOutput(tmp, sizeof(tmp));
- if (len < 1) break;
- writeLog(tmp, len);
- }
-}
-
void MainWindow::keyPressEvent(QKeyEvent *event)
{
int c = event->key();
if (c == Qt::Key_T && (event->modifiers() & Qt::ControlModifier)) {
test();
return;
}
if (QApplication::focusWidget() == ui->widget_log) {
auto write_char = [&](char c){
if (getPtyProcess()->isRunning()) {
getPtyProcess()->writeInput(&c, 1);
}
};
auto write_text = [&](QString const &str){
std::string s = str.toStdString();
for (char i : s) {
write_char(i);
}
};
if (c == Qt::Key_Return || c == Qt::Key_Enter) {
write_char('\n');
} else {
QString text = event->text();
write_text(text);
}
}
}
void MainWindow::on_action_edit_settings_triggered()
{
SettingsDialog dlg(this);
if (dlg.exec() == QDialog::Accepted) {
ApplicationSettings const &newsettings = dlg.settings();
setAppSettings(newsettings);
setGitCommand(appsettings()->git_command, false);
setFileCommand(appsettings()->file_command, false);
setGpgCommand(appsettings()->gpg_command, false);
}
}
void MainWindow::onCloneCompleted(bool success, QVariant const &userdata)
{
if (success) {
RepositoryItem r = userdata.value<RepositoryItem>();
saveRepositoryBookmark(r);
setCurrentRepository(r, false);
openRepository(true);
}
}
void MainWindow::onPtyProcessCompleted(bool /*ok*/, QVariant const &userdata)
{
switch (getPtyCondition()) {
case PtyCondition::Clone:
onCloneCompleted(getPtyProcessOk(), userdata);
break;
}
setPtyCondition(PtyCondition::None);
}
void MainWindow::on_action_clone_triggered()
{
clone();
}
void MainWindow::on_action_about_triggered()
{
AboutDialog dlg(this);
dlg.exec();
}
void MainWindow::on_toolButton_clone_clicked()
{
ui->action_clone->trigger();
}
void MainWindow::on_toolButton_fetch_clicked()
{
ui->action_fetch->trigger();
}
void MainWindow::clearRepoFilter()
{
ui->lineEdit_filter->clear();
}
void MainWindow::appendCharToRepoFilter(ushort c)
{
if (QChar(c).isLetter()) {
c = QChar(c).toLower().unicode();
}
ui->lineEdit_filter->setText(getRepositoryFilterText() + c);
}
void MainWindow::backspaceRepoFilter()
{
QString s = getRepositoryFilterText();
int n = s.size();
if (n > 0) {
s = s.mid(0, n - 1);
}
ui->lineEdit_filter->setText(s);
}
void MainWindow::on_lineEdit_filter_textChanged(QString const &text)
{
setRepositoryFilterText(text);
updateRepositoriesList();
}
void MainWindow::on_toolButton_erase_filter_clicked()
{
clearRepoFilter();
ui->lineEdit_filter->setFocus();
}
void MainWindow::deleteTags(RepositoryWrapperFrame *frame, QStringList const &tagnames)
{
int row = frame->logtablewidget()->currentRow();
internalDeleteTags(tagnames);
frame->logtablewidget()->selectRow(row);
}
void MainWindow::revertCommit(RepositoryWrapperFrame *frame)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
Git::CommitItem const *commit = selectedCommitItem(frame);
if (commit) {
g->revert(commit->commit_id);
openRepository(false);
}
}
bool MainWindow::addTag(RepositoryWrapperFrame *frame, QString const &name)
{
int row = frame->logtablewidget()->currentRow();
bool ok = internalAddTag(frame, name);
frame->selectLogTableRow(row);
return ok;
}
void MainWindow::on_action_push_all_tags_triggered()
{
reopenRepository(false, [&](GitPtr g){
g->push(true);
});
}
void MainWindow::on_tableWidget_log_itemDoubleClicked(QTableWidgetItem *)
{
Git::CommitItem const *commit = selectedCommitItem(frame());
if (commit) {
- execCommitPropertyDialog(this, commit);
+ execCommitPropertyDialog(this, frame(), commit);
}
}
void MainWindow::on_listWidget_unstaged_itemDoubleClicked(QListWidgetItem * item)
{
execFilePropertyDialog(item);
}
void MainWindow::on_listWidget_staged_itemDoubleClicked(QListWidgetItem *item)
{
execFilePropertyDialog(item);
}
void MainWindow::on_listWidget_files_itemDoubleClicked(QListWidgetItem *item)
{
execFilePropertyDialog(item);
}
QListWidgetItem *MainWindow::currentFileItem() const
{
QListWidget *listwidget = nullptr;
if (ui->stackedWidget_filelist->currentWidget() == ui->page_uncommited) {
QWidget *w = qApp->focusWidget();
if (w == ui->listWidget_unstaged) {
listwidget = ui->listWidget_unstaged;
} else if (w == ui->listWidget_staged) {
listwidget = ui->listWidget_staged;
}
} else {
listwidget = ui->listWidget_files;
}
if (listwidget) {
return listwidget->currentItem();
}
return nullptr;
}
void MainWindow::on_action_set_config_user_triggered()
{
Git::User global_user;
Git::User repo_user;
GitPtr g = git();
if (isValidWorkingCopy(g)) {
repo_user = g->getUser(Git::Source::Local);
}
global_user = g->getUser(Git::Source::Global);
execSetUserDialog(global_user, repo_user, currentRepositoryName());
}
void MainWindow::showLogWindow(bool show)
{
ui->dockWidget_log->setVisible(show);
}
void MainWindow::on_action_window_log_triggered(bool checked)
{
showLogWindow(checked);
}
void MainWindow::on_action_repo_jump_triggered()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
NamedCommitList items = namedCommitItems(Branches | Tags | Remotes);
{
NamedCommitItem head;
head.name = "HEAD";
head.id = getHeadId();
items.push_front(head);
}
JumpDialog dlg(this, items);
if (dlg.exec() == QDialog::Accepted) {
QString text = dlg.text();
if (text.isEmpty()) return;
QString id = g->rev_parse(text);
if (id.isEmpty() && Git::isValidID(text)) {
QStringList list = findGitObject(text);
if (list.isEmpty()) {
QMessageBox::warning(this, tr("Jump"), QString("%1\n\n").arg(text) + tr("No such commit"));
return;
}
ObjectBrowserDialog dlg2(this, list);
if (dlg2.exec() == QDialog::Accepted) {
id = dlg2.text();
if (id.isEmpty()) return;
}
}
if (g->objectType(id) == "tag") {
id = getObjCache()->getCommitIdFromTag(id);
}
int row = rowFromCommitId(frame(), id);
if (row < 0) {
QMessageBox::warning(this, tr("Jump"), QString("%1\n(%2)\n\n").arg(text).arg(id) + tr("No such commit"));
} else {
setCurrentLogRow(frame(), row);
}
}
}
void MainWindow::on_action_repo_checkout_triggered()
{
checkout(frame());
}
void MainWindow::on_action_delete_branch_triggered()
{
deleteBranch(frame());
}
void MainWindow::on_toolButton_terminal_clicked()
{
openTerminal(nullptr);
}
void MainWindow::on_toolButton_explorer_clicked()
{
openExplorer(nullptr);
}
void MainWindow::on_action_reset_HEAD_1_triggered()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->reset_head1();
openRepository(false);
}
void MainWindow::on_action_create_a_repository_triggered()
{
createRepository(QString());
}
bool MainWindow::isOnlineMode() const
{
return m2->is_online_mode;
}
void MainWindow::setRemoteOnline(bool f, bool save)
{
m2->is_online_mode = f;
{
QRadioButton *rb = nullptr;
rb = f ? ui->radioButton_remote_online : ui->radioButton_remote_offline;
rb->blockSignals(true);
rb->click();
rb->blockSignals(false);
ui->action_online->setCheckable(true);
ui->action_offline->setCheckable(true);
ui->action_online->setChecked(f);
ui->action_offline->setChecked(!f);
setNetworkingCommandsEnabled(f);
}
if (save) {
MySettings s;
s.beginGroup("Remote");
s.setValue("Online", f);
s.endGroup();
}
}
void MainWindow::on_radioButton_remote_online_clicked()
{
setRemoteOnline(true, true);
}
void MainWindow::on_radioButton_remote_offline_clicked()
{
setRemoteOnline(false, true);
}
void MainWindow::on_verticalScrollBar_log_valueChanged(int)
{
ui->widget_log->refrectScrollBar();
}
void MainWindow::on_horizontalScrollBar_log_valueChanged(int)
{
ui->widget_log->refrectScrollBar();
}
void MainWindow::on_toolButton_stop_process_clicked()
{
abortPtyProcess();
}
void MainWindow::on_action_stop_process_triggered()
{
abortPtyProcess();
}
void MainWindow::on_action_exit_triggered()
{
close();
}
void MainWindow::on_action_reflog_triggered()
{
GitPtr g = git();
Git::ReflogItemList reflog;
g->reflog(&reflog);
ReflogWindow dlg(this, this, reflog);
dlg.exec();
}
void MainWindow::blame(QListWidgetItem *item)
{
QList<BlameItem> list;
QString path = getFilePath(item);
{
GitPtr g = git();
QByteArray ba = g->blame(path);
if (!ba.isEmpty()) {
char const *begin = ba.data();
char const *end = begin + ba.size();
list = BlameWindow::parseBlame(begin, end);
}
}
if (!list.isEmpty()) {
qApp->setOverrideCursor(Qt::WaitCursor);
BlameWindow win(this, path, list);
qApp->restoreOverrideCursor();
win.exec();
}
}
void MainWindow::blame()
{
blame(currentFileItem());
}
void MainWindow::on_action_repository_property_triggered()
{
execRepositoryPropertyDialog(currentRepository());
}
void MainWindow::on_action_set_gpg_signing_triggered()
{
GitPtr g = git();
QString global_key_id = g->signingKey(Git::Source::Global);
QString repository_key_id;
if (g->isValidWorkingCopy()) {
repository_key_id = g->signingKey(Git::Source::Local);
}
SetGpgSigningDialog dlg(this, currentRepositoryName(), global_key_id, repository_key_id);
if (dlg.exec() == QDialog::Accepted) {
g->setSigningKey(dlg.id(), dlg.isGlobalChecked());
}
}
void MainWindow::execAreYouSureYouWantToContinueConnectingDialog()
{
using TheDlg = AreYouSureYouWantToContinueConnectingDialog;
setInteractionMode(InteractionMode::Busy);
QApplication::restoreOverrideCursor();
TheDlg dlg(this);
if (dlg.exec() == QDialog::Accepted) {
TheDlg::Result r = dlg.result();
if (r == TheDlg::Result::Yes) {
getPtyProcess()->writeInput("yes\n", 4);
} else {
setPtyProcessOk(false); // abort
getPtyProcess()->writeInput("no\n", 3);
QThread::msleep(300);
stopPtyProcess();
}
} else {
ui->widget_log->setFocus();
setInteractionCanceled(true);
}
setInteractionMode(InteractionMode::Busy);
}
void MainWindow::onLogIdle()
{
if (interactionCanceled()) return;
if (interactionMode() != InteractionMode::None) return;
static char const are_you_sure_you_want_to_continue_connecting[] = "Are you sure you want to continue connecting (yes/no)?";
static char const enter_passphrase[] = "Enter passphrase: ";
static char const enter_passphrase_for_key[] = "Enter passphrase for key '";
static char const fatal_authentication_failed_for[] = "fatal: Authentication failed for '";
std::vector<char> vec;
ui->widget_log->retrieveLastText(&vec, 100);
if (!vec.empty()) {
std::string line;
int n = (int)vec.size();
int i = n;
while (i > 0) {
i--;
if (i + 1 < n && vec[i] == '\n') {
i++;
line.assign(&vec[i], n - i);
break;
}
}
if (!line.empty()) {
auto ExecLineEditDialog = [&](QWidget *parent, QString const &title, QString const &prompt, QString const &val, bool password){
LineEditDialog dlg(parent, title, prompt, val, password);
if (dlg.exec() == QDialog::Accepted) {
std::string ret = dlg.text().toStdString();
std::string str = ret + '\n';
getPtyProcess()->writeInput(str.c_str(), str.size());
return ret;
}
abortPtyProcess();
return std::string();
};
auto Match = [&](char const *str){
int n = strlen(str);
if (strncmp(line.c_str(), str, n) == 0) {
char const *p = line.c_str() + n;
while (1) {
if (!*p) return true;
if (!isspace((unsigned char)*p)) break;
p++;
}
}
return false;
};
auto StartsWith = [&](char const *str){
char const *p = line.c_str();
while (*str) {
if (*p != *str) return false;
str++;
p++;
}
return true;
};
if (Match(are_you_sure_you_want_to_continue_connecting)) {
execAreYouSureYouWantToContinueConnectingDialog();
return;
}
if (line == enter_passphrase) {
ExecLineEditDialog(this, "Passphrase", QString::fromStdString(line), QString(), true);
return;
}
if (StartsWith(enter_passphrase_for_key)) {
std::string keyfile;
{
int i = strlen(enter_passphrase_for_key);
char const *p = line.c_str() + i;
char const *q = strrchr(p, ':');
if (q && p + 2 < q && q[-1] == '\'') {
keyfile.assign(p, q - 1);
}
}
if (!keyfile.empty()) {
if (keyfile == sshPassphraseUser() && !sshPassphrasePass().empty()) {
std::string text = sshPassphrasePass() + '\n';
getPtyProcess()->writeInput(text.c_str(), text.size());
} else {
std::string secret = ExecLineEditDialog(this, "Passphrase for key", QString::fromStdString(line), QString(), true);
sshSetPassphrase(keyfile, secret);
}
return;
}
}
char const *begin = line.c_str();
char const *end = line.c_str() + line.size();
auto Input = [&](QString const &title, bool password, std::string *value){
Q_ASSERT(value);
std::string header = QString("%1 for '").arg(title).toStdString();
if (strncmp(begin, header.c_str(), header.size()) == 0) {
QString msg;
if (memcmp(end - 2, "':", 2) == 0) {
msg = QString::fromUtf8(begin, end - begin - 1);
} else if (memcmp(end - 3, "': ", 3) == 0) {
msg = QString::fromUtf8(begin, end - begin - 2);
}
if (!msg.isEmpty()) {
std::string s = ExecLineEditDialog(this, title, msg, value ? QString::fromStdString(*value) : QString(), password);
*value = s;
return true;
}
}
return false;
};
std::string uid = httpAuthenticationUser();
std::string pwd = httpAuthenticationPass();
bool ok = false;
if (Input("Username", false, &uid)) ok = true;
if (Input("Password", true, &pwd)) ok = true;
if (ok) {
httpSetAuthentication(uid, pwd);
return;
}
if (StartsWith(fatal_authentication_failed_for)) {
QMessageBox::critical(this, tr("Authentication Failed"), QString::fromStdString(line));
abortPtyProcess();
return;
}
}
}
}
void MainWindow::on_action_edit_tags_triggered()
{
Git::CommitItem const *commit = selectedCommitItem(frame());
if (commit && Git::isValidID(commit->commit_id)) {
EditTagsDialog dlg(this, commit);
dlg.exec();
}
}
void MainWindow::on_action_push_u_triggered()
{
pushSetUpstream(false);
}
void MainWindow::on_action_delete_remote_branch_triggered()
{
deleteRemoteBranch(selectedCommitItem(frame()));
}
void MainWindow::on_action_terminal_triggered()
{
auto const *repo = &currentRepository();
openTerminal(repo);
}
void MainWindow::on_action_explorer_triggered()
{
auto const *repo = &currentRepository();
openExplorer(repo);
}
void MainWindow::on_action_reset_hard_triggered()
{
doGitCommand([&](GitPtr g){
g->reset_hard();
});
}
void MainWindow::on_action_clean_df_triggered()
{
doGitCommand([&](GitPtr g){
g->clean_df();
});
}
void MainWindow::postOpenRepositoryFromGitHub(QString const &username, QString const &reponame)
{
QVariantList list;
list.push_back(username);
list.push_back(reponame);
- postUserFunctionEvent([&](QVariant const &v){
+ postUserFunctionEvent([&](QVariant const &v, void *){
QVariantList l = v.toList();
QString uname = l[0].toString();
QString rname = l[1].toString();
CloneFromGitHubDialog dlg(this, uname, rname);
if (dlg.exec() == QDialog::Accepted) {
clone(dlg.url());
}
}, QVariant(list));
}
void MainWindow::on_action_stash_triggered()
{
doGitCommand([&](GitPtr g){
g->stash();
});
}
void MainWindow::on_action_stash_apply_triggered()
{
doGitCommand([&](GitPtr g){
g->stash_apply();
});
}
void MainWindow::on_action_stash_drop_triggered()
{
doGitCommand([&](GitPtr g){
g->stash_drop();
});
}
void MainWindow::on_action_online_triggered()
{
ui->radioButton_remote_online->click();
}
void MainWindow::on_action_offline_triggered()
{
ui->radioButton_remote_offline->click();
}
void MainWindow::on_action_repositories_panel_triggered()
{
bool checked = ui->action_repositories_panel->isChecked();
ui->stackedWidget_leftpanel->setCurrentWidget(checked ? ui->page_repos : ui->page_collapsed);
if (checked) {
ui->stackedWidget_leftpanel->setFixedWidth(m2->repos_panel_width);
ui->stackedWidget_leftpanel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
ui->stackedWidget_leftpanel->setMinimumWidth(QWIDGETSIZE_MAX);
ui->stackedWidget_leftpanel->setMaximumWidth(QWIDGETSIZE_MAX);
} else {
m2->repos_panel_width = ui->stackedWidget_leftpanel->width();
ui->stackedWidget_leftpanel->setFixedWidth(24);
}
}
void MainWindow::on_action_find_triggered()
{
m2->searching = false;
if (getLogs(frame()).empty()) {
return;
}
FindCommitDialog dlg(this, m2->search_text);
if (dlg.exec() == QDialog::Accepted) {
m2->search_text = dlg.text();
frame()->setFocusToLogTable();
findNext(frame());
}
}
void MainWindow::on_action_find_next_triggered()
{
if (m2->search_text.isEmpty()) {
on_action_find_triggered();
} else {
findNext(frame());
}
}
void MainWindow::on_action_repo_jump_to_head_triggered()
{
QString name = "HEAD";
GitPtr g = git();
QString id = g->rev_parse(name);
int row = rowFromCommitId(frame(), id);
if (row < 0) {
qDebug() << "No such commit";
} else {
setCurrentLogRow(frame(), row);
}
}
void MainWindow::on_action_repo_merge_triggered()
{
merge(frame());
}
void MainWindow::on_action_expand_commit_log_triggered()
{
ui->splitter_h->setSizes({10000, 1, 1});
}
void MainWindow::on_action_expand_file_list_triggered()
{
ui->splitter_h->setSizes({1, 10000, 1});
}
void MainWindow::on_action_expand_diff_view_triggered()
{
ui->splitter_h->setSizes({1, 1, 10000});
}
void MainWindow::on_action_sidebar_triggered()
{
bool f = ui->stackedWidget_leftpanel->isVisible();
f = !f;
ui->stackedWidget_leftpanel->setVisible(f);
ui->action_sidebar->setChecked(f);
}
#if 0
void MainWindow::on_action_wide_triggered()
{
QWidget *w = focusWidget();
if (w == m->focused_widget) {
ui->splitter_h->setSizes(m->splitter_h_sizes);
m->focused_widget = nullptr;
} else {
m->focused_widget = w;
m->splitter_h_sizes = ui->splitter_h->sizes();
if (w == frame->logtablewidget()) {
ui->splitter_h->setSizes({10000, 1, 1});
} else if (ui->stackedWidget_filelist->isAncestorOf(w)) {
ui->splitter_h->setSizes({1, 10000, 1});
} else if (ui->frame_diff_view->isAncestorOf(w)) {
ui->splitter_h->setSizes({1, 1, 10000});
}
}
}
#endif
void MainWindow::setShowLabels(bool show, bool save)
{
ApplicationSettings *as = appsettings();
as->show_labels = show;
bool b = ui->action_show_labels->blockSignals(true);
ui->action_show_labels->setChecked(show);
ui->action_show_labels->blockSignals(b);
if (save) {
saveApplicationSettings();
}
}
bool MainWindow::isLabelsVisible() const
{
return appsettings()->show_labels;
}
void MainWindow::on_action_show_labels_triggered()
{
bool f = ui->action_show_labels->isChecked();
setShowLabels(f, true);
frame()->updateLogTableView();
}
void MainWindow::on_action_submodules_triggered()
{
GitPtr g = git();
QList<Git::SubmoduleItem> mods = g->submodules();
std::vector<SubmodulesDialog::Submodule> mods2;
mods2.resize(mods.size());
for (size_t i = 0; i < mods.size(); i++) {
const Git::SubmoduleItem mod = mods[i];
mods2[i].submodule = mod;
GitPtr g2 = git(g->workingRepositoryDir() / mod.path, g->sshKey());
g2->queryCommit(mod.id, &mods2[i].head);
}
SubmodulesDialog dlg(this, mods2);
dlg.exec();
}
void MainWindow::on_action_submodule_add_triggered()
{
QString dir = currentRepository().local_dir;
submodule_add({}, dir);
}
-
-
-
void MainWindow::on_action_submodule_update_triggered()
{
SubmoduleUpdateDialog dlg(this);
if (dlg.exec() == QDialog::Accepted) {
GitPtr g = git();
Git::SubmoduleUpdateData data;
data.init = dlg.isInit();
data.recursive = dlg.isRecursive();
g->submodule_update(data, getPtyProcess());
}
}
+/**
+ * @brief アイコンの読み込みが完了した
+ */
+void MainWindow::onAvatarUpdated(RepositoryWrapperFrameP frame)
+{
+ updateCommitLogTableLater(frame.pointer, 100); // コミットログを更新（100ms後）
+}
void MainWindow::test()
{
SubmoduleMainWindow *w = new SubmoduleMainWindow(this);
w->show();
w->reset();
}
diff --git a/src/MainWindow.h b/src/MainWindow.h
index 7effd3f..65abb6f 100644
--- a/src/MainWindow.h
+++ b/src/MainWindow.h
@@ -1,571 +1,574 @@
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include "BasicMainWindow.h"
#include "Git.h"
#include "GitHubAPI.h"
#include "RepositoryData.h"
#include "MyProcess.h"
#include "main.h"
#include "webclient.h"
#include "AvatarLoader.h"
#include "GitObjectManager.h"
#include "Theme.h"
#include "BranchLabel.h"
class RepositoryWrapperFrame;
class LogTableWidget;
class QListWidgetItem;
class QListWidget;
class QTreeWidgetItem;
class QTableWidgetItem;
namespace Ui {
class MainWindow;
}
class HunkItem {
public:
int hunk_number = -1;
size_t pos, len;
std::vector<std::string> lines;
};
class MainWindow : public BasicMainWindow {
Q_OBJECT
friend class RepositoryWrapperFrame;
friend class SubmoduleMainWindow;
friend class ImageViewWidget;
friend class FileDiffSliderWidget;
friend class FileHistoryWindow;
friend class FileDiffWidget;
friend class AboutDialog;
private:
struct Private1 {
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;
QList<Git::SubmoduleItem> submodules;
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;
+// 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<BranchLabel>> 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;
};
Private1 *m1;
struct Private2;
Private2 *m2;
struct ObjectData {
QString id;
QString path;
Git::SubmoduleItem submod;
Git::CommitItem submod_commit;
QString header;
int idiff;
};
public:
explicit MainWindow(QWidget *parent = nullptr);
~MainWindow() override;
RepositoryWrapperFrame *frame();
RepositoryWrapperFrame const *frame() const;
QPixmap const &digitsPixmap() const;
// QString currentWorkingCopyDir() const override;
QColor color(unsigned int i);
bool isOnlineMode() const;
private:
Ui::MainWindow *ui;
+ void postEvent(QObject *receiver, QEvent *event, int ms_later);
+ void postUserFunctionEvent(const std::function<void (const QVariant &, void *)> &fn, QVariant const &v = QVariant(), void *p = nullptr, int ms_later = 0);
+
void updateFilesList(RepositoryWrapperFrame *frame, QString id, bool wait);
void updateFilesList(RepositoryWrapperFrame *frame, Git::CommitItem const &commit, bool wait);
void updateRepositoriesList();
void openRepository_(GitPtr g, bool keep_selection = false);
void openRepository_(RepositoryWrapperFrame *frame, GitPtr g, bool keep_selection = false);
void prepareLogTableWidget();
QStringList selectedFiles_(QListWidget *listwidget) const;
QStringList selectedFiles() const;
void for_each_selected_files(std::function<void (QString const &)> const &fn);
void showFileList(FilesListType files_list_type);
void clearLog(RepositoryWrapperFrame *frame);
void clearFileList(RepositoryWrapperFrame *frame);
void clearDiffView(RepositoryWrapperFrame *frame);
void clearRepositoryInfo();
int repositoryIndex_(const QTreeWidgetItem *item) const;
RepositoryItem const *repositoryItem(const QTreeWidgetItem *item) const;
QTreeWidgetItem *newQTreeWidgetFolderItem(QString const &name);
void buildRepoTree(QString const &group, QTreeWidgetItem *item, QList<RepositoryItem> *repos);
void refrectRepositories();
void updateDiffView(RepositoryWrapperFrame *frame, QListWidgetItem *item);
void updateDiffView(RepositoryWrapperFrame *frame);
void updateUnstagedFileCurrentItem(RepositoryWrapperFrame *frame);
void updateStagedFileCurrentItem(RepositoryWrapperFrame *frame);
void updateStatusBarText(RepositoryWrapperFrame *frame);
void setRepositoryInfo(QString const &reponame, QString const &brname);
int indexOfRepository(const QTreeWidgetItem *treeitem) const;
void clearRepoFilter();
void appendCharToRepoFilter(ushort c);
void backspaceRepoFilter();
void revertCommit(RepositoryWrapperFrame *frame);
void mergeBranch(const QString &commit, Git::MergeFastForward ff);
void mergeBranch(Git::CommitItem const *commit, Git::MergeFastForward ff);
void rebaseBranch(Git::CommitItem const *commit);
void cherrypick(Git::CommitItem const *commit);
void merge(RepositoryWrapperFrame *frame, const Git::CommitItem *commit = nullptr);
void detectGitServerType(const GitPtr &g);
void setRemoteOnline(bool f, bool save);
void startTimers();
void onCloneCompleted(bool success, const QVariant &userdata);
void setNetworkingCommandsEnabled(bool enabled);
void blame(QListWidgetItem *item);
void blame();
QListWidgetItem *currentFileItem() const;
void execAreYouSureYouWantToContinueConnectingDialog();
void deleteRemoteBranch(Git::CommitItem const *commit);
QStringList remoteBranches(QString const &id, QStringList *all);
bool isUninitialized();
void doLogCurrentItemChanged(RepositoryWrapperFrame *frame);
void findNext(RepositoryWrapperFrame *frame);
void findText(const QString &text);
void showStatus();
void onStartEvent();
void showLogWindow(bool show);
QString getObjectID(QListWidgetItem *item);
bool isValidRemoteURL(const QString &url, const QString &sshkey);
QStringList whichCommand_(const QString &cmdfile1, const QString &cmdfile2 = {});
QString selectCommand_(const QString &cmdname, const QStringList &cmdfiles, const QStringList &list, QString path, const std::function<void (const QString &)> &callback);
QString selectCommand_(const QString &cmdname, const QString &cmdfile, const QStringList &list, const QString &path, const std::function<void (const QString &)> &callback);
const RepositoryItem *findRegisteredRepository(QString *workdir) const;
static bool git_callback(void *cookie, const char *ptr, int len);
bool execSetGlobalUserDialog();
void revertAllFiles();
void addWorkingCopyDir(QString dir, QString name, bool open);
bool execWelcomeWizardDialog();
void execRepositoryPropertyDialog(const RepositoryItem &repo, bool open_repository_menu = false);
void execSetUserDialog(const Git::User &global_user, const Git::User &repo_user, const QString &reponame);
void setGitCommand(QString path, bool save);
void setFileCommand(QString path, bool save);
void setGpgCommand(QString path, bool save);
void setSshCommand(QString path, bool save);
bool checkGitCommand();
bool checkFileCommand();
bool saveBlobAs(const QString &id, const QString &dstpath);
bool saveByteArrayAs(const QByteArray &ba, const QString &dstpath);
static QString makeRepositoryName(const QString &loc);
bool saveFileAs(const QString &srcpath, const QString &dstpath);
QString saveAsTemp(const QString &id);
QString executableOrEmpty(const QString &path);
bool checkExecutable(const QString &path);
void internalSaveCommandPath(const QString &path, bool save, const QString &name);
void logGitVersion();
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 (const GitPtr &)> &callback);
void setCurrentRepository(const RepositoryItem &repo, bool clear_authentication);
void openSelectedRepository();
QList<Git::Diff> makeDiffs(QString id, bool *ok);
void queryBranches(const GitPtr &g);
void updateRemoteInfo();
void queryRemotes(const GitPtr &g);
void clone(QString url = {}, QString dir = {});
void submodule_add(QString url = {}, QString local_dir = {});
const Git::CommitItem *selectedCommitItem(RepositoryWrapperFrame *frame) const;
void commit(RepositoryWrapperFrame *frame, bool amend = false);
void commitAmend(RepositoryWrapperFrame *framae);
void pushSetUpstream(const QString &remote, const QString &branch);
bool pushSetUpstream(bool testonly);
void push();
void deleteBranch(const Git::CommitItem *commit);
void deleteBranch(RepositoryWrapperFrame *frame);
void resetFile(const QStringList &paths);
void clearAuthentication();
void clearSshAuthentication();
void internalDeleteTags(const QStringList &tagnames);
bool internalAddTag(RepositoryWrapperFrame *frame, const QString &name);
void createRepository(const QString &dir);
void setLogEnabled(const GitPtr &g, bool f);
void doGitCommand(const std::function<void (GitPtr)> &callback);
void setWindowTitle_(const Git::User &user);
void setUnknownRepositoryInfo();
void setCurrentRemoteName(const QString &name);
void deleteTags(RepositoryWrapperFrame *frame, const Git::CommitItem &commit);
bool isAvatarEnabled() const;
bool isGitHub() const;
QStringList remotes() const;
QList<Git::Branch> findBranch(const QString &id);
QString tempfileHeader() const;
void deleteTempFiles();
QString getCommitIdFromTag(const QString &tag);
QString newTempFilePath();
int limitLogCount() const;
Git::Object cat_file_(const GitPtr &g, const QString &id);
bool isThereUncommitedChanges() const;
static void addDiffItems(const QList<Git::Diff> *diff_list, const std::function<void (const ObjectData &)> &add_item);
Git::CommitItemList retrieveCommitLog(const GitPtr &g);
std::map<QString, QList<Git::Branch> > &branchMapRef();
- void updateCommitTableLater();
+ void updateCommitLogTableLater(RepositoryWrapperFrame *frame, int ms_later);
void updateWindowTitle(const GitPtr &g);
QString makeCommitInfoText(RepositoryWrapperFrame *frame, int row, QList<BranchLabel> *label_list);
void removeRepositoryFromBookmark(int index, bool ask);
void openTerminal(const RepositoryItem *repo);
void openExplorer(const RepositoryItem *repo);
bool askAreYouSureYouWantToRun(const QString &title, const QString &command);
bool editFile(const QString &path, const QString &title);
void setAppSettings(const ApplicationSettings &appsettings);
QIcon getRepositoryIcon() const;
QIcon getFolderIcon() const;
QIcon getSignatureGoodIcon() const;
QIcon getSignatureDubiousIcon() const;
QIcon getSignatureBadIcon() const;
QPixmap getTransparentPixmap() const;
QStringList findGitObject(const QString &id) const;
void writeLog(const char *ptr, int len);
void writeLog(const QString &str);
QList<BranchLabel> sortedLabels(int row) const;
void saveApplicationSettings();
void loadApplicationSettings();
void setDiffResult(const QList<Git::Diff> &diffs);
const QList<Git::SubmoduleItem> &submodules() const;
void setSubmodules(const QList<Git::SubmoduleItem> &submodules);
bool runOnRepositoryDir(const std::function<void (QString)> &callback, const RepositoryItem *repo);
NamedCommitList namedCommitItems(int flags);
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);
static void updateSubmodules(GitPtr g, const QString &id, QList<Git::SubmoduleItem> *out);
void saveRepositoryBookmark(RepositoryItem item);
int rowFromCommitId(RepositoryWrapperFrame *frame, const QString &id);
QList<Git::Tag> findTag(const QString &id);
void sshSetPassphrase(const std::string &user, const std::string &pass);
std::string sshPassphraseUser() const;
std::string sshPassphrasePass() const;
void httpSetAuthentication(const std::string &user, const std::string &pass);
std::string httpAuthenticationUser() const;
std::string httpAuthenticationPass() const;
// const Git::CommitItemList &getLogs() const;
const Git::CommitItem *getLog(RepositoryWrapperFrame const *frame, int index) const;
void updateCommitGraph(RepositoryWrapperFrame *frame);
- void postUserFunctionEvent(const std::function<void(QVariant const &)> &fn, QVariant const &v = QVariant());
void initNetworking();
bool saveRepositoryBookmarks() const;
QString getBookmarksFilePath() const;
void stopPtyProcess();
void abortPtyProcess();
Git::CommitItemList *getLogsPtr(RepositoryWrapperFrame *frame);
void setLogs(RepositoryWrapperFrame *frame, const Git::CommitItemList &logs);
void clearLogs(RepositoryWrapperFrame *frame);
PtyProcess *getPtyProcess();
bool getPtyProcessOk() const;
BasicMainWindow::PtyCondition getPtyCondition();
void setPtyUserData(const QVariant &userdata);
void setPtyProcessOk(bool pty_process_ok);
bool fetch(const GitPtr &g, bool prune);
bool fetch_tags_f(const GitPtr &g);
void setPtyCondition(const PtyCondition &ptyCondition);
const QList<RepositoryItem> &getRepos() const;
QList<RepositoryItem> *getReposPtr();
AvatarLoader *getAvatarLoader();
const AvatarLoader *getAvatarLoader() const;
- int *ptrUpdateFilesListCounter();
- int *ptrUpdateCommitTableCounter();
+// int *ptrUpdateFilesListCounter();
+// int *ptrUpdateCommitTableCounter();
bool interactionCanceled() const;
void setInteractionCanceled(bool canceled);
BasicMainWindow::InteractionMode interactionMode() const;
void setInteractionMode(const InteractionMode &im);
QString getRepositoryFilterText() const;
void setRepositoryFilterText(const QString &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<BranchLabel> > *getLabelMap();
const std::map<int, QList<BranchLabel> > *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(const QString &head_id);
void setPtyProcessCompletionData(const QVariant &value);
const QVariant &getTempRepoForCloneCompleteV() const;
void msgNoRepositorySelected();
bool isRepositoryOpened() const;
static std::pair<QString, QString> makeFileItemText(const ObjectData &data);
QString gitCommand() const;
QPixmap getTransparentPixmap();
static QListWidgetItem *NewListWidgetFileItem(const MainWindow::ObjectData &data);
+ void cancelPendingUserEvents();
protected:
void customEvent(QEvent *);
void dragEnterEvent(QDragEnterEvent *event) override;
- void timerEvent(QTimerEvent *) override;
+// void timerEvent(QTimerEvent *) override;
void keyPressEvent(QKeyEvent *event) override;
bool event(QEvent *event) override;
bool eventFilter(QObject *watched, QEvent *event) override;
public:
void drawDigit(QPainter *pr, int x, int y, int n) const;
int digitWidth() const;
int digitHeight() const;
void setStatusBarText(QString const &text);
void clearStatusBarText();
void setCurrentLogRow(RepositoryWrapperFrame *frame, int row);
bool shown();
void deleteTags(RepositoryWrapperFrame *frame, QStringList const &tagnames);
bool addTag(RepositoryWrapperFrame *frame, QString const &name);
void updateCurrentFilesList(RepositoryWrapperFrame *frame);
- void notifyRemoteChanged(bool f);
void postOpenRepositoryFromGitHub(const QString &username, const QString &reponame);
int selectedLogIndex(RepositoryWrapperFrame *frame) const;
void updateAncestorCommitMap(RepositoryWrapperFrame *frame);
bool isAncestorCommit(const QString &id);
- void postStartEvent();
+ void postStartEvent(int ms_later);
void setShowLabels(bool show, bool save);
bool isLabelsVisible() const;
void updateFilesList2(const QString &id, QList<Git::Diff> *diff_list, QListWidget *listwidget);
void execCommitViewWindow(const Git::CommitItem *commit);
- void execCommitPropertyDialog(QWidget *parent, const Git::CommitItem *commit);
+ void execCommitPropertyDialog(QWidget *parent, RepositoryWrapperFrame *frame, const Git::CommitItem *commit);
void execCommitExploreWindow(QWidget *parent, const Git::CommitItem *commit);
void execFileHistory(const QString &path);
void execFileHistory(QListWidgetItem *item);
void execFilePropertyDialog(QListWidgetItem *item);
bool testRemoteRepositoryValidity(const QString &url, const QString &sshkey);
QString selectGitCommand(bool save);
QString selectFileCommand(bool save);
QString selectGpgCommand(bool save);
QString selectSshCommand(bool save);
const Git::Branch &currentBranch() const;
void setCurrentBranch(const Git::Branch &b);
const RepositoryItem &currentRepository() const;
QString currentRepositoryName() const;
QString currentRemoteName() const;
QString currentBranchName() const;
GitPtr git(const QString &dir, const QString &sshkey = {}) const;
GitPtr git();
GitPtr git(const Git::SubmoduleItem &submod);
void autoOpenRepository(QString dir);
bool queryCommit(const QString &id, Git::CommitItem *out);
void checkout(QWidget *parent, const Git::CommitItem *commit, std::function<void ()> accepted_callback = {});
void checkout(RepositoryWrapperFrame *frame);
void jumpToCommit(RepositoryWrapperFrame *frame, QString id);
Git::Object cat_file(const QString &id);
void addWorkingCopyDir(const QString &dir, bool open);
bool saveAs(const QString &id, const QString &dstpath);
QString determinFileType_(const QString &path, bool mime, const std::function<void (const QString &, QByteArray *)> &callback) const;
QString determinFileType(const QString &path, bool mime);
QString determinFileType(QByteArray in, bool mime);
QList<Git::Tag> queryTagList(RepositoryWrapperFrame *frame);
TextEditorThemePtr themeForTextEditor();
bool isValidWorkingCopy(const GitPtr &g) const;
void emitWriteLog(const QByteArray &ba);
QString findFileID(const QString &commit_id, const QString &file);
const Git::CommitItem *commitItem(RepositoryWrapperFrame *frame, int row) const;
- QIcon committerIcon(const RepositoryWrapperFrame *frame, int row) const;
+ QIcon committerIcon(RepositoryWrapperFrame *frame, int row) const;
void changeSshKey(const QString &localdir, const QString &sshkey);
static QString abbrevCommitID(const Git::CommitItem &commit);
const Git::CommitItemList &getLogs(RepositoryWrapperFrame const *frame) const;
const QList<BranchLabel> *label(int row) const;
ApplicationSettings *appsettings();
const ApplicationSettings *appsettings() const;
QString defaultWorkingDir() const;
WebContext *webContext();
QIcon verifiedIcon(char s) const;
QAction *addMenuActionProperty(QMenu *menu);
QString currentWorkingCopyDir() const;
Git::SubmoduleItem const *querySubmoduleByPath(const QString &path, Git::CommitItem *commit);
public slots:
void writeLog_(QByteArray ba);
private slots:
void updateUI();
void onLogVisibilityChanged();
void onPtyProcessCompleted(bool ok, const QVariant &userdata);
void onRepositoriesTreeDropped();
void on_action_about_triggered();
void on_action_clean_df_triggered();
void on_action_clone_triggered();
void on_action_commit_triggered();
void on_action_create_a_repository_triggered();
void on_action_delete_branch_triggered();
void on_action_delete_remote_branch_triggered();
void on_action_edit_git_config_triggered();
void on_action_edit_gitignore_triggered();
void on_action_edit_global_gitconfig_triggered();
void on_action_edit_settings_triggered();
void on_action_edit_tags_triggered();
void on_action_exit_triggered();
void on_action_explorer_triggered();
void on_action_fetch_triggered();
void on_action_fetch_prune_triggered();
void on_action_find_next_triggered();
void on_action_find_triggered();
void on_action_offline_triggered();
void on_action_online_triggered();
void on_action_open_existing_working_copy_triggered();
void on_action_pull_triggered();
void on_action_push_all_tags_triggered();
void on_action_push_triggered();
void on_action_push_u_triggered();
void on_action_reflog_triggered();
void on_action_repo_checkout_triggered();
void on_action_repo_jump_to_head_triggered();
void on_action_repo_jump_triggered();
void on_action_repositories_panel_triggered();
void on_action_repository_property_triggered();
void on_action_repository_status_triggered();
void on_action_reset_HEAD_1_triggered();
void on_action_reset_hard_triggered();
void on_action_set_config_user_triggered();
void on_action_set_gpg_signing_triggered();
void on_action_stash_apply_triggered();
void on_action_stash_drop_triggered();
void on_action_stash_triggered();
void on_action_stop_process_triggered();
void on_action_terminal_triggered();
void on_action_view_refresh_triggered();
void on_action_window_log_triggered(bool checked);
void on_horizontalScrollBar_log_valueChanged(int);
void on_lineEdit_filter_textChanged(QString const &text);
void on_listWidget_files_currentRowChanged(int currentRow);
void on_listWidget_files_customContextMenuRequested(const QPoint &pos);
void on_listWidget_files_itemDoubleClicked(QListWidgetItem *item);
void on_listWidget_staged_currentRowChanged(int currentRow);
void on_listWidget_staged_customContextMenuRequested(const QPoint &pos);
void on_listWidget_staged_itemDoubleClicked(QListWidgetItem *item);
void on_listWidget_unstaged_currentRowChanged(int currentRow);
void on_listWidget_unstaged_customContextMenuRequested(const QPoint &pos);
void on_listWidget_unstaged_itemDoubleClicked(QListWidgetItem *item);
void on_radioButton_remote_offline_clicked();
void on_radioButton_remote_online_clicked();
void on_tableWidget_log_currentItemChanged(QTableWidgetItem *current, QTableWidgetItem *previous);
void on_tableWidget_log_customContextMenuRequested(const QPoint &pos);
void on_tableWidget_log_itemDoubleClicked(QTableWidgetItem *);
void on_toolButton_clone_clicked();
void on_toolButton_commit_clicked();
void on_toolButton_erase_filter_clicked();
void on_toolButton_explorer_clicked();
void on_toolButton_fetch_clicked();
void on_toolButton_pull_clicked();
void on_toolButton_push_clicked();
void on_toolButton_select_all_clicked();
void on_toolButton_stage_clicked();
void on_toolButton_status_clicked();
void on_toolButton_stop_process_clicked();
void on_toolButton_terminal_clicked();
void on_toolButton_unstage_clicked();
void on_treeWidget_repos_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous);
void on_treeWidget_repos_customContextMenuRequested(const QPoint &pos);
void on_treeWidget_repos_itemDoubleClicked(QTreeWidgetItem *item, int column);
void on_verticalScrollBar_log_valueChanged(int);
void on_action_repo_merge_triggered();
void on_action_expand_commit_log_triggered();
void on_action_expand_file_list_triggered();
void on_action_expand_diff_view_triggered();
// void on_action_wide_triggered();
void on_action_sidebar_triggered();
void on_action_show_labels_triggered();
void on_action_submodule_add_triggered();
void on_action_submodules_triggered();
void on_action_submodule_update_triggered();
- void onAvatarUpdated();
+ void onAvatarUpdated(RepositoryWrapperFrameP frame);
void test();
+ void onInterval10ms();
protected:
void closeEvent(QCloseEvent *event) override;
void internalWriteLog(const char *ptr, int len);
RepositoryItem const *selectedRepositoryItem() const;
void removeSelectedRepositoryFromBookmark(bool ask);
protected slots:
void onLogIdle();
signals:
void signalWriteLog(QByteArray ba);
void remoteInfoChanged();
void signalSetRemoteChanged(bool f);
void onEscapeKeyPressed();
void updateButton();
};
#endif // MAINWINDOW_H
diff --git a/src/ObjectBrowserDialog.cpp b/src/ObjectBrowserDialog.cpp
index 3615fc9..f0ab347 100644
--- a/src/ObjectBrowserDialog.cpp
+++ b/src/ObjectBrowserDialog.cpp
@@ -1,124 +1,124 @@
#include "MainWindow.h"
#include "ui_ObjectBrowserDialog.h"
#include "ObjectBrowserDialog.h"
#include <QMessageBox>
enum {
IdRole = Qt::UserRole,
TypeRole,
};
ObjectBrowserDialog::ObjectBrowserDialog(MainWindow *parent, const QStringList &list)
: QDialog(parent)
, ui(new Ui::ObjectBrowserDialog)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
GitPtr g = git();
QStringList cols = {
tr("ID"),
tr("Type"),
};
auto NewQTableWidgetItem = [](){
auto *item = new QTableWidgetItem();
return item;
};
ui->tableWidget->setColumnCount(cols.size());
for (int i = 0; i < cols.size(); i++) {
QTableWidgetItem *item = NewQTableWidgetItem();
item->setText(cols[i]);
ui->tableWidget->setHorizontalHeaderItem(i, item);
}
ui->tableWidget->setRowCount(list.size());
for (int row = 0; row < list.size(); row++) {
QString const &text = list[row];
QString type = g->objectType(text);
auto *item0 = NewQTableWidgetItem();
item0->setData(IdRole, text);
item0->setData(TypeRole, type);
item0->setText(text);
ui->tableWidget->setItem(row, 0, item0);
auto *item1 = NewQTableWidgetItem();
item1->setText(type);
ui->tableWidget->setItem(row, 1, item1);
}
ui->tableWidget->resizeColumnsToContents();
ui->tableWidget->setCurrentItem(ui->tableWidget->item(0, 0));
}
ObjectBrowserDialog::~ObjectBrowserDialog()
{
delete ui;
}
MainWindow *ObjectBrowserDialog::mainwindow()
{
return qobject_cast<MainWindow *>(parent());
}
GitPtr ObjectBrowserDialog::git()
{
return mainwindow()->git();
}
QString ObjectBrowserDialog::text() const
{
int row = ui->tableWidget->currentRow();
auto *item = ui->tableWidget->item(row, 0);
if (item) {
return item->data(IdRole).toString();
}
return QString();
}
void ObjectBrowserDialog::on_tableWidget_itemDoubleClicked(QTableWidgetItem *item)
{
(void)item;
done(QDialog::Accepted);
}
void ObjectBrowserDialog::on_tableWidget_currentItemChanged(QTableWidgetItem *current, QTableWidgetItem *previous)
{
(void)current;
(void)previous;
// if (current) {
// QString id = current->data(IdRole).toString();
// QString ty = current->data(TypeRole).toString();
// if (Git::isValidID(id) && ty == "commit") {
// }
// }
}
void ObjectBrowserDialog::on_pushButton_inspect_clicked()
{
int row = ui->tableWidget->currentRow();
auto *item = ui->tableWidget->item(row, 0);
if (item) {
GitPtr g = git();
QString id = item->data(IdRole).toString();
QString ty = item->data(TypeRole).toString();
if (Git::isValidID(id) && ty == "commit") {
Git::CommitItem commit;
if (g->queryCommit(id, &commit)) {
- mainwindow()->execCommitPropertyDialog(this, &commit);
+ mainwindow()->execCommitPropertyDialog(this, mainwindow()->frame(), &commit);
}
} else {
QMessageBox::information(this, tr("Object Inspection"), id + "\n\n" + ty);
}
}
}
diff --git a/src/ReflogWindow.cpp b/src/ReflogWindow.cpp
index 6a59c92..494ad5c 100644
--- a/src/ReflogWindow.cpp
+++ b/src/ReflogWindow.cpp
@@ -1,126 +1,126 @@
#include "CommitExploreWindow.h"
#include "ReflogWindow.h"
#include "ui_ReflogWindow.h"
#include "MainWindow.h"
#include "Git.h"
#include <QMenu>
ReflogWindow::ReflogWindow(QWidget *parent, MainWindow *mainwin, Git::ReflogItemList const &reflog)
: QDialog(parent)
, ui(new Ui::ReflogWindow)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
flags |= Qt::WindowMaximizeButtonHint;
setWindowFlags(flags);
mainwindow_ = mainwin;
reflog_ = reflog;
updateTable(reflog_);
}
ReflogWindow::~ReflogWindow()
{
delete ui;
}
void ReflogWindow::updateTable(Git::ReflogItemList const &reflog)
{
QTableWidgetItem *item;
ui->tableWidget->clear();
QStringList cols = {
tr("Commit"),
tr("Head"),
tr("Command"),
tr("Message"),
};
auto newQTableWidgetItem = [](QString const &text){
auto *item = new QTableWidgetItem(text);
return item;
};
ui->tableWidget->setColumnCount(cols.size());
ui->tableWidget->setRowCount(reflog.size());
for (int col = 0; col < cols.size(); col++) {
item = newQTableWidgetItem(cols[col]);
ui->tableWidget->setHorizontalHeaderItem(col, item);
}
int row = 0;
for (Git::ReflogItem const &t : reflog) {
QString text = t.id.mid(0, 7);
item = newQTableWidgetItem(text);
ui->tableWidget->setItem(row, 0, item);
item = newQTableWidgetItem(t.head);
ui->tableWidget->setItem(row, 1, item);
QString cmd = t.command;
int i = cmd.indexOf(' ');
if (i < 0) i = cmd.size();
if (i > 10) i = 10;
cmd = cmd.mid(0, i);
item = newQTableWidgetItem(cmd);
ui->tableWidget->setItem(row, 2, item);
item = newQTableWidgetItem(t.message);
ui->tableWidget->setItem(row, 3, item);
ui->tableWidget->setRowHeight(row, 24);
row++;
}
ui->tableWidget->resizeColumnsToContents();
ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
}
bool ReflogWindow::currentCommit(Git::CommitItem *out)
{
bool ok = false;
*out = Git::CommitItem();
int row = ui->tableWidget->currentRow();
if (row >= 0 && row < reflog_.size()) {
Git::ReflogItem const &logitem = reflog_[row];
if (mainwindow()->queryCommit(logitem.id, out)) {
ok = true;
}
}
return ok;
}
void ReflogWindow::on_tableWidget_customContextMenuRequested(const QPoint &pos)
{
Git::CommitItem commit;
if (!currentCommit(&commit)) return;
QMenu menu;
QAction *a_checkout = menu.addAction(tr("Checkout"));
QAction *a_explorer = menu.addAction(tr("Explorer"));
QAction *a_property = mainwindow()->addMenuActionProperty(&menu);
QAction *a = menu.exec(ui->tableWidget->viewport()->mapToGlobal(pos) + QPoint(8, -8));
if (a) {
if (a == a_checkout) {
mainwindow()->checkout(this, &commit);
return;
}
if (a == a_explorer) {
mainwindow()->execCommitExploreWindow(this, &commit);
return;
}
if (a == a_property) {
- mainwindow()->execCommitPropertyDialog(this, &commit);
+ mainwindow()->execCommitPropertyDialog(this, mainwindow()->frame(), &commit);
return;
}
}
}
void ReflogWindow::on_tableWidget_itemDoubleClicked(QTableWidgetItem *item)
{
(void)item;
Git::CommitItem commit;
if (!currentCommit(&commit)) return;
- mainwindow()->execCommitPropertyDialog(this, &commit);
+ mainwindow()->execCommitPropertyDialog(this, mainwindow()->frame(), &commit);
}
diff --git a/src/RepositoryWrapperFrame.cpp b/src/RepositoryWrapperFrame.cpp
index bdc0afe..83f81a5 100644
--- a/src/RepositoryWrapperFrame.cpp
+++ b/src/RepositoryWrapperFrame.cpp
@@ -1,144 +1,144 @@
#include "LogTableWidget.h"
#include "MainWindow.h"
#include "RepositoryWrapperFrame.h"
RepositoryWrapperFrame::RepositoryWrapperFrame(QWidget *parent)
: QFrame(parent)
{
}
void RepositoryWrapperFrame::bind(MainWindow *mw, LogTableWidget *logtablewidget, FilesListWidget *fileslistwidget, FilesListWidget *unstagedfileslistwidget, FilesListWidget *stagesfileslistwidget, FileDiffWidget *filediffwidget)
{
mw_ = mw;
logtablewidget_ = logtablewidget;
fileslistwidget_ = fileslistwidget;
unstagedfileslistwidget_ = unstagedfileslistwidget;
stagesfileslistwidget_ = stagesfileslistwidget;
filediffwidget_ = filediffwidget;
logtablewidget->bind(this);
}
MainWindow *RepositoryWrapperFrame::mainwindow()
{
Q_ASSERT(mw_);
return mw_;
}
MainWindow const *RepositoryWrapperFrame::mainwindow() const
{
Q_ASSERT(mw_);
return mw_;
}
LogTableWidget *RepositoryWrapperFrame::logtablewidget()
{
return logtablewidget_;
}
FilesListWidget *RepositoryWrapperFrame::fileslistwidget()
{
return fileslistwidget_;
}
FilesListWidget *RepositoryWrapperFrame::unstagedFileslistwidget()
{
return unstagedfileslistwidget_;
}
FilesListWidget *RepositoryWrapperFrame::stagedFileslistwidget()
{
return stagesfileslistwidget_;
}
FileDiffWidget *RepositoryWrapperFrame::filediffwidget()
{
return filediffwidget_;
}
const Git::CommitItem *RepositoryWrapperFrame::commitItem(int row)
{
return mainwindow()->commitItem(mainwindow()->frame(), row);
}
QIcon RepositoryWrapperFrame::verifiedIcon(char s) const
{
return mainwindow()->verifiedIcon(s);
}
QIcon RepositoryWrapperFrame::committerIcon(int row) const
{
- return mainwindow()->committerIcon(mainwindow()->frame(), row);
+ return mainwindow()->committerIcon(const_cast<RepositoryWrapperFrame *>(mainwindow()->frame()), row);
}
QList<BranchLabel> const *RepositoryWrapperFrame::label(int row) const
{
return mainwindow()->label(row);
}
QString RepositoryWrapperFrame::currentBranchName() const
{
return mainwindow()->currentBranchName();
}
const Git::CommitItemList &RepositoryWrapperFrame::getLogs() const
{
return mainwindow()->getLogs(mainwindow()->frame());
}
bool RepositoryWrapperFrame::isAncestorCommit(const QString &id)
{
return mainwindow()->isAncestorCommit(id);
}
QColor RepositoryWrapperFrame::color(unsigned int i)
{
return mainwindow()->color(i);
}
void RepositoryWrapperFrame::updateAncestorCommitMap()
{
mainwindow()->updateAncestorCommitMap(this);
}
void RepositoryWrapperFrame::updateLogTableView()
{
logtablewidget_->viewport()->update();
}
void RepositoryWrapperFrame::setFocusToLogTable()
{
logtablewidget_->setFocus();
}
void RepositoryWrapperFrame::selectLogTableRow(int row)
{
logtablewidget_->selectRow(row);
}
void RepositoryWrapperFrame::prepareLogTableWidget()
{
QStringList cols = {
tr("Graph"),
tr("Commit"),
tr("Date"),
tr("Author"),
tr("Message"),
};
int n = cols.size();
logtablewidget_->setColumnCount(n);
logtablewidget_->setRowCount(0);
for (int i = 0; i < n; i++) {
QString const &text = cols[i];
auto *item = new QTableWidgetItem(text);
logtablewidget_->setHorizontalHeaderItem(i, item);
}
mainwindow()->updateCommitGraph(this); // コミットグラフを更新
}
void RepositoryWrapperFrame::clearLogContents()
{
logtablewidget_->clearContents();
logtablewidget_->scrollToTop();
}
diff --git a/src/RepositoryWrapperFrame.h b/src/RepositoryWrapperFrame.h
index d1e78e6..c43585e 100644
--- a/src/RepositoryWrapperFrame.h
+++ b/src/RepositoryWrapperFrame.h
@@ -1,59 +1,67 @@
#ifndef REPOSITORYWRAPPERFRAME_H
#define REPOSITORYWRAPPERFRAME_H
#include "BranchLabel.h"
#include "Git.h"
#include <QFrame>
class MainWindow;
class LogTableWidget;
class FilesListWidget;
class FileDiffWidget;
class RepositoryWrapperFrame : public QFrame {
Q_OBJECT
friend class MainWindow;
private:
Git::CommitItemList logs;
MainWindow *mw_ = nullptr;
LogTableWidget *logtablewidget_ = nullptr;
FilesListWidget *fileslistwidget_ = nullptr;
FilesListWidget *unstagedfileslistwidget_ = nullptr;
FilesListWidget *stagesfileslistwidget_ = nullptr;
FileDiffWidget *filediffwidget_ = nullptr;
MainWindow *mainwindow();
MainWindow const *mainwindow() const;
public:
explicit RepositoryWrapperFrame(QWidget *parent = nullptr);
Git::CommitItem const *commitItem(int row);
QIcon verifiedIcon(char s) const;
QIcon committerIcon(int row) const;
const QList<BranchLabel> *label(int row) const;
QString currentBranchName() const;
const Git::CommitItemList &getLogs() const;
bool isAncestorCommit(const QString &id);
QColor color(unsigned int i);
void updateAncestorCommitMap();
void bind(MainWindow *mw
, LogTableWidget *logtablewidget
, FilesListWidget *fileslistwidget
, FilesListWidget *unstagedfileslistwidget
, FilesListWidget *stagesfileslistwidget
, FileDiffWidget *filediffwidget
);
void prepareLogTableWidget();
void clearLogContents();
LogTableWidget *logtablewidget();
FilesListWidget *fileslistwidget();
FilesListWidget *unstagedFileslistwidget();
FileDiffWidget *filediffwidget();
FilesListWidget *stagedFileslistwidget();
void updateLogTableView();
void setFocusToLogTable();
void selectLogTableRow(int row);
};
+struct RepositoryWrapperFrameP {
+ RepositoryWrapperFrame *pointer;
+ RepositoryWrapperFrameP(RepositoryWrapperFrame *pointer = nullptr)
+ : pointer(pointer)
+ {
+ }
+};
+
#endif // REPOSITORYWRAPPERFRAME_H
diff --git a/src/SetUserDialog.cpp b/src/SetUserDialog.cpp
index b7540bc..2ace25b 100644
--- a/src/SetUserDialog.cpp
+++ b/src/SetUserDialog.cpp
@@ -1,130 +1,130 @@
#include "SetUserDialog.h"
#include "ui_SetUserDialog.h"
#include "AvatarLoader.h"
#include "MainWindow.h"
#include "common/misc.h"
struct SetUserDialog::Private {
Git::User global_user;
Git::User repo_user;
AvatarLoader avatar_loader;
};
SetUserDialog::SetUserDialog(MainWindow *parent, Git::User const &global_user, Git::User const &repo_user, QString const &repo)
: QDialog(parent)
, ui(new Ui::SetUserDialog)
, m(new Private)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
misc::setFixedSize(this);
m->global_user = global_user;
m->repo_user = repo_user;
if (repo.isEmpty()) {
ui->radioButton_repository->setEnabled(false);
} else {
QString text = tr("Repository");
text += " : ";
text += repo;
ui->radioButton_repository->setText(text);
}
ui->radioButton_global->click();
ui->lineEdit_name->setFocus();
m->avatar_loader.start(mainwindow());
- connect(&m->avatar_loader, &AvatarLoader::updated, [&](){
+ connect(&m->avatar_loader, &AvatarLoader::updated, [&](RepositoryWrapperFrameP frame){
QString email = ui->lineEdit_mail->text();
- QIcon icon = m->avatar_loader.fetch(email.toStdString(), false);
+ QIcon icon = m->avatar_loader.fetch(frame.pointer, email.toStdString(), false);
setAvatar(icon);
});
}
SetUserDialog::~SetUserDialog()
{
m->avatar_loader.stop();
delete m;
delete ui;
}
MainWindow *SetUserDialog::mainwindow()
{
return qobject_cast<MainWindow *>(parent());
}
bool SetUserDialog::isGlobalChecked() const
{
return ui->radioButton_global->isChecked();
}
bool SetUserDialog::isRepositoryChecked() const
{
return ui->radioButton_repository->isChecked();
}
Git::User SetUserDialog::user() const
{
Git::User user;
user.name = ui->lineEdit_name->text();
user.email = ui->lineEdit_mail->text();
return user;
}
void SetUserDialog::setAvatar(QIcon const &icon)
{
QPixmap pm = icon.pixmap(QSize(64, 64));
ui->label_avatar->setPixmap(pm);
}
void SetUserDialog::on_radioButton_global_toggled(bool checked)
{
if (checked) {
ui->lineEdit_name->setText(m->global_user.name);
ui->lineEdit_mail->setText(m->global_user.email);
}
}
void SetUserDialog::on_radioButton_repository_toggled(bool checked)
{
if (checked) {
ui->lineEdit_name->setText(m->repo_user.name);
ui->lineEdit_mail->setText(m->repo_user.email);
}
}
void SetUserDialog::on_lineEdit_name_textChanged(QString const &text)
{
if (isGlobalChecked()) {
m->global_user.name = text;
}
if (isRepositoryChecked()) {
m->repo_user.name = text;
}
}
void SetUserDialog::on_lineEdit_mail_textChanged(QString const &text)
{
if (isGlobalChecked()) {
m->global_user.email = text;
}
if (isRepositoryChecked()) {
m->repo_user.email = text;
}
}
void SetUserDialog::on_pushButton_get_icon_clicked()
{
ui->label_avatar->setPixmap(QPixmap());
QString email = ui->lineEdit_mail->text();
if (email.indexOf('@') > 0) {
- QIcon icon = m->avatar_loader.fetch(email.toStdString(), true);
+ QIcon icon = m->avatar_loader.fetch(nullptr, email.toStdString(), true);
if (!icon.isNull()) {
setAvatar(icon);
}
}
}
diff --git a/src/UserEvent.h b/src/UserEvent.h
index 2ef6abb..713172f 100644
--- a/src/UserEvent.h
+++ b/src/UserEvent.h
@@ -1,35 +1,37 @@
#ifndef USEREVENT_H
#define USEREVENT_H
#include <QEvent>
#include <QVariant>
#include <functional>
-enum UserEvent {
+enum class UserEvent {
Start = QEvent::User,
- EventUserFunction,
+ UserFunction,
};
class StartEvent : public QEvent {
public:
StartEvent()
: QEvent((QEvent::Type)UserEvent::Start)
{
}
};
class UserFunctionEvent : public QEvent {
public:
- std::function<void(QVariant &)> func;
+ std::function<void(QVariant const &, void *ptr)> func;
QVariant var;
+ void *ptr = nullptr;
- explicit UserFunctionEvent(std::function<void(QVariant const &)> const &func, QVariant const &var)
- : QEvent((QEvent::Type)EventUserFunction)
+ explicit UserFunctionEvent(std::function<void(QVariant const &, void *ptr)> const &func, QVariant const &var, void *ptr = nullptr)
+ : QEvent((QEvent::Type)UserEvent::UserFunction)
, func(func)
, var(var)
+ , ptr(ptr)
{
}
};
#endif // USEREVENT_H
diff --git a/src/WelcomeWizardDialog.cpp b/src/WelcomeWizardDialog.cpp
index 6d10a4a..d5b63a1 100644
--- a/src/WelcomeWizardDialog.cpp
+++ b/src/WelcomeWizardDialog.cpp
@@ -1,216 +1,216 @@
#include "WelcomeWizardDialog.h"
#include "ui_WelcomeWizardDialog.h"
#include <QFileDialog>
#include "MainWindow.h"
#include "common/misc.h"
#include "Git.h"
WelcomeWizardDialog::WelcomeWizardDialog(MainWindow *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, [&](){
+ connect(&avatar_loader_, &AvatarLoader::updated, [&](RepositoryWrapperFrameP frame){
QString email = ui->lineEdit_user_email->text();
- QIcon icon = avatar_loader_.fetch(email.toStdString(), false);
+ QIcon icon = avatar_loader_.fetch(frame.pointer, 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);
+ QIcon icon = avatar_loader_.fetch(nullptr, 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/main.cpp b/src/main.cpp
index 3c79ae2..5a41008 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,190 +1,191 @@
#include "main.h"
#include "ApplicationGlobal.h"
#include "MainWindow.h"
#include "MySettings.h"
#include "SettingGeneralForm.h"
#include "common/joinpath.h"
#include "common/misc.h"
#include "darktheme/DarkStyle.h"
#include "platform.h"
#include "webclient.h"
#include <QApplication>
#include <QDebug>
#include <QDir>
#include <QMessageBox>
#include <QProxyStyle>
#include <QStandardPaths>
#include <QTranslator>
#include <signal.h>
#include <string>
#ifdef Q_OS_WIN
#include "win32/win32.h"
#include "SettingGeneralForm.h"
#endif
#ifndef APP_GUITAR
#error APP_GUITAR is not defined.
#endif
ApplicationGlobal *global = nullptr;
ApplicationSettings ApplicationSettings::defaultSettings()
{
ApplicationSettings s;
s.proxy_server = "http://squid:3128/";
s.branch_label_color.head = QColor(255, 192, 224); // pink
s.branch_label_color.local = QColor(192, 224, 255); // blue
s.branch_label_color.remote = QColor(192, 240, 224); // green
s.branch_label_color.tag = QColor(255, 224, 192); // orange
return s;
}
static bool isHighDpiScalingEnabled()
{
MySettings s;
s.beginGroup("UI");
QVariant v = s.value("EnableHighDpiScaling");
return v.isNull() || v.toBool();
}
void setEnvironmentVariable(QString const &name, QString const &value);
void onSigTerm(int)
{
qDebug() << "SIGTERM caught";
if (global->mainwindow) {
global->mainwindow->close();
}
}
int main(int argc, char *argv[])
{
#ifdef Q_OS_WIN
setEnvironmentVariable("UNICODEMAP_JP", "cp932");
#else
setenv("UNICODEMAP_JP", "cp932", 1);
#endif
ApplicationGlobal g;
global = &g;
signal(SIGTERM, onSigTerm);
global->organization_name = ORGANIZATION_NAME;
global->application_name = APPLICATION_NAME;
global->generic_config_dir = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
global->app_config_dir = global->generic_config_dir / global->organization_name / global->application_name;
global->config_file_path = joinpath(global->app_config_dir, global->application_name + ".ini");
if (!QFileInfo(global->app_config_dir).isDir()) {
QDir().mkpath(global->app_config_dir);
}
if (isHighDpiScalingEnabled()){
#if (QT_VERSION < QT_VERSION_CHECK(5, 6, 0))
qDebug() << "High DPI scaling is not supported";
#else
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
#endif
}
QApplication a(argc, argv);
a.setAttribute(Qt::AA_UseHighDpiPixmaps);
QApplication::setOrganizationName(global->organization_name);
QApplication::setApplicationName(global->application_name);
qRegisterMetaType<RepositoryItem>("RepositoryItem");
+ qRegisterMetaType<RepositoryWrapperFrameP>("RepositoryWrapperFrameP");
{
MySettings s;
s.beginGroup("UI");
global->language_id = s.value("Language").toString();
global->theme_id = s.value("Theme").toString();
if (global->theme_id.compare("dark", Qt::CaseInsensitive) == 0) {
global->theme = createDarkTheme();
} else {
global->theme = createStandardTheme();
}
s.endGroup();
}
QApplication::setStyle(global->theme->newStyle());
if (QApplication::queryKeyboardModifiers() & Qt::ShiftModifier) {
global->start_with_shift_key = true;
}
WebClient::initialize();
bool f_open_here = false;
QStringList args;
for (int i = 1; i < argc; i++) {
std::string arg = argv[i];
if (arg[0] == '-') {
if (arg == "--open-here") {
f_open_here = true;
}
} else {
args.push_back(QString::fromStdString(arg));
}
}
if (global->app_config_dir.isEmpty()) {
QMessageBox::warning(nullptr, qApp->applicationName(), "Preparation of data storage folder failed.");
return 1;
}
// 設定ファイルがないときは、言語の選択をする。
if (!QFileInfo::exists(global->config_file_path)) {
auto langs = SettingGeneralForm::languages();
SettingGeneralForm::execSelectLanguageDialog(nullptr, langs, [](){});
}
QTranslator translator;
{
if (global->language_id.isEmpty() || global->language_id == "en") {
// thru
} else {
QString path = ":/translations/Guitar_" + global->language_id;
bool f = translator.load(path, QApplication::applicationDirPath());
if (!f) {
qDebug() << QString("Failed to load the translation file: %1").arg(path);
}
QApplication::installTranslator(&translator);
}
}
MainWindow w;
global->mainwindow = &w;
global->panel_bg_color = w.palette().color(QPalette::Background);
w.setWindowIcon(QIcon(":/image/guitar.png"));
w.show();
w.shown();
if (f_open_here) {
QString dir = QDir::current().absolutePath();
w.autoOpenRepository(dir);
} else if (args.size() == 1) {
QString dir = args[0] / QString();
if (dir.startsWith("./") || dir.startsWith(".\\")) {
dir = QDir::current().absolutePath() / dir.mid(2);
}
QFileInfo fi(dir);
if (fi.isDir()) {
dir = fi.absolutePath();
w.autoOpenRepository(dir);
}
}
int r = QApplication::exec();
global->mainwindow = nullptr;
return r;
}

File Metadata

Mime Type
text/x-diff
Expires
Sat, Feb 7, 8:48 AM (23 h, 12 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
55926
Default Alt Text
(266 KB)

Event Timeline