No OneTemporary
Actions

Authored By

Unknown

Size

433 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/darktheme/src/DarkStyle.cpp b/darktheme/src/DarkStyle.cpp
	index 6dad4db..d211281 100644
	--- a/darktheme/src/DarkStyle.cpp
	+++ b/darktheme/src/DarkStyle.cpp
	@@ -1,2368 +1,2369 @@
	#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 <QToolTip>
	-#include <math.h>
	-#include <stdint.h>
	+#include <cmath>
	+#include <cstdint>

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

	namespace {

	-static const int windowsItemFrame = 2; // menu item frame width
	-static const int windowsItemHMargin = 3; // menu item hor text margin
	-static const int windowsItemVMargin = 4; // menu item ver text margin
	-static const int windowsArrowHMargin = 6; // arrow horizontal margin
	-static const int windowsRightBorder = 15; // right border on windows
	+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 color_topleft, QColor 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;
	// int alpha = qAlpha(source);
	if (alpha != 0) {
	// int light = qGray(source);
	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 base_color)
	+DarkStyle::DarkStyle(QColor const &base_color)
	: m(new Private)
	{
	setBaseColor(base_color);
	// setBaseColor(QColor(128, 255, 240));
	// setBaseColor(QColor(128, 240, 255));
	}

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

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

	void DarkStyle::setBaseColor(QColor 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();
	//image = image.convertToFormat(QImage::Format_ARGB32);
	Q_ASSERT(image.format() == QImage::Format_ARGB32);
	for (int y = 0; y < h; y++) {
	QRgb p = (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, const QString &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(const QString &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 = (QRgb )source.scanLine(y + 1);
	QRgb src2 = (QRgb )source.scanLine(y + 2);
	QRgb src3 = (QRgb )source.scanLine(y + 3);
	QRgb dst0 = (QRgb )buttons.im_normal.scanLine(y + 2) + 2;
	QRgb dst1 = (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] = qRgba(v, v, v, alpha);
	dst0[x] = colorize(rgb, v, alpha);
	v = lighten[v];
	// dst1[x] = qRgba(v, v, v, alpha);
	dst1[x] = colorize(rgb, v, alpha);
	}
	}
	// buttons.im_normal = colorizeImage(buttons.im_normal);
	// buttons.im_hover = colorizeImage(buttons.im_hover);
	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 = (QRgb )newimage.scanLine(y + 1) + 1;
	for (int x = 0; x < w; x++) {
	int v = qGray(ptr[x]);
	v = lighten[v];
	// ptr[x] = qRgba(v, v, v, qAlpha(ptr[x]));
	ptr[x] = colorize(rgb, v, qAlpha(ptr[x]));
	}
	}
	// newimage = colorizeImage(newimage);
	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::colorForSelectedFrame(const QStyleOption *opt) const
	{
	(void)opt;
	return QColor(128, 192, 255);

	}

	QColor DarkStyle::colorForItemView(QStyleOption const *opt) const
	{
	return opt->palette.color(QPalette::Dark);
	// return opt->palette.color(QPalette::Base); // これじゃない
	}

	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));
	#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::drawSelectedMenuFrame(const QStyleOption option, QPainter p, QRect rect, const QWidget *widget, bool deep) const
	{
	(void)widget;
	QColor color = colorForSelectedFrame(option);

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

	auto SetAlpha = [&](QColor *color, int alpha){
	if (deep) {
	alpha = alpha * 3 / 2;
	}
	color->setAlpha(alpha);
	};

	QString key;
	{
	char tmp[100];
	sprintf(tmp, "selection_frame:%02x%02x%02x:%dx%d", color.red(), color.green(), color.blue(), w, h);
	key = tmp;
	}

	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;
	SetAlpha(&pencolor, 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;
	SetAlpha(&color0, 96 * a / 255);
	SetAlpha(&color1, 32 * 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::drawButton(QPainter p, const QStyleOption option) const
	{
	QRect rect = option->rect;
	int w = rect.width();
	int h = rect.height();

	#ifdef Q_OS_MAC
	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();
	}
	}
	#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
	p->setPen(QColor(80, 160, 255));
	p->setBrush(Qt::NoBrush);
	double m = 3.5;
	p->drawRoundedRect(((QRectF)rect).adjusted(m, m, -m, -m), 4, 4);
	#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);
	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 (const QStyleOptionSlider slider = qstyleoption_cast<const QStyleOptionSlider >(option)) {
	QRect rect;
	int extent = std::min(widget->width(), widget->height());
	int span = pixelMetric(PM_SliderLength, slider, widget);
	bool horizontal = slider->orientation == Qt::Horizontal;
	int sliderPos = sliderPositionFromValue(slider->minimum, slider->maximum,
	slider->sliderPosition,
	(horizontal ? slider->rect.width()
	: slider->rect.height()) - span,
	slider->upsideDown);
	if (horizontal) {
	rect.setRect(slider->rect.x() + sliderPos, slider->rect.y(), span, extent);
	} else {
	rect.setRect(slider->rect.x(), slider->rect.y() + sliderPos, extent, span);
	}
	return rect;
	}
	}
	if (cc == CC_GroupBox) {
	// return QProxyStyle::subControlRect(cc, option, sc, widget);
	QRect ret;
	if (const QStyleOptionGroupBox groupBox = qstyleoption_cast<const QStyleOptionGroupBox >(option)) {
	switch (sc) {
	case SC_GroupBoxFrame:
	case SC_GroupBoxContents:
	{
	int topMargin = 0;
	int topHeight = 0;
	int verticalAlignment = proxy()->styleHint(SH_GroupBox_TextLabelVerticalAlignment, groupBox, widget);
	#ifdef Q_OS_MACX
	verticalAlignment \|= Qt::AlignVCenter;
	#endif
	if (groupBox->text.size() \|\| (groupBox->subControls & QStyle::SC_GroupBoxCheckBox)) {
	topHeight = groupBox->fontMetrics.height();
	if (verticalAlignment & Qt::AlignVCenter) {
	topMargin = topHeight / 2;
	} else if (verticalAlignment & Qt::AlignTop) {
	topMargin = topHeight;
	}
	}

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

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

	int frameWidth = 0;
	if ((groupBox->features & QStyleOptionFrame::Flat) == 0) {
	frameWidth = proxy()->pixelMetric(PM_DefaultFrameWidth, groupBox, widget);
	}
	ret = frameRect.adjusted(frameWidth, frameWidth + topHeight - topMargin, -frameWidth, -frameWidth);
	}
	break;
	case SC_GroupBoxCheckBox:
	case SC_GroupBoxLabel:
	{
	QFontMetrics fontMetrics = groupBox->fontMetrics;
	int h = fontMetrics.height();
	int tw = fontMetrics.size(Qt::TextShowMnemonic, groupBox->text + QLatin1Char(' ')).width();
	int marg = (groupBox->features & QStyleOptionFrame::Flat) ? 0 : 8;
	ret = groupBox->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 = groupBox->subControls & QStyle::SC_GroupBoxCheckBox;
	int checkBoxSize = hasCheckBox ? (indicatorWidth + indicatorSpace) : 0;

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

	// Adjust totalRect if checkbox is set
	if (hasCheckBox) {
	bool ltr = groupBox->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);
	}

	void DarkStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption option, QPainter p, const QWidget *widget) const
	{
	// qDebug() << pe;
	#ifdef Q_OS_LINUX
	if (pe == PE_FrameFocusRect) {
	QColor color(64, 128, 255);
	drawFrame(p, option->rect, color, color);
	return;
	}
	#endif
	if (pe == PE_IndicatorArrowDown) {
	// p->fillRect(option->rect, Qt::red);
	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;
	// QString pixmapName = QStyleHelper::uniqueName(QLatin1String("$qt_ia-")
	// % QLatin1String(metaObject()->className()), option, QSize(size, size))
	// % HexString<uint>(pe);
	if (1) {//if (!QPixmapCache::find(pixmapName, pixmap)) {
	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);
	// QPixmapCache::insert(pixmapName, pixmap);
	}
	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) {
	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) {
	drawRaisedFrame(p, option->rect, option->palette);
	return;
	}
	if (pe == PE_PanelLineEdit) {
	if (const QStyleOptionFrame panel = qstyleoption_cast<const QStyleOptionFrame >(option)) {
	// p->fillRect(option->rect, option->palette.color(QPalette::Dark));
	p->fillRect(option->rect, colorForItemView(option));
	if (panel->lineWidth > 0) {
	drawFrame(p, option->rect, option->palette.color(QPalette::Shadow), option->palette.color(QPalette::Light));
	}

	// option->
	// if (qobject_cast<QComboBox const *>(widget->parent())) {
	// // nop
	// } else {
	// }
	}
	return;
	}
	if (pe == PE_FrameGroupBox) {
	#if 0
	// p->save();
	// p->setRenderHint(QPainter::Antialiasing);
	QRectF r = option->rect;
	qDebug() << r;
	// r = r.adjusted(19.5, 19.5, -18.5, -18.5);
	p->setPen(option->palette.color(QPalette::Light));
	p->fillRect(r, Qt::red);
	// r = r.adjusted(-1, -1, -1, -1);
	// p->setPen(option->palette.color(QPalette::Dark));
	// p->drawRoundedRect(r, 5, 5);
	// p->restore();
	#else
	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();
	#endif
	return;
	}
	if (pe == PE_PanelItemViewRow) {
	#ifdef Q_OS_WIN
	// thru
	#else
	return;
	#endif
	}
	if (pe == PE_PanelItemViewItem) {
	// p->fillRect(option->rect, colorForItemView(option)); // 選択枠を透過描画させるので背景は描かない
	if (QTableView const tableview = qobject_cast<QTableView const >(widget)) {
	Qt::PenStyle grid_pen_style = Qt::NoPen;
	if (tableview->showGrid()) {
	grid_pen_style = tableview->gridStyle();
	}
	QAbstractItemView::SelectionBehavior selection_behavior = tableview->selectionBehavior();
	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));
	}
	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());
	}
	drawSelectedMenuFrame(option, p, r, widget, false);
	p->restore();
	}
	} else {
	int n = 0;
	if (option->state & State_Selected) {
	n++;
	}
	// if (option->state & State_MouseOver) {
	// n++;
	// }
	if (n > 0) {
	drawSelectedMenuFrame(option, p, option->rect, widget, n > 1);
	}
	}
	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 = 0;
	+ 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;
	}
	// if (ce == CE_ToolButtonLabel) {
	// 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 (const QStyleOptionButton button = qstyleoption_cast<const QStyleOptionButton >(option)) {
	QRect ir = button->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, button, widget)) {
	tf \|= Qt::TextShowMnemonic;
	} else {
	tf \|= Qt::TextHideMnemonic;
	}

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

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

	QIcon::State state = QIcon::Off;

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

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

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

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

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

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

	if (button->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 (!button->text.isEmpty()) {
	tf \|= Qt::AlignLeft;
	}

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

	ir.translate(buttonShift);

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

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

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

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

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

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

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

	if (!styleHint(SH_UnderlineShortcut, opt, widget)) {
	alignment \|= Qt::TextHideMnemonic;
	}
	QPixmap pix;
	QRect iconRect(editRect);
	QIcon icon = opt->currentIcon;
	QString text = opt->currentText;
	if (!icon.isNull()) {
	pix = icon.pixmap(opt->iconSize, opt->state & State_Enabled ? QIcon::Normal : QIcon::Disabled);
	drawItemPixmap(p, iconRect, alignment, pix);
	if (opt->direction == Qt::RightToLeft) {
	editRect.setRight(editRect.right() - opt->iconSize.width() - 4);
	} else {
	editRect.setLeft(editRect.left() + opt->iconSize.width() + 4);
	}
	}
	if (!text.isEmpty()){
	drawItemText(p, editRect, alignment, opt->palette, opt->state & State_Enabled, text, QPalette::ButtonText);
	}
	return;
	}
	}
	#endif
	if (ce == CE_ShapedFrame) {
	if (QStyleOptionFrameV3 const o = qstyleoption_cast<QStyleOptionFrameV3 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) {
	enum PartID {
	BP_PUSHBUTTON,
	BP_COMMANDLINK,
	};

	enum StateID {
	PBS_DISABLED,
	PBS_PRESSED,
	PBS_HOT,
	PBS_DEFAULTED,
	PBS_NORMAL,
	};

	if (const QStyleOptionButton btn = qstyleoption_cast<const QStyleOptionButton >(option)) {
	int state = option->state;
	State flags = option->state;
	int partId = BP_PUSHBUTTON;
	int stateId = 0;
	if (btn->features & QStyleOptionButton::CommandLinkButton) {
	partId = BP_COMMANDLINK;
	}
	if (!(flags & State_Enabled) && !(btn->features & QStyleOptionButton::Flat)) {
	stateId = PBS_DISABLED;
	} else if (flags & (State_Sunken \| State_On)) {
	stateId = PBS_PRESSED;
	} else if (flags & State_MouseOver) {
	stateId = PBS_HOT;
	} else if (btn->features & QStyleOptionButton::DefaultButton && (state & State_Active)) {
	stateId = PBS_DEFAULTED;
	} else {
	stateId = PBS_NORMAL;
	}

	drawButton(p, option);

	if (btn->features & QStyleOptionButton::HasMenu) {
	int mbiw = 0, mbih = 0;
	- QRect r = subElementRect(SE_PushButtonContents, option, 0);
	+ QRect r = subElementRect(SE_PushButtonContents, option, nullptr);
	QStyleOptionButton newBtn = *btn;
	r = QRect(r.right() - mbiw - 2, option->rect.top() + (option->rect.height()/2) - (mbih/2), mbiw + 1, mbih + 1);
	newBtn.rect = QStyle::visualRect(option->direction, option->rect, r);
	drawPrimitive(PE_IndicatorArrowDown, &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) {
	drawSelectedMenuFrame(option, p, option->rect, widget, false);
	}
	if (const QStyleOptionMenuItem mbi = qstyleoption_cast<const QStyleOptionMenuItem >(option)) {
	QPalette::ColorRole textRole = disabled ? QPalette::Text : QPalette::ButtonText;
	QPixmap pix = mbi->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), QIcon::Normal);
	uint alignment = Qt::AlignCenter \| Qt::TextShowMnemonic \| Qt::TextDontClip \| Qt::TextSingleLine;
	if (!styleHint(SH_UnderlineShortcut, mbi, widget)) {
	alignment \|= Qt::TextHideMnemonic;
	}
	if (!pix.isNull()) {
	drawItemPixmap(p, mbi->rect, alignment, pix);
	} else {
	drawItemText(p, mbi->rect, alignment, mbi->palette, mbi->state & State_Enabled, mbi->text, textRole);
	}
	}
	return;
	}
	if (ce == CE_MenuEmptyArea) {
	return;
	}
	if (ce == CE_MenuItem) {
	if (const QStyleOptionMenuItem opt = qstyleoption_cast<const QStyleOptionMenuItem >(option)) {
	int stateId = 0;
	// windows always has a check column, regardless whether we have an icon or not
	int checkcol = 25;// / QWindowsXPStylePrivate::devicePixelRatio(widget);
	const int gutterWidth = 3;// / QWindowsXPStylePrivate::devicePixelRatio(widget);
	QRect rect = option->rect;

	bool ignoreCheckMark = false;
	if (qobject_cast<const QComboBox*>(widget)) {
	{ // bg
	int x = option->rect.x();
	int y = option->rect.y();
	int w = option->rect.width();
	int h = option->rect.height();
	p->fillRect(x, y, w, h, option->palette.color(QPalette::Light));
	}
	ignoreCheckMark = true; //ignore the checkmarks provided by the QComboMenuDelegate
	}

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

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

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

	QRect vCheckRect = visualRect(option->direction, opt->rect, QRect(opt->rect.x(), opt->rect.y(), checkcol - (gutterWidth + opt->rect.x()), opt->rect.height()));

	if (act) {
	stateId = dis ? MBI_DISABLED : MBI_HOT;
	drawSelectedMenuFrame(option, p, option->rect, widget, false);
	}

	if (checked && !ignoreCheckMark) {
	const qreal boxMargin = 3.5;
	const qreal boxWidth = checkcol - 2 * boxMargin;
	const int checkColHOffset = windowsItemHMargin + windowsItemFrame - 1;
	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
	checkRect = visualRect(opt->direction, opt->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 (!opt->icon.isNull()) {
	QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;
	if (act && !dis) {
	mode = QIcon::Active;
	}
	QPixmap pixmap;
	if (checked) {
	pixmap = opt->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode, QIcon::On);
	} else {
	pixmap = opt->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode);
	}
	- const int pixw = pixmap.width() / pixmap.devicePixelRatio();
	- const int pixh = pixmap.height() / pixmap.devicePixelRatio();
	+ const int pixw = int(pixmap.width() / pixmap.devicePixelRatio());
	+ const int pixh = int(pixmap.height() / pixmap.devicePixelRatio());
	QRect pmr(0, 0, pixw, pixh);
	pmr.moveCenter(vCheckRect.center());
	p->setPen(opt->palette.text().color());
	p->drawPixmap(pmr.topLeft(), pixmap);
	}
	} else {
	if (opt->icon.isNull()) {
	checkcol = 0;
	} else {
	checkcol = opt->maxIconWidth;
	}
	}

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

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

	int xm = windowsItemFrame + checkcol + windowsItemHMargin + (gutterWidth - opt->rect.x()) - 1;
	int xpos = opt->rect.x() + xm;
	QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
	QRect vTextRect = visualRect(option->direction, opt->rect, textRect);
	QString s = opt->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, opt, widget)) {
	text_flags \|= Qt::TextHideMnemonic;
	}
	text_flags \|= Qt::AlignLeft;
	if (t >= 0) {
	QRect vShortcutRect = visualRect(option->direction, opt->rect, QRect(textRect.topRight(), QPoint(opt->rect.right(), textRect.bottom())));
	p->drawText(vShortcutRect, text_flags, s.mid(t + 1));
	s = s.left(t);
	}
	QFont font = opt->font;
	if (opt->menuItemType == QStyleOptionMenuItem::DefaultItem) {
	font.setBold(true);
	}
	p->setFont(font);
	p->setPen(textColor);
	p->drawText(vTextRect, text_flags, s.left(t));
	p->restore();
	}
	if (opt->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, opt->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim));
	QStyleOptionMenuItem newMI = *opt;
	newMI.rect = vSubMenuRect;
	newMI.state = dis ? State_None : State_Enabled;
	drawPrimitive(arrow, &newMI, p, widget);
	}
	}
	return;
	}
	if (ce == CE_TabBarTabShape) {
	- if (const QStyleOptionTab tab = qstyleoption_cast<const QStyleOptionTab >(option)) {
	+ if (const auto tab = qstyleoption_cast<const QStyleOptionTab >(option)) {
	bool rtlHorTabs = (tab->direction == Qt::RightToLeft && (tab->shape == QTabBar::RoundedNorth \|\| tab->shape == QTabBar::RoundedSouth));
	bool selected = tab->state & State_Selected;
	bool lastTab = ((!rtlHorTabs && tab->position == QStyleOptionTab::End) \|\| (rtlHorTabs && tab->position == QStyleOptionTab::Beginning));
	bool firstTab = ((!rtlHorTabs && tab->position == QStyleOptionTab::Beginning) \|\| (rtlHorTabs && tab->position == QStyleOptionTab::End));
	bool onlyOne = tab->position == QStyleOptionTab::OnlyOneTab;
	bool previousSelected = ((!rtlHorTabs && tab->selectedPosition == QStyleOptionTab::PreviousIsSelected) \|\| (rtlHorTabs && tab->selectedPosition == QStyleOptionTab::NextIsSelected));
	bool nextSelected = ((!rtlHorTabs && tab->selectedPosition == QStyleOptionTab::NextIsSelected) \|\| (rtlHorTabs && tab->selectedPosition == QStyleOptionTab::PreviousIsSelected));
	int tabBarAlignment = styleHint(SH_TabBar_Alignment, tab, widget);
	bool leftAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignLeft) \|\| (rtlHorTabs && tabBarAlignment == Qt::AlignRight);
	bool rightAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignRight) \|\| (rtlHorTabs && tabBarAlignment == Qt::AlignLeft);

	QColor light = tab->palette.light().color();
	QColor dark = tab->palette.dark().color();
	QColor shadow = tab->palette.shadow().color();
	int borderThinkness = pixelMetric(PM_TabBarBaseOverlap, tab, 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 (tab->shape) {
	default:
	{
	p->save();

	QRect rect(tab->rect);
	int tabOverlap = onlyOne ? 0 : pixelMetric(PM_TabBarTabOverlap, option, widget);

	if (!selected) {
	switch (tab->shape) {
	case QTabBar::TriangularNorth:
	rect.adjust(0, 0, 0, -tabOverlap);
	if(!selected) rect.adjust(1, 1, -1, 0);
	break;
	case QTabBar::TriangularSouth:
	rect.adjust(0, tabOverlap, 0, 0);
	if(!selected) rect.adjust(1, 0, -1, -1);
	break;
	case QTabBar::TriangularEast:
	rect.adjust(tabOverlap, 0, 0, 0);
	if(!selected) rect.adjust(0, 1, -1, -1);
	break;
	case QTabBar::TriangularWest:
	rect.adjust(0, 0, -tabOverlap, 0);
	if(!selected) rect.adjust(1, 1, 0, -1);
	break;
	default:
	break;
	}
	}

	p->setPen(QPen(tab->palette.foreground(), 0));
	if (selected) {
	p->setBrush(tab->palette.background());
	} else {
	if (widget && widget->parentWidget()) {
	p->setBrush(widget->parentWidget()->palette().shadow());
	} else {
	p->setBrush(tab->palette.shadow());
	}
	}

	int y;
	int x;
	QPolygon a(10);
	switch (tab->shape) {
	case QTabBar::TriangularNorth:
	case QTabBar::TriangularSouth:
	{
	a.setPoint(0, 0, -1);
	a.setPoint(1, 0, 0);
	y = rect.height() - 2;
	x = y / 3;
	a.setPoint(2, x++, y - 1);
	++x;
	a.setPoint(3, x++, y++);
	a.setPoint(4, x, y);

	int i;
	int right = rect.width() - 1;
	for (i = 0; i < 5; ++i) {
	a.setPoint(9 - i, right - a.point(i).x(), a.point(i).y());
	}
	if (tab->shape == QTabBar::TriangularNorth) {
	for (i = 0; i < 10; ++i) {
	a.setPoint(i, a.point(i).x(), rect.height() - 1 - a.point(i).y());
	}
	}

	a.translate(rect.left(), rect.top());
	p->setRenderHint(QPainter::Antialiasing);
	p->translate(0, 0.5);

	QPainterPath path;
	path.addPolygon(a);
	p->drawPath(path);
	break;
	}
	case QTabBar::TriangularEast:
	case QTabBar::TriangularWest:
	{
	a.setPoint(0, -1, 0);
	a.setPoint(1, 0, 0);
	x = rect.width() - 2;
	y = x / 3;
	a.setPoint(2, x - 1, y++);
	++y;
	a.setPoint(3, x++, y++);
	a.setPoint(4, x, y);
	int i;
	int bottom = rect.height() - 1;
	for (i = 0; i < 5; ++i) {
	a.setPoint(9 - i, a.point(i).x(), bottom - a.point(i).y());
	}
	if (tab->shape == QTabBar::TriangularWest) {
	for (i = 0; i < 10; ++i) {
	a.setPoint(i, rect.width() - 1 - a.point(i).x(), a.point(i).y());
	}
	}
	a.translate(rect.left(), rect.top());
	p->setRenderHint(QPainter::Antialiasing);
	p->translate(0.5, 0);
	QPainterPath path;
	path.addPolygon(a);
	p->drawPath(path);
	break;
	}
	default:
	break;
	}
	p->restore();
	}
	break;
	case QTabBar::RoundedNorth:
	{
	if (!selected) {
	y1 += 2;
	x1 += onlyOne \|\| firstTab ? borderThinkness : 0;
	x2 -= onlyOne \|\| lastTab ? borderThinkness : 0;
	}

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

	// Delete border
	if (selected) {
	p->fillRect(QRect(x1,y2-1,x2-x1,1), tab->palette.background());
	p->fillRect(QRect(x1,y2,x2-x1,1), tab->palette.background());
	}
	// Left
	if (firstTab \|\| selected \|\| onlyOne \|\| !previousSelected) {
	p->setPen(light);
	p->drawLine(x1, y1 + 2, x1, y2 - ((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 - ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness));
	p->drawPoint(x2 - 1, y1 + 1);
	p->setPen(dark);
	p->drawLine(x2 - 1, y1 + 2, x2 - 1, y2 - ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness));
	}
	break;
	}
	case QTabBar::RoundedSouth:
	{
	if (!selected) {
	y2 -= 2;
	x1 += firstTab ? borderThinkness : 0;
	x2 -= lastTab ? borderThinkness : 0;
	}

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

	// Delete border
	if (selected) {
	p->fillRect(QRect(x1, y1 + 1, (x2 - 1)-x1, 1), tab->palette.background());
	p->fillRect(QRect(x1, y1, (x2 - 1)-x1, 1), tab->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);
	p->setPen(dark);
	p->drawLine(beg, y2 - 1, end, y2 - 1);
	}
	// 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);
	p->setPen(dark);
	p->drawLine(x2 - 1, y2 - 2, x2 - 1, y1 + ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness));
	}
	break;
	}
	case QTabBar::RoundedWest:
	{
	if (!selected) {
	x1 += 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}

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

	// Delete border
	if (selected) {
	p->fillRect(QRect(x2 - 1, y1, 1, y2-y1), tab->palette.background());
	p->fillRect(QRect(x2, y1, 1, y2-y1), tab->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 + 3, y2, x2 - ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness), y2);
	p->drawPoint(x1 + 2, y2 - 1);
	p->setPen(dark);
	p->drawLine(x1 + 3, y2 - 1, x2 - ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness), y2 - 1);
	p->drawPoint(x1 + 1, y2 - 1);
	p->drawPoint(x1 + 2, y2);
	}
	break;
	}
	case QTabBar::RoundedEast:
	{
	if (!selected) {
	x2 -= 2;
	y1 += firstTab ? borderThinkness : 0;
	y2 -= lastTab ? borderThinkness : 0;
	}

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

	// Delete border
	if (selected) {
	p->fillRect(QRect(x1 + 1, y1, 1, (y2 - 1)-y1),tab->palette.background());
	p->fillRect(QRect(x1, y1, 1, (y2-1)-y1), tab->palette.background());
	}
	// Top
	if (firstTab \|\| selected \|\| onlyOne \|\| !previousSelected) {
	p->setPen(light);
	p->drawLine(x2 - 2, y1, x1 + ((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);
	p->setPen(dark);
	p->drawLine(x2 - 1, beg, x2 - 1, end);
	}
	// Bottom
	if (lastTab \|\| selected \|\| onlyOne \|\| !nextSelected) {
	p->setPen(shadow);
	p->drawLine(x2 - 2, y2, x1 + ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness), y2);
	p->drawPoint(x2 - 1, y2 - 1);
	p->setPen(dark);
	p->drawLine(x2 - 2, y2 - 1, x1 + ((onlyOne \|\| lastTab) && selected && rightAligned ? 0 : borderThinkness), y2 - 1);
	}
	break;
	}
	}
	}
	return;
	}
	if (ce == CE_ProgressBarGroove \|\| ce == CE_ProgressBarContents) {
	if (const QStyleOptionProgressBar bar = qstyleoption_cast<const QStyleOptionProgressBar >(option)) {

	QColor color(0, 128, 255);

	QImage const *image = &m->progress_horz;

	QString key = "horz";

	bool horz = true;
	if (bar->orientation == Qt::Vertical) {
	image = &m->progress_vert;
	key = "vert";
	horz = false;
	}

	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 = bar->progress - bar->minimum;
	int div = bar->maximum - bar->minimum;
	bool inv = bar->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) {
	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);
	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 (ce == CE_HeaderSection) {
	if (option->state & QStyle::State_MouseOver) {
	p->save();
	p->fillRect(x, y, w, h, QColor(255, 255, 255, 32));
	p->restore();
	}
	}
	return;
	}
	#ifdef Q_OS_MAC
	if (ce == CE_DockWidgetTitle) {
	if (const QStyleOptionDockWidget dwOpt = qstyleoption_cast<const QStyleOptionDockWidget >(option)) {
	const QDockWidget dockWidget = qobject_cast<const QDockWidget >(widget);
	QRect rect = option->rect;
	if (dockWidget && dockWidget->isFloating()) {
	QProxyStyle::drawControl(ce, option, p, widget);
	return;
	}

	const QStyleOptionDockWidgetV2 v2 = qstyleoption_cast<const QStyleOptionDockWidgetV2>(dwOpt);
	bool verticalTitleBar = v2 == 0 ? false : 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, dwOpt, widget);
	int fw = proxy()->pixelMetric(PM_DockWidgetFrameWidth, dwOpt, widget);
	const QDockWidget dw = qobject_cast<const QDockWidget >(widget);
	bool isFloating = dw != 0 && dw->isFloating();

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

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

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

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

	if (!dwOpt->title.isEmpty()) {
	QString titleText = p->fontMetrics().elidedText(dwOpt->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, dwOpt->palette,
	dwOpt->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
	// 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 (const QStyleOptionComboBox cmb = qstyleoption_cast<const QStyleOptionComboBox >(option)) {
	SubControls sub = option->subControls;
	if (cmb->editable) {
	int partId = 0;
	// int stateId = 0;
	#define EP_EDITBORDER_NOSCROLL 6
	#define EP_EDITBORDER_HVSCROLL 9
	State flags = option->state;
	if (sub & SC_ComboBoxEditField) {
	partId = EP_EDITBORDER_NOSCROLL;
	// if (!(flags & State_Enabled))
	// stateId = ETS_DISABLED;
	// else if (flags & State_MouseOver)
	// stateId = ETS_HOT;
	// else if (flags & State_HasFocus)
	// stateId = ETS_FOCUSED;
	// else
	// stateId = ETS_NORMAL;

	// XPThemeData theme(widget, painter,
	// QWindowsXPStylePrivate::EditTheme,
	// partId, stateId, r);

	// d->drawBackground(theme);
	p->fillRect(option->rect, option->palette.color(QPalette::Dark));
	drawFrame(p, option->rect, option->palette.color(QPalette::Shadow), option->palette.color(QPalette::Light));
	// drawFrame(p, option->rect, option->palette.color(QPalette::Dark), option->palette.color(QPalette::Light));
	}
	if (sub & SC_ComboBoxArrow) {
	QRect subRect = subControlRect(CC_ComboBox, option, SC_ComboBoxArrow, widget);
	// XPThemeData theme(widget, painter, QWindowsXPStylePrivate::ComboboxTheme);
	// theme.rect = subRect;
	// partId = option->direction == Qt::RightToLeft ? CP_DROPDOWNBUTTONLEFT : CP_DROPDOWNBUTTONRIGHT;

	// if (!(cmb->state & State_Enabled))
	// stateId = CBXS_DISABLED;
	// else if (cmb->state & State_Sunken \|\| cmb->state & State_On)
	// stateId = CBXS_PRESSED;
	// else if (cmb->state & State_MouseOver && option->activeSubControls & SC_ComboBoxArrow)
	// stateId = CBXS_HOT;
	// else
	// stateId = CBXS_NORMAL;

	// theme.partId = partId;
	// theme.stateId = stateId;
	// d->drawBackground(theme);
	QStyleOptionComplex opt = *option;
	// p->fillRect(subRect, Qt::blue);
	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 (const QStyleOptionToolButton toolbutton = qstyleoption_cast<const QStyleOptionToolButton >(option)) {
	QRect button, menuarea;
	button = subControlRect(cc, toolbutton, SC_ToolButton, widget);
	menuarea = subControlRect(cc, toolbutton, SC_ToolButtonMenu, widget);

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

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

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

	if (toolbutton->state & State_HasFocus) {
	QStyleOptionFocusRect fr;
	fr.QStyleOption::operator=(*toolbutton);
	fr.rect.adjust(3, 3, -3, -3);
	if (toolbutton->features & QStyleOptionToolButton::MenuButtonPopup) {
	fr.rect.adjust(0, 0, -pixelMetric(QStyle::PM_MenuButtonIndicator, toolbutton, widget), 0);
	}
	drawPrimitive(PE_FrameFocusRect, &fr, p, widget);
	}
	QStyleOptionToolButton label = *toolbutton;
	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 (toolbutton->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 (toolbutton->features & QStyleOptionToolButton::HasMenu) {
	int mbi = pixelMetric(PM_MenuButtonIndicator, toolbutton, widget);
	QRect ir = toolbutton->rect;
	QStyleOptionToolButton newBtn = *toolbutton;
	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);
	- ScrollBarTextures tx = const_cast<ScrollBarTextures >(ishorz ? &m->hsb : &m->vsb);
	+ 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 (const QStyleOptionGroupBox groupBox = qstyleoption_cast<const QStyleOptionGroupBox >(option)) {
	QRect textRect = subControlRect(CC_GroupBox, option, SC_GroupBoxLabel, widget);
	QRect checkBoxRect = subControlRect(CC_GroupBox, option, SC_GroupBoxCheckBox, widget);
	if (groupBox->subControls & QStyle::SC_GroupBoxFrame) {
	QStyleOptionFrame frame;
	frame.QStyleOption::operator=(*groupBox);
	frame.features = groupBox->features;
	frame.lineWidth = groupBox->lineWidth;
	frame.midLineWidth = groupBox->midLineWidth;
	frame.rect = subControlRect(CC_GroupBox, option, SC_GroupBoxFrame, widget);
	p->save();
	QRegion region(groupBox->rect);
	if (!groupBox->text.isEmpty()) {
	bool ltr = groupBox->direction == Qt::LeftToRight;
	QRect finalRect;
	if (groupBox->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 ((groupBox->subControls & QStyle::SC_GroupBoxLabel) && !groupBox->text.isEmpty()) {
	QColor textColor = groupBox->textColor;
	if (textColor.isValid()) {
	p->setPen(textColor);
	}
	int alignment = int(groupBox->textAlignment);
	if (!styleHint(QStyle::SH_UnderlineShortcut, option, widget)) {
	alignment \|= Qt::TextHideMnemonic;
	}

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

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

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

	bool horizontal = slider->orientation == Qt::Horizontal;
	bool ticksAbove = slider->tickPosition & QSlider::TicksAbove;
	bool ticksBelow = slider->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;
	{
	double n = r * 3 / 4;
	- grooveRect = rect.adjusted(n, n, -n, -n);
	+ int i = (int)n;
	+ grooveRect = rect.adjusted(i, i, -i, -i);
	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, slider, widget);
	int interval = slider->tickInterval;
	if (interval <= 0) {
	interval = slider->singleStep;
	if (QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, interval, available) - QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, 0, available) < 3) {
	interval = slider->pageStep;
	}
	}
	if (interval <= 0) {
	interval = 1;
	}

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

	if (horizontal) {
	if (ticksAbove) {
	p->setPen(color(128));
	p->drawLine(pos, slider->rect.top() + extra, pos, slider->rect.top() + tickSize);
	}
	if (ticksBelow) {
	p->setPen(color(0));
	p->drawLine(pos, slider->rect.bottom() - extra, pos, slider->rect.bottom() - tickSize);
	}
	} else {
	if (ticksAbove) {
	p->setPen(color(128));
	p->drawLine(slider->rect.left() + extra, pos, slider->rect.left() + tickSize, pos);
	}
	if (ticksBelow) {
	p->setPen(color(0));
	p->drawLine(slider->rect.right() - extra, pos, slider->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/darktheme/src/DarkStyle.h b/darktheme/src/DarkStyle.h
	index 6ab5f2b..5ce10c1 100644
	--- a/darktheme/src/DarkStyle.h
	+++ b/darktheme/src/DarkStyle.h
	@@ -1,59 +1,59 @@
	#ifndef DARKSTYLE_H
	#define DARKSTYLE_H

	#include <QPainter>
	#include <QProxyStyle>

	class DarkStyle : public QProxyStyle {
	public:
	private:
	struct Private;
	Private *m;

	class ButtonImages {
	public:
	QImage im_normal;
	QImage im_hover;
	};

	struct ScrollBarTextures {
	QImage page_bg;
	ButtonImages sub_line;
	ButtonImages add_line;
	ButtonImages slider;
	};

	QImage colorizeImage(QImage image);
	QImage loadColorizedImage(const QString &path, const QString &role = QString());
	ButtonImages generateButtonImages(const QString &path);
	QImage generateHoverImage(const QImage &source);
	QPixmap pixmapFromImage(QImage const &image, QSize size) const;
	void loadImages();

	QColor colorForSelectedFrame(QStyleOption const *opt) const;
	QColor colorForItemView(QStyleOption const *opt) const;

	void drawNinePatchImage(QPainter *p, QImage const &image, QRect const &r, int w, int h) const;
	void drawGutter(QPainter *p, QRect const &r) const;
	void drawSelectedMenuFrame(const QStyleOption option, QPainter p, QRect rect, QWidget const *widget, bool deep) const;
	void drawButton(QPainter p, QStyleOption const option) const;
	void drawToolButton(QPainter p, QStyleOption const option) const;
	void drawMenuBarBG(QPainter p, const QStyleOption option, const QWidget *widget) const;
	QColor color(int level, int alpha = 255) const;
	public:
	- DarkStyle(QColor base_color = QColor());
	+ DarkStyle(const QColor &base_color = QColor());
	~DarkStyle();

	QColor getBaseColor();
	void setBaseColor(QColor color);
	void setScrollBarExtent(int n);

	void polish(QPalette &palette);
	int pixelMetric(PixelMetric metric, const QStyleOption option, const QWidget widget) const;
	QRect subControlRect(ComplexControl cc, const QStyleOptionComplex option, SubControl sc, const QWidget widget) const;
	void drawPrimitive(PrimitiveElement pe, const QStyleOption option, QPainter p, const QWidget *widget) const;
	void drawControl(ControlElement ce, const QStyleOption option, QPainter p, const QWidget *widget) const;
	void drawComplexControl(ComplexControl cc, const QStyleOptionComplex option, QPainter p, const QWidget *widget) const;
	};

	#endif // DARKSTYLE_H
	diff --git a/darktheme/src/NinePatch.cpp b/darktheme/src/NinePatch.cpp
	index 84a029e..9ac30f0 100644
	--- a/darktheme/src/NinePatch.cpp
	+++ b/darktheme/src/NinePatch.cpp
	@@ -1,139 +1,133 @@
	#include "NinePatch.h"
	#include <QPainter>
	#include <vector>
	-#include <math.h>
	+#include <cmath>

	struct Part {
	- bool stretchable;
	- int pos;
	- int len;
	- Part()
	- : stretchable(false)
	- , pos(0)
	- , len(0)
	- {
	- }
	+ bool stretchable = false;
	+ int pos = 0;
	+ int len = 0;
	+ Part() = default;
	Part(int pos, int len, bool stretchable)
	: stretchable(stretchable)
	, pos(pos)
	, len(len)
	{
	}
	};

	static inline bool isStretchableMarker(QRgb pixel)
	{
	return (qAlpha(pixel) >> 7) & 1;
	}

	static QImage resize9patch(QImage const &image, int dw, int dh)
	{
	int sw = image.width();
	int sh = image.height();
	if (sw > 2 && sh > 2 && dw > 0 && dh > 0) {
	QImage newimage(dw, dh, image.format());
	newimage.fill(Qt::transparent);
	QPainter pr(&newimage);
	pr.setRenderHint(QPainter::SmoothPixmapTransform);

	std::vector<Part> horz;
	std::vector<Part> vert;
	int horz_stretch = 0;
	int vert_stretch = 0;
	{
	int pos;
	QRgb last;
	QRgb next;
	pos = 0;
	last = image.pixel(1, 0);
	for (int x = 1; x < sw - 1; x++) {
	next = image.pixel(x + 1, 0);
	if (isStretchableMarker(last) != isStretchableMarker(next) \|\| x == sw - 2) {
	bool stretchable = isStretchableMarker(last);
	int len = x - pos;
	- horz.push_back(Part(pos, len, stretchable));
	+ horz.emplace_back(pos, len, stretchable);
	if (stretchable) horz_stretch += len;
	last = next;
	pos = x;
	}
	}
	pos = 0;
	last = image.pixel(0, 1);
	for (int y = 1; y < sh - 1; y++) {
	next = image.pixel(0, y + 1);
	if (isStretchableMarker(last) != isStretchableMarker(next) \|\| y == sh - 2) {
	bool stretchable = isStretchableMarker(last);
	int len = y - pos;
	- vert.push_back(Part(pos, len, stretchable));
	+ vert.emplace_back(pos, len, stretchable);
	if (stretchable) vert_stretch += len;
	last = next;
	pos = y;
	}
	}
	}
	double horz_mul = 0;
	double vert_mul = 0;
	if (horz_stretch > 0) horz_mul = (double)(dw - (sw - 2 - horz_stretch)) / horz_stretch;
	if (vert_stretch > 0) vert_mul = (double)(dh - (sh - 2 - vert_stretch)) / vert_stretch;
	int dy0 = 0;
	int dy1 = 0;
	double vstretch = 0;
	for (int i = 0; i < (int)vert.size(); i++) {
	int sy0 = vert[i].pos;
	int sy1 = vert[i].pos + vert[i].len;
	if (i + 1 == (int)vert.size()) {
	dy1 = dh;
	} else if (vert[i].stretchable) {
	vstretch += (double)vert[i].len * vert_mul;
	double s = floor(vstretch);
	vstretch -= s;
	dy1 += (int)s;
	} else {
	dy1 += vert[i].len;
	}
	int dx0 = 0;
	int dx1 = 0;
	double hstretch = 0;
	for (int j = 0; j < (int)horz.size(); j++) {
	int sx0 = horz[j].pos;
	int sx1 = horz[j].pos + horz[j].len;
	if (j + 1 == (int)horz.size()) {
	dx1 = dw;
	} else if (horz[j].stretchable) {
	hstretch += (double)horz[j].len * horz_mul;
	double s = floor(hstretch);
	hstretch -= s;
	dx1 += (int)s;
	} else {
	dx1 += horz[j].len;
	}
	pr.drawImage(QRect(dx0, dy0, dx1 - dx0, dy1 - dy0), image, QRect(sx0 + 1, sy0 + 1, sx1 - sx0, sy1 - sy0));
	dx0 = dx1;
	}
	dy0 = dy1;
	}

	return newimage;
	}
	return QImage();
	}

	QImage createImageFromNinePatchImage(QImage const &image, int dw, int dh)
	{
	int w = dw;
	int h = dh;
	if (w < image.width() \|\| h < image.height()) { // shrink
	if (w < image.width()) w = image.width();
	if (h < image.height()) h = image.height();
	QImage pm1 = resize9patch(image, w, h);
	if (pm1.isNull()) return QImage();
	QImage pm2(dw, dh, image.format());
	pm2.fill(Qt::transparent);
	QPainter pr(&pm2);
	pr.setRenderHint(QPainter::SmoothPixmapTransform);
	pr.drawImage(QRect(0, 0, dw, dh), pm1, QRect(0, 0, w, h));
	return pm2;
	- } else {
	- return resize9patch(image, w, h);
	}
	+ return resize9patch(image, w, h);
	}
	diff --git a/src/BigDiffWindow.cpp b/src/BigDiffWindow.cpp
	index 0fcbfaf..7921743 100644
	--- a/src/BigDiffWindow.cpp
	+++ b/src/BigDiffWindow.cpp
	@@ -1,65 +1,67 @@
	+#include <memory>
	+
	#include "BigDiffWindow.h"
	#include "ui_BigDiffWindow.h"

	struct BigDiffWindow::Private {
	TextEditorEnginePtr text_editor_engine;
	FileDiffWidget::InitParam_ param;
	};

	BigDiffWindow::BigDiffWindow(QWidget *parent)
	: QDialog(parent)
	, ui(new Ui::BigDiffWindow)
	, m(new Private)
	{
	ui->setupUi(this);
	Qt::WindowFlags flags = windowFlags();
	flags &= ~Qt::WindowContextHelpButtonHint;
	flags \|= Qt::WindowMaximizeButtonHint;
	setWindowFlags(flags);

	ui->widget_diff->setMaximizeButtonEnabled(false);

	connect(ui->widget_diff, &FileDiffWidget::textcodecChanged, [&](){ updateDiffView(); });
	}

	BigDiffWindow::~BigDiffWindow()
	{
	delete m;
	delete ui;
	}

	void BigDiffWindow::setTextCodec(QTextCodec *codec)
	{
	- m->text_editor_engine = TextEditorEnginePtr(new TextEditorEngine);
	+ m->text_editor_engine = std::make_shared<TextEditorEngine>();
	ui->widget_diff->setTextCodec(codec);
	}

	void BigDiffWindow::updateDiffView()
	{
	ui->widget_diff->updateDiffView(m->param.diff, m->param.uncommited);
	}

	void BigDiffWindow::init(MainWindow *mw, FileDiffWidget::InitParam_ const &param)
	{
	ui->widget_diff->bind(mw);
	m->param = param;

	switch (m->param.view_style) {
	case FileDiffWidget::ViewStyle::LeftOnly:
	ui->widget_diff->setLeftOnly(m->param.bytes_a, m->param.diff);
	break;
	case FileDiffWidget::ViewStyle::RightOnly:
	ui->widget_diff->setRightOnly(m->param.bytes_b, m->param.diff);
	break;
	case FileDiffWidget::ViewStyle::SideBySideText:
	ui->widget_diff->setSideBySide(m->param.bytes_a, m->param.diff, m->param.uncommited, m->param.workingdir);
	break;
	case FileDiffWidget::ViewStyle::SideBySideImage:
	ui->widget_diff->setSideBySide_(m->param.bytes_a, m->param.bytes_b, m->param.workingdir);
	break;
	}
	}




	diff --git a/src/FileDiffWidget.cpp b/src/FileDiffWidget.cpp
	index 44806bb..8c35bb8 100644
	--- a/src/FileDiffWidget.cpp
	+++ b/src/FileDiffWidget.cpp
	@@ -1,741 +1,744 @@
	+#include <memory>
	+
	+#include <memory>
	+
	#include "FileDiffWidget.h"
	#include "ui_FileDiffWidget.h"

	#include "BigDiffWindow.h"
	#include "GitDiff.h"
	#include "common/joinpath.h"
	#include "MainWindow.h"
	#include "common/misc.h"

	#include "ApplicationGlobal.h"
	#include "Theme.h"

	#include <QBuffer>
	#include <QDebug>
	#include <QKeyEvent>
	#include <QMenu>
	#include <QPainter>
	#include <QStyle>
	#include <QTextCodec>

	enum {
	DiffIndexRole = Qt::UserRole,
	};

	struct FileDiffWidget::Private {
	MainWindow *mainwindow = nullptr;
	InitParam_ init_param_;
	Git::CommitItemList commit_item_list;
	std::vector<std::string> original_lines;
	TextEditorEnginePtr engine_left;
	TextEditorEnginePtr engine_right;
	TextDiffLineList left_lines;
	TextDiffLineList right_lines;
	int max_line_length = 0;

	int term_cursor_row = 0;
	int term_cursor_col = 0;

	QTextCodec *text_codec = nullptr;
	};

	FileDiffWidget::FileDiffWidget(QWidget *parent)
	: QWidget(parent)
	, ui(new Ui::FileDiffWidget)
	, m(new Private)
	{
	ui->setupUi(this);
	Qt::WindowFlags flags = windowFlags();
	flags &= ~Qt::WindowContextHelpButtonHint;
	setWindowFlags(flags);

	ui->widget_diff_slider->init([&](DiffPane pane, int width, int height){
	return makeDiffPixmap(pane, width, height);
	}, global->theme);

	connect(ui->widget_diff_slider, SIGNAL(valueChanged(int)), this, SLOT(scrollTo(int)));
	connect(ui->widget_diff_left->texteditor(), SIGNAL(moved(int,int,int,int)), this, SLOT(onMoved(int,int,int,int)));
	connect(ui->widget_diff_right->texteditor(), SIGNAL(moved(int,int,int,int)), this, SLOT(onMoved(int,int,int,int)));

	setFocusAcceptable(true);

	int n = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
	ui->toolButton_fullscreen->setFixedSize(n, n);

	setMaximizeButtonEnabled(true);

	- m->engine_left = TextEditorEnginePtr(new TextEditorEngine);
	- m->engine_right = TextEditorEnginePtr(new TextEditorEngine);
	+ m->engine_left = std::make_shared<TextEditorEngine>();
	+ m->engine_right = std::make_shared<TextEditorEngine>();
	ui->widget_diff_left->setDiffMode(m->engine_left, ui->verticalScrollBar, ui->horizontalScrollBar);
	ui->widget_diff_right->setDiffMode(m->engine_right, ui->verticalScrollBar, ui->horizontalScrollBar);

	setViewType(FileViewType::None);
	}

	FileDiffWidget::~FileDiffWidget()
	{
	delete m;
	delete ui;
	}

	void FileDiffWidget::setViewType(FileViewType type)
	{
	ui->widget_diff_left->setViewType(type);
	ui->widget_diff_right->setViewType(type);
	}

	void FileDiffWidget::setMaximizeButtonEnabled(bool f)
	{
	ui->toolButton_fullscreen->setVisible(f);
	ui->toolButton_fullscreen->setEnabled(f);
	}

	FileDiffWidget::ViewStyle FileDiffWidget::viewstyle() const
	{
	return m->init_param_.view_style;
	}



	void FileDiffWidget::bind(MainWindow *mw)
	{
	Q_ASSERT(mw);
	m->mainwindow = mw;
	ui->widget_diff_left->bind(mw, this, ui->verticalScrollBar, ui->horizontalScrollBar, mw->themeForTextEditor());
	ui->widget_diff_right->bind(mw, this, ui->verticalScrollBar, ui->horizontalScrollBar, mw->themeForTextEditor());

	connect(ui->verticalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(onVerticalScrollValueChanged(int)));
	connect(ui->horizontalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(onHorizontalScrollValueChanged(int)));
	}

	MainWindow *FileDiffWidget::mainwindow()
	{
	return m->mainwindow;
	}

	GitPtr FileDiffWidget::git()
	{
	if (!mainwindow()) {
	qDebug() << "Maybe, you forgot to call FileDiffWidget::bind() ?";
	return GitPtr();
	}
	return mainwindow()->git();
	}

	Git::Object FileDiffWidget::cat_file(GitPtr /g/, QString const &id)
	{
	return mainwindow()->cat_file(id);
	}

	int FileDiffWidget::totalTextLines() const
	{
	return m->engine_left->document.lines.size();
	}

	void FileDiffWidget::clearDiffView()
	{
	ui->widget_diff_slider->clear(false);
	}

	int FileDiffWidget::fileviewHeight() const
	{
	return ui->widget_diff_left->height();
	}

	void FileDiffWidget::resetScrollBarValue()
	{
	ui->verticalScrollBar->setValue(0);
	ui->horizontalScrollBar->setValue(0);
	}

	void FileDiffWidget::scrollToBottom()
	{
	QScrollBar *sb = ui->verticalScrollBar;
	sb->setValue(sb->maximum());
	}

	void FileDiffWidget::updateSliderCursor()
	{
	if (viewstyle() == SideBySideText) {
	ui->widget_diff_slider->clear(true);
	}
	}

	void FileDiffWidget::updateControls()
	{
	updateSliderCursor();
	}

	void FileDiffWidget::makeSideBySideDiffData(Git::Diff const &diff, std::vector<std::string> const &original_lines, TextDiffLineList left_lines, TextDiffLineList right_lines)
	{
	left_lines->clear();
	right_lines->clear();

	m->original_lines = original_lines;

	size_t linenum = original_lines.size();

	std::vector<HunkItem> hunks;
	int number = 0;
	for (auto it = diff.hunks.begin(); it != diff.hunks.end(); it++, number++) {
	std::string at = it->at;
	if (strncmp(at.c_str(), "@@ -", 4) == 0) {
	size_t pos = 0;
	size_t len = 0;
	char const *p = at.c_str() + 4;
	auto ParseNumber = [&](){
	size_t v = 0;
	while (isdigit(*p & 0xff)) {
	v = v * 10 + (*p - '0');
	p++;
	}
	return v;
	};
	pos = ParseNumber();
	if (*p == ',') {
	p++;
	len = ParseNumber();
	} else {
	len = 1;
	}
	if (pos > 0) pos--;
	HunkItem item;
	item.hunk_number = number;
	item.pos = pos;
	item.len = len;
	for (std::string const &line : it->lines) {
	item.lines.push_back(line);
	}
	hunks.push_back(item);
	}
	}
	std::sort(hunks.begin(), hunks.end(), [](HunkItem const &l, HunkItem const &r){
	return l.pos + l.len < r.pos + r.len;
	});
	size_t h = hunks.size();
	while (linenum > 0 \|\| h > 0) {
	while (h > 0) {
	int hunk_number = h - 1;
	HunkItem const &hi = hunks[hunk_number];
	if (hi.pos + hi.len < linenum) {
	break;
	}
	std::vector<TextDiffLine> tmp_left;
	std::vector<TextDiffLine> tmp_right;
	int minus = 0;
	int plus = 0;
	auto FlushBlank = [&](){
	while (minus < plus) {
	- tmp_left.push_back(TextDiffLine());
	+ tmp_left.emplace_back();
	minus++;
	}
	while (minus > plus) {
	- tmp_right.push_back(TextDiffLine());
	+ tmp_right.emplace_back();
	plus++;
	}
	minus = plus = 0;
	};
	- for (auto it = hi.lines.begin(); it != hi.lines.end(); it++) {
	- std::string line = *it;
	+ for (auto line : hi.lines) {
	int c = line[0] & 0xff;
	line = line.substr(1);
	if (c == '-') {
	minus++;
	TextDiffLine l(line, TextDiffLine::Del);
	l.hunk_number = hunk_number;
	tmp_left.push_back(l);
	} else if (c == '+') {
	plus++;
	TextDiffLine l(line, TextDiffLine::Add);
	l.hunk_number = hunk_number;
	tmp_right.push_back(l);
	} else {
	FlushBlank();
	TextDiffLine l(line, TextDiffLine::Normal);
	l.hunk_number = hunk_number;
	tmp_left.push_back(l);
	tmp_right.push_back(l);
	}
	}
	FlushBlank();
	auto ComplementNewLine = [](std::vector<TextDiffLine> *lines){
	for (TextDiffLine &line : *lines) {
	int n = line.text.size();
	if (n > 0) {
	int c = line.text[n - 1] & 0xff;
	if (c != '\r' && c != '\n') {
	line.text.push_back('\n');
	}
	}
	}
	};
	ComplementNewLine(&tmp_left);
	ComplementNewLine(&tmp_right);
	for (auto it = tmp_left.rbegin(); it != tmp_left.rend(); it++) {
	TextDiffLine l(*it);
	if (m->text_codec) {
	if (!l.text.isEmpty()) {
	QString s = QString::fromUtf8(l.text.data(), l.text.size());
	l.text = m->text_codec->fromUnicode(s);
	}
	}
	left_lines->push_back(l);
	}
	for (auto it = tmp_right.rbegin(); it != tmp_right.rend(); it++) {
	TextDiffLine l(*it);
	if (m->text_codec) {
	if (!l.text.isEmpty()) {
	QString s = QString::fromUtf8(l.text.data(), l.text.size());
	l.text = m->text_codec->fromUnicode(s);
	}
	}
	right_lines->push_back(l);
	}
	linenum = hi.pos;
	h--;
	}
	if (linenum > 0) {
	linenum--;
	if (linenum < (size_t)original_lines.size()) {
	std::string line = original_lines[linenum];
	left_lines->push_back(TextDiffLine(line, TextDiffLine::Normal));
	right_lines->push_back(TextDiffLine(line, TextDiffLine::Normal));
	}
	}
	}

	std::reverse(left_lines->begin(), left_lines->end());
	std::reverse(right_lines->begin(), right_lines->end());
	}

	void FileDiffWidget::setDiffText(Git::Diff const &diff, TextDiffLineList const &left, TextDiffLineList const &right)
	{
	m->max_line_length = 0;

	enum Pane {
	Left,
	Right,
	};
	auto SetLineNumber = [&](TextDiffLineList const &lines, Pane pane, TextDiffLineList *out){
	out->clear();
	int linenum = 1;
	for (TextDiffLine const &line : lines) {
	TextDiffLine item = line;

	switch (item.type) {
	case TextDiffLine::Normal:
	item.line_number = linenum++;
	break;
	case TextDiffLine::Add:
	if (pane == Pane::Right) {
	item.line_number = linenum++;
	}
	break;
	case TextDiffLine::Del:
	if (pane == Pane::Left) {
	item.line_number = linenum++;
	}
	break;
	default:
	item.line_number = linenum; // 行番号は設定するが、インクリメントはしない
	break;
	}

	out->push_back(item);
	}
	};
	SetLineNumber(left, Pane::Left, &m->left_lines);
	SetLineNumber(right, Pane::Right, &m->right_lines);

	ui->widget_diff_left->setText(&m->left_lines, mainwindow(), diff.blob.a_id, diff.path);
	ui->widget_diff_right->setText(&m->right_lines, mainwindow(), diff.blob.b_id, diff.path);
	refrectScrollBar();
	ui->widget_diff_slider->clear(true);
	}

	FileViewType FileDiffWidget::setupPreviewWidget()
	{
	clearDiffView();

	QString mimetype_l = mainwindow()->determinFileType(m->init_param_.bytes_a, true);
	QString mimetype_r = mainwindow()->determinFileType(m->init_param_.bytes_b, true);

	if (misc::isImage(mimetype_l) \|\| misc::isImage(mimetype_r)) { // image

	ui->verticalScrollBar->setVisible(false);
	ui->horizontalScrollBar->setVisible(false);
	ui->widget_diff_slider->setVisible(false);

	ui->widget_diff_left->setImage(mimetype_l, m->init_param_.bytes_a, m->init_param_.diff.blob.a_id, m->init_param_.diff.path);
	ui->widget_diff_right->setImage(mimetype_r, m->init_param_.bytes_b, m->init_param_.diff.blob.b_id, m->init_param_.diff.path);

	return FileViewType::Image;

	} else { // text

	ui->verticalScrollBar->setVisible(true);
	ui->horizontalScrollBar->setVisible(true);
	ui->widget_diff_slider->setVisible(true);

	setViewType(FileViewType::Text);
	return FileViewType::Text;
	}
	}

	void FileDiffWidget::setSingleFile(QByteArray const &ba, QString const &id, QString const &path)
	{
	m->init_param_ = InitParam_();
	m->init_param_.view_style = FileDiffWidget::ViewStyle::SingleFile;
	m->init_param_.bytes_a = ba;
	m->init_param_.diff.path = path;
	m->init_param_.diff.blob.a_id = id;
	}

	void FileDiffWidget::setOriginalLines_(QByteArray const &ba)
	{
	m->original_lines.clear();
	if (!ba.isEmpty()) {
	char const *begin = ba.data();
	char const *end = begin + ba.size();
	misc::splitLines(begin, end, &m->original_lines, true);
	}
	}

	void FileDiffWidget::setLeftOnly(QByteArray const &ba, Git::Diff const &diff)
	{
	m->init_param_ = InitParam_();
	m->init_param_.view_style = FileDiffWidget::ViewStyle::LeftOnly;
	m->init_param_.bytes_a = ba;
	m->init_param_.diff = diff;

	setOriginalLines_(ba);

	if (setupPreviewWidget() == FileViewType::Text) {

	TextDiffLineList left_lines;
	TextDiffLineList right_lines;

	for (std::string const &line : m->original_lines) {
	left_lines.push_back(TextDiffLine(line, TextDiffLine::Del));
	right_lines.push_back(TextDiffLine());
	}

	setDiffText(diff, left_lines, right_lines);
	}
	}

	void FileDiffWidget::setRightOnly(QByteArray const &ba, Git::Diff const &diff)
	{
	m->init_param_ = InitParam_();
	m->init_param_.view_style = FileDiffWidget::ViewStyle::RightOnly;
	m->init_param_.bytes_b = ba;
	m->init_param_.diff = diff;

	setOriginalLines_(ba);

	if (setupPreviewWidget() == FileViewType::Text) {

	TextDiffLineList left_lines;
	TextDiffLineList right_lines;

	for (std::string const &line : m->original_lines) {
	left_lines.push_back(TextDiffLine());
	right_lines.push_back(TextDiffLine(line, TextDiffLine::Add));
	}

	setDiffText(diff, left_lines, right_lines);
	}
	}

	void FileDiffWidget::setSideBySide(QByteArray const &ba, Git::Diff const &diff, bool uncommited, QString const &workingdir)
	{
	m->init_param_ = InitParam_();
	m->init_param_.view_style = FileDiffWidget::ViewStyle::SideBySideText;
	m->init_param_.bytes_a = ba;
	m->init_param_.diff = diff;
	m->init_param_.uncommited = uncommited;
	m->init_param_.workingdir = workingdir;

	setOriginalLines_(ba);

	if (setupPreviewWidget() == FileViewType::Text) {

	TextDiffLineList left_lines;
	TextDiffLineList right_lines;

	makeSideBySideDiffData(diff, m->original_lines, &left_lines, &right_lines);

	setDiffText(diff, left_lines, right_lines);
	}
	}

	void FileDiffWidget::setSideBySide_(QByteArray const &ba_a, QByteArray const &ba_b, QString const &workingdir)
	{
	m->init_param_ = InitParam_();
	m->init_param_.view_style = FileDiffWidget::ViewStyle::SideBySideImage;
	m->init_param_.bytes_a = ba_a;
	m->init_param_.bytes_b = ba_b;
	m->init_param_.workingdir = workingdir;

	setOriginalLines_(ba_a);

	if (setupPreviewWidget() == FileViewType::Text) {

	TextDiffLineList left_lines;
	TextDiffLineList right_lines;

	makeSideBySideDiffData(m->init_param_.diff, m->original_lines, &left_lines, &right_lines);

	setDiffText(m->init_param_.diff, left_lines, right_lines);
	}
	}

	QString FileDiffWidget::diffObjects(GitPtr g, QString const &a_id, QString const &b_id)
	{
	if (m->text_codec) {
	Git::Object obj_a = mainwindow()->cat_file_(g, a_id);
	Git::Object obj_b = mainwindow()->cat_file_(g, b_id);
	if (obj_b.type == Git::Object::Type::UNKNOWN) {
	obj_b.type = Git::Object::Type::BLOB;
	}
	if (obj_a.type == Git::Object::Type::BLOB && obj_b.type == Git::Object::Type::BLOB) {
	QString path_a = mainwindow()->newTempFilePath();
	QString path_b = mainwindow()->newTempFilePath();
	QFile file_a(path_a);
	QFile file_b(path_b);
	if (file_a.open(QFile::WriteOnly) && file_b.open(QFile::WriteOnly)) {
	file_a.write(m->text_codec->toUnicode(obj_a.content).toUtf8());
	file_b.write(m->text_codec->toUnicode(obj_b.content).toUtf8());
	file_a.close();
	file_b.close();
	QString s = g->diff_file(path_a, path_b);
	file_a.remove();
	file_b.remove();
	return s;
	}
	}
	}
	return GitDiff::diffObjects(g, a_id, b_id);
	}

	bool FileDiffWidget::isValidID_(QString const &id)
	{
	if (id.startsWith(PATH_PREFIX)) {
	return true;
	}
	return Git::isValidID(id);
	}

	void FileDiffWidget::updateDiffView(Git::Diff const &info, bool uncommited)
	{
	GitPtr g = git();
	if (!g) return;
	if (!g->isValidWorkingCopy()) return;

	if (isValidID_(info.blob.a_id) && isValidID_(info.blob.b_id)) {
	Git::Object obj_a = cat_file(g, info.blob.a_id);
	Git::Object obj_b = cat_file(g, info.blob.b_id);
	QString mime_a = mainwindow()->determinFileType(obj_a.content, true);
	QString mime_b = mainwindow()->determinFileType(obj_b.content, true);
	if (misc::isImage(mime_a) && misc::isImage(mime_b)) {
	setSideBySide_(obj_a.content, obj_b.content, g->workingRepositoryDir());
	return;
	}
	}

	{
	Git::Diff diff;
	if (isValidID_(info.blob.a_id) && isValidID_(info.blob.b_id)) {
	std::string text = diffObjects(g, info.blob.a_id, info.blob.b_id).toStdString();
	GitDiff::parseDiff(text, &info, &diff);
	} else {
	diff = info;
	}

	Git::Object obj;
	if (isValidID_(diff.blob.a_id)) { // 左が有効
	obj = cat_file(g, diff.blob.a_id);
	if (isValidID_(diff.blob.b_id)) { // 右が有効
	setSideBySide(obj.content, diff, uncommited, g->workingRepositoryDir()); // 通常のdiff表示
	} else {
	setLeftOnly(obj.content, diff); // 右が無効の時は、削除されたファイル
	}
	} else if (isValidID_(diff.blob.b_id)) { // 左が無効で右が有効の時は、追加されたファイル
	obj = cat_file(g, diff.blob.b_id);
	setRightOnly(obj.content, diff);
	}
	}
	}

	void FileDiffWidget::updateDiffView(QString id_left, QString id_right, QString const &path)
	{
	GitPtr g = git();
	if (!g) return;
	if (!g->isValidWorkingCopy()) return;

	Git::Diff diff;
	diff.path = path;
	diff.blob.a_id = id_left;
	diff.blob.b_id = id_right;
	diff.mode = "0";
	std::string text = diffObjects(g, diff.blob.a_id, diff.blob.b_id).toStdString();
	GitDiff::parseDiff(text, &diff, &diff);

	Git::Object obj = cat_file(g, diff.blob.a_id);
	setSideBySide(obj.content, diff, false, g->workingRepositoryDir());

	ui->widget_diff_slider->clear(false);

	resetScrollBarValue();
	updateControls();

	ui->widget_diff_slider->update();
	}

	void FileDiffWidget::resizeEvent(QResizeEvent *)
	{
	refrectScrollBar();
	}

	void FileDiffWidget::keyPressEvent(QKeyEvent *event)
	{
	if (event->key() == Qt::Key_Escape) {
	event->ignore(); // Escが押されたとき、親ウィジェットに処理させる。（通常、ウィンドウを閉じる、など）
	return;
	}

	if (focusWidget() == ui->widget_diff_left->texteditor()) {
	ui->widget_diff_left->write(event);
	} else if (focusWidget() == ui->widget_diff_right->texteditor()) {
	ui->widget_diff_right->write(event);
	}
	}

	void FileDiffWidget::scrollTo(int value)
	{
	ui->verticalScrollBar->setValue(value);
	}

	void FileDiffWidget::onVerticalScrollValueChanged(int)
	{
	refrectScrollBar();
	}

	void FileDiffWidget::onHorizontalScrollValueChanged(int)
	{
	refrectScrollBar();
	}

	void FileDiffWidget::onDiffWidgetWheelScroll(int lines)
	{
	while (lines > 0) {
	ui->verticalScrollBar->triggerAction(QScrollBar::SliderSingleStepAdd);
	lines--;
	}
	while (lines < 0) {
	ui->verticalScrollBar->triggerAction(QScrollBar::SliderSingleStepSub);
	lines++;
	}
	}

	void FileDiffWidget::onScrollValueChanged2(int value)
	{
	ui->verticalScrollBar->setValue(value);
	}

	void FileDiffWidget::onDiffWidgetResized()
	{
	updateControls();
	}

	void FileDiffWidget::on_toolButton_fullscreen_clicked()
	{
	BigDiffWindow win(mainwindow());
	win.setWindowState(Qt::WindowMaximized);
	win.init(mainwindow(), m->init_param_);
	win.exec();
	}

	void FileDiffWidget::setFocusAcceptable(bool f)
	{
	Qt::FocusPolicy focuspolicy = f ? Qt::StrongFocus : Qt::NoFocus;
	ui->widget_diff_left->setFocusPolicy(focuspolicy);
	ui->widget_diff_right->setFocusPolicy(focuspolicy);
	}

	void FileDiffWidget::onUpdateSliderBar()
	{
	int total = m->engine_left->document.lines.size();
	int value = ui->verticalScrollBar->value();
	int page = ui->verticalScrollBar->pageStep();
	ui->widget_diff_slider->setScrollPos(total, value, page);
	}

	void FileDiffWidget::refrectScrollBar()
	{
	ui->widget_diff_left->refrectScrollBar();
	ui->widget_diff_right->refrectScrollBar();
	onUpdateSliderBar();
	}

	QPixmap FileDiffWidget::makeDiffPixmap(DiffPane pane, int width, int height)
	{
	auto Do = [&](TextDiffLineList const &lines){
	return FileDiffSliderWidget::makeDiffPixmap(width, height, lines, global->theme);
	};
	if (pane == DiffPane::Left) return Do(m->left_lines);
	if (pane == DiffPane::Right) return Do(m->right_lines);
	return QPixmap();
	}

	void FileDiffWidget::onMoved(int cur_row, int cur_col, int scr_row, int scr_col)
	{
	(void)cur_col;
	(void)cur_row;
	ui->widget_diff_left->move(-1, -1, scr_row, scr_col, false);
	ui->widget_diff_right->move(-1, -1, scr_row, scr_col, false);
	refrectScrollBar();
	onUpdateSliderBar();
	}

	void FileDiffWidget::setTextCodec(QTextCodec *codec)
	{
	m->text_codec = codec;
	ui->widget_diff_left->setTextCodec(codec);
	ui->widget_diff_right->setTextCodec(codec);
	emit textcodecChanged();
	}

	void FileDiffWidget::setTextCodec(char const *name)
	{
	QTextCodec *codec = name ? QTextCodec::codecForName(name) : nullptr;
	setTextCodec(codec);
	}

	void FileDiffWidget::on_toolButton_menu_clicked()
	{
	QMenu menu;
	QAction *a_utf8 = menu.addAction("UTF-8");
	QAction *a_sjis = menu.addAction("SJIS (CP932)");
	QAction *a_eucjp = menu.addAction("EUC-JP");
	QAction *a_iso2022jp = menu.addAction("JIS (ISO-2022-JP)");
	QAction *a = menu.exec(QCursor::pos() + QPoint(8, -8));
	if (a) {
	if (a == a_utf8) {
	setTextCodec((char const *)nullptr);
	return;
	}
	if (a == a_sjis) {
	setTextCodec("Shift_JIS");
	return;
	}
	if (a == a_eucjp) {
	setTextCodec("EUC-JP");
	return;
	}
	if (a == a_iso2022jp) {
	setTextCodec("ISO-2022-JP");
	return;
	}
	}
	}
	diff --git a/src/FileUtil.cpp b/src/FileUtil.cpp
	index 712b682..dfd6383 100644
	--- a/src/FileUtil.cpp
	+++ b/src/FileUtil.cpp
	@@ -1,274 +1,274 @@

	#include "FileUtil.h"
	#include "common/joinpath.h"

	#include <sys/stat.h>

	#ifdef __HAIKU__
	struct stat s;
	#endif

	#ifdef _WIN32
	#include <windows.h>
	#include <direct.h>

	std::string FileUtil::getcwd()
	{
	std::string cwd;
	- char *p = _getcwd(0, 0);
	+ char *p = _getcwd(nullptr, 0);
	cwd = p;
	free(p);
	return cwd;
	}

	bool FileUtil::isdir(std::string const &path)
	{
	DWORD f = GetFileAttributesA(path.c_str());
	return f != INVALID_FILE_ATTRIBUTES && (f & FILE_ATTRIBUTE_DIRECTORY) != 0;
	}

	void FileUtil::mkdir(const std::string &dir, int /perm/)
	{
	- CreateDirectoryA(dir.c_str(), 0);
	+ CreateDirectoryA(dir.c_str(), nullptr);
	}

	void FileUtil::rmdir(const std::string &dir)
	{
	RemoveDirectoryA(dir.c_str());
	}

	bool FileUtil::chdir(const std::string &dir)
	{
	return SetCurrentDirectoryA(dir.c_str()) != 0;
	}

	void FileUtil::rmfile(const std::string &path)
	{
	DeleteFileA(path.c_str());
	}

	void FileUtil::mv(const std::string &src, const std::string &dst)
	{
	MoveFileA(src.c_str(), dst.c_str());
	// DWORD e = GetLastError();
	}

	void FileUtil::getdirents(const std::string &loc, std::vector<DirEnt> *out)
	{
	out->clear();
	std::string filter = loc / ".";
	WIN32_FIND_DATAA fd;
	HANDLE h = FindFirstFileA(filter.c_str(), &fd);
	if (h != INVALID_HANDLE_VALUE) {
	do {
	DirEnt de;
	de.name = fd.cFileName;
	if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
	if (de.name == "." \|\| de.name == "..") {
	continue;
	}
	de.isdir = true;
	}
	out->push_back(de);
	} while (FindNextFileA(h, &fd));
	FindClose(h);
	}
	}

	#else // _WIN32
	#include <unistd.h>
	#include <dirent.h>
	#include <pwd.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <stdio.h>
	#include <fcntl.h>

	std::string FileUtil::getcwd()
	{
	std::string cwd;
	char *p = ::getcwd(0, 0);
	cwd = p;
	free(p);
	return cwd;
	}

	bool FileUtil::isdir(std::string const &path)
	{
	struct stat st;
	if (stat(path.c_str(), &st) == 0) {
	if (st.st_mode & S_IFDIR) {
	return true;
	}
	}
	return false;
	}

	void FileUtil::rmdir(const std::string &dir)
	{
	::rmdir(dir.c_str());
	}

	void FileUtil::rmfile(const std::string &path)
	{
	unlink(path.c_str());
	}

	void FileUtil::mkdir(const std::string &dir, int perm)
	{
	::mkdir(dir.c_str(), perm);
	}

	bool FileUtil::chdir(const std::string &dir)
	{
	return ::chdir(dir.c_str()) == 0;
	}

	void FileUtil::mv(std::string const &src, std::string const &dst)
	{
	rename(src.c_str(), dst.c_str());
	}

	void FileUtil::getdirents(std::string const &loc, std::vector<DirEnt> *out)
	{
	out->clear();
	DIR *dir = opendir(loc.c_str());
	if (dir) {
	while (dirent *d = readdir(dir)) {
	DirEnt de;
	de.name = d->d_name;
	de.isdir = false;
	#ifdef DT_DIR
	if (d->d_type & DT_DIR) {
	#else
	stat(d->d_name, &s);
	if(S_ISDIR(s.st_mode)) {
	#endif
	if (de.name == "." \|\| de.name == "..") {
	continue;
	}
	de.isdir = true;
	}
	out->push_back(de);
	}
	closedir(dir);
	}
	}

	#endif

	void FileUtil::rmtree(const std::string &path)
	{
	std::vector<DirEnt> ents;
	getdirents(path, &ents);
	for (DirEnt const &e : ents) {
	if (e.isdir) {
	rmtree(path / e.name);
	} else {
	rmfile(path / e.name);
	}
	}
	rmdir(path);
	}

	#ifdef _WIN32
	std::string FileUtil::normalize_path_separator(std::string const &s)
	{
	if (!s.empty()) {
	size_t n = s.size();
	std::vector<char> v;
	v.reserve(n);
	for (size_t i = 0; i < n; i++) {
	char c = s[i];
	if (c == '/') {
	c = '\\';
	}
	v.push_back(c);
	}
	char const *p = &v[0];
	return std::string(p, p + n);
	}
	return std::string();
	}
	#else
	std::string FileUtil::normalize_path_separator(std::string const &s)
	{
	return s;
	}
	#endif

	static std::string which(std::string const &name, std::string const &dir)
	{
	std::vector<FileUtil::DirEnt> ents;
	FileUtil::getdirents(dir, &ents);
	for (FileUtil::DirEnt const &ent : ents) {
	if (!ent.isdir) {
	#ifdef _WIN32
	if (stricmp(ent.name.c_str(), name.c_str()) == 0) {
	return FileUtil::normalize_path_separator(dir / ent.name);
	}
	#else
	if (ent.name == name) {
	return dir / ent.name;
	}
	#endif
	}
	}
	return std::string();
	}

	static void split_path(std::string const &path, std::vector<std::string> *out)
	{
	char const *begin = path.c_str();
	char const *end = begin + path.size();
	char const *ptr = begin;
	char const *left = ptr;
	#ifdef _WIN32
	const int sep = ';';
	#else
	const int sep = ':';
	#endif
	while (1) {
	int c = 0;
	if (ptr < end) {
	c = *ptr & 0xff;
	}
	if (c == sep \|\| c == 0) {
	if (left < ptr) {
	out->push_back(std::string(left, ptr));
	}
	if (c == 0) break;
	ptr++;
	left = ptr;
	} else {
	ptr++;
	}
	}
	}

	std::string FileUtil::which(std::string const &name, std::vector<std::string> *out)
	{
	if (out) {
	out->clear();
	}
	char const *p = getenv("PATH");
	if (p) {
	std::vector<std::string> paths;
	split_path(p, &paths);
	for (std::string const &path : paths) {
	std::string t = ::which(name, path);
	if (!t.empty()) {
	if (out) {
	out->push_back(t);
	} else {
	return t;
	}
	}
	}
	}
	if (out && !out->empty()) {
	return out->front();
	}
	return std::string();
	}

	diff --git a/src/Git.cpp b/src/Git.cpp
	index 1ed97e0..b657e4b 100644
	--- a/src/Git.cpp
	+++ b/src/Git.cpp
	@@ -1,1431 +1,1431 @@
	#include "Git.h"
	#include <QDateTime>
	#include <QDebug>
	#include <QDir>
	#include <QDirIterator>
	#include <QProcess>
	#include <QThread>
	#include <QTimer>
	#include <set>
	#include "common/joinpath.h"
	#include "common/misc.h"
	#include "GitObjectManager.h"

	#include "MyProcess.h"

	#define DEBUGLOG 0

	using callback_t = Git::callback_t;

	struct Git::Private {
	QString git_command;
	std::vector<char> result;
	QString error_message;
	int process_exit_code = 0;
	QString working_repo_dir;
	callback_t callback_func = nullptr;
	void *callback_cookie = nullptr;
	};

	Git::Git()
	: m(new Private)
	{
	}

	Git::Git(const Context &cx, QString const &repodir)
	: m(new Private)
	{
	setGitCommand(cx.git_command);
	setWorkingRepositoryDir(repodir);
	}

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

	void Git::setLogCallback(callback_t func, void *cookie)
	{
	m->callback_func = func;
	m->callback_cookie = cookie;
	}

	void Git::setWorkingRepositoryDir(QString const &repo)
	{
	m->working_repo_dir = repo;
	}

	QString const &Git::workingRepositoryDir() const
	{
	return m->working_repo_dir;
	}

	bool Git::isValidID(const QString &id)
	{
	int zero = 0;
	int n = id.size();
	if (n > 2 && n <= GIT_ID_LENGTH) {
	ushort const *p = id.utf16();
	for (int i = 0; i < n; i++) {
	uchar c = p[i];
	if (c == '0') {
	zero++;
	} else if ((c >= '0' && c <= '9') \|\| (c >= 'a' && c <= 'f')) {
	// ok
	} else {
	return false;
	}
	}
	if (zero == GIT_ID_LENGTH) { // 全部 0 の時は false を返す
	return false;
	}
	return true; // ok
	}
	return false;
	}

	QByteArray Git::toQByteArray() const
	{
	if (m->result.empty()) return QByteArray();
	return QByteArray(&m->result[0], m->result.size());
	}

	QString Git::resultText() const
	{
	return QString::fromUtf8(toQByteArray());
	}
	void Git::setGitCommand(QString const &path)
	{
	m->git_command = path;
	}

	QString Git::gitCommand() const
	{
	Q_ASSERT(m);
	return m->git_command;
	}

	void Git::clearResult()
	{
	m->result.clear();
	m->process_exit_code = 0;
	m->error_message = QString();
	}

	QString Git::errorMessage() const
	{
	return m->error_message;
	}

	int Git::getProcessExitCode() const
	{
	return m->process_exit_code;
	}

	-bool Git::chdirexec(std::function<bool()> fn)
	+bool Git::chdirexec(std::function<bool()> const &fn)
	{
	bool ok = false;
	QDir cwd = QDir::current();
	QString dir = workingRepositoryDir();
	if (isValidWorkingCopy(dir) && QDir::setCurrent(dir)) {

	ok = fn();

	QDir::setCurrent(cwd.path());
	}
	return ok;
	}

	bool Git::git(const QString &arg, bool chdir, bool errout, AbstractPtyProcess *pty)
	{
	QFileInfo info(gitCommand());
	if (!info.isExecutable()) {
	qDebug() << "Invalid git command: " << gitCommand();
	return false;
	}
	#if DEBUGLOG
	qDebug() << "exec: git " << arg;
	QTime timer;
	timer.start();
	#endif
	clearResult();

	auto DoIt = [&](){
	QString cmd = QString("\"%1\" --no-pager ").arg(gitCommand());
	cmd += arg;

	if (m->callback_func) {
	QByteArray ba;
	ba.append("> git ");
	ba.append(arg);
	ba.append('\n');
	m->callback_func(m->callback_cookie, ba.data(), (int)ba.size());
	}

	if (pty) {
	pty->start(cmd);
	m->process_exit_code = 0; // バックグラウンドで実行を継続するけど、とりあえず成功したことにしておく
	} else {
	Process proc;
	proc.start(cmd, false);
	m->process_exit_code = proc.wait();

	if (errout) {
	m->result = proc.errbytes;
	} else {
	m->result = proc.outbytes;
	}
	m->error_message = proc.errstring();
	}

	return m->process_exit_code == 0;
	};

	bool ok = false;

	if (chdir) {
	if (pty) {
	pty->setChangeDir(workingRepositoryDir());
	ok = DoIt();
	} else {
	ok = chdirexec(DoIt);
	}
	} else {
	ok = DoIt();
	}

	#if DEBUGLOG
	qDebug() << timer.elapsed() << "ms";
	#endif

	return ok;
	}

	GitPtr Git::dup() const
	{
	Git *p = new Git();
	p->m->git_command = m->git_command;
	p->m->working_repo_dir = m->working_repo_dir;
	p->m->callback_func = m->callback_func;
	p->m->callback_cookie = m->callback_cookie;
	return GitPtr(p);
	}

	bool Git::isValidWorkingCopy(QString const &dir)
	{
	return QFileInfo(dir).isDir() && QDir(dir / ".git").exists();
	}

	bool Git::isValidWorkingCopy() const
	{
	return isValidWorkingCopy(workingRepositoryDir());
	}

	QString Git::version()
	{
	git("--version", false);
	return resultText().trimmed();
	}

	bool Git::init()
	{
	bool ok = false;
	QDir cwd = QDir::current();
	QString dir = workingRepositoryDir();
	if (QDir::setCurrent(dir)) {
	QString gitdir = dir / ".git";
	if (!QFileInfo(gitdir).isDir()) {
	git("init", false);
	if (QFileInfo(gitdir).isDir()) {
	ok = true;
	}
	}
	QDir::setCurrent(cwd.path());
	}
	return ok;
	}

	QString Git::rev_parse(QString const &name)
	{
	QString cmd = "rev-parse %1";
	cmd = cmd.arg(name);
	if (git(cmd)) {
	return resultText().trimmed();
	}
	return QString();
	}

	QStringList Git::refs()
	{
	QStringList lines;
	{
	QString path = workingRepositoryDir() / ".git/packed-refs";
	QFile file(path);
	if (file.open(QFile::ReadOnly)) {
	while (!file.atEnd()) {
	QByteArray ba = file.readLine();
	QString line = QString::fromLatin1(ba).trimmed();
	if (line.indexOf(" refs/") > 0) {
	lines.push_back(line);
	}
	}
	}
	}
	{
	QString refspath = workingRepositoryDir() / ".git/refs/tags";
	QDirIterator it(refspath);
	while (it.hasNext()) {
	it.next();
	QString path = it.filePath();
	if (QFileInfo(path).isFile()) {
	QString name = it.fileName();
	QFile file(path);
	if (file.open(QFile::ReadOnly)) {
	QByteArray ba = file.readAll();
	QString id = QString::fromLatin1(ba).trimmed();
	if (Git::isValidID(id)) {
	QString line = id + " refs/tags/" + name;
	lines.push_back(line);
	}
	}
	}
	}
	}
	return lines;
	}

	QList<Git::Tag> Git::tags()
	{
	auto MidCmp = [](QString const &line, int i, char const *ptr){
	ushort const *p = line.utf16();
	for (int j = 0; ptr[j]; j++) {
	if (p[i + j] != ptr[j]) return false;
	}
	return true;
	};
	QList<Git::Tag> list;
	QStringList lines = refs();
	for (QString const &line : lines) {
	Tag tag;
	if (line.isEmpty()) continue;
	int i = line.indexOf(' ');
	if (i == GIT_ID_LENGTH) {
	tag.id = line.mid(0, i);
	if (MidCmp(line, i, " refs/tags/")) {
	tag.name = line.mid(i + 11).trimmed();
	if (tag.name.isEmpty()) continue;
	list.push_back(tag);
	}
	}
	}
	return list;
	}

	bool Git::tag(const QString &name, const QString &id)
	{
	QString cmd = "tag \"%1\" %2";
	cmd = cmd.arg(name).arg(id);
	return git(cmd);
	}

	void Git::delete_tag(const QString &name, bool remote)
	{
	QString cmd = "tag --delete \"%1\"";
	cmd = cmd.arg(name);
	git(cmd);

	if (remote) {
	QString cmd = "push --delete origin \"%1\"";
	cmd = cmd.arg(name);
	git(cmd);
	}
	}

	QString Git::diff(QString const &old_id, QString const &new_id)
	{
	QString cmd = "diff --full-index -a %1 %2";
	cmd = cmd.arg(old_id).arg(new_id);
	git(cmd);
	return resultText();
	}

	QString Git::diff_file(QString const &old_path, QString const &new_path)
	{
	QString cmd = "diff --full-index -a -- %1 %2";
	cmd = cmd.arg(old_path).arg(new_path);
	git(cmd);
	return resultText();
	}

	QList<Git::DiffRaw> Git::diff_raw(QString const &old_id, QString const &new_id)
	{
	QList<DiffRaw> list;
	QString cmd = "diff --raw --abbrev=%1 %2 %3";
	cmd = cmd.arg(GIT_ID_LENGTH).arg(old_id).arg(new_id);
	git(cmd);
	QString text = resultText();
	QStringList lines = text.split('\n', QString::SkipEmptyParts);
	for (QString const &line : lines) { // raw format: e.g. ":100644 100644 08bc10d... 18f0501... M src/MainWindow.cpp"
	DiffRaw item;
	int colon = line.indexOf(':');
	int tab = line.indexOf('\t');
	if (colon >= 0 && colon < tab) {
	QStringList header = line.mid(colon + 1, tab - colon - 1).split(' ', QString::SkipEmptyParts); // コロンとタブの間の文字列を空白で分割
	if (header.size() >= 5) {
	QStringList files = line.mid(tab + 1).split('\t', QString::SkipEmptyParts); // タブより後ろはファイルパス
	- if (files.size() > 0) {
	+ if (!files.empty()) {
	for (QString &file : files) {
	file = Git::trimPath(file);
	}
	item.a.id = header[2];
	item.b.id = header[3];
	item.a.mode = header[0];
	item.b.mode = header[1];
	item.state = header[4];
	item.files = files;
	list.push_back(item);
	}
	}
	}
	}
	return list;
	}

	QString Git::diff_to_file(QString const &old_id, QString const &path)
	{
	#if 1
	QString cmd = "diff --full-index -a %1 -- \"%2\"";
	cmd = cmd.arg(old_id).arg(path);
	git(cmd);
	return resultText();
	#else
	return diff_(old_id, new_id);
	#endif
	}

	QString Git::getCurrentBranchName()
	{
	if (isValidWorkingCopy()) {
	git("rev-parse --abbrev-ref HEAD");
	QString s = resultText().trimmed();
	if (!s.isEmpty() && !s.startsWith("fatal:") && s.indexOf(' ') < 0) {
	return s;
	}
	}
	return QString();
	}

	QStringList Git::getUntrackedFiles()
	{
	QStringList files;
	Git::FileStatusList stats = status();
	for (FileStatus const &s : stats) {
	if (s.code() == FileStatusCode::Untracked) {
	files.push_back(s.path1());
	}
	}
	return files;
	}

	void Git::parseAheadBehind(QString const &s, Branch *b)
	{
	ushort const *begin = s.utf16();
	ushort const *end = begin + s.size();
	ushort const *ptr = begin;

	auto NCompare = [](ushort const a, char const b, size_t n){
	for (size_t i = 0; i < n; i++) {
	if (a < (unsigned char)b) return false;
	if (a > (unsigned char)b) return false;
	if (!*a) break;
	a++;
	b++;
	}
	return true;
	};

	auto SkipSpace = [&](){
	while (ptr < end && QChar(*ptr).isSpace()) {
	ptr++;
	}
	};

	auto GetNumber = [&](){
	int n = 0;
	while (ptr < end && QChar(*ptr).isDigit()) {
	n = n * 10 + (*ptr - '0');
	ptr++;
	}
	return n;
	};

	if (*ptr == '[') {
	ptr++;
	ushort const *e = nullptr;
	int n;
	for (n = 0; ptr + n < end; n++) {
	if (ptr[n] == ']') {
	e = ptr + n;
	break;
	}
	}
	if (e) {
	end = e;
	while (1) {
	if (NCompare(ptr, "ahead ", 6)) {
	ptr += 6;
	SkipSpace();
	b->ahead = GetNumber();
	} else if (NCompare(ptr, "behind ", 7)) {
	ptr += 7;
	SkipSpace();
	b->behind = GetNumber();
	} else {
	ushort c = 0;
	if (ptr < end) {
	c = *ptr;
	}
	if (c == 0) break;
	ptr++;
	}
	}
	}
	}
	}

	QList<Git::Branch> Git::branches()
	{
	QList<Branch> branches;
	git(QString("branch -vv -a --abbrev=%1").arg(GIT_ID_LENGTH));
	QString s = resultText();
	#if DEBUGLOG
	qDebug() << s;
	#endif

	QStringList lines = misc::splitLines(s);
	for (QString const &line : lines) {
	if (line.size() > 2) {
	QString name;
	QString text = line.mid(2);
	int pos = 0;
	if (text.startsWith('(')) {
	int i, paren = 1;
	for (i = 1; i < text.size(); i++) {
	if (text[i] == '(') {
	paren++;
	} else if (text[i] == ')') {
	if (paren > 0) {
	paren--;
	if (paren == 0) {
	pos = i;
	break;
	}
	}
	}
	}
	// pos = text.indexOf(')');
	if (pos > 1) {
	name = text.mid(1, pos - 1);
	pos++;
	}
	} else {
	while (pos < text.size() && !QChar::isSpace(text.utf16()[pos])) {
	pos++;
	}
	name = text.mid(0, pos);
	}
	if (!name.isEmpty()) {
	while (pos < text.size() && QChar::isSpace(text.utf16()[pos])) {
	pos++;
	}
	text = text.mid(pos);

	Branch b;

	if (name.startsWith("HEAD detached at ")) {
	b.flags \|= Branch::HeadDetachedAt;
	name = name.mid(17);
	}

	if (name.startsWith("HEAD detached from ")) {
	b.flags \|= Branch::HeadDetachedFrom;
	name = name.mid(19);
	}

	if (name.startsWith("remotes/")) {
	name = name.mid(8);
	int i = name.indexOf('/');
	if (i > 0) {
	b.remote = name.mid(0, i);
	name = name.mid(i + 1);
	}
	}

	b.name = name;

	if (text.startsWith("-> ")) {
	b.id = ">" + text.mid(3);
	} else {
	int i = text.indexOf(' ');
	if (i == GIT_ID_LENGTH) {
	b.id = text.mid(0, GIT_ID_LENGTH);
	}
	while (i < text.size() && QChar::isSpace(text.utf16()[i])) {
	i++;
	}
	text = text.mid(i);
	parseAheadBehind(text, &b);
	}

	if (line.startsWith('*')) {
	b.flags \|= Branch::Current;
	}

	branches.push_back(b);
	}
	}
	}
	for (int i = 0; i < branches.size(); i++) {
	Branch *b = &branches[i];
	if (b->id.startsWith('>')) {
	QString name = b->id.mid(1);
	for (int j = 0; j < branches.size(); j++) {
	if (j != i) {
	if (branches[j].name == name) {
	branches[i].id = branches[j].id;
	break;
	}
	}
	}
	}
	}
	return branches;
	}

	Git::CommitItemList Git::log_all(QString const &id, int maxcount)
	{
	CommitItemList items;
	QString text;

	QString cmd = "log --pretty=format:\"commit:%H#gpg:%G?#key:%GK#parent:%P#author:%an#mail:%ae#date:%ci##%s\" --all -%1 %2";
	cmd = cmd.arg(maxcount).arg(id);
	git(cmd);
	if (getProcessExitCode() == 0) {
	text = resultText().trimmed();
	QStringList lines = misc::splitLines(text);
	for (QString const &line : lines) {
	int i = line.indexOf("##");
	if (i > 0) {
	Git::CommitItem item;
	QString signed_key;
	item.message = line.mid(i + 2);
	QStringList atts = line.mid(0, i).split('#');
	for (QString const &s : atts) {
	int j = s.indexOf(':');
	if (j > 0) {
	QString key = s.mid(0, j);
	QString val = s.mid(j + 1);
	if (key == "commit") {
	item.commit_id = val;
	} else if (key == "gpg") {
	item.signature = *val.utf16();
	} else if (key == "key") {
	signed_key = val;
	} else if (key == "parent") {
	item.parent_ids = val.split(' ', QString::SkipEmptyParts);
	} else if (key == "author") {
	item.author = val;
	} else if (key == "mail") {
	item.email = val;
	} else if (key == "date") {
	item.commit_date = QDateTime::fromString(val, Qt::ISODate).toLocalTime();
	} else if (key == "debug") {
	}
	}
	}
	if (!signed_key.isEmpty()) {
	ushort const *begin = signed_key.utf16();
	int n = signed_key.size();
	for (int i = 0; i + 1 < n; i += 2) {
	ushort c = begin[i];
	ushort d = begin[i + 1];
	- if (c < 0x80 && c < 0x80 && isxdigit(c) && isxdigit(d)) {
	+ if (c < 0x80 && isxdigit(c) && isxdigit(d)) {
	char tmp[3];
	tmp[0] = c;
	tmp[1] = d;
	tmp[2] = 0;
	int v = strtol(tmp, nullptr, 16);
	item.fingerprint.push_back(v);
	} else {
	break;
	}
	}
	}
	items.push_back(item);
	}
	}
	}
	return items;
	}

	Git::CommitItemList Git::log(int maxcount)
	{
	return log_all(QString(), maxcount);
	}

	bool Git::queryCommit(QString const &id, CommitItem *out)
	{
	if (objectType(id) == "commit") {
	out->commit_id = id;
	QByteArray ba;
	if (cat_file(id, &ba)) {
	QStringList lines = misc::splitLines(ba, [](char const *p, size_t n){
	return QString::fromUtf8(p, (int)n);
	});
	- while (lines.size() > 0 && lines[lines.size() - 1].isEmpty()) {
	+ while (!lines.empty() && lines[lines.size() - 1].isEmpty()) {
	lines.pop_back();
	}

	int i;
	for (i = 0; i < lines.size(); i++) {
	QString const &line = lines[i];
	if (line.isEmpty()) {
	i++;
	for (; i < lines.size(); i++) {
	QString const &line = lines[i];
	if (!out->message.isEmpty()) {
	out->message.append('\n');
	}
	out->message.append(line);
	}
	break;
	}
	if (line.startsWith("parent ")) {
	out->parent_ids.push_back(line.mid(7));
	} else if (line.startsWith("author ")) {
	QStringList arr = misc::splitWords(line);
	int n = arr.size();
	if (n > 4) {
	n -= 2;
	out->commit_date = QDateTime::fromTime_t(atol(arr[n].toStdString().c_str()));
	n--;
	out->email = arr[n];
	if (out->email.startsWith('<') && out->email.endsWith('>')) {
	int n = out->email.size();
	out->email = out->email.mid(1, n - 2);
	}
	for (int i = 1; i < n; i++) {
	if (!out->author.isEmpty()) {
	out->author += ' ';
	}
	out->author += arr[i];
	}
	}
	}
	}
	}
	return true;
	}
	return false;
	}

	Git::CloneData Git::preclone(QString const &url, QString const &path)
	{
	CloneData d;
	d.url = url;
	if (path.endsWith('/') \|\| path.endsWith('\\')) {
	auto GitBaseName = [](QString location){
	int i = location.lastIndexOf('/');
	int j = location.lastIndexOf('\\');
	if (i < j) i = j;
	i = i < 0 ? 0 : (i + 1);
	j = location.size();
	if (location.endsWith(".git")) {
	j -= 4;
	}
	if (i < j) {
	location = location.mid(i, j - i);
	}
	return location;
	};
	d.basedir = path;
	d.subdir = GitBaseName(url);
	} else {
	QFileInfo info(path);
	d.basedir = info.dir().path();
	d.subdir = info.fileName();
	}
	return d;
	}

	bool Git::clone(CloneData const &data, AbstractPtyProcess *pty)
	{
	QString clone_to = data.basedir / data.subdir;
	m->working_repo_dir = misc::normalizePathSeparator(clone_to);

	bool ok = false;
	QDir cwd = QDir::current();

	auto DoIt = [&](){
	QString cmd = "clone --progress \"%1\" \"%2\"";
	cmd = cmd.arg(data.url).arg(data.subdir);
	ok = git(cmd, false, true, pty);
	};

	if (pty) {
	pty->setChangeDir(data.basedir);
	DoIt();
	} else {
	if (QDir::setCurrent(data.basedir)) {
	DoIt();
	QDir::setCurrent(cwd.path());
	}
	}

	return ok;
	}

	QString Git::encodeQuotedText(const QString &str)
	{
	std::vector<ushort> vec;
	ushort const *begin = str.utf16();
	ushort const *end = begin + str.size();
	ushort const *ptr = begin;
	vec.push_back('\"');
	while (ptr < end) {
	ushort c = *ptr;
	ptr++;
	if (c == '\"') { // triple quotes
	vec.push_back(c);
	vec.push_back(c);
	vec.push_back(c);
	} else {
	vec.push_back(c);
	}
	}
	vec.push_back('\"');
	return QString::fromUtf16(&vec[0], vec.size());
	}

	bool Git::commit_(QString const &msg, bool amend, bool sign, AbstractPtyProcess *pty)
	{
	QString cmd = "commit";
	if (amend) {
	cmd += " --amend";
	}
	if (sign) {
	cmd += " -S";
	}

	QString text = msg.trimmed();
	if (text.isEmpty()) {
	text = "no message";
	}
	text = encodeQuotedText(text);
	cmd += QString(" -m %1").arg(text);

	return git(cmd, true, false, pty);
	}

	bool Git::commit(QString const &text, bool sign, AbstractPtyProcess *pty)
	{
	return commit_(text, false, sign, pty);
	}

	bool Git::commit_amend_m(const QString &text, bool sign, AbstractPtyProcess *pty)
	{
	return commit_(text, true, sign, pty);
	}

	bool Git::revert(const QString &id)
	{
	QString cmd = "revert %1";
	cmd = cmd.arg(id);
	return git(cmd);
	}

	void Git::push_u(QString const &remote, QString const &branch, AbstractPtyProcess *pty)
	{
	if (remote.indexOf('\"') >= 0 \|\| branch.indexOf('\"') >= 0) {
	return;
	}
	QString cmd = "push -u \"%1\" \"%2\"";
	git(cmd.arg(remote).arg(branch), true, false, pty);
	}

	bool Git::push_(bool tags, AbstractPtyProcess *pty)
	{
	QString cmd = "push";
	if (tags) {
	cmd += " --tags";
	}
	return git(cmd, true, false, pty);
	}

	bool Git::push(bool tags, AbstractPtyProcess *pty)
	{
	return push_(tags, pty);
	}


	Git::FileStatusList Git::status_()
	{
	FileStatusList files;
	if (git("status -s -u --porcelain")) {
	QString text = resultText();
	QStringList lines = misc::splitLines(text);
	for (QString const &line : lines) {
	if (line.size() > 3) {
	FileStatus s(line);
	if (s.code() != FileStatusCode::Unknown) {
	files.push_back(s);
	}
	}
	}
	}
	return files;
	}

	Git::FileStatusList Git::status()
	{
	return status_();
	}

	QString Git::objectType(QString const &id)
	{
	git("cat-file -t " + id);
	return resultText().trimmed();
	}

	QByteArray Git::cat_file_(QString const &id)
	{
	git("cat-file -p " + id);
	return toQByteArray();
	}

	bool Git::cat_file(QString const &id, QByteArray *out)
	{
	if (isValidID(id)) {
	*out = cat_file_(id);
	return true;
	}
	return false;
	}

	void Git::resetFile(const QString &path)
	{
	git("checkout -- " + path);
	}

	void Git::resetAllFiles()
	{
	git("reset --hard HEAD");
	}

	void Git::removeFile(const QString &path)
	{
	git("rm " + path);
	}

	void Git::stage(QString const &path)
	{
	git("add " + path);
	}

	void Git::stage(QStringList const &paths)
	{
	QString cmd = "add";
	for (QString const &path : paths) {
	cmd += ' ';
	cmd += '\"';
	cmd += path;
	cmd += '\"';
	}
	git(cmd);
	}

	void Git::unstage(QString const &path)
	{
	QString cmd = "reset HEAD \"%1\"";
	git(cmd.arg(path));
	}

	void Git::unstage(QStringList const &paths)
	{
	QString cmd = "reset HEAD";
	for (QString const &path : paths) {
	cmd += " \"";
	cmd += path;
	cmd += '\"';
	}
	git(cmd);
	}

	void Git::pull(AbstractPtyProcess *pty)
	{
	git("pull", true, false, pty);
	}

	void Git::fetch(AbstractPtyProcess *pty)
	{
	git("fetch", true, false, pty);
	}

	void Git::rebaseOnto(QString const &newbase, QString const &upstream, QString const &branch, AbstractPtyProcess *pty)
	{
	QString cmd = "rebase --onto \"%1\" \"%2\" \"%3\"";
	cmd = cmd.arg(newbase).arg(upstream).arg(branch);
	git(cmd, true, false, pty);
	}

	QStringList Git::make_branch_list_()
	{
	QStringList list;
	QStringList l = misc::splitLines(resultText());
	for (QString const &s : l) {
	if (s.startsWith("* ")) list.push_back(s.mid(2));
	if (s.startsWith(" ")) list.push_back(s.mid(2));
	}
	return list;
	}

	void Git::createBranch(QString const &name)
	{
	git("branch " + name);
	}

	void Git::checkoutBranch(QString const &name)
	{
	git("checkout " + name);
	}

	void Git::cherrypick(QString const &name)
	{
	git("cherry-pick " + name);
	}

	void Git::mergeBranch(QString const &name)
	{
	git("merge " + name);
	}

	void Git::rebaseBranch(QString const &name)
	{
	git("rebase " + name);
	}

	QStringList Git::getRemotes()
	{
	QStringList ret;
	git("remote");
	QStringList lines = misc::splitLines(resultText());
	for (QString const &line: lines) {
	if (!line.isEmpty()) {
	ret.push_back(line);
	}
	}
	return ret;
	}

	Git::User Git::getUser(Source purpose)
	{
	User user;
	bool global = purpose == Git::Source::Global;
	bool local = purpose == Git::Source::Local;
	QString arg1;
	if (global) arg1 = "--global";
	if (local) arg1 = "--local";
	bool chdir = !global;
	if (git(QString("config %1 user.name").arg(arg1), chdir)) {
	user.name = resultText().trimmed();
	}
	if (git(QString("config %1 user.email").arg(arg1), chdir)) {
	user.email = resultText().trimmed();
	}
	return user;
	}

	void Git::setUser(const User &user, bool global)
	{
	bool chdir = !global;
	git(QString("config %1 user.name %2").arg(global ? "--global" : "").arg(encodeQuotedText(user.name)), chdir);
	git(QString("config %1 user.email %2").arg(global ? "--global" : "").arg(encodeQuotedText(user.email)), chdir);
	}

	bool Git::reset_head1()
	{
	return git("reset HEAD~1");
	}

	bool Git::rm_cached(QString const &file)
	{
	QString cmd = "rm --cached \"%1\"";
	return git(cmd.arg(file));
	}

	void Git::getRemoteURLs(QList<Remote> *out)
	{
	out->clear();
	git("remote -v");
	QStringList lines = misc::splitLines(resultText());
	for (QString const &line : lines) {
	int i = line.indexOf('\t');
	int j = line.indexOf(" (");
	if (i > 0 && i < j) {
	Remote r;
	r.name = line.mid(0, i);
	r.url = line.mid(i + 1, j - i - 1);
	r.purpose = line.mid(j + 1);
	if (r.purpose.startsWith('(') && r.purpose.endsWith(')')) {
	r.purpose = r.purpose.mid(1, r.purpose.size() - 2);
	}
	out->push_back(r);
	}
	}
	}

	void Git::setRemoteURL(QString const &name, QString const &url)
	{
	QString cmd = "remote set-url %1 %2";
	cmd = cmd.arg(encodeQuotedText(name)).arg(encodeQuotedText(url));
	git(cmd);
	}

	void Git::addRemoteURL(QString const &name, QString const &url)
	{
	QString cmd = "remote add \"%1\" \"%2\"";
	cmd = cmd.arg(encodeQuotedText(name)).arg(encodeQuotedText(url));
	git(cmd);
	}

	void Git::removeRemote(QString const &name)
	{
	QString cmd = "remote remove %1";
	cmd = cmd.arg(encodeQuotedText(name));
	git(cmd);
	}

	bool Git::reflog(ReflogItemList *out, int maxcount)
	{
	out->clear();
	QString cmd = "reflog --no-abbrev --raw -n %1";
	cmd = cmd.arg(maxcount);
	if (!git(cmd)) return false;
	QByteArray ba = toQByteArray();
	if (!ba.isEmpty()) {
	ReflogItem item;
	char const *begin = ba.data();
	char const *end = begin + ba.size();
	char const *left = begin;
	char const *ptr = begin;
	while (1) {
	int c = 0;
	if (ptr < end) {
	c = *ptr;
	}
	if (c == '\r' \|\| c == '\n' \|\| c == 0) {
	int d = 0;
	QString line = QString::fromUtf8(left, ptr - left);
	if (left < ptr) {
	d = *left & 0xff;
	}
	if (d == ':') {
	// ex. ":100644 100644 bb603836fb597cca994309a1f0a52251d6b20314 d6b9798854debee375bb419f0f2ed9c8437f1932 M\tsrc/MainWindow.cpp"
	int tab = line.indexOf('\t');
	if (tab > 1) {
	QString tmp = line.mid(1, tab - 1);
	QString path = line.mid(tab + 1);
	QStringList cols = misc::splitWords(tmp);
	if (!path.isEmpty() && cols.size() == 5) {
	ReflogItem::File file;
	file.atts_a = cols[0];
	file.atts_b = cols[1];
	file.id_a = cols[2];
	file.id_b = cols[3];
	file.type = cols[4];
	file.path = path;
	item.files.push_back(file);
	}
	}
	} else {
	bool start = isxdigit(d);
	if (start \|\| c == 0) {
	if (!item.id.isEmpty()) {
	out->push_back(item);
	}
	}
	if (start) {
	// ex. "0a2a8b6b66f48bcbf985d8a2afcd14ff41676c16 HEAD@{188}: commit: comment text"
	item = ReflogItem();
	int i = line.indexOf(": ");
	if (i > 0) {
	int j = line.indexOf(": ", i + 2);
	if (j > 2) {
	item.head = line.mid(0, i);
	item.command = line.mid(i + 2, j - i - 2);
	item.comment= line.mid(j + 2);
	if (item.head.size() > GIT_ID_LENGTH) {
	item.id = item.head.mid(0, GIT_ID_LENGTH);
	item.head = item.head.mid(GIT_ID_LENGTH + 1);
	}
	}
	}
	}
	}
	if (c == 0) break;
	ptr++;
	left = ptr;
	} else {
	ptr++;
	}
	}
	}
	return true;
	}

	// Git::FileStatus

	QString Git::trimPath(QString const &s)
	{
	ushort const *begin = s.utf16();
	ushort const *end = begin + s.size();
	ushort const *left = begin;
	ushort const *right = end;
	while (left < right && QChar(*left).isSpace()) left++;
	while (left < right && QChar(right[-1]).isSpace()) right--;
	if (left + 1 < right && *left == '\"' && right[-1] == '\"') { // if quoted ?
	left++;
	right--;
	QByteArray ba;
	ushort const *ptr = left;
	while (ptr < right) {
	ushort c = *ptr;
	ptr++;
	if (c == '\\') {
	c = 0;
	while (ptr < right && QChar(*ptr).isDigit()) { // decode \oct
	c = c * 8 + (*ptr - '0');
	ptr++;
	}
	}
	ba.push_back(c);
	}
	return QString::fromUtf8(ba);
	}
	if (left == begin && right == end) return s;
	return QString::fromUtf16(left, right - left);
	}

	Git::FileStatusCode Git::FileStatus::parseFileStatusCode(char x, char y)
	{
	if (x == ' ' && (y == 'M' \|\| y == 'D')) return FileStatusCode::NotUpdated;
	if (x == 'M' && (y == 'M' \|\| y == 'D' \|\| y == ' ')) return FileStatusCode::UpdatedInIndex;
	if (x == 'A' && (y == 'M' \|\| y == 'D' \|\| y == ' ')) return FileStatusCode::AddedToIndex;
	if (x == 'D' && (y == 'M' \|\| y == ' ')) return FileStatusCode::DeletedFromIndex;
	if (x == 'R' && (y == 'M' \|\| y == 'D' \|\| y == ' ')) return FileStatusCode::RenamedInIndex;
	if (x == 'C' && (y == 'M' \|\| y == 'D' \|\| y == ' ')) return FileStatusCode::CopiedInIndex;
	if (x == 'C' && (y == 'M' \|\| y == 'D' \|\| y == ' ')) return FileStatusCode::CopiedInIndex;
	if (x == 'D' && y == 'D') return FileStatusCode::Unmerged_BothDeleted;
	if (x == 'A' && y == 'U') return FileStatusCode::Unmerged_AddedByUs;
	if (x == 'U' && y == 'D') return FileStatusCode::Unmerged_DeletedByThem;
	if (x == 'U' && y == 'A') return FileStatusCode::Unmerged_AddedByThem;
	if (x == 'D' && y == 'U') return FileStatusCode::Unmerged_DeletedByUs;
	if (x == 'A' && y == 'A') return FileStatusCode::Unmerged_BothAdded;
	if (x == 'U' && y == 'U') return FileStatusCode::Unmerged_BothModified;
	if (x == '?' && y == '?') return FileStatusCode::Untracked;
	if (x == '!' && y == '!') return FileStatusCode::Ignored;
	return FileStatusCode::Unknown;
	}

	void Git::FileStatus::parse(const QString &text)
	{
	data = Data();
	if (text.size() > 3) {
	ushort const *p = text.utf16();
	if (p[2] == ' ') {
	data.code_x = p[0];
	data.code_y = p[1];

	int i = text.indexOf(" -> ", 3);
	if (i > 3) {
	data.rawpath1 = text.mid(3, i - 3);
	data.rawpath2 = text.mid(i + 4);
	data.path1 = trimPath(data.rawpath1);
	data.path2 = trimPath(data.rawpath2);
	} else {
	data.rawpath1 = text.mid(3);
	data.path1 = trimPath(data.rawpath1);
	data.path2 = QString();
	}

	data.code = parseFileStatusCode(data.code_x, data.code_y);
	}
	}
	}

	QByteArray Git::blame(QString const &path)
	{
	QString cmd = "blame --abbrev=40 \"%1\"";
	cmd = cmd.arg(path);
	if (git(cmd)) {
	return toQByteArray();
	}
	return QByteArray();
	}

	QList<Git::RemoteInfo> Git::ls_remote()
	{
	QList<RemoteInfo> list;
	QString cmd = "ls-remote";
	if (git(cmd)) {
	QStringList lines = misc::splitLines(resultText());
	for (QString const &line : lines) {
	QStringList words = misc::splitWords(line);
	if (words.size() == 2 && isValidID(words[0])) {
	RemoteInfo info;
	info.commit_id = words[0];
	info.name = words[1];
	list.push_back(info);
	}
	}
	}
	return list;
	}

	QString Git::signingKey(Source purpose)
	{
	QString arg1;
	if (purpose == Source::Global) arg1 = "--global";
	if (purpose == Source::Local) arg1 = "--local";
	QString cmd = "config %1 user.signingkey";
	cmd = cmd.arg(arg1);
	bool chdir = purpose != Source::Global;
	if (git(cmd, chdir)) {
	return resultText().trimmed();
	}
	return QString();
	}

	bool Git::setSigningKey(QString const &id, bool global)
	{
	- for (int i = 0; i < id.size(); i++) {
	- if (!QChar(id[i]).isLetterOrNumber()) return false;
	+ for (auto i : id) {
	+ if (!QChar(i).isLetterOrNumber()) return false;
	}

	QString cmd = "config %1 %2 user.signingkey %3";
	cmd = cmd.arg(global ? "--global" : "--local").arg(id.isEmpty() ? "--unset" : "").arg(id);
	return git(cmd, !global);
	}

	Git::SignPolicy Git::signPolicy(Source source)
	{
	QString arg1;
	if (source == Source::Global) arg1 = "--global";
	if (source == Source::Local) arg1 = "--local";
	QString cmd = "config %1 commit.gpgsign";
	cmd = cmd.arg(arg1);
	bool chdir = source != Source::Global;
	if (git(cmd, chdir)) {
	QString t = resultText().trimmed();
	if (t == "false") return SignPolicy::False;
	if (t == "true") return SignPolicy::True;
	}
	return SignPolicy::Unset;
	}

	bool Git::setSignPolicy(Source source, SignPolicy policy)
	{
	QString arg1;
	if (source == Source::Global) arg1 = "--global";
	if (source == Source::Local) arg1 = "--local";
	QString cmd = "config %1 %2 commit.gpgsign %3";
	QString arg2;
	QString arg3;
	if (policy == SignPolicy::False) {
	arg3 = "false";
	} else if (policy == SignPolicy::True) {
	arg3 = "true";
	} else {
	arg2 = "--unset";
	}
	cmd = cmd.arg(arg1).arg(arg2).arg(arg3);
	bool chdir = source != Source::Global;
	return git(cmd, chdir);
	}

	bool Git::configGpgProgram(QString const &path, bool global)
	{
	QString cmd = "config ";
	if (global) {
	cmd += "--global ";
	}
	if (path.isEmpty()) {
	cmd += "--unset ";
	}
	cmd += "gpg.program ";
	if (!path.isEmpty()) {
	cmd += QString("\"%1\"").arg(path);
	}
	return git(cmd, false);
	}

	// Diff

	void Git::Diff::makeForSingleFile(Git::Diff *diff, const QString &id_a, const QString &id_b, const QString &path, QString const &mode)
	{
	diff->diff = QString("diff --git a/%1 b/%2").arg(path).arg(path);
	diff->index = QString("index %1..%2 %3").arg(id_a).arg(id_b).arg(0);
	diff->blob.a_id = id_a;
	diff->blob.b_id = id_b;
	diff->path = path;
	diff->mode = mode;
	diff->type = Git::Diff::Type::Create;
	}

	//

	void parseDiff(std::string const &s, Git::Diff const info, Git::Diff out)
	{
	std::vector<std::string> lines;
	{
	char const *begin = s.c_str();
	char const *end = begin + s.size();
	misc::splitLines(begin, end, &lines, false);
	}


	out->diff = QString("diff --git ") + ("a/" + info->path) + ' ' + ("b/" + info->path);
	out->index = QString("index ") + info->blob.a_id + ".." + info->blob.b_id + ' ' + info->mode;
	out->path = info->path;
	out->blob = info->blob;

	bool atat = false;
	for (std::string const &line : lines) {
	int c = line[0] & 0xff;
	if (c == '@') {
	if (strncmp(line.c_str(), "@@ ", 3) == 0) {
	out->hunks.push_back(Git::Hunk());
	out->hunks.back().at = line;
	atat = true;
	}
	} else {
	if (atat && c == '\\') { // e.g. \ No newline at end of file...
	// ignore this line
	} else {
	if (atat) {
	if (c == ' ' \|\| c == '-' \|\| c == '+') {
	// nop
	} else {
	atat = false;
	}
	}
	if (atat) {
	if (!out->hunks.isEmpty()) {
	out->hunks.back().lines.push_back(line);
	}
	}
	}
	}
	}
	}

	diff --git a/src/Git.h b/src/Git.h
	index 91bff83..2b2d000 100644
	--- a/src/Git.h
	+++ b/src/Git.h
	@@ -1,485 +1,485 @@
	#ifndef GIT_H
	#define GIT_H

	#include "AbstractProcess.h"

	#include <QDateTime>
	#include <QObject>
	#include <functional>

	#include <QDebug>
	#include <QMutex>
	#include <memory>

	#define SINGLE_THREAD 0

	#define GIT_ID_LENGTH (40)

	class Win32PtyProcess;

	enum class LineSide {
	Left,
	Right,
	};

	struct TreeLine {
	int index;
	int depth;
	int color_number = 0;
	bool bend_early = false;
	TreeLine(int index = -1, int depth = -1)
	: index(index)
	, depth(depth)
	{
	}
	};

	struct NamedCommitItem {
	enum class Type {
	None,
	Branch,
	Tag,
	};
	Type type = Type::None;
	QString remote;
	QString name;
	QString id;
	};
	typedef QList<NamedCommitItem> NamedCommitList;


	class Git;
	typedef std::shared_ptr<Git> GitPtr;

	class Git : QObject {
	public:
	class Context {
	public:
	QString git_command;
	};

	struct Object {
	enum class Type {
	UNKNOWN = 0,
	COMMIT = 1,
	TREE = 2,
	BLOB = 3,
	TAG = 4,
	UNDEFINED = 5,
	OFS_DELTA = 6,
	REF_DELTA = 7,
	};
	Type type = Type::UNKNOWN;
	QByteArray content;
	};

	class Hunk {
	public:
	std::string at;
	std::vector<std::string> lines;
	};
	class Diff {
	public:
	enum class Type {
	Unknown,
	Modify,
	Copy,
	Rename,
	Create,
	Delete,
	ChType,
	Unmerged,
	};
	Type type = Type::Unknown;
	QString diff;
	QString index;
	QString path;
	QString mode;
	struct BLOB_AB_ {
	QString a_id;
	QString b_id;
	} blob;
	QList<Hunk> hunks;
	Diff()
	{
	}
	Diff(const QString &id, const QString &path, const QString &mode)
	{
	makeForSingleFile(this, QString(GIT_ID_LENGTH, '0'), id, path, mode);

	}
	private:
	void makeForSingleFile(Git::Diff *diff, const QString &id_a, const QString &id_b, const QString &path, const QString &mode);
	};

	enum class SignatureGrade {
	NoSignature,
	Unknown,
	Good,
	Dubious,
	Missing,
	Bad,
	};

	static SignatureGrade evaluateSignature(char s)
	{
	switch (s) {
	case 'G':
	return SignatureGrade::Good;
	case 'U':
	case 'X':
	case 'Y':
	return SignatureGrade::Dubious;
	case 'B':
	case 'R':
	return SignatureGrade::Bad;
	case 'E':
	return SignatureGrade::Missing;
	case 'N':
	case ' ':
	case 0:
	return SignatureGrade::NoSignature;
	}
	return SignatureGrade::Unknown;
	}

	struct CommitItem {
	QString commit_id;
	QStringList parent_ids;
	QString author;
	QString email;
	QString message;
	QDateTime commit_date;
	std::vector<TreeLine> parent_lines;
	QByteArray fingerprint;
	char signature = 0; // git log format:%G?
	bool has_child = false;
	int marker_depth = -1;
	bool resolved = false;

	};
	typedef std::vector<CommitItem> CommitItemList;

	static bool isUncommited(CommitItem const &item)
	{
	return item.commit_id.isEmpty();
	}

	struct Branch {
	QString name;
	QString id;
	QString remote;
	int ahead = 0;
	int behind = 0;
	enum {
	None,
	Current = 0x0001,
	HeadDetachedAt = 0x0002,
	HeadDetachedFrom = 0x0004,
	};
	int flags = 0;
	operator bool () const
	{
	if (name.isEmpty()) return false;
	if (id.isEmpty()) return false;
	return true;
	}
	bool isCurrent() const
	{
	return flags & Current;
	}
	bool isHeadDetached() const
	{
	return flags & HeadDetachedAt;
	}
	};

	struct Tag {
	QString name;
	QString id;
	};

	enum class FileStatusCode : unsigned int {
	Unknown,
	Ignored,
	Untracked,
	NotUpdated = 0x10000000,
	Staged_ = 0x20000000,
	UpdatedInIndex,
	AddedToIndex,
	DeletedFromIndex,
	RenamedInIndex,
	CopiedInIndex,
	Unmerged_ = 0x40000000,
	Unmerged_BothDeleted,
	Unmerged_AddedByUs,
	Unmerged_DeletedByThem,
	Unmerged_AddedByThem,
	Unmerged_DeletedByUs,
	Unmerged_BothAdded,
	Unmerged_BothModified,
	Tracked_ = 0xf0000000
	};

	class FileStatus {
	public:
	struct Data {
	char code_x = 0;
	char code_y = 0;
	FileStatusCode code = FileStatusCode::Unknown;
	QString rawpath1;
	QString rawpath2;
	QString path1;
	QString path2;
	} data;

	static FileStatusCode parseFileStatusCode(char x, char y);

	bool isStaged() const
	{
	return (int)data.code & (int)FileStatusCode::Staged_;
	}

	bool isUnmerged() const
	{
	return (int)data.code & (int)FileStatusCode::Unmerged_;
	}

	bool isTracked() const
	{
	return (int)data.code & (int)FileStatusCode::Tracked_;
	}

	void parse(QString const &text);

	FileStatus()
	{
	}

	FileStatus(QString const &text)
	{
	parse(text);
	}

	FileStatusCode code() const
	{
	return data.code;
	}

	int code_x() const
	{
	return data.code_x;
	}

	int code_y() const
	{
	return data.code_y;
	}

	bool isDeleted() const
	{
	return code_x() == 'D' \|\| code_y() == 'D';
	}

	QString path1() const
	{
	return data.path1;
	}

	QString path2() const
	{
	return data.path2;
	}

	QString rawpath1() const
	{
	return data.rawpath1;
	}

	QString rawpath2() const
	{
	return data.rawpath2;
	}
	};
	typedef std::vector<FileStatus> FileStatusList;

	static QString trimPath(const QString &s);

	private:
	struct Private;
	Private *m;
	QStringList make_branch_list_();
	QByteArray cat_file_(const QString &id);
	FileStatusList status_();
	bool commit_(const QString &msg, bool amend, bool sign, AbstractPtyProcess *pty);
	bool push_(bool tags, AbstractPtyProcess *pty);
	static void parseAheadBehind(const QString &s, Branch *b);
	Git();
	QString encodeQuotedText(const QString &str);
	QStringList refs();
	public:
	Git(Context const &cx, const QString &repodir);
	Git(Git &&r) = delete;
	virtual ~Git();

	typedef bool (callback_t)(void cookie, char const *ptr, int len);

	void setLogCallback(callback_t func, void *cookie);

	QByteArray toQByteArray() const;
	void setGitCommand(const QString &path);
	QString gitCommand() const;
	void clearResult();
	QString resultText() const;
	- bool chdirexec(std::function<bool ()> fn);
	+ bool chdirexec(std::function<bool ()> const &fn);
	bool git(QString const &arg, bool chdir, bool errout = false, AbstractPtyProcess *pty = nullptr);
	bool git(QString const &arg)
	{
	return git(arg, true);
	}

	void setWorkingRepositoryDir(const QString &repo);
	const QString &workingRepositoryDir() const;

	QString getCurrentBranchName();
	bool isValidWorkingCopy() const;
	QString version();
	bool init();
	QStringList getUntrackedFiles();
	CommitItemList log_all(const QString &id, int maxcount);
	CommitItemList log(int maxcount);
	bool queryCommit(const QString &id, CommitItem *out);

	struct CloneData {
	QString url;
	QString basedir;
	QString subdir;
	};
	static CloneData preclone(QString const &url, QString const &path);
	bool clone(CloneData const &data, AbstractPtyProcess *pty);

	FileStatusList status();
	bool cat_file(const QString &id, QByteArray *out);
	void resetFile(const QString &path);
	void resetAllFiles();

	void removeFile(const QString &path);

	void stage(const QString &path);
	void stage(const QStringList &paths);
	void unstage(const QString &path);
	void unstage(const QStringList &paths);
	void pull(AbstractPtyProcess *pty = 0);

	void fetch(AbstractPtyProcess *pty = 0);

	QList<Branch> branches();

	int getProcessExitCode() const;

	QString diff(QString const &old_id, QString const &new_id);
	QString diff_file(const QString &old_path, const QString &new_path);

	struct DiffRaw {
	struct AB {
	QString id;
	QString mode;
	} a, b;
	QString state;
	QStringList files;
	};

	struct Remote {
	QString name;
	QString url;
	QString purpose;
	};

	QList<DiffRaw> diff_raw(const QString &old_id, const QString &new_id);

	static bool isValidID(QString const &s);

	bool commit(const QString &text, bool sign, AbstractPtyProcess *pty);
	bool commit_amend_m(const QString &text, bool sign, AbstractPtyProcess *pty);
	bool revert(const QString &id);
	bool push(bool tags, AbstractPtyProcess *pty = 0);
	void getRemoteURLs(QList<Remote> *out);
	void createBranch(const QString &name);
	void checkoutBranch(const QString &name);
	void mergeBranch(const QString &name);
	void rebaseBranch(const QString &name);
	static bool isValidWorkingCopy(const QString &dir);
	QString diff_to_file(const QString &old_id, const QString &path);
	QString errorMessage() const;

	GitPtr dup() const;
	QString rev_parse(const QString &name);
	QList<Tag> tags();
	bool tag(const QString &name, QString const &id = QString());
	void delete_tag(const QString &name, bool remote);
	void setRemoteURL(const QString &name, const QString &url);
	void addRemoteURL(QString const &name, QString const &url);
	void removeRemote(QString const &name);
	QStringList getRemotes();

	struct User {
	QString name;
	QString email;
	};
	enum class Source {
	Default,
	Global,
	Local,
	};

	User getUser(Source purpose);
	void setUser(User const&user, bool global);

	bool reset_head1();
	void push_u(const QString &remote, const QString &branch, AbstractPtyProcess *pty);
	QString objectType(const QString &id);
	bool rm_cached(const QString &file);
	void cherrypick(const QString &name);

	struct ReflogItem {
	QString id;
	QString head;
	QString command;
	QString comment;
	struct File {
	QString atts_a;
	QString atts_b;
	QString id_a;
	QString id_b;
	QString type;
	QString path;
	};
	QList<File> files;
	};
	typedef QList<ReflogItem> ReflogItemList;

	bool reflog(ReflogItemList *out, int maxcount = 100);
	QByteArray blame(const QString &path);

	enum SignPolicy {
	Unset,
	False,
	True,
	};
	QString signingKey(Source purpose);
	bool setSigningKey(const QString &id, bool global);
	SignPolicy signPolicy(Source source);
	bool setSignPolicy(Source source, SignPolicy policy);
	bool configGpgProgram(const QString &path, bool global);
	void rebaseOnto(const QString &newbase, const QString &upstream, const QString &branch, AbstractPtyProcess *pty);

	struct RemoteInfo {
	QString commit_id;
	QString name;
	};
	QList<RemoteInfo> ls_remote();
	};

	void parseDiff(std::string const &s, Git::Diff const info, Git::Diff out);

	#endif // GIT_H
	diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
	index 8a504ab..9ef4deb 100644
	--- a/src/MainWindow.cpp
	+++ b/src/MainWindow.cpp
	@@ -1,4923 +1,4922 @@
	#include "AreYouSureYouWantToContinueConnectingDialog.h"
	#include "BlameWindow.h"
	#include "CommitViewWindow.h"
	#include "Git.h"
	#include "LineEditDialog.h"
	#include "MainWindow.h"
	#include "ReflogWindow.h"
	#include "SetGlobalUserDialog.h"
	#include "EditTagsDialog.h"
	#include "WelcomeWizardDialog.h"
	#include "ui_MainWindow.h"
	#include "EditGitIgnoreDialog.h"
	#include "DoYouWantToInitDialog.h"
	#include "RemoteWatcher.h"
	-
	-#ifdef Q_OS_WIN
	-#include "win32/win32.h"
	-#else
	-#include <unistd.h>
	-#endif
	-
	#include "ApplicationGlobal.h"
	#include "AboutDialog.h"
	#include "AvatarLoader.h"
	#include "CheckoutDialog.h"
	#include "CloneDialog.h"
	#include "CommitExploreWindow.h"
	#include "CommitPropertyDialog.h"
	#include "common/joinpath.h"
	#include "common/misc.h"
	#include "ConfigCredentialHelperDialog.h"
	#include "CreateRepositoryDialog.h"
	#include "DeleteBranchDialog.h"
	#include "DeleteTagsDialog.h"
	#include "InputNewTagDialog.h"
	#include "FileHistoryWindow.h"
	#include "FilePropertyDialog.h"
	#include "FileUtil.h"
	#include "Git.h"
	#include "GitDiff.h"
	#include "gunzip.h"
	#include "JumpDialog.h"
	#include "LocalSocketReader.h"
	#include "main.h"
	#include "MemoryReader.h"
	#include "MergeBranchDialog.h"
	#include "MyProcess.h"
	#include "MySettings.h"
	#include "PushDialog.h"
	#include "RepositoryData.h"
	#include "RepositoryPropertyDialog.h"
	#include "SelectCommandDialog.h"
	#include "SetRemoteUrlDialog.h"
	#include "SettingsDialog.h"
	#include "SetUserDialog.h"
	#include "StatusLabel.h"
	#include "Terminal.h"
	#include "TextEditDialog.h"
	#include "CommitDialog.h"
	#include "SelectGpgKeyDialog.h"
	#include "SetGpgSigningDialog.h"
	#include "gpg.h"
	#include "webclient.h"
	-#include <deque>
	-#include <set>
	-#include <stdlib.h>
	-
	+#include "RebaseOntoDialog.h"
	#include <QBuffer>
	#include <QClipboard>
	#include <QDateTime>
	#include <QDebug>
	#include <QDesktopServices>
	#include <QDirIterator>
	#include <QDragEnterEvent>
	#include <QFileDialog>
	#include <QFileIconProvider>
	#include <QKeyEvent>
	#include <QLocalServer>
	#include <QMessageBox>
	#include <QMimeData>
	#include <QPainter>
	#include <QProcess>
	#include <QStandardPaths>
	#include <QThread>
	#include <QTimer>
	-#include <RebaseOntoDialog.h>
	+#include <deque>
	+#include <set>
	+#include <stdlib.h>
	+
	+#ifdef Q_OS_WIN
	+#include "win32/win32.h"
	+#else
	+#include <unistd.h>
	+#endif
	+

	#ifdef Q_OS_MAC
	extern "C" char **environ;
	#endif

	struct GitHubRepositoryInfo {
	QString owner_account_name;
	QString repository_name;
	};

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

	FileDiffWidget::DrawData::DrawData()
	{
	bgcolor_text = QColor(255, 255, 255);
	bgcolor_gray = QColor(224, 224, 224);
	bgcolor_add = QColor(192, 240, 192);
	bgcolor_del = QColor(255, 224, 224);
	bgcolor_add_dark = QColor(64, 192, 64);
	bgcolor_del_dark = QColor(240, 64, 64);
	}

	enum {
	IndexRole = Qt::UserRole,
	FilePathRole,
	DiffIndexRole,
	HunkIndexRole,
	};

	enum {
	GroupItem = -1,
	};

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

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

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

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

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

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

	enum InteractionMode {
	None,
	Busy,
	};

	struct MainWindow::Private {
	QString starting_dir;
	Git::Context gcx;
	ApplicationSettings appsettings;
	QList<RepositoryItem> repos;
	RepositoryItem current_repo;
	ServerType server_type = ServerType::Standard;
	GitHubRepositoryInfo github;
	QString current_remote;
	Git::Branch current_branch;
	QString head_id;
	struct Diff {
	QList<Git::Diff> result;
	std::shared_ptr<QThread> thread;
	QList<std::shared_ptr<QThread>> garbage;
	} diff;
	std::map<QString, Git::Diff> diff_cache;
	QStringList added;
	Git::CommitItemList logs;
	std::map<int, QList<Label>> label_map;
	bool force_fetch = false;
	bool uncommited_changes = false;
	int update_files_list_counter = 0;
	QTimer interval_10ms_timer;
	QTimer remote_watcher_timer;
	QImage graph_color;
	QStringList remotes;
	std::map<QString, QList<Git::Branch>> branch_map;
	std::map<QString, QList<Git::Tag>> tag_map;
	QString repository_filter_text;
	QPixmap digits;
	QIcon repository_icon;
	QIcon folder_icon;
	QIcon signature_good_icon;
	QIcon signature_dubious_icon;
	QIcon signature_bad_icon;
	unsigned int temp_file_counter = 0;
	GitObjectCache objcache;
	QPixmap transparent_pixmap;
	StatusLabel *status_bar_label;

	QObject *last_focused_file_list = 0;

	WebContext webcx;
	AvatarLoader avatar_loader;
	int update_commit_table_counter = 0;

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

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

	RepositoryItem temp_repo;

	QListWidgetItem *last_selected_file_item = nullptr;

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

	bool remote_changed = false;

	std::string ssh_passphrase_for;
	std::string ssh_passphrase_secret;

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

	RemoteWatcher remote_watcher;
	};

	MainWindow::MainWindow(QWidget *parent)
	: QMainWindow(parent)
	, ui(new Ui::MainWindow)
	, m(new Private)
	{
	ui->setupUi(this);

	#ifdef Q_OS_MACX
	ui->action_about->setText("About Guitar...");
	ui->action_edit_settings->setText("Settings...");
	#endif

	m->starting_dir = QDir::current().absolutePath();

	ui->splitter_v->setSizes({100, 400});
	ui->splitter_h->setSizes({200, 100, 200});

	m->status_bar_label = new StatusLabel(this);
	ui->statusBar->addWidget(m->status_bar_label);

	ui->widget_diff_view->bind(this);

	qApp->installEventFilter(this);

	ui->widget_log->setupForLogWidget(ui->verticalScrollBar_log, ui->horizontalScrollBar_log, themeForTextEditor());
	onLogVisibilityChanged();

	SettingsDialog::loadSettings(&m->appsettings);

	initNetworking();

	showFileList(FilesListType::SingleList);

	QFileIconProvider icons;

	m->digits.load(":/image/digits.png");
	m->graph_color = global->theme->graphColorMap();

	m->repository_icon = QIcon(":/image/repository.png");
	m->folder_icon = icons.icon(QFileIconProvider::Folder);

	m->signature_good_icon = QIcon(":/image/signature-good.png");
	m->signature_bad_icon = QIcon(":/image/signature-bad.png");
	m->signature_dubious_icon = QIcon(":/image/signature-dubious.png");

	prepareLogTableWidget();

	#ifdef Q_OS_WIN
	{
	QFont font;

	font = ui->label_repo_name->font();
	font.setFamily("Meiryo");
	ui->label_repo_name->setFont(font);

	font = ui->label_branch_name->font();
	font.setFamily("Meiryo");
	ui->label_branch_name->setFont(font);
	}
	#endif

	connect(this, SIGNAL(signalWriteLog(QByteArray)), this, SLOT(writeLog(QByteArray)));

	connect(ui->dockWidget_log, SIGNAL(visibilityChanged(bool)), this, SLOT(onLogVisibilityChanged()));
	connect(ui->widget_log, SIGNAL(idle()), this, SLOT(onLogIdle()));

	connect(ui->treeWidget_repos, SIGNAL(dropped()), this, SLOT(onRepositoriesTreeDropped()));

	connect((AbstractPtyProcess *)&m->pty_process, SIGNAL(completed()), this, SLOT(onPtyProcessCompleted()));

	// リモート監視
	connect(this, SIGNAL(signalCheckRemoteUpdate()), &m->remote_watcher, SLOT(checkRemoteUpdate()));
	connect(&m->remote_watcher_timer, SIGNAL(timeout()), &m->remote_watcher, SLOT(checkRemoteUpdate()));
	connect(this, &MainWindow::updateButton, [&](){
	doUpdateButton();
	});
	m->remote_watcher.start(this);
	setWatchRemoteInterval(appsettings()->watch_remote_changes_every_mins);

	//

	QString path = getBookmarksFilePath();
	m->repos = RepositoryBookmark::load(path);
	updateRepositoriesList();

	m->webcx.set_keep_alive_enabled(true);
	m->avatar_loader.start(&m->webcx);
	connect(&m->avatar_loader, SIGNAL(updated()), this, SLOT(onAvatarUpdated()));

	m->update_files_list_counter = 0;

	connect(ui->widget_diff_view, &FileDiffWidget::textcodecChanged, [&](){ updateDiffView(); });

	if (!global->start_with_shift_key && appsettings()->remember_and_restore_window_position) {
	Qt::WindowStates state = windowState();
	MySettings settings;

	settings.beginGroup("MainWindow");
	bool maximized = settings.value("Maximized").toBool();
	restoreGeometry(settings.value("Geometry").toByteArray());
	// ui->splitter->restoreState(settings.value("SplitterState").toByteArray());
	settings.endGroup();
	if (maximized) {
	state \|= Qt::WindowMaximized;
	setWindowState(state);
	}
	}

	startTimers();
	}

	MainWindow::~MainWindow()
	{
	stopPtyProcess();

	m->avatar_loader.stop();

	m->remote_watcher.quit();
	m->remote_watcher.wait();

	deleteTempFiles();

	delete m;
	delete ui;
	}

	bool MainWindow::checkGitCommand()
	{
	while (1) {
	if (misc::isExecutable(m->gcx.git_command)) {
	return true;
	}
	if (selectGitCommand(true).isEmpty()) {
	close();
	return false;
	}
	}
	}

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

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

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

	bool MainWindow::execWelcomeWizardDialog()
	{
	WelcomeWizardDialog dlg(this);
	dlg.set_git_command_path(appsettings()->git_command);
	dlg.set_file_command_path(appsettings()->file_command);
	dlg.set_default_working_folder(appsettings()->default_working_dir);
	if (misc::isExecutable(appsettings()->git_command)) {
	m->gcx.git_command = appsettings()->git_command;
	Git g(m->gcx, QString());
	Git::User user = g.getUser(Git::Source::Global);
	dlg.set_user_name(user.name);
	dlg.set_user_email(user.email);
	}
	if (dlg.exec() == QDialog::Accepted) {
	appsettings()->git_command = m->gcx.git_command = dlg.git_command_path();
	appsettings()->file_command = global->file_command = dlg.file_command_path();
	appsettings()->default_working_dir = dlg.default_working_folder();
	SettingsDialog::saveSettings(&m->appsettings);

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

	return true;
	}
	return false;
	}

	bool MainWindow::shown()
	{
	while (!misc::isExecutable(appsettings()->git_command) \|\| !misc::isExecutable(appsettings()->file_command)) {
	if (!execWelcomeWizardDialog()) {
	return false;
	}
	}

	setGitCommand(appsettings()->git_command, false);
	setFileCommand(appsettings()->file_command, false);

	writeLog(AboutDialog::appVersion() + '\n'); // print application version
	logGitVersion(); // print git command version

	setGpgCommand(appsettings()->gpg_command, false);

	{
	MySettings s;
	s.beginGroup("Remote");
	bool f = s.value("Online", true).toBool();
	s.endGroup();
	setRemoteOnline(f);
	}

	setUnknownRepositoryInfo();

	checkUser();

	return true;
	}

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

	void MainWindow::startTimers()
	{
	// interval 10ms

	connect(&m->interval_10ms_timer, &QTimer::timeout, [&](){
	const int ms = 10;
	if (m->update_commit_table_counter > 0) {
	if (m->update_commit_table_counter > ms) {
	m->update_commit_table_counter -= ms;
	} else {
	m->update_commit_table_counter = 0;
	ui->tableWidget_log->viewport()->update();
	}
	}
	if (m->update_files_list_counter > 0) {
	if (m->update_files_list_counter > ms) {
	m->update_files_list_counter -= ms;
	} else {
	m->update_files_list_counter = 0;
	updateCurrentFilesList();
	}
	}
	});
	m->interval_10ms_timer.setInterval(10);
	m->interval_10ms_timer.start();

	startTimer(10);
	}

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

	void MainWindow::setCurrentLogRow(int row)
	{
	if (row >= 0 && row < ui->tableWidget_log->rowCount()) {
	ui->tableWidget_log->setCurrentCell(row, 2);
	ui->tableWidget_log->setFocus();
	updateStatusBarText();
	}
	}

	bool MainWindow::event(QEvent *event)
	{
	QEvent::Type et = event->type();
	if (et == QEvent::WindowActivate) {
	checkRemoteUpdate();
	} else if (et == QEvent::KeyPress) {
	QKeyEvent e = dynamic_cast<QKeyEvent >(event);
	Q_ASSERT(e);
	int k = e->key();
	if (k == Qt::Key_Escape) {
	emit onEscapeKeyPressed();
	} else if (k == Qt::Key_Delete) {
	if (qApp->focusWidget() == ui->treeWidget_repos) {
	removeSelectedRepositoryFromBookmark(true);
	return true;
	}
	}
	}
	return QMainWindow::event(event);
	}

	bool MainWindow::eventFilter(QObject watched, QEvent event)
	{
	QEvent::Type et = event->type();

	if (et == QEvent::KeyPress) {
	QKeyEvent e = dynamic_cast<QKeyEvent >(event);
	Q_ASSERT(e);
	int k = e->key();
	if (k == Qt::Key_Tab) {
	if (centralWidget()->isAncestorOf(qApp->focusWidget())) {
	QList<QWidget *> tabstops;
	tabstops.push_back(ui->treeWidget_repos);
	tabstops.push_back(ui->tableWidget_log);
	if (ui->stackedWidget->currentWidget() == ui->page_files) {
	tabstops.push_back(ui->listWidget_files);
	} else if (ui->stackedWidget->currentWidget() == ui->page_uncommited) {
	tabstops.push_back(ui->listWidget_unstaged);
	tabstops.push_back(ui->toolButton_select_all);
	tabstops.push_back(ui->toolButton_stage);
	tabstops.push_back(ui->toolButton_unstage);
	tabstops.push_back(ui->toolButton_commit);
	tabstops.push_back(ui->listWidget_staged);
	}
	tabstops.push_back(ui->widget_diff_view);
	int n = tabstops.size();
	if (n > 0) {
	QWidget *f = qApp->focusWidget();
	int i;
	for (i = 0; i < n; i++) {
	if (tabstops[i] == f) {
	break;
	}
	}
	if (i < n) {
	if (e->modifiers() & Qt::ShiftModifier) {
	i = (i + n - 1) % n;
	} else {
	i = (i + 1) % n;
	}
	tabstops[i]->setFocus();
	}
	}
	return true;
	}
	}
	if (k == Qt::Key_Escape) {
	if (centralWidget()->isAncestorOf(qApp->focusWidget())) {
	ui->treeWidget_repos->setFocus();
	return true;
	}
	}
	if (e->modifiers() & Qt::ControlModifier) {
	if (k == Qt::Key_Up \|\| k == Qt::Key_Down) {
	int rows = ui->tableWidget_log->rowCount();
	int row = ui->tableWidget_log->currentRow();
	if (k == Qt::Key_Up) {
	if (row > 0) {
	row--;
	}
	} else if (k == Qt::Key_Down) {
	if (row + 1 < rows) {
	row++;
	}
	}
	ui->tableWidget_log->setCurrentCell(row, 0);
	return true;
	}
	}
	if (watched == ui->treeWidget_repos) {
	if (k == Qt::Key_Enter \|\| k == Qt::Key_Return) {
	openSelectedRepository();
	return true;
	}
	if (!(e->modifiers() & Qt::ControlModifier)) {
	if (k >= 0 && k < 128 && QChar((uchar)k).isLetterOrNumber()) {
	appendCharToRepoFilter(k);
	return true;
	}
	if (k == Qt::Key_Backspace) {
	backspaceRepoFilter();
	return true;
	}
	if (k == Qt::Key_Escape) {
	clearRepoFilter();
	return true;
	}
	}
	} else if (watched == ui->tableWidget_log) {
	if (k == Qt::Key_Home) {
	setCurrentLogRow(0);
	return true;
	}
	if (k == Qt::Key_Escape) {
	ui->treeWidget_repos->setFocus();
	return true;
	}
	} else if (watched == ui->listWidget_files \|\| watched == ui->listWidget_unstaged \|\| watched == ui->listWidget_staged) {
	if (k == Qt::Key_Escape) {
	ui->tableWidget_log->setFocus();
	return true;
	}
	}
	} else if (et == QEvent::FocusIn) {
	// ファイルリストがフォーカスを得たとき、diffビューを更新する。（コンテキストメニュー対応）
	if (watched == ui->listWidget_unstaged) {
	m->last_focused_file_list = watched;
	updateStatusBarText();
	updateUnstagedFileCurrentItem();
	return true;
	}
	if (watched == ui->listWidget_staged) {
	m->last_focused_file_list = watched;
	updateStatusBarText();
	updateStagedFileCurrentItem();
	return true;
	}
	if (watched == ui->listWidget_files) {
	m->last_focused_file_list = watched;
	}
	}
	return false;
	}

	void MainWindow::closeEvent(QCloseEvent *event)
	{
	if (appsettings()->remember_and_restore_window_position) {
	setWindowOpacity(0);
	Qt::WindowStates state = windowState();
	bool maximized = (state & Qt::WindowMaximized) != 0;
	if (maximized) {
	state &= ~Qt::WindowMaximized;
	setWindowState(state);
	}
	{
	MySettings settings;

	settings.beginGroup("MainWindow");
	settings.setValue("Maximized", maximized);
	settings.setValue("Geometry", saveGeometry());
	// settings.setValue("SplitterState", ui->splitter->saveState());
	settings.endGroup();
	}
	}
	QMainWindow::closeEvent(event);
	}

	void MainWindow::setStatusBarText(QString const &text)
	{
	m->status_bar_label->setText(text);
	}

	void MainWindow::clearStatusBarText()
	{
	setStatusBarText(QString());
	}

	WebContext *MainWindow::getWebContextPtr()
	{
	return &m->webcx;
	}

	QString MainWindow::getObjectID(QListWidgetItem *item)
	{
	int i = indexOfDiff(item);
	if (i >= 0 && i < m->diff.result.size()) {
	Git::Diff const &diff = m->diff.result[i];
	return diff.blob.a_id;
	}
	return QString();
	}

	void MainWindow::onLogVisibilityChanged()
	{
	ui->action_window_log->setChecked(ui->dockWidget_log->isVisible());
	}

	void MainWindow::writeLog(char const *ptr, int len)
	{
	ui->widget_log->logicalMoveToBottom();
	ui->widget_log->write(ptr, len, false);
	ui->widget_log->setChanged(false);
	m->interaction_canceled = false;
	}

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

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

	void MainWindow::emitWriteLog(QByteArray ba)
	{
	emit signalWriteLog(ba);
	}

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

	bool MainWindow::saveRepositoryBookmarks() const
	{
	QString path = getBookmarksFilePath();
	return RepositoryBookmark::save(path, &m->repos);
	}

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

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

	bool done = false;
	for (int i = 0; i < m->repos.size(); i++) {
	RepositoryItem *p = &m->repos[i];
	if (item.local_dir == p->local_dir) {
	*p = item;
	done = true;
	break;
	}
	}
	if (!done) {
	m->repos.push_back(item);
	}
	saveRepositoryBookmarks();
	updateRepositoriesList();
	}

	void MainWindow::buildRepoTree(QString const &group, QTreeWidgetItem item, QList<RepositoryItem> repos)
	{
	QString name = item->text(0);
	if (isGroupItem(item)) {
	int n = item->childCount();
	for (int i = 0; i < n; i++) {
	QTreeWidgetItem *child = item->child(i);
	QString sub = group / name;
	buildRepoTree(sub, child, repos);
	}
	} else {
	RepositoryItem const *repo = repositoryItem(item);
	if (repo) {
	RepositoryItem newrepo = *repo;
	newrepo.name = name;
	newrepo.group = group;
	item->setData(0, IndexRole, repos->size());
	repos->push_back(newrepo);
	}
	}
	}

	void MainWindow::refrectRepositories()
	{
	QList<RepositoryItem> newrepos;
	int n = ui->treeWidget_repos->topLevelItemCount();
	for (int i = 0; i < n; i++) {
	QTreeWidgetItem *item = ui->treeWidget_repos->topLevelItem(i);
	buildRepoTree(QString(), item, &newrepos);
	}
	m->repos = std::move(newrepos);
	saveRepositoryBookmarks();
	}

	void MainWindow::onRepositoriesTreeDropped()
	{
	refrectRepositories();
	QTreeWidgetItem *item = ui->treeWidget_repos->currentItem();
	if (item) item->setExpanded(true);
	}

	const QPixmap &MainWindow::digitsPixmap() const
	{
	return m->digits;
	}

	int MainWindow::digitWidth() const
	{
	return 5;
	}

	int MainWindow::digitHeight() const
	{
	return 7;
	}

	void MainWindow::drawDigit(QPainter *pr, int x, int y, int n) const
	{
	int w = digitWidth();
	int h = digitHeight();
	pr->drawPixmap(x, y, w, h, m->digits, n * w, 0, w, h);
	}

	QString MainWindow::defaultWorkingDir() const
	{
	return appsettings()->default_working_dir;
	}

	QColor MainWindow::color(unsigned int i)
	{
	unsigned int n = m->graph_color.width();
	if (n > 0) {
	n--;
	if (i > n) i = n;
	QRgb const p = (QRgb const )m->graph_color.scanLine(0);
	return QColor(qRed(p[i]), qGreen(p[i]), qBlue(p[i]));
	}
	return Qt::black;
	}

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

	Git::CommitItemList const *MainWindow::logs() const
	{
	return &m->logs;
	}

	QString MainWindow::currentWorkingCopyDir() const
	{
	QString workdir = m->current_repo.local_dir;
	if (!workdir.isEmpty()) return workdir;

	QTreeWidgetItem *treeitem = ui->treeWidget_repos->currentItem();
	if (treeitem) {
	RepositoryItem const *repo = repositoryItem(treeitem);
	if (repo) {
	workdir = repo->local_dir;
	return workdir;
	}
	}

	return QString();
	}

	QString MainWindow::currentRepositoryName() const
	{
	return m->current_repo.name;
	}

	QString MainWindow::currentRemoteName() const
	{
	return m->current_remote;
	}

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

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

	GitPtr MainWindow::git(QString const &dir) const
	{
	const_cast<MainWindow *>(this)->checkGitCommand();

	GitPtr g = std::shared_ptr<Git>(new Git(m->gcx, dir));
	g->setLogCallback(git_callback, (void *)this);
	return g;
	}

	GitPtr MainWindow::git()
	{
	return git(currentWorkingCopyDir());
	}

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

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

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

	RepositoryItem const MainWindow::findRegisteredRepository(QString workdir) const
	{
	workdir = QDir(workdir).absolutePath();
	workdir->replace('\\', '/');

	if (Git::isValidWorkingCopy(*workdir)) {
	for (RepositoryItem const &item : m->repos) {
	Qt::CaseSensitivity cs = Qt::CaseSensitive;
	#ifdef Q_OS_WIN
	cs = Qt::CaseInsensitive;
	#endif
	if (workdir->compare(item.local_dir, cs) == 0) {
	return &item;
	}
	}
	}
	return nullptr;
	}

	int MainWindow::repositoryIndex_(QTreeWidgetItem const *item) const
	{
	if (item) {
	int i = item->data(0, IndexRole).toInt();
	if (i >= 0 && i < m->repos.size()) {
	return i;
	}
	}
	return -1;
	}

	RepositoryItem const MainWindow::repositoryItem(QTreeWidgetItem const item) const
	{
	int row = repositoryIndex_(item);
	if (row >= 0 && row < m->repos.size()) {
	return &m->repos[row];
	}
	return nullptr;
	}

	static QTreeWidgetItem *newQTreeWidgetItem()
	{
	QTreeWidgetItem *item = new QTreeWidgetItem();
	item->setSizeHint(0, QSize(20, 20));
	return item;
	}

	QTreeWidgetItem *MainWindow::newQTreeWidgetFolderItem(QString const &name)
	{
	QTreeWidgetItem *item = newQTreeWidgetItem();
	item->setText(0, name);
	item->setData(0, IndexRole, GroupItem);
	item->setIcon(0, m->folder_icon);
	item->setFlags(item->flags() \| Qt::ItemIsEditable);
	return item;
	}

	void MainWindow::updateRepositoriesList()
	{
	QString path = getBookmarksFilePath();

	m->repos = RepositoryBookmark::load(path);

	QString filter = m->repository_filter_text;

	ui->treeWidget_repos->clear();

	std::map<QString, QTreeWidgetItem *> parentmap;

	for (int i = 0; i < m->repos.size(); i++) {
	RepositoryItem const &repo = m->repos[i];
	if (!filter.isEmpty() && repo.name.indexOf(filter, 0, Qt::CaseInsensitive) < 0) {
	continue;
	}
	QTreeWidgetItem *parent = nullptr;
	{
	QString group = repo.group;
	if (group.startsWith('/')) {
	group = group.mid(1);
	}
	auto it = parentmap.find(group);
	if (it != parentmap.end()) {
	parent = it->second;
	}
	if (!parent) {
	QStringList list = group.split('/', QString::SkipEmptyParts);
	if (list.isEmpty()) {
	list.push_back(tr("Default"));
	}
	for (QString const &name : list) {
	if (name.isEmpty()) continue;
	if (!parent) {
	auto it = parentmap.find(name);
	if (it != parentmap.end()) {
	parent = it->second;
	} else {
	parent = newQTreeWidgetFolderItem(name);
	ui->treeWidget_repos->addTopLevelItem(parent);
	}
	} else {
	QTreeWidgetItem *child = newQTreeWidgetFolderItem(name);
	parent->addChild(child);
	parent = child;
	}
	parent->setExpanded(true);
	}
	Q_ASSERT(parent);
	parentmap[group] = parent;
	}
	parent->setData(0, FilePathRole, "");
	}
	QTreeWidgetItem *child = newQTreeWidgetItem();
	child->setText(0, repo.name);
	child->setData(0, IndexRole, i);
	child->setIcon(0, m->repository_icon);
	child->setFlags(child->flags() & ~Qt::ItemIsDropEnabled);
	parent->addChild(child);
	parent->setExpanded(true);
	}
	}

	void MainWindow::showFileList(FilesListType files_list_type)
	{
	switch (files_list_type) {
	case FilesListType::SingleList:
	ui->stackedWidget->setCurrentWidget(ui->page_files);
	break;
	case FilesListType::SideBySide:
	ui->stackedWidget->setCurrentWidget(ui->page_uncommited);
	break;
	}
	}

	void MainWindow::clearFileList()
	{
	showFileList(FilesListType::SingleList);
	ui->listWidget_unstaged->clear();
	ui->listWidget_staged->clear();
	ui->listWidget_files->clear();
	}

	void MainWindow::clearDiffView()
	{
	ui->widget_diff_view->clearDiffView();
	}

	void MainWindow::clearRepositoryInfo()
	{
	m->head_id = QString();
	m->current_branch = Git::Branch();
	m->server_type = ServerType::Standard;
	m->github = GitHubRepositoryInfo();
	ui->label_repo_name->setText(QString());
	ui->label_branch_name->setText(QString());

	}

	void MainWindow::setRepositoryInfo(QString const &reponame, QString const &brname)
	{
	ui->label_repo_name->setText(reponame);
	ui->label_branch_name->setText(brname);
	}

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

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

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

	Git::FileStatusList list = g->status();
	m->uncommited_changes = !list.empty();

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

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

	GitDiff dm(&m->objcache);
	if (uncommited) {
	dm.diff_uncommited(out);
	} else {
	dm.diff(id, out);
	}

	return true; // success
	}

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

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

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

	void MainWindow::updateFilesList(QString id, bool wait)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	if (!wait) return;

	clearFileList();

	Git::FileStatusList stats = g->status();
	m->uncommited_changes = !stats.empty();

	FilesListType files_list_type = FilesListType::SingleList;

	bool staged = false;
	auto AddItem = [&](QString const &filename, QString header, int idiff){
	if (header.isEmpty()) {
	header = "(??\?) "; // damn trigraph
	}
	QListWidgetItem *item = new QListWidgetItem(header + filename);
	item->setData(FilePathRole, filename);
	item->setData(DiffIndexRole, idiff);
	item->setData(HunkIndexRole, -1);
	switch (files_list_type) {
	case FilesListType::SingleList:
	ui->listWidget_files->addItem(item);
	break;
	case FilesListType::SideBySide:
	if (staged) {
	ui->listWidget_staged->addItem(item);
	} else {
	ui->listWidget_unstaged->addItem(item);
	}
	break;
	}
	};

	if (id.isEmpty()) {
	bool uncommited = isThereUncommitedChanges();
	if (uncommited) {
	files_list_type = FilesListType::SideBySide;
	}
	if (!makeDiff(uncommited ? QString() : id, &m->diff.result)) {
	return;
	}

	std::map<QString, int> diffmap;

	for (int idiff = 0; idiff < m->diff.result.size(); idiff++) {
	Git::Diff const &diff = m->diff.result[idiff];
	QString filename = diff.path;
	if (!filename.isEmpty()) {
	diffmap[filename] = idiff;
	}
	}

	showFileList(files_list_type);

	for (Git::FileStatus const &s : stats) {
	staged = (s.isStaged() && s.code_y() == ' ');
	int idiff = -1;
	QString header;
	auto it = diffmap.find(s.path1());
	if (it != diffmap.end()) {
	idiff = it->second;
	}
	QString path = s.path1();
	if (s.code() == Git::FileStatusCode::Unknown) {
	qDebug() << "something wrong...";
	} else if (s.code() == Git::FileStatusCode::Untracked) {
	// nop
	} else if (s.isUnmerged()) {
	header += "(unmerged) ";
	} else if (s.code() == Git::FileStatusCode::AddedToIndex) {
	header = "(add) ";
	} else if (s.code_x() == 'D' \|\| s.code_y() == 'D' \|\| s.code() == Git::FileStatusCode::DeletedFromIndex) {
	header = "(del) ";
	} else if (s.code_x() == 'R' \|\| s.code() == Git::FileStatusCode::RenamedInIndex) {
	header = "(ren) ";
	path = s.path2(); // renamed newer path
	} else if (s.code_x() == 'M' \|\| s.code_y() == 'M') {
	header = "(chg) ";
	}
	AddItem(path, header, idiff);
	}
	} else {
	if (!makeDiff(id, &m->diff.result)) {
	return;
	}
	showFileList(files_list_type);
	addDiffItems(&m->diff.result, AddItem);
	}

	for (Git::Diff const &diff : m->diff.result) {
	QString key = GitDiff::makeKey(diff);
	m->diff_cache[key] = diff;
	}
	}

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

	listwidget->clear();

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

	GitDiff dm(&m->objcache);
	if (!dm.diff(id, diff_list)) return;

	addDiffItems(diff_list, AddItem);
	}

	void MainWindow::updateFilesList(Git::CommitItem const &commit, bool wait)
	{
	QString id;
	if (Git::isUncommited(commit)) {
	// empty id for uncommited changes
	} else {
	id = commit.commit_id;
	}
	updateFilesList(id, wait);
	}

	void MainWindow::updateCurrentFilesList()
	{
	QTableWidgetItem *item = ui->tableWidget_log->item(selectedLogIndex(), 0);
	if (!item) return;
	int row = item->data(IndexRole).toInt();
	int logs = (int)m->logs.size();
	if (row < logs) {
	updateFilesList(m->logs[row], true);
	}
	}

	void MainWindow::setRemoteChanged(bool f)
	{
	m->remote_changed = f;
	updateButton();
	}

	void MainWindow::prepareLogTableWidget()
	{
	QStringList cols = {
	tr("Graph"),
	tr("Commit"),
	tr("Date"),
	tr("Author"),
	tr("Description"),
	};
	int n = cols.size();
	ui->tableWidget_log->setColumnCount(n);
	ui->tableWidget_log->setRowCount(0);
	for (int i = 0; i < n; i++) {
	QString const &text = cols[i];
	QTableWidgetItem *item = new QTableWidgetItem(text);
	ui->tableWidget_log->setHorizontalHeaderItem(i, item);
	}

	updateCommitGraph(); // コミットグラフを更新
	}

	void MainWindow::clearAuthentication()
	{
	m->ssh_passphrase_for.clear();
	m->ssh_passphrase_secret.clear();
	m->http_uid.clear();
	m->http_pwd.clear();
	}

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

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

	void MainWindow::queryRemotes(GitPtr g)
	{
	m->remotes = g->getRemotes();
	std::sort(m->remotes.begin(), m->remotes.end());
	}

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

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

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

	ui->lineEdit_remote->setText(m->current_remote);
	}

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

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

	QString MainWindow::findFileID(GitPtr /g/, const QString &commit_id, const QString &file)
	{
	return lookupFileID(&m->objcache, commit_id, file);
	}

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

	void MainWindow::updateCommitTableLater()
	{
	m->update_commit_table_counter = 200;
	}

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

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

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

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

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

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

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

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

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

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

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

	struct TemporaryCommitItem {
	Git::CommitItem const *commit;
	std::vector<TemporaryCommitItem *> children;
	};

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

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

	std::set<QString> set;

	size_t i = 0;
	while (i < list.size()) {
	size_t newpos = -1;
	for (QString const &parent : list[i].parent_ids) {
	auto it = set.find(parent);
	if (it != set.end()) {
	for (size_t j = 0; j < i; j++) {
	if (parent == list[j].commit_id) {
	if (newpos == (size_t)-1 \|\| j < newpos) {
	newpos = j;
	}
	qDebug() << "fix commit order" << parent;
	break;
	}
	}
	}
	}
	set.insert(set.end(), list[i].commit_id);
	if (newpos != (size_t)-1) {
	Git::CommitItem t = list[newpos];
	list.erase(list.begin() + newpos);
	list.insert(list.begin() + i, t);
	}
	i++;
	}

	return list;
	}

	void MainWindow::detectGitServerType(GitPtr g)
	{
	m->server_type = ServerType::Standard;
	m->github = GitHubRepositoryInfo();

	QString push_url;
	QList<Git::Remote> remotes;
	g->getRemoteURLs(&remotes);
	for (Git::Remote const &r : remotes) {
	if (r.purpose == "push") {
	push_url = r.url;
	}
	}

	auto Check = [&](QString const &s){
	int i = push_url.indexOf(s);
	if (i > 0) return i + s.size();
	return 0;
	};

	// check GitHub
	int pos = Check("@github.com:");
	if (pos == 0) {
	pos = Check("://github.com/");
	}
	if (pos > 0) {
	int end = push_url.size();
	{
	QString s = ".git";
	if (push_url.endsWith(s)) {
	end -= s.size();
	}
	}
	QString s = push_url.mid(pos, end - pos);
	int i = s.indexOf('/');
	if (i > 0) {
	QString user = s.mid(0, i);
	QString repo = s.mid(i + 1);
	m->github.owner_account_name = user;
	m->github.repository_name = repo;
	}
	m->server_type = ServerType::GitHub;
	}
	}

	bool MainWindow::fetch(GitPtr g)
	{
	m->pty_condition = PtyCondition::Fetch;
	m->pty_process_ok = true;
	g->fetch(&m->pty_process);
	while (1) {
	if (m->pty_process.wait(1)) break;
	QApplication::processEvents();
	}
	return m->pty_process_ok;
	}

	void MainWindow::clearLog()
	{
	m->logs.clear();
	m->label_map.clear();
	m->uncommited_changes = false;
	ui->tableWidget_log->clearContents();
	ui->tableWidget_log->scrollToTop();
	}

	void MainWindow::openRepository_(GitPtr g)
	{
	m->objcache.setup(g);

	if (isValidWorkingCopy(g)) {

	bool do_fetch = isRemoteOnline() && (m->force_fetch \|\| appsettings()->automatically_fetch_when_opening_the_repository);
	m->force_fetch = false;
	if (do_fetch) {
	if (!fetch(g)) {
	return;
	}
	}

	clearLog();
	clearRepositoryInfo();

	detectGitServerType(g);

	updateFilesList(QString(), true);

	bool canceled = false;
	ui->tableWidget_log->setEnabled(false);

	// ログを取得
	m->logs = retrieveCommitLog(g);
	// ブランチを取得
	queryBranches(g);
	// タグを取得
	m->tag_map.clear();
	QList<Git::Tag> tags = g->tags();
	for (Git::Tag const &tag : tags) {
	Git::Tag t = tag;
	t.id = m->objcache.getCommitIdFromTag(t.id);
	m->tag_map[t.id].push_back(t);
	}

	ui->tableWidget_log->setEnabled(true);
	updateCommitTableLater();
	if (canceled) return;

	QString branch_name;
	if (currentBranch().flags & Git::Branch::HeadDetachedAt) {
	branch_name += QString("(HEAD detached at %1)").arg(currentBranchName());
	}
	if (currentBranch().flags & Git::Branch::HeadDetachedFrom) {
	branch_name += QString("(HEAD detached from %1)").arg(currentBranchName());
	}
	if (branch_name.isEmpty()) {
	branch_name = currentBranchName();
	}

	QString repo_name = currentRepositoryName();
	setRepositoryInfo(repo_name, branch_name);
	} else {
	clearLog();
	clearRepositoryInfo();
	}

	updateRemoteInfo();

	updateWindowTitle(g);

	m->head_id = m->objcache.revParse("HEAD");

	if (isThereUncommitedChanges()) {
	Git::CommitItem item;
	item.parent_ids.push_back(m->current_branch.id);
	item.message = tr("Uncommited changes");
	m->logs.insert(m->logs.begin(), item);
	}

	prepareLogTableWidget();

	int count = m->logs.size();

	ui->tableWidget_log->setRowCount(count);

	int selrow = -1;

	for (int row = 0; row < count; row++) {
	Git::CommitItem const *commit = &m->logs[row];
	{
	QTableWidgetItem *item = new QTableWidgetItem();
	item->setData(IndexRole, row);
	ui->tableWidget_log->setItem(row, 0, item);
	}
	int col = 1; // カラム0はコミットグラフなので、その次から
	auto AddColumn = [&](QString const &text, bool bold, QString const &tooltip){
	QTableWidgetItem *item = new QTableWidgetItem(text);
	if (!tooltip.isEmpty()) {
	QString tt = tooltip;
	tt.replace('\n', ' ');
	tt = tt.toHtmlEscaped();
	tt = "<p style='white-space: pre'>" + tt + "</p>";
	item->setToolTip(tt);
	}
	if (bold) {
	QFont font = item->font();
	font.setBold(true);
	item->setFont(font);
	}
	ui->tableWidget_log->setItem(row, col, item);
	col++;
	};
	QString commit_id;
	QString datetime;
	QString author;
	QString message;
	QString message_ex;
	bool isHEAD = commit->commit_id == m->head_id;
	bool bold = false;
	{
	if (Git::isUncommited(*commit)) { // 未コミットの時
	bold = true; // 太字
	selrow = row;
	} else {
	if (isHEAD && !isThereUncommitedChanges()) { // HEADで、未コミットがないとき
	bold = true; // 太字
	selrow = row;
	}
	commit_id = abbrevCommitID(*commit);
	}
	datetime = misc::makeDateTimeString(commit->commit_date);
	author = commit->author;
	message = commit->message;
	message_ex = makeCommitInfoText(row, &m->label_map[row]);
	}
	AddColumn(commit_id, false, QString());
	AddColumn(datetime, false, QString());
	AddColumn(author, false, QString());
	AddColumn(message, bold, message + message_ex);
	ui->tableWidget_log->setRowHeight(row, 24);
	}
	ui->tableWidget_log->resizeColumnsToContents();
	ui->tableWidget_log->horizontalHeader()->setStretchLastSection(false);
	ui->tableWidget_log->horizontalHeader()->setStretchLastSection(true);

	m->last_focused_file_list = 0;

	ui->tableWidget_log->setFocus();
	setCurrentLogRow(0);

	QTableWidgetItem *p = ui->tableWidget_log->item(selrow < 0 ? 0 : selrow, 2);
	ui->tableWidget_log->setCurrentItem(p);

	m->remote_watcher.setCurrent(currentRemoteName(), currentBranchName());

	checkRemoteUpdate();
	doUpdateButton();
	}

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

	void MainWindow::removeSelectedRepositoryFromBookmark(bool ask)
	{
	int i = indexOfRepository(ui->treeWidget_repos->currentItem());
	removeRepositoryFromBookmark(i, ask);
	}

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

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

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

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

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

	void MainWindow::doUpdateButton()
	{
	setNetworkingCommandsEnabled(isRemoteOnline());

	Git::Branch b = currentBranch();

	int n;

	ui->toolButton_fetch->setDot(m->remote_changed);

	n = b.ahead > 0 ? b.ahead : -1;
	ui->toolButton_push->setNumber(n);

	n = b.behind > 0 ? b.behind : -1;
	ui->toolButton_pull->setNumber(n);
	}

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

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

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

	void MainWindow::openSelectedRepository()
	{
	QTreeWidgetItem *treeitem = ui->treeWidget_repos->currentItem();
	RepositoryItem const *item = repositoryItem(treeitem);
	if (item) {
	setCurrentRepository(*item, true);
	openRepository(true);
	}
	}

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



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

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

	void MainWindow::commit_amend()
	{
	commit(true);
	}


	void MainWindow::updateStatusBarText()
	{
	QString text;

	QWidget *w = qApp->focusWidget();
	if (w == ui->treeWidget_repos) {
	QTreeWidgetItem *ite = ui->treeWidget_repos->currentItem();
	RepositoryItem const *item = repositoryItem(ite);
	if (item) {
	text = QString("%1 : %2")
	.arg(item->name)
	.arg(misc::normalizePathSeparator(item->local_dir))
	;
	}
	} else if (w == ui->tableWidget_log) {
	QTableWidgetItem *item = ui->tableWidget_log->item(selectedLogIndex(), 0);
	if (item) {
	int row = item->data(IndexRole).toInt();
	if (row < (int)m->logs.size()) {
	Git::CommitItem const &commit = m->logs[row];
	if (Git::isUncommited(commit)) {
	text = tr("Uncommited changes");
	} else {
	QString id = commit.commit_id;
	text = QString("%1 : %2%3")
	.arg(id.mid(0, 7))
	.arg(commit.message)
	.arg(makeCommitInfoText(row, nullptr))
	;
	}
	}
	}
	}

	setStatusBarText(text);
	}

	void MainWindow::execRepositoryPropertyDialog(QString workdir, bool open_repository_menu)
	{
	if (workdir.isEmpty()) {
	workdir = currentWorkingCopyDir();
	}
	QString name;
	RepositoryItem const *repo = findRegisteredRepository(&workdir);
	if (repo) {
	name = repo->name;
	} else {
	QMessageBox::warning(this, tr("Repository Property"), tr("Not a valid git repository") + "\n\n" + workdir);
	return;
	}
	if (name.isEmpty()) {
	name = makeRepositoryName(workdir);
	}
	GitPtr g = git(workdir);
	RepositoryPropertyDialog dlg(this, g, *repo, open_repository_menu);
	dlg.exec();
	if (dlg.isRemoteChanged()) {
	updateRemoteInfo();
	}
	}



	void MainWindow::on_action_commit_triggered()
	{
	commit();
	}

	void MainWindow::on_action_fetch_triggered()
	{
	if (!isRemoteOnline()) return;

	reopenRepository(true, [&](GitPtr g){
	fetch(g);
	});
	}

	void MainWindow::on_action_push_triggered()
	{
	if (!isRemoteOnline()) return;

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

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

	int exitcode = 0;
	QString errormsg;

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

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

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

	void MainWindow::on_action_pull_triggered()
	{
	if (!isRemoteOnline()) return;

	reopenRepository(true, [&](GitPtr g){
	m->pty_condition = PtyCondition::Pull;
	m->pty_process_ok = true;
	g->pull(&m->pty_process);
	while (1) {
	if (m->pty_process.wait(1)) break;
	QApplication::processEvents();
	}
	});
	}

	void MainWindow::on_toolButton_push_clicked()
	{
	ui->action_push->trigger();
	}

	void MainWindow::on_toolButton_pull_clicked()
	{
	ui->action_pull->trigger();
	}

	void MainWindow::on_treeWidget_repos_currentItemChanged(QTreeWidgetItem * /current/, QTreeWidgetItem * /previous/)
	{
	updateStatusBarText();
	}

	void MainWindow::on_treeWidget_repos_itemDoubleClicked(QTreeWidgetItem * /item/, int /column/)
	{
	openSelectedRepository();
	}

	void MainWindow::execCommitPropertyDialog(QWidget parent, Git::CommitItem const commit)
	{
	CommitPropertyDialog dlg(parent, this, commit);
	dlg.exec();
	}

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

	int MainWindow::indexOfRepository(QTreeWidgetItem const *treeitem) const
	{
	if (!treeitem) return -1;
	return treeitem->data(0, IndexRole).toInt();
	}

	void MainWindow::on_treeWidget_repos_customContextMenuRequested(const QPoint &pos)
	{
	QTreeWidgetItem *treeitem = ui->treeWidget_repos->currentItem();
	if (!treeitem) return;

	RepositoryItem const *repo = repositoryItem(treeitem);

	int index = indexOfRepository(treeitem);
	if (isGroupItem(treeitem)) { // group item
	QMenu menu;
	QAction *a_add_new_group = menu.addAction(tr("&Add new group"));
	QAction *a_delete_group = menu.addAction(tr("&Delete group"));
	QAction *a_rename_group = menu.addAction(tr("&Rename group"));
	QPoint pt = ui->treeWidget_repos->mapToGlobal(pos);
	QAction *a = menu.exec(pt + QPoint(8, -8));
	if (a) {
	if (a == a_add_new_group) {
	QTreeWidgetItem *child = newQTreeWidgetFolderItem(tr("New group"));
	treeitem->addChild(child);
	child->setFlags(child->flags() \| Qt::ItemIsEditable);
	ui->treeWidget_repos->setCurrentItem(child);
	return;
	}
	if (a == a_delete_group) {
	QTreeWidgetItem *parent = treeitem->parent();
	if (parent) {
	int i = parent->indexOfChild(treeitem);
	delete parent->takeChild(i);
	} else {
	int i = ui->treeWidget_repos->indexOfTopLevelItem(treeitem);
	delete ui->treeWidget_repos->takeTopLevelItem(i);
	}
	refrectRepositories();
	return;
	}
	if (a == a_rename_group) {
	ui->treeWidget_repos->editItem(treeitem);
	return;
	}
	}
	} else if (repo) { // repository item
	QString open_terminal = tr("Open &terminal");
	QString open_commandprompt = tr("Open command promp&t");
	QMenu menu;
	QAction *a_open = menu.addAction(tr("&Open"));
	menu.addSeparator();
	#ifdef Q_OS_WIN
	QAction *a_open_terminal = menu.addAction(open_commandprompt);
	(void)open_terminal;
	#else
	QAction *a_open_terminal = menu.addAction(open_terminal);
	(void)open_commandprompt;
	#endif
	QAction *a_open_folder = menu.addAction(tr("Open &folder"));
	menu.addSeparator();
	QAction *a_remove = menu.addAction(tr("&Remove"));

	menu.addSeparator();
	QAction *a_properties = addMenuActionProperty(&menu);

	QPoint pt = ui->treeWidget_repos->mapToGlobal(pos);
	QAction *a = menu.exec(pt + QPoint(8, -8));
	if (a) {
	if (a == a_open) {
	openSelectedRepository();
	return;
	}
	if (a == a_open_folder) {
	openExplorer(repo);
	return;
	}
	if (a == a_open_terminal) {
	openTerminal(repo);
	return;
	}
	if (a == a_remove) {
	removeRepositoryFromBookmark(index, true);
	return;
	}
	if (a == a_properties) {
	execRepositoryPropertyDialog(repo->local_dir);
	return;
	}
	}
	}
	}

	void MainWindow::execCommitExploreWindow(QWidget parent, Git::CommitItem const commit)
	{
	CommitExploreWindow win(parent, this, &m->objcache, commit);
	win.exec();
	}

	void MainWindow::on_tableWidget_log_customContextMenuRequested(const QPoint &pos)
	{
	Git::CommitItem const *commit = selectedCommitItem();
	if (commit) {
	bool is_valid_commit_id = Git::isValidID(commit->commit_id);
	int row = selectedLogIndex();

	QMenu menu;

	QAction *a_copy_id_7_letters = menu.addAction(tr("Copy commit id (7 letters)"));
	QAction *a_copy_id_complete = menu.addAction(tr("Copy commit id (completely)"));

	menu.addSeparator();

	QAction *a_checkout = is_valid_commit_id ? menu.addAction(tr("Checkout/Branch...")) : nullptr;

	menu.addSeparator();

	QAction *a_edit_comment = nullptr;
	if (row == 0 && currentBranch().ahead > 0) {
	a_edit_comment = menu.addAction(tr("Edit comment..."));
	}

	QAction *a_merge = is_valid_commit_id ? menu.addAction(tr("Merge")) : nullptr;
	QAction *a_rebase = is_valid_commit_id ? menu.addAction(tr("Rebase")) : nullptr;
	QAction *a_cherrypick = is_valid_commit_id ? menu.addAction(tr("Cherry-pick")) : nullptr;
	QAction *a_edit_tags = is_valid_commit_id ? menu.addAction(tr("Edit tags...")) : nullptr;
	QAction *a_revert = is_valid_commit_id ? menu.addAction(tr("Revert")) : nullptr;

	QAction *a_reset_head = nullptr;
	#if 0 // 下手に使うと危険なので、とりあえず無効にしておく
	if (is_valid_commit_id && commit->commit_id == m->head_id) {
	a_reset_head = menu.addAction(tr("Reset HEAD"));
	}
	#endif

	menu.addSeparator();

	QAction *a_delbranch = is_valid_commit_id ? menu.addAction(tr("Delete branch...")) : nullptr;
	QAction *a_delrembranch = remoteBranches(commit->commit_id).isEmpty() ? nullptr : menu.addAction(tr("Delete remote branch..."));

	menu.addSeparator();

	QAction *a_explore = is_valid_commit_id ? menu.addAction(tr("Explore")) : nullptr;
	QAction *a_properties = addMenuActionProperty(&menu);

	QAction *a = menu.exec(ui->tableWidget_log->viewport()->mapToGlobal(pos) + QPoint(8, -8));
	if (a) {
	if (a == a_copy_id_7_letters) {
	qApp->clipboard()->setText(commit->commit_id.mid(0, 7));
	return;
	}
	if (a == a_copy_id_complete) {
	qApp->clipboard()->setText(commit->commit_id);
	return;
	}
	if (a == a_properties) {
	execCommitPropertyDialog(this, commit);
	return;
	}
	if (a == a_edit_comment) {
	commit_amend();
	return;
	}
	if (a == a_checkout) {
	checkout(this, commit);
	return;
	}
	if (a == a_delbranch) {
	deleteBranch(commit);
	return;
	}
	if (a == a_delrembranch) {
	deleteRemoteBranch(commit);
	return;
	}
	if (a == a_merge) {
	mergeBranch(commit);
	return;
	}
	if (a == a_rebase) {
	rebaseBranch(commit);
	return;
	}
	if (a == a_cherrypick) {
	cherrypick(commit);
	return;
	}
	if (a == a_edit_tags) {
	ui->action_edit_tags->trigger();
	return;
	}
	if (a == a_revert) {
	revertCommit();
	return;
	}
	if (a == a_explore) {
	execCommitExploreWindow(this, commit);
	return;
	}
	if (a == a_reset_head) {
	reopenRepository(false, [](GitPtr g){
	g->reset_head1();
	});
	return;
	}
	}
	}
	}

	void MainWindow::on_listWidget_files_customContextMenuRequested(const QPoint &pos)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QMenu menu;
	QAction *a_delete = menu.addAction(tr("Delete"));
	QAction *a_untrack = menu.addAction(tr("Untrack"));
	QAction *a_history = menu.addAction(tr("History"));
	QAction *a_blame = menu.addAction(tr("Blame"));
	QAction *a_properties = addMenuActionProperty(&menu);

	QPoint pt = ui->listWidget_files->mapToGlobal(pos) + QPoint(8, -8);
	QAction *a = menu.exec(pt);
	if (a) {
	QListWidgetItem *item = ui->listWidget_files->currentItem();
	if (a == a_delete) {
	if (askAreYouSureYouWantToRun("Delete", tr("Delete selected files."))) {
	for_each_selected_files([&](QString const &path){
	g->removeFile(path);
	g->chdirexec([&](){
	QFile(path).remove();
	return true;
	});
	});
	openRepository(false);
	}
	} else if (a == a_untrack) {
	if (askAreYouSureYouWantToRun("Untrack", tr("rm --cached files"))) {
	for_each_selected_files([&](QString const &path){
	g->rm_cached(path);
	});
	openRepository(false);
	}
	} else if (a == a_history) {
	execFileHistory(item);
	} else if (a == a_blame) {
	blame(item);
	} else if (a == a_properties) {
	execFilePropertyDialog(item);
	}
	}
	}

	void MainWindow::on_listWidget_unstaged_customContextMenuRequested(const QPoint &pos)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QList<QListWidgetItem *> items = ui->listWidget_unstaged->selectedItems();
	if (!items.isEmpty()) {
	QMenu menu;
	QAction *a_stage = menu.addAction(tr("Stage"));
	QAction *a_reset_file = menu.addAction(tr("Reset"));
	QAction *a_ignore = menu.addAction(tr("Ignore"));
	QAction *a_delete = menu.addAction(tr("Delete"));
	QAction *a_untrack = menu.addAction(tr("Untrack"));
	QAction *a_history = menu.addAction(tr("History"));
	QAction *a_blame = menu.addAction(tr("Blame"));
	QAction *a_properties = addMenuActionProperty(&menu);
	QPoint pt = ui->listWidget_unstaged->mapToGlobal(pos) + QPoint(8, -8);
	QAction *a = menu.exec(pt);
	if (a) {
	QListWidgetItem *item = ui->listWidget_unstaged->currentItem();
	if (a == a_stage) {
	for_each_selected_files([&](QString const &path){
	g->stage(path);
	});
	updateCurrentFilesList();
	return;
	}
	if (a == a_reset_file) {
	QStringList paths;
	for_each_selected_files([&](QString const &path){
	paths.push_back(path);
	});
	resetFile(paths);
	return;
	}
	if (a == a_ignore) {
	QString gitignore_path = currentWorkingCopyDir() / ".gitignore";
	if (items.size() == 1) {
	QString file = getFilePath(items[0]);
	EditGitIgnoreDialog dlg(this, gitignore_path, file);
	if (dlg.exec() == QDialog::Accepted) {
	QString appending = dlg.text();
	if (!appending.isEmpty()) {
	QString text;

	QString path = gitignore_path;
	path.replace('/', QDir::separator());

	{
	QFile file(path);
	if (file.open(QFile::ReadOnly)) {
	text += QString::fromUtf8(file.readAll());
	}
	}

	size_t n = text.size();
	if (n > 0 && text[(int)n - 1] != '\n') {
	text += '\n'; // 最後に改行を追加
	}

	text += appending + '\n';

	{
	QFile file(path);
	if (file.open(QFile::WriteOnly)) {
	file.write(text.toUtf8());
	}
	}
	updateCurrentFilesList();
	return;
	}
	} else {
	return;
	}
	}

	QString append;
	for_each_selected_files([&](QString const &path){
	if (path == ".gitignore") {
	// skip
	} else {
	append += path + '\n';
	}
	});
	if (TextEditDialog::editFile(this, gitignore_path, ".gitignore", append)) {
	updateCurrentFilesList();
	}
	return;
	}
	if (a == a_delete) {
	if (askAreYouSureYouWantToRun("Delete", "Delete selected files.")) {
	for_each_selected_files([&](QString const &path){
	g->removeFile(path);
	g->chdirexec([&](){
	QFile(path).remove();
	return true;
	});
	});
	openRepository(false);
	}
	return;
	}
	if (a == a_untrack) {
	if (askAreYouSureYouWantToRun("Untrack", "rm --cached")) {
	for_each_selected_files([&](QString const &path){
	g->rm_cached(path);
	});
	openRepository(false);
	}
	return;
	}
	if (a == a_history) {
	execFileHistory(item);
	return;
	}
	if (a == a_blame) {
	blame(item);
	return;
	}
	if (a == a_properties) {
	execFilePropertyDialog(item);
	return;
	}
	}
	}
	}

	void MainWindow::on_listWidget_staged_customContextMenuRequested(const QPoint &pos)
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	QListWidgetItem *item = ui->listWidget_staged->currentItem();
	if (item) {
	QString path = getFilePath(item);
	QString fullpath = currentWorkingCopyDir() / path;
	if (QFileInfo(fullpath).isFile()) {
	QMenu menu;
	QAction *a_unstage = menu.addAction(tr("Unstage"));
	QAction *a_history = menu.addAction(tr("History"));
	QAction *a_blame = menu.addAction(tr("Blame"));
	QAction *a_properties = addMenuActionProperty(&menu);
	QPoint pt = ui->listWidget_staged->mapToGlobal(pos) + QPoint(8, -8);
	QAction *a = menu.exec(pt);
	if (a) {
	QListWidgetItem *item = ui->listWidget_unstaged->currentItem();
	if (a == a_unstage) {
	g->unstage(path);
	openRepository(false);
	} else if (a == a_history) {
	execFileHistory(item);
	} else if (a == a_blame) {
	blame(item);
	} else if (a == a_properties) {
	execFilePropertyDialog(item);
	}
	}
	}
	}
	}

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

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

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

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

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

	QStringList MainWindow::selectedFiles_(QListWidget *listwidget) const
	{
	QStringList list;
	QList<QListWidgetItem *> items = listwidget->selectedItems();
	for (QListWidgetItem *item : items) {
	QString path = getFilePath(item);
	list.push_back(path);
	}
	return list;

	}

	QStringList MainWindow::selectedFiles() const
	{
	if (m->last_focused_file_list == ui->listWidget_files) return selectedFiles_(ui->listWidget_files);
	if (m->last_focused_file_list == ui->listWidget_staged) return selectedFiles_(ui->listWidget_staged);
	if (m->last_focused_file_list == ui->listWidget_unstaged) return selectedFiles_(ui->listWidget_unstaged);
	return QStringList();
	}

	void MainWindow::for_each_selected_files(std::function<void(QString const&)> fn)
	{
	for (QString path : selectedFiles()) {
	fn(path);
	}
	}

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

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

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

	void MainWindow::execFileHistory(QListWidgetItem *item)
	{
	if (item) {
	QString path = getFilePath(item);
	if (!path.isEmpty()) {
	execFileHistory(path);
	}
	}
	}

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

	if (!Git::isValidWorkingCopy(dir)) {
	qDebug() << "Invalid working dir: " + dir;
	return;
	}

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

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

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

	void MainWindow::on_action_open_existing_working_copy_triggered()
	{
	QString dir = defaultWorkingDir();
	dir = QFileDialog::getExistingDirectory(this, tr("Add existing working copy"), dir);
	addWorkingCopyDir(dir, false);
	}

	void MainWindow::on_action_view_refresh_triggered()
	{
	openRepository(true);
	}

	void MainWindow::on_tableWidget_log_currentItemChanged(QTableWidgetItem * /current/, QTableWidgetItem * /previous/)
	{
	clearFileList();

	QTableWidgetItem *item = ui->tableWidget_log->item(selectedLogIndex(), 0);
	if (!item) return;

	int row = item->data(IndexRole).toInt();
	if (row < (int)m->logs.size()) {
	updateStatusBarText();
	m->update_files_list_counter = 200;
	}
	}

	void MainWindow::on_toolButton_stage_clicked()
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	g->stage(selectedFiles());
	updateCurrentFilesList();
	}

	void MainWindow::on_toolButton_unstage_clicked()
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	g->unstage(selectedFiles());
	updateCurrentFilesList();
	}

	void MainWindow::on_toolButton_select_all_clicked()
	{
	if (ui->listWidget_unstaged->count() > 0) {
	ui->listWidget_unstaged->setFocus();
	ui->listWidget_unstaged->selectAll();
	} else if (ui->listWidget_staged->count() > 0) {
	ui->listWidget_staged->setFocus();
	ui->listWidget_staged->selectAll();
	}
	}

	void MainWindow::on_toolButton_commit_clicked()
	{
	ui->action_commit->trigger();
	}

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

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

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

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

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

	void MainWindow::on_action_edit_global_gitconfig_triggered()
	{
	QString dir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
	QString path = dir / ".gitconfig";
	editFile(path, ".gitconfig");
	}

	void MainWindow::on_action_edit_git_config_triggered()
	{
	QString dir = currentWorkingCopyDir();
	QString path = dir / ".git/config";
	editFile(path, ".git/config");
	}

	void MainWindow::on_action_edit_gitignore_triggered()
	{
	QString dir = currentWorkingCopyDir();
	QString path = dir / ".gitignore";
	if (editFile(path, ".gitignore")) {
	updateCurrentFilesList();
	}
	}

	int MainWindow::selectedLogIndex() const
	{
	int i = ui->tableWidget_log->currentRow();
	if (i >= 0 && i < (int)m->logs.size()) {
	return i;
	}
	return -1;
	}

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

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

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

	void MainWindow::updateDiffView(QListWidgetItem *item)
	{
	clearDiffView();

	m->last_selected_file_item = item;

	if (!item) return;

	int idiff = indexOfDiff(item);
	if (idiff >= 0 && idiff < m->diff.result.size()) {
	Git::Diff const &diff = m->diff.result[idiff];
	QString key = GitDiff::makeKey(diff);
	auto it = m->diff_cache.find(key);
	if (it != m->diff_cache.end()) {
	int row = ui->tableWidget_log->currentRow();
	bool uncommited = (row >= 0 && row < (int)m->logs.size() && Git::isUncommited(m->logs[row]));
	ui->widget_diff_view->updateDiffView(it->second, uncommited);
	}
	}
	}

	void MainWindow::updateDiffView()
	{
	updateDiffView(m->last_selected_file_item);
	}

	void MainWindow::updateUnstagedFileCurrentItem()
	{
	updateDiffView(ui->listWidget_unstaged->currentItem());
	}

	void MainWindow::updateStagedFileCurrentItem()
	{
	updateDiffView(ui->listWidget_staged->currentItem());
	}

	void MainWindow::on_listWidget_unstaged_currentRowChanged(int /currentRow/)
	{
	updateUnstagedFileCurrentItem();
	}

	void MainWindow::on_listWidget_staged_currentRowChanged(int /currentRow/)
	{
	updateStagedFileCurrentItem();
	}

	void MainWindow::on_listWidget_files_currentRowChanged(int /currentRow/)
	{
	updateDiffView(ui->listWidget_files->currentItem());
	}

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

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

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

	void MainWindow::setGitCommand(QString const &path, bool save)
	{
	internalSetCommand(path, save, "GitCommand", &m->gcx.git_command);
	}

	void MainWindow::setFileCommand(QString const &path, bool save)
	{
	internalSetCommand(path, save, "FileCommand", &global->file_command);
	}

	void MainWindow::setGpgCommand(QString const &path, bool save)
	{
	internalSetCommand(path, save, "GpgCommand", &global->gpg_command);
	if (!global->gpg_command.isEmpty()) {
	GitPtr g = git();
	g->configGpgProgram(global->gpg_command, true);
	}
	}

	void MainWindow::setWatchRemoteInterval(int mins)
	{
	if (mins > 0) {
	m->remote_watcher_timer.start(mins * 60000);
	} else {
	m->remote_watcher_timer.stop();
	}
	}

	#ifdef Q_OS_WIN
	QString getWin32HttpProxy();
	#endif

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



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

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

	return list;
	}

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

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

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

	#ifdef Q_OS_WIN
	#define GIT_COMMAND "git.exe"
	#define FILE_COMMAND "file.exe"
	#define GPG_COMMAND "gpg.exe"
	#define GPG2_COMMAND "gpg2.exe"
	#else
	#define GIT_COMMAND "git"
	#define FILE_COMMAND "file"
	#define GPG_COMMAND "gpg"
	#define GPG2_COMMAND "gpg2"
	#endif

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

	QString path = m->gcx.git_command;

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

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

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

	QString path = global->file_command;

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

	QStringList list = whichCommand_(exe);

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

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

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

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

	QStringList list = whichCommand_(GPG_COMMAND, GPG2_COMMAND);

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

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

	void MainWindow::dragEnterEvent(QDragEnterEvent *event)
	{
	if (QApplication::modalWindow()) return;

	if (event->mimeData()->hasUrls()) {
	event->acceptProposedAction();
	event->accept();
	}
	}

	void MainWindow::timerEvent(QTimerEvent *)
	{
	bool running = m->pty_process.isRunning();
	if (ui->toolButton_stop_process->isEnabled() != running) {
	ui->toolButton_stop_process->setEnabled(running);
	ui->action_stop_process->setEnabled(running);
	setNetworkingCommandsEnabled(!running);
	}
	if (!running) {
	m->interaction_mode = InteractionMode::None;
	}

	while (1) {
	char tmp[1024];
	int len = m->pty_process.readOutput(tmp, sizeof(tmp));
	if (len < 1) break;
	writeLog(tmp, len);
	}
	}

	void MainWindow::keyPressEvent(QKeyEvent *event)
	{
	if (qApp->focusWidget() == ui->widget_log) {
	int c = event->key();

	auto write_char = [&](char c){
	if (m->pty_process.isRunning()) {
	m->pty_process.writeInput(&c, 1);
	}
	};

	auto write_text = [&](QString const &str){
	std::string s = str.toStdString();
	for (int i = 0; i < (int)s.size(); i++) {
	write_char(s[i]);
	}
	};

	if (c == Qt::Key_Return \|\| c == Qt::Key_Enter) {
	write_char('\n');
	} else {
	QString text = event->text();
	write_text(text);
	}
	}
	}

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

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

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

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

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

	void MainWindow::on_action_edit_settings_triggered()
	{
	SettingsDialog dlg(this);
	if (dlg.exec() == QDialog::Accepted) {
	ApplicationSettings const &newsettings = dlg.settings();
	m->appsettings = newsettings;
	setGitCommand(appsettings()->git_command, false);
	setFileCommand(appsettings()->file_command, false);
	setGpgCommand(appsettings()->gpg_command, false);
	setWatchRemoteInterval(appsettings()->watch_remote_changes_every_mins);
	}
	}

	void MainWindow::clone()
	{
	if (!isRemoteOnline()) return;

	QString url;
	QString dir = defaultWorkingDir();
	while (1) {
	CloneDialog dlg(this, url, dir);
	if (dlg.exec() != QDialog::Accepted) {
	return;
	}

	url = dlg.url();
	dir = dlg.dir();

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

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

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

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

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

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

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

	// ディレクトリを作成

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

	m->temp_repo.local_dir = dir;
	m->temp_repo.local_dir.replace('\\', '/');
	m->temp_repo.name = makeRepositoryName(dir);

	GitPtr g = git(QString());
	m->pty_condition = PtyCondition::Clone;
	m->pty_process_ok = true;
	g->clone(clone_data, &m->pty_process);

	} else if (dlg.action() == CloneDialog::Action::AddExisting) {
	addWorkingCopyDir(dir, true);
	}

	return; // done
	}
	}

	void MainWindow::onCloneCompleted(bool success)
	{
	if (success) {
	saveRepositoryBookmark(m->temp_repo);
	setCurrentRepository(m->temp_repo, false);
	openRepository(true);
	}
	}

	void MainWindow::onPtyProcessCompleted()
	{
	switch (m->pty_condition) {
	case PtyCondition::Clone:
	onCloneCompleted(m->pty_process_ok);
	break;
	}
	m->pty_condition = PtyCondition::None;
	}

	void MainWindow::on_action_clone_triggered()
	{
	clone();
	}

	void MainWindow::on_action_about_triggered()
	{
	AboutDialog dlg(this);
	dlg.exec();
	}

	void MainWindow::on_toolButton_clone_clicked()
	{
	ui->action_clone->trigger();
	}

	void MainWindow::on_toolButton_fetch_clicked()
	{
	ui->action_fetch->trigger();
	}

	void MainWindow::clearRepoFilter()
	{
	ui->lineEdit_filter->clear();
	}

	void MainWindow::appendCharToRepoFilter(ushort c)
	{
	if (QChar(c).isLetter()) {
	c = QChar(c).toLower().unicode();
	}
	ui->lineEdit_filter->setText(m->repository_filter_text + c);
	}

	void MainWindow::backspaceRepoFilter()
	{
	QString s = m->repository_filter_text;
	int n = s.size();
	if (n > 0) {
	s = s.mid(0, n - 1);
	}
	ui->lineEdit_filter->setText(s);
	}

	void MainWindow::on_lineEdit_filter_textChanged(const QString &text)
	{
	m->repository_filter_text = text;
	updateRepositoriesList();
	}

	void MainWindow::on_toolButton_erase_filter_clicked()
	{
	clearRepoFilter();
	ui->lineEdit_filter->setFocus();
	}

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

	int row = ui->tableWidget_log->currentRow();

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

	ui->tableWidget_log->selectRow(row);
	}

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



	void MainWindow::revertCommit()
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	Git::CommitItem const *commit = selectedCommitItem();
	if (commit) {
	g->revert(commit->commit_id);
	openRepository(false);
	}
	}

	bool MainWindow::addTag(QString const &name)
	{
	if (name.isEmpty()) return false;

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

	QString commit_id;

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

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

	int row = ui->tableWidget_log->currentRow();

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

	ui->tableWidget_log->selectRow(row);
	return ok;
	}

	void MainWindow::on_action_tag_push_all_triggered()
	{
	reopenRepository(false, [&](GitPtr g){
	g->push(true);
	});
	}

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

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

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

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

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

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

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

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

	void MainWindow::on_tableWidget_log_itemDoubleClicked(QTableWidgetItem *)
	{
	Git::CommitItem const *commit = selectedCommitItem();
	if (commit) {
	execCommitPropertyDialog(this, commit);
	}
	}

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

	void MainWindow::on_listWidget_unstaged_itemDoubleClicked(QListWidgetItem * item)
	{
	execFilePropertyDialog(item);
	}

	void MainWindow::on_listWidget_staged_itemDoubleClicked(QListWidgetItem *item)
	{
	execFilePropertyDialog(item);
	}

	void MainWindow::on_listWidget_files_itemDoubleClicked(QListWidgetItem *item)
	{
	execFilePropertyDialog(item);
	}

	QListWidgetItem *MainWindow::currentFileItem() const
	{
	QListWidget *listwidget = nullptr;
	if (ui->stackedWidget->currentWidget() == ui->page_uncommited) {
	QWidget *w = qApp->focusWidget();
	if (w == ui->listWidget_unstaged) {
	listwidget = ui->listWidget_unstaged;
	} else if (w == ui->listWidget_staged) {
	listwidget = ui->listWidget_staged;
	}
	} else {
	listwidget = ui->listWidget_files;
	}
	if (listwidget) {
	return listwidget->currentItem();
	}
	return nullptr;
	}

	QPixmap MainWindow::getTransparentPixmap()
	{
	if (m->transparent_pixmap.isNull()) {
	m->transparent_pixmap = QPixmap(":/image/transparent.png");
	}
	return m->transparent_pixmap;
	}

	QString MainWindow::getCommitIdFromTag(QString const &tag)
	{
	return m->objcache.getCommitIdFromTag(tag);
	}

	bool MainWindow::isValidRemoteURL(const QString &url)
	{
	if (url.indexOf('\"') >= 0) {
	return false;
	}
	stopPtyProcess();
	GitPtr g = git(QString());
	QString cmd = "ls-remote \"%1\" HEAD";
	bool f = g->git(cmd.arg(url), false, false, &m->pty_process);
	{
	QTime time;
	time.start();
	while (!m->pty_process.wait(10)) {
	if (time.elapsed() > 10000) {
	f = false;
	break;
	}
	QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
	}
	stopPtyProcess();
	}
	QString line = g->resultText().trimmed();
	QString head;
	int i = line.indexOf('\t');
	if (i == GIT_ID_LENGTH) {
	QString id = line.mid(0, i);
	QString name = line.mid(i + 1);
	qDebug() << id << name;
	if (name == "HEAD" && Git::isValidID(id)) {
	head = id;
	}
	}
	if (f) {
	qDebug() << "This is a valid repository.";
	if (head.isEmpty()) {
	qDebug() << "But HEAD not found";
	}
	return true;
	} else {
	qDebug() << "It is not a repository.";
	}
	return false;
	}

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

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

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

	QString title = tr("Remote Repository");

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

	return ok;
	}

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

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

	void MainWindow::on_action_set_config_user_triggered()
	{
	Git::User global_user;
	Git::User repo_user;
	GitPtr g = git();
	if (isValidWorkingCopy(g)) {
	repo_user = g->getUser(Git::Source::Local);
	}
	global_user = g->getUser(Git::Source::Global);

	execSetUserDialog(global_user, repo_user, currentRepositoryName());
	}

	void MainWindow::on_action_window_log_triggered(bool checked)
	{
	ui->dockWidget_log->setVisible(checked);
	}

	NamedCommitList MainWindow::namedCommitItems(int flags)
	{
	NamedCommitList items;
	if (flags & Branches) {
	for (auto pair: m->branch_map) {
	QList<Git::Branch> const &list = pair.second;
	for (Git::Branch const &b : list) {
	if (b.isHeadDetached()) continue;
	QString key = b.name;
	if (flags & NamedCommitFlag::Remotes) {
	if (!b.remote.isEmpty()) {
	key = "remotes" / b.remote / key;
	}
	} else {
	if (!b.remote.isEmpty()) continue;
	}
	NamedCommitItem item;
	item.type = NamedCommitItem::Type::Branch;
	item.remote = b.remote;
	item.name = b.name;
	item.id = b.id;
	items.push_back(item);
	}
	}
	}
	if (flags & Tags) {
	for (auto pair: m->tag_map) {
	QList<Git::Tag> const &list = pair.second;
	for (Git::Tag const &t : list) {
	NamedCommitItem item;
	item.type = NamedCommitItem::Type::Tag;
	item.name = t.name;
	item.id = t.id;
	items.push_back(item);
	}
	}
	}
	return items;
	}

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

	void MainWindow::on_action_repo_jump_triggered()
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	NamedCommitList items = namedCommitItems(Branches \| Tags \| Remotes);
	JumpDialog::sort(&items);
	{
	NamedCommitItem head;
	head.name = "HEAD";
	head.id = m->head_id;
	items.push_front(head);
	}
	JumpDialog dlg(this, items);
	if (dlg.exec() == QDialog::Accepted) {
	JumpDialog::Action action = dlg.action();
	if (action == JumpDialog::Action::BranchsAndTags) {
	QString name = dlg.text();
	QString id = g->rev_parse(name);
	if (g->objectType(id) == "tag") {
	id = m->objcache.getCommitIdFromTag(id);
	}
	int row = rowFromCommitId(id);
	if (row < 0) {
	QMessageBox::warning(this, tr("Jump"), QString("%1\n(%2)\n\n").arg(name).arg(id) + tr("That commmit has not foud or not read yet"));
	} else {
	setCurrentLogRow(row);

	if (dlg.isCheckoutChecked()) {
	NamedCommitItem item;
	for (NamedCommitItem const &t : items) {
	if (t.name == name) {
	item = t;
	break;
	}
	}
	bool ok = false;
	if (item.type == NamedCommitItem::Type::Branch) {
	ok = g->git(QString("checkout \"%1\"").arg(name), true);
	} else if (item.type == NamedCommitItem::Type::Tag) {
	ok = g->git(QString("checkout -b \"%1\" \"%2\"").arg(name).arg(id), true);
	}
	if (ok) {
	openRepository(true);
	}
	}
	}
	} else if (action == JumpDialog::Action::CommitId) {
	QString id = dlg.text();
	jumpToCommit(id);
	}
	}
	}

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

	void MainWindow::checkout(QWidget parent, Git::CommitItem const commit)
	{
	if (!commit) return;

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

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

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

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

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

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

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

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

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

	g->mergeBranch(commit->commit_id);
	openRepository(true);
	}

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

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

	QString text = tr("Are you sure you want to rebase the commit ?");
	text += "\n\n";
	text += "> git rebase " + commit->commit_id;
	int r = QMessageBox::information(this, tr("Rebase"), text, QMessageBox::Ok, QMessageBox::Cancel);
	if (r == QMessageBox::Ok) {
	g->rebaseBranch(commit->commit_id);
	openRepository(true);
	}
	}

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

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

	g->cherrypick(commit->commit_id);
	openRepository(true);
	}

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

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

	void MainWindow::on_action_repo_checkout_triggered()
	{
	checkout();
	}

	void MainWindow::on_action_delete_branch_triggered()
	{
	deleteBranch();
	}

	bool MainWindow::runOnRepositoryDir(std::function<void(QString)> callback, RepositoryItem const *repo)
	{
	if (!repo) {
	repo = &m->current_repo;
	}
	QString dir = repo->local_dir;
	dir.replace('\\', '/');
	if (QFileInfo(dir).isDir()) {
	callback(dir);
	return true;
	}
	QMessageBox::warning(this, qApp->applicationName(), tr("No repository selected"));
	return false;
	}

	#ifdef Q_OS_MAC
	namespace {

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

	}
	#endif

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

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

	void MainWindow::on_toolButton_terminal_clicked()
	{
	openTerminal(nullptr);
	}

	void MainWindow::on_toolButton_explorer_clicked()
	{
	openExplorer(nullptr);
	}

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

	int exitcode = 0;
	QString errormsg;

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

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

	updateRemoteInfo();
	}

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

	QString current_branch = currentBranchName();

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

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

	if (testonly) {
	return true;
	}

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

	return false;
	}

	void MainWindow::on_action_reset_HEAD_1_triggered()
	{
	GitPtr g = git();
	if (!isValidWorkingCopy(g)) return;

	g->reset_head1();
	openRepository(false);
	}

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

	void MainWindow::on_action_create_a_repository_triggered()
	{
	createRepository(QString());
	}

	bool MainWindow::isRemoteOnline() const
	{
	return ui->radioButton_remote_online->isChecked();
	}

	void MainWindow::setNetworkingCommandsEnabled(bool f)
	{
	ui->action_clone->setEnabled(f);

	ui->toolButton_clone->setEnabled(f);

	if (!Git::isValidWorkingCopy(currentWorkingCopyDir())) {
	f = false;
	}

	ui->action_fetch->setEnabled(f);
	ui->action_pull->setEnabled(f);
	ui->action_push->setEnabled(f);

	ui->toolButton_fetch->setEnabled(f);
	ui->toolButton_pull->setEnabled(f);
	ui->toolButton_push->setEnabled(f);
	}

	void MainWindow::setRemoteOnline(bool f)
	{
	QRadioButton *rb = nullptr;
	rb = f ? ui->radioButton_remote_online : ui->radioButton_remote_offline;
	rb->blockSignals(true);
	rb->click();
	rb->blockSignals(false);

	setNetworkingCommandsEnabled(f);

	MySettings s;
	s.beginGroup("Remote");
	s.setValue("Online", f);
	s.endGroup();
	}

	void MainWindow::on_radioButton_remote_online_clicked()
	{
	setRemoteOnline(true);
	}

	void MainWindow::on_radioButton_remote_offline_clicked()
	{
	setRemoteOnline(false);
	}

	void MainWindow::on_verticalScrollBar_log_valueChanged(int)
	{
	ui->widget_log->refrectScrollBar();
	}

	void MainWindow::on_horizontalScrollBar_log_valueChanged(int)
	{
	ui->widget_log->refrectScrollBar();
	}

	void MainWindow::stopPtyProcess()
	{
	m->pty_process.stop();
	QDir::setCurrent(m->starting_dir);
	}

	void MainWindow::abortPtyProcess()
	{
	stopPtyProcess();
	m->pty_process_ok = false;
	m->interaction_canceled = true;
	}

	void MainWindow::on_toolButton_stop_process_clicked()
	{
	abortPtyProcess();
	}

	void MainWindow::on_action_stop_process_triggered()
	{
	abortPtyProcess();
	}

	void MainWindow::on_action_exit_triggered()
	{
	close();
	}

	void MainWindow::on_action_reflog_triggered()
	{
	GitPtr g = git();
	Git::ReflogItemList reflog;
	g->reflog(&reflog);

	ReflogWindow dlg(this, this, reflog);
	dlg.exec();
	}

	void MainWindow::blame(QListWidgetItem *item)
	{
	QList<BlameItem> list;
	QString path = getFilePath(item);
	{
	GitPtr g = git();
	QByteArray ba = g->blame(path);
	if (!ba.isEmpty()) {
	char const *begin = ba.data();
	char const *end = begin + ba.size();
	list = BlameWindow::parseBlame(begin, end);
	}
	}
	if (!list.isEmpty()) {
	qApp->setOverrideCursor(Qt::WaitCursor);
	BlameWindow win(this, path, list);
	qApp->restoreOverrideCursor();
	win.exec();
	}
	}

	void MainWindow::blame()
	{
	blame(currentFileItem());
	}

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

	void MainWindow::on_action_repository_property_triggered()
	{
	execRepositoryPropertyDialog(currentWorkingCopyDir());
	}

	void MainWindow::on_action_set_gpg_signing_triggered()
	{
	GitPtr g = git();
	QString global_key_id = g->signingKey(Git::Source::Global);
	QString repository_key_id;
	if (g->isValidWorkingCopy()) {
	repository_key_id = g->signingKey(Git::Source::Local);
	}
	SetGpgSigningDialog dlg(this, currentRepositoryName(), global_key_id, repository_key_id);
	if (dlg.exec() == QDialog::Accepted) {
	g->setSigningKey(dlg.id(), dlg.isGlobalChecked());
	}
	}

	void MainWindow::execAreYouSureYouWantToContinueConnectingDialog()
	{
	using TheDlg = AreYouSureYouWantToContinueConnectingDialog;

	m->interaction_mode = InteractionMode::Busy;

	QApplication::restoreOverrideCursor();

	TheDlg dlg(this);
	if (dlg.exec() == QDialog::Accepted) {
	TheDlg::Result r = dlg.result();
	if (r == TheDlg::Result::Yes) {
	m->pty_process.writeInput("yes\n", 4);
	} else {
	m->pty_process_ok = false; // abort
	m->pty_process.writeInput("no\n", 3);
	QThread::msleep(300);
	stopPtyProcess();
	}
	} else {
	ui->widget_log->setFocus();
	m->interaction_canceled = true;
	}
	m->interaction_mode = InteractionMode::Busy;
	}

	void MainWindow::onLogIdle()
	{
	if (m->interaction_canceled) return;
	if (m->interaction_mode != InteractionMode::None) return;

	static char const are_you_sure_you_want_to_continue_connecting[] = "Are you sure you want to continue connecting (yes/no)?";
	static char const enter_passphrase[] = "Enter passphrase: ";
	static char const enter_passphrase_for_key[] = "Enter passphrase for key '";
	static char const fatal_authentication_failed_for[] = "fatal: Authentication failed for '";

	std::vector<char> vec;
	ui->widget_log->retrieveLastText(&vec, 100);
	if (vec.size() > 0) {
	std::string line;
	int n = (int)vec.size();
	int i = n;
	while (i > 0) {
	i--;
	if (i + 1 < n && vec[i] == '\n') {
	i++;
	line.assign(&vec[i], n - i);
	break;
	}
	}
	if (!line.empty()) {
	auto ExecLineEditDialog = [&](QWidget *parent, QString const &title, QString const &prompt, QString const &val, bool password){
	LineEditDialog dlg(parent, title, prompt, val, password);
	if (dlg.exec() == QDialog::Accepted) {
	std::string ret = dlg.text().toStdString();
	std::string str = ret + '\n';
	m->pty_process.writeInput(str.c_str(), str.size());
	return ret;
	} else {
	abortPtyProcess();
	}
	return std::string();
	};

	auto Match = [&](char const *str){
	int n = strlen(str);
	if (strncmp(line.c_str(), str, n) == 0) {
	char const *p = line.c_str() + n;
	while (1) {
	if (!*p) return true;
	if (!isspace((unsigned char)*p)) break;
	p++;
	}
	}
	return false;
	};

	auto StartsWith = [&](char const *str){
	char const *p = line.c_str();
	while (*str) {
	if (p != str) return false;
	str++;
	p++;
	}
	return true;
	};

	if (Match(are_you_sure_you_want_to_continue_connecting)) {
	execAreYouSureYouWantToContinueConnectingDialog();
	return;
	}

	if (line == enter_passphrase) {
	ExecLineEditDialog(this, "Passphrase", QString::fromStdString(line), QString(), true);
	return;
	}

	if (StartsWith(enter_passphrase_for_key)) {
	std::string keyfile;
	{
	int i = strlen(enter_passphrase_for_key);
	char const *p = line.c_str() + i;
	char const *q = strrchr(p, ':');
	if (q && p + 2 < q && q[-1] == '\'') {
	keyfile.assign(p, q - 1);
	}
	}
	if (!keyfile.empty()) {
	if (keyfile == m->ssh_passphrase_for && !m->ssh_passphrase_secret.empty()) {
	std::string text = m->ssh_passphrase_secret + '\n';
	m->pty_process.writeInput(text.c_str(), text.size());
	} else {
	m->ssh_passphrase_for = keyfile;
	std::string s = ExecLineEditDialog(this, "Passphrase for key", QString::fromStdString(line), QString(), true);
	m->ssh_passphrase_secret = s;
	}
	return;
	}
	}

	char const *begin = line.c_str();
	char const *end = line.c_str() + line.size();
	auto Input = [&](QString const &title, bool password, std::string *value){
	std::string header = QString("%1 for '").arg(title).toStdString();
	if (strncmp(begin, header.c_str(), header.size()) == 0) {
	QString msg;
	if (memcmp(end - 2, "':", 2) == 0) {
	msg = QString::fromUtf8(begin, end - begin - 1);
	} else if (memcmp(end - 3, "': ", 3) == 0) {
	msg = QString::fromUtf8(begin, end - begin - 2);
	}
	if (!msg.isEmpty()) {
	std::string s = ExecLineEditDialog(this, title, msg, value ? QString::fromStdString(*value) : QString(), password);
	if (value) *value = s;
	return true;
	}
	}
	return false;
	};
	std::string uid = m->http_uid;
	std::string pwd = m->http_pwd;
	if (Input("Username", false, &uid)) {
	m->http_uid = uid;
	return;
	}
	if (Input("Password", true, &pwd)) {
	m->http_pwd = pwd;
	return;
	}

	if (StartsWith(fatal_authentication_failed_for)) {
	QMessageBox::critical(this, tr("Authentication Failed"), QString::fromStdString(line));
	abortPtyProcess();
	return;
	}
	}
	}
	}

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

	void MainWindow::on_action_edit_tags_triggered()
	{
	Git::CommitItem const *commit = selectedCommitItem();
	if (commit && Git::isValidID(commit->commit_id)) {
	EditTagsDialog dlg(this, commit);
	dlg.exec();
	}
	}

	void MainWindow::on_action_push_u_triggered()
	{
	pushSetUpstream(false);
	}

	QStringList MainWindow::remoteBranches(QString const &id)
	{
	QStringList list;

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

	return list;
	}

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

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

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

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

	void MainWindow::on_action_delete_remote_branch_triggered()
	{
	deleteRemoteBranch(selectedCommitItem());
	}

	void MainWindow::rebaseOnto()
	{
	struct Commit {
	QStringList parents;
	QStringList children;
	};

	std::map<QString, Commit> commit_map;

	Git::CommitItem const *commit = selectedCommitItem();
	if (commit) {
	for (Git::CommitItem const &item : m->logs) {
	Commit c;
	c.parents = item.parent_ids;
	commit_map[item.commit_id] = c;
	}
	for (Git::CommitItem const &item : m->logs) {
	for (QString const &parent : item.parent_ids) {
	auto it = commit_map.find(parent);
	if (it != commit_map.end()) {
	it->second.children.push_back(item.commit_id);
	}
	}
	}
	QString upstream;
	QString id = m->head_id;
	while (1) {
	auto it = commit_map.find(id);
	if (it == commit_map.end()) break;
	Commit const &c = it->second;
	if (c.parents.size() > 1) goto done;
	if (c.parents.size() != 1) break;
	if (id != m->head_id) {
	if (c.children.size() > 1) goto done;
	if (!findTag(id).isEmpty()) goto done;
	auto it2 = m->branch_map.find(id);
	if (it2 != m->branch_map.end()) {
	QList<Git::Branch> b = it2->second;
	if (!it2->second.empty()) goto done;
	}
	}
	id = c.parents.first();
	continue;
	done:;
	upstream = id;
	break;
	}

	QString newbase = commit->commit_id;
	QString branch = m->head_id;

	RebaseOntoDialog dlg(this);
	if (dlg.exec(newbase, upstream, branch) == QDialog::Accepted) {
	reopenRepository(true, [&](GitPtr g){
	m->pty_condition = PtyCondition::Pull;
	m->pty_process_ok = true;
	g->rebaseOnto(newbase, upstream, branch, &m->pty_process);
	while (1) {
	if (m->pty_process.wait(1)) break;
	QApplication::processEvents();
	}
	});
	}
	}
	}

	void MainWindow::on_action_rebase_onto_triggered()
	{
	rebaseOnto();
	}

	void MainWindow::checkRemoteUpdate()
	{
	if (m->pty_process.isRunning()) return;

	emit signalCheckRemoteUpdate();
	}

	void MainWindow::on_action_test_triggered()
	{
	}

	diff --git a/src/MainWindow.h b/src/MainWindow.h
	index 21029d3..692be79 100644
	--- a/src/MainWindow.h
	+++ b/src/MainWindow.h
	@@ -1,412 +1,412 @@
	#ifndef MAINWINDOW_H
	#define MAINWINDOW_H

	#include <QMainWindow>
	#include "Git.h"
	#include "RepositoryData.h"
	#include <memory>
	#include <functional>
	#include "GitHubAPI.h"
	#include "main.h"
	#include "TextEditorTheme.h"

	namespace Ui {
	class MainWindow;
	}

	class QScrollBar;

	class QListWidget;
	class QListWidgetItem;
	class QTreeWidgetItem;
	class QTableWidgetItem;
	class AboutDialog;

	class MySettings;

	class LocalSocketReader;

	class CommitList;
	class WebContext;

	#define PATH_PREFIX "*"


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

	class MainWindow : public QMainWindow {
	Q_OBJECT
	friend class ImageViewWidget;
	friend class FileDiffSliderWidget;
	friend class FileHistoryWindow;
	friend class FileDiffWidget;
	friend class AboutDialog;
	public:
	struct Label {
	enum {
	Head,
	LocalBranch,
	RemoteBranch,
	Tag,
	};
	int kind;
	QString text;
	Label(int kind = LocalBranch)
	: kind(kind)
	{

	}
	};
	private:
	struct Private;
	Private *m;
	public:
	explicit MainWindow(QWidget *parent = 0);
	~MainWindow();

	QPixmap const &digitsPixmap() const;

	QString currentWorkingCopyDir() const;

	static QString makeRepositoryName(QString const &loc);
	const Git::CommitItemList *logs() const;
	QColor color(unsigned int i);
	private:
	Ui::MainWindow *ui;

	enum class FilesListType {
	SingleList,
	SideBySide,
	};

	- void addDiffItems(const QList<Git::Diff> *diff_list, std::function<void (const QString &, QString, int)> AddItem_);
	+ void addDiffItems(const QList<Git::Diff> *diff_list, std::function<void (const QString &, QString, int)> const &AddItem_);
	void updateFilesList(QString id, bool wait);
	void updateFilesList(const Git::CommitItem &commit, bool wait);
	void updateRepositoriesList();
	QString getBookmarksFilePath() const;
	bool saveRepositoryBookmarks() const;

	void openRepository_(GitPtr g);
	void openRepository(bool validate, bool waitcursor = true);
	void reopenRepository(bool log, std::function<void(GitPtr)> callback);

	void openSelectedRepository();
	bool askAreYouSureYouWantToRun(const QString &title, const QString &command);
	void resetFile(const QStringList &path);
	void revertAllFiles();
	void prepareLogTableWidget();
	QStringList selectedFiles_(QListWidget *listwidget) const;
	QStringList selectedFiles() const;
	void for_each_selected_files(std::function<void (const QString &)> fn);
	bool editFile(const QString &path, const QString &title);
	void updateCommitGraph();
	void showFileList(FilesListType files_list_type);

	bool checkGitCommand();
	bool checkFileCommand();
	void checkUser();

	void clearLog();
	void clearFileList();
	void clearDiffView();
	void clearRepositoryInfo();

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

	bool makeDiff(QString id, QList<Git::Diff> *out);

	void commit(bool amend = false);
	void commit_amend();
	void queryBranches(GitPtr g);
	void updateRemoteInfo();
	QList<Git::Branch> findBranch(const QString &id);
	QList<Git::Tag> findTag(const QString &id);
	int selectedLogIndex() const;
	const Git::CommitItem *selectedCommitItem() const;
	void deleteTags(const Git::CommitItem &commit);
	QTreeWidgetItem *newQTreeWidgetFolderItem(const QString &name);
	void buildRepoTree(const QString &group, QTreeWidgetItem item, QList<RepositoryItem> repos);
	void refrectRepositories();

	bool saveByteArrayAs(const QByteArray &ba, const QString &dstpath);
	bool saveFileAs(const QString &srcpath, const QString &dstpath);
	bool saveBlobAs(const QString &id, const QString &dstpath);
	QString selectCommand_(const QString &cmdname, const QStringList &cmdfile, const QStringList &list, QString path, std::function<void (const QString &)> callback);
	QString selectCommand_(const QString &cmdname, const QString &cmdfile, const QStringList &list, QString path, std::function<void(const QString &)> callback);
	void updateDiffView(QListWidgetItem *item);
	void updateDiffView();
	void updateUnstagedFileCurrentItem();
	void updateStagedFileCurrentItem();
	// void addTag();
	QStringList whichCommand_(const QString &cmdfile1, const QString &cmdfile2 = QString());
	QString getObjectID(QListWidgetItem *item);
	QString determinFileType_(const QString &path, bool mime, std::function<void(QString const &cmd, QByteArray *ba)> callback) const;
	Git::Object cat_file_(GitPtr g, const QString &id);
	Git::Object cat_file(const QString &id);
	void updateStatusBarText();
	void setUnknownRepositoryInfo();
	void setWindowTitle_(const Git::User &user);
	void setRepositoryInfo(const QString &reponame, const QString &brname);
	void updateWindowTitle(GitPtr g);
	void logGitVersion();
	static bool git_callback(void cookie, const char ptr, int len);
	int indexOfRepository(const QTreeWidgetItem *treeitem) const;
	void removeRepositoryFromBookmark(int index, bool ask);

	enum NamedCommitFlag {
	Branches = 0x0001,
	Tags = 0x0002,
	Remotes = 0x0100,
	};
	NamedCommitList namedCommitItems(int flags);

	void deleteBranch(const Git::CommitItem *commit);
	void checkout();
	void clone();
	void deleteBranch();
	Git::CommitItemList retrieveCommitLog(GitPtr g);
	bool runOnRepositoryDir(std::function<void(QString)> callback, const RepositoryItem *repo);
	void openTerminal(const RepositoryItem *repo);
	void openExplorer(const RepositoryItem *repo);
	void pushSetUpstream(const QString &remote, const QString &branch);
	bool pushSetUpstream(bool testonly);
	void clearRepoFilter();
	void appendCharToRepoFilter(ushort c);
	void backspaceRepoFilter();
	void revertCommit();
	int rowFromCommitId(const QString &id);
	void cherrypick(const Git::CommitItem *commit);
	void mergeBranch(const Git::CommitItem *commit);
	void rebaseBranch(const Git::CommitItem *commit);
	void detectGitServerType(GitPtr g);
	void initNetworking();
	void setRemoteOnline(bool f);
	bool isRemoteOnline() const;
	void startTimers();
	void onCloneCompleted(bool success);
	bool fetch(GitPtr g);
	void stopPtyProcess();
	void abortPtyProcess();
	void setNetworkingCommandsEnabled(bool f);
	void execSetUserDialog(const Git::User &global_user, const Git::User &repo_user, const QString &reponame);
	bool execSetGlobalUserDialog();
	void blame(QListWidgetItem *item);
	void blame();
	QListWidgetItem *currentFileItem() const;
	const RepositoryItem findRegisteredRepository(QString workdir) const;
	void execAreYouSureYouWantToContinueConnectingDialog();
	void queryRemotes(GitPtr g);
	void internalSetCommand(const QString &path, bool save, const QString &name, QString *out);
	void deleteRemoteBranch(const Git::CommitItem *commit);
	QStringList remoteBranches(const QString &id);
	void rebaseOnto();
	void createRepository(const QString &dir);
	void checkRemoteUpdate();
	void setWatchRemoteInterval(int mins);
	void emitWriteLog(QByteArray ba);
	protected:
	void dragEnterEvent(QDragEnterEvent *event);
	void timerEvent(QTimerEvent *);
	void keyPressEvent(QKeyEvent *event);
	bool event(QEvent *event);
	bool eventFilter(QObject watched, QEvent event);
	public:

	QString selectGitCommand(bool save);
	QString selectFileCommand(bool save);
	QString selectGpgCommand(bool save);

	int limitLogCount() const;

	void setGitCommand(const QString &path, bool save);
	void setFileCommand(const QString &path, bool save);
	void setGpgCommand(const QString &path, bool save);
	void clearAuthentication();
	void setCurrentRepository(const RepositoryItem &repo, bool clear_authentication);
	bool isThereUncommitedChanges() const;
	QString defaultWorkingDir() const;
	void autoOpenRepository(QString dir);
	void saveRepositoryBookmark(RepositoryItem item);
	void drawDigit(QPainter *pr, int x, int y, int n) const;
	int digitWidth() const;
	int digitHeight() const;
	bool isValidWorkingCopy(const GitPtr &g) const;
	QString tempfileHeader() const;
	void deleteTempFiles();
	QString newTempFilePath();
	bool saveAs(const QString &id, const QString &dstpath);
	QString saveAsTemp(const QString &id);
	QString abbrevCommitID(const Git::CommitItem &commit);
	QString findFileID(GitPtr g, const QString &commit_id, const QString &file);
	QString determinFileType(const QString &path, bool mime);
	QString determinFileType(QByteArray in, bool mime);
	QPixmap getTransparentPixmap();
	QString getCommitIdFromTag(const QString &tag);
	void setStatusBarText(const QString &text);
	void clearStatusBarText();
	QString makeCommitInfoText(int row, QList<Label> *label_list);
	void setLogEnabled(GitPtr g, bool f);
	void addWorkingCopyDir(QString dir, QString name, bool open);
	void addWorkingCopyDir(QString dir, bool open)
	{
	addWorkingCopyDir(dir, QString(), open);
	}
	bool isValidRemoteURL(QString const &url);
	bool testRemoteRepositoryValidity(const QString &url);
	void removeSelectedRepositoryFromBookmark(bool ask);
	void setCurrentLogRow(int row);
	GitPtr git(const QString &dir) const;
	GitPtr git();
	const QList<Label> *label(int row);
	bool isGitHub() const;
	QIcon committerIcon(int row) const;
	void updateCommitTableLater();
	bool isAvatarEnabled() const;
	WebContext *getWebContextPtr();
	bool shown();
	void execFileHistory(QListWidgetItem *item);
	void execFileHistory(const QString &path);
	void execCommitExploreWindow(QWidget parent, const Git::CommitItem commit);
	void execCommitPropertyDialog(QWidget parent, const Git::CommitItem commit);
	void checkout(QWidget parent, const Git::CommitItem commit);
	TextEditorThemePtr themeForTextEditor();
	bool queryCommit(const QString &id, Git::CommitItem *out);
	void jumpToCommit(QString id);
	WebContext *webContext();
	bool execWelcomeWizardDialog();
	void updateFilesList(QString id, QList<Git::Diff> diff_list, QListWidget listwidget);
	void execCommitViewWindow(const Git::CommitItem *commit);
	QAction addMenuActionProperty(QMenu menu);
	void execFilePropertyDialog(QListWidgetItem *item);
	void execRepositoryPropertyDialog(QString workdir, bool open_repository_menu = false);
	QStringList remotes() const;
	QIcon verifiedIcon(char s) const;
	ApplicationSettings *appsettings();
	const ApplicationSettings *appsettings() const;
	const Git::CommitItem *commitItem(int row) const;
	bool checkExecutable(const QString &path);
	void deleteTags(const QStringList &tagnames);
	QList<Git::Tag> queryTagList();
	bool addTag(const QString &name);
	void updateCurrentFilesList();
	void setRemoteChanged(bool f);
	QString currentRepositoryName() const;
	QString currentRemoteName() const;
	Git::Branch const &currentBranch() const;
	QString currentBranchName() const;
	public slots:
	void writeLog(const char *ptr, int len);
	void writeLog(const QString &str);
	void writeLog(QByteArray ba);
	private slots:
	void on_action_clone_triggered();
	void on_action_commit_triggered();
	void on_action_edit_git_config_triggered();
	void on_action_edit_gitignore_triggered();
	void on_action_edit_global_gitconfig_triggered();
	void on_action_edit_settings_triggered();
	void on_action_fetch_triggered();
	void on_action_open_existing_working_copy_triggered();
	void on_action_pull_triggered();
	void on_action_push_triggered();
	void on_action_test_triggered();
	void on_action_view_refresh_triggered();
	void on_action_tag_push_all_triggered();

	void on_treeWidget_repos_currentItemChanged(QTreeWidgetItem current, QTreeWidgetItem previous);
	void on_treeWidget_repos_itemDoubleClicked(QTreeWidgetItem *item, int column);

	void on_tableWidget_log_currentItemChanged(QTableWidgetItem current, QTableWidgetItem previous);

	void on_treeWidget_repos_customContextMenuRequested(const QPoint &pos);
	void on_tableWidget_log_customContextMenuRequested(const QPoint &pos);
	void on_listWidget_files_customContextMenuRequested(const QPoint &pos);
	void on_listWidget_unstaged_customContextMenuRequested(const QPoint &pos);
	void on_listWidget_staged_customContextMenuRequested(const QPoint &pos);

	void on_listWidget_unstaged_currentRowChanged(int currentRow);
	void on_listWidget_staged_currentRowChanged(int currentRow);
	void on_listWidget_files_currentRowChanged(int currentRow);

	void on_toolButton_commit_clicked();
	void on_toolButton_pull_clicked();
	void on_toolButton_push_clicked();
	void on_toolButton_select_all_clicked();
	void on_toolButton_stage_clicked();
	void on_toolButton_unstage_clicked();
	void on_action_about_triggered();
	void on_toolButton_clone_clicked();
	void on_toolButton_fetch_clicked();

	void on_lineEdit_filter_textChanged(const QString &text);
	void on_toolButton_erase_filter_clicked();

	void on_tableWidget_log_itemDoubleClicked(QTableWidgetItem *);
	void on_listWidget_unstaged_itemDoubleClicked(QListWidgetItem *item);
	void on_listWidget_staged_itemDoubleClicked(QListWidgetItem *item);
	void on_listWidget_files_itemDoubleClicked(QListWidgetItem *item);

	void onRepositoriesTreeDropped();
	void on_action_set_config_user_triggered();

	void on_action_window_log_triggered(bool checked);

	void onLogVisibilityChanged();

	void on_action_repo_jump_triggered();
	void on_action_repo_checkout_triggered();
	void on_action_delete_branch_triggered();

	void on_toolButton_terminal_clicked();
	void on_toolButton_explorer_clicked();

	void on_action_reset_HEAD_1_triggered();

	void on_action_create_a_repository_triggered();

	void onAvatarUpdated();
	void on_radioButton_remote_online_clicked();

	void on_radioButton_remote_offline_clicked();
	void on_verticalScrollBar_log_valueChanged(int);
	void on_horizontalScrollBar_log_valueChanged(int);

	void onPtyProcessCompleted();
	void on_toolButton_stop_process_clicked();

	void on_action_stop_process_triggered();

	void on_action_exit_triggered();

	void on_action_reflog_triggered();


	void on_action_repository_property_triggered();
	void on_action_set_gpg_signing_triggered();
	void on_action_edit_tags_triggered();

	void on_action_push_u_triggered();

	void on_action_delete_remote_branch_triggered();

	void on_action_rebase_onto_triggered();

	void doUpdateButton();
	signals:
	void onEscapeKeyPressed();
	void signalCheckRemoteUpdate();
	void updateButton();
	void signalWriteLog(QByteArray ba);
	protected:
	void closeEvent(QCloseEvent *event);
	protected slots:
	void onLogIdle();
	};

	#endif // MAINWINDOW_H
	diff --git a/src/MyImageViewWidget.h b/src/MyImageViewWidget.h
	index a7cc7b6..188a227 100644
	--- a/src/MyImageViewWidget.h
	+++ b/src/MyImageViewWidget.h
	@@ -1,25 +1,23 @@
	#ifndef MYIMAGEVIEWWIDGET_H
	#define MYIMAGEVIEWWIDGET_H

	#include "ImageViewWidget.h"

	// used from FileViewWidget.h

	// ImageViewWidgetクラスは、他のアプリで再利用する想定の設計。
	// MyImageViewWidgetクラスは、Guitar専用にカスタマイズを行っている。

	class MyImageViewWidget : public ImageViewWidget {
	private:
	QString object_id_;
	QString path_;
	protected:
	- void contextMenuEvent(QContextMenuEvent *e);
	+ void contextMenuEvent(QContextMenuEvent *e) override;
	public:
	- MyImageViewWidget(QWidget *parent = 0);
	+ MyImageViewWidget(QWidget *parent = nullptr);

	void setImage(QString mimetype, QByteArray const &ba, QString const &object_id_, QString const &path_);
	-
	-
	};

	#endif // MYIMAGEVIEWWIDGET_H
	diff --git a/src/common/joinpath.cpp b/src/common/joinpath.cpp
	index e4b5cc5..9a91e0f 100644
	--- a/src/common/joinpath.cpp
	+++ b/src/common/joinpath.cpp
	@@ -1,67 +1,67 @@
	#include "common/joinpath.h"
	#include <sstream>
	#include <vector>
	-#include <string.h>
	+#include <cstring>

	#ifdef WIN32
	#pragma warning(disable:4996)
	#endif

	template <typename T> static inline void trimquot(T const begin, T const end)
	{
	if (begin + 1 < end && (begin)[0] == '"' && (end)[-1] == '"') {
	(*begin)++;
	(*end)--;
	}
	}

	template <typename T, typename U> void joinpath_(T const left, T const right, U *vec)
	{
	size_t llen = 0;
	size_t rlen = 0;
	if (left) {
	T const *leftend = left + std::char_traits<T>::length(left);
	trimquot(&left, &leftend);
	while (left < leftend && (leftend[-1] == '/' \|\| leftend[-1] == '\\')) {
	leftend--;
	}
	llen = leftend - left;
	}
	if (right) {
	T const *rightend = right + std::char_traits<T>::length(right);
	trimquot(&right, &rightend);
	while (right < rightend && (right[0] == '/' \|\| right[0] == '\\')) {
	right++;
	}
	rlen = rightend - right;
	}
	vec->resize(llen + 1 + rlen);
	if (llen > 0) {
	std::char_traits<T>::copy(&vec->at(0), left, llen);
	}
	vec->at(llen) = '/';
	if (rlen > 0) {
	std::char_traits<T>::copy(&vec->at(llen + 1), right, rlen);
	}
	}

	std::string joinpath(char const left, char const right)
	{
	std::vector<char> vec;
	joinpath_(left, right, &vec);
	return std::string(vec.begin(), vec.end());
	}

	std::string joinpath(std::string const &left, std::string const &right)
	{
	return joinpath(left.c_str(), right.c_str());
	}

	QString qjoinpath(ushort const left, ushort const right)
	{
	std::vector<ushort> vec;
	joinpath_(left, right, &vec);
	if (vec.empty()) return QString();
	return QString::fromUtf16(&vec[0], vec.size());
	}

	diff --git a/src/common/misc.cpp b/src/common/misc.cpp
	index c419815..29540fe 100644
	--- a/src/common/misc.cpp
	+++ b/src/common/misc.cpp
	@@ -1,463 +1,463 @@
	#include "common/misc.h"
	#include <QDebug>
	#include <QFileInfo>
	#include <QPainter>
	#include <QProcess>
	#include <QWidget>
	#include <QContextMenuEvent>
	#include <vector>
	#include "common/joinpath.h"
	#include "misc.h"

	QString misc::getApplicationDir()
	{
	QString path = QApplication::applicationFilePath();
	int i = path.lastIndexOf('\\');
	int j = path.lastIndexOf('/');
	if (i < j) i = j;
	if (i > 0) path = path.mid(0, i);
	return path;
	}

	-QStringList misc::splitLines(QByteArray const &ba, std::function<QString(char const *ptr, size_t len)> tos)
	+QStringList misc::splitLines(QByteArray const &ba, std::function<QString(char const *ptr, size_t len)> const &tos)
	{
	QStringList list;
	char const *begin = ba.data();
	char const *end = begin + ba.size();
	char const *ptr = begin;
	char const *left = ptr;
	while (1) {
	ushort c = 0;
	if (ptr < end) {
	c = *ptr;
	}
	if (c == '\n' \|\| c == '\r' \|\| c == 0) {
	list.push_back(tos(left, ptr - left));
	if (c == 0) break;
	if (c == '\n') {
	ptr++;
	} else if (c == '\r') {
	ptr++;
	if (ptr < end && *ptr == '\n') {
	ptr++;
	}
	}
	left = ptr;
	} else {
	ptr++;
	}
	}
	return list;
	}

	QStringList misc::splitLines(const QString &text)
	{
	QStringList list;
	ushort const *begin = text.utf16();
	ushort const *end = begin + text.size();
	ushort const *ptr = begin;
	ushort const *left = ptr;
	while (1) {
	ushort c = 0;
	if (ptr < end) {
	c = *ptr;
	}
	if (c == '\n' \|\| c == '\r' \|\| c == 0) {
	list.push_back(QString::fromUtf16(left, ptr - left));
	if (c == 0) break;
	if (c == '\n') {
	ptr++;
	} else if (c == '\r') {
	ptr++;
	if (ptr < end && *ptr == '\n') {
	ptr++;
	}
	}
	left = ptr;
	} else {
	ptr++;
	}
	}
	return list;
	}

	void misc::splitLines(char const begin, char const end, std::vector<std::string> *out, bool keep_newline)
	{
	char const *ptr = begin;
	char const *left = ptr;
	while (1) {
	char c = 0;
	if (ptr < end) {
	c = *ptr;
	}
	if (c == '\n' \|\| c == '\r' \|\| c == 0) {
	char const *right = ptr;
	if (c == '\n') {
	ptr++;
	} else if (c == '\r') {
	ptr++;
	if (ptr < end && *ptr == '\n') {
	ptr++;
	}
	}
	if (keep_newline) {
	right = ptr;
	}
	out->push_back(std::string(left, right - left));
	if (c == 0) break;
	left = ptr;
	} else {
	ptr++;
	}
	}
	}

	void misc::splitLines(std::string const &text, std::vector<std::string> *out, bool need_crlf)
	{
	char const *begin = text.c_str();
	char const *end = begin + text.size();
	splitLines(begin, end, out, need_crlf);
	}

	QStringList misc::splitWords(const QString &text)
	{
	QStringList list;
	ushort const *begin = text.utf16();
	ushort const *end = begin + text.size();
	ushort const *ptr = begin;
	ushort const *left = ptr;
	while (1) {
	ushort c = 0;
	if (ptr < end) {
	c = *ptr;
	}
	if (QChar::isSpace(c) \|\| c == 0) {
	if (left < ptr) {
	list.push_back(QString::fromUtf16(left, ptr - left));
	}
	if (c == 0) break;
	ptr++;
	left = ptr;
	} else {
	ptr++;
	}
	}
	return list;
	}

	QString misc::getFileName(QString const &path)
	{
	int i = path.lastIndexOf('/');
	int j = path.lastIndexOf('\\');
	if (i < j) i = j;
	if (i >= 0) {
	return path.mid(i + 1);
	}
	return path;
	}

	QString misc::makeDateTimeString(QDateTime const &dt)
	{
	if (dt.isValid()) {
	#if 0
	char tmp[100];
	sprintf(tmp, "%04u-%02u-%02u %02u:%02u:%02u"
	, dt.date().year()
	, dt.date().month()
	, dt.date().day()
	, dt.time().hour()
	, dt.time().minute()
	, dt.time().second()
	);
	return tmp;
	#elif 0
	QString s = dt.toLocalTime().toString(Qt::DefaultLocaleShortDate);
	return s;
	#else
	QString s = dt.toLocalTime().toString(Qt::ISODate);
	s.replace('T', ' ');
	return s;
	#endif
	}
	return QString();
	}

	bool misc::starts_with(const std::string &str, const std::string &with)
	{
	return strncmp(str.c_str(), with.c_str(), with.size()) == 0;
	}

	std::string misc::mid(const std::string &str, int start, int length)
	{
	int size = (int)str.size();
	if (length < 0) length = size;

	length += start;
	if (start < 0) start = 0;
	if (length < 0) length = 0;
	if (start > size) start = size;
	if (length > size) length = size;
	length -= start;

	return std::string(str.c_str() + start, length);
	}

	#ifdef _WIN32
	QString misc::normalizePathSeparator(QString const &str)
	{
	if (!str.isEmpty()) {
	ushort const *s = str.utf16();
	size_t n = str.size();
	std::vector<ushort> v;
	v.reserve(n);
	for (size_t i = 0; i < n; i++) {
	ushort c = s[i];
	if (c == '/') {
	c = '\\';
	}
	v.push_back(c);
	}
	ushort const *p = &v[0];
	return QString::fromUtf16(p, n);
	}
	return QString();
	}
	#else
	QString misc::normalizePathSeparator(QString const &s)
	{
	return s;
	}
	#endif

	QString misc::joinWithSlash(QString const &left, QString const &right)
	{
	if (!left.isEmpty() && !right.isEmpty()) {
	return joinpath(left, right);
	}
	return !left.isEmpty() ? left : right;
	}

	void misc::setFixedSize(QWidget *w)
	{
	Qt::WindowFlags flags = w->windowFlags();
	flags &= ~Qt::WindowContextHelpButtonHint;
	flags \|= Qt::MSWindowsFixedSizeDialogHint;
	w->setWindowFlags(flags);
	w->setFixedSize(w->size());
	}

	void misc::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 misc::dump(uint8_t const *ptr, size_t len)
	{
	if (ptr && len > 0) {
	size_t pos = 0;
	while (pos < len) {
	char tmp[100];
	char *dst = tmp;
	sprintf(dst, "%08llX ", ((unsigned long long)(pos)));
	dst += 9;
	for (int i = 0; i < 16; i++) {
	if (pos + i < len) {
	sprintf(dst, "%02X ", ptr[pos + i] & 0xff);
	} else {
	sprintf(dst, " ");
	}
	dst += 3;
	}
	for (int i = 0; i < 16; i++) {
	int c = ' ';
	if (pos < len) {
	c = ptr[pos] & 0xff;
	if (!isprint(c)) {
	c = '.';
	}
	pos++;
	}
	*dst = c;
	dst++;
	}
	*dst = 0;
	qDebug() << tmp;
	}
	}
	}

	void misc::dump(const QByteArray *in)
	{
	size_t len = 0;
	uint8_t const *ptr = nullptr;
	if (in) {
	len = in->size();
	if (len > 0) {
	ptr = (uint8_t const *)in->data();
	}
	}
	dump(ptr, len);
	}

	bool misc::isText(const QString &mimetype)
	{
	return mimetype.startsWith("text/");
	}

	bool misc::isSVG(const QString &mimetype)
	{
	if (mimetype == "image/svg") return true;
	if (mimetype == "image/svg+xml") return true;
	return false;
	}

	bool misc::isPSD(const QString &mimetype)
	{
	if (mimetype == "image/vnd.adobe.photoshop") return true;
	return false;
	}

	bool misc::isImage(const QString &mimetype)
	{
	#if 0
	if (mimetype == "image/jpeg") return true;
	if (mimetype == "image/jpg") return true;
	if (mimetype == "image/png") return true;
	if (mimetype == "image/gif") return true;
	if (mimetype == "image/bmp") return true;
	if (mimetype == "image/x-ms-bmp") return true;
	if (mimetype == "image/x-icon") return true;
	if (mimetype == "image/tiff") return true;
	if (isSVG(mimetype)) return true;
	if (isPSD(mimetype)) return true;
	return false;
	#else
	return mimetype.startsWith("image/");
	#endif
	}

	QString misc::abbrevBranchName(QString const &name)
	{
	QStringList sl = name.split('/');
	if (sl.size() == 1) return sl[0];
	QString newname;
	for (int i = 0; i < sl.size(); i++) {
	QString s = sl[i];
	if (i + 1 < sl.size()) {
	s = s.mid(0, 1);
	}
	if (i > 0) {
	newname += '/';
	}
	newname += s;
	}
	return newname;
	}

	-QString misc::determinFileType(const QString &filecommand, const QString &path, bool mime, std::function<void (const QString &, QByteArray *)> callback)
	+QString misc::determinFileType(const QString &filecommand, const QString &path, bool mime, std::function<void (const QString &, QByteArray *)> const &callback)
	{ // ファイルタイプを調べる
	if (QFileInfo(filecommand).isExecutable()) {
	- QString file = filecommand;
	+ QString const &file = filecommand;
	QString mgc;
	#ifdef Q_OS_WIN
	int i = file.lastIndexOf('/');
	int j = file.lastIndexOf('\\');
	if (i < j) i = j;
	if (i >= 0) {
	mgc = file.mid(0, i + 1) + "magic.mgc";
	if (QFileInfo(mgc).isReadable()) {
	// ok
	} else {
	mgc = QString();
	}
	}
	#endif
	QString cmd;
	if (mgc.isEmpty()) {
	cmd = "\"%1\"";
	cmd = cmd.arg(file);
	} else {
	cmd = "\"%1\" -m \"%2\"";
	cmd = cmd.arg(file).arg(mgc);
	cmd = cmd.replace('\\', '/');
	}
	if (mime) {
	cmd += " --mime";
	}
	cmd += " --brief ";
	if (path == "-") {
	cmd += path;
	} else {
	cmd += QString("\"%1\"").arg(path);
	}
	cmd = misc::normalizePathSeparator(cmd);

	// run file command

	QByteArray ba;

	callback(cmd, &ba);

	// parse file type

	if (!ba.isEmpty()) {
	QString s = QString::fromUtf8(ba).trimmed();
	QStringList list = s.split(';', QString::SkipEmptyParts);
	if (!list.isEmpty()) {
	QString mimetype = list[0].trimmed();
	return mimetype;
	}
	}

	} else {
	qDebug() << "No executable 'file' command";
	}
	return QString();
	}

	std::string misc::makeProxyServerURL(std::string text)
	{
	if (!text.empty() && !strstr(text.c_str(), "://")) {
	text = "http://" + text;
	if (text[text.size() - 1] != '/') {
	text += '/';
	}
	}
	return text;
	}

	QString misc::makeProxyServerURL(QString text)
	{
	if (!text.isEmpty() && text.indexOf("://") < 0) {
	text = "http://" + text;
	if (text[text.size() - 1] != '/') {
	text += '/';
	}
	}
	return text;
	}

	QPoint misc::contextMenuPos(QWidget w, QContextMenuEvent e)
	{
	if (e && e->reason() == QContextMenuEvent::Mouse) {
	return QCursor::pos() + QPoint(8, -8);
	}
	return w->mapToGlobal(QPoint(4, 4));
	}

	bool misc::isExecutable(const QString &cmd)
	{
	QFileInfo info(cmd);
	return info.isExecutable();
	}
	diff --git a/src/common/misc.h b/src/common/misc.h
	index 00196c5..d8ad3b6 100644
	--- a/src/common/misc.h
	+++ b/src/common/misc.h
	@@ -1,57 +1,57 @@
	#ifndef MISC_H
	#define MISC_H

	#include <QApplication>
	#include <QStringList>
	#include <QDateTime>
	#include <functional>
	#include <vector>
	-#include <stdint.h>
	+#include <cstdint>
	#include <QColor>

	class QContextMenuEvent;

	class misc {
	public:
	static QString getApplicationDir();
	- static QStringList splitLines(const QByteArray &text, std::function<QString(char const *ptr, size_t len)> tos);
	+ static QStringList splitLines(const QByteArray &text, std::function<QString(char const *ptr, size_t len)> const &tos);
	static QStringList splitLines(QString const &text);
	static void splitLines(const char begin, const char end, std::vector<std::string> *out, bool keep_newline);
	static void splitLines(const std::string &text, std::vector<std::string> *out, bool need_crlf);
	static QStringList splitWords(const QString &text);
	static QString getFileName(const QString &path);
	static QString makeDateTimeString(const QDateTime &dt);
	static bool starts_with(std::string const &str, std::string const &with);
	static std::string mid(std::string const &str, int start, int length = -1);
	static QString normalizePathSeparator(const QString &str);
	static QString joinWithSlash(const QString &left, const QString &right);
	static void setFixedSize(QWidget *w);
	static void drawFrame(QPainter *pr, int x, int y, int w, int h, QColor color_topleft, QColor color_bottomright = QColor());
	static void dump(const uint8_t *ptr, size_t len);
	static void dump(QByteArray const *in);
	static bool isText(const QString &mimetype);
	static bool isImage(const QString &mimetype);
	static bool isSVG(const QString &mimetype);
	static bool isPSD(const QString &mimetype);
	static QString abbrevBranchName(const QString &name);
	- static QString determinFileType(const QString &filecommand, const QString &path, bool mime, std::function<void (const QString &, QByteArray *)> callback);
	+ static QString determinFileType(const QString &filecommand, const QString &path, bool mime, std::function<void(const QString &, QByteArray *)> const &callback);
	static std::string makeProxyServerURL(std::string text);
	static QString makeProxyServerURL(QString text);
	static QPoint contextMenuPos(QWidget w, QContextMenuEvent e);
	static bool isExecutable(QString const &cmd);
	};

	class OverrideWaitCursor_ {
	public:
	OverrideWaitCursor_()
	{
	qApp->setOverrideCursor(Qt::WaitCursor);
	}
	~OverrideWaitCursor_()
	{
	qApp->restoreOverrideCursor();
	}
	};
	#define OverrideWaitCursor OverrideWaitCursor_ waitcursor_; (void)waitcursor_;

	#endif // MISC_H
	diff --git a/src/texteditor/AbstractCharacterBasedApplication.cpp b/src/texteditor/AbstractCharacterBasedApplication.cpp
	index c12c671..631a3bf 100644
	--- a/src/texteditor/AbstractCharacterBasedApplication.cpp
	+++ b/src/texteditor/AbstractCharacterBasedApplication.cpp
	@@ -1,2579 +1,2584 @@
	+#include <memory>
	+
	+#include <memory>
	+
	+
	#include "AbstractCharacterBasedApplication.h"
	#include "UnicodeWidth.h"
	#include "unicode.h"

	#include <QApplication>
	#include <QClipboard>
	#include <QDebug>
	#include <QFile>
	#include <QTextCodec>
	-#include "unicode.h"
	+#include <memory>

	using WriteMode = AbstractCharacterBasedApplication::WriteMode;
	using FormattedLine = AbstractCharacterBasedApplication::FormattedLine;

	class EsccapeSequence {
	private:
	int offset = 0;
	unsigned char data[100];
	int color_fg = -1;
	int color_bg = -1;
	public:
	bool isActive() const
	{
	return offset > 0;
	}
	void write(char c)
	{
	if (c == 0x1b) {
	data[0] = c;
	offset = 1;
	return;
	}
	data[offset] = c;
	if (offset > 0) {
	if (c == 'm') {
	if (data[1] == '[' && isdigit(data[2]) && isdigit(data[3])) {
	data[offset] = 0;
	if (data[2] == '3') {
	color_fg = atoi((char const *)data + 3);
	if (color_fg == 9) {
	color_fg = -1;
	}
	}
	if (data[2] == '4') {
	color_bg = atoi((char const *)data + 3);
	if (color_bg == 9) {
	color_bg = -1;
	}
	}
	}
	offset = 0;
	return;
	}
	if (offset + 1 < (int)sizeof(data)) {
	offset++;
	}
	}
	}
	int fg_color_code() const
	{
	return color_fg == 9 ? -1 : color_fg;
	}
	int bg_color_code() const
	{
	return color_bg == 9 ? -1 : color_bg;
	}
	};

	struct AbstractCharacterBasedApplication::Private {
	bool is_changed = false;
	bool is_quit_enabled = false;
	bool is_open_enabled = false;
	bool is_save_enabled = false;
	bool is_toggle_selection_anchor_enabled = true;
	bool is_read_only = false;
	bool is_terminal_mode = false;
	bool is_cursor_visible = true;
	State state = State::Normal;
	int header_line = 1;
	int footer_line = 1;
	int screen_width = 80;
	int screen_height = 24;
	bool auto_layout = false;
	QString recently_used_path;
	bool show_line_number = true;
	int left_margin = AbstractCharacterBasedApplication::LEFT_MARGIN;
	QString dialog_title;
	QString dialog_value;
	std::vector<Character> screen;
	std::vector<uint8_t> line_flags;
	int parsed_row_index = -1;
	int parsed_col_index = -1;
	bool parsed_for_edit = false;
	QByteArray parsed_line;
	std::vector<uint32_t> prepared_current_line;
	QList<Document::CharAttr_> syntax_table;
	bool dialog_mode = false;
	DialogHandler dialog_handler;
	bool is_painting_suppressed = false;
	int valid_line_index = -1;
	int line_margin = 3;
	WriteMode write_mode = WriteMode::Insert;
	QTextCodec *text_codec = nullptr;
	Qt::KeyboardModifiers keyboard_modifiers = Qt::KeyboardModifier::NoModifier;
	bool ctrl_modifier = false;
	bool shift_modifier = false;
	EsccapeSequence escape_sequence;

	bool cursor_moved_by_mouse = false;
	};

	AbstractCharacterBasedApplication::AbstractCharacterBasedApplication()
	: m(new Private)
	{
	}

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

	void AbstractCharacterBasedApplication::setModifierKeys(Qt::KeyboardModifiers keymod)
	{
	m->keyboard_modifiers = keymod;
	m->ctrl_modifier = m->keyboard_modifiers & Qt::ControlModifier;
	m->shift_modifier = m->keyboard_modifiers & Qt::ShiftModifier;
	}

	void AbstractCharacterBasedApplication::clearShiftModifier()
	{
	m->shift_modifier = false;
	}

	bool AbstractCharacterBasedApplication::isControlModifierPressed() const
	{
	return m->ctrl_modifier;
	}

	bool AbstractCharacterBasedApplication::isShiftModifierPressed() const
	{
	return m->shift_modifier;
	}

	void AbstractCharacterBasedApplication::setTextCodec(QTextCodec *codec)
	{
	m->text_codec = codec;
	clearParsedLine();
	invalidateArea();
	makeBuffer();
	}

	void AbstractCharacterBasedApplication::setAutoLayout(bool f)
	{
	m->auto_layout = f;
	layoutEditor();
	}

	void AbstractCharacterBasedApplication::showHeader(bool f)
	{
	m->header_line = f ? 1 : 0;
	layoutEditor();
	}

	void AbstractCharacterBasedApplication::showFooter(bool f)
	{
	m->footer_line = f ? 1 : 0;
	layoutEditor();
	}

	void AbstractCharacterBasedApplication::showLineNumber(bool show, int left_margin)
	{
	m->show_line_number = show;
	m->left_margin = left_margin;
	}

	void AbstractCharacterBasedApplication::setCursorVisible(bool show)
	{
	m->is_cursor_visible = show;
	}

	bool AbstractCharacterBasedApplication::isCursorVisible()
	{
	return m->is_cursor_visible;
	}

	void AbstractCharacterBasedApplication::retrieveLastText(std::vector<char> *out, int maxlen) const
	{
	const_cast<AbstractCharacterBasedApplication *>(this)->document()->retrieveLastText(out, maxlen);
	}

	bool AbstractCharacterBasedApplication::isChanged() const
	{
	return m->is_changed;
	}

	void AbstractCharacterBasedApplication::setChanged(bool f)
	{
	m->is_changed = f;
	}

	int AbstractCharacterBasedApplication::leftMargin_() const
	{
	return m->left_margin;
	}

	void AbstractCharacterBasedApplication::setRecentlyUsedPath(QString const &path)
	{
	m->recently_used_path = path;
	}

	QString AbstractCharacterBasedApplication::recentlyUsedPath()
	{
	return m->recently_used_path;
	}

	std::vector<AbstractCharacterBasedApplication::Character> *AbstractCharacterBasedApplication::screen()
	{
	return &m->screen;
	}

	const std::vector<AbstractCharacterBasedApplication::Character> *AbstractCharacterBasedApplication::screen() const
	{
	return &m->screen;
	}

	std::vector<uint8_t> *AbstractCharacterBasedApplication::line_flags()
	{
	return &m->line_flags;
	}

	void AbstractCharacterBasedApplication::makeBuffer()
	{
	int w = screenWidth();
	int h = screenHeight();
	int size = w * h;
	m->screen.resize(size);
	std::fill(m->screen.begin(), m->screen.end(), Character());
	m->line_flags.resize(h);
	}

	void AbstractCharacterBasedApplication::layoutEditor()
	{
	makeBuffer();
	editor_cx->viewport_org_x = leftMargin_();
	editor_cx->viewport_org_y = m->header_line;
	editor_cx->viewport_width = screenWidth() - cx()->viewport_org_x;
	editor_cx->viewport_height = screenHeight() - (m->header_line + m->footer_line);
	}

	void AbstractCharacterBasedApplication::initEditor()
	{
	- editor_cx = std::shared_ptr<TextEditorContext>(new TextEditorContext());
	+ editor_cx = std::make_shared<TextEditorContext>();
	layoutEditor();
	}

	bool AbstractCharacterBasedApplication::isLineNumberVisible() const
	{
	return m->show_line_number;
	}

	int AbstractCharacterBasedApplication::charWidth(uint32_t c)
	{
	return UnicodeWidth::width(UnicodeWidth::type(c));
	}

	QList<FormattedLine> AbstractCharacterBasedApplication::formatLine(Document::Line const &line, int tab_span, int anchor_a, int anchor_b) const
	{
	QByteArray ba;
	if (m->text_codec) {
	ba = m->text_codec->toUnicode(line.text).toUtf8();
	} else {
	ba = line.text;
	}

	std::vector<ushort> vec;
	vec.reserve(ba.size() + 100);
	size_t len = ba.size();
	QList<FormattedLine> res;

	int col = 0;
	int col_start = col;

	bool flag_a = false;
	bool flag_b = false;

	auto Color = [&](size_t offset, size_t *next_offset){
	int i = findSyntax(&m->syntax_table, offset);
	if (i < m->syntax_table.size() && m->syntax_table[i].offset <= offset) {
	if (next_offset) {
	if (i + 1 < m->syntax_table.size()) {
	*next_offset = m->syntax_table[i + 1].offset;
	} else {
	*next_offset = -1;
	}
	}
	static int color[] = {
	0x000000,
	0x0000ff,
	0x00ff00,
	0x00ffff,
	0xff0000,
	0xff00ff,
	0xffff00,
	0xffffff,
	};
	i = m->syntax_table[i].color;
	if (i >= 0 && i < 8) {
	return color[i];
	}
	}
	if (next_offset) {
	*next_offset = -1;
	}
	return 0;
	};


	auto Flush = [&](size_t offset, size_t *next_offset){
	if (!vec.empty()) {
	int atts = 0;
	atts \|= Color(offset, next_offset);
	if (anchor_a >= 0 \|\| anchor_b >= 0) {
	if ((anchor_a < 0 \|\| col_start >= anchor_a) && (anchor_b == -1 \|\| col_start < anchor_b)) {
	atts \|= FormattedLine::Selected;
	}
	}
	ushort const *left = &vec[0];
	ushort const *right = left + vec.size();
	while (left < right && (right[-1] == '\r' \|\| right[-1] == '\n')) right--;
	if (left < right) {
	res.push_back(FormattedLine(QString::fromUtf16(left, right - left), atts));
	}
	vec.clear();
	} else {
	*next_offset = -1;
	}
	col_start = col;
	};

	size_t offset = 0;
	size_t next_offset = -1;
	if (len > 0) {
	{
	size_t o = line.byte_offset;
	int i = findSyntax(&m->syntax_table, o);
	if (i < m->syntax_table.size() && m->syntax_table[i].offset <= o) {
	if (i + 1 < m->syntax_table.size()) {
	o = m->syntax_table[i + 1].offset;
	if (o != (size_t)-1) {
	next_offset = o;
	}
	}
	}
	}
	utf8 u8(ba.data(), len);
	u8.to_utf32([&](uint32_t c){
	if (line.byte_offset + u8.offset() == next_offset) {
	Flush(line.byte_offset + offset, &next_offset);
	offset += u8.offset();
	}
	if (c == '\t') {
	do {
	vec.push_back(' ');
	col++;
	} while (col % tab_span != 0);
	} else if (c < ' ') {
	// nop
	} else {
	int cw = charWidth(c);
	if (c < 0xffff) {
	vec.push_back(c);
	} else {
	int a = c >> 16;
	if (a > 0 && a <= 0x20) {
	a--;
	int b = c & 0x03ff;
	a = (a << 6) \| ((c >> 10) & 0x003f);
	a \|= 0xd800;
	b \|= 0xdc00;
	vec.push_back(a);
	vec.push_back(b);
	}
	}
	col += cw;
	}
	if ((anchor_a >= 0 \|\| anchor_b >= 0) && anchor_a != anchor_b) {
	if (!flag_a && col >= anchor_a) {
	Flush(line.byte_offset + offset, &next_offset);
	flag_a = true;
	}
	if (!flag_b && col >= anchor_b) {
	Flush(line.byte_offset + offset, &next_offset);
	flag_b = true;
	}
	}
	return true;
	});
	}
	Flush(line.byte_offset + offset, &next_offset);
	return res;
	}

	void AbstractCharacterBasedApplication::fetchCurrentLine() const
	{
	QByteArray line;
	const int row = cx()->current_row;
	int lines = documentLines();
	if (row >= 0 && row < lines) {
	line = cx()->engine->document.lines[row].text;
	}
	m->parsed_row_index = row;
	m->parsed_line = line;
	}

	void AbstractCharacterBasedApplication::clearParsedLine()
	{
	m->parsed_row_index = -1;
	m->parsed_for_edit = false;
	m->parsed_line.clear();
	}

	int AbstractCharacterBasedApplication::cursorX() const
	{
	return cx()->current_col - cx()->scroll_col_pos;
	}

	int AbstractCharacterBasedApplication::cursorY() const
	{
	return cx()->current_row - cx()->scroll_row_pos;
	}

	int AbstractCharacterBasedApplication::screenWidth() const
	{
	return m->screen_width;
	}

	int AbstractCharacterBasedApplication::screenHeight() const
	{
	return m->screen_height;
	}

	void AbstractCharacterBasedApplication::setScreenSize(int w, int h, bool update_layout)
	{
	m->screen_width = w;
	m->screen_height = h;
	if (update_layout) {
	layoutEditor();
	}
	}

	bool AbstractCharacterBasedApplication::isPaintingSuppressed() const
	{
	return m->is_painting_suppressed;
	}

	void AbstractCharacterBasedApplication::setPaintingSuppressed(bool f)
	{
	m->is_painting_suppressed = f;
	}

	void AbstractCharacterBasedApplication::commitLine(std::vector<uint32_t> const &vec)
	{
	if (isReadOnly()) return;

	QByteArray ba;
	if (!vec.empty()){
	utf32 u32(&vec[0], vec.size());
	u32.to_utf8([&](char c, int pos){
	(void)pos;
	ba.push_back(c);
	return true;
	});
	}
	if (m->parsed_row_index == 0 && engine()->document.lines.empty()) {
	Document::Line newline;
	engine()->document.lines.push_back(newline);
	}
	Document::Line *line = &engine()->document.lines[m->parsed_row_index];
	if (m->parsed_row_index == 0) {
	line->byte_offset = 0;
	line->line_number = (line->type == Document::Line::Unknown) ? 0 : 1;
	}
	line->text = ba;

	if (m->valid_line_index > m->parsed_row_index) {
	m->valid_line_index = m->parsed_row_index;
	}

	int y = m->parsed_row_index - cx()->scroll_row_pos + cx()->viewport_org_y;
	if (y >= 0 && y < (int)m->line_flags.size()) {
	m->line_flags[y] \|= LineChanged;
	}
	}

	void AbstractCharacterBasedApplication::parseLine(std::vector<uint32_t> *vec, int increase_hint, bool force)
	{
	if (force) {
	clearParsedLine();
	}

	if (force \|\| !m->parsed_for_edit) {
	fetchCurrentLine();
	m->parsed_col_index = internalParseLine(vec ? vec : &m->prepared_current_line, increase_hint);
	m->parsed_for_edit = true;
	} else {
	if (vec) {
	*vec = m->prepared_current_line;
	}
	}
	}

	QByteArray AbstractCharacterBasedApplication::parsedLine() const
	{
	return m->parsed_line;
	}

	bool AbstractCharacterBasedApplication::isCurrentLineWritable() const
	{
	if (isReadOnly()) return false;

	int row = cx()->current_row;
	if (row >= 0 && row < cx()->engine->document.lines.size()) {
	if (cx()->engine->document.lines[row].type != Document::Line::Unknown) {
	return true;
	}
	}
	return false;
	}

	int AbstractCharacterBasedApplication::editorViewportWidth() const
	{
	return cx()->viewport_width;
	}

	int AbstractCharacterBasedApplication::editorViewportHeight() const
	{
	return cx()->viewport_height;
	}

	int AbstractCharacterBasedApplication::print(int x, int y, const QString &text, const AbstractCharacterBasedApplication::Option &opt)
	{
	CharAttr attr = opt.char_attr;
	if (opt.char_attr.flags & CharAttr::Selected) {
	attr.index = CharAttr::Invert;
	}
	if (opt.char_attr.flags & CharAttr::CurrentLine) {
	attr.index = CharAttr::Hilite;
	}

	const int screen_w = screenWidth();
	const int screen_h = screenHeight();
	int x_start = 0;
	int y_start = 0;
	int x_limit = screen_w;
	int y_limit = screen_h;
	if (!opt.clip.isNull()) {
	x_start = opt.clip.x();
	y_start = opt.clip.y();
	x_limit = x_start + opt.clip.width();
	y_limit = y_start + opt.clip.height();
	}
	if (y >= y_start && y < y_limit) {
	bool changed = false;
	int x2 = x;
	int y2 = y;
	if (text.isEmpty()) {
	changed = true; // set changed flag if text is empty
	} else {
	for (int i = 0; i < text.size(); i++) {
	ushort c = text.utf16()[i];
	if (c < ' ' \|\| c == 0x7f) continue;
	int cw = charWidth(c);
	if (x2 + cw > x_limit) {
	break;
	}
	for (int j = 0; j < cw; j++) {
	if (x2 >= x_start && x2 < screen_w) {
	int o = y2 * screen_w + x2;
	CharAttr a;
	if (j == 0) {
	a = attr;
	} else {
	c = -1;
	}
	if (c != m->screen[o].c \|\| a != m->screen[o].a) {
	m->screen[o].c = c;
	m->screen[o].a = a;
	changed = true;
	}
	}
	x2++;
	}
	}
	}
	if (changed) {
	m->line_flags[y] \|= LineChanged;
	}
	x = x2;
	}
	return x;
	}

	-void AbstractCharacterBasedApplication::initEngine(std::shared_ptr<TextEditorContext> cx)
	+void AbstractCharacterBasedApplication::initEngine(std::shared_ptr<TextEditorContext> const &cx)
	{
	- cx->engine = TextEditorEnginePtr(new TextEditorEngine);
	+ cx->engine = std::make_shared<TextEditorEngine>();
	}

	TextEditorContext *AbstractCharacterBasedApplication::cx()
	{
	if (dialog_cx) {
	if (!dialog_cx->engine) {
	initEngine(dialog_cx);
	}
	return dialog_cx.get();
	}
	if (!editor_cx->engine) {
	initEngine(editor_cx);
	}
	return editor_cx.get();
	}

	const TextEditorContext *AbstractCharacterBasedApplication::cx() const
	{
	return const_cast<AbstractCharacterBasedApplication *>(this)->cx();
	}

	TextEditorEnginePtr AbstractCharacterBasedApplication::engine()
	{
	Q_ASSERT(cx()->engine);
	return cx()->engine;
	}

	-void AbstractCharacterBasedApplication::setTextEditorEngine(TextEditorEnginePtr e)
	+void AbstractCharacterBasedApplication::setTextEditorEngine(TextEditorEnginePtr const &e)
	{
	cx()->engine = e;
	}

	void AbstractCharacterBasedApplication::setDocument(QList<Document::Line> const *source)
	{
	document()->lines = *source;
	}

	void AbstractCharacterBasedApplication::openFile(const QString &path)
	{
	document()->lines.clear();
	QFile file(path);
	if (file.open(QFile::ReadOnly)) {
	size_t offset = 0;
	QString line;
	unsigned int linenum = 0;
	while (!file.atEnd()) {
	linenum++;
	Document::Line line(file.readLine());
	line.byte_offset = offset;
	line.type = Document::Line::Normal;
	line.line_number = linenum;
	document()->lines.push_back(line);
	offset += line.text.size();
	}
	int n = line.size();
	if (n > 0) {
	ushort const *p = line.utf16();
	ushort c = p[n - 1];
	if (c == '\r' \|\| c == '\n') {
	document()->lines.push_back(Document::Line(QByteArray()));
	}
	}
	m->valid_line_index = (int)document()->lines.size();
	setRecentlyUsedPath(path);
	}
	scrollToTop();
	}

	void AbstractCharacterBasedApplication::saveFile(const QString &path)
	{
	QFile file(path);
	if (file.open(QFile::WriteOnly)) {
	for (Document::Line const &line : document()->lines) {
	file.write(line.text);
	}
	}
	}

	void AbstractCharacterBasedApplication::pressEnter()
	{
	deleteIfSelected();

	if (isDialogMode()) {
	closeDialog(true);
	} else {
	writeNewLine();
	}
	}

	void AbstractCharacterBasedApplication::pressEscape()
	{
	if (isTerminalMode()) {
	m->escape_sequence.write(0x1b);
	return;
	}

	if (isDialogMode()) {
	closeDialog(false);
	return;
	}

	deselect();
	updateVisibility(false, false, false);
	}

	AbstractCharacterBasedApplication::State AbstractCharacterBasedApplication::state() const
	{
	return m->state;
	}

	Document *AbstractCharacterBasedApplication::document()
	{
	return &engine()->document;
	}

	int AbstractCharacterBasedApplication::documentLines() const
	{
	return const_cast<AbstractCharacterBasedApplication *>(this)->document()->lines.size();
	}

	bool AbstractCharacterBasedApplication::isSingleLineMode() const
	{
	return cx()->single_line;
	}

	void AbstractCharacterBasedApplication::setLineMargin(int n)
	{
	m->line_margin = n;
	}

	void AbstractCharacterBasedApplication::ensureCurrentLineVisible()
	{
	int margin = (cx()->viewport_height >= 6 && !isSingleLineMode()) ? m->line_margin : 0;
	int pos = cx()->scroll_row_pos;
	int top = cx()->current_row - margin;
	int bottom = cx()->current_row + 1 - editorViewportHeight() + margin;
	if (pos > top) pos = top;
	if (pos < bottom) pos = bottom;
	if (pos < 0) pos = 0;
	if (cx()->scroll_row_pos != pos) {
	cx()->scroll_row_pos = pos;
	invalidateArea();
	}
	}

	int AbstractCharacterBasedApplication::decideColumnScrollPos() const
	{
	int x = cx()->current_col;
	int w = editorViewportWidth() - RIGHT_MARGIN;
	if (w < 0) w = 0;
	return x > w ? (cx()->current_col - w) : 0;
	}

	int AbstractCharacterBasedApplication::calcVisualWidth(const Document::Line &line) const
	{
	QList<FormattedLine> lines = formatLine(line, cx()->tab_span);
	int x = 0;
	for (FormattedLine const &line : lines) {
	if (line.text.isEmpty()) continue;
	ushort const *ptr = line.text.utf16();
	ushort const *end = ptr + line.text.size();
	while (1) {
	int c = -1;
	if (ptr < end) {
	c = *ptr;
	ptr++;
	}
	if (c == -1 \|\| c == '\r' \|\| c == '\n') {
	break;
	}
	if (c == '\t') {
	x += cx()->tab_span;
	x -= x % cx()->tab_span;
	} else {
	x += charWidth(c);
	}
	}
	}
	return x;
	}



	void AbstractCharacterBasedApplication::clearRect(int x, int y, int w, int h)
	{
	int scr_w = screenWidth();
	int scr_h = screenHeight();
	int y0 = y;
	int y1 = y + h;
	if (y0 < 0) y0 = 0;
	if (y1 > scr_h) y1 = scr_h;
	int x0 = x;
	int x1 = x + w;
	if (x0 < 0) x0 = 0;
	if (x1 > scr_w) x1 = scr_w;
	for (int y = y0; y < y1; y++) {
	for (int x = x0; x < x1; x++) {
	int o = y * scr_w + x;
	m->screen[o] = Character();
	}
	}
	}

	int AbstractCharacterBasedApplication::calcIndexToColumn(const std::vector<uint32_t> &vec, int index) const
	{
	int col = 0;
	for (int i = 0; i < index; i++) {
	uint32_t c = vec.at(i);
	if (c == '\t') {
	col += cx()->tab_span;
	col -= col % cx()->tab_span;
	} else {
	col += charWidth(c);
	}
	}
	return col;
	}

	void AbstractCharacterBasedApplication::savePos()
	{
	TextEditorContext *p = editor_cx.get();
	if (p) {
	p->saved_row = p->current_row;
	p->saved_col = p->current_col;
	p->saved_col_hint = p->current_col_hint;
	}
	}

	void AbstractCharacterBasedApplication::restorePos()
	{
	TextEditorContext *p = editor_cx.get();
	if (p) {
	p->current_row = p->saved_row;
	p->current_col = p->saved_col;
	p->current_col_hint = p->saved_col_hint;
	}
	}

	void AbstractCharacterBasedApplication::setCursorRow(int row, bool auto_scroll, bool by_mouse)
	{
	if (cx()->current_row == row) return;

	if (isShiftModifierPressed()) {
	if (selection_anchor_0.enabled == SelectionAnchor::No) {
	setSelectionAnchor(SelectionAnchor::EnabledEasy, true, auto_scroll);
	selection_anchor_1 = selection_anchor_0;
	}
	} else if (selection_anchor_0.enabled == SelectionAnchor::EnabledEasy) {
	setSelectionAnchor(SelectionAnchor::No, false, auto_scroll);
	}

	cx()->current_row = row;

	if (selection_anchor_0.enabled != SelectionAnchor::No) {
	setSelectionAnchor(selection_anchor_0.enabled, true, auto_scroll);
	}

	m->cursor_moved_by_mouse = by_mouse;

	}

	void AbstractCharacterBasedApplication::setCursorCol(int col, bool auto_scroll, bool by_mouse)
	{
	if (cx()->current_col == col) {
	cx()->current_col_hint = col;
	return;
	}

	if (isShiftModifierPressed()) {
	if (selection_anchor_0.enabled == SelectionAnchor::No) {
	setSelectionAnchor(SelectionAnchor::EnabledEasy, true, auto_scroll);
	selection_anchor_1 = selection_anchor_0;
	}
	} else if (selection_anchor_0.enabled == SelectionAnchor::EnabledEasy) {
	setSelectionAnchor(SelectionAnchor::No, false, auto_scroll);
	}

	cx()->current_col = col;
	cx()->current_col_hint = col;

	if (selection_anchor_0.enabled != SelectionAnchor::No) {
	setSelectionAnchor(selection_anchor_0.enabled, true, auto_scroll);
	}

	m->cursor_moved_by_mouse = by_mouse;
	}

	void AbstractCharacterBasedApplication::setCursorPos(int row, int col)
	{
	setCursorRow(row, false);
	setCursorCol(col, false);
	}

	void AbstractCharacterBasedApplication::setCursorColByIndex(std::vector<uint32_t> const &vec, int col_index)
	{
	int col = calcIndexToColumn(vec, col_index);
	setCursorCol(col);
	}

	int AbstractCharacterBasedApplication::nextTabStop(int x) const
	{
	x += cx()->tab_span;
	x -= x % cx()->tab_span;
	return x;
	}

	void AbstractCharacterBasedApplication::editSelected(EditOperation op, std::vector<uint32_t> *cutbuffer)
	{
	if (isReadOnly() && op == EditOperation::Cut) {
	op = EditOperation::Copy;
	}

	SelectionAnchor a = selection_anchor_0;
	SelectionAnchor b = selection_anchor_1;
	if (!a.enabled) return;
	if (!b.enabled) return;
	if (a == b) return;

	auto UpdateVisibility = [&](){
	updateVisibility(false, false, false);
	};

	if (cutbuffer) {
	cutbuffer->clear();
	}
	std::list<std::vector<uint32_t>> cutlist;

	if (a.row > b.row) {
	std::swap(a, b);
	} else if (a.row == b.row) {
	if (a.col > b.col) {
	std::swap(a, b);
	}
	}

	int curr_row = cx()->current_row;
	int curr_col = cx()->current_col;

	cx()->current_row = b.row;
	cx()->current_col = b.col;

	if (a.row == b.row) {
	std::vector<uint32_t> vec1;
	parseLine(&vec1, 0, true);
	auto begin = vec1.begin() + calcColumnToIndex(a.col);
	auto end = vec1.begin() + calcColumnToIndex(b.col);
	if (cutbuffer) {
	std::vector<uint32_t> cut;
	cut.insert(cut.end(), begin, end);
	cutlist.push_back(std::move(cut));
	}
	if (op == EditOperation::Cut) {
	vec1.erase(begin, end);
	commitLine(vec1);
	UpdateVisibility();
	}
	} else {
	std::vector<uint32_t> vec1;
	parseLine(&vec1, 0, true);
	{
	auto begin = vec1.begin();
	auto end = vec1.begin() + calcColumnToIndex(b.col);
	if (cutbuffer) {
	std::vector<uint32_t> cut;
	cut.insert(cut.end(), begin, end);
	cutlist.push_back(std::move(cut));
	}
	if (op == EditOperation::Cut) {
	vec1.erase(begin, end);
	commitLine(vec1);
	UpdateVisibility();
	}
	}
	int n = b.row - a.row;
	for (int i = 0; i < n; i++) {
	QList<Document::Line> *lines = &cx()->engine->document.lines;
	if (cutbuffer && i > 0) {
	cx()->current_row = b.row - i;
	cx()->current_col = 0;
	std::vector<uint32_t> cut;
	parseLine(&cut, 0, true);
	cutlist.push_back(std::move(cut));
	}
	if (op == EditOperation::Cut) {
	lines->erase(lines->begin() + b.row - i);
	}
	}

	cx()->current_row = a.row;
	cx()->current_col = a.col;
	int index = calcColumnToIndex(a.col);
	std::vector<uint32_t> vec2;
	parseLine(&vec2, 0, true);
	if (cutbuffer) {
	std::vector<uint32_t> cut;
	cut.insert(cut.end(), vec2.begin() + index, vec2.end());
	cutlist.push_back(std::move(cut));
	}

	if (op == EditOperation::Cut) {
	vec2.resize(index);
	vec2.insert(vec2.end(), vec1.begin(), vec1.end());
	commitLine(vec2);
	UpdateVisibility();
	}
	}

	if (cutbuffer) {
	size_t size = 0;
	for (std::vector<uint32_t> const &v : cutlist) {
	size += v.size();
	}
	cutbuffer->reserve(size);
	for (auto it = cutlist.rbegin(); it != cutlist.rend(); it++) {
	std::vector<uint32_t> const &v = *it;
	cutbuffer->insert(cutbuffer->end(), v.begin(), v.end());
	}
	}


	if (op == EditOperation::Cut) {
	deselect();
	setCursorPos(a.row, a.col);
	invalidateArea(a.row - cx()->scroll_row_pos);
	} else {
	cx()->current_row = curr_row;
	cx()->current_col = curr_col;
	invalidateArea(curr_row - cx()->scroll_row_pos);
	}

	clearParsedLine();
	UpdateVisibility();
	}

	void AbstractCharacterBasedApplication::edit_(EditOperation op)
	{
	std::vector<uint32_t> u32buf;
	editSelected(op, &u32buf);
	if (u32buf.empty()) return;

	std::vector<ushort> u16buf;
	u16buf.reserve(1024);
	utf32(&u32buf[0], u32buf.size()).to_utf16([&](uint16_t c){
	u16buf.push_back(c);
	return true;
	});
	if (!u16buf.empty()) {
	QString s = QString::fromUtf16(&u16buf[0], u16buf.size());
	qApp->clipboard()->setText(s);
	}
	}

	bool AbstractCharacterBasedApplication::deleteIfSelected()
	{
	if (selection_anchor_0.enabled && selection_anchor_1.enabled) {
	if (selection_anchor_0 != selection_anchor_1) {
	editSelected(EditOperation::Cut, nullptr);
	return true;
	}
	}
	return false;
	}

	void AbstractCharacterBasedApplication::doDelete()
	{
	if (isReadOnly()) return;
	if (isTerminalMode()) return;

	if (deleteIfSelected()) {
	return;
	}

	parseLine(nullptr, 0, false);
	std::vector<uint32_t> *vec = &m->prepared_current_line;
	int index = m->parsed_col_index;
	int c = -1;
	if (index >= 0 && index < (int)vec->size()) {
	c = (*vec)[index];
	}
	if (c == '\n' \|\| c == '\r' \|\| c == -1) {
	if (index == 0) {
	m->parsed_row_index--;
	}
	invalidateAreaBelowTheCurrentLine();
	if (isSingleLineMode()) {
	// nop
	} else {
	if (c != -1) {
	vec->erase(vec->begin() + index);
	if (c == '\r' && index < (int)vec->size() && (*vec)[index] == '\n') {
	vec->erase(vec->begin() + index);
	}
	}
	if (vec->empty()) {
	clearParsedLine();
	if (cx()->current_row + 1 < (int)cx()->engine->document.lines.size()) {
	cx()->engine->document.lines.erase(cx()->engine->document.lines.begin() + cx()->current_row);
	}
	} else {
	commitLine(*vec);
	setCursorColByIndex(*vec, index);
	if (index == (int)vec->size()) {
	int nextrow = cx()->current_row + 1;
	int lines = documentLines();
	if (nextrow < lines) {
	Document::Line *ba1 = &cx()->engine->document.lines[cx()->current_row];
	Document::Line const &ba2 = cx()->engine->document.lines[nextrow];
	ba1->text.append(ba2.text);
	cx()->engine->document.lines.erase(cx()->engine->document.lines.begin() + nextrow);
	}
	}
	}
	clearParsedLine();
	updateVisibility(true, true, true);
	}
	} else {
	vec->erase(vec->begin() + index);
	commitLine(*vec);
	setCursorColByIndex(*vec, index);
	updateVisibility(true, true, true);
	}
	}

	void AbstractCharacterBasedApplication::doBackspace()
	{
	if (isReadOnly()) return;
	if (isTerminalMode()) return;

	if (deleteIfSelected()) {
	return ;
	}

	if (cx()->current_row > 0 \|\| cx()->current_col > 0) {
	setPaintingSuppressed(true);
	moveCursorLeft();
	doDelete();
	setPaintingSuppressed(false);
	updateVisibility(true, true, true);
	}
	}

	bool AbstractCharacterBasedApplication::isDialogMode()
	{
	return m->dialog_mode;
	}

	-void AbstractCharacterBasedApplication::setDialogOption(QString const &title, QString value, DialogHandler handler)
	+void AbstractCharacterBasedApplication::setDialogOption(QString const &title, QString const &value, DialogHandler handler)
	{
	m->dialog_title = title;
	m->dialog_value = value;
	m->dialog_handler = handler;
	}

	void AbstractCharacterBasedApplication::setDialogMode(bool f)
	{
	if (f) {
	if (!dialog_cx) {
	int y = screenHeight() - 2;
	- dialog_cx = std::shared_ptr<TextEditorContext>(new TextEditorContext);
	- dialog_cx->engine = std::shared_ptr<TextEditorEngine>(new TextEditorEngine);
	+ dialog_cx = std::make_shared<TextEditorContext>();
	+ dialog_cx->engine = std::make_shared<TextEditorEngine>();
	dialog_cx->single_line = true;
	dialog_cx->viewport_org_x = 0;
	dialog_cx->viewport_org_y = y + 1;
	dialog_cx->viewport_width = screenWidth();
	dialog_cx->viewport_height = 1;
	}
	dialog_cx->engine->document.lines.push_back(Document::Line(m->dialog_value.toUtf8()));
	editor_cx->viewport_height = screenHeight() - m->header_line - 2;
	m->dialog_mode = true;
	clearParsedLine();
	moveCursorEnd();
	} else {
	dialog_cx.reset();
	m->dialog_mode = false;
	layoutEditor();
	clearParsedLine();
	updateVisibility(true, true, true);
	}
	}

	void AbstractCharacterBasedApplication::execDialog(QString const &dialog_title, QString dialog_value, DialogHandler handler)
	{
	setDialogOption(dialog_title, dialog_value, handler);
	setDialogMode(true);
	}

	void AbstractCharacterBasedApplication::closeDialog(bool result)
	{
	if (isDialogMode()) {
	deselect();
	QString line;
	if (!dialog_cx->engine->document.lines.empty()) {
	Document::Line const &l = dialog_cx->engine->document.lines.front();
	line = QString::fromUtf8(l.text);
	}
	setDialogMode(false);
	if (m->dialog_handler) {
	m->dialog_handler(result, line);
	}
	return;
	}
	}

	int AbstractCharacterBasedApplication::internalParseLine(std::vector<uint32_t> *vec, int increase_hint) const
	{
	vec->clear();

	int index = -1;
	int col = 0;
	int len = m->parsed_line.size();
	if (len > 0) {
	vec->reserve(len + increase_hint);
	char const *src = m->parsed_line.data();
	utf8 u8(src, len);
	while (1) {
	int n = 0;
	uint32_t c = u8.next();
	if (c == 0) {
	n = 1;
	} else {
	if (c == '\t') {
	int z = nextTabStop(col);
	n = z - col;
	} else {
	n = charWidth(c);
	}
	}
	if (col <= cx()->current_col && col + n > cx()->current_col) {
	index = (int)vec->size();
	}
	if (c == 0) break;
	col += n;
	vec->push_back(c);
	}
	}
	return index;
	}

	int AbstractCharacterBasedApplication::calcColumnToIndex(int column)
	{
	int index = 0;
	if (column > 0) {
	fetchCurrentLine();
	int col = 0;
	int len = m->parsed_line.size();
	if (len > 0) {
	char const *src = m->parsed_line.data();
	utf8 u8(src, len);
	while (1) {
	uint32_t c = u8.next();
	int n = 0;
	if (c == '\r' \|\| c == '\n' \|\| c == 0) {
	break;
	}
	if (c == '\t') {
	int z = nextTabStop(col);
	n = z - col;
	} else {
	n = charWidth(c);
	}
	col += n;
	index++;
	if (col >= column) {
	break;
	}
	}
	}
	}
	return index;
	}

	void AbstractCharacterBasedApplication::invalidateArea(int top_y)
	{
	int y0 = cx()->viewport_org_y;
	int y1 = cx()->viewport_height + y0;
	top_y += y0;
	if (y0 < top_y) y0 = top_y;
	int n = m->line_flags.size();
	if (y0 < 0) y0 = 0;
	if (y1 > n) y1 = n;
	for (int y = y0; y < y1; y++) {
	m->line_flags[y] \|= LineChanged;
	}
	}

	void AbstractCharacterBasedApplication::invalidateAreaBelowTheCurrentLine()
	{
	int y;

	y = m->parsed_row_index;
	if (m->valid_line_index > y) {
	m->valid_line_index = y;
	}

	y = m->parsed_row_index - cx()->scroll_row_pos;
	invalidateArea(y);
	}

	int AbstractCharacterBasedApplication::scrollBottomLimit() const
	{
	return documentLines() - editorViewportHeight() / 2;
	}

	void AbstractCharacterBasedApplication::writeCR()
	{
	deleteIfSelected();

	setCursorCol(0);
	clearParsedLine();
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::moveCursorOut()
	{
	setCursorRow(-1);
	}

	void AbstractCharacterBasedApplication::moveCursorHome()
	{
	fetchCurrentLine();
	QString line = m->parsed_line;
	ushort const *ptr = line.utf16();
	ushort const *end = ptr + line.size();
	int x = 0;
	while (1) {
	int c = -1;
	if (ptr < end) {
	c = *ptr;
	ptr++;
	}
	if (c == ' ') {
	x++;
	} else if (c == '\t') {
	x = nextTabStop(x);
	} else {
	break;
	}
	}
	if (x == cx()->current_col) {
	x = 0;
	}
	setCursorCol(x);
	clearParsedLine();
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::moveCursorEnd()
	{
	fetchCurrentLine();
	QByteArray line = m->parsed_line;
	int col = calcVisualWidth(Document::Line(line));
	setCursorCol(col);
	clearParsedLine();
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::scrollUp()
	{
	if (cx()->scroll_row_pos > 0) {
	cx()->scroll_row_pos--;
	invalidateArea();
	clearParsedLine();
	updateVisibility(false, false, true);
	}
	}

	void AbstractCharacterBasedApplication::scrollDown()
	{
	int limit = scrollBottomLimit();
	if (cx()->scroll_row_pos < limit) {
	cx()->scroll_row_pos++;
	invalidateArea();
	clearParsedLine();
	updateVisibility(false, false, true);
	}
	}

	void AbstractCharacterBasedApplication::moveCursorUp()
	{
	if (isSingleLineMode()) {
	// nop
	} else if (cx()->current_row > 0) {
	setCursorRow(cx()->current_row - 1);
	clearParsedLine();
	updateVisibility(true, false, true);
	}
	}

	void AbstractCharacterBasedApplication::moveCursorDown()
	{
	if (isSingleLineMode()) {
	// nop
	} else if (cx()->current_row + 1 < (int)document()->lines.size()) {
	setCursorRow(cx()->current_row + 1);
	clearParsedLine();
	updateVisibility(true, false, true);
	}
	}

	void AbstractCharacterBasedApplication::scrollToTop()
	{
	if (isSingleLineMode()) return;

	setCursorRow(0);
	setCursorCol(0);
	cx()->scroll_row_pos = 0;
	invalidateArea();
	clearParsedLine();
	updateVisibility(true, false, true);
	}

	void AbstractCharacterBasedApplication::moveCursorLeft()
	{
	if (!isShiftModifierPressed() && selection_anchor_0.enabled && selection_anchor_1.enabled) { // 選択領域があったら
	if (selection_anchor_0 != selection_anchor_1) {
	SelectionAnchor a = std::min(selection_anchor_0, selection_anchor_1);
	deselect();
	setCursorRow(a.row);
	setCursorCol(a.col);
	updateVisibility(true, true, true);
	return;
	}
	}

	if (cx()->current_col == 0) {
	if (isSingleLineMode()) {
	// nop
	} else {
	if (cx()->current_row > 0) {
	setCursorRow(cx()->current_row - 1);
	clearParsedLine();
	moveCursorEnd();
	}
	}
	return;
	}

	int col = 0;
	int newcol = 0;
	int index;
	for (index = 0; index < (int)m->prepared_current_line.size(); index++) {
	ushort c = m->prepared_current_line[index];
	if (c == '\r' \|\| c == '\n') {
	break;
	}
	newcol = col;
	if (c == '\t') {
	col = nextTabStop(col);
	} else {
	col += charWidth(c);
	}
	if (col >= cx()->current_col) {
	break;
	}
	}
	m->parsed_col_index = index;
	setCursorCol(newcol);

	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::moveCursorRight()
	{
	if (!isShiftModifierPressed() && selection_anchor_0.enabled && selection_anchor_1.enabled) { // 選択領域があったら
	if (selection_anchor_0 != selection_anchor_1) {
	SelectionAnchor a = std::max(selection_anchor_0, selection_anchor_1);
	deselect();
	setCursorRow(a.row);
	setCursorCol(a.col);
	updateVisibility(true, true, true);
	return;
	}
	}

	int col = 0;
	int i = 0;
	while (1) {
	int c = -1;
	if (i < (int)m->prepared_current_line.size()) {
	c = m->prepared_current_line[i];
	}
	if (c == '\r' \|\| c == '\n' \|\| c == -1) {
	if (!isSingleLineMode()) {
	int nextrow = cx()->current_row + 1;
	int lines = document()->lines.size();
	if (nextrow < lines) {
	setCursorPos(nextrow, 0);
	clearParsedLine();
	updateVisibility(true, true, true);
	return;
	}
	}
	break;
	}
	if (c == '\t') {
	col = nextTabStop(col);
	} else {
	col += charWidth(c);
	}
	if (col > cx()->current_col) {
	break;
	}
	i++;
	}
	if (col != cx()->current_col) {
	setCursorCol(col);
	clearParsedLine();
	updateVisibility(true, true, true);
	}
	}

	void AbstractCharacterBasedApplication::movePageUp()
	{
	if (!isSingleLineMode()) {
	int step = editorViewportHeight();
	setCursorRow(cx()->current_row - step);
	cx()->scroll_row_pos -= step;
	if (cx()->current_row < 0) {
	cx()->current_row = 0;
	}
	if (cx()->scroll_row_pos < 0) {
	cx()->scroll_row_pos = 0;
	}
	invalidateArea();
	clearParsedLine();
	updateVisibility(true, false, true);
	}
	}

	void AbstractCharacterBasedApplication::movePageDown()
	{
	if (!isSingleLineMode()) {
	int limit = documentLines();
	if (limit > 0) {
	limit--;
	int step = editorViewportHeight();
	setCursorRow(cx()->current_row + step);
	cx()->scroll_row_pos += step;
	if (cx()->current_row > limit) {
	cx()->current_row = limit;
	}
	limit = scrollBottomLimit();
	if (cx()->scroll_row_pos > limit) {
	cx()->scroll_row_pos = limit;
	}
	} else {
	setCursorRow(0);
	cx()->scroll_row_pos = 0;
	}
	invalidateArea();
	clearParsedLine();
	updateVisibility(true, false, true);
	}
	}

	void AbstractCharacterBasedApplication::scrollRight()
	{
	if (cx()->scroll_col_pos > 0) {
	cx()->scroll_col_pos--;
	} else {
	cx()->scroll_col_pos = 0;
	}
	invalidateArea();
	clearParsedLine();
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::scrollLeft()
	{
	cx()->scroll_col_pos++;
	invalidateArea();
	clearParsedLine();
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::addNewLineToBottom()
	{
	int row = cx()->engine->document.lines.size();
	if (cx()->current_row >= row) {
	setCursorPos(row, 0);
	cx()->engine->document.lines.push_back(Document::Line(QByteArray()));
	}
	}

	void AbstractCharacterBasedApplication::appendNewLine(std::vector<uint32_t> *vec)
	{
	if (isSingleLineMode()) return;

	vec->push_back('\r');
	vec->push_back('\n');
	}

	void AbstractCharacterBasedApplication::writeNewLine()
	{
	if (isReadOnly()) return;
	if (isSingleLineMode()) return;
	if (!isCurrentLineWritable()) return;

	invalidateAreaBelowTheCurrentLine();

	std::vector<uint32_t> curr_line;
	parseLine(&curr_line, 0, false);
	int index = m->parsed_col_index;
	if (index < 0) {
	addNewLineToBottom();
	index = 0;
	}
	std::vector<uint32_t> next_line;
	// split line
	next_line.insert(next_line.end(), curr_line.begin() + index, curr_line.end());
	// shrink current line
	curr_line.resize(index);
	// append new line code
	appendNewLine(&curr_line);
	// next line index
	cx()->current_row = m->parsed_row_index + 1;
	// commit current line
	commitLine(curr_line);
	// insert next line
	m->parsed_row_index = cx()->current_row;
	engine()->document.lines.insert(engine()->document.lines.begin() + m->parsed_row_index, Document::Line(QByteArray()));
	// commit next line
	commitLine(next_line);

	setCursorColByIndex(next_line, 0);

	clearParsedLine();
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::makeColumnPosList(std::vector<int> *out)
	{
	out->clear();
	std::vector<uint32_t> const *line = &m->prepared_current_line;
	int x = 0;
	while (1) {
	size_t index = out->size();
	out->push_back(x);
	int n;
	int c = -1;
	if (index < line->size()) {
	c = line->at(index);
	}
	if (c == '\r' \|\| c == '\n' \|\| c == -1) {
	break;
	} else if (c == '\t') {
	int z = nextTabStop(x);
	n = z - x;
	} else {
	n = charWidth(c);
	}
	x += n;
	}
	}

	void AbstractCharacterBasedApplication::updateCursorPos(bool auto_scroll)
	{
	if (!cx()->engine) {
	return;
	}

	parseLine(&m->prepared_current_line, 0, false);

	int index = 0;
	int char_span = 0;
	int col = cx()->current_col_hint;

	{
	std::vector<int> pts;
	makeColumnPosList(&pts);
	if (pts.size() > 1) {
	int newcol = pts.back();
	int newindex = pts.size() - 1;
	for (size_t i = 0; i + 1 < pts.size(); i++) {
	int x = pts[i];
	if (x <= col && col < pts[i + 1]) {
	char_span = pts[i + 1] - pts[i];
	newindex = i;
	newcol = x;
	break;
	}
	}
	index = newindex;
	col = newcol;
	- } else if (pts.size() > 0) {
	+ } else if (!pts.empty()) {
	col = pts.back();
	} else {
	col = 0;
	}
	}

	m->parsed_col_index = index;

	cx()->current_col = col;

	if (char_span < 1) {
	char_span = 1;
	}
	cx()->current_char_span = char_span;

	if (auto_scroll) {
	int pos = decideColumnScrollPos();
	if (cx()->scroll_col_pos != pos) {
	cx()->scroll_col_pos = pos;
	invalidateArea();
	}
	}
	}

	void AbstractCharacterBasedApplication::printInvertedBar(int x, int y, char const *text, int padchar)
	{
	int w = screenWidth();
	int o = w * y;
	for (int i = 0; i < w; i++) {
	m->screen[o + i].c = 0;
	}

	AbstractCharacterBasedApplication::Option opt;
	opt.char_attr = CharAttr::Invert;
	print(x, y, text, opt);

	for (int i = 0; i < w; i++) {
	if (m->screen[o + i].c == 0) {
	m->screen[o + i].c = padchar;
	}
	m->screen[o + i].a = opt.char_attr;
	}
	}

	QString AbstractCharacterBasedApplication::statusLine() const
	{
	QString text = "[%1:%2]";
	text = text.arg(cx()->current_row + 1).arg(cx()->current_col + 1);
	return text;
	}

	int AbstractCharacterBasedApplication::printArea(TextEditorContext const cx, const SelectionAnchor sel_a, const SelectionAnchor *sel_b)
	{
	int end_of_line_y = -1;
	if (cx) {
	int height = cx->viewport_height;
	QRect clip(cx->viewport_org_x, cx->viewport_org_y, cx->viewport_width, height);
	int row = cx->scroll_row_pos;
	for (int i = 0; i < height; i++) {
	if (row < 0) continue;
	int y = cx->viewport_org_y + i;
	if (row < (int)cx->engine->document.lines.size()) {
	if (i < height) {
	int x = cx->viewport_org_x - cx->scroll_col_pos;
	Document::Line const &line = cx->engine->document.lines[row];
	int anchor_a = -1;
	int anchor_b = -1;
	if (sel_a && sel_a->enabled && sel_b && sel_b->enabled) {
	SelectionAnchor a = *sel_a;
	SelectionAnchor b = *sel_b;
	if (a.row > b.row) {
	std::swap(a, b);
	} else if (a.row == b.row) {
	if (a.col > b.col) {
	std::swap(a, b);
	}
	}
	if (row > a.row && row < b.row) {
	anchor_a = 0;
	} else {
	if (row == a.row) {
	anchor_a = a.col;
	}
	if (row == b.row) {
	anchor_b = b.col;
	}
	}
	}
	QList<FormattedLine> lines = formatLine(line, cx->tab_span, anchor_a, anchor_b);
	for (FormattedLine const &line : lines) {
	AbstractCharacterBasedApplication::Option opt;
	if (line.atts & FormattedLine::StyleID) {
	opt.char_attr.color = QColor(line.atts & 0xff, (line.atts >> 8) & 0xff, (line.atts >> 16) & 0xff);
	}
	opt.clip = clip;
	if (line.isSelected()) {
	opt.char_attr.flags \|= CharAttr::Selected;
	}
	x = print(x, y, line.text, opt);
	}
	int end_x = clip.x() + clip.width();
	if (x < end_x) {
	if (x < clip.left()) {
	x = clip.left();
	}
	if (x < end_x) {
	clearRect(x, y, end_x - x, 1);
	}
	}
	}
	} else {
	if (end_of_line_y < 0) {
	end_of_line_y = i;
	}
	clearRect(cx->viewport_org_x, y, cx->viewport_width, 1);
	if (y >= 0 && y < (int)m->line_flags.size()) {
	m->line_flags[y] \|= LineChanged;
	}
	}
	row++;
	}
	}
	return end_of_line_y;
	}

	-void AbstractCharacterBasedApplication::paintLineNumbers(std::function<void(int, QString, Document::Line const *line)> draw)
	+void AbstractCharacterBasedApplication::paintLineNumbers(std::function<void(int, QString, Document::Line const *line)> const &draw)
	{
	auto Line = [&](int index)->Document::Line &{
	return editor_cx->engine->document.lines[index];
	};
	int rightpadding = 2;
	int left_margin = editor_cx->viewport_org_x;
	int num = 1;
	size_t offset = 0;
	for (int i = 0; i < editor_cx->viewport_height; i++) {
	char tmp[100];
	Q_ASSERT(left_margin < (int)sizeof(tmp));
	memset(tmp, ' ', left_margin);
	tmp[left_margin] = 0;
	int row = editor_cx->scroll_row_pos + i;
	Document::Line *line = nullptr;
	if (row < (int)editor_cx->engine->document.lines.size()) {
	if (m->valid_line_index < 0) {
	m->valid_line_index = 0;
	Document::Line *p = &Line(0);
	if (p->type != Document::Line::Unknown) {
	p->byte_offset = offset;
	p->line_number = num;
	offset += p->text.size();
	num++;
	}
	}
	line = &Line(row);
	if (row >= m->valid_line_index) {
	{
	Document::Line const &line = Line(m->valid_line_index);
	offset = line.byte_offset;
	num = line.line_number;
	}
	while (m->valid_line_index <= row) {
	Document::Line const &line = Line(m->valid_line_index);
	if (line.type != Document::Line::Unknown) {
	offset += line.text.size();
	num++;
	}
	m->valid_line_index++;
	if (m->valid_line_index < editor_cx->engine->document.lines.size()) {
	Document::Line *p = &Line(m->valid_line_index);
	p->byte_offset = offset;
	p->line_number = num;
	}
	}
	}
	if (left_margin > 1) {
	unsigned int linenum = -1;
	if (row < m->valid_line_index) {
	#if 1
	linenum = line->line_number;
	#else
	linenum = line->byte_offset;
	#endif
	}
	if (linenum != (unsigned int)-1 && line->type != Document::Line::Unknown) {
	sprintf(tmp, "%*u ", left_margin - rightpadding, linenum);
	}
	}
	}
	int y = editor_cx->viewport_org_y + i;
	draw(y, tmp, line);
	}
	}

	bool AbstractCharacterBasedApplication::isAutoLayout() const
	{
	return m->auto_layout;
	}

	void AbstractCharacterBasedApplication::preparePaintScreen()
	{
	if (m->header_line > 0) {
	char const *line = "Hello, world\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86";
	printInvertedBar(0, 0, line, ' ');
	}

	if (m->show_line_number) {
	Option opt_normal;
	paintLineNumbers([&](int y, QString text, Document::Line const *line){
	(void)line;
	print(0, y, text + '\|', opt_normal);
	});
	}

	SelectionAnchor anchor_a;
	SelectionAnchor anchor_b;

	auto MakeSelectionAnchor = [&](){
	if (selection_anchor_0.enabled != SelectionAnchor::No) {
	anchor_a = selection_anchor_0;
	#if 0
	anchor_b.row = cx()->current_row;
	anchor_b.col = cx()->current_col;
	anchor_b.enabled = selection_anchor_0.enabled;
	#else
	anchor_b = selection_anchor_1;
	#endif
	}
	};

	if (isDialogMode()) {
	printArea(editor_cx.get(), &anchor_a, &anchor_b);

	std::string text = m->dialog_title.toStdString();
	text = ' ' + text + ' ';
	int y = screenHeight() - 2;
	printInvertedBar(3, y, text.c_str(), '-');

	MakeSelectionAnchor();
	printArea(dialog_cx.get(), &anchor_a, &anchor_b);
	} else {
	MakeSelectionAnchor();
	editor_cx->bottom_line_y = printArea(editor_cx.get(), &anchor_a, &anchor_b);

	if (m->footer_line > 0) {
	QString line = statusLine();
	int y = screenHeight() - 1;
	printInvertedBar(0, y, line.toStdString().c_str(), ' ');
	}
	}
	}

	void AbstractCharacterBasedApplication::onQuit()
	{
	if (!m->is_quit_enabled) return;

	if (!isDialogMode()) {
	m->state = State::Exit;
	}
	}

	void AbstractCharacterBasedApplication::onOpenFile()
	{
	if (isReadOnly()) return;
	if (!m->is_open_enabled) return;

	if (!isDialogMode()) {
	execDialog("Open File", recentlyUsedPath(), [&](bool ok, QString const &text){
	if (ok) {
	openFile(text);
	}
	});
	}
	}

	void AbstractCharacterBasedApplication::onSaveFile()
	{
	if (!m->is_save_enabled) return;

	if (!isDialogMode()) {
	execDialog("Save File", recentlyUsedPath(), [&](bool ok, QString const &text){
	if (ok) {
	saveFile(text);
	}
	});
	}
	}

	void AbstractCharacterBasedApplication::setNormalTextEditorMode(bool f)
	{
	m->is_quit_enabled = f;
	m->is_open_enabled = f;
	m->is_save_enabled = f;
	setTerminalMode(!f);
	}

	SelectionAnchor AbstractCharacterBasedApplication::currentAnchor(SelectionAnchor::Enabled enabled)
	{
	SelectionAnchor a;
	a.row = cx()->current_row;
	a.col = cx()->current_col;
	a.enabled = enabled;
	return a;
	}

	void AbstractCharacterBasedApplication::deselect()
	{
	selection_anchor_0.enabled = SelectionAnchor::No;
	selection_anchor_1.enabled = SelectionAnchor::No;
	}

	bool AbstractCharacterBasedApplication::isSelectionAnchorEnabled() const
	{
	return selection_anchor_0.enabled != SelectionAnchor::No;
	}

	void AbstractCharacterBasedApplication::setToggleSelectionAnchorEnabled(bool f)
	{
	m->is_toggle_selection_anchor_enabled = f;
	}

	void AbstractCharacterBasedApplication::setReadOnly(bool f)
	{
	m->is_read_only = f;
	}

	bool AbstractCharacterBasedApplication::isReadOnly() const
	{
	return m->is_read_only && !m->is_terminal_mode;
	}

	void AbstractCharacterBasedApplication::setSelectionAnchor(SelectionAnchor::Enabled enabled, bool update_anchor, bool auto_scroll)
	{
	if (update_anchor) {
	selection_anchor_0 = currentAnchor(enabled);
	} else {
	selection_anchor_0.enabled = enabled;
	}
	clearParsedLine();
	updateVisibility(false, false, auto_scroll);
	}

	void AbstractCharacterBasedApplication::toggleSelectionAnchor()
	{
	if (!m->is_toggle_selection_anchor_enabled) return;

	setSelectionAnchor(isSelectionAnchorEnabled() ? SelectionAnchor::No : SelectionAnchor::EnabledHard, true, true);
	selection_anchor_1 = selection_anchor_0;
	}

	void AbstractCharacterBasedApplication::editPaste()
	{
	if (isReadOnly()) return;
	if (isTerminalMode()) return;

	setPaintingSuppressed(true);

	QString str = qApp->clipboard()->text();
	utf16(str.utf16(), str.size()).to_utf32([&](uint32_t c){
	write(c, false);
	return true;
	});

	setPaintingSuppressed(false);
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::editCopy()
	{
	edit_(EditOperation::Copy);
	}

	void AbstractCharacterBasedApplication::editCut()
	{
	if (isReadOnly()) return;
	if (isTerminalMode()) return;
	edit_(EditOperation::Cut);
	}

	void AbstractCharacterBasedApplication::setWriteMode(WriteMode wm)
	{
	m->write_mode = wm;
	}

	bool AbstractCharacterBasedApplication::isInsertMode() const
	{
	return m->write_mode == WriteMode::Insert && !isTerminalMode();
	}

	bool AbstractCharacterBasedApplication::isOverwriteMode() const
	{
	return m->write_mode == WriteMode::Overwrite \|\| isTerminalMode();
	}

	void AbstractCharacterBasedApplication::setTerminalMode(bool f)
	{
	m->is_terminal_mode = f;
	if (isTerminalMode()) {
	showHeader(false);
	showFooter(false);
	showLineNumber(false, 0);
	setLineMargin(0);
	setWriteMode(WriteMode::Overwrite);
	setReadOnly(true);
	}
	layoutEditor();
	}

	bool AbstractCharacterBasedApplication::isTerminalMode() const
	{
	return m->is_terminal_mode;
	}

	bool AbstractCharacterBasedApplication::isBottom() const
	{
	if (cx()->current_row == m->parsed_row_index) {
	if (m->parsed_col_index == (int)m->prepared_current_line.size()) {
	return true;
	}
	}
	return false;
	}

	void AbstractCharacterBasedApplication::moveToTop()
	{
	if (isSingleLineMode()) return;

	deselect();

	cx()->current_row = 0;
	cx()->current_col = 0;
	cx()->current_col_hint = 0;
	cx()->scroll_row_pos = 0;
	scrollToTop();
	invalidateArea();
	clearParsedLine();
	updateVisibility(true, false, true);
	}

	void AbstractCharacterBasedApplication::logicalMoveToBottom()
	{
	deselect();

	cx()->current_row = documentLines();
	cx()->current_col = 0;
	if (cx()->current_row > 0) {
	cx()->current_row = cx()->current_row - 1;
	clearParsedLine();
	fetchCurrentLine();
	int col = calcVisualWidth(Document::Line(m->parsed_line));
	cx()->current_col = col;
	cx()->current_col_hint = col;
	}
	cx()->scroll_row_pos = scrollBottomLimit();
	}

	void AbstractCharacterBasedApplication::moveToBottom()
	{
	if (isSingleLineMode()) return;

	logicalMoveToBottom();

	invalidateArea();
	clearParsedLine();
	updateVisibility(true, false, true);
	}

	int AbstractCharacterBasedApplication::findSyntax(QList<Document::CharAttr_> const *list, size_t offset)
	{
	int lo = 0;
	int hi = list->size();
	while (lo + 1 < hi) {
	int mid = (lo + hi) / 2;
	Document::CharAttr_ const *a = &list->at(mid);
	if (offset == a->offset) {
	return mid;
	}
	if (offset < a->offset) {
	hi = mid;
	} else {
	lo = mid;
	}
	}
	return lo;
	}

	void AbstractCharacterBasedApplication::insertSyntax(QList<Document::CharAttr_> *list, size_t offset, Document::CharAttr_ const &a)
	{
	int i = findSyntax(list, offset);
	int n = list->size();
	if (i < n) {
	if (list->at(i).offset == offset) {
	(*list)[i] = a;
	} else {
	if (i < n) {
	if (a.offset < list->at(i).offset) {
	if (list->at(i).color == a.color) {
	(*list)[i].offset = offset;
	return;
	}
	}
	}
	if (list->at(i).color == a.color) {
	return;
	}
	if (list->at(i).offset < a.offset) {
	i++;
	}
	list->insert(list->begin() + i, a);
	while (++i < n) {
	(*list)[i].offset++;
	}
	}
	} else {
	list->push_back(a);
	}
	}

	void AbstractCharacterBasedApplication::internalWrite(const ushort begin, const ushort end)
	{
	deleteIfSelected();
	clearShiftModifier();

	if (cx()->engine->document.lines.isEmpty()) {
	Document::Line line;
	line.type = Document::Line::Normal;
	line.line_number = 1;
	cx()->engine->document.lines.push_back(line);
	}

	if (!isCurrentLineWritable()) return;

	int len = end - begin;
	parseLine(nullptr, len, false);
	int index = m->parsed_col_index;
	if (index < 0) {
	addNewLineToBottom();
	index = 0;
	}

	std::vector<uint32_t> *vec = &m->prepared_current_line;

	auto WriteChar = [&](ushort c){
	if (isInsertMode()) {
	vec->insert(vec->begin() + index, c);
	} else if (isOverwriteMode()) {
	if (index < (int)vec->size()) {
	ushort d = vec->at(index);
	if (d == '\n' \|\| d == '\r') {
	vec->insert(vec->begin() + index, c);
	} else {
	vec->at(index) = c;
	}
	} else {
	vec->push_back(c);
	}
	}
	Document::CharAttr_ a;
	a.offset = index;
	a.color = m->escape_sequence.fg_color_code();
	insertSyntax(&m->syntax_table, index, a);
	};

	ushort const *ptr = begin;
	while (ptr < end) {
	ushort c = *ptr;
	ptr++;
	if (c >= 0xd800 && c < 0xdc00) {
	if (ptr < end) {
	ushort d = *ptr;
	if (d >= 0xdc00 && d < 0xe000) {
	ptr++;
	int u = 0x10000 + (c - 0xd800) * 0x400 + (d - 0xdc00);
	WriteChar(u);
	index++;
	}
	}
	} else {
	WriteChar(c);
	index++;
	}
	}
	m->parsed_col_index = index;
	commitLine(*vec);
	setCursorColByIndex(*vec, index);
	updateVisibility(true, true, true);
	}

	void AbstractCharacterBasedApplication::pressLetterWithControl(int c)
	{
	if (c < 0 \|\| c > 0x7f) {
	return;
	}
	if (c < 0x40) {
	c += 0x40;
	}
	c = toupper(c);
	switch (c) {
	case 'A':
	toggleSelectionAnchor();
	break;
	case 'Q':
	onQuit();
	break;
	case 'O':
	onOpenFile();
	break;
	case 'S':
	onSaveFile();
	break;
	case 'X':
	editCut();
	break;
	case 'C':
	editCopy();
	break;
	case 'V':
	editPaste();
	break;
	}
	}

	void AbstractCharacterBasedApplication::write(uint32_t c, bool by_keyboard)
	{
	if (isTerminalMode()) {
	if (c == '\r') {
	setCursorCol(0);
	clearParsedLine();
	updateVisibility(true, true, true);
	return;
	}
	if (m->cursor_moved_by_mouse) {
	moveToBottom();
	}
	if (c == 0x1b \|\| m->escape_sequence.isActive()) {
	m->escape_sequence.write(c);
	return;
	}
	}

	bool ok = !(isTerminalMode() && by_keyboard);

	if (c < 0x20) {
	if (c == 0x08) {
	if (ok) {
	doBackspace();
	}
	} else if (c == 0x09) {
	if (ok) {
	ushort u = c;
	internalWrite(&u, &u + 1);
	}
	} else if (c == 0x0a) {
	if (ok) {
	pressEnter();
	}
	} else if (c == 0x0d) {
	if (ok) {
	writeCR();
	}
	} else if (c == 0x1b) {
	pressEscape();
	} else if (c >= 1 && c <= 26) {
	pressLetterWithControl(c);
	}
	} else if (c == 0x7f) {
	if (ok) {
	doDelete();
	}
	} else if (c < 0x10000) {
	if (ok) {
	ushort u = c;
	internalWrite(&u, &u + 1);
	}
	} else if (c >= 0x10000 && c <= 0x10ffff) {
	if (ok) {
	ushort t[2];
	t[0] = (c - 0x10000) / 0x400 + 0xd800;
	t[1] = (c - 0x10000) % 0x400 + 0xdc00;
	internalWrite(t, t + 2);
	}
	} else {
	switch (c) {
	case EscapeCode::Up:
	if (ok) moveCursorUp();
	break;
	case EscapeCode::Down:
	if (ok) moveCursorDown();
	break;
	case EscapeCode::Right:
	if (ok) moveCursorRight();
	break;
	case EscapeCode::Left:
	if (ok) moveCursorLeft();
	break;
	case EscapeCode::Home:
	if (ok) moveCursorHome();
	break;
	case EscapeCode::End:
	if (ok) moveCursorEnd();
	break;
	case EscapeCode::PageUp:
	if (ok) movePageUp();
	break;
	case EscapeCode::PageDown:
	if (ok) movePageDown();
	break;
	case EscapeCode::Insert:
	clearShiftModifier();
	break;
	case EscapeCode::Delete:
	clearShiftModifier();
	if (ok) doDelete();
	break;
	}
	}
	}

	void AbstractCharacterBasedApplication::write(char const *ptr, int len, bool by_keyboard)
	{
	if (isReadOnly()) return;

	char const *begin = ptr;
	char const *end = begin + (len < 0 ? strlen(ptr) : len);
	char const *left = begin;
	char const *right = begin;
	while (1) {
	int c = -1;
	if (right < end) {
	c = *right & 0xff;
	}
	if (c == '\n' \|\| c == '\r' \|\| c < 0) {
	utf8 src(left, right);
	while (1) {
	int d = src.next();
	if (d == 0) break;
	write(d, by_keyboard);
	}
	if (c < 0) break;
	right++;
	if (c == '\r') {
	c = isInsertMode() ? '\n' : '\r';
	if (right < end && *right == '\n') {
	c = '\n';
	right++;
	}
	write(c, by_keyboard);
	} else if (c == '\n') {
	write('\n', by_keyboard);
	}
	left = right;
	} else {
	right++;
	}
	}
	}

	void AbstractCharacterBasedApplication::write(const std::string &text)
	{
	if (!text.empty()) {
	write(text.c_str(), text.size(), false);
	}
	}

	void AbstractCharacterBasedApplication::write_(const char *ptr, bool by_keyboard)
	{
	write(ptr, -1, by_keyboard);
	}

	void AbstractCharacterBasedApplication::write_(QString text, bool by_keyboard)
	{
	if (isReadOnly()) return;

	if (text.size() == 1) {
	ushort c = text.at(0).unicode();
	write(c, by_keyboard);
	return;
	}
	int len = text.size();
	if (len > 0) {
	ushort const *begin = text.utf16();
	ushort const *end = begin + len;
	ushort const *left = begin;
	ushort const *right = begin;
	while (1) {
	int c = -1;
	if (right < end) {
	c = *right;
	}
	if (c < 0x20) {
	if (left < right) {
	internalWrite(left, right);
	}
	if (c == -1) break;
	right++;
	if (c == '\n' \|\| c == '\r') {
	if (c == '\r') {
	if (right < end && *right == '\n') {
	right++;
	}
	}
	writeNewLine();
	} else {
	write(c, by_keyboard);
	}
	left = right;
	} else {
	right++;
	}
	}
	}
	}



	void AbstractCharacterBasedApplication::write(QKeyEvent *e)
	{
	setModifierKeys(e->modifiers());

	int c = e->key();
	if (c == Qt::Key_Backspace) {
	write(0x08, true);
	} else if (c == Qt::Key_Delete) {
	write(0x7f, true);
	} else if (c == Qt::Key_Up) {
	if (isControlModifierPressed()) {
	scrollUp();
	} else {
	write(EscapeCode::Up, true);
	}
	} else if (c == Qt::Key_Down) {
	if (isControlModifierPressed()) {
	scrollDown();
	} else {
	write(EscapeCode::Down, true);
	}
	} else if (c == Qt::Key_Left) {
	write(EscapeCode::Left, true);
	} else if (c == Qt::Key_Right) {
	write(EscapeCode::Right, true);
	} else if (c == Qt::Key_PageUp) {
	write(EscapeCode::PageUp, true);
	} else if (c == Qt::Key_PageDown) {
	write(EscapeCode::PageDown, true);
	} else if (c == Qt::Key_Home) {
	if (isControlModifierPressed()) {
	moveToTop();
	} else {
	write(EscapeCode::Home, true);
	}
	} else if (c == Qt::Key_End) {
	if (isControlModifierPressed()) {
	moveToBottom();
	} else {
	write(EscapeCode::End, true);
	}
	} else if (c == Qt::Key_Return \|\| c == Qt::Key_Enter) {
	write('\n', true);
	} else if (c == Qt::Key_Escape) {
	write(0x1b, true);
	} else if (isControlModifierPressed()) {
	if (QChar(c).isLetter()) {
	c = QChar(c).toUpper().unicode();
	if (c >= 0x40 && c < 0x60) {
	write(c - 0x40, true);
	}
	}
	} else {
	QString text = e->text();
	write_(text, true);
	}
	}



	void Document::retrieveLastText(std::vector<char> *out, int maxlen) const
	{
	int remain = maxlen;
	int i = lines.size();
	while (i > 0 && remain > 0) {
	i--;
	QByteArray const &data = lines[i].text;
	int n = data.size();
	if (n > remain) {
	n = remain;
	}
	char const *p = data.data() + data.size() - n;
	out->insert(out->begin(), p, p + n);
	remain -= n;
	}
	}
	diff --git a/src/texteditor/AbstractCharacterBasedApplication.h b/src/texteditor/AbstractCharacterBasedApplication.h
	index 8e45e6b..a0747f3 100644
	--- a/src/texteditor/AbstractCharacterBasedApplication.h
	+++ b/src/texteditor/AbstractCharacterBasedApplication.h
	@@ -1,423 +1,421 @@
	#ifndef ABSTRACTCHARACTERBASEDAPPLICATION_H
	#define ABSTRACTCHARACTERBASEDAPPLICATION_H

	#include <QList>
	#include <QRect>
	#include <QString>
	#include <QByteArray>
	#include <memory>
	#include <vector>
	#include <functional>
	#include <QKeyEvent>
	#include <QColor>

	namespace EscapeCode {
	enum EscapeCode {
	Up = 0x1b5b4100,
	Down = 0x1b5b4200,
	Right = 0x1b5b4300,
	Left = 0x1b5b4400,
	Home = 0x1b4f4800,
	End = 0x1b4f4600,
	Insert = 0x1b5b327e,
	Delete = 0x1b5b337e,
	PageUp = 0x1b5b357e,
	PageDown = 0x1b5b367e,
	};
	}

	class Document {
	public:
	struct CharAttr_ {
	size_t offset = 0;
	int color = -1;
	};
	struct Line {
	enum Type {
	Unknown,
	Normal,
	Add,
	Del,
	};
	int type = Unknown;
	int hunk_number = -1;
	int line_number = 0;
	size_t byte_offset = 0;
	QByteArray text;

	- Line()
	- {
	- }
	+ Line() = default;

	explicit Line(QByteArray const &ba)
	: type(Normal)
	, text(ba)
	{
	}

	explicit Line(std::string const &str, Type type = Normal)
	: type(type)
	{
	text.append(str.c_str(), str.size());
	}
	};

	QList<Line> lines;
	void retrieveLastText(std::vector<char> *out, int maxlen) const;
	};

	class TextEditorEngine {
	public:
	Document document;
	TextEditorEngine()
	{
	document.lines.push_back(Document::Line(QByteArray()));
	}
	};

	struct SelectionAnchor {
	enum Enabled {
	No,
	EnabledHard,
	EnabledEasy,
	};

	Enabled enabled = No;
	int row = 0;
	int col = 0;
	int compare(SelectionAnchor const &a) const
	{
	if (enabled && a.enabled) {
	if (row < a.row) return -1;
	if (row > a.row) return 1;
	if (col < a.col) return -1;
	if (col > a.col) return 1;
	} else {
	if (a.enabled) return -1;
	if (enabled) return 1;
	}
	return 0;
	}
	bool operator == (SelectionAnchor const &a) const
	{
	return compare(a) == 0;
	}
	bool operator != (SelectionAnchor const &a) const
	{
	return compare(a) != 0;
	}
	bool operator < (SelectionAnchor const &a) const
	{
	return compare(a) < 0;
	}
	bool operator > (SelectionAnchor const &a) const
	{
	return compare(a) > 0;
	}
	bool operator <= (SelectionAnchor const &a) const
	{
	return compare(a) <= 0;
	}
	bool operator >= (SelectionAnchor const &a) const
	{
	return compare(a) >= 0;
	}
	};

	-typedef std::shared_ptr<TextEditorEngine> TextEditorEnginePtr;
	+using TextEditorEnginePtr = std::shared_ptr<TextEditorEngine>;

	struct TextEditorContext {
	QRect cursor_rect;
	bool single_line = false;
	int current_row = 0;
	int current_col = 0;
	int current_col_hint = 0;
	int saved_row = 0;
	int saved_col = 0;
	int saved_col_hint = 0;
	int current_char_span = 1;
	int scroll_row_pos = 0;
	int scroll_col_pos = 0;
	int viewport_org_x = 0;
	int viewport_org_y = 1;
	int viewport_width = 80;
	int viewport_height = 23;
	int tab_span = 4;
	int bottom_line_y = -1;
	TextEditorEnginePtr engine;
	};

	-typedef std::function<void(bool, QString const &text)> DialogHandler;
	+using DialogHandler = std::function<void (bool, const QString &)>;

	class AbstractCharacterBasedApplication {
	public:
	static const int LEFT_MARGIN = 8;
	static const int RIGHT_MARGIN = 10;

	enum class WriteMode {
	Insert,
	Overwrite,
	};

	enum class State {
	Normal,
	Exit,
	};

	struct CharAttr {
	uint16_t index;
	uint16_t flags = 0;
	QColor color;
	CharAttr(int index = Normal)
	: index(index)
	{
	}
	bool operator == (CharAttr const &r) const
	{
	return index == r.index && color == r.color;
	}
	bool operator != (CharAttr const &r) const
	{
	return !operator == (r);
	}
	enum Index {
	Normal,
	Invert,
	Hilite,
	};
	enum Flag {
	Selected = 0x0001,
	CurrentLine = 0x0002,
	};
	};

	struct Option {
	CharAttr char_attr;
	QRect clip;
	};

	struct Character {
	uint16_t c = 0;
	CharAttr a;
	};

	enum LineFlag {
	LineChanged = 1,
	};

	static int charWidth(uint32_t c);

	class FormattedLine {
	public:
	QString text;
	enum Attr {
	StyleID = 0x00ffffff,
	Selected = 0x01000000,
	};
	uint32_t atts;
	FormattedLine(QString const &text, int atts)
	: text(text)
	, atts(atts)
	{
	}
	bool isSelected() const
	{
	return atts & Selected;
	}
	};

	QList<FormattedLine> formatLine(const Document::Line &line, int tab_span, int anchor_a = -1, int anchor_b = -1) const;
	private:
	struct Private;
	Private *m;
	protected:
	SelectionAnchor selection_anchor_0;
	SelectionAnchor selection_anchor_1;
	protected:

	std::vector<Character> *screen();
	std::vector<Character> const *screen() const;
	std::vector<uint8_t> *line_flags();

	void initEditor();

	void fetchCurrentLine() const;
	void clearParsedLine();

	int cursorX() const;
	int cursorY() const;

	int editorViewportWidth() const;
	int editorViewportHeight() const;

	virtual int print(int x, int y, QString const &text, Option const &opt);

	std::shared_ptr<TextEditorContext> editor_cx;
	std::shared_ptr<TextEditorContext> dialog_cx;

	TextEditorContext *cx();
	TextEditorContext const *cx() const;

	Document *document();
	int documentLines() const;

	bool isSingleLineMode() const;

	void ensureCurrentLineVisible();
	int decideColumnScrollPos() const;

	int calcVisualWidth(Document::Line const &line) const;

	int leftMargin_() const;

	void makeBuffer();
	int printArea(const TextEditorContext cx, SelectionAnchor const sel_a = nullptr, SelectionAnchor const *sel_b = nullptr);

	int calcIndexToColumn(const std::vector<uint32_t> &vec, int index) const;

	virtual void updateVisibility(bool ensure_current_line_visible, bool change_col, bool auto_scroll) = 0;
	void commitLine(const std::vector<uint32_t> &vec);

	void doDelete();
	void doBackspace();

	bool isDialogMode();
	void setDialogMode(bool f);
	void closeDialog(bool result);
	- void setDialogOption(const QString &title, QString value, DialogHandler handler);
	+ void setDialogOption(const QString &title, const QString &value, DialogHandler handler);
	void execDialog(const QString &dialog_title, QString dialog_value, DialogHandler handler);
	void toggleSelectionAnchor();
	private:
	int internalParseLine(std::vector<uint32_t> *vec, int increase_hint) const;
	void internalWrite(const ushort begin, const ushort end);
	void pressLetterWithControl(int c);
	void invalidateAreaBelowTheCurrentLine();
	void onQuit();
	void onOpenFile();
	void onSaveFile();
	void printInvertedBar(int x, int y, const char *text, int padchar);
	SelectionAnchor currentAnchor(SelectionAnchor::Enabled enabled);
	enum class EditOperation {
	Cut,
	Copy,
	};
	void editSelected(EditOperation op, std::vector<uint32_t> *cutbuffer);
	void deselect();
	int calcColumnToIndex(int column);
	void edit_(EditOperation op);
	bool isCurrentLineWritable() const;
	- void initEngine(std::shared_ptr<TextEditorContext> cx);
	+ void initEngine(const std::shared_ptr<TextEditorContext>& cx);
	void writeCR();
	bool deleteIfSelected();
	static int findSyntax(const QList<Document::CharAttr_> *list, size_t offset);
	static void insertSyntax(QList<Document::CharAttr_> *list, size_t offset, const Document::CharAttr_ &a);
	protected:

	void parseLine(std::vector<uint32_t> *vec, int increase_hint, bool force);
	QByteArray parsedLine() const;
	void setCursorRow(int row, bool auto_scroll = true, bool by_mouse = false);
	void setCursorCol(int col, bool auto_scroll = true, bool by_mouse = false);
	void setCursorPos(int row, int col);
	void setCursorColByIndex(const std::vector<uint32_t> &vec, int col_index);
	int nextTabStop(int x) const;
	int scrollBottomLimit() const;
	bool isPaintingSuppressed() const;
	void setPaintingSuppressed(bool f);
	void scrollRight();
	void scrollLeft();

	void addNewLineToBottom();
	void appendNewLine(std::vector<uint32_t> *vec);
	void writeNewLine();
	void updateCursorPos(bool auto_scroll);

	QString statusLine() const;

	void preparePaintScreen();
	void setRecentlyUsedPath(const QString &path);
	QString recentlyUsedPath();
	void clearRect(int x, int y, int w, int h);
	- void paintLineNumbers(std::function<void(int, QString, const Document::Line *)> draw);
	+ void paintLineNumbers(std::function<void(int, QString, Document::Line const *line)> const &draw);
	bool isAutoLayout() const;
	void invalidateArea(int top_y = 0);
	void savePos();
	void restorePos();
	public:
	virtual void layoutEditor();
	void scrollUp();
	void scrollDown();
	void moveCursorOut();
	void moveCursorHome();
	void moveCursorEnd();
	void moveCursorUp();
	void moveCursorDown();
	void moveCursorLeft();
	void moveCursorRight();
	void movePageUp();
	void movePageDown();
	void scrollToTop();

	AbstractCharacterBasedApplication();
	virtual ~AbstractCharacterBasedApplication();
	TextEditorEnginePtr engine();
	int screenWidth() const;
	int screenHeight() const;
	void setScreenSize(int w, int h, bool update_layout);
	- void setTextEditorEngine(TextEditorEnginePtr e);
	+ void setTextEditorEngine(const TextEditorEnginePtr &e);
	void openFile(const QString &path);
	void saveFile(const QString &path);
	void loadExampleFile();
	void pressEnter();
	void pressEscape();
	State state() const;
	bool isLineNumberVisible() const;
	void showLineNumber(bool show, int left_margin = LEFT_MARGIN);
	void showHeader(bool f);
	void showFooter(bool f);
	void setAutoLayout(bool f);
	void setDocument(const QList<Document::Line> *source);
	void setSelectionAnchor(SelectionAnchor::Enabled enabled, bool update_anchor, bool auto_scroll);
	bool isSelectionAnchorEnabled() const;
	void setNormalTextEditorMode(bool f);
	void setToggleSelectionAnchorEnabled(bool f);
	void setReadOnly(bool f);
	bool isReadOnly() const;
	void editPaste();
	void editCopy();
	void editCut();
	void setWriteMode(WriteMode wm);
	bool isInsertMode() const;
	bool isOverwriteMode() const;
	void setTerminalMode(bool f);
	bool isTerminalMode() const;
	void moveToTop();
	void moveToBottom();
	bool isBottom() const;
	void setLineMargin(int n);
	void write(uint32_t c, bool by_keyboard);
	void write(const char *ptr, int len, bool by_keyboard);
	void write(std::string const &text);
	void write(QKeyEvent *e);
	void setTextCodec(QTextCodec *codec);
	void setCursorVisible(bool show);
	bool isCursorVisible();
	void setModifierKeys(Qt::KeyboardModifiers keymod);
	bool isControlModifierPressed() const;
	bool isShiftModifierPressed() const;
	void clearShiftModifier();
	void retrieveLastText(std::vector<char> *out, int maxlen) const;
	bool isChanged() const;
	void setChanged(bool f);
	void logicalMoveToBottom();
	protected:
	void write_(const char *ptr, bool by_keyboard);
	void write_(QString text, bool by_keyboard);
	void makeColumnPosList(std::vector<int> *out);
	};

	class AbstractTextEditorApplication : public AbstractCharacterBasedApplication {

	};


	#endif // ABSTRACTCHARACTERBASEDAPPLICATION_H
	diff --git a/src/texteditor/TextEditorTheme.cpp b/src/texteditor/TextEditorTheme.cpp
	index 3ae99e6..0e2cf21 100644
	--- a/src/texteditor/TextEditorTheme.cpp
	+++ b/src/texteditor/TextEditorTheme.cpp
	@@ -1,37 +1,37 @@
	+
	#include "TextEditorTheme.h"
	+#include <memory>
	+

	-TextEditorTheme::TextEditorTheme()
	-{
	-}

	TextEditorThemePtr TextEditorTheme::Light()
	{
	- TextEditorThemePtr t = TextEditorThemePtr(new TextEditorTheme());
	+ TextEditorThemePtr t = std::make_shared<TextEditorTheme>();
	t->fg_default = QColor(0, 0, 0);
	t->bg_default = QColor(240, 240, 240);
	t->fg_line_number = QColor(96, 96, 96);
	t->bg_line_number = QColor(208, 208, 208);
	t->fg_cursor = QColor(0, 128, 255);
	t->bg_current_line = QColor(192, 192, 192);
	t->bg_current_line_number = QColor(176, 176, 176);
	t->bg_diff_unknown = QColor(208, 208, 208);
	t->bg_diff_add = QColor(192, 240, 192);
	t->bg_diff_del = QColor(240, 208, 208);
	return t;
	}

	TextEditorThemePtr TextEditorTheme::Dark()
	{
	- TextEditorThemePtr t = TextEditorThemePtr(new TextEditorTheme());
	+ TextEditorThemePtr t = std::make_shared<TextEditorTheme>();
	t->fg_default = QColor(255, 255, 255);
	t->bg_default = QColor(48, 48, 48); // t->bg_default = QColor(0, 0, 64);
	t->fg_line_number = QColor(176, 176, 176);
	t->bg_line_number = QColor(64, 64, 64);
	t->fg_cursor = QColor(0, 128, 255);
	t->bg_current_line_number = QColor(96, 96, 96);
	t->bg_diff_unknown = QColor(0, 0, 0);
	t->bg_diff_add = QColor(0, 64, 0);
	t->bg_diff_del = QColor(80, 0, 0);
	return t;
	}

	diff --git a/src/texteditor/TextEditorTheme.h b/src/texteditor/TextEditorTheme.h
	index 769fa54..cdd25b8 100644
	--- a/src/texteditor/TextEditorTheme.h
	+++ b/src/texteditor/TextEditorTheme.h
	@@ -1,70 +1,70 @@
	#ifndef TEXTEDITORTHEME_H
	#define TEXTEDITORTHEME_H

	#include <QColor>
	#include <memory>

	class TextEditorTheme;

	typedef std::shared_ptr<TextEditorTheme> TextEditorThemePtr;

	class TextEditorTheme {
	public:
	QColor fg_default;
	QColor bg_default;
	QColor fg_line_number;
	QColor bg_line_number;
	QColor fg_cursor;
	QColor bg_current;
	QColor bg_current_line;
	QColor bg_current_line_number;
	QColor bg_diff_unknown;
	QColor bg_diff_add;
	QColor bg_diff_del;
	public:
	- TextEditorTheme();
	+ TextEditorTheme() = default;
	QColor fgDefault() const
	{
	return fg_default;
	}
	QColor bgDefault() const
	{
	return bg_default;
	}
	QColor fgLineNumber() const
	{
	return fg_line_number;
	}
	QColor bgLineNumber() const
	{
	return bg_line_number;
	}
	QColor fgCursor() const
	{
	return fg_cursor;
	}
	QColor bgCurrentLine() const
	{
	return bg_current_line;
	}
	QColor bgCurrentLineNumber() const
	{
	return bg_current_line_number;
	}
	QColor bgDiffUnknown() const
	{
	return bg_diff_unknown;
	}
	QColor bgDiffAdd() const
	{
	return bg_diff_add;
	}
	QColor bgDiffDel() const
	{
	return bg_diff_del;
	}
	static TextEditorThemePtr Dark();
	static TextEditorThemePtr Light();
	};

	#endif // TEXTEDITORTHEME_H
	diff --git a/src/texteditor/TextEditorWidget.cpp b/src/texteditor/TextEditorWidget.cpp
	index 7edd7b4..1355411 100644
	--- a/src/texteditor/TextEditorWidget.cpp
	+++ b/src/texteditor/TextEditorWidget.cpp
	@@ -1,735 +1,735 @@
	#include "TextEditorWidget.h"
	#include "TextEditorWidget.h"

	#include <QDebug>
	#include <QFile>
	#include <QFontDatabase>
	#include <QKeyEvent>
	#include <QPainter>
	#include <QScrollBar>
	#include <QApplication>
	#include <functional>
	#include <QMenu>
	#include <QTextCodec>
	#include <QTimer>

	#include "common/misc.h"
	#include "InputMethodPopup.h"
	#include "unicode.h"

	struct TextEditorWidget::Private {
	TextEditorWidget::RenderingMode rendering_mode = TextEditorWidget::CharacterMode;
	PreEditText preedit;
	QFont text_font;
	InputMethodPopup *ime_popup = nullptr;
	int top_margin = 0;
	int bottom_margin = 0;
	int latin1_width = 0;
	int line_height = 0;
	int ascent = 0;
	int descent = 0;

	QString status_line;
	QScrollBar *scroll_bar_v = nullptr;
	QScrollBar *scroll_bar_h = nullptr;

	TextEditorThemePtr theme;

	int wheel_delta = 0;

	bool is_focus_frame_visible = false;

	unsigned int idle_count = 0;

	std::function<void(void)> custom_context_menu_requested;
	};

	TextEditorWidget::TextEditorWidget(QWidget *parent)
	: QWidget(parent)
	, m(new Private)
	{
	#ifdef Q_OS_WIN
	m->text_font = QFont("MS Gothic", 10);
	#endif
	#ifdef Q_OS_LINUX
	m->text_font = QFont("Monospace", 9);
	#endif
	#ifdef Q_OS_MACX
	m->text_font = QFontDatabase().font("Osaka", "Regular-Mono", 14);
	#endif

	m->top_margin = 0;
	m->bottom_margin = 1;
	QPixmap pm(1, 1);
	QPainter pr(&pm);
	pr.setFont(textFont());
	QFontMetrics fm = pr.fontMetrics();
	m->ascent = fm.ascent();
	m->descent = fm.descent();
	m->latin1_width = fm.width('l');
	m->line_height = m->ascent + m->descent + m->top_margin + m->bottom_margin;
	// qDebug() << latin1Width() << fm.width("\xe3\x80\x93"); // GETA MARK

	initEditor();

	setFont(textFont());

	setAttribute(Qt::WA_InputMethodEnabled);
	#ifdef Q_OS_WIN
	m->ime_popup = new InputMethodPopup();
	m->ime_popup->setFont(font());
	m->ime_popup->setPreEditText(PreEditText());
	#endif

	setContextMenuPolicy(Qt::DefaultContextMenu);

	setRenderingMode(DecoratedMode);

	updateCursorRect(true);

	startTimer(100);
	}

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

	void TextEditorWidget::setTheme(TextEditorThemePtr theme)
	{
	m->theme = theme;
	}

	TextEditorTheme const *TextEditorWidget::theme() const
	{
	if (!m->theme) {
	const_cast<TextEditorWidget *>(this)->setTheme(TextEditorTheme::Light());
	}
	return m->theme.get();
	}

	void TextEditorWidget::setRenderingMode(RenderingMode mode)
	{
	m->rendering_mode = mode;
	if (m->rendering_mode == DecoratedMode) {
	showLineNumber(false);
	} else {
	showLineNumber(true);
	}
	update();
	}

	TextEditorWidget::RenderingMode TextEditorWidget::renderingMode() const
	{
	return m->rendering_mode;
	}

	void AbstractCharacterBasedApplication::loadExampleFile()
	{
	#ifdef Q_OS_WIN
	QString path = "C:/develop/ore/example.txt";
	#elif defined(Q_OS_MAC)
	QString path = "/Users/soramimi/develop/ore/example.txt";
	#else
	QString path = "/home/soramimi/develop/ore/example.txt";
	#endif
	openFile(path);
	}

	bool TextEditorWidget::event(QEvent *event)
	{
	if (event->type() == QEvent::Polish) {
	clearParsedLine();
	updateVisibility(true, true, true);
	}
	return QWidget::event(event);
	}

	int TextEditorWidget::latin1Width() const
	{
	return m->latin1_width;
	}

	int TextEditorWidget::lineHeight() const
	{
	return m->line_height;
	}

	QPoint TextEditorWidget::mapFromPixel(QPoint const &pt)
	{
	int x = pt.x() / latin1Width();
	int y = pt.y() / lineHeight();
	return QPoint(x, y);
	}

	QPoint TextEditorWidget::mapToPixel(QPoint const &pt)
	{
	int x = pt.x() * latin1Width();
	int y = pt.y() * lineHeight();
	return QPoint(x, y);
	}

	void TextEditorWidget::bindScrollBar(QScrollBar vsb, QScrollBar hsb)
	{
	m->scroll_bar_v = vsb;
	m->scroll_bar_h = hsb;
	}

	void TextEditorWidget::setupForLogWidget(QScrollBar vsb, QScrollBar hsb, TextEditorThemePtr theme)
	{
	bindScrollBar(vsb, hsb);
	setTheme(theme);
	setAutoLayout(true);
	setTerminalMode(true);
	layoutEditor();
	}

	QRect TextEditorWidget::updateCursorRect(bool auto_scroll)
	{
	updateCursorPos(auto_scroll);

	int x = cx()->viewport_org_x + cursorX();
	int y = cx()->viewport_org_y + cursorY();
	x *= latin1Width();
	y *= lineHeight();
	QPoint pt = QPoint(x, y);
	int w = cx()->current_char_span * latin1Width();
	int h = lineHeight();
	cx()->cursor_rect = QRect(pt.x(), pt.y(), w, h);

	QApplication::inputMethod()->update(Qt::ImCursorRectangle);

	return cx()->cursor_rect;
	}

	void TextEditorWidget::internalUpdateScrollBar()
	{
	QScrollBar *sb;

	sb = m->scroll_bar_v;
	if (sb) {
	sb->blockSignals(true);
	sb->setRange(0, document()->lines.size() - cx()->viewport_height / 2);
	sb->setPageStep(editorViewportHeight());
	sb->setValue(cx()->scroll_row_pos);
	sb->blockSignals(false);
	}

	sb = m->scroll_bar_h;
	if (sb) {
	int w = editorViewportWidth();
	sb->blockSignals(true);
	sb->setRange(0, w + 100);
	sb->setPageStep(w);
	sb->setValue(cx()->scroll_col_pos);
	sb->blockSignals(false);
	}

	emit updateScrollBar();
	}

	void TextEditorWidget::internalUpdateVisibility(bool ensure_current_line_visible, bool change_col, bool auto_scroll)
	{
	if (ensure_current_line_visible) {
	ensureCurrentLineVisible();
	}

	updateCursorRect(auto_scroll);

	if (change_col) {
	cx()->current_col_hint = cx()->current_col;
	}

	if (isPaintingSuppressed()) {
	return;
	}

	internalUpdateScrollBar();

	update();
	}

	void TextEditorWidget::updateVisibility(bool ensure_current_line_visible, bool change_col, bool auto_scroll)
	{
	internalUpdateVisibility(ensure_current_line_visible, change_col, auto_scroll);
	emit moved(cx()->current_row, cx()->current_col, cx()->scroll_row_pos, cx()->scroll_col_pos);
	}

	void TextEditorWidget::move(int cur_row, int cur_col, int scr_row, int scr_col, bool auto_scroll)
	{
	if ((cur_row >= 0 && cx()->current_row != cur_row) \|\| (cur_col >= 0 && cx()->current_col != cur_col) \|\| cx()->scroll_row_pos != scr_row \|\| cx()->scroll_col_pos != scr_col) {
	if (cur_row >= 0) cx()->current_row = cur_row;
	if (cur_col >= 0) cx()->current_col = cur_col;
	if (scr_row >= 0) cx()->scroll_row_pos = scr_row;
	if (scr_col >= 0) cx()->scroll_col_pos = scr_col;
	internalUpdateVisibility(false, true, auto_scroll);
	}
	}

	void TextEditorWidget::setPreEditText(const PreEditText &preedit)
	{
	m->preedit = preedit;
	update();
	}

	QFont TextEditorWidget::textFont()
	{
	return m->text_font;
	}

	void TextEditorWidget::drawText(QPainter *painter, int px, int py, QString const &str)
	{
	painter->drawText(px, py + lineHeight() - m->bottom_margin - m->descent, str);
	}

	QColor TextEditorWidget::defaultForegroundColor()
	{
	if (renderingMode() == DecoratedMode) {
	return theme()->fgDefault();
	}
	return Qt::white;
	}

	QColor TextEditorWidget::defaultBackgroundColor()
	{
	if (renderingMode() == DecoratedMode) {
	return theme()->bgDefault();
	}
	return Qt::black;
	}

	QColor TextEditorWidget::colorForIndex(CharAttr const &attr, bool foreground)
	{
	if (foreground && attr.color.isValid()) {
	return attr.color;
	}
	switch (attr.index) {
	case CharAttr::Invert:
	return foreground ? defaultBackgroundColor() : defaultForegroundColor();
	}
	return foreground ? defaultForegroundColor() : Qt::transparent;//defaultBackgroundColor();
	}

	void TextEditorWidget::paintScreen(QPainter *painter)
	{
	int w = screenWidth();
	int h = screenHeight();
	for (int y = 0; y < h; y++) {
	int x = 0;
	while (x < w) {
	std::vector<uint16_t> text;
	text.reserve(w);
	int o = y * w;
	CharAttr charattr;
	Character const *line = &screen()->at(o);
	int n = 0;
	while (x + n < w) {
	uint32_t c = line[x + n].c;
	uint32_t d = 0;
	if (c == 0 \|\| c == 0xffff) break;
	if ((c & 0xfc00) == 0xdc00) {
	// surrogate 2nd
	break;
	}
	uint32_t unicode = c;
	if ((c & 0xfc00) == 0xd800) {
	// surrogate 1st
	if (x + n + 1 < w) {
	uint16_t t = line[x + n + 1].c;
	if ((t & 0xfc00) == 0xdc00) {
	d = t;
	unicode = (((c & 0x03c0) + 0x0040) << 10) \| ((c & 0x003f) << 10) \| (d & 0x03ff);
	} else {
	break;
	}
	} else {
	break;
	}
	}
	int cw = charWidth(unicode);
	if (cw < 1) break;
	if (n == 0) {
	charattr = line[x].a;
	} else if (charattr != line[x + n].a) {
	break;
	}
	if (d == 0) {
	text.push_back(c);
	} else { // surrogate pair
	text.push_back(c);
	text.push_back(d);
	}
	n += cw;
	}
	if (n == 0) {
	n = 1;
	} else if (!text.empty()) {
	QString str = QString::fromUtf16(&text[0], text.size());
	int px = x * latin1Width();
	int py = y * lineHeight();
	painter->setFont(textFont());
	QFontMetrics fm = painter->fontMetrics();
	int w = fm.width(str);
	int h = lineHeight();
	QColor fgcolor = colorForIndex(charattr, true);
	QColor bgcolor = colorForIndex(charattr, false);
	painter->fillRect(px, py, w, h, bgcolor);
	painter->setPen(fgcolor);
	drawText(painter, px, py, str);
	}
	x += n;
	}
	}
	}

	void TextEditorWidget::drawCursor(QPainter *pr)
	{
	int x = cx()->viewport_org_x + cursorX();
	int y = cx()->viewport_org_y + cursorY();
	if (x < cx()->viewport_org_x \|\| x >= cx()->viewport_org_x + cx()->viewport_width) return;
	if (y < cx()->viewport_org_y \|\| y >= cx()->viewport_org_y + cx()->viewport_height) return;
	x *= latin1Width();
	y *= lineHeight();
	int h = lineHeight();
	pr->fillRect(x -1, y, 2, h, theme()->fgCursor());
	pr->fillRect(x - 2, y, 4, 2, theme()->fgCursor());
	pr->fillRect(x - 2, y + h - 2, 4, 2, theme()->fgCursor());
	}

	void TextEditorWidget::drawFocusFrame(QPainter *pr)
	{
	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 TextEditorWidget::paintEvent(QPaintEvent *)
	{
	bool has_focus = hasFocus();

	preparePaintScreen();

	QPainter pr(this);
	pr.fillRect(0, 0, width(), height(), defaultBackgroundColor());

	// diff mode
	if (renderingMode() == DecoratedMode) {
	auto FillRowBackground = [&](int row, QColor const &color){
	int y = editor_cx->viewport_org_y + row - editor_cx->scroll_row_pos;
	y *= lineHeight();
	pr.fillRect(0, y, width(), lineHeight(), color);
	};
	Document const &doc = editor_cx->engine->document;
	for (int i = 0; i < editor_cx->viewport_height; i++) {
	int row = i + editor_cx->scroll_row_pos;
	if (row < doc.lines.size()) {
	if (doc.lines[row].type == Document::Line::Unknown) {
	FillRowBackground(row, theme()->bgDiffUnknown());
	} else if (doc.lines[row].type == Document::Line::Add) {
	FillRowBackground(row, theme()->bgDiffAdd());
	} else if (doc.lines[row].type == Document::Line::Del) {
	FillRowBackground(row, theme()->bgDiffDel());
	}
	}
	}
	}

	auto visualY = [&](TextEditorContext const *context){
	return context->viewport_org_y + editor_cx->current_row - editor_cx->scroll_row_pos;
	};


	if (has_focus) {
	if (isCursorVisible()) {
	// current line
	if (renderingMode() == DecoratedMode) {
	int x = cx()->viewport_org_x * latin1Width();
	int y = visualY(cx()) * lineHeight();
	pr.fillRect(x, y, width() - x, lineHeight(), theme()->bgCurrentLine());
	pr.fillRect(x, y + lineHeight() - 1, width() - x, 1, theme()->fgCursor());
	}
	drawCursor(&pr);
	}
	}

	paintScreen(&pr);

	if (renderingMode() == DecoratedMode) {
	int linenum_width = editor_cx->viewport_org_x * latin1Width();
	auto FillLineNumberBG = [&](int y, int h, QColor color){
	pr.fillRect(0, y, linenum_width - 2, h, color);
	};
	int bottom = editor_cx->bottom_line_y;

	int view_y = editor_cx->viewport_org_y;
	int view_h = editor_cx->viewport_height;
	view_y *= lineHeight();
	view_h *= lineHeight();
	FillLineNumberBG(view_y, view_h, theme()->bgLineNumber());

	paintLineNumbers([&](int y, QString text, Document::Line const *line){
	if (bottom >= 0 && y > bottom) return;
	if (isCursorVisible() && y == visualY(editor_cx.get())) {
	FillLineNumberBG(y * lineHeight(), lineHeight(), theme()->bgCurrentLineNumber());
	}
	pr.setBackground(Qt::transparent);
	pr.setPen(theme()->fgLineNumber());
	drawText(&pr, 0, y * lineHeight(), text);
	if (line) {
	char const *mark = nullptr;
	if (line->type == Document::Line::Add) {
	mark = "+";
	} else if (line->type == Document::Line::Del) {
	mark = "-";
	}
	if (mark) {
	pr.setPen(theme()->fgDefault());
	drawText(&pr, linenum_width - latin1Width() * 3 / 2, y * lineHeight(), mark);
	}
	}
	});

	if (linenum_width > 0) {
	pr.fillRect(0, view_y, 1, view_h, Qt::black);
	}
	pr.fillRect(linenum_width - 2, view_y, 1, view_h, Qt::black);

	if (bottom >= 0) {
	int y = (editor_cx->viewport_org_y + bottom) * lineHeight() + 1;
	pr.fillRect(0, y, width(), 1, Qt::black);
	}
	}

	if (m->is_focus_frame_visible && has_focus) {
	drawFocusFrame(&pr);
	}
	}

	void TextEditorWidget::moveCursorByMouse()
	{
	QPoint mousepos = mapFromGlobal(QCursor::pos());
	int row, col;
	{
	QPoint pos = mapFromPixel(mousepos);
	row = pos.y() + cx()->scroll_row_pos - cx()->viewport_org_y;
	col = pos.x() + cx()->scroll_col_pos - cx()->viewport_org_x;
	}

	// row
	if (!isSingleLineMode()) {
	if (row < 0) {
	row = 0;
	} else {
	int maxrow = cx()->engine->document.lines.size();
	maxrow = maxrow > 0 ? (maxrow - 1) : 0;
	if (row > maxrow) {
	row = maxrow;
	}
	}
	}
	setCursorRow(row, false, true);

	// column
	{
	if (col < 0) {
	col = 0;
	} else {
	int mouse_x = mousepos.x() + (cx()->scroll_col_pos - cx()->viewport_org_x) * m->latin1_width;
	parseLine(nullptr, 0, true);
	std::vector<int> pts;
	makeColumnPosList(&pts);
	int newcol = 0;
	int distance = -1;
	for (size_t i = 0; i < pts.size(); i++) {
	int x = pts[i] * m->latin1_width;
	int d = abs(x - mouse_x);
	if (distance < 0 \|\| d < distance) {
	distance = d;
	newcol = x;
	}
	}
	col = newcol / m->latin1_width;
	}
	}
	setCursorCol(col, false, true);

	clearParsedLine();
	updateVisibility(false, true, false);
	}

	void TextEditorWidget::mousePressEvent(QMouseEvent *event)
	{
	if (event->button() == Qt::RightButton) return;

	savePos();

	bool shift = (event->modifiers() & Qt::ShiftModifier);
	if (shift) {
	if (isSelectionAnchorEnabled()) {
	setSelectionAnchor(SelectionAnchor::EnabledEasy, false, false);
	} else {
	setSelectionAnchor(SelectionAnchor::EnabledEasy, true, false);
	}
	}

	moveCursorByMouse();

	if (shift) {
	setSelectionAnchor(SelectionAnchor::EnabledEasy, false, false);
	} else {
	setSelectionAnchor(SelectionAnchor::EnabledEasy, true, false);
	}
	selection_anchor_1 = selection_anchor_0;

	if (isTerminalMode()) {
	clearParsedLine();
	restorePos();
	}
	}

	void TextEditorWidget::mouseReleaseEvent(QMouseEvent * /event/)
	{
	}

	void TextEditorWidget::mouseMoveEvent(QMouseEvent * /event/)
	{
	savePos();

	moveCursorByMouse();

	setSelectionAnchor(SelectionAnchor::EnabledEasy, true, false);

	if (isTerminalMode()) {
	clearParsedLine();
	restorePos();
	}
	}

	QVariant TextEditorWidget::inputMethodQuery(Qt::InputMethodQuery q) const
	{
	if (q == Qt::ImCursorRectangle) {
	QRect r = cx()->cursor_rect;
	return r;
	}
	return QWidget::inputMethodQuery(q);
	}

	void TextEditorWidget::inputMethodEvent(QInputMethodEvent *e)
	{
	#ifdef Q_OS_WIN
	PreEditText preedit;
	preedit.text = e->preeditString();
	for (QInputMethodEvent::Attribute const &a : e->attributes()) {
	if (a.type == QInputMethodEvent::TextFormat) {
	QTextFormat f = qvariant_cast<QTextFormat>(a.value);
	if (f.type() == QTextFormat::CharFormat) {
	- preedit.format.push_back(PreEditText::Format(a.start, a.length, f));
	+ preedit.format.emplace_back(a.start, a.length, f);
	} else {
	}
	}
	}
	if (preedit.text.isEmpty()) {
	m->ime_popup->hide();
	} else {
	QPoint pt = mapToGlobal(cx()->cursor_rect.topLeft());
	m->ime_popup->move(pt);
	m->ime_popup->setFont(font());
	m->ime_popup->setPreEditText(preedit);
	m->ime_popup->show();
	}
	#endif
	// qDebug() << e->preeditString() << e->commitString();

	- QString commit_text = e->commitString();
	+ QString const &commit_text = e->commitString();
	if (!commit_text.isEmpty()) {
	write_(commit_text, true);
	}
	}

	void TextEditorWidget::refrectScrollBar()
	{
	int v = m->scroll_bar_v ? m->scroll_bar_v->value() : -1;
	int h = m->scroll_bar_h ? m->scroll_bar_h->value() : -1;
	move(-1, -1, v, h, false);
	}

	void TextEditorWidget::layoutEditor()
	{
	if (isAutoLayout()) {
	int h = height() / lineHeight();
	int w = width() / latin1Width();
	setScreenSize(w, h, false);
	}
	AbstractTextEditorApplication::layoutEditor();
	}

	void TextEditorWidget::resizeEvent(QResizeEvent * /event/)
	{
	if (isAutoLayout()) {
	layoutEditor();
	}
	internalUpdateScrollBar();
	}

	void TextEditorWidget::wheelEvent(QWheelEvent *event)
	{
	int pos = 0;
	m->wheel_delta += event->delta();
	while (m->wheel_delta >= 40) {
	m->wheel_delta -= 40;
	pos--;
	}
	while (m->wheel_delta <= -40) {
	m->wheel_delta += 40;
	pos++;
	}
	if (m->scroll_bar_v) {
	m->scroll_bar_v->setValue(m->scroll_bar_v->value() + pos);
	}
	}

	void TextEditorWidget::setFocusFrameVisible(bool f)
	{
	m->is_focus_frame_visible = f;
	}



	void TextEditorWidget::timerEvent(QTimerEvent *)
	{
	if (!isChanged()) {
	m->idle_count++;
	if (m->idle_count >= 10) {
	m->idle_count = 0;
	emit idle();
	}
	}
	}

	void TextEditorWidget::contextMenuEvent(QContextMenuEvent *event)
	{
	QMenu menu;
	QAction *a_cut = nullptr;
	if (!isReadOnly() && !isTerminalMode()) a_cut = menu.addAction("Cut");
	QAction *a_copy = menu.addAction("Copy");
	QAction *a_paste = nullptr;
	if (!isReadOnly() && !isTerminalMode()) a_paste = menu.addAction("Paste");
	QAction *a = menu.exec(misc::contextMenuPos(this, event));
	if (a) {
	if (a == a_cut) {
	editCut();
	return;
	}
	if (a == a_copy) {
	editCopy();
	return;
	}
	if (a == a_paste) {
	editPaste();
	return;
	}
	}
	}




	diff --git a/src/texteditor/unicode.cpp b/src/texteditor/unicode.cpp
	index acc5c6c..4ee66a9 100644
	--- a/src/texteditor/unicode.cpp
	+++ b/src/texteditor/unicode.cpp
	@@ -1,369 +1,364 @@

	#include "unicode.h"


	namespace unicode_helper_ {

	class reader {
	public:
	- virtual ~reader() {}
	+ virtual ~reader() = default;
	virtual int get() = 0;
	};

	class writer8 {
	public:
	- virtual ~writer8() {}
	+ virtual ~writer8() = default;
	virtual void put(int c) = 0;
	};

	class writer16 {
	public:
	- virtual ~writer16() {}
	+ virtual ~writer16() = default;
	virtual void put(int c) = 0;
	};

	void clear_state(utf8_reader_state_t *s)
	{
	s->a = 0;
	s->b = 0;
	}

	int decode_utf8(utf8_reader_state_t *state, uint8_t c)
	{
	if (c & 0x80) {
	if (c & 0x40) {
	state->a = c;
	if (c & 0x20) {
	if (c & 0x10) {
	if (c & 0x08) {
	if (c & 0x04) {
	state->b = c & 0x01;
	} else {
	state->b = c & 0x03;
	}
	} else {
	state->b = c & 0x07;
	}
	} else {
	state->b = c & 0x0f;
	}
	} else {
	state->b = c & 0x1f;
	}
	return -1;
	} else {
	state->a <<= 1;
	state->b = (state->b << 6) \| (c & 0x3f);
	if ((state->a & 0x40) == 0) {
	return state->b;
	}
	return -1;
	}
	} else {
	state->a = 0;
	state->b = 0;
	return c;
	}
	}

	void encode_utf8(writer8 *writer, uint32_t code)
	{
	if (code < 0x80) {
	writer->put(code);
	} else if (code < 0x800) {
	writer->put((code >> 6) \| 0xc0);
	writer->put((code & 0x3f) \| 0x80);
	} else if (code < 0x10000) {
	writer->put((code >> 12) \| 0xe0);
	writer->put(((code >> 6) & 0x3f) \| 0x80);
	writer->put((code & 0x3f) \| 0x80);
	} else if (code < 0x200000) {
	writer->put((code >> 18) \| 0xf0);
	writer->put(((code >> 12) & 0x3f) \| 0x80);
	writer->put(((code >> 6) & 0x3f) \| 0x80);
	writer->put((code & 0x3f) \| 0x80);
	} else if (code < 0x4000000) {
	writer->put((code >> 24) \| 0xf8);
	writer->put(((code >> 18) & 0x3f) \| 0x80);
	writer->put(((code >> 12) & 0x3f) \| 0x80);
	writer->put(((code >> 6) & 0x3f) \| 0x80);
	writer->put((code & 0x3f) \| 0x80);
	} else {
	writer->put((code >> 30) \| 0xfc);
	writer->put(((code >> 24) & 0x3f) \| 0x80);
	writer->put(((code >> 18) & 0x3f) \| 0x80);
	writer->put(((code >> 12) & 0x3f) \| 0x80);
	writer->put(((code >> 6) & 0x3f) \| 0x80);
	writer->put((code & 0x3f) \| 0x80);
	}
	}

	void encode_utf16(writer16 *writer, uint32_t code)
	{
	if (code >= 0x010000 && code <= 0x10ffff) {
	uint16_t hi = (code - 0x10000) / 0x400 + 0xD800;
	uint16_t lo = (code - 0x10000) % 0x400 + 0xDC00;
	writer->put(hi);
	writer->put(lo);
	return;
	}
	writer->put(code);
	}

	//

	utf8decoder::utf8decoder(const char begin, const char end)
	: begin(begin)
	, end(end)
	, pos(0)
	{
	clear_state(&s);
	}

	uint32_t utf8decoder::next()
	{
	while (begin + pos < end) {
	int c = decode_utf8(&s, (uint8_t)begin[pos]);
	pos++;
	if (c >= 0) return c;
	}
	return 0;
	}

	} // namespace


	//

	utf32::utf32(const uint32_t ptr, const uint32_t end)
	{
	data.ptr = ptr;
	data.end = end;
	}

	utf32::utf32(const uint32_t *ptr)
	{
	data.ptr = ptr;
	for (data.end = ptr; *data.end; data.end++);
	}

	utf32::utf32(const uint32_t *ptr, size_t len)
	{
	data.ptr = ptr;
	data.end = ptr + len;
	}

	uint32_t utf32::next()
	{
	if (data.ptr && data.ptr < data.end) {
	return *data.ptr++;
	}
	return 0;
	}

	//

	utf16::utf16(const uint16_t ptr, const uint16_t end)
	{
	data.ptr = ptr;
	data.end = end;
	}

	utf16::utf16(const uint16_t *ptr)
	{
	data.ptr = ptr;
	for (data.end = ptr; *data.end; data.end++);
	}

	utf16::utf16(const uint16_t *ptr, size_t len)
	{
	data.ptr = ptr;
	data.end = ptr + len;
	}

	uint32_t utf16::next()
	{
	if (data.ptr && data.ptr < data.end) {
	uint32_t code = *data.ptr++;
	if (code >= 0xd800 && code < 0xdc00) {
	if (data.ptr < data.end) {
	uint32_t low = *data.ptr;
	if (low >= 0xdc00 && low < 0xe000) {
	code = 0x10000 + (code - 0xd800) * 0x0400 + (low - 0xdc00);
	data.ptr++;
	}
	}
	}
	return code;
	}
	return 0;
	}

	//

	class utf8encoder::internal_writer : public unicode_helper_::writer8 {
	public:
	char *dst;
	int len;
	public:
	internal_writer(char *p)
	: dst(p)
	, len(0)
	{
	}
	- virtual ~internal_writer()
	- {
	- }
	- virtual void put(int c)
	+ ~internal_writer() override = default;
	+ void put(int c) override
	{
	dst[len++] = c;
	}
	};

	utf8encoder::utf8encoder(abstract_unicode_reader *reader)
	{
	set(reader);
	}

	void utf8encoder::set(abstract_unicode_reader *reader)
	{
	data.reader = reader;
	data.len = 0;
	data.pos = 0;
	}

	bool utf8encoder::next_()
	{
	if (data.pos < data.len) {
	data.c = data.buf[data.pos];
	data.pos++;
	return true;
	}
	data.c = 0;
	return false;
	}

	bool utf8encoder::next()
	{
	if (next_()) {
	return true;
	}
	if (data.reader) {
	uint32_t code = data.reader->next();
	if (code) {
	internal_writer w(data.buf);
	unicode_helper_::encode_utf8(&w, code);
	data.len = w.len;
	data.pos = 0;
	return next_();
	}
	}
	return false;
	}

	char utf8encoder::get()
	{
	if (next()) {
	return data.c;
	}
	return 0;
	}

	int utf8encoder::pos() const
	{
	return data.pos;
	}

	//

	class utf16encoder::internal_writer : public unicode_helper_::writer16 {
	public:
	uint16_t *dst;
	- int len;
	+ int len = 0;
	public:
	internal_writer(uint16_t *p)
	: dst(p)
	- , len(0)
	- {
	- }
	- virtual ~internal_writer()
	{
	}
	- virtual void put(int c)
	+ ~internal_writer() override = default;
	+ void put(int c) override
	{
	dst[len++] = c;
	}
	};

	utf16encoder::utf16encoder(abstract_unicode_reader *reader)
	{
	set(reader);
	}

	void utf16encoder::set(abstract_unicode_reader *reader)
	{
	data.reader = reader;
	data.len = 0;
	data.pos = 0;
	}

	bool utf16encoder::next_()
	{
	if (data.pos < data.len) {
	data.c = data.buf[data.pos];
	data.pos++;
	return true;
	}
	data.c = 0;
	return false;
	}

	bool utf16encoder::next()
	{
	if (next_()) {
	return true;
	}
	if (data.reader) {
	uint32_t code = data.reader->next();
	if (code) {
	internal_writer w(data.buf);
	unicode_helper_::encode_utf16(&w, code);
	data.len = w.len;
	data.pos = 0;
	return next_();
	}
	}
	return false;
	}

	uint16_t utf16encoder::get()
	{
	if (next()) {
	return data.c;
	}
	return 0;
	}

	//

	utf8::utf8(const char ptr, const char end)
	: reader(ptr, end)
	{
	}

	utf8::utf8(const char *ptr)
	: reader(ptr, ptr + strlen(ptr))
	{
	}

	utf8::utf8(const char *ptr, size_t len)
	: reader(ptr, ptr + len)
	{
	}

	uint32_t utf8::next()
	{
	return reader.next();
	}


	diff --git a/src/win32/Win32Process.cpp b/src/win32/Win32Process.cpp
	index 62b1e72..a5870f9 100644
	--- a/src/win32/Win32Process.cpp
	+++ b/src/win32/Win32Process.cpp
	@@ -1,276 +1,276 @@
	#include <windows.h>
	#include "Win32Process.h"
	#include <QThread>
	#include <QTextCodec>
	#include <deque>
	#include <QDir>
	#include <QDebug>
	#include <QDateTime>
	#include <QMutex>


	class OutputReaderThread : public QThread {
	private:
	HANDLE hRead;
	QMutex *mutex;
	std::deque<char> *buffer;
	protected:
	- void run()
	+ void run() override
	{
	while (1) {
	char buf[256];
	DWORD len = 0;
	if (!ReadFile(hRead, buf, sizeof(buf), &len, nullptr)) break;
	if (len < 1) break;
	if (buffer) {
	QMutexLocker lock(mutex);
	buffer->insert(buffer->end(), buf, buf + len);
	}
	}
	}
	public:
	OutputReaderThread(HANDLE hRead, QMutex mutex, std::deque<char> buffer)
	: hRead(hRead)
	, mutex(mutex)
	, buffer(buffer)
	{
	}
	};

	class Win32ProcessThread : public QThread {
	friend class Win32Process2;
	private:
	public:
	QMutex *mutex = nullptr;
	std::string command;
	DWORD exit_code = -1;
	std::deque<char> inq;
	std::deque<char> outq;
	std::deque<char> errq;
	bool use_input = false;
	HANDLE hInputWrite = INVALID_HANDLE_VALUE;
	bool close_input_later = false;

	void reset()
	{
	mutex = nullptr;
	command.clear();
	exit_code = -1;
	inq.clear();
	outq.clear();
	errq.clear();
	use_input = false;
	hInputWrite = INVALID_HANDLE_VALUE;
	close_input_later = false;
	}

	protected:
	- void run()
	+ void run() override
	{
	try {
	hInputWrite = INVALID_HANDLE_VALUE;
	HANDLE hOutputRead = INVALID_HANDLE_VALUE;
	HANDLE hErrorRead = INVALID_HANDLE_VALUE;

	HANDLE hInputWriteTmp = INVALID_HANDLE_VALUE;
	HANDLE hOutputReadTmp = INVALID_HANDLE_VALUE;
	HANDLE hErrorReadTmp = INVALID_HANDLE_VALUE;
	HANDLE hInputRead = INVALID_HANDLE_VALUE;
	HANDLE hOutputWrite = INVALID_HANDLE_VALUE;
	HANDLE hErrorWrite = INVALID_HANDLE_VALUE;

	SECURITY_ATTRIBUTES sa;

	sa.nLength = sizeof(SECURITY_ATTRIBUTES);
	- sa.lpSecurityDescriptor = 0;
	+ sa.lpSecurityDescriptor = nullptr;
	sa.bInheritHandle = TRUE;

	HANDLE currproc = GetCurrentProcess();

	// パイプを作成
	if (!CreatePipe(&hInputRead, &hInputWriteTmp, &sa, 0))
	throw std::string("Failed to CreatePipe");

	if (!CreatePipe(&hOutputReadTmp, &hOutputWrite, &sa, 0))
	throw std::string("Failed to CreatePipe");

	if (!CreatePipe(&hErrorReadTmp, &hErrorWrite, &sa, 0))
	throw std::string("Failed to CreatePipe");

	// 子プロセスの標準入力
	if (!DuplicateHandle(currproc, hInputWriteTmp, currproc, &hInputWrite, 0, FALSE, DUPLICATE_SAME_ACCESS))
	throw std::string("Failed to DupliateHandle");

	// 子プロセスの標準出力
	if (!DuplicateHandle(currproc, hOutputReadTmp, currproc, &hOutputRead, 0, FALSE, DUPLICATE_SAME_ACCESS))
	throw std::string("Failed to DupliateHandle");

	// 子プロセスのエラー出力
	if (!DuplicateHandle(currproc, hErrorReadTmp, currproc, &hErrorRead, 0, FALSE, DUPLICATE_SAME_ACCESS))
	throw std::string("Failed to DuplicateHandle");

	// 不要なハンドルを閉じる
	CloseHandle(hInputWriteTmp);
	CloseHandle(hOutputReadTmp);
	CloseHandle(hErrorReadTmp);

	// プロセス起動
	PROCESS_INFORMATION pi;
	STARTUPINFOA si;

	ZeroMemory(&si, sizeof(STARTUPINFO));
	si.cb = sizeof(STARTUPINFO);
	si.dwFlags = STARTF_USESTDHANDLES \| STARTF_USESHOWWINDOW;
	si.wShowWindow = SW_HIDE;
	si.hStdInput = hInputRead; // 標準入力ハンドル
	si.hStdOutput = hOutputWrite; // 標準出力ハンドル
	si.hStdError = hErrorWrite; // エラー出力ハンドル

	char tmp = (char )alloca(command.size() + 1);
	strcpy(tmp, command.c_str());
	- if (!CreateProcessA(0, tmp, 0, 0, TRUE, CREATE_NO_WINDOW, 0, 0, &si, &pi)) {
	+ if (!CreateProcessA(nullptr, tmp, nullptr, nullptr, TRUE, CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi)) {
	throw std::string("Failed to CreateProcess");
	}

	// 不要なハンドルを閉じる
	CloseHandle(hInputRead);
	CloseHandle(hOutputWrite);
	CloseHandle(hErrorWrite);

	if (!use_input) {
	closeInput();
	}

	OutputReaderThread t1(hOutputRead, mutex, &outq);
	OutputReaderThread t2(hErrorRead, mutex, &errq);
	t1.start();
	t2.start();

	while (WaitForSingleObject(pi.hProcess, 1) != WAIT_OBJECT_0) {
	QMutexLocker lock(mutex);
	int n = inq.size();
	if (n > 0) {
	while (n > 0) {
	char tmp[1024];
	int l = n;
	if (l > sizeof(tmp)) {
	l = sizeof(tmp);
	}
	std::copy(inq.begin(), inq.begin() + l, tmp);
	inq.erase(inq.begin(), inq.begin() + l);
	if (hInputWrite != INVALID_HANDLE_VALUE) {
	DWORD written;
	WriteFile(hInputWrite, tmp, l, &written, nullptr);
	}
	n -= l;
	}
	} else if (close_input_later) {
	closeInput();
	}
	}

	t1.wait();
	t2.wait();

	CloseHandle(hOutputRead);
	CloseHandle(hErrorRead);

	GetExitCodeProcess(pi.hProcess, &exit_code);

	// 終了
	CloseHandle(pi.hThread);
	CloseHandle(pi.hProcess);
	} catch (std::string const &e) { // 例外
	OutputDebugStringA(e.c_str());
	}
	}
	public:
	void closeInput()
	{
	CloseHandle(hInputWrite);
	hInputWrite = INVALID_HANDLE_VALUE;
	}
	void writeInput(const char *ptr, int len)
	{
	QMutexLocker lock(mutex);
	inq.insert(inq.end(), ptr, ptr + len);
	}
	};

	QString toQString(const std::vector<char> &vec)
	{
	if (vec.empty()) return QString();
	return QString::fromUtf8(&vec[0], vec.size());
	}

	struct Win32Process::Private {
	QMutex mutex;
	Win32ProcessThread th;

	};

	Win32Process::Win32Process()
	: m(new Private)
	{

	}

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

	void Win32Process::start(QString const &command, bool use_input)
	{
	QTextCodec *sjis = QTextCodec::codecForName("Shift_JIS");
	Q_ASSERT(sjis);

	QByteArray ba = sjis->fromUnicode(command);
	ba.push_back((char)0);
	char const *cmd = ba.data();

	m->th.mutex = &m->mutex;
	m->th.use_input = use_input;
	m->th.command = cmd;
	m->th.start();
	}

	int Win32Process::wait()
	{
	m->th.wait();

	outbytes.clear();
	errbytes.clear();
	outbytes.insert(outbytes.end(), m->th.outq.begin(), m->th.outq.end());
	errbytes.insert(errbytes.end(), m->th.errq.begin(), m->th.errq.end());
	int exit_code = m->th.exit_code;
	m->th.reset();
	return exit_code;
	}

	QString Win32Process::outstring() const
	{
	return toQString(outbytes);
	}

	QString Win32Process::errstring() const
	{
	return toQString(errbytes);
	}

	void Win32Process::writeInput(char const *ptr, int len)
	{
	m->th.writeInput(ptr, len);
	}

	void Win32Process::closeInput(bool justnow)
	{
	if (justnow) {
	m->th.closeInput();
	} else {
	m->th.close_input_later = true;
	}
	}



	diff --git a/src/win32/Win32PtyProcess.cpp b/src/win32/Win32PtyProcess.cpp
	index 908d566..63581b7 100644
	--- a/src/win32/Win32PtyProcess.cpp
	+++ b/src/win32/Win32PtyProcess.cpp
	@@ -1,256 +1,256 @@
	#include <windows.h>
	#include "Win32PtyProcess.h"
	#include <deque>

	#include <winpty.h>

	#include <QDir>
	#include <QMutex>

	namespace {

	class OutputReaderThread : public QThread {
	friend class ::Win32PtyProcess;
	private:
	public:
	HANDLE handle;
	std::deque<char> *output_queue = nullptr;
	std::vector<char> *output_vector = nullptr;
	protected:
	- void run();
	+ void run() override;
	public:
	void start(HANDLE hOutput, std::deque<char> outq, std::vector<char> outv);
	};

	void OutputReaderThread::run()
	{
	char buf[1024];
	while (1) {
	if (isInterruptionRequested()) break;
	DWORD amount = 0;
	BOOL ret = ReadFile(handle, buf, sizeof(buf), &amount, nullptr);
	if (!ret \|\| amount == 0) {
	break;
	}
	output_queue->insert(output_queue->end(), buf, buf + amount);
	output_vector->insert(output_vector->end(), buf, buf + amount);
	}
	}

	void OutputReaderThread::start(HANDLE hOutput, std::deque<char> outq, std::vector<char> outv)
	{
	handle = hOutput;
	output_queue = outq;
	output_vector = outv;
	QThread::start();
	}

	} // namespace

	// Win32PtyProcess

	struct Win32PtyProcess::Private {
	QMutex mutex;
	QString command;
	std::deque<char> output_queue;
	std::vector<char> output_vector;
	OutputReaderThread th_output_reader;
	HANDLE hProcess = INVALID_HANDLE_VALUE;
	HANDLE hOutput = INVALID_HANDLE_VALUE;
	HANDLE hInput = INVALID_HANDLE_VALUE;
	DWORD exit_code = 0;
	};

	Win32PtyProcess::Win32PtyProcess()
	: m(new Private)
	{
	}

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

	bool Win32PtyProcess::isRunning() const
	{
	return QThread::isRunning();
	}

	QString Win32PtyProcess::getProgram(const QString &cmdline)
	{
	ushort const *begin = cmdline.utf16();
	ushort const *end = begin + cmdline.size();
	ushort const *ptr = begin;
	bool quote = 0;
	while (1) {
	ushort c = 0;
	if (ptr < end) {
	c = *ptr;
	}
	if (c == '\"') {
	if (quote) {
	quote = false;
	} else {
	quote = true;
	}
	ptr++;
	} else if (quote && c != 0) {
	ptr++;
	} else if (QChar(c).isSpace() \|\| c == 0) {
	break;
	} else {
	ptr++;
	}
	}
	ushort const *left = begin;
	ushort const *right = ptr;
	if (left + 1 < right) {
	if (left[0] == '\"' && right[-1] == '\"') {
	left++;
	right--;
	}
	}
	return QString::fromUtf16(left, right - left);
	}

	void Win32PtyProcess::run()
	{
	QString program;
	program = getProgram(m->command);

	QDir::setCurrent(change_dir);

	winpty_config_t *agent_cfg = winpty_config_new(WINPTY_FLAG_PLAIN_OUTPUT, nullptr);
	winpty_t *pty = winpty_open(agent_cfg, nullptr);
	winpty_config_free(agent_cfg);

	m->hInput = CreateFileW(winpty_conin_name(pty), GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
	m->hOutput = CreateFileW(winpty_conout_name(pty), GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr);
	m->th_output_reader.start(m->hOutput, &m->output_queue, &m->output_vector);

	winpty_spawn_config_t spawn_cfg = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, (wchar_t const )program.utf16(), (wchar_t const *)m->command.utf16(), nullptr, nullptr, nullptr);
	BOOL spawnSuccess = winpty_spawn(pty, spawn_cfg, &m->hProcess, nullptr, nullptr, nullptr);

	if (spawnSuccess) {
	while (1) {
	if (isInterruptionRequested()) break;
	GetExitCodeProcess(m->hProcess, &m->exit_code);
	if (m->exit_code == STILL_ACTIVE) {
	// running
	msleep(1);
	} else {
	break;
	}
	}
	}

	// プロセスの出力を確実に取得するため、ここで output reader スレッドの終了を待つ
	m->th_output_reader.wait();

	winpty_free(pty);

	CloseHandle(m->hInput);
	CloseHandle(m->hOutput);
	CloseHandle(m->hProcess);
	m->hInput = INVALID_HANDLE_VALUE;
	m->hOutput = INVALID_HANDLE_VALUE;
	m->hProcess = INVALID_HANDLE_VALUE;

	emit completed();
	}

	int Win32PtyProcess::readOutput(char *dstptr, int maxlen)
	{
	int len = m->output_queue.size();
	if (len > maxlen) {
	len = maxlen;
	}
	if (len > 0) {
	auto begin = m->output_queue.begin();
	std::copy(begin, begin + len, dstptr);
	m->output_queue.erase(begin, begin + len);
	}
	return len;
	}

	void Win32PtyProcess::writeInput(const char *ptr, int len)
	{
	char const *begin = ptr;
	char const *end = begin + len;
	char const *left = begin;
	char const *right = begin;
	while (1) {
	int c = -1;
	if (right < end) {
	c = *right & 0xff;
	}
	if (c == '\r' \|\| c == '\n' \|\| c < 0) {
	if (left < right) {
	DWORD written;
	- WriteFile(m->hInput, left, right - left, &written, 0);
	+ WriteFile(m->hInput, left, right - left, &written, nullptr);
	}
	if (c < 0) break;
	right++;
	if (c == '\r') {
	if (*right == '\n') {
	right++;
	}
	c = '\r';
	} else if (c == '\n') {
	c = '\r';
	} else {
	c = -1;
	}
	if (c >= 0) {
	DWORD written;
	- WriteFile(m->hInput, &c, 1, &written, 0);
	+ WriteFile(m->hInput, &c, 1, &written, nullptr);
	}
	left = right;
	} else {
	right++;
	}
	}
	}

	void Win32PtyProcess::start(const QString &cmdline)
	{
	if (isRunning()) return;
	m->command = cmdline;
	QThread::start();
	}

	bool Win32PtyProcess::wait(unsigned long time)
	{
	return QThread::wait(time) && m->th_output_reader.wait(time);
	}

	void Win32PtyProcess::stop()
	{
	// 標準出力読み出しスレッドを強制終了しないとwinptyプロセスが終了してくれない
	m->th_output_reader.terminate();
	// プロセススレッド停止
	requestInterruption();
	wait();
	}

	const std::vector<char> *Win32PtyProcess::result() const
	{
	return &m->output_vector;
	}

	int Win32PtyProcess::getExitCode() const
	{
	return m->exit_code;
	}

	QString Win32PtyProcess::getMessage() const
	{
	QString s;
	if (!m->output_vector.empty()) {
	s = QString::fromUtf8(&m->output_vector[0], m->output_vector.size());
	}
	return s;
	}



	diff --git a/src/win32/event.cpp b/src/win32/event.cpp
	index 77c67ec..134f316 100644
	--- a/src/win32/event.cpp
	+++ b/src/win32/event.cpp
	@@ -1,71 +1,71 @@

	#ifdef WIN32
	#include <windows.h>
	#else
	#include <pthread.h>
	#include <sys/time.h>
	#endif

	#include "event.h"

	#ifdef WIN32

	Event::Event()
	{
	- _handle = CreateEvent(0, FALSE, FALSE, 0);
	+ _handle = CreateEvent(nullptr, FALSE, FALSE, nullptr);
	}

	Event::~Event()
	{
	CloseHandle(_handle);
	}

	bool Event::wait(int ms)
	{
	if (ms < 0) {
	return WaitForSingleObject(_handle, INFINITE) == WAIT_OBJECT_0;
	} else {
	return WaitForSingleObject(_handle, ms) == WAIT_OBJECT_0;
	}
	}

	void Event::signal()
	{
	SetEvent(_handle);
	}

	#else

	Event::Event()
	{
	pthread_cond_init(&_cond, 0);
	}

	Event::~Event()
	{
	pthread_cond_destroy(&_cond);
	}

	bool Event::wait(int ms)
	{
	if (ms < 0) {
	pthread_cond_wait(&_cond, &_mutex._handle);
	return false;
	} else {
	struct timeval tv;
	struct timespec ts;
	gettimeofday(&tv, 0);
	long long t = (long long)tv.tv_sec * 1000000 + tv.tv_usec;
	t = t * 1000 + ms * 1000000LL;
	ts.tv_sec = t / 1000000000;
	ts.tv_nsec = t % 1000000000;
	return pthread_cond_timedwait(&_cond, &_mutex._handle, &ts) == EINTR;
	}
	}

	void Event::signal()
	{
	pthread_cond_signal(&_cond);
	}

	#endif
	diff --git a/src/win32/thread.cpp b/src/win32/thread.cpp
	index 8d06197..cd97ac2 100644
	--- a/src/win32/thread.cpp
	+++ b/src/win32/thread.cpp
	@@ -1,80 +1,80 @@
	#include "thread.h"

	#ifdef WIN32
	unsigned int __stdcall Thread::run_(void *arg)
	{
	Thread me = (Thread )arg;
	me->run();
	me->_running = false;
	return 0;
	}
	#else
	void Thread::run_(void arg)
	{
	Thread me = (Thread )arg;
	me->run();
	me->_running = false;
	return 0;
	}
	#endif

	void Thread::start()
	{
	detach();
	_interrupted = false;
	#ifdef WIN32
	- _thread_handle = (HANDLE)_beginthreadex(0, 0, run_, this, CREATE_SUSPENDED, 0);
	+ _thread_handle = (HANDLE)_beginthreadex(nullptr, 0, run_, this, CREATE_SUSPENDED, nullptr);
	ResumeThread(_thread_handle);
	#else
	pthread_create(&_thread_handle, NULL, run_, this);
	#endif
	_running = true;
	}

	void Thread::stop()
	{
	_interrupted = true;
	}

	void Thread::join()
	{
	if (_running) {
	#ifdef WIN32
	WaitForSingleObject(_thread_handle, INFINITE);
	#else
	pthread_join(_thread_handle, 0);
	#endif
	_running = false;
	}
	_interrupted = false;
	}

	void Thread::terminate()
	{
	if (_running) {
	#ifdef WIN32
	TerminateThread(_thread_handle, 0);
	#else
	pthread_cancel(_thread_handle);
	#endif
	_running = false;
	}
	_interrupted = false;
	}

	void Thread::detach()
	{
	#ifdef WIN32
	if (_thread_handle) {
	CloseHandle(_thread_handle);
	- _thread_handle = 0;
	+ _thread_handle = nullptr;
	}
	#else
	if (_thread_handle) {
	pthread_detach(_thread_handle);
	_thread_handle = 0;
	}
	#endif
	_running = false;
	_interrupted = false;
	}
	diff --git a/src/win32/win32.cpp b/src/win32/win32.cpp
	index 58d7880..d5efcaf 100644
	--- a/src/win32/win32.cpp
	+++ b/src/win32/win32.cpp
	@@ -1,354 +1,354 @@
	#include <QFileInfo>
	#include <QtGlobal>

	#include "win32.h"
	#include <Windows.h>
	#include <ShlObj.h>

	#include <windows.h>
	#include <shlobj.h>
	#include <shellapi.h>
	#include <commoncontrols.h>
	#include <QtWinExtras/QtWinExtras>


	QString getModuleFileName()
	{
	wchar_t tmp[300];
	- DWORD n = GetModuleFileNameW(0, tmp, 300);
	+ DWORD n = GetModuleFileNameW(nullptr, tmp, 300);
	return QString::fromUtf16((ushort const *)tmp, n);
	}

	//QString getModuleFileDir()
	//{
	// QString path = getModuleFileName();
	// int i = path.lastIndexOf('\\');
	// int j = path.lastIndexOf('/');
	// if (i < j) i = j;
	// if (i > 0) path = path.mid(0, i);
	// return path;
	//}

	QString getAppDataLocation()
	{
	wchar_t tmp[300];
	- if (SHGetSpecialFolderPathW(0, tmp, CSIDL_APPDATA, TRUE)) {
	+ if (SHGetSpecialFolderPathW(nullptr, tmp, CSIDL_APPDATA, TRUE)) {
	return QString::fromUtf16((ushort const *)tmp);
	}
	return QString();
	}


	#include "thread.h"
	#include "event.h"
	#include <deque>
	#define FAILED_(TEXT) throw std::string(TEXT)

	class ProcessThread : Thread {
	friend class StreamThread;
	private:
	Event start_event;
	QString command;
	DWORD exit_code = 0;
	HANDLE hOutputRead;
	HANDLE hInputWrite;
	HANDLE hErrorWrite;
	bool isProcessRunning = false;

	class StreamThread : public Thread {
	private:
	ProcessThread *procthread;
	std::deque<char> out;
	Mutex mutex;
	protected:
	- virtual void run()
	+ void run() override
	{
	try {
	// 子プロセスの標準出力を読み出す
	while (1) {
	CHAR tmp[1024];
	DWORD len;
	- if (!ReadFile(procthread->hOutputRead, tmp, sizeof(tmp), &len, 0) \|\| len == 0) {
	+ if (!ReadFile(procthread->hOutputRead, tmp, sizeof(tmp), &len, nullptr) \|\| len == 0) {
	if (GetLastError() == ERROR_BROKEN_PIPE) {
	break; // pipe done - normal exit path.
	}
	FAILED_("ReadFile"); // Something bad happened.
	}
	mutex.lock();
	out.insert(out.end(), tmp, tmp + len);
	mutex.unlock();
	}
	} catch (std::string const &e) { // 例外
	OutputDebugStringA(e.c_str());
	}
	- procthread = 0;
	+ procthread = nullptr;
	}
	public:
	void Prepare(ProcessThread *pt)
	{
	procthread = pt;
	}
	int ReadOutput(char *ptr, int len)
	{
	mutex.lock();
	size_t n = 0;
	if (ptr && len > 0) {
	n = out.size();
	if (len > len) {
	n = len;
	}
	for (size_t i = 0; i < n; i++) {
	*ptr++ = out.front();
	out.pop_front();
	}
	}
	mutex.unlock();
	if (n == 0 && !procthread) return -1;
	return n;
	}
	};
	StreamThread stream;

	protected:

	void CloseOutput()
	{
	if (hOutputRead != INVALID_HANDLE_VALUE) {
	if (!CloseHandle(hOutputRead)) FAILED_("CloseHandle"); // 子プロセスの標準出力を閉じる
	hOutputRead = INVALID_HANDLE_VALUE;
	}
	}

	- virtual void run()
	+ void run() override
	{
	hOutputRead = INVALID_HANDLE_VALUE;
	hInputWrite = INVALID_HANDLE_VALUE;
	hErrorWrite = INVALID_HANDLE_VALUE;

	HANDLE hOutputReadTmp = INVALID_HANDLE_VALUE;
	HANDLE hOutputWrite = INVALID_HANDLE_VALUE;
	HANDLE hInputWriteTmp = INVALID_HANDLE_VALUE;
	HANDLE hInputRead = INVALID_HANDLE_VALUE;

	try {
	SECURITY_ATTRIBUTES sa;

	sa.nLength = sizeof(SECURITY_ATTRIBUTES);
	- sa.lpSecurityDescriptor = 0;
	+ sa.lpSecurityDescriptor = nullptr;
	sa.bInheritHandle = TRUE;

	HANDLE currproc = GetCurrentProcess();

	// パイプを作成
	if (!CreatePipe(&hOutputReadTmp, &hOutputWrite, &sa, 0))
	FAILED_("CreatePipe");

	// 子プロセスのエラー出力
	if (!DuplicateHandle(currproc, hOutputWrite, currproc, &hErrorWrite, 0, TRUE, DUPLICATE_SAME_ACCESS))
	FAILED_("DuplicateHandle");

	// パイプを作成
	if (!CreatePipe(&hInputRead, &hInputWriteTmp, &sa, 0))
	FAILED_("CreatePipe");

	// 子プロセスの標準出力
	if (!DuplicateHandle(currproc, hOutputReadTmp, currproc, &hOutputRead, 0, FALSE, DUPLICATE_SAME_ACCESS))
	FAILED_("DupliateHandle");

	// 子プロセスの標準入力
	if (!DuplicateHandle(currproc, hInputWriteTmp, currproc, &hInputWrite, 0, FALSE, DUPLICATE_SAME_ACCESS))
	FAILED_("DupliateHandle");

	// 不要なハンドルを閉じる
	CloseHandle(hOutputReadTmp);
	CloseHandle(hInputWriteTmp);

	// プロセス起動
	PROCESS_INFORMATION pi;
	STARTUPINFOW si;

	ZeroMemory(&si, sizeof(STARTUPINFO));
	si.cb = sizeof(STARTUPINFO);
	si.dwFlags = STARTF_USESTDHANDLES \| STARTF_USESHOWWINDOW;
	si.wShowWindow = SW_HIDE;
	si.hStdInput = hInputRead; // 標準入力ハンドル
	si.hStdOutput = hOutputWrite; // 標準出力ハンドル
	si.hStdError = hErrorWrite; // エラー出力ハンドル

	std::vector<wchar_t> tmp;
	tmp.resize(command.size() + 1);
	wcscpy(&tmp[0], (wchar_t const *)command.utf16());
	- if (!CreateProcessW(0, &tmp[0], 0, 0, TRUE, CREATE_NO_WINDOW, 0, 0, &si, &pi)) {
	+ if (!CreateProcessW(nullptr, &tmp[0], nullptr, nullptr, TRUE, CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi)) {
	FAILED_("CreateProcess");
	}

	// 不要なハンドルを閉じる
	CloseHandle(hOutputWrite);
	CloseHandle(hInputRead);
	CloseHandle(hErrorWrite);

	stream.start(); // ストリームスレッドを開始
	isProcessRunning = true;
	start_event.signal(); // 開始イベントを発行

	stream.join(); // ストリームスレッドの終了を待つ
	isProcessRunning = false;
	CloseOutput(); // 標準出力を閉じる

	WaitForSingleObject(pi.hProcess, INFINITE); // プロセス終了を待つ
	GetExitCodeProcess(pi.hProcess, &exit_code);

	// 終了
	CloseHandle(pi.hThread);
	CloseHandle(pi.hProcess);
	} catch (std::string const &e) { // 例外
	stream.stop();
	OutputDebugStringA(e.c_str());
	}
	}

	void WaitForStart() // プロセスの開始を待つ
	{
	start_event.wait();
	}

	public:
	ProcessThread()
	{
	}

	~ProcessThread()
	{
	WaitForExit();
	}

	void Start(QString const &cmd, bool input)
	{
	command = cmd;
	exit_code = 0;
	stream.Prepare(this);
	start();
	WaitForStart();
	if (!input) {
	CloseInput();
	}
	}

	void WriteInput(char const *ptr, int len)
	{
	if (ptr && len > 0) {
	DWORD l = 0;
	- WriteFile(hInputWrite, ptr, len, &l, 0);
	+ WriteFile(hInputWrite, ptr, len, &l, nullptr);
	}
	}

	int ReadOutput(char *ptr, int len)
	{
	return stream.ReadOutput(ptr, len);
	}

	void CloseInput()
	{
	if (hInputWrite != INVALID_HANDLE_VALUE) {
	if (!CloseHandle(hInputWrite)) FAILED_("CloseHandle"); // 子プロセスの標準入力を閉じる
	hInputWrite = INVALID_HANDLE_VALUE;
	}
	}

	int WaitForExit()
	{
	CloseInput();
	join();
	return exit_code;
	}

	bool IsRunning()
	{
	return isProcessRunning;
	}
	};

	int winRunCommand(QString const &cmd, QByteArray *out)
	{
	out->clear();
	ProcessThread proc;
	proc.Start(cmd, false);
	while (1) {
	char tmp[1024];
	bool r = proc.IsRunning();
	int n = proc.ReadOutput(tmp, sizeof(tmp));
	if (n > 0) {
	out->append(tmp, n);
	} else if (!r) {
	break;
	}
	Sleep(0);
	}
	return proc.WaitForExit();
	}


	void setEnvironmentVariable(QString const &name, QString const &value)
	{
	SetEnvironmentVariableW((wchar_t const )name.utf16(), (wchar_t const )value.utf16());
	}


	QString getWin32HttpProxy()
	{
	- HKEY hk = 0;
	+ HKEY hk = nullptr;
	auto Close = [&](){
	RegCloseKey(hk);
	};
	try {
	LSTATUS s;
	s = RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", 0, KEY_READ, &hk);
	if (s != ERROR_SUCCESS) throw s;
	char tmp[1000];
	DWORD type = 0;
	DWORD len = sizeof(tmp);
	s = RegQueryValueExA(hk, "ProxyServer", nullptr, &type, (unsigned char *)tmp, &len);
	if (s != ERROR_SUCCESS) throw s;
	while (len > 0 && tmp[len - 1] == 0) {
	len--;
	}
	Close();
	return QString::fromLatin1(tmp, len);
	} catch (LSTATUS s) {
	Close();
	(void)s;
	}
	return QString();
	}




	namespace {
	QIcon iconFromExtension_(QString const &ext, UINT flag)
	{
	QIcon icon;
	QString name = "*." + ext;
	SHFILEINFOW shinfo;
	if (SHGetFileInfoW((wchar_t const *)name.utf16(), 0, &shinfo, sizeof(shinfo), flag \| SHGFI_ICON \| SHGFI_USEFILEATTRIBUTES) != 0) {
	if (shinfo.hIcon) {
	QPixmap pm = QtWin::fromHICON(shinfo.hIcon);
	if (!pm.isNull()) {
	icon = QIcon(pm);
	}
	DestroyIcon(shinfo.hIcon);
	}
	}
	return icon;
	}
	}

	QIcon winIconFromExtensionLarge(QString const &ext)
	{
	return iconFromExtension_(ext, SHGFI_LARGEICON);
	}

	QIcon winIconFromExtensionSmall(QString const &ext)
	{
	return iconFromExtension_(ext, SHGFI_SMALLICON);
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jun 17, 9:12 PM (1 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71216
Default Alt Text: (433 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions