WindowContainer.h

Go to the documentation of this file.

#pragma once
#include <QWindow>
#include <QTimer>
#include <QPainter>
#include <QHBoxLayout>
#include <QResizeEvent>
#include <QFrame>
#if defined(ANDROID)
    #define FORCE_HIDE_WINDOW 0
    #define NDEVR_SPECIAL_GRAPHICS_WINDOW 0
    #define USE_WINDOW_WIDGET 0
    //typedef QAbstractScrollArea BaseWindowContainer;
    typedef QFrame BaseWindowContainer;
#elif defined(Q_OS_WASM)
    #include <QFrame>
    #define FORCE_HIDE_WINDOW 0
    #define USE_WINDOW_WIDGET 0
    #define NDEVR_SPECIAL_GRAPHICS_WINDOW 0
    typedef QFrame BaseWindowContainer;
#else
    #include <QFrame>
    #define FORCE_HIDE_WINDOW 0
    #define USE_WINDOW_WIDGET 0
    #define NDEVR_SPECIAL_GRAPHICS_WINDOW 0
    typedef QFrame BaseWindowContainer;
#endif
 
namespace NDEVR
{
    class WindowContainer : public BaseWindowContainer
    {
    public:
        WindowContainer(QWidget* parent = nullptr)
            : BaseWindowContainer(parent)
            , m_location_timer(new QTimer(this))
            , m_last_paint_size(0,0)
            , m_window(nullptr)
            , m_container(nullptr)
        {
/*#ifdef ANDROID
            connect(m_location_timer, &QTimer::timeout, this, [this] {
                updateSize();
            });
            m_location_timer->setInterval(1);
            m_location_timer->setSingleShot(false);
            m_location_timer->start();
#endif*/
            //setAttribute(Qt::WA_NoSystemBackground);
            //setAttribute(Qt::WA_OpaquePaintEvent);
            //setAutoFillBackground(true);
        }
        static Qt::WindowFlags windowFlags()
        {
    #if USE_WINDOW_WIDGET
            return Qt::WindowFlags();//Qt::WindowFlags(Qt::Window | Qt::WindowDoesNotAcceptFocus | Qt::WindowTransparentForInput | Qt::WindowStaysOnBottomHint);
    #else
        #if defined(ANDROID)
            return Qt::WindowFlags();//Qt::WindowDoesNotAcceptFocus | Qt::WindowTransparentForInput);
        #elif defined(Q_OS_WASM)
            return Qt::WindowFlags();
        #else
            return Qt::WindowFlags();// Qt::WindowFlags(Qt::Widget | Qt::WindowDoesNotAcceptFocus | Qt::WindowTransparentForInput);
        #endif
    #endif
        }
 
