Subversion Repositories tpanel

/*

 * Copyright (C) 2020 to 2023 by Andreas Theofilu <andreas@theosys.at>

 *

 * 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, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 */

/** @file tqtmain.cpp

 * @brief Implements the surface of the application.

 *

 * This file implements the callback functions of the suface. While the most

 * classes are drawing the elements, the methods here take the ready elements

 * and display them. This file makes the surface completely independent of

 * the rest of the application which makes it easy to change the surface by

 * any other technology.

 */

#include <QApplication>

#include <QGuiApplication>

#include <QByteArray>

#include <QCommandLineParser>

#include <QCommandLineOption>

#include <QLabel>

#include <QtWidgets>

#include <QStackedWidget>

#include <QMouseEvent>

#include <QMoveEvent>

#include <QTouchEvent>

#include <QPalette>

#include <QPixmap>

#include <QFont>

#include <QFontDatabase>

#include <QtMultimediaWidgets/QVideoWidget>

#include <QtMultimedia/QMediaPlayer>

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

#   include <QtMultimedia/QMediaPlaylist>

#else

#   include <QAudioOutput>

#endif

#include <QListWidget>

#include <QLayout>

#include <QSizePolicy>

#include <QUrl>

#include <QThread>

#ifdef Q_OS_IOS

#include <QOrientationSensor>

#endif

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

#   include <QSound>

#if defined(Q_OS_IOS) || defined(Q_OS_ANDROID)

#   include <QtSensors/QOrientationSensor>

#   include <qpa/qplatformscreen.h>

#endif

#else

#   include <QPlainTextEdit>

#if defined(Q_OS_IOS) || defined(Q_OS_ANDROID)

#   include <QGeoPositionInfoSource>

#   include <QtSensors/QOrientationReading>

#endif

#endif

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) && defined(Q_OS_ANDROID)

#include <QtAndroidExtras/QAndroidJniObject>

#include <QtAndroidExtras/QtAndroid>

#endif

#include <functional>

#include <mutex>

#ifdef Q_OS_ANDROID

#include <android/log.h>

#endif

#include "tpagemanager.h"

#include "tqtmain.h"

#include "tconfig.h"

#if !defined(Q_OS_IOS) && !defined(Q_OS_ANDROID)

#include "tqtsettings.h"

#endif

#include "tqkeyboard.h"

#include "tqkeypad.h"

#include "tcolor.h"

#include "texcept.h"

#include "ttpinit.h"

#include "tqdownload.h"

#include "tqtphone.h"

#include "tqeditline.h"

#include "tqtwait.h"

#include "terror.h"

#include "tresources.h"

#include "tqscrollarea.h"

#include "tlock.h"

#ifdef Q_OS_IOS

#include "ios/QASettings.h"

#include "ios/tiosrotate.h"

#include "ios/tiosbattery.h"

#endif

#if __cplusplus < 201402L

#   error "This module requires at least C++14 standard!"

#else

#   if __cplusplus < 201703L

#       include <experimental/filesystem>

namespace fs = std::experimental::filesystem;

#       warning "Support for C++14 and experimental filesystem will be removed in a future version!"

#   else

#       include <filesystem>

#       ifdef __ANDROID__

namespace fs = std::__fs::filesystem;

#       else

namespace fs = std::filesystem;

#       endif

#   endif

#endif

/**

 * @def THREAD_WAIT

 * This defines a time in milliseconds. It is used in the callbacks for the

 * functions to draw the elements. Qt need a little time to do it's work.

 * Therefore we're waiting a little bit. Otherwise it may result in missing

 * elements or black areas on the screen.

 */

#define THREAD_WAIT     1

extern amx::TAmxNet *gAmxNet;                   //!< Pointer to the class running the thread which handles the communication with the controller.

extern bool _restart_;                          //!< If this is set to true then the whole program will start over.

extern TPageManager *gPageManager;              //!< The pointer to the global defined main class.

static bool isRunning = false;                  //!< TRUE = the pageManager was started.

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

static double gScale = 1.0;                     //!< Global variable holding the scale factor.

static int gFullWidth = 0;                      //!< Global variable holding the width of the AMX screen. This is used to calculate the scale factor for the settings dialog.

