basalt-win32 0.0.0-rc5 → 0.1.0

package/native/CMakeLists.txt

@@ -159,24 +159,33 @@ add_library(basalt_win32_view STATIC
   # why this is in the view target rather than beside the demo: it is what the
   # rendering assertions in tests/test_win32_paint.cpp are built on.
   win32/Win32Snapshot.cpp
+  # The cursors Windows has no stock art for -- six CSS keywords drawn here as
+  # DIBs. Header-only until they were drawn; see Win32Cursors.h.
+  win32/Win32Cursors.cpp
   # Where a hidden title bar's pieces are -- the caption buttons and the drag
   # regions. Pure geometry over the view tree, so it is tested here with no
   # window and no React Native.
   win32/Win32TitleBarLayout.cpp)
 target_compile_options(basalt_win32_view PRIVATE ${BASALT_WIN32_WARNINGS})
 target_include_directories(basalt_win32_view PUBLIC win32)
-# core/FocusRing.h and core/Backface.h, and nothing else from there. Both are
-# header-only and have no React Native in them, so taking them does not make
-# this target depend on the half that does -- and the alternative is a focus
-# ring that is a different blue on each desktop, and three toolkits each with
-# their own idea of which way a rotated card is facing.
+# The header-only part of core, and only that: FocusRing.h, Backface.h,
+# ImageAnimation.h and ShadowShape.h so far. None of them has React Native in
+# it, so taking them does not make this target depend on the half that does --
+# and the alternative is a focus ring that is a different blue on each desktop,
+# three toolkits each with their own idea of which way a rotated card is facing,
+# a GIF paced differently on each, and a hand-rolled copy of CSS's shadow-corner
+# cubic per platform.
 #
 # Header-only is the constraint, not a preference: this library links no core,
 # so anything it takes from there has to be `inline`.
 target_include_directories(basalt_win32_view PUBLIC
     ${CMAKE_CURRENT_SOURCE_DIR}/../../basalt-core/native/core)
+# dxguid is for the effect CLSIDs, and it is the kind of thing that only a
+# linker tells you: `CLSID_D2D1Shadow` and its siblings are `DEFINE_GUID`
+# declarations in d2d1effects.h, so the symbols live in that library rather
+# than in d2d1. Without it a text shadow compiles and fails to link.
 target_link_libraries(basalt_win32_view PUBLIC
-  d2d1 dwrite windowscodecs uiautomationcore ole32 oleaut32 user32 shcore)
+  d2d1 dwrite windowscodecs uiautomationcore ole32 oleaut32 user32 shcore dxguid)
 
 add_executable(demo_layout_win32 win32/demo_layout_win32.cpp)
 target_compile_options(demo_layout_win32 PRIVATE ${BASALT_WIN32_WARNINGS})
@@ -343,6 +352,14 @@ if(TARGET basalt_core)
     # This host is still the only one that can check the table, and the
     # Windows CI shards, which do have React Native, still do.
     tests/test_win32_key_events.cpp
+    # Selecting text with a pointer, here for the same reason and found the
+    # same way: it drives a Win32TouchDispatcher and asserts against
+    # core/TextSelection.h, both of which speak React Native, and it sat in
+    # the unconditional set above from the day it was written. The MSBuild job
+    # is the only build without a React Native, so it failed there and nowhere
+    # else -- the second time this file has learnt that, which is why the
+    # rule is now in the comment above rather than in a commit message.
+    tests/test_win32_selection.cpp
     win32/Win32KeyEvents.cpp
     # A package's own tests; see the AppKit package for why they sit with core's.
     ${BASALT_PACKAGE_TESTS}
@@ -353,6 +370,11 @@ if(TARGET basalt_core)
     # The image loader: the cache, the failure paths, and the two lifetimes.
     # In the RN-dependent set because the fetch is core/ImageBytes.cpp.
     tests/test_win32_imageloader.cpp
