tst_qwasmwindowtreenode.cpp

Enable keyboard shortcuts

// Copyright (C) 2022 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "../../../../src/plugins/platforms/wasm/qwasmwindowtreenode.h"

#include <QtGui/QWindow>

#include <QTest>

#include <emscripten/val.h>

class TestQWindow

public:

    int flags() { return 0; }

    QVariant property(const char *) { return QVariant(); }

};

class TestWindowTreeNode;

using SetWindowZOrderCallback = std::function<void(TestWindowTreeNode *window, int z)>;

struct SetWindowZOrderCallData

    TestWindowTreeNode *window;

    int z;

};

class TestWindowTreeNode final : public QWasmWindowTreeNode<TestWindowTreeNode>

public:

    TestWindowTreeNode() = default;

    explicit TestWindowTreeNode(SetWindowZOrderCallback setWindowZOrderCallback)

        : m_setWindowZOrderCallback(std::move(setWindowZOrderCallback))

    ~TestWindowTreeNode() final { }

    void setParent(TestWindowTreeNode *parent)

        auto *previous = m_parent;

        m_parent = parent;

        onParentChanged(previous, parent, QWasmWindowStack<TestWindowTreeNode>::PositionPreference::Regular);

    void setContainerElement(emscripten::val container) { m_containerElement = container; }

    void bringToTop() { QWasmWindowTreeNode::bringToTop(); }

    void sendToBottom() { QWasmWindowTreeNode::sendToBottom(); }

    const QWasmWindowStack<TestWindowTreeNode> &childStack() { return QWasmWindowTreeNode::childStack(); }

    emscripten::val containerElement() final { return m_containerElement; }

    QWasmWindowTreeNode *parentNode() final { return m_parent; }

    TestWindowTreeNode *asWasmWindow() final { return this; }

    TestWindowTreeNode *transientParent() const {

        return nullptr;

    TestQWindow *window() { return &m_qWindow; }

    void requestActivateWindow() { ; }

    void setZOrder(int) { ; }

    bool isModal() const { return false; }

    Qt::WindowFlags windowFlags() const { return Qt::WindowFlags(); }

protected:

    void setWindowZOrder(TestWindowTreeNode *window, int z) final

        if (m_setWindowZOrderCallback)

            m_setWindowZOrderCallback(window, z);

    TestWindowTreeNode *m_parent = nullptr;

    emscripten::val m_containerElement = emscripten::val::undefined();

    SetWindowZOrderCallback m_setWindowZOrderCallback;

    TestQWindow m_qWindow;

};

#define QWasmWindowTreeNode QWasmWindowTreeNode<TestWindowTreeNode>

#define QWasmWindow TestWindowTreeNode

class tst_QWasmWindowTreeNode : public QObject

    Q_OBJECT

public:

    tst_QWasmWindowTreeNode() { }

private slots:

    void init();

    void nestedWindowStacks();

    void settingChildWindowZOrder();

};

void tst_QWasmWindowTreeNode::init() { }

bool operator==(const SetWindowZOrderCallData &lhs, const SetWindowZOrderCallData &rhs)

    return lhs.window == rhs.window && lhs.z == rhs.z;

void tst_QWasmWindowTreeNode::nestedWindowStacks()

    TestWindowTreeNode node;

    node.bringToTop();

    TestWindowTreeNode node2;

    node2.setParent(&node);

    QCOMPARE(node.childStack().size(), 1u);

    QCOMPARE(node2.childStack().size(), 0u);

    QCOMPARE(node.childStack().topWindow(), &node2);

    TestWindowTreeNode node3;

    node3.setParent(&node);

    QCOMPARE(node.childStack().size(), 2u);

    QCOMPARE(node2.childStack().size(), 0u);

    QCOMPARE(node3.childStack().size(), 0u);

    QCOMPARE(node.childStack().topWindow(), &node3);

    TestWindowTreeNode node4;

    node4.setParent(&node);

    QCOMPARE(node.childStack().size(), 3u);

    QCOMPARE(node2.childStack().size(), 0u);

    QCOMPARE(node3.childStack().size(), 0u);

    QCOMPARE(node4.childStack().size(), 0u);

    QCOMPARE(node.childStack().topWindow(), &node4);

    node3.bringToTop();

    QCOMPARE(node.childStack().topWindow(), &node3);

    node4.setParent(nullptr);

    QCOMPARE(node.childStack().size(), 2u);

    QCOMPARE(node.childStack().topWindow(), &node3);

    node2.setParent(nullptr);

    QCOMPARE(node.childStack().size(), 1u);

    QCOMPARE(node.childStack().topWindow(), &node3);

    node3.setParent(nullptr);

    QVERIFY(node.childStack().empty());

    QCOMPARE(node.childStack().topWindow(), nullptr);

void tst_QWasmWindowTreeNode::settingChildWindowZOrder()

    QList<SetWindowZOrderCallData> calls;

    SetWindowZOrderCallback onSetWindowZOrder = [&calls](QWasmWindow *window, int z) {

        calls.push_back(SetWindowZOrderCallData{ window, z });

};

    TestWindowTreeNode node(onSetWindowZOrder);

    TestWindowTreeNode node2;

    node2.setParent(&node);

        QCOMPARE(calls.size(), 1u);

        SetWindowZOrderCallData expected{ &node2, 3 };

        QCOMPARE(calls[0], expected);

        calls.clear();

    TestWindowTreeNode node3;

    node3.setParent(&node);

        QCOMPARE(calls.size(), 2u);

        SetWindowZOrderCallData expected{ &node2, 3 };

        QCOMPARE(calls[0], expected);

        expected = SetWindowZOrderCallData{ &node3, 4 };

        QCOMPARE(calls[1], expected);

        calls.clear();

    TestWindowTreeNode node4;

    node4.setParent(&node);

        QCOMPARE(calls.size(), 3u);

        SetWindowZOrderCallData expected{ &node2, 3 };

        QCOMPARE(calls[0], expected);

        expected = SetWindowZOrderCallData{ &node3, 4 };

        QCOMPARE(calls[1], expected);

        expected = SetWindowZOrderCallData{ &node4, 5 };

        QCOMPARE(calls[2], expected);

        calls.clear();

    node2.bringToTop();

        QCOMPARE(calls.size(), 3u);

        SetWindowZOrderCallData expected{ &node3, 3 };

        QCOMPARE(calls[0], expected);

        expected = SetWindowZOrderCallData{ &node4, 4 };

        QCOMPARE(calls[1], expected);

        expected = SetWindowZOrderCallData{ &node2, 5 };

        QCOMPARE(calls[2], expected);

        calls.clear();

QTEST_MAIN(tst_QWasmWindowTreeNode)

#include "tst_qwasmwindowtreenode.moc"