Subversion Repositories tpanel

/*

 * Copyright (C) 2020 to 2022 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 <QMouseEvent>

#include <QMoveEvent>

#include <QTouchEvent>

#include <QPalette>

#include <QPixmap>

#include <QFont>

#include <QFontDatabase>

#include <QtMultimediaWidgets/QVideoWidget>

#include <QtMultimedia/QMediaPlayer>

#include <QtMultimedia/QMediaPlaylist>

#include <QLayout>

#include <QSizePolicy>

#include <QUrl>

#include <QThread>

#include <QSound>

#ifdef __ANDROID__

#include <QAndroidJniObject>

#endif

#include <functional>

#include <mutex>

#ifdef __ANDROID__

#include <android/log.h>

#endif

#include "tpagemanager.h"

#include "tqtmain.h"

#include "tconfig.h"

#include "tqtsettings.h"

#include "tqkeyboard.h"

#include "tqkeypad.h"

#include "tcolor.h"

#include "texcept.h"

/**

 * @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.

std::mutex draw_mutex;                          //!< We're using threads and need to block execution sometimes

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

TObject *gObject = nullptr;                     //!< Internal used pointer to a TObject class. (Necessary because of threads!)

#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.

#endif

using std::bind;

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;

    }

    if (!gPageManager || gPageManager != pmanager)

        gPageManager = pmanager;

#ifdef __ANDROID__

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

#   if __ANDROID_API__ < 29

#       warn "The Android API version is less than 29! Some functions may not work!"

#   endif

#endif

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

    QApplication::setAttribute(Qt::AA_ForceRasterWidgets);

#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 (pmanager->getSettings()->getRotate() == 1)  // portrait?

    {

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

        screen->setOrientationUpdateMask(Qt::PortraitOrientation);

    }

    else

    {

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

        screen->setOrientationUpdateMask(Qt::LandscapeOrientation);

    }

    double scale = 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.

        QList<QScreen *> screens = QGuiApplication::screens();

        QRect screenGeometry = screens.at(0)->availableGeometry();

        double width = 0.0;

        double height = 0.0;

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

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

        if (pmanager->getSettings()->getRotate() == 1)  // portrait?

        {

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

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

        }

        else

        {

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

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

        }

        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 scaleW = width / minWidth;

        double scaleH = height / minHeight;

        scale = std::min(scaleW, scaleH);

        gScale = scale;     // The calculated scale factor

        gFullWidth = width;

        // 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)

    // Initialize the application

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

    QCoreApplication::setApplicationName("AMX panel simulator");

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

    mainWin.setStyleSheet("QMainWindow {background: 'black';}");    // Keep the background black. Helps to save battery on OLED displays.

    mainWin.grabGesture(Qt::PinchGesture);

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

    gObject = new TObject;

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

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

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

    if (gPageManager && gPageManager->getSettings()->getRotate() == 1)  // portrait?

    {

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

        _setOrientation(O_PORTRAIT);

    }

    else

    {

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

        _setOrientation(O_LANDSCAPE);

    }

#else

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

#endif

    if (!gPageManager)

    {

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

    }

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

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

                                         std::placeholders::_1,

                                         std::placeholders::_2,

                                         std::placeholders::_3,

                                         std::placeholders::_4,

                                         std::placeholders::_5,

                                         std::placeholders::_6,

                                         std::placeholders::_7));

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

    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->registerCBsetVisible(bind(&MainWindow::_setVisible, this, std::placeholders::_1, std::placeholders::_2));

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

    gPageManager->deployCallbacks();

    createActions();

#ifndef QT_NO_SESSIONMANAGER

    QGuiApplication::setFallbackSessionManagementEnabled(false);

    connect(qApp, &QGuiApplication::commitDataRequest,

            this, &MainWindow::writeSettings);

#endif

    // 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 *>("TButton");

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

    // 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::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::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(qApp, &QGuiApplication::applicationStateChanged, this, &MainWindow::appStateChanged);

    }

    catch (std::exception& e)

    {

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

    }

    catch(...)

    {

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

    }

    setUnifiedTitleAndToolBarOnMac(true);

#ifdef __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

    _restart_ = false;

}

MainWindow::~MainWindow()

{

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

    killed = true;

    prg_stopped = true;

    if (gAmxNet && !gAmxNet->isStopped())

        gAmxNet->stop();

    if (mToolbar)

    {

        removeToolBar(mToolbar);

        mToolbar = nullptr;

    }

    if (gObject)

    {

        delete gObject;

        gObject = nullptr;

    }

    isRunning = false;

}

#ifdef __ANDROID__

/**

 * @brief Small thread to invoke the initialization on an Android device.

 *

 * On Android devices the signal ApplicationActive is not send if the class

 * \p MainWindow is destroyed and recreated. Therefore we need this little

 * helper to send the signal when the class is initialized.

 *

 * @param state     This defines the signal to send.

 */

