qohosplatformwindow.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 OHOSPLATFORMWINDOW_H
#define OHOSPLATFORMWINDOW_H
 
#include <QtCore/private/qohoscommon_p.h>
#include <QtCore/qglobal.h>
#include <QtCore/qharmonyjsobjectref.h>
#include <QtCore/qobject.h>
#include <QtCore/qrect.h>
#include <QtGui/qpa/qplatformwindow_p.h>
#include <QtGui/qwindow_platform.h>
#include <functional>
#include <memory>
#include <optional>
#include <qohosdisplayinfo.h>
#include <qohosinternalwindowid_p.h>
#include <qohoswindowproperty.h>
#include <qpa/qplatformwindow.h>
#include <render/qohossurface.h>
 
QT_BEGIN_NAMESPACE
 
class QOhosPlatformScreen;
class QOhosPlatformBackingStore;
class QOhosView;
 
class QOhosPlatformWindow: public QPlatformWindow, public QNativeInterface::Private::QOhosWindow, public QNativeInterface::QHarmonyWindow
{
public:
    enum class DecorationPreset {
        Standard,
        Frameless,
    };
 
    static const QOhosPropertyDescriptor<QWindow *> subWindowOfTagProperty;
    static const QOhosPropertyDescriptor<bool> mainWindowTagProperty;
    static const QOhosPropertyDescriptor<bool> floatWindowTagProperty;
    static const QOhosPropertyDescriptor<double> windowCornerRadiusProperty;
    static const QOhosPropertyDescriptor<bool> windowPrivacyModeSettingProperty;
    static const QOhosPropertyDescriptor<QColor> surfaceBackgroundColorProperty;
    static const QOhosPropertyDescriptor<int> nativeNodeRenderFitPolicyHintProperty;
    static const QOhosPropertyDescriptor<bool> windowKeepScreenOnProperty;
    static const QOhosPropertyDescriptor<bool> windowDragResizableProperty;
    static const QOhosPropertyDescriptor<bool> windowFixedSizeStateProperty;
    static const QOhosPropertyDescriptor<int> windowBrightnessProperty;
    static const QOhosPropertyDescriptor<int> windowContrastProperty;
    static const QOhosPropertyDescriptor<int> windowSaturationProperty;
 
    static QOhosPlatformWindow* fromQWindow(QWindow *window);
    static QOhosPlatformWindow *fromQWindowOrNull(QWindow *window);
    static void tagWindowOrWidgetAsSubWindowOf(QObject *windowOrWidgetToTag, QWindow *targetMainWindow);
    static void tagWindowOrWidgetAsMainWindow(QObject *windowOrWidgetToTag, bool forceMainWindow);
    static void tagWindowOrWidgetAsFloatWindow(QObject *windowOrWidgetToTag, bool showAsFloatWindow);
    static QWindow *getWindowOrWidgetAsSubWindowOfTagValue(QObject *windowOrWidget);
    static Qt::WindowFlags platformWindowFlagsForQWindow(QWindow *window);
    static bool isEmbeddedWindow(QWindow *window);
    static void closeAllActivePopups();
 
    template<typename T, const QOhosPropertyDescriptor<T> *propertyPtr>
    static void setWindowOrWidgetProperty(QObject *windowOrWidget, T propertyValue);
 
    template<typename T, const QOhosPropertyDescriptor<T> *propertyPtr>
    static std::optional<T> tryGetWindowOrWidgetProperty(QObject *windowOrWidget);
 
    static std::shared_ptr<void> setSurfaceConsumer(
        QWindow *targetWindow, QObject *surfaceConsumerContext,
        std::function<void(std::optional<void *>)> surfaceConsumer);
 
    explicit QOhosPlatformWindow(QWindow *window);
 
    static bool isWindowBeingClosedOrDestroyed(QWindow *window);
    void setVisible(bool visible) override;
 
    void setCursor(const QCursor &cursor);
 
    void setWindowTitle(const QString &title) override;
 
    void setParent(const QPlatformWindow *newParent) override;
    QPlatformScreen *screen() const override;
 
    void setWindowState(Qt::WindowStates state) override;
    void setWindowFlags(Qt::WindowFlags flags) override;
    Qt::WindowFlags windowFlags() const;
 
    void propagateSizeHints() override;
    inline bool isRaster() const {
        if (isForeignWindow())
            return false;
 
        return window()->surfaceType() == QSurface::RasterSurface;
    }
    bool isExposed() const final;
 
