No OneTemporary
Actions

Size

181 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/FileViewWidget.cpp b/src/FileViewWidget.cpp
	index 9a590dd..bfc4d61 100644
	--- a/src/FileViewWidget.cpp
	+++ b/src/FileViewWidget.cpp
	@@ -1,170 +1,170 @@
	#include "FileViewWidget.h"
	#include "common/misc.h"
	#include <QMenu>
	#include <QPainter>
	#include <QStackedWidget>
	#include <QVBoxLayout>

	FileViewWidget::FileViewWidget(QWidget *parent)
	: QWidget(parent)
	{
	setObjectName(QStringLiteral("FileViewWidget"));
	ui_verticalLayout = new QVBoxLayout(this);
	ui_verticalLayout->setSpacing(0);
	ui_verticalLayout->setObjectName(QStringLiteral("verticalLayout"));
	ui_verticalLayout->setContentsMargins(0, 0, 0, 0);
	ui_stackedWidget = new QStackedWidget(this);
	ui_stackedWidget->setObjectName(QStringLiteral("stackedWidget"));
	ui_page_none = new QWidget();
	ui_page_none->setObjectName(QStringLiteral("page_none"));
	ui_stackedWidget->addWidget(ui_page_none);
	ui_page_text = new X_TextEditorWidget();
	ui_page_text->setObjectName(QStringLiteral("page_text"));
	ui_page_text->setFocusPolicy(Qt::ClickFocus);
	ui_stackedWidget->addWidget(ui_page_text);
	ui_page_image = new X_ImageViewWidget();
	ui_page_image->setObjectName(QStringLiteral("page_image"));
	ui_page_image->setFocusPolicy(Qt::ClickFocus);
	ui_stackedWidget->addWidget(ui_page_image);
	ui_verticalLayout->addWidget(ui_stackedWidget);
	setWindowTitle(QApplication::translate("FileViewWidget", "Form", Q_NULLPTR));
	ui_stackedWidget->setCurrentIndex(1);
	QMetaObject::connectSlotsByName(this);

	ui_page_text->setRenderingMode(TextEditorWidget::DecoratedMode);
	ui_page_text->setTheme(TextEditorTheme::Light());
	ui_page_text->showHeader(false);
	ui_page_text->showFooter(false);
	ui_page_text->setAutoLayout(true);
	ui_page_text->setReadOnly(true);
	ui_page_text->setToggleSelectionAnchorEnabled(false);
	ui_page_text->setFocusFrameVisible(true);

	ui_stackedWidget->setCurrentWidget(ui_page_none);
	}



	void FileViewWidget::setTextCodec(QTextCodec *codec)
	{
	ui_page_text->setTextCodec(codec);
	}

	void FileViewWidget::bind(QMainWindow mw, FileDiffWidget fdw, QScrollBar vsb, QScrollBar hsb, TextEditorThemePtr const &theme)
	{
	ui_page_text->bindScrollBar(vsb, hsb);
	ui_page_image->bind(mw, fdw, vsb, hsb);
	ui_page_text->setTheme(theme);
	}

	void FileViewWidget::setViewType(FileViewType type)
	{
	view_type = type;
	switch (view_type) {
	case FileViewType::Text:
	ui_stackedWidget->setCurrentWidget(ui_page_text);
	return;
	case FileViewType::Image:
	ui_stackedWidget->setCurrentWidget(ui_page_image);
	return;
	default:
	ui_stackedWidget->setCurrentWidget(ui_page_none);
	return;
	}
	}

	const TextEditorTheme *FileViewWidget::theme() const
	{
	return ui_page_text->theme();
	}

	-int FileViewWidget::latin1Width() const
	-{
	- return ui_page_text->latin1Width();
	-}
	+//int FileViewWidget::latin1Width(QString const &s) const
	+//{
	+// return ui_page_text->latin1Width(s);
	+//}

	int FileViewWidget::lineHeight() const
	{
	return ui_page_text->lineHeight();
	}

	void FileViewWidget::setDiffMode(TextEditorEnginePtr const &editor_engine, QScrollBar vsb, QScrollBar hsb)
	{
	ui_page_text->setTextEditorEngine(editor_engine);
	return ui_page_text->bindScrollBar(vsb, hsb);
	}

	void FileViewWidget::refrectScrollBar()
	{
	switch (view_type) {
	case FileViewType::Text:
	ui_page_text->refrectScrollBar();
	return;
	case FileViewType::Image:
	ui_page_image->refrectScrollBar();
	return;
	}
	}

	void FileViewWidget::move(int cur_row, int cur_col, int scr_row, int scr_col, bool auto_scroll)
	{
	return ui_page_text->move(cur_row, cur_col, scr_row, scr_col, auto_scroll);
	}

	void FileViewWidget::setImage(QString const &mimetype, QByteArray const &ba, QString const &object_id, QString const &path)
	{
	setViewType(FileViewType::Image);
	this->source_id = object_id;
	#ifdef APP_GUITAR
	ui_page_image->setImage(mimetype, ba, object_id, path);
	#else
	ui_page_image->setImage(mimetype, ba);
	#endif
	}

	void FileViewWidget::setText(const QList<Document::Line> source, QMainWindow mw, QString const &object_id, QString const &object_path)
	{
	setViewType(FileViewType::Text);
	this->source_id = object_id;
	#ifdef APP_GUITAR
	ui_page_text->setDocument(source, qobject_cast<BasicMainWindow *>(mw), object_id, object_path);
	scrollToTop();
	texteditor()->moveCursorOut(); // 現在行を -1 にして、カーソルを非表示にする。
	#else
	ui_page_text->setDocument(source);
	scrollToTop();
	#endif
	}

	void FileViewWidget::setText(QByteArray const &ba, QMainWindow *mw, QString const &object_id, QString const &object_path)
	{
	std::vector<std::string> lines;
	char const *begin = ba.data();
	char const *end = begin + ba.size();
	misc::splitLines(begin, end, &lines, true);
	QList<Document::Line> source;
	source.reserve(lines.size());
	int num = 0;
	for (std::string const &line : lines) {
	Document::Line t(line);
	t.line_number = ++num;
	source.push_back(t);
	}
	setText(&source, mw, object_id, object_path);
	}

	void FileViewWidget::scrollToTop()
	{
	ui_page_text->scrollToTop();
	}

	void FileViewWidget::write(QKeyEvent *e)
	{
	ui_page_text->write(e);
	}

	TextEditorWidget *FileViewWidget::texteditor()
	{
	return ui_page_text;
	}

	diff --git a/src/FileViewWidget.h b/src/FileViewWidget.h
	index 1dc1a39..0000554 100644
	--- a/src/FileViewWidget.h
	+++ b/src/FileViewWidget.h
	@@ -1,74 +1,74 @@
	#ifndef FILEVIEWWIDGET_H
	#define FILEVIEWWIDGET_H

	#include <QWidget>

	#include "texteditor/TextEditorWidget.h"

	class QScrollBar;
	struct PreEditText;
	class BasicMainWindow;
	class FileDiffWidget;
	class QVBoxLayout;
	class QStackedWidget;

	enum class FileViewType {
	None,
	Text,
	Image,
	};

	#ifdef APP_GUITAR
	#include "MyTextEditorWidget.h"
	#include "MyImageViewWidget.h"
	#else
	#include "ImageViewWidget.h"
	#endif

	class FileViewWidget : public QWidget {
	private:

	#ifdef APP_GUITAR
	using X_TextEditorWidget = MyTextEditorWidget;
	using X_ImageViewWidget = MyImageViewWidget;
	#else
	using X_TextEditorWidget = TextEditorWidget;
	using X_ImageViewWidget = ImageViewWidget;
	#endif

	QVBoxLayout *ui_verticalLayout;
	QStackedWidget *ui_stackedWidget;
	QWidget *ui_page_none;
	X_TextEditorWidget *ui_page_text;
	X_ImageViewWidget *ui_page_image;

	QString source_id;
	FileViewType view_type = FileViewType::None;

	public:
	explicit FileViewWidget(QWidget *parent = nullptr);

	void setTextCodec(QTextCodec *codec);

	void setViewType(FileViewType type);

	void setImage(const QString &mimetype, const QByteArray &ba, QString const &object_id, const QString &path);
	void setText(const QList<Document::Line> source, QMainWindow mw, QString const &object_id, const QString &object_path);
	void setText(const QByteArray &ba, QMainWindow *mw, const QString &object_id, const QString &object_path);

	void setDiffMode(const TextEditorEnginePtr &editor_engine, QScrollBar vsb, QScrollBar hsb);

	- int latin1Width() const;
	+// int latin1Width(const QString &s) const;
	int lineHeight() const;

	TextEditorTheme const *theme() const;
	void scrollToTop();
	void write(QKeyEvent *e);
	void refrectScrollBar();
	void move(int cur_row, int cur_col, int scr_row, int scr_col, bool auto_scroll);

	TextEditorWidget *texteditor();
	void bind(QMainWindow mw, FileDiffWidget fdw, QScrollBar vsb, QScrollBar hsb, const TextEditorThemePtr &theme);
	};

	#endif // FILEVIEWWIDGET_H
	diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
	index eff2fa8..66bceb6 100644
	--- a/src/MainWindow.cpp
	+++ b/src/MainWindow.cpp
	@@ -1,2972 +1,2991 @@
	#include "MainWindow.h"
	#include "ui_MainWindow.h"
	#include "AboutDialog.h"
	#include "ApplicationGlobal.h"
	#include "AreYouSureYouWantToContinueConnectingDialog.h"
	#include "AvatarLoader.h"
	#include "BlameWindow.h"
	#include "CloneFromGitHubDialog.h"
	#include "CommitPropertyDialog.h"
	#include "DeleteBranchDialog.h"
	#include "EditGitIgnoreDialog.h"
	#include "EditTagsDialog.h"
	#include "FileDiffWidget.h"
	#include "FindCommitDialog.h"
	#include "GitDiff.h"
	#include "JumpDialog.h"
	#include "LineEditDialog.h"
	#include "MySettings.h"
	#include "ObjectBrowserDialog.h"
	#include "ReflogWindow.h"
	#include "RemoteWatcher.h"
	#include "SetGpgSigningDialog.h"
	#include "SettingsDialog.h"
	#include "StatusLabel.h"
	#include "TextEditDialog.h"
	#include "common/joinpath.h"
	#include "common/misc.h"
	#include "CherryPickDialog.h"
	#include "MergeDialog.h"
	#include "platform.h"
	#include "webclient.h"
	#include <QClipboard>
	#include <QDirIterator>
	+#include <QElapsedTimer>
	#include <QFileDialog>
	#include <QFileIconProvider>
	#include <QMessageBox>
	#include <QMimeData>
	#include <QPainter>
	#include <QStandardPaths>
	#include <QTimer>

	enum class CustomEvent {
	Start = QEvent::User,
	};

	class StartEvent : public QEvent {
	public:
	StartEvent()
	: QEvent((QEvent::Type)CustomEvent::Start)
	{
	}
	};

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

	struct MainWindow::Private {
	bool is_online_mode = true;
	QTimer interval_10ms_timer;
	QImage graph_color;
	QPixmap digits;
	StatusLabel *status_bar_label;

	QObject *last_focused_file_list = nullptr;

	QListWidgetItem *last_selected_file_item = nullptr;

	bool searching = false;
	QString search_text;

	RemoteWatcher remote_watcher;

	int repos_panel_width = 0;

	std::set<QString> ancestors;

	QWidget *focused_widget = nullptr;
	QList<int> splitter_h_sizes;
	};

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

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

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

	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();

	initNetworking();

	showFileList(FilesListType::SingleList);

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

	prepareLogTableWidget();

	#ifdef Q_OS_WIN
	{
	QFont font;

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

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

	connect(this, &BasicMainWindow::signalWriteLog, this, &BasicMainWindow::writeLog_);

	connect(ui->dockWidget_log, &QDockWidget::visibilityChanged, this, &MainWindow::onLogVisibilityChanged);
	connect(ui->widget_log, &TextEditorWidget::idle, this, &MainWindow::onLogIdle);

	connect(ui->treeWidget_repos, &RepositoriesTreeWidget::dropped, this, &MainWindow::onRepositoriesTreeDropped);

	connect((AbstractPtyProcess *)getPtyProcess(), &AbstractPtyProcess::completed, this, &MainWindow::onPtyProcessCompleted);

	connect(this, &BasicMainWindow::remoteInfoChanged, [&](){
	ui->lineEdit_remote->setText(currentRemoteName());
	});

	connect(this, &MainWindow::signalSetRemoteChanged, [&](bool f){
	setRemoteChanged(f);
	updateButton();
	});

	//

	QString path = getBookmarksFilePath();
	*getReposPtr() = RepositoryBookmark::load(path);
	updateRepositoriesList();

	webContext()->set_keep_alive_enabled(true);
	getAvatarLoader()->start(this);
	connect(getAvatarLoader(), &AvatarLoader::updated, this, &MainWindow::onAvatarUpdated);

	*ptrUpdateFilesListCounter() = 0;

	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());
	settings.endGroup();
	if (maximized) {
	state \|= Qt::WindowMaximized;
	setWindowState(state);
	}
	}

	startTimers();
	}

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

	getAvatarLoader()->stop();

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

	delete m;
	delete ui;
	}


	void MainWindow::notifyRemoteChanged(bool f)
	{
	postUserFunctionEvent([&](QVariant const &v){
	setRemoteChanged(v.toBool());
	updateButton();
	}, QVariant(f));
	}

	void MainWindow::postStartEvent()
	{
	QTimer::singleShot(100, [&](){
	QApplication::postEvent(this, new StartEvent);
	});
	}

	bool MainWindow::shown()
	{
	m->repos_panel_width = ui->stackedWidget_leftpanel->width();
	ui->stackedWidget_leftpanel->setCurrentWidget(ui->page_repos);
	ui->action_repositories_panel->setChecked(true);

	{
	MySettings settings;
	{
	settings.beginGroup("Remote");
	bool f = settings.value("Online", true).toBool();
	settings.endGroup();
	setRemoteOnline(f, false);
	}
	{
	settings.beginGroup("MainWindow");
	int n = settings.value("FirstColumnWidth", 50).toInt();
	if (n < 10) n = 50;
	ui->tableWidget_log->setColumnWidth(0, n);
	settings.endGroup();
	}
	}
	updateUI();

	postStartEvent(); // 開始イベント

	return true;
	}

	bool MainWindow::isUninitialized()
	{
	return !misc::isExecutable(appsettings()->git_command) \|\| !misc::isExecutable(appsettings()->file_command);
	}

	void MainWindow::onStartEvent()
	{
	if (isUninitialized()) { // gitコマンドの有効性チェック
	if (!execWelcomeWizardDialog()) { // ようこそダイアログを表示
	close(); // キャンセルされたらプログラム終了
	}
	}
	if (isUninitialized()) { // 正しく初期設定されたか
	postStartEvent(); // 初期設定されなかったら、もういちどようこそダイアログを出す。
	} else {
	// 外部コマンド登録
	setGitCommand(appsettings()->git_command, false);
	setFileCommand(appsettings()->file_command, false);
	setGpgCommand(appsettings()->gpg_command, false);

	// メインウィンドウのタイトルを設定
	updateWindowTitle(git());

	// プログラムバーション表示
	writeLog(AboutDialog::appVersion() + '\n');
	// gitコマンドバージョン表示
	logGitVersion();
	}
	}

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

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

	startTimer(10);
	}

	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::eventFilter(QObject watched, QEvent event)
	{
	QEvent::Type et = event->type();

	if (et == QEvent::KeyPress) {
	if (QApplication::activeModalWidget()) {
	// thru
	} else {
	auto e = dynamic_cast<QKeyEvent >(event);
	Q_ASSERT(e);
	int k = e->key();
	if (k == Qt::Key_Escape) {
	if (centralWidget()->isAncestorOf(qApp->focusWidget())) {
	ui->treeWidget_repos->setFocus();
	return true;
	}
	}
	if (e->modifiers() & Qt::ControlModifier) {
	if (k == Qt::Key_Up \|\| k == Qt::Key_Down) {
	int rows = 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) {
	auto SelectItem = [](QListWidget *w){
	int row = w->currentRow();
	if (row < 0) {
	row = 0;
	w->setCurrentRow(row);
	}
	w->setItemSelected(w->item(row), true);
	w->viewport()->update();
	};
	// ファイルリストがフォーカスを得たとき、diffビューを更新する。（コンテキストメニュー対応）
	if (watched == ui->listWidget_unstaged) {
	m->last_focused_file_list = watched;
	updateStatusBarText();
	updateUnstagedFileCurrentItem();
	SelectItem(ui->listWidget_unstaged);
	return true;
	}
	if (watched == ui->listWidget_staged) {
	m->last_focused_file_list = watched;
	updateStatusBarText();
	updateStagedFileCurrentItem();
	SelectItem(ui->listWidget_staged);
	return true;
	}
	if (watched == ui->listWidget_files) {
	m->last_focused_file_list = watched;
	SelectItem(ui->listWidget_files);
	return true;
	}
	}
	return false;
	}

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

	void MainWindow::customEvent(QEvent *e)
	{
	if (e->type() == (QEvent::Type)CustomEvent::Start) {
	onStartEvent();
	return;
	}
	}

	void MainWindow::closeEvent(QCloseEvent *event)
	{
	MySettings settings;

	if (appsettings()->remember_and_restore_window_position) {
	setWindowOpacity(0);
	Qt::WindowStates state = windowState();
	bool maximized = (state & Qt::WindowMaximized) != 0;
	if (maximized) {
	state &= ~Qt::WindowMaximized;
	setWindowState(state);
	}
	{
	settings.beginGroup("MainWindow");
	settings.setValue("Maximized", maximized);
	settings.setValue("Geometry", saveGeometry());
	settings.endGroup();
	}
	}

	{
	settings.beginGroup("MainWindow");
	settings.setValue("FirstColumnWidth", ui->tableWidget_log->columnWidth(0));
	settings.endGroup();
	}

	QMainWindow::closeEvent(event);
	}

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

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

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

	void MainWindow::internalWriteLog(char const *ptr, int len)
	{
	ui->widget_log->logicalMoveToBottom();
	ui->widget_log->write(ptr, len, false);
	ui->widget_log->setChanged(false);
	setInteractionCanceled(false);
	}

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

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

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

	const QPixmap &MainWindow::digitsPixmap() const
	{
	return 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 BasicMainWindow::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;
	}

	QString MainWindow::currentWorkingCopyDir() const
	{
	QString workdir = BasicMainWindow::currentWorkingCopyDir();
	if (workdir.isEmpty()) {
	RepositoryItem const *repo = selectedRepositoryItem();
	if (repo) {
	workdir = repo->local_dir;
	return workdir;
	}
	}
	return workdir;
	}

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

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

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

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

	RepositoryItem const *MainWindow::selectedRepositoryItem() const
	{
	return repositoryItem(ui->treeWidget_repos->currentItem());
	}

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

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

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

	auto *repos = getReposPtr();
	*repos = RepositoryBookmark::load(path);

	QString filter = getRepositoryFilterText();

	ui->treeWidget_repos->clear();

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

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

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

	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()
	{
	internalClearRepositoryInfo();
	ui->label_repo_name->setText(QString());
	ui->label_branch_name->setText(QString());
	}

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

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

	if (!wait) return;

	clearFileList();

	Git::FileStatusList stats = g->status_s();
	setUncommitedChanges(!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(filename);
	item->setSizeHint(QSize(item->sizeHint().width(), 18));
	item->setData(FilePathRole, filename);
	item->setData(DiffIndexRole, idiff);
	item->setData(HunkIndexRole, -1);
	item->setData(HeaderRole, header);
	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, diffResult())) {
	return;
	}

	std::map<QString, int> diffmap;

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

	showFileList(files_list_type);

	for (Git::FileStatus const &s : stats) {
	staged = (s.isStaged() && s.code_y() == ' ');
	int idiff = -1;
	QString header;
	auto it = diffmap.find(s.path1());
	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, diffResult())) {
	return;
	}
	showFileList(files_list_type);
	addDiffItems(diffResult(), AddItem);
	}

	for (Git::Diff const &diff : *diffResult()) {
	QString key = GitDiff::makeKey(diff);
	(*getDiffCacheMap())[key] = diff;
	}
	}

	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()
	{
	auto logs = getLogs();
	QTableWidgetItem *item = ui->tableWidget_log->item(selectedLogIndex(), 0);
	if (!item) return;
	int row = item->data(IndexRole).toInt();
	int count = (int)logs.size();
	if (row < count) {
	updateFilesList(logs[row], true);
	}
	}

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

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

	void MainWindow::detectGitServerType(GitPtr const &g)
	{
	setServerType(ServerType::Standard);
	*ptrGitHub() = GitHubRepositoryInfo();

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

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

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

	void MainWindow::clearLog()
	{
	clearLogs();
	clearLabelMap();
	setUncommitedChanges(false);
	ui->tableWidget_log->clearContents();
	ui->tableWidget_log->scrollToTop();
	}

	void MainWindow::openRepository_(GitPtr g, bool keep_selection)
	{
	getObjCache()->setup(g);

	int scroll_pos = -1;
	int select_row = -1;

	if (keep_selection) {
	scroll_pos = ui->tableWidget_log->verticalScrollBar()->value();
	select_row = ui->tableWidget_log->currentRow();
	}

	if (isValidWorkingCopy(g)) {

	bool do_fetch = isOnlineMode() && (getForceFetch() \|\| appsettings()->automatically_fetch_when_opening_the_repository);
	setForceFetch(false);
	if (do_fetch) {
	if (!fetch(g, false)) {
	return;
	}
	}

	clearLog();
	clearRepositoryInfo();

	detectGitServerType(g);

	updateFilesList(QString(), true);

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

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

	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();
	}

	if (!g) return;

	updateRemoteInfo();

	updateWindowTitle(g);

	setHeadId(getObjCache()->revParse("HEAD"));

	if (isThereUncommitedChanges()) {
	Git::CommitItem item;
	item.parent_ids.push_back(currentBranch().id);
	item.message = tr("Uncommited changes");
	auto p = getLogsPtr();
	p->insert(p->begin(), item);
	}

	prepareLogTableWidget();

	auto const &logs = getLogs();
	const int count = logs.size();

	ui->tableWidget_log->setRowCount(count);

	int selrow = 0;

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

	m->last_focused_file_list = nullptr;

	ui->tableWidget_log->setFocus();

	if (select_row < 0) {
	setCurrentLogRow(selrow);
	} else {
	setCurrentLogRow(select_row);
	ui->tableWidget_log->verticalScrollBar()->setValue(scroll_pos >= 0 ? scroll_pos : 0);
	}

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

	updateUI();
	}

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

	void MainWindow::setNetworkingCommandsEnabled(bool enabled)
	{
	ui->action_clone->setEnabled(enabled);

	ui->toolButton_clone->setEnabled(enabled);

	if (!Git::isValidWorkingCopy(currentWorkingCopyDir())) {
	enabled = false;
	}

	bool opened = !currentRepository().name.isEmpty();
	ui->action_fetch->setEnabled(enabled \|\| opened);
	ui->toolButton_fetch->setEnabled(enabled \|\| opened);

	if (isOnlineMode()) {
	ui->action_fetch->setText(tr("Fetch"));
	ui->toolButton_fetch->setText(tr("Fetch"));
	} else {
	ui->action_fetch->setText(tr("Update"));
	ui->toolButton_fetch->setText(tr("Update"));
	}

	ui->action_fetch_prune->setEnabled(enabled);
	ui->action_pull->setEnabled(enabled);
	ui->action_push->setEnabled(enabled);
	ui->action_push_u->setEnabled(enabled);
	ui->action_push_all_tags->setEnabled(enabled);

	ui->toolButton_pull->setEnabled(enabled);
	ui->toolButton_push->setEnabled(enabled);
	}

	void MainWindow::updateUI()
	{
	setNetworkingCommandsEnabled(isOnlineMode());

	ui->toolButton_fetch->setDot(getRemoteChanged());

	Git::Branch b = currentBranch();
	ui->toolButton_push->setNumber(b.ahead > 0 ? b.ahead : -1);
	ui->toolButton_pull->setNumber(b.behind > 0 ? b.behind : -1);

	{
	bool f = isRepositoryOpened();
	ui->toolButton_status->setEnabled(f);
	ui->toolButton_terminal->setEnabled(f);
	ui->toolButton_explorer->setEnabled(f);
	ui->action_repository_status->setEnabled(f);
	ui->action_terminal->setEnabled(f);
	ui->action_explorer->setEnabled(f);
	}
	}

	void MainWindow::updateStatusBarText()
	{
	QString text;

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

	setStatusBarText(text);
	}

	void MainWindow::mergeBranch(QString const &commit, Git::MergeFastForward ff)
	{
	if (commit.isEmpty()) return;

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

	g->mergeBranch(commit, ff);
	openRepository(true);
	}

	void MainWindow::mergeBranch(Git::CommitItem const *commit, Git::MergeFastForward ff)
	{
	if (!commit) return;
	mergeBranch(commit->commit_id, ff);
	}

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

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

	QString text = tr("Are you sure you want to rebase the commit ?");
	text += "\n\n";
	text += "> git rebase " + commit->commit_id;
	int r = QMessageBox::information(this, tr("Rebase"), text, QMessageBox::Ok, QMessageBox::Cancel);
	if (r == QMessageBox::Ok) {
	g->rebaseBranch(commit->commit_id);
	openRepository(true);
	}
	}

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

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



	int n = commit->parent_ids.size();
	if (n == 1) {
	g->cherrypick(commit->commit_id);
	} else if (n > 1) {
	Git::CommitItem head;
	Git::CommitItem pick;
	g->queryCommit(g->rev_parse("HEAD"), &head);
	g->queryCommit(commit->commit_id, &pick);
	QList<Git::CommitItem> parents;
	for (int i = 0; i < n; i++) {
	QString id = commit->commit_id + QString("^%1").arg(i + 1);
	id = g->rev_parse(id);
	Git::CommitItem item;
	g->queryCommit(id, &item);
	parents.push_back(item);
	}
	CherryPickDialog dlg(this, head, pick, parents);
	if (dlg.exec() == QDialog::Accepted) {
	QString cmd = "-m %1 ";
	cmd = cmd.arg(dlg.number());
	if (dlg.allowEmpty()) {
	cmd += "--allow-empty ";
	}
	cmd += commit->commit_id;
	g->cherrypick(cmd);
	} else {
	return;
	}
	}

	openRepository(true);
	}

	void MainWindow::merge(Git::CommitItem const *commit)
	{
	if (isThereUncommitedChanges()) return;

	if (!commit) {
	int row = selectedLogIndex();
	commit = commitItem(row);
	if (!commit) return;
	}

	if (!Git::isValidID(commit->commit_id)) return;

	static const char MergeFastForward[] = "MergeFastForward";

	QString fastforward;
	{
	MySettings s;
	s.beginGroup("Behavior");
	fastforward = s.value(MergeFastForward).toString();
	s.endGroup();
	}

	std::vector<QString> labels;
	{
	int row = selectedLogIndex();
	QList<Label> const *v = label(row);
	for (Label const &label : *v) {
	if (label.kind == Label::LocalBranch \|\| label.kind == Label::Tag) {
	labels.push_back(label.text);
	}
	}
	std::sort(labels.begin(), labels.end());
	labels.erase(std::unique(labels.begin(), labels.end()), labels.end());
	}

	labels.push_back(commit->commit_id);

	QString branch_name = currentBranchName();

	MergeDialog dlg(fastforward, labels, branch_name, this);
	if (dlg.exec() == QDialog::Accepted) {
	fastforward = dlg.getFastForwardPolicy();
	{
	MySettings s;
	s.beginGroup("Behavior");
	s.setValue(MergeFastForward, fastforward);
	s.endGroup();
	}
	QString from = dlg.mergeFrom();
	mergeBranch(from, MergeDialog::ff(fastforward));
	}
	}

	void MainWindow::showStatus()
	{
	auto g = git();
	if (!g->isValidWorkingCopy()) {
	msgNoRepositorySelected();
	return;
	}
	QString s = g->status();
	TextEditDialog dlg(this);
	dlg.setWindowTitle(tr("Status"));
	dlg.setText(s, true);
	dlg.exec();
	}

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

	void MainWindow::on_action_fetch_triggered()
	{
	if (isOnlineMode()) {
	reopenRepository(true, [&](GitPtr g){
	fetch(g, false);
	});
	} else {
	updateRepository();
	}
	}



	void MainWindow::on_action_fetch_prune_triggered()
	{
	if (!isOnlineMode()) return;

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

	void MainWindow::on_action_push_triggered()
	{
	push();
	}

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

	reopenRepository(true, [&](GitPtr g){
	setPtyCondition(PtyCondition::Pull);
	setPtyProcessOk(true);
	g->pull(getPtyProcess());
	while (1) {
	if (getPtyProcess()->wait(1)) break;
	QApplication::processEvents();
	}
	});
	}

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

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

	void MainWindow::on_toolButton_status_clicked()
	{
	showStatus();
	}

	void MainWindow::on_action_repository_status_triggered()
	{
	showStatus();
	}

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

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

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

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

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

	RepositoryItem const *repo = repositoryItem(treeitem);

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

	QAction *a_open_folder = menu.addAction(tr("Open &folder"));
	a_open_folder->setIcon(QIcon(":/image/explorer.svg"));

	menu.addSeparator();

	QAction *a_remove = menu.addAction(tr("&Remove"));

	menu.addSeparator();

	QAction *a_properties = addMenuActionProperty(&menu);

	QPoint pt = ui->treeWidget_repos->mapToGlobal(pos);
	QAction *a = menu.exec(pt + QPoint(8, -8));

	if (a) {
	if (a == a_open) {
	openSelectedRepository();
	return;
	}
	if (a == a_open_folder) {
	openExplorer(repo);
	return;
	}
	if (a == a_open_terminal) {
	openTerminal(repo);
	return;
	}
	if (a == a_remove) {
	removeRepositoryFromBookmark(index, true);
	return;
	}
	if (a == a_properties) {
	execRepositoryPropertyDialog(repo->local_dir);
	return;
	}
	}
	}
	}

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

	QMenu menu;

	QAction *a_copy_id_7letters = is_valid_commit_id ? menu.addAction(tr("Copy commit id (7 letters)")) : nullptr;
	QAction *a_copy_id_complete = is_valid_commit_id ? menu.addAction(tr("Copy commit id (completely)")) : nullptr;

	std::set<QAction *> copy_label_actions;
	{
	QList<BasicMainWindow::Label> v = sortedLabels(row);
	if (!v.isEmpty()) {
	auto *copy_lebel_menu = menu.addMenu("Copy label");
	for (BasicMainWindow::Label const &l : v) {
	QAction *a = copy_lebel_menu->addAction(l.text);
	copy_label_actions.insert(copy_label_actions.end(), a);
	}
	}
	}

	menu.addSeparator();

	QAction *a_checkout = menu.addAction(tr("Checkout/Branch..."));

	menu.addSeparator();

	QAction *a_edit_message = nullptr;

	auto canEditMessage = [&](){
	if (commit->has_child) return false; // 子がないこと
	if (Git::isUncommited(*commit)) return false; // 未コミットがないこと
	bool is_head = false;
	bool has_remote_branch = false;
	QList<Label> const *labels = label(row);
	for (const Label &label : *labels) {
	if (label.kind == Label::Head) {
	is_head = true;
	} else if (label.kind == Label::RemoteBranch) {
	has_remote_branch = true;
	}
	}
	return is_head && !has_remote_branch; // HEAD && リモートブランチ無し
	};
	if (canEditMessage()) {
	a_edit_message = menu.addAction(tr("Edit message..."));
	}

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

	menu.addSeparator();

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

	menu.addSeparator();

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

	QAction *a = menu.exec(ui->tableWidget_log->viewport()->mapToGlobal(pos) + QPoint(8, -8));
	if (a) {
	if (a == a_copy_id_7letters) {
	qApp->clipboard()->setText(commit->commit_id.mid(0, 7));
	return;
	}
	if (a == a_copy_id_complete) {
	qApp->clipboard()->setText(commit->commit_id);
	return;
	}
	if (a == a_properties) {
	execCommitPropertyDialog(this, commit);
	return;
	}
	if (a == a_edit_message) {
	commitAmend();
	return;
	}
	if (a == a_checkout) {
	checkout(this, commit);
	return;
	}
	if (a == a_delbranch) {
	deleteBranch(commit);
	return;
	}
	if (a == a_delrembranch) {
	deleteRemoteBranch(commit);
	return;
	}
	if (a == a_merge) {
	merge(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 (copy_label_actions.find(a) != copy_label_actions.end()) {
	QString text = a->text();
	QApplication::clipboard()->setText(text);
	return;
	}
	}
	}
	}

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

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

	QPoint pt = 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);
	}
	}
	}
	}
	}

	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&)> const &fn)
	{
	for (QString const &path : selectedFiles()) {
	fn(path);
	}
	}

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

	void MainWindow::doLogCurrentItemChanged()
	{
	clearFileList();

	int row = selectedLogIndex();
	QTableWidgetItem *item = ui->tableWidget_log->item(row, 0);
	if (item) {
	auto const &logs = getLogs();
	int row = item->data(IndexRole).toInt();
	if (row < (int)logs.size()) {
	updateStatusBarText();
	*ptrUpdateFilesListCounter() = 200;
	}
	} else {
	row = -1;
	}
	updateAncestorCommitMap();
	ui->tableWidget_log->viewport()->update();
	}

	void MainWindow::findNext()
	{
	if (m->search_text.isEmpty()) {
	return;
	}
	auto const &logs = getLogs();
	for (int pass = 0; pass < 2; pass++) {
	int row = 0;
	if (pass == 0) {
	row = selectedLogIndex();
	if (row < 0) {
	row = 0;
	} else if (m->searching) {
	row++;
	}
	}
	while (row < (int)logs.size()) {
	Git::CommitItem const commit = logs[row];
	if (!Git::isUncommited(commit)) {
	if (commit.message.indexOf(m->search_text, 0, Qt::CaseInsensitive) >= 0) {
	bool b = ui->tableWidget_log->blockSignals(true);
	setCurrentLogRow(row);
	ui->tableWidget_log->blockSignals(b);
	m->searching = true;
	return;
	}
	}
	row++;
	}
	}
	}

	void MainWindow::findText(QString const &text)
	{
	m->search_text = text;
	}

	bool MainWindow::isAncestorCommit(QString const &id)
	{
	auto it = m->ancestors.find(id);
	return it != m->ancestors.end();
	}

	void MainWindow::updateAncestorCommitMap()
	{
	m->ancestors.clear();

	auto const &logs = getLogs();
	const size_t LogCount = logs.size();
	const size_t index = selectedLogIndex();
	if (index < LogCount) {
	// ok
	} else {
	return;
	}

	auto *logsp = getLogsPtr();
	auto LogItem = [&](size_t i)->Git::CommitItem &{ return logsp->at(i); };

	std::map<QString, size_t> commit_to_index_map;

	size_t end = LogCount;

	if (index < end) {
	for (size_t i = index; i < end; i++) {
	Git::CommitItem const &commit = LogItem(i);
	commit_to_index_map[commit.commit_id] = i;
	auto *item = ui->tableWidget_log->item(i, 0);
	QRect r = ui->tableWidget_log->visualItemRect(item);
	if (r.y() >= ui->tableWidget_log->height()) {
	end = i + 1;
	break;
	}
	}
	}

	Git::CommitItem *item = &LogItem(index);
	if (item) {
	m->ancestors.insert(m->ancestors.end(), item->commit_id);
	}

	for (size_t i = index; i < end; i++) {
	Git::CommitItem *item = &LogItem(i);
	if (isAncestorCommit(item->commit_id)) {
	for (QString const &parent : item->parent_ids) {
	m->ancestors.insert(m->ancestors.end(), parent);
	}
	}
	}
	}

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

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

	void MainWindow::on_tableWidget_log_currentItemChanged(QTableWidgetItem * /current/, QTableWidgetItem * /previous/)
	{
	doLogCurrentItemChanged();
	m->searching = false;
	}

	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();
	}



	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
	{
	auto const &logs = getLogs();
	int i = ui->tableWidget_log->currentRow();
	if (i >= 0 && i < (int)logs.size()) {
	return i;
	}
	return -1;
	}

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

	m->last_selected_file_item = item;

	if (!item) return;

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

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

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

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

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

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

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

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

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

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

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

	void MainWindow::keyPressEvent(QKeyEvent *event)
	{
	int c = event->key();
	if (c == Qt::Key_T && (event->modifiers() & Qt::ControlModifier)) {
	test();
	return;
	}
	if (QApplication::focusWidget() == ui->widget_log) {

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

	auto write_text = [&](QString const &str){
	std::string s = str.toStdString();
	for (char i : s) {
	write_char(i);
	}
	};

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

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

	void MainWindow::onCloneCompleted(bool success, QVariant const &userdata)
	{
	if (success) {
	RepositoryItem r = userdata.value<RepositoryItem>();
	saveRepositoryBookmark(r);
	setCurrentRepository(r, false);
	openRepository(true);
	}
	}

	void MainWindow::onPtyProcessCompleted(bool /ok/, QVariant const &userdata)
	{
	switch (getPtyCondition()) {
	case PtyCondition::Clone:
	onCloneCompleted(getPtyProcessOk(), userdata);
	break;
	}
	setPtyCondition(PtyCondition::None);
	}

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

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

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

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

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

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

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

	void MainWindow::on_lineEdit_filter_textChanged(QString const &text)
	{
	setRepositoryFilterText(text);
	updateRepositoriesList();
	}

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

	void MainWindow::deleteTags(QStringList const &tagnames)
	{
	int row = ui->tableWidget_log->currentRow();

	internalDeleteTags(tagnames);

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

	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)
	{
	int row = ui->tableWidget_log->currentRow();

	bool ok = internalAddTag(name);

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

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

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

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

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

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

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

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

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

	void MainWindow::showLogWindow(bool show)
	{
	ui->dockWidget_log->setVisible(show);
	}

	void MainWindow::on_action_window_log_triggered(bool checked)
	{
	showLogWindow(checked);
	}

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

	NamedCommitList items = namedCommitItems(Branches \| Tags \| Remotes);
	{
	NamedCommitItem head;
	head.name = "HEAD";
	head.id = getHeadId();
	items.push_front(head);
	}
	JumpDialog dlg(this, items);
	if (dlg.exec() == QDialog::Accepted) {
	QString text = dlg.text();
	if (text.isEmpty()) return;
	QString id = g->rev_parse(text);
	if (id.isEmpty() && Git::isValidID(text)) {
	QStringList list = findGitObject(text);
	if (list.isEmpty()) {
	QMessageBox::warning(this, tr("Jump"), QString("%1\n\n").arg(text) + tr("No such commit"));
	return;
	}
	ObjectBrowserDialog dlg2(this, list);
	if (dlg2.exec() == QDialog::Accepted) {
	id = dlg2.text();
	if (id.isEmpty()) return;
	}
	}
	if (g->objectType(id) == "tag") {
	id = getObjCache()->getCommitIdFromTag(id);
	}
	int row = rowFromCommitId(id);
	if (row < 0) {
	QMessageBox::warning(this, tr("Jump"), QString("%1\n(%2)\n\n").arg(text).arg(id) + tr("No such commit"));
	} else {
	setCurrentLogRow(row);
	}
	}
	}

	void MainWindow::on_action_repo_checkout_triggered()
	{
	checkout();
	}

	void MainWindow::on_action_delete_branch_triggered()
	{
	deleteBranch();
	}

	void MainWindow::on_toolButton_terminal_clicked()
	{
	openTerminal(nullptr);
	}

	void MainWindow::on_toolButton_explorer_clicked()
	{
	openExplorer(nullptr);
	}

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

	g->reset_head1();
	openRepository(false);
	}

	void MainWindow::on_action_create_a_repository_triggered()
	{
	createRepository(QString());
	}

	bool MainWindow::isOnlineMode() const
	{
	return m->is_online_mode;
	}

	void MainWindow::setRemoteOnline(bool f, bool save)
	{
	m->is_online_mode = f;

	{
	QRadioButton *rb = nullptr;
	rb = f ? ui->radioButton_remote_online : ui->radioButton_remote_offline;
	rb->blockSignals(true);
	rb->click();
	rb->blockSignals(false);

	ui->action_online->setCheckable(true);
	ui->action_offline->setCheckable(true);
	ui->action_online->setChecked(f);
	ui->action_offline->setChecked(!f);

	setNetworkingCommandsEnabled(f);
	}

	if (save) {
	MySettings s;
	s.beginGroup("Remote");
	s.setValue("Online", f);
	s.endGroup();
	}
	}

	void MainWindow::on_radioButton_remote_online_clicked()
	{
	setRemoteOnline(true, true);
	}

	void MainWindow::on_radioButton_remote_offline_clicked()
	{
	setRemoteOnline(false, true);
	}

	void MainWindow::on_verticalScrollBar_log_valueChanged(int)
	{
	ui->widget_log->refrectScrollBar();
	}

	void MainWindow::on_horizontalScrollBar_log_valueChanged(int)
	{
	ui->widget_log->refrectScrollBar();
	}

	void MainWindow::on_toolButton_stop_process_clicked()
	{
	abortPtyProcess();
	}

	void MainWindow::on_action_stop_process_triggered()
	{
	abortPtyProcess();
	}

	void MainWindow::on_action_exit_triggered()
	{
	close();
	}

	void MainWindow::on_action_reflog_triggered()
	{
	GitPtr g = git();
	Git::ReflogItemList reflog;
	g->reflog(&reflog);

	ReflogWindow dlg(this, this, reflog);
	dlg.exec();
	}

	void MainWindow::blame(QListWidgetItem *item)
	{
	QList<BlameItem> list;
	QString path = getFilePath(item);
	{
	GitPtr g = git();
	QByteArray ba = g->blame(path);
	if (!ba.isEmpty()) {
	char const *begin = ba.data();
	char const *end = begin + ba.size();
	list = BlameWindow::parseBlame(begin, end);
	}
	}
	if (!list.isEmpty()) {
	qApp->setOverrideCursor(Qt::WaitCursor);
	BlameWindow win(this, path, list);
	qApp->restoreOverrideCursor();
	win.exec();
	}
	}

	void MainWindow::blame()
	{
	blame(currentFileItem());
	}

	void MainWindow::on_action_repository_property_triggered()
	{
	execRepositoryPropertyDialog(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;

	setInteractionMode(InteractionMode::Busy);

	QApplication::restoreOverrideCursor();

	TheDlg dlg(this);
	if (dlg.exec() == QDialog::Accepted) {
	TheDlg::Result r = dlg.result();
	if (r == TheDlg::Result::Yes) {
	getPtyProcess()->writeInput("yes\n", 4);
	} else {
	setPtyProcessOk(false); // abort
	getPtyProcess()->writeInput("no\n", 3);
	QThread::msleep(300);
	stopPtyProcess();
	}
	} else {
	ui->widget_log->setFocus();
	setInteractionCanceled(true);
	}
	setInteractionMode(InteractionMode::Busy);
	}

	void MainWindow::onLogIdle()
	{
	if (interactionCanceled()) return;
	if (interactionMode() != InteractionMode::None) return;

	static char const are_you_sure_you_want_to_continue_connecting[] = "Are you sure you want to continue connecting (yes/no)?";
	static char const enter_passphrase[] = "Enter passphrase: ";
	static char const enter_passphrase_for_key[] = "Enter passphrase for key '";
	static char const fatal_authentication_failed_for[] = "fatal: Authentication failed for '";

	std::vector<char> vec;
	ui->widget_log->retrieveLastText(&vec, 100);
	if (!vec.empty()) {
	std::string line;
	int n = (int)vec.size();
	int i = n;
	while (i > 0) {
	i--;
	if (i + 1 < n && vec[i] == '\n') {
	i++;
	line.assign(&vec[i], n - i);
	break;
	}
	}
	if (!line.empty()) {
	auto ExecLineEditDialog = [&](QWidget *parent, QString const &title, QString const &prompt, QString const &val, bool password){
	LineEditDialog dlg(parent, title, prompt, val, password);
	if (dlg.exec() == QDialog::Accepted) {
	std::string ret = dlg.text().toStdString();
	std::string str = ret + '\n';
	getPtyProcess()->writeInput(str.c_str(), str.size());
	return ret;
	}
	abortPtyProcess();
	return std::string();
	};

	auto Match = [&](char const *str){
	int n = strlen(str);
	if (strncmp(line.c_str(), str, n) == 0) {
	char const *p = line.c_str() + n;
	while (1) {
	if (!*p) return true;
	if (!isspace((unsigned char)*p)) break;
	p++;
	}
	}
	return false;
	};

	auto StartsWith = [&](char const *str){
	char const *p = line.c_str();
	while (*str) {
	if (p != str) return false;
	str++;
	p++;
	}
	return true;
	};

	if (Match(are_you_sure_you_want_to_continue_connecting)) {
	execAreYouSureYouWantToContinueConnectingDialog();
	return;
	}

	if (line == enter_passphrase) {
	ExecLineEditDialog(this, "Passphrase", QString::fromStdString(line), QString(), true);
	return;
	}

	if (StartsWith(enter_passphrase_for_key)) {
	std::string keyfile;
	{
	int i = strlen(enter_passphrase_for_key);
	char const *p = line.c_str() + i;
	char const *q = strrchr(p, ':');
	if (q && p + 2 < q && q[-1] == '\'') {
	keyfile.assign(p, q - 1);
	}
	}
	if (!keyfile.empty()) {
	if (keyfile == sshPassphraseUser() && !sshPassphrasePass().empty()) {
	std::string text = sshPassphrasePass() + '\n';
	getPtyProcess()->writeInput(text.c_str(), text.size());
	} else {
	std::string secret = ExecLineEditDialog(this, "Passphrase for key", QString::fromStdString(line), QString(), true);
	sshSetPassphrase(keyfile, secret);
	}
	return;
	}
	}

	char const *begin = line.c_str();
	char const *end = line.c_str() + line.size();
	auto Input = [&](QString const &title, bool password, std::string *value){
	Q_ASSERT(value);
	std::string header = QString("%1 for '").arg(title).toStdString();
	if (strncmp(begin, header.c_str(), header.size()) == 0) {
	QString msg;
	if (memcmp(end - 2, "':", 2) == 0) {
	msg = QString::fromUtf8(begin, end - begin - 1);
	} else if (memcmp(end - 3, "': ", 3) == 0) {
	msg = QString::fromUtf8(begin, end - begin - 2);
	}
	if (!msg.isEmpty()) {
	std::string s = ExecLineEditDialog(this, title, msg, value ? QString::fromStdString(*value) : QString(), password);
	*value = s;
	return true;
	}
	}
	return false;
	};
	std::string uid = httpAuthenticationUser();
	std::string pwd = httpAuthenticationPass();
	bool ok = false;
	if (Input("Username", false, &uid)) ok = true;
	if (Input("Password", true, &pwd)) ok = true;
	if (ok) {
	httpSetAuthentication(uid, pwd);
	return;
	}

	if (StartsWith(fatal_authentication_failed_for)) {
	QMessageBox::critical(this, tr("Authentication Failed"), QString::fromStdString(line));
	abortPtyProcess();
	return;
	}
	}
	}
	}

	void MainWindow::on_action_edit_tags_triggered()
	{
	Git::CommitItem const *commit = selectedCommitItem();
	if (commit && Git::isValidID(commit->commit_id)) {
	EditTagsDialog dlg(this, commit);
	dlg.exec();
	}
	}

	void MainWindow::on_action_push_u_triggered()
	{
	pushSetUpstream(false);
	}

	void MainWindow::on_action_delete_remote_branch_triggered()
	{
	deleteRemoteBranch(selectedCommitItem());
	}

	void MainWindow::on_action_terminal_triggered()
	{
	auto const *repo = &currentRepository();
	openTerminal(repo);
	}

	void MainWindow::on_action_explorer_triggered()
	{
	auto const *repo = &currentRepository();
	openExplorer(repo);
	}

	void MainWindow::on_action_reset_hard_triggered()
	{
	doGitCommand([&](GitPtr g){
	g->reset_hard();
	});
	}

	void MainWindow::on_action_clean_df_triggered()
	{
	doGitCommand([&](GitPtr g){
	g->clean_df();
	});
	}

	void MainWindow::postOpenRepositoryFromGitHub(QString const &username, QString const &reponame)
	{
	QVariantList list;
	list.push_back(username);
	list.push_back(reponame);
	postUserFunctionEvent([&](QVariant const &v){
	QVariantList l = v.toList();
	QString uname = l[0].toString();
	QString rname = l[1].toString();
	CloneFromGitHubDialog dlg(this, uname, rname);
	if (dlg.exec() == QDialog::Accepted) {
	clone(dlg.url());
	}
	}, QVariant(list));
	}

	void MainWindow::on_action_stash_triggered()
	{
	doGitCommand([&](GitPtr g){
	g->stash();
	});
	}

	void MainWindow::on_action_stash_apply_triggered()
	{
	doGitCommand([&](GitPtr g){
	g->stash_apply();
	});
	}

	void MainWindow::on_action_stash_drop_triggered()
	{
	doGitCommand([&](GitPtr g){
	g->stash_drop();
	});
	}

	void MainWindow::on_action_online_triggered()
	{
	ui->radioButton_remote_online->click();
	}

	void MainWindow::on_action_offline_triggered()
	{
	ui->radioButton_remote_offline->click();
	}

	void MainWindow::on_action_repositories_panel_triggered()
	{
	bool checked = ui->action_repositories_panel->isChecked();
	ui->stackedWidget_leftpanel->setCurrentWidget(checked ? ui->page_repos : ui->page_collapsed);

	if (checked) {
	ui->stackedWidget_leftpanel->setFixedWidth(m->repos_panel_width);
	ui->stackedWidget_leftpanel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
	ui->stackedWidget_leftpanel->setMinimumWidth(QWIDGETSIZE_MAX);
	ui->stackedWidget_leftpanel->setMaximumWidth(QWIDGETSIZE_MAX);
	} else {
	m->repos_panel_width = ui->stackedWidget_leftpanel->width();
	ui->stackedWidget_leftpanel->setFixedWidth(24);
	}
	}

	void MainWindow::on_action_find_triggered()
	{
	m->searching = false;

	if (getLogs().empty()) {
	return;
	}

	FindCommitDialog dlg(this, m->search_text);
	if (dlg.exec() == QDialog::Accepted) {
	m->search_text = dlg.text();
	ui->tableWidget_log->setFocus();
	findNext();
	}
	}

	void MainWindow::on_action_find_next_triggered()
	{
	if (m->search_text.isEmpty()) {
	on_action_find_triggered();
	} else {
	findNext();
	}
	}

	void MainWindow::on_action_repo_jump_to_head_triggered()
	{
	QString name = "HEAD";
	GitPtr g = git();
	QString id = g->rev_parse(name);
	int row = rowFromCommitId(id);
	if (row < 0) {
	qDebug() << "No such commit";
	} else {
	setCurrentLogRow(row);
	}

	}

	void MainWindow::on_action_repo_merge_triggered()
	{
	merge();
	}

	-void MainWindow::test()
	-{
	-}
	-
	void MainWindow::on_action_expand_commit_log_triggered()
	{
	ui->splitter_h->setSizes({10000, 1, 1});
	}

	void MainWindow::on_action_expand_file_list_triggered()
	{
	ui->splitter_h->setSizes({1, 10000, 1});
	}

	void MainWindow::on_action_expand_diff_view_triggered()
	{
	ui->splitter_h->setSizes({1, 1, 10000});
	}

	void MainWindow::on_action_sidebar_triggered()
	{
	bool f = ui->stackedWidget_leftpanel->isVisible();
	f = !f;
	ui->stackedWidget_leftpanel->setVisible(f);
	}



	void MainWindow::on_action_wide_triggered()
	{
	QWidget *w = focusWidget();

	if (w == m->focused_widget) {
	ui->splitter_h->setSizes(m->splitter_h_sizes);
	m->focused_widget = nullptr;
	} else {
	m->focused_widget = w;
	m->splitter_h_sizes = ui->splitter_h->sizes();

	if (w == ui->tableWidget_log) {
	ui->splitter_h->setSizes({10000, 1, 1});
	} else if (ui->stackedWidget_filelist->isAncestorOf(w)) {
	ui->splitter_h->setSizes({1, 10000, 1});
	} else if (ui->frame_diff_view->isAncestorOf(w)) {
	ui->splitter_h->setSizes({1, 1, 10000});
	}
	}
	}

	+void MainWindow::test()
	+{
	+ QElapsedTimer t;
	+ t.start();
	+ {
	+ QPixmap pm(1, 1);
	+ QPainter pr(&pm);
	+ pr.setFont(QFont("MS Gothic", 30));
	+ char tmp[2];
	+ for (int i = 0x20; i < 0x80; i++) {
	+ tmp[0] = i;
	+ tmp[1] = 0;
	+ QString s = tmp;
	+ int w = pr.fontMetrics().size(0, s).width();
	+ qDebug() << w;
	+
	+ }
	+
	+ }
	+ qDebug() << QString("%1ms").arg(t.elapsed());
	+}
	+



	diff --git a/src/texteditor/AbstractCharacterBasedApplication.cpp b/src/texteditor/AbstractCharacterBasedApplication.cpp
	index cad4cc4..b7302d6 100644
	--- a/src/texteditor/AbstractCharacterBasedApplication.cpp
	+++ b/src/texteditor/AbstractCharacterBasedApplication.cpp
	@@ -1,2585 +1,2607 @@
	#include <memory>

	#include <memory>


	#include "AbstractCharacterBasedApplication.h"
	#include "UnicodeWidth.h"
	#include "unicode.h"

	#include <QApplication>
	#include <QClipboard>
	#include <QDebug>
	#include <QFile>
	#include <QTextCodec>
	#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;
	+ std::vector<AbstractCharacterBasedApplication::Char> 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::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 AbstractCharacterBasedApplication::fetchLine(int row) const
	{
	QByteArray line;
	- const int row = cx()->current_row;
	int lines = documentLines();
	if (row >= 0 && row < lines) {
	line = cx()->engine->document.lines[row].text;
	}
	+ return line;
	+}
	+
	+void AbstractCharacterBasedApplication::fetchCurrentLine() const
	+{
	+ int row = cx()->current_row;
	+ m->parsed_line = fetchLine(row);
	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)
	+void AbstractCharacterBasedApplication::commitLine(std::vector<Char> const &vec)
	{
	if (isReadOnly()) return;

	QByteArray ba;
	if (!vec.empty()){
	- utf32 u32(&vec[0], vec.size());
	+ std::vector<uint32_t> v;
	+ for (Char const &c : vec) {
	+ v.push_back(c.unicode);
	+ }
	+ utf32 u32(&v[0], v.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)
	+void AbstractCharacterBasedApplication::parseLine(std::vector<Char> *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_col_index = internalParseLine(m->parsed_line, vec ? vec : &m->prepared_current_line, increase_hint);
	m->parsed_for_edit = true;
	} else {
	if (vec) {
	*vec = m->prepared_current_line;
	}
	}
	}

	+int AbstractCharacterBasedApplication::parseLine2(int row, std::vector<Char> *vec) const
	+{
	+ QByteArray line = fetchLine(row);
	+ int index = internalParseLine(line, vec, 0);
	+ return index;
	+}
	+
	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, QString const &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> const &cx)
	{
	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 const &e)
	{
	cx()->engine = e;
	}

	void AbstractCharacterBasedApplication::setDocument(QList<Document::Line> const *source)
	{
	document()->lines = *source;
	}

	void AbstractCharacterBasedApplication::openFile(QString const &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(QString const &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 AbstractCharacterBasedApplication::calcIndexToColumn(const std::vector<Char> &vec, int index) const
	{
	int col = 0;
	for (int i = 0; i < index; i++) {
	- uint32_t c = vec.at(i);
	+ uint32_t c = vec.at(i).unicode;
	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)
	+void AbstractCharacterBasedApplication::setCursorColByIndex(std::vector<Char> 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)
	+void AbstractCharacterBasedApplication::editSelected(EditOperation op, std::vector<Char> *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;
	+ std::list<std::vector<Char>> 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;
	+ std::vector<Char> 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;
	+ std::vector<Char> 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;
	+ std::vector<Char> vec1;
	parseLine(&vec1, 0, true);
	{
	auto begin = vec1.begin();
	auto end = vec1.begin() + calcColumnToIndex(b.col);
	if (cutbuffer) {
	- std::vector<uint32_t> cut;
	+ std::vector<Char> 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;
	+ std::vector<Char> 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;
	+ std::vector<Char> vec2;
	parseLine(&vec2, 0, true);
	if (cutbuffer) {
	- std::vector<uint32_t> cut;
	+ std::vector<Char> 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) {
	+ for (std::vector<Char> 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;
	+ std::vector<Char> 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;
	+ std::vector<Char> 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){
	+ utf32(&u32buf[0].unicode, 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;
	+ std::vector<Char> *vec = &m->prepared_current_line;
	int index = m->parsed_col_index;
	int c = -1;
	if (index >= 0 && index < (int)vec->size()) {
	- c = (*vec)[index];
	+ c = (*vec)[index].unicode;
	}
	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') {
	+ if (c == '\r' && index < (int)vec->size() && (*vec)[index].unicode == '\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 const &value, DialogHandler const &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::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 const &dialog_value, DialogHandler const &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
	+int AbstractCharacterBasedApplication::internalParseLine(QByteArray const &parsed_line, std::vector<Char> *vec, int increase_hint) const
	{
	vec->clear();

	int index = -1;
	int col = 0;
	- int len = m->parsed_line.size();
	+ int len = parsed_line.size();
	if (len > 0) {
	vec->reserve(len + increase_hint);
	- char const *src = m->parsed_line.data();
	+ char const *src = 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);
	+ vec->push_back(Char(c, 0));
	}
	}
	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];
	+ uint32_t c = m->prepared_current_line[index].unicode;
	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];
	+ c = m->prepared_current_line[i].unicode;
	}
	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)
	+void AbstractCharacterBasedApplication::appendNewLine(std::vector<Char> *vec)
	{
	if (isSingleLineMode()) return;

	- vec->push_back('\r');
	- vec->push_back('\n');
	+ vec->emplace_back('\r', 0);
	+ vec->emplace_back('\n', 0);
	}

	void AbstractCharacterBasedApplication::writeNewLine()
	{
	if (isReadOnly()) return;
	if (isSingleLineMode()) return;
	if (!isCurrentLineWritable()) return;

	invalidateAreaBelowTheCurrentLine();

	- std::vector<uint32_t> curr_line;
	+ std::vector<Char> 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;
	+ std::vector<Char> 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;
	+ std::vector<Char> 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);
	+ c = line->at(index).unicode;
	}
	if (c == '\r' \|\| c == '\n' \|\| c == -1) {
	break;
	}
	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.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)> 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;
	+ std::vector<Char> *vec = &m->prepared_current_line;

	auto WriteChar = [&](ushort c){
	if (isInsertMode()) {
	- vec->insert(vec->begin() + index, c);
	+ vec->insert(vec->begin() + index, Char(c, 0));
	} else if (isOverwriteMode()) {
	if (index < (int)vec->size()) {
	- ushort d = vec->at(index);
	+ uint32_t d = vec->at(index).unicode;
	if (d == '\n' \|\| d == '\r') {
	- vec->insert(vec->begin() + index, c);
	+ vec->insert(vec->begin() + index, Char(c, 0));
	} else {
	- vec->at(index) = c;
	+ vec->at(index) = Char(c, 0);
	}
	} else {
	- vec->push_back(c);
	+ vec->emplace_back(c, 0);
	}
	}
	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(std::string const &text)
	{
	if (!text.empty()) {
	write(text.c_str(), text.size(), false);
	}
	}

	void AbstractCharacterBasedApplication::write_(char const *ptr, bool by_keyboard)
	{
	write(ptr, -1, by_keyboard);
	}

	void AbstractCharacterBasedApplication::write_(QString const &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;
	}
	}
	+
	+//AbstractCharacterBasedApplication::Char::operator unsigned int() const
	+//{
	+// qDebug();
	+// return 'A';
	+//}
	diff --git a/src/texteditor/AbstractCharacterBasedApplication.h b/src/texteditor/AbstractCharacterBasedApplication.h
	index e7418f9..ef3474a 100644
	--- a/src/texteditor/AbstractCharacterBasedApplication.h
	+++ b/src/texteditor/AbstractCharacterBasedApplication.h
	@@ -1,421 +1,435 @@
	#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() = 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;
	}
	};

	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;
	};

	using DialogHandler = std::function<void (bool, QString const &)>;

	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;
	};

	+ struct Char {
	+ unsigned int pos = 0;
	+ uint32_t unicode = 0;
	+ Char() = default;
	+ Char(uint32_t unicode, unsigned int pos)
	+ : unicode(unicode)
	+ , pos(pos)
	+ {
	+
	+ }
	+// operator unsigned int () const = delete;
	+ };
	+
	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;
	+ QByteArray fetchLine(int row) 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;
	+ int calcIndexToColumn(const std::vector<Char> &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 commitLine(const std::vector<Char> &vec);

	void doDelete();
	void doBackspace();

	bool isDialogMode();
	void setDialogMode(bool f);
	void closeDialog(bool result);
	void setDialogOption(QString const &title, QString const &value, const DialogHandler &handler);
	void execDialog(QString const &dialog_title, const QString &dialog_value, const DialogHandler &handler);
	void toggleSelectionAnchor();
	private:
	- int internalParseLine(std::vector<uint32_t> *vec, int increase_hint) const;
	+ int internalParseLine(const QByteArray &parsed_line, std::vector<Char> *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, char const *text, int padchar);
	SelectionAnchor currentAnchor(SelectionAnchor::Enabled enabled);
	enum class EditOperation {
	Cut,
	Copy,
	};
	- void editSelected(EditOperation op, std::vector<uint32_t> *cutbuffer);
	+ void editSelected(EditOperation op, std::vector<Char> *cutbuffer);
	void deselect();
	int calcColumnToIndex(int column);
	void edit_(EditOperation op);
	bool isCurrentLineWritable() const;
	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);
	+ void parseLine(std::vector<Char> *vec, int increase_hint, bool force);
	+ int parseLine2(int row, std::vector<Char> *vec) const;
	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);
	+ void setCursorColByIndex(const std::vector<Char> &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 appendNewLine(std::vector<Char> *vec);
	void writeNewLine();
	void updateCursorPos(bool auto_scroll);

	QString statusLine() const;

	void preparePaintScreen();
	void setRecentlyUsedPath(QString const &path);
	QString recentlyUsedPath();
	void clearRect(int x, int y, int w, int h);
	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(const TextEditorEnginePtr &e);
	void openFile(QString const &path);
	void saveFile(QString const &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(char const *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_(char const *ptr, bool by_keyboard);
	void write_(QString const &text, bool by_keyboard);
	void makeColumnPosList(std::vector<int> *out);
	};

	class AbstractTextEditorApplication : public AbstractCharacterBasedApplication {

	};


	#endif // ABSTRACTCHARACTERBASEDAPPLICATION_H
	diff --git a/src/texteditor/TextEditorWidget.cpp b/src/texteditor/TextEditorWidget.cpp
	index a2b23ab..0a029ff 100644
	--- a/src/texteditor/TextEditorWidget.cpp
	+++ b/src/texteditor/TextEditorWidget.cpp
	@@ -1,738 +1,847 @@
	#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"

	+class CharacterSize {
	+private:
	+ QFont font_;
	+ mutable int ascii_[128];
	+ mutable int height_ = 0;
	+ mutable std::map<unsigned int, int> map_;
	+public:
	+ void reset(QFont const &font)
	+ {
	+ font_ = font;
	+ height_ = 0;
	+ map_.clear();
	+ for (int i = 0; i < 128; i++) {
	+ ascii_[i] = 0;
	+ }
	+ }
	+ int width(unsigned int c) const
	+ {
	+ if (height_ == 0) {
	+ QPixmap pm(1, 1);
	+ QPainter pr(&pm);
	+ pr.setFont(font_);
	+ QFontMetrics fm = pr.fontMetrics();
	+ height_ = fm.ascent() + fm.descent();
	+ for (int i = 0; i < 0x20; i++) {
	+ ascii_[i] = 0;
	+ }
	+ for (int i = 0x20; i < 0x80; i++) {
	+ char tmp[2];
	+ tmp[0] = i;
	+ tmp[1] = 0;
	+ ascii_[i] = fm.size(0, tmp).width();
	+ }
	+ }
	+ if (c < 0x80) {
	+ return ascii_[c];
	+ }
	+ auto it = map_.find(c);
	+ if (it != map_.end()) {
	+ return it->second;
	+ } else {
	+ QPixmap pm(1, 1);
	+ QPainter pr(&pm);
	+ pr.setFont(font_);
	+ QFontMetrics fm = pr.fontMetrics();
	+ QString s = QChar(c);
	+ int w = fm.size(0, s).width();
	+ map_[c] = w;
	+ return w;
	+ }
	+ }
	+ int height() const
	+ {
	+ if (height_ == 0) {
	+ width(' ');
	+ }
	+ return height_;
	+ }
	+};
	+
	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;
	+ CharacterSize character_size;
	+// 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);
	+ setTextFont(QFont("MS Gothic", 10));
	+// setTextFont(QFont("MS PGothic", 16));
	#endif
	#ifdef Q_OS_LINUX
	- m->text_font = QFont("Monospace", 9);
	+ setTextFont(QFont("Monospace", 9));
	#endif
	#ifdef Q_OS_MACX
	- m->text_font = QFontDatabase().font("Osaka", "Regular-Mono", 14);
	+ setTextFont(QFontDatabase().font("Osaka", "Regular-Mono", 14));
	#endif
	#ifdef Q_OS_HAIKU
	- m->text_font = QFont("Noto Mono", 9);
	+ setTextFont(QFont("Noto Mono", 9));
	#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;
	+// 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 const &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::setTextFont(QFont const &font)
	+{
	+ m->text_font = font;
	+ m->character_size.reset(m->text_font);
	+}
	+
	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
	+int TextEditorWidget::charWidth2(unsigned int c) const
	{
	- return m->latin1_width;
	+ return m->character_size.width(c);
	}

	int TextEditorWidget::lineHeight() const
	{
	- return m->line_height;
	+ return m->character_size.height() + m->top_margin + m->bottom_margin;
	+}
	+
	+int TextEditorWidget::defaultCharWidth() const
	+{
	+ return m->character_size.width('8');
	+// return charWidth2('W');
	+}
	+
	+int TextEditorWidget::parseLine3(int row, std::vector<Char> *vec) const
	+{
	+ int index = parseLine2(row, vec);
	+ {
	+ int pos = 0;
	+ for (int i = 0; i < (int)vec->size(); i++) {
	+ vec->at(i).pos = pos;
	+ pos += m->character_size.width(vec->at(i).unicode);
	+ }
	+ }
	+ return index;
	}

	QPoint TextEditorWidget::mapFromPixel(QPoint const &pt)
	{
	- int x = pt.x() / latin1Width();
	+ if (1) {
	+// int x = pt.x() / defaultCharWidth();
	+ int y = pt.y() / lineHeight();
	+ int row = y + cx()->scroll_row_pos - cx()->viewport_org_y;
	+ int w = defaultCharWidth();
	+ int x = pt.x() + (cx()->scroll_col_pos - cx()->viewport_org_x) * w;
	+// int x = pt.x() + cx()->scroll_col_pos - cx()->viewport_org_x;
	+ std::vector<Char> vec;
	+ parseLine3(row, &vec);
	+// {
	+// int pos = 0;
	+// for (int i = 0; i < (int)vec.size(); i++) {
	+// vec[i].pos = pos;
	+// pos += m->character_size.width(vec[i].unicode);
	+// }
	+// }
	+ for (int col = 0; col + 1 < (int)vec.size(); col++) {
	+ if (x < vec[col + 1].pos) {
	+ return QPoint(col, row);
	+ }
	+ }
	+ return QPoint(vec.size(), row);
	+ }
	+
	+ int x = pt.x() / defaultCharWidth();
	int y = pt.y() / lineHeight();
	return QPoint(x, y);
	}

	QPoint TextEditorWidget::mapToPixel(QPoint const &pt)
	{
	- int x = pt.x() * latin1Width();
	+ int x = pt.x() * defaultCharWidth();
	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 const &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();
	+ x *= defaultCharWidth();
	y *= lineHeight();
	QPoint pt = QPoint(x, y);
	- int w = cx()->current_char_span * latin1Width();
	+ int w = cx()->current_char_span * defaultCharWidth();
	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;
	+ int x2 = 0;
	+ int x3 = 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);
	}
	+ x3 += charWidth2(unicode);
	n += cw;
	}
	if (n == 0) {
	n = 1;
	+ x3 += defaultCharWidth();
	} else if (!text.empty()) {
	QString str = QString::fromUtf16(&text[0], text.size());
	- int px = x * latin1Width();
	+ if (str.startsWith("#include")) {
	+ qDebug() << str;
	+ }
	+ int px = x * defaultCharWidth();
	int py = y * lineHeight();
	+ px = x2;
	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;
	+ x2 = x3;
	}
	}
	}

	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 col = cx()->viewport_org_x + cursorX();
	+ int row = cx()->viewport_org_y + cursorY();
	+ if (col < cx()->viewport_org_x \|\| col >= cx()->viewport_org_x + cx()->viewport_width) return;
	+ if (row < cx()->viewport_org_y \|\| row >= cx()->viewport_org_y + cx()->viewport_height) return;
	int h = lineHeight();
	+ int x = col * defaultCharWidth();
	+ int y = row * h;
	+ {
	+ col = cursorX();
	+ std::vector<Char> vec;
	+ parseLine3(row, &vec);
	+ if (vec.empty()) {
	+ x = 0;
	+ } else if (col >= 0 && col < vec.size()) {
	+ x = vec[col].pos;
	+ } else {
	+ x = vec.back().pos;
	+ }
	+ }
	+ x += cx()->viewport_org_x * defaultCharWidth();
	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 x = cx()->viewport_org_x * defaultCharWidth();
	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());
	}
	+ int linenum_width = editor_cx->viewport_org_x * defaultCharWidth();
	drawCursor(&pr);
	}
	}

	paintScreen(&pr);

	if (renderingMode() == DecoratedMode) {
	- int linenum_width = editor_cx->viewport_org_x * latin1Width();
	+ int linenum_width = editor_cx->viewport_org_x * defaultCharWidth();
	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);
	+ drawText(&pr, linenum_width - defaultCharWidth() * 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;
	- }
	+ QPoint pos = mapFromPixel(mousepos);
	+ int row = pos.y();
	+ int col = pos.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 (int pt : pts) {
	- int x = pt * 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.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 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();
	+ int w = width() / defaultCharWidth();
	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/TextEditorWidget.h b/src/texteditor/TextEditorWidget.h
	index 72e43c3..8dc4479 100644
	--- a/src/texteditor/TextEditorWidget.h
	+++ b/src/texteditor/TextEditorWidget.h
	@@ -1,105 +1,108 @@
	#ifndef OREWIDGET_H
	#define OREWIDGET_H

	#include <QTextFormat>
	#include <QWidget>
	#include <vector>
	#include <cstdint>
	#include <memory>
	#include "AbstractCharacterBasedApplication.h"
	#include "TextEditorTheme.h"

	class QScrollBar;

	struct PreEditText {
	struct Format {
	int start;
	int length;
	QTextFormat format;
	Format(int start, int length, QTextFormat const &f)
	: start(start)
	, length(length)
	, format(f)
	{
	}
	};

	QString text;
	std::vector<Format> format;
	};

	class TextEditorWidget : public QWidget, public AbstractTextEditorApplication {
	Q_OBJECT
	public:
	enum RenderingMode {
	CharacterMode,
	DecoratedMode,
	};
	private:
	struct Private;
	Private *m;

	void paintScreen(QPainter *painter);
	void drawCursor(QPainter *pr);
	void drawFocusFrame(QPainter *pr);
	QRect updateCursorRect(bool auto_scroll);
	RenderingMode renderingMode() const;
	QColor defaultForegroundColor();
	QColor defaultBackgroundColor();
	QColor colorForIndex(CharAttr const &attr, bool foreground);
	void internalUpdateVisibility(bool ensure_current_line_visible, bool change_col, bool auto_scroll);
	void internalUpdateScrollBar();
	void moveCursorByMouse();
	+ void setTextFont(const QFont &font);
	+ int defaultCharWidth() const;
	+ int parseLine3(int row, std::vector<Char> *vec) const;
	protected:
	void paintEvent(QPaintEvent *) override;
	void mousePressEvent(QMouseEvent *event) override;
	void mouseReleaseEvent(QMouseEvent *event) override;
	void mouseMoveEvent(QMouseEvent *event) override;
	void wheelEvent(QWheelEvent *event) override;
	void resizeEvent(QResizeEvent *event) override;
	void contextMenuEvent(QContextMenuEvent *event) override;
	QFont textFont();
	void drawText(QPainter *painter, int px, int py, QString const &str);
	public:
	explicit TextEditorWidget(QWidget *parent = nullptr);
	~TextEditorWidget() override;

	void setTheme(const TextEditorThemePtr &theme);
	TextEditorTheme const *theme() const;

	- int latin1Width() const;
	+ int charWidth2(unsigned int c) const;
	int lineHeight() const;

	void setPreEditText(PreEditText const &preedit);

	void updateVisibility(bool ensure_current_line_visible, bool change_col, bool auto_scroll) override;

	bool event(QEvent *event) override;

	void bindScrollBar(QScrollBar vsb, QScrollBar hsb);
	void setupForLogWidget(QScrollBar vsb, QScrollBar hsb, const TextEditorThemePtr &theme);

	QPoint mapFromPixel(const QPoint &pt);
	QPoint mapToPixel(const QPoint &pt);

	QVariant inputMethodQuery(Qt::InputMethodQuery q) const override;
	void inputMethodEvent(QInputMethodEvent *e) override;
	void refrectScrollBar();

	void setRenderingMode(RenderingMode mode);

	void move(int cur_row, int cur_col, int scr_row, int scr_col, bool auto_scroll);
	void layoutEditor() override;
	void setFocusFrameVisible(bool f);
	signals:
	void moved(int cur_row, int cur_col, int scr_row, int scr_col);
	void updateScrollBar();
	void idle();
	protected:
	void timerEvent(QTimerEvent *) override;
	};




	#endif // OREWIDGET_H

File Metadata

Mime Type: text/x-diff
Expires: Sat, Feb 7, 1:15 PM (10 h, 28 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55946
Default Alt Text: (181 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions