qohosview.h

Go to the documentation of this file.

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#ifndef QOHOSVIEW_H
#define QOHOSVIEW_H
 
#include <QtCore/private/qohoscommon_p.h>
#include <QtCore/qflags.h>
#include <QtCore/qglobal.h>
#include <QtCore/qmimedata.h>
#include <QtCore/qobject.h>
#include <QtCore/qpoint.h>
#include <QtCore/qpointer.h>
#include <QtCore/qsharedpointer.h>
#include <QtCore/qsize.h>
#include <QtCore/qstring.h>
#include <QtGui/qimage.h>
#include <QtGui/qwindow.h>
#include <memory>
#include <optional>
#include <qohosdisplayinfo.h>
#include <qohosforeignwindow.h>
#include <qohosplatformwindow.h>
#include <qohosruntimedevicetypeandmode.h>
#include <qohossettings.h>
#include <qohoswindowproperty.h>
#include <render/qnativenode.h>
#include <render/qohossurface.h>
#include <render/qohoswindowproxy.h>
#include <functional>
#include <vector>
 
QT_BEGIN_NAMESPACE
 
enum class ViewGeometryPersistencePolicy
{
    Disabled,
    Enabled,
    FollowSystemSetting,
    Ignore,
};
 
class QOhosView : public QObject
{
    Q_OBJECT
 
public:
    enum class ViewType
    {
        MainWindow,
        SubWindow,
        EmbeddedWindow,
        FloatWindow,
    };
 
    enum class WindowHideMethod {
        Minimize,
        HideAbility,
        NativeNodeVisibility,
    };
 
    struct SubWindowHacks
    {
        bool disableWindowFocusableBeforeLoadContent = false;
    };
 
    struct SubWindowOptions
    {
        bool decorEnabled;
        SubWindowHacks hacks;
    };
 
    struct ViewGeometry
    {
        std::optional<QOhosDisplayInfo::JsDisplayId> displayId;
        QRect frameGeometry;
        QRect geometry;
    };
 
    struct WindowMinMaxCloseButtonsState
    {
        bool maxButtonShown = true;
        bool minButtonShown = true;
        bool closeButtonShown = true;
        bool operator==(const WindowMinMaxCloseButtonsState &other) const;
        bool operator!=(const WindowMinMaxCloseButtonsState &other) const;
    };
 
    enum class WindowStateSyncReason
    {
        Normal,
        ViewTypeChanged,
    };
 
    static std::unique_ptr<QOhosView> createForWindow(
        QOhosPlatformWindow *window, QOhosPropertiesProvider windowPropertiesProvider);
 
    explicit QOhosView(
        QWindow *ownerWindow, QSharedPointer<QNativeNode> nativeNode,
        QOhosPropertiesProvider propertiesProvider);
 
    void setSizeLimits(const QSize &minSize, const QSize &maxSize);
    void setPosition(const QPoint &position);
    void setPositionOnScreenImmediate(const QPoint &position, QOhosDisplayInfo::JsDisplayId jsDisplayId);
    void setSize(const QSize &size);
    void setOpacity(qreal opacity);
    void setCursor(const QCursor &cursor);
    void setTransparentBackground(bool transparent);
    void setFocusable(bool focusable);
    void setWindowTransparentForInput(bool transparentForInput);
    void setModality(Qt::WindowModality modality);
    void setTitle(const QString &title);
    void raise();
    void lower();
    void setFullScreen();
    void recover();
    void minimize();
    void maximize();
    void setWindowMask(const QOhosWindowProxy::WindowMask &windowMask);
    void handleSurfaceContentsUpdated();
    void setParentOrReparent(QOhosView &parentView);
    void tryDetachFromEmbeddedParent();
    WId viewWindowId() const;
    void addForeignWindowChild(QOhosForeignWindow *foreignWindow);
    bool isFullscreenImmersiveModeEnabled();
    bool isSubWindowCoveringFullScreen() const;
    void setWindowMinMaxCloseButtonState(const WindowMinMaxCloseButtonsState &state);
    void setWindowStaysOnTop(bool staysOnTop);
    void setFramelessWindow(bool frameless);
    void setWindowShadowDisabled();
    void setNativeNodeVisibility(bool visible);
    QPixmap makeSnapshot() const;
    bool startMoving();
    void startDrag(
        const std::vector<QImage> &images, const QPointF &hotspot,
        const QMimeData &mimeData, QOhosConsumer<Qt::DropAction> dropActionConsumer);
    void restoreMainWindow();
    void handleWindowStateChange(
        Qt::WindowStates previousWindowState, Qt::WindowStates currentWindowState);
    void handleWindowFlagsChange(
        Qt::WindowFlags previousWindowFlags, Qt::WindowFlags currentWindowFlags);
    void handlePaletteChange();
    QArkUi::QQtEmbeddedWindowNode::NodeAreaInfo nodeAreaInfo() const;
    bool isNodeLaidOut() const;
 
