qmlexecutorguiimpl.h

Go to the documentation of this file.

#ifndef QMLEXECUTORGUIIMPL_H
#define QMLEXECUTORGUIIMPL_H
 
#include <chrono>
#include <cassert>
 
#include <QList>
#include <QWidget>
#include <QDesktopServices>
#include <QPushButton>
#include <QUrl>
#include <QFileDialog>
#include <QDesktopServices>
#include <QMessageBox>
#include <QDateTime>
#include <QTimer>
#include <QtQml/QQmlError>
#include <QtQml/QQmlEngine>
#include <QtQml/QQmlContext>
 
#include "ui_qmlexecutor.h"
#include "qmlexecutorguiint.h"
#include "canbusmodel.hpp"
 
class QMLExecutorGuiImpl : public QMLExecutorGuiInt
{
    Q_OBJECT
 
public:
    explicit QMLExecutorGuiImpl(QObject* parent)
        : QMLExecutorGuiInt(parent)
        , _ui(new Ui::QMLExecutorPrivate)
        , _widget(new QWidget)
        , _qmlUpdateCheckTimer(this)
        , _CANBusModel(nullptr)
    {
        _ui->setupUi(_widget);
        _ui->logWindow->setVisible(false);
 
        _ui->splitter->setCollapsible(1, true);
 
        constexpr int size = 1234;
        _ui->splitter->setSizes(QList<int>({size,size}));
 
        _ui->fileName->setReadOnly(true);
 
        QObject::connect(_ui->editQMLButton, SIGNAL(clicked()), this, SLOT(editQML()));
        QObject::connect(_ui->loadQMLButton, SIGNAL(clicked()), this, SLOT(browseAndOpenQML()));
        QObject::connect(&_qmlUpdateCheckTimer, SIGNAL(timeout()), this, SLOT(checkQMLModification()));
        QObject::connect(_ui->pbDockUndock, &QPushButton::clicked, this, &QMLExecutorGuiImpl::dockUndock);
        QObject::connect(_ui->showLog, &QPushButton::clicked, [this] {
                    _ui->logWindow->setVisible(!_ui->logWindow->isVisible());
                });
        QObject::connect(_ui->pbClean, &QPushButton::clicked, [this] {
                    _ui->logWindow->clear();
                });
    }
 
    virtual QWidget* mainWidget() override
    {
        // Using this in constructor is too early (no CSS colors set yet)
        // Background color of QQuickWidget cannot be set via CSS
        updateUIColor();
 
        return _widget;
    }
 
    void updateUIColor() override
    {
        auto color = _widget->palette().color(_widget->backgroundRole());
        _ui->quickWidget->setClearColor(color);
    }
 
public slots:
    void browseAndOpenQML()
    {
         QUrl url = QFileDialog::getOpenFileUrl(mainWidget(), "Open QML");
 
         if(!url.isEmpty() && url.isValid())
         {
             loadQML(url);
         }
    }
 
    virtual void loadQML(const QUrl& url) override
    {
        if(url.isValid() && !url.isEmpty())
        {
            // The easiest way to reload QML seems to be creating new QQuickWidget
            auto splitter = static_cast<QSplitter*>(_ui->quickWidget->parentWidget());
            auto splitState = splitter->saveState();
 
            delete _ui->quickWidget;
            _ui->quickWidget = new QQuickWidget();
            updateUIColor();
            splitter->insertWidget(0, _ui->quickWidget);
            splitter->restoreState(splitState);
 
            QObject::connect(_ui->quickWidget, &QQuickWidget::statusChanged, this, &QMLExecutorGuiImpl::handleStatusChange);
 
            _qmlUrl = url;
 
            log("Loading qml file: " + url.toLocalFile());
 
            assert(_CANBusModel != nullptr);
            
            _ui->quickWidget->rootContext()->setContextProperty("CANBusModel", _CANBusModel);
            _ui->quickWidget->rootContext()->setContextProperty("LogWindow", _ui->logWindow);
 
            _ui->quickWidget->setSource(url);
 
            _ui->fileName->setText(url.toLocalFile());
 
            emit QMLLoaded(_qmlUrl);
 
            startQMLFileModificationChecks();
 
            _ui->editQMLButton->setEnabled(true);
        }
 
    }
 
    virtual void setModel(CANBusModel* model) override
    {
        _CANBusModel = model;
    }
 
    void startQMLFileModificationChecks()
    {
        _qmlLoadTime = QDateTime::currentDateTime();
        _qmlUpdateCheckTimer.start(std::chrono::milliseconds(1000).count());
    }
 
    void stopFileModificationChecks()
    {
        _qmlUpdateCheckTimer.stop();
    }
 
    void checkQMLModification()
    {
        QDateTime modifycationTime = QFileInfo(_qmlUrl.toLocalFile()).lastModified();
 
        if(modifycationTime > _qmlLoadTime)
        {
            stopFileModificationChecks();
 
            if(askForQMLReload())
            {
                loadQML(_qmlUrl);
            }
 
            startQMLFileModificationChecks();
        }
    }
 
    bool askForQMLReload()
    {
        QMessageBox::StandardButton reply;
 
        reply = QMessageBox::question(mainWidget(), "QML was updated", _qmlUrl.toLocalFile() + " was changed.\nDo you want to reload it?", QMessageBox::Yes|QMessageBox::No);
 
        if (reply == QMessageBox::Yes)
        {
            return true;
        }
 
        return false;
    }
 
    void log(const QString& text)
    {
        _ui->logWindow->appendPlainText(text);
    }
 
    void editQML()
    {
        if(_qmlUrl.isValid() && !_qmlUrl.isEmpty())
        {
            bool status = QDesktopServices::openUrl(_qmlUrl);
 
            if(!status)
            {
                log(QString("Failed to launch external editor for file: ") + _qmlUrl.toString());
            }
            else
            {
                log(QString("System editor for QML launched!"));
            }
        }
    }
 
 
public slots:
    void handleStatusChange(QQuickWidget::Status status)
    {
        switch (status)
        {
        case QQuickWidget::Status::Error:
            {
            auto errors = _ui->quickWidget->errors();
 
            for (auto error : errors)
            {
                QString errorString = error.toString();
 
                log(QString("QML status: error - ") + errorString);
            }
            }
            break;
 
        case QQuickWidget::Status::Null:
            log(QString("QML status: Null"));
            break;
 
        case QQuickWidget::Status::Loading:
            log(QString("QML status: Loading"));
            break;
 
        case QQuickWidget::Status::Ready:
            log(QString("QML status: Ready"));
            break;
        }
    }
 
private:
    Ui::QMLExecutorPrivate* _ui;
 
    QWidget* _widget;
 
    QUrl _qmlUrl;
 
    QDateTime _qmlLoadTime;
 
    QTimer _qmlUpdateCheckTimer;
 
    CANBusModel* _CANBusModel;
};
 
#endif // QMLEXECUTORGUIIMPL_H