Diff
Modified: trunk/Source/WebCore/ChangeLog (285996 => 285997)
--- trunk/Source/WebCore/ChangeLog 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/ChangeLog 2021-11-18 12:34:31 UTC (rev 285997)
@@ -1,3 +1,30 @@
+2021-10-26 Carlos Garcia Campos <[email protected]>
+
+ [GTK][a11y] Add implementation of value interface when building with ATSPI
+ https://bugs.webkit.org/show_bug.cgi?id=232300
+
+ Reviewed by Adrian Perez de Castro.
+
+ * SourcesGTK.txt:
+ * accessibility/atspi/AXObjectCacheAtspi.cpp:
+ (WebCore::AXObjectCache::postPlatformNotification):
+ * accessibility/atspi/AccessibilityAtspi.cpp:
+ (WebCore::AccessibilityAtspi::valueChanged):
+ * accessibility/atspi/AccessibilityAtspi.h:
+ * accessibility/atspi/AccessibilityObjectAtspi.cpp:
+ (WebCore::AccessibilityObjectAtspi::interfacesForObject):
+ (WebCore::AccessibilityObjectAtspi::path):
+ (WebCore::AccessibilityObjectAtspi::buildInterfaces const):
+ * accessibility/atspi/AccessibilityObjectAtspi.h:
+ * accessibility/atspi/AccessibilityObjectValueAtspi.cpp: Added.
+ (WebCore::AccessibilityObjectAtspi::currentValue const):
+ (WebCore::AccessibilityObjectAtspi::setCurrentValue):
+ (WebCore::AccessibilityObjectAtspi::minimumValue const):
+ (WebCore::AccessibilityObjectAtspi::maximumValue const):
+ (WebCore::AccessibilityObjectAtspi::minimumIncrement const):
+ (WebCore::AccessibilityObjectAtspi::valueChanged):
+ * accessibility/atspi/AccessibilityRootAtspi.cpp:
+
2021-10-25 Carlos Garcia Campos <[email protected]>
[GTK][a11y] Add initial WTR accessibility support when building with ATSPI
Modified: trunk/Source/WebCore/SourcesGTK.txt (285996 => 285997)
--- trunk/Source/WebCore/SourcesGTK.txt 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/SourcesGTK.txt 2021-11-18 12:34:31 UTC (rev 285997)
@@ -43,6 +43,7 @@
accessibility/atspi/AccessibilityObjectAtspi.cpp
accessibility/atspi/AccessibilityObjectComponentAtspi.cpp
accessibility/atspi/AccessibilityObjectTextAtspi.cpp
+accessibility/atspi/AccessibilityObjectValueAtspi.cpp
accessibility/atspi/AccessibilityRootAtspi.cpp
accessibility/atspi/AXObjectCacheAtspi.cpp
Modified: trunk/Source/WebCore/accessibility/atspi/AXObjectCacheAtspi.cpp (285996 => 285997)
--- trunk/Source/WebCore/accessibility/atspi/AXObjectCacheAtspi.cpp 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/accessibility/atspi/AXObjectCacheAtspi.cpp 2021-11-18 12:34:31 UTC (rev 285997)
@@ -86,6 +86,8 @@
case AXMenuListValueChanged:
break;
case AXValueChanged:
+ if (wrapper->interfaces().contains(AccessibilityObjectAtspi::Interface::Value))
+ wrapper->valueChanged(coreObject->valueForRange());
break;
case AXInvalidStatusChanged:
wrapper->stateChanged("invalid-entry", coreObject->invalidStatus() != "false");
Modified: trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.cpp (285996 => 285997)
--- trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.cpp 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.cpp 2021-11-18 12:34:31 UTC (rev 285997)
@@ -220,6 +220,18 @@
});
}
+void AccessibilityAtspi::valueChanged(AccessibilityObjectAtspi& atspiObject, double value)
+{
+ RELEASE_ASSERT(isMainThread());
+ m_queue->dispatch([this, atspiObject = Ref { atspiObject }, value] {
+ if (!m_connection)
+ return;
+
+ g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject->path().utf8().data(), "org.a11y.atspi.Event.Object", "PropertyChange",
+ g_variant_new("(siiva{sv})", "accessible-value", 0, 0, g_variant_new_double(value), nullptr), nullptr);
+ });
+}
+
struct RoleNameEntry {
const char* name;
const char* localizedName;
Modified: trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.h (285996 => 285997)
--- trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.h 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/accessibility/atspi/AccessibilityAtspi.h 2021-11-18 12:34:31 UTC (rev 285997)
@@ -63,6 +63,8 @@
void textCaretMoved(AccessibilityObjectAtspi&, unsigned);
void textSelectionChanged(AccessibilityObjectAtspi&);
+ void valueChanged(AccessibilityObjectAtspi&, double);
+
static const char* localizedRoleName(AccessibilityRole);
private:
Modified: trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp (285996 => 285997)
--- trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.cpp 2021-11-18 12:34:31 UTC (rev 285997)
@@ -83,6 +83,9 @@
}
}
+ if (coreObject.supportsRangeValue())
+ interfaces.add(Interface::Value);
+
return interfaces;
}
@@ -469,6 +472,8 @@
interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_component_interface), &s_componentFunctions });
if (m_interfaces.contains(Interface::Text))
interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_text_interface), &s_textFunctions });
+ if (m_interfaces.contains(Interface::Value))
+ interfaces.append({ const_cast<GDBusInterfaceInfo*>(&webkit_value_interface), &s_valueFunctions });
m_path = atspiRoot->atspi().registerObject(*this, WTFMove(interfaces));
}
@@ -1084,6 +1089,8 @@
g_variant_builder_add(builder, "s", webkit_component_interface.name);
if (m_interfaces.contains(Interface::Text))
g_variant_builder_add(builder, "s", webkit_text_interface.name);
+ if (m_interfaces.contains(Interface::Value))
+ g_variant_builder_add(builder, "s", webkit_value_interface.name);
}
void AccessibilityObjectAtspi::serialize(GVariantBuilder* builder) const
Modified: trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h (285996 => 285997)
--- trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectAtspi.h 2021-11-18 12:34:31 UTC (rev 285997)
@@ -45,7 +45,8 @@
enum class Interface : uint8_t {
Accessible = 1 << 0,
Component = 1 << 1,
- Text = 1 << 2
+ Text = 1 << 2,
+ Value = 1 << 3
};
const OptionSet<Interface>& interfaces() const { return m_interfaces; }
@@ -109,6 +110,13 @@
void textAttributesChanged();
void selectionChanged(const VisibleSelection&);
+ WEBCORE_EXPORT double currentValue() const;
+ WEBCORE_EXPORT bool setCurrentValue(double);
+ WEBCORE_EXPORT double minimumValue() const;
+ WEBCORE_EXPORT double maximumValue() const;
+ WEBCORE_EXPORT double minimumIncrement() const;
+ void valueChanged(double);
+
private:
explicit AccessibilityObjectAtspi(AXCoreObject*);
@@ -145,6 +153,7 @@
static GDBusInterfaceVTable s_accessibleFunctions;
static GDBusInterfaceVTable s_componentFunctions;
static GDBusInterfaceVTable s_textFunctions;
+ static GDBusInterfaceVTable s_valueFunctions;
AXCoreObject* m_axObject { nullptr };
AXCoreObject* m_coreObject { nullptr };
Added: trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectValueAtspi.cpp (0 => 285997)
--- trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectValueAtspi.cpp (rev 0)
+++ trunk/Source/WebCore/accessibility/atspi/AccessibilityObjectValueAtspi.cpp 2021-11-18 12:34:31 UTC (rev 285997)
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2021 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "AccessibilityObjectAtspi.h"
+
+#if ENABLE(ACCESSIBILITY) && USE(ATSPI)
+
+#include "AccessibilityObject.h"
+#include "AccessibilityRootAtspi.h"
+#include <gio/gio.h>
+
+namespace WebCore {
+
+GDBusInterfaceVTable AccessibilityObjectAtspi::s_valueFunctions = {
+ // method_call
+ nullptr,
+ // get_property
+ [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar* propertyName, GError** error, gpointer userData) -> GVariant* {
+ RELEASE_ASSERT(!isMainThread());
+ auto atspiObject = Ref { *static_cast<AccessibilityObjectAtspi*>(userData) };
+ atspiObject->updateBackingStore();
+
+ if (!g_strcmp0(propertyName, "CurrentValue"))
+ return g_variant_new_double(atspiObject->currentValue());
+ if (!g_strcmp0(propertyName, "MinimumValue"))
+ return g_variant_new_double(atspiObject->minimumValue());
+ if (!g_strcmp0(propertyName, "MaximumValue"))
+ return g_variant_new_double(atspiObject->maximumValue());
+ if (!g_strcmp0(propertyName, "MinimumIncrement"))
+ return g_variant_new_double(atspiObject->minimumIncrement());
+
+ g_set_error(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Unknown property '%s'", propertyName);
+ return nullptr;
+ },
+ // set_property,
+ [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar* propertyName, GVariant* propertyValue, GError** error, gpointer userData) -> gboolean {
+ RELEASE_ASSERT(!isMainThread());
+ auto atspiObject = Ref { *static_cast<AccessibilityObjectAtspi*>(userData) };
+ atspiObject->updateBackingStore();
+
+ if (!g_strcmp0(propertyName, "CurrentValue"))
+ return atspiObject->setCurrentValue(g_variant_get_double(propertyValue));
+
+ g_set_error(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Unknown property '%s'", propertyName);
+ return FALSE;
+ },
+ // padding
+ nullptr
+};
+
+double AccessibilityObjectAtspi::currentValue() const
+{
+ RELEASE_ASSERT(!isMainThread());
+ if (!m_axObject)
+ return 0;
+
+ return m_axObject->valueForRange();
+}
+
+bool AccessibilityObjectAtspi::setCurrentValue(double value)
+{
+ return Accessibility::retrieveValueFromMainThread<bool>([this, value]() -> bool {
+ if (m_coreObject)
+ m_coreObject->updateBackingStore();
+
+ if (!m_coreObject)
+ return false;
+
+ if (!m_coreObject->canSetValueAttribute())
+ return false;
+
+ if (m_coreObject->canSetNumericValue())
+ return m_coreObject->setValue(value);
+
+ return m_coreObject->setValue(String::numberToStringFixedPrecision(value));
+ });
+}
+
+double AccessibilityObjectAtspi::minimumValue() const
+{
+ RELEASE_ASSERT(!isMainThread());
+ if (!m_axObject)
+ return 0;
+
+ return m_axObject->minValueForRange();
+}
+
+double AccessibilityObjectAtspi::maximumValue() const
+{
+ RELEASE_ASSERT(!isMainThread());
+ if (!m_axObject)
+ return 0;
+
+ return m_axObject->maxValueForRange();
+}
+
+double AccessibilityObjectAtspi::minimumIncrement() const
+{
+ return Accessibility::retrieveValueFromMainThread<float>([this]() -> float {
+ if (m_coreObject)
+ m_coreObject->updateBackingStore();
+
+ if (!m_coreObject)
+ return 0;
+
+ auto stepAttribute = static_cast<AccessibilityObject*>(m_coreObject)->getAttribute(HTMLNames::stepAttr);
+ if (!stepAttribute.isEmpty())
+ return stepAttribute.toFloat();
+
+ // If 'step' attribute is not defined, WebCore assumes a 5% of the range between
+ // minimum and maximum values. Implicit value of step should be one or larger.
+ float step = (m_coreObject->maxValueForRange() - m_coreObject->minValueForRange()) * 0.05;
+ return step < 1 ? 1 : step;
+ });
+}
+
+void AccessibilityObjectAtspi::valueChanged(double value)
+{
+ RELEASE_ASSERT(isMainThread());
+ if (!m_isRegistered.load())
+ return;
+
+ root()->atspi().valueChanged(*this, value);
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(ACCESSIBILITY) && USE(ATSPI)
Modified: trunk/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp (285996 => 285997)
--- trunk/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Source/WebCore/accessibility/atspi/AccessibilityRootAtspi.cpp 2021-11-18 12:34:31 UTC (rev 285997)
@@ -27,6 +27,7 @@
#include "Document.h"
#include "FocusController.h"
#include "Frame.h"
+#include "FrameView.h"
#include "Page.h"
#include <glib/gi18n-lib.h>
#include <wtf/MainThread.h>
Modified: trunk/Tools/ChangeLog (285996 => 285997)
--- trunk/Tools/ChangeLog 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Tools/ChangeLog 2021-11-18 12:34:31 UTC (rev 285997)
@@ -1,3 +1,24 @@
+2021-10-26 Carlos Garcia Campos <[email protected]>
+
+ [GTK][a11y] Add implementation of value interface when building with ATSPI
+ https://bugs.webkit.org/show_bug.cgi?id=232300
+
+ Reviewed by Adrian Perez de Castro.
+
+ Add new unit test for the value interface and implement WTR value support.
+
+ * TestWebKitAPI/Tests/WebKitGtk/TestWebKitAccessibility.cpp:
+ (testValueBasic):
+ (beforeAll):
+ * WebKitTestRunner/InjectedBundle/atspi/AccessibilityUIElementAtspi.cpp:
+ (WTR::AccessibilityUIElement::isAttributeSettable):
+ (WTR::AccessibilityUIElement::intValue const):
+ (WTR::AccessibilityUIElement::minValue):
+ (WTR::AccessibilityUIElement::maxValue):
+ (WTR::AccessibilityUIElement::valueDescription):
+ (WTR::AccessibilityUIElement::increment):
+ (WTR::AccessibilityUIElement::decrement):
+
2021-10-25 Carlos Garcia Campos <[email protected]>
[GTK][a11y] Add initial WTR accessibility support when building with ATSPI
Modified: trunk/Tools/TestWebKitAPI/Tests/WebKitGtk/TestWebKitAccessibility.cpp (285996 => 285997)
--- trunk/Tools/TestWebKitAPI/Tests/WebKitGtk/TestWebKitAccessibility.cpp 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Tools/TestWebKitAPI/Tests/WebKitGtk/TestWebKitAccessibility.cpp 2021-11-18 12:34:31 UTC (rev 285997)
@@ -1614,6 +1614,57 @@
#endif
}
+static void testValueBasic(AccessibilityTest* test, gconstpointer)
+{
+ test->showInWindow(800, 600);
+ test->loadHtml(
+ "<html>"
+ " <body>"
+ " <input type='range' min='0' max='100' value='50' step='25'/>"
+ " </body>"
+ "</html>",
+ nullptr);
+ test->waitUntilLoadFinished();
+
+ auto testApp = test->findTestApplication();
+ g_assert_true(ATSPI_IS_ACCESSIBLE(testApp.get()));
+
+ auto documentWeb = test->findDocumentWeb(testApp.get());
+ g_assert_true(ATSPI_IS_ACCESSIBLE(documentWeb.get()));
+ g_assert_cmpint(atspi_accessible_get_child_count(documentWeb.get(), nullptr), ==, 1);
+
+ auto panel = adoptGRef(atspi_accessible_get_child_at_index(documentWeb.get(), 0, nullptr));
+ g_assert_true(ATSPI_IS_ACCESSIBLE(panel.get()));
+ g_assert_cmpint(atspi_accessible_get_role(panel.get(), nullptr), ==, ATSPI_ROLE_PANEL);
+
+ auto slider = adoptGRef(atspi_accessible_get_child_at_index(panel.get(), 0, nullptr));
+ g_assert_true(ATSPI_IS_VALUE(slider.get()));
+ g_assert_cmpfloat(atspi_value_get_current_value(ATSPI_VALUE(slider.get()), nullptr), ==, 50);
+ g_assert_cmpfloat(atspi_value_get_minimum_value(ATSPI_VALUE(slider.get()), nullptr), ==, 0);
+ g_assert_cmpfloat(atspi_value_get_maximum_value(ATSPI_VALUE(slider.get()), nullptr), ==, 100);
+ g_assert_cmpfloat(atspi_value_get_minimum_increment(ATSPI_VALUE(slider.get()), nullptr), ==, 25);
+
+ test->startEventMonitor(slider.get(), { "object:property-change:accessible-value" });
+ g_assert_true(atspi_value_set_current_value(ATSPI_VALUE(slider.get()), 75, nullptr));
+ auto events = test->stopEventMonitor(1);
+ g_assert_cmpuint(events.size(), ==, 1);
+ g_assert_cmpstr(events[0]->type, ==, "object:property-change:accessible-value");
+ g_assert_cmpfloat(atspi_value_get_current_value(ATSPI_VALUE(slider.get()), nullptr), ==, 75);
+
+ test->startEventMonitor(slider.get(), { "object:property-change:accessible-value" });
+ g_assert_true(atspi_value_set_current_value(ATSPI_VALUE(slider.get()), 125, nullptr));
+ events = test->stopEventMonitor(1);
+ g_assert_cmpuint(events.size(), ==, 1);
+ g_assert_cmpstr(events[0]->type, ==, "object:property-change:accessible-value");
+ g_assert_cmpfloat(atspi_value_get_current_value(ATSPI_VALUE(slider.get()), nullptr), ==, 100);
+ test->startEventMonitor(slider.get(), { "object:property-change:accessible-value" });
+ g_assert_true(atspi_value_set_current_value(ATSPI_VALUE(slider.get()), -25, nullptr));
+ events = test->stopEventMonitor(1);
+ g_assert_cmpuint(events.size(), ==, 1);
+ g_assert_cmpstr(events[0]->type, ==, "object:property-change:accessible-value");
+ g_assert_cmpfloat(atspi_value_get_current_value(ATSPI_VALUE(slider.get()), nullptr), ==, 0);
+}
+
void beforeAll()
{
AccessibilityTest::add("WebKitAccessibility", "accessible/basic-hierarchy", testAccessibleBasicHierarchy);
@@ -1634,6 +1685,7 @@
AccessibilityTest::add("WebKitAccessibility", "text/attributes", testTextAttributes);
AccessibilityTest::add("WebKitAccessibility", "text/state-changed", testTextStateChanged);
AccessibilityTest::add("WebKitAccessibility", "text/replaced-objects", testTextReplacedObjects);
+ AccessibilityTest::add("WebKitAccessibility", "value/basic", testValueBasic);
}
void afterAll()
Modified: trunk/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityUIElementAtspi.cpp (285996 => 285997)
--- trunk/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityUIElementAtspi.cpp 2021-11-18 11:46:10 UTC (rev 285996)
+++ trunk/Tools/WebKitTestRunner/InjectedBundle/atspi/AccessibilityUIElementAtspi.cpp 2021-11-18 12:34:31 UTC (rev 285997)
@@ -383,6 +383,31 @@
bool AccessibilityUIElement::isAttributeSettable(JSStringRef attribute)
{
+ String attributeName = toWTFString(attribute);
+ if (attributeName != "AXValue")
+ return false;
+
+ if (checkElementState(m_element.get(), WebCore::Atspi::State::ReadOnly))
+ return false;
+
+ if (checkElementState(m_element.get(), WebCore::Atspi::State::Editable))
+ return true;
+
+ if (checkElementState(m_element.get(), WebCore::Atspi::State::Checkable))
+ return true;
+
+ if (m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Value)
+ && checkElementState(m_element.get(), WebCore::Atspi::State::Focusable)) {
+ double minimumValue, maximumValue;
+ s_controller->executeOnAXThreadAndWait([this, &minimumValue, &maximumValue] {
+ m_element->updateBackingStore();
+ minimumValue = m_element->minimumValue();
+ maximumValue = m_element->maximumValue();
+ });
+ if (minimumValue != maximumValue)
+ return true;
+ }
+
return false;
}
@@ -717,22 +742,48 @@
double AccessibilityUIElement::intValue() const
{
- return 0;
+ if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Value))
+ return 0;
+
+ double currentValue;
+ s_controller->executeOnAXThreadAndWait([this, ¤tValue] {
+ m_element->updateBackingStore();
+ currentValue = m_element->currentValue();
+ });
+ return currentValue;
}
double AccessibilityUIElement::minValue()
{
- return 0;
+ if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Value))
+ return 0;
+
+ double minimumValue;
+ s_controller->executeOnAXThreadAndWait([this, &minimumValue] {
+ m_element->updateBackingStore();
+ minimumValue = m_element->minimumValue();
+ });
+ return minimumValue;
}
double AccessibilityUIElement::maxValue()
{
- return 0;
+ if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Value))
+ return 0;
+
+ double maximumValue;
+ s_controller->executeOnAXThreadAndWait([this, &maximumValue] {
+ m_element->updateBackingStore();
+ maximumValue = m_element->maximumValue();
+ });
+ return maximumValue;
}
JSRetainPtr<JSStringRef> AccessibilityUIElement::valueDescription()
{
- return JSStringCreateWithCharacters(0, 0);
+ auto attributes = m_element->attributes();
+ auto value = makeString("AXValueDescription: ", attributes.get("valuetext"));
+ return OpaqueJSString::tryCreate(value).leakRef();
}
int AccessibilityUIElement::insertionPointLineNumber()
@@ -1022,10 +1073,18 @@
void AccessibilityUIElement::increment()
{
+ if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Value))
+ return;
+
+ m_element->setCurrentValue(intValue() + m_element->minimumIncrement());
}
void AccessibilityUIElement::decrement()
{
+ if (!m_element->interfaces().contains(WebCore::AccessibilityObjectAtspi::Interface::Value))
+ return;
+
+ m_element->setCurrentValue(intValue() - m_element->minimumIncrement());
}
void AccessibilityUIElement::showMenu()
