1 files changed, 569 insertions, 30 deletions

diff --git a/src/plugins/platforms/wasm/qwasmaccessibility.cpp b/src/plugins/platforms/wasm/qwasmaccessibility.cpp
index b96a3799e6..4c3cb46ba3 100644
--- a/src/plugins/platforms/wasm/qwasmaccessibility.cpp
+++ b/src/plugins/platforms/wasm/qwasmaccessibility.cpp
@@ -3,6 +3,15 @@
 
 #include "qwasmaccessibility.h"
 #include "qwasmscreen.h"
+#include "qwasmwindow.h"
+#include "qwasmintegration.h"
+#include <QtGui/qwindow.h>
+
+#if QT_CONFIG(accessibility)
+
+#include <QtGui/private/qaccessiblebridgeutils_p.h>
+
+Q_LOGGING_CATEGORY(lcQpaAccessibility, "qt.qpa.accessibility")
 
 // Qt WebAssembly a11y backend
 //
@@ -14,33 +23,107 @@
 // events. In addition or alternatively, we could also walk the accessibility tree
 // from setRootObject().
 
-
 QWasmAccessibility::QWasmAccessibility()
 {
 
+    s_instance = this;
 }
 
 QWasmAccessibility::~QWasmAccessibility()
 {
+    s_instance = nullptr;
+}
+
+QWasmAccessibility *QWasmAccessibility::s_instance = nullptr;
 
+QWasmAccessibility* QWasmAccessibility::get()
+{
+    return s_instance;
+}
+
+void QWasmAccessibility::addAccessibilityEnableButton(QWindow *window)
+{
+    get()->addAccessibilityEnableButtonImpl(window);
+}
+
+void QWasmAccessibility::removeAccessibilityEnableButton(QWindow *window)
+{
+    get()->removeAccessibilityEnableButtonImpl(window);
+}
+
+void QWasmAccessibility::addAccessibilityEnableButtonImpl(QWindow *window)
+{
+    if (m_accessibilityEnabled)
+        return;
+
+    emscripten::val container = getContainer(window);
+    emscripten::val document = getDocument(container);
+    emscripten::val button = document.call<emscripten::val>("createElement", std::string("button"));
+    button.set("innerText", std::string("Enable Screen Reader"));
+    button["classList"].call<void>("add", emscripten::val("hidden-visually-read-by-screen-reader"));
+    container.call<void>("appendChild", button);
+
+    auto enableContext = std::make_tuple(button, std::make_unique<qstdweb::EventCallback>
+        (button, std::string("click"), [this](emscripten::val) { enableAccessibility(); }));
+    m_enableButtons.insert(std::make_pair(window, std::move(enableContext)));
+}
+
+void QWasmAccessibility::removeAccessibilityEnableButtonImpl(QWindow *window)
+{
+    auto it = m_enableButtons.find(window);
+    if (it == m_enableButtons.end())
+        return;
+
+    // Remove button
+    auto [element, callback] = it->second;
+    Q_UNUSED(callback);
+    element["parentElement"].call<void>("removeChild", element);
+    m_enableButtons.erase(it);
+}
+
+void QWasmAccessibility::enableAccessibility()
+{
+    // Enable accessibility globally for the applicaton. Remove all "enable"
+    // buttons and populate the accessibility tree, starting from the root object.
+
+    Q_ASSERT(!m_accessibilityEnabled);
+    m_accessibilityEnabled = true;
+    for (const auto& [key, value] : m_enableButtons) {
+        const auto &[element, callback] = value;
+        Q_UNUSED(key);
+        Q_UNUSED(callback);
+        element["parentElement"].call<void>("removeChild", element);
+    }
+    m_enableButtons.clear();
+    populateAccessibilityTree(QAccessible::queryAccessibleInterface(m_rootObject));
+}
+
+emscripten::val QWasmAccessibility::getContainer(QWindow *window)
+{
+    return window ? static_cast<QWasmWindow *>(window->handle())->a11yContainer()
+                  : emscripten::val::undefined();
 }
 
 emscripten::val QWasmAccessibility::getContainer(QAccessibleInterface *iface)
 {
-    // Get to QWasmScreen::container(), return undefined element if unable to
-    QWindow *window = iface->window();
-    if (!window)
+    if (!iface)
         return emscripten::val::undefined();
-    QWasmScreen *screen = QWasmScreen::get(window->screen());
-    if (!screen)
-        return emscripten::val::undefined();
-    return screen->container();
+    return getContainer(getWindow(iface));
+}
+
+QWindow *QWasmAccessibility::getWindow(QAccessibleInterface *iface)
+{
+    QWindow *window = iface->window();
+    // this is needed to add tabs as the window is not available
+    if (!window && iface->parent())
+        window = iface->parent()->window();
+    return window;
 }
 
 emscripten::val QWasmAccessibility::getDocument(const emscripten::val &container)
 {
     if (container.isUndefined())
-        return emscripten::val::undefined();
+        return emscripten::val::global("document");
     return container["ownerDocument"];
 }
 
@@ -58,12 +141,12 @@ emscripten::val QWasmAccessibility::createHtmlElement(QAccessibleInterface *ifac
 
     // Get the correct html document for the container, or fall back
     // to the global document. TODO: Does using the correct document actually matter?
-    emscripten::val document = container.isUndefined() ? emscripten::val::global("document") : getDocument(container);
+    emscripten::val document = getDocument(container);
 
     // Translate the Qt a11y elemen role into html element type + ARIA role.
     // Here we can either create <div> elements with a spesific ARIA role,
     // or create e.g. <button> elements which should have built-in accessibility.
-    emscripten::val element = [iface, document] {
+    emscripten::val element = [this, iface, document] {
 
         emscripten::val element = emscripten::val::undefined();
 
@@ -71,17 +154,134 @@ emscripten::val QWasmAccessibility::createHtmlElement(QAccessibleInterface *ifac
 
         case QAccessible::Button: {
             element = document.call<emscripten::val>("createElement", std::string("button"));
+            element.call<void>("addEventListener", emscripten::val("click"),
+                               emscripten::val::module_property("qtEventReceived"), true);
         } break;
-
         case QAccessible::CheckBox: {
             element = document.call<emscripten::val>("createElement", std::string("input"));
             element.call<void>("setAttribute", std::string("type"), std::string("checkbox"));
+            if (iface->state().checked) {
+                element.call<void>("setAttribute", std::string("checked"), std::string("true"));
+            }
+            element.call<void>("addEventListener", emscripten::val("change"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+
+        } break;
+
+        case QAccessible::RadioButton: {
+            element = document.call<emscripten::val>("createElement", std::string("input"));
+            element.call<void>("setAttribute", std::string("type"), std::string("radio"));
+            if (iface->state().checked) {
+                element.call<void>("setAttribute", std::string("checked"), std::string("true"));
+            }
+            element.set(std::string("name"), std::string("buttonGroup"));
+            element.call<void>("addEventListener", emscripten::val("change"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+        } break;
+
+        case QAccessible::SpinBox: {
+            element = document.call<emscripten::val>("createElement", std::string("input"));
+            element.call<void>("setAttribute", std::string("type"), std::string("number"));
+            std::string valueString = iface->valueInterface()->currentValue().toString().toStdString();
+            element.call<void>("setAttribute", std::string("value"), valueString);
+            element.call<void>("addEventListener", emscripten::val("change"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+        } break;
+
+        case QAccessible::Slider: {
+            element = document.call<emscripten::val>("createElement", std::string("input"));
+            element.call<void>("setAttribute", std::string("type"), std::string("range"));
+            std::string valueString = iface->valueInterface()->currentValue().toString().toStdString();
+            element.call<void>("setAttribute", std::string("value"), valueString);
+            element.call<void>("addEventListener", emscripten::val("change"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+        } break;
+
+        case QAccessible::PageTabList:{
+            element = document.call<emscripten::val>("createElement", std::string("div"));
+            element.call<void>("setAttribute", std::string("role"), std::string("tablist"));
+            QString idName = iface->text(QAccessible::Name).replace(" ", "_");
+            idName += "_tabList";
+            element.call<void>("setAttribute", std::string("id"), idName.toStdString());
+
+            for (int i = 0; i < iface->childCount();  ++i) {
+                if (iface->child(i)->role() == QAccessible::PageTab){
+                    emscripten::val elementTab = emscripten::val::undefined();
+                    elementTab = ensureHtmlElement(iface->child(i));
+                    elementTab.call<void>("setAttribute", std::string("aria-owns"), idName.toStdString());
+                    setHtmlElementGeometry(iface->child(i));
+                }
+            }
+        } break;
+
+        case QAccessible::PageTab:{
+            element =   document.call<emscripten::val>("createElement", std::string("button"));
+            element.call<void>("setAttribute", std::string("role"), std::string("tab"));
+            QString text = iface->text(QAccessible::Name);
+            element.call<void>("setAttribute", std::string("title"), text.toStdString());
+            element.call<void>("addEventListener", emscripten::val("click"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+        } break;
+
+        case QAccessible::ScrollBar: {
+            element = document.call<emscripten::val>("createElement", std::string("div"));
+            element.call<void>("setAttribute", std::string("role"), std::string("scrollbar"));
+            std::string valueString = iface->valueInterface()->currentValue().toString().toStdString();
+            element.call<void>("setAttribute", std::string("aria-valuenow"), valueString);
+            element.call<void>("addEventListener", emscripten::val("change"),
+                               emscripten::val::module_property("qtEventReceived"), true);
         } break;
 
+        case QAccessible::StaticText: {
+            element = document.call<emscripten::val>("createElement", std::string("textarea"));
+            element.call<void>("setAttribute", std::string("readonly"), std::string("true"));
+
+        } break;
+        case QAccessible::Dialog: {
+            element = document.call<emscripten::val>("createElement", std::string("dialog"));
+        }break;
+        case QAccessible::ToolBar:{
+            element = document.call<emscripten::val>("createElement", std::string("div"));
+            QString text = iface->text(QAccessible::Name);
+
+            element.call<void>("setAttribute", std::string("role"), std::string("toolbar"));
+            element.call<void>("setAttribute", std::string("title"), text.toStdString());
+            element.call<void>("addEventListener", emscripten::val("click"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+        }break;
+        case QAccessible::MenuItem:
+        case QAccessible::ButtonMenu: {
+            element = document.call<emscripten::val>("createElement", std::string("button"));
+            QString text = iface->text(QAccessible::Name);
+
+            element.call<void>("setAttribute", std::string("role"), std::string("menuitem"));
+            element.call<void>("setAttribute", std::string("title"), text.toStdString());
+            element.call<void>("addEventListener", emscripten::val("click"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+        }break;
+        case QAccessible::MenuBar:
+        case QAccessible::PopupMenu: {
+          element = document.call<emscripten::val>("createElement",std::string("div"));
+          QString text = iface->text(QAccessible::Name);
+          element.call<void>("setAttribute", std::string("role"), std::string("menubar"));
+          element.call<void>("setAttribute", std::string("title"), text.toStdString());
+          for (int i = 0; i < iface->childCount(); ++i) {
+                emscripten::val childElement = emscripten::val::undefined();
+                childElement= ensureHtmlElement(iface->child(i));
+                childElement.call<void>("setAttribute", std::string("aria-owns"), text.toStdString());
+                setHtmlElementTextName(iface->child(i));
+                setHtmlElementGeometry(iface->child(i));
+          }
+        }break;
+        case QAccessible::EditableText: {
+            element = document.call<emscripten::val>("createElement", std::string("input"));
+            element.call<void>("setAttribute", std::string("type"),std::string("text"));
+            element.call<void>("addEventListener", emscripten::val("input"),
+                               emscripten::val::module_property("qtEventReceived"), true);
+        } break;
         default:
-            qDebug() << "TODO: createHtmlElement() handle" << iface->role();
+            qCDebug(lcQpaAccessibility) << "TODO: createHtmlElement() handle" << iface->role();
             element = document.call<emscripten::val>("createElement", std::string("div"));
-            //element.set("AriaRole", "foo");
         }
 
         return element;
@@ -99,7 +299,7 @@ emscripten::val QWasmAccessibility::createHtmlElement(QAccessibleInterface *ifac
 void QWasmAccessibility::destroyHtmlElement(QAccessibleInterface *iface)
 {
     Q_UNUSED(iface);
-    qDebug() << "TODO destroyHtmlElement";
+    qCDebug(lcQpaAccessibility) << "TODO destroyHtmlElement";
 }
 
 emscripten::val QWasmAccessibility::ensureHtmlElement(QAccessibleInterface *iface)
@@ -120,7 +320,7 @@ void QWasmAccessibility::setHtmlElementVisibility(QAccessibleInterface *iface, b
     emscripten::val container = getContainer(iface);
 
     if (container.isUndefined()) {
-        qDebug() << "TODO: setHtmlElementVisibility: unable to find html container for element" << iface;
+        qCDebug(lcQpaAccessibility) << "TODO: setHtmlElementVisibility: unable to find html container for element" << iface;
         return;
     }
 
@@ -132,17 +332,27 @@ void QWasmAccessibility::setHtmlElementVisibility(QAccessibleInterface *iface, b
 void QWasmAccessibility::setHtmlElementGeometry(QAccessibleInterface *iface)
 {
     emscripten::val element = ensureHtmlElement(iface);
-    setHtmlElementGeometry(iface, element);
+
+    // QAccessibleInterface gives us the geometry in global (screen) coordinates. Translate that
+    // to window geometry in order to position elements relative to window origin.
+    QWindow *window = getWindow(iface);
+    if (!window)
+        qCWarning(lcQpaAccessibility) << "Unable to find window for" << iface << "setting null geometry";
+    QRect screenGeometry = iface->rect();
+    QPoint windowPos = window ? window->mapFromGlobal(screenGeometry.topLeft()) : QPoint();
+    QRect windowGeometry(windowPos, screenGeometry.size());
+
+    setHtmlElementGeometry(element, windowGeometry);
 }
 
-void QWasmAccessibility::setHtmlElementGeometry(QAccessibleInterface *iface, emscripten::val element)
+void QWasmAccessibility::setHtmlElementGeometry(emscripten::val element, QRect geometry)
 {
     // Position the element using "position: absolute" in order to place
-    // it under the corresponding Qt element on the canvas.
-    QRect geometry = iface->rect();
+    // it under the corresponding Qt element in the screen.
     emscripten::val style = element["style"];
     style.set("position", std::string("absolute"));
-    style.set("z-index", std::string("-1")); // FIXME: "0" should be sufficient to order beheind the canvas, but isn't
+    style.set("z-index", std::string("-1")); // FIXME: "0" should be sufficient to order beheind the
+                                             // screen element, but isn't
     style.set("left", std::to_string(geometry.x()) + "px");
     style.set("top", std::to_string(geometry.y()) + "px");
     style.set("width", std::to_string(geometry.width()) + "px");
@@ -156,37 +366,325 @@ void QWasmAccessibility::setHtmlElementTextName(QAccessibleInterface *iface)
     element.set("innerHTML", text.toStdString()); // FIXME: use something else than innerHTML
 }
 
+void QWasmAccessibility::setHtmlElementTextNameLE(QAccessibleInterface *iface) {
+    emscripten::val element = ensureHtmlElement(iface);
+    QString text = iface->text(QAccessible::Name);
+    element.call<void>("setAttribute", std::string("name"), text.toStdString());
+    QString value = iface->text(QAccessible::Value);
+    element.set("innerHTML", value.toStdString());
+}
+
+void QWasmAccessibility::setHtmlElementDescription(QAccessibleInterface *iface) {
+    emscripten::val element = ensureHtmlElement(iface);
+    QString desc = iface->text(QAccessible::Description);
+    element.call<void>("setAttribute", std::string("aria-description"), desc.toStdString());
+}
+
 void QWasmAccessibility::handleStaticTextUpdate(QAccessibleEvent *event)
 {
     switch (event->type()) {
     case QAccessible::NameChanged: {
         setHtmlElementTextName(event->accessibleInterface());
     } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
     default:
-        qDebug() << "TODO: implement handleStaticTextUpdate for event" << event->type();
+        qCDebug(lcQpaAccessibility) << "TODO: implement handleStaticTextUpdate for event" << event->type();
     break;
     }
 }
 
+void QWasmAccessibility::handleLineEditUpdate(QAccessibleEvent *event) {
+
+    switch (event->type()) {
+    case QAccessible::NameChanged: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::Focus:
+    case QAccessible::TextRemoved:
+    case QAccessible::TextInserted:
+    case QAccessible::TextCaretMoved: {
+        setHtmlElementTextNameLE(event->accessibleInterface());
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+        qCDebug(lcQpaAccessibility) << "TODO: implement handleLineEditUpdate for event" << event->type();
+        break;
+    }
+}
+
+void QWasmAccessibility::handleEventFromHtmlElement(const emscripten::val event)
+{
+
+    QAccessibleInterface *iface = m_elements.key(event["target"]);
+    if (iface == nullptr) {
+        return;
+    } else {
+        QString eventType = QString::fromStdString(event["type"].as<std::string>());
+        const auto& actionNames = QAccessibleBridgeUtils::effectiveActionNames(iface);
+        if (actionNames.contains(QAccessibleActionInterface::pressAction())) {
+
+            iface->actionInterface()->doAction(QAccessibleActionInterface::pressAction());
+
+        } else if (actionNames.contains(QAccessibleActionInterface::toggleAction())) {
+
+            iface->actionInterface()->doAction(QAccessibleActionInterface::toggleAction());
+
+        } else if (actionNames.contains(QAccessibleActionInterface::increaseAction()) ||
+                   actionNames.contains(QAccessibleActionInterface::decreaseAction())) {
+
+            QString val = QString::fromStdString(event["target"]["value"].as<std::string>());
+
+            iface->valueInterface()->setCurrentValue(val.toInt());
+
+        } else if (eventType == "input") {
+
+            // as EditableTextInterface is not implemented in qml accessibility
+            // so we need to check the role for text to update in the textbox during accessibility
+
+            if (iface->editableTextInterface() || iface->role() == QAccessible::EditableText) {
+                std::string insertText = event["target"]["value"].as<std::string>();
+                iface->setText(QAccessible::Value, QString::fromStdString(insertText));
+            }
+        }
+    }
+}
+
 void QWasmAccessibility::handleButtonUpdate(QAccessibleEvent *event)
 {
-    qDebug() << "TODO: implement handleButtonUpdate for event" << event->type();
+    qCDebug(lcQpaAccessibility) << "TODO: implement handleButtonUpdate for event" << event->type();
 }
 
 void QWasmAccessibility::handleCheckBoxUpdate(QAccessibleEvent *event)
 {
     switch (event->type()) {
+    case QAccessible::Focus:
+    case QAccessible::NameChanged: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::StateChanged: {
+        QAccessibleInterface *accessible = event->accessibleInterface();
+        emscripten::val element = ensureHtmlElement(accessible);
+        bool checkedString = accessible->state().checked ? true : false;
+        element.call<void>("setAttribute", std::string("checked"), checkedString);
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+        qCDebug(lcQpaAccessibility) << "TODO: implement handleCheckBoxUpdate for event" << event->type();
+    break;
+    }
+}
+void QWasmAccessibility::handleToolUpdate(QAccessibleEvent *event)
+{
+    QAccessibleInterface *iface = event->accessibleInterface();
+    QString text = iface->text(QAccessible::Name);
+    QString desc = iface->text(QAccessible::Description);
+    switch (event->type()) {
+    case QAccessible::NameChanged:
+    case QAccessible::StateChanged:{
+      emscripten::val element = ensureHtmlElement(iface);
+      element.call<void>("setAttribute", std::string("title"), text.toStdString());
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+      qCDebug(lcQpaAccessibility) << "TODO: implement handleToolUpdate for event" << event->type();
+      break;
+    }
+}
+void QWasmAccessibility::handleMenuUpdate(QAccessibleEvent *event)
+{
+    QAccessibleInterface *iface = event->accessibleInterface();
+    QString text = iface->text(QAccessible::Name);
+    QString desc = iface->text(QAccessible::Description);
+    switch (event->type()) {
+    case QAccessible::Focus:
+    case QAccessible::NameChanged:
+    case QAccessible::MenuStart  ://"TODO: To implement later
+    case QAccessible::PopupMenuStart://"TODO: To implement later
+    case QAccessible::StateChanged:{
+      emscripten::val element = ensureHtmlElement(iface);
+      element.call<void>("setAttribute", std::string("title"), text.toStdString());
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+      qCDebug(lcQpaAccessibility) << "TODO: implement handleMenuUpdate for event" << event->type();
+      break;
+    }
+}
+void QWasmAccessibility::handleDialogUpdate(QAccessibleEvent *event) {
+
+    switch (event->type()) {
+    case QAccessible::NameChanged:
+    case QAccessible::Focus:
+    case QAccessible::DialogStart:
+    case QAccessible::StateChanged: {
+      setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+      qCDebug(lcQpaAccessibility) << "TODO: implement handleLineEditUpdate for event" << event->type();
+      break;
+    }
+}
+
+void QWasmAccessibility::populateAccessibilityTree(QAccessibleInterface *iface)
+{
+    if (!iface)
+        return;
+
+    // Create html element for the interface, sync up properties.
+    ensureHtmlElement(iface);
+    const bool visible = !iface->state().invisible;
+    setHtmlElementVisibility(iface, visible);
+    setHtmlElementGeometry(iface);
+    setHtmlElementTextName(iface);
+    setHtmlElementDescription(iface);
+
+    for (int i = 0; i < iface->childCount(); ++i)
+        populateAccessibilityTree(iface->child(i));
+}
+
+void QWasmAccessibility::handleRadioButtonUpdate(QAccessibleEvent *event)
+{
+    switch (event->type()) {
+    case QAccessible::Focus:
+    case QAccessible::NameChanged: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::StateChanged: {
+        QAccessibleInterface *accessible = event->accessibleInterface();
+        emscripten::val element = ensureHtmlElement(accessible);
+        std::string checkedString = accessible->state().checked ? "true" : "false";
+        element.call<void>("setAttribute", std::string("checked"), checkedString);
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+        qDebug() << "TODO: implement handleRadioButtonUpdate for event" << event->type();
+    break;
+    }
+}
+
+void QWasmAccessibility::handleSpinBoxUpdate(QAccessibleEvent *event)
+{
+    switch (event->type()) {
+    case QAccessible::Focus:
+    case QAccessible::NameChanged: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::ValueChanged: {
+        QAccessibleInterface *accessible = event->accessibleInterface();
+        emscripten::val element = ensureHtmlElement(accessible);
+        std::string valueString = accessible->valueInterface()->currentValue().toString().toStdString();
+        element.call<void>("setAttribute", std::string("value"), valueString);
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+        qDebug() << "TODO: implement handleSpinBoxUpdate for event" << event->type();
+    break;
+    }
+}
+
+void QWasmAccessibility::handleSliderUpdate(QAccessibleEvent *event)
+{
+    switch (event->type()) {
+    case QAccessible::Focus:
+    case QAccessible::NameChanged: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::ValueChanged: {
+        QAccessibleInterface *accessible = event->accessibleInterface();
+        emscripten::val element = ensureHtmlElement(accessible);
+        std::string valueString = accessible->valueInterface()->currentValue().toString().toStdString();
+        element.call<void>("setAttribute", std::string("value"), valueString);
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+        qDebug() << "TODO: implement handleSliderUpdate for event" << event->type();
+    break;
+    }
+}
+
+void QWasmAccessibility::handleScrollBarUpdate(QAccessibleEvent *event)
+{
+    switch (event->type()) {
+    case QAccessible::Focus:
     case QAccessible::NameChanged: {
         setHtmlElementTextName(event->accessibleInterface());
     } break;
+    case QAccessible::ValueChanged: {
+        QAccessibleInterface *accessible = event->accessibleInterface();
+        emscripten::val element = ensureHtmlElement(accessible);
+        std::string valueString = accessible->valueInterface()->currentValue().toString().toStdString();
+        element.call<void>("setAttribute", std::string("aria-valuenow"), valueString);
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
     default:
-        qDebug() << "TODO: implement handleCheckBoxUpdate for event" << event->type();
+        qDebug() << "TODO: implement handleSliderUpdate for event" << event->type();
+    break;
+    }
+
+}
+
+void QWasmAccessibility::handlePageTabUpdate(QAccessibleEvent *event)
+{
+    switch (event->type()) {
+    case QAccessible::NameChanged: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::Focus: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+        qDebug() << "TODO: implement handlePageTabUpdate for event" << event->type();
+    break;
+    }
+}
+
+void QWasmAccessibility::handlePageTabListUpdate(QAccessibleEvent *event)
+{
+    switch (event->type()) {
+    case QAccessible::NameChanged: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::Focus: {
+        setHtmlElementTextName(event->accessibleInterface());
+    } break;
+    case QAccessible::DescriptionChanged: {
+        setHtmlElementDescription(event->accessibleInterface());
+    } break;
+    default:
+        qDebug() << "TODO: implement handlePageTabUpdate for event" << event->type();
     break;
     }
 }
 
 void QWasmAccessibility::notifyAccessibilityUpdate(QAccessibleEvent *event)
 {
+    if (!m_accessibilityEnabled)
+        return;
+
     QAccessibleInterface *iface = event->accessibleInterface();
     if (!iface) {
         qWarning() << "notifyAccessibilityUpdate with null a11y interface" ;
@@ -197,12 +695,12 @@ void QWasmAccessibility::notifyAccessibilityUpdate(QAccessibleEvent *event)
     // https://doc.qt.io/qt-5/qaccessible.html#Event-enum
     switch (event->type()) {
     case QAccessible::ObjectShow:
-
         setHtmlElementVisibility(iface, true);
 
         // Sync up properties on show;
         setHtmlElementGeometry(iface);
         setHtmlElementTextName(iface);
+        setHtmlElementDescription(iface);
 
         return;
     break;
@@ -227,16 +725,46 @@ void QWasmAccessibility::notifyAccessibilityUpdate(QAccessibleEvent *event)
     case QAccessible::CheckBox:
         handleCheckBoxUpdate(event);
     break;
+    case QAccessible::EditableText:
+        handleLineEditUpdate(event);
+    break;
+    case QAccessible::Dialog:
+        handleDialogUpdate(event);
+    break;
+    case QAccessible::MenuItem:
+    case QAccessible::MenuBar:
+    case QAccessible::PopupMenu:
+        handleMenuUpdate(event);
+    break;
+    case QAccessible::ToolBar:
+    case QAccessible::ButtonMenu:
+       handleToolUpdate(event);
+    case QAccessible::RadioButton:
+        handleRadioButtonUpdate(event);
+    break;
+    case QAccessible::SpinBox:
+        handleSpinBoxUpdate(event);
+    break;
+    case QAccessible::Slider:
+        handleSliderUpdate(event);
+    break;
+    case QAccessible::PageTab:
+        handlePageTabUpdate(event);
+    break;
+    case QAccessible::PageTabList:
+        handlePageTabListUpdate(event);
+    break;
+    case QAccessible::ScrollBar:
+        handleScrollBarUpdate(event);
+    break;
     default:
-        qDebug() << "TODO: implement notifyAccessibilityUpdate for role" << iface->role();
+        qCDebug(lcQpaAccessibility) << "TODO: implement notifyAccessibilityUpdate for role" << iface->role();
     };
 }
 
-void QWasmAccessibility::setRootObject(QObject *o)
+void QWasmAccessibility::setRootObject(QObject *root)
 {
-    qDebug() << "setRootObject" << o;
-    QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(o);
-    Q_UNUSED(iface)
+    m_rootObject = root;
 }
 
 void QWasmAccessibility::initialize()
@@ -248,3 +776,14 @@ void QWasmAccessibility::cleanup()
 {
 
 }
+
+void QWasmAccessibility::onHtmlEventReceived(emscripten::val event)
+{
+    static_cast<QWasmAccessibility *>(QWasmIntegration::get()->accessibility())->handleEventFromHtmlElement(event);
+}
+
+EMSCRIPTEN_BINDINGS(qtButtonEvent) {
+    function("qtEventReceived", &QWasmAccessibility::onHtmlEventReceived);
+}
+
+#endif // QT_CONFIG(accessibility)