Add native Wine accessibility bridge

wine-access/CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.20)
+project(cthulhu_wine_access LANGUAGES C CXX)
+
+include(GNUInstallDirs)
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
+find_program(WIDL_EXECUTABLE widl REQUIRED)
+
+set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
+set(generated_header "${generated_dir}/nvdaController.h")
+set(generated_server "${generated_dir}/nvdaController_s.c")
+file(MAKE_DIRECTORY "${generated_dir}")
+
+add_custom_command(
+    OUTPUT "${generated_header}" "${generated_server}"
+    COMMAND "${WIDL_EXECUTABLE}" --win64 -h -H "${generated_header}"
+            -s -S "${generated_server}" "${CMAKE_CURRENT_SOURCE_DIR}/nvdaController.idl"
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/nvdaController.idl"
+    VERBATIM)
+
+add_executable(cthulhu-wine-access main.cpp "${generated_server}")
+target_compile_features(cthulhu-wine-access PRIVATE cxx_std_20)
+target_include_directories(cthulhu-wine-access PRIVATE "${generated_dir}")
+target_link_libraries(cthulhu-wine-access PRIVATE
+    PkgConfig::GIO oleacc ole32 oleaut32 rpcrt4 user32)
+target_compile_options(cthulhu-wine-access PRIVATE
+    $<$<COMPILE_LANGUAGE:C,CXX>:-Wall -Wextra>)
+
+install(TARGETS cthulhu-wine-access RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")

wine-access/main.cpp

@@ -0,0 +1,282 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#include "nvdaController.h"
+
+#include <gio/gio.h>
+#include <oleacc.h>
+#include <rpc.h>
+#include <windows.h>
+
+#include <cstdlib>
+#include <cwchar>
+#include <string>
+
+namespace {
+constexpr auto BUS_NAME = "org.stormux.Cthulhu1.Service";
+constexpr auto OBJECT_PATH = "/org/stormux/Cthulhu1/Service";
+constexpr auto INTERFACE_NAME = "org.stormux.Cthulhu1.Service";
+constexpr int DBUS_TIMEOUT_MS = 500;
+GDBusConnection *connection = nullptr;
+
+std::string to_utf8(const wchar_t *text) {
+  if (text == nullptr)
+    return {};
+  GError *error = nullptr;
+  gchar *converted = g_utf16_to_utf8(reinterpret_cast<const gunichar2 *>(text),
+                                     -1, nullptr, nullptr, &error);
+  if (error != nullptr)
+    g_error_free(error);
+  if (converted == nullptr)
+    return {};
+  std::string result{converted};
+  g_free(converted);
+  return result;
+}
+
+DWORD call_boolean(const char *method, GVariant *parameters) {
+  if (connection == nullptr)
+    return ERROR_SERVICE_NOT_ACTIVE;
+  GError *error = nullptr;
+  GVariant *reply = g_dbus_connection_call_sync(
+      connection, BUS_NAME, OBJECT_PATH, INTERFACE_NAME, method, parameters,
+      G_VARIANT_TYPE("(b)"), G_DBUS_CALL_FLAGS_NONE, DBUS_TIMEOUT_MS, nullptr,
+      &error);
+  if (error != nullptr)
+    g_error_free(error);
+  if (reply == nullptr)
+    return ERROR_GEN_FAILURE;
+  gboolean result = FALSE;
+  g_variant_get(reply, "(b)", &result);
+  g_variant_unref(reply);
+  return result == TRUE ? ERROR_SUCCESS : ERROR_GEN_FAILURE;
+}
+
+bool cthulhu_is_available() {
+  GError *error = nullptr;
+  GVariant *reply = g_dbus_connection_call_sync(
+      connection, "org.freedesktop.DBus", "/org/freedesktop/DBus",
+      "org.freedesktop.DBus", "NameHasOwner", g_variant_new("(s)", BUS_NAME),
+      G_VARIANT_TYPE("(b)"), G_DBUS_CALL_FLAGS_NONE, DBUS_TIMEOUT_MS, nullptr,
+      &error);
+  if (error != nullptr)
+    g_error_free(error);
+  if (reply == nullptr)
+    return false;
+  gboolean owned = FALSE;
+  g_variant_get(reply, "(b)", &owned);
+  g_variant_unref(reply);
+  return owned == TRUE;
+}
+
+std::string variant_text(const VARIANT &value) {
+  if (value.vt == VT_BSTR)
+    return to_utf8(value.bstrVal);
+  if (value.vt == VT_I4) {
+    wchar_t buffer[128] = {};
+    if (GetRoleTextW(value.lVal, buffer, 128) > 0)
+      return to_utf8(buffer);
+    return std::to_string(value.lVal);
+  }
+  return {};
+}
+
+std::string accessible_property(
+    IAccessible *accessible,
+    HRESULT (STDMETHODCALLTYPE IAccessible::*getter)(VARIANT, BSTR *),
+    const VARIANT &child) {
+  BSTR value = nullptr;
+  const HRESULT result = (accessible->*getter)(child, &value);
+  if (FAILED(result) || value == nullptr)
+    return {};
+  const std::string text = to_utf8(value);
+  SysFreeString(value);
+  return text;
+}
+
+void CALLBACK winevent_callback(HWINEVENTHOOK, DWORD event, HWND window,
+                                LONG objectId, LONG childId, DWORD, DWORD) {
+  if (event != EVENT_OBJECT_FOCUS && event != EVENT_OBJECT_NAMECHANGE &&
+      event != EVENT_OBJECT_VALUECHANGE && event != EVENT_OBJECT_SELECTION &&
+      event != EVENT_OBJECT_STATECHANGE)
+    return;
+  IAccessible *accessible = nullptr;
+  VARIANT child{};
+  VariantInit(&child);
+  if (FAILED(AccessibleObjectFromEvent(window, objectId, childId, &accessible,
+                                       &child)) ||
+      accessible == nullptr)
+    return;
+
+  const std::string name =
+      accessible_property(accessible, &IAccessible::get_accName, child);
+  const std::string value =
+      accessible_property(accessible, &IAccessible::get_accValue, child);
+  const std::string description =
+      accessible_property(accessible, &IAccessible::get_accDescription, child);
+  VARIANT role{};
+  VariantInit(&role);
+  std::string roleText;
+  if (SUCCEEDED(accessible->get_accRole(child, &role)))
+    roleText = variant_text(role);
+  VariantClear(&role);
+  VARIANT state{};
+  VariantInit(&state);
+  std::string stateText;
+  if (SUCCEEDED(accessible->get_accState(child, &state)))
+    stateText = variant_text(state);
+  VariantClear(&state);
+  LONG childCount = 0;
+  accessible->get_accChildCount(&childCount);
+  accessible->Release();
+  VariantClear(&child);
+
+  wchar_t title[512] = {};
+  GetWindowTextW(GetAncestor(window, GA_ROOT), title, 512);
+  const std::string windowTitle = to_utf8(title);
+  const char *eventType = event == EVENT_OBJECT_FOCUS ? "focus" : "change";
+  call_boolean("PresentAccessibleEvent",
+               g_variant_new("(sssssssiis)", "msaa", eventType, name.c_str(),
+                             roleText.c_str(), value.c_str(), stateText.c_str(),
+                             description.c_str(), 0,
+                             static_cast<int>(childCount),
+                             windowTitle.c_str()));
+}
+
+bool register_rpc_server() {
+  if (RpcServerUseProtseqEpW(
+          reinterpret_cast<RPC_WSTR>(const_cast<wchar_t *>(L"ncalrpc")),
+          RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
+          reinterpret_cast<RPC_WSTR>(const_cast<wchar_t *>(L"NvdaCtlr")),
+          nullptr) != RPC_S_OK)
+    return false;
+  DWORD sessionId = 0;
+  if (!ProcessIdToSessionId(GetCurrentProcessId(), &sessionId))
+    return false;
+  wchar_t desktopName[256] = {};
+  DWORD bytesNeeded = 0;
+  if (!GetUserObjectInformationW(GetThreadDesktop(GetCurrentThreadId()),
+                                 UOI_NAME, desktopName, sizeof(desktopName),
+                                 &bytesNeeded))
+    return false;
+  wchar_t endpoint[512] = {};
+  wsprintfW(endpoint, L"NvdaCtlr.%lu.%s", sessionId, desktopName);
+  if (RpcServerUseProtseqEpW(
+          reinterpret_cast<RPC_WSTR>(const_cast<wchar_t *>(L"ncalrpc")),
+          RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
+          reinterpret_cast<RPC_WSTR>(endpoint),
+          nullptr) != RPC_S_OK)
+    return false;
+  for (RPC_IF_HANDLE spec :
+       {NvdaController_v1_0_s_ifspec, NvdaController2_v1_0_s_ifspec,
+        NvdaController3_v1_0_s_ifspec}) {
+    if (RpcServerRegisterIf(spec, nullptr, nullptr) != RPC_S_OK)
+      return false;
+  }
+  return RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE) == RPC_S_OK;
+}
+} // namespace
+
+extern "C" void *__RPC_USER MIDL_user_allocate(size_t size) {
+  return malloc(size);
+}
+extern "C" void __RPC_USER MIDL_user_free(void *pointer) { free(pointer); }
+
+extern "C" error_status_t __stdcall testIfRunning(void) {
+  return cthulhu_is_available() ? ERROR_SUCCESS : ERROR_SERVICE_NOT_ACTIVE;
+}
+extern "C" error_status_t __stdcall speakText(const wchar_t *text) {
+  const std::string utf8 = to_utf8(text);
+  return call_boolean("SpeakText", g_variant_new("(sb)", utf8.c_str(), TRUE));
+}
+extern "C" error_status_t __stdcall cancelSpeech(void) {
+  return call_boolean("CancelSpeech", nullptr);
+}
+extern "C" error_status_t __stdcall brailleMessage(const wchar_t *text) {
+  const std::string utf8 = to_utf8(text);
+  return call_boolean("BrailleMessage", g_variant_new("(s)", utf8.c_str()));
+}
+extern "C" error_status_t __stdcall getProcessId(ULONG *pid) {
+  if (pid == nullptr)
+    return ERROR_INVALID_PARAMETER;
+  *pid = GetCurrentProcessId();
+  return ERROR_SUCCESS;
+}
+extern "C" error_status_t __stdcall speakSsml(const wchar_t *ssml, SYMBOL_LEVEL,
+                                              SPEECH_PRIORITY, boolean) {
+  const std::string utf8 = to_utf8(ssml);
+  GError *error = nullptr;
+  GVariant *reply = g_dbus_connection_call_sync(
+      connection, BUS_NAME, OBJECT_PATH, INTERFACE_NAME, "SpeakSsml",
+      g_variant_new("(ss)", "wine-nvda-controller", utf8.c_str()),
+      G_VARIANT_TYPE("(i)"), G_DBUS_CALL_FLAGS_NONE, DBUS_TIMEOUT_MS, nullptr,
+      &error);
+  if (error != nullptr)
+    g_error_free(error);
+  if (reply == nullptr)
+    return ERROR_GEN_FAILURE;
+  gint result = ERROR_GEN_FAILURE;
+  g_variant_get(reply, "(i)", &result);
+  g_variant_unref(reply);
+  return static_cast<error_status_t>(result);
+}
+extern "C" error_status_t __stdcall onSsmlMarkReached(const wchar_t *) {
+  return ERROR_CALL_NOT_IMPLEMENTED;
+}
+extern "C" error_status_t __stdcall isSpeaking(boolean *speaking) {
+  if (speaking == nullptr)
+    return ERROR_INVALID_PARAMETER;
+  *speaking = FALSE;
+  return ERROR_CALL_NOT_IMPLEMENTED;
+}
+
+int WINAPI WinMain(HINSTANCE instance, HINSTANCE, char *, int) {
+  const wchar_t *commandLine = GetCommandLineW();
+  const bool dialogReaderEnabled =
+      wcsstr(commandLine, L"--no-dialog-reader") == nullptr;
+  const bool controllerEnabled =
+      wcsstr(commandLine, L"--no-controller") == nullptr;
+  if (!dialogReaderEnabled && !controllerEnabled)
+    return 0;
+  if (controllerEnabled && FindWindowW(L"wxWindowClassNR", L"NVDA") != nullptr)
+    return 0;
+  GError *error = nullptr;
+  connection = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error);
+  if (error != nullptr)
+    g_error_free(error);
+  if (connection == nullptr || !cthulhu_is_available())
+    return 1;
+
+  HWND window = nullptr;
+  if (controllerEnabled) {
+    WNDCLASSW windowClass{};
+    windowClass.lpfnWndProc = DefWindowProcW;
+    windowClass.hInstance = instance;
+    windowClass.lpszClassName = L"wxWindowClassNR";
+    RegisterClassW(&windowClass);
+    window = CreateWindowW(windowClass.lpszClassName, L"NVDA", 0, 0, 0, 0, 0,
+                           nullptr, nullptr, instance, nullptr);
+  }
+  if ((controllerEnabled && (window == nullptr || !register_rpc_server()))) {
+    g_object_unref(connection);
+    return 1;
+  }
+  HWINEVENTHOOK hook = nullptr;
+  if (dialogReaderEnabled) {
+    hook = SetWinEventHook(EVENT_MIN, EVENT_MAX, nullptr, winevent_callback, 0,
+                           0, WINEVENT_OUTOFCONTEXT | WINEVENT_SKIPOWNPROCESS);
+  }
+  MSG message{};
+  while (GetMessageW(&message, nullptr, 0, 0) > 0) {
+    TranslateMessage(&message);
+    DispatchMessageW(&message);
+  }
+  if (hook != nullptr)
+    UnhookWinEvent(hook);
+  if (controllerEnabled) {
+    RpcMgmtStopServerListening(nullptr);
+    RpcServerUnregisterIf(nullptr, nullptr, FALSE);
+    DestroyWindow(window);
+  }
+  g_object_unref(connection);
+  return 0;
+}