std::atomic<double> mScaleFactorW{1.0};

std::atomic<double> mScaleFactorH{1.0};

int gScreenWidth{0};

int gScreenHeight{0};

bool isPortrait{false};

#endif

using std::bind;

using std::map;

using std::pair;

using std::string;

using std::vector;

string _NO_OBJECT = "The global class TObject is not available!";

/**

 * @brief qtmain is used here as the entry point for the surface.

 *

 * The main entry function parses the command line parameters, if there were

 * any and sets the basic attributes. It creates the main window and starts the

 * application.

 *

 * @param argc      The number of command line arguments

 * @param argv      A pointer to a 2 dimensional array containing the command

 *                  line parameters.

 * @param pmanager  A pointer to the page manager class which is the main class

 *                  managing everything.

 *

 * @return If no errors occured it returns 0.

 */

int qtmain(int argc, char **argv, TPageManager *pmanager)

{

    DECL_TRACER("qtmain(int argc, char **argv, TPageManager *pmanager)");

    if (!pmanager)

    {

        MSG_ERROR("Fatal: No pointer to the page manager received!");

        return 1;

    }

    gPageManager = pmanager;

#ifdef __ANDROID__

    MSG_INFO("Android API version: " << __ANDROID_API__);

#if __ANDROID_API__ < 30

#warning "The Android API version is less than 30! Some functions may not work!"

#endif  // __ANDROID_API__

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

    QAndroidJniObject activity = QtAndroid::androidActivity();

    QAndroidJniObject::callStaticMethod<void>("org/qtproject/theosys/HideToolbar", "hide", "(Landroid/app/Activity;Z)V", activity.object(), true);

#else

    QJniObject activity = QNativeInterface::QAndroidApplication::context();

    QJniObject::callStaticMethod<void>("org/qtproject/theosys/HideToolbar", "hide", "(Landroid/app/Activity;Z)V", activity.object(), true);

#endif  // QT5_LINUX

#endif  // __ANDROID__

#if defined(Q_OS_ANDROID)

    QApplication::setAttribute(Qt::AA_ForceRasterWidgets);

//    QApplication::setAttribute(Qt::AA_Use96Dpi);

//    QApplication::setAttribute(Qt::AA_DontUseNativeDialogs);

#endif

    QApplication app(argc, argv);

    // Set the orientation

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    QScreen *screen = QGuiApplication::primaryScreen();

    if (!screen)

    {

        MSG_ERROR("Couldn't determine the primary screen!")

        return 1;

    }

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

    if (pmanager->getSettings()->isPortrait())  // portrait?

    {

        MSG_INFO("Orientation set to portrait mode.");

        screen->setOrientationUpdateMask(Qt::PortraitOrientation);

    }

    else

    {

        MSG_INFO("Orientation set to landscape mode.");

        screen->setOrientationUpdateMask(Qt::LandscapeOrientation);

    }

#endif  // QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

    double scale = 1.0;

    double setupScaleFactor = 1.0;

    // Calculate the scale factor

    if (TConfig::getScale())

    {

        // Because we've no window here we can not know on which screen, if

        // there are more than one, the application will start. Because on a

        // mobile mostly no external screen is connected, we take always the

        // resolution of the first (built in) screen.

        // TODO: Find a way to get the screen the application will start and

        // take this screen to calculate the scale factor.

        QRect screenGeometry = screen->availableGeometry();

        double width = 0.0;

        double height = 0.0;

        double sysWidth = 0.0;

        double sysHeight = 0.0;

        gScreenWidth = std::max(screenGeometry.width(), screenGeometry.height());

        gScreenHeight = std::min(screenGeometry.height(), screenGeometry.width());

        if (screenGeometry.width() > screenGeometry.height())

            isPortrait = false;

        else

            isPortrait = true;

        int minWidth = pmanager->getSettings()->getWidth();

        int minHeight = pmanager->getSettings()->getHeight();

        int minSysWidth = pmanager->getSystemSettings()->getWidth();

        int minSysHeight = pmanager->getSystemSettings()->getHeight();

        if (pmanager->getSettings()->isPortrait())  // portrait?

        {

            width = std::min(gScreenWidth, gScreenHeight);

            height = std::max(gScreenHeight, gScreenWidth);

        }

        else

        {

            width = std::max(gScreenWidth, gScreenHeight);

            height = std::min(gScreenHeight, gScreenWidth);

        }

        // The setup pages are always landscape

        sysWidth = std::max(gScreenWidth, gScreenHeight);

        sysHeight = std::min(gScreenHeight, gScreenWidth);

        if (!TConfig::getToolbarSuppress() && TConfig::getToolbarForce())

            minWidth += 48;

        MSG_INFO("Dimension of AMX screen:" << minWidth << " x " << minHeight);

        MSG_INFO("Screen size: " << width << " x " << height);

        // The scale factor is always calculated in difference to the prefered

        // size of the original AMX panel.

        mScaleFactorW = width / (double)minWidth;

        mScaleFactorH = height / (double)minHeight;

        double scaleFactorW = sysWidth / (double)minSysWidth;

        double scaleFactorH = sysHeight / (double)minSysHeight;

        scale = std::min(mScaleFactorW, mScaleFactorH);

        setupScaleFactor = std::min(scaleFactorW, scaleFactorH);

#ifdef __ANDROID__

        __android_log_print(ANDROID_LOG_DEBUG, "tpanel", "scale: %f (Screen: %1.0fx%1.0f, Page: %dx%d)", scale, width, height, minWidth, minHeight);

        __android_log_print(ANDROID_LOG_DEBUG, "tpanel", "setupScaleFactor: %f (Screen: %1.0fx%1.0f, Page: %dx%d)", setupScaleFactor, sysWidth, sysHeight, minSysWidth, minSysHeight);

#endif

        gScale = scale;     // The calculated scale factor

        gFullWidth = width;

        MSG_INFO("Calculated scale factor: " << scale);

        // This preprocessor variable allows the scaling to be done by the Skia

        // library, which is used to draw everything. In comparison to Qt this

        // library is a bit slower and sometimes does not honor the aspect ratio

        // correct. But in case there is another framework than Qt in use, this

        // could be necessary.

#ifdef _SCALE_SKIA_

        if (scale != 0.0)

        {

            pmanager->setScaleFactor(scale);

            MSG_INFO("Scale factor: " << scale);

        }

        if (scaleW != 0.0)

            pmanager->setScaleFactorWidth(scaleW);

        if (scaleH != 0.0)

            pmanager->setScaleFactorHeight(scaleH);

#endif  // _SCALE_SKIA_

    }

#endif  // defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

#if not defined(Q_OS_ANDROID) && not defined(Q_OS_IOS)

    double setupScaleFactor = 1.0;

    if (pmanager->getSettings() != pmanager->getSystemSettings())

    {

        double width = 0.0;

        double height = 0.0;

        int minWidth = pmanager->getSystemSettings()->getWidth();

        int minHeight = pmanager->getSystemSettings()->getHeight();

        if (!TConfig::getToolbarSuppress() && TConfig::getToolbarForce())

            minWidth += 48;

        width = std::max(pmanager->getSettings()->getWidth(), pmanager->getSettings()->getHeight());

        height = std::min(pmanager->getSettings()->getHeight(), pmanager->getSettings()->getWidth());

        MSG_INFO("Dimension of AMX screen:" << minWidth << " x " << minHeight);

        MSG_INFO("Screen size: " << width << " x " << height);

        // The scale factor is always calculated in difference to the prefered

        // size of the original AMX panel.

        double scaleFactorW = width / (double)minWidth;

        double scaleFactorH = height / (double)minHeight;

        setupScaleFactor = std::min(scaleFactorW, scaleFactorH);

        MSG_DEBUG("Scale factor for setup screen: " << setupScaleFactor);

    }

#endif

    // Initialize the application

    pmanager->setDPI(QGuiApplication::primaryScreen()->logicalDotsPerInch());

    QCoreApplication::setOrganizationName(TConfig::getProgName().c_str());

    QCoreApplication::setApplicationName("TPanel");

    QCoreApplication::setApplicationVersion(VERSION_STRING());

    QCommandLineParser parser;

    parser.setApplicationDescription(QCoreApplication::applicationName());

    parser.addHelpOption();

    parser.addVersionOption();

    parser.process(app);

    MainWindow mainWin;

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

#   ifndef _SCALE_SKIA_

    if (TConfig::getScale() && scale != 1.0)

        mainWin.setScaleFactor(scale);

#   endif   // _SCALE_SKIA_

#endif  // defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    mainWin.setConfigFile(TConfig::getConfigPath() + "/" + TConfig::getConfigFileName());

    QPalette palette(mainWin.palette());

    palette.setColor(QPalette::Window, Qt::black);  // Keep the background black. Helps to save battery on OLED displays.

    mainWin.setPalette(palette);

    mainWin.grabGesture(Qt::PinchGesture);

    mainWin.grabGesture(Qt::SwipeGesture);

    mainWin.setOrientation(Qt::PrimaryOrientation);

//#ifdef Q_OS_IOS

 //   mainWin.setWindowFlag(Qt::MaximizeUsingFullscreenGeometryHint, true);

//#endif

    if (setupScaleFactor != 1.0 && setupScaleFactor > 0.0)

        mainWin.setSetupScaleFactor(setupScaleFactor);

    mainWin.show();

    return app.exec();

}

