No OneTemporary
Actions

Size

133 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/Guitar.pro b/Guitar.pro
	index 05e6731..0a0563f 100644
	--- a/Guitar.pro
	+++ b/Guitar.pro
	@@ -1,466 +1,466 @@

	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++17 nostrip debug_info
	+CONFIG += c++1z nostrip debug_info

	DESTDIR = $$PWD/_bin

	TRANSLATIONS = $$PWD/src/resources/translations/Guitar_ja.ts
	TRANSLATIONS += $$PWD/src/resources/translations/Guitar_ru.ts
	TRANSLATIONS += $$PWD/src/resources/translations/Guitar_zh-CN.ts
	TRANSLATIONS += $$PWD/src/resources/translations/Guitar_zh-TW.ts

	DEFINES += APP_GUITAR

	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/coloredit
	INCLUDEPATH += $$PWD/src/texteditor
	win32:INCLUDEPATH += $$PWD/misc/winpty
	win32:LIBS += $$PWD/misc/winpty/winpty.lib

	# OpenSSL

	linux {
	static_link_openssl {
	LIBS += $$OPENSSL_LIB_DIR/libssl.a $$OPENSSL_LIB_DIR/libcrypto.a -ldl
	} else {
	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:\Program Files (x86)\OpenSSL\include"
	INCLUDEPATH += $$PWD/../zlib
	LIBS += "-LC:\Program Files (x86)\OpenSSL\lib"
	# OpenSSL 1.0
	# LIBS += -llibeay32 -lssleay32
	# OpenSSL 1.1
	LIBS += -llibcrypto -llibssl
	}

	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 {
	use_system_zlib {
	unix:LIBS += -lz
	} else {
	unix:CONFIG(debug, debug\|release):LIBS += $$PWD/_bin/libzd.a
	unix:CONFIG(release, debug\|release):LIBS += $$PWD/_bin/libz.a
	}
	}

	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 += src/resources/Guitar.icns
	t.path=Contents/Resources
	QMAKE_BUNDLE_DATA += t
	}

	SOURCES += \
	src/AboutDialog.cpp \
	src/AbstractProcess.cpp \
	src/AbstractSettingForm.cpp \
	src/ApplicationGlobal.cpp \
	src/AreYouSureYouWantToContinueConnectingDialog.cpp \
	src/AvatarLoader.cpp \
	src/BasicMainWindow.cpp \
	src/BasicRepositoryDialog.cpp \
	src/BigDiffWindow.cpp \
	src/BlameWindow.cpp \
	src/BranchLabel.cpp \
	src/CheckoutDialog.cpp \
	src/CherryPickDialog.cpp \
	src/ClearButton.cpp \
	src/CloneDialog.cpp \
	src/CloneFromGitHubDialog.cpp \
	src/ColorButton.cpp \
	src/CommitDialog.cpp \
	src/CommitExploreWindow.cpp \
	src/CommitPropertyDialog.cpp \
	src/CommitViewWindow.cpp \
	src/ConfigCredentialHelperDialog.cpp \
	src/ConfigSigningDialog.cpp \
	src/CreateRepositoryDialog.cpp \
	src/DeleteBranchDialog.cpp \
	src/DeleteTagsDialog.cpp \
	src/DialogHeaderFrame.cpp \
	src/DirectoryLineEdit.cpp \
	src/DoYouWantToInitDialog.cpp \
	src/EditGitIgnoreDialog.cpp \
	src/EditRemoteDialog.cpp \
	src/EditTagsDialog.cpp \
	src/ExperimentDialog.cpp \
	src/FileDiffSliderWidget.cpp \
	src/FileDiffWidget.cpp \
	src/FileHistoryWindow.cpp \
	src/FilePropertyDialog.cpp \
	src/FileUtil.cpp \
	src/FileViewWidget.cpp \
	src/FilesListWidget.cpp \
	src/FindCommitDialog.cpp \
	src/Git.cpp \
	src/GitDiff.cpp \
	src/GitHubAPI.cpp \
	src/GitObjectManager.cpp \
	src/GitPack.cpp \
	src/GitPackIdxV2.cpp \
	src/HyperLinkLabel.cpp \
	src/ImageViewWidget.cpp \
	src/InputNewTagDialog.cpp \
	src/JumpDialog.cpp \
	src/Languages.cpp \
	src/LineEditDialog.cpp \
	src/LocalSocketReader.cpp \
	src/LogTableWidget.cpp \
	src/MainWindow.cpp \
	src/MaximizeButton.cpp \
	src/MemoryReader.cpp \
	src/MenuButton.cpp \
	src/MergeDialog.cpp \
	src/MyImageViewWidget.cpp \
	src/MyProcess.cpp \
	src/MySettings.cpp \
	src/MyTableWidgetDelegate.cpp \
	src/MyTextEditorWidget.cpp \
	src/MyToolButton.cpp \
	src/ObjectBrowserDialog.cpp \
	src/Photoshop.cpp \
	src/PushDialog.cpp \
	src/ReadOnlyLineEdit.cpp \
	src/ReadOnlyPlainTextEdit.cpp \
	src/ReflogWindow.cpp \
	src/RemoteAdvancedOptionWidget.cpp \
	src/RemoteRepositoriesTableWidget.cpp \
	src/RepositoriesTreeWidget.cpp \
	src/RepositoryData.cpp \
	src/RepositoryInfoFrame.cpp \
	src/RepositoryLineEdit.cpp \
	src/RepositoryPropertyDialog.cpp \
	src/RepositoryWrapperFrame.cpp \
	src/SearchFromGitHubDialog.cpp \
	src/SelectCommandDialog.cpp \
	src/SelectGpgKeyDialog.cpp \
	src/SelectItemDialog.cpp \
	src/SetGlobalUserDialog.cpp \
	src/SetGpgSigningDialog.cpp \
	src/SetRemoteUrlDialog.cpp \
	src/SetUserDialog.cpp \
	src/SettingBehaviorForm.cpp \
	src/SettingExampleForm.cpp \
	src/SettingGeneralForm.cpp \
	src/SettingNetworkForm.cpp \
	src/SettingProgramsForm.cpp \
	src/SettingVisualForm.cpp \
	src/SettingsDialog.cpp \
	src/StatusLabel.cpp \
	src/SubmoduleAddDialog.cpp \
	src/SubmoduleMainWindow.cpp \
	src/SubmoduleUpdateDialog.cpp \
	src/SubmodulesDialog.cpp \
	src/Terminal.cpp \
	src/TextEditDialog.cpp \
	src/Theme.cpp \
	src/UserEvent.cpp \
	src/WelcomeWizardDialog.cpp \
	src/charvec.cpp \
	src/coloredit/ColorDialog.cpp \
	src/coloredit/ColorEditWidget.cpp \
	src/coloredit/ColorPreviewWidget.cpp \
	src/coloredit/ColorSlider.cpp \
	src/coloredit/ColorSquareWidget.cpp \
	src/coloredit/RingSlider.cpp \
	src/common/joinpath.cpp \
	src/common/misc.cpp \
	src/darktheme/DarkStyle.cpp \
	src/darktheme/NinePatch.cpp \
	src/darktheme/StandardStyle.cpp \
	src/darktheme/TraditionalWindowsStyleTreeControl.cpp \
	src/gpg.cpp \
	src/gunzip.cpp \
	src/main.cpp\
	src/texteditor/AbstractCharacterBasedApplication.cpp \
	src/texteditor/InputMethodPopup.cpp \
	src/texteditor/TextEditorTheme.cpp \
	src/texteditor/TextEditorWidget.cpp \
	src/texteditor/UnicodeWidth.cpp \
	src/texteditor/unicode.cpp \
	src/urlencode.cpp \
	src/webclient.cpp \

	HEADERS += \
	src/AboutDialog.h \
	src/AbstractProcess.h \
	src/AbstractSettingForm.h \
	src/ApplicationGlobal.h \
	src/AreYouSureYouWantToContinueConnectingDialog.h \
	src/AvatarLoader.h \
	src/BasicMainWindow.h \
	src/BasicRepositoryDialog.h \
	src/BigDiffWindow.h \
	src/BlameWindow.h \
	src/BranchLabel.h \
	src/CheckoutDialog.h \
	src/CherryPickDialog.h \
	src/ClearButton.h \
	src/CloneDialog.h \
	src/CloneFromGitHubDialog.h \
	src/ColorButton.h \
	src/CommitDialog.h \
	src/CommitExploreWindow.h \
	src/CommitPropertyDialog.h \
	src/CommitViewWindow.h \
	src/ConfigCredentialHelperDialog.h \
	src/ConfigSigningDialog.h \
	src/CreateRepositoryDialog.h \
	src/Debug.h \
	src/DeleteBranchDialog.h \
	src/DeleteTagsDialog.h \
	src/DialogHeaderFrame.h \
	src/DirectoryLineEdit.h \
	src/DoYouWantToInitDialog.h \
	src/EditGitIgnoreDialog.h \
	src/EditRemoteDialog.h \
	src/EditTagsDialog.h \
	src/ExperimentDialog.h \
	src/FileDiffSliderWidget.h \
	src/FileDiffWidget.h \
	src/FileHistoryWindow.h \
	src/FilePropertyDialog.h \
	src/FileUtil.h \
	src/FilesListWidget.h \
	src/FindCommitDialog.h \
	src/Git.h \
	src/GitDiff.h \
	src/GitHubAPI.h \
	src/GitObjectManager.h \
	src/GitPack.h \
	src/GitPackIdxV2.h \
	src/HyperLinkLabel.h \
	src/ImageViewWidget.h \
	src/InputNewTagDialog.h \
	src/JumpDialog.h \
	src/Languages.h \
	src/LineEditDialog.h \
	src/LocalSocketReader.h \
	src/LogTableWidget.h \
	src/MainWindow.h \
	src/MaximizeButton.h \
	src/MemoryReader.h \
	src/MenuButton.h \
	src/MergeDialog.h \
	src/MyImageViewWidget.h \
	src/MyProcess.h \
	src/MySettings.h \
	src/MyTableWidgetDelegate.h \
	src/MyTextEditorWidget.h \
	src/MyToolButton.h \
	src/ObjectBrowserDialog.h \
	src/Photoshop.h \
	src/PushDialog.h \
	src/ReadOnlyLineEdit.h \
	src/ReadOnlyPlainTextEdit.h \
	src/ReflogWindow.h \
	src/RemoteAdvancedOptionWidget.h \
	src/RemoteRepositoriesTableWidget.h \
	src/RepositoriesTreeWidget.h \
	src/RepositoryData.h \
	src/RepositoryInfoFrame.h \
	src/RepositoryLineEdit.h \
	src/RepositoryPropertyDialog.h \
	src/RepositoryWrapperFrame.h \
	src/SaturationBrightnessWidget.h \
	src/SearchFromGitHubDialog.h \
	src/SelectCommandDialog.h \
	src/SelectGpgKeyDialog.h \
	src/SelectItemDialog.h \
	src/SetGlobalUserDialog.h \
	src/SetGpgSigningDialog.h \
	src/SetRemoteUrlDialog.h \
	src/SetUserDialog.h \
	src/SettingBehaviorForm.h \
	src/SettingExampleForm.h \
	src/SettingGeneralForm.h \
	src/SettingNetworkForm.h \
	src/SettingProgramsForm.h \
	src/SettingVisualForm.h \
	src/SettingsDialog.h \
	src/StatusLabel.h \
	src/SubmoduleAddDialog.h \
	src/SubmoduleMainWindow.h \
	src/SubmoduleUpdateDialog.h \
	src/SubmodulesDialog.h \
	src/Terminal.h \
	src/TextEditDialog.h \
	src/Theme.h \
	src/UserEvent.h \
	src/WelcomeWizardDialog.h \
	src/charvec.h \
	src/coloredit/ColorDialog.h \
	src/coloredit/ColorEditWidget.h \
	src/coloredit/ColorPreviewWidget.h \
	src/coloredit/ColorSlider.h \
	src/coloredit/ColorSquareWidget.h \
	src/coloredit/RingSlider.h \
	src/common/joinpath.h \
	src/common/misc.h \
	src/darktheme/DarkStyle.h \
	src/darktheme/NinePatch.h \
	src/darktheme/StandardStyle.h \
	src/darktheme/TraditionalWindowsStyleTreeControl.h \
	src/gpg.h \
	src/gunzip.h \
	src/main.h \
	src/platform.h \
	src/texteditor/AbstractCharacterBasedApplication.h \
	src/texteditor/InputMethodPopup.h \
	src/texteditor/TextEditorTheme.h \
	src/texteditor/TextEditorWidget.h \
	src/texteditor/UnicodeWidth.h \
	src/texteditor/unicode.h \
	src/urlencode.h \
	src/webclient.h

	HEADERS += src/version.h

	FORMS += \
	src/AboutDialog.ui \
	src/AreYouSureYouWantToContinueConnectingDialog.ui \
	src/BigDiffWindow.ui \
	src/BlameWindow.ui \
	src/CheckoutDialog.ui \
	src/CherryPickDialog.ui \
	src/CloneDialog.ui \
	src/CloneFromGitHubDialog.ui \
	src/CommitDialog.ui \
	src/CommitExploreWindow.ui \
	src/CommitPropertyDialog.ui \
	src/CommitViewWindow.ui \
	src/ConfigCredentialHelperDialog.ui \
	src/ConfigSigningDialog.ui \
	src/CreateRepositoryDialog.ui \
	src/DeleteBranchDialog.ui \
	src/DeleteTagsDialog.ui \
	src/DoYouWantToInitDialog.ui \
	src/EditGitIgnoreDialog.ui \
	src/EditRemoteDialog.ui \
	src/EditTagsDialog.ui \
	src/ExperimentDialog.ui \
	src/FileDiffWidget.ui \
	src/FileHistoryWindow.ui \
	src/FilePropertyDialog.ui \
	src/FindCommitDialog.ui \
	src/InputNewTagDialog.ui \
	src/JumpDialog.ui \
	src/LineEditDialog.ui \
	src/MainWindow.ui \
	src/MergeDialog.ui \
	src/ObjectBrowserDialog.ui \
	src/PushDialog.ui \
	src/ReflogWindow.ui \
	src/RemoteAdvancedOptionWidget.ui \
	src/RepositoryPropertyDialog.ui \
	src/SearchFromGitHubDialog.ui \
	src/SelectCommandDialog.ui \
	src/SelectGpgKeyDialog.ui \
	src/SelectItemDialog.ui \
	src/SetGlobalUserDialog.ui \
	src/SetGpgSigningDialog.ui \
	src/SetRemoteUrlDialog.ui \
	src/SetUserDialog.ui \
	src/SettingBehaviorForm.ui \
	src/SettingExampleForm.ui \
	src/SettingGeneralForm.ui \
	src/SettingNetworkForm.ui \
	src/SettingProgramsForm.ui \
	src/SettingVisualForm.ui \
	src/SettingsDialog.ui \
	src/SubmoduleAddDialog.ui \
	src/SubmoduleMainWindow.ui \
	src/SubmoduleUpdateDialog.ui \
	src/SubmodulesDialog.ui \
	src/TextEditDialog.ui \
	src/WelcomeWizardDialog.ui \
	src/coloredit/ColorDialog.ui \
	src/coloredit/ColorEditWidget.ui

	RESOURCES += \
	src/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/Win32Process.cpp \
	src/win32/Win32PtyProcess.cpp \
	src/win32/event.cpp \
	src/win32/thread.cpp \
	src/win32/win32.cpp

	HEADERS += \
	src/win32/Win32Process.h \
	src/win32/Win32PtyProcess.h \
	src/win32/event.h \
	src/win32/mutex.h \
	src/win32/thread.h \
	src/win32/win32.h
	}


	diff --git a/src/ImageViewWidget.cpp b/src/ImageViewWidget.cpp
	index 373ee27..e11f540 100644
	--- a/src/ImageViewWidget.cpp
	+++ b/src/ImageViewWidget.cpp
	@@ -1,373 +1,373 @@

	#include "ImageViewWidget.h"
	#include "FileDiffSliderWidget.h"
	#include "FileDiffWidget.h"
	#include "MainWindow.h"
	#include "MemoryReader.h"
	#include "Photoshop.h"
	#include "charvec.h"
	#include "common/joinpath.h"
	#include "common/misc.h"
	#include <QBuffer>
	#include <QDebug>
	#include <QFileDialog>
	#include <QMenu>
	#include <QPainter>
	#include <QSvgRenderer>
	#include <QWheelEvent>
	#include <cmath>
	#include <functional>
	#include <memory>

	using SvgRendererPtr = std::shared_ptr<QSvgRenderer>;

	struct ImageViewWidget::Private {
	QMainWindow *mainwindow = nullptr;
	FileDiffWidget *filediffwidget = nullptr;
	// FileDiffWidget::DrawData *draw_data = nullptr;
	QScrollBar *v_scroll_bar = nullptr;
	QScrollBar *h_scroll_bar = nullptr;
	QString mime_type;

	QPixmap pixmap;
	SvgRendererPtr svg;

	double image_scroll_x = 0;
	double image_scroll_y = 0;
	double image_scale = 1;
	double scroll_origin_x = 0;
	double scroll_origin_y = 0;
	QPoint mouse_press_pos;
	int wheel_delta = 0;
	QPointF interest_pos;
	int top_margin = 1;
	int bottom_margin = 1;
	bool draw_left_border = true;

	#ifndef APP_GUITAR
	QPixmap transparent_pixmap;
	#endif
	};

	ImageViewWidget::ImageViewWidget(QWidget *parent)
	: QWidget(parent)
	, m(new Private)
	{
	#if defined(Q_OS_WIN32)
	setFont(QFont("MS Gothic"));
	#elif defined(Q_OS_LINUX)
	setFont(QFont("Monospace"));
	#elif defined(Q_OS_MAC)
	setFont(QFont("Menlo"));
	#endif

	setContextMenuPolicy(Qt::DefaultContextMenu);
	}

	ImageViewWidget::~ImageViewWidget()
	{
	delete m;
	}

	void ImageViewWidget::bind(QMainWindow mainwindow, FileDiffWidget filediffwidget, QScrollBar vsb, QScrollBar hsb)
	{
	m->mainwindow = mainwindow;
	m->filediffwidget = filediffwidget;
	m->v_scroll_bar = vsb;
	m->h_scroll_bar = hsb;
	}

	bool ImageViewWidget::hasFocus() const
	{
	QWidget *w = qApp->focusWidget();
	return w && w != m->filediffwidget && w->isAncestorOf(this);
	}

	void ImageViewWidget::setLeftBorderVisible(bool f)
	{
	m->draw_left_border = f;
	}

	void ImageViewWidget::internalScrollImage(double x, double y)
	{
	m->image_scroll_x = x;
	m->image_scroll_y = y;
	QSizeF sz = imageScrollRange();
	if (m->image_scroll_x < 0) m->image_scroll_x = 0;
	if (m->image_scroll_y < 0) m->image_scroll_y = 0;
	if (m->image_scroll_x > sz.width()) m->image_scroll_x = sz.width();
	if (m->image_scroll_y > sz.height()) m->image_scroll_y = sz.height();
	update();
	}

	void ImageViewWidget::scrollImage(double x, double y)
	{
	internalScrollImage(x, y);

	if (m->h_scroll_bar) {
	m->h_scroll_bar->blockSignals(true);
	m->h_scroll_bar->setValue((int)m->image_scroll_x);
	m->h_scroll_bar->blockSignals(false);
	}
	if (m->v_scroll_bar) {
	m->v_scroll_bar->blockSignals(true);
	m->v_scroll_bar->setValue((int)m->image_scroll_y);
	m->v_scroll_bar->blockSignals(false);
	}
	}

	void ImageViewWidget::refrectScrollBar()
	{
	double e = 0.75;
	double x = m->h_scroll_bar->value();
	double y = m->v_scroll_bar->value();
	if (fabs(x - m->image_scroll_x) < e) x = m->image_scroll_x; // 差が小さいときは値を維持する
	if (fabs(y - m->image_scroll_y) < e) y = m->image_scroll_y;
	internalScrollImage(x, y);
	}

	void ImageViewWidget::clear()
	{
	m->mime_type = QString();
	m->pixmap = QPixmap();
	setMouseTracking(false);
	update();
	}

	QString ImageViewWidget::formatText(Document::Line const &line)
	{
	QByteArray const &ba = line.text;
	if (ba.isEmpty()) return QString();
	std::vector<char> vec;
	vec.reserve(ba.size() + 100);
	char const *begin = ba.data();
	char const *end = begin + ba.size();
	char const *ptr = begin;
	int x = 0;
	while (ptr < end) {
	if (*ptr == '\t') {
	do {
	vec.push_back(' ');
	x++;
	} while ((x % 4) != 0);
	ptr++;
	} else {
	vec.push_back(*ptr);
	ptr++;
	x++;
	}
	}
	return QString::fromUtf8(&vec[0], vec.size());
	}

	QSizeF ImageViewWidget::imageScrollRange() const
	{
	QSize sz = imageSize();
	int w = int(sz.width() * m->image_scale);
	int h = int(sz.height() * m->image_scale);
	return QSize(w, h);
	}

	void ImageViewWidget::setScrollBarRange(QScrollBar h, QScrollBar v)
	{
	h->blockSignals(true);
	v->blockSignals(true);
	QSizeF sz = imageScrollRange();
	h->setRange(0, (int)sz.width());
	v->setRange(0, (int)sz.height());
	h->setPageStep(width());
	v->setPageStep(height());
	h->blockSignals(false);
	v->blockSignals(false);
	}

	void ImageViewWidget::updateScrollBarRange()
	{
	setScrollBarRange(m->h_scroll_bar, m->v_scroll_bar);
	}

	QMainWindow *ImageViewWidget::mainwindow()
	{
	return m->mainwindow;
	}

	QBrush ImageViewWidget::getTransparentBackgroundBrush()
	{
	#ifdef APP_GUITAR
	return qobject_cast<MainWindow *>(mainwindow())->getTransparentPixmap();
	#else
	if (m->transparent_pixmap.isNull()) {
	m->transparent_pixmap = QPixmap(":/image/transparent.png");
	}
	return m->transparent_pixmap;
	#endif
	}

	bool ImageViewWidget::isValidImage() const
	{
	return !m->pixmap.isNull() \|\| (m->svg && m->svg->isValid());
	}

	QSize ImageViewWidget::imageSize() const
	{
	if (!m->pixmap.isNull()) return m->pixmap.size();
	if (m->svg && m->svg->isValid()) return m->svg->defaultSize();
	return QSize();
	}

	void ImageViewWidget::paintEvent(QPaintEvent *)
	{
	QPainter pr(this);

	QSize imagesize = imageSize();
	if (imagesize.width() > 0 && imagesize.height() > 0) {
	pr.save();
	if (!m->draw_left_border) {
	pr.setClipRect(1, 0, width() - 1, height());
	}
	double cx = width() / 2.0;
	double cy = height() / 2.0;
	double x = cx - m->image_scroll_x;
	double y = cy - m->image_scroll_y;
	QSizeF sz = imageScrollRange();
	if (sz.width() > 0 && sz.height() > 0) {
	QBrush br = getTransparentBackgroundBrush();
	pr.setBrushOrigin((int)x, (int)y);
	pr.fillRect((int)x, (int)y, (int)sz.width(), (int)sz.height(), br);
	if (!m->pixmap.isNull()) {
	pr.drawPixmap((int)x, (int)y, (int)sz.width(), (int)sz.height(), m->pixmap, 0, 0, imagesize.width(), imagesize.height());
	} else if (m->svg && m->svg->isValid()) {
	m->svg->render(&pr, QRectF(x, y, sz.width(), sz.height()));
	}
	}
	misc::drawFrame(&pr, (int)x - 1, (int)y - 1, (int)sz.width() + 2, (int)sz.height() + 2, Qt::black);
	pr.restore();
	}

	if (m->draw_left_border) {
	pr.fillRect(0, 0, 1, height(), QColor(160, 160, 160));
	}

	if (hasFocus()) {
	misc::drawFrame(&pr, 0, 0, width(), height(), QColor(0, 128, 255, 128));
	misc::drawFrame(&pr, 1, 1, width() - 2, height() - 2, QColor(0, 128, 255, 64));
	}
	}

	void ImageViewWidget::resizeEvent(QResizeEvent *)
	{
	updateScrollBarRange();
	}

	void ImageViewWidget::setImage(QString mimetype, QByteArray const &ba)
	{
	if (mimetype.isEmpty()) {
	mimetype = "image/x-unknown";
	}

	setMouseTracking(true);

	m->pixmap = QPixmap();
	m->svg = SvgRendererPtr();
	if (!ba.isEmpty()) {
	if (misc::isSVG(mimetype)) {
	m->svg = std::make_shared<QSvgRenderer>(ba);
	} else if (misc::isPSD(mimetype)) {
	if (!ba.isEmpty()) {
	MemoryReader reader(ba.data(), ba.size());
	if (reader.open(QIODevice::ReadOnly)) {
	std::vector<char> jpeg;
	photoshop::readThumbnail(&reader, &jpeg);
	if (!jpeg.empty()) {
	m->pixmap.loadFromData((uchar const *)&jpeg[0], jpeg.size());
	}
	}
	}
	} else {
	m->pixmap.loadFromData(ba);
	}
	}
	QSize sz = imageSize();
	double sx = sz.width();
	double sy = sz.height();
	if (sx > 0 && sy > 0) {
	sx = width() / sx;
	sy = height() / sy;
	m->image_scale = (sx < sy ? sx : sy) * 0.9;
	}
	updateScrollBarRange();

	m->h_scroll_bar->blockSignals(true);
	m->v_scroll_bar->blockSignals(true);
	m->h_scroll_bar->setValue(m->h_scroll_bar->maximum() / 2);
	m->v_scroll_bar->setValue(m->v_scroll_bar->maximum() / 2);
	m->h_scroll_bar->blockSignals(false);
	m->v_scroll_bar->blockSignals(false);
	refrectScrollBar();
	}

	void ImageViewWidget::mousePressEvent(QMouseEvent *e)
	{
	if (e->button() == Qt::LeftButton) {
	QPoint pos = mapFromGlobal(QCursor::pos());
	m->mouse_press_pos = pos;
	m->scroll_origin_x = m->image_scroll_x;
	m->scroll_origin_y = m->image_scroll_y;
	}
	}

	void ImageViewWidget::mouseMoveEvent(QMouseEvent *e)
	{
	if (isValidImage()) {
	QPoint pos = mapFromGlobal(QCursor::pos());
	if ((e->buttons() & Qt::LeftButton) && hasFocus()) {
	int delta_x = pos.x() - m->mouse_press_pos.x();
	int delta_y = pos.y() - m->mouse_press_pos.y();
	scrollImage(m->scroll_origin_x - delta_x, m->scroll_origin_y - delta_y);
	}
	double cx = width() / 2.0;
	double cy = height() / 2.0;
	double x = (pos.x() + 0.5 - cx + m->image_scroll_x) / m->image_scale;
	double y = (pos.y() + 0.5 - cy + m->image_scroll_y) / m->image_scale;
	m->interest_pos = QPointF(x, y);
	m->wheel_delta = 0;
	}
	}

	void ImageViewWidget::setImageScale(double scale)
	{
	if (scale < 1 / 32.0) scale = 1 / 32.0;
	if (scale > 32) scale = 32;
	m->image_scale = scale;
	}

	void ImageViewWidget::wheelEvent(QWheelEvent *e)
	{
	if (isValidImage()) {
	double scale = 1;
	const double mul = 1.189207115; // sqrt(sqrt(2))
	- m->wheel_delta += e->delta();
	+ m->wheel_delta += e->angleDelta().y();
	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/JumpDialog.h b/src/JumpDialog.h
	index 8a9d418..046cb6c 100644
	--- a/src/JumpDialog.h
	+++ b/src/JumpDialog.h
	@@ -1,35 +1,33 @@
	#ifndef JUMPDIALOG_H
	#define JUMPDIALOG_H

	#include "MyTableWidgetDelegate.h"
	#include "Git.h"
	#include <QDialog>

	namespace Ui {
	class JumpDialog;
	}

	class QTableWidgetItem;

	class JumpDialog : public QDialog {
	Q_OBJECT
	-public:
	private:
	+ Ui::JumpDialog *ui;
	struct Private;
	Private *m;
	+ void updateTable();
	+ void internalUpdateTable(const NamedCommitList &list2);
	public:
	explicit JumpDialog(QWidget *parent, NamedCommitList const &items);
	~JumpDialog() override;
	QString text() const;
	static void sort(NamedCommitList *items);
	private slots:
	void on_toolButton_clicked();
	void on_lineEdit_filter_textChanged(QString const &text);
	void on_tableWidget_currentItemChanged(QTableWidgetItem current, QTableWidgetItem previous);
	-private:
	- Ui::JumpDialog *ui;
	- void updateTable();
	- void internalUpdateTable(const NamedCommitList &list2);
	};

	#endif // JUMPDIALOG_H
	diff --git a/src/MainWindow.h b/src/MainWindow.h
	index 6686ce9..94baf1f 100644
	--- a/src/MainWindow.h
	+++ b/src/MainWindow.h
	@@ -1,574 +1,574 @@
	#ifndef MAINWINDOW_H
	#define MAINWINDOW_H

	#include "BasicMainWindow.h"
	#include "Git.h"

	#include "GitHubAPI.h"
	#include "RepositoryData.h"
	#include "MyProcess.h"
	#include "main.h"
	#include "webclient.h"
	#include "AvatarLoader.h"
	#include "GitObjectManager.h"
	#include "Theme.h"
	#include "BranchLabel.h"

	class RepositoryWrapperFrame;
	class LogTableWidget;
	class QListWidgetItem;
	class QListWidget;
	class QTreeWidgetItem;
	class QTableWidgetItem;

	namespace Ui {
	class MainWindow;
	}


	class HunkItem {
	public:
	int hunk_number = -1;
	size_t pos, len;
	std::vector<std::string> lines;
	};

	class MainWindow : public BasicMainWindow {
	Q_OBJECT
	friend class RepositoryWrapperFrame;
	friend class SubmoduleMainWindow;
	friend class ImageViewWidget;
	friend class FileDiffSliderWidget;
	friend class FileHistoryWindow;
	friend class FileDiffWidget;
	friend class AboutDialog;
	private:
	struct Private1 {

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

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

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

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

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

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

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

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

	WebContext webcx;

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

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

	QString repository_filter_text;
	bool uncommited_changes = false;

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

	bool remote_changed = false;

	ServerType server_type = ServerType::Standard;
	GitHubRepositoryInfo github;

	QString head_id;
	bool force_fetch = false;

	RepositoryItem temp_repo_for_clone_complete;
	QVariant pty_process_completion_data;
	};
	Private1 *m1;

	struct Private2;
	Private2 *m2;

	struct ObjectData {
	QString id;
	QString path;
	Git::SubmoduleItem submod;
	Git::CommitItem submod_commit;
	QString header;
	int idiff;
	};

	public:
	explicit MainWindow(QWidget *parent = nullptr);
	~MainWindow() override;

	RepositoryWrapperFrame *frame();
	RepositoryWrapperFrame const *frame() const;

	QPixmap const &digitsPixmap() const;

	// QString currentWorkingCopyDir() const override;

	QColor color(unsigned int i);

	bool isOnlineMode() const;
	private:
	Ui::MainWindow *ui;

	void postEvent(QObject receiver, QEvent event, int ms_later);
	void postUserFunctionEvent(const std::function<void (const QVariant &, void )> &fn, QVariant const &v = QVariant(), void p = nullptr, int ms_later = 0);

	void updateFilesList(RepositoryWrapperFrame *frame, QString id, bool wait);
	void updateFilesList(RepositoryWrapperFrame *frame, Git::CommitItem const &commit, bool wait);
	void updateRepositoriesList();

	void openRepository_(GitPtr g, bool keep_selection = false);
	void openRepository_(RepositoryWrapperFrame *frame, GitPtr g, bool keep_selection = false);

	// void prepareLogTableWidget(RepositoryWrapperFrame *frame);
	QStringList selectedFiles_(QListWidget *listwidget) const;
	QStringList selectedFiles() const;
	void for_each_selected_files(std::function<void (QString const &)> const &fn);
	void showFileList(FilesListType files_list_type);

	void clearLog(RepositoryWrapperFrame *frame);
	void clearFileList(RepositoryWrapperFrame *frame);
	void clearDiffView(RepositoryWrapperFrame *frame);
	void clearRepositoryInfo();

	int repositoryIndex_(const QTreeWidgetItem *item) const;
	RepositoryItem const repositoryItem(const QTreeWidgetItem item) const;

	QTreeWidgetItem *newQTreeWidgetFolderItem(QString const &name);
	void buildRepoTree(QString const &group, QTreeWidgetItem item, QList<RepositoryItem> repos);
	void refrectRepositories();

	void updateDiffView(RepositoryWrapperFrame frame, QListWidgetItem item);
	void updateDiffView(RepositoryWrapperFrame *frame);
	void updateUnstagedFileCurrentItem(RepositoryWrapperFrame *frame);
	void updateStagedFileCurrentItem(RepositoryWrapperFrame *frame);
	void updateStatusBarText(RepositoryWrapperFrame *frame);
	void setRepositoryInfo(QString const &reponame, QString const &brname);
	int indexOfRepository(const QTreeWidgetItem *treeitem) const;
	void clearRepoFilter();
	void appendCharToRepoFilter(ushort c);
	void backspaceRepoFilter();
	void revertCommit(RepositoryWrapperFrame *frame);
	void mergeBranch(const QString &commit, Git::MergeFastForward ff);
	void mergeBranch(Git::CommitItem const *commit, Git::MergeFastForward ff);
	void rebaseBranch(Git::CommitItem const *commit);
	void cherrypick(Git::CommitItem const *commit);
	void merge(RepositoryWrapperFrame frame, const Git::CommitItem commit = nullptr);
	void detectGitServerType(const GitPtr &g);
	void setRemoteOnline(bool f, bool save);
	void startTimers();
	void onCloneCompleted(bool success, const QVariant &userdata);
	void setNetworkingCommandsEnabled(bool enabled);
	void blame(QListWidgetItem *item);
	void blame();
	QListWidgetItem *currentFileItem() const;
	void execAreYouSureYouWantToContinueConnectingDialog();
	void deleteRemoteBranch(Git::CommitItem const *commit);
	QStringList remoteBranches(QString const &id, QStringList *all);
	bool isUninitialized();
	void doLogCurrentItemChanged(RepositoryWrapperFrame *frame);
	void findNext(RepositoryWrapperFrame *frame);
	void findText(const QString &text);
	void showStatus();
	void onStartEvent();
	void showLogWindow(bool show);
	QString getObjectID(QListWidgetItem *item);
	bool isValidRemoteURL(const QString &url, const QString &sshkey);
	QStringList whichCommand_(const QString &cmdfile1, const QString &cmdfile2 = {});
	QString selectCommand_(const QString &cmdname, const QStringList &cmdfiles, const QStringList &list, QString path, const std::function<void (const QString &)> &callback);
	QString selectCommand_(const QString &cmdname, const QString &cmdfile, const QStringList &list, const QString &path, const std::function<void (const QString &)> &callback);
	const RepositoryItem findRegisteredRepository(QString workdir) const;
	static bool git_callback(void cookie, const char ptr, int len);
	bool execSetGlobalUserDialog();
	void revertAllFiles();
	void addWorkingCopyDir(QString dir, QString name, bool open);
	bool execWelcomeWizardDialog();
	void execRepositoryPropertyDialog(const RepositoryItem &repo, bool open_repository_menu = false);
	void execSetUserDialog(const Git::User &global_user, const Git::User &repo_user, const QString &reponame);
	void setGitCommand(QString path, bool save);
	void setFileCommand(QString path, bool save);
	void setGpgCommand(QString path, bool save);
	void setSshCommand(QString path, bool save);
	bool checkGitCommand();
	bool checkFileCommand();
	bool saveBlobAs(const QString &id, const QString &dstpath);
	bool saveByteArrayAs(const QByteArray &ba, const QString &dstpath);
	static QString makeRepositoryName(const QString &loc);
	bool saveFileAs(const QString &srcpath, const QString &dstpath);
	QString saveAsTemp(const QString &id);
	QString executableOrEmpty(const QString &path);
	bool checkExecutable(const QString &path);
	void internalSaveCommandPath(const QString &path, bool save, const QString &name);
	void logGitVersion();
	void internalClearRepositoryInfo();
	void checkUser();
	void openRepository(bool validate, bool waitcursor = true, bool keep_selection = false);
	void updateRepository();
	void reopenRepository(bool log, const std::function<void (const GitPtr &)> &callback);
	void setCurrentRepository(const RepositoryItem &repo, bool clear_authentication);
	void openSelectedRepository();
	QList<Git::Diff> makeDiffs(QString id, bool *ok);
	void queryBranches(const GitPtr &g);
	void updateRemoteInfo();
	void queryRemotes(const GitPtr &g);
	void clone(QString url = {}, QString dir = {});
	void submodule_add(QString url = {}, QString local_dir = {});
	const Git::CommitItem selectedCommitItem(RepositoryWrapperFrame frame) const;
	void commit(RepositoryWrapperFrame *frame, bool amend = false);
	void commitAmend(RepositoryWrapperFrame *framae);
	void pushSetUpstream(const QString &remote, const QString &branch);
	bool pushSetUpstream(bool testonly);
	void push();
	void deleteBranch(const Git::CommitItem *commit);
	void deleteBranch(RepositoryWrapperFrame *frame);
	void resetFile(const QStringList &paths);
	void clearAuthentication();
	void clearSshAuthentication();
	void internalDeleteTags(const QStringList &tagnames);
	bool internalAddTag(RepositoryWrapperFrame *frame, const QString &name);
	void createRepository(const QString &dir);
	void setLogEnabled(const GitPtr &g, bool f);
	void doGitCommand(const std::function<void (GitPtr)> &callback);
	void setWindowTitle_(const Git::User &user);
	void setUnknownRepositoryInfo();
	void setCurrentRemoteName(const QString &name);
	void deleteTags(RepositoryWrapperFrame *frame, const Git::CommitItem &commit);
	bool isAvatarEnabled() const;
	bool isGitHub() const;
	QStringList remotes() const;
	QList<Git::Branch> findBranch(const QString &id);
	QString tempfileHeader() const;
	void deleteTempFiles();
	QString getCommitIdFromTag(const QString &tag);
	QString newTempFilePath();
	int limitLogCount() const;
	Git::Object cat_file_(const GitPtr &g, const QString &id);
	bool isThereUncommitedChanges() const;
	static void addDiffItems(const QList<Git::Diff> *diff_list, const std::function<void (const ObjectData &)> &add_item);
	Git::CommitItemList retrieveCommitLog(const GitPtr &g);
	std::map<QString, QList<Git::Branch> > &branchMapRef();
	void updateCommitLogTableLater(RepositoryWrapperFrame *frame, int ms_later);
	void updateWindowTitle(const GitPtr &g);
	QString makeCommitInfoText(RepositoryWrapperFrame frame, int row, QList<BranchLabel> label_list);
	void removeRepositoryFromBookmark(int index, bool ask);
	void openTerminal(const RepositoryItem *repo);
	void openExplorer(const RepositoryItem *repo);
	bool askAreYouSureYouWantToRun(const QString &title, const QString &command);
	bool editFile(const QString &path, const QString &title);
	void setAppSettings(const ApplicationSettings &appsettings);
	QIcon getRepositoryIcon() const;
	QIcon getFolderIcon() const;
	QIcon getSignatureGoodIcon() const;
	QIcon getSignatureDubiousIcon() const;
	QIcon getSignatureBadIcon() const;
	QPixmap getTransparentPixmap() const;
	QStringList findGitObject(const QString &id) const;
	void writeLog(const char *ptr, int len);
	void writeLog(const QString &str);
	QList<BranchLabel> sortedLabels(int row) const;
	void saveApplicationSettings();
	void loadApplicationSettings();
	void setDiffResult(const QList<Git::Diff> &diffs);
	const QList<Git::SubmoduleItem> &submodules() const;
	void setSubmodules(const QList<Git::SubmoduleItem> &submodules);
	bool runOnRepositoryDir(const std::function<void (QString)> &callback, const RepositoryItem *repo);
	NamedCommitList namedCommitItems(int flags);
	static QString getFilePath(QListWidgetItem *item);
	static bool isGroupItem(QTreeWidgetItem *item);
	static int indexOfLog(QListWidgetItem *item);
	static int indexOfDiff(QListWidgetItem *item);
	static int getHunkIndex(QListWidgetItem *item);
	static void updateSubmodules(GitPtr g, const QString &id, QList<Git::SubmoduleItem> *out);
	void saveRepositoryBookmark(RepositoryItem item);
	int rowFromCommitId(RepositoryWrapperFrame *frame, const QString &id);
	QList<Git::Tag> findTag(const QString &id);
	void sshSetPassphrase(const std::string &user, const std::string &pass);
	std::string sshPassphraseUser() const;
	std::string sshPassphrasePass() const;
	void httpSetAuthentication(const std::string &user, const std::string &pass);
	std::string httpAuthenticationUser() const;
	std::string httpAuthenticationPass() const;
	// const Git::CommitItemList &getLogs() const;
	const Git::CommitItem getLog(RepositoryWrapperFrame const frame, int index) const;
	void updateCommitGraph(RepositoryWrapperFrame *frame);
	void initNetworking();
	bool saveRepositoryBookmarks() const;
	QString getBookmarksFilePath() const;
	void stopPtyProcess();
	void abortPtyProcess();
	Git::CommitItemList getLogsPtr(RepositoryWrapperFrame frame);
	void setLogs(RepositoryWrapperFrame *frame, const Git::CommitItemList &logs);
	void clearLogs(RepositoryWrapperFrame *frame);
	PtyProcess *getPtyProcess();
	bool getPtyProcessOk() const;
	BasicMainWindow::PtyCondition getPtyCondition();
	void setPtyUserData(const QVariant &userdata);
	void setPtyProcessOk(bool pty_process_ok);
	bool fetch(const GitPtr &g, bool prune);
	bool fetch_tags_f(const GitPtr &g);
	void setPtyCondition(const PtyCondition &ptyCondition);
	const QList<RepositoryItem> &getRepos() const;
	QList<RepositoryItem> *getReposPtr();
	AvatarLoader *getAvatarLoader();
	const AvatarLoader *getAvatarLoader() const;
	// int *ptrUpdateFilesListCounter();
	// int *ptrUpdateCommitTableCounter();
	bool interactionCanceled() const;
	void setInteractionCanceled(bool canceled);
	BasicMainWindow::InteractionMode interactionMode() const;
	void setInteractionMode(const InteractionMode &im);
	QString getRepositoryFilterText() const;
	void setRepositoryFilterText(const QString &text);
	void setUncommitedChanges(bool uncommited_changes);
	QList<Git::Diff> *diffResult();
	std::map<QString, Git::Diff> *getDiffCacheMap();
	bool getRemoteChanged() const;
	void setRemoteChanged(bool remote_changed);
	void setServerType(const ServerType &server_type);
	GitHubRepositoryInfo *ptrGitHub();
	std::map<int, QList<BranchLabel> > *getLabelMap();
	const std::map<int, QList<BranchLabel> > *getLabelMap() const;
	void clearLabelMap();
	GitObjectCache *getObjCache();
	bool getForceFetch() const;
	void setForceFetch(bool force_fetch);
	std::map<QString, QList<Git::Tag> > *ptrTagMap();
	QString getHeadId() const;
	void setHeadId(const QString &head_id);
	void setPtyProcessCompletionData(const QVariant &value);
	const QVariant &getTempRepoForCloneCompleteV() const;
	void msgNoRepositorySelected();
	bool isRepositoryOpened() const;
	static std::pair<QString, QString> makeFileItemText(const ObjectData &data);
	QString gitCommand() const;
	QPixmap getTransparentPixmap();
	static QListWidgetItem *NewListWidgetFileItem(const MainWindow::ObjectData &data);
	void cancelPendingUserEvents();
	protected:
	- void customEvent(QEvent *);
	+ void customEvent(QEvent *) override;
	void dragEnterEvent(QDragEnterEvent *event) override;
	// void timerEvent(QTimerEvent *) override;
	void keyPressEvent(QKeyEvent *event) override;
	bool event(QEvent *event) override;
	bool eventFilter(QObject watched, QEvent event) override;
	public:
	void drawDigit(QPainter *pr, int x, int y, int n) const;
	int digitWidth() const;
	int digitHeight() const;
	void setStatusBarText(QString const &text);
	void clearStatusBarText();
	void setCurrentLogRow(RepositoryWrapperFrame *frame, int row);
	bool shown();
	void deleteTags(RepositoryWrapperFrame *frame, QStringList const &tagnames);
	bool addTag(RepositoryWrapperFrame *frame, QString const &name);
	void updateCurrentFilesList(RepositoryWrapperFrame *frame);
	void postOpenRepositoryFromGitHub(const QString &username, const QString &reponame);
	int selectedLogIndex(RepositoryWrapperFrame *frame) const;
	void updateAncestorCommitMap(RepositoryWrapperFrame *frame);
	bool isAncestorCommit(const QString &id);
	void postStartEvent(int ms_later);
	void setShowLabels(bool show, bool save);
	bool isLabelsVisible() const;
	void updateFilesList2(const QString &id, QList<Git::Diff> diff_list, QListWidget listwidget);
	void execCommitViewWindow(const Git::CommitItem *commit);
	void execCommitPropertyDialog(QWidget parent, RepositoryWrapperFrame frame, const Git::CommitItem *commit);
	void execCommitExploreWindow(QWidget parent, const Git::CommitItem commit);
	void execFileHistory(const QString &path);
	void execFileHistory(QListWidgetItem *item);
	void execFilePropertyDialog(QListWidgetItem *item);
	bool testRemoteRepositoryValidity(const QString &url, const QString &sshkey);
	QString selectGitCommand(bool save);
	QString selectFileCommand(bool save);
	QString selectGpgCommand(bool save);
	QString selectSshCommand(bool save);
	const Git::Branch &currentBranch() const;
	void setCurrentBranch(const Git::Branch &b);
	const RepositoryItem &currentRepository() const;
	QString currentRepositoryName() const;
	QString currentRemoteName() const;
	QString currentBranchName() const;
	GitPtr git(const QString &dir, const QString &sshkey = {}) const;
	GitPtr git();
	GitPtr git(const Git::SubmoduleItem &submod);
	void autoOpenRepository(QString dir);
	bool queryCommit(const QString &id, Git::CommitItem *out);
	void checkout(QWidget parent, const Git::CommitItem commit, std::function<void ()> accepted_callback = {});
	void checkout(RepositoryWrapperFrame *frame);
	void jumpToCommit(RepositoryWrapperFrame *frame, QString id);
	Git::Object cat_file(const QString &id);
	void addWorkingCopyDir(const QString &dir, bool open);
	bool saveAs(const QString &id, const QString &dstpath);
	QString determinFileType_(const QString &path, bool mime, const std::function<void (const QString &, QByteArray *)> &callback) const;
	QString determinFileType(const QString &path, bool mime);
	QString determinFileType(QByteArray in, bool mime);
	QList<Git::Tag> queryTagList(RepositoryWrapperFrame *frame);
	TextEditorThemePtr themeForTextEditor();
	bool isValidWorkingCopy(const GitPtr &g) const;
	void emitWriteLog(const QByteArray &ba);
	QString findFileID(const QString &commit_id, const QString &file);
	const Git::CommitItem commitItem(RepositoryWrapperFrame frame, int row) const;
	QIcon committerIcon(RepositoryWrapperFrame *frame, int row) const;
	void changeSshKey(const QString &localdir, const QString &sshkey);
	static QString abbrevCommitID(const Git::CommitItem &commit);
	const Git::CommitItemList &getLogs(RepositoryWrapperFrame const *frame) const;
	const QList<BranchLabel> *label(int row) const;
	ApplicationSettings *appsettings();
	const ApplicationSettings *appsettings() const;
	QString defaultWorkingDir() const;
	WebContext *webContext();
	QIcon verifiedIcon(char s) const;
	QAction addMenuActionProperty(QMenu menu);
	QString currentWorkingCopyDir() const;
	Git::SubmoduleItem const querySubmoduleByPath(const QString &path, Git::CommitItem commit);
	public slots:
	void writeLog_(QByteArray ba);
	private slots:
	void updateUI();
	void onLogVisibilityChanged();
	void onPtyProcessCompleted(bool ok, const QVariant &userdata);
	void onRepositoriesTreeDropped();
	void on_action_about_triggered();
	void on_action_clean_df_triggered();
	void on_action_clone_triggered();
	void on_action_commit_triggered();
	void on_action_create_a_repository_triggered();
	void on_action_delete_branch_triggered();
	void on_action_delete_remote_branch_triggered();
	void on_action_edit_git_config_triggered();
	void on_action_edit_gitignore_triggered();
	void on_action_edit_global_gitconfig_triggered();
	void on_action_edit_settings_triggered();
	void on_action_edit_tags_triggered();
	void on_action_exit_triggered();
	void on_action_explorer_triggered();
	void on_action_fetch_triggered();
	void on_action_fetch_prune_triggered();
	void on_action_find_next_triggered();
	void on_action_find_triggered();
	void on_action_offline_triggered();
	void on_action_online_triggered();
	void on_action_open_existing_working_copy_triggered();
	void on_action_pull_triggered();
	void on_action_push_all_tags_triggered();
	void on_action_push_triggered();
	void on_action_push_u_triggered();
	void on_action_reflog_triggered();
	void on_action_repo_checkout_triggered();
	void on_action_repo_jump_to_head_triggered();
	void on_action_repo_jump_triggered();
	void on_action_repositories_panel_triggered();
	void on_action_repository_property_triggered();
	void on_action_repository_status_triggered();
	void on_action_reset_HEAD_1_triggered();
	void on_action_reset_hard_triggered();
	void on_action_set_config_user_triggered();
	void on_action_set_gpg_signing_triggered();
	void on_action_stash_apply_triggered();
	void on_action_stash_drop_triggered();
	void on_action_stash_triggered();
	void on_action_stop_process_triggered();
	void on_action_terminal_triggered();
	void on_action_view_refresh_triggered();
	void on_action_window_log_triggered(bool checked);
	void on_horizontalScrollBar_log_valueChanged(int);
	void on_lineEdit_filter_textChanged(QString const &text);
	void on_listWidget_files_currentRowChanged(int currentRow);
	void on_listWidget_files_customContextMenuRequested(const QPoint &pos);
	void on_listWidget_files_itemDoubleClicked(QListWidgetItem *item);
	void on_listWidget_staged_currentRowChanged(int currentRow);
	void on_listWidget_staged_customContextMenuRequested(const QPoint &pos);
	void on_listWidget_staged_itemDoubleClicked(QListWidgetItem *item);
	void on_listWidget_unstaged_currentRowChanged(int currentRow);
	void on_listWidget_unstaged_customContextMenuRequested(const QPoint &pos);
	void on_listWidget_unstaged_itemDoubleClicked(QListWidgetItem *item);
	void on_radioButton_remote_offline_clicked();
	void on_radioButton_remote_online_clicked();
	void on_tableWidget_log_currentItemChanged(QTableWidgetItem current, QTableWidgetItem previous);
	void on_tableWidget_log_customContextMenuRequested(const QPoint &pos);
	void on_tableWidget_log_itemDoubleClicked(QTableWidgetItem *);
	void on_toolButton_clone_clicked();
	void on_toolButton_commit_clicked();
	void on_toolButton_erase_filter_clicked();
	void on_toolButton_explorer_clicked();
	void on_toolButton_fetch_clicked();
	void on_toolButton_pull_clicked();
	void on_toolButton_push_clicked();
	void on_toolButton_select_all_clicked();
	void on_toolButton_stage_clicked();
	void on_toolButton_status_clicked();
	void on_toolButton_stop_process_clicked();
	void on_toolButton_terminal_clicked();
	void on_toolButton_unstage_clicked();
	void on_treeWidget_repos_currentItemChanged(QTreeWidgetItem current, QTreeWidgetItem previous);
	void on_treeWidget_repos_customContextMenuRequested(const QPoint &pos);
	void on_treeWidget_repos_itemDoubleClicked(QTreeWidgetItem *item, int column);
	void on_verticalScrollBar_log_valueChanged(int);
	void on_action_repo_merge_triggered();

	void on_action_expand_commit_log_triggered();

	void on_action_expand_file_list_triggered();

	void on_action_expand_diff_view_triggered();

	// void on_action_wide_triggered();

	void on_action_sidebar_triggered();


	void on_action_show_labels_triggered();

	void on_action_submodule_add_triggered();

	void on_action_submodules_triggered();

	void on_action_submodule_update_triggered();

	void onAvatarUpdated(RepositoryWrapperFrameP frame);
	void test();
	void onInterval10ms();
	protected:
	void closeEvent(QCloseEvent *event) override;
	void internalWriteLog(const char *ptr, int len);
	RepositoryItem const *selectedRepositoryItem() const;
	void removeSelectedRepositoryFromBookmark(bool ask);
	protected slots:
	void onLogIdle();
	signals:
	void signalWriteLog(QByteArray ba);
	void remoteInfoChanged();
	void signalSetRemoteChanged(bool f);
	void onEscapeKeyPressed();
	void updateButton();
	};

	#endif // MAINWINDOW_H
	diff --git a/src/coloredit/ColorPreviewWidget.cpp b/src/coloredit/ColorPreviewWidget.cpp
	index b38416c..79e1f25 100644
	--- a/src/coloredit/ColorPreviewWidget.cpp
	+++ b/src/coloredit/ColorPreviewWidget.cpp
	@@ -1,27 +1,27 @@
	#include "ColorPreviewWidget.h"

	#include <QPainter>

	ColorPreviewWidget::ColorPreviewWidget(QWidget *parent)
	: QWidget(parent)
	{
	color_ = Qt::red;
	}

	void ColorPreviewWidget::setColor(const QColor &color)
	{
	color_ = color;
	update();
	}

	-void ColorPreviewWidget::paintEvent(QPaintEvent *event)
	+void ColorPreviewWidget::paintEvent(QPaintEvent *)
	{
	int w = width();
	int h = height();
	QPainter pr(this);
	pr.fillRect(0, 0, w - 1, 1, Qt::black);
	pr.fillRect(0, 1, 1, h - 1, Qt::black);
	pr.fillRect(w - 1, 0, 1, h - 1, Qt::black);
	pr.fillRect(1, h - 1, w - 1, 1, Qt::black);
	pr.fillRect(1, 1, w - 2, h - 2, color_);
	}
	diff --git a/src/coloredit/ColorPreviewWidget.h b/src/coloredit/ColorPreviewWidget.h
	index 0f3cb9a..ac9c87f 100644
	--- a/src/coloredit/ColorPreviewWidget.h
	+++ b/src/coloredit/ColorPreviewWidget.h
	@@ -1,16 +1,16 @@
	#ifndef COLORPREVIEWWIDGET_H
	#define COLORPREVIEWWIDGET_H

	#include <QWidget>

	class ColorPreviewWidget : public QWidget {
	private:
	QColor color_;
	protected:
	- void paintEvent(QPaintEvent *event);
	+ void paintEvent(QPaintEvent *);
	public:
	ColorPreviewWidget(QWidget *parent);
	void setColor(QColor const &color);
	};

	#endif // COLORPREVIEWWIDGET_H
	diff --git a/src/coloredit/ColorSquareWidget.cpp b/src/coloredit/ColorSquareWidget.cpp
	index b2bada7..2e571b9 100644
	--- a/src/coloredit/ColorSquareWidget.cpp
	+++ b/src/coloredit/ColorSquareWidget.cpp
	@@ -1,159 +1,159 @@
	#include "ColorSquareWidget.h"
	#include "MainWindow.h"
	#include <QDebug>
	#include <QFile>
	#include <QPainter>
	#include <stdint.h>
	#include <QMouseEvent>
	-#include <omp.h>
	+//#include <omp.h>

	struct ColorSquareWidget::Private {
	int hue = 0;
	int sat = 255;
	int val = 255;
	QImage image;
	QRect rect;
	};

	ColorSquareWidget::ColorSquareWidget(QWidget *parent)
	: QWidget(parent)
	, m(new Private)
	{
	QString path = ":/cl/example.cl";
	std::string source;
	QFile file(path);
	if (file.open(QFile::ReadOnly)) {
	QByteArray ba = file.readAll();
	if (!ba.isEmpty()) {
	source = std::string(ba.begin(), ba.end());
	}
	}

	#if USE_OPENCL
	prog.build(getCL(), source, "saturation_brightness");
	#endif
	}

	ColorSquareWidget::~ColorSquareWidget()
	{
	delete m;
	}

	static void drawFrame(QPainter *pr, int x, int y, int w, int h)
	{
	if (w < 3 \|\| h < 3) {
	pr->fillRect(x, y, w, h, Qt::black);
	} else {
	pr->fillRect(x, y, w - 1, 1, Qt::black);
	pr->fillRect(x, y + 1, 1, h - 1, Qt::black);
	pr->fillRect(x + w - 1, y, 1, h - 1, Qt::black);
	pr->fillRect(x + 1, y + h - 1, w - 1, 1, Qt::black);
	}
	}

	#if USE_OPENCL
	MiraCL *SaturationBrightnessWidget::getCL()
	{
	return theApp->getCL();
	}
	#endif

	QImage ColorSquareWidget::createImage(int w, int h)
	{
	QImage image(w, h, QImage::Format_RGB32);
	#if USE_OPENCL
	QColor color = QColor::fromHsv(hue, 255, 255);
	cl_uint r = color.red();
	cl_uint g = color.green();
	cl_uint b = color.blue();
	MiraCL::Buffer buff(getCL());
	buff.alloc(w * h * sizeof(uint32_t));
	prog.arg(0, &w);
	prog.arg(1, &h);
	prog.arg(2, &r);
	prog.arg(3, &g);
	prog.arg(4, &b);
	prog.arg(5, &buff);
	prog.run(w, h);
	buff.read(0, w * h * sizeof(uint32_t), image.bits());
	getCL()->flush();
	getCL()->finish();
	#else
	for (int y = 0; y < h; y++) {
	int bri = 255 - 255 * y / h;
	QRgb dst = (QRgb )image.scanLine(y);
	for (int x = 0; x < w; x++) {
	int sat = 256 * x / w;
	QColor color = QColor::fromHsv(m->hue, sat, bri);
	dst[x] = qRgb(color.red(), color.green(), color.blue());
	}
	}
	#endif
	return image;
	}

	MainWindow *ColorSquareWidget::mainwindow()
	{
	return qobject_cast<MainWindow *>(window());
	}

	void ColorSquareWidget::updatePixmap(bool force)
	{
	int w = width();
	int h = height();
	if (w > 1 && h > 1) {
	if ((m->image.width() != w \|\| m->image.height() != h) \|\| force) {
	m->image = createImage(w, h);
	m->rect = QRect(0, 0, w, h);
	}
	} else {
	m->image = QImage();
	}
	}

	void ColorSquareWidget::paintEvent(QPaintEvent *)
	{
	updatePixmap(false);
	if (!m->image.isNull()) {
	QPainter pr(this);
	pr.drawImage(0, 0, m->image);
	drawFrame(&pr, 0, 0, width(), height());
	}
	}

	void ColorSquareWidget::press(QPoint const &pos)
	{
	int x = pos.x() - m->rect.x();
	int y = pos.y() - m->rect.y();
	x = std::max(0, std::min(x, m->image.width() - 1));
	y = std::max(0, std::min(y, m->image.height() - 1));
	m->sat = x * 255 / m->image.width();
	m->val = 255 - y * 255 / m->image.height();
	emit changeColor(QColor::fromHsv(m->hue, m->sat, m->val));
	}

	void ColorSquareWidget::mousePressEvent(QMouseEvent *event)
	{
	press(event->pos());
	}

	void ColorSquareWidget::mouseMoveEvent(QMouseEvent *event)
	{
	press(event->pos());
	}

	void ColorSquareWidget::setHue(int h)
	{
	if (h < 0) {
	h = 360 - (-h % 360);
	} else {
	h %= 360;
	}
	m->hue = h;
	updatePixmap(true);
	emit changeColor(QColor::fromHsv(m->hue, m->sat, m->val));
	update();
	}



	diff --git a/src/darktheme/DarkStyle.cpp b/src/darktheme/DarkStyle.cpp
	index 1dd810d..eaad340 100644
	--- a/src/darktheme/DarkStyle.cpp
	+++ b/src/darktheme/DarkStyle.cpp
	@@ -1,2573 +1,2573 @@
	#include "DarkStyle.h"
	#include "NinePatch.h"
	#include "TraditionalWindowsStyleTreeControl.h"
	#include <QApplication>
	#include <QComboBox>
	#include <QDebug>
	#include <QDialogButtonBox>
	#include <QDockWidget>
	#include <QInputDialog>
	#include <QListView>
	#include <QMessageBox>
	#include <QPixmapCache>
	#include <QStyleOptionComplex>
	#include <QStyleOptionFrameV3>
	#include <QTableWidget>
	#include <QTextLayout>
	#include <QToolTip>
	#include <cmath>
	#include <cstdint>

	#include <QPainterPath>

	#define MBI_NORMAL 1
	#define MBI_HOT 2
	#define MBI_PUSHED 3
	#define MBI_DISABLED 4

	namespace {

	const int windowsItemFrame = 2; // menu item frame width
	const int windowsItemHMargin = 3; // menu item hor text margin
	const int windowsItemVMargin = 4; // menu item ver text margin
	const int windowsArrowHMargin = 6; // arrow horizontal margin
	const int windowsRightBorder = 15; // right border on windows

	void drawFrame(QPainter *pr, int x, int y, int w, int h, QColor color_topleft, QColor color_bottomright)
	{
	if (w < 3 \|\| h < 3) {
	if (w > 0 && h > 0) {
	pr->fillRect(x, y, w, h, color_topleft);
	}
	} else {
	if (!color_topleft.isValid()) color_topleft = Qt::black;
	if (!color_bottomright.isValid()) color_bottomright = color_topleft;
	pr->fillRect(x, y, w - 1, 1, color_topleft);
	pr->fillRect(x, y + 1, 1, h -1, color_topleft);
	pr->fillRect(x + w - 1, y, 1, h -1, color_bottomright);
	pr->fillRect(x + 1, y + h - 1, w - 1, 1, color_bottomright);
	}
	}

	void drawFrame(QPainter *pr, QRect const &r, QColor const &color_topleft, QColor const &color_bottomright)
	{
	return drawFrame(pr, r.x(), r.y(), r.width(), r.height(), color_topleft, color_bottomright);
	}

	struct TextureCacheItem {
	QString key;
	QPixmap pm;
	};

	QString pixmapkey(QString const &name, QString const &role, QSize const &size, QColor const &color)
	{
	QString key = "%1:%2:%3:%4:%5";
	key = key.arg(name).arg(role).arg(size.width()).arg(size.height()).arg(QString().sprintf("%02X%02X%02X", color.red(), color.green(), color.blue()));
	return key;
	}

	void drawRaisedFrame(QPainter *p, const QRect &rect, const QPalette &palette)
	{
	p->save();
	int x = rect.x();
	int y = rect.y();
	int w = rect.width();
	int h = rect.height();
	p->setClipRect(x, y, w, h);
	p->fillRect(x, y, w, h, palette.color(QPalette::Window));
	p->fillRect(x, y, w - 1, 1, palette.color(QPalette::Light));
	p->fillRect(x, y, 1, h - 1, palette.color(QPalette::Light));
	// p->fillRect(x + 1, y + h - 2, w - 2, 1, palette.color(QPalette::Dark));
	// p->fillRect(x + w - 2, y + 1, 1, h - 2, palette.color(QPalette::Dark));
	p->fillRect(x, y + h - 1, w, 1, palette.color(QPalette::Shadow));
	p->fillRect(x + w - 1, y, 1, h, palette.color(QPalette::Shadow));
	p->restore();
	}

	QImage loadImage(QString const &path, QString const &role = QString())
	{
	QImage image(path);
	image.setText("name", path);
	image.setText("role", role);
	return image;
	}

	QRgb colorize(QRgb color, int light, int alpha)
	{
	int r, g, b;
	r = g = b = 0;
	if (alpha != 0) {
	r = qRed(color);
	g = qGreen(color);
	b = qBlue(color);
	if (light < 128) {
	r = r * light / 127;
	g = g * light / 127;
	b = b * light / 127;
	} else {
	int u = 255 - light;
	r = 255 - (255 - r) * u / 127;
	g = 255 - (255 - g) * u / 127;
	b = 255 - (255 - b) * u / 127;
	}
	}
	return qRgba(r, g, b, alpha);
	}

	} // namespace

	// DarkStyle

	static const int TEXTURE_CACHE_SIZE = 100;

	struct DarkStyle::Private {
	QColor base_color;
	bool images_loaded = false;

	ScrollBarTextures hsb;
	ScrollBarTextures vsb;

	int scroll_bar_extent = -1;

	QImage button_normal;
	QImage button_press;

	QImage progress_horz;
	QImage progress_vert;

	TraditionalWindowsStyleTreeControl legacy_windows;

	};

	DarkStyle::DarkStyle(QColor const &base_color)
	: m(new Private)
	{
	setBaseColor(base_color);
	}

	DarkStyle::~DarkStyle()
	{
	delete m;
	}

	QColor DarkStyle::getBaseColor()
	{
	return m->base_color;
	}

	void DarkStyle::setBaseColor(QColor const &color)
	{
	m->base_color = color;
	m->images_loaded = false;
	}

	QColor DarkStyle::color(int level, int alpha) const
	{
	QColor c = m->base_color.lighter(level * 100 / 255);
	c.setAlpha(alpha);
	return c;
	}

	void DarkStyle::setScrollBarExtent(int n)
	{
	m->scroll_bar_extent = n;
	}

	QImage DarkStyle::colorizeImage(QImage image)
	{
	int w = image.width();
	int h = image.height();
	if (w > 0 && h > 0) {
	QColor c = color(128);
	QRgb rgb = c.rgb();
	Q_ASSERT(image.format() == QImage::Format_ARGB32);
	for (int y = 0; y < h; y++) {
	QRgb p = reinterpret_cast<QRgb >(image.scanLine(y));
	for (int x = 0; x < w; x++) {
	p[x] = colorize(rgb, qGray(p[x]), qAlpha(p[x]));
	}
	}
	}
	return image;
	}

	QImage DarkStyle::loadColorizedImage(QString const &path, QString const &role)
	{
	QImage image = loadImage(path);
	image = colorizeImage(image);
	image.setText("name", path);
	image.setText("role", role);
	return image;
	}

	namespace {
	class Lighten {
	private:
	int lut[256];
	public:
	Lighten()
	{
	#if 0
	const double x = 0.75;
	for (int i = 0; i < 256; i++) {
	lut[i] = (int)(pow(i / 255.0, x) * 255);
	}
	#else
	for (int i = 0; i < 256; i++) {
	lut[i] = 255 - (255 - i) * 192 / 256;
	}
	#endif
	}
	int operator [] (int i)
	{
	return lut[i];
	}
	};
	}

	DarkStyle::ButtonImages DarkStyle::generateButtonImages(QString const &path)
	{
	QImage source = loadImage(path);
	ButtonImages buttons;
	int w = source.width();
	int h = source.height();
	if (w > 4 && h > 4) {
	QColor c = color(128);
	QRgb rgb = c.rgb();
	Lighten lighten;
	buttons.im_normal = source;
	buttons.im_hover = source;
	w -= 4;
	h -= 4;
	for (int y = 0; y < h; y++) {
	QRgb src1 = reinterpret_cast<QRgb >(source.scanLine(y + 1));
	QRgb src2 = reinterpret_cast<QRgb >(source.scanLine(y + 2));
	QRgb src3 = reinterpret_cast<QRgb >(source.scanLine(y + 3));
	QRgb dst0 = reinterpret_cast<QRgb >(buttons.im_normal.scanLine(y + 2)) + 2;
	QRgb dst1 = reinterpret_cast<QRgb >(buttons.im_hover.scanLine(y + 2)) + 2;
	for (int x = 0; x < w; x++) {
	int v = (int)qAlpha(src3[x + 3]) - (int)qAlpha(src1[x + 1]);
	v = (v + 256) / 2;
	int alpha = qAlpha(src2[x + 2]);
	dst0[x] = colorize(rgb, v, alpha);
	v = lighten[v];
	dst1[x] = colorize(rgb, v, alpha);
	}
	}
	buttons.im_normal.setText("name", source.text("name"));
	buttons.im_hover.setText("name", source.text("name"));
	buttons.im_normal.setText("role", "normal");
	buttons.im_hover.setText("role", "hover");
	}
	return buttons;
	}

	QImage DarkStyle::generateHoverImage(QImage const &source)
	{
	QImage newimage;
	int w = source.width();
	int h = source.height();
	if (w > 2 && h > 2) {
	QColor c = color(128);
	QRgb rgb = c.rgb();
	Lighten lighten;
	newimage = source;
	Q_ASSERT(newimage.format() == QImage::Format_ARGB32);
	w -= 2;
	h -= 2;
	for (int y = 0; y < h; y++) {
	QRgb ptr = reinterpret_cast<QRgb >(newimage.scanLine(y + 1)) + 1;
	for (int x = 0; x < w; x++) {
	int v = qGray(ptr[x]);
	v = lighten[v];
	ptr[x] = colorize(rgb, v, qAlpha(ptr[x]));
	}
	}
	newimage.setText("role", "hover");
	}
	return newimage;
	}

	void DarkStyle::loadImages()
	{
	if (m->images_loaded) return;

	if (!m->base_color.isValid()) {
	setBaseColor(Qt::white);
	}

	m->button_normal = loadColorizedImage(QLatin1String(":/darktheme/button/button_normal.png"), QLatin1String("normal"));
	m->button_press = loadColorizedImage(QLatin1String(":/darktheme/button/button_press.png"), QLatin1String("press"));

	m->hsb.sub_line = generateButtonImages(QLatin1String(":/darktheme/hsb/hsb_sub_line.png"));
	m->hsb.add_line = generateButtonImages(QLatin1String(":/darktheme/hsb/hsb_add_line.png"));
	m->hsb.page_bg = loadColorizedImage(QLatin1String(":/darktheme/hsb/hsb_page_bg.png"));
	m->hsb.slider.im_normal = loadColorizedImage(QLatin1String(":/darktheme/hsb/hsb_slider.png"));
	m->hsb.slider.im_hover = generateHoverImage(m->hsb.slider.im_normal);

	m->vsb.sub_line = generateButtonImages(QLatin1String(":/darktheme/vsb/vsb_sub_line.png"));
	m->vsb.add_line = generateButtonImages(QLatin1String(":/darktheme/vsb/vsb_add_line.png"));
	m->vsb.page_bg = loadColorizedImage(QLatin1String(":/darktheme/vsb/vsb_page_bg.png"));
	m->vsb.slider.im_normal = loadColorizedImage(QLatin1String(":/darktheme/vsb/vsb_slider.png"));
	m->vsb.slider.im_hover = generateHoverImage(m->vsb.slider.im_normal);

	m->progress_horz = loadImage(QLatin1String(":/darktheme/progress/horz.png"));
	m->progress_vert = loadImage(QLatin1String(":/darktheme/progress/vert.png"));

	m->images_loaded = true;
	}

	QPixmap DarkStyle::pixmapFromImage(const QImage &image, QSize size) const
	{
	QString key = pixmapkey(image.text("name"), image.text("role"), size, m->base_color);

	QPixmap *pm = QPixmapCache::find(key);
	if (pm) return *pm;

	TextureCacheItem t;
	t.key = key;
	t.pm = QPixmap::fromImage(image.scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
	QPixmapCache::insert(key, t.pm);
	return t.pm;
	}

	QColor DarkStyle::selectionColor() const
	{
	// return QColor(128, 192, 255);
	return QColor(80, 160, 255);
	}

	QColor DarkStyle::colorForItemView(QStyleOption const *opt) const
	{
	#ifdef Q_OS_WIN
	return opt->palette.color(QPalette::Base);
	#else
	return opt->palette.color(QPalette::Dark);
	#endif
	}

	void DarkStyle::drawNinePatchImage(QPainter *p, const QImage &image, const QRect &r, int w, int h) const
	{
	QImage im = createImageFromNinePatchImage(image, w, h);
	im.setText("name", image.text("name"));
	im.setText("role", image.text("role"));
	QPixmap pm = pixmapFromImage(im, r.size());
	p->drawPixmap(r.x(), r.y(), pm);
	}

	void DarkStyle::polish(QPalette &palette)
	{
	if (!m->base_color.isValid()) {
	setBaseColor(Qt::white);
	}
	loadImages();
	palette = QPalette(color(64));
	palette.setColor(QPalette::Disabled, QPalette::Text, color(160));
	palette.setColor(QPalette::Normal, QPalette::Highlight, selectionColor().lighter(75));
	palette.setColor(QPalette::Disabled, QPalette::ButtonText, color(128));
	#ifndef Q_OS_WIN
	palette.setColor(QPalette::ToolTipText, Qt::black); // ツールチップの文字色
	#endif
	}

	void DarkStyle::drawGutter(QPainter *p, const QRect &r) const
	{
	int x = r.x();
	int y = r.y();
	int w = r.width();
	int h = r.height();
	QColor dark = color(32);
	QColor lite = color(128);
	if (w < h) {
	x += (w - 1) / 2;
	p->fillRect(x, y, 1, h, dark);
	p->fillRect(x + 1, y, 1, h, lite);
	} else if (w > h) {
	y += (h - 1) / 2;
	p->fillRect(x, y, w, 1, dark);
	p->fillRect(x, y + 1, w, 1, lite);
	}
	}

	void DarkStyle::drawSelectedItemFrame(QPainter *p, QRect rect, bool focus) const
	{
	QColor color = focus ? selectionColor() : QColor(128, 128, 128);

	int x, y, w, h;
	x = rect.x();
	y = rect.y();
	w = rect.width();
	h = rect.height();

	QString key = QString::asprintf("selection_frame:%02x%02x%02x:%dx%d", color.red(), color.green(), color.blue(), w, h);

	QPixmap pixmap;
	if (!QPixmapCache::find(key, &pixmap)) {
	pixmap = QPixmap(w, h);
	pixmap.fill(Qt::transparent);
	QPainter pr(&pixmap);
	pr.setRenderHint(QPainter::Antialiasing);

	QColor pencolor = color;
	pencolor.setAlpha(128);
	pr.setPen(pencolor);
	pr.setBrush(Qt::NoBrush);

	QPainterPath path;
	path.addRoundedRect(1.5, 1.5, w - 1.5, h - 1.5, 3, 3);

	pr.drawPath(path);

	pr.setClipPath(path);

	int a = color.alpha();
	QColor color0 = color;
	QColor color1 = color;
	color0.setAlpha(128 * a / 255);
	color1.setAlpha(64 * a / 255);
	QLinearGradient gr(QPointF(0, 0), QPointF(0, h));
	gr.setColorAt(0, color0);
	gr.setColorAt(1, color1);
	QBrush br(gr);
	pr.fillRect(0, 0, w, h, br);

	pr.end();
	QPixmapCache::insert(key, pixmap);
	}

	p->drawPixmap(x, y, w, h, pixmap);
	}

	void DarkStyle::drawFocusFrame(QPainter *p, QRect const &rect, int margin) const
	{
	p->save();
	p->setRenderHint(QPainter::Antialiasing);
	QColor color = selectionColor();
	p->setPen(color);
	p->setBrush(Qt::NoBrush);
	double m = margin + 0.5;
	p->drawRoundedRect(((QRectF)rect).adjusted(m, m, -m, -m), 3, 3);
	p->restore();
	}

	void DarkStyle::drawButton(QPainter p, const QStyleOption option, bool mac_margin) const
	{
	QRect rect = option->rect;
	int w = rect.width();
	int h = rect.height();

	#ifdef Q_OS_MAC
	if (mac_margin) {
	int margin = pixelMetric(PM_ButtonMargin, option, nullptr);
	if (margin > 0) {
	int n = std::min(w, h);
	if (n > margin * 2) {
	n = (n - margin * 2) / 2;
	if (n > margin) n = margin;
	rect = rect.adjusted(n, n, -n, -n);
	w = rect.width();
	h = rect.height();
	}
	}
	}
	#else
	(void)mac_margin;
	#endif

	bool pressed = (option->state & (State_Sunken \| State_On));
	bool hover = (option->state & State_MouseOver);

	if (pressed) {
	drawNinePatchImage(p, m->button_press, rect, w, h);
	} else {
	drawNinePatchImage(p, m->button_normal, rect, w, h);
	}
	{
	QPainterPath path;
	path.addRoundedRect(rect, 6, 6); // 角丸四角形のパス
	p->save();
	p->setRenderHint(QPainter::Antialiasing);
	p->setClipPath(path);

	int x = rect.x();
	int y = rect.y();
	int w = rect.width();
	int h = rect.height();
	QColor color0, color1;
	#ifdef Q_OS_MAC
	if (pressed) {
	color0 = Qt::black;
	color1 = Qt::black;
	color0.setAlpha(48);
	color1.setAlpha(144);
	} else {
	color0 = Qt::black;
	color1 = Qt::black;
	color0.setAlpha(32);
	color1.setAlpha(128);
	}
	#else
	if (pressed) {
	color0 = Qt::black;
	color1 = Qt::black;
	color0.setAlpha(32);
	color1.setAlpha(128);
	} else if (hover) {
	color0 = Qt::black;
	color1 = Qt::black;
	color0.setAlpha(16);
	color1.setAlpha(96);
	} else {
	color0 = Qt::black;
	color1 = Qt::black;
	color0.setAlpha(32);
	color1.setAlpha(128);
	}
	#endif
	QLinearGradient gr(QPointF(x, y), QPointF(x, y + h));
	gr.setColorAt(0, color0);
	gr.setColorAt(1, color1);
	QBrush br(gr);
	p->fillRect(x, y, w, h, br);

	if (option->state & State_HasFocus) {
	#if 1
	drawFocusFrame(p, rect, 3);
	#else
	p->fillRect(x, y, w, h, QColor(80, 160, 255, 32));
	#endif
	}

	p->restore();
	}
	}

	void DarkStyle::drawToolButton(QPainter p, const QStyleOption option) const
	{
	p->save();

	bool hover = (option->state & State_MouseOver);
	bool pressed = (option->state & State_Sunken);
	#ifdef Q_OS_MAC
	hover = false;
	#endif

	int x = option->rect.x();
	int y = option->rect.y();
	int w = option->rect.width();
	int h = option->rect.height();
	QColor color0, color1;
	#ifdef Q_OS_MAC
	if (pressed) {
	color0 = color(72);
	color1 = color(40);
	} else {
	color0 = color(80);
	color1 = color(48);
	}
	#else
	if (pressed) {
	color0 = color(80);
	color1 = color(48);
	} else if (hover) {
	color0 = color(96);
	color1 = color(64);
	} else {
	color0 = color(80);
	color1 = color(48);
	}
	#endif
	QLinearGradient gr(QPointF(x, y), QPointF(x, y + h));
	gr.setColorAt(0, color0);
	gr.setColorAt(1, color1);
	QBrush br(gr);
	p->fillRect(x, y, w, h, br);

	if (option->state & State_Raised) {
	drawFrame(p, option->rect, color(96), color(32));
	} else if (option->state & State_Sunken) {
	drawFrame(p, option->rect, color(48), color(48));
	}

	p->restore();
	}

	void DarkStyle::drawMenuBarBG(QPainter p, const QStyleOption option, QWidget const *widget) const
	{
	int x = option->rect.x();
	int y = widget->y();
	int w = option->rect.width();
	int h = widget->height();
	QLinearGradient gradient;
	gradient.setStart(x, y);
	gradient.setFinalStop(x, y + h / 2.0);
	gradient.setColorAt(0, option->palette.color(QPalette::Light));
	gradient.setColorAt(1, option->palette.color(QPalette::Window));
	p->fillRect(x, y, w, h, gradient);
	p->fillRect(x, y + h - 1, w, 1, option->palette.color(QPalette::Dark));
	}

	int DarkStyle::pixelMetric(PixelMetric metric, const QStyleOption option, const QWidget widget) const
	{
	if (metric == PM_ScrollBarExtent) {
	if (m->scroll_bar_extent > 0) {
	return m->scroll_bar_extent;
	}
	}
	if (metric == PM_SliderLength) {
	return std::min(widget->width(), widget->height());
	}
	return QProxyStyle::pixelMetric(metric, option, widget);
	}

	QRect DarkStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex option, SubControl sc, const QWidget widget) const
	{
	if (cc == CC_Slider && sc == SC_SliderGroove) {
	return widget->rect();
	}
	if (cc == CC_Slider && sc == SC_SliderHandle) {
	if (auto const o = qstyleoption_cast<QStyleOptionSlider const >(option)) {
	QRect rect;
	int extent = std::min(widget->width(), widget->height());
	int span = pixelMetric(PM_SliderLength, o, widget);
	bool horizontal = o->orientation == Qt::Horizontal;
	int sliderPos = sliderPositionFromValue(o->minimum, o->maximum,
	o->sliderPosition,
	(horizontal ? o->rect.width()
	: o->rect.height()) - span,
	o->upsideDown);
	if (horizontal) {
	rect.setRect(o->rect.x() + sliderPos, o->rect.y(), span, extent);
	} else {
	rect.setRect(o->rect.x(), o->rect.y() + sliderPos, extent, span);
	}
	return rect;
	}
	}
	if (cc == CC_GroupBox) {
	QRect ret;
	if (auto const o = qstyleoption_cast<QStyleOptionGroupBox const >(option)) {
	switch (sc) {
	case SC_GroupBoxFrame:
	case SC_GroupBoxContents:
	{
	int topMargin = 0;
	int topHeight = 0;
	int verticalAlignment = proxy()->styleHint(SH_GroupBox_TextLabelVerticalAlignment, o, widget);
	#ifdef Q_OS_MACX
	verticalAlignment \|= Qt::AlignVCenter;
	#endif
	if (o->text.size() \|\| (o->subControls & QStyle::SC_GroupBoxCheckBox)) {
	topHeight = o->fontMetrics.height();
	if (verticalAlignment & Qt::AlignVCenter) {
	topMargin = topHeight / 2;
	} else if (verticalAlignment & Qt::AlignTop) {
	topMargin = topHeight;
	}
	}

	QRect frameRect = o->rect;
	frameRect.setTop(topMargin);

	if (sc == SC_GroupBoxFrame) {
	ret = frameRect;
	break;
	}

	int frameWidth = 0;
	if ((o->features & QStyleOptionFrame::Flat) == 0) {
	frameWidth = proxy()->pixelMetric(PM_DefaultFrameWidth, o, widget);
	}
	ret = frameRect.adjusted(frameWidth, frameWidth + topHeight - topMargin, -frameWidth, -frameWidth);
	}
	break;
	case SC_GroupBoxCheckBox:
	case SC_GroupBoxLabel:
	{
	QFontMetrics fontMetrics = o->fontMetrics;
	int h = fontMetrics.height();
	int tw = fontMetrics.size(Qt::TextShowMnemonic, o->text + QLatin1Char(' ')).width();
	int marg = (o->features & QStyleOptionFrame::Flat) ? 0 : 8;
	ret = o->rect.adjusted(marg, 0, -marg, 0);
	ret.setHeight(h);

	int indicatorWidth = proxy()->pixelMetric(PM_IndicatorWidth, option, widget);
	int indicatorSpace = proxy()->pixelMetric(PM_CheckBoxLabelSpacing, option, widget) - 1;
	bool hasCheckBox = o->subControls & QStyle::SC_GroupBoxCheckBox;
	int checkBoxSize = hasCheckBox ? (indicatorWidth + indicatorSpace) : 0;

	// Adjusted rect for label + indicatorWidth + indicatorSpace
	QRect totalRect = alignedRect(o->direction, o->textAlignment, QSize(tw + checkBoxSize, h), ret);

	// Adjust totalRect if checkbox is set
	if (hasCheckBox) {
	bool ltr = o->direction == Qt::LeftToRight;
	int left = 0;
	// Adjust for check box
	if (sc == SC_GroupBoxCheckBox) {
	int indicatorHeight = proxy()->pixelMetric(PM_IndicatorHeight, option, widget);
	left = ltr ? totalRect.left() : (totalRect.right() - indicatorWidth);
	int top = totalRect.top() + qMax(0, fontMetrics.height() - indicatorHeight) / 2;
	totalRect.setRect(left, top, indicatorWidth, indicatorHeight);
	// Adjust for label
	} else {
	left = ltr ? (totalRect.left() + checkBoxSize - 2) : totalRect.left();
	totalRect.setRect(left, totalRect.top(), totalRect.width() - checkBoxSize, totalRect.height());
	}
	}
	ret = totalRect;
	}
	break;
	}
	return ret;
	}
	}
	return QProxyStyle::subControlRect(cc, option, sc, widget);
	}

	int DarkStyle::styleHint(QStyle::StyleHint stylehint, const QStyleOption opt, const QWidget widget, QStyleHintReturn *returnData) const
	{
	if (stylehint == SH_Table_GridLineColor) {
	return static_cast<int>(color(32).rgb());
	}
	return QProxyStyle::styleHint(stylehint, opt, widget, returnData);
	}

	#if 0
	static QSizeF viewItemTextLayout(QTextLayout &textLayout, int lineWidth)
	{
	qreal height = 0;
	qreal widthUsed = 0;
	textLayout.beginLayout();
	while (true) {
	QTextLine line = textLayout.createLine();
	if (!line.isValid())
	break;
	line.setLineWidth(lineWidth);
	line.setPosition(QPointF(0, height));
	height += line.height();
	widthUsed = qMax(widthUsed, line.naturalTextWidth());
	}
	textLayout.endLayout();
	return QSizeF(widthUsed, height);
	}

	void DarkStyle::drawItemViewText(QPainter p, const QStyleOptionViewItem option, const QRect &rect) const
	{
	const QWidget *widget = option->widget;
	const int textMargin = pixelMetric(QStyle::PM_FocusFrameHMargin, 0, widget) + 1;

	QRect textRect = rect.adjusted(textMargin, 0, -textMargin, 0); // remove width padding
	const bool wrapText = option->features & QStyleOptionViewItem::WrapText;
	QTextOption textOption;
	textOption.setWrapMode(wrapText ? QTextOption::WordWrap : QTextOption::ManualWrap);
	textOption.setTextDirection(option->direction);
	textOption.setAlignment(QStyle::visualAlignment(option->direction, option->displayAlignment));
	QTextLayout textLayout(option->text, option->font);
	textLayout.setTextOption(textOption);

	viewItemTextLayout(textLayout, textRect.width());

	const QRectF boundingRect = textLayout.boundingRect();
	const QRect layoutRect = QStyle::alignedRect(option->direction, option->displayAlignment, boundingRect.size().toSize(), textRect);
	const QPointF position = layoutRect.topLeft();
	const int lineCount = textLayout.lineCount();

	qreal height = 0;
	for (int i = 0; i < lineCount; ++i) {
	const QTextLine line = textLayout.lineAt(i);
	height += line.height();

	// above visible rect
	if (height + layoutRect.top() <= textRect.top()) continue;

	const int start = line.textStart();
	const int length = line.textLength();

	const bool drawElided = line.naturalTextWidth() > textRect.width();
	bool elideLastVisibleLine = false;
	if (!drawElided && i + 1 < lineCount) {
	const QTextLine nextLine = textLayout.lineAt(i + 1);
	const int nextHeight = height + nextLine.height() / 2;
	// elide when less than the next half line is visible
	if (nextHeight + layoutRect.top() > textRect.height() + textRect.top()) {
	elideLastVisibleLine = true;
	}
	}

	if (drawElided \|\| elideLastVisibleLine) {
	QString text = textLayout.text().mid(start, length);
	if (elideLastVisibleLine) {
	text += QChar(0x2026);
	}
	// const QStackTextEngine engine(text, option->font);
	const QString elidedText = text;//engine.elidedText(option->textElideMode, textRect.width());
	const QPointF pos(position.x() + line.x(), position.y() + line.y() + line.ascent());
	p->save();
	p->setFont(option->font);
	p->drawText(pos, elidedText);
	p->restore();
	} else {
	line.draw(p, position);
	}

	// below visible text, can stop
	if (height + layoutRect.top() >= textRect.bottom()) {
	break;
	}
	}
	}
	#else
	void DarkStyle::drawItemViewText(QPainter p, const QStyleOptionViewItem option, const QRect &rect, bool abbreviation) const
	{
	bool enabled = (option->state & State_Enabled);
	p->save();
	p->setFont(option->font);
	QString text = option->text;
	if (abbreviation) {
	int n = text.size();
	if (n > 1) {
	QFontMetrics fm = p->fontMetrics();
	int w = rect.width();
	while (1) {
	if (fm.size(0, text).width() <= w) break;
	n--;
	text = text.mid(0, n);
	text += "...";
	}
	}
	}
	drawItemText(p, rect, option->displayAlignment, option->palette, enabled, text, QPalette::NoRole);
	p->restore();
	}
	#endif

	void DarkStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption option, QPainter p, const QWidget *widget) const
	{
	// qDebug() << pe;
	#ifndef Q_OS_MAC
	if (pe == PE_FrameFocusRect) {
	// if (auto const w = qobject_cast<QTableView const >(widget)) {
	// if (w->selectionBehavior() == QAbstractItemView::SelectRows) {
	// if (auto const *v = w->viewport()) {
	// QRect r(0, option->rect.y(), v->width(), option->rect.height());
	// return;
	// }

	// }
	// }
	drawFocusFrame(p, option->rect, 0);
	return;
	}
	#endif
	if (pe == PE_IndicatorArrowDown) {
	switch (pe) {
	case PE_IndicatorArrowUp:
	case PE_IndicatorArrowDown:
	case PE_IndicatorArrowRight:
	case PE_IndicatorArrowLeft:
	{
	if (option->rect.width() <= 1 \|\| option->rect.height() <= 1) {
	break;
	}
	QRect r = option->rect.adjusted(-10, -10, 0, 10);
	int size = qMin(r.height(), r.width());
	QPixmap pixmap;
	if (1) {
	int border = size / 5;
	int sqsize = 2 * (size / 2);
	QImage image(sqsize, sqsize, QImage::Format_ARGB32_Premultiplied);
	image.fill(0);
	QPainter imagePainter(&image);

	QPolygon a;
	switch (pe) {
	case PE_IndicatorArrowUp:
	a.setPoints(3, border, sqsize / 2, sqsize / 2, border, sqsize - border, sqsize / 2);
	break;
	case PE_IndicatorArrowDown:
	a.setPoints(3, border, sqsize / 2, sqsize / 2, sqsize - border, sqsize - border, sqsize / 2);
	break;
	case PE_IndicatorArrowRight:
	a.setPoints(3, sqsize - border, sqsize / 2, sqsize / 2, border, sqsize / 2, sqsize - border);
	break;
	case PE_IndicatorArrowLeft:
	a.setPoints(3, border, sqsize / 2, sqsize / 2, border, sqsize / 2, sqsize - border);
	break;
	default:
	break;
	}

	int bsx = 0;
	int bsy = 0;

	if (option->state & State_Sunken) {
	bsx = pixelMetric(PM_ButtonShiftHorizontal, option, widget);
	bsy = pixelMetric(PM_ButtonShiftVertical, option, widget);
	}

	QRect bounds = a.boundingRect();
	int sx = sqsize / 2 - bounds.center().x() - 1;
	int sy = sqsize / 2 - bounds.center().y() - 1;
	imagePainter.translate(sx + bsx, sy + bsy);
	imagePainter.setPen(option->palette.buttonText().color());
	imagePainter.setBrush(option->palette.buttonText());
	imagePainter.setRenderHint(QPainter::Qt4CompatiblePainting);

	if (!(option->state & State_Enabled)) {
	imagePainter.translate(1, 1);
	imagePainter.setBrush(option->palette.light().color());
	imagePainter.setPen(option->palette.light().color());
	imagePainter.drawPolygon(a);
	imagePainter.translate(-1, -1);
	imagePainter.setBrush(option->palette.mid().color());
	imagePainter.setPen(option->palette.mid().color());
	}

	imagePainter.drawPolygon(a);
	imagePainter.end();
	pixmap = QPixmap::fromImage(image);
	}
	int xOffset = r.x() + (r.width() - size)/2;
	int yOffset = r.y() + (r.height() - size)/2;
	p->drawPixmap(xOffset, yOffset, pixmap);
	}
	}
	return;
	}
	if (pe == PE_PanelMenu) {
	#ifdef Q_OS_MACX
	if (qobject_cast<const QComboBox *>(widget->parent())) {
	p->fillRect(option->rect, option->palette.color(QPalette::Light));
	return;
	}
	#endif
	QRect r = option->rect;
	drawFrame(p, r, Qt::black, Qt::black);
	r = r.adjusted(1, 1, -1, -1);
	drawFrame(p, r, color(128), color(64));
	r = r.adjusted(1, 1, -1, -1);
	p->fillRect(r, color(80));
	return;
	}
	if (pe == PE_FrameMenu) {
	return;
	}
	if (pe == PE_PanelButtonBevel) {
	drawButton(p, option);
	return;
	}
	if (pe == PE_PanelStatusBar) {
	p->fillRect(option->rect, option->palette.color(QPalette::Window));
	return;
	}
	if (pe == PE_FrameTabWidget) {
	if (auto const o = qstyleoption_cast<QStyleOptionTabWidgetFrame const >(option)) {
	int x = o->rect.x();
	int y = o->rect.y();
	int w = o->rect.width();
	int h = o->rect.height();
	#ifdef Q_OS_WIN
	switch (o->shape) {
	case QTabBar::RoundedNorth:
	break;
	case QTabBar::RoundedSouth:
	h -= 1;
	break;
	case QTabBar::RoundedWest:
	break;
	case QTabBar::RoundedEast:
	w -= 2;
	break;
	}
	#endif
	drawRaisedFrame(p, QRect(x, y, w, h), o->palette);
	return;
	}
	}
	if (pe == PE_PanelLineEdit) {
	if (auto const panel = qstyleoption_cast<QStyleOptionFrame const >(option)) {
	p->fillRect(option->rect, colorForItemView(option));
	if (panel->lineWidth > 0) {
	drawFrame(p, option->rect, option->palette.color(QPalette::Shadow), option->palette.color(QPalette::Light));
	}
	}
	return;
	}
	if (pe == PE_FrameGroupBox) {
	p->save();
	p->setRenderHint(QPainter::Antialiasing);
	QRectF r = option->rect;
	r = r.adjusted(1.5, 1.5, -0.5, -0.5);
	p->setPen(option->palette.color(QPalette::Light));
	p->drawRoundedRect(r, 5, 5);
	r = r.adjusted(-1, -1, -1, -1);
	p->setPen(option->palette.color(QPalette::Dark));
	p->drawRoundedRect(r, 5, 5);
	p->restore();
	return;
	}
	if (pe == PE_PanelItemViewRow) {
	// p->drawEllipse(option->rect);
	// return;
	#ifdef Q_OS_WIN
	// thru
	#else
	return;
	#endif
	}
	if (pe == PE_PanelItemViewItem) {
	// p->fillRect(option->rect, colorForItemView(option)); // 選択枠を透過描画させるので背景は描かない
	auto DrawSelectionFrame = [&](QRect const &r){
	bool focus = widget && widget->hasFocus();
	drawSelectedItemFrame(p, r, focus);
	};
	if (auto const tableview = qobject_cast<QTableView const >(widget)) {
	#if 0
	Qt::PenStyle grid_pen_style = Qt::NoPen;
	if (tableview->showGrid()) {
	grid_pen_style = tableview->gridStyle();
	}
	if (grid_pen_style != Qt::NoPen) {
	int x = option->rect.x();
	int y = option->rect.y();
	int w = option->rect.width();
	int h = option->rect.height();
	p->fillRect(x + w - 1, y, 1, h, option->palette.color(QPalette::Dark));
	p->fillRect(x, y + h - 1, w, 1, option->palette.color(QPalette::Dark));
	}
	#endif
	QAbstractItemView::SelectionBehavior selection_behavior = tableview->selectionBehavior();
	if (option->state & State_Selected) {
	p->save();
	p->setClipRect(option->rect);
	QRect r = widget->rect();
	if (selection_behavior == QAbstractItemView::SelectionBehavior::SelectRows) {
	r = QRect(r.x(), option->rect.y(), r.width(), option->rect.height());
	} else if (selection_behavior == QAbstractItemView::SelectionBehavior::SelectRows) {
	r = QRect(option->rect.x(), r.y(), option->rect.y(), r.height());
	}
	DrawSelectionFrame(r);
	p->restore();
	}
	} else {
	if (option->state & State_Selected) {
	DrawSelectionFrame(option->rect);
	}
	}
	return;
	}
	if (pe == QStyle::PE_IndicatorBranch) {
	QColor bg = option->palette.color(QPalette::Base);
	p->fillRect(option->rect, bg);

	if (m->legacy_windows.drawPrimitive(pe, option, p, widget)) {
	return;
	}
	}
	if (pe == QStyle::PE_Widget) { // bg for messagebox
	const QDialogButtonBox *buttonBox = nullptr;

	if (qobject_cast<const QMessageBox *> (widget))
	buttonBox = widget->findChild<const QDialogButtonBox *>(QLatin1String("qt_msgbox_buttonbox"));
	#ifndef QT_NO_INPUTDIALOG
	else if (qobject_cast<const QInputDialog *> (widget))
	buttonBox = widget->findChild<const QDialogButtonBox *>(QLatin1String("qt_inputdlg_buttonbox"));
	#endif // QT_NO_INPUTDIALOG

	if (buttonBox) {
	int y = buttonBox->geometry().top();
	QRect r(option->rect.x(), y, option->rect.width(), 1);
	p->fillRect(r, option->palette.color(QPalette::Light));
	r.translate(0, -1);
	p->fillRect(r, option->palette.color(QPalette::Dark));
	}
	return;
	}
	#ifndef Q_OS_WIN
	if (pe == QStyle::PE_PanelTipLabel) {
	// ツールチップの背景パネル
	p->fillRect(option->rect, QColor(255, 255, 192));
	drawFrame(p, option->rect, Qt::black, Qt::black);
	return;
	}
	#endif
	// qDebug() << pe;
	QProxyStyle::drawPrimitive(pe, option, p, widget);
	}

	void DarkStyle::drawControl(ControlElement ce, const QStyleOption option, QPainter p, const QWidget *widget) const
	{
	// qDebug() << ce;
	bool disabled = !(option->state & State_Enabled);
	#ifdef Q_OS_MAC
	if (ce == CE_ToolBar) {
	int x = option->rect.x();
	int y = option->rect.y();
	int w = option->rect.width();
	int h = option->rect.height();
	p->fillRect(x, y + h - 1, w, 1, color(32));
	return;
	}
	#endif
	#ifdef Q_OS_LINUX
	if (ce == CE_ToolBar) {
	int x = option->rect.x();
	int y = option->rect.y();
	int w = option->rect.width();
	int h = option->rect.height();
	QColor color = option->palette.color(QPalette::Window);
	p->fillRect(x, y + h - 1, w, 1, color);
	return;
	}
	if (ce == CE_PushButtonLabel) {
	if (auto const o = qstyleoption_cast<QStyleOptionButton const >(option)) {
	QRect ir = o->rect;
	uint tf = Qt::AlignVCenter \| Qt::TextShowMnemonic;
	QPoint buttonShift;

	if (option->state & State_Sunken) {
	buttonShift = QPoint(pixelMetric(PM_ButtonShiftHorizontal, option, widget), proxy()->pixelMetric(PM_ButtonShiftVertical, option, widget));
	}

	if (proxy()->styleHint(SH_UnderlineShortcut, o, widget)) {
	tf \|= Qt::TextShowMnemonic;
	} else {
	tf \|= Qt::TextHideMnemonic;
	}

	if (!o->icon.isNull()) {
	//Center both icon and text
	QPoint point;

	QIcon::Mode mode = o->state & State_Enabled ? QIcon::Normal : QIcon::Disabled;
	if (mode == QIcon::Normal && o->state & State_HasFocus) {
	mode = QIcon::Active;
	}

	QIcon::State state = QIcon::Off;

	if (o->state & State_On) {
	state = QIcon::On;
	}

	QPixmap pixmap = o->icon.pixmap(o->iconSize, mode, state);
	int w = pixmap.width();
	int h = pixmap.height();

	if (!o->text.isEmpty()) {
	w += o->fontMetrics.boundingRect(option->rect, tf, o->text).width() + 4;
	}

	point = QPoint(ir.x() + ir.width() / 2 - w / 2, ir.y() + ir.height() / 2 - h / 2);

	if (o->direction == Qt::RightToLeft) {
	point.rx() += pixmap.width();
	}

	p->drawPixmap(visualPos(o->direction, o->rect, point + buttonShift), pixmap);

	if (o->direction == Qt::RightToLeft) {
	ir.translate(-point.x() - 2, 0);
	} else {
	ir.translate(point.x() + pixmap.width() + 2, 0);
	}

	// left-align text if there is
	if (!o->text.isEmpty()) {
	tf \|= Qt::AlignLeft;
	}

	} else {
	tf \|= Qt::AlignHCenter;
	}

	ir.translate(buttonShift);

	if (o->features & QStyleOptionButton::HasMenu) {
	ir = ir.adjusted(0, 0, -pixelMetric(PM_MenuButtonIndicator, o, widget), 0);
	}

	drawItemText(p, ir, tf, option->palette, (o->state & State_Enabled), o->text, QPalette::ButtonText);
	return;
	}
	}
	if (ce == CE_RadioButton \|\| ce == CE_CheckBox) {
	if (auto const o = qstyleoption_cast<QStyleOptionButton const >(option)) {
	bool isRadio = (ce == CE_RadioButton);

	QStyleOptionButton subopt = *o;
	subopt.rect = subElementRect(isRadio ? SE_RadioButtonIndicator : SE_CheckBoxIndicator, o, widget);
	proxy()->drawPrimitive(isRadio ? PE_IndicatorRadioButton : PE_IndicatorCheckBox, &subopt, p, widget);
	subopt.rect = subElementRect(isRadio ? SE_RadioButtonContents : SE_CheckBoxContents, o, widget);

	drawControl(isRadio ? CE_RadioButtonLabel : CE_CheckBoxLabel, &subopt, p, widget);

	if (o->state & State_HasFocus) {
	QStyleOptionFocusRect fropt;
	fropt.QStyleOption::operator=(*o);
	fropt.rect = subElementRect(isRadio ? SE_RadioButtonFocusRect : SE_CheckBoxFocusRect, o, widget);
	drawPrimitive(PE_FrameFocusRect, &fropt, p, widget);
	}
	return;
	}
	}
	if (ce == CE_RadioButtonLabel \|\| ce == CE_CheckBoxLabel) {
	if (auto const o = qstyleoption_cast<QStyleOptionButton const >(option)) {
	uint alignment = visualAlignment(o->direction, Qt::AlignLeft \| Qt::AlignVCenter);

	if (!styleHint(SH_UnderlineShortcut, o, widget)) {
	alignment \|= Qt::TextHideMnemonic;
	}
	QPixmap pix;
	QRect textRect = o->rect;
	if (!o->icon.isNull()) {
	pix = o->icon.pixmap(o->iconSize, o->state & State_Enabled ? QIcon::Normal : QIcon::Disabled);
	drawItemPixmap(p, o->rect, alignment, pix);
	if (o->direction == Qt::RightToLeft) {
	textRect.setRight(textRect.right() - o->iconSize.width() - 4);
	} else {
	textRect.setLeft(textRect.left() + o->iconSize.width() + 4);
	}
	}
	if (!o->text.isEmpty()){
	drawItemText(p, textRect, alignment \| Qt::TextShowMnemonic, o->palette, o->state & State_Enabled, o->text, QPalette::ButtonText);
	}
	return;
	}
	}
	if (ce == CE_ComboBoxLabel) {
	if (auto const o = qstyleoption_cast<QStyleOptionComboBox const >(option)) {
	QRect editRect = subControlRect(CC_ComboBox, o, SC_ComboBoxEditField, widget);

	uint alignment = Qt::AlignLeft \| Qt::AlignVCenter;

	if (!styleHint(SH_UnderlineShortcut, o, widget)) {
	alignment \|= Qt::TextHideMnemonic;
	}
	QPixmap pix;
	QRect iconRect(editRect);
	QIcon icon = o->currentIcon;
	QString text = o->currentText;
	if (!icon.isNull()) {
	pix = icon.pixmap(o->iconSize, o->state & State_Enabled ? QIcon::Normal : QIcon::Disabled);
	drawItemPixmap(p, iconRect, alignment, pix);
	if (o->direction == Qt::RightToLeft) {
	editRect.setRight(editRect.right() - o->iconSize.width() - 4);
	} else {
	editRect.setLeft(editRect.left() + o->iconSize.width() + 4);
	}
	}
	if (!text.isEmpty()){
	drawItemText(p, editRect, alignment, o->palette, o->state & State_Enabled, text, QPalette::ButtonText);
	}
	return;
	}
	}
	#endif
	if (ce == CE_ShapedFrame) {
	- if (auto const o = qstyleoption_cast<QStyleOptionFrameV3 const >(option)) {
	+ if (auto const o = qstyleoption_cast<QStyleOptionFrame const >(option)) {
	int lw = o->lineWidth;
	if (lw > 0) {
	QRect r = o->rect;
	if (o->frameShape == QFrame::Panel \|\| o->frameShape == QFrame::HLine \|\| o->frameShape == QFrame::VLine) {
	if (o->state & (State_Sunken \| State_Raised)) {
	if (r.width() < r.height()) {
	if (r.width() > 2) {
	r.adjust(0, 0, -1, 0);
	}
	} else {
	if (r.height() > 2) {
	r.adjust(0, 0, 0, -1);
	}
	}
	int x = r.x();
	int y = r.y();
	int w = r.width();
	int h = r.height();
	QColor color_topleft = o->palette.color(QPalette::Dark);
	QColor color_bottomright = o->palette.color(QPalette::Light);
	if (o->state & State_Raised) {
	std::swap(color_topleft, color_bottomright);
	}
	int t = lw;
	if (o->frameShape == QFrame::HLine) {
	y = h / 2 - t;
	h = t * 2;
	} else if (o->frameShape == QFrame::VLine) {
	x = w / 2 - t;
	w = t * 2;
	}
	p->fillRect(x, y, w - t, t, color_topleft);
	p->fillRect(x, y + t, t, h - t, color_topleft);
	p->fillRect(x + w - t, y, t, h - t, color_bottomright);
	p->fillRect(x + t, y + h - t, w - t, t, color_bottomright);
	} else {
	if (r.width() < r.height()) {
	if (lw < r.width()) {
	r = QRect(r.x() + (r.width() - lw) / 2, r.y(), lw, r.height());
	}
	} else {
	if (lw < r.height()) {
	r = QRect(r.x(), r.y() + (r.height() - lw) / 2, r.width(), lw);
	}
	}
	int x = r.x();
	int y = r.y();
	int w = r.width();
	int h = r.height();
	QColor color = o->palette.color(QPalette::Shadow);
	p->fillRect(x, y, w, h, color);
	}
	} else if (o->frameShape == QFrame::Box) {
	int x = r.x();
	int y = r.y();
	int w = r.width();
	int h = r.height();
	if (w > 1) w--;
	if (h > 1) h--;
	QColor color_topleft = o->palette.color(QPalette::Dark);
	QColor color_bottomright = o->palette.color(QPalette::Light);
	if (o->state & State_Raised) {
	std::swap(color_topleft, color_bottomright);
	}
	drawFrame(p, x + 1, y + 1, w, h, color_bottomright, color_bottomright);
	drawFrame(p, x, y, w, h, color_topleft, color_topleft);
	} else if (o->frameShape == QFrame::StyledPanel) {
	QColor color = o->palette.color(QPalette::Midlight);
	int x = r.x();
	int y = r.y();
	int w = r.width();
	int h = r.height();
	drawFrame(p, x, y, w, h, color, color);
	}
	}
	}
	return;
	}
	if (ce == CE_PushButtonBevel) {
	if (auto const o = qstyleoption_cast<QStyleOptionButton const >(option)) {
	if (o->features & QStyleOptionButton::Flat) {
	// nop
	} else {
	drawButton(p, option);
	}

	if (o->features & QStyleOptionButton::HasMenu) {
	QStyleOptionButton newBtn = *o;
	QRect rect = option->rect;
	#ifdef Q_OS_MAC
	{
	int margin = pixelMetric(PM_ButtonMargin, option, nullptr);
	if (margin > 0) {
	int n = rect.height();
	if (n > margin * 2) {
	n = (n - margin * 2) / 2;
	if (n > margin) n = margin;
	rect = rect.adjusted(n, n, -n, -n);
	}
	}
	}
	#endif
	int mbi = pixelMetric(PM_IndicatorWidth, o, widget);
	rect = QRect(rect.x() + rect.width() - mbi, rect.y(), mbi - 4, rect.height());
	newBtn.rect = rect.adjusted(1, 1, -1, -1);
	drawPrimitive(PE_IndicatorSpinDown, &newBtn, p, widget);
	}
	}
	return;
	}
	if (ce == CE_MenuBarEmptyArea) {
	drawMenuBarBG(p, option, widget);
	return;
	}
	if (ce == CE_MenuBarItem) {
	drawMenuBarBG(p, option, widget);
	if (option->state & State_Selected) {
	drawSelectedItemFrame(p, option->rect, true);
	}
	if (auto const o = qstyleoption_cast<QStyleOptionMenuItem const >(option)) {
	QPalette::ColorRole textRole = disabled ? QPalette::Text : QPalette::ButtonText;
	QPixmap pix = o->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), QIcon::Normal);
	uint alignment = Qt::AlignCenter \| Qt::TextShowMnemonic \| Qt::TextDontClip \| Qt::TextSingleLine;
	if (!styleHint(SH_UnderlineShortcut, o, widget)) {
	alignment \|= Qt::TextHideMnemonic;
	}
	if (!pix.isNull()) {
	drawItemPixmap(p, o->rect, alignment, pix);
	} else {
	drawItemText(p, o->rect, alignment, o->palette, o->state & State_Enabled, o->text, textRole);
	}
	}
	return;
	}
	if (ce == CE_MenuEmptyArea) {
	return;
	}
	if (ce == CE_MenuItem) {
	if (auto const o = qstyleoption_cast<QStyleOptionMenuItem const >(option)) {
	#ifdef Q_OS_MAC
	int checkcol = 15;
	#else
	// windows always has a check column, regardless whether we have an icon or not
	int checkcol = 25;// / QWindowsXPStylePrivate::devicePixelRatio(widget);
	#endif
	const int gutterWidth = 3;// / QWindowsXPStylePrivate::devicePixelRatio(widget);
	QRect rect = option->rect;

	bool ignoreCheckMark = false;
	if (qobject_cast<const QComboBox*>(widget)) {
	// bg
	p->fillRect(option->rect, option->palette.color(QPalette::Light));
	#ifndef Q_OS_MACX
	ignoreCheckMark = true; //ignore the checkmarks provided by the QComboMenuDelegate
	#endif
	}

	//draw vertical menu line
	if (option->direction == Qt::LeftToRight) {
	checkcol += rect.x();
	}

	int x, y, w, h;
	o->rect.getRect(&x, &y, &w, &h);
	int tab = o->tabWidth;
	bool dis = !(o->state & State_Enabled);
	bool checked = (o->checkType != QStyleOptionMenuItem::NotCheckable) && o->checked;
	bool act = o->state & State_Selected;

	if (o->menuItemType == QStyleOptionMenuItem::Separator) {
	QRect r = option->rect.adjusted(2, 0, -2, 0);
	drawGutter(p, r);
	return;
	}

	#ifdef Q_OS_MAC
	// qDebug() << pixelMetric(PM_SmallIconSize, option, widget);
	QRect vCheckRect = visualRect(option->direction, o->rect, QRect(o->rect.x(), o->rect.y(), 20 - (gutterWidth + o->rect.x()), o->rect.height()));
	#else
	QRect vCheckRect = visualRect(option->direction, o->rect, QRect(o->rect.x(), o->rect.y(), checkcol - (gutterWidth + o->rect.x()), o->rect.height()));
	#endif

	if (act) {
	drawSelectedItemFrame(p, option->rect, true);
	}

	int xm = windowsItemFrame;
	#ifdef Q_OS_WIN
	xm += windowsItemHMargin + (gutterWidth - o->rect.x()) - 1;
	#endif
	if (!ignoreCheckMark) {
	xm += checkcol;
	}

	int xpos = o->rect.x() + xm;

	if (checked && !ignoreCheckMark) {
	const qreal boxMargin = 3.5;
	const qreal boxWidth = checkcol - 2 * boxMargin;
	const int checkColHOffset = windowsItemHMargin + windowsItemFrame - 1;
	#ifdef Q_OS_MAC
	QRectF checkRectF(0, option->rect.y(), xpos, option->rect.height());
	QRect checkRect = checkRectF.toRect();
	checkRect.setWidth(checkRect.height());
	checkRect.adjust(windowsItemFrame + (xpos - windowsItemFrame - checkRect.width()) / 2, 0, 0, 0);
	#else
	QRectF checkRectF(option->rect.left() + boxMargin + checkColHOffset, option->rect.center().y() - boxWidth / 2 + 1, boxWidth, boxWidth);
	QRect checkRect = checkRectF.toRect();
	checkRect.setWidth(checkRect.height()); // avoid .toRect() round error results in non-perfect square
	#endif
	checkRect = visualRect(o->direction, o->rect, checkRect);

	QStyleOptionButton box;
	box.QStyleOption::operator=(*option);
	box.rect = checkRect;
	if (checked) {
	box.state \|= State_On;
	}
	drawPrimitive(PE_IndicatorCheckBox, &box, p, widget);
	}


	if (!ignoreCheckMark) {
	if (!o->icon.isNull()) {
	QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
	if (act && !dis) {
	mode = QIcon::Active;
	}
	QPixmap pixmap;
	if (checked) {
	pixmap = o->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode, QIcon::On);
	} else {
	pixmap = o->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode);
	}
	double dpr = pixmap.devicePixelRatio();
	if (dpr > 0) {
	const int pixw = int(pixmap.width() / dpr);
	const int pixh = int(pixmap.height() / dpr);
	#ifdef Q_OS_MAC
	QRect pmr(xpos, vCheckRect.y() + (vCheckRect.height() - pixh) / 2, pixw, pixh);
	p->setPen(o->palette.text().color());
	p->drawPixmap(pmr.topLeft(), pixmap);
	xpos += pmr.width() + 4;
	#else
	QRect pmr(0, 0, pixw, pixh);
	pmr.moveCenter(vCheckRect.center());
	p->setPen(o->palette.text().color());
	p->drawPixmap(pmr.topLeft(), pixmap);
	#endif
	}
	}
	} else {
	if (o->icon.isNull()) {
	checkcol = 0;
	} else {
	checkcol = o->maxIconWidth;
	}
	}

	p->setPen(o->palette.buttonText().color());

	const QColor textColor = o->palette.text().color();
	if (dis) {
	p->setPen(textColor);
	}

	QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
	QRect vTextRect = visualRect(option->direction, o->rect, textRect);
	QString s = o->text;
	if (!s.isEmpty()) { // draw text
	p->save();
	int t = s.indexOf(QLatin1Char('\t'));
	int text_flags = Qt::AlignVCenter \| Qt::TextShowMnemonic \| Qt::TextDontClip \| Qt::TextSingleLine;
	if (!styleHint(SH_UnderlineShortcut, o, widget)) {
	text_flags \|= Qt::TextHideMnemonic;
	}
	text_flags \|= Qt::AlignLeft;
	if (t >= 0) {
	QRect vShortcutRect = visualRect(option->direction, o->rect, QRect(textRect.topRight(), QPoint(o->rect.right(), textRect.bottom())));
	p->drawText(vShortcutRect, text_flags, s.mid(t + 1));
	s = s.left(t);
	}
	QFont font = o->font;
	if (o->menuItemType == QStyleOptionMenuItem::DefaultItem) {
	font.setBold(true);
	}
	p->setFont(font);
	p->setPen(textColor);
	p->drawText(vTextRect, text_flags, s.left(t));
	p->restore();
	}
	if (o->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
	int dim = (h - 2 * windowsItemFrame) / 2;
	PrimitiveElement arrow;
	arrow = (option->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
	xpos = x + w - windowsArrowHMargin - windowsItemFrame - dim;
	QRect vSubMenuRect = visualRect(option->direction, o->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim));
	QStyleOptionMenuItem newMI = *o;
	newMI.rect = vSubMenuRect;
	newMI.state = dis ? State_None : State_Enabled;
	drawPrimitive(arrow, &newMI, p, widget);
	}
	}
	return;
	}
	if (ce == CE_TabBarTabShape) {
	#ifdef Q_OS_MAC
	if (auto const o = qstyleoption_cast<QStyleOptionTab const >(option)) {
	drawButton(p, option, false);
	bool selected = o->state & State_Selected;
	if (selected) {
	drawSelectedItemFrame(p, o->rect.adjusted(0, 0, -2, -2), widget);
	}
	return;
	}
	#else
	if (auto const o = qstyleoption_cast<QStyleOptionTab const >(option)) {
	bool rtlHorTabs = (o->direction == Qt::RightToLeft && (o->shape == QTabBar::RoundedNorth \|\| o->shape == QTabBar::RoundedSouth));
	bool selected = o->state & State_Selected;
	bool lastTab = ((!rtlHorTabs && o->position == QStyleOptionTab::End) \|\| (rtlHorTabs && o->position == QStyleOptionTab::Beginning));
	bool firstTab = ((!rtlHorTabs && o->position == QStyleOptionTab::Beginning) \|\| (rtlHorTabs && o->position == QStyleOptionTab::End));
	bool onlyOne = o->position == QStyleOptionTab::OnlyOneTab;
	bool previousSelected = ((!rtlHorTabs && o->selectedPosition == QStyleOptionTab::PreviousIsSelected) \|\| (rtlHorTabs && o->selectedPosition == QStyleOptionTab::NextIsSelected));
	bool nextSelected = ((!rtlHorTabs && o->selectedPosition == QStyleOptionTab::NextIsSelected) \|\| (rtlHorTabs && o->selectedPosition == QStyleOptionTab::PreviousIsSelected));
	int tabBarAlignment = proxy()->styleHint(SH_TabBar_Alignment, o, widget);
	bool leftAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignLeft) \|\| (rtlHorTabs && tabBarAlignment == Qt::AlignRight);
	bool rightAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignRight) \|\| (rtlHorTabs && tabBarAlignment == Qt::AlignLeft);

	QColor light = o->palette.light().color();
	// QColor dark = o->palette.dark().color();
	QColor shadow = o->palette.shadow().color();
	int borderThinkness = proxy()->pixelMetric(PM_TabBarBaseOverlap, o, widget);
	if (selected) {
	borderThinkness /= 2;
	}
	QRect r2(option->rect);
	int x1 = r2.left();
	int x2 = r2.right();
	int y1 = r2.top();
	int y2 = r2.bottom();
	switch (o->shape) {
	default:
	QProxyStyle::drawControl(ce, o, p, widget);
	break;
	case QTabBar::RoundedNorth:
	{
	#ifdef Q_OS_WIN
	if (selected) {
	y2 += 2;
	} else {
	y2 += 1;
	y1 += 2;
	x1 += onlyOne \|\| firstTab ? borderThinkness : 0;
	x2 -= onlyOne \|\| lastTab ? borderThinkness : 0;
	}
	#elif 1
	if (selected) {
	y2 += 2;
	} else {
	y2 += 1;
	y1 += 2;
	x1 += onlyOne \|\| firstTab ? borderThinkness : 0;
	x2 -= onlyOne \|\| lastTab ? borderThinkness : 0;
	}

	#else
	if (!selected) {
	y1 += 2;
	x1 += onlyOne \|\| firstTab ? borderThinkness : 0;
	x2 -= onlyOne \|\| lastTab ? borderThinkness : 0;
	}
	#endif

	p->fillRect(QRect(x1 + 1, y1 + 1, (x2 - x1) - 1, (y2 - y1) - 2), o->palette.background());

	// Left
	if (firstTab \|\| selected \|\| onlyOne \|\| !previousSelected) {
	p->setPen(light);
	p->drawLine(x1, y1 + 2, x1, y2 - 1 - ((onlyOne \|\| firstTab) && selected && leftAligned ? 0 : borderThinkness));
	p->drawPoint(x1 + 1, y1 + 1);
	}
	// Top
	{
	int beg = x1 + (previousSelected ? 0 : 2);
	int end = x2 - (nextSelected ? 0 : 2);
	p->setPen(light);
	p->drawLine(beg, y1, end, y1);
	}
	// Right
	if (lastTab \|\| selected \|\| onlyOne \|\| !nextSelected) {
	p->setPen(shadow);
	p->drawLine(x2, y1 + 2, x2, y2 - 1 - ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness));
	p->drawPoint(x2 - 1, y1 + 1);
	}
	break;
	}
	case QTabBar::RoundedSouth:
	{
	#ifdef Q_OS_WIN
	if (selected) {
	y1 -= 2;
	} else {
	x1 -= 1;
	y1 -= 1;
	y2 -= 2;
	x1 += firstTab ? borderThinkness : 0;
	x2 -= lastTab ? borderThinkness : 0;
	}
	#elif 1
	if (selected) {
	y1 -= 2;
	} else {
	y1 -= 1;
	y2 -= 2;
	x1 += firstTab ? borderThinkness : 0;
	x2 -= lastTab ? borderThinkness : 0;
	}
	#else
	if (!selected) {
	y2 -= 2;
	x1 += firstTab ? borderThinkness : 0;
	x2 -= lastTab ? borderThinkness : 0;
	}
	#endif

	p->fillRect(QRect(x1 + 1, y1 + 2, (x2 - x1) - 1, (y2 - y1) - 1), o->palette.background());

	// Left
	if (firstTab \|\| selected \|\| onlyOne \|\| !previousSelected) {
	p->setPen(light);
	p->drawLine(x1, y2 - 2, x1, y1 + ((onlyOne \|\| firstTab) && selected && leftAligned ? 0 : borderThinkness));
	p->drawPoint(x1 + 1, y2 - 1);
	}
	// Bottom
	{
	int beg = x1 + (previousSelected ? 0 : 2);
	int end = x2 - (nextSelected ? 0 : 2);
	p->setPen(shadow);
	p->drawLine(beg, y2, end, y2);
	}
	// Right
	if (lastTab \|\| selected \|\| onlyOne \|\| !nextSelected) {
	p->setPen(shadow);
	p->drawLine(x2, y2 - 2, x2, y1 + ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness));
	p->drawPoint(x2 - 1, y2 - 1);
	}
	break; }
	case QTabBar::RoundedWest:
	{
	#ifdef Q_OS_WIN
	if (selected) {
	x2 += 1;
	} else {
	x1 += 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}
	#elif 1
	if (selected) {
	x2 += 1;
	} else {
	x1 += 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}
	#else
	if (!selected) {
	x1 += 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}
	#endif

	p->fillRect(QRect(x1 + 1, y1 + 1, (x2 - x1) - 1, (y2 - y1) - 1), o->palette.background());

	// Top
	if (firstTab \|\| selected \|\| onlyOne \|\| !previousSelected) {
	p->setPen(light);
	p->drawLine(x1 + 2, y1, x2 - ((onlyOne \|\| firstTab) && selected && leftAligned ? 0 : borderThinkness), y1);
	p->drawPoint(x1 + 1, y1 + 1);
	}
	// Left
	{
	int beg = y1 + (previousSelected ? 0 : 2);
	int end = y2 - (nextSelected ? 0 : 2);
	p->setPen(light);
	p->drawLine(x1, beg, x1, end);
	}
	// Bottom
	if (lastTab \|\| selected \|\| onlyOne \|\| !nextSelected) {
	p->setPen(shadow);
	p->drawLine(x1 + 2, y2, x2 - ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness), y2);
	p->drawPoint(x1 + 1, y2 - 1);
	}
	break;
	}
	case QTabBar::RoundedEast:
	{
	#ifdef Q_OS_WIN
	if (selected) {
	x1 -= 2;
	} else {
	y1 -= 2;
	x1 -= 1;
	x2 -= 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}
	#elif 1
	if (selected) {
	x1 -= 2;
	} else {
	x1 -= 1;
	x2 -= 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}
	#else
	if (!selected) {
	x2 -= 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}
	#endif

	p->fillRect(QRect(x1 + 2, y1 + 1, (x2 - x1) - 1, (y2 - y1) - 1), o->palette.background());

	// Top
	if (firstTab \|\| selected \|\| onlyOne \|\| !previousSelected) {
	p->setPen(light);
	p->drawLine(x2 - 2, y1, x1 - 1 + ((onlyOne \|\| firstTab) && selected && leftAligned ? 0 : borderThinkness), y1);
	p->drawPoint(x2 - 1, y1 + 1);
	}
	// Right
	{
	int beg = y1 + (previousSelected ? 0 : 2);
	int end = y2 - (nextSelected ? 0 : 2);
	p->setPen(shadow);
	p->drawLine(x2, beg, x2, end);
	}
	// Bottom
	if (lastTab \|\| selected \|\| onlyOne \|\| !nextSelected) {
	p->setPen(shadow);
	p->drawLine(x2 - 2, y2, x1 - 1 + ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness), y2);
	p->drawPoint(x2 - 1, y2 - 1);
	}
	break;
	}
	}
	}
	#endif
	return;
	}
	if (ce == CE_ProgressBarGroove \|\| ce == CE_ProgressBarContents) {
	if (auto const o = qstyleoption_cast<QStyleOptionProgressBar const >(option)) {

	QColor color(0, 128, 255);

	bool horz = (o->orientation == Qt::Horizontal);

	QString key;
	QImage const *image;

	if (horz) {
	key = "horz";
	image = &m->progress_horz;
	} else {
	key = "vert";
	image = &m->progress_vert;
	}

	p->save();

	int x = option->rect.x();
	int y = option->rect.y();
	int w = option->rect.width();
	int h = option->rect.height();
	if (ce == CE_ProgressBarContents) {
	int len = o->progress - o->minimum;
	int div = o->maximum - o->minimum;
	bool inv = o->invertedAppearance;
	if (horz) {
	int v = div > 0 ? (w * len / div) : 0;
	if (inv) {
	x = x + w - v;
	}
	w = v;
	} else {
	int v = div > 0 ? (h * len / div) : 0;
	if (!inv) {
	y = y + h - v;
	}
	h = v;
	}
	QRect r(x, y, w, h);
	p->setClipRect(r);
	p->fillRect(option->rect, color);
	}
	QPixmap pm;
	QSize size(w, h);
	key = pixmapkey("progress_bar", key, size, m->base_color);
	if (!QPixmapCache::find(key, &pm)) {
	QImage im = image->scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
	pm = QPixmap::fromImage(im);
	QPixmapCache::insert(key, pm);
	}
	p->setOpacity(0.5);
	p->drawPixmap(option->rect, pm, pm.rect());

	p->restore();
	}
	return;
	}
	if (ce == CE_HeaderSection \|\| ce == CE_HeaderEmptyArea) {
	bool horz = true;
	if (auto const o = qstyleoption_cast<QStyleOptionHeader const >(option)) {
	horz = (o->orientation == Qt::Horizontal);
	}
	int x = option->rect.x();
	int y = option->rect.y();
	int w = option->rect.width();
	int h = option->rect.height();
	QLinearGradient gradient;
	gradient.setStart(x, y);
	gradient.setFinalStop(x, y + h / 4.0);
	gradient.setColorAt(0, option->palette.color(QPalette::Light));
	gradient.setColorAt(1, option->palette.color(QPalette::Window));
	p->fillRect(x, y, w, h, gradient);
	p->fillRect(x, y + h - 1, w, 1, option->palette.color(QPalette::Dark));
	if (horz) {
	p->fillRect(x + w - 1, y, 1, h, option->palette.color(QPalette::Dark));
	}
	if (ce == CE_HeaderSection) {
	if (horz) {
	p->fillRect(x, y, 1, h, option->palette.color(QPalette::Light));
	}
	if (option->state & QStyle::State_MouseOver) {
	p->save();
	p->fillRect(x, y, w, h, QColor(255, 255, 255, 32));
	p->restore();
	}
	}
	if (option->state & QStyle::State_Sunken) {
	drawFocusFrame(p, option->rect.adjusted(0, 0, -1, -1), 0);
	}
	return;
	}
	if (ce == CE_HeaderLabel) {
	if (auto const o = qstyleoption_cast<QStyleOptionHeader const >(option)) {
	QRect rect = o->rect;
	if (!o->icon.isNull()) {
	int iconExtent = pixelMetric(PM_SmallIconSize, option, widget);
	QPixmap pixmap = o->icon.pixmap(QSize(iconExtent, iconExtent), (o->state & State_Enabled) ? QIcon::Normal : QIcon::Disabled);
	int pixw = int(pixmap.width() / pixmap.devicePixelRatio());

	QRect aligned = alignedRect(o->direction, QFlag(o->iconAlignment), pixmap.size() / pixmap.devicePixelRatio(), rect);
	QRect inter = aligned.intersected(rect);
	p->drawPixmap(inter.x(), inter.y(), pixmap, inter.x() - aligned.x(), inter.y() - aligned.y(), int(aligned.width() * pixmap.devicePixelRatio()), int(pixmap.height() * pixmap.devicePixelRatio()));

	const int margin = pixelMetric(QStyle::PM_HeaderMargin, option, widget);
	if (o->direction == Qt::LeftToRight) {
	rect.setLeft(rect.left() + pixw + margin);
	} else {
	rect.setRight(rect.right() - pixw - margin);
	}
	}
	if (o->state & QStyle::State_On) {
	QFont fnt = p->font();
	fnt.setBold(true);
	p->setFont(fnt);
	}
	int leftmargin = 0;
	auto align = o->textAlignment;
	if (align & Qt::AlignLeft) {
	leftmargin += 4;
	}
	drawItemText(p, rect.adjusted(leftmargin, 0, 0, 0), align, o->palette, (o->state & State_Enabled), o->text, QPalette::ButtonText);
	}
	return;
	}
	#ifdef Q_OS_MAC
	if (ce == CE_DockWidgetTitle) {
	if (auto const o = qstyleoption_cast<QStyleOptionDockWidget const >(option)) {
	auto const dockWidget = qobject_cast<QDockWidget const >(widget);
	QRect rect = option->rect;
	if (dockWidget && dockWidget->isFloating()) {
	QProxyStyle::drawControl(ce, option, p, widget);
	return;
	}

	auto const v2 = qstyleoption_cast<const QStyleOptionDockWidgetV2>(o);
	bool verticalTitleBar = v2 && v2->verticalTitleBar;

	if (verticalTitleBar) {
	rect.setSize(rect.size().transposed());

	p->translate(rect.left() - 1, rect.top() + rect.width());
	p->rotate(-90);
	p->translate(-rect.left() + 1, -rect.top());
	}

	p->setBrush(option->palette.background().color().darker(110));
	p->setPen(option->palette.background().color().darker(130));
	p->drawRect(rect.adjusted(0, 1, -1, -3));

	int buttonMargin = 4;
	int mw = proxy()->pixelMetric(QStyle::PM_DockWidgetTitleMargin, o, widget);
	int fw = proxy()->pixelMetric(PM_DockWidgetFrameWidth, o, widget);
	auto const dw = qobject_cast<const QDockWidget >(widget);
	bool isFloating = dw && dw->isFloating();

	QRect r = option->rect.adjusted(0, 2, -1, -3);
	QRect titleRect = r;

	if (o->closable) {
	QSize sz = proxy()->standardIcon(QStyle::SP_TitleBarCloseButton, o, widget).actualSize(QSize(10, 10));
	titleRect.adjust(0, 0, -sz.width() - mw - buttonMargin, 0);
	}

	if (o->floatable) {
	QSize sz = proxy()->standardIcon(QStyle::SP_TitleBarMaxButton, o, widget).actualSize(QSize(10, 10));
	titleRect.adjust(0, 0, -sz.width() - mw - buttonMargin, 0);
	}

	if (isFloating) {
	titleRect.adjust(0, -fw, 0, 0);
	if (widget && widget->windowIcon().cacheKey() != QApplication::windowIcon().cacheKey()) {
	titleRect.adjust(titleRect.height() + mw, 0, 0, 0);
	}
	} else {
	titleRect.adjust(mw, 0, 0, 0);
	if (!o->floatable && !o->closable) {
	titleRect.adjust(0, 0, -mw, 0);
	}
	}
	if (!verticalTitleBar) {
	titleRect = visualRect(o->direction, r, titleRect);
	}

	if (!o->title.isEmpty()) {
	QString titleText = p->fontMetrics().elidedText(o->title, Qt::ElideRight, verticalTitleBar ? titleRect.height() : titleRect.width());
	const int indent = 4;
	int align = Qt::AlignRight \| Qt::AlignVCenter;
	drawItemText(p, rect.adjusted(indent + 1, 1, -indent - 1, -1), align, o->palette, o->state & State_Enabled, titleText, QPalette::WindowText);
	}
	}
	return;
	}
	#endif // Q_OS_MAC
	#ifdef Q_OS_LINUX
	if (ce == CE_Splitter) {
	p->fillRect(option->rect, option->palette.color(QPalette::Window));
	return;
	}
	#endif
	if (ce == CE_ItemViewItem) {
	#if 0
	if (auto const o = qstyleoption_cast<QStyleOptionViewItem const >(option)) {
	p->save();
	p->setFont(o->font);
	drawPrimitive(PE_PanelItemViewItem, option, p, widget);
	drawItemText(p, o->rect.adjusted(2, 0, 0, 0), o->displayAlignment, option->palette, true, o->text);
	p->restore();
	return;
	}
	#else
	if (auto const o = qstyleoption_cast<QStyleOptionViewItem const >(option)) {
	p->save();
	p->setClipRect(o->rect);

	QRect checkRect = subElementRect(SE_ItemViewItemCheckIndicator, o, widget);
	QRect iconRect = subElementRect(SE_ItemViewItemDecoration, o, widget);
	QRect textRect = subElementRect(SE_ItemViewItemText, o, widget);
	textRect.adjust(2, 0, 0, 0);

	// draw the background
	drawPrimitive(PE_PanelItemViewItem, o, p, widget);

	// draw the check mark
	if (o->features & QStyleOptionViewItem::HasCheckIndicator) {
	QStyleOptionViewItem o2(*o);
	o2.rect = checkRect;
	o2.state = o2.state & ~QStyle::State_HasFocus;

	switch (o->checkState) {
	case Qt::Unchecked:
	o2.state \|= QStyle::State_Off;
	break;
	case Qt::PartiallyChecked:
	o2.state \|= QStyle::State_NoChange;
	break;
	case Qt::Checked:
	o2.state \|= QStyle::State_On;
	break;
	}
	drawPrimitive(QStyle::PE_IndicatorViewItemCheck, &o2, p, widget);
	}

	// draw the icon
	QIcon::Mode mode = QIcon::Normal;
	if (!(o->state & QStyle::State_Enabled)) {
	mode = QIcon::Disabled;
	} else if (o->state & QStyle::State_Selected) {
	mode = QIcon::Selected;
	}
	QIcon::State state = o->state & QStyle::State_Open ? QIcon::On : QIcon::Off;
	o->icon.paint(p, iconRect, o->decorationAlignment, mode, state);

	// draw the text
	if (!o->text.isEmpty()) {
	QPalette::ColorGroup cg = o->state & QStyle::State_Enabled ? QPalette::Normal : QPalette::Disabled;
	if (cg == QPalette::Normal && !(o->state & QStyle::State_Active)) {
	cg = QPalette::Inactive;
	}
	if (o->state & QStyle::State_Selected) {
	p->setPen(o->palette.color(cg, QPalette::HighlightedText));
	} else {
	p->setPen(o->palette.color(cg, QPalette::Text));
	}
	if (o->state & QStyle::State_Editing) {
	p->setPen(o->palette.color(cg, QPalette::Text));
	p->drawRect(textRect.adjusted(0, 0, -1, -1));
	}
	drawItemViewText(p, o, textRect, true);
	}

	#if 0
	// draw the focus rect
	if (o->state & QStyle::State_HasFocus) {
	QStyleOptionFocusRect o3;
	o3.QStyleOption::operator=(*o);
	o3.rect = subElementRect(SE_ItemViewItemFocusRect, o, widget);
	o3.state \|= QStyle::State_KeyboardFocusChange;
	o3.state \|= QStyle::State_Item;
	QPalette::ColorGroup cg = (o->state & QStyle::State_Enabled) ? QPalette::Normal : QPalette::Disabled;
	o3.backgroundColor = o->palette.color(cg, (o->state & QStyle::State_Selected) ? QPalette::Highlight : QPalette::Window);
	drawPrimitive(PE_FrameFocusRect, &o3, p, widget);
	}
	#endif

	p->restore();
	}
	return;
	#endif
	}
	if (ce == CE_Header) {
	drawControl(CE_HeaderSection, option, p, widget);
	drawControl(CE_HeaderLabel, option, p, widget);
	return;
	}
	if (ce == CE_TabBarTab) {
	drawControl(CE_TabBarTabShape, option, p, widget);
	drawControl(CE_TabBarTabLabel, option, p, widget);
	return;
	}
	if (ce == CE_PushButton) {
	drawControl(CE_PushButtonBevel, option, p, widget);
	drawControl(CE_PushButtonLabel, option, p, widget);
	return;
	}
	if (ce == CE_ProgressBar) {
	drawControl(CE_ProgressBarGroove, option, p, widget);
	drawControl(CE_ProgressBarContents, option, p, widget);
	return;
	}
	// qDebug() << ce;
	QProxyStyle::drawControl(ce, option, p, widget);
	}

	void DarkStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex option, QPainter p, const QWidget *widget) const
	{
	// qDebug() << cc;
	if (cc == QStyle::CC_ComboBox) {
	if (auto const o = qstyleoption_cast<QStyleOptionComboBox const >(option)) {
	SubControls sub = option->subControls;
	if (o->editable) {
	#define EP_EDITBORDER_NOSCROLL 6
	#define EP_EDITBORDER_HVSCROLL 9
	if (sub & SC_ComboBoxEditField) {
	p->fillRect(option->rect, option->palette.color(QPalette::Dark));
	drawFrame(p, option->rect, option->palette.color(QPalette::Shadow), option->palette.color(QPalette::Light));
	}
	if (sub & SC_ComboBoxArrow) {
	QRect subRect = subControlRect(CC_ComboBox, option, SC_ComboBoxArrow, widget);
	QStyleOptionComplex opt = *option;
	opt.rect = subRect;
	drawToolButton(p, &opt);
	opt.rect = QRect(subRect.right() - 4, subRect.y() + subRect.height() / 2 - 1, 2, 2);
	drawPrimitive(PE_IndicatorArrowDown, &opt, p, widget);
	}

	} else {
	if (sub & SC_ComboBoxFrame) {
	QStyleOptionButton btn;
	btn.QStyleOption::operator=(*option);
	btn.rect = option->rect.adjusted(-1, -1, 1, 1);
	if (sub & SC_ComboBoxArrow) {
	btn.features = QStyleOptionButton::HasMenu;
	}
	drawControl(QStyle::CE_PushButton, &btn, p, widget);
	}
	}
	}
	return;
	}
	if (cc == QStyle::CC_ToolButton) {
	QStyle::State flags = option->state;
	if (auto const o = qstyleoption_cast<QStyleOptionToolButton const >(option)) {
	QRect button, menuarea;
	button = subControlRect(cc, o, SC_ToolButton, widget);
	menuarea = subControlRect(cc, o, SC_ToolButtonMenu, widget);

	State bflags = o->state & ~State_Sunken;
	State mflags = bflags;
	bool autoRaise = flags & State_AutoRaise;
	if (autoRaise) {
	if (!(bflags & State_MouseOver) \|\| !(bflags & State_Enabled)) {
	bflags &= ~State_Raised;
	}
	}

	if (o->state & State_Sunken) {
	if (o->activeSubControls & SC_ToolButton) {
	bflags \|= State_Sunken;
	mflags \|= State_MouseOver \| State_Sunken;
	} else if (o->activeSubControls & SC_ToolButtonMenu) {
	mflags \|= State_Sunken;
	bflags \|= State_MouseOver;
	}
	}

	QStyleOption tool(0);
	tool.palette = o->palette;
	if (o->subControls & SC_ToolButton) {
	if (flags & (State_Sunken \| State_On \| State_Raised) \|\| !autoRaise) {
	tool.rect = option->rect;
	tool.state = bflags;
	drawToolButton(p, &tool);
	}
	}

	if (o->state & State_HasFocus) {
	QStyleOptionFocusRect fr;
	fr.QStyleOption::operator=(*o);
	fr.rect.adjust(3, 3, -3, -3);
	if (o->features & QStyleOptionToolButton::MenuButtonPopup) {
	fr.rect.adjust(0, 0, -pixelMetric(QStyle::PM_MenuButtonIndicator, o, widget), 0);
	}
	drawPrimitive(PE_FrameFocusRect, &fr, p, widget);
	}
	QStyleOptionToolButton label = *o;
	label.state = bflags;
	int fw = 2;
	if (!autoRaise)
	label.state &= ~State_Sunken;
	label.rect = button.adjusted(fw, fw, -fw, -fw);
	drawControl(CE_ToolButtonLabel, &label, p, widget);

	if (o->subControls & SC_ToolButtonMenu) {
	tool.rect = menuarea;
	tool.state = mflags;
	if (autoRaise) {
	drawPrimitive(PE_IndicatorButtonDropDown, &tool, p, widget);
	} else {
	tool.state = mflags;
	menuarea.adjust(-2, 0, 0, 0);
	// Draw menu button
	if ((bflags & State_Sunken) != (mflags & State_Sunken)){
	p->save();
	p->setClipRect(menuarea);
	tool.rect = option->rect;
	drawToolButton(p, &tool);
	p->restore();
	}
	// Draw arrow
	p->save();
	p->setPen(option->palette.dark().color());
	p->drawLine(menuarea.left(), menuarea.top() + 3, menuarea.left(), menuarea.bottom() - 3);
	p->setPen(option->palette.light().color());
	p->drawLine(menuarea.left() - 1, menuarea.top() + 3, menuarea.left() - 1, menuarea.bottom() - 3);

	tool.rect = menuarea.adjusted(2, 3, -2, -1);
	drawPrimitive(PE_IndicatorArrowDown, &tool, p, widget);
	p->restore();
	}
	} else if (o->features & QStyleOptionToolButton::HasMenu) {
	int mbi = pixelMetric(PM_MenuButtonIndicator, o, widget);
	QRect ir = o->rect;
	QStyleOptionToolButton newBtn = *o;
	newBtn.rect = QRect(ir.right() + 4 - mbi, ir.height() - mbi + 4, mbi - 5, mbi - 5);
	drawPrimitive(PE_IndicatorArrowDown, &newBtn, p, widget);
	}
	}
	return;
	}
	if (cc == QStyle::CC_ScrollBar) {
	bool ishorz = (option->state & State_Horizontal);
	auto tx = const_cast<ScrollBarTextures >(ishorz ? &m->hsb : &m->vsb);

	int extent = (ishorz ? tx->slider.im_normal.height() : tx->slider.im_normal.width()) - 2;

	auto DrawNinePatchImage2 = [&](QImage const &image, QRect const &r){
	int w, h;
	if (ishorz) {
	h = extent;
	int d = r.height();
	w = (d == 0) ? 0 : (h * r.width() / d);
	} else {
	w = extent;
	int d = r.width();
	h = (d == 0) ? 0 : (w * r.height() / d);
	}
	drawNinePatchImage(p, image, r, w, h);
	};

	p->fillRect(option->rect, color(64));
	p->setRenderHint(QPainter::Antialiasing);

	{
	#ifdef Q_OS_MAC
	QRect r = option->rect;
	#else
	QRect r1 = subControlRect(CC_ScrollBar, option, SC_ScrollBarAddPage, widget);
	QRect r2 = subControlRect(CC_ScrollBar, option, SC_ScrollBarSubPage, widget);
	QRect r = r1.united(r2);
	#endif
	DrawNinePatchImage2(tx->page_bg, r);
	}

	#ifndef Q_OS_MAC // macOSのスクロールバーには、ラインステップボタンが無い
	{
	QRect r = subControlRect(CC_ScrollBar, option, SC_ScrollBarSubLine, widget);
	DrawNinePatchImage2(tx->page_bg, r);
	}
	{
	QRect r = subControlRect(CC_ScrollBar, option, SC_ScrollBarAddLine, widget);
	DrawNinePatchImage2(tx->page_bg, r);
	}

	auto DrawAddSubButton = [&](ButtonImages const &ims, SubControl subctl){
	QRect r = subControlRect(CC_ScrollBar, option, subctl, widget);
	QPixmap pm;;
	if (!(option->activeSubControls & subctl)) {
	pm = pixmapFromImage(ims.im_normal, r.size());
	p->drawPixmap(r.topLeft(), pm);
	} else {
	pm = pixmapFromImage(ims.im_hover, r.size());
	p->drawPixmap(r.topLeft(), pm);
	}
	};
	DrawAddSubButton(tx->sub_line, SC_ScrollBarSubLine);
	DrawAddSubButton(tx->add_line, SC_ScrollBarAddLine);
	#endif

	{
	QRect r = subControlRect(CC_ScrollBar, option, SC_ScrollBarSlider, widget);
	int w, h;
	if (ishorz) {
	h = extent;
	int d = r.height();
	w = (d == 0) ? 0 : (h * r.width() / d);
	} else {
	w = extent;
	int d = r.width();
	h = (d == 0) ? 0 : (w * r.height() / d);
	}
	#ifdef Q_OS_MAC // macだとズレて見えるので調整する
	if (ishorz) {
	r = r.translated(1, 0);
	} else {
	r = r.translated(0, 1);
	}
	#endif
	if (!(option->activeSubControls & SC_ScrollBarSlider)) {
	DrawNinePatchImage2(tx->slider.im_normal, r);
	} else {
	DrawNinePatchImage2(tx->slider.im_hover, r);
	}
	}

	return;
	}
	if (cc == CC_GroupBox) {
	if (auto const o = qstyleoption_cast<QStyleOptionGroupBox const >(option)) {
	QRect textRect = subControlRect(CC_GroupBox, option, SC_GroupBoxLabel, widget);
	QRect checkBoxRect = subControlRect(CC_GroupBox, option, SC_GroupBoxCheckBox, widget);
	if (o->subControls & QStyle::SC_GroupBoxFrame) {
	QStyleOptionFrame frame;
	frame.QStyleOption::operator=(*o);
	frame.features = o->features;
	frame.lineWidth = o->lineWidth;
	frame.midLineWidth = o->midLineWidth;
	frame.rect = subControlRect(CC_GroupBox, option, SC_GroupBoxFrame, widget);
	p->save();
	QRegion region(o->rect);
	if (!o->text.isEmpty()) {
	bool ltr = o->direction == Qt::LeftToRight;
	QRect finalRect;
	if (o->subControls & QStyle::SC_GroupBoxCheckBox) {
	finalRect = checkBoxRect.united(textRect);
	finalRect.adjust(ltr ? -4 : 0, 0, ltr ? 0 : 4, 0);
	} else {
	finalRect = textRect;
	}
	region -= finalRect;
	}
	p->setClipRegion(region);
	drawPrimitive(PE_FrameGroupBox, &frame, p, widget);
	p->restore();
	}
	// Draw title
	if ((o->subControls & QStyle::SC_GroupBoxLabel) && !o->text.isEmpty()) {
	QColor textColor = o->textColor;
	if (textColor.isValid()) {
	p->setPen(textColor);
	}
	int alignment = int(o->textAlignment);
	if (!styleHint(QStyle::SH_UnderlineShortcut, option, widget)) {
	alignment \|= Qt::TextHideMnemonic;
	}

	alignment \|= Qt::TextShowMnemonic;
	alignment \|= Qt::AlignHCenter;
	drawItemText(p, textRect, alignment, o->palette, o->state & State_Enabled, o->text, QPalette::WindowText);

	if (o->state & State_HasFocus) {
	QStyleOptionFocusRect fropt;
	fropt.QStyleOption::operator=(*o);
	fropt.rect = textRect;
	drawPrimitive(PE_FrameFocusRect, &fropt, p, widget);
	}
	}

	// Draw checkbox
	if (o->subControls & SC_GroupBoxCheckBox) {
	QStyleOptionButton box;
	box.QStyleOption::operator=(*o);
	box.rect = checkBoxRect;
	drawPrimitive(PE_IndicatorCheckBox, &box, p, widget);
	}
	}
	return;
	}
	if (cc == CC_Slider) {
	if (auto const o = qstyleoption_cast<QStyleOptionSlider const >(option)) {
	QRect groove = subControlRect(CC_Slider, option, SC_SliderGroove, widget);
	QRect handle = subControlRect(CC_Slider, option, SC_SliderHandle, widget);

	bool horizontal = o->orientation == Qt::Horizontal;
	bool ticksAbove = o->tickPosition & QSlider::TicksAbove;
	bool ticksBelow = o->tickPosition & QSlider::TicksBelow;
	QPixmap cache;
	QBrush oldBrush = p->brush();
	QPen oldPen = p->pen();
	QColor shadowAlpha(Qt::black);
	shadowAlpha.setAlpha(10);

	if ((option->subControls & SC_SliderGroove) && groove.isValid()) {
	QRect rect(0, 0, groove.width(), groove.height());
	QString key = pixmapkey("slider_groove", horizontal ? "horz" : "vert", rect.size(), m->base_color);

	QRectF grooveRect;
	double r = std::min(groove.width(), groove.height()) / 2.0;
	{
	double n = r * 3 / 4;
	grooveRect = QRectF(rect).adjusted(n, n, -n, -n);
	r -= n;
	}

	// draw background groove
	QPixmap cache;
	if (!QPixmapCache::find(key, cache)) {
	cache = QPixmap(rect.size());
	cache.fill(Qt::transparent);
	QPainter groovePainter(&cache);
	groovePainter.setRenderHint(QPainter::Antialiasing, true);
	groovePainter.translate(0.5, 0.5);
	QLinearGradient gradient;
	if (horizontal) {
	gradient.setStart(grooveRect.center().x(), grooveRect.top());
	gradient.setFinalStop(grooveRect.center().x(), grooveRect.bottom());
	} else {
	gradient.setStart(grooveRect.left(), grooveRect.center().y());
	gradient.setFinalStop(grooveRect.right(), grooveRect.center().y());
	}
	groovePainter.setPen(Qt::NoPen);
	gradient.setColorAt(0, color(32));
	gradient.setColorAt(1, color(128));
	groovePainter.setBrush(gradient);
	groovePainter.drawRoundedRect(grooveRect, r, r);
	groovePainter.end();
	QPixmapCache::insert(key, cache);
	}
	p->drawPixmap(groove.topLeft(), cache);
	}

	if (option->subControls & SC_SliderTickmarks) {
	int tickSize = pixelMetric(PM_SliderTickmarkOffset, option, widget);
	int available = pixelMetric(PM_SliderSpaceAvailable, o, widget);
	int interval = o->tickInterval;
	if (interval <= 0) {
	interval = o->singleStep;
	if (QStyle::sliderPositionFromValue(o->minimum, o->maximum, interval, available) - QStyle::sliderPositionFromValue(o->minimum, o->maximum, 0, available) < 3) {
	interval = o->pageStep;
	}
	}
	if (interval <= 0) {
	interval = 1;
	}

	int v = o->minimum;
	int len = pixelMetric(PM_SliderLength, o, widget);
	while (v <= o->maximum + 1) {
	if (v == o->maximum + 1 && interval == 1) break;
	const int v2 = qMin(v, o->maximum);
	int pos = sliderPositionFromValue(o->minimum, o->maximum,
	v2, (horizontal
	? o->rect.width()
	: o->rect.height()) - len,
	o->upsideDown) + len / 2;
	int extra = 2 - ((v2 == o->minimum \|\| v2 == o->maximum) ? 1 : 0);

	if (horizontal) {
	if (ticksAbove) {
	p->setPen(color(128));
	p->drawLine(pos, o->rect.top() + extra, pos, o->rect.top() + tickSize);
	}
	if (ticksBelow) {
	p->setPen(color(0));
	p->drawLine(pos, o->rect.bottom() - extra, pos, o->rect.bottom() - tickSize);
	}
	} else {
	if (ticksAbove) {
	p->setPen(color(128));
	p->drawLine(o->rect.left() + extra, pos, o->rect.left() + tickSize, pos);
	}
	if (ticksBelow) {
	p->setPen(color(0));
	p->drawLine(o->rect.right() - extra, pos, o->rect.right() - tickSize, pos);
	}
	}
	// in the case where maximum is max int
	int nextInterval = v + interval;
	if (nextInterval < v) break;
	v = nextInterval;
	}
	}
	// draw handle
	if ((option->subControls & SC_SliderHandle) ) {
	QRect pixmapRect(0, 0, handle.width(), handle.height());
	QRect r = pixmapRect.adjusted(0, 0, -1, -1);
	QPainterPath path;
	path.addEllipse(r);
	QString handlePixmapName = pixmapkey(QLatin1String("slider_handle"), "", handle.size(), m->base_color);
	if (!QPixmapCache::find(handlePixmapName, cache)) {
	cache = QPixmap(handle.size());
	cache.fill(Qt::transparent);
	QPainter handlePainter(&cache);

	handlePainter.setRenderHint(QPainter::Antialiasing, true);
	handlePainter.translate(0.5, 0.5);

	QLinearGradient gradient;
	gradient.setStart(pixmapRect.topLeft());
	gradient.setFinalStop(pixmapRect.bottomRight());
	gradient.setColorAt(0, color(192));
	gradient.setColorAt(1, QColor(0, 0, 0));
	handlePainter.save();
	handlePainter.setClipPath(path);
	handlePainter.fillRect(r, gradient);

	QColor highlight_color = colorize(color(160).rgb(), 192, 255);

	handlePainter.setPen(QPen(highlight_color, 2));
	handlePainter.setBrush(Qt::NoBrush);
	handlePainter.drawEllipse(r.adjusted(0, 0, 2, 2));
	handlePainter.setPen(QPen(QColor(0, 0, 0), 2));
	handlePainter.setBrush(Qt::NoBrush);
	handlePainter.drawEllipse(r.adjusted(-2, -2, 0, 0));

	handlePainter.restore();
	handlePainter.end();
	QPixmapCache::insert(handlePixmapName, cache);
	}

	QPoint topleft = handle.topLeft();
	p->drawPixmap(topleft, cache);

	if ((option->state & State_HasFocus) && (option->state & State_KeyboardFocusChange)) {
	p->save();
	p->setClipPath(path.translated(topleft));
	p->fillRect(handle, QColor(255, 255, 255, 32));
	p->restore();
	}
	}
	p->setBrush(oldBrush);
	p->setPen(oldPen);
	}
	return;
	}
	// qDebug() << cc;
	QProxyStyle::drawComplexControl(cc, option, p, widget);
	}

	diff --git a/src/unix/UnixPtyProcess.h b/src/unix/UnixPtyProcess.h
	index 3c646c5..3d8bc4c 100644
	--- a/src/unix/UnixPtyProcess.h
	+++ b/src/unix/UnixPtyProcess.h
	@@ -1,27 +1,27 @@
	#ifndef UNIXPTYPROCESS_H
	#define UNIXPTYPROCESS_H

	#include "AbstractProcess.h"
	#include <QThread>

	class UnixPtyProcess : public AbstractPtyProcess, public QThread {
	private:
	struct Private;
	Private *m;
	protected:
	void run() override;
	public:
	UnixPtyProcess();
	~UnixPtyProcess() override;
	bool isRunning() const override;
	void writeInput(char const *ptr, int len) override;
	int readOutput(char *ptr, int len) override;
	void start(QString const &cmd, QString const &env, QVariant const &userdata) override;
	bool wait(unsigned long time = ULONG_MAX) override;
	void stop() override;
	int getExitCode() const override;
	QString getMessage() const override;
	- void readResult(std::vector<char> *out);
	+ void readResult(std::vector<char> *out) override;
	};

	#endif // UNIXPTYPROCESS_H

File Metadata

Mime Type: text/x-diff
Expires: Sat, Feb 7, 7:31 AM (21 h, 54 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55890
Default Alt Text: (133 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions