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
{
    /**--------------------------------------------------------------------------------------------------
    \brief A (hacky) class for storing a window into a container. This is used if the rendering engine
        for a particular widget is different from the one used by the application. The hackiness comes
        from Qt's limited support for this functionality which results in the need to hack around the
        errors in Qt's core library.
    **/
    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;
    };
}