/**

 * @brief MainWindow::MainWindow constructor

 *

 * This method is the constructor for this class. It registers the callback

 * functions to the class TPageManager and starts the main run loop.

 *

 * Qt is used only to manage widgets to handle pages and subpages. A page as

 * well as a subpage may contain a background graphic and some elements. The

 * elements could be buttons, bargraphs and other objects. The underlying layer

 * draw every element as a ready graphic image and call a callback function to

 * let Qt display the graphic.

 * If there are some animations on a subpage defined, this is also handled by

 * Qt. Especialy sliding and fading.

 */

MainWindow::MainWindow()

{

    DECL_TRACER("MainWindow::MainWindow()");

    TObject::setParent(this);

    if (!gPageManager)

    {

        EXCEPTFATALMSG("The class TPageManager was not initialized!");

    }

    mGestureFilter = new TQGestureFilter(this);

    connect(mGestureFilter, &TQGestureFilter::gestureEvent, this, &MainWindow::onGestureEvent);

    setAttribute(Qt::WA_AcceptTouchEvents, true);   // We accept touch events

    grabGesture(Qt::PinchGesture);                  // We use a pinch gesture to open the settings dialog

    grabGesture(Qt::SwipeGesture);                  // We support swiping also

#ifdef Q_OS_IOS                                     // Block autorotate on IOS

    initGeoLocation();

    mIosRotate = new TIOSRotate;

    mIosRotate->automaticRotation(false);           // FIXME: This doesn't work!

    if (!mSensor)

    {

        mSensor = new QOrientationSensor(this);

        if (mSensor)

        {

            connect(mSensor, &QSensor::currentOrientationChanged, this, &MainWindow::onCurrentOrientationChanged);

            mSensor->setAxesOrientationMode(QSensor::UserOrientation);

            mSensor->setUserOrientation(180);

            if (gPageManager && gPageManager->getSettings()->isPortrait())

                mSensor->setCurrentOrientation(Qt::PortraitOrientation);

            else

                mSensor->setCurrentOrientation(Qt::LandscapeOrientation);

        }

    }

#endif  // Q_OS_IOS

    // We create the central widget here to make sure the application

    // initializes correct. On mobiles the whole screen is used while on

    // desktops a window with the necessary size is created.

    QWidget *central = new QWidget;

    central->setObjectName("centralWidget");

    central->setBackgroundRole(QPalette::Window);

#if defined(Q_OS_IOS) || defined(Q_OS_ANDROID)

//    central->setAutoFillBackground(false);

    central->setFixedSize(gScreenWidth, gScreenHeight);

#endif  // defined(Q_OS_IOS) || defined(Q_OSANDROID)

    setCentralWidget(central);      // Here we set the central widget

    central->show();

    // This is a stacked widget used to hold all pages. With it we can also

    // simply manage the objects bound to a page.

    mCentralWidget = new QStackedWidget(central);

    mCentralWidget->setObjectName("stackedPageWidgets");

#if defined(Q_OS_IOS) || defined(Q_OS_ANDROID)

    MSG_DEBUG("Size will be set for " << (isPortrait ? "PORTRAIT" : "LANDSCAPE"));

    if (gPageManager && gPageManager->getSettings()->isLandscape())

    {

        if (!isPortrait)

            mCentralWidget->setFixedSize((mToolbar ? gScreenWidth - mToolbar->width() : gScreenWidth), gScreenHeight);

        else

            mCentralWidget->setFixedSize(gScreenWidth, gScreenHeight);

    }

    else

    {

        if (isPortrait)

            mCentralWidget->setFixedSize((mToolbar ? gScreenHeight - mToolbar->width() : gScreenHeight), gScreenWidth);

        else

            mCentralWidget->setFixedSize(gScreenHeight, gScreenWidth);

    }

#else

    QSize qs = menuBar()->sizeHint();

    QSize icSize =  iconSize();

    int lwidth = gPageManager->getSettings()->getWidth() + icSize.width() + 16;

    int lheight = gPageManager->getSettings()->getHeight() + qs.height();

    mCentralWidget->setFixedSize(gPageManager->getSettings()->getWidth(), gPageManager->getSettings()->getHeight());

#endif  // defined(Q_OS_IOS) || defined(Q_OS_ANDROID)

#if defined(Q_OS_IOS) || defined(Q_OS_ANDROID)

    if (gPageManager->getSettings()->isPortrait())  // portrait?

    {

        MSG_INFO("Orientation set to portrait mode.");

        _setOrientation(O_PORTRAIT);

        mOrientation = Qt::PortraitOrientation;

    }

    else

    {

        MSG_INFO("Orientation set to landscape mode.");

        _setOrientation(O_LANDSCAPE);

        mOrientation = Qt::LandscapeOrientation;

    }

#else

    QRect rectMain = geometry();

    rectMain.setWidth(lwidth);

    rectMain.setHeight(lheight);

    setGeometry(rectMain);

    MSG_DEBUG("Height of main window:  " << rectMain.height());

    MSG_DEBUG("Height of panel screen: " << lheight);

    // If our first top pixel is not 0, maybe because of a menu, window

    // decorations or a toolbar, we must add this extra height to the

    // positions of widgets and mouse presses.

    int avHeight = rectMain.height() - gPageManager->getSettings()->getHeight();

    MSG_DEBUG("Difference in height:   " << avHeight);

    gPageManager->setFirstTopPixel(avHeight);

#endif

    setWindowIcon(QIcon(":images/icon.png"));

    // First we register all our surface callbacks to the underlying work

    // layer. All the graphics are drawn by the Skia library. The layer below

    // call the following functions to let Qt display the graphics on the

    // screen let it manage the widgets containing the graphics.

    gPageManager->registerCallbackDB(bind(&MainWindow::_displayButton, this,

                                       std::placeholders::_1,

                                       std::placeholders::_2,

                                       std::placeholders::_3,

                                       std::placeholders::_4,

                                       std::placeholders::_5,

                                       std::placeholders::_6,

                                       std::placeholders::_7,

                                       std::placeholders::_8));

    gPageManager->regDisplayViewButton(bind(&MainWindow::_displayViewButton, this,

                                          std::placeholders::_1,

                                          std::placeholders::_2,

                                          std::placeholders::_3,

                                          std::placeholders::_4,

                                          std::placeholders::_5,

                                          std::placeholders::_6,

                                          std::placeholders::_7,

                                          std::placeholders::_8,

                                          std::placeholders::_9,

                                          std::placeholders::_10));

    gPageManager->regAddViewButtonItems(bind(&MainWindow::_addViewButtonItems, this,

                                             std::placeholders::_1,

                                             std::placeholders::_2));

    gPageManager->regUpdateViewButton(bind(&MainWindow::_updateViewButton, this,

                                           std::placeholders::_1,

                                           std::placeholders::_2,

                                           std::placeholders::_3,

                                           std::placeholders::_4));

    gPageManager->regUpdateViewButtonItem(bind(&MainWindow::_updateViewButtonItem, this,

                                               std::placeholders::_1,

                                               std::placeholders::_2));

    gPageManager->regShowSubViewItem(bind(&MainWindow::_showViewButtonItem, this,

                                          std::placeholders::_1,

                                          std::placeholders::_2,

                                          std::placeholders::_3,

                                          std::placeholders::_4));

    gPageManager->regHideAllSubViewItems(bind(&MainWindow::_hideAllViewItems, this, std::placeholders::_1));

    gPageManager->regHideSubViewItem(bind(&MainWindow::_hideViewItem, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->regSetSubViewPadding(bind(&MainWindow::_setSubViewPadding, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->registerCallbackSP(bind(&MainWindow::_setPage, this,

                                         std::placeholders::_1,

                                         std::placeholders::_2,

                                         std::placeholders::_3));

    gPageManager->registerCallbackSSP(bind(&MainWindow::_setSubPage, this,

                                          std::placeholders::_1,

                                          std::placeholders::_2,

                                          std::placeholders::_3,

                                          std::placeholders::_4,

                                          std::placeholders::_5,

                                          std::placeholders::_6,

                                          std::placeholders::_7));

    gPageManager->registerCallbackSB(bind(&MainWindow::_setBackground, this,

                                         std::placeholders::_1,

                                         std::placeholders::_2,

                                         std::placeholders::_3,

                                         std::placeholders::_4,

#ifdef _OPAQUE_SKIA_

                                         std::placeholders::_5));

#else

                                         std::placeholders::_5,

                                         std::placeholders::_6));

#endif

    gPageManager->regCallDropPage(bind(&MainWindow::_dropPage, this, std::placeholders::_1));

    gPageManager->regCallDropSubPage(bind(&MainWindow::_dropSubPage, this, std::placeholders::_1));

    gPageManager->regCallPlayVideo(bind(&MainWindow::_playVideo, this,

                                       std::placeholders::_1,

                                       std::placeholders::_2,

                                       std::placeholders::_3,

                                       std::placeholders::_4,

                                       std::placeholders::_5,

                                       std::placeholders::_6,

                                       std::placeholders::_7,

                                       std::placeholders::_8,

                                       std::placeholders::_9));

    gPageManager->regCallInputText(bind(&MainWindow::_inputText, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->regCallListBox(bind(&MainWindow::_listBox, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->registerDropButton(bind(&MainWindow::_dropButton, this, std::placeholders::_1));

    gPageManager->regCallbackKeyboard(bind(&MainWindow::_showKeyboard, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->regCallbackKeypad(bind(&MainWindow::_showKeypad, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));

    gPageManager->regCallResetKeyboard(bind(&MainWindow::_resetKeyboard, this));

    gPageManager->regCallShowSetup(bind(&MainWindow::_showSetup, this));

    gPageManager->regCallbackResetSurface(bind(&MainWindow::_resetSurface, this));

    gPageManager->regCallbackShutdown(bind(&MainWindow::_shutdown, this));

    gPageManager->regCallbackPlaySound(bind(&MainWindow::_playSound, this, std::placeholders::_1));

    gPageManager->regCallbackStopSound(bind(&MainWindow::_stopSound, this));

    gPageManager->regCallbackMuteSound(bind(&MainWindow::_muteSound, this, std::placeholders::_1));

    gPageManager->registerCBsetVisible(bind(&MainWindow::_setVisible, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->regSendVirtualKeys(bind(&MainWindow::_sendVirtualKeys, this, std::placeholders::_1));

    gPageManager->regShowPhoneDialog(bind(&MainWindow::_showPhoneDialog, this, std::placeholders::_1));

    gPageManager->regSetPhoneNumber(bind(&MainWindow::_setPhoneNumber, this, std::placeholders::_1));

    gPageManager->regSetPhoneStatus(bind(&MainWindow::_setPhoneStatus, this, std::placeholders::_1));

    gPageManager->regSetPhoneState(bind(&MainWindow::_setPhoneState, this, std::placeholders::_1, std::placeholders::_2));

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

    gPageManager->regOnOrientationChange(bind(&MainWindow::_orientationChanged, this, std::placeholders::_1));

    gPageManager->regOnSettingsChanged(bind(&MainWindow::_activateSettings, this, std::placeholders::_1,

                                            std::placeholders::_2,

                                            std::placeholders::_3,

                                            std::placeholders::_4,

                                            std::placeholders::_5,

                                            std::placeholders::_6));

#endif

    gPageManager->regRepaintWindows(bind(&MainWindow::_repaintWindows, this));

    gPageManager->regToFront(bind(&MainWindow::_toFront, this, std::placeholders::_1));

#if !defined (Q_OS_ANDROID) && !defined(Q_OS_IOS)

    gPageManager->regSetMainWindowSize(bind(&MainWindow::_setSizeMainWindow, this, std::placeholders::_1, std::placeholders::_2));

#endif

    gPageManager->regDownloadSurface(bind(&MainWindow::_downloadSurface, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->regDisplayMessage(bind(&MainWindow::_displayMessage, this, std::placeholders::_1, std::placeholders::_2));

    gPageManager->regFileDialogFunction(bind(&MainWindow::_fileDialog, this,

                                             std::placeholders::_1,

                                             std::placeholders::_2,

                                             std::placeholders::_3,

                                             std::placeholders::_4));

    gPageManager->regStartWait(bind(&MainWindow::_startWait, this, std::placeholders::_1));

    gPageManager->regStopWait(bind(&MainWindow::_stopWait, this));

    gPageManager->regPageFinished(bind(&MainWindow::_pageFinished, this, std::placeholders::_1));

    gPageManager->deployCallbacks();

    createActions();        // Create the toolbar, if enabled by settings.

#ifndef QT_NO_SESSIONMANAGER

#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

    QGuiApplication::setFallbackSessionManagementEnabled(false);

    connect(qApp, &QGuiApplication::commitDataRequest,

            this, &MainWindow::writeSettings);

#endif  // QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

#endif  // QT_NO_SESSIONMANAGER

    // Some types used to transport data from the layer below.

    qRegisterMetaType<size_t>("size_t");

    qRegisterMetaType<QByteArray>("QByteArray");

    qRegisterMetaType<ANIMATION_t>("ANIMATION_t");

    qRegisterMetaType<Button::TButton*>("Button::TButton*");

    qRegisterMetaType<std::string>("std::string");

    qRegisterMetaType<SUBVIEWLIST_T>("SUBVIEWLIST_T");

    qRegisterMetaType<PGSUBVIEWITEM_T>("PGSUBVIEWITEM_T");

    qRegisterMetaType<PGSUBVIEWITEM_T>("PGSUBVIEWITEM_T&");

    qRegisterMetaType<PGSUBVIEWATOM_T>("PGSUBVIEWATOM_T");

    qRegisterMetaType<TBitmap>("TBitmap");

    // All the callback functions doesn't act directly. Instead they emit an

    // event. Then Qt decides whether the real function is started directly and

    // immediately or if the call is queued and called later in a thread. To

    // handle this we're "connecting" the real functions to some signals.

    try

    {

        connect(this, &MainWindow::sigDisplayButton, this, &MainWindow::displayButton);

        connect(this, &MainWindow::sigDisplayViewButton, this, &MainWindow::displayViewButton);

        connect(this, &MainWindow::sigAddViewButtonItems, this, &MainWindow::addViewButtonItems);

        connect(this, &MainWindow::sigShowViewButtonItem, this, &MainWindow::showViewButtonItem);

        connect(this, &MainWindow::sigUpdateViewButton, this, &MainWindow::updateViewButton);

        connect(this, &MainWindow::sigUpdateViewButtonItem, this, &MainWindow::updateViewButtonItem);

        connect(this, &MainWindow::sigSetPage, this, &MainWindow::setPage);

        connect(this, &MainWindow::sigSetSubPage, this, &MainWindow::setSubPage);

        connect(this, &MainWindow::sigSetBackground, this, &MainWindow::setBackground);

        connect(this, &MainWindow::sigDropPage, this, &MainWindow::dropPage);

        connect(this, &MainWindow::sigDropSubPage, this, &MainWindow::dropSubPage);

        connect(this, &MainWindow::sigPlayVideo, this, &MainWindow::playVideo);

        connect(this, &MainWindow::sigInputText, this, &MainWindow::inputText);

        connect(this, &MainWindow::sigListBox, this, &MainWindow::listBox);

        connect(this, &MainWindow::sigKeyboard, this, &MainWindow::showKeyboard);

        connect(this, &MainWindow::sigKeypad, this, &MainWindow::showKeypad);

        connect(this, &MainWindow::sigShowSetup, this, &MainWindow::showSetup);

        connect(this, &MainWindow::sigPlaySound, this, &MainWindow::playSound);

        connect(this, &MainWindow::sigDropButton, this, &MainWindow::dropButton);

        connect(this, &MainWindow::sigSetVisible, this, &MainWindow::SetVisible);

        connect(this, &MainWindow::sigSendVirtualKeys, this, &MainWindow::sendVirtualKeys);

        connect(this, &MainWindow::sigShowPhoneDialog, this, &MainWindow::showPhoneDialog);

        connect(this, &MainWindow::sigSetPhoneNumber, this, &MainWindow::setPhoneNumber);

        connect(this, &MainWindow::sigSetPhoneStatus, this, &MainWindow::setPhoneStatus);

        connect(this, &MainWindow::sigSetPhoneState, this, &MainWindow::setPhoneState);

        connect(this, &MainWindow::sigRepaintWindows, this, &MainWindow::repaintWindows);

        connect(this, &MainWindow::sigToFront, this, &MainWindow::toFront);

        connect(this, &MainWindow::sigOnProgressChanged, this, &MainWindow::onProgressChanged);

#if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)

        connect(this, &MainWindow::sigSetSizeMainWindow, this, &MainWindow::setSizeMainWindow);

#endif

        connect(this, &MainWindow::sigDownloadSurface, this, &MainWindow::downloadSurface);

        connect(this, &MainWindow::sigDisplayMessage, this, &MainWindow::displayMessage);

        connect(this, &MainWindow::sigFileDialog, this, &MainWindow::fileDialog);

        connect(this, &MainWindow::sigStartWait, this, &MainWindow::startWait);

        connect(this, &MainWindow::sigStopWait, this, &MainWindow::stopWait);

        connect(this, &MainWindow::sigPageFinished, this, &MainWindow::pageFinished);

        connect(qApp, &QGuiApplication::applicationStateChanged, this, &MainWindow::onAppStateChanged);

#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)

        QScreen *screen = QGuiApplication::primaryScreen();

        connect(screen, &QScreen::orientationChanged, this, &MainWindow::onScreenOrientationChanged);

        connect(this, &MainWindow::sigActivateSettings, this, &MainWindow::activateSettings);

#endif

    }

    catch (std::exception& e)

    {

        MSG_ERROR("Connection error: " << e.what());

    }

    catch(...)

    {

        MSG_ERROR("Unexpected exception occured [MainWindow::MainWindow()]");

    }

    setUnifiedTitleAndToolBarOnMac(true);

#ifdef Q_OS_ANDROID

    // At least initialize the phone call listener

    if (gPageManager)

        gPageManager->initPhoneState();

    /*

     * In case this class was created not the first time, we initiate a small

     * thread to send the signal ApplicationActive to initiate the communication

     * with the controller again. This also starts the page manager thread

     * (TPageManager), which handles all elements of the surface.

     */

    if (_restart_ && gPageManager)

    {

        try

        {

            std::thread mThread = std::thread([=] { this->_signalState(Qt::ApplicationActive); });

            mThread.detach();   // We detach immediately to leave this method.

        }

        catch (std::exception& e)

        {

            MSG_ERROR("Error starting the thread to reinvoke communication!");

        }

        catch(...)

        {

            MSG_ERROR("Unexpected exception occured [MainWindow::MainWindow()]");

        }

    }

#endif

#ifdef Q_OS_IOS

    // To get the battery level periodicaly we setup a timer.

    if (!mIosBattery)

        mIosBattery = new TIOSBattery;

    mIosBattery->update();

    int left = mIosBattery->getBatteryLeft();

    int state = mIosBattery->getBatteryState();

    // At this point no buttons are registered and therefore the battery

    // state will not be visible. To have the state at the moment a button

    // is registered, we tell the page manager to store the values.