    void setGeometry(const QRect &rect) override;
    bool shouldDisplayAsOhosWindow() const;
    QtOhos::InternalWindowId internalWindowId() const;
    std::optional<double> windowId() const override;
    QHarmonyJsObjectRef ability() const override;
    QHarmonyJsObjectRef jsWindow() const override;
 
    virtual QOhosSurface *ownedSurfaceOrNull() const;
    virtual QOhosView *ownedViewOrNull() const;
 
    DecorationPreset decorationPreset() const;
    QMargins frameMargins() const override;
    QMargins safeAreaMargins() const override;
 
    QWindow *validSubWindowOfTagValueOrNull() const;
    bool mainWindowTagValueOrFalse() const;
    bool floatWindowTagValueOrFalse() const;
    void initialize() override;
    Qt::WindowStates windowStates() const;
    void resetRefusedMaximizeState();
    void requestActivateWindow() override;
    void handleDpiChange();
    bool shouldShowWindowWithoutActivating() const;
 
    QPixmap makeSnapshot() const;
 
    bool setMouseGrabEnabled(bool grab) override;
    bool setKeyboardGrabEnabled(bool grab) override;
 
    QRect lastRequestedWindowFrameGeometry() const;
 
protected:
    QOhosPlatformScreen *platformScreen() const;
    bool canBeShownOnScreen() const;
 
    void setWindowStateFromOhos(Qt::WindowStates state);
    void setWindowMarginsFromOhos(const QMargins &margins);
    void setSafeAreaMarginsFromOhos(const QMargins &margins);
    void setExposedFromOhos(bool exposed);
    void setDisplayIdFromOhos(std::optional<QOhosDisplayInfo::JsDisplayId> displayId);
    void setWindowGeometryFromOhos(const QRect &nativeWindowDrawGeometry);
    QSize lastReportedWindowSize() const;
    void notifyWindowDestroyedFromOhos();
    bool checkWindowAcceptsFocus() const;
    bool checkWindowAcceptsInput() const;
 
    void notifyInputSystemsWindowActiveStatusChanged(bool active);
    QOhosPropertiesProvider propertiesProvider();
 
    virtual void onWindowFlagsChanged(
        Qt::WindowFlags previousWindowFlags,
        Qt::WindowFlags currentWindowFlags);
    virtual void onWindowStateChanged(
        Qt::WindowStates oldWindowState, Qt::WindowStates currentWindowState);
 
    bool windowEvent(QEvent *event) override;
 
    Qt::WindowFlags m_windowFlags;
    Qt::WindowStates m_windowState;
    std::optional<Qt::WindowStates> m_lastWindowState;
 
    QtOhos::InternalWindowId m_windowId = QtOhos::InternalWindowId::invalidWindowId();
    QRect m_oldGeometry;
    std::unique_ptr<QMargins> m_optFrameMargins;
    std::optional<QCursor> m_cursor;
    QMargins m_safeAreaMargins;
 
private:
    void sendExposeUpdate();
 
    QPlatformWindow *m_parent {nullptr};
    std::optional<QOhosDisplayInfo::JsDisplayId> m_displayId;
    QOhosPropertiesStore m_propertiesStore;
    bool m_exposed = false;
    QRect m_lastRequestedWindowFrameGeometry;
    std::optional<QSize> m_optLastReportedWindowSize;
};
 
template<typename T, const QOhosPropertyDescriptor<T> *propertyPtr>
void QOhosPlatformWindow::setWindowOrWidgetProperty(QObject *windowOrWidget, T propertyValue)
{
    if (windowOrWidget == nullptr)
        qOhosReportFatalErrorAndAbort("%s: windowOrWidget is null", Q_FUNC_INFO);
 
    if (!windowOrWidget->isWindowType() && !windowOrWidget->isWidgetType()) {
        qOhosReportFatalErrorAndAbort(
            "%s: Invalid object - expected either window or widget, got %s",
            Q_FUNC_INFO,
            windowOrWidget->metaObject()->className());
    }
 
    setQOhosPropertyOnQObject<T, propertyPtr>(windowOrWidget, propertyValue);
}
 
template<typename T, const QOhosPropertyDescriptor<T> *propertyPtr>
std::optional<T> QOhosPlatformWindow::tryGetWindowOrWidgetProperty(QObject *windowOrWidget)
{
    return tryGetQOhosPropertyFromQObject<T, propertyPtr>(windowOrWidget);
}
 
QT_END_NAMESPACE
 
#endif // OHOSPLATFORMWINDOW_H