Page MenuHomePhabricator (Chris)
Files F131203

No OneTemporary
Actions

Authored By
Unknown
Size
300 KB
Referenced Files
None
Subscribers
None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/Guitar.pro b/Guitar.pro
index 1c8b4b2..1440596 100644
--- a/Guitar.pro
+++ b/Guitar.pro
@@ -1,393 +1,395 @@
QT += core gui widgets svg network
win32:QT += winextras
CONFIG(debug,debug|release):TARGET = Guitard
CONFIG(release,debug|release):TARGET = Guitar
TEMPLATE = app
CONFIG += c++11
DESTDIR = $$PWD/_bin
TRANSLATIONS = Guitar_ja.ts
DEFINES += APP_GUITAR
DEFINES += USE_DARK_THEME
DEFINES += HAVE_POSIX_OPENPT
macx:DEFINES += HAVE_SYS_TIME_H
macx:DEFINES += HAVE_UTMPX
gcc:QMAKE_CXXFLAGS += -Wall -Wextra -Werror=return-type -Werror=trigraphs -Wno-switch -Wno-reorder
linux:QMAKE_RPATHDIR += $ORIGIN
macx:QMAKE_RPATHDIR += @executable_path/../Frameworks
linux:QTPLUGIN += ibusplatforminputcontextplugin
#linux:QTPLUGIN += fcitxplatforminputcontextplugin
INCLUDEPATH += $$PWD/src
INCLUDEPATH += $$PWD/src/texteditor
win32:INCLUDEPATH += $$PWD/winpty
win32:LIBS += $$PWD/winpty/winpty.lib
# OpenSSL
linux:LIBS += -lssl -lcrypto
haiku:LIBS += -lssl -lcrypto -lnetwork
macx:INCLUDEPATH += /usr/local/include
macx:LIBS += /usr/local/lib/libssl.a /usr/local/lib/libcrypto.a
win32:msvc {
INCLUDEPATH += C:\openssl\include
LIBS += -LC:\openssl\lib
}
win32:gcc {
INCLUDEPATH += C:\Qt\Tools\mingw530_32\opt\include
LIBS += -LC:\Qt\Tools\mingw530_32\opt\lib
LIBS += -lcrypto -lssl
}
# execute 'ruby prepare.rb' automatically
prepare.target = prepare
prepare.commands = cd $$PWD && ruby -W0 prepare.rb
QMAKE_EXTRA_TARGETS += prepare
PRE_TARGETDEPS += prepare
# zlib
win32:msvc {
CONFIG(debug, debug|release):LIBS += $$PWD/_bin/libz.lib
CONFIG(release, debug|release):LIBS += $$PWD/_bin/libz.lib
}
win32:gcc {
CONFIG(debug, debug|release):LIBS += $$PWD/_bin/liblibz.a
CONFIG(release, debug|release):LIBS += $$PWD/_bin/liblibz.a
}
!haiku {
unix:CONFIG(debug, debug|release):LIBS += $$PWD/_bin/libzd.a
unix:CONFIG(release, debug|release):LIBS += $$PWD/_bin/libz.a
#unix:LIBS += -lz
}
haiku:LIBS += -lz
win32 {
LIBS += -ladvapi32 -lshell32 -luser32 -lws2_32
RC_FILE = win.rc
QMAKE_SUBSYSTEM_SUFFIX=,5.01
}
macx {
QMAKE_INFO_PLIST = Info.plist
ICON += Guitar.icns
t.path=Contents/Resources
QMAKE_BUNDLE_DATA += t
}
SOURCES += \
version.c \
src/main.cpp\
src/MainWindow.cpp \
src/Git.cpp \
src/common/joinpath.cpp \
src/common/misc.cpp \
src/ConfigCredentialHelperDialog.cpp \
src/MySettings.cpp \
src/FileDiffWidget.cpp \
src/TextEditDialog.cpp \
src/LogTableWidget.cpp \
src/FileDiffSliderWidget.cpp \
src/FileUtil.cpp \
src/SettingsDialog.cpp \
src/MergeBranchDialog.cpp \
src/CloneDialog.cpp \
src/AboutDialog.cpp \
src/RepositoryInfoFrame.cpp \
src/RepositoryPropertyDialog.cpp \
src/RepositoryData.cpp \
src/MyToolButton.cpp \
src/GitDiff.cpp \
src/CommitPropertyDialog.cpp \
src/Terminal.cpp \
src/DeleteTagsDialog.cpp \
src/RepositoriesTreeWidget.cpp \
src/SelectCommandDialog.cpp \
src/ImageViewWidget.cpp \
src/FileHistoryWindow.cpp \
src/GitPackIdxV2.cpp \
src/GitPack.cpp \
src/GitObjectManager.cpp \
src/FilePropertyDialog.cpp \
src/BigDiffWindow.cpp \
src/MaximizeButton.cpp \
src/CommitExploreWindow.cpp \
src/ReadOnlyLineEdit.cpp \
src/ReadOnlyPlainTextEdit.cpp \
src/MyTableWidgetDelegate.cpp \
src/SetRemoteUrlDialog.cpp \
src/ClearButton.cpp \
src/SetUserDialog.cpp \
src/SearchFromGitHubDialog.cpp \
src/webclient.cpp \
src/charvec.cpp \
src/urlencode.cpp \
src/HyperLinkLabel.cpp \
src/JumpDialog.cpp \
src/CheckoutDialog.cpp \
src/DeleteBranchDialog.cpp \
src/BasicRepositoryDialog.cpp \
src/RemoteRepositoriesTableWidget.cpp \
src/LocalSocketReader.cpp \
src/PushDialog.cpp \
src/StatusLabel.cpp \
src/RepositoryLineEdit.cpp \
src/DirectoryLineEdit.cpp \
src/AbstractSettingForm.cpp \
src/SettingExampleForm.cpp \
src/CreateRepositoryDialog.cpp \
src/GitHubAPI.cpp \
src/MemoryReader.cpp \
src/ExperimentDialog.cpp \
src/gunzip.cpp \
src/AvatarLoader.cpp \
src/SettingNetworkForm.cpp \
src/Photoshop.cpp \
src/SettingBehaviorForm.cpp \
src/MyProcess.cpp \
src/FileViewWidget.cpp \
src/MyTextEditorWidget.cpp \
src/AbstractProcess.cpp \
src/texteditor/AbstractCharacterBasedApplication.cpp \
src/texteditor/InputMethodPopup.cpp \
src/texteditor/TextEditorTheme.cpp \
src/texteditor/TextEditorWidget.cpp \
src/texteditor/unicode.cpp \
src/texteditor/UnicodeWidth.cpp \
src/MyImageViewWidget.cpp \
src/SetGlobalUserDialog.cpp \
src/ReflogWindow.cpp \
src/Theme.cpp \
src/ApplicationGlobal.cpp \
src/BlameWindow.cpp \
src/MenuButton.cpp \
src/SettingGeneralForm.cpp \
src/WelcomeWizardDialog.cpp \
src/DialogHeaderFrame.cpp \
src/CommitViewWindow.cpp \
src/EditRemoteDialog.cpp \
src/gpg.cpp \
src/SelectGpgKeyDialog.cpp \
src/SetGpgSigningDialog.cpp \
src/CommitDialog.cpp \
src/ConfigSigningDialog.cpp \
src/AreYouSureYouWantToContinueConnectingDialog.cpp \
src/LineEditDialog.cpp \
src/SettingProgramsForm.cpp \
src/InputNewTagDialog.cpp \
src/EditTagsDialog.cpp \
darktheme/src/DarkStyle.cpp \
darktheme/src/NinePatch.cpp \
darktheme/src/StandardStyle.cpp \
darktheme/src/TraditionalWindowsStyleTreeControl.cpp \
src/EditGitIgnoreDialog.cpp \
src/SelectItemDialog.cpp \
src/RebaseOntoDialog.cpp \
src/DoYouWantToInitDialog.cpp \
- src/RemoteWatcher.cpp
+ src/RemoteWatcher.cpp \
+ src/BasicMainWindow.cpp
HEADERS += \
src/MainWindow.h \
src/Git.h \
src/common/joinpath.h \
src/common/misc.h \
src/ConfigCredentialHelperDialog.h \
src/MySettings.h \
src/main.h \
src/FileDiffWidget.h \
src/TextEditDialog.h \
src/LogTableWidget.h \
src/FileDiffSliderWidget.h \
src/FileUtil.h \
src/SettingsDialog.h \
src/MergeBranchDialog.h \
src/CloneDialog.h \
src/AboutDialog.h \
src/RepositoryInfoFrame.h \
src/RepositoryPropertyDialog.h \
src/RepositoryData.h \
src/MyToolButton.h \
src/GitDiff.h \
src/CommitPropertyDialog.h \
src/Terminal.h \
src/DeleteTagsDialog.h \
src/RepositoriesTreeWidget.h \
src/SelectCommandDialog.h \
src/ImageViewWidget.h \
src/FileHistoryWindow.h \
src/Debug.h \
src/GitPackIdxV2.h \
src/GitPack.h \
src/GitObjectManager.h \
src/FilePropertyDialog.h \
src/BigDiffWindow.h \
src/MaximizeButton.h \
src/CommitExploreWindow.h \
src/ReadOnlyLineEdit.h \
src/ReadOnlyPlainTextEdit.h \
src/MyTableWidgetDelegate.h \
src/SetRemoteUrlDialog.h \
myzlib.h \
src/ClearButton.h \
src/SetUserDialog.h \
src/SearchFromGitHubDialog.h \
src/webclient.h \
src/charvec.h \
src/urlencode.h \
src/HyperLinkLabel.h \
src/JumpDialog.h \
src/CheckoutDialog.h \
src/DeleteBranchDialog.h \
src/BasicRepositoryDialog.h \
src/RemoteRepositoriesTableWidget.h \
src/LocalSocketReader.h \
src/PushDialog.h \
src/StatusLabel.h \
src/RepositoryLineEdit.h \
src/DirectoryLineEdit.h \
src/AbstractSettingForm.h \
src/SettingExampleForm.h \
src/CreateRepositoryDialog.h \
src/GitHubAPI.h \
src/MemoryReader.h \
src/ExperimentDialog.h \
src/gunzip.h \
src/AvatarLoader.h \
src/SettingNetworkForm.h \
src/Photoshop.h \
src/SettingBehaviorForm.h \
src/MyProcess.h \
src/MyTextEditorWidget.h \
src/AbstractProcess.h \
src/texteditor/AbstractCharacterBasedApplication.h \
src/texteditor/InputMethodPopup.h \
src/texteditor/TextEditorTheme.h \
src/texteditor/TextEditorWidget.h \
src/texteditor/unicode.h \
src/texteditor/UnicodeWidth.h \
src/MyImageViewWidget.h \
src/SetGlobalUserDialog.h \
src/ReflogWindow.h \
src/Theme.h \
src/ApplicationGlobal.h \
src/BlameWindow.h \
src/MenuButton.h \
src/SettingGeneralForm.h \
src/WelcomeWizardDialog.h \
src/DialogHeaderFrame.h \
src/CommitViewWindow.h \
src/EditRemoteDialog.h \
src/gpg.h \
src/SelectGpgKeyDialog.h \
src/SetGpgSigningDialog.h \
src/CommitDialog.h \
src/ConfigSigningDialog.h \
src/AreYouSureYouWantToContinueConnectingDialog.h \
src/LineEditDialog.h \
src/SettingProgramsForm.h \
src/InputNewTagDialog.h \
src/EditTagsDialog.h \
darktheme/src/DarkStyle.h \
darktheme/src/NinePatch.h \
darktheme/src/StandardStyle.h \
darktheme/src/TraditionalWindowsStyleTreeControl.h \
src/EditGitIgnoreDialog.h \
src/SelectItemDialog.h \
src/RebaseOntoDialog.h \
src/DoYouWantToInitDialog.h \
- src/RemoteWatcher.h
+ src/RemoteWatcher.h \
+ src/BasicMainWindow.h
FORMS += \
src/MainWindow.ui \
src/ConfigCredentialHelperDialog.ui \
src/TextEditDialog.ui \
src/SettingsDialog.ui \
src/MergeBranchDialog.ui \
src/CloneDialog.ui \
src/AboutDialog.ui \
src/RepositoryPropertyDialog.ui \
src/CommitPropertyDialog.ui \
src/DeleteTagsDialog.ui \
src/SelectCommandDialog.ui \
src/FileDiffWidget.ui \
src/FileHistoryWindow.ui \
src/FilePropertyDialog.ui \
src/BigDiffWindow.ui \
src/CommitExploreWindow.ui \
src/SetRemoteUrlDialog.ui \
src/SetUserDialog.ui \
src/SearchFromGitHubDialog.ui \
src/JumpDialog.ui \
src/CheckoutDialog.ui \
src/DeleteBranchDialog.ui \
src/PushDialog.ui \
src/SettingExampleForm.ui \
src/CreateRepositoryDialog.ui \
src/ExperimentDialog.ui \
src/SettingNetworkForm.ui \
src/SettingBehaviorForm.ui \
src/SetGlobalUserDialog.ui \
src/ReflogWindow.ui \
src/BlameWindow.ui \
src/SettingGeneralForm.ui \
src/WelcomeWizardDialog.ui \
src/CommitViewWindow.ui \
src/EditRemoteDialog.ui \
src/SelectGpgKeyDialog.ui \
src/SetGpgSigningDialog.ui \
src/CommitDialog.ui \
src/ConfigSigningDialog.ui \
src/AreYouSureYouWantToContinueConnectingDialog.ui \
src/LineEditDialog.ui \
src/SettingProgramsForm.ui \
src/InputNewTagDialog.ui \
src/EditTagsDialog.ui \
src/EditGitIgnoreDialog.ui \
src/SelectItemDialog.ui \
src/RebaseOntoDialog.ui \
src/DoYouWantToInitDialog.ui
RESOURCES += \
resources.qrc
unix {
SOURCES += \
src/unix/UnixProcess.cpp \
src/unix/UnixPtyProcess.cpp
HEADERS += \
src/unix/UnixProcess.h \
src/unix/UnixPtyProcess.h
}
win32 {
SOURCES += \
src/win32/thread.cpp \
src/win32/event.cpp \
src/win32/win32.cpp \
src/win32/Win32Process.cpp \
src/win32/Win32PtyProcess.cpp
HEADERS += \
src/win32/thread.h \
src/win32/event.h \
src/win32/mutex.h \
src/win32/win32.h \
src/win32/Win32Process.h \
src/win32/Win32PtyProcess.h
}
diff --git a/src/AvatarLoader.cpp b/src/AvatarLoader.cpp
index 8ce5483..414629c 100644
--- a/src/AvatarLoader.cpp
+++ b/src/AvatarLoader.cpp
@@ -1,182 +1,182 @@
#include "AvatarLoader.h"
#include "MemoryReader.h"
#include "webclient.h"
#include <QCryptographicHash>
#include <QDebug>
namespace {
const int MAX_CACHE_COUNT = 1000;
const int ICON_SIZE = 64;
}
using WebClientPtr = std::shared_ptr<WebClient>;
struct AvatarLoader::Private {
QMutex data_mutex;
QMutex thread_mutex;
QWaitCondition condition;
std::map<std::string, std::string> avatar_url_cache;
std::deque<RequestItem> requested;
std::deque<RequestItem> completed;
std::set<std::string> notfound;
WebContext *webcx = nullptr;
WebClientPtr web;
};
AvatarLoader::AvatarLoader()
: m(new Private)
{
}
AvatarLoader::~AvatarLoader()
{
delete m;
}
void AvatarLoader::start(WebContext *webcx)
{
m->webcx = webcx;
QThread::start();
}
void AvatarLoader::run()
{
m->web = std::make_shared<WebClient>(m->webcx);
while (1) {
std::deque<RequestItem> requests;
if (isInterruptionRequested()) return;
m->thread_mutex.lock();
{
QMutexLocker lock(&m->data_mutex);
requests = std::move(m->requested);
}
if (requests.empty()) {
m->condition.wait(&m->thread_mutex);
{
QMutexLocker lock(&m->data_mutex);
requests = std::move(m->requested);
}
}
m->thread_mutex.unlock();
if (isInterruptionRequested()) return;
for (RequestItem &item : requests) {
if (isInterruptionRequested()) return;
if (item.email.empty()) continue;
if (strchr(item.email.c_str(), '@')) {
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);
}
QString id = tmp;
QString url = "https://www.gravatar.com/avatar/%1?s=%2";
url = url.arg(id).arg(ICON_SIZE);
if (m->web->get(WebClient::URL(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.icon = QIcon(QPixmap::fromImage(image));
{
QMutexLocker lock(&m->data_mutex);
while (m->completed.size() >= MAX_CACHE_COUNT) {
m->completed.pop_back();
}
m->completed.push_front(item);
}
emit updated();
continue;
}
}
}
}
{ // not found
QMutexLocker lock(&m->data_mutex);
m->notfound.insert(m->notfound.end(), item.email);
}
}
}
}
namespace {
bool isValidGitHubName(std::string const &name)
{
size_t n = name.size();
if (n < 1 || n > 39) return false;
char const *begin = name.c_str();
char const *end = begin + name.size();
char const *ptr = begin;
while (ptr < end) {
int c = (unsigned char)*ptr;
ptr++;
if (isalnum(c)) {
// ok
} else if (c == '-') {
if (ptr == begin) return false;
if (ptr < end && *ptr == '-') return false;
}
}
return true;
}
}
-QIcon AvatarLoader::fetch(std::string const &email, bool request)
+QIcon AvatarLoader::fetch(std::string const &email, bool request) const
{
RequestItem item;
item.email = email;
if (isValidGitHubName(item.email)) {
QMutexLocker lock(&m->data_mutex);
auto it = m->notfound.find(item.email);
if (it == m->notfound.end()) {
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 item.icon;
}
}
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()
{
requestInterruption();
if (m->web) m->web->close();
m->condition.wakeAll();
wait();
}
diff --git a/src/AvatarLoader.h b/src/AvatarLoader.h
index 5e1a3b6..1b42da7 100644
--- a/src/AvatarLoader.h
+++ b/src/AvatarLoader.h
@@ -1,37 +1,37 @@
#ifndef AVATARLOADER_H
#define AVATARLOADER_H
#include "GitHubAPI.h"
#include <QIcon>
#include <QThread>
#include <QMutex>
#include <deque>
#include <QWaitCondition>
#include <set>
#include <string>
class WebContext;
class AvatarLoader : public QThread {
Q_OBJECT
private:
struct RequestItem {
std::string email;
QIcon icon;
};
struct Private;
Private *m;
protected:
void run();
public:
AvatarLoader();
~AvatarLoader();
- QIcon fetch(const std::string &email, bool request);
+ QIcon fetch(const std::string &email, bool request) const;
void stop();
void start(WebContext *webcx);
signals:
void updated();
};
#endif // AVATARLOADER_H
diff --git a/src/BasicMainWindow.cpp b/src/BasicMainWindow.cpp
new file mode 100644
index 0000000..8f5295c
--- /dev/null
+++ b/src/BasicMainWindow.cpp
@@ -0,0 +1,11 @@
+#include "BasicMainWindow.h"
+
+BasicMainWindow::BasicMainWindow(QWidget *parent)
+ : QMainWindow(parent)
+{
+}
+
+WebContext *BasicMainWindow::webContext()
+{
+ return &webcx_;
+}
diff --git a/src/BasicMainWindow.h b/src/BasicMainWindow.h
new file mode 100644
index 0000000..0b45291
--- /dev/null
+++ b/src/BasicMainWindow.h
@@ -0,0 +1,254 @@
+#ifndef BASICMAINWINDOW_H
+#define BASICMAINWINDOW_H
+
+#include <QMainWindow>
+#include "BasicMainWindow.h"
+#include "Git.h"
+#include "RepositoryData.h"
+#include "GitHubAPI.h"
+#include "main.h"
+#include "TextEditorTheme.h"
+#include "GitObjectManager.h"
+#include "webclient.h"
+#include "AvatarLoader.h"
+#include <functional>
+#include <memory>
+#include "MyProcess.h"
+
+class QListWidget;
+class QListWidgetItem;
+
+struct GitHubRepositoryInfo {
+ QString owner_account_name;
+ QString repository_name;
+};
+
+
+class BasicMainWindow : public QMainWindow {
+ Q_OBJECT
+public:
+ struct Label {
+ enum {
+ Head,
+ LocalBranch,
+ RemoteBranch,
+ Tag,
+ };
+ int kind;
+ QString text;
+ Label(int kind = LocalBranch)
+ : kind(kind)
+ {
+
+ }
+ };
+protected:
+ struct Diff_ {
+ QList<Git::Diff> result;
+ std::shared_ptr<QThread> thread;
+ QList<std::shared_ptr<QThread>> garbage;
+ };
+
+ enum class PtyCondition {
+ None,
+ Clone,
+ Fetch,
+ Pull,
+ Push,
+ };
+
+ enum InteractionMode {
+ None,
+ Busy,
+ };
+
+ enum NamedCommitFlag {
+ Branches = 0x0001,
+ Tags = 0x0002,
+ Remotes = 0x0100,
+ };
+
+ enum class FilesListType {
+ SingleList,
+ SideBySide,
+ };
+
+
+ QString starting_dir_;
+ Git::Context gcx_;
+ ApplicationSettings appsettings_;
+ QList<RepositoryItem> repos_;
+ RepositoryItem current_repo_;
+ ServerType server_type_ = ServerType::Standard;
+ GitHubRepositoryInfo github_;
+ QString current_remote_;
+ Git::Branch current_branch_;
+ QString head_id_;
+ BasicMainWindow::Diff_ diff_;
+ std::map<QString, Git::Diff> diff_cache_;
+ QStringList added_;
+ Git::CommitItemList logs_;
+ bool force_fetch_ = false;
+ bool uncommited_changes_ = false;
+ int update_files_list_counter_ = 0;
+ std::map<int, QList<Label>> label_map_;
+ QStringList remotes_;
+ std::map<QString, QList<Git::Branch>> branch_map_;
+ std::map<QString, QList<Git::Tag>> tag_map_;
+ QString repository_filter_text_;
+ unsigned int temp_file_counter_ = 0;
+ GitObjectCache objcache_;
+
+ WebContext webcx_;
+ AvatarLoader avatar_loader_;
+ int update_commit_table_counter_ = 0;
+
+ std::map<QString, GitHubAPI::User> committer_map_; // key is email
+
+ PtyProcess pty_process_;
+ PtyCondition pty_condition_ = PtyCondition::None;
+ bool pty_process_ok_ = false;
+
+ RepositoryItem temp_repo_;
+ InteractionMode interaction_mode_ = InteractionMode::None;
+ bool interaction_canceled_ = false;
+
+ bool remote_changed_ = false;
+
+ std::string ssh_passphrase_for_;
+ std::string ssh_passphrase_secret_;
+
+ std::string http_uid_;
+ std::string http_pwd_;
+
+ QIcon repository_icon_;
+ QIcon folder_icon_;
+ QIcon signature_good_icon_;
+ QIcon signature_dubious_icon_;
+ QIcon signature_bad_icon_;
+
+ QPixmap transparent_pixmap_;
+
+ QString selectCommand_(const QString &cmdname, const QStringList &cmdfiles, const QStringList &list, QString path, std::function<void (const QString &)> callback);
+ QString selectCommand_(const QString &cmdname, const QString &cmdfile, const QStringList &list, QString path, std::function<void (const QString &)> callback);
+ bool checkGitCommand();
+ bool checkFileCommand();
+ static bool git_callback(void *cookie, const char *ptr, int len);
+ void emitWriteLog(QByteArray ba);
+ void internalSetCommand(const QString &path, bool save, const QString &name, QString *out);
+ virtual void internalWriteLog(const char *ptr, int len) = 0;
+ QStringList whichCommand_(const QString &cmdfile1, const QString &cmdfile2 = QString());
+ void checkUser();
+ bool execSetGlobalUserDialog();
+ void setWindowTitle_(const Git::User &user);
+ void setUnknownRepositoryInfo();
+ virtual void setRepositoryInfo(const QString &reponame, const QString &brname) = 0;
+ void updateWindowTitle(GitPtr g);
+ Git::CommitItemList retrieveCommitLog(GitPtr g);
+ void initNetworking();
+ bool saveByteArrayAs(const QByteArray &ba, const QString &dstpath);
+ bool saveFileAs(const QString &srcpath, const QString &dstpath);
+ bool saveBlobAs(const QString &id, const QString &dstpath);
+
+ void openRepository(bool validate, bool waitcursor = true);
+ virtual void removeSelectedRepositoryFromBookmark(bool ask) = 0;
+ virtual void openRepository_(GitPtr g) = 0;
+ virtual void setCurrentLogRow(int row) = 0;
+ bool saveRepositoryBookmarks() const;
+ QString getBookmarksFilePath() const;
+ virtual void updateRepositoriesList() = 0;
+ virtual int selectedLogIndex() const = 0;
+ virtual void clearFileList() = 0;
+ virtual void updateFilesList(QString id, bool wait) = 0;
+public:
+ explicit BasicMainWindow(QWidget *parent = nullptr);
+ WebContext *webContext();
+ QString currentRepositoryName() const;
+ QString currentRemoteName() const;
+ const Git::Branch &currentBranch() const;
+ QString currentBranchName() const;
+ virtual QString currentWorkingCopyDir() const;
+ GitPtr git(const QString &dir) const;
+ GitPtr git();
+ QString selectGitCommand(bool save);
+ bool execWelcomeWizardDialog();
+ ApplicationSettings *appsettings();
+ const ApplicationSettings *appsettings() const;
+ QString selectFileCommand(bool save);
+ QString selectGpgCommand(bool save);
+ bool checkExecutable(const QString &path);
+ void setGitCommand(const QString &path, bool save);
+ void setFileCommand(const QString &path, bool save);
+ void setGpgCommand(const QString &path, bool save);
+ bool isValidWorkingCopy(const GitPtr &g) const;
+ bool isAvatarEnabled() const;
+ void updateCommitTableLater();
+ bool isGitHub() const;
+ const Git::CommitItem *commitItem(int row) const;
+ QIcon committerIcon(int row) const;
+ const QList<BasicMainWindow::Label> *label(int row);
+ QString makeCommitInfoText(int row, QList<Label> *label_list);
+ QStringList remotes() const;
+ int limitLogCount() const;
+ QList<Git::Branch> findBranch(const QString &id);
+ QList<Git::Tag> findTag(const QString &id);
+ void logGitVersion();
+ bool saveAs(const QString &id, const QString &dstpath);
+ QString saveAsTemp(const QString &id);
+ QString newTempFilePath();
+ QString tempfileHeader() const;
+ void deleteTempFiles();
+ QString determinFileType_(const QString &path, bool mime, std::function<void (const QString &, QByteArray *)> callback) const;
+ QString determinFileType(const QString &path, bool mime);
+ QString determinFileType(QByteArray in, bool mime);
+ void execFilePropertyDialog(QListWidgetItem *item);
+ QString getCommitIdFromTag(const QString &tag);
+ bool isValidRemoteURL(const QString &url);
+ bool testRemoteRepositoryValidity(const QString &url);
+ void execSetUserDialog(const Git::User &global_user, const Git::User &repo_user, const QString &reponame);
+ NamedCommitList namedCommitItems(int flags);
+ QString getObjectID(QListWidgetItem *item);
+ void stopPtyProcess();
+ void abortPtyProcess();
+ void jumpToCommit(QString id);
+ int rowFromCommitId(const QString &id);
+ void execFileHistory(const QString &path);
+ void execFileHistory(QListWidgetItem *item);
+ void addWorkingCopyDir(QString dir, QString name, bool open);
+ void addWorkingCopyDir(QString dir, bool open);
+ void setLogEnabled(GitPtr g, bool f);
+ QString findFileID(GitPtr, const QString &commit_id, const QString &file);
+ static QString abbrevCommitID(const Git::CommitItem &commit);
+ static QString makeRepositoryName(const QString &loc);
+ void saveRepositoryBookmark(RepositoryItem item);
+ void setCurrentRepository(const RepositoryItem &repo, bool clear_authentication);
+ void clearAuthentication();
+ TextEditorThemePtr themeForTextEditor();
+ Git::Object cat_file_(GitPtr g, const QString &id);
+ Git::Object cat_file(const QString &id);
+ void execCommitPropertyDialog(QWidget *parent, const Git::CommitItem *commit);
+ QIcon verifiedIcon(char s) const;
+ bool queryCommit(const QString &id, Git::CommitItem *out);
+ void checkout(QWidget *parent, const Git::CommitItem *commit);
+ void checkout();
+ const Git::CommitItem *selectedCommitItem() const;
+ void execCommitExploreWindow(QWidget *parent, const Git::CommitItem *commit);
+ void execCommitViewWindow(const Git::CommitItem *commit);
+ QAction *addMenuActionProperty(QMenu *menu);
+ QPixmap getTransparentPixmap();
+ void updateFilesList(QString id, QList<Git::Diff> *diff_list, QListWidget *listwidget);
+ void addDiffItems(const QList<Git::Diff> *diff_list, const std::function<void (const QString &, QString, int)> &add_item);
+ void onAvatarUpdated();
+ QList<Git::Tag> queryTagList();
+ void execRepositoryPropertyDialog(QString workdir, bool open_repository_menu = false);
+ const RepositoryItem *findRegisteredRepository(QString *workdir) const;
+public slots:
+ void writeLog(const char *ptr, int len);
+ void writeLog(const QString &str);
+ void writeLog(QByteArray ba);
+signals:
+ void signalWriteLog(QByteArray ba);
+ void remoteInfoChanged();
+};
+
+#endif // BASICMAINWINDOW_H
diff --git a/src/BasicRepositoryDialog.cpp b/src/BasicRepositoryDialog.cpp
index 537259d..e91ffce 100644
--- a/src/BasicRepositoryDialog.cpp
+++ b/src/BasicRepositoryDialog.cpp
@@ -1,89 +1,89 @@
#include "BasicRepositoryDialog.h"
-#include "MainWindow.h"
+#include "BasicMainWindow.h"
#include <QTableWidget>
#include <QHeaderView>
struct BasicRepositoryDialog::Private {
- MainWindow *mainwindow = nullptr;
+ BasicMainWindow *mainwindow = nullptr;
GitPtr git;
QList<Git::Remote> remotes;
};
-BasicRepositoryDialog::BasicRepositoryDialog(MainWindow *mainwindow, GitPtr g)
+BasicRepositoryDialog::BasicRepositoryDialog(BasicMainWindow *mainwindow, GitPtr g)
: QDialog(mainwindow)
, m(new Private)
{
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
m->mainwindow = mainwindow;
m->git = g;
}
BasicRepositoryDialog::~BasicRepositoryDialog()
{
delete m;
}
-MainWindow *BasicRepositoryDialog::mainwindow()
+BasicMainWindow *BasicRepositoryDialog::mainwindow()
{
return m->mainwindow;
}
GitPtr BasicRepositoryDialog::git()
{
return m->git;
}
QList<Git::Remote> const *BasicRepositoryDialog::remotes() const
{
return &m->remotes;
}
QString BasicRepositoryDialog::updateRemotesTable(QTableWidget *tablewidget)
{
tablewidget->clear();
m->remotes.clear();
GitPtr g = git();
if (g->isValidWorkingCopy()) {
g->getRemoteURLs(&m->remotes);
}
QString url;
QString alturl;
int rows = m->remotes.size();
tablewidget->setColumnCount(3);
tablewidget->setRowCount(rows);
auto newQTableWidgetItem = [](QString const &text){
auto *item = new QTableWidgetItem;
item->setSizeHint(QSize(20, 20));
item->setText(text);
return item;
};
auto SetHeaderItem = [&](int col, QString const &text){
tablewidget->setHorizontalHeaderItem(col, newQTableWidgetItem(text));
};
SetHeaderItem(0, tr("Name"));
SetHeaderItem(1, tr("Purpose"));
SetHeaderItem(2, tr("URL"));
for (int row = 0; row < rows; row++) {
Git::Remote const &r = m->remotes[row];
if (r.purpose == "push") {
url = r.url;
} else {
alturl = r.url;
}
auto SetItem = [&](int col, QString const &text){
tablewidget->setItem(row, col, newQTableWidgetItem(text));
};
SetItem(0, r.name);
SetItem(1, r.purpose);
SetItem(2, r.url);
}
tablewidget->horizontalHeader()->setStretchLastSection(true);
if (url.isEmpty()) {
url = alturl;
}
return url;
}
diff --git a/src/BasicRepositoryDialog.h b/src/BasicRepositoryDialog.h
index ca01633..214da49 100644
--- a/src/BasicRepositoryDialog.h
+++ b/src/BasicRepositoryDialog.h
@@ -1,26 +1,26 @@
#ifndef BASICREPOSITORYDIALOG_H
#define BASICREPOSITORYDIALOG_H
#include <QDialog>
#include "Git.h"
class QTableWidget;
-class MainWindow;
+class BasicMainWindow;
class BasicRepositoryDialog : public QDialog {
public:
- explicit BasicRepositoryDialog(MainWindow *mainwindow, GitPtr g);
+ explicit BasicRepositoryDialog(BasicMainWindow *mainwindow, GitPtr g);
virtual ~BasicRepositoryDialog();
private:
struct Private;
Private *m;
protected:
- MainWindow *mainwindow();
+ BasicMainWindow *mainwindow();
GitPtr git();
QString updateRemotesTable(QTableWidget *tablewidget);
const QList<Git::Remote> *remotes() const;
};
#endif // BASICREPOSITORYDIALOG_H
diff --git a/src/BigDiffWindow.cpp b/src/BigDiffWindow.cpp
index 7921743..21186ca 100644
--- a/src/BigDiffWindow.cpp
+++ b/src/BigDiffWindow.cpp
@@ -1,67 +1,67 @@
#include <memory>
#include "BigDiffWindow.h"
#include "ui_BigDiffWindow.h"
struct BigDiffWindow::Private {
TextEditorEnginePtr text_editor_engine;
FileDiffWidget::InitParam_ param;
};
BigDiffWindow::BigDiffWindow(QWidget *parent)
: QDialog(parent)
, ui(new Ui::BigDiffWindow)
, m(new Private)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
flags |= Qt::WindowMaximizeButtonHint;
setWindowFlags(flags);
ui->widget_diff->setMaximizeButtonEnabled(false);
connect(ui->widget_diff, &FileDiffWidget::textcodecChanged, [&](){ updateDiffView(); });
}
BigDiffWindow::~BigDiffWindow()
{
delete m;
delete ui;
}
void BigDiffWindow::setTextCodec(QTextCodec *codec)
{
m->text_editor_engine = std::make_shared<TextEditorEngine>();
ui->widget_diff->setTextCodec(codec);
}
void BigDiffWindow::updateDiffView()
{
ui->widget_diff->updateDiffView(m->param.diff, m->param.uncommited);
}
-void BigDiffWindow::init(MainWindow *mw, FileDiffWidget::InitParam_ const &param)
+void BigDiffWindow::init(BasicMainWindow *mw, FileDiffWidget::InitParam_ const &param)
{
ui->widget_diff->bind(mw);
m->param = param;
switch (m->param.view_style) {
case FileDiffWidget::ViewStyle::LeftOnly:
ui->widget_diff->setLeftOnly(m->param.bytes_a, m->param.diff);
break;
case FileDiffWidget::ViewStyle::RightOnly:
ui->widget_diff->setRightOnly(m->param.bytes_b, m->param.diff);
break;
case FileDiffWidget::ViewStyle::SideBySideText:
ui->widget_diff->setSideBySide(m->param.bytes_a, m->param.diff, m->param.uncommited, m->param.workingdir);
break;
case FileDiffWidget::ViewStyle::SideBySideImage:
ui->widget_diff->setSideBySide_(m->param.bytes_a, m->param.bytes_b, m->param.workingdir);
break;
}
}
diff --git a/src/BigDiffWindow.h b/src/BigDiffWindow.h
index 9e89110..b24ab3e 100644
--- a/src/BigDiffWindow.h
+++ b/src/BigDiffWindow.h
@@ -1,29 +1,29 @@
#ifndef BIGDIFFWINDOW_H
#define BIGDIFFWINDOW_H
#include <QDialog>
#include "Git.h"
#include "FileDiffWidget.h"
namespace Ui {
class BigDiffWindow;
}
class BigDiffWindow : public QDialog
{
Q_OBJECT
private:
struct Private;
Private *m;
public:
explicit BigDiffWindow(QWidget *parent = 0);
~BigDiffWindow();
- void init(MainWindow *mw, const FileDiffWidget::InitParam_ &param);
+ void init(BasicMainWindow *mw, const FileDiffWidget::InitParam_ &param);
void setTextCodec(QTextCodec *codec);
private:
Ui::BigDiffWindow *ui;
void updateDiffView();
};
#endif // BIGDIFFWINDOW_H
diff --git a/src/CommitExploreWindow.cpp b/src/CommitExploreWindow.cpp
index c744100..21d9373 100644
--- a/src/CommitExploreWindow.cpp
+++ b/src/CommitExploreWindow.cpp
@@ -1,281 +1,281 @@
#include "CommitExploreWindow.h"
#include "ui_CommitExploreWindow.h"
#include "GitObjectManager.h"
#include "ImageViewWidget.h"
#include "common/misc.h"
#include "MainWindow.h"
#include "main.h"
#include <QFileIconProvider>
#include <QMenu>
#ifdef Q_OS_WIN
#include "win32/win32.h"
#endif
static QTreeWidgetItem *newQTreeWidgetItem()
{
auto *item = new QTreeWidgetItem;
item->setSizeHint(0, QSize(20, 20));
return item;
}
enum {
ItemTypeRole = Qt::UserRole,
ObjectIdRole,
FilePathRole,
};
struct CommitExploreWindow::Private {
- MainWindow *mainwindow;
+ BasicMainWindow *mainwindow;
GitObjectCache *objcache;
Git::CommitItem const *commit;
QString root_tree_id;
GitTreeItemList tree_item_list;
Git::Object content_object;
ObjectContent content;
TextEditorEnginePtr text_editor_engine;
};
-CommitExploreWindow::CommitExploreWindow(QWidget *parent, MainWindow *mainwin, GitObjectCache *objcache, const Git::CommitItem *commit)
+CommitExploreWindow::CommitExploreWindow(QWidget *parent, BasicMainWindow *mainwin, GitObjectCache *objcache, const Git::CommitItem *commit)
: QDialog(parent)
, ui(new Ui::CommitExploreWindow)
, m(new Private)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
flags |= Qt::WindowMaximizeButtonHint;
setWindowFlags(flags);
m->mainwindow = mainwin;
m->objcache = objcache;
m->commit = commit;
m->text_editor_engine = TextEditorEnginePtr(new TextEditorEngine);
ui->widget_fileview->bind(mainwin, nullptr, ui->verticalScrollBar, ui->horizontalScrollBar, mainwin->themeForTextEditor());
ui->widget_fileview->setDiffMode(m->text_editor_engine, ui->verticalScrollBar, ui->horizontalScrollBar);
ui->splitter->setSizes({100, 100, 200});
// set text
ui->lineEdit_commit_id->setText(commit->commit_id);
ui->lineEdit_date->setText(misc::makeDateTimeString(commit->commit_date));
ui->lineEdit_author->setText(commit->author);
{
GitCommit c;
c.parseCommit(objcache, m->commit->commit_id);
m->root_tree_id = c.tree_id;
}
{
GitCommitTree tree(objcache);
tree.parseTree(m->root_tree_id);
}
{
QTreeWidgetItem *rootitem = newQTreeWidgetItem();
rootitem->setText(0, tr("Commit"));
rootitem->setData(0, ItemTypeRole, (int)GitTreeItem::TREE);
rootitem->setData(0, ObjectIdRole, m->root_tree_id);
ui->treeWidget->addTopLevelItem(rootitem);
loadTree(m->root_tree_id);
rootitem->setExpanded(true);
}
}
CommitExploreWindow::~CommitExploreWindow()
{
delete m;
delete ui;
}
-MainWindow *CommitExploreWindow::mainwindow()
+BasicMainWindow *CommitExploreWindow::mainwindow()
{
return m->mainwindow;
}
void CommitExploreWindow::clearContent()
{
m->content = ObjectContent();
}
void CommitExploreWindow::expandTreeItem_(QTreeWidgetItem *item)
{
if (item->childCount() == 1) {
if (item->child(0)->text(0).isEmpty()) {
delete item->takeChild(0);
}
}
if (item->childCount() == 0) {
QFileIconProvider icons;
QString path = item->data(0, FilePathRole).toString();
QString tree_id = item->data(0, ObjectIdRole).toString();
loadTree(tree_id);
for (GitTreeItem const &ti : m->tree_item_list) {
if (ti.type == GitTreeItem::TREE) {
QTreeWidgetItem *child = newQTreeWidgetItem();
child->setIcon(0, icons.icon(QFileIconProvider::Folder));
child->setText(0, ti.name);
child->setData(0, ItemTypeRole, (int)ti.type);
child->setData(0, ObjectIdRole, ti.id);
child->setData(0, FilePathRole, misc::joinWithSlash(path, ti.name));
QTreeWidgetItem *placeholder = newQTreeWidgetItem();
child->addChild(placeholder);
item->addChild(child);
}
}
}
}
void CommitExploreWindow::on_treeWidget_itemExpanded(QTreeWidgetItem *item)
{
expandTreeItem_(item);
}
void CommitExploreWindow::loadTree(QString const &tree_id)
{
GitCommitTree tree(m->objcache);
tree.parseTree(tree_id);
m->tree_item_list = *tree.treelist();
std::sort(m->tree_item_list.begin(), m->tree_item_list.end(), [](GitTreeItem const &left, GitTreeItem const &right){
int l = (left.type == GitTreeItem::TREE) ? 0 : 1;
int r = (right.type == GitTreeItem::TREE) ? 0 : 1;
if (l != r) return l < r;
return left.name.compare(right.name, Qt::CaseInsensitive) < 0;
});
}
void CommitExploreWindow::doTreeItemChanged_(QTreeWidgetItem *current)
{
ui->listWidget->clear();
QString path = current->data(0, FilePathRole).toString();
QString tree_id = current->data(0, ObjectIdRole).toString();
loadTree(tree_id);
QFileIconProvider icons;
for (GitTreeItem const &ti : m->tree_item_list) {
QIcon icon;
if (ti.type == GitTreeItem::TREE) {
icon = icons.icon(QFileIconProvider::Folder);
} else {
#ifdef Q_OS_WIN
{
int i = ti.name.lastIndexOf('.');
if (i > 0) {
QString ext = ti.name.mid(i + 1);
icon = winIconFromExtensionLarge(ext);
}
}
#endif
if (icon.isNull()) {
icon = icons.icon(QFileIconProvider::File);
}
}
auto *p = new QListWidgetItem;
p->setIcon(icon);
p->setText(ti.name);
p->setData(ItemTypeRole, (int)ti.type);
p->setData(ObjectIdRole, ti.id);
p->setData(FilePathRole, misc::joinWithSlash(path, ti.name));
ui->listWidget->addItem(p);
}
}
void CommitExploreWindow::on_treeWidget_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem * /*previous*/)
{
clearContent();
doTreeItemChanged_(current);
}
void CommitExploreWindow::on_listWidget_itemDoubleClicked(QListWidgetItem *item)
{
Q_ASSERT(item);
GitTreeItem::Type type = (GitTreeItem::Type)item->data(ItemTypeRole).toInt();
if (type == GitTreeItem::TREE) {
QString tree_id = item->data(ObjectIdRole).toString();
clearContent();
QTreeWidgetItem *parent = ui->treeWidget->currentItem();
expandTreeItem_(parent);
parent->setExpanded(true);
int n = parent->childCount();
for (int i = 0; i < n; i++) {
QTreeWidgetItem *child = parent->child(i);
if (child->data(0, ItemTypeRole).toInt() == GitTreeItem::TREE) {
QString tid = child->data(0, ObjectIdRole).toString();
if (tid == tree_id) {
child->setExpanded(true);
ui->treeWidget->setCurrentItem(child);
break;
}
}
}
}
}
void CommitExploreWindow::on_listWidget_currentItemChanged(QListWidgetItem *current, QListWidgetItem * /*previous*/)
{
if (!current) return;
GitTreeItem::Type type = (GitTreeItem::Type)current->data(ItemTypeRole).toInt();
if (type == GitTreeItem::BLOB) {
QString id = current->data(ObjectIdRole).toString();
m->content_object = m->objcache->catFile(id);
QString path = current->data(FilePathRole).toString();
clearContent();
QString mimetype = mainwindow()->determinFileType(m->content_object.content, true);
if (misc::isImage(mimetype)) {
ui->widget_fileview->setImage(mimetype, m->content_object.content, id, path);
} else {
ui->widget_fileview->setText(m->content_object.content, mainwindow(), id, path);
}
} else {
clearContent();
}
}
void CommitExploreWindow::on_verticalScrollBar_valueChanged(int)
{
ui->widget_fileview->refrectScrollBar();
}
void CommitExploreWindow::on_horizontalScrollBar_valueChanged(int)
{
ui->widget_fileview->refrectScrollBar();
}
void CommitExploreWindow::on_listWidget_customContextMenuRequested(const QPoint &pos)
{
(void)pos;
QListWidgetItem *current = ui->listWidget->currentItem();
if (!current) return;
GitTreeItem::Type type = (GitTreeItem::Type)current->data(ItemTypeRole).toInt();
if (type == GitTreeItem::BLOB) {
QMenu menu;
QAction *a_history = menu.addAction("History");
QAction *a = menu.exec(QCursor::pos() + QPoint(8, -8));
if (a) {
if (a == a_history) {
QString path = current->data(FilePathRole).toString();
mainwindow()->execFileHistory(path);
return;
}
}
}
}
diff --git a/src/CommitExploreWindow.h b/src/CommitExploreWindow.h
index 5d3d2cf..fd4ea7c 100644
--- a/src/CommitExploreWindow.h
+++ b/src/CommitExploreWindow.h
@@ -1,43 +1,43 @@
#ifndef COMMITEXPLOREWINDOW_H
#define COMMITEXPLOREWINDOW_H
#include <QDialog>
#include "FileDiffWidget.h"
namespace Ui {
class CommitExploreWindow;
}
class QTreeWidgetItem;
class QListWidgetItem;
class GitObjectCache;
class CommitExploreWindow : public QDialog
{
Q_OBJECT
private:
Ui::CommitExploreWindow *ui;
struct Private;
Private *m;
void loadTree(QString const &tree_id);
void doTreeItemChanged_(QTreeWidgetItem *current);
void expandTreeItem_(QTreeWidgetItem *item);
- MainWindow *mainwindow();
+ BasicMainWindow *mainwindow();
public:
- explicit CommitExploreWindow(QWidget *parent, MainWindow *mainwin, GitObjectCache *objcache, Git::CommitItem const *commit);
+ explicit CommitExploreWindow(QWidget *parent, BasicMainWindow *mainwin, GitObjectCache *objcache, Git::CommitItem const *commit);
~CommitExploreWindow();
void clearContent();
private slots:
void on_treeWidget_itemExpanded(QTreeWidgetItem *item);
void on_treeWidget_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous);
void on_listWidget_itemDoubleClicked(QListWidgetItem *item);
void on_listWidget_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous);
void on_verticalScrollBar_valueChanged(int);
void on_horizontalScrollBar_valueChanged(int);
void on_listWidget_customContextMenuRequested(const QPoint &pos);
};
#endif // COMMITEXPLOREWINDOW_H
diff --git a/src/CommitPropertyDialog.cpp b/src/CommitPropertyDialog.cpp
index 017e339..cfe1d71 100644
--- a/src/CommitPropertyDialog.cpp
+++ b/src/CommitPropertyDialog.cpp
@@ -1,168 +1,168 @@
#include "CommitPropertyDialog.h"
-#include "MainWindow.h"
+#include "BasicMainWindow.h"
#include "gpg.h"
#include "ui_CommitPropertyDialog.h"
#include "ApplicationGlobal.h"
#include "AvatarLoader.h"
#include "common/misc.h"
struct CommitPropertyDialog::Private {
- MainWindow *mainwindow;
+ BasicMainWindow *mainwindow;
Git::CommitItem commit;
AvatarLoader avatar_loader;
};
-void CommitPropertyDialog::init(MainWindow *mw)
+void CommitPropertyDialog::init(BasicMainWindow *mw)
{
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
ui->pushButton_jump->setVisible(false);
m->mainwindow = mw;
ui->lineEdit_description->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()->webContext());
connect(&m->avatar_loader, &AvatarLoader::updated, [&](){
UpdateAvatar(false);
});
UpdateAvatar(true);
}
void CommitPropertyDialog::UpdateAvatar(bool request)
{
auto SetAvatar = [&](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);
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);
}
-CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, MainWindow *mw, Git::CommitItem const *commit)
+CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, BasicMainWindow *mw, Git::CommitItem const *commit)
: QDialog(parent)
, ui(new Ui::CommitPropertyDialog)
, m(new Private)
{
ui->setupUi(this);
m->commit = *commit;
init(mw);
}
-CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, MainWindow *mw, QString const &commit_id)
+CommitPropertyDialog::CommitPropertyDialog(QWidget *parent, BasicMainWindow *mw, QString const &commit_id)
: QDialog(parent)
, ui(new Ui::CommitPropertyDialog)
, m(new Private)
{
ui->setupUi(this);
mw->queryCommit(commit_id, &m->commit);
init(mw);
}
CommitPropertyDialog::~CommitPropertyDialog()
{
m->avatar_loader.stop();
delete m;
delete ui;
}
-MainWindow *CommitPropertyDialog::mainwindow()
+BasicMainWindow *CommitPropertyDialog::mainwindow()
{
return m->mainwindow;
}
void CommitPropertyDialog::setAvatar(QIcon 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);
done(QDialog::Rejected);
}
void CommitPropertyDialog::on_pushButton_jump_clicked()
{
mainwindow()->jumpToCommit(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 a78808d..7085d9d 100644
--- a/src/CommitPropertyDialog.h
+++ b/src/CommitPropertyDialog.h
@@ -1,47 +1,46 @@
#ifndef COMMITPROPERTYDIALOG_H
#define COMMITPROPERTYDIALOG_H
#include <QDialog>
#include "Git.h"
class QLabel;
namespace Ui {
class CommitPropertyDialog;
}
-class MainWindow;
+class BasicMainWindow;
-class CommitPropertyDialog : public QDialog
-{
+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, BasicMainWindow *mw, Git::CommitItem const *commit);
+ explicit CommitPropertyDialog(QWidget *parent, BasicMainWindow *mw, QString const &commit_id);
~CommitPropertyDialog();
void showCheckoutButton(bool f);
void showJumpButton(bool f);
private slots:
void on_pushButton_checkout_clicked();
void on_pushButton_jump_clicked();
void on_pushButton_details_clicked();
void on_pushButton_explorer_clicked();
private:
Ui::CommitPropertyDialog *ui;
- void init(MainWindow *mw);
- MainWindow *mainwindow();
+ void init(BasicMainWindow *mw);
+ BasicMainWindow *mainwindow();
void setAvatar(QIcon icon, QLabel *label);
void UpdateAvatar(bool request);
};
#endif // COMMITPROPERTYDIALOG_H
diff --git a/src/CommitViewWindow.cpp b/src/CommitViewWindow.cpp
index 27c2912..bed5d30 100644
--- a/src/CommitViewWindow.cpp
+++ b/src/CommitViewWindow.cpp
@@ -1,71 +1,71 @@
#include "CommitViewWindow.h"
#include "ui_CommitViewWindow.h"
#include <QMenu>
struct CommitViewWindow::Private {
Git::CommitItem const *commit = nullptr;
QList<Git::Diff> diff_list;
};
-CommitViewWindow::CommitViewWindow(MainWindow *parent, const Git::CommitItem *commit)
+CommitViewWindow::CommitViewWindow(BasicMainWindow *parent, const Git::CommitItem *commit)
: QDialog(parent)
, ui(new Ui::CommitViewWindow)
, m(new Private)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
m->commit = commit;
ui->widget_diff->bind(mainwindow());
ui->lineEdit_message->setText(m->commit->message);
ui->lineEdit_id->setText(m->commit->commit_id);
mainwindow()->updateFilesList(m->commit->commit_id, &m->diff_list, ui->listWidget_files);
ui->listWidget_files->setCurrentRow(0);
}
CommitViewWindow::~CommitViewWindow()
{
delete m;
delete ui;
}
-MainWindow *CommitViewWindow::mainwindow()
+BasicMainWindow *CommitViewWindow::mainwindow()
{
- return qobject_cast<MainWindow *>(parent());
+ return qobject_cast<BasicMainWindow *>(parent());
}
void CommitViewWindow::on_listWidget_files_currentRowChanged(int currentRow)
{
if (currentRow >= 0 && currentRow < m->diff_list.size()) {
Git::Diff const &diff = m->diff_list[currentRow];
ui->widget_diff->updateDiffView(diff, false);
}
}
void CommitViewWindow::on_listWidget_files_customContextMenuRequested(const QPoint &pos)
{
GitPtr g = mainwindow()->git();
if (!mainwindow()->isValidWorkingCopy(g)) return;
QMenu menu;
QAction *a_history = menu.addAction(tr("History"));
QAction *a_properties = mainwindow()->addMenuActionProperty(&menu);
QPoint pt = ui->listWidget_files->mapToGlobal(pos) + QPoint(8, -8);
QAction *a = menu.exec(pt);
if (a) {
QListWidgetItem *item = ui->listWidget_files->currentItem();
if (a == a_history) {
mainwindow()->execFileHistory(item);
} else if (a == a_properties) {
mainwindow()->execFilePropertyDialog(item);
}
}
}
diff --git a/src/CommitViewWindow.h b/src/CommitViewWindow.h
index 232eef0..20a8e1c 100644
--- a/src/CommitViewWindow.h
+++ b/src/CommitViewWindow.h
@@ -1,34 +1,34 @@
#ifndef COMMITVIEWWINDOW_H
#define COMMITVIEWWINDOW_H
#include "Git.h"
#include <QDialog>
-class MainWindow;
+class BasicMainWindow;
namespace Ui {
class CommitViewWindow;
}
class CommitViewWindow : public QDialog
{
Q_OBJECT
private:
struct Private;
Private *m;
- MainWindow *mainwindow();
+ BasicMainWindow *mainwindow();
public:
- explicit CommitViewWindow(MainWindow *parent, Git::CommitItem const *commit);
+ explicit CommitViewWindow(BasicMainWindow *parent, Git::CommitItem const *commit);
~CommitViewWindow();
private slots:
void on_listWidget_files_currentRowChanged(int currentRow);
void on_listWidget_files_customContextMenuRequested(const QPoint &pos);
private:
Ui::CommitViewWindow *ui;
};
#endif // COMMITVIEWWINDOW_H
diff --git a/src/EditRemoteDialog.cpp b/src/EditRemoteDialog.cpp
index a8b4266..4632fa2 100644
--- a/src/EditRemoteDialog.cpp
+++ b/src/EditRemoteDialog.cpp
@@ -1,66 +1,66 @@
#include "EditRemoteDialog.h"
#include "ui_EditRemoteDialog.h"
-#include "MainWindow.h"
+#include "BasicMainWindow.h"
-EditRemoteDialog::EditRemoteDialog(MainWindow *parent, Operation op) :
+EditRemoteDialog::EditRemoteDialog(BasicMainWindow *parent, Operation op) :
QDialog(parent),
ui(new Ui::EditRemoteDialog)
{
ui->setupUi(this);
if (op == RemoteSet) {
ui->lineEdit_name->setReadOnly(true);
ui->lineEdit_name->setEnabled(false);
}
}
EditRemoteDialog::~EditRemoteDialog()
{
delete ui;
}
-MainWindow *EditRemoteDialog::mainwindow()
+BasicMainWindow *EditRemoteDialog::mainwindow()
{
- return qobject_cast<MainWindow *>(parent());
+ return qobject_cast<BasicMainWindow *>(parent());
}
void EditRemoteDialog::setName(QString const &s) const
{
ui->lineEdit_name->setText(s);
}
void EditRemoteDialog::setUrl(QString const &s) const
{
ui->lineEdit_url->setText(s);
}
QString EditRemoteDialog::name() const
{
return ui->lineEdit_name->text();
}
QString EditRemoteDialog::url() const
{
return ui->lineEdit_url->text();
}
int EditRemoteDialog::exec()
{
if (ui->lineEdit_name->text().isEmpty()) {
ui->lineEdit_name->setFocus();
} else {
ui->lineEdit_url->setFocus();
}
return QDialog::exec();
}
void EditRemoteDialog::on_pushButton_test_clicked()
{
QString url = ui->lineEdit_url->text();
if (mainwindow()->testRemoteRepositoryValidity(url)) {
ui->pushButton_ok->setFocus();
} else {
ui->lineEdit_url->setFocus();
}
}
diff --git a/src/EditRemoteDialog.h b/src/EditRemoteDialog.h
index 2b2e115..07d8386 100644
--- a/src/EditRemoteDialog.h
+++ b/src/EditRemoteDialog.h
@@ -1,38 +1,37 @@
#ifndef EDITREMOTEDIALOG_H
#define EDITREMOTEDIALOG_H
#include <QDialog>
-class MainWindow;
+class BasicMainWindow;
namespace Ui {
class EditRemoteDialog;
}
-class EditRemoteDialog : public QDialog
-{
+class EditRemoteDialog : public QDialog {
Q_OBJECT
public:
enum Operation {
RemoteAdd,
RemoteSet,
};
public:
- explicit EditRemoteDialog(MainWindow *parent, Operation op);
+ explicit EditRemoteDialog(BasicMainWindow *parent, Operation op);
~EditRemoteDialog();
void setName(QString const &s) const;
void setUrl(QString const &s) const;
QString name() const;
QString url() const;
int exec();
private slots:
void on_pushButton_test_clicked();
private:
Ui::EditRemoteDialog *ui;
- MainWindow *mainwindow();
+ BasicMainWindow *mainwindow();
};
#endif // EDITREMOTEDIALOG_H
diff --git a/src/FileDiffWidget.cpp b/src/FileDiffWidget.cpp
index 8c35bb8..be6705f 100644
--- a/src/FileDiffWidget.cpp
+++ b/src/FileDiffWidget.cpp
@@ -1,744 +1,744 @@
#include <memory>
#include <memory>
#include "FileDiffWidget.h"
#include "ui_FileDiffWidget.h"
#include "BigDiffWindow.h"
#include "GitDiff.h"
#include "common/joinpath.h"
#include "MainWindow.h"
#include "common/misc.h"
#include "ApplicationGlobal.h"
#include "Theme.h"
#include <QBuffer>
#include <QDebug>
#include <QKeyEvent>
#include <QMenu>
#include <QPainter>
#include <QStyle>
#include <QTextCodec>
enum {
DiffIndexRole = Qt::UserRole,
};
struct FileDiffWidget::Private {
- MainWindow *mainwindow = nullptr;
+ BasicMainWindow *mainwindow = nullptr;
InitParam_ init_param_;
Git::CommitItemList commit_item_list;
std::vector<std::string> original_lines;
TextEditorEnginePtr engine_left;
TextEditorEnginePtr engine_right;
TextDiffLineList left_lines;
TextDiffLineList right_lines;
int max_line_length = 0;
int term_cursor_row = 0;
int term_cursor_col = 0;
QTextCodec *text_codec = nullptr;
};
FileDiffWidget::FileDiffWidget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::FileDiffWidget)
, m(new Private)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
ui->widget_diff_slider->init([&](DiffPane pane, int width, int height){
return makeDiffPixmap(pane, width, height);
}, global->theme);
connect(ui->widget_diff_slider, SIGNAL(valueChanged(int)), this, SLOT(scrollTo(int)));
connect(ui->widget_diff_left->texteditor(), SIGNAL(moved(int,int,int,int)), this, SLOT(onMoved(int,int,int,int)));
connect(ui->widget_diff_right->texteditor(), SIGNAL(moved(int,int,int,int)), this, SLOT(onMoved(int,int,int,int)));
setFocusAcceptable(true);
int n = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
ui->toolButton_fullscreen->setFixedSize(n, n);
setMaximizeButtonEnabled(true);
m->engine_left = std::make_shared<TextEditorEngine>();
m->engine_right = std::make_shared<TextEditorEngine>();
ui->widget_diff_left->setDiffMode(m->engine_left, ui->verticalScrollBar, ui->horizontalScrollBar);
ui->widget_diff_right->setDiffMode(m->engine_right, ui->verticalScrollBar, ui->horizontalScrollBar);
setViewType(FileViewType::None);
}
FileDiffWidget::~FileDiffWidget()
{
delete m;
delete ui;
}
void FileDiffWidget::setViewType(FileViewType type)
{
ui->widget_diff_left->setViewType(type);
ui->widget_diff_right->setViewType(type);
}
void FileDiffWidget::setMaximizeButtonEnabled(bool f)
{
ui->toolButton_fullscreen->setVisible(f);
ui->toolButton_fullscreen->setEnabled(f);
}
FileDiffWidget::ViewStyle FileDiffWidget::viewstyle() const
{
return m->init_param_.view_style;
}
-void FileDiffWidget::bind(MainWindow *mw)
+void FileDiffWidget::bind(BasicMainWindow *mw)
{
Q_ASSERT(mw);
m->mainwindow = mw;
ui->widget_diff_left->bind(mw, this, ui->verticalScrollBar, ui->horizontalScrollBar, mw->themeForTextEditor());
ui->widget_diff_right->bind(mw, this, ui->verticalScrollBar, ui->horizontalScrollBar, mw->themeForTextEditor());
connect(ui->verticalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(onVerticalScrollValueChanged(int)));
connect(ui->horizontalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(onHorizontalScrollValueChanged(int)));
}
-MainWindow *FileDiffWidget::mainwindow()
+BasicMainWindow *FileDiffWidget::mainwindow()
{
return m->mainwindow;
}
GitPtr FileDiffWidget::git()
{
if (!mainwindow()) {
qDebug() << "Maybe, you forgot to call FileDiffWidget::bind() ?";
return GitPtr();
}
return mainwindow()->git();
}
Git::Object FileDiffWidget::cat_file(GitPtr /*g*/, QString const &id)
{
return mainwindow()->cat_file(id);
}
int FileDiffWidget::totalTextLines() const
{
return m->engine_left->document.lines.size();
}
void FileDiffWidget::clearDiffView()
{
ui->widget_diff_slider->clear(false);
}
int FileDiffWidget::fileviewHeight() const
{
return ui->widget_diff_left->height();
}
void FileDiffWidget::resetScrollBarValue()
{
ui->verticalScrollBar->setValue(0);
ui->horizontalScrollBar->setValue(0);
}
void FileDiffWidget::scrollToBottom()
{
QScrollBar *sb = ui->verticalScrollBar;
sb->setValue(sb->maximum());
}
void FileDiffWidget::updateSliderCursor()
{
if (viewstyle() == SideBySideText) {
ui->widget_diff_slider->clear(true);
}
}
void FileDiffWidget::updateControls()
{
updateSliderCursor();
}
void FileDiffWidget::makeSideBySideDiffData(Git::Diff const &diff, std::vector<std::string> const &original_lines, TextDiffLineList *left_lines, TextDiffLineList *right_lines)
{
left_lines->clear();
right_lines->clear();
m->original_lines = original_lines;
size_t linenum = original_lines.size();
std::vector<HunkItem> hunks;
int number = 0;
for (auto it = diff.hunks.begin(); it != diff.hunks.end(); it++, number++) {
std::string at = it->at;
if (strncmp(at.c_str(), "@@ -", 4) == 0) {
size_t pos = 0;
size_t len = 0;
char const *p = at.c_str() + 4;
auto ParseNumber = [&](){
size_t v = 0;
while (isdigit(*p & 0xff)) {
v = v * 10 + (*p - '0');
p++;
}
return v;
};
pos = ParseNumber();
if (*p == ',') {
p++;
len = ParseNumber();
} else {
len = 1;
}
if (pos > 0) pos--;
HunkItem item;
item.hunk_number = number;
item.pos = pos;
item.len = len;
for (std::string const &line : it->lines) {
item.lines.push_back(line);
}
hunks.push_back(item);
}
}
std::sort(hunks.begin(), hunks.end(), [](HunkItem const &l, HunkItem const &r){
return l.pos + l.len < r.pos + r.len;
});
size_t h = hunks.size();
while (linenum > 0 || h > 0) {
while (h > 0) {
int hunk_number = h - 1;
HunkItem const &hi = hunks[hunk_number];
if (hi.pos + hi.len < linenum) {
break;
}
std::vector<TextDiffLine> tmp_left;
std::vector<TextDiffLine> tmp_right;
int minus = 0;
int plus = 0;
auto FlushBlank = [&](){
while (minus < plus) {
tmp_left.emplace_back();
minus++;
}
while (minus > plus) {
tmp_right.emplace_back();
plus++;
}
minus = plus = 0;
};
for (auto line : hi.lines) {
int c = line[0] & 0xff;
line = line.substr(1);
if (c == '-') {
minus++;
TextDiffLine l(line, TextDiffLine::Del);
l.hunk_number = hunk_number;
tmp_left.push_back(l);
} else if (c == '+') {
plus++;
TextDiffLine l(line, TextDiffLine::Add);
l.hunk_number = hunk_number;
tmp_right.push_back(l);
} else {
FlushBlank();
TextDiffLine l(line, TextDiffLine::Normal);
l.hunk_number = hunk_number;
tmp_left.push_back(l);
tmp_right.push_back(l);
}
}
FlushBlank();
auto ComplementNewLine = [](std::vector<TextDiffLine> *lines){
for (TextDiffLine &line : *lines) {
int n = line.text.size();
if (n > 0) {
int c = line.text[n - 1] & 0xff;
if (c != '\r' && c != '\n') {
line.text.push_back('\n');
}
}
}
};
ComplementNewLine(&tmp_left);
ComplementNewLine(&tmp_right);
for (auto it = tmp_left.rbegin(); it != tmp_left.rend(); it++) {
TextDiffLine l(*it);
if (m->text_codec) {
if (!l.text.isEmpty()) {
QString s = QString::fromUtf8(l.text.data(), l.text.size());
l.text = m->text_codec->fromUnicode(s);
}
}
left_lines->push_back(l);
}
for (auto it = tmp_right.rbegin(); it != tmp_right.rend(); it++) {
TextDiffLine l(*it);
if (m->text_codec) {
if (!l.text.isEmpty()) {
QString s = QString::fromUtf8(l.text.data(), l.text.size());
l.text = m->text_codec->fromUnicode(s);
}
}
right_lines->push_back(l);
}
linenum = hi.pos;
h--;
}
if (linenum > 0) {
linenum--;
if (linenum < (size_t)original_lines.size()) {
std::string line = original_lines[linenum];
left_lines->push_back(TextDiffLine(line, TextDiffLine::Normal));
right_lines->push_back(TextDiffLine(line, TextDiffLine::Normal));
}
}
}
std::reverse(left_lines->begin(), left_lines->end());
std::reverse(right_lines->begin(), right_lines->end());
}
void FileDiffWidget::setDiffText(Git::Diff const &diff, TextDiffLineList const &left, TextDiffLineList const &right)
{
m->max_line_length = 0;
enum Pane {
Left,
Right,
};
auto SetLineNumber = [&](TextDiffLineList const &lines, Pane pane, TextDiffLineList *out){
out->clear();
int linenum = 1;
for (TextDiffLine const &line : lines) {
TextDiffLine item = line;
switch (item.type) {
case TextDiffLine::Normal:
item.line_number = linenum++;
break;
case TextDiffLine::Add:
if (pane == Pane::Right) {
item.line_number = linenum++;
}
break;
case TextDiffLine::Del:
if (pane == Pane::Left) {
item.line_number = linenum++;
}
break;
default:
item.line_number = linenum; // 行番号は設定するが、インクリメントはしない
break;
}
out->push_back(item);
}
};
SetLineNumber(left, Pane::Left, &m->left_lines);
SetLineNumber(right, Pane::Right, &m->right_lines);
ui->widget_diff_left->setText(&m->left_lines, mainwindow(), diff.blob.a_id, diff.path);
ui->widget_diff_right->setText(&m->right_lines, mainwindow(), diff.blob.b_id, diff.path);
refrectScrollBar();
ui->widget_diff_slider->clear(true);
}
FileViewType FileDiffWidget::setupPreviewWidget()
{
clearDiffView();
QString mimetype_l = mainwindow()->determinFileType(m->init_param_.bytes_a, true);
QString mimetype_r = mainwindow()->determinFileType(m->init_param_.bytes_b, true);
if (misc::isImage(mimetype_l) || misc::isImage(mimetype_r)) { // image
ui->verticalScrollBar->setVisible(false);
ui->horizontalScrollBar->setVisible(false);
ui->widget_diff_slider->setVisible(false);
ui->widget_diff_left->setImage(mimetype_l, m->init_param_.bytes_a, m->init_param_.diff.blob.a_id, m->init_param_.diff.path);
ui->widget_diff_right->setImage(mimetype_r, m->init_param_.bytes_b, m->init_param_.diff.blob.b_id, m->init_param_.diff.path);
return FileViewType::Image;
} else { // text
ui->verticalScrollBar->setVisible(true);
ui->horizontalScrollBar->setVisible(true);
ui->widget_diff_slider->setVisible(true);
setViewType(FileViewType::Text);
return FileViewType::Text;
}
}
void FileDiffWidget::setSingleFile(QByteArray const &ba, QString const &id, QString const &path)
{
m->init_param_ = InitParam_();
m->init_param_.view_style = FileDiffWidget::ViewStyle::SingleFile;
m->init_param_.bytes_a = ba;
m->init_param_.diff.path = path;
m->init_param_.diff.blob.a_id = id;
}
void FileDiffWidget::setOriginalLines_(QByteArray const &ba)
{
m->original_lines.clear();
if (!ba.isEmpty()) {
char const *begin = ba.data();
char const *end = begin + ba.size();
misc::splitLines(begin, end, &m->original_lines, true);
}
}
void FileDiffWidget::setLeftOnly(QByteArray const &ba, Git::Diff const &diff)
{
m->init_param_ = InitParam_();
m->init_param_.view_style = FileDiffWidget::ViewStyle::LeftOnly;
m->init_param_.bytes_a = ba;
m->init_param_.diff = diff;
setOriginalLines_(ba);
if (setupPreviewWidget() == FileViewType::Text) {
TextDiffLineList left_lines;
TextDiffLineList right_lines;
for (std::string const &line : m->original_lines) {
left_lines.push_back(TextDiffLine(line, TextDiffLine::Del));
right_lines.push_back(TextDiffLine());
}
setDiffText(diff, left_lines, right_lines);
}
}
void FileDiffWidget::setRightOnly(QByteArray const &ba, Git::Diff const &diff)
{
m->init_param_ = InitParam_();
m->init_param_.view_style = FileDiffWidget::ViewStyle::RightOnly;
m->init_param_.bytes_b = ba;
m->init_param_.diff = diff;
setOriginalLines_(ba);
if (setupPreviewWidget() == FileViewType::Text) {
TextDiffLineList left_lines;
TextDiffLineList right_lines;
for (std::string const &line : m->original_lines) {
left_lines.push_back(TextDiffLine());
right_lines.push_back(TextDiffLine(line, TextDiffLine::Add));
}
setDiffText(diff, left_lines, right_lines);
}
}
void FileDiffWidget::setSideBySide(QByteArray const &ba, Git::Diff const &diff, bool uncommited, QString const &workingdir)
{
m->init_param_ = InitParam_();
m->init_param_.view_style = FileDiffWidget::ViewStyle::SideBySideText;
m->init_param_.bytes_a = ba;
m->init_param_.diff = diff;
m->init_param_.uncommited = uncommited;
m->init_param_.workingdir = workingdir;
setOriginalLines_(ba);
if (setupPreviewWidget() == FileViewType::Text) {
TextDiffLineList left_lines;
TextDiffLineList right_lines;
makeSideBySideDiffData(diff, m->original_lines, &left_lines, &right_lines);
setDiffText(diff, left_lines, right_lines);
}
}
void FileDiffWidget::setSideBySide_(QByteArray const &ba_a, QByteArray const &ba_b, QString const &workingdir)
{
m->init_param_ = InitParam_();
m->init_param_.view_style = FileDiffWidget::ViewStyle::SideBySideImage;
m->init_param_.bytes_a = ba_a;
m->init_param_.bytes_b = ba_b;
m->init_param_.workingdir = workingdir;
setOriginalLines_(ba_a);
if (setupPreviewWidget() == FileViewType::Text) {
TextDiffLineList left_lines;
TextDiffLineList right_lines;
makeSideBySideDiffData(m->init_param_.diff, m->original_lines, &left_lines, &right_lines);
setDiffText(m->init_param_.diff, left_lines, right_lines);
}
}
QString FileDiffWidget::diffObjects(GitPtr g, QString const &a_id, QString const &b_id)
{
if (m->text_codec) {
Git::Object obj_a = mainwindow()->cat_file_(g, a_id);
Git::Object obj_b = mainwindow()->cat_file_(g, b_id);
if (obj_b.type == Git::Object::Type::UNKNOWN) {
obj_b.type = Git::Object::Type::BLOB;
}
if (obj_a.type == Git::Object::Type::BLOB && obj_b.type == Git::Object::Type::BLOB) {
QString path_a = mainwindow()->newTempFilePath();
QString path_b = mainwindow()->newTempFilePath();
QFile file_a(path_a);
QFile file_b(path_b);
if (file_a.open(QFile::WriteOnly) && file_b.open(QFile::WriteOnly)) {
file_a.write(m->text_codec->toUnicode(obj_a.content).toUtf8());
file_b.write(m->text_codec->toUnicode(obj_b.content).toUtf8());
file_a.close();
file_b.close();
QString s = g->diff_file(path_a, path_b);
file_a.remove();
file_b.remove();
return s;
}
}
}
return GitDiff::diffObjects(g, a_id, b_id);
}
bool FileDiffWidget::isValidID_(QString const &id)
{
if (id.startsWith(PATH_PREFIX)) {
return true;
}
return Git::isValidID(id);
}
void FileDiffWidget::updateDiffView(Git::Diff const &info, bool uncommited)
{
GitPtr g = git();
if (!g) return;
if (!g->isValidWorkingCopy()) return;
if (isValidID_(info.blob.a_id) && isValidID_(info.blob.b_id)) {
Git::Object obj_a = cat_file(g, info.blob.a_id);
Git::Object obj_b = cat_file(g, info.blob.b_id);
QString mime_a = mainwindow()->determinFileType(obj_a.content, true);
QString mime_b = mainwindow()->determinFileType(obj_b.content, true);
if (misc::isImage(mime_a) && misc::isImage(mime_b)) {
setSideBySide_(obj_a.content, obj_b.content, g->workingRepositoryDir());
return;
}
}
{
Git::Diff diff;
if (isValidID_(info.blob.a_id) && isValidID_(info.blob.b_id)) {
std::string text = diffObjects(g, info.blob.a_id, info.blob.b_id).toStdString();
GitDiff::parseDiff(text, &info, &diff);
} else {
diff = info;
}
Git::Object obj;
if (isValidID_(diff.blob.a_id)) { // 左が有効
obj = cat_file(g, diff.blob.a_id);
if (isValidID_(diff.blob.b_id)) { // 右が有効
setSideBySide(obj.content, diff, uncommited, g->workingRepositoryDir()); // 通常のdiff表示
} else {
setLeftOnly(obj.content, diff); // 右が無効の時は、削除されたファイル
}
} else if (isValidID_(diff.blob.b_id)) { // 左が無効で右が有効の時は、追加されたファイル
obj = cat_file(g, diff.blob.b_id);
setRightOnly(obj.content, diff);
}
}
}
void FileDiffWidget::updateDiffView(QString id_left, QString id_right, QString const &path)
{
GitPtr g = git();
if (!g) return;
if (!g->isValidWorkingCopy()) return;
Git::Diff diff;
diff.path = path;
diff.blob.a_id = id_left;
diff.blob.b_id = id_right;
diff.mode = "0";
std::string text = diffObjects(g, diff.blob.a_id, diff.blob.b_id).toStdString();
GitDiff::parseDiff(text, &diff, &diff);
Git::Object obj = cat_file(g, diff.blob.a_id);
setSideBySide(obj.content, diff, false, g->workingRepositoryDir());
ui->widget_diff_slider->clear(false);
resetScrollBarValue();
updateControls();
ui->widget_diff_slider->update();
}
void FileDiffWidget::resizeEvent(QResizeEvent *)
{
refrectScrollBar();
}
void FileDiffWidget::keyPressEvent(QKeyEvent *event)
{
if (event->key() == Qt::Key_Escape) {
event->ignore(); // Escが押されたとき、親ウィジェットに処理させる。（通常、ウィンドウを閉じる、など）
return;
}
if (focusWidget() == ui->widget_diff_left->texteditor()) {
ui->widget_diff_left->write(event);
} else if (focusWidget() == ui->widget_diff_right->texteditor()) {
ui->widget_diff_right->write(event);
}
}
void FileDiffWidget::scrollTo(int value)
{
ui->verticalScrollBar->setValue(value);
}
void FileDiffWidget::onVerticalScrollValueChanged(int)
{
refrectScrollBar();
}
void FileDiffWidget::onHorizontalScrollValueChanged(int)
{
refrectScrollBar();
}
void FileDiffWidget::onDiffWidgetWheelScroll(int lines)
{
while (lines > 0) {
ui->verticalScrollBar->triggerAction(QScrollBar::SliderSingleStepAdd);
lines--;
}
while (lines < 0) {
ui->verticalScrollBar->triggerAction(QScrollBar::SliderSingleStepSub);
lines++;
}
}
void FileDiffWidget::onScrollValueChanged2(int value)
{
ui->verticalScrollBar->setValue(value);
}
void FileDiffWidget::onDiffWidgetResized()
{
updateControls();
}
void FileDiffWidget::on_toolButton_fullscreen_clicked()
{
BigDiffWindow win(mainwindow());
win.setWindowState(Qt::WindowMaximized);
win.init(mainwindow(), m->init_param_);
win.exec();
}
void FileDiffWidget::setFocusAcceptable(bool f)
{
Qt::FocusPolicy focuspolicy = f ? Qt::StrongFocus : Qt::NoFocus;
ui->widget_diff_left->setFocusPolicy(focuspolicy);
ui->widget_diff_right->setFocusPolicy(focuspolicy);
}
void FileDiffWidget::onUpdateSliderBar()
{
int total = m->engine_left->document.lines.size();
int value = ui->verticalScrollBar->value();
int page = ui->verticalScrollBar->pageStep();
ui->widget_diff_slider->setScrollPos(total, value, page);
}
void FileDiffWidget::refrectScrollBar()
{
ui->widget_diff_left->refrectScrollBar();
ui->widget_diff_right->refrectScrollBar();
onUpdateSliderBar();
}
QPixmap FileDiffWidget::makeDiffPixmap(DiffPane pane, int width, int height)
{
auto Do = [&](TextDiffLineList const &lines){
return FileDiffSliderWidget::makeDiffPixmap(width, height, lines, global->theme);
};
if (pane == DiffPane::Left) return Do(m->left_lines);
if (pane == DiffPane::Right) return Do(m->right_lines);
return QPixmap();
}
void FileDiffWidget::onMoved(int cur_row, int cur_col, int scr_row, int scr_col)
{
(void)cur_col;
(void)cur_row;
ui->widget_diff_left->move(-1, -1, scr_row, scr_col, false);
ui->widget_diff_right->move(-1, -1, scr_row, scr_col, false);
refrectScrollBar();
onUpdateSliderBar();
}
void FileDiffWidget::setTextCodec(QTextCodec *codec)
{
m->text_codec = codec;
ui->widget_diff_left->setTextCodec(codec);
ui->widget_diff_right->setTextCodec(codec);
emit textcodecChanged();
}
void FileDiffWidget::setTextCodec(char const *name)
{
QTextCodec *codec = name ? QTextCodec::codecForName(name) : nullptr;
setTextCodec(codec);
}
void FileDiffWidget::on_toolButton_menu_clicked()
{
QMenu menu;
QAction *a_utf8 = menu.addAction("UTF-8");
QAction *a_sjis = menu.addAction("SJIS (CP932)");
QAction *a_eucjp = menu.addAction("EUC-JP");
QAction *a_iso2022jp = menu.addAction("JIS (ISO-2022-JP)");
QAction *a = menu.exec(QCursor::pos() + QPoint(8, -8));
if (a) {
if (a == a_utf8) {
setTextCodec((char const *)nullptr);
return;
}
if (a == a_sjis) {
setTextCodec("Shift_JIS");
return;
}
if (a == a_eucjp) {
setTextCodec("EUC-JP");
return;
}
if (a == a_iso2022jp) {
setTextCodec("ISO-2022-JP");
return;
}
}
}
diff --git a/src/FileDiffWidget.h b/src/FileDiffWidget.h
index affe692..23398fc 100644
--- a/src/FileDiffWidget.h
+++ b/src/FileDiffWidget.h
@@ -1,167 +1,167 @@
#ifndef FILEDIFFWIDGET_H
#define FILEDIFFWIDGET_H
#include "texteditor/AbstractCharacterBasedApplication.h"
#include <QDialog>
#include "Git.h"
#include "MainWindow.h"
#include "FileViewWidget.h"
#include "FileDiffSliderWidget.h"
namespace Ui {
class FileDiffWidget;
}
enum class ViewType {
None,
Left,
Right
};
typedef Document::Line TextDiffLine;
typedef QList<Document::Line> TextDiffLineList;
struct ObjectContent {
QString id;
QString path;
QByteArray bytes;
TextDiffLineList lines;
};
typedef std::shared_ptr<ObjectContent> ObjectContentPtr;
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 = ObjectContentPtr(new ObjectContent());
right = ObjectContentPtr(new 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();
};
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(GitPtr g, QString const &id);
int totalTextLines() const;
void resetScrollBarValue();
void updateSliderCursor();
int fileviewHeight() const;
void setDiffText(const Git::Diff &diff, const TextDiffLineList &left, const TextDiffLineList &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);
QString diffObjects(GitPtr g, QString const &a_id, QString const &b_id);
- MainWindow *mainwindow();
+ BasicMainWindow *mainwindow();
protected:
void resizeEvent(QResizeEvent *);
void keyPressEvent(QKeyEvent *event);
public:
explicit FileDiffWidget(QWidget *parent = 0);
~FileDiffWidget();
- void bind(MainWindow *mw);
+ void bind(BasicMainWindow *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(QString id_left, QString id_right, QString const &path = QString());
void setMaximizeButtonEnabled(bool f);
void setFocusAcceptable(bool f);
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 fe9b804..db97bce 100644
--- a/src/FileHistoryWindow.cpp
+++ b/src/FileHistoryWindow.cpp
@@ -1,252 +1,252 @@
#include "FileHistoryWindow.h"
-#include "MainWindow.h"
+#include "BasicMainWindow.h"
#include "ui_FileHistoryWindow.h"
#include "common/misc.h"
#include "GitDiff.h"
#include "common/joinpath.h"
#include "FileDiffWidget.h"
#include "MyTableWidgetDelegate.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::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;
}
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;
}
-FileHistoryWindow::FileHistoryWindow(MainWindow *parent)
+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, SIGNAL(moveNextItem()), this, SLOT(onMoveNextItem()));
connect(ui->widget_diff_view, SIGNAL(movePreviousItem()), this, SLOT(onMovePreviousItem()));
}
FileHistoryWindow::~FileHistoryWindow()
{
delete m;
delete ui;
}
-MainWindow *FileHistoryWindow::mainwindow()
+BasicMainWindow *FileHistoryWindow::mainwindow()
{
- return qobject_cast<MainWindow *>(parent());
+ return qobject_cast<BasicMainWindow *>(parent());
}
void FileHistoryWindow::prepare(GitPtr 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("Description"),
};
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];
QTableWidgetItem *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){
QTableWidgetItem *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;
+ BasicMainWindow *mainwindow;
GitPtr g;
QString commit_id;
QString file;
public:
QString result;
- FindFileIdThread(MainWindow *mainwindow, GitPtr g, QString const &commit_id, QString const &file)
+ FindFileIdThread(BasicMainWindow *BasicMainWindow, GitPtr g, QString const &commit_id, QString const &file)
{
- this->mainwindow = mainwindow;
+ this->mainwindow = BasicMainWindow;
this->g = g;
this->commit_id = commit_id;
this->file = file;
}
protected:
void run() override
{
result = mainwindow->findFileID(g, 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(m->g, 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);
return;
}
}
}
diff --git a/src/FileHistoryWindow.h b/src/FileHistoryWindow.h
index 5364ac1..2daf4a0 100644
--- a/src/FileHistoryWindow.h
+++ b/src/FileHistoryWindow.h
@@ -1,49 +1,49 @@
#ifndef FILEHISTORYWINDOW_H
#define FILEHISTORYWINDOW_H
#include <QDialog>
#include "Git.h"
-#include "MainWindow.h"
+#include "BasicMainWindow.h"
#include "FileDiffWidget.h"
namespace Ui {
class FileHistoryWindow;
}
-class MainWindow;
+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;
int totalTextLines() const;
int fileviewScrollPos() const;
public:
- explicit FileHistoryWindow(MainWindow *parent);
+ explicit FileHistoryWindow(BasicMainWindow *parent);
~FileHistoryWindow();
void prepare(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();
+ BasicMainWindow *mainwindow();
};
#endif // FILEHISTORYWINDOW_H
diff --git a/src/FilePropertyDialog.cpp b/src/FilePropertyDialog.cpp
index 17b513d..cd9cf07 100644
--- a/src/FilePropertyDialog.cpp
+++ b/src/FilePropertyDialog.cpp
@@ -1,30 +1,30 @@
#include "FilePropertyDialog.h"
#include "MainWindow.h"
#include "ui_FilePropertyDialog.h"
#include "main.h"
FilePropertyDialog::FilePropertyDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::FilePropertyDialog)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
}
FilePropertyDialog::~FilePropertyDialog()
{
delete ui;
}
-void FilePropertyDialog::exec(MainWindow *mw, QString const &path, QString const &id)
+void FilePropertyDialog::exec(BasicMainWindow *mw, QString const &path, QString const &id)
{
mainwindow = mw;
ui->lineEdit_repo->setText(mainwindow->currentRepositoryName());
ui->lineEdit_path->setText(path);
ui->lineEdit_id->setText(id);
QDialog::exec();
}
diff --git a/src/FilePropertyDialog.h b/src/FilePropertyDialog.h
index fa836a4..4f8ed43 100644
--- a/src/FilePropertyDialog.h
+++ b/src/FilePropertyDialog.h
@@ -1,26 +1,25 @@
#ifndef FILEPROPERTYDIALOG_H
#define FILEPROPERTYDIALOG_H
#include <QDialog>
namespace Ui {
class FilePropertyDialog;
}
-class MainWindow;
+class BasicMainWindow;
-class FilePropertyDialog : public QDialog
-{
+class FilePropertyDialog : public QDialog {
Q_OBJECT
private:
- MainWindow *mainwindow;
+ BasicMainWindow *mainwindow;
public:
explicit FilePropertyDialog(QWidget *parent = 0);
~FilePropertyDialog();
- void exec(MainWindow *mw, QString const &path, QString const &id);
+ void exec(BasicMainWindow *mw, QString const &path, QString const &id);
private:
Ui::FilePropertyDialog *ui;
};
#endif // FILEPROPERTYDIALOG_H
diff --git a/src/FileViewWidget.cpp b/src/FileViewWidget.cpp
index 7b22e71..89065b7 100644
--- a/src/FileViewWidget.cpp
+++ b/src/FileViewWidget.cpp
@@ -1,171 +1,171 @@
#include "FileViewWidget.h"
#include <QMenu>
#include <QPainter>
#include <QStackedWidget>
#include <QVBoxLayout>
#include "common/misc.h"
FileViewWidget::FileViewWidget(QWidget *parent)
: QWidget(parent)
{
setObjectName(QStringLiteral("FileViewWidget"));
ui_verticalLayout = new QVBoxLayout(this);
ui_verticalLayout->setSpacing(0);
ui_verticalLayout->setObjectName(QStringLiteral("verticalLayout"));
ui_verticalLayout->setContentsMargins(0, 0, 0, 0);
ui_stackedWidget = new QStackedWidget(this);
ui_stackedWidget->setObjectName(QStringLiteral("stackedWidget"));
ui_page_none = new QWidget();
ui_page_none->setObjectName(QStringLiteral("page_none"));
ui_stackedWidget->addWidget(ui_page_none);
ui_page_text = new X_TextEditorWidget();
ui_page_text->setObjectName(QStringLiteral("page_text"));
ui_page_text->setFocusPolicy(Qt::StrongFocus);
ui_stackedWidget->addWidget(ui_page_text);
ui_page_image = new X_ImageViewWidget();
ui_page_image->setObjectName(QStringLiteral("page_image"));
ui_page_image->setFocusPolicy(Qt::StrongFocus);
ui_stackedWidget->addWidget(ui_page_image);
ui_verticalLayout->addWidget(ui_stackedWidget);
setWindowTitle(QApplication::translate("FileViewWidget", "Form", Q_NULLPTR));
ui_stackedWidget->setCurrentIndex(1);
QMetaObject::connectSlotsByName(this);
ui_page_text->setRenderingMode(TextEditorWidget::DecoratedMode);
ui_page_text->setTheme(TextEditorTheme::Light());
ui_page_text->showHeader(false);
ui_page_text->showFooter(false);
ui_page_text->setAutoLayout(true);
ui_page_text->setReadOnly(true);
ui_page_text->setToggleSelectionAnchorEnabled(false);
ui_page_text->setFocusFrameVisible(true);
ui_stackedWidget->setCurrentWidget(ui_page_none);
}
void FileViewWidget::setTextCodec(QTextCodec *codec)
{
ui_page_text->setTextCodec(codec);
}
-void FileViewWidget::bind(MainWindow *mw, FileDiffWidget *fdw, QScrollBar *vsb, QScrollBar *hsb, TextEditorThemePtr theme)
+void FileViewWidget::bind(BasicMainWindow *mw, FileDiffWidget *fdw, QScrollBar *vsb, QScrollBar *hsb, TextEditorThemePtr theme)
{
ui_page_text->bindScrollBar(vsb, hsb);
ui_page_image->bind(mw, fdw, vsb, hsb);
ui_page_text->setTheme(theme);
}
void FileViewWidget::setViewType(FileViewType type)
{
view_type = type;
switch (view_type) {
case FileViewType::Text:
ui_stackedWidget->setCurrentWidget(ui_page_text);
return;
case FileViewType::Image:
ui_stackedWidget->setCurrentWidget(ui_page_image);
return;
default:
ui_stackedWidget->setCurrentWidget(ui_page_none);
return;
}
}
const TextEditorTheme *FileViewWidget::theme() const
{
return ui_page_text->theme();
}
int FileViewWidget::latin1Width() const
{
return ui_page_text->latin1Width();
}
int FileViewWidget::lineHeight() const
{
return ui_page_text->lineHeight();
}
void FileViewWidget::setDiffMode(TextEditorEnginePtr editor_engine, QScrollBar *vsb, QScrollBar *hsb)
{
ui_page_text->setTextEditorEngine(editor_engine);
return ui_page_text->bindScrollBar(vsb, hsb);
}
void FileViewWidget::refrectScrollBar()
{
switch (view_type) {
case FileViewType::Text:
ui_page_text->refrectScrollBar();
return;
case FileViewType::Image:
ui_page_image->refrectScrollBar();
return;
}
}
void FileViewWidget::move(int cur_row, int cur_col, int scr_row, int scr_col, bool auto_scroll)
{
return ui_page_text->move(cur_row, cur_col, scr_row, scr_col, auto_scroll);
}
void FileViewWidget::setImage(QString mimetype, QByteArray const &ba, QString const &object_id, QString const &path)
{
setViewType(FileViewType::Image);
this->source_id = object_id;
#ifdef APP_GUITAR
ui_page_image->setImage(mimetype, ba, object_id, path);
#else
ui_page_image->setImage(mimetype, ba);
#endif
}
-void FileViewWidget::setText(const QList<Document::Line> *source, MainWindow *mw, QString const &object_id, QString const &object_path)
+void FileViewWidget::setText(const QList<Document::Line> *source, BasicMainWindow *mw, QString const &object_id, QString const &object_path)
{
setViewType(FileViewType::Text);
this->source_id = object_id;
#ifdef APP_GUITAR
ui_page_text->setDocument(source, mw, object_id, object_path);
scrollToTop();
texteditor()->moveCursorOut(); // 現在行を -1 にして、カーソルを非表示にする。
#else
ui_page_text->setDocument(source);
scrollToTop();
#endif
}
-void FileViewWidget::setText(QByteArray const &ba, MainWindow *mw, QString const &object_id, QString const &object_path)
+void FileViewWidget::setText(QByteArray const &ba, BasicMainWindow *mw, QString const &object_id, QString const &object_path)
{
std::vector<std::string> lines;
char const *begin = ba.data();
char const *end = begin + ba.size();
misc::splitLines(begin, end, &lines, true);
QList<Document::Line> source;
source.reserve(lines.size());
int num = 0;
for (std::string const &line : lines) {
Document::Line t(line);
t.line_number = ++num;
source.push_back(t);
}
setText(&source, mw, object_id, object_path);
}
void FileViewWidget::scrollToTop()
{
ui_page_text->scrollToTop();
}
void FileViewWidget::write(QKeyEvent *e)
{
ui_page_text->write(e);
}
TextEditorWidget *FileViewWidget::texteditor()
{
return ui_page_text;
}
diff --git a/src/FileViewWidget.h b/src/FileViewWidget.h
index 2655264..67961d1 100644
--- a/src/FileViewWidget.h
+++ b/src/FileViewWidget.h
@@ -1,77 +1,77 @@
#ifndef FILEVIEWWIDGET_H
#define FILEVIEWWIDGET_H
#include <QWidget>
#include "texteditor/TextEditorWidget.h"
class QScrollBar;
struct PreEditText;
-class MainWindow;
+class BasicMainWindow;
class FileDiffWidget;
class QVBoxLayout;
class QStackedWidget;
enum class FileViewType {
None,
Text,
Image,
};
#ifdef APP_GUITAR
#include "MyTextEditorWidget.h"
#include "MyImageViewWidget.h"
#else
#include "ImageViewWidget.h"
#endif
class FileViewWidget : public QWidget {
private:
#ifdef APP_GUITAR
using X_TextEditorWidget = MyTextEditorWidget;
using X_ImageViewWidget = MyImageViewWidget;
#else
using X_TextEditorWidget = TextEditorWidget;
using X_ImageViewWidget = ImageViewWidget;
#endif
QVBoxLayout *ui_verticalLayout;
QStackedWidget *ui_stackedWidget;
QWidget *ui_page_none;
X_TextEditorWidget *ui_page_text;
X_ImageViewWidget *ui_page_image;
QString source_id;
FileViewType view_type = FileViewType::None;
public:
explicit FileViewWidget(QWidget *parent = 0);
~FileViewWidget()
{
}
void setTextCodec(QTextCodec *codec);
void setViewType(FileViewType type);
void setImage(QString mimetype, const QByteArray &ba, QString const &object_id, const QString &path);
- void setText(const QList<Document::Line> *source, MainWindow *mw, QString const &object_id, const QString &object_path);
- void setText(const QByteArray &ba, MainWindow *mw, const QString &object_id, const QString &object_path);
+ void setText(const QList<Document::Line> *source, BasicMainWindow *mw, QString const &object_id, const QString &object_path);
+ void setText(const QByteArray &ba, BasicMainWindow *mw, const QString &object_id, const QString &object_path);
void setDiffMode(TextEditorEnginePtr editor_engine, QScrollBar *vsb, QScrollBar *hsb);
int latin1Width() const;
int lineHeight() const;
TextEditorTheme const *theme() const;
void scrollToTop();
void write(QKeyEvent *e);
void refrectScrollBar();
void move(int cur_row, int cur_col, int scr_row, int scr_col, bool auto_scroll);
TextEditorWidget *texteditor();
- void bind(MainWindow *mw, FileDiffWidget *fdw, QScrollBar *vsb, QScrollBar *hsb, TextEditorThemePtr theme);
+ void bind(BasicMainWindow *mw, FileDiffWidget *fdw, QScrollBar *vsb, QScrollBar *hsb, TextEditorThemePtr theme);
};
#endif // FILEVIEWWIDGET_H
diff --git a/src/ImageViewWidget.cpp b/src/ImageViewWidget.cpp
index 47ff559..d76c548 100644
--- a/src/ImageViewWidget.cpp
+++ b/src/ImageViewWidget.cpp
@@ -1,376 +1,376 @@
#include <memory>
#include "ImageViewWidget.h"
#include "FileDiffSliderWidget.h"
#include "FileDiffWidget.h"
#include "MainWindow.h"
#include "common/misc.h"
#include "common/joinpath.h"
#include "Photoshop.h"
#include "MemoryReader.h"
#include "charvec.h"
#include <math.h>
#include <functional>
#include <QDebug>
#include <QFileDialog>
#include <QMenu>
#include <QPainter>
#include <QWheelEvent>
#include <QSvgRenderer>
#include <QBuffer>
using SvgRendererPtr = std::shared_ptr<QSvgRenderer>;
struct ImageViewWidget::Private {
- MainWindow *mainwindow = nullptr;
+ BasicMainWindow *mainwindow = nullptr;
FileDiffWidget *filediffwidget = 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(MainWindow *mainwindow, FileDiffWidget *filediffwidget, QScrollBar *vsb, QScrollBar *hsb)
+void ImageViewWidget::bind(BasicMainWindow *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);
}
-MainWindow *ImageViewWidget::mainwindow()
+BasicMainWindow *ImageViewWidget::mainwindow()
{
return m->mainwindow;
}
QBrush ImageViewWidget::getTransparentBackgroundBrush()
{
#ifdef APP_GUITAR
return 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/ImageViewWidget.h b/src/ImageViewWidget.h
index 0e1a8d7..b5756a6 100644
--- a/src/ImageViewWidget.h
+++ b/src/ImageViewWidget.h
@@ -1,57 +1,57 @@
#ifndef IMAGEVIEWWIDGET_H
#define IMAGEVIEWWIDGET_H
#include <QScrollBar>
#include <QWidget>
#include "Git.h"
#include "MainWindow.h"
#include "AbstractCharacterBasedApplication.h"
class FileDiffWidget;
class FileDiffSliderWidget;
class ImageViewWidget : public QWidget {
Q_OBJECT
private:
struct Private;
Private *m;
bool isValidImage() const;
QSize imageSize() const;
QSizeF imageScrollRange() const;
void internalScrollImage(double x, double y);
void scrollImage(double x, double y);
void setImageScale(double scale);
QBrush getTransparentBackgroundBrush();
bool hasFocus() const;
void setScrollBarRange(QScrollBar *h, QScrollBar *v);
void updateScrollBarRange();
protected:
- MainWindow *mainwindow();
+ BasicMainWindow *mainwindow();
void resizeEvent(QResizeEvent *);
void paintEvent(QPaintEvent *);
void mousePressEvent(QMouseEvent *event);
void mouseMoveEvent(QMouseEvent *event);
void wheelEvent(QWheelEvent *);
public:
explicit ImageViewWidget(QWidget *parent = 0);
~ImageViewWidget();
- void bind(MainWindow *m, FileDiffWidget *filediffwidget, QScrollBar *vsb, QScrollBar *hsb);
+ void bind(BasicMainWindow *m, FileDiffWidget *filediffwidget, QScrollBar *vsb, QScrollBar *hsb);
void clear();
void setImage(QString mimetype, QByteArray const &ba);
void setLeftBorderVisible(bool f);
void refrectScrollBar();
static QString formatText(const Document::Line &line2);
signals:
void scrollByWheel(int lines);
};
#endif // IMAGEVIEWWIDGET_H
diff --git a/src/LogTableWidget.cpp b/src/LogTableWidget.cpp
index 1de2feb..0f014b5 100644
--- a/src/LogTableWidget.cpp
+++ b/src/LogTableWidget.cpp
@@ -1,334 +1,334 @@
#include "LogTableWidget.h"
#include <QDebug>
#include <QEvent>
#include <QPainter>
#include <QProxyStyle>
#include <cmath>
#include "MainWindow.h"
#include <QApplication>
#include "MyTableWidgetDelegate.h"
#include "common/misc.h"
struct LogTableWidget::Private {
};
class LogTableWidgetDelegate : public MyTableWidgetDelegate {
private:
MainWindow *mainwindow() const
{
LogTableWidget *w = dynamic_cast<LogTableWidget *>(QStyledItemDelegate::parent());
Q_ASSERT(w);
return w->mainwindow();
}
static QColor labelColor(int kind)
{
switch (kind) {
- case MainWindow::Label::Head: return QColor(255, 192, 224); // blue
- case MainWindow::Label::LocalBranch: return QColor(192, 224, 255); // blue
- case MainWindow::Label::RemoteBranch: return QColor(192, 240, 224); // green
- case MainWindow::Label::Tag: return QColor(255, 224, 192); // orange
+ case BasicMainWindow::Label::Head: return QColor(255, 192, 224); // blue
+ case BasicMainWindow::Label::LocalBranch: return QColor(192, 224, 255); // blue
+ case BasicMainWindow::Label::RemoteBranch: return QColor(192, 240, 224); // green
+ case BasicMainWindow::Label::Tag: return QColor(255, 224, 192); // orange
}
return QColor(224, 224, 224); // gray
}
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, const QModelIndex &index) const
{
if (!opt.widget->isEnabled()) return;
Git::CommitItem const *commit = mainwindow()->commitItem(index.row());
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, const QModelIndex &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 drawDescription(QPainter *painter, const QStyleOptionViewItem &opt, const QModelIndex &index) const
{
int row = index.row();
- QList<MainWindow::Label> const *labels = mainwindow()->label(row);
+ QList<BasicMainWindow::Label> const *labels = mainwindow()->label(row);
if (labels) {
painter->save();
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--;
- MainWindow::Label const &label = labels->at(i);
+ BasicMainWindow::Label const &label = labels->at(i);
QString text = misc::abbrevBranchName(label.text);
int w = fm.size(0, text).width() + space * 2;
int x0 = x1 - w;
QRect r(x0, y0, x1 - x0, y1 - y0);
painter->setPen(Qt::NoPen);
auto DrawRect = [&](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 = labelColor(label.kind);
QColor hilite = hiliteColor(color);
QColor shadow = shadowColor(color);
DrawRect(-1, -1, hilite);
DrawRect(1, 1, shadow);
DrawRect(0, 0, color);
painter->setPen(Qt::black);
painter->setBrush(Qt::NoBrush);
qApp->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, const QModelIndex &index) const override
{
MyTableWidgetDelegate::paint(painter, option, index);
// signatureの描画
if (index.column() == 1) {
drawSignatureIcon(painter, option, index);
}
// avatarの描画
if (index.column() == 3) {
drawAvatar(painter, option, index);
}
// Descriptionの描画
if (index.column() == 4) {
drawDescription(painter, option, index);
}
}
};
LogTableWidget::LogTableWidget(QWidget *parent)
: QTableWidget(parent)
, m(new Private)
{
setItemDelegate(new LogTableWidgetDelegate(this));
}
LogTableWidget::~LogTableWidget()
{
delete m;
}
MainWindow *LogTableWidget::mainwindow()
{
MainWindow *mw = qobject_cast<MainWindow *>(window());
Q_ASSERT(mw);
return mw;
}
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 = mainwindow()->logs();
int indent_span = 16;
auto ItemRect = [&](int row){
QRect r;
QTableWidgetItem *p = item(row, 0);
if (p) {
r = visualItemRect(p);
}
return r;
};
int line_width = 2;
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 /*continued*/){
QColor c = mainwindow()->color(level + 1);
Qt::PenStyle s = Qt::SolidLine;
pr->setPen(QPen(c, 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, false);
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;
SetPen(&pr, item.marker_depth, false);
if (item.resolved) {
// ◯
pr.drawEllipse((int)x, (int)y, int(r * 2), int(r * 2));
} else {
// ▽
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(mainwindow()->color(0));
for (size_t i = 0; i < list->size(); i++) {
double y = DrawMark(i, i);
if (y >= height()) break;
}
}
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index ec3c857..d541813 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -1,4914 +1,4855 @@
#include "AreYouSureYouWantToContinueConnectingDialog.h"
#include "BlameWindow.h"
#include "CommitViewWindow.h"
#include "Git.h"
#include "LineEditDialog.h"
#include "MainWindow.h"
#include "ReflogWindow.h"
#include "SetGlobalUserDialog.h"
#include "EditTagsDialog.h"
#include "WelcomeWizardDialog.h"
#include "ui_MainWindow.h"
#include "EditGitIgnoreDialog.h"
#include "DoYouWantToInitDialog.h"
#include "RemoteWatcher.h"
#include "ApplicationGlobal.h"
#include "AboutDialog.h"
#include "AvatarLoader.h"
#include "CheckoutDialog.h"
#include "CloneDialog.h"
#include "CommitExploreWindow.h"
#include "CommitPropertyDialog.h"
#include "common/joinpath.h"
#include "common/misc.h"
#include "ConfigCredentialHelperDialog.h"
#include "CreateRepositoryDialog.h"
#include "DeleteBranchDialog.h"
#include "DeleteTagsDialog.h"
#include "InputNewTagDialog.h"
#include "FileHistoryWindow.h"
#include "FilePropertyDialog.h"
#include "FileUtil.h"
#include "Git.h"
#include "GitDiff.h"
#include "gunzip.h"
#include "JumpDialog.h"
#include "LocalSocketReader.h"
#include "main.h"
#include "MemoryReader.h"
#include "MergeBranchDialog.h"
#include "MyProcess.h"
#include "MySettings.h"
#include "PushDialog.h"
#include "RepositoryData.h"
#include "RepositoryPropertyDialog.h"
#include "SelectCommandDialog.h"
#include "SetRemoteUrlDialog.h"
#include "SettingsDialog.h"
#include "SetUserDialog.h"
#include "StatusLabel.h"
#include "Terminal.h"
#include "TextEditDialog.h"
#include "CommitDialog.h"
#include "SelectGpgKeyDialog.h"
#include "SetGpgSigningDialog.h"
#include "gpg.h"
#include "webclient.h"
#include "RebaseOntoDialog.h"
#include <QBuffer>
#include <QClipboard>
#include <QDateTime>
#include <QDebug>
#include <QDesktopServices>
#include <QDirIterator>
#include <QDragEnterEvent>
#include <QFileDialog>
#include <QFileIconProvider>
#include <QKeyEvent>
#include <QLocalServer>
#include <QMessageBox>
#include <QMimeData>
#include <QPainter>
#include <QProcess>
#include <QStandardPaths>
#include <QThread>
#include <QTimer>
#include <deque>
#include <set>
#include <stdlib.h>
#ifdef Q_OS_WIN
#include "win32/win32.h"
#else
#include <unistd.h>
#endif
#ifdef Q_OS_MAC
extern "C" char **environ;
#endif
-struct GitHubRepositoryInfo {
- QString owner_account_name;
- QString repository_name;
-};
-
class AsyncExecGitThread_ : public QThread {
private:
GitPtr g;
std::function<void(GitPtr g)> callback;
public:
AsyncExecGitThread_(GitPtr g, std::function<void(GitPtr g)> callback)
: g(g)
, callback(callback)
{
}
protected:
void run() override
{
callback(g);
}
};
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);
}
enum {
IndexRole = Qt::UserRole,
FilePathRole,
DiffIndexRole,
HunkIndexRole,
};
enum {
GroupItem = -1,
};
static inline bool isGroupItem(QTreeWidgetItem *item)
{
if (item) {
int index = item->data(0, IndexRole).toInt();
if (index == GroupItem) {
return true;
}
}
return false;
}
static inline QString getFilePath(QListWidgetItem *item)
{
if (!item) return QString();
return item->data(FilePathRole).toString();
}
static inline int indexOfLog(QListWidgetItem *item)
{
if (!item) return -1;
return item->data(IndexRole).toInt();
}
static inline int indexOfDiff(QListWidgetItem *item)
{
if (!item) return -1;
return item->data(DiffIndexRole).toInt();
}
static inline int getHunkIndex(QListWidgetItem *item)
{
if (!item) return -1;
return item->data(HunkIndexRole).toInt();
}
-enum class PtyCondition {
- None,
- Clone,
- Fetch,
- Pull,
- Push,
-};
-
-enum InteractionMode {
- None,
- Busy,
-};
-
struct MainWindow::Private {
- QString starting_dir;
- Git::Context gcx;
- ApplicationSettings appsettings;
- QList<RepositoryItem> repos;
- RepositoryItem current_repo;
- ServerType server_type = ServerType::Standard;
- GitHubRepositoryInfo github;
- QString current_remote;
- Git::Branch current_branch;
- QString head_id;
- struct Diff {
- QList<Git::Diff> result;
- std::shared_ptr<QThread> thread;
- QList<std::shared_ptr<QThread>> garbage;
- } diff;
- std::map<QString, Git::Diff> diff_cache;
- QStringList added;
- Git::CommitItemList logs;
- std::map<int, QList<Label>> label_map;
- bool force_fetch = false;
- bool uncommited_changes = false;
- int update_files_list_counter = 0;
QTimer interval_10ms_timer;
QTimer remote_watcher_timer;
QImage graph_color;
- QStringList remotes;
- std::map<QString, QList<Git::Branch>> branch_map;
- std::map<QString, QList<Git::Tag>> tag_map;
- QString repository_filter_text;
QPixmap digits;
- QIcon repository_icon;
- QIcon folder_icon;
- QIcon signature_good_icon;
- QIcon signature_dubious_icon;
- QIcon signature_bad_icon;
- unsigned int temp_file_counter = 0;
- GitObjectCache objcache;
- QPixmap transparent_pixmap;
StatusLabel *status_bar_label;
QObject *last_focused_file_list = nullptr;
- WebContext webcx;
- AvatarLoader avatar_loader;
- int update_commit_table_counter = 0;
-
- std::map<QString, GitHubAPI::User> committer_map; // key is email
-
- PtyProcess pty_process;
- PtyCondition pty_condition = PtyCondition::None;
- bool pty_process_ok = false;
-
- RepositoryItem temp_repo;
-
QListWidgetItem *last_selected_file_item = nullptr;
- InteractionMode interaction_mode = InteractionMode::None;
- bool interaction_canceled = false;
-
- bool remote_changed = false;
-
- std::string ssh_passphrase_for;
- std::string ssh_passphrase_secret;
-
- std::string http_uid;
- std::string http_pwd;
-
RemoteWatcher remote_watcher;
};
MainWindow::MainWindow(QWidget *parent)
- : QMainWindow(parent)
+ : BasicMainWindow(parent)
, ui(new Ui::MainWindow)
, m(new Private)
{
ui->setupUi(this);
#ifdef Q_OS_MACX
ui->action_about->setText("About Guitar...");
ui->action_edit_settings->setText("Settings...");
#endif
- m->starting_dir = QDir::current().absolutePath();
+ starting_dir_ = QDir::current().absolutePath();
ui->splitter_v->setSizes({100, 400});
ui->splitter_h->setSizes({200, 100, 200});
m->status_bar_label = new StatusLabel(this);
ui->statusBar->addWidget(m->status_bar_label);
ui->widget_diff_view->bind(this);
qApp->installEventFilter(this);
ui->widget_log->setupForLogWidget(ui->verticalScrollBar_log, ui->horizontalScrollBar_log, themeForTextEditor());
onLogVisibilityChanged();
- SettingsDialog::loadSettings(&m->appsettings);
+ SettingsDialog::loadSettings(&appsettings_);
initNetworking();
showFileList(FilesListType::SingleList);
QFileIconProvider icons;
m->digits.load(":/image/digits.png");
m->graph_color = global->theme->graphColorMap();
- m->repository_icon = QIcon(":/image/repository.png");
- m->folder_icon = icons.icon(QFileIconProvider::Folder);
+ repository_icon_ = QIcon(":/image/repository.png");
+ folder_icon_ = icons.icon(QFileIconProvider::Folder);
- m->signature_good_icon = QIcon(":/image/signature-good.png");
- m->signature_bad_icon = QIcon(":/image/signature-bad.png");
- m->signature_dubious_icon = QIcon(":/image/signature-dubious.png");
+ signature_good_icon_ = QIcon(":/image/signature-good.png");
+ signature_bad_icon_ = QIcon(":/image/signature-bad.png");
+ signature_dubious_icon_ = QIcon(":/image/signature-dubious.png");
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, SIGNAL(signalWriteLog(QByteArray)), this, SLOT(writeLog(QByteArray)));
connect(ui->dockWidget_log, SIGNAL(visibilityChanged(bool)), this, SLOT(onLogVisibilityChanged()));
connect(ui->widget_log, SIGNAL(idle()), this, SLOT(onLogIdle()));
connect(ui->treeWidget_repos, SIGNAL(dropped()), this, SLOT(onRepositoriesTreeDropped()));
- connect((AbstractPtyProcess *)&m->pty_process, SIGNAL(completed()), this, SLOT(onPtyProcessCompleted()));
+ connect((AbstractPtyProcess *)&pty_process_, SIGNAL(completed()), this, SLOT(onPtyProcessCompleted()));
+
+ connect(this, &BasicMainWindow::remoteInfoChanged, [&](){
+ ui->lineEdit_remote->setText(current_remote_);
+ });
// リモート監視
connect(this, SIGNAL(signalCheckRemoteUpdate()), &m->remote_watcher, SLOT(checkRemoteUpdate()));
connect(&m->remote_watcher_timer, SIGNAL(timeout()), &m->remote_watcher, SLOT(checkRemoteUpdate()));
connect(this, &MainWindow::updateButton, [&](){
doUpdateButton();
});
m->remote_watcher.start(this);
setWatchRemoteInterval(appsettings()->watch_remote_changes_every_mins);
//
QString path = getBookmarksFilePath();
- m->repos = RepositoryBookmark::load(path);
+ repos_ = RepositoryBookmark::load(path);
updateRepositoriesList();
- m->webcx.set_keep_alive_enabled(true);
- m->avatar_loader.start(&m->webcx);
- connect(&m->avatar_loader, SIGNAL(updated()), this, SLOT(onAvatarUpdated()));
+ webcx_.set_keep_alive_enabled(true);
+ avatar_loader_.start(&webcx_);
+ connect(&avatar_loader_, SIGNAL(updated()), this, SLOT(onAvatarUpdated()));
- m->update_files_list_counter = 0;
+ update_files_list_counter_ = 0;
connect(ui->widget_diff_view, &FileDiffWidget::textcodecChanged, [&](){ updateDiffView(); });
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());
// ui->splitter->restoreState(settings.value("SplitterState").toByteArray());
settings.endGroup();
if (maximized) {
state |= Qt::WindowMaximized;
setWindowState(state);
}
}
startTimers();
}
MainWindow::~MainWindow()
{
stopPtyProcess();
- m->avatar_loader.stop();
+ avatar_loader_.stop();
m->remote_watcher.quit();
m->remote_watcher.wait();
deleteTempFiles();
delete m;
delete ui;
}
-bool MainWindow::checkGitCommand()
+bool BasicMainWindow::checkGitCommand()
{
while (1) {
- if (misc::isExecutable(m->gcx.git_command)) {
+ if (misc::isExecutable(gcx_.git_command)) {
return true;
}
if (selectGitCommand(true).isEmpty()) {
close();
return false;
}
}
}
-bool MainWindow::checkFileCommand()
+bool BasicMainWindow::checkFileCommand()
{
while (1) {
if (misc::isExecutable(global->file_command)) {
return true;
}
if (selectFileCommand(true).isEmpty()) {
close();
return false;
}
}
}
-ApplicationSettings *MainWindow::appsettings()
+ApplicationSettings *BasicMainWindow::appsettings()
{
- return &m->appsettings;
+ return &appsettings_;
}
-ApplicationSettings const *MainWindow::appsettings() const
+ApplicationSettings const *BasicMainWindow::appsettings() const
{
- return &m->appsettings;
+ return &appsettings_;
}
-bool MainWindow::execWelcomeWizardDialog()
+bool BasicMainWindow::execWelcomeWizardDialog()
{
WelcomeWizardDialog dlg(this);
dlg.set_git_command_path(appsettings()->git_command);
dlg.set_file_command_path(appsettings()->file_command);
dlg.set_default_working_folder(appsettings()->default_working_dir);
if (misc::isExecutable(appsettings()->git_command)) {
- m->gcx.git_command = appsettings()->git_command;
- Git g(m->gcx, QString());
+ gcx_.git_command = appsettings()->git_command;
+ Git g(gcx_, QString());
Git::User user = g.getUser(Git::Source::Global);
dlg.set_user_name(user.name);
dlg.set_user_email(user.email);
}
if (dlg.exec() == QDialog::Accepted) {
- appsettings()->git_command = m->gcx.git_command = dlg.git_command_path();
+ appsettings()->git_command = gcx_.git_command = dlg.git_command_path();
appsettings()->file_command = global->file_command = dlg.file_command_path();
appsettings()->default_working_dir = dlg.default_working_folder();
- SettingsDialog::saveSettings(&m->appsettings);
+ SettingsDialog::saveSettings(&appsettings_);
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;
}
bool MainWindow::shown()
{
while (!misc::isExecutable(appsettings()->git_command) || !misc::isExecutable(appsettings()->file_command)) {
if (!execWelcomeWizardDialog()) {
return false;
}
}
setGitCommand(appsettings()->git_command, false);
setFileCommand(appsettings()->file_command, false);
writeLog(AboutDialog::appVersion() + '\n'); // print application version
logGitVersion(); // print git command version
setGpgCommand(appsettings()->gpg_command, false);
{
MySettings s;
s.beginGroup("Remote");
bool f = s.value("Online", true).toBool();
s.endGroup();
setRemoteOnline(f);
}
setUnknownRepositoryInfo();
checkUser();
return true;
}
-WebContext *MainWindow::webContext()
-{
- return &m->webcx;
-}
+
void MainWindow::startTimers()
{
// interval 10ms
connect(&m->interval_10ms_timer, &QTimer::timeout, [&](){
const int ms = 10;
- if (m->update_commit_table_counter > 0) {
- if (m->update_commit_table_counter > ms) {
- m->update_commit_table_counter -= ms;
+ if (update_commit_table_counter_ > 0) {
+ if (update_commit_table_counter_ > ms) {
+ update_commit_table_counter_ -= ms;
} else {
- m->update_commit_table_counter = 0;
+ update_commit_table_counter_ = 0;
ui->tableWidget_log->viewport()->update();
}
}
- if (m->update_files_list_counter > 0) {
- if (m->update_files_list_counter > ms) {
- m->update_files_list_counter -= ms;
+ if (update_files_list_counter_ > 0) {
+ if (update_files_list_counter_ > ms) {
+ update_files_list_counter_ -= ms;
} else {
- m->update_files_list_counter = 0;
+ update_files_list_counter_ = 0;
updateCurrentFilesList();
}
}
});
m->interval_10ms_timer.setInterval(10);
m->interval_10ms_timer.start();
startTimer(10);
}
-TextEditorThemePtr MainWindow::themeForTextEditor()
+TextEditorThemePtr BasicMainWindow::themeForTextEditor()
{
return global->theme->text_editor_theme;
}
void MainWindow::setCurrentLogRow(int row)
{
if (row >= 0 && row < ui->tableWidget_log->rowCount()) {
ui->tableWidget_log->setCurrentCell(row, 2);
ui->tableWidget_log->setFocus();
updateStatusBarText();
}
}
bool MainWindow::event(QEvent *event)
{
QEvent::Type et = event->type();
if (et == QEvent::WindowActivate) {
checkRemoteUpdate();
} else 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;
}
}
}
return QMainWindow::event(event);
}
bool MainWindow::eventFilter(QObject *watched, 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_Tab) {
if (centralWidget()->isAncestorOf(qApp->focusWidget())) {
QList<QWidget *> tabstops;
tabstops.push_back(ui->treeWidget_repos);
tabstops.push_back(ui->tableWidget_log);
if (ui->stackedWidget->currentWidget() == ui->page_files) {
tabstops.push_back(ui->listWidget_files);
} else if (ui->stackedWidget->currentWidget() == ui->page_uncommited) {
tabstops.push_back(ui->listWidget_unstaged);
tabstops.push_back(ui->toolButton_select_all);
tabstops.push_back(ui->toolButton_stage);
tabstops.push_back(ui->toolButton_unstage);
tabstops.push_back(ui->toolButton_commit);
tabstops.push_back(ui->listWidget_staged);
}
tabstops.push_back(ui->widget_diff_view);
int n = tabstops.size();
if (n > 0) {
QWidget *f = qApp->focusWidget();
int i;
for (i = 0; i < n; i++) {
if (tabstops[i] == f) {
break;
}
}
if (i < n) {
if (e->modifiers() & Qt::ShiftModifier) {
i = (i + n - 1) % n;
} else {
i = (i + 1) % n;
}
tabstops[i]->setFocus();
}
}
return true;
}
}
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 = ui->tableWidget_log->rowCount();
int row = ui->tableWidget_log->currentRow();
if (k == Qt::Key_Up) {
if (row > 0) {
row--;
}
} else if (k == Qt::Key_Down) {
if (row + 1 < rows) {
row++;
}
}
ui->tableWidget_log->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 == ui->tableWidget_log) {
if (k == Qt::Key_Home) {
setCurrentLogRow(0);
return true;
}
if (k == Qt::Key_Escape) {
ui->treeWidget_repos->setFocus();
return true;
}
} else if (watched == ui->listWidget_files || watched == ui->listWidget_unstaged || watched == ui->listWidget_staged) {
if (k == Qt::Key_Escape) {
ui->tableWidget_log->setFocus();
return true;
}
}
} else if (et == QEvent::FocusIn) {
// ファイルリストがフォーカスを得たとき、diffビューを更新する。（コンテキストメニュー対応）
if (watched == ui->listWidget_unstaged) {
m->last_focused_file_list = watched;
updateStatusBarText();
updateUnstagedFileCurrentItem();
return true;
}
if (watched == ui->listWidget_staged) {
m->last_focused_file_list = watched;
updateStatusBarText();
updateStagedFileCurrentItem();
return true;
}
if (watched == ui->listWidget_files) {
m->last_focused_file_list = watched;
}
}
return false;
}
void MainWindow::closeEvent(QCloseEvent *event)
{
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);
}
{
MySettings settings;
settings.beginGroup("MainWindow");
settings.setValue("Maximized", maximized);
settings.setValue("Geometry", saveGeometry());
// settings.setValue("SplitterState", ui->splitter->saveState());
settings.endGroup();
}
}
QMainWindow::closeEvent(event);
}
void MainWindow::setStatusBarText(QString const &text)
{
m->status_bar_label->setText(text);
}
void MainWindow::clearStatusBarText()
{
setStatusBarText(QString());
}
-WebContext *MainWindow::getWebContextPtr()
-{
- return &m->webcx;
-}
-QString MainWindow::getObjectID(QListWidgetItem *item)
+
+QString BasicMainWindow::getObjectID(QListWidgetItem *item)
{
int i = indexOfDiff(item);
- if (i >= 0 && i < m->diff.result.size()) {
- Git::Diff const &diff = m->diff.result[i];
+ if (i >= 0 && i < diff_.result.size()) {
+ Git::Diff const &diff = diff_.result[i];
return diff.blob.a_id;
}
return QString();
}
void MainWindow::onLogVisibilityChanged()
{
ui->action_window_log->setChecked(ui->dockWidget_log->isVisible());
}
-void MainWindow::writeLog(char const *ptr, int len)
+void MainWindow::internalWriteLog(char const *ptr, int len)
{
ui->widget_log->logicalMoveToBottom();
ui->widget_log->write(ptr, len, false);
ui->widget_log->setChanged(false);
- m->interaction_canceled = false;
+ interaction_canceled_ = false;
}
-void MainWindow::writeLog(QString const &str)
+void BasicMainWindow::writeLog(QString const &str)
{
std::string s = str.toStdString();
writeLog(s.c_str(), s.size());
}
-void MainWindow::writeLog(QByteArray ba)
+void BasicMainWindow::writeLog(QByteArray ba)
{
if (!ba.isEmpty()) {
writeLog(ba.data(), ba.size());
}
}
-void MainWindow::emitWriteLog(QByteArray ba)
+void BasicMainWindow::emitWriteLog(QByteArray ba)
{
emit signalWriteLog(ba);
}
-bool MainWindow::git_callback(void *cookie, char const *ptr, int len)
+bool BasicMainWindow::git_callback(void *cookie, char const *ptr, int len)
{
- auto *mw = (MainWindow *)cookie;
+ auto *mw = (BasicMainWindow *)cookie;
mw->emitWriteLog(QByteArray(ptr, len));
return true;
}
-bool MainWindow::saveRepositoryBookmarks() const
+bool BasicMainWindow::saveRepositoryBookmarks() const
{
QString path = getBookmarksFilePath();
- return RepositoryBookmark::save(path, &m->repos);
+ return RepositoryBookmark::save(path, &repos_);
}
-void MainWindow::saveRepositoryBookmark(RepositoryItem item)
+void BasicMainWindow::saveRepositoryBookmark(RepositoryItem item)
{
if (item.local_dir.isEmpty()) return;
if (item.name.isEmpty()) {
item.name = tr("Unnamed");
}
bool done = false;
- for (auto &repo : m->repos) {
+ for (auto &repo : repos_) {
RepositoryItem *p = &repo;
if (item.local_dir == p->local_dir) {
*p = item;
done = true;
break;
}
}
if (!done) {
- m->repos.push_back(item);
+ repos_.push_back(item);
}
saveRepositoryBookmarks();
updateRepositoriesList();
}
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);
}
- m->repos = std::move(newrepos);
+ repos_ = 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 m->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, m->digits, n * w, 0, w, h);
}
QString MainWindow::defaultWorkingDir() const
{
return appsettings()->default_working_dir;
}
QColor MainWindow::color(unsigned int i)
{
unsigned int n = m->graph_color.width();
if (n > 0) {
n--;
if (i > n) i = n;
QRgb const *p = (QRgb const *)m->graph_color.scanLine(0);
return QColor(qRed(p[i]), qGreen(p[i]), qBlue(p[i]));
}
return Qt::black;
}
bool MainWindow::isThereUncommitedChanges() const
{
- return m->uncommited_changes;
+ return uncommited_changes_;
}
Git::CommitItemList const *MainWindow::logs() const
{
- return &m->logs;
+ return &logs_;
}
-QString MainWindow::currentWorkingCopyDir() const
+QString BasicMainWindow::currentWorkingCopyDir() const
{
- QString workdir = m->current_repo.local_dir;
- if (!workdir.isEmpty()) return workdir;
+ QString workdir = current_repo_.local_dir;
+ return workdir.isEmpty() ? QString() : workdir;
+}
- QTreeWidgetItem *treeitem = ui->treeWidget_repos->currentItem();
- if (treeitem) {
- RepositoryItem const *repo = repositoryItem(treeitem);
- if (repo) {
- workdir = repo->local_dir;
- return workdir;
+QString MainWindow::currentWorkingCopyDir() const
+{
+ QString workdir = BasicMainWindow::currentWorkingCopyDir();
+ if (workdir.isEmpty()) {
+ QTreeWidgetItem *treeitem = ui->treeWidget_repos->currentItem();
+ if (treeitem) {
+ RepositoryItem const *repo = repositoryItem(treeitem);
+ if (repo) {
+ workdir = repo->local_dir;
+ return workdir;
+ }
}
}
-
- return QString();
+ return workdir;
}
-QString MainWindow::currentRepositoryName() const
+QString BasicMainWindow::currentRepositoryName() const
{
- return m->current_repo.name;
+ return current_repo_.name;
}
-QString MainWindow::currentRemoteName() const
+QString BasicMainWindow::currentRemoteName() const
{
- return m->current_remote;
+ return current_remote_;
}
-Git::Branch const &MainWindow::currentBranch() const
+Git::Branch const &BasicMainWindow::currentBranch() const
{
- return m->current_branch;
+ return current_branch_;
}
-QString MainWindow::currentBranchName() const
+QString BasicMainWindow::currentBranchName() const
{
return currentBranch().name;
}
-GitPtr MainWindow::git(QString const &dir) const
+GitPtr BasicMainWindow::git(QString const &dir) const
{
- const_cast<MainWindow *>(this)->checkGitCommand();
+ const_cast<BasicMainWindow *>(this)->checkGitCommand();
- GitPtr g = std::shared_ptr<Git>(new Git(m->gcx, dir));
+ GitPtr g = std::shared_ptr<Git>(new Git(gcx_, dir));
g->setLogCallback(git_callback, (void *)this);
return g;
}
-GitPtr MainWindow::git()
+GitPtr BasicMainWindow::git()
{
return git(currentWorkingCopyDir());
}
-bool MainWindow::queryCommit(QString const &id, Git::CommitItem *out)
+bool BasicMainWindow::queryCommit(QString const &id, Git::CommitItem *out)
{
*out = Git::CommitItem();
GitPtr g = git();
return g->queryCommit(id, out);
}
-void MainWindow::setLogEnabled(GitPtr g, bool f)
+void BasicMainWindow::setLogEnabled(GitPtr g, bool f)
{
if (f) {
g->setLogCallback(git_callback, this);
} else {
g->setLogCallback(nullptr, nullptr);
}
}
-QString MainWindow::makeRepositoryName(QString const &loc)
+QString BasicMainWindow::makeRepositoryName(QString const &loc)
{
int i = loc.lastIndexOf('/');
int j = loc.lastIndexOf('\\');
if (i < j) i = j;
if (i >= 0) {
i++;
j = loc.size();
if (loc.endsWith(".git")) {
j -= 4;
}
return loc.mid(i, j - i);
}
return QString();
}
-RepositoryItem const *MainWindow::findRegisteredRepository(QString *workdir) const
+RepositoryItem const *BasicMainWindow::findRegisteredRepository(QString *workdir) const
{
*workdir = QDir(*workdir).absolutePath();
workdir->replace('\\', '/');
if (Git::isValidWorkingCopy(*workdir)) {
- for (RepositoryItem const &item : m->repos) {
+ for (RepositoryItem const &item : repos_) {
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 < m->repos.size()) {
+ if (i >= 0 && i < repos_.size()) {
return i;
}
}
return -1;
}
RepositoryItem const *MainWindow::repositoryItem(QTreeWidgetItem const *item) const
{
int row = repositoryIndex_(item);
- if (row >= 0 && row < m->repos.size()) {
- return &m->repos[row];
+ if (row >= 0 && row < repos_.size()) {
+ return &repos_[row];
}
return nullptr;
}
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, m->folder_icon);
+ item->setIcon(0, folder_icon_);
item->setFlags(item->flags() | Qt::ItemIsEditable);
return item;
}
void MainWindow::updateRepositoriesList()
{
QString path = getBookmarksFilePath();
- m->repos = RepositoryBookmark::load(path);
+ repos_ = RepositoryBookmark::load(path);
- QString filter = m->repository_filter_text;
+ QString filter = repository_filter_text_;
ui->treeWidget_repos->clear();
std::map<QString, QTreeWidgetItem *> parentmap;
- for (int i = 0; i < m->repos.size(); i++) {
- RepositoryItem const &repo = m->repos[i];
+ for (int i = 0; i < repos_.size(); i++) {
+ RepositoryItem const &repo = repos_[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, m->repository_icon);
+ child->setIcon(0, repository_icon_);
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->setCurrentWidget(ui->page_files);
break;
case FilesListType::SideBySide:
ui->stackedWidget->setCurrentWidget(ui->page_uncommited);
break;
}
}
void MainWindow::clearFileList()
{
showFileList(FilesListType::SingleList);
ui->listWidget_unstaged->clear();
ui->listWidget_staged->clear();
ui->listWidget_files->clear();
}
void MainWindow::clearDiffView()
{
ui->widget_diff_view->clearDiffView();
}
void MainWindow::clearRepositoryInfo()
{
- m->head_id = QString();
- m->current_branch = Git::Branch();
- m->server_type = ServerType::Standard;
- m->github = GitHubRepositoryInfo();
+ head_id_ = QString();
+ current_branch_ = Git::Branch();
+ server_type_ = ServerType::Standard;
+ github_ = GitHubRepositoryInfo();
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);
}
-void MainWindow::setUnknownRepositoryInfo()
+void BasicMainWindow::setUnknownRepositoryInfo()
{
setRepositoryInfo("---", "");
- Git g(m->gcx, QString());
+ Git g(gcx_, QString());
Git::User user = g.getUser(Git::Source::Global);
setWindowTitle_(user);
}
bool MainWindow::makeDiff(QString id, QList<Git::Diff> *out)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return false;
Git::FileStatusList list = g->status();
- m->uncommited_changes = !list.empty();
+ uncommited_changes_ = !list.empty();
if (id.isEmpty() && !isThereUncommitedChanges()) {
- id = m->objcache.revParse("HEAD");
+ id = objcache_.revParse("HEAD");
}
bool uncommited = (id.isEmpty() && isThereUncommitedChanges());
- GitDiff dm(&m->objcache);
+ GitDiff dm(&objcache_);
if (uncommited) {
dm.diff_uncommited(out);
} else {
dm.diff(id, out);
}
return true; // success
}
-void MainWindow::addDiffItems(QList<Git::Diff> const *diff_list, std::function<void(QString const &filename, QString header, int idiff)> const &add_item)
+void BasicMainWindow::addDiffItems(QList<Git::Diff> const *diff_list, std::function<void(QString const &filename, QString header, int idiff)> const &add_item)
{
for (int idiff = 0; idiff < diff_list->size(); idiff++) {
Git::Diff const &diff = diff_list->at(idiff);
QString header;
switch (diff.type) {
case Git::Diff::Type::Modify: header = "(chg) "; break;
case Git::Diff::Type::Copy: header = "(cpy) "; break;
case Git::Diff::Type::Rename: header = "(ren) "; break;
case Git::Diff::Type::Create: header = "(add) "; break;
case Git::Diff::Type::Delete: header = "(del) "; break;
case Git::Diff::Type::ChType: header = "(chg) "; break;
case Git::Diff::Type::Unmerged: header = "(unmerged) "; break;
}
add_item(diff.path, header, idiff);
}
}
void MainWindow::updateFilesList(QString id, bool wait)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
if (!wait) return;
clearFileList();
Git::FileStatusList stats = g->status();
- m->uncommited_changes = !stats.empty();
+ uncommited_changes_ = !stats.empty();
FilesListType files_list_type = FilesListType::SingleList;
bool staged = false;
auto AddItem = [&](QString const &filename, QString header, int idiff){
if (header.isEmpty()) {
header = "(??\?) "; // damn trigraph
}
QListWidgetItem *item = new QListWidgetItem(header + filename);
item->setData(FilePathRole, filename);
item->setData(DiffIndexRole, idiff);
item->setData(HunkIndexRole, -1);
switch (files_list_type) {
case FilesListType::SingleList:
ui->listWidget_files->addItem(item);
break;
case FilesListType::SideBySide:
if (staged) {
ui->listWidget_staged->addItem(item);
} else {
ui->listWidget_unstaged->addItem(item);
}
break;
}
};
if (id.isEmpty()) {
bool uncommited = isThereUncommitedChanges();
if (uncommited) {
files_list_type = FilesListType::SideBySide;
}
- if (!makeDiff(uncommited ? QString() : id, &m->diff.result)) {
+ if (!makeDiff(uncommited ? QString() : id, &diff_.result)) {
return;
}
std::map<QString, int> diffmap;
- for (int idiff = 0; idiff < m->diff.result.size(); idiff++) {
- Git::Diff const &diff = m->diff.result[idiff];
+ for (int idiff = 0; idiff < diff_.result.size(); idiff++) {
+ Git::Diff const &diff = diff_.result[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());
if (it != diffmap.end()) {
idiff = it->second;
}
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) ";
}
AddItem(path, header, idiff);
}
} else {
- if (!makeDiff(id, &m->diff.result)) {
+ if (!makeDiff(id, &diff_.result)) {
return;
}
showFileList(files_list_type);
- addDiffItems(&m->diff.result, AddItem);
+ addDiffItems(&diff_.result, AddItem);
}
- for (Git::Diff const &diff : m->diff.result) {
+ for (Git::Diff const &diff : diff_.result) {
QString key = GitDiff::makeKey(diff);
- m->diff_cache[key] = diff;
+ diff_cache_[key] = diff;
}
}
-void MainWindow::updateFilesList(QString id, QList<Git::Diff> *diff_list, QListWidget *listwidget)
+void BasicMainWindow::updateFilesList(QString id, QList<Git::Diff> *diff_list, QListWidget *listwidget)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
listwidget->clear();
auto AddItem = [&](QString const &filename, QString header, int idiff){
if (header.isEmpty()) {
header = "(??\?) "; // damn trigraph
}
QListWidgetItem *item = new QListWidgetItem(header + filename);
item->setData(FilePathRole, filename);
item->setData(DiffIndexRole, idiff);
item->setData(HunkIndexRole, -1);
listwidget->addItem(item);
};
- GitDiff dm(&m->objcache);
+ GitDiff dm(&objcache_);
if (!dm.diff(id, diff_list)) return;
addDiffItems(diff_list, AddItem);
}
void MainWindow::updateFilesList(Git::CommitItem const &commit, bool wait)
{
QString id;
if (Git::isUncommited(commit)) {
// empty id for uncommited changes
} else {
id = commit.commit_id;
}
updateFilesList(id, wait);
}
void MainWindow::updateCurrentFilesList()
{
QTableWidgetItem *item = ui->tableWidget_log->item(selectedLogIndex(), 0);
if (!item) return;
int row = item->data(IndexRole).toInt();
- int logs = (int)m->logs.size();
+ int logs = (int)logs_.size();
if (row < logs) {
- updateFilesList(m->logs[row], true);
+ updateFilesList(logs_[row], true);
}
}
void MainWindow::setRemoteChanged(bool f)
{
- m->remote_changed = f;
+ remote_changed_ = f;
updateButton();
}
void MainWindow::prepareLogTableWidget()
{
QStringList cols = {
tr("Graph"),
tr("Commit"),
tr("Date"),
tr("Author"),
tr("Description"),
};
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);
}
updateCommitGraph(); // コミットグラフを更新
}
-void MainWindow::clearAuthentication()
+void BasicMainWindow::clearAuthentication()
{
- m->ssh_passphrase_for.clear();
- m->ssh_passphrase_secret.clear();
- m->http_uid.clear();
- m->http_pwd.clear();
+ ssh_passphrase_for_.clear();
+ ssh_passphrase_secret_.clear();
+ http_uid_.clear();
+ http_pwd_.clear();
}
-void MainWindow::setCurrentRepository(RepositoryItem const &repo, bool clear_authentication)
+void BasicMainWindow::setCurrentRepository(RepositoryItem const &repo, bool clear_authentication)
{
if (clear_authentication) {
clearAuthentication();
}
- m->current_repo = repo;
+ current_repo_ = repo;
}
-bool MainWindow::isValidWorkingCopy(GitPtr const &g) const
+bool BasicMainWindow::isValidWorkingCopy(GitPtr const &g) const
{
return g && g->isValidWorkingCopy();
}
void MainWindow::queryRemotes(GitPtr g)
{
- m->remotes = g->getRemotes();
- std::sort(m->remotes.begin(), m->remotes.end());
+ remotes_ = g->getRemotes();
+ std::sort(remotes_.begin(), remotes_.end());
}
void MainWindow::queryBranches(GitPtr g)
{
Q_ASSERT(g);
- m->branch_map.clear();
+ branch_map_.clear();
QList<Git::Branch> branches = g->branches();
for (Git::Branch const &b : branches) {
if (b.isCurrent()) {
- m->current_branch = b;
+ current_branch_ = b;
}
- m->branch_map[b.id].append(b);
+ branch_map_[b.id].append(b);
}
}
void MainWindow::updateRemoteInfo()
{
queryRemotes(git());
- m->current_remote = QString();
+ current_remote_ = QString();
{
Git::Branch const &r = currentBranch();
- m->current_remote = r.remote;
+ current_remote_ = r.remote;
}
- if (m->current_remote.isEmpty()) {
- if (m->remotes.size() == 1) {
- m->current_remote = m->remotes[0];
+ if (current_remote_.isEmpty()) {
+ if (remotes_.size() == 1) {
+ current_remote_ = remotes_[0];
}
}
- ui->lineEdit_remote->setText(m->current_remote);
+ emit remoteInfoChanged();
}
-QList<Git::Branch> MainWindow::findBranch(QString const &id)
+QList<Git::Branch> BasicMainWindow::findBranch(QString const &id)
{
- auto it = m->branch_map.find(id);
- if (it != m->branch_map.end()) {
+ auto it = branch_map_.find(id);
+ if (it != branch_map_.end()) {
return it->second;
}
return QList<Git::Branch>();
}
-QString MainWindow::abbrevCommitID(Git::CommitItem const &commit)
+QString BasicMainWindow::abbrevCommitID(Git::CommitItem const &commit)
{
return commit.commit_id.mid(0, 7);
}
-QString MainWindow::findFileID(GitPtr /*g*/, QString const &commit_id, QString const &file)
+QString BasicMainWindow::findFileID(GitPtr /*g*/, QString const &commit_id, QString const &file)
+{
+ return lookupFileID(&objcache_, commit_id, file);
+}
+
+bool BasicMainWindow::isGitHub() const
{
- return lookupFileID(&m->objcache, commit_id, file);
+ return server_type_ == ServerType::GitHub;
}
-bool MainWindow::isGitHub() const
+void BasicMainWindow::writeLog(const char *ptr, int len)
{
- return m->server_type == ServerType::GitHub;
+ internalWriteLog(ptr, len);
}
-void MainWindow::updateCommitTableLater()
+void BasicMainWindow::updateCommitTableLater()
{
- m->update_commit_table_counter = 200;
+ update_commit_table_counter_ = 200;
}
-void MainWindow::onAvatarUpdated()
+void BasicMainWindow::onAvatarUpdated()
{
updateCommitTableLater();
}
-bool MainWindow::isAvatarEnabled() const
+bool BasicMainWindow::isAvatarEnabled() const
{
return appsettings()->get_committer_icon;
}
-Git::CommitItem const *MainWindow::commitItem(int row) const
+Git::CommitItem const *BasicMainWindow::commitItem(int row) const
{
- if (row >= 0 && row < (int)m->logs.size()) {
- return &m->logs[row];
+ if (row >= 0 && row < (int)logs_.size()) {
+ return &logs_[row];
}
return nullptr;
}
-QIcon MainWindow::verifiedIcon(char s) const
+QIcon BasicMainWindow::verifiedIcon(char s) const
{
Git::SignatureGrade g = Git::evaluateSignature(s);
switch (g) {
case Git::SignatureGrade::Good:
- return m->signature_good_icon;
+ return signature_good_icon_;
case Git::SignatureGrade::Bad:
- return m->signature_bad_icon;
+ return signature_bad_icon_;
case Git::SignatureGrade::Unknown:
case Git::SignatureGrade::Dubious:
case Git::SignatureGrade::Missing:
- return m->signature_dubious_icon;
+ return signature_dubious_icon_;
}
return QIcon();
}
-QIcon MainWindow::committerIcon(int row) const
+QIcon BasicMainWindow::committerIcon(int row) const
{
QIcon icon;
if (isAvatarEnabled()) {
- if (row >= 0 && row < (int)m->logs.size()) {
- Git::CommitItem const &commit = m->logs[row];
+ 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 = m->avatar_loader.fetch(email, true); // from gavatar
+ icon = avatar_loader_.fetch(email, true); // from gavatar
}
}
}
return icon;
}
-QList<MainWindow::Label> const *MainWindow::label(int row)
+QList<BasicMainWindow::Label> const *BasicMainWindow::label(int row)
{
- auto it = m->label_map.find(row);
- if (it != m->label_map.end()) {
+ auto it = label_map_.find(row);
+ if (it != label_map_.end()) {
return &it->second;
}
return nullptr;
}
-QString MainWindow::makeCommitInfoText(int row, QList<Label> *label_list)
+QString BasicMainWindow::makeCommitInfoText(int row, QList<Label> *label_list)
{
QString message_ex;
- Git::CommitItem const *commit = &m->logs[row];
+ Git::CommitItem const *commit = &logs_[row];
{ // branch
if (label_list) {
- if (commit->commit_id == m->head_id) {
+ if (commit->commit_id == head_id_) {
Label label(Label::Head);
label.text = "HEAD";
label_list->push_back(label);
}
}
QList<Git::Branch> list = findBranch(commit->commit_id);
for (Git::Branch const &b : list) {
if (b.flags & Git::Branch::HeadDetachedAt) continue;
if (b.flags & Git::Branch::HeadDetachedFrom) continue;
Label label(Label::LocalBranch);
label.text = b.name;
if (!b.remote.isEmpty()) {
label.kind = Label::RemoteBranch;
label.text = "remotes" / b.remote / label.text;
}
if (b.ahead > 0) {
label.text += tr(", %1 ahead").arg(b.ahead);
}
if (b.behind > 0) {
label.text += tr(", %1 behind").arg(b.behind);
}
message_ex += " {" + label.text + '}';
if (label_list) label_list->push_back(label);
}
}
{ // tag
QList<Git::Tag> list = findTag(commit->commit_id);
for (Git::Tag const &t : list) {
Label label(Label::Tag);
label.text = t.name;
message_ex += QString(" {#%1}").arg(label.text);
if (label_list) label_list->push_back(label);
}
}
return message_ex;
}
-void MainWindow::setWindowTitle_(Git::User const &user)
+void BasicMainWindow::setWindowTitle_(Git::User const &user)
{
if (user.name.isEmpty() && user.email.isEmpty()) {
setWindowTitle(qApp->applicationName());
} else {
setWindowTitle(QString("%1 : %2 <%3>")
.arg(qApp->applicationName())
.arg(user.name)
.arg(user.email)
);
}
}
-void MainWindow::updateWindowTitle(GitPtr g)
+void BasicMainWindow::updateWindowTitle(GitPtr g)
{
if (isValidWorkingCopy(g)) {
Git::User user = g->getUser(Git::Source::Default);
setWindowTitle_(user);
} else {
setUnknownRepositoryInfo();
}
}
-QStringList MainWindow::remotes() const
+QStringList BasicMainWindow::remotes() const
{
- return m->remotes;
+ return remotes_;
}
-int MainWindow::limitLogCount() const
+int BasicMainWindow::limitLogCount() const
{
int n = appsettings()->maximum_number_of_commit_item_acquisitions;
return (n >= 1 && n <= 100000) ? n : 10000;
}
-struct TemporaryCommitItem {
- Git::CommitItem const *commit;
- std::vector<TemporaryCommitItem *> children;
-};
+//struct TemporaryCommitItem {
+// Git::CommitItem const *commit;
+// std::vector<TemporaryCommitItem *> children;
+//};
-Git::CommitItemList MainWindow::retrieveCommitLog(GitPtr g)
+Git::CommitItemList BasicMainWindow::retrieveCommitLog(GitPtr g)
{
Git::CommitItemList list = g->log(limitLogCount());
// 親子関係を調べて、順番が狂っていたら、修正する。
std::set<QString> set;
size_t i = 0;
while (i < list.size()) {
size_t newpos = -1;
for (QString const &parent : list[i].parent_ids) {
auto it = set.find(parent);
if (it != 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" << parent;
break;
}
}
}
}
set.insert(set.end(), list[i].commit_id);
if (newpos != (size_t)-1) {
Git::CommitItem t = list[newpos];
list.erase(list.begin() + newpos);
list.insert(list.begin() + i, t);
}
i++;
}
return list;
}
void MainWindow::detectGitServerType(GitPtr g)
{
- m->server_type = ServerType::Standard;
- m->github = GitHubRepositoryInfo();
+ server_type_ = ServerType::Standard;
+ github_ = 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) {
QString user = s.mid(0, i);
QString repo = s.mid(i + 1);
- m->github.owner_account_name = user;
- m->github.repository_name = repo;
+ github_.owner_account_name = user;
+ github_.repository_name = repo;
}
- m->server_type = ServerType::GitHub;
+ server_type_ = ServerType::GitHub;
}
}
bool MainWindow::fetch(GitPtr g)
{
- m->pty_condition = PtyCondition::Fetch;
- m->pty_process_ok = true;
- g->fetch(&m->pty_process);
+ pty_condition_ = PtyCondition::Fetch;
+ pty_process_ok_ = true;
+ g->fetch(&pty_process_);
while (1) {
- if (m->pty_process.wait(1)) break;
+ if (pty_process_.wait(1)) break;
QApplication::processEvents();
}
- return m->pty_process_ok;
+ return pty_process_ok_;
}
void MainWindow::clearLog()
{
- m->logs.clear();
- m->label_map.clear();
- m->uncommited_changes = false;
+ logs_.clear();
+ label_map_.clear();
+ uncommited_changes_ = false;
ui->tableWidget_log->clearContents();
ui->tableWidget_log->scrollToTop();
}
void MainWindow::openRepository_(GitPtr g)
{
- m->objcache.setup(g);
+ objcache_.setup(g);
if (isValidWorkingCopy(g)) {
- bool do_fetch = isRemoteOnline() && (m->force_fetch || appsettings()->automatically_fetch_when_opening_the_repository);
- m->force_fetch = false;
+ bool do_fetch = isRemoteOnline() && (force_fetch_ || appsettings()->automatically_fetch_when_opening_the_repository);
+ force_fetch_ = false;
if (do_fetch) {
if (!fetch(g)) {
return;
}
}
clearLog();
clearRepositoryInfo();
detectGitServerType(g);
updateFilesList(QString(), true);
bool canceled = false;
ui->tableWidget_log->setEnabled(false);
// ログを取得
- m->logs = retrieveCommitLog(g);
+ logs_ = retrieveCommitLog(g);
// ブランチを取得
queryBranches(g);
// タグを取得
- m->tag_map.clear();
+ tag_map_.clear();
QList<Git::Tag> tags = g->tags();
for (Git::Tag const &tag : tags) {
Git::Tag t = tag;
- t.id = m->objcache.getCommitIdFromTag(t.id);
- m->tag_map[t.id].push_back(t);
+ t.id = objcache_.getCommitIdFromTag(t.id);
+ tag_map_[t.id].push_back(t);
}
ui->tableWidget_log->setEnabled(true);
updateCommitTableLater();
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();
clearRepositoryInfo();
}
updateRemoteInfo();
updateWindowTitle(g);
- m->head_id = m->objcache.revParse("HEAD");
+ head_id_ = objcache_.revParse("HEAD");
if (isThereUncommitedChanges()) {
Git::CommitItem item;
- item.parent_ids.push_back(m->current_branch.id);
+ item.parent_ids.push_back(current_branch_.id);
item.message = tr("Uncommited changes");
- m->logs.insert(m->logs.begin(), item);
+ logs_.insert(logs_.begin(), item);
}
prepareLogTableWidget();
- int count = m->logs.size();
+ int count = logs_.size();
ui->tableWidget_log->setRowCount(count);
int selrow = -1;
for (int row = 0; row < count; row++) {
- Git::CommitItem const *commit = &m->logs[row];
+ Git::CommitItem const *commit = &logs_[row];
{
auto *item = new QTableWidgetItem;
item->setData(IndexRole, row);
ui->tableWidget_log->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);
}
ui->tableWidget_log->setItem(row, col, item);
col++;
};
QString commit_id;
QString datetime;
QString author;
QString message;
QString message_ex;
- bool isHEAD = commit->commit_id == m->head_id;
+ bool isHEAD = commit->commit_id == head_id_;
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(row, &m->label_map[row]);
+ message_ex = makeCommitInfoText(row, &label_map_[row]);
}
AddColumn(commit_id, false, QString());
AddColumn(datetime, false, QString());
AddColumn(author, false, QString());
AddColumn(message, bold, message + message_ex);
ui->tableWidget_log->setRowHeight(row, 24);
}
ui->tableWidget_log->resizeColumnsToContents();
ui->tableWidget_log->horizontalHeader()->setStretchLastSection(false);
ui->tableWidget_log->horizontalHeader()->setStretchLastSection(true);
m->last_focused_file_list = nullptr;
ui->tableWidget_log->setFocus();
setCurrentLogRow(0);
QTableWidgetItem *p = ui->tableWidget_log->item(selrow < 0 ? 0 : selrow, 2);
ui->tableWidget_log->setCurrentItem(p);
m->remote_watcher.setCurrent(currentRemoteName(), currentBranchName());
checkRemoteUpdate();
doUpdateButton();
}
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;
}
- if (index >= 0 && index < m->repos.size()) {
- m->repos.erase(m->repos.begin() + index);
+ if (index >= 0 && index < repos_.size()) {
+ repos_.erase(repos_.begin() + index);
saveRepositoryBookmarks();
updateRepositoriesList();
}
}
void MainWindow::removeSelectedRepositoryFromBookmark(bool ask)
{
int i = indexOfRepository(ui->treeWidget_repos->currentItem());
removeRepositoryFromBookmark(i, ask);
}
-void MainWindow::openRepository(bool validate, bool waitcursor)
+void BasicMainWindow::openRepository(bool validate, bool waitcursor)
{
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);
return;
}
GitPtr g = git(); // ポインタの有効性チェックはしない（nullptrでも続行）
openRepository_(g);
}
void MainWindow::reopenRepository(bool log, std::function<void(GitPtr g)> 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::doUpdateButton()
{
setNetworkingCommandsEnabled(isRemoteOnline());
Git::Branch b = currentBranch();
int n;
- ui->toolButton_fetch->setDot(m->remote_changed);
+ ui->toolButton_fetch->setDot(remote_changed_);
n = b.ahead > 0 ? b.ahead : -1;
ui->toolButton_push->setNumber(n);
n = b.behind > 0 ? b.behind : -1;
ui->toolButton_pull->setNumber(n);
}
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);
}
}
}
void MainWindow::openSelectedRepository()
{
QTreeWidgetItem *treeitem = ui->treeWidget_repos->currentItem();
RepositoryItem const *item = repositoryItem(treeitem);
if (item) {
setCurrentRepository(*item, true);
openRepository(true);
}
}
-QString MainWindow::getBookmarksFilePath() const
+QString BasicMainWindow::getBookmarksFilePath() const
{
return global->app_config_dir / "bookmarks.xml";
}
void MainWindow::commit(bool amend)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
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);
if (amend) {
- dlg.setText(m->logs[0].message);
+ dlg.setText(logs_[0].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) {
- ok = g->commit_amend_m(text, sign, &m->pty_process);
+ ok = g->commit_amend_m(text, sign, &pty_process_);
} else {
- ok = g->commit(text, sign, &m->pty_process);
+ ok = g->commit(text, sign, &pty_process_);
}
if (ok) {
- m->force_fetch = true;
+ force_fetch_ = true;
openRepository(true);
} else {
QString err = g->errorMessage().trimmed();
err += "\n*** ";
err += tr("Failed to commit");
err += " ***\n";
writeLog(err);
}
}
break;
}
}
void MainWindow::commit_amend()
{
commit(true);
}
void MainWindow::updateStatusBarText()
{
QString text;
QWidget *w = qApp->focusWidget();
if (w == ui->treeWidget_repos) {
QTreeWidgetItem *ite = ui->treeWidget_repos->currentItem();
RepositoryItem const *item = repositoryItem(ite);
if (item) {
text = QString("%1 : %2")
.arg(item->name)
.arg(misc::normalizePathSeparator(item->local_dir))
;
}
} else if (w == ui->tableWidget_log) {
QTableWidgetItem *item = ui->tableWidget_log->item(selectedLogIndex(), 0);
if (item) {
int row = item->data(IndexRole).toInt();
- if (row < (int)m->logs.size()) {
- Git::CommitItem const &commit = m->logs[row];
+ 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(row, nullptr))
;
}
}
}
}
setStatusBarText(text);
}
-void MainWindow::execRepositoryPropertyDialog(QString workdir, bool open_repository_menu)
+void BasicMainWindow::execRepositoryPropertyDialog(QString workdir, bool open_repository_menu)
{
if (workdir.isEmpty()) {
workdir = currentWorkingCopyDir();
}
QString name;
RepositoryItem const *repo = findRegisteredRepository(&workdir);
if (repo) {
name = repo->name;
} else {
QMessageBox::warning(this, tr("Repository Property"), tr("Not a valid git repository") + "\n\n" + workdir);
return;
}
if (name.isEmpty()) {
name = makeRepositoryName(workdir);
}
GitPtr g = git(workdir);
RepositoryPropertyDialog dlg(this, g, *repo, open_repository_menu);
dlg.exec();
if (dlg.isRemoteChanged()) {
- updateRemoteInfo();
+ emit remoteInfoChanged();
}
}
void MainWindow::on_action_commit_triggered()
{
commit();
}
void MainWindow::on_action_fetch_triggered()
{
if (!isRemoteOnline()) return;
reopenRepository(true, [&](GitPtr g){
fetch(g);
});
}
void MainWindow::on_action_push_triggered()
{
if (!isRemoteOnline()) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
if (g->getRemotes().isEmpty()) {
QMessageBox::warning(this, qApp->applicationName(), tr("No remote repository is registered."));
execRepositoryPropertyDialog(QString(), true);
return;
}
int exitcode = 0;
QString errormsg;
reopenRepository(true, [&](GitPtr g){
- g->push(false, &m->pty_process);
+ g->push(false, &pty_process_);
while (1) {
- if (m->pty_process.wait(1)) break;
+ if (pty_process_.wait(1)) break;
QApplication::processEvents();
}
- exitcode = m->pty_process.getExitCode();
- errormsg = m->pty_process.getMessage();
+ exitcode = pty_process_.getExitCode();
+ errormsg = pty_process_.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;
}
}
}
void MainWindow::on_action_pull_triggered()
{
if (!isRemoteOnline()) return;
reopenRepository(true, [&](GitPtr g){
- m->pty_condition = PtyCondition::Pull;
- m->pty_process_ok = true;
- g->pull(&m->pty_process);
+ pty_condition_ = PtyCondition::Pull;
+ pty_process_ok_ = true;
+ g->pull(&pty_process_);
while (1) {
- if (m->pty_process.wait(1)) break;
+ if (pty_process_.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_treeWidget_repos_currentItemChanged(QTreeWidgetItem * /*current*/, QTreeWidgetItem * /*previous*/)
{
updateStatusBarText();
}
void MainWindow::on_treeWidget_repos_itemDoubleClicked(QTreeWidgetItem * /*item*/, int /*column*/)
{
openSelectedRepository();
}
-void MainWindow::execCommitPropertyDialog(QWidget *parent, Git::CommitItem const *commit)
+void BasicMainWindow::execCommitPropertyDialog(QWidget *parent, Git::CommitItem const *commit)
{
CommitPropertyDialog dlg(parent, this, commit);
dlg.exec();
}
-QAction *MainWindow::addMenuActionProperty(QMenu *menu)
+QAction *BasicMainWindow::addMenuActionProperty(QMenu *menu)
{
return menu->addAction(tr("&Property"));
}
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
QAction *a_open_folder = menu.addAction(tr("Open &folder"));
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->local_dir);
return;
}
}
}
}
-void MainWindow::execCommitExploreWindow(QWidget *parent, Git::CommitItem const *commit)
+void BasicMainWindow::execCommitExploreWindow(QWidget *parent, Git::CommitItem const *commit)
{
- CommitExploreWindow win(parent, this, &m->objcache, commit);
+ CommitExploreWindow win(parent, this, &objcache_, commit);
win.exec();
}
void MainWindow::on_tableWidget_log_customContextMenuRequested(const QPoint &pos)
{
Git::CommitItem const *commit = selectedCommitItem();
if (commit) {
bool is_valid_commit_id = Git::isValidID(commit->commit_id);
int row = selectedLogIndex();
QMenu menu;
QAction *a_copy_id_7_letters = menu.addAction(tr("Copy commit id (7 letters)"));
QAction *a_copy_id_complete = menu.addAction(tr("Copy commit id (completely)"));
menu.addSeparator();
- QAction *a_checkout = is_valid_commit_id ? menu.addAction(tr("Checkout/Branch...")) : nullptr;
+ QAction *a_checkout = menu.addAction(tr("Checkout/Branch..."));
menu.addSeparator();
QAction *a_edit_comment = nullptr;
if (row == 0 && currentBranch().ahead > 0) {
a_edit_comment = menu.addAction(tr("Edit comment..."));
}
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;
QAction *a_reset_head = nullptr;
#if 0 // 下手に使うと危険なので、とりあえず無効にしておく
- if (is_valid_commit_id && commit->commit_id == m->head_id) {
+ if (is_valid_commit_id && commit->commit_id == head_id_) {
a_reset_head = menu.addAction(tr("Reset HEAD"));
}
#endif
menu.addSeparator();
QAction *a_delbranch = is_valid_commit_id ? menu.addAction(tr("Delete branch...")) : nullptr;
QAction *a_delrembranch = remoteBranches(commit->commit_id).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(ui->tableWidget_log->viewport()->mapToGlobal(pos) + QPoint(8, -8));
if (a) {
if (a == a_copy_id_7_letters) {
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);
return;
}
if (a == a_edit_comment) {
commit_amend();
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) {
mergeBranch(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();
return;
}
if (a == a_explore) {
execCommitExploreWindow(this, commit);
return;
}
if (a == a_reset_head) {
reopenRepository(false, [](GitPtr g){
g->reset_head1();
});
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 = ui->listWidget_files->mapToGlobal(pos) + QPoint(8, -8);
QAction *a = menu.exec(pt);
if (a) {
QListWidgetItem *item = ui->listWidget_files->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 = ui->listWidget_unstaged->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 = ui->listWidget_unstaged->mapToGlobal(pos) + QPoint(8, -8);
QAction *a = menu.exec(pt);
if (a) {
QListWidgetItem *item = ui->listWidget_unstaged->currentItem();
if (a == a_stage) {
for_each_selected_files([&](QString const &path){
g->stage(path);
});
updateCurrentFilesList();
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();
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();
}
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 = ui->listWidget_staged->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 = ui->listWidget_staged->mapToGlobal(pos) + QPoint(8, -8);
QAction *a = menu.exec(pt);
if (a) {
QListWidgetItem *item = ui->listWidget_unstaged->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);
}
}
}
}
}
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;
}
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::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);
}
}
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 (m->last_focused_file_list == ui->listWidget_files) return selectedFiles_(ui->listWidget_files);
if (m->last_focused_file_list == ui->listWidget_staged) return selectedFiles_(ui->listWidget_staged);
if (m->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&)> fn)
{
for (QString path : selectedFiles()) {
fn(path);
}
}
-void MainWindow::execFileHistory(QString const &path)
+void BasicMainWindow::execFileHistory(QString const &path)
{
if (path.isEmpty()) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
FileHistoryWindow dlg(this);
dlg.prepare(g, path);
dlg.exec();
}
-void MainWindow::execFileHistory(QListWidgetItem *item)
+void BasicMainWindow::execFileHistory(QListWidgetItem *item)
{
if (item) {
QString path = getFilePath(item);
if (!path.isEmpty()) {
execFileHistory(path);
}
}
}
-void MainWindow::addWorkingCopyDir(QString dir, QString name, bool open)
+void BasicMainWindow::addWorkingCopyDir(QString dir, QString name, bool open)
{
if (dir.endsWith(".git")) {
int i = dir.size();
if (i > 4) {
ushort c = dir.utf16()[i - 5];
if (c == '/' || c == '\\') {
dir = dir.mid(0, i - 5);
}
}
}
if (!Git::isValidWorkingCopy(dir)) {
qDebug() << "Invalid working dir: " + 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);
}
}
+void BasicMainWindow::addWorkingCopyDir(QString dir, bool open)
+{
+ addWorkingCopyDir(dir, QString(), open);
+}
+
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*/)
{
clearFileList();
QTableWidgetItem *item = ui->tableWidget_log->item(selectedLogIndex(), 0);
if (!item) return;
int row = item->data(IndexRole).toInt();
- if (row < (int)m->logs.size()) {
+ if (row < (int)logs_.size()) {
updateStatusBarText();
- m->update_files_list_counter = 200;
+ update_files_list_counter_ = 200;
}
}
void MainWindow::on_toolButton_stage_clicked()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->stage(selectedFiles());
updateCurrentFilesList();
}
void MainWindow::on_toolButton_unstage_clicked()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->unstage(selectedFiles());
updateCurrentFilesList();
}
void MainWindow::on_toolButton_select_all_clicked()
{
if (ui->listWidget_unstaged->count() > 0) {
ui->listWidget_unstaged->setFocus();
ui->listWidget_unstaged->selectAll();
} else if (ui->listWidget_staged->count() > 0) {
ui->listWidget_staged->setFocus();
ui->listWidget_staged->selectAll();
}
}
void MainWindow::on_toolButton_commit_clicked()
{
ui->action_commit->trigger();
}
bool MainWindow::editFile(QString const &path, QString const &title)
{
return TextEditDialog::editFile(this, path, title);
}
struct Task {
int index = 0;
int parent = 0;
Task() = default;
Task(int index, int parent)
: index(index)
, parent(parent)
{
}
};
struct Element {
int depth = 0;
std::vector<int> indexes;
};
void MainWindow::updateCommitGraph()
{
- const size_t LogCount = m->logs.size();
+ const size_t LogCount = logs_.size();
// 樹形図情報を構築する
if (LogCount > 0) {
- auto LogItem = [&](size_t i)->Git::CommitItem &{ return m->logs[i]; };
+ auto LogItem = [&](size_t i)->Git::CommitItem &{ return logs_[i]; };
enum { // 有向グラフを構築するあいだ CommitItem::marker_depth をフラグとして使用する
UNKNOWN = 0,
KNOWN = 1,
};
- for (Git::CommitItem &item : m->logs) {
+ for (Git::CommitItem &item : logs_) {
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 : m->logs) {
+ for (Git::CommitItem &item : logs_) {
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 (const auto & e : elements) {
auto ColorNumber = [&](){ return e.depth; };
size_t count = e.indexes.size();
for (size_t j = 0; j + 1 < count; j++) {
int curr = e.indexes[j];
int next = e.indexes[j + 1];
TreeLine line(next, e.depth);
line.color_number = ColorNumber();
line.bend_early = (j + 2 < count || !LogItem(next).resolved);
if (j + 2 == count) {
if (count > 2 || !LogItem(curr).has_child) { // 直結ではない、または、子がない
line.depth = LogItem(next).marker_depth; // 合流する先のアイテムの深さと同じにする
}
}
LogItem(curr).parent_lines.push_back(line); // 線を追加
}
}
} else {
if (LogCount == 1) { // コミットが一つだけ
LogItem(0).marker_depth = 0;
}
}
}
}
-QList<Git::Tag> MainWindow::findTag(QString const &id)
+QList<Git::Tag> BasicMainWindow::findTag(QString const &id)
{
- auto it = m->tag_map.find(id);
- if (it != m->tag_map.end()) {
+ auto it = tag_map_.find(id);
+ if (it != tag_map_.end()) {
return it->second;
}
return QList<Git::Tag>();
}
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();
}
}
int MainWindow::selectedLogIndex() const
{
int i = ui->tableWidget_log->currentRow();
- if (i >= 0 && i < (int)m->logs.size()) {
+ if (i >= 0 && i < (int)logs_.size()) {
return i;
}
return -1;
}
-Git::CommitItem const *MainWindow::selectedCommitItem() const
+Git::CommitItem const *BasicMainWindow::selectedCommitItem() const
{
int i = selectedLogIndex();
return commitItem(i);
}
-Git::Object MainWindow::cat_file_(GitPtr g, QString const &id)
+Git::Object BasicMainWindow::cat_file_(GitPtr 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 m->objcache.catFile(id);;
+ return objcache_.catFile(id);;
}
}
return Git::Object();
}
-Git::Object MainWindow::cat_file(QString const &id)
+Git::Object BasicMainWindow::cat_file(QString const &id)
{
return cat_file_(git(), id);
}
void MainWindow::updateDiffView(QListWidgetItem *item)
{
clearDiffView();
m->last_selected_file_item = item;
if (!item) return;
int idiff = indexOfDiff(item);
- if (idiff >= 0 && idiff < m->diff.result.size()) {
- Git::Diff const &diff = m->diff.result[idiff];
+ if (idiff >= 0 && idiff < diff_.result.size()) {
+ Git::Diff const &diff = diff_.result[idiff];
QString key = GitDiff::makeKey(diff);
- auto it = m->diff_cache.find(key);
- if (it != m->diff_cache.end()) {
+ auto it = diff_cache_.find(key);
+ if (it != diff_cache_.end()) {
int row = ui->tableWidget_log->currentRow();
- bool uncommited = (row >= 0 && row < (int)m->logs.size() && Git::isUncommited(m->logs[row]));
+ bool uncommited = (row >= 0 && row < (int)logs_.size() && Git::isUncommited(logs_[row]));
ui->widget_diff_view->updateDiffView(it->second, uncommited);
}
}
}
void MainWindow::updateDiffView()
{
updateDiffView(m->last_selected_file_item);
}
void MainWindow::updateUnstagedFileCurrentItem()
{
updateDiffView(ui->listWidget_unstaged->currentItem());
}
void MainWindow::updateStagedFileCurrentItem()
{
updateDiffView(ui->listWidget_staged->currentItem());
}
void MainWindow::on_listWidget_unstaged_currentRowChanged(int /*currentRow*/)
{
updateUnstagedFileCurrentItem();
}
void MainWindow::on_listWidget_staged_currentRowChanged(int /*currentRow*/)
{
updateStagedFileCurrentItem();
}
void MainWindow::on_listWidget_files_currentRowChanged(int /*currentRow*/)
{
updateDiffView(ui->listWidget_files->currentItem());
}
-void MainWindow::logGitVersion()
+void BasicMainWindow::logGitVersion()
{
GitPtr g = git();
QString s = g->version();
if (!s.isEmpty()) {
s += '\n';
writeLog(s);
}
}
-bool MainWindow::checkExecutable(QString const &path)
+bool BasicMainWindow::checkExecutable(QString const &path)
{
if (QFileInfo(path).isExecutable()) {
return true;
}
QString text = "The specified program '%1' is not executable.\n";
text = text.arg(path);
writeLog(text);
return false;
}
-void MainWindow::internalSetCommand(QString const &path, bool save, QString const &name, QString *out)
+void BasicMainWindow::internalSetCommand(QString const &path, bool save, QString const &name, QString *out)
{
if (!path.isEmpty() && checkExecutable(path)) {
if (save) {
MySettings s;
s.beginGroup("Global");
s.setValue(name, path);
s.endGroup();
}
*out = path;
} else {
*out = QString();
}
}
-void MainWindow::setGitCommand(QString const &path, bool save)
+void BasicMainWindow::setGitCommand(QString const &path, bool save)
{
- internalSetCommand(path, save, "GitCommand", &m->gcx.git_command);
+ internalSetCommand(path, save, "GitCommand", &gcx_.git_command);
}
-void MainWindow::setFileCommand(QString const &path, bool save)
+void BasicMainWindow::setFileCommand(QString const &path, bool save)
{
internalSetCommand(path, save, "FileCommand", &global->file_command);
}
-void MainWindow::setGpgCommand(QString const &path, bool save)
+void BasicMainWindow::setGpgCommand(QString const &path, bool save)
{
internalSetCommand(path, save, "GpgCommand", &global->gpg_command);
if (!global->gpg_command.isEmpty()) {
GitPtr g = git();
g->configGpgProgram(global->gpg_command, true);
}
}
void MainWindow::setWatchRemoteInterval(int mins)
{
if (mins > 0) {
m->remote_watcher_timer.start(mins * 60000);
} else {
m->remote_watcher_timer.stop();
}
}
#ifdef Q_OS_WIN
QString getWin32HttpProxy();
#endif
-void MainWindow::initNetworking()
+void BasicMainWindow::initNetworking()
{
std::string http_proxy;
std::string https_proxy;
if (appsettings()->proxy_type == "auto") {
#ifdef Q_OS_WIN
http_proxy = misc::makeProxyServerURL(getWin32HttpProxy().toStdString());
#else
auto getienv = [](std::string const &name)->char const *{
char **p = environ;
while (*p) {
if (strncasecmp(*p, name.c_str(), name.size()) == 0) {
char const *e = *p + name.size();
if (*e == '=') {
return e + 1;
}
}
p++;
}
return nullptr;
};
char const *p;
p = getienv("http_proxy");
if (p) {
http_proxy = misc::makeProxyServerURL(std::string(p));
}
p = getienv("https_proxy");
if (p) {
https_proxy = misc::makeProxyServerURL(std::string(p));
}
#endif
} else if (appsettings()->proxy_type == "manual") {
http_proxy = appsettings()->proxy_server.toStdString();
}
- m->webcx.set_http_proxy(http_proxy);
- m->webcx.set_https_proxy(https_proxy);
+ webcx_.set_http_proxy(http_proxy);
+ webcx_.set_https_proxy(https_proxy);
}
-QStringList MainWindow::whichCommand_(QString const &cmdfile1, QString const &cmdfile2)
+QStringList BasicMainWindow::whichCommand_(QString const &cmdfile1, QString const &cmdfile2)
{
QStringList list;
if (!cmdfile1.isEmpty()){
std::vector<std::string> vec;
FileUtil::which(cmdfile1.toStdString(), &vec);
for (std::string const &s : vec) {
list.push_back(QString::fromStdString(s));
}
}
if (!cmdfile2.isEmpty()){
std::vector<std::string> vec;
FileUtil::which(cmdfile2.toStdString(), &vec);
for (std::string const &s : vec) {
list.push_back(QString::fromStdString(s));
}
}
return list;
}
-QString MainWindow::selectCommand_(QString const &cmdname, QStringList const &cmdfiles, QStringList const &list, QString path, std::function<void(QString const &)> callback)
+QString BasicMainWindow::selectCommand_(QString const &cmdname, QStringList const &cmdfiles, QStringList const &list, QString path, std::function<void(QString 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 path, std::function<void(QString const &)> callback)
+QString BasicMainWindow::selectCommand_(QString const &cmdname, QString const &cmdfile, QStringList const &list, QString path, std::function<void(QString const &)> callback)
{
QStringList cmdfiles;
cmdfiles.push_back(cmdfile);
return selectCommand_(cmdname, cmdfiles, list, path, callback);
}
#ifdef Q_OS_WIN
#define GIT_COMMAND "git.exe"
#define FILE_COMMAND "file.exe"
#define GPG_COMMAND "gpg.exe"
#define GPG2_COMMAND "gpg2.exe"
#else
#define GIT_COMMAND "git"
#define FILE_COMMAND "file"
#define GPG_COMMAND "gpg"
#define GPG2_COMMAND "gpg2"
#endif
-QString MainWindow::selectGitCommand(bool save)
+QString BasicMainWindow::selectGitCommand(bool save)
{
char const *exe = GIT_COMMAND;
- QString path = m->gcx.git_command;
+ QString path = gcx_.git_command;
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)
+QString BasicMainWindow::selectFileCommand(bool save)
{
char const *exe = FILE_COMMAND;
QString path = global->file_command;
auto fn = [&](QString const &path){
setFileCommand(path, save);
};
QStringList list = whichCommand_(exe);
#ifdef Q_OS_WIN
QString dir = misc::getApplicationDir();
QString path1 = dir / FILE_COMMAND;
QString path2;
int i = dir.lastIndexOf('/');
int j = dir.lastIndexOf('\\');
if (i < j) i = j;
if (i > 0) {
path2 = dir.mid(0, i) / FILE_COMMAND;
}
path1 = misc::normalizePathSeparator(path1);
path2 = misc::normalizePathSeparator(path2);
if (misc::isExecutable(path1)) list.push_back(path1);
if (misc::isExecutable(path2)) list.push_back(path2);
#endif
return selectCommand_("File", exe, list, path, fn);
}
-QString MainWindow::selectGpgCommand(bool save)
+QString BasicMainWindow::selectGpgCommand(bool save)
{
QString path = global->gpg_command;
auto fn = [&](QString const &path){
setGpgCommand(path, save);
};
QStringList list = whichCommand_(GPG_COMMAND, GPG2_COMMAND);
QStringList cmdlist;
cmdlist.push_back(GPG_COMMAND);
cmdlist.push_back(GPG2_COMMAND);
return selectCommand_("GPG", cmdlist, list, path, fn);
}
-void MainWindow::checkUser()
+void BasicMainWindow::checkUser()
{
- Git g(m->gcx, QString());
+ Git g(gcx_, QString());
while (1) {
Git::User user = g.getUser(Git::Source::Global);
if (!user.name.isEmpty() && !user.email.isEmpty()) {
return; // ok
}
if (!execSetGlobalUserDialog()) {
return;
}
}
}
void MainWindow::dragEnterEvent(QDragEnterEvent *event)
{
if (QApplication::modalWindow()) return;
if (event->mimeData()->hasUrls()) {
event->acceptProposedAction();
event->accept();
}
}
void MainWindow::timerEvent(QTimerEvent *)
{
- bool running = m->pty_process.isRunning();
+ bool running = pty_process_.isRunning();
if (ui->toolButton_stop_process->isEnabled() != running) {
ui->toolButton_stop_process->setEnabled(running);
ui->action_stop_process->setEnabled(running);
setNetworkingCommandsEnabled(!running);
}
if (!running) {
- m->interaction_mode = InteractionMode::None;
+ interaction_mode_ = InteractionMode::None;
}
while (1) {
char tmp[1024];
- int len = m->pty_process.readOutput(tmp, sizeof(tmp));
+ int len = pty_process_.readOutput(tmp, sizeof(tmp));
if (len < 1) break;
writeLog(tmp, len);
}
}
void MainWindow::keyPressEvent(QKeyEvent *event)
{
if (qApp->focusWidget() == ui->widget_log) {
int c = event->key();
auto write_char = [&](char c){
- if (m->pty_process.isRunning()) {
- m->pty_process.writeInput(&c, 1);
+ if (pty_process_.isRunning()) {
+ pty_process_.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);
}
}
}
-bool MainWindow::saveByteArrayAs(QByteArray const &ba, QString const &dstpath)
+bool BasicMainWindow::saveByteArrayAs(QByteArray const &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)
+bool BasicMainWindow::saveFileAs(QString const &srcpath, QString const &dstpath)
{
QFile f(srcpath);
if (f.open(QFile::ReadOnly)) {
QByteArray ba = f.readAll();
if (saveByteArrayAs(ba, dstpath)) {
return true;
}
} else {
QString msg = "Failed to open the file '%1' for read";
msg = msg.arg(srcpath);
qDebug() << msg;
}
return false;
}
-bool MainWindow::saveBlobAs(QString const &id, QString const &dstpath)
+bool BasicMainWindow::saveBlobAs(QString const &id, QString const &dstpath)
{
Git::Object obj = cat_file(id);
if (!obj.content.isEmpty()) {
if (saveByteArrayAs(obj.content, dstpath)) {
return true;
}
} else {
QString msg = "Failed to get the content of the object '%1'";
msg = msg.arg(id);
qDebug() << msg;
}
return false;
}
-bool MainWindow::saveAs(QString const &id, QString const &dstpath)
+bool BasicMainWindow::saveAs(QString const &id, QString const &dstpath)
{
if (id.startsWith(PATH_PREFIX)) {
return saveFileAs(id.mid(1), dstpath);
} else {
return saveBlobAs(id, dstpath);
}
}
-QString MainWindow::saveAsTemp(QString const &id)
+QString BasicMainWindow::saveAsTemp(QString const &id)
{
QString path = newTempFilePath();
saveAs(id, path);
return path;
}
void MainWindow::on_action_edit_settings_triggered()
{
SettingsDialog dlg(this);
if (dlg.exec() == QDialog::Accepted) {
ApplicationSettings const &newsettings = dlg.settings();
- m->appsettings = newsettings;
+ appsettings_ = newsettings;
setGitCommand(appsettings()->git_command, false);
setFileCommand(appsettings()->file_command, false);
setGpgCommand(appsettings()->gpg_command, false);
setWatchRemoteInterval(appsettings()->watch_remote_changes_every_mins);
}
}
void MainWindow::clone()
{
if (!isRemoteOnline()) return;
QString url;
QString dir = defaultWorkingDir();
while (1) {
CloneDialog dlg(this, url, dir);
if (dlg.exec() != QDialog::Accepted) {
return;
}
url = dlg.url();
dir = dlg.dir();
if (dlg.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;
}
// クローン先ディレクトリを求める
Git::CloneData clone_data = Git::preclone(url, dir);
// クローン先ディレクトリの存在チェック
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);
}
- m->temp_repo.local_dir = dir;
- m->temp_repo.local_dir.replace('\\', '/');
- m->temp_repo.name = makeRepositoryName(dir);
+ temp_repo_.local_dir = dir;
+ temp_repo_.local_dir.replace('\\', '/');
+ temp_repo_.name = makeRepositoryName(dir);
GitPtr g = git(QString());
- m->pty_condition = PtyCondition::Clone;
- m->pty_process_ok = true;
- g->clone(clone_data, &m->pty_process);
+ pty_condition_ = PtyCondition::Clone;
+ pty_process_ok_ = true;
+ g->clone(clone_data, &pty_process_);
} else if (dlg.action() == CloneDialog::Action::AddExisting) {
addWorkingCopyDir(dir, true);
}
return; // done
}
}
void MainWindow::onCloneCompleted(bool success)
{
if (success) {
- saveRepositoryBookmark(m->temp_repo);
- setCurrentRepository(m->temp_repo, false);
+ saveRepositoryBookmark(temp_repo_);
+ setCurrentRepository(temp_repo_, false);
openRepository(true);
}
}
void MainWindow::onPtyProcessCompleted()
{
- switch (m->pty_condition) {
+ switch (pty_condition_) {
case PtyCondition::Clone:
- onCloneCompleted(m->pty_process_ok);
+ onCloneCompleted(pty_process_ok_);
break;
}
- m->pty_condition = PtyCondition::None;
+ pty_condition_ = 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(m->repository_filter_text + c);
+ ui->lineEdit_filter->setText(repository_filter_text_ + c);
}
void MainWindow::backspaceRepoFilter()
{
- QString s = m->repository_filter_text;
+ QString s = repository_filter_text_;
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)
{
- m->repository_filter_text = text;
+ repository_filter_text_ = text;
updateRepositoriesList();
}
void MainWindow::on_toolButton_erase_filter_clicked()
{
clearRepoFilter();
ui->lineEdit_filter->setFocus();
}
void MainWindow::deleteTags(QStringList const &tagnames)
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
int row = ui->tableWidget_log->currentRow();
if (!tagnames.isEmpty()) {
reopenRepository(false, [&](GitPtr g){
for (QString const &name : tagnames) {
g->delete_tag(name, true);
}
});
}
ui->tableWidget_log->selectRow(row);
}
void MainWindow::deleteTags(const Git::CommitItem &commit)
{
- auto it = m->tag_map.find(commit.commit_id);
- if (it != m->tag_map.end()) {
+ auto it = tag_map_.find(commit.commit_id);
+ if (it != tag_map_.end()) {
QStringList names;
QList<Git::Tag> const &tags = it->second;
for (Git::Tag const &tag : tags) {
names.push_back(tag.name);
}
deleteTags(names);
}
}
void MainWindow::revertCommit()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
Git::CommitItem const *commit = selectedCommitItem();
if (commit) {
g->revert(commit->commit_id);
openRepository(false);
}
}
bool MainWindow::addTag(QString const &name)
{
if (name.isEmpty()) return false;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return false;
QString commit_id;
Git::CommitItem const *commit = selectedCommitItem();
if (commit && !commit->commit_id.isEmpty()) {
commit_id = commit->commit_id;
}
if (!Git::isValidID(commit_id)) return false;
int row = ui->tableWidget_log->currentRow();
bool ok = false;
reopenRepository(false, [&](GitPtr g){
ok = g->tag(name, commit_id);
});
ui->tableWidget_log->selectRow(row);
return ok;
}
void MainWindow::on_action_tag_push_all_triggered()
{
reopenRepository(false, [&](GitPtr g){
g->push(true);
});
}
-QString MainWindow::tempfileHeader() const
+QString BasicMainWindow::tempfileHeader() const
{
QString name = "jp_soramimi_Guitar_%1_";
return name.arg(QApplication::applicationPid());
}
-void MainWindow::deleteTempFiles()
+void BasicMainWindow::deleteTempFiles()
{
QString dir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
QString name = tempfileHeader();
QDirIterator it(dir, { name + "*" });
while (it.hasNext()) {
QString path = it.next();
QFile::remove(path);
}
}
-QString MainWindow::newTempFilePath()
+QString BasicMainWindow::newTempFilePath()
{
QString tmpdir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
- QString path = tmpdir / tempfileHeader() + QString::number(m->temp_file_counter);
- m->temp_file_counter++;
+ QString path = tmpdir / tempfileHeader() + QString::number(temp_file_counter_);
+ temp_file_counter_++;
return path;
}
-QString MainWindow::determinFileType_(QString const &path, bool mime, std::function<void(QString const &cmd, QByteArray *ba)> callback) const
+QString BasicMainWindow::determinFileType_(QString const &path, bool mime, std::function<void(QString const &cmd, QByteArray *ba)> callback) const
{
- const_cast<MainWindow *>(this)->checkFileCommand();
+ const_cast<BasicMainWindow *>(this)->checkFileCommand();
return misc::determinFileType(global->file_command, path, mime, callback);
}
-QString MainWindow::determinFileType(QString const &path, bool mime)
+QString BasicMainWindow::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)
+QString BasicMainWindow::determinFileType(QByteArray in, bool mime)
{
if (in.isEmpty()) return QString();
if (in.size() > 10) {
if (memcmp(in.data(), "\x1f\x8b\x08", 3) == 0) { // gzip
QBuffer buf;
MemoryReader reader(in.data(), in.size());
reader.open(MemoryReader::ReadOnly);
buf.open(QBuffer::WriteOnly);
gunzip z;
z.set_maximul_size(100000);
z.decode(&reader, &buf);
in = buf.buffer();
}
}
// ファイル名を "-" にすると、リダイレクトで標準入力へ流し込める。
return determinFileType_("-", mime, [&](QString const &cmd, QByteArray *ba){
int r = misc2::runCommand(cmd, &in, ba);
if (r != 0) {
ba->clear();
}
});
}
void MainWindow::on_tableWidget_log_itemDoubleClicked(QTableWidgetItem *)
{
Git::CommitItem const *commit = selectedCommitItem();
if (commit) {
execCommitPropertyDialog(this, commit);
}
}
-void MainWindow::execFilePropertyDialog(QListWidgetItem *item)
+void BasicMainWindow::execFilePropertyDialog(QListWidgetItem *item)
{
if (item) {
QString path = getFilePath(item);
QString id = getObjectID(item);
FilePropertyDialog dlg(this);
dlg.exec(this, path, id);
}
}
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->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;
}
-QPixmap MainWindow::getTransparentPixmap()
+QPixmap BasicMainWindow::getTransparentPixmap()
{
- if (m->transparent_pixmap.isNull()) {
- m->transparent_pixmap = QPixmap(":/image/transparent.png");
+ if (transparent_pixmap_.isNull()) {
+ transparent_pixmap_ = QPixmap(":/image/transparent.png");
}
- return m->transparent_pixmap;
+ return transparent_pixmap_;
}
-QString MainWindow::getCommitIdFromTag(QString const &tag)
+QString BasicMainWindow::getCommitIdFromTag(QString const &tag)
{
- return m->objcache.getCommitIdFromTag(tag);
+ return objcache_.getCommitIdFromTag(tag);
}
-bool MainWindow::isValidRemoteURL(QString const &url)
+bool BasicMainWindow::isValidRemoteURL(QString const &url)
{
if (url.indexOf('\"') >= 0) {
return false;
}
stopPtyProcess();
GitPtr g = git(QString());
QString cmd = "ls-remote \"%1\" HEAD";
- bool f = g->git(cmd.arg(url), false, false, &m->pty_process);
+ bool f = g->git(cmd.arg(url), false, false, &pty_process_);
{
QTime time;
time.start();
- while (!m->pty_process.wait(10)) {
+ while (!pty_process_.wait(10)) {
if (time.elapsed() > 10000) {
f = false;
break;
}
QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
}
stopPtyProcess();
}
QString line = g->resultText().trimmed();
QString head;
int i = line.indexOf('\t');
if (i == GIT_ID_LENGTH) {
QString id = line.mid(0, i);
QString name = line.mid(i + 1);
qDebug() << id << name;
if (name == "HEAD" && Git::isValidID(id)) {
head = id;
}
}
if (f) {
qDebug() << "This is a valid repository.";
if (head.isEmpty()) {
qDebug() << "But HEAD not found";
}
return true;
}
qDebug() << "It is not a repository.";
return false;
}
-bool MainWindow::testRemoteRepositoryValidity(QString const &url)
+bool BasicMainWindow::testRemoteRepositoryValidity(QString const &url)
{
bool ok;
{
OverrideWaitCursor;
ok = isValidRemoteURL(url);
}
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;
}
-bool MainWindow::execSetGlobalUserDialog()
+bool BasicMainWindow::execSetGlobalUserDialog()
{
SetGlobalUserDialog dlg(this);
if (dlg.exec() == QDialog::Accepted) {
GitPtr g = git();
Git::User user = dlg.user();
g->setUser(user, true);
updateWindowTitle(g);
return true;
}
return false;
}
-void MainWindow::execSetUserDialog(Git::User const &global_user, Git::User const &repo_user, QString const &reponame)
+void BasicMainWindow::execSetUserDialog(Git::User const &global_user, Git::User const &repo_user, QString const &reponame)
{
SetUserDialog dlg(this, global_user, repo_user, reponame);
if (dlg.exec() == QDialog::Accepted) {
GitPtr g = git();
Git::User user = dlg.user();
if (dlg.isGlobalChecked()) {
g->setUser(user, true);
}
if (dlg.isRepositoryChecked()) {
g->setUser(user, false);
}
updateWindowTitle(g);
}
}
void 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::on_action_window_log_triggered(bool checked)
{
ui->dockWidget_log->setVisible(checked);
}
-NamedCommitList MainWindow::namedCommitItems(int flags)
+NamedCommitList BasicMainWindow::namedCommitItems(int flags)
{
NamedCommitList items;
if (flags & Branches) {
- for (auto pair: m->branch_map) {
+ for (auto pair: branch_map_) {
QList<Git::Branch> const &list = pair.second;
for (Git::Branch const &b : list) {
if (b.isHeadDetached()) continue;
QString key = b.name;
if (flags & NamedCommitFlag::Remotes) {
if (!b.remote.isEmpty()) {
key = "remotes" / b.remote / key;
}
} else {
if (!b.remote.isEmpty()) continue;
}
NamedCommitItem item;
item.type = NamedCommitItem::Type::Branch;
item.remote = b.remote;
item.name = b.name;
item.id = b.id;
items.push_back(item);
}
}
}
if (flags & Tags) {
- for (auto pair: m->tag_map) {
+ for (auto pair: tag_map_) {
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;
items.push_back(item);
}
}
}
return items;
}
-int MainWindow::rowFromCommitId(QString const &id)
+int BasicMainWindow::rowFromCommitId(QString const &id)
{
- for (size_t i = 0; i < m->logs.size(); i++) {
- Git::CommitItem const &item = m->logs[i];
+ 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::on_action_repo_jump_triggered()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
NamedCommitList items = namedCommitItems(Branches | Tags | Remotes);
JumpDialog::sort(&items);
{
NamedCommitItem head;
head.name = "HEAD";
- head.id = m->head_id;
+ head.id = head_id_;
items.push_front(head);
}
JumpDialog dlg(this, items);
if (dlg.exec() == QDialog::Accepted) {
JumpDialog::Action action = dlg.action();
if (action == JumpDialog::Action::BranchsAndTags) {
QString name = dlg.text();
QString id = g->rev_parse(name);
if (g->objectType(id) == "tag") {
- id = m->objcache.getCommitIdFromTag(id);
+ id = objcache_.getCommitIdFromTag(id);
}
int row = rowFromCommitId(id);
if (row < 0) {
QMessageBox::warning(this, tr("Jump"), QString("%1\n(%2)\n\n").arg(name).arg(id) + tr("That commmit has not foud or not read yet"));
} else {
setCurrentLogRow(row);
if (dlg.isCheckoutChecked()) {
NamedCommitItem item;
for (NamedCommitItem const &t : items) {
if (t.name == name) {
item = t;
break;
}
}
bool ok = false;
if (item.type == NamedCommitItem::Type::Branch) {
ok = g->git(QString("checkout \"%1\"").arg(name), true);
} else if (item.type == NamedCommitItem::Type::Tag) {
ok = g->git(QString("checkout -b \"%1\" \"%2\"").arg(name).arg(id), true);
}
if (ok) {
openRepository(true);
}
}
}
} else if (action == JumpDialog::Action::CommitId) {
QString id = dlg.text();
jumpToCommit(id);
}
}
}
-void MainWindow::jumpToCommit(QString id)
+void BasicMainWindow::jumpToCommit(QString id)
{
GitPtr g = git();
id = g->rev_parse(id);
if (!id.isEmpty()) {
int row = rowFromCommitId(id);
setCurrentLogRow(row);
}
}
-void MainWindow::checkout(QWidget *parent, Git::CommitItem const *commit)
+void BasicMainWindow::checkout(QWidget *parent, Git::CommitItem const *commit)
{
if (!commit) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
QStringList tags;
QStringList local_branches;
QStringList remote_branches;
{
NamedCommitList named_commits = namedCommitItems(Branches | Tags | Remotes);
JumpDialog::sort(&named_commits);
for (NamedCommitItem const &item : named_commits) {
if (item.id == commit->commit_id) {
QString name = item.name;
if (item.type == NamedCommitItem::Type::Tag) {
tags.push_back(name);
} else if (item.type == NamedCommitItem::Type::Branch) {
int i = name.lastIndexOf('/');
if (i < 0 && name == "HEAD") continue;
if (i > 0 && name.mid(i + 1) == "HEAD") continue;
if (item.remote.isNull()) {
local_branches.push_back(name);
} else {
remote_branches.push_back(name);
}
}
}
}
}
CheckoutDialog dlg(parent, tags, local_branches, remote_branches);
if (dlg.exec() == QDialog::Accepted) {
CheckoutDialog::Operation op = dlg.operation();
QString name = dlg.branchName();
QString id = commit->commit_id;
bool ok = false;
setLogEnabled(g, true);
if (op == CheckoutDialog::Operation::HeadDetached) {
ok = g->git(QString("checkout \"%1\"").arg(id), true);
} else if (op == CheckoutDialog::Operation::CreateLocalBranch) {
ok = g->git(QString("checkout -b \"%1\" \"%2\"").arg(name).arg(id), true);
} else if (op == CheckoutDialog::Operation::ExistingLocalBranch) {
ok = g->git(QString("checkout \"%1\"").arg(name), true);
}
if (ok) {
openRepository(true);
}
}
}
+void BasicMainWindow::checkout()
+{
+ checkout(this, selectedCommitItem());
+}
+
+
void MainWindow::deleteBranch(Git::CommitItem const *commit)
{
if (!commit) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
QStringList all_local_branch_names;
QStringList current_local_branch_names;
{
NamedCommitList named_commits = namedCommitItems(Branches);
JumpDialog::sort(&named_commits);
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_local_branch_names.push_back(item.name);
}
}
DeleteBranchDialog dlg(this, false, all_local_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'\n").arg(name));
}
}
if (count > 0) {
openRepository(true);
}
}
}
void MainWindow::mergeBranch(Git::CommitItem const *commit)
{
if (!commit) return;
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->mergeBranch(commit->commit_id);
openRepository(true);
}
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;
g->cherrypick(commit->commit_id);
openRepository(true);
}
-void MainWindow::checkout()
-{
- checkout(this, selectedCommitItem());
-}
+
void MainWindow::deleteBranch()
{
deleteBranch(selectedCommitItem());
}
void MainWindow::on_action_repo_checkout_triggered()
{
checkout();
}
void MainWindow::on_action_delete_branch_triggered()
{
deleteBranch();
}
bool MainWindow::runOnRepositoryDir(std::function<void(QString)> callback, RepositoryItem const *repo)
{
if (!repo) {
- repo = &m->current_repo;
+ repo = &current_repo_;
}
QString dir = repo->local_dir;
dir.replace('\\', '/');
if (QFileInfo(dir).isDir()) {
callback(dir);
return true;
}
QMessageBox::warning(this, qApp->applicationName(), tr("No repository selected"));
return false;
}
#ifdef Q_OS_MAC
namespace {
bool isValidDir(QString const &dir)
{
if (dir.indexOf('\"') >= 0 || dir.indexOf('\\') >= 0) return false;
return QFileInfo(dir).isDir();
}
}
#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);
}
void MainWindow::on_toolButton_terminal_clicked()
{
openTerminal(nullptr);
}
void MainWindow::on_toolButton_explorer_clicked()
{
openExplorer(nullptr);
}
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, &m->pty_process);
+ g->push_u(remote, branch, &pty_process_);
while (1) {
- if (m->pty_process.wait(1)) break;
+ if (pty_process_.wait(1)) break;
QApplication::processEvents();
}
- exitcode = m->pty_process.getExitCode();
- errormsg = m->pty_process.getMessage();
+ exitcode = pty_process_.getExitCode();
+ errormsg = pty_process_.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) {
ui->action_push->trigger();
} else if (a == PushDialog::PushSetUpstream) {
QString remote = dlg.remote();
QString branch = dlg.branch();
pushSetUpstream(remote, branch);
}
return true;
}
return false;
}
void MainWindow::on_action_reset_HEAD_1_triggered()
{
GitPtr g = git();
if (!isValidWorkingCopy(g)) return;
g->reset_head1();
openRepository(false);
}
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()) {
g->addRemoteURL(remote_name, remote_url);
}
}
}
} else {
// not dir
}
}
}
void MainWindow::on_action_create_a_repository_triggered()
{
createRepository(QString());
}
bool MainWindow::isRemoteOnline() const
{
return ui->radioButton_remote_online->isChecked();
}
void MainWindow::setNetworkingCommandsEnabled(bool f)
{
ui->action_clone->setEnabled(f);
ui->toolButton_clone->setEnabled(f);
if (!Git::isValidWorkingCopy(currentWorkingCopyDir())) {
f = false;
}
ui->action_fetch->setEnabled(f);
ui->action_pull->setEnabled(f);
ui->action_push->setEnabled(f);
ui->toolButton_fetch->setEnabled(f);
ui->toolButton_pull->setEnabled(f);
ui->toolButton_push->setEnabled(f);
}
void MainWindow::setRemoteOnline(bool f)
{
QRadioButton *rb = nullptr;
rb = f ? ui->radioButton_remote_online : ui->radioButton_remote_offline;
rb->blockSignals(true);
rb->click();
rb->blockSignals(false);
setNetworkingCommandsEnabled(f);
MySettings s;
s.beginGroup("Remote");
s.setValue("Online", f);
s.endGroup();
}
void MainWindow::on_radioButton_remote_online_clicked()
{
setRemoteOnline(true);
}
void MainWindow::on_radioButton_remote_offline_clicked()
{
setRemoteOnline(false);
}
void MainWindow::on_verticalScrollBar_log_valueChanged(int)
{
ui->widget_log->refrectScrollBar();
}
void MainWindow::on_horizontalScrollBar_log_valueChanged(int)
{
ui->widget_log->refrectScrollBar();
}
-void MainWindow::stopPtyProcess()
+void BasicMainWindow::stopPtyProcess()
{
- m->pty_process.stop();
- QDir::setCurrent(m->starting_dir);
+ pty_process_.stop();
+ QDir::setCurrent(starting_dir_);
}
-void MainWindow::abortPtyProcess()
+void BasicMainWindow::abortPtyProcess()
{
stopPtyProcess();
- m->pty_process_ok = false;
- m->interaction_canceled = true;
+ pty_process_ok_ = false;
+ interaction_canceled_ = true;
}
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::execCommitViewWindow(Git::CommitItem const *commit)
+void BasicMainWindow::execCommitViewWindow(Git::CommitItem const *commit)
{
CommitViewWindow win(this, commit);
win.exec();
}
void MainWindow::on_action_repository_property_triggered()
{
execRepositoryPropertyDialog(currentWorkingCopyDir());
}
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;
- m->interaction_mode = InteractionMode::Busy;
+ interaction_mode_ = InteractionMode::Busy;
QApplication::restoreOverrideCursor();
TheDlg dlg(this);
if (dlg.exec() == QDialog::Accepted) {
TheDlg::Result r = dlg.result();
if (r == TheDlg::Result::Yes) {
- m->pty_process.writeInput("yes\n", 4);
+ pty_process_.writeInput("yes\n", 4);
} else {
- m->pty_process_ok = false; // abort
- m->pty_process.writeInput("no\n", 3);
+ pty_process_ok_ = false; // abort
+ pty_process_.writeInput("no\n", 3);
QThread::msleep(300);
stopPtyProcess();
}
} else {
ui->widget_log->setFocus();
- m->interaction_canceled = true;
+ interaction_canceled_ = true;
}
- m->interaction_mode = InteractionMode::Busy;
+ interaction_mode_ = InteractionMode::Busy;
}
void MainWindow::onLogIdle()
{
- if (m->interaction_canceled) return;
- if (m->interaction_mode != InteractionMode::None) return;
+ if (interaction_canceled_) return;
+ if (interaction_mode_ != 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';
- m->pty_process.writeInput(str.c_str(), str.size());
+ pty_process_.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 == m->ssh_passphrase_for && !m->ssh_passphrase_secret.empty()) {
- std::string text = m->ssh_passphrase_secret + '\n';
- m->pty_process.writeInput(text.c_str(), text.size());
+ if (keyfile == ssh_passphrase_for_ && !ssh_passphrase_secret_.empty()) {
+ std::string text = ssh_passphrase_secret_ + '\n';
+ pty_process_.writeInput(text.c_str(), text.size());
} else {
- m->ssh_passphrase_for = keyfile;
+ ssh_passphrase_for_ = keyfile;
std::string s = ExecLineEditDialog(this, "Passphrase for key", QString::fromStdString(line), QString(), true);
- m->ssh_passphrase_secret = s;
+ ssh_passphrase_secret_ = s;
}
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){
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);
if (value) *value = s;
return true;
}
}
return false;
};
- std::string uid = m->http_uid;
- std::string pwd = m->http_pwd;
+ std::string uid = http_uid_;
+ std::string pwd = http_pwd_;
if (Input("Username", false, &uid)) {
- m->http_uid = uid;
+ http_uid_ = uid;
return;
}
if (Input("Password", true, &pwd)) {
- m->http_pwd = pwd;
+ http_pwd_ = pwd;
return;
}
if (StartsWith(fatal_authentication_failed_for)) {
QMessageBox::critical(this, tr("Authentication Failed"), QString::fromStdString(line));
abortPtyProcess();
return;
}
}
}
}
-QList<Git::Tag> MainWindow::queryTagList()
+QList<Git::Tag> BasicMainWindow::queryTagList()
{
QList<Git::Tag> list;
Git::CommitItem const *commit = selectedCommitItem();
if (commit && Git::isValidID(commit->commit_id)) {
list = findTag(commit->commit_id);
}
return list;
}
void MainWindow::on_action_edit_tags_triggered()
{
Git::CommitItem const *commit = selectedCommitItem();
if (commit && Git::isValidID(commit->commit_id)) {
EditTagsDialog dlg(this, commit);
dlg.exec();
}
}
void MainWindow::on_action_push_u_triggered()
{
pushSetUpstream(false);
}
QStringList MainWindow::remoteBranches(QString const &id)
{
QStringList list;
GitPtr g = git();
if (isValidWorkingCopy(g)) {
NamedCommitList named_commits = namedCommitItems(Branches | Remotes);
JumpDialog::sort(&named_commits);
for (NamedCommitItem const &item : named_commits) {
if (item.id == id && !item.remote.isEmpty()) {
list.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 remote_branches = remoteBranches(commit->commit_id);
if (remote_branches.isEmpty()) return;
DeleteBranchDialog dlg(this, true, QStringList(), 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);
}
}
}
}
void MainWindow::on_action_delete_remote_branch_triggered()
{
deleteRemoteBranch(selectedCommitItem());
}
void MainWindow::rebaseOnto()
{
struct Commit {
QStringList parents;
QStringList children;
};
std::map<QString, Commit> commit_map;
Git::CommitItem const *commit = selectedCommitItem();
if (commit) {
- for (Git::CommitItem const &item : m->logs) {
+ for (Git::CommitItem const &item : logs_) {
Commit c;
c.parents = item.parent_ids;
commit_map[item.commit_id] = c;
}
- for (Git::CommitItem const &item : m->logs) {
+ for (Git::CommitItem const &item : logs_) {
for (QString const &parent : item.parent_ids) {
auto it = commit_map.find(parent);
if (it != commit_map.end()) {
it->second.children.push_back(item.commit_id);
}
}
}
QString upstream;
- QString id = m->head_id;
+ QString id = head_id_;
while (1) {
auto it = commit_map.find(id);
if (it == commit_map.end()) break;
Commit const &c = it->second;
if (c.parents.size() > 1) goto done;
if (c.parents.size() != 1) break;
- if (id != m->head_id) {
+ if (id != head_id_) {
if (c.children.size() > 1) goto done;
if (!findTag(id).isEmpty()) goto done;
- auto it2 = m->branch_map.find(id);
- if (it2 != m->branch_map.end()) {
+ auto it2 = branch_map_.find(id);
+ if (it2 != branch_map_.end()) {
QList<Git::Branch> b = it2->second;
if (!it2->second.empty()) goto done;
}
}
id = c.parents.first();
continue;
done:;
upstream = id;
break;
}
QString newbase = commit->commit_id;
- QString branch = m->head_id;
+ QString branch = head_id_;
RebaseOntoDialog dlg(this);
if (dlg.exec(newbase, upstream, branch) == QDialog::Accepted) {
reopenRepository(true, [&](GitPtr g){
- m->pty_condition = PtyCondition::Pull;
- m->pty_process_ok = true;
- g->rebaseOnto(newbase, upstream, branch, &m->pty_process);
+ pty_condition_ = PtyCondition::Pull;
+ pty_process_ok_ = true;
+ g->rebaseOnto(newbase, upstream, branch, &pty_process_);
while (1) {
- if (m->pty_process.wait(1)) break;
+ if (pty_process_.wait(1)) break;
QApplication::processEvents();
}
});
}
}
}
void MainWindow::on_action_rebase_onto_triggered()
{
rebaseOnto();
}
void MainWindow::checkRemoteUpdate()
{
- if (m->pty_process.isRunning()) return;
+ if (pty_process_.isRunning()) return;
emit signalCheckRemoteUpdate();
}
void MainWindow::on_action_test_triggered()
{
}
diff --git a/src/MainWindow.h b/src/MainWindow.h
index 81ee9f6..aad7598 100644
--- a/src/MainWindow.h
+++ b/src/MainWindow.h
@@ -1,412 +1,382 @@
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
-#include <QMainWindow>
+#include "BasicMainWindow.h"
#include "Git.h"
#include "RepositoryData.h"
-#include <memory>
-#include <functional>
#include "GitHubAPI.h"
#include "main.h"
#include "TextEditorTheme.h"
+#include <functional>
+#include <memory>
namespace Ui {
class MainWindow;
}
class QScrollBar;
class QListWidget;
class QListWidgetItem;
class QTreeWidgetItem;
class QTableWidgetItem;
class AboutDialog;
class MySettings;
class LocalSocketReader;
class CommitList;
class WebContext;
#define PATH_PREFIX "*"
class HunkItem {
public:
int hunk_number = -1;
size_t pos, len;
std::vector<std::string> lines;
};
-class MainWindow : public QMainWindow {
+class MainWindow : public BasicMainWindow {
Q_OBJECT
friend class ImageViewWidget;
friend class FileDiffSliderWidget;
friend class FileHistoryWindow;
friend class FileDiffWidget;
friend class AboutDialog;
public:
- struct Label {
- enum {
- Head,
- LocalBranch,
- RemoteBranch,
- Tag,
- };
- int kind;
- QString text;
- Label(int kind = LocalBranch)
- : kind(kind)
- {
-
- }
- };
private:
struct Private;
Private *m;
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
QPixmap const &digitsPixmap() const;
QString currentWorkingCopyDir() const;
- static QString makeRepositoryName(QString const &loc);
+// static QString makeRepositoryName(QString const &loc);
const Git::CommitItemList *logs() const;
QColor color(unsigned int i);
private:
Ui::MainWindow *ui;
- enum class FilesListType {
- SingleList,
- SideBySide,
- };
-
- void addDiffItems(const QList<Git::Diff> *diff_list, std::function<void (QString const &, QString, int)> const &AddItem_);
+// void addDiffItems(const QList<Git::Diff> *diff_list, std::function<void (QString const &, QString, int)> const &AddItem_);
void updateFilesList(QString id, bool wait);
void updateFilesList(const Git::CommitItem &commit, bool wait);
void updateRepositoriesList();
- QString getBookmarksFilePath() const;
- bool saveRepositoryBookmarks() const;
+// QString getBookmarksFilePath() const;
+// bool saveRepositoryBookmarks() const;
void openRepository_(GitPtr g);
- void openRepository(bool validate, bool waitcursor = true);
+// void openRepository(bool validate, bool waitcursor = true);
void reopenRepository(bool log, std::function<void(GitPtr)> callback);
void openSelectedRepository();
bool askAreYouSureYouWantToRun(QString const &title, QString const &command);
void resetFile(QStringList const &path);
void revertAllFiles();
void prepareLogTableWidget();
QStringList selectedFiles_(QListWidget *listwidget) const;
QStringList selectedFiles() const;
void for_each_selected_files(std::function<void (QString const &)> fn);
bool editFile(QString const &path, QString const &title);
void updateCommitGraph();
void showFileList(FilesListType files_list_type);
- bool checkGitCommand();
- bool checkFileCommand();
- void checkUser();
+// bool checkGitCommand();
+// bool checkFileCommand();
+// void checkUser();
void clearLog();
void clearFileList();
void clearDiffView();
void clearRepositoryInfo();
int repositoryIndex_(const QTreeWidgetItem *item) const;
RepositoryItem const *repositoryItem(const QTreeWidgetItem *item) const;
bool makeDiff(QString id, QList<Git::Diff> *out);
void commit(bool amend = false);
void commit_amend();
void queryBranches(GitPtr g);
void updateRemoteInfo();
- QList<Git::Branch> findBranch(QString const &id);
- QList<Git::Tag> findTag(QString const &id);
+// QList<Git::Branch> findBranch(QString const &id);
+// QList<Git::Tag> findTag(QString const &id);
int selectedLogIndex() const;
- const Git::CommitItem *selectedCommitItem() const;
+// const Git::CommitItem *selectedCommitItem() const;
void deleteTags(const Git::CommitItem &commit);
QTreeWidgetItem *newQTreeWidgetFolderItem(QString const &name);
void buildRepoTree(QString const &group, QTreeWidgetItem *item, QList<RepositoryItem> *repos);
void refrectRepositories();
- bool saveByteArrayAs(QByteArray const &ba, QString const &dstpath);
- bool saveFileAs(QString const &srcpath, QString const &dstpath);
- bool saveBlobAs(QString const &id, QString const &dstpath);
- QString selectCommand_(QString const &cmdname, QStringList const &cmdfile, QStringList const &list, QString path, std::function<void (QString const &)> callback);
- QString selectCommand_(QString const &cmdname, QString const &cmdfile, QStringList const &list, QString path, std::function<void(QString const &)> callback);
+// bool saveByteArrayAs(QByteArray const &ba, QString const &dstpath);
+// bool saveFileAs(QString const &srcpath, QString const &dstpath);
+// bool saveBlobAs(QString const &id, QString const &dstpath);
+// QString selectCommand_(QString const &cmdname, QStringList const &cmdfile, QStringList const &list, QString path, std::function<void (QString const &)> callback);
+// QString selectCommand_(QString const &cmdname, QString const &cmdfile, QStringList const &list, QString path, std::function<void(QString const &)> callback);
void updateDiffView(QListWidgetItem *item);
void updateDiffView();
void updateUnstagedFileCurrentItem();
void updateStagedFileCurrentItem();
// void addTag();
- QStringList whichCommand_(QString const &cmdfile1, QString const &cmdfile2 = QString());
- QString getObjectID(QListWidgetItem *item);
- QString determinFileType_(QString const &path, bool mime, std::function<void(QString const &cmd, QByteArray *ba)> callback) const;
- Git::Object cat_file_(GitPtr g, QString const &id);
- Git::Object cat_file(QString const &id);
+// QStringList whichCommand_(QString const &cmdfile1, QString const &cmdfile2 = QString());
+// QString getObjectID(QListWidgetItem *item);
+// QString determinFileType_(QString const &path, bool mime, std::function<void(QString const &cmd, QByteArray *ba)> callback) const;
+// Git::Object cat_file_(GitPtr g, QString const &id);
+// Git::Object cat_file(QString const &id);
void updateStatusBarText();
- void setUnknownRepositoryInfo();
- void setWindowTitle_(const Git::User &user);
+// void setUnknownRepositoryInfo();
+// void setWindowTitle_(const Git::User &user);
void setRepositoryInfo(QString const &reponame, QString const &brname);
- void updateWindowTitle(GitPtr g);
- void logGitVersion();
- static bool git_callback(void *cookie, char const *ptr, int len);
+// void updateWindowTitle(GitPtr g);
+// void logGitVersion();
+// static bool git_callback(void *cookie, char const *ptr, int len);
int indexOfRepository(const QTreeWidgetItem *treeitem) const;
void removeRepositoryFromBookmark(int index, bool ask);
- enum NamedCommitFlag {
- Branches = 0x0001,
- Tags = 0x0002,
- Remotes = 0x0100,
- };
- NamedCommitList namedCommitItems(int flags);
+// NamedCommitList namedCommitItems(int flags);
void deleteBranch(const Git::CommitItem *commit);
- void checkout();
void clone();
void deleteBranch();
- Git::CommitItemList retrieveCommitLog(GitPtr g);
+// Git::CommitItemList retrieveCommitLog(GitPtr g);
bool runOnRepositoryDir(std::function<void(QString)> callback, const RepositoryItem *repo);
void openTerminal(const RepositoryItem *repo);
void openExplorer(const RepositoryItem *repo);
void pushSetUpstream(QString const &remote, QString const &branch);
bool pushSetUpstream(bool testonly);
void clearRepoFilter();
void appendCharToRepoFilter(ushort c);
void backspaceRepoFilter();
void revertCommit();
- int rowFromCommitId(QString const &id);
+// int rowFromCommitId(QString const &id);
void cherrypick(const Git::CommitItem *commit);
void mergeBranch(const Git::CommitItem *commit);
void rebaseBranch(const Git::CommitItem *commit);
void detectGitServerType(GitPtr g);
- void initNetworking();
+// void initNetworking();
void setRemoteOnline(bool f);
bool isRemoteOnline() const;
void startTimers();
void onCloneCompleted(bool success);
bool fetch(GitPtr g);
- void stopPtyProcess();
- void abortPtyProcess();
+// void stopPtyProcess();
+// void abortPtyProcess();
void setNetworkingCommandsEnabled(bool f);
- void execSetUserDialog(const Git::User &global_user, const Git::User &repo_user, QString const &reponame);
- bool execSetGlobalUserDialog();
+// void execSetUserDialog(const Git::User &global_user, const Git::User &repo_user, QString const &reponame);
+// bool execSetGlobalUserDialog();
void blame(QListWidgetItem *item);
void blame();
QListWidgetItem *currentFileItem() const;
- const RepositoryItem *findRegisteredRepository(QString *workdir) const;
+// const RepositoryItem *findRegisteredRepository(QString *workdir) const;
void execAreYouSureYouWantToContinueConnectingDialog();
void queryRemotes(GitPtr g);
- void internalSetCommand(QString const &path, bool save, QString const &name, QString *out);
+// void internalSetCommand(QString const &path, bool save, QString const &name, QString *out);
void deleteRemoteBranch(const Git::CommitItem *commit);
QStringList remoteBranches(QString const &id);
void rebaseOnto();
void createRepository(QString const &dir);
void checkRemoteUpdate();
void setWatchRemoteInterval(int mins);
- void emitWriteLog(QByteArray ba);
+// void emitWriteLog(QByteArray ba);
protected:
void dragEnterEvent(QDragEnterEvent *event);
void timerEvent(QTimerEvent *);
void keyPressEvent(QKeyEvent *event);
bool event(QEvent *event);
bool eventFilter(QObject *watched, QEvent *event);
public:
- QString selectGitCommand(bool save);
- QString selectFileCommand(bool save);
- QString selectGpgCommand(bool save);
+// QString selectGitCommand(bool save);
+// QString selectFileCommand(bool save);
+// QString selectGpgCommand(bool save);
- int limitLogCount() const;
+// int limitLogCount() const;
- void setGitCommand(QString const &path, bool save);
- void setFileCommand(QString const &path, bool save);
- void setGpgCommand(QString const &path, bool save);
- void clearAuthentication();
- void setCurrentRepository(const RepositoryItem &repo, bool clear_authentication);
+// void setGitCommand(QString const &path, bool save);
+// void setFileCommand(QString const &path, bool save);
+// void setGpgCommand(QString const &path, bool save);
+// void clearAuthentication();
+// void setCurrentRepository(const RepositoryItem &repo, bool clear_authentication);
bool isThereUncommitedChanges() const;
QString defaultWorkingDir() const;
void autoOpenRepository(QString dir);
- void saveRepositoryBookmark(RepositoryItem item);
+// void saveRepositoryBookmark(RepositoryItem item);
void drawDigit(QPainter *pr, int x, int y, int n) const;
int digitWidth() const;
int digitHeight() const;
- bool isValidWorkingCopy(const GitPtr &g) const;
- QString tempfileHeader() const;
- void deleteTempFiles();
- QString newTempFilePath();
- bool saveAs(QString const &id, QString const &dstpath);
- QString saveAsTemp(QString const &id);
- QString abbrevCommitID(const Git::CommitItem &commit);
- QString findFileID(GitPtr g, QString const &commit_id, QString const &file);
- QString determinFileType(QString const &path, bool mime);
- QString determinFileType(QByteArray in, bool mime);
- QPixmap getTransparentPixmap();
- QString getCommitIdFromTag(QString const &tag);
+// bool isValidWorkingCopy(const GitPtr &g) const;
+// QString tempfileHeader() const;
+// void deleteTempFiles();
+// QString newTempFilePath();
+// bool saveAs(QString const &id, QString const &dstpath);
+// QString saveAsTemp(QString const &id);
+// QString abbrevCommitID(const Git::CommitItem &commit);
+// QString findFileID(GitPtr g, QString const &commit_id, QString const &file);
+// QString determinFileType(QString const &path, bool mime);
+// QString determinFileType(QByteArray in, bool mime);
+// QPixmap getTransparentPixmap();
+// QString getCommitIdFromTag(QString const &tag);
void setStatusBarText(QString const &text);
void clearStatusBarText();
- QString makeCommitInfoText(int row, QList<Label> *label_list);
- void setLogEnabled(GitPtr g, bool f);
- void addWorkingCopyDir(QString dir, QString name, bool open);
- void addWorkingCopyDir(QString dir, bool open)
- {
- addWorkingCopyDir(dir, QString(), open);
- }
- bool isValidRemoteURL(QString const &url);
- bool testRemoteRepositoryValidity(QString const &url);
+// QString makeCommitInfoText(int row, QList<Label> *label_list);
+// void setLogEnabled(GitPtr g, bool f);
+// void addWorkingCopyDir(QString dir, QString name, bool open);
+// void addWorkingCopyDir(QString dir, bool open);
+// bool isValidRemoteURL(QString const &url);
+// bool testRemoteRepositoryValidity(QString const &url);
void removeSelectedRepositoryFromBookmark(bool ask);
void setCurrentLogRow(int row);
- GitPtr git(QString const &dir) const;
- GitPtr git();
- const QList<Label> *label(int row);
- bool isGitHub() const;
- QIcon committerIcon(int row) const;
- void updateCommitTableLater();
- bool isAvatarEnabled() const;
- WebContext *getWebContextPtr();
+// GitPtr git(QString const &dir) const;
+// GitPtr git();
+// const QList<Label> *label(int row);
+// bool isGitHub() const;
+// QIcon committerIcon(int row) const;
+// void updateCommitTableLater();
+// bool isAvatarEnabled() const;
bool shown();
- void execFileHistory(QListWidgetItem *item);
- void execFileHistory(QString const &path);
- void execCommitExploreWindow(QWidget *parent, const Git::CommitItem *commit);
- void execCommitPropertyDialog(QWidget *parent, const Git::CommitItem *commit);
- void checkout(QWidget *parent, const Git::CommitItem *commit);
- TextEditorThemePtr themeForTextEditor();
- bool queryCommit(QString const &id, Git::CommitItem *out);
- void jumpToCommit(QString id);
- WebContext *webContext();
- bool execWelcomeWizardDialog();
- void updateFilesList(QString id, QList<Git::Diff> *diff_list, QListWidget *listwidget);
- void execCommitViewWindow(const Git::CommitItem *commit);
- QAction *addMenuActionProperty(QMenu *menu);
- void execFilePropertyDialog(QListWidgetItem *item);
- void execRepositoryPropertyDialog(QString workdir, bool open_repository_menu = false);
- QStringList remotes() const;
- QIcon verifiedIcon(char s) const;
- ApplicationSettings *appsettings();
- const ApplicationSettings *appsettings() const;
- const Git::CommitItem *commitItem(int row) const;
- bool checkExecutable(QString const &path);
+// void execFileHistory(QListWidgetItem *item);
+// void execFileHistory(QString const &path);
+// void execCommitExploreWindow(QWidget *parent, const Git::CommitItem *commit);
+// void execCommitPropertyDialog(QWidget *parent, const Git::CommitItem *commit);
+// void checkout(QWidget *parent, const Git::CommitItem *commit);
+// void checkout();
+// TextEditorThemePtr themeForTextEditor();
+// bool queryCommit(QString const &id, Git::CommitItem *out);
+// void jumpToCommit(QString id);
+// bool execWelcomeWizardDialog();
+// void updateFilesList(QString id, QList<Git::Diff> *diff_list, QListWidget *listwidget);
+// void execCommitViewWindow(const Git::CommitItem *commit);
+// QAction *addMenuActionProperty(QMenu *menu);
+// void execFilePropertyDialog(QListWidgetItem *item);
+// void execRepositoryPropertyDialog(QString workdir, bool open_repository_menu = false);
+// QStringList remotes() const;
+// QIcon verifiedIcon(char s) const;
+// ApplicationSettings *appsettings();
+// const ApplicationSettings *appsettings() const;
+// const Git::CommitItem *commitItem(int row) const;
+// bool checkExecutable(QString const &path);
void deleteTags(QStringList const &tagnames);
- QList<Git::Tag> queryTagList();
+// QList<Git::Tag> queryTagList();
bool addTag(QString const &name);
void updateCurrentFilesList();
void setRemoteChanged(bool f);
- QString currentRepositoryName() const;
- QString currentRemoteName() const;
- Git::Branch const &currentBranch() const;
- QString currentBranchName() const;
-public slots:
- void writeLog(char const *ptr, int len);
- void writeLog(QString const &str);
- void writeLog(QByteArray ba);
+// QString currentRepositoryName() const;
+// QString currentRemoteName() const;
+// Git::Branch const &currentBranch() const;
+// QString currentBranchName() const;
+//public slots:
+// void writeLog(char const *ptr, int len);
+// void writeLog(QString const &str);
+// void writeLog(QByteArray ba);
private slots:
void on_action_clone_triggered();
void on_action_commit_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_fetch_triggered();
void on_action_open_existing_working_copy_triggered();
void on_action_pull_triggered();
void on_action_push_triggered();
void on_action_test_triggered();
void on_action_view_refresh_triggered();
void on_action_tag_push_all_triggered();
void on_treeWidget_repos_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous);
void on_treeWidget_repos_itemDoubleClicked(QTreeWidgetItem *item, int column);
void on_tableWidget_log_currentItemChanged(QTableWidgetItem *current, QTableWidgetItem *previous);
void on_treeWidget_repos_customContextMenuRequested(const QPoint &pos);
void on_tableWidget_log_customContextMenuRequested(const QPoint &pos);
void on_listWidget_files_customContextMenuRequested(const QPoint &pos);
void on_listWidget_unstaged_customContextMenuRequested(const QPoint &pos);
void on_listWidget_staged_customContextMenuRequested(const QPoint &pos);
void on_listWidget_unstaged_currentRowChanged(int currentRow);
void on_listWidget_staged_currentRowChanged(int currentRow);
void on_listWidget_files_currentRowChanged(int currentRow);
void on_toolButton_commit_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_unstage_clicked();
void on_action_about_triggered();
void on_toolButton_clone_clicked();
void on_toolButton_fetch_clicked();
void on_lineEdit_filter_textChanged(QString const &text);
void on_toolButton_erase_filter_clicked();
void on_tableWidget_log_itemDoubleClicked(QTableWidgetItem *);
void on_listWidget_unstaged_itemDoubleClicked(QListWidgetItem *item);
void on_listWidget_staged_itemDoubleClicked(QListWidgetItem *item);
void on_listWidget_files_itemDoubleClicked(QListWidgetItem *item);
void onRepositoriesTreeDropped();
void on_action_set_config_user_triggered();
void on_action_window_log_triggered(bool checked);
void onLogVisibilityChanged();
void on_action_repo_jump_triggered();
void on_action_repo_checkout_triggered();
void on_action_delete_branch_triggered();
void on_toolButton_terminal_clicked();
void on_toolButton_explorer_clicked();
void on_action_reset_HEAD_1_triggered();
void on_action_create_a_repository_triggered();
- void onAvatarUpdated();
+// void onAvatarUpdated();
void on_radioButton_remote_online_clicked();
void on_radioButton_remote_offline_clicked();
void on_verticalScrollBar_log_valueChanged(int);
void on_horizontalScrollBar_log_valueChanged(int);
void onPtyProcessCompleted();
void on_toolButton_stop_process_clicked();
void on_action_stop_process_triggered();
void on_action_exit_triggered();
void on_action_reflog_triggered();
void on_action_repository_property_triggered();
void on_action_set_gpg_signing_triggered();
void on_action_edit_tags_triggered();
void on_action_push_u_triggered();
void on_action_delete_remote_branch_triggered();
void on_action_rebase_onto_triggered();
void doUpdateButton();
signals:
void onEscapeKeyPressed();
void signalCheckRemoteUpdate();
void updateButton();
- void signalWriteLog(QByteArray ba);
protected:
void closeEvent(QCloseEvent *event);
+ virtual void internalWriteLog(const char *ptr, int len);
protected slots:
void onLogIdle();
};
#endif // MAINWINDOW_H
diff --git a/src/MyTextEditorWidget.cpp b/src/MyTextEditorWidget.cpp
index 970fd0f..67c9780 100644
--- a/src/MyTextEditorWidget.cpp
+++ b/src/MyTextEditorWidget.cpp
@@ -1,57 +1,57 @@
#include "MyTextEditorWidget.h"
#include "MainWindow.h"
#include "common/misc.h"
#include <QMenu>
#include <QFileDialog>
#include "common/joinpath.h"
MyTextEditorWidget::MyTextEditorWidget(QWidget *parent)
: TextEditorWidget(parent)
{
}
-void MyTextEditorWidget::setDocument(const QList<Document::Line> *source, MainWindow *mw, QString const &object_id, QString const &object_path)
+void MyTextEditorWidget::setDocument(const QList<Document::Line> *source, BasicMainWindow *mw, QString const &object_id, QString const &object_path)
{
this->mainwindow = mw;
this->object_id = object_id;
this->object_path = object_path;
TextEditorWidget::setDocument(source);
}
void MyTextEditorWidget::contextMenuEvent(QContextMenuEvent *event)
{
QString id = object_id;
if (id.startsWith(PATH_PREFIX)) {
// pass
} else if (Git::isValidID(id)) {
// pass
} else {
return; // invalid id
}
QMenu menu;
QAction *a_save_as = id.isEmpty() ? nullptr : menu.addAction(tr("Save as..."));
QAction *a_copy = menu.addAction(tr("Copy"));
if (!menu.actions().isEmpty()) {
update();
QAction *a = menu.exec(misc::contextMenuPos(this, event));
if (a) {
if (a == a_save_as) {
QString path = mainwindow->currentWorkingCopyDir() / object_path;
QString dstpath = QFileDialog::getSaveFileName(window(), tr("Save as"), path);
if (!dstpath.isEmpty()) {
mainwindow->saveAs(id, dstpath);
}
update();
return;
}
if (a == a_copy) {
editCopy();
return;
}
}
}
}
diff --git a/src/MyTextEditorWidget.h b/src/MyTextEditorWidget.h
index 952cc2e..7b309d3 100644
--- a/src/MyTextEditorWidget.h
+++ b/src/MyTextEditorWidget.h
@@ -1,22 +1,22 @@
#ifndef MYTEXTEDITORWIDGET_H
#define MYTEXTEDITORWIDGET_H
#include "texteditor/TextEditorWidget.h"
-class MainWindow;
+class BasicMainWindow;
class MyTextEditorWidget : public TextEditorWidget {
private:
- MainWindow *mainwindow;
+ BasicMainWindow *mainwindow;
QString object_id;
QString object_path;
public:
MyTextEditorWidget(QWidget *parent = 0);
// QWidget interface
- void setDocument(const QList<Document::Line> *source, MainWindow *mw, QString const &object_id, QString const &object_path);
+ void setDocument(const QList<Document::Line> *source, BasicMainWindow *mw, QString const &object_id, QString const &object_path);
protected:
void contextMenuEvent(QContextMenuEvent *event);
};
#endif // MYTEXTEDITORWIDGET_H
diff --git a/src/RepositoryPropertyDialog.cpp b/src/RepositoryPropertyDialog.cpp
index ef6a4a5..64dd8e9 100644
--- a/src/RepositoryPropertyDialog.cpp
+++ b/src/RepositoryPropertyDialog.cpp
@@ -1,141 +1,141 @@
#include "RepositoryPropertyDialog.h"
#include "ui_RepositoryPropertyDialog.h"
#include "common/misc.h"
#include "MainWindow.h"
#include <QClipboard>
#include <QMenu>
#include <QMessageBox>
-RepositoryPropertyDialog::RepositoryPropertyDialog(MainWindow *parent, GitPtr g, const RepositoryItem &item, bool open_repository_menu)
+RepositoryPropertyDialog::RepositoryPropertyDialog(BasicMainWindow *parent, GitPtr g, const RepositoryItem &item, bool open_repository_menu)
: BasicRepositoryDialog(parent, g)
, ui(new Ui::RepositoryPropertyDialog)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
repository = item;
ui->groupBox_remote->setVisible(open_repository_menu);
ui->label_name->setText(repository.name);
ui->lineEdit_local_dir->setText(misc::normalizePathSeparator(repository.local_dir));
updateRemotesTable();
}
RepositoryPropertyDialog::~RepositoryPropertyDialog()
{
delete ui;
}
void RepositoryPropertyDialog::updateRemotesTable()
{
BasicRepositoryDialog::updateRemotesTable(ui->tableWidget);
}
void RepositoryPropertyDialog::toggleRemoteMenuActivity()
{
ui->groupBox_remote->setVisible(!ui->groupBox_remote->isVisible());
}
bool RepositoryPropertyDialog::execEditRemoteDialog(Git::Remote *remote, EditRemoteDialog::Operation op)
{
auto const *list = remotes();
if (op == EditRemoteDialog::RemoteSet) {
int row = ui->tableWidget->currentRow();
if (row >= 0 && row < list->size()) {
*remote = list->at(row);
}
} else {
*remote = Git::Remote();
}
if (remote->name.isEmpty() && list->isEmpty()) {
op = EditRemoteDialog::RemoteAdd;
remote->name = "origin";
}
EditRemoteDialog dlg(mainwindow(), op);
dlg.setName(remote->name);
dlg.setUrl(remote->url);
if (dlg.exec() == QDialog::Accepted) {
remote->name = dlg.name();
remote->url = dlg.url();
GitPtr g = git();
if (op == EditRemoteDialog::RemoteAdd) {
bool ok = true;
for (Git::Remote const &r : *list) {
if (r.name == remote->name) {
qDebug() << "remote add: Already exists" << remote->name;
ok = false;
break;
}
}
if (ok) {
g->addRemoteURL(remote->name, remote->url);
}
} else if (op == EditRemoteDialog::RemoteSet) {
g->setRemoteURL(remote->name, remote->url);
}
updateRemotesTable();
return true;
}
return false;
}
Git::Remote RepositoryPropertyDialog::selectedRemote() const
{
Git::Remote remote;
auto const *list = remotes();
int row = ui->tableWidget->currentRow();
if (row >= 0 && row < list->size()) {
remote = list->at(row);
}
return remote;
}
bool RepositoryPropertyDialog::isRemoteChanged() const
{
return remote_changed;
}
void RepositoryPropertyDialog::on_pushButton_remote_add_clicked()
{
Git::Remote r;
if (execEditRemoteDialog(&r, EditRemoteDialog::RemoteAdd)) {
remote_changed = true;
}
}
void RepositoryPropertyDialog::on_pushButton_remote_edit_clicked()
{
Git::Remote remote = selectedRemote();
if (execEditRemoteDialog(&remote, EditRemoteDialog::RemoteSet)) {
remote_changed = true;
}
}
void RepositoryPropertyDialog::on_pushButton_remote_remove_clicked()
{
Git::Remote remote = selectedRemote();
if (!remote.name.isEmpty()) {
int r = QMessageBox::warning(this, tr("Confirm Remove"), tr("Are you sure you want to remove the remote '%1' from the repository '%2' ?").arg(remote.name).arg(repository.name), QMessageBox::Ok, QMessageBox::Cancel);
if (r == QMessageBox::Ok) {
GitPtr g = git();
g->removeRemote(remote.name);
updateRemotesTable();
remote_changed = true;
}
}
}
void RepositoryPropertyDialog::on_pushButton_remote_menu_clicked()
{
toggleRemoteMenuActivity();
}
diff --git a/src/RepositoryPropertyDialog.h b/src/RepositoryPropertyDialog.h
index b84af67..49067ad 100644
--- a/src/RepositoryPropertyDialog.h
+++ b/src/RepositoryPropertyDialog.h
@@ -1,39 +1,39 @@
#ifndef REPOSITORYPROPERTYDIALOG_H
#define REPOSITORYPROPERTYDIALOG_H
#include "RepositoryData.h"
#include "BasicRepositoryDialog.h"
#include "EditRemoteDialog.h"
#include <QDialog>
#include "Git.h"
+class BasicMainWindow;
namespace Ui {
class RepositoryPropertyDialog;
}
-class RepositoryPropertyDialog : public BasicRepositoryDialog
-{
+class RepositoryPropertyDialog : public BasicRepositoryDialog {
Q_OBJECT
private:
RepositoryItem repository;
bool remote_changed = false;
public:
- explicit RepositoryPropertyDialog(MainWindow *parent, GitPtr g, RepositoryItem const &item, bool open_repository_menu = false);
+ explicit RepositoryPropertyDialog(BasicMainWindow *parent, GitPtr g, RepositoryItem const &item, bool open_repository_menu = false);
~RepositoryPropertyDialog();
bool isRemoteChanged() const;
private slots:
void on_pushButton_remote_add_clicked();
void on_pushButton_remote_edit_clicked();
void on_pushButton_remote_remove_clicked();
void on_pushButton_remote_menu_clicked();
private:
Ui::RepositoryPropertyDialog *ui;
void updateRemotesTable();
bool execEditRemoteDialog(Git::Remote *remote, EditRemoteDialog::Operation op);
Git::Remote selectedRemote() const;
void toggleRemoteMenuActivity();
};
#endif // REPOSITORYPROPERTYDIALOG_H
diff --git a/src/SearchFromGitHubDialog.cpp b/src/SearchFromGitHubDialog.cpp
index 02ba15a..bf174e1 100644
--- a/src/SearchFromGitHubDialog.cpp
+++ b/src/SearchFromGitHubDialog.cpp
@@ -1,169 +1,169 @@
#include "SearchFromGitHubDialog.h"
#include "ui_SearchFromGitHubDialog.h"
#include "common/misc.h"
#include "urlencode.h"
#include "MainWindow.h"
#include <QDebug>
#include <QThread>
#include <QDesktopServices>
#include <QUrl>
#include <functional>
using SearchResultItem = GitHubAPI::SearchResultItem;
static QString toQString(std::string const &s)
{
return QString::fromUtf8(s.c_str(), s.size());
}
SearchFromGitHubDialog::SearchFromGitHubDialog(QWidget *parent, MainWindow *mw)
: QDialog(parent)
, ui(new Ui::SearchFromGitHubDialog)
, mainwindow(mw)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
ui->tableWidget->setItemDelegate(&item_delegate);
connect(ui->label_hyperlink, SIGNAL(clicked()), this, SLOT(onHyperlinkClicked()));
ui->pushButton_ok->setEnabled(false);
}
SearchFromGitHubDialog::~SearchFromGitHubDialog()
{
delete ui;
}
QString SearchFromGitHubDialog::url() const
{
return url_;
}
void SearchFromGitHubDialog::on_pushButton_search_clicked()
{
std::string q = ui->lineEdit_keywords->text().trimmed().toStdString();
q = url_encode(q);
if (q.empty()) return;
- GitHubAPI github(mainwindow->getWebContextPtr());
+ GitHubAPI github(mainwindow->webContext());
items = github.searchRepository(q);
QStringList cols = {
tr("Name"),
tr("Owner"),
tr("Score"),
tr("Description"),
};
ui->tableWidget->setColumnCount(cols.size());
ui->tableWidget->setRowCount(items.size());
for (int col = 0; col < cols.size(); col++) {
QTableWidgetItem *p = new QTableWidgetItem();
p->setText(cols[col]);
ui->tableWidget->setHorizontalHeaderItem(col, p);
}
for (int row = 0; row < items.size(); row++) {
SearchResultItem const &item = items[row];
QTableWidgetItem *p;
QString name = QString::fromStdString(item.full_name);
QString owner;
int i = name.indexOf('/');
if (i > 0) {
owner = name.mid(0, i);
name = name.mid(i + 1);
}
int col = 0;
auto AddItem = [&](std::function<void(QTableWidgetItem *)> callback){
p = new QTableWidgetItem();
callback(p);
ui->tableWidget->setItem(row, col, p);
col++;
};
AddItem([&](QTableWidgetItem *p){
p->setData(Qt::UserRole, (int)row);
p->setText(name);
});
AddItem([&](QTableWidgetItem *p){
p->setText(owner);
});
AddItem([&](QTableWidgetItem *p){
char tmp[100];
sprintf(tmp, "%.2f", item.score);
p->setText(tmp);
p->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
});
AddItem([&](QTableWidgetItem *p){
p->setText(toQString(item.description));
});
ui->tableWidget->setRowHeight(row, 24);
}
ui->tableWidget->resizeColumnsToContents();
ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
}
void SearchFromGitHubDialog::updateUI()
{
auto Check = [&](){
if (ui->radioButton_ssh->isChecked()) {
url_ = ui->lineEdit_ssh->text();
if (!url_.isEmpty()) {
return true;
}
}
if (ui->radioButton_http->isChecked()) {
url_ = ui->lineEdit_http->text();
if (!url_.isEmpty()) {
return true;
}
}
url_ = QString();
return false;
};
ui->pushButton_ok->setEnabled(Check());
}
void SearchFromGitHubDialog::on_tableWidget_currentItemChanged(QTableWidgetItem * /*current*/, QTableWidgetItem * /*previous*/)
{
int row = ui->tableWidget->currentRow();
QTableWidgetItem *p = ui->tableWidget->item(row, 0);
if (p) {
int i = p->data(Qt::UserRole).toInt();
if (i < items.size()) {
SearchResultItem const &item = items[i];
ui->lineEdit_ssh->setText(toQString(item.ssh_url));
ui->lineEdit_http->setText(toQString(item.clone_url));
ui->label_hyperlink->setText(toQString(item.html_url));
}
}
updateUI();
}
void SearchFromGitHubDialog::on_radioButton_ssh_clicked()
{
updateUI();
}
void SearchFromGitHubDialog::on_radioButton_http_clicked()
{
updateUI();
}
void SearchFromGitHubDialog::onHyperlinkClicked()
{
QString url = ui->label_hyperlink->text();
QDesktopServices::openUrl(QUrl(url));
}
diff --git a/src/SetUserDialog.cpp b/src/SetUserDialog.cpp
index 5530dde..e842daa 100644
--- a/src/SetUserDialog.cpp
+++ b/src/SetUserDialog.cpp
@@ -1,130 +1,130 @@
#include "AvatarLoader.h"
-#include "MainWindow.h"
+#include "BasicMainWindow.h"
#include "SetUserDialog.h"
#include "ui_SetUserDialog.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)
+SetUserDialog::SetUserDialog(BasicMainWindow *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()->webContext());
connect(&m->avatar_loader, &AvatarLoader::updated, [&](){
QString email = ui->lineEdit_mail->text();
QIcon icon = m->avatar_loader.fetch(email.toStdString(), false);
setAvatar(icon);
});
}
SetUserDialog::~SetUserDialog()
{
m->avatar_loader.stop();
delete m;
delete ui;
}
-MainWindow *SetUserDialog::mainwindow()
+BasicMainWindow *SetUserDialog::mainwindow()
{
- return qobject_cast<MainWindow *>(parent());
+ return qobject_cast<BasicMainWindow *>(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 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);
if (!icon.isNull()) {
setAvatar(icon);
}
}
}
diff --git a/src/SetUserDialog.h b/src/SetUserDialog.h
index 31c19a9..3f83a2f 100644
--- a/src/SetUserDialog.h
+++ b/src/SetUserDialog.h
@@ -1,45 +1,44 @@
#ifndef SETUSERDIALOG_H
#define SETUSERDIALOG_H
#include "Git.h"
#include <QDialog>
-class MainWindow;
+class BasicMainWindow;
namespace Ui {
class SetUserDialog;
}
-class SetUserDialog : public QDialog
-{
+class SetUserDialog : public QDialog {
Q_OBJECT
private:
struct Private;
Private *m;
public:
- explicit SetUserDialog(MainWindow *parent, const Git::User &global_user, const Git::User &repo_user, QString const &repo);
+ explicit SetUserDialog(BasicMainWindow *parent, const Git::User &global_user, const Git::User &repo_user, QString const &repo);
~SetUserDialog();
bool isGlobalChecked() const;
bool isRepositoryChecked() const;
Git::User user() const;
private slots:
void on_radioButton_global_toggled(bool checked);
void on_radioButton_repository_toggled(bool checked);
void on_lineEdit_name_textChanged(QString const &text);
void on_lineEdit_mail_textChanged(QString const &text);
void on_pushButton_get_icon_clicked();
private:
Ui::SetUserDialog *ui;
void setAvatar(QIcon icon);
- MainWindow *mainwindow();
+ BasicMainWindow *mainwindow();
};
#endif // SETUSERDIALOG_H
diff --git a/src/WelcomeWizardDialog.cpp b/src/WelcomeWizardDialog.cpp
index f634ba6..2af1a85 100644
--- a/src/WelcomeWizardDialog.cpp
+++ b/src/WelcomeWizardDialog.cpp
@@ -1,190 +1,190 @@
#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)
+WelcomeWizardDialog::WelcomeWizardDialog(BasicMainWindow *parent)
+ : QDialog(parent)
+ , ui(new Ui::WelcomeWizardDialog)
{
ui->setupUi(this);
Qt::WindowFlags flags = windowFlags();
flags &= ~Qt::WindowContextHelpButtonHint;
setWindowFlags(flags);
mainwindow_ = parent;
pages_.push_back(ui->page_helper_tools);
pages_.push_back(ui->page_global_user_information);
pages_.push_back(ui->page_default_working_folder);
pages_.push_back(ui->page_finish);
ui->stackedWidget->setCurrentWidget(pages_[0]);
on_stackedWidget_currentChanged(0);
avatar_loader_.start(mainwindow_->webContext());
connect(&avatar_loader_, &AvatarLoader::updated, [&](){
QString email = ui->lineEdit_user_email->text();
QIcon icon = avatar_loader_.fetch(email.toStdString(), false);
setAvatar(icon);
});
ui->lineEdit_user_name->setFocus();
}
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, QString());
Git::User user = g.getUser(Git::Source::Global);
set_user_name(user.name);
set_user_email(user.email);
}
} 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_prev->setText(prev_text.isEmpty() ? tr("<< Prev") : prev_text);
ui->pushButton_next->setText(next_text.isEmpty() ? tr("Next >>") : next_text);
ui->pushButton_next->setDefault(true);
}
void WelcomeWizardDialog::on_pushButton_browse_default_workiing_folder_clicked()
{
QString s = ui->lineEdit_default_working_folder->text();
s = QFileDialog::getExistingDirectory(this, tr("Default Working Folder"), s);
s = misc::normalizePathSeparator(s);
ui->lineEdit_default_working_folder->setText(s);
}
void WelcomeWizardDialog::on_pushButton_browse_git_clicked()
{
QString s = mainwindow_->selectGitCommand(false);
ui->lineEdit_git->setText(s);
}
void WelcomeWizardDialog::on_pushButton_browse_file_clicked()
{
QString s = mainwindow_->selectFileCommand(false);
ui->lineEdit_file->setText(s);
}
void WelcomeWizardDialog::setAvatar(QIcon const &icon)
{
QPixmap pm = icon.pixmap(QSize(64, 64));
ui->label_avatar->setPixmap(pm);
}
void WelcomeWizardDialog::on_pushButton_get_icon_clicked()
{
ui->label_avatar->setPixmap(QPixmap());
QString email = ui->lineEdit_user_email->text();
if (email.indexOf('@') > 0) {
QIcon icon = avatar_loader_.fetch(email.toStdString(), true);
if (!icon.isNull()) {
setAvatar(icon);
}
}
}
diff --git a/src/WelcomeWizardDialog.h b/src/WelcomeWizardDialog.h
index 27e32f2..2f68ec2 100644
--- a/src/WelcomeWizardDialog.h
+++ b/src/WelcomeWizardDialog.h
@@ -1,51 +1,50 @@
#ifndef WELCOMEWIZARDDIALOG_H
#define WELCOMEWIZARDDIALOG_H
#include "AvatarLoader.h"
#include <QDialog>
-class MainWindow;
+class BasicMainWindow;
namespace Ui {
class WelcomeWizardDialog;
}
-class WelcomeWizardDialog : public QDialog
-{
+class WelcomeWizardDialog : public QDialog {
Q_OBJECT
private:
- MainWindow *mainwindow_;
+ BasicMainWindow *mainwindow_;
AvatarLoader avatar_loader_;
QList<QWidget *> pages_;
public:
- explicit WelcomeWizardDialog(MainWindow *parent = 0);
+ explicit WelcomeWizardDialog(BasicMainWindow *parent = 0);
~WelcomeWizardDialog();
void set_user_name(QString const &v);
void set_user_email(QString const &v);
void set_default_working_folder(QString const &v);
void set_git_command_path(QString const &v);
void set_file_command_path(QString const &v);
QString user_name() const;
QString user_email() const;
QString default_working_folder() const;
QString git_command_path() const;
QString file_command_path() const;
private slots:
void on_stackedWidget_currentChanged(int arg1);
void on_pushButton_browse_default_workiing_folder_clicked();
void on_pushButton_browse_git_clicked();
void on_pushButton_browse_file_clicked();
void on_pushButton_get_icon_clicked();
void on_pushButton_prev_clicked();
void on_pushButton_next_clicked();
private:
Ui::WelcomeWizardDialog *ui;
void setAvatar(const QIcon &icon);
};
#endif // WELCOMEWIZARDDIALOG_H

File Metadata

Mime Type
text/x-diff
Expires
Tue, Jun 16, 12:08 AM (2 w, 2 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
71188
Default Alt Text
(300 KB)

Event Timeline