overlaymessagesframe.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_GUI_OVERLAYMESSAGES_FRAME_H
#define SWIFT_GUI_OVERLAYMESSAGES_FRAME_H
 
#include <functional>
 
#include <QDockWidget>
#include <QFrame>
#include <QKeyEvent>
#include <QMessageBox>
#include <QObject>
#include <QSize>
#include <QString>
#include <QTabWidget>
#include <QTableView>
#include <QTreeView>
#include <QUrl>
#include <QWizardPage>
 
#include "gui/components/textmessagecomponenttab.h"
#include "gui/enablefordockwidgetinfoarea.h"
#include "gui/guiutility.h"
#include "gui/overlaymessages.h"
#include "gui/swiftguiexport.h"
#include "misc/logmessage.h"
#include "misc/network/textmessage.h"
#include "misc/pixmap.h"
#include "misc/statusmessagelist.h"
#include "misc/variant.h"
 
class QKeyEvent;
class QPaintEvent;
 
namespace swift::gui
{
    template <class WIDGET>
    class COverlayMessagesBase : public WIDGET
    {
    public:
        virtual ~COverlayMessagesBase() override {}
 
        void initOverlayMessages(QSize inner = {})
        {
            if (m_overlayMessages) { return; }
            if (inner.isNull()) { inner = this->innerFrameSize(); }
 
            m_overlayMessages = new COverlayMessages(inner.width(), inner.height(), this);
            m_overlayMessages->hide();
            m_overlayMessages->setForceSmall(m_forceSmallMsgs);
            m_overlayMessages->setReducedInfo(m_reducedInfo);
        }
 
        void activateTextMessages(bool activate)
        {
            this->initOverlayMessages();
            m_overlayMessages->activateTextMessages(activate);
        }
 
        void showStatusMessagesFrame() { this->initInnerFrame(); }
 
        void setOverlaySizeFactors(double widthFactor, double heightFactor, double middleFactor = 2)
        {
            m_widthFactor = widthFactor;
            m_heightFactor = heightFactor;
            if (middleFactor >= 0) { m_middleFactor = middleFactor; }
        }
 
        void setForceSmall(bool force)
        {
            m_forceSmallMsgs = force;
            if (m_overlayMessages) { m_overlayMessages->setForceSmall(force); }
        }
 
        void setReducedInfo(bool reduced)
        {
            m_reducedInfo = reduced;
            if (m_overlayMessages) { m_overlayMessages->setReducedInfo(reduced); }
        }
 
        void showOverlayMessagesWithConfirmation(const swift::misc::CStatusMessageList &messages,
                                                 bool appendOldMessages, const QString &confirmationMessage,
                                                 std::function<void()> okLambda,
                                                 QMessageBox::StandardButton defaultButton = QMessageBox::Cancel,
                                                 std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            if (messages.isEmpty()) { return; }
            this->initInnerFrame();
            if (!this->hasMinimumSize(150, 150)) { return; }
            m_overlayMessages->showOverlayMessagesWithConfirmation(messages, appendOldMessages, confirmationMessage,
                                                                   okLambda, defaultButton, timeout);
            WIDGET::repaint();
        }
 
        void clearOverlayMessages()
        {
            if (!m_overlayMessages) { return; }
            m_overlayMessages->clearOverlayMessages();
        }
 
        void closeOverlay()
        {
            if (!m_overlayMessages) { return; }
            m_overlayMessages->close();
        }
 
        void showOverlayMessages(const swift::misc::CStatusMessageList &messages, bool appendOldMessages = false,
                                 std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            if (messages.isEmpty()) { return; }
            this->initInnerFrame();
            m_overlayMessages->showOverlayMessages(messages, appendOldMessages, timeout);
            WIDGET::repaint();
        }
 
        void showOverlayMessagesOrSingleMessage(const swift::misc::CStatusMessageList &messages,
                                                bool appendOldMessages = false,
                                                std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            if (messages.isEmpty()) { return; }
            this->initInnerFrame();
            m_overlayMessages->showOverlayMessagesOrSingleMessage(messages, appendOldMessages, timeout);
            WIDGET::repaint();
        }
 
        void showOverlayMessagesOrHTMLMessage(const swift::misc::CStatusMessageList &messages,
                                              bool appendOldMessages = false,
                                              std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            if (messages.isEmpty()) { return; }
            this->initInnerFrame();
            m_overlayMessages->showOverlayMessagesOrHTMLMessage(messages, appendOldMessages, timeout);
            WIDGET::repaint();
        }
 
        void sortOverlayMessages(const swift::misc::CPropertyIndex &property, Qt::SortOrder order)
        {
            m_overlayMessages->sortOverlayMessages(property, order);
        }
 