    void showImmediate();
    void hide();
    void requestActivate();
    void forceGeometryUpdate();
 
    QWindow *ownerWindow() const;
    QOhosSurface *surfaceOrNull() const;
 
    ViewGeometry viewGeometry() const;
    QMargins avoidAreaMargins(QOhosWindowProxy::AvoidAreaType type) const;
    QList<QRect> displayCutoutRects() const;
    ViewType viewType() const;
    std::optional<QSize> surfaceResolution() const;
    const QOhosView *viewParentOrNull() const;
    QRect nodeScreenGeometryPixels() const;
    QRect nodeParentRelativeGeometryPixels() const;
    bool consumePendingSelfMinimizeEcho();
 
    ~QOhosView();
 
Q_SIGNALS:
    void windowEvent(QOhosWindowProxy::WindowEvent event);
    void windowStatusChange(QOhosWindowProxy::WindowStatus windowStatus);
    void windowVisibilityChange(bool visibility);
    void windowTouchOutside();
    void avoidAreaChanged(QOhosWindowProxy::AvoidAreaType avoidAreaType, const QOhosWindowProxy::AvoidArea &avoidArea);
    void windowRectChanged(QOhosWindowProxy::RectChangeOptions rectChangeOptions);
    void windowRectChangedInGlobalDisplay(QOhosWindowProxy::RectChangeOptions rectChangeOptions);
    void surfaceStatusChanged(const std::optional<QSize> &optSurfaceSize);
    void windowDisplayIdChanged(QOhosDisplayInfo::JsDisplayId);
    void externalContentInteractionDetected();
    void nodeAreaChanged(QArkUi::QQtEmbeddedWindowNode::NodeAreaInfo areaChangeEvt);
 
private:
    void applyPhoneWindowChrome();
 
    static constexpr QOhosRuntimeDeviceTypeAndMode allModes =
        QOhosRuntimeDeviceTypeAndMode::_2in1
        | QOhosRuntimeDeviceTypeAndMode::HandheldDeviceFullScreen
        | QOhosRuntimeDeviceTypeAndMode::HandheldDeviceWindowPcMode;
 
    template <typename T, QOhosRuntimeDeviceTypeAndMode supportedModes = allModes>
    struct SystemUpdateDataProperty
    {
        std::optional<T> optPendingUpdateRequest;
    };
 
    template<typename T>
    using NoTabletSystemUpdateDataProperty = SystemUpdateDataProperty<T, QOhosRuntimeDeviceTypeAndMode::_2in1>;
 
    template<typename T>
    using WindowModeOnlySystemUpdateDataProperty = SystemUpdateDataProperty<
        T, QOhosRuntimeDeviceTypeAndMode::_2in1 | QOhosRuntimeDeviceTypeAndMode::HandheldDeviceWindowPcMode>;
 