+    # Animated GIFs: the frames WIC decodes and the pacing core shares. Here
+    # for the same reason as the loader's own tests -- the fixtures are `data:`
+    # URIs, read by core/ImageBytes.cpp -- even though most of the file is the
+    # view layer's.
+    tests/test_win32_animated_image.cpp
     # The touch state machine and the gesture handover, asking what
     # tests/test_appkit_input.mm asks of AppKit.
     tests/test_win32_input.cpp
@@ -383,6 +405,15 @@ endif()
 # needs onScroll and scroll state, and <TextInput>, which needs an EDIT peer.
 # ---------------------------------------------------------------------------
 
+# Without React Native there is no basalt_core to link, and the harness calls
+# `basalt::installCrashHandler` whatever it is linked against -- so this build
+# compiles that one file itself. The MSBuild job in release.yml is the only
+# build that gets here, which is why the link error it answered with was
+# invisible to every CI run.
+if(NOT TARGET basalt_core)
+  list(APPEND BASALT_WIN32_TEST_SOURCES ${BASALT_CRASH_HANDLER})
+endif()
+
 add_executable(basalt_win32_tests ${BASALT_WIN32_TEST_SOURCES})
 target_compile_options(basalt_win32_tests PRIVATE ${BASALT_WIN32_WARNINGS})
 target_include_directories(basalt_win32_tests PRIVATE ${BASALT_TEST_INCLUDE})

package/native/tests/test_win32_accessibility.cpp

@@ -14,6 +14,7 @@
 #include "TestHarness.h"
 
 #include "RnWin32Accessible.h"
+#include "RnWin32TextLayout.h"
 #include "RnWin32View.h"
 // For narrow(): UIA answers in BSTRs and these assertions are written in UTF-8,
 // like the rest of the project.
@@ -36,6 +37,8 @@
 using Microsoft::WRL::ComPtr;
 using basalt::win32::RnAccessibleFlag;
 using basalt::win32::RnAccessibleInfo;