        QPoint windowOffset() const
        {
#if USE_WINDOW_WIDGET
            return mapToGlobal(QPoint(0, 0));
#else
            return QPoint(0,0);
#endif 
        }
        void setWidget(QWidget* window)
        {
            if (m_container == window)
                return;
            if (m_container)
            {
                m_container->deleteLater();
                m_container = nullptr;
            }
            m_window = nullptr;
            m_container = window;
            if (m_container)
            {
                //m_container->setAttribute(Qt::WA_NoSystemBackground);
                m_container->setParent(this);
                m_container->setMouseTracking(true);
            }
        }
        void setWindow(QWindow* window)
        {
            if (window != m_window)
            {
                if (m_container)
                {
                    m_container->deleteLater();
                    m_container = nullptr;
                }
                m_window = window;
                if (m_window)
                {
#if NDEVR_SPECIAL_GRAPHICS_WINDOW
                    QHBoxLayout* layout = new QHBoxLayout();
                    layout->setContentsMargins(0,0,0,0);
#endif
                    m_container = QWidget::createWindowContainer(m_window, this, windowFlags());
                    //m_container->setAttribute(Qt::WA_ShowWithoutActivating);
                    //m_container->installEventFilter(this);
                    m_container->setMouseTracking(true);
#if NDEVR_SPECIAL_GRAPHICS_WINDOW
                    layout->addWidget(m_container);
                    setLayout(layout);
#endif
                    
                    //m_container->setEnabled(false);
                    //m_window->resize(size());
                }
            }
        }
        void resizeEvent(QResizeEvent* resize_event) override
        {
            BaseWindowContainer::resizeEvent(resize_event);
            m_last_paint_size = resize_event->oldSize();
#ifndef ANDROID
            //repaint();
#endif
            updateSize();
        }
        void visibleHack()
        {
#if !NDEVR_SPECIAL_GRAPHICS_WINDOW
            /*QTimer::singleShot(1000, this, [this]
            {
                QWidget* widget = new QWidget(this, windowFlags());
                widget->setAttribute(Qt::WidgetAttribute::WA_PaintOnScreen, false);
                widget->show();
                qApp->setActiveWindow(this);
                widget->deleteLater();
            });*/
#endif
        }
        void paintEvent(QPaintEvent* event) override
        {
#if !NDEVR_SPECIAL_GRAPHICS_WINDOW
            updateSize();
#endif
            /*QSize new_size = size();
            QSize old_size = QSize(0, 0);// window()->size();
 
            if (new_size.width() == 0 || new_size.height() == 0)
                return;
            if (old_size.width() < new_size.width() || old_size.height() < new_size.height())
            {
 
                QRect current_size_x(QPoint(old_size.width(), 0), QSize(new_size.width() - old_size.width(), height()));
                QRect current_size_y(QPoint(0, old_size.height()), QSize(new_size.width(), new_size.height() - old_size.height()));
                QPalette pal = palette();
 
                QPainter painter(this);
                QRegion region;
                if (current_size_x.size().width() > 0)
                    region += current_size_x;
                if (current_size_y.size().height() > 0)
                    region += current_size_y;
                if (current_size_x.size().width() > 0)
                    painter.fillRect(current_size_x, pal.color(backgroundRole()));
                if (current_size_y.size().height() > 0)
                    painter.fillRect(current_size_y, pal.color(backgroundRole()));
                painter.end();
                m_last_paint_size = size();
            }*/
            BaseWindowContainer::paintEvent(event);
        }
 
        /*bool eventFilter(QObject* watched, QEvent* e) override
        {
            QEvent::Type q_event = e->type();
            switch (q_event)
            {
            case QEvent::MouseMove:
            case QEvent::MouseButtonPress:
            case QEvent::MouseButtonRelease:
            case QEvent::MouseButtonDblClick:
                if (QMouseEvent* mouse_event = dynamic_cast<QMouseEvent*>(e))
                {
                    if (!geometry().contains(mapFromGlobal(mouse_event->globalPos())))
                    {
                        //e->setAccepted(false);
                        return true;
                    }
                }
                return false;
            case QEvent::Resize:
                return true;
            default:
                return false;
            }
        }*/
        virtual void updateSize()
        {
#if !NDEVR_SPECIAL_GRAPHICS_WINDOW
            if(isVisible())
            {
                QRect rect = QRect(windowOffset(), size());
                if (m_container && m_container->geometry() != rect)
                {
                    m_container->setGeometry(rect);
                    //m_window->resize(size());
                }
            }
            else
            {
                if(m_container)
                {
                    m_container->setVisible(false);
                    m_container->resize(1,1);
                }
            }
#endif
        }
        bool event(QEvent* event) override
        {
#if !NDEVR_SPECIAL_GRAPHICS_WINDOW
            QEvent::Type event_type = event->type();
            switch(event_type)
            {
            case QEvent::Type::Show:
                if (m_container)
                {
                    m_container->setVisible(true);
#if FORCE_HIDE_WINDOW
                    if(m_window)
                        m_window->show();
                    visibleHack();
#endif      
                }
                break;
            case QEvent::Type::Hide:
                if(m_container)
                {
                    m_container->setVisible(false);
#if FORCE_HIDE_WINDOW
                    if(m_window)
                        m_window->hide();
#endif
                }
                break;
            default:
                break;
            }
#endif
            if (m_event_forwarder)
                m_event_forwarder(event);
            //return false;
            return BaseWindowContainer::event(event);
        }
        void setEventForwarder(const std::function<bool(QEvent * event)>& forwarder)
        {
            m_event_forwarder = forwarder;
        }
    protected:
        std::function<bool(QEvent * event)> m_event_forwarder;
        QTimer* m_location_timer;
        QSize m_last_paint_size;
        QWindow* m_window;
        QWidget* m_container;
    };
}