void MainWindow::_signalState(Qt::ApplicationState state)

{

    DECL_TRACER("MainWindow::_signalState(Qt::ApplicationState state)");

    std::this_thread::sleep_for(std::chrono::seconds(1));   // Wait a second

    appStateChanged(state);

}

#endif

/**

 * @brief MainWindow::closeEvent called when the application receives an exit event.

 *

 * If the user clicks on the exit icon or on the menu point _Exit_ this method

 * is called. It makes sure everything is written to the configuration file

 * and accepts the evernt.

 *

 * @param event The exit event

 */

void MainWindow::closeEvent(QCloseEvent *event)

{

    DECL_TRACER("MainWindow::closeEvent(QCloseEvent *event)");

#ifdef __ANDROID__

    __android_log_print(ANDROID_LOG_DEBUG,"tpanel","Close event; settingsChanged=%s", (settingsChanged ? "true":"false"));

#endif

    if (settingsChanged)

    {

        writeSettings();

        event->accept();

    }

    else

    {

        prg_stopped = true;

        killed = true;

        MSG_INFO("Program will stop!");

#ifdef __ANDROID__

        if (gPageManager)

            gPageManager->stopNetworkState();

#endif

        event->accept();

    }

}

/**

 * @brief MainWindow::eventFilter filters the QEvent::MouseMove event

 * Beside the filtering of the MouseEvent, it waits for a gesture and

 * call the method gestureEvent() which handles the gesture and opens the

 * setting dialog.

 * @param obj   The object where the event occured.

 * @param event The event.

 * @return `true` when the event should be ignored.

 */

bool MainWindow::eventFilter(QObject *obj, QEvent *event)

{

    if (event->type() == QEvent::MouseMove)

        return true;    // Filter event out, i.e. stop it being handled further.

    if (event->type() == QEvent::Gesture)

        return gestureEvent(static_cast<QGestureEvent*>(event));

    return QMainWindow::eventFilter(obj, event);

}

/**

 * @brief MainWindow::event Looks for a gesture

 * @param event The event occured

 * @return TRUE if event was accepted

 */

bool MainWindow::event(QEvent* event)

{

    if (event->type() == QEvent::Gesture)

        return gestureEvent(static_cast<QGestureEvent*>(event));

    return QWidget::event(event);

}

/**

 * @brief MainWindow::gestureEvent handles a pinch event

 * If a pinch event occured where the scale factor increased, the settings

 * dialog is called. This exists for devices, where the left toolbox is not

 * visible.

 * @param event The guesture occured

 * @return TRUE

 */

bool MainWindow::gestureEvent(QGestureEvent* event)

{

    DECL_TRACER("MainWindow::gestureEvent(QGestureEvent* event)");

    if (QGesture *pinch = event->gesture(Qt::PinchGesture))

    {

        string gs;

        QPinchGesture *pg = static_cast<QPinchGesture *>(pinch);

        switch(pg->state())

        {

            case Qt::NoGesture:         gs.assign("no gesture"); break;

            case Qt::GestureStarted:    gs.assign("gesture started"); break;

            case Qt::GestureUpdated:    gs.assign("gesture updated"); break;

            case Qt::GestureFinished:   gs.assign("gesture finished"); break;

            case Qt::GestureCanceled:   gs.assign("gesture canceled"); break;

        }

        MSG_DEBUG("PinchGesture state " << gs << " detected");

        if (pg->state() == Qt::GestureFinished)

        {

            MSG_DEBUG("total scale: " << pg->totalScaleFactor() << ", scale: " << pg->scaleFactor() << ", last scale: " << pg->lastScaleFactor());

            if (pg->totalScaleFactor() > pg->scaleFactor())

                settings();

        }

    }

    return false;

}

