Gui: refactor Application::runApplication

2024-02-24 16:21:14 +01:00
parent 45e33a7f12
commit 58a53e929d
6 changed files with 780 additions and 508 deletions
--- a/src/Gui/StartupProcess.cpp
+++ b/src/Gui/StartupProcess.cpp
@@ -0,0 +1,569 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+/***************************************************************************
+ *   Copyright (c) 2024 Werner Mayer <wmayer[at]users.sourceforge.net>     *
+ *                                                                         *
+ *   This file is part of FreeCAD.                                         *
+ *                                                                         *
+ *   FreeCAD is free software: you can redistribute it and/or modify it    *
+ *   under the terms of the GNU Lesser General Public License as           *
+ *   published by the Free Software Foundation, either version 2.1 of the  *
+ *   License, or (at your option) any later version.                       *
+ *                                                                         *
+ *   FreeCAD 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      *
+ *   Lesser General Public License for more details.                       *
+ *                                                                         *
+ *   You should have received a copy of the GNU Lesser General Public      *
+ *   License along with FreeCAD. If not, see                               *
+ *   <https://www.gnu.org/licenses/>.                                      *
+ *                                                                         *
+ **************************************************************************/
+
+#include "PreCompiled.h"
+#ifndef _PreComp_
+#include <QApplication>
+#include <QDir>
+#include <QImageReader>
+#include <QLabel>
+#include <QOpenGLContext>
+#include <QOpenGLFunctions>
+#include <QStatusBar>
+#include <QWindow>
+#include <Inventor/SoDB.h>
+#endif
+
+#include "StartupProcess.h"
+#include "Application.h"
+#include "AutoSaver.h"
+#include "DlgCheckableMessageBox.h"
+#include "FileDialog.h"
+#include "GuiApplication.h"
+#include "MainWindow.h"
+#include "Language/Translator.h"
+#include <App/Application.h>
+
+
+using namespace Gui;
+
+
+StartupProcess::StartupProcess() = default;
+
+void StartupProcess::setupApplication()
+{
+    QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
+
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
+    QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL);
+#endif
+
+    // Automatic scaling for legacy apps (disable once all parts of GUI are aware of HiDpi)
+    ParameterGrp::handle hDPI =
+        App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/HighDPI");
+    bool disableDpiScaling = hDPI->GetBool("DisableDpiScaling", false);
+    if (disableDpiScaling) {
+#ifdef FC_OS_WIN32
+        SetProcessDPIAware(); // call before the main event loop
+#endif
+#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
+        QApplication::setAttribute(Qt::AA_DisableHighDpiScaling);
+#endif
+    }
+    else {
+        // Enable automatic scaling based on pixel density of display (added in Qt 5.6)
+#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
+        QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+#endif
+#if QT_VERSION >= QT_VERSION_CHECK(5,14,0) && defined(Q_OS_WIN)
+        QGuiApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
+#endif
+    }
+
+#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
+    //Enable support for highres images (added in Qt 5.1, but off by default)
+    QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
+#endif
+
+    // Use software rendering for OpenGL
+    ParameterGrp::handle hOpenGL =
+        App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/OpenGL");
+    bool useSoftwareOpenGL = hOpenGL->GetBool("UseSoftwareOpenGL", false);
+    if (useSoftwareOpenGL) {
+        QApplication::setAttribute(Qt::AA_UseSoftwareOpenGL);
+    }
+
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
+    // By default (on platforms that support it, see docs for
+    // Qt::AA_CompressHighFrequencyEvents) QT applies compression
+    // for high frequency events (mouse move, touch, window resizes)
+    // to keep things smooth even when handling the event takes a
+    // while (e.g. to calculate snapping).
+    // However, tablet pen move events (and mouse move events
+    // synthesised from those) are not compressed by default (to
+    // allow maximum precision when e.g. hand-drawing curves),
+    // leading to unacceptable slowdowns using a tablet pen. Enable
+    // compression for tablet events here to solve that.
+    QCoreApplication::setAttribute(Qt::AA_CompressTabletEvents);
+#endif
+}
+
+void StartupProcess::execute()
+{
+    setLibraryPath();
+    setStyleSheetPaths();
+    setImagePaths();
+    registerEventType();
+    setThemePaths();
+    setupFileDialog();
+}
+
+void StartupProcess::setLibraryPath()
+{
+    QString plugin;
+    plugin = QString::fromStdString(App::Application::getHomePath());
+    plugin += QLatin1String("/plugins");
+    QCoreApplication::addLibraryPath(plugin);
+}
+
+void StartupProcess::setStyleSheetPaths()
+{
+    // setup the search paths for Qt style sheets
+    QStringList qssPaths;
+    qssPaths << QString::fromUtf8(
+        (App::Application::getUserAppDataDir() + "Gui/Stylesheets/").c_str())
+            << QString::fromUtf8((App::Application::getResourceDir() + "Gui/Stylesheets/").c_str())
+            << QLatin1String(":/stylesheets");
+    QDir::setSearchPaths(QString::fromLatin1("qss"), qssPaths);
+    // setup the search paths for Qt overlay style sheets
+    QStringList qssOverlayPaths;
+    qssOverlayPaths << QString::fromUtf8((App::Application::getUserAppDataDir()
+                        + "Gui/Stylesheets/overlay").c_str())
+                    << QString::fromUtf8((App::Application::getResourceDir()
+                        + "Gui/Stylesheets/overlay").c_str());
+    QDir::setSearchPaths(QStringLiteral("overlay"), qssOverlayPaths);
+}
+
+void StartupProcess::setImagePaths()
+{
+    // set search paths for images
+    QStringList imagePaths;
+    imagePaths << QString::fromUtf8((App::Application::getUserAppDataDir() + "Gui/images").c_str())
+            << QString::fromUtf8((App::Application::getUserAppDataDir() + "pixmaps").c_str())
+            << QLatin1String(":/icons");
+    QDir::setSearchPaths(QString::fromLatin1("images"), imagePaths);
+}
+
+void StartupProcess::registerEventType()
+{
+    // register action style event type
+    ActionStyleEvent::EventType = QEvent::registerEventType(QEvent::User + 1);
+}
+
+void StartupProcess::setThemePaths()
+{
+    ParameterGrp::handle hTheme = App::GetApplication().GetParameterGroupByPath(
+        "User parameter:BaseApp/Preferences/Bitmaps/Theme");
+#if !defined(Q_OS_LINUX)
+    QIcon::setThemeSearchPaths(QIcon::themeSearchPaths()
+                            << QString::fromLatin1(":/icons/FreeCAD-default"));
+    QIcon::setThemeName(QLatin1String("FreeCAD-default"));
+#else
+    // Option to opt-out from using a Linux desktop icon theme.
+    // https://forum.freecad.org/viewtopic.php?f=4&t=35624
+    bool themePaths = hTheme->GetBool("ThemeSearchPaths",true);
+    if (!themePaths) {
+        QStringList searchPaths;
+        searchPaths.prepend(QString::fromUtf8(":/icons"));
+        QIcon::setThemeSearchPaths(searchPaths);
+        QIcon::setThemeName(QLatin1String("FreeCAD-default"));
+    }
+#endif
+
+    std::string searchpath = hTheme->GetASCII("SearchPath");
+    if (!searchpath.empty()) {
+        QStringList searchPaths = QIcon::themeSearchPaths();
+        searchPaths.prepend(QString::fromUtf8(searchpath.c_str()));
+        QIcon::setThemeSearchPaths(searchPaths);
+    }
+
+    std::string name = hTheme->GetASCII("Name");
+    if (!name.empty()) {
+        QIcon::setThemeName(QString::fromLatin1(name.c_str()));
+    }
+}
+
+void StartupProcess::setupFileDialog()
+{
+#if defined(FC_OS_LINUX)
+    // See #0001588
+    QString path = FileDialog::restoreLocation();
+    FileDialog::setWorkingDirectory(QDir::currentPath());
+    FileDialog::saveLocation(path);
+#else
+    FileDialog::setWorkingDirectory(FileDialog::restoreLocation());
+#endif
+}
+
+// ------------------------------------------------------------------------------------------------
+
+StartupPostProcess::StartupPostProcess(MainWindow* mw, Application& guiApp, QApplication* app)
+    : mainWindow{mw}
+    , guiApp{guiApp}
+    , qtApp(app)
+{
+}
+
+void StartupPostProcess::setLoadFromPythonModule(bool value)
+{
+    loadFromPythonModule = value;
+}
+
+void StartupPostProcess::execute()
+{
+    setWindowTitle();
+    setProcessMessages();
+    setAutoSaving();
+    setToolBarIconSize();
+    setWheelEventFilter();
+    setLocale();
+    setCursorFlashing();
+    checkOpenGL();
+    loadOpenInventor();
+    setBranding();
+    showMainWindow();
+    activateWorkbench();
+}
+
+void StartupPostProcess::setWindowTitle()
+{
+    // allow to disable version number
+    ParameterGrp::handle hGen =
+        App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/General");
+    bool showVersion = hGen->GetBool("ShowVersionInTitle", true);
+
+    QString appName = QCoreApplication::applicationName();
+    if (appName.isEmpty()) {
+        appName = QString::fromLatin1(App::Application::Config()["ExeName"].c_str());
+    }
+    if (showVersion) {
+        // set main window title with FreeCAD Version
+        std::map<std::string, std::string>& config = App::Application::Config();
+        QString major  = QString::fromLatin1(config["BuildVersionMajor"].c_str());
+        QString minor  = QString::fromLatin1(config["BuildVersionMinor"].c_str());
+        QString point = QString::fromLatin1(config["BuildVersionPoint"].c_str());
+        QString suffix = QString::fromLatin1(config["BuildVersionSuffix"].c_str());
+        QString title = QString::fromLatin1("%1 %2.%3.%4%5").arg(
+            appName, major, minor, point, suffix
+        );
+        mainWindow->setWindowTitle(title);
+    }
+    else {
+        mainWindow->setWindowTitle(appName);
+    }
+}
+
+void StartupPostProcess::setProcessMessages()
+{
+    if (!loadFromPythonModule) {
+        QObject::connect(qtApp, SIGNAL(messageReceived(const QList<QByteArray> &)),
+                         mainWindow, SLOT(processMessages(const QList<QByteArray> &)));
+    }
+}
+
+void StartupPostProcess::setAutoSaving()
+{
+    ParameterGrp::handle hDocGrp = WindowParameter::getDefaultParameter()->GetGroup("Document");
+    int timeout = int(hDocGrp->GetInt("AutoSaveTimeout", 15L)); // 15 min
+    if (!hDocGrp->GetBool("AutoSaveEnabled", true)) {
+        timeout = 0;
+    }
+
+    AutoSaver::instance()->setTimeout(timeout * 60000);  // NOLINT
+    AutoSaver::instance()->setCompressed(hDocGrp->GetBool("AutoSaveCompressed", true));
+}
+
+void StartupPostProcess::setToolBarIconSize()
+{
+    // set toolbar icon size
+    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("General");
+    int size = int(hGrp->GetInt("ToolbarIconSize", 0));
+    // must not be lower than this
+    if (size >= 16) {  // NOLINT
+        mainWindow->setIconSize(QSize(size,size));
+    }
+}
+
+void StartupPostProcess::setWheelEventFilter()
+{
+    // filter wheel events for combo boxes
+    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("General");
+    if (hGrp->GetBool("ComboBoxWheelEventFilter", false)) {
+        auto filter = new WheelEventFilter(qtApp);
+        qtApp->installEventFilter(filter);
+    }
+}
+
+void StartupPostProcess::setLocale()
+{
+    // For values different to 1 and 2 use the OS locale settings
+    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("General");
+    auto localeFormat = hGrp->GetInt("UseLocaleFormatting", 0);
+    if (localeFormat == 1) {
+        Translator::instance()->setLocale(
+            hGrp->GetASCII("Language", Translator::instance()->activeLanguage().c_str()));
+    }
+    else if (localeFormat == 2) {
+        Translator::instance()->setLocale("C");
+    }
+
+}
+
+void StartupPostProcess::setCursorFlashing()
+{
+    // set text cursor blinking state
+    ParameterGrp::handle hGrp = WindowParameter::getDefaultParameter()->GetGroup("General");
+    int blinkTime = hGrp->GetBool("EnableCursorBlinking", true) ? -1 : 0;
+    QApplication::setCursorFlashTime(blinkTime);
+}
+
+void StartupPostProcess::checkOpenGL()
+{
+    QWindow window;
+    window.setSurfaceType(QWindow::OpenGLSurface);
+    window.create();
+
+    QOpenGLContext context;
+    if (context.create()) {
+        context.makeCurrent(&window);
+        if (!context.functions()->hasOpenGLFeature(QOpenGLFunctions::Framebuffers)) {
+            Base::Console().Log("This system does not support framebuffer objects\n");
+        }
+        if (!context.functions()->hasOpenGLFeature(QOpenGLFunctions::NPOTTextures)) {
+            Base::Console().Log("This system does not support NPOT textures\n");
+        }
+
+        int major = context.format().majorVersion();
+        int minor = context.format().minorVersion();
+
+#ifdef NDEBUG
+        // In release mode, issue a warning to users that their version of OpenGL is
+        // potentially going to cause problems
+        if (major < 2) {
+            auto message =
+                QObject::tr("This system is running OpenGL %1.%2. "
+                            "FreeCAD requires OpenGL 2.0 or above. "
+                            "Please upgrade your graphics driver and/or card as required.")
+                    .arg(major)
+                    .arg(minor)
+                + QStringLiteral("\n");
+            Base::Console().Warning(message.toStdString().c_str());
+            Dialog::DlgCheckableMessageBox::showMessage(
+                QCoreApplication::applicationName() + QStringLiteral(" - ")
+                    + QObject::tr("Invalid OpenGL Version"),
+                message);
+        }
+#endif
+        const char* glVersion = reinterpret_cast<const char*>(glGetString(GL_VERSION));
+        Base::Console().Log("OpenGL version is: %d.%d (%s)\n", major, minor, glVersion);
+    }
+}
+
+void StartupPostProcess::loadOpenInventor()
+{
+    bool loadedInventor = false;
+    if (loadFromPythonModule) {
+        loadedInventor = SoDB::isInitialized();
+    }
+
+    if (!loadedInventor) {
+        // init the Inventor subsystem
+        Application::initOpenInventor();
+    }
+}
+
+void StartupPostProcess::setBranding()
+{
+    QString home = QString::fromStdString(App::Application::getHomePath());
+
+    const std::map<std::string,std::string>& cfg = App::Application::Config();
+    std::map<std::string,std::string>::const_iterator it;
+    it = cfg.find("WindowTitle");
+    if (it != cfg.end()) {
+        QString title = QString::fromUtf8(it->second.c_str());
+        mainWindow->setWindowTitle(title);
+    }
+    it = cfg.find("WindowIcon");
+    if (it != cfg.end()) {
+        QString path = QString::fromUtf8(it->second.c_str());
+        if (QDir(path).isRelative()) {
+            path = QFileInfo(QDir(home), path).absoluteFilePath();
+        }
+        QApplication::setWindowIcon(QIcon(path));
+    }
+    it = cfg.find("ProgramLogo");
+    if (it != cfg.end()) {
+        QString path = QString::fromUtf8(it->second.c_str());
+        if (QDir(path).isRelative()) {
+            path = QFileInfo(QDir(home), path).absoluteFilePath();
+        }
+        QPixmap px(path);
+        if (!px.isNull()) {
+            auto logo = new QLabel();
+            logo->setPixmap(px.scaledToHeight(32));
+            mainWindow->statusBar()->addPermanentWidget(logo, 0);
+            logo->setFrameShape(QFrame::NoFrame);
+        }
+    }
+}
+
+void StartupPostProcess::setImportImageFormats()
+{
+    QList<QByteArray> supportedFormats = QImageReader::supportedImageFormats();
+    std::stringstream str;
+    str << "Image formats (";
+    for (const auto& ext : supportedFormats) {
+        str << "*." << ext.constData() << " *." << ext.toUpper().constData() << " ";
+    }
+    str << ")";
+
+    std::string filter = str.str();
+    App::GetApplication().addImportType(filter.c_str(), "FreeCADGui");
+}
+
+bool StartupPostProcess::hiddenMainWindow() const
+{
+    const std::map<std::string,std::string>& cfg = App::Application::Config();
+    bool hidden = false;
+    auto it = cfg.find("StartHidden");
+    if (it != cfg.end()) {
+        hidden = true;
+    }
+
+    return hidden;
+}
+
+void StartupPostProcess::showMainWindow()
+{
+    bool hidden = hiddenMainWindow();
+
+    // show splasher while initializing the GUI
+    if (!hidden && !loadFromPythonModule) {
+        mainWindow->startSplasher();
+    }
+
+    // running the GUI init script
+    try {
+        Base::Console().Log("Run Gui init script\n");
+        Application::runInitGuiScript();
+        setImportImageFormats();
+    }
+    catch (const Base::Exception& e) {
+        Base::Console().Error("Error in FreeCADGuiInit.py: %s\n", e.what());
+        mainWindow->stopSplasher();
+        throw;
+
+    }
+
+    // stop splash screen and set immediately the active window that may be of interest
+    // for scripts using Python binding for Qt
+    mainWindow->stopSplasher();
+    qtApp->setActiveWindow(mainWindow);
+}
+
+void StartupPostProcess::activateWorkbench()
+{
+    // Activate the correct workbench
+    std::string start = App::Application::Config()["StartWorkbench"];
+    Base::Console().Log("Init: Activating default workbench %s\n", start.c_str());
+    std::string autoload =
+        App::GetApplication()
+            .GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
+            ->GetASCII("AutoloadModule", start.c_str());
+    if ("$LastModule" == autoload) {
+        start = App::GetApplication()
+                    .GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
+                    ->GetASCII("LastModule", start.c_str());
+    }
+    else {
+        start = autoload;
+    }
+    // if the auto workbench is not visible then force to use the default workbech
+    // and replace the wrong entry in the parameters
+    QStringList wb = guiApp.workbenches();
+    if (!wb.contains(QString::fromLatin1(start.c_str()))) {
+        start = App::Application::Config()["StartWorkbench"];
+        if ("$LastModule" == autoload) {
+            App::GetApplication()
+                .GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
+                ->SetASCII("LastModule", start.c_str());
+        }
+        else {
+            App::GetApplication()
+                .GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
+                ->SetASCII("AutoloadModule", start.c_str());
+        }
+    }
+
+    // Call this before showing the main window because otherwise:
+    // 1. it shows a white window for a few seconds which doesn't look nice
+    // 2. the layout of the toolbars is completely broken
+    guiApp.activateWorkbench(start.c_str());
+
+    // show the main window
+    if (!hiddenMainWindow()) {
+        Base::Console().Log("Init: Showing main window\n");
+        mainWindow->loadWindowSettings();
+    }
+
+    //initialize spaceball.
+    if (auto fcApp = qobject_cast<GUIApplicationNativeEventAware*>(qtApp)) {
+        fcApp->initSpaceball(mainWindow);
+    }
+
+    setStyleSheet();
+
+    // Now run the background autoload, for workbenches that should be loaded at startup, but not
+    // displayed to the user immediately
+    autoloadModules(wb);
+
+    // Reactivate the startup workbench
+    guiApp.activateWorkbench(start.c_str());
+}
+
+void StartupPostProcess::setStyleSheet()
+{
+    ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath(
+        "User parameter:BaseApp/Preferences/MainWindow");
+    std::string style = hGrp->GetASCII("StyleSheet");
+    if (style.empty()) {
+        // check the branding settings
+        const auto& config = App::Application::Config();
+        auto it = config.find("StyleSheet");
+        if (it != config.end()) {
+            style = it->second;
+        }
+    }
+
+    guiApp.setStyleSheet(QLatin1String(style.c_str()), hGrp->GetBool("TiledBackground", false));
+}
+
+void StartupPostProcess::autoloadModules(const QStringList& wb)
+{
+    // Now run the background autoload, for workbenches that should be loaded at startup, but not
+    // displayed to the user immediately
+    std::string autoloadCSV =
+        App::GetApplication()
+            .GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
+            ->GetASCII("BackgroundAutoloadModules", "");
+
+    // Tokenize the comma-separated list and load the requested workbenches if they exist in this
+    // installation
+    std::stringstream stream(autoloadCSV);
+    std::string workbench;
+    while (std::getline(stream, workbench, ',')) {
+        if (wb.contains(QString::fromLatin1(workbench.c_str()))) {
+            guiApp.activateWorkbench(workbench.c_str());
+        }
+    }
+}