    struct SystemUpdateData
    {
        WindowModeOnlySystemUpdateDataProperty<QSize> size;
        WindowModeOnlySystemUpdateDataProperty<std::pair<QSize, QSize>> sizeLimits;
        WindowModeOnlySystemUpdateDataProperty<std::pair<QPoint, std::optional<QOhosDisplayInfo::JsDisplayId>>> position;
        SystemUpdateDataProperty<bool> visibility;
        NoTabletSystemUpdateDataProperty<bool> backgroundTransparent;
        SystemUpdateDataProperty<QCursor> cursor;
        NoTabletSystemUpdateDataProperty<bool> focusable;
        SystemUpdateDataProperty<QColor> backgroundColor;
        SystemUpdateDataProperty<int> brightness;
        SystemUpdateDataProperty<int> contrast;
        SystemUpdateDataProperty<int> saturation;
        SystemUpdateDataProperty<bool> windowTransparentForInput;
        WindowModeOnlySystemUpdateDataProperty<Qt::WindowModality> modality;
        WindowModeOnlySystemUpdateDataProperty<QString> title;
        WindowModeOnlySystemUpdateDataProperty<WindowMinMaxCloseButtonsState> windowMinMaxCloseButtonsState;
        WindowModeOnlySystemUpdateDataProperty<bool> windowStaysOnTop;
        WindowModeOnlySystemUpdateDataProperty<bool> frameless;
    };
 
    static constexpr auto makeSystemUpdateDataPropertyUpdateFuncPairsTuple()
    {
        return std::make_tuple(
            std::make_pair(&SystemUpdateData::sizeLimits, &QOhosView::updateWindowSizeLimits),
            std::make_pair(&SystemUpdateData::size, &QOhosView::updateWindowSize),
            std::make_pair(&SystemUpdateData::position, &QOhosView::updateWindowPosition),
            std::make_pair(&SystemUpdateData::backgroundTransparent, &QOhosView::updateWindowBackgroundTransparency),
            std::make_pair(&SystemUpdateData::cursor, &QOhosView::updateWindowCursor),
            std::make_pair(&SystemUpdateData::focusable, &QOhosView::updateWindowFocusable),
            std::make_pair(&SystemUpdateData::backgroundColor, &QOhosView::updateWindowBackgroundColor),
            std::make_pair(&SystemUpdateData::brightness, &QOhosView::updateWindowBrightness),
            std::make_pair(&SystemUpdateData::contrast, &QOhosView::updateWindowContrast),
            std::make_pair(&SystemUpdateData::saturation, &QOhosView::updateWindowSaturation),
            std::make_pair(&SystemUpdateData::windowTransparentForInput, &QOhosView::updateWindowTransparentForInput),
            std::make_pair(&SystemUpdateData::modality, &QOhosView::updateWindowModality),
            std::make_pair(&SystemUpdateData::title, &QOhosView::updateWindowTitle),
            std::make_pair(&SystemUpdateData::windowMinMaxCloseButtonsState, &QOhosView::updateWindowMinMaxCloseButtonsState),
            std::make_pair(&SystemUpdateData::windowStaysOnTop, &QOhosView::updateWindowStaysOnTop),
            std::make_pair(&SystemUpdateData::frameless, &QOhosView::updateWindowFrameless));
    };
 
    template <typename T, QOhosRuntimeDeviceTypeAndMode SupportedModes>
    void setSystemUpdateProperty(SystemUpdateDataProperty<T, SupportedModes> SystemUpdateData::*property, const T &value);
 
    void scheduleSystemUpdateIfNeeded();
    void updateWindowSize(const QSize &size);
    void updateWindowSizeLimits(const std::pair<QSize, QSize> &sizeLimits);
    void updateWindowPosition(const std::pair<QPoint, std::optional<QOhosDisplayInfo::JsDisplayId>> &position);
    void updateWindowBackgroundTransparency(bool transparent);
    void updateWindowCursor(const QCursor &cursor);
    void updateWindowFocusable(bool focusable);
    void updateWindowBackgroundColor(const QColor &color);
    void updateWindowBrightness(int brightness);
    void updateWindowContrast(int contast);
    void updateWindowSaturation(int saturation);
    void updateWindowTransparentForInput(bool transparentForInput);
    void updateWindowModality(Qt::WindowModality modality);
    void updateWindowTitle(const QString &title);
    void updateWindowMinMaxCloseButtonsState(const WindowMinMaxCloseButtonsState &state);
    void updateWindowStaysOnTop(bool staysOnTop);
    void updateWindowFrameless(bool frameless);
    void syncWindowStateImmediate(WindowStateSyncReason reason = WindowStateSyncReason::Normal);
    void flushSystemPropertyUpdatesImmediate();
    QOhosWindowProxy *flushedWindowProxyOrNull();
    void setOrResetWindowProxy(std::shared_ptr<QOhosWindowProxy> windowProxy, QWindow *optLogicalParent);
    const QOhosView *ancestorViewWithWindowOrNull() const;
    void hideMainWindow();
    void setWindowCornerRadius(double radius);
    void setPrivacyMode(bool privacyModeEnabled);
    void setBackgroundColor(const QColor &color);
    void setBrightness(int brightness);
    void setContrast(int contrast);
    void setSaturation(int saturation);
    void setWindowKeepScreenOn(bool keepScreenOn);
    void setFixedSizeStateEnabled(bool fixedSizeStateEnabled);
    void setWindowDragResizable(bool dragResizable);
    void showWindow();
    void sendAsyncSyntheticWindowActiveEvent();
 