/**

 * @brief MainWindow::createActions creates the toolbar on the right side.

 */

void MainWindow::createActions()

{

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

    // Add a mToolbar (on the right side)

    mToolbar = new QToolBar(this);

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

    mToolbar->setAllowedAreas(Qt::RightToolBarArea);

    mToolbar->setFloatable(false);

    mToolbar->setMovable(false);

    if (TConfig::getScale() && gPageManager && gScale != 1.0)

    {

        int width = (int)((double)gPageManager->getSettings()->getWith() * gScale);

        int tbWidth = (int)(48.0 * gScale);

        int icWidth = (int)(40.0 * gScale);

        if ((gFullWidth - width) < tbWidth)

        {

            delete mToolbar;

            mToolbar = nullptr;

            return;

        }

        QSize iSize(icWidth, icWidth);

        mToolbar->setIconSize(iSize);

    }

#else

    mToolbar->setFloatable(true);

    mToolbar->setMovable(true);

    mToolbar->setAllowedAreas(Qt::RightToolBarArea | Qt::BottomToolBarArea);

#endif

    QAction *arrowUpAct = new QAction(QIcon(":/images/arrow_up.png"), tr("Up"), this);

    connect(arrowUpAct, &QAction::triggered, this, &MainWindow::arrowUp);

    mToolbar->addAction(arrowUpAct);

    QAction *arrowLeftAct = new QAction(QIcon(":/images/arrow_left.png"), tr("Left"), this);

    connect(arrowLeftAct, &QAction::triggered, this, &MainWindow::arrowLeft);

    mToolbar->addAction(arrowLeftAct);

    QAction *arrowRightAct = new QAction(QIcon(":/images/arrow_right.png"), tr("Right"), this);

    connect(arrowRightAct, &QAction::triggered, this, &MainWindow::arrowRight);

    mToolbar->addAction(arrowRightAct);

    QAction *arrowDownAct = new QAction(QIcon(":/images/arrow_down.png"), tr("Down"), this);

    connect(arrowDownAct, &QAction::triggered, this, &MainWindow::arrowDown);

    mToolbar->addAction(arrowDownAct);

    QAction *selectOkAct = new QAction(QIcon(":/images/ok.png"), tr("Ok"), this);

    connect(selectOkAct, &QAction::triggered, this, &MainWindow::selectOk);

    mToolbar->addAction(selectOkAct);

    mToolbar->addSeparator();

    QToolButton *btVolUp = new QToolButton(this);

    btVolUp->setIcon(QIcon(":/images/vol_up.png"));

    connect(btVolUp, &QToolButton::pressed, this, &MainWindow::volumeUpPressed);

    connect(btVolUp, &QToolButton::released, this, &MainWindow::volumeUpReleased);

    mToolbar->addWidget(btVolUp);

    QToolButton *btVolDown = new QToolButton(this);

    btVolDown->setIcon(QIcon(":/images/vol_down.png"));

    connect(btVolDown, &QToolButton::pressed, this, &MainWindow::volumeDownPressed);

    connect(btVolDown, &QToolButton::released, this, &MainWindow::volumeDownReleased);

    mToolbar->addWidget(btVolDown);

/*

    QAction *volMute = new QAction(QIcon(":/images/vol_mute.png"), tr("X"), this);

    connect(volMute, &QAction::triggered, this, &MainWindow::volumeMute);

    mToolbar->addAction(volMute);

*/

    mToolbar->addSeparator();

    const QIcon settingsIcon = QIcon::fromTheme("settings-configure", QIcon(":/images/settings.png"));

    QAction *settingsAct = new QAction(settingsIcon, tr("&Settings..."), this);

    settingsAct->setStatusTip(tr("Change the settings"));

    connect(settingsAct, &QAction::triggered, this, &MainWindow::settings);

    mToolbar->addAction(settingsAct);

    const QIcon aboutIcon = QIcon::fromTheme("help-about", QIcon(":/images/info.png"));

    QAction *aboutAct = new QAction(aboutIcon, tr("&About..."), this);

    aboutAct->setShortcuts(QKeySequence::Open);

    aboutAct->setStatusTip(tr("About this program"));

    connect(aboutAct, &QAction::triggered, this, &MainWindow::about);

    mToolbar->addAction(aboutAct);

    const QIcon exitIcon = QIcon::fromTheme("application-exit", QIcon(":/images/off.png"));

    QAction *exitAct = mToolbar->addAction(exitIcon, tr("E&xit"), this, &QWidget::close);

    exitAct->setShortcuts(QKeySequence::Quit);

    exitAct->setStatusTip(tr("Exit the application"));

    addToolBar(Qt::RightToolBarArea, mToolbar);

}