        void setOverlayMessagesSorting(const swift::misc::CPropertyIndex &property, Qt::SortOrder order)
        {
            m_overlayMessages->setOverlayMessagesSorting(property, order);
        }
 
        bool showOverlayMessage(const swift::misc::CStatusMessage &message,
                                std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            if (message.isEmpty()) { return false; }
            this->initInnerFrame();
            m_overlayMessages->showOverlayMessage(message, timeout);
            WIDGET::repaint();
            return true;
        }
 
        bool showOverlayTextMessage(const swift::misc::network::CTextMessage &textMessage,
                                    std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            if (textMessage.isEmpty()) { return false; }
            this->initInnerFrame();
            m_overlayMessages->showOverlayTextMessage(textMessage, timeout);
            WIDGET::repaint();
            return true;
        }
 
        void showOverlayVariant(const swift::misc::CVariant &variant,
                                std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            if (m_overlayMessages->isTextMessagesActivated() &&
                variant.canConvert<swift::misc::network::CTextMessage>())
            {
                this->initInnerFrame(0.75, 0.75);
                if (!this->hasMinimumSize(150, 150)) { return; }
            }
            else { this->initInnerFrame(); }
 
            m_overlayMessages->showOverlayVariant(variant, timeout);
            WIDGET::repaint();
        }
 
        void showOverlayImage(const swift::misc::CPixmap &pixmap,
                              std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            this->initInnerFrame();
            m_overlayMessages->showOverlayImage(pixmap, timeout);
            WIDGET::repaint();
        }
 
        bool showOverlayHTMLMessage(const QString &htmlMessage,
                                    std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            this->initMinimalFrame();
            m_overlayMessages->showHTMLMessage(htmlMessage, timeout);
            WIDGET::repaint();
            return true;
        }
 
        bool showOverlayHTMLMessage(const swift::misc::CStatusMessage &message,
                                    std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            this->initMinimalFrame();
            m_overlayMessages->showHTMLMessage(message, timeout);
            WIDGET::repaint();
            return true;
        }
 
        void showDownloadProgress(int progress, qint64 current, qint64 max, const QUrl &url,
                                  std::chrono::milliseconds timeout = std::chrono::milliseconds(0))
        {
            this->initMinimalFrame();
            m_overlayMessages->showDownloadProgress(progress, current, max, url, timeout);
            WIDGET::repaint();
        }
 
        void showOverlayInlineTextMessage(components::TextMessageTab tab)
        {
            this->initInnerFrame(0.75, 0.75);
            if (!this->hasMinimumSize(150, 150)) { return; }
            m_overlayMessages->showOverlayInlineTextMessage(tab);
            WIDGET::repaint();
        }
 
        void showOverlayInlineTextMessage(const swift::misc::aviation::CCallsign &callsign)
        {
            this->initInnerFrame(0.75, 0.75);
            if (!this->hasMinimumSize(150, 150)) { return; }
            m_overlayMessages->showOverlayInlineTextMessage(callsign);
            WIDGET::repaint();
        }
 
    protected:
        COverlayMessages *m_overlayMessages = nullptr; 
 
        COverlayMessagesBase(QWidget *parent, Qt::WindowFlags f = Qt::WindowFlags()) : WIDGET(parent)
        {
            this->setWindowFlags(f);
            const bool isFrameless = CGuiUtility::isMainWindowFrameless();
            m_middleFactor = isFrameless ? 1.25 : 1.5; // 2 is middle in normal window
        }
 
        void initInnerFrame(double widthFactor = -1, double heightFactor = -1)
        {
            const QSize inner(innerFrameSize(widthFactor, heightFactor));
            if (!m_overlayMessages)
            {
                // lazy init
                this->initOverlayMessages(inner);
            }
 
            Q_ASSERT(m_overlayMessages);
 
            const QPoint middle = WIDGET::geometry().center();
            const int w = inner.width();
            const int h = inner.height();
            const int x = middle.x() - w / 2;
            const int y = qRound(middle.y() - h / m_middleFactor);
 
            m_overlayMessages->setGeometry(x, y, w, h);
            m_overlayMessages->setVisible(true);
        }
 
        void initMinimalFrame(int lines = 4)
        {
            this->initInnerFrame();
 
            // get logical resolution
            constexpr int MinHeight = 100;
            QSizeF s = CGuiUtility::fontMetricsEstimateSize(100, lines, true); // 2 lines for header
            if (s.height() < MinHeight) { s.setHeight(MinHeight); }
 
            const QSize inner(innerFrameSize());
            const QPoint middle = WIDGET::geometry().center();
            const int w = qMin(inner.width(), qRound(s.width()));
            const int h = qMin(inner.height(), qRound(s.height()));
            const int x = middle.x() - w / 2;
            const int y = qRound(middle.y() - h / m_middleFactor);
            m_overlayMessages->setGeometry(x, y, w, h);
        }
 
