WindowContainer.h

#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 1
    #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 1
    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);
        }
        ~WindowContainer()
        {
            if (m_window)
                m_window->setVisible(QWindow::Visibility::Hidden);
        }
        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(Qt::WindowStaysOnBottomHint | Qt::Widget | Qt::WindowDoesNotAcceptFocus);
        #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)
            {
#if NDEVR_SPECIAL_GRAPHICS_WINDOW
                QHBoxLayout* layout = new QHBoxLayout();
                layout->setContentsMargins(0, 0, 0, 0);
#endif
                //m_container->setAttribute(Qt::WA_NoSystemBackground);
                m_container->setParent(this);
                m_container->setMouseTracking(true);
#if NDEVR_SPECIAL_GRAPHICS_WINDOW
                layout->addWidget(m_container);
                setLayout(layout);
#endif
            }
        }

        void setWindow(QWindow* window)
        {
            if (window == m_window)
                return;
            if (m_container)
            {
                m_container->deleteLater();
                m_container = nullptr;
            }
            m_window = window;
            if (m_window)
            {
                m_window->setVisible(QWindow::Visibility::Hidden);
#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 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);
        }

        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
        {
            QEvent::Type event_type = event->type();
            switch (event_type)
            {
            case QEvent::Show:
                if (m_container)
                    m_container->setVisible(true);
                if (m_window)
                    m_window->setVisibility(QWindow::Visibility::Windowed);
                break;
            case QEvent::Hide:
                if (m_container)
                    m_container->setVisible(false);
                if (m_window)
                    m_window->setVisibility(QWindow::Visibility::Hidden);
                break;
            default:
                break;
            }
            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;
        }
#if defined(ANDROID)
        void setVisible(bool visible) override
        {
            BaseWindowContainer::setVisible(visible);
            if (m_container)
                m_container->setVisible(visible);
            if (m_window)
                m_window->setVisible(visible ? QWindow::Visibility::Windowed
                    : QWindow::Visibility::Hidden);
        }

        void resizeEvent(QResizeEvent* resize_event) override
        {
            BaseWindowContainer::resizeEvent(resize_event);
            QSize s = resize_event->size();
            if (m_container)
                m_container->resize(s);
            if (m_window)
                m_window->resize(s);
        }
#endif
    protected:
        std::function<bool(QEvent * event)> m_event_forwarder;  
        QTimer* m_location_timer;                               
        QSize m_last_paint_size;                                
        QWindow* m_window;                                      
        QWidget* m_container;                                   
    };
}