diff -r ca23936b455b -r 5d201ee4a9c3 src/main.cpp
--- a/src/main.cpp	Mon Jun 06 22:01:22 2022 +0300
+++ b/src/main.cpp	Tue Jun 07 01:37:26 2022 +0300
@@ -1,24 +1,14 @@
-/*
- *  LDForge: LDraw parts authoring CAD
- *  Copyright (C) 2013 - 2020 Teemu Piippo
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
+#include <QApplication>
+#include <QFileDialog>
+#include <QMessageBox>
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+#include "version.h"
+#include "document.h"
+#include "settingseditor/settingseditor.h"
+#include "widgets/colorselectdialog.h"
 
-#include <QApplication>
-#include "mainwindow.h"
-#include "version.h"
+static const QDir LOCALE_DIR {":/locale"};
 
 static void doQtRegistrations()
 {
@@ -29,11 +19,408 @@
 	qRegisterMetaTypeStreamOperators<Libraries>("Libraries");
 }
 
+template<typename BaseType, typename MemberType, typename DataType>
+struct MemberData
+{
+	std::size_t member;
+	DataType payload;
+	constexpr MemberType memberInstance(BaseType* instance) const
+	{
+		return *reinterpret_cast<MemberType*>(reinterpret_cast<char*>(instance) + this->member);
+	}
+};
+
+static constexpr MemberData<Ui_MainWindow, QAction*, gl::RenderStyle> renderStyleButtons[] = {
+	{ offsetof(Ui_MainWindow, actionRenderStyleNormal), gl::RenderStyle::Normal },
+	{ offsetof(Ui_MainWindow, actionRenderStyleBfc), gl::RenderStyle::BfcRedGreen },
+	{ offsetof(Ui_MainWindow, actionRenderStyleRandom), gl::RenderStyle::RandomColors },
+	{ offsetof(Ui_MainWindow, actionRenderStylePickScene), gl::RenderStyle::PickScene },
+};
+
+static std::optional<ModelId> openModelFromPath(
+	const QString& path,
+	const LibraryManager* libraries,
+	DocumentManager* documents,
+	QWidget* parent)
+{
+	QString errorString;
+	QTextStream errorStream{&errorString};
+	const std::optional<ModelId> modelIdOpt = documents->openModel(
+		path,
+		errorStream,
+		DocumentManager::OpenType::ManuallyOpened);
+	if (modelIdOpt.has_value()) {
+		documents->loadDependenciesForModel(modelIdOpt.value(), path, *libraries, errorStream);
+		if (not errorString.isEmpty()) {
+			QMessageBox::warning(
+				parent,
+				QObject::tr("Problem loading references"),
+				errorString);
+		}
+	}
+	else {
+		QMessageBox::critical(
+			parent,
+			QObject::tr("Problem opening file"),
+			format(QObject::tr("Could not open %1: %2"), path, errorString));
+	}
+	return modelIdOpt;
+}
+
+static QString getOpenModelPath(QWidget* parent)
+{
+	return QFileDialog::getOpenFileName(
+		parent,
+		QObject::tr("Open model"),
+		"",
+		QObject::tr("LDraw models (*.ldr *.dat)"));
+}
+
+static const QString localeCode(const QString& locale)
+{
+	if (locale == "system") {
+		return QLocale::system().name();
+	}
+	else {
+		return locale;
+	}
+}
+
+/**
+ * @brief Changes the application language to the specified language
+ */
+static void changeLanguage(const QString& locale, QTranslator* translator)
+{
+	if (not locale.isEmpty()) {
+		const QString localeCode = ::localeCode(locale);
+		QLocale::setDefault({localeCode});
+		qApp->removeTranslator(translator);
+		const QString path = LOCALE_DIR.filePath(localeCode + ".qm");
+		const bool loadSuccessful = translator->load(path);
+		if (loadSuccessful)
+		{
+			qApp->installTranslator(translator);
+		}
+	}
+}
+
+/*
+void MainWindow::handleDocumentSplitterChange()
+{
+	EditorTabWidget* currentDocument = this->currentDocument();
+	if (currentDocument != nullptr)
+	{
+		this->documentSplitterState = currentDocument->saveSplitterState();
+		for (int i = 0; i < this->ui->tabs->count(); i += 1)
+		{
+			EditorTabWidget* document = qobject_cast<EditorTabWidget*>(this->ui->tabs->widget(i));
+			if (document != nullptr and document != currentDocument)
+			{
+				document->restoreSplitterState(this->documentSplitterState);
+			}
+		}
+		this->settings.setMainSplitterState(this->documentSplitterState);
+	}
+}
+*/
+
+static EditorTabWidget* currentTabWidget(Ui_MainWindow* ui)
+{
+	return qobject_cast<EditorTabWidget*>(ui->tabs->currentWidget());
+};
+
+
+static void closeDocument(DocumentManager* documents, EditorTabWidget *document)
+{
+	std::optional<ModelId> modelId = documents->findIdForModel(document->model);
+	if (modelId.has_value()) {
+		documents->closeDocument(modelId.value());
+		delete document;
+	}
+}
+
+static void handleTabCloseButton(Ui_MainWindow* ui, DocumentManager* documents, int tabIndex)
+{
+	if (tabIndex >= 0 and tabIndex < ui->tabs->count()) {
+		EditorTabWidget* tab = qobject_cast<EditorTabWidget*>(ui->tabs->widget(tabIndex));
+		if (tab != nullptr) {
+			closeDocument(documents, tab);
+		}
+	}
+}
+
+static std::optional<ModelId> findCurrentModelId(Ui_MainWindow* ui, DocumentManager* documents)
+{
+	const EditorTabWidget* tab = currentTabWidget(ui);
+	if (tab != nullptr) {
+		return documents->findIdForModel(tab->model);
+	}
+	else {
+		return {};
+	}
+}
+
+/**
+ * @brief Updates the title of the main window so to contain the app's name
+ * and version as well as the open document name.
+ */
+static QString title()
+{
+	QString title = ::appName;
+	title += " ";
+	title += fullVersionString();
+	return title;
+}
+
+static ldraw::ColorTable loadColors(const LibraryManager* libraries)
+{
+	QTextStream errors;
+	return libraries->loadColorTable(errors);
+}
+
+static QString tabName(const QFileInfo& fileInfo)
+{
+	QString result = fileInfo.baseName();
+	if (result.isEmpty()) {
+		result = QObject::tr("<unnamed>");
+	}
+	return result;
+}
+
+void rebuildRecentFilesMenu(QMenu* menu, const QStringList& strings, QWidget* parent)
+{
+	menu->clear();
+	for (const QString& path : strings) {
+		QAction* action = new QAction{path, parent};
+		action->setData(path);
+		menu->addAction(action);
+	}
+}
+
+static void updateRenderPreferences(
+	Ui_MainWindow* ui,
+	const gl::RenderPreferences* renderPreferences)
+{
+	for (int i = 0; i < ui->tabs->count(); i += 1) {
+		EditorTabWidget* tab = qobject_cast<EditorTabWidget*>(ui->tabs->widget(i));
+		if (tab != nullptr) {
+			tab->canvas->setRenderPreferences(*renderPreferences);
+		}
+	}
+	for (auto data : ::renderStyleButtons) {
+		QAction* action = data.memberInstance(ui);
+		action->setChecked(renderPreferences->style == data.payload);
+	}
+	ui->actionDrawAxes->setChecked(renderPreferences->drawAxes);
+};
+
+static gl::RenderPreferences loadRenderPreferences(Configuration* settings)
+{
+	return gl::RenderPreferences{
+		.style = static_cast<gl::RenderStyle>(settings->renderStyle()),
+		.mainColor = settings->mainColor(),
+		.backgroundColor = settings->backgroundColor(),
+		.selectedColor = settings->selectedColor(),
+		.lineThickness = settings->lineThickness(),
+		.lineAntiAliasing = settings->lineAntiAliasing(),
+		.drawAxes = settings->drawAxes(),
+	};
+}
+
 int main(int argc, char *argv[])
 {
 	doQtRegistrations();
 	QApplication app{argc, argv};
-	MainWindow mainwindow;
-	mainwindow.show();
-	return app.exec();
+	QMainWindow mainWindow;
+	Ui_MainWindow ui;
+	DocumentManager documents{&mainWindow};
+	QString currentLanguage = "en";
+	QTranslator translator{&mainWindow};
+	Configuration settings;
+	LibraryManager libraries{&mainWindow};
+	QByteArray documentSplitterState;
+	QStringList recentlyOpenedFiles;
+	ldraw::ColorTable colorTable;
+	gl::RenderPreferences renderPreferences;
+	ui.setupUi(&mainWindow);
+	const uiutilities::KeySequenceMap defaultKeyboardShortcuts =
+		uiutilities::makeKeySequenceMap(uiutilities::collectActions(&mainWindow));
+	const auto saveSettings = [&]{
+		settings.setMainWindowGeometry(mainWindow.saveGeometry());
+		settings.setRecentFiles(recentlyOpenedFiles);
+		settings.setMainSplitterState(documentSplitterState);
+		settings.setRenderStyle(static_cast<int>(renderPreferences.style));
+		settings.setDrawAxes(renderPreferences.drawAxes);
+		libraries.storeToSettings(&settings);
+	};
+	const auto updateRecentlyOpenedDocumentsMenu = [&]{
+		rebuildRecentFilesMenu(ui.menuRecentFiles, recentlyOpenedFiles, &mainWindow);
+		for (QAction* action : ui.menuRecentFiles->findChildren<QAction*>()) {
+			QString path = action->data().toString();
+			QObject::connect(
+				action,
+				&QAction::triggered,
+				[path, &libraries, &documents, &mainWindow]() {
+					openModelFromPath(path, &libraries, &documents, &mainWindow);
+				}
+			);
+		}
+	};
+	const auto restoreSettings = [&]{
+		recentlyOpenedFiles = settings.recentFiles();
+		documentSplitterState = settings.mainSplitterState();
+		renderPreferences = loadRenderPreferences(&settings);
+		changeLanguage(settings.locale(), &translator);
+		libraries.restoreFromSettings(&settings);
+		updateRecentlyOpenedDocumentsMenu();
+		colorTable = loadColors(&libraries);
+		updateRenderPreferences(&ui, &renderPreferences);
+		ui.retranslateUi(&mainWindow);
+	};
+	const auto addRecentlyOpenedFile = [&](const QString& path){
+		constexpr int maxRecentlyOpenedFiles = 10;
+		recentlyOpenedFiles.removeAll(path);
+		recentlyOpenedFiles.insert(0, path);
+		while (recentlyOpenedFiles.size() > maxRecentlyOpenedFiles)
+		{
+			recentlyOpenedFiles.removeLast();
+		}
+		saveSettings();
+		updateRecentlyOpenedDocumentsMenu();
+	};
+	const auto openModelForEditing = [&](const ModelId modelId){
+		EditorTabWidget* document = new EditorTabWidget{
+			documents.getModelById(modelId),
+			&documents,
+			colorTable,
+		};
+		document->canvas->setRenderPreferences(renderPreferences);
+		QObject::connect(
+			document,
+			&EditorTabWidget::newStatusText,
+			[&](const QString& newStatusText) {
+				mainWindow.statusBar()->showMessage(newStatusText);
+			});
+		const QFileInfo fileInfo{*documents.modelPath(modelId)};
+		ui.tabs->addTab(document, tabName(fileInfo));
+		ui.tabs->setCurrentWidget(document);
+		document->restoreSplitterState(documentSplitterState);
+	};
+	const auto newModel = [&openModelForEditing](DocumentManager* documents){
+		openModelForEditing(documents->newModel());
+	};
+	QObject::connect(ui.actionNew, &QAction::triggered, [&newModel, &documents]{
+		newModel(&documents);
+	});
+	QObject::connect(ui.actionOpen, &QAction::triggered, [&]{
+		const QString path = getOpenModelPath(&mainWindow);
+		if (not path.isEmpty())
+		{
+			const std::optional<ModelId> id = openModelFromPath(path, &libraries, &documents, &mainWindow);
+			if (id.has_value()) {
+				openModelForEditing(id.value());
+				addRecentlyOpenedFile(path);
+			}
+		}
+	});
+	QObject::connect(ui.actionSettingsEditor, &QAction::triggered, [&]{
+		SettingsEditor settingsEditor{&settings, defaultKeyboardShortcuts, &mainWindow};
+		const int result = settingsEditor.exec();
+		if (result == QDialog::Accepted)
+		{
+			restoreSettings();
+		}
+	});
+	QObject::connect(ui.actionQuit, &QAction::triggered, &mainWindow, &QMainWindow::close);
+	QObject::connect(ui.actionAdjustGridToView, &QAction::triggered, [&ui]{
+		EditorTabWidget* tab = currentTabWidget(&ui);
+		if (tab != nullptr)
+		{
+			adjustGridToView(tab->canvas);
+		}
+	});
+	QObject::connect(ui.actionClose, &QAction::triggered, [&ui, &documents]{
+		EditorTabWidget* tab = currentTabWidget(&ui);
+		if (tab != nullptr)
+		{
+			closeDocument(&documents, tab);
+		}
+	});
+	const auto save = [&](ModelId modelId){
+		QString error;
+		QTextStream errorStream{&error};
+		const bool succeeded = documents.saveModel(modelId, errorStream);
+		if (not succeeded)
+		{
+			QMessageBox::critical(&mainWindow, QObject::tr("Save error"), error);
+		}
+		else
+		{
+			const QString* pathPtr = documents.modelPath(modelId);
+			if (pathPtr != nullptr) {
+				addRecentlyOpenedFile(*pathPtr);
+			}
+		}
+	};
+	const auto actionSaveAs = [&]{
+		const std::optional<ModelId> modelId = findCurrentModelId(&ui, &documents);
+		if (modelId.has_value())
+		{
+			const QString* pathPtr = documents.modelPath(*modelId);
+			QString defaultPath = (pathPtr != nullptr) ? *pathPtr : "";
+			const QString newPath = QFileDialog::getSaveFileName(
+				&mainWindow,
+				QObject::tr("Save as…"),
+				QFileInfo{defaultPath}.absoluteDir().path(), 
+				QObject::tr("LDraw files (*.ldr *dat);;All files (*)")
+			);
+			if (not newPath.isEmpty()) {
+				QString error;
+				QTextStream errorStream{&error};
+				documents.setModelPath(*modelId, newPath, libraries, errorStream);
+				ui.tabs->setTabText(ui.tabs->currentIndex(), QFileInfo{newPath}.fileName());
+				save(*modelId);
+			}
+		}
+	};
+	QObject::connect(ui.actionSaveAs, &QAction::triggered, actionSaveAs);
+	QObject::connect(ui.actionSave, &QAction::triggered, [&]{
+		if (currentTabWidget(&ui) != nullptr) {
+			const std::optional<ModelId> modelId = findCurrentModelId(&ui, &documents);
+			if (modelId.has_value()) {
+				const QString* path = documents.modelPath(*modelId);
+				if (path == nullptr or path->isEmpty()) {
+					actionSaveAs();
+				}
+				else {
+					save(*modelId);
+				}
+			}
+		}
+	});
+	QObject::connect(ui.tabs, &QTabWidget::tabCloseRequested, [&](int index){
+		handleTabCloseButton(&ui, &documents, index);
+	});
+	QObject::connect(ui.actionDrawAxes, &QAction::triggered, [&](bool drawAxes){
+		renderPreferences.drawAxes = drawAxes;
+		saveSettings();
+		updateRenderPreferences(&ui, &renderPreferences);
+	});
+	for (auto data : ::renderStyleButtons) {
+		QAction* action = data.memberInstance(&ui);
+		QObject::connect(action, &QAction::triggered, [&, data]{
+			renderPreferences.style = data.payload;
+			saveSettings();
+			updateRenderPreferences(&ui, &renderPreferences);
+		});
+	}
+	mainWindow.setWindowTitle(title());
+	mainWindow.restoreGeometry(settings.mainWindowGeometry());
+	restoreSettings();
+	updateRenderPreferences(&ui, &renderPreferences);
+	newModel(&documents);
+	mainWindow.show();
+	const int result = app.exec();
+	saveSettings();
+	return result;
 }