        bool hasMinimumSize(int w, int h) const
        {
            if (w > 0 && m_overlayMessages->width() < w)
            {
                swift::misc::CLogMessage(this).info(u"Overlay widget too small (w)");
                return false;
            }
 
            if (h > 0 && m_overlayMessages->height() < h)
            {
                swift::misc::CLogMessage(this).info(u"Overlay widget too small (h)");
                return false;
            }
            return true;
        }
 
        virtual void keyPressEvent(QKeyEvent *event) override
        {
            if (m_overlayMessages && event->key() == Qt::Key_Escape)
            {
                m_overlayMessages->close();
                event->accept();
            }
            else { WIDGET::keyPressEvent(event); }
        }
 
        virtual void resizeEvent(QResizeEvent *event) override
        {
            WIDGET::resizeEvent(event);
            if (m_overlayMessages && m_overlayMessages->isVisible()) { this->initInnerFrame(); }
        }
 
    private:
        QSize innerFrameSize(double widthFactor = -1, double heightFactor = -1) const
        {
            // check against minimum if widget is initialized, but not yet resized
            const int w = std::max(WIDGET::width(), WIDGET::minimumWidth());
            const int h = std::max(WIDGET::height(), WIDGET::minimumHeight());
 
            widthFactor = qMin(widthFactor < 0 ? m_widthFactor : widthFactor, 0.95);
            heightFactor = qMin(heightFactor < 0 ? m_heightFactor : heightFactor, 0.95);
 
            int wInner = qRound(widthFactor * w);
            int hInner = qRound(heightFactor * h);
            if (wInner > WIDGET::maximumWidth()) { wInner = WIDGET::maximumWidth(); }
            if (hInner > WIDGET::maximumHeight()) { hInner = WIDGET::maximumHeight(); }
            return QSize(wInner, hInner);
        }
 
        bool m_forceSmallMsgs = false; 
        bool m_reducedInfo = false; 
        double m_widthFactor = 0.7; 
        double m_heightFactor = 0.6; 
        double m_middleFactor = 2; 
    };
 
    class SWIFT_GUI_EXPORT COverlayMessagesFrame : public COverlayMessagesBase<QFrame>
    {
        Q_OBJECT
 
    public:
        explicit COverlayMessagesFrame(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
 
    signals:
        void requestTextMessageEntryTab(components::TextMessageTab tab);
 
        void requestTextMessageEntryCallsign(const swift::misc::aviation::CCallsign &callsign);
 
        void requestTextMessageWidget(const swift::misc::aviation::CCallsign &callsign);
    };
 
    class SWIFT_GUI_EXPORT COverlayMessagesFrameEnableForDockWidgetInfoArea :
        public COverlayMessagesFrame,
        public CEnableForDockWidgetInfoArea
    {
        Q_OBJECT
 
    public:
        explicit COverlayMessagesFrameEnableForDockWidgetInfoArea(QWidget *parent = nullptr,
                                                                  Qt::WindowFlags f = Qt::WindowFlags());
 
    private:
        bool isForwardingOverlayMessages() const;
    };
 
    class SWIFT_GUI_EXPORT COverlayMessagesTabWidget : public COverlayMessagesBase<QTabWidget>
    {
        Q_OBJECT
 
    public:
        explicit COverlayMessagesTabWidget(QWidget *parent = nullptr);
    };
 
    class SWIFT_GUI_EXPORT COverlayMessagesWizardPage : public COverlayMessagesBase<QWizardPage>
    {
        Q_OBJECT
 
    public:
        explicit COverlayMessagesWizardPage(QWidget *parent = nullptr);
    };
 
    class SWIFT_GUI_EXPORT COverlayMessagesDockWidget : public COverlayMessagesBase<QDockWidget>
    {
        Q_OBJECT
 
    public:
        explicit COverlayMessagesDockWidget(QWidget *parent = nullptr);
    };
 
    class SWIFT_GUI_EXPORT COverlayMessagesTableView : public COverlayMessagesBase<QTableView>
    {
        Q_OBJECT
 
    public:
        explicit COverlayMessagesTableView(QWidget *parent = nullptr);
    };
 
    class SWIFT_GUI_EXPORT COverlayMessagesTreeView : public COverlayMessagesBase<QTreeView>
    {
        Q_OBJECT
 
    public:
        explicit COverlayMessagesTreeView(QWidget *parent = nullptr);
    };
 
} // namespace swift::gui
 
#endif // SWIFT_GUI_OVERLAYMESSAGES_FRAME_H