qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Common/LtsMultiMonitor/lts_screen_container.cpp

#include "lts_screen_container.h"

#include "lts_dummy_widget.h"

#include <LtsWidgets/lts_base_layout_widget.h>
#include <QtCore/QDebug>
#include <QtWidgets/QHBoxLayout>
#include <QtCore/QRect>
#include <QtGui/QResizeEvent>
#include <QtCore/QTimer>

namespace LtsMultiMonitor
{
QString LtsScreenContainer::geoStr() const
{
    return QStringLiteral("%1:%2:")
        .arg(QString::number(m_screenGeo.x()).rightJustified(4, QLatin1Char(' ')))
        .arg(QString::number(m_screenGeo.y()).rightJustified(4, QLatin1Char(' ')));
}

LtsScreenContainer::LtsScreenContainer(QRect screenGeo) : m_layout(new QHBoxLayout), m_screenGeo(screenGeo)
{

    m_layout->setContentsMargins(0, 0, 0, 0);
    m_layout->setSpacing(0);
    m_layout->setStretch(0, 999);

    setContentsMargins(0, 0, 0, 0);
    vanish();
    setLayout(m_layout);

    QTimer* t = new QTimer(this);
    t->setInterval(3000);
#ifdef LTS_DEBUG
    t->start();
#endif
    connect(t, &QTimer::timeout, this, [this, screenGeo]() {
        QString old(QStringLiteral("<#!UNKNOWN!#>"));

        if (m_oldActiveWidget == nullptr)
            old = QStringLiteral("null");
        else if (m_oldActiveWidget == &m_mainWidget)
            old = QStringLiteral("MAIN");
        else if (m_oldActiveWidget == &m_secondaryWidget)
            old = QStringLiteral("SECONDARY");
    });
}

bool LtsScreenContainer::isInactiveWidgetOccupied() const
{
    if (m_activeWidget == &m_mainWidget && m_secondaryWidget != nullptr)
        return true;
    if (m_activeWidget == &m_secondaryWidget && m_mainWidget != nullptr)
        return true;
    return false;
}

QIcon LtsScreenContainer::mainWindowIcon() const
{
    if (m_mainWidget != nullptr)
        return m_mainWidget->windowIcon();
    return {};
}

QIcon LtsScreenContainer::secondaryWindowIcon() const
{
    if (m_secondaryWidget != nullptr)
        return m_secondaryWidget->windowIcon();
    return {};
}

bool LtsScreenContainer::mainAndSecondaryOccupied() const
{
    return (m_mainWidget != nullptr && m_secondaryWidget != nullptr);
}

LtsScreenBase::WidgetType LtsScreenContainer::activeWidgetType() const
{
    if (m_activeWidget == &m_mainWidget)
        return LtsScreenBase::WidgetType::MainWidget;
    if (m_activeWidget == &m_secondaryWidget)
        return LtsScreenBase::WidgetType::SecondaryWidget;

    assert(false);
    return LtsScreenBase::WidgetType::None;
}

void LtsScreenContainer::toggle()
{

    switchToTemp((*m_activeWidget == m_mainWidget) ? LtsScreenBase::WidgetType::SecondaryWidget
                                                   : LtsScreenBase::WidgetType::MainWidget);

    QWidget* w = activeWidget();

    assert(w != nullptr);
    if (w == nullptr)
    {
        revertSwitch();
        return;
    }

    if (!tryPutDummyUnmanaged(w))
        w->show();

    finalizeSwitch();
}

bool LtsScreenContainer::isIrreplaceable() const
{
    if (m_activeWidget == nullptr)
        return false;

    auto* blw = qobject_cast<LtsWidgets::LtsBaseLayoutWidget*>(activeWidget());
    if (blw == nullptr)
        return false;

    return blw->isIrreplaceable();
}

QWidget* LtsScreenContainer::activeWidget() const
{
    assert(m_activeWidget != nullptr);

    return *m_activeWidget;
}

QWidget** LtsScreenContainer::activeWidgetPtr()
{
    assert(m_activeWidget != nullptr);

    return m_activeWidget;
}

void LtsScreenContainer::vanish()
{
    return;

    m_layout->setParent(nullptr);
}

void LtsScreenContainer::reappear()
{
    return;

    setAttribute(Qt::WA_TranslucentBackground, false);

    if (m_layout->parent() == nullptr)
        setLayout(m_layout);
}

QWidget* LtsScreenContainer::stealWidget() noexcept(false)
{

    QWidget** widgetPtr = activeWidgetPtr();
    QWidget* widget = *widgetPtr;

    if (widget == nullptr)
    {

        throw "stealWidget: no widget to steal";
    }

    widget->setParent(nullptr);
    vanish();

    disconnect(widget, &QWidget::destroyed, this, &LtsScreenContainer::slotChildDestroyed);

    QWidget* oldWidget = widget;
    *widgetPtr = nullptr;

    return oldWidget;
}

bool LtsScreenContainer::hasWidget(QWidget* widget) const
{
    if (m_mainWidget != nullptr && m_mainWidget == widget)
        return true;
    if (m_secondaryWidget != nullptr && m_secondaryWidget == widget)
        return true;
    return false;
}

bool LtsScreenContainer::isEmpty() const
{
    QWidget** currentWidgetPtr = m_activeWidget;
    if (currentWidgetPtr == nullptr)
        return true;
    return (*currentWidgetPtr == nullptr);
}

bool LtsScreenContainer::hasMainWidget()
{
    return m_mainWidget != nullptr;
}

bool LtsScreenContainer::hasSecondaryWidget()
{
    return m_secondaryWidget != nullptr;
}

bool LtsScreenContainer::tryPutDummyUnmanaged(QWidget* widget)
{
    auto* dummy = qobject_cast<FullscreenVideoDummyWidget*>(widget);

    if (dummy == nullptr)
        return false;

    QRect r(mapToGlobal(rect().topLeft()), rect().size());

    emit dummy->signalWidgetPlaced(r);

    emit signalSetCornerIcons();

    return true;
}

void LtsScreenContainer::switchToTemp(LtsScreenBase::WidgetType widgetType)
{

    Q_ASSERT(widgetType != LtsScreenBase::WidgetType::None);

    if ((m_activeWidget == &m_mainWidget && widgetType == LtsScreenBase::WidgetType::MainWidget) ||
        (m_activeWidget == &m_secondaryWidget && widgetType == LtsScreenBase::WidgetType::SecondaryWidget))
    {

        m_nullSwitchActive = true;
        return;
    }

    if (widgetType == LtsScreenBase::WidgetType::MainWidget)
        m_oldActiveWidget = &m_secondaryWidget;
    else if (widgetType == LtsScreenBase::WidgetType::SecondaryWidget)
        m_oldActiveWidget = &m_mainWidget;
    else
        Q_ASSERT(false);

    m_activeWidget = (widgetType == LtsScreenBase::WidgetType::SecondaryWidget ? &m_secondaryWidget : &m_mainWidget);
}

void LtsScreenContainer::finalizeSwitch()
{

    QWidget** oldActiveWidget = m_oldActiveWidget;
    m_oldActiveWidget = nullptr;

    if (m_nullSwitchActive)
    {

        m_nullSwitchActive = false;
        return;
    }

    if (oldActiveWidget == nullptr)
    {

        return;
    }

    if (*oldActiveWidget == nullptr)
    {

        return;
    }

    QWidget* widget = *oldActiveWidget;
    auto* dummy = qobject_cast<FullscreenVideoDummyWidget*>(widget);
    if (dummy != nullptr)
    {

        dummy->hideVideo();
    }
    else
    {

        widget->hide();
    }

    QWidget* widget2 = *m_activeWidget;
    auto* dummy2 = qobject_cast<FullscreenVideoDummyWidget*>(widget2);
    if (dummy2 != nullptr)
    {
        dummy2->showVideo();
    }

    emit signalSetCornerIcons();
}

void LtsScreenContainer::revertSwitch()
{

    QWidget** oldActiveWidgetBackup = m_oldActiveWidget;
    m_oldActiveWidget = nullptr;

    if (m_nullSwitchActive)
    {

        m_nullSwitchActive = false;
        return;
    }

    if (oldActiveWidgetBackup == nullptr)
        return;

    m_activeWidget = oldActiveWidgetBackup;
}

void LtsScreenContainer::setWidget(QWidget* widget)
{

    QWidget** widgetPtr = activeWidgetPtr();

    qWarning() << geoStr() << "setWidget: m_activeWidget" << m_activeWidget;

    QWidget* currentWidget = *widgetPtr;

    Q_ASSERT(currentWidget == nullptr);

    *widgetPtr = widget;
    reappear();

    connect(widget, &QWidget::destroyed, this, &LtsScreenContainer::slotChildDestroyed, Qt::UniqueConnection);

    if (tryPutDummyUnmanaged(widget))
        return;

    m_layout->addWidget(widget);

    widget->show();

    emit signalSetCornerIcons();
}

void LtsScreenContainer::slotChildDestroyed()
{
    if (sender() == static_cast<QObject*>(m_mainWidget))
    {
        m_mainWidget = nullptr;
        qWarning() << geoStr() << "m_mainWidget set to nullptr!";

        if (*m_activeWidget == m_mainWidget)
        {
            qWarning() << "slotChildDestroyed: switching to sec";
            switchToTemp(LtsScreenBase::WidgetType::SecondaryWidget);

            QWidget* widget = activeWidget();

            if (widget != nullptr)
            {
                auto* dummy = qobject_cast<FullscreenVideoDummyWidget*>(widget);
                if (dummy != nullptr)
                {
                    QRect r(mapToGlobal(rect().topLeft()), rect().size());
                    qWarning() << geoStr()
                               << "LtsScreenContainer::slotChildDestroyed => (main) dummy->signalWidgetPlaced";
                    emit dummy->signalWidgetPlaced(r);
                }
                else
                {
                    widget->show();
                }
            }

            finalizeSwitch();
        }
    }
    else if (sender() == static_cast<QObject*>(m_secondaryWidget))
    {
        m_secondaryWidget = nullptr;
        qWarning() << geoStr() << "m_secondaryWidget set to nullptr!";

        if (*m_activeWidget == m_secondaryWidget)
        {
            qWarning() << "slotChildDestroyed: switching to main";
            switchToTemp(LtsScreenBase::WidgetType::MainWidget);

            QWidget* widget = activeWidget();

            if (widget != nullptr)
            {
                auto* dummy = qobject_cast<FullscreenVideoDummyWidget*>(widget);
                if (dummy != nullptr)
                {
                    QRect r(mapToGlobal(rect().topLeft()), rect().size());
                    qWarning() << geoStr()
                               << "LtsScreenContainer::slotChildDestroyed => (sec) dummy->signalWidgetPlaced";
                    emit dummy->signalWidgetPlaced(r);
                }
                else
                {
                    widget->show();
                }
            }

            finalizeSwitch();
        }
    }
    else
    {
        qWarning() << geoStr() << "slotChildDestroyed NOT received from any known widget !!";
        Q_ASSERT(false);
    }

    vanish();
    emit check();
}

QWidget* LtsScreenContainer::widget() noexcept(false)
{
    QWidget** widgetPtr = m_activeWidget;
    if (widgetPtr != nullptr && *widgetPtr != nullptr)
        return *widgetPtr;
    throw "no widget in container";
}

} // namespace LtsMultiMonitor