    std::shared_ptr<QOhosWindowProxy> tryCreateWindowProxyIfNeeded(ViewType viewType, QWindow *optLogicalParent);
 
    bool isWindowTransparencyRequested() const;
 
    QOhosPropertiesProvider m_windowPropertiesProvider;
    QPointer<QWindow> m_ownerWindow;
    std::shared_ptr<QOhosWindowProxy> m_ohosWindowProxy;
    QSharedPointer<QNativeNode> m_nativeNode;
    // True once the node has reported its first area through the
    // area-change handler. Before that nodeAreaInfo() returns an empty
    // 0x0 rect, so callers must not treat it as geometry. The node lives
    // for the whole view (reset only in the destructor), so this is
    // never cleared.
    bool m_nodeLaidOut = false;
    SystemUpdateData m_updateData;
    bool m_updatePending;
    std::function<QOhosWindowProxy::AvoidArea(QOhosWindowProxy::AvoidAreaType)> m_avoidAreasProvider;
    bool m_requireHandheldDeviceSupport;
    QtOhos::InternalWindowId m_ownerWindowId;
    bool m_windowDestroyed = false;
    std::optional<ViewType> m_viewType;
    QPointer<QWindow> m_optLogicalParent;
    std::optional<WindowHideMethod> m_lastMainWindowHideMethod;
    ViewGeometryPersistencePolicy m_geometryPersistencePolicy = ViewGeometryPersistencePolicy::Ignore;
    std::shared_ptr<void> m_windowPropertiesProviderCallbacksHandle;
    std::function<void()> m_optPostSurfaceDrawTask;
    int m_pendingSelfMinimizeEchoes = 0;
};
 
template <typename T, QOhosRuntimeDeviceTypeAndMode SupportedModes>
void QOhosView::setSystemUpdateProperty(SystemUpdateDataProperty<T, SupportedModes> SystemUpdateData::*propertyMemberPtr, const T &value)
{
    QFlags<QOhosRuntimeDeviceTypeAndMode> supportedModes(SupportedModes);
 
    if (m_requireHandheldDeviceSupport
        && !supportedModes.testFlag(QOhosRuntimeDeviceTypeAndMode::HandheldDeviceWindowPcMode)
        && !supportedModes.testFlag(QOhosRuntimeDeviceTypeAndMode::HandheldDeviceFullScreen)) {
        return;
    }
 
    bool windowModeOnly =
        !supportedModes.testFlag(QOhosRuntimeDeviceTypeAndMode::HandheldDeviceFullScreen)
        && (supportedModes.testFlag(QOhosRuntimeDeviceTypeAndMode::_2in1)
            || supportedModes.testFlag(QOhosRuntimeDeviceTypeAndMode::HandheldDeviceWindowPcMode));
 
    if (windowModeOnly && !QOhosSettings::instance().isWindowPcModeEnabled()
        && viewType() == ViewType::MainWindow) {
        return;
    }
 
    auto &property = m_updateData.*propertyMemberPtr;
    if (property.optPendingUpdateRequest != value) {
        property.optPendingUpdateRequest = value;
        scheduleSystemUpdateIfNeeded();
    }
}
 
QT_END_NAMESPACE
 
#endif