wine-access/nvdaController.idl

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+typedef [v1_enum] enum tagSPEECH_PRIORITY {
+    SPEECH_PRIORITY_NORMAL = 0,
+    SPEECH_PRIORITY_NEXT = 1,
+    SPEECH_PRIORITY_NOW = 2
+} SPEECH_PRIORITY;
+
+typedef [v1_enum] enum tagSYMBOL_LEVEL {
+    SYMBOL_LEVEL_NONE = 0,
+    SYMBOL_LEVEL_SOME = 100,
+    SYMBOL_LEVEL_MOST = 200,
+    SYMBOL_LEVEL_ALL = 300,
+    SYMBOL_LEVEL_CHAR = 1000,
+    SYMBOL_LEVEL_UNCHANGED = -1
+} SYMBOL_LEVEL;
+
+[
+    uuid(DFF50B99-F7FD-4ca7-A82C-DAEB3E025295),
+    version(1.0)
+]
+interface NvdaController {
+    error_status_t __stdcall testIfRunning();
+    error_status_t __stdcall speakText([in, string] const wchar_t *text);
+    error_status_t __stdcall cancelSpeech();
+    error_status_t __stdcall brailleMessage([in, string] const wchar_t *message);
+};
+
+[
+    uuid(3D168D45-CB58-4270-8257-4E0BE515D557),
+    version(1.0)
+]
+interface NvdaController2 {
+    error_status_t __stdcall getProcessId([out] unsigned long *pid);
+    error_status_t __stdcall speakSsml(
+        [in, string] const wchar_t *ssml,
+        [in] const SYMBOL_LEVEL symbolLevel,
+        [in] const SPEECH_PRIORITY priority,
+        [in] const boolean asynchronous);
+    // WIDL lacks MIDL's callback attribute. Keeping this method in slot 2
+    // preserves the wire layout used by the unmodified controller client.
+    error_status_t __stdcall onSsmlMarkReached([in, string] const wchar_t *mark);
+};
+
+[
+    uuid(019e4216-a9a1-7540-a217-e1a2d2793025),
+    version(1.0)
+]
+interface NvdaController3 {
+    error_status_t __stdcall isSpeaking([out] boolean *speaking);
+};

wine-access/winelib-toolchain.cmake

@@ -0,0 +1,14 @@
+set(CMAKE_SYSTEM_NAME Linux)
+find_program(WINEGCC winegcc REQUIRED)
+find_program(WINEGXX wineg++ REQUIRED)
+set(CMAKE_C_COMPILER "${WINEGCC}")
+set(CMAKE_CXX_COMPILER "${WINEGXX}")
+foreach(language C CXX)
+  set(CMAKE_SHARED_LIBRARY_PREFIX_${language} "")
+  set(CMAKE_SHARED_LIBRARY_SUFFIX_${language} ".dll")
+endforeach()
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+set(CMAKE_SHARED_LIBRARY_SUFFIX ".dll")
+set(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG "")
+set(CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG "")
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)