+using basalt::win32::RnTextStyle;
+using basalt::win32::RnWin32TextLayout;
 using basalt::win32::RnWin32View;
 
 namespace {
@@ -269,3 +272,314 @@ TEST(accessibility_role_can_change_after_mount) {
   asCheckbox.Attach(view->createAccessibleProvider());
   EXPECT_EQ(controlTypeOf(asCheckbox), static_cast<long>(UIA_CheckBoxControlTypeId));
 }
+
+// `testID`, which UIA calls the automation id: the property every Windows test
+// runner looks a control up by, and the same idea as AppKit's
+// `accessibilityIdentifier` and GTK's accessible id.
+TEST(accessibility_a_test_id_becomes_the_automation_id) {
+  RnAccessibleInfo info = withRole("button");
+  info.label = "Save";
+  info.testId = "save-button";
+
+  auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(stringProperty(provider, UIA_AutomationIdPropertyId), std::string("save-button"));
+  // Not the name: a runner searching by automation id and a screen reader
+  // reading the label are different questions, and `testID` answers only one.
+  EXPECT_EQ(stringProperty(provider, UIA_NamePropertyId), std::string("Save"));
+
+  auto view = std::make_unique<RnWin32View>(4);
+  view->setFrame(0, 0, 100, 40);
+  view->setAccessibleInfo(info);
+  EXPECT_EQ(view->describeTree(),
+            std::string("view tag=4 frame=(0,0 100x40) role=button testid=save-button\n"));
+}
+
+// And a view with no testID leaves the property unset rather than empty: a
+// runner searching for "" would otherwise match the first control it saw.
+TEST(accessibility_no_test_id_leaves_the_automation_id_unset) {
+  auto provider = providerFor(withRole("button"));
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(propertyType(provider, UIA_AutomationIdPropertyId), VT_EMPTY);
+}
+
+// `accessibilityViewIsModal`, which UIA calls a dialog: a client that honours
+// `IsDialog` stops offering what is behind the element.
+TEST(accessibility_a_modal_view_is_a_dialog) {
+  RnAccessibleInfo info = withRole("button");
+  info.label = "Save";
+  info.modal = true;
+
+  auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(propertyType(provider, UIA_IsDialogPropertyId), VT_BOOL);
+  EXPECT(boolProperty(provider, UIA_IsDialogPropertyId));
+
+  auto view = std::make_unique<RnWin32View>(5);
+  view->setFrame(0, 0, 100, 40);
+  view->setAccessibleInfo(info);
+  EXPECT_EQ(view->describeTree(),
+            std::string("view tag=5 frame=(0,0 100x40) role=button modal\n"));
+}
+
+// Unset rather than false: "this is not a dialog" is a claim, and the other two
+// hosts stay quiet about it too.
+TEST(accessibility_a_plain_view_claims_no_dialog) {
+  auto provider = providerFor(withRole("button"));
+  EXPECT(provider != nullptr);
+  EXPECT_EQ(propertyType(provider, UIA_IsDialogPropertyId), VT_EMPTY);
+}
+
+// ---------------------------------------------------------------------------
+// `accessibilityLabelledBy`, which is the one accessibility prop that is a
+// relation between two views rather than a value on one.
+//
+// A relation rather than a copied string: the field's name lives on the caption
+// beside it, so a caption that changes its text does not leave a stale copy
+// behind. GTK sets an AT-SPI LABELLED_BY relation, macOS an
+// `accessibilityTitleUIElement`, and UIA answers `UIA_LabeledByPropertyId` with
+// an element -- which is why these go through a view rather than through a bare
+// `RnAccessibleInfo`: the view is what knows the other view.
+// ---------------------------------------------------------------------------
+
+TEST(accessibility_labelled_by_answers_with_the_labelling_element) {
+  auto field = std::make_unique<RnWin32View>(1);
+  auto caption = std::make_unique<RnWin32View>(2);
+
+  // A field with no label of its own, which is the whole point of the relation:
+  // its name is the caption's. `role` has to be something, though -- "none" is
+  // presentational and has no provider at all, which is the right behaviour and
+  // what the first version of this test tripped over.
+  RnAccessibleInfo fieldInfo;
+  fieldInfo.role = "textbox";
+  fieldInfo.testId = "field";
+  field->setAccessibleInfo(fieldInfo);
+
+  RnAccessibleInfo captionInfo;
+  captionInfo.role = "text";
+  captionInfo.label = "Save the document";
+  caption->setAccessibleInfo(captionInfo);
+
+  // Nothing yet: a view with no relation answers with no element rather than
+  // with itself.
+  ComPtr<IRawElementProviderSimple> before;
+  before.Attach(field->createAccessibleProvider());
+  EXPECT(before != nullptr);
+  if (before) {
+    EXPECT_EQ(propertyType(before, UIA_LabeledByPropertyId), VT_EMPTY);
+  }
+
+  field->setLabelledBy({caption.get()});
+
+  ComPtr<IRawElementProviderSimple> provider;
+  provider.Attach(field->createAccessibleProvider());
+  EXPECT(provider != nullptr);
+  if (!provider) {
+    return;
+  }
+
+  VARIANT value;
+  VariantInit(&value);
+  EXPECT(SUCCEEDED(provider->GetPropertyValue(UIA_LabeledByPropertyId, &value)));
+  EXPECT_EQ(value.vt, VT_UNKNOWN);
+  if (value.vt == VT_UNKNOWN && value.punkVal != nullptr) {
+    // The element is a provider, and what it is for is reading the caption's
+    // name: a relation pointing at the wrong view is the failure that matters.
+    ComPtr<IRawElementProviderSimple> label;
+    EXPECT(SUCCEEDED(value.punkVal->QueryInterface(IID_PPV_ARGS(label.GetAddressOf()))));
+    EXPECT_EQ(stringProperty(label, UIA_NamePropertyId), std::string("Save the document"));
+  }
+  VariantClear(&value);
+}
+
+// The relation comes apart again, which is what a caption being unmounted means
+// and what a stale element would get wrong.
+TEST(accessibility_labelled_by_can_be_taken_away) {
+  auto field = std::make_unique<RnWin32View>(1);
+  auto caption = std::make_unique<RnWin32View>(2);
+  RnAccessibleInfo info;
+  info.label = "Name";
+  field->setAccessibleInfo(info);
+  caption->setAccessibleInfo(info);
+
+  field->setLabelledBy({caption.get()});
+  field->setLabelledBy({});
+
+  ComPtr<IRawElementProviderSimple> provider;
+  provider.Attach(field->createAccessibleProvider());
+  EXPECT(provider != nullptr);
+  if (provider) {
+    EXPECT_EQ(propertyType(provider, UIA_LabeledByPropertyId), VT_EMPTY);
+  }
+}
+
+// The resolved relation in the dump, by tag, which is what the end-to-end
+// scenario reads on all three hosts.
+TEST(accessibility_labelled_by_is_reported_in_the_tree) {
+  auto field = std::make_unique<RnWin32View>(7);
+  auto caption = std::make_unique<RnWin32View>(9);
+  EXPECT(field->describeTree().find("labelled-by=") == std::string::npos);
+
+  field->setLabelledBy({caption.get()});
+  EXPECT(field->describeTree().find("labelled-by=9") != std::string::npos);
+}
+
+// ---------------------------------------------------------------------------
+// `accessibilityLiveRegion`: the text a status message says, and saying it.
+//
+// The change detection is `core/LiveRegions.h`'s and has its own tests there;
+// what is this host's is collecting the text and raising the announcement. UIA
+// has no "say this" except `UiaRaiseNotificationEvent`, and nothing in a test
+// run is listening to it, so what is asserted here is the text -- which is the
+// half that was wrong on both other hosts first.
+// ---------------------------------------------------------------------------
+
+TEST(accessibility_a_live_region_collects_the_text_of_its_subtree) {
+  auto region = std::make_unique<RnWin32View>(1);
+  auto first = std::make_unique<RnWin32View>(2);
+  auto second = std::make_unique<RnWin32View>(3);
+  RnTextStyle style;
+  first->setTextLayout(RnWin32TextLayout::create("Saving", style, 0));
+  second->setTextLayout(RnWin32TextLayout::create("one of three", style, 0));
+  region->insertChild(first.get(), 0);
+  region->insertChild(second.get(), 1);
+
+  // In paint order, joined with a space: a status line is a <View> with text
+  // inside it, and the view itself carries no string at all. Both other hosts
+  // collect it the same way.
+  EXPECT_EQ(region->collectText(), std::string("Saving one of three"));
+
+  // A view with nothing in it says nothing, rather than a stray space.
+  auto empty = std::make_unique<RnWin32View>(4);
+  EXPECT(empty->collectText().empty());
+
+  region->removeChild(first.get());
+  region->removeChild(second.get());
+}
+
+TEST(accessibility_an_announcement_is_remembered_and_an_empty_one_is_not_made) {
+  auto view = std::make_unique<RnWin32View>(1);
+  RnAccessibleInfo info;
+  info.role = "text";
+  info.label = "Saved";
+  view->setAccessibleInfo(info);
+
+  EXPECT(view->lastAnnouncement().empty());
+
+  view->announce("Saved", false);
+  EXPECT_EQ(view->lastAnnouncement(), std::string("Saved"));
+
+  // Nothing to say is not an announcement: a region whose text went empty must
+  // not read out silence, and `UiaRaiseNotificationEvent` with an empty string
+  // is a notification a screen reader still reports as one.
+  view->announce("", true);
+  EXPECT_EQ(view->lastAnnouncement(), std::string("Saved"));
+
+  view->announce("Saved twice", true);
+  EXPECT_EQ(view->lastAnnouncement(), std::string("Saved twice"));
+}
+
+// ---------------------------------------------------------------------------
+// `accessibilityValue`: a range, a position in it, and a text form.
+//
+// Four independent optionals, and the whole difficulty is that an absent part
+// has to stay absent: a view that never said what its range is must not be
+// announced as sitting at the bottom of one. GTK resets a property per part and
+// AppKit leaves its attribute nil; UIA has the RangeValue properties and a
+// separate Value one for the text, so each is answered or left VT_EMPTY.
+// ---------------------------------------------------------------------------
+
+TEST(accessibility_value_answers_the_range_and_the_position) {
+  RnAccessibleInfo info;
+  info.role = "slider";
+  info.value.min = 0;
+  info.value.max = 10;
+  info.value.now = 7;
+
+  const auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  if (!provider) {
+    return;
+  }
+
+  const auto number = [&provider](PROPERTYID id) {
+    VARIANT value;
+    VariantInit(&value);
+    if (FAILED(provider->GetPropertyValue(id, &value))) {
+      return -1.0;
+    }
+    const double result = value.vt == VT_R8 ? value.dblVal : -1.0;
+    VariantClear(&value);
+    return result;
+  };
+
+  EXPECT_NEAR(number(UIA_RangeValueMinimumPropertyId), 0.0, 0.001);
+  EXPECT_NEAR(number(UIA_RangeValueMaximumPropertyId), 10.0, 0.001);
+  EXPECT_NEAR(number(UIA_RangeValueValuePropertyId), 7.0, 0.001);
+  // Read-only, because nothing here lets a client change it: the pattern that
+  // would is `IRangeValueProvider`, and React Native expresses "you may change
+  // this" as an accessibility action.
+  EXPECT_EQ(propertyType(provider, UIA_RangeValueIsReadOnlyPropertyId), VT_BOOL);
+  // And no text form was given, so none is claimed.
+  EXPECT_EQ(propertyType(provider, UIA_ValueValuePropertyId), VT_EMPTY);
+}
+
+TEST(accessibility_value_leaves_a_part_nobody_mentioned_unset) {
+  RnAccessibleInfo info;
+  info.role = "progressbar";
+  // Only the position, which is what a progress bar with no declared range
+  // looks like. The other two parts must stay absent rather than become zeros.
+  info.value.now = 3;
+
+  const auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  if (!provider) {
+    return;
+  }
+  EXPECT_EQ(propertyType(provider, UIA_RangeValueValuePropertyId), VT_R8);
+  EXPECT_EQ(propertyType(provider, UIA_RangeValueMinimumPropertyId), VT_EMPTY);
+  EXPECT_EQ(propertyType(provider, UIA_RangeValueMaximumPropertyId), VT_EMPTY);
+
+  // A view with no value at all says nothing about any of them, and does not
+  // claim to be read-only either.
+  RnAccessibleInfo plain;
+  plain.role = "button";
+  const auto bare = providerFor(plain);
+  EXPECT(bare != nullptr);
+  if (bare) {
+    EXPECT_EQ(propertyType(bare, UIA_RangeValueValuePropertyId), VT_EMPTY);
+    EXPECT_EQ(propertyType(bare, UIA_RangeValueIsReadOnlyPropertyId), VT_EMPTY);
+  }
+}
+
+TEST(accessibility_value_text_is_its_own_property) {
+  RnAccessibleInfo info;
+  info.role = "adjustable";
+  info.value.now = 1530;
+  info.value.text = "half past three";
+
+  const auto provider = providerFor(info);
+  EXPECT(provider != nullptr);
+  if (!provider) {
+    return;
+  }
+  // The text a screen reader reads instead of the number, which UIA keeps in
+  // the Value pattern rather than RangeValue -- so both are answered and
+  // neither replaces the other.
+  EXPECT_EQ(stringProperty(provider, UIA_ValueValuePropertyId),
+            std::string("half past three"));
+  EXPECT_EQ(propertyType(provider, UIA_RangeValueValuePropertyId), VT_R8);
+}
+
+// A value on its own makes a view worth reporting, which is the one change this
+// made to what counts as an accessibility element: a <View> that says where it
+// is in a range means to be heard, even if it named no role.
+TEST(accessibility_a_value_alone_is_enough_to_be_an_element) {
+  RnAccessibleInfo info;
+  info.value.now = 2;
+  info.value.max = 5;
+  EXPECT(basalt::win32::isAccessibilityElement(info));
+
+  RnAccessibleInfo scaffolding;
+  EXPECT(!basalt::win32::isAccessibilityElement(scaffolding));
+}