/**

 * @brief MainWindow::mousePressEvent catches the event Qt::LeftButton.

 *

 * If the user presses the left mouse button somewhere in the main window, this

 * method is triggered. It retrieves the position of the mouse pointer and

 * sends it to the page manager TPageManager.

 *

 * @param event The event

 */

void MainWindow::mousePressEvent(QMouseEvent* event)

{

    DECL_TRACER("MainWindow::mousePressEvent(QMouseEvent* event)");

    if(event->button() == Qt::LeftButton)

    {

        int x = event->x();

        int y = event->y();

        mLastPressX = x;

        mLastPressY = y;

        if (isScaled())

        {

            x = (int)((double)x / mScaleFactor);

            y = (int)((double)y / mScaleFactor);

        }

        gPageManager->mouseEvent(x, y, true);

    }

    else if (event->button() == Qt::MiddleButton)

        settings();

}

/**

 * @brief MainWindow::mouseReleaseEvent catches the event Qt::LeftButton.

 *

 * If the user releases the left mouse button somewhere in the main window, this

 * method is triggered. It retrieves the position of the mouse pointer and

 * sends it to the page manager TPageManager.

 *

 * @param event The event

 */

void MainWindow::mouseReleaseEvent(QMouseEvent* event)

{

    DECL_TRACER("MainWindow::mouseReleaseEvent(QMouseEvent* event)");

    if(event->button() == Qt::LeftButton)

    {

        int x = ((mLastPressX >= 0) ? mLastPressX : event->x());

        int y = ((mLastPressY >= 0) ? mLastPressY : event->y());

        mLastPressX = mLastPressY = -1;

        if (isScaled())

        {

            x = (int)((double)x / mScaleFactor);

            y = (int)((double)y / mScaleFactor);

        }

        gPageManager->mouseEvent(x, y, false);

    }

}

/**

 * @brief MainWindow::settings initiates the configuration dialog.

 */

void MainWindow::settings()

{

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

    // Save some old values to decide whether to start over or not.

    string oldHost = TConfig::getController();

    int oldPort = TConfig::getPort();

    int oldChannelID = TConfig::getChannel();

    // Initialize and open the settings dialog.

    TQtSettings *dlg_settings = new TQtSettings(this);

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

    // On mobile devices we set the scale factor always because otherwise the

    // dialog will be unusable.

    dlg_settings->setScaleFactor(gScale);

    dlg_settings->doResize();

#endif

    int ret = dlg_settings->exec();

    if (ret && dlg_settings->hasChanged())

    {

        writeSettings();

        if (TConfig::getController() != oldHost ||

            TConfig::getChannel() != oldChannelID ||

            TConfig::getPort() != oldPort)

        {

            // Start over by exiting this class

            MSG_INFO("Program will start over!");

            _restart_ = true;

            prg_stopped = true;

            killed = true;

            if (gAmxNet)

                gAmxNet->stop();

            close();

        }

    }

    else if (!ret && dlg_settings->hasChanged())

    {

        TConfig cf(TConfig::getConfigPath() + "/" + TConfig::getConfigFileName());

    }

    delete dlg_settings;

}

/**

 * @brief MainWindow::writeSettings Writes the settings into the configuration file.

 */