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>

#include <QtSensors/QOrientationSensor>

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

#include "ttpinit.h"

#include "tqtbusy.h"

#include "tqtphone.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();

    QOrientationReading::Orientation ori = QOrientationReading::Undefined;

    Qt::ScreenOrientations mask = Qt::PrimaryOrientation;

    QOrientationSensor qOri;

    QOrientationReading *pORead = qOri.reading();

    if (pORead)

    {

        ori = pORead->orientation();

        switch(ori)

        {

            case QOrientationReading::LeftUp:   mask = Qt::InvertedLandscapeOrientation; break;

            case QOrientationReading::RightUp:  mask = Qt::LandscapeOrientation; break;

            case QOrientationReading::TopDown:  mask = Qt::InvertedPortraitOrientation; break;

            default:

                mask = Qt::PortraitOrientation;

        }

        MSG_PROTOCOL("Detected orientation: " << mask);

    }

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

        if (mask == Qt::InvertedPortraitOrientation)

            screen->setOrientationUpdateMask(Qt::InvertedPortraitOrientation);

        else

            screen->setOrientationUpdateMask(Qt::PortraitOrientation);

    }

    else

    {

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

        if (mask == Qt::InvertedLandscapeOrientation)

            screen->setOrientationUpdateMask(Qt::InvertedLandscapeOrientation);

        else

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

        }

        if (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.

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

#endif

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

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

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

        QScreen *screen = QGuiApplication::primaryScreen();

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

#endif

    }

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

        delete mMediaPlayer;

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

}

void MainWindow::_orientationChanged(int orientation)

{

    DECL_TRACER("MainWindow::_orientationChanged(int orientation)");

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

    {

        if (orientation == O_REVERSE_PORTRAIT && mOrientation != Qt::InvertedPortraitOrientation)

            _setOrientation((J_ORIENTATION)orientation);

        else if (orientation == O_PORTRAIT && mOrientation != Qt::PortraitOrientation)

            _setOrientation((J_ORIENTATION)orientation);

    }

    else

    {

        if (orientation == O_REVERSE_LANDSCAPE && mOrientation != Qt::InvertedLandscapeOrientation)

            _setOrientation((J_ORIENTATION)orientation);

        else if (orientation == O_LANDSCAPE && mOrientation != Qt::LandscapeOrientation)

            _setOrientation((J_ORIENTATION)orientation);

    }

}

#endif

void MainWindow::_repaintWindows()

{

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

    emit repaintWindows();

}

/**

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

    else if (event->type() == QEvent::OrientationChange)

    {

        MSG_TRACE("The orientation has changed!");

    }

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

    else if (event->type() == QEvent::OrientationChange)

    {

        MSG_TRACE("The orientation has changed!");

    }

    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 FALSE

 */

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::onScreenOrientationChanged sets invers or normal orientation.

 * This method sets according to the actual set orientation the invers

 * orientations or switches back to normal orientation.

 * For example: When the orientation is set to portrait and the device is turned

 * to top down, then the orientation is set to invers portrait.

 * @param ori   The detected orientation

 */

void MainWindow::onScreenOrientationChanged(Qt::ScreenOrientation ori)

{

    DECL_TRACER("MainWindow::onScreenOrientationChanged(int ori)");

    MSG_PROTOCOL("Orientation changed to " << ori);

    if (mOrientation == Qt::PrimaryOrientation || mOrientation == ori)

        return;

    if ((mOrientation == Qt::LandscapeOrientation || mOrientation == Qt::InvertedLandscapeOrientation) &&

            (ori == Qt::PortraitOrientation || ori == Qt::InvertedPortraitOrientation))

        return;

    if ((mOrientation == Qt::PortraitOrientation || mOrientation == Qt::InvertedPortraitOrientation) &&

            (ori == Qt::LandscapeOrientation || ori == Qt::InvertedLandscapeOrientation))

        return;

    J_ORIENTATION jori = O_UNDEFINED;

    switch(mOrientation)

    {

        case Qt::LandscapeOrientation:          jori = O_LANDSCAPE; break;

        case Qt::InvertedLandscapeOrientation:  jori = O_REVERSE_LANDSCAPE; break;

        case Qt::PortraitOrientation:           jori = O_PORTRAIT; break;

        case Qt::InvertedPortraitOrientation:   jori = O_REVERSE_PORTRAIT; break;

        default:

            return;

    }

    _setOrientation(jori);

}

/**

 * @brief Displays or hides a phone dialog window.

 * This method creates and displays a phone dialog window containing everything

 * a simple phone needs. Depending on the parameter \p state the dialog is

 * created or an exeisting dialog is closed.

 * @param state     If TRUE the dialog is created or if it is not visible

 * brought to front and is made visible.

 * If this is FALSE an existing dialog window is destroid and disappears. If

 * the window didn't exist nothing happens.

 */

void MainWindow::showPhoneDialog(bool state)

{

    DECL_TRACER("MainWindow::showPhoneDialog(bool state)");

    if (mPhoneDialog)

    {

        if (!state)

        {

            mPhoneDialog->close();

            delete mPhoneDialog;

            mPhoneDialog = nullptr;

            return;

        }

        if (!mPhoneDialog->isVisible())

            mPhoneDialog->setVisible(true);

        return;

    }

    if (!state)

        return;

    mPhoneDialog = new TQtPhone(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.

    mPhoneDialog->setScaleFactor(gScale);

    mPhoneDialog->doResize();

#endif

    mPhoneDialog->open();

}

/**

 * Displays a phone number (can also be an URL) on a label in the phone dialog

 * window.

 * @param number    The string contains the phone number to display.

 */

void MainWindow::setPhoneNumber(const std::string& number)

{

    DECL_TRACER("MainWindow::setPhoneNumber(const std::string& number)");

    if (!mPhoneDialog)

        return;

    mPhoneDialog->setPhoneNumber(number);

}

/**

 * Displays a message in the status line on the bottom of the phone dialog

 * window.

 * @param msg   The string conaining a message.

 */

void MainWindow::setPhoneStatus(const std::string& msg)

{

    DECL_TRACER("MainWindow::setPhoneStatus(const std::string& msg)");

    if (!mPhoneDialog)

        return;

    mPhoneDialog->setPhoneStatus(msg);

}

void MainWindow::setPhoneState(int state, int id)

{

    DECL_TRACER("MainWindow::setPhoneState(int state)");

    if (mPhoneDialog)

        mPhoneDialog->setPhoneState(state, id);

}

/**

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

 */