diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml index 39f4f0b67eb..4539f1b77cf 100644 --- a/.github/workflows/linux_builds.yml +++ b/.github/workflows/linux_builds.yml @@ -5,7 +5,7 @@ on: # Global Settings env: GODOT_CPP_BRANCH: 4.4 - SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes strict_checks=yes + SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes strict_checks=yes "accesskit_sdk_path=${{ github.workspace }}/accesskit-c-0.15.1/" DOTNET_NOLOGO: true DOTNET_CLI_TELEMETRY_OPTOUT: true TSAN_OPTIONS: suppressions=${{ github.workspace }}/misc/error_suppressions/tsan.txt @@ -151,6 +151,17 @@ jobs: # Targeting the oldest version we want to support to ensure it still builds. dotnet-version: 8.0.100 + - name: Download pre-built AccessKit + uses: dsaltares/fetch-gh-release-asset@1.1.2 + with: + repo: AccessKit/accesskit-c + version: tags/0.15.1 + file: accesskit-c-0.15.1.zip + target: accesskit-c-0.15.1/accesskit_c.zip + + - name: Extract pre-built AccessKit + run: unzip -o accesskit-c-0.15.1/accesskit_c.zip + - name: Compilation uses: ./.github/actions/godot-build with: diff --git a/.github/workflows/macos_builds.yml b/.github/workflows/macos_builds.yml index 1244ce25e47..93189b2e4ef 100644 --- a/.github/workflows/macos_builds.yml +++ b/.github/workflows/macos_builds.yml @@ -4,7 +4,7 @@ on: # Global Settings env: - SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes strict_checks=yes + SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes strict_checks=yes "accesskit_sdk_path=${{ github.workspace }}/accesskit-c-0.15.1/" jobs: build-macos: @@ -43,6 +43,17 @@ jobs: - name: Setup Python and SCons uses: ./.github/actions/godot-deps + - name: Download pre-built AccessKit + uses: dsaltares/fetch-gh-release-asset@1.1.2 + with: + repo: AccessKit/accesskit-c + version: tags/0.15.1 + file: accesskit-c-0.15.1.zip + target: accesskit-c-0.15.1/accesskit_c.zip + + - name: Extract pre-built AccessKit + run: unzip -o accesskit-c-0.15.1/accesskit_c.zip + - name: Setup Vulkan SDK id: vulkan-sdk run: | diff --git a/.github/workflows/windows_builds.yml b/.github/workflows/windows_builds.yml index 535756025a4..1a93e66cd0e 100644 --- a/.github/workflows/windows_builds.yml +++ b/.github/workflows/windows_builds.yml @@ -5,7 +5,7 @@ on: # Global Settings # SCONS_CACHE for windows must be set in the build environment env: - SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes d3d12=yes strict_checks=yes "angle_libs=${{ github.workspace }}/" + SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes d3d12=yes strict_checks=yes "angle_libs=${{ github.workspace }}/" "accesskit_sdk_path=${{ github.workspace }}/accesskit-c-0.15.1/" SCONS_CACHE_MSVC_CONFIG: true jobs: @@ -81,6 +81,17 @@ jobs: - name: Extract pre-built ANGLE static libraries run: Expand-Archive -Force angle/angle.zip ${{ github.workspace }}/ + - name: Download pre-built AccessKit + uses: dsaltares/fetch-gh-release-asset@1.1.2 + with: + repo: AccessKit/accesskit-c + version: tags/0.15.1 + file: accesskit-c-0.15.1.zip + target: accesskit-c-0.15.1/accesskit_c.zip + + - name: Extract pre-built AccessKit + run: unzip -o accesskit-c-0.15.1/accesskit_c.zip + - name: Compilation uses: ./.github/actions/godot-build with: diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f1bc349fb90..8c9f033afbc 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,9 +4,7 @@ default_language_version: exclude: | (?x)^( .*thirdparty/.*| - .*-so_wrap\.(h|c)| - .*-dll_wrap\.(h|c)| - .*-dylib_wrap\.(h|c)| + .*-(dll|dylib|so)_wrap\.[ch]| platform/android/java/editor/src/main/java/com/android/.*| platform/android/java/lib/src/com/google/.* )$ diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt index 6fdfacc552e..380090935ee 100644 --- a/COPYRIGHT.txt +++ b/COPYRIGHT.txt @@ -163,6 +163,11 @@ Comment: Temporal Anti-Aliasing resolve implementation Copyright: 2016, Panos Karabelas License: Expat +Files: thirdparty/accesskit/* +Comment: AccessKit +Copyright: 2023, The AccessKit Authors. +License: Expat + Files: thirdparty/amd-fsr/* Comment: AMD FidelityFX Super Resolution Copyright: 2021, Advanced Micro Devices, Inc. diff --git a/SConstruct b/SConstruct index aaebea97a9d..03990864310 100644 --- a/SConstruct +++ b/SConstruct @@ -191,6 +191,8 @@ opts.Add(BoolVariable("use_volk", "Use the volk library to load the Vulkan loade opts.Add(BoolVariable("disable_exceptions", "Force disabling exception handling code", True)) opts.Add("custom_modules", "A list of comma-separated directory paths containing custom modules to build.", "") opts.Add(BoolVariable("custom_modules_recursive", "Detect custom modules recursively for each specified path.", True)) +opts.Add(BoolVariable("accesskit", "Use AccessKit C SDK", True)) +opts.Add(("accesskit_sdk_path", "Path to the AccessKit C SDK", "")) # Advanced options opts.Add( diff --git a/drivers/SCsub b/drivers/SCsub index cc07a40f091..b5624b17780 100644 --- a/drivers/SCsub +++ b/drivers/SCsub @@ -26,9 +26,15 @@ if env["xaudio2"]: print_error("Target platform '{}' does not support the XAudio2 audio driver".format(env["platform"])) Exit(255) SConscript("xaudio2/SCsub") + # Shared Apple platform drivers if env["platform"] in ["macos", "ios"]: SConscript("apple/SCsub") + +# Accessibility +if env["accesskit"] and env["platform"] in ["macos", "windows", "linuxbsd"]: + SConscript("accesskit/SCsub") + # Midi drivers SConscript("alsamidi/SCsub") if env["platform"] in ["macos", "ios"]: diff --git a/drivers/accesskit/SCsub b/drivers/accesskit/SCsub new file mode 100644 index 00000000000..6365898a81c --- /dev/null +++ b/drivers/accesskit/SCsub @@ -0,0 +1,16 @@ +#!/usr/bin/env python +from misc.utility.scons_hints import * + +Import("env") + +# Driver source files +env.add_source_files(env.drivers_sources, "accessibility_driver_accesskit.cpp") + +if env["accesskit_sdk_path"] == "": + if env["platform"] == "windows": + env.add_source_files(env.drivers_sources, "dynwrappers/accesskit-dll_wrap.c") + if env["platform"] == "macos": + env.add_source_files(env.drivers_sources, "dynwrappers/accesskit-dylib_wrap.c") + if env["platform"] == "linuxbsd": + env.add_source_files(env.drivers_sources, "dynwrappers/accesskit-so_wrap.c") + env.Prepend(CPPPATH=["#thirdparty/accesskit/include"]) diff --git a/drivers/accesskit/accessibility_driver_accesskit.cpp b/drivers/accesskit/accessibility_driver_accesskit.cpp new file mode 100644 index 00000000000..1ab3137d89e --- /dev/null +++ b/drivers/accesskit/accessibility_driver_accesskit.cpp @@ -0,0 +1,1653 @@ +/**************************************************************************/ +/* accessibility_driver_accesskit.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#ifdef ACCESSKIT_ENABLED + +#include "accessibility_driver_accesskit.h" + +#include "core/config/project_settings.h" +#include "core/version.h" + +#include "servers/text_server.h" + +AccessibilityDriverAccessKit *AccessibilityDriverAccessKit::singleton = nullptr; + +_FORCE_INLINE_ accesskit_role AccessibilityDriverAccessKit::_accessibility_role(DisplayServer::AccessibilityRole p_role) const { + if (role_map.has(p_role)) { + return role_map[p_role]; + } + return ACCESSKIT_ROLE_UNKNOWN; +} + +_FORCE_INLINE_ accesskit_action AccessibilityDriverAccessKit::_accessibility_action(DisplayServer::AccessibilityAction p_action) const { + if (action_map.has(p_action)) { + return action_map[p_action]; + } + return ACCESSKIT_ACTION_CLICK; +} + +bool AccessibilityDriverAccessKit::window_create(DisplayServer::WindowID p_window_id, void *p_handle) { + ERR_FAIL_COND_V(windows.has(p_window_id), false); + + WindowData &wd = windows[p_window_id]; + + AccessibilityElement *ae = memnew(AccessibilityElement); + ae->role = ACCESSKIT_ROLE_WINDOW; + ae->window_id = p_window_id; + wd.root_id = rid_owner.make_rid(ae); + +#ifdef WINDOWS_ENABLED + wd.adapter = accesskit_windows_subclassing_adapter_new(static_cast(p_handle), &_accessibility_initial_tree_update_callback, (void *)(size_t)p_window_id, &_accessibility_action_callback, (void *)(size_t)p_window_id); +#endif +#ifdef MACOS_ENABLED + wd.adapter = accesskit_macos_subclassing_adapter_for_window(p_handle, &_accessibility_initial_tree_update_callback, (void *)(size_t)p_window_id, &_accessibility_action_callback, (void *)(size_t)p_window_id); +#endif +#ifdef LINUXBSD_ENABLED + wd.adapter = accesskit_unix_adapter_new(&_accessibility_initial_tree_update_callback, (void *)(size_t)p_window_id, &_accessibility_action_callback, (void *)(size_t)p_window_id, &_accessibility_deactivation_callback, (void *)(size_t)p_window_id); +#endif + + if (wd.adapter == nullptr) { + memdelete(ae); + rid_owner.free(wd.root_id); + windows.erase(p_window_id); + + return false; + } else { + return true; + } +} + +void AccessibilityDriverAccessKit::window_destroy(DisplayServer::WindowID p_window_id) { + WindowData *wd = windows.getptr(p_window_id); + ERR_FAIL_NULL(wd); + +#ifdef WINDOWS_ENABLED + accesskit_windows_subclassing_adapter_free(wd->adapter); +#endif +#ifdef MACOS_ENABLED + accesskit_macos_subclassing_adapter_free(wd->adapter); +#endif +#ifdef LINUXBSD_ENABLED + accesskit_unix_adapter_free(wd->adapter); +#endif + accessibility_free_element(wd->root_id); + + windows.erase(p_window_id); +} + +void AccessibilityDriverAccessKit::_accessibility_deactivation_callback(void *p_user_data) { + // NOP +} + +void AccessibilityDriverAccessKit::_accessibility_action_callback(struct accesskit_action_request *p_request, void *p_user_data) { + DisplayServer::WindowID window_id = (DisplayServer::WindowID)(size_t)p_user_data; + ERR_FAIL_COND(!singleton->windows.has(window_id)); + + RID rid = RID::from_uint64(p_request->target); + AccessibilityElement *ae = singleton->rid_owner.get_or_null(rid); + ERR_FAIL_NULL(ae); + + Variant rq_data; + if (!ae->actions.has(p_request->action) && ae->role == ACCESSKIT_ROLE_TEXT_RUN && p_request->action == ACCESSKIT_ACTION_SCROLL_INTO_VIEW) { + AccessibilityElement *root_ae = singleton->rid_owner.get_or_null(ae->parent); + ERR_FAIL_NULL(root_ae); + ae = root_ae; + rq_data = ae->run; + } + + if (ae->actions.has(p_request->action)) { + Callable &cb = ae->actions[p_request->action]; + if (cb.is_valid()) { + if (p_request->data.has_value) { + switch (p_request->data.value.tag) { + case ACCESSKIT_ACTION_DATA_CUSTOM_ACTION: { + rq_data = p_request->data.value.custom_action; + } break; + case ACCESSKIT_ACTION_DATA_VALUE: { + rq_data = String::utf8(p_request->data.value.value); + } break; + case ACCESSKIT_ACTION_DATA_NUMERIC_VALUE: { + rq_data = p_request->data.value.numeric_value; + } break; + case ACCESSKIT_ACTION_DATA_SCROLL_TARGET_RECT: { + rq_data = Rect2(p_request->data.value.scroll_target_rect.x0, p_request->data.value.scroll_target_rect.y0, p_request->data.value.scroll_target_rect.x1 - p_request->data.value.scroll_target_rect.x0, p_request->data.value.scroll_target_rect.y1 - p_request->data.value.scroll_target_rect.y0); + } break; + case ACCESSKIT_ACTION_DATA_SCROLL_TO_POINT: { + rq_data = Point2(p_request->data.value.scroll_to_point.x, p_request->data.value.scroll_to_point.y); + } break; + case ACCESSKIT_ACTION_DATA_SET_SCROLL_OFFSET: { + rq_data = Point2(p_request->data.value.set_scroll_offset.x, p_request->data.value.set_scroll_offset.y); + } break; + case ACCESSKIT_ACTION_DATA_SET_TEXT_SELECTION: { + Dictionary sel; + + RID start_rid = RID::from_uint64(p_request->data.value.set_text_selection.anchor.node); + AccessibilityElement *start_ae = singleton->rid_owner.get_or_null(start_rid); + ERR_FAIL_NULL(start_ae); + + RID end_rid = RID::from_uint64(p_request->data.value.set_text_selection.focus.node); + AccessibilityElement *end_ae = singleton->rid_owner.get_or_null(end_rid); + ERR_FAIL_NULL(end_ae); + + sel["start_element"] = start_ae->parent; + sel["start_char"] = (int64_t)p_request->data.value.set_text_selection.anchor.character_index + start_ae->run.x; + sel["end_element"] = end_ae->parent; + sel["end_char"] = (int64_t)p_request->data.value.set_text_selection.focus.character_index + end_ae->run.x; + rq_data = sel; + } break; + } + } + + cb.call_deferred(rq_data); + } + } +} + +accesskit_tree_update *AccessibilityDriverAccessKit::_accessibility_initial_tree_update_callback(void *p_user_data) { + DisplayServer::WindowID window_id = (DisplayServer::WindowID)(size_t)p_user_data; + WindowData *wd = singleton->windows.getptr(window_id); + ERR_FAIL_NULL_V(wd, nullptr); + + accesskit_node *win_node = accesskit_node_new(ACCESSKIT_ROLE_WINDOW); + accesskit_node_set_label(win_node, "Godot Engine"); + accesskit_node_set_busy(win_node); + + accesskit_node_id win_id = (accesskit_node_id)wd->root_id.get_id(); + + accesskit_tree_update *tree_update = accesskit_tree_update_with_capacity_and_focus(1, win_id); + + accesskit_tree_update_set_tree(tree_update, accesskit_tree_new(win_id)); + accesskit_tree_update_push_node(tree_update, win_id, win_node); + + return tree_update; +} + +RID AccessibilityDriverAccessKit::accessibility_create_element(DisplayServer::WindowID p_window_id, DisplayServer::AccessibilityRole p_role) { + AccessibilityElement *ae = memnew(AccessibilityElement); + ae->role = _accessibility_role(p_role); + ae->window_id = p_window_id; + RID rid = rid_owner.make_rid(ae); + + return rid; +} + +RID AccessibilityDriverAccessKit::accessibility_create_sub_element(const RID &p_parent_rid, DisplayServer::AccessibilityRole p_role, int p_insert_pos) { + AccessibilityElement *parent_ae = rid_owner.get_or_null(p_parent_rid); + ERR_FAIL_NULL_V(parent_ae, RID()); + + WindowData *wd = windows.getptr(parent_ae->window_id); + ERR_FAIL_NULL_V(wd, RID()); + + AccessibilityElement *ae = memnew(AccessibilityElement); + ae->role = _accessibility_role(p_role); + ae->window_id = parent_ae->window_id; + ae->parent = p_parent_rid; + ae->node = accesskit_node_new(ae->role); + RID rid = rid_owner.make_rid(ae); + if (p_insert_pos == -1) { + parent_ae->children.push_back(rid); + } else { + parent_ae->children.insert(p_insert_pos, rid); + } + wd->update.insert(rid); + + return rid; +} + +RID AccessibilityDriverAccessKit::accessibility_create_sub_text_edit_elements(const RID &p_parent_rid, const RID &p_shaped_text, float p_min_height, int p_insert_pos) { + AccessibilityElement *parent_ae = rid_owner.get_or_null(p_parent_rid); + ERR_FAIL_NULL_V(parent_ae, RID()); + + WindowData *wd = windows.getptr(parent_ae->window_id); + ERR_FAIL_NULL_V(wd, RID()); + + AccessibilityElement *root_ae = memnew(AccessibilityElement); + root_ae->role = ACCESSKIT_ROLE_GENERIC_CONTAINER; + root_ae->window_id = parent_ae->window_id; + root_ae->parent = p_parent_rid; + root_ae->node = accesskit_node_new(root_ae->role); + RID root_rid = rid_owner.make_rid(root_ae); + if (p_insert_pos == -1) { + parent_ae->children.push_back(root_rid); + } else { + parent_ae->children.insert(p_insert_pos, root_rid); + } + wd->update.insert(root_rid); + + float text_width = 0; + float text_height = p_min_height; + Vector words; + int64_t run_count = 0; // Note: runs in visual order. + const Glyph *gl = nullptr; + int64_t gl_count = 0; + int64_t gl_index = 0; + float run_off_x = 0.0; + Vector2i full_range; + + if (p_shaped_text.is_valid()) { + text_width = TS->shaped_text_get_size(p_shaped_text).x; + text_height = MAX(text_height, TS->shaped_text_get_size(p_shaped_text).y); + words = TS->shaped_text_get_word_breaks(p_shaped_text); + run_count = TS->shaped_get_run_count(p_shaped_text); + gl = TS->shaped_text_get_glyphs(p_shaped_text); + gl_count = TS->shaped_text_get_glyph_count(p_shaped_text); + full_range = TS->shaped_text_get_range(p_shaped_text); + } + + accesskit_rect root_rect; + root_rect.x0 = 0; + root_rect.y0 = 0; + root_rect.x1 = text_width; + root_rect.y1 = MAX(p_min_height, text_height); + accesskit_node_set_bounds(root_ae->node, root_rect); + + // Create text element for each run. + Vector text_elements; + for (int64_t i = 0; i < run_count; i++) { + const Vector2i range = TS->shaped_get_run_range(p_shaped_text, i); + String t = TS->shaped_get_run_text(p_shaped_text, i); + + if (t.is_empty()) { + continue; + } + + AccessibilityElement *ae = memnew(AccessibilityElement); + ae->role = ACCESSKIT_ROLE_TEXT_RUN; + ae->window_id = parent_ae->window_id; + ae->parent = root_rid; + ae->run = Vector3i(range.x, range.y, i); + ae->node = accesskit_node_new(ae->role); + + text_elements.push_back(ae); + + // UTF-8 text and char lengths. + Vector char_lengths; + CharString text = t.utf8(&char_lengths); + + accesskit_node_set_value(ae->node, text.ptr()); + accesskit_node_set_character_lengths(ae->node, char_lengths.size(), char_lengths.ptr()); + + // Word sizes. + Vector word_lengths; + + int32_t prev = ae->run.x; + int32_t total = 0; + for (int j = 0; j < words.size(); j += 2) { + if (words[j] < ae->run.x) { + continue; + } + if (words[j] >= ae->run.y) { + break; + } + int32_t wlen = words[j] - prev; + while (wlen > 255) { + word_lengths.push_back(255); + wlen -= 255; + total += 255; + } + if (wlen > 0) { + word_lengths.push_back(wlen); + total += wlen; + } + prev = words[j]; + } + if (total < t.length()) { + word_lengths.push_back(t.length() - total); + } + accesskit_node_set_word_lengths(ae->node, word_lengths.size(), word_lengths.ptr()); + + // Char widths and positions. + Vector char_positions; + Vector char_widths; + + char_positions.resize_zeroed(t.length()); + float *positions_ptr = char_positions.ptrw(); + + char_widths.resize_zeroed(t.length()); + float *widths_ptr = char_widths.ptrw(); + + float size_x = 0.0; + for (int j = gl_index; j < gl_count; j += gl[j].count) { + if (gl[j].start >= ae->run.y) { + gl_index = j; + break; + } + + float advance = 0.0; // Graphame advance. + for (int k = 0; k < gl[j].count; k++) { + advance += gl[j + k].advance; + } + int chars = gl[j].end - gl[j].start; + float adv_per_char = advance / (float)chars; + + for (int k = 0; k < chars; k++) { + int index = gl[j].start + k - ae->run.x; + ERR_CONTINUE(index < 0 || index >= t.length()); + positions_ptr[index] = size_x + adv_per_char * k; + widths_ptr[index] = adv_per_char; + } + size_x += advance * gl[j].repeat; + } + positions_ptr[t.length() - 1] = size_x; + widths_ptr[t.length() - 1] = 1.0; + + accesskit_node_set_character_positions(ae->node, char_positions.size(), char_positions.ptr()); + accesskit_node_set_character_widths(ae->node, char_widths.size(), char_widths.ptr()); + + RID font_rid = TS->shaped_get_run_font_rid(p_shaped_text, i); + if (font_rid != RID()) { + CharString font_name = TS->font_get_name(font_rid).utf8(); + if (font_name.length() > 0) { + accesskit_node_set_font_family(ae->node, font_name.ptr()); + } + if (TS->font_get_style(font_rid).has_flag(TextServer::FONT_BOLD)) { + accesskit_node_set_bold(ae->node); + } + if (TS->font_get_style(font_rid).has_flag(TextServer::FONT_ITALIC)) { + accesskit_node_set_italic(ae->node); + } + accesskit_node_set_font_weight(ae->node, TS->font_get_weight(font_rid)); + } + accesskit_node_set_font_size(ae->node, TS->shaped_get_run_font_size(p_shaped_text, i)); + CharString language = TS->shaped_get_run_language(p_shaped_text, i).utf8(); + if (language.length() > 0) { + accesskit_node_set_language(ae->node, language.ptr()); + } + accesskit_node_set_text_direction(ae->node, ACCESSKIT_TEXT_DIRECTION_LEFT_TO_RIGHT); + + accesskit_rect rect; + rect.x0 = run_off_x; + rect.y0 = 0; + rect.x1 = run_off_x + size_x; + rect.y1 = text_height; + accesskit_node_set_bounds(ae->node, rect); + accesskit_node_add_action(ae->node, ACCESSKIT_ACTION_SCROLL_INTO_VIEW); + + run_off_x += size_x; + } + { + // Add "\n" at the end. + AccessibilityElement *ae = memnew(AccessibilityElement); + ae->role = ACCESSKIT_ROLE_TEXT_RUN; + ae->window_id = parent_ae->window_id; + ae->parent = root_rid; + ae->run = Vector3i(full_range.y, full_range.y, run_count); + ae->node = accesskit_node_new(ae->role); + + text_elements.push_back(ae); + + Vector char_lengths; + char_lengths.push_back(1); + accesskit_node_set_value(ae->node, "\n"); + accesskit_node_set_character_lengths(ae->node, char_lengths.size(), char_lengths.ptr()); + + Vector char_positions; + Vector char_widths; + char_positions.push_back(0.0); + char_widths.push_back(1.0); + + accesskit_node_set_character_positions(ae->node, char_positions.size(), char_positions.ptr()); + accesskit_node_set_character_widths(ae->node, char_widths.size(), char_widths.ptr()); + accesskit_node_set_text_direction(ae->node, ACCESSKIT_TEXT_DIRECTION_LEFT_TO_RIGHT); + + accesskit_rect rect; + rect.x0 = run_off_x; + rect.y0 = 0; + rect.x1 = run_off_x + 1; + rect.y1 = text_height; + accesskit_node_set_bounds(ae->node, rect); + } + + // Sort runs in logical order. + struct RunCompare { + _FORCE_INLINE_ bool operator()(const AccessibilityElement *l, const AccessibilityElement *r) const { + return l->run.x < r->run.x; + } + }; + text_elements.sort_custom(); + for (AccessibilityElement *text_element : text_elements) { + RID rid = rid_owner.make_rid(text_element); + root_ae->children.push_back(rid); + wd->update.insert(rid); + } + + return root_rid; +} + +bool AccessibilityDriverAccessKit::accessibility_has_element(const RID &p_id) const { + return rid_owner.owns(p_id); +} + +void AccessibilityDriverAccessKit::_free_recursive(WindowData *p_wd, const RID &p_id) { + if (p_wd && p_wd->update.has(p_id)) { + p_wd->update.erase(p_id); + } + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + for (const RID &rid : ae->children) { + _free_recursive(p_wd, rid); + } + if (ae->node) { + accesskit_node_free(ae->node); + } + memdelete(ae); + rid_owner.free(p_id); +} + +void AccessibilityDriverAccessKit::accessibility_free_element(const RID &p_id) { + ERR_FAIL_COND_MSG(in_accessibility_update, "Element can't be removed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + if (ae) { + WindowData *wd = windows.getptr(ae->window_id); + AccessibilityElement *parent_ae = rid_owner.get_or_null(ae->parent); + if (parent_ae) { + parent_ae->children.erase(p_id); + } + _free_recursive(wd, p_id); + } +} + +void AccessibilityDriverAccessKit::accessibility_element_set_meta(const RID &p_id, const Variant &p_meta) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + ae->meta = p_meta; +} + +Variant AccessibilityDriverAccessKit::accessibility_element_get_meta(const RID &p_id) const { + const AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL_V(ae, Variant()); + return ae->meta; +} + +void AccessibilityDriverAccessKit::accessibility_update_set_focus(const RID &p_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + if (p_id.is_valid() && rid_owner.owns(p_id)) { + focus = p_id; + } else { + focus = RID(); + } +} + +RID AccessibilityDriverAccessKit::accessibility_get_window_root(DisplayServer::WindowID p_window_id) const { + const WindowData *wd = windows.getptr(p_window_id); + ERR_FAIL_NULL_V(wd, RID()); + + return wd->root_id; +} + +accesskit_tree_update *AccessibilityDriverAccessKit::_accessibility_build_tree_update(void *p_user_data) { + DisplayServer::WindowID window_id = (DisplayServer::WindowID)(size_t)p_user_data; + + ERR_FAIL_COND_V(!singleton->windows.has(window_id), nullptr); + WindowData &wd = singleton->windows[window_id]; + + singleton->in_accessibility_update = true; + if (singleton->update_cb.is_valid()) { + singleton->update_cb.call(window_id); + } + singleton->in_accessibility_update = false; + + AccessibilityElement *focus_ae = singleton->rid_owner.get_or_null(singleton->focus); + uint32_t update_size = wd.update.size(); + + accesskit_node_id ac_focus = (accesskit_node_id)wd.root_id.get_id(); + if (focus_ae && focus_ae->window_id == window_id) { + ac_focus = (accesskit_node_id)singleton->focus.get_id(); + } + + accesskit_tree_update *tree_update = (update_size > 0) ? accesskit_tree_update_with_capacity_and_focus(update_size, ac_focus) : accesskit_tree_update_with_focus(ac_focus); + for (const RID &rid : wd.update) { + AccessibilityElement *ae = singleton->rid_owner.get_or_null(rid); + if (ae && ae->node) { + for (const RID &child_rid : ae->children) { + accesskit_node_push_child(ae->node, (accesskit_node_id)child_rid.get_id()); + } + accesskit_tree_update_push_node(tree_update, (accesskit_node_id)rid.get_id(), ae->node); + ae->node = nullptr; + } + } + wd.update.clear(); + + return tree_update; +} + +void AccessibilityDriverAccessKit::accessibility_update_if_active(const Callable &p_callable) { + ERR_FAIL_COND(!p_callable.is_valid()); + update_cb = p_callable; + for (KeyValue &window : windows) { +#ifdef WINDOWS_ENABLED + accesskit_windows_queued_events *events = accesskit_windows_subclassing_adapter_update_if_active(window.value.adapter, _accessibility_build_tree_update, (void *)(size_t)window.key); + if (events) { + accesskit_windows_queued_events_raise(events); + } +#endif +#ifdef MACOS_ENABLED + accesskit_macos_queued_events *events = accesskit_macos_subclassing_adapter_update_if_active(window.value.adapter, _accessibility_build_tree_update, (void *)(size_t)window.key); + if (events) { + accesskit_macos_queued_events_raise(events); + } +#endif +#ifdef LINUXBSD_ENABLED + accesskit_unix_adapter_update_if_active(window.value.adapter, _accessibility_build_tree_update, (void *)(size_t)window.key); +#endif + } + update_cb = Callable(); +} + +_FORCE_INLINE_ void AccessibilityDriverAccessKit::_ensure_node(const RID &p_id, AccessibilityElement *p_ae) { + if (unlikely(!p_ae->node)) { + WindowData *wd = windows.getptr(p_ae->window_id); + ERR_FAIL_NULL(wd); + + wd->update.insert(p_id); + p_ae->node = accesskit_node_new(p_ae->role); + } +} + +void AccessibilityDriverAccessKit::accessibility_set_window_rect(DisplayServer::WindowID p_window_id, const Rect2 &p_rect_out, const Rect2 &p_rect_in) { +#ifdef LINUXBSD_ENABLED + const WindowData *wd = windows.getptr(p_window_id); + ERR_FAIL_NULL(wd); + + accesskit_rect outer_bounds = { p_rect_out.position.x, p_rect_out.position.y, p_rect_out.position.x + p_rect_out.size.width, p_rect_out.position.y + p_rect_out.size.height }; + accesskit_rect inner_bounds = { p_rect_in.position.x, p_rect_in.position.y, p_rect_in.position.x + p_rect_in.size.width, p_rect_in.position.y + p_rect_in.size.height }; + accesskit_unix_adapter_set_root_window_bounds(wd->adapter, outer_bounds, inner_bounds); +#endif +} + +void AccessibilityDriverAccessKit::accessibility_set_window_focused(DisplayServer::WindowID p_window_id, bool p_focused) { + const WindowData *wd = windows.getptr(p_window_id); + ERR_FAIL_NULL(wd); + +#ifdef LINUXBSD_ENABLED + accesskit_unix_adapter_update_window_focus_state(wd->adapter, p_focused); +#endif +#ifdef MACOS_ENABLED + accesskit_macos_queued_events *events = accesskit_macos_subclassing_adapter_update_view_focus_state(wd->adapter, p_focused); + if (events != nullptr) { + accesskit_macos_queued_events_raise(events); + } +#endif + // Note: On Windows, the subclassing adapter takes care of this. +} + +void AccessibilityDriverAccessKit::accessibility_update_set_role(const RID &p_id, DisplayServer::AccessibilityRole p_role) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + if (ae->role == _accessibility_role(p_role)) { + return; + } + ae->role = _accessibility_role(p_role); + _ensure_node(p_id, ae); + + accesskit_node_set_role(ae->node, ae->role); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_name(const RID &p_id, const String &p_name) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + ae->name = p_name; + String full_name = ae->name + " " + ae->name_extra_info; + if (!full_name.is_empty()) { + accesskit_node_set_label(ae->node, full_name.utf8().ptr()); + } else { + accesskit_node_clear_label(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_extra_info(const RID &p_id, const String &p_name_extra_info) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + ae->name_extra_info = p_name_extra_info; + String full_name = ae->name + " " + ae->name_extra_info; + if (!full_name.is_empty()) { + accesskit_node_set_label(ae->node, full_name.utf8().ptr()); + } else { + accesskit_node_clear_label(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_description(const RID &p_id, const String &p_description) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_description.is_empty()) { + accesskit_node_set_description(ae->node, p_description.utf8().ptr()); + } else { + accesskit_node_clear_description(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_value(const RID &p_id, const String &p_value) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_value.is_empty()) { + Vector ch_length; + accesskit_node_set_value(ae->node, p_value.utf8(&ch_length).ptr()); + accesskit_node_set_character_lengths(ae->node, ch_length.size(), ch_length.ptr()); + } else { + accesskit_node_clear_value(ae->node); + accesskit_node_clear_character_lengths(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_tooltip(const RID &p_id, const String &p_tooltip) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_tooltip.is_empty()) { + accesskit_node_set_tooltip(ae->node, p_tooltip.utf8().ptr()); + } else { + accesskit_node_clear_tooltip(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_bounds(const RID &p_id, const Rect2 &p_rect) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_rect rect; + rect.x0 = p_rect.position.x; + rect.y0 = p_rect.position.y; + rect.x1 = p_rect.position.x + p_rect.size.x; + rect.y1 = p_rect.position.y + p_rect.size.y; + accesskit_node_set_bounds(ae->node, rect); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_transform(const RID &p_id, const Transform2D &p_transform) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_affine transform = { p_transform.columns[0][0], p_transform.columns[0][1], p_transform.columns[1][0], p_transform.columns[1][1], p_transform.columns[2][0], p_transform.columns[2][1] }; + accesskit_node_set_transform(ae->node, transform); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_child(const RID &p_id, const RID &p_child_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_child_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_push_child(ae->node, (accesskit_node_id)p_child_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_related_controls(const RID &p_id, const RID &p_related_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_related_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_push_controlled(ae->node, (accesskit_node_id)p_related_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_related_details(const RID &p_id, const RID &p_related_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_related_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_push_detail(ae->node, (accesskit_node_id)p_related_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_related_described_by(const RID &p_id, const RID &p_related_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_related_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_push_described_by(ae->node, (accesskit_node_id)p_related_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_related_flow_to(const RID &p_id, const RID &p_related_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_related_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_push_flow_to(ae->node, (accesskit_node_id)p_related_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_related_labeled_by(const RID &p_id, const RID &p_related_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_related_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_push_labelled_by(ae->node, (accesskit_node_id)p_related_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_related_radio_group(const RID &p_id, const RID &p_related_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_related_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_push_to_radio_group(ae->node, (accesskit_node_id)p_related_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_active_descendant(const RID &p_id, const RID &p_other_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_other_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_set_active_descendant(ae->node, (accesskit_node_id)p_other_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_next_on_line(const RID &p_id, const RID &p_other_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_other_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_set_next_on_line(ae->node, (accesskit_node_id)p_other_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_previous_on_line(const RID &p_id, const RID &p_other_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_other_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_set_previous_on_line(ae->node, (accesskit_node_id)p_other_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_member_of(const RID &p_id, const RID &p_group_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_group_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_set_member_of(ae->node, (accesskit_node_id)p_group_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_in_page_link_target(const RID &p_id, const RID &p_other_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_other_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_set_in_page_link_target(ae->node, (accesskit_node_id)p_other_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_error_message(const RID &p_id, const RID &p_other_id) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *other_ae = rid_owner.get_or_null(p_other_id); + ERR_FAIL_NULL(other_ae); + ERR_FAIL_COND(other_ae->window_id != ae->window_id); + _ensure_node(p_id, ae); + + accesskit_node_set_error_message(ae->node, (accesskit_node_id)p_other_id.get_id()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_live(const RID &p_id, DisplayServer::AccessibilityLiveMode p_live) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + switch (p_live) { + case DisplayServer::AccessibilityLiveMode::LIVE_OFF: { + accesskit_node_set_live(ae->node, ACCESSKIT_LIVE_OFF); + } break; + case DisplayServer::AccessibilityLiveMode::LIVE_POLITE: { + accesskit_node_set_live(ae->node, ACCESSKIT_LIVE_POLITE); + } break; + case DisplayServer::AccessibilityLiveMode::LIVE_ASSERTIVE: { + accesskit_node_set_live(ae->node, ACCESSKIT_LIVE_ASSERTIVE); + } break; + } +} + +void AccessibilityDriverAccessKit::accessibility_update_add_action(const RID &p_id, DisplayServer::AccessibilityAction p_action, const Callable &p_callable) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + ae->actions[_accessibility_action(p_action)] = p_callable; + + accesskit_node_add_action(ae->node, _accessibility_action(p_action)); +} + +void AccessibilityDriverAccessKit::accessibility_update_add_custom_action(const RID &p_id, int p_action_id, const String &p_action_description) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_action_description.is_empty()) { + accesskit_custom_action ca = accesskit_custom_action_new(p_action_id, p_action_description.utf8().ptr()); + accesskit_node_push_custom_action(ae->node, ca); + } else { + String cs_name = vformat("Custom Action %d", p_action_id); + accesskit_custom_action ca = accesskit_custom_action_new(p_action_id, cs_name.utf8().ptr()); + accesskit_node_push_custom_action(ae->node, ca); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_table_row_count(const RID &p_id, int p_count) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_row_count(ae->node, p_count); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_table_column_count(const RID &p_id, int p_count) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_column_count(ae->node, p_count); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_table_row_index(const RID &p_id, int p_index) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_row_index(ae->node, p_index); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_table_column_index(const RID &p_id, int p_index) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_column_index(ae->node, p_index); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_table_cell_position(const RID &p_id, int p_row_index, int p_column_index) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_row_index(ae->node, p_row_index); + accesskit_node_set_column_index(ae->node, p_column_index); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_table_cell_span(const RID &p_id, int p_row_span, int p_column_span) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_row_span(ae->node, p_row_span); + accesskit_node_set_column_span(ae->node, p_column_span); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_list_item_count(const RID &p_id, int p_size) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_size_of_set(ae->node, p_size); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_list_item_index(const RID &p_id, int p_index) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_position_in_set(ae->node, p_index); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_list_item_level(const RID &p_id, int p_level) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_level(ae->node, p_level); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_list_item_selected(const RID &p_id, bool p_selected) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_selected(ae->node, p_selected); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_list_item_expanded(const RID &p_id, bool p_expanded) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_expanded(ae->node, p_expanded); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_popup_type(const RID &p_id, DisplayServer::AccessibilityPopupType p_popup) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + switch (p_popup) { + case DisplayServer::AccessibilityPopupType::POPUP_UNKNOWN: { + accesskit_node_set_has_popup(ae->node, ACCESSKIT_HAS_POPUP_TRUE); + } break; + case DisplayServer::AccessibilityPopupType::POPUP_MENU: { + accesskit_node_set_has_popup(ae->node, ACCESSKIT_HAS_POPUP_MENU); + } break; + case DisplayServer::AccessibilityPopupType::POPUP_LIST: { + accesskit_node_set_has_popup(ae->node, ACCESSKIT_HAS_POPUP_LISTBOX); + } break; + case DisplayServer::AccessibilityPopupType::POPUP_TREE: { + accesskit_node_set_has_popup(ae->node, ACCESSKIT_HAS_POPUP_TREE); + } break; + case DisplayServer::AccessibilityPopupType::POPUP_DIALOG: { + accesskit_node_set_has_popup(ae->node, ACCESSKIT_HAS_POPUP_DIALOG); + } break; + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_checked(const RID &p_id, bool p_checekd) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (p_checekd) { + accesskit_node_set_toggled(ae->node, ACCESSKIT_TOGGLED_TRUE); + } else { + accesskit_node_set_toggled(ae->node, ACCESSKIT_TOGGLED_FALSE); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_num_value(const RID &p_id, double p_position) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_numeric_value(ae->node, p_position); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_num_range(const RID &p_id, double p_min, double p_max) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_min_numeric_value(ae->node, p_min); + accesskit_node_set_max_numeric_value(ae->node, p_max); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_num_step(const RID &p_id, double p_step) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_numeric_value_step(ae->node, p_step); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_num_jump(const RID &p_id, double p_jump) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_numeric_value_jump(ae->node, p_jump); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_scroll_x(const RID &p_id, double p_position) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_scroll_x(ae->node, p_position); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_scroll_x_range(const RID &p_id, double p_min, double p_max) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_scroll_x_min(ae->node, p_min); + accesskit_node_set_scroll_x_max(ae->node, p_max); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_scroll_y(const RID &p_id, double p_position) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_scroll_y(ae->node, p_position); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_scroll_y_range(const RID &p_id, double p_min, double p_max) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_scroll_y_min(ae->node, p_min); + accesskit_node_set_scroll_y_max(ae->node, p_max); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_text_decorations(const RID &p_id, bool p_underline, bool p_strikethrough, bool p_overline) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (p_underline) { + accesskit_node_set_underline(ae->node, ACCESSKIT_TEXT_DECORATION_SOLID); + } else { + accesskit_node_clear_underline(ae->node); + } + if (p_overline) { + accesskit_node_set_overline(ae->node, ACCESSKIT_TEXT_DECORATION_SOLID); + } else { + accesskit_node_clear_overline(ae->node); + } + if (p_strikethrough) { + accesskit_node_set_strikethrough(ae->node, ACCESSKIT_TEXT_DECORATION_SOLID); + } else { + accesskit_node_clear_strikethrough(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_text_align(const RID &p_id, HorizontalAlignment p_align) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + switch (p_align) { + case HORIZONTAL_ALIGNMENT_LEFT: { + accesskit_node_set_text_align(ae->node, ACCESSKIT_TEXT_ALIGN_LEFT); + } break; + case HORIZONTAL_ALIGNMENT_CENTER: { + accesskit_node_set_text_align(ae->node, ACCESSKIT_TEXT_ALIGN_RIGHT); + } break; + case HORIZONTAL_ALIGNMENT_RIGHT: { + accesskit_node_set_text_align(ae->node, ACCESSKIT_TEXT_ALIGN_CENTER); + } break; + case HORIZONTAL_ALIGNMENT_FILL: { + accesskit_node_set_text_align(ae->node, ACCESSKIT_TEXT_ALIGN_JUSTIFY); + } break; + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_text_selection(const RID &p_id, const RID &p_text_start_id, int p_start_char, const RID &p_text_end_id, int p_end_char) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + AccessibilityElement *start_ae = rid_owner.get_or_null(p_text_start_id); + ERR_FAIL_NULL(start_ae); + ERR_FAIL_COND(start_ae->window_id != ae->window_id); + AccessibilityElement *end_ae = rid_owner.get_or_null(p_text_end_id); + ERR_FAIL_NULL(end_ae); + ERR_FAIL_COND(end_ae->window_id != ae->window_id); + + int start_pos = p_start_char; + int end_pos = p_end_char; + RID start_rid; + RID end_rid; + for (const RID &rid : start_ae->children) { + const AccessibilityElement *child_ae = rid_owner.get_or_null(rid); + if (child_ae && child_ae->role == ACCESSKIT_ROLE_TEXT_RUN) { + if (p_start_char >= child_ae->run.x && p_start_char <= child_ae->run.y) { + start_rid = rid; + start_pos = p_start_char - child_ae->run.x; + break; + } + } + } + for (const RID &rid : end_ae->children) { + const AccessibilityElement *child_ae = rid_owner.get_or_null(rid); + if (child_ae && child_ae->role == ACCESSKIT_ROLE_TEXT_RUN) { + if (p_end_char >= child_ae->run.x && p_end_char <= child_ae->run.y) { + end_rid = rid; + end_pos = p_end_char - child_ae->run.x; + break; + } + } + } + ERR_FAIL_COND(start_rid.is_null() && end_rid.is_null()); + _ensure_node(p_id, ae); + + accesskit_text_selection sel; + sel.anchor.node = (accesskit_node_id)start_rid.get_id(); + sel.anchor.character_index = start_pos; + sel.focus.node = (accesskit_node_id)end_rid.get_id(); + sel.focus.character_index = end_pos; + accesskit_node_set_text_selection(ae->node, sel); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_flag(const RID &p_id, DisplayServer::AccessibilityFlags p_flag, bool p_value) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + switch (p_flag) { + case DisplayServer::AccessibilityFlags::FLAG_HIDDEN: { + if (p_value) { + accesskit_node_set_hidden(ae->node); + } else { + accesskit_node_clear_hidden(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_LINKED: { + if (p_value) { + accesskit_node_set_linked(ae->node); + } else { + accesskit_node_clear_linked(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_MULTISELECTABLE: { + if (p_value) { + accesskit_node_set_multiselectable(ae->node); + } else { + accesskit_node_clear_multiselectable(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_REQUIRED: { + if (p_value) { + accesskit_node_set_required(ae->node); + } else { + accesskit_node_clear_required(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_VISITED: { + if (p_value) { + accesskit_node_set_visited(ae->node); + } else { + accesskit_node_clear_visited(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_BUSY: { + if (p_value) { + accesskit_node_set_busy(ae->node); + } else { + accesskit_node_clear_busy(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_MODAL: { + if (p_value) { + accesskit_node_set_modal(ae->node); + } else { + accesskit_node_clear_modal(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_TOUCH_PASSTHROUGH: { + if (p_value) { + accesskit_node_set_touch_transparent(ae->node); + } else { + accesskit_node_clear_touch_transparent(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_READONLY: { + if (p_value) { + accesskit_node_set_read_only(ae->node); + } else { + accesskit_node_clear_read_only(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_DISABLED: { + if (p_value) { + accesskit_node_set_disabled(ae->node); + } else { + accesskit_node_clear_disabled(ae->node); + } + } break; + case DisplayServer::AccessibilityFlags::FLAG_CLIPS_CHILDREN: { + if (p_value) { + accesskit_node_set_clips_children(ae->node); + } else { + accesskit_node_clear_clips_children(ae->node); + } + } break; + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_classname(const RID &p_id, const String &p_classname) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_classname.is_empty()) { + accesskit_node_set_class_name(ae->node, p_classname.utf8().ptr()); + } else { + accesskit_node_clear_class_name(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_placeholder(const RID &p_id, const String &p_placeholder) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_placeholder.is_empty()) { + accesskit_node_set_placeholder(ae->node, p_placeholder.utf8().ptr()); + } else { + accesskit_node_clear_placeholder(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_language(const RID &p_id, const String &p_language) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_language(ae->node, p_language.utf8().ptr()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_text_orientation(const RID &p_id, bool p_vertical) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (p_vertical) { + accesskit_node_set_text_direction(ae->node, ACCESSKIT_TEXT_DIRECTION_TOP_TO_BOTTOM); + } else { + accesskit_node_set_text_direction(ae->node, ACCESSKIT_TEXT_DIRECTION_LEFT_TO_RIGHT); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_list_orientation(const RID &p_id, bool p_vertical) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (p_vertical) { + accesskit_node_set_orientation(ae->node, ACCESSKIT_ORIENTATION_VERTICAL); + } else { + accesskit_node_set_orientation(ae->node, ACCESSKIT_ORIENTATION_HORIZONTAL); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_shortcut(const RID &p_id, const String &p_shortcut) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_shortcut.is_empty()) { + accesskit_node_set_keyboard_shortcut(ae->node, p_shortcut.utf8().ptr()); + } else { + accesskit_node_clear_keyboard_shortcut(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_url(const RID &p_id, const String &p_url) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_url.is_empty()) { + accesskit_node_set_url(ae->node, p_url.utf8().ptr()); + } else { + accesskit_node_clear_url(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_role_description(const RID &p_id, const String &p_description) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_description.is_empty()) { + accesskit_node_set_role_description(ae->node, p_description.utf8().ptr()); + } else { + accesskit_node_clear_role_description(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_state_description(const RID &p_id, const String &p_description) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + if (!p_description.is_empty()) { + accesskit_node_set_state_description(ae->node, p_description.utf8().ptr()); + } else { + accesskit_node_clear_state_description(ae->node); + } +} + +void AccessibilityDriverAccessKit::accessibility_update_set_color_value(const RID &p_id, const Color &p_color) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_color_value(ae->node, p_color.to_rgba32()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_background_color(const RID &p_id, const Color &p_color) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_background_color(ae->node, p_color.to_rgba32()); +} + +void AccessibilityDriverAccessKit::accessibility_update_set_foreground_color(const RID &p_id, const Color &p_color) { + ERR_FAIL_COND_MSG(!in_accessibility_update, "Accessiblinity update is only allowed inside NOTIFICATION_ACCESSIBILITY_UPDATE notification."); + + AccessibilityElement *ae = rid_owner.get_or_null(p_id); + ERR_FAIL_NULL(ae); + _ensure_node(p_id, ae); + + accesskit_node_set_foreground_color(ae->node, p_color.to_rgba32()); +} + +Error AccessibilityDriverAccessKit::init() { +#ifdef ACCESSKIT_DYNAMIC +#ifdef DEBUG_ENABLED + int dylibloader_verbose = 1; +#else + int dylibloader_verbose = 0; +#endif + void *library_handle = nullptr; + String path; + String arch = Engine::get_singleton()->get_architecture_name(); +#ifdef LINUXBSD_ENABLED + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("libaccesskit." + arch + ".so"); + if (!FileAccess::exists(path)) { + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("../lib").path_join("libaccesskit." + arch + ".so"); + } + if (!FileAccess::exists(path)) { + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("libaccesskit.so"); + } + if (!FileAccess::exists(path)) { + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("../lib").path_join("libaccesskit.so"); + } + if (!FileAccess::exists(path)) { + return ERR_CANT_CREATE; + } +#endif +#ifdef MACOS_ENABLED + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("libaccesskit." + arch + ".dylib"); + if (!FileAccess::exists(path)) { + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("../Frameworks").path_join("libaccesskit." + arch + ".dylib"); + } + if (!FileAccess::exists(path)) { + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("libaccesskit.dylib"); + } + if (!FileAccess::exists(path)) { + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("../Frameworks").path_join("libaccesskit.dylib"); + } + if (!FileAccess::exists(path)) { + return ERR_CANT_CREATE; + } +#endif +#ifdef WINDOWS_ENABLED + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("accesskit." + arch + ".dll"); + if (!FileAccess::exists(path)) { + path = OS::get_singleton()->get_executable_path().get_base_dir().path_join("accesskit.dll"); + } + if (!FileAccess::exists(path)) { + return ERR_CANT_CREATE; + } +#endif + + Error err = OS::get_singleton()->open_dynamic_library(path, library_handle); + if (err == OK && initialize_libaccesskit(dylibloader_verbose, library_handle) == 0) { + print_verbose("AccessKit loaded."); + } else { + return ERR_CANT_CREATE; + } +#endif +#ifdef MACOS_ENABLED + //accesskit_macos_add_focus_forwarder_to_window_class("GodotWindow"); +#endif + return OK; +} + +AccessibilityDriverAccessKit::AccessibilityDriverAccessKit() { + singleton = this; + + role_map[DisplayServer::AccessibilityRole::ROLE_UNKNOWN] = ACCESSKIT_ROLE_UNKNOWN; + role_map[DisplayServer::AccessibilityRole::ROLE_DEFAULT_BUTTON] = ACCESSKIT_ROLE_DEFAULT_BUTTON; + role_map[DisplayServer::AccessibilityRole::ROLE_AUDIO] = ACCESSKIT_ROLE_AUDIO; + role_map[DisplayServer::AccessibilityRole::ROLE_VIDEO] = ACCESSKIT_ROLE_VIDEO; + role_map[DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT] = ACCESSKIT_ROLE_LABEL; + role_map[DisplayServer::AccessibilityRole::ROLE_CONTAINER] = ACCESSKIT_ROLE_GENERIC_CONTAINER; + role_map[DisplayServer::AccessibilityRole::ROLE_PANEL] = ACCESSKIT_ROLE_PANE; + role_map[DisplayServer::AccessibilityRole::ROLE_BUTTON] = ACCESSKIT_ROLE_BUTTON; + role_map[DisplayServer::AccessibilityRole::ROLE_LINK] = ACCESSKIT_ROLE_LINK; + role_map[DisplayServer::AccessibilityRole::ROLE_CHECK_BOX] = ACCESSKIT_ROLE_CHECK_BOX; + role_map[DisplayServer::AccessibilityRole::ROLE_RADIO_BUTTON] = ACCESSKIT_ROLE_RADIO_BUTTON; + role_map[DisplayServer::AccessibilityRole::ROLE_CHECK_BUTTON] = ACCESSKIT_ROLE_SWITCH; + role_map[DisplayServer::AccessibilityRole::ROLE_SCROLL_BAR] = ACCESSKIT_ROLE_SCROLL_BAR; + role_map[DisplayServer::AccessibilityRole::ROLE_SCROLL_VIEW] = ACCESSKIT_ROLE_SCROLL_VIEW; + role_map[DisplayServer::AccessibilityRole::ROLE_SPLITTER] = ACCESSKIT_ROLE_SPLITTER; + role_map[DisplayServer::AccessibilityRole::ROLE_SLIDER] = ACCESSKIT_ROLE_SLIDER; + role_map[DisplayServer::AccessibilityRole::ROLE_SPIN_BUTTON] = ACCESSKIT_ROLE_SPIN_BUTTON; + role_map[DisplayServer::AccessibilityRole::ROLE_PROGRESS_INDICATOR] = ACCESSKIT_ROLE_PROGRESS_INDICATOR; + role_map[DisplayServer::AccessibilityRole::ROLE_TEXT_FIELD] = ACCESSKIT_ROLE_TEXT_INPUT; + role_map[DisplayServer::AccessibilityRole::ROLE_MULTILINE_TEXT_FIELD] = ACCESSKIT_ROLE_MULTILINE_TEXT_INPUT; + role_map[DisplayServer::AccessibilityRole::ROLE_COLOR_PICKER] = ACCESSKIT_ROLE_COLOR_WELL; + role_map[DisplayServer::AccessibilityRole::ROLE_TABLE] = ACCESSKIT_ROLE_TABLE; + role_map[DisplayServer::AccessibilityRole::ROLE_CELL] = ACCESSKIT_ROLE_CELL; + role_map[DisplayServer::AccessibilityRole::ROLE_ROW] = ACCESSKIT_ROLE_ROW; + role_map[DisplayServer::AccessibilityRole::ROLE_ROW_GROUP] = ACCESSKIT_ROLE_ROW_GROUP; + role_map[DisplayServer::AccessibilityRole::ROLE_ROW_HEADER] = ACCESSKIT_ROLE_ROW_HEADER; + role_map[DisplayServer::AccessibilityRole::ROLE_COLUMN_HEADER] = ACCESSKIT_ROLE_COLUMN_HEADER; + role_map[DisplayServer::AccessibilityRole::ROLE_TREE] = ACCESSKIT_ROLE_TREE; + role_map[DisplayServer::AccessibilityRole::ROLE_TREE_ITEM] = ACCESSKIT_ROLE_TREE_ITEM; + role_map[DisplayServer::AccessibilityRole::ROLE_LIST] = ACCESSKIT_ROLE_LIST; + role_map[DisplayServer::AccessibilityRole::ROLE_LIST_ITEM] = ACCESSKIT_ROLE_LIST_ITEM; + role_map[DisplayServer::AccessibilityRole::ROLE_LIST_BOX] = ACCESSKIT_ROLE_LIST_BOX; + role_map[DisplayServer::AccessibilityRole::ROLE_LIST_BOX_OPTION] = ACCESSKIT_ROLE_LIST_BOX_OPTION; + role_map[DisplayServer::AccessibilityRole::ROLE_TAB_BAR] = ACCESSKIT_ROLE_TAB_LIST; + role_map[DisplayServer::AccessibilityRole::ROLE_TAB] = ACCESSKIT_ROLE_TAB; + role_map[DisplayServer::AccessibilityRole::ROLE_TAB_PANEL] = ACCESSKIT_ROLE_TAB_PANEL; + role_map[DisplayServer::AccessibilityRole::ROLE_MENU_BAR] = ACCESSKIT_ROLE_MENU_BAR; + role_map[DisplayServer::AccessibilityRole::ROLE_MENU] = ACCESSKIT_ROLE_MENU; + role_map[DisplayServer::AccessibilityRole::ROLE_MENU_ITEM] = ACCESSKIT_ROLE_MENU_ITEM; + role_map[DisplayServer::AccessibilityRole::ROLE_MENU_ITEM_CHECK_BOX] = ACCESSKIT_ROLE_MENU_ITEM_CHECK_BOX; + role_map[DisplayServer::AccessibilityRole::ROLE_MENU_ITEM_RADIO] = ACCESSKIT_ROLE_MENU_ITEM_RADIO; + role_map[DisplayServer::AccessibilityRole::ROLE_IMAGE] = ACCESSKIT_ROLE_IMAGE; + role_map[DisplayServer::AccessibilityRole::ROLE_WINDOW] = ACCESSKIT_ROLE_WINDOW; + role_map[DisplayServer::AccessibilityRole::ROLE_TITLE_BAR] = ACCESSKIT_ROLE_TITLE_BAR; + role_map[DisplayServer::AccessibilityRole::ROLE_DIALOG] = ACCESSKIT_ROLE_DIALOG; + role_map[DisplayServer::AccessibilityRole::ROLE_TOOLTIP] = ACCESSKIT_ROLE_TOOLTIP; + + action_map[DisplayServer::AccessibilityAction::ACTION_CLICK] = ACCESSKIT_ACTION_CLICK; + action_map[DisplayServer::AccessibilityAction::ACTION_FOCUS] = ACCESSKIT_ACTION_FOCUS; + action_map[DisplayServer::AccessibilityAction::ACTION_BLUR] = ACCESSKIT_ACTION_BLUR; + action_map[DisplayServer::AccessibilityAction::ACTION_COLLAPSE] = ACCESSKIT_ACTION_COLLAPSE; + action_map[DisplayServer::AccessibilityAction::ACTION_EXPAND] = ACCESSKIT_ACTION_EXPAND; + action_map[DisplayServer::AccessibilityAction::ACTION_DECREMENT] = ACCESSKIT_ACTION_DECREMENT; + action_map[DisplayServer::AccessibilityAction::ACTION_INCREMENT] = ACCESSKIT_ACTION_INCREMENT; + action_map[DisplayServer::AccessibilityAction::ACTION_HIDE_TOOLTIP] = ACCESSKIT_ACTION_HIDE_TOOLTIP; + action_map[DisplayServer::AccessibilityAction::ACTION_SHOW_TOOLTIP] = ACCESSKIT_ACTION_SHOW_TOOLTIP; + //action_map[DisplayServer::AccessibilityAction::ACTION_INVALIDATE_TREE] = ACCESSKIT_ACTION_INVALIDATE_TREE; + //action_map[DisplayServer::AccessibilityAction::ACTION_LOAD_INLINE_TEXT_BOXES] = ACCESSKIT_ACTION_LOAD_INLINE_TEXT_BOXES; + action_map[DisplayServer::AccessibilityAction::ACTION_SET_TEXT_SELECTION] = ACCESSKIT_ACTION_SET_TEXT_SELECTION; + action_map[DisplayServer::AccessibilityAction::ACTION_REPLACE_SELECTED_TEXT] = ACCESSKIT_ACTION_REPLACE_SELECTED_TEXT; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_BACKWARD] = ACCESSKIT_ACTION_SCROLL_BACKWARD; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_DOWN] = ACCESSKIT_ACTION_SCROLL_DOWN; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_FORWARD] = ACCESSKIT_ACTION_SCROLL_FORWARD; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_LEFT] = ACCESSKIT_ACTION_SCROLL_LEFT; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_RIGHT] = ACCESSKIT_ACTION_SCROLL_RIGHT; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_UP] = ACCESSKIT_ACTION_SCROLL_UP; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW] = ACCESSKIT_ACTION_SCROLL_INTO_VIEW; + action_map[DisplayServer::AccessibilityAction::ACTION_SCROLL_TO_POINT] = ACCESSKIT_ACTION_SCROLL_TO_POINT; + action_map[DisplayServer::AccessibilityAction::ACTION_SET_SCROLL_OFFSET] = ACCESSKIT_ACTION_SET_SCROLL_OFFSET; + //action_map[DisplayServer::AccessibilityAction::ACTION_SET_SEQUENTIAL_FOCUS_NAVIGATION_STARTING_POINT] = ACCESSKIT_ACTION_SET_SEQUENTIAL_FOCUS_NAVIGATION_STARTING_POINT; + action_map[DisplayServer::AccessibilityAction::ACTION_SET_VALUE] = ACCESSKIT_ACTION_SET_VALUE; + action_map[DisplayServer::AccessibilityAction::ACTION_SHOW_CONTEXT_MENU] = ACCESSKIT_ACTION_SHOW_CONTEXT_MENU; + action_map[DisplayServer::AccessibilityAction::ACTION_CUSTOM] = ACCESSKIT_ACTION_CUSTOM_ACTION; +} + +AccessibilityDriverAccessKit::~AccessibilityDriverAccessKit() { + singleton = nullptr; +} + +#endif // ACCESSKIT_ENABLED diff --git a/drivers/accesskit/accessibility_driver_accesskit.h b/drivers/accesskit/accessibility_driver_accesskit.h new file mode 100644 index 00000000000..5676ebe8406 --- /dev/null +++ b/drivers/accesskit/accessibility_driver_accesskit.h @@ -0,0 +1,197 @@ +/**************************************************************************/ +/* accessibility_driver_accesskit.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#pragma once + +#ifdef ACCESSKIT_ENABLED + +#include "core/templates/rid_owner.h" +#include "servers/display_server.h" + +#ifdef ACCESSKIT_DYNAMIC +#ifdef LINUXBSD_ENABLED +#include "drivers/accesskit/dynwrappers/accesskit-so_wrap.h" +#endif +#ifdef MACOS_ENABLED +#include "drivers/accesskit/dynwrappers/accesskit-dylib_wrap.h" +#endif +#ifdef WINDOWS_ENABLED +#include "drivers/accesskit/dynwrappers/accesskit-dll_wrap.h" +#endif +#else +#include +#endif + +class AccessibilityDriverAccessKit : public AccessibilityDriver { + static AccessibilityDriverAccessKit *singleton; + + struct AccessibilityElement { + HashMap actions; + + DisplayServer::WindowID window_id = DisplayServer::INVALID_WINDOW_ID; + RID parent; + LocalVector children; + Vector3i run; + Variant meta; + String name; + String name_extra_info; + + accesskit_role role = ACCESSKIT_ROLE_UNKNOWN; + accesskit_node *node = nullptr; + }; + mutable RID_PtrOwner rid_owner; + + struct WindowData { + // Adapter. +#ifdef WINDOWS_ENABLED + accesskit_windows_subclassing_adapter *adapter = nullptr; +#endif +#ifdef MACOS_ENABLED + accesskit_macos_subclassing_adapter *adapter = nullptr; +#endif +#ifdef LINUXBSD_ENABLED + accesskit_unix_adapter *adapter = nullptr; +#endif + + RID root_id; + HashSet update; + }; + + RID focus; + + HashMap windows; + + HashMap role_map; + HashMap action_map; + + _FORCE_INLINE_ accesskit_role _accessibility_role(DisplayServer::AccessibilityRole p_role) const; + _FORCE_INLINE_ accesskit_action _accessibility_action(DisplayServer::AccessibilityAction p_action) const; + + void _free_recursive(WindowData *p_wd, const RID &p_id); + _FORCE_INLINE_ void _ensure_node(const RID &p_id, AccessibilityElement *p_ae); + + static void _accessibility_action_callback(struct accesskit_action_request *p_request, void *p_user_data); + static accesskit_tree_update *_accessibility_initial_tree_update_callback(void *p_user_data); + static void _accessibility_deactivation_callback(void *p_user_data); + static accesskit_tree_update *_accessibility_build_tree_update(void *p_user_data); + + bool in_accessibility_update = false; + Callable update_cb; + +public: + Error init() override; + + bool window_create(DisplayServer::WindowID p_window_id, void *p_handle) override; + void window_destroy(DisplayServer::WindowID p_window_id) override; + + RID accessibility_create_element(DisplayServer::WindowID p_window_id, DisplayServer::AccessibilityRole p_role) override; + RID accessibility_create_sub_element(const RID &p_parent_rid, DisplayServer::AccessibilityRole p_role, int p_insert_pos = -1) override; + virtual RID accessibility_create_sub_text_edit_elements(const RID &p_parent_rid, const RID &p_shaped_text, float p_min_height, int p_insert_pos = -1) override; + bool accessibility_has_element(const RID &p_id) const override; + void accessibility_free_element(const RID &p_id) override; + + void accessibility_element_set_meta(const RID &p_id, const Variant &p_meta) override; + Variant accessibility_element_get_meta(const RID &p_id) const override; + + void accessibility_update_if_active(const Callable &p_callable) override; + + void accessibility_update_set_focus(const RID &p_id) override; + RID accessibility_get_window_root(DisplayServer::WindowID p_window_id) const override; + + void accessibility_set_window_rect(DisplayServer::WindowID p_window_id, const Rect2 &p_rect_out, const Rect2 &p_rect_in) override; + void accessibility_set_window_focused(DisplayServer::WindowID p_window_id, bool p_focused) override; + + void accessibility_update_set_role(const RID &p_id, DisplayServer::AccessibilityRole p_role) override; + void accessibility_update_set_name(const RID &p_id, const String &p_name) override; + void accessibility_update_set_extra_info(const RID &p_id, const String &p_name_extra_info) override; + void accessibility_update_set_description(const RID &p_id, const String &p_description) override; + void accessibility_update_set_value(const RID &p_id, const String &p_value) override; + void accessibility_update_set_tooltip(const RID &p_id, const String &p_tooltip) override; + void accessibility_update_set_bounds(const RID &p_id, const Rect2 &p_rect) override; + void accessibility_update_set_transform(const RID &p_id, const Transform2D &p_transform) override; + void accessibility_update_add_child(const RID &p_id, const RID &p_child_id) override; + void accessibility_update_add_related_controls(const RID &p_id, const RID &p_related_id) override; + void accessibility_update_add_related_details(const RID &p_id, const RID &p_related_id) override; + void accessibility_update_add_related_described_by(const RID &p_id, const RID &p_related_id) override; + void accessibility_update_add_related_flow_to(const RID &p_id, const RID &p_related_id) override; + void accessibility_update_add_related_labeled_by(const RID &p_id, const RID &p_related_id) override; + void accessibility_update_add_related_radio_group(const RID &p_id, const RID &p_related_id) override; + void accessibility_update_set_active_descendant(const RID &p_id, const RID &p_other_id) override; + void accessibility_update_set_next_on_line(const RID &p_id, const RID &p_other_id) override; + void accessibility_update_set_previous_on_line(const RID &p_id, const RID &p_other_id) override; + void accessibility_update_set_member_of(const RID &p_id, const RID &p_group_id) override; + void accessibility_update_set_in_page_link_target(const RID &p_id, const RID &p_other_id) override; + void accessibility_update_set_error_message(const RID &p_id, const RID &p_other_id) override; + void accessibility_update_set_live(const RID &p_id, DisplayServer::AccessibilityLiveMode p_live) override; + void accessibility_update_add_action(const RID &p_id, DisplayServer::AccessibilityAction p_action, const Callable &p_callable) override; + void accessibility_update_add_custom_action(const RID &p_id, int p_action_id, const String &p_action_description) override; + void accessibility_update_set_table_row_count(const RID &p_id, int p_count) override; + void accessibility_update_set_table_column_count(const RID &p_id, int p_count) override; + void accessibility_update_set_table_row_index(const RID &p_id, int p_index) override; + void accessibility_update_set_table_column_index(const RID &p_id, int p_index) override; + void accessibility_update_set_table_cell_position(const RID &p_id, int p_row_index, int p_column_index) override; + void accessibility_update_set_table_cell_span(const RID &p_id, int p_row_span, int p_column_span) override; + void accessibility_update_set_list_item_count(const RID &p_id, int p_size) override; + void accessibility_update_set_list_item_index(const RID &p_id, int p_index) override; + void accessibility_update_set_list_item_level(const RID &p_id, int p_level) override; + void accessibility_update_set_list_item_selected(const RID &p_id, bool p_selected) override; + void accessibility_update_set_list_item_expanded(const RID &p_id, bool p_expanded) override; + void accessibility_update_set_popup_type(const RID &p_id, DisplayServer::AccessibilityPopupType p_popup) override; + void accessibility_update_set_checked(const RID &p_id, bool p_checekd) override; + void accessibility_update_set_num_value(const RID &p_id, double p_position) override; + void accessibility_update_set_num_range(const RID &p_id, double p_min, double p_max) override; + void accessibility_update_set_num_step(const RID &p_id, double p_step) override; + void accessibility_update_set_num_jump(const RID &p_id, double p_jump) override; + void accessibility_update_set_scroll_x(const RID &p_id, double p_position) override; + void accessibility_update_set_scroll_x_range(const RID &p_id, double p_min, double p_max) override; + void accessibility_update_set_scroll_y(const RID &p_id, double p_position) override; + void accessibility_update_set_scroll_y_range(const RID &p_id, double p_min, double p_max) override; + void accessibility_update_set_text_decorations(const RID &p_id, bool p_underline, bool p_strikethrough, bool p_overline) override; + void accessibility_update_set_text_align(const RID &p_id, HorizontalAlignment p_align) override; + void accessibility_update_set_text_selection(const RID &p_id, const RID &p_text_start_id, int p_start_char, const RID &p_text_end_id, int p_end_char) override; + void accessibility_update_set_flag(const RID &p_id, DisplayServer::AccessibilityFlags p_flag, bool p_value) override; + void accessibility_update_set_classname(const RID &p_id, const String &p_classname) override; + void accessibility_update_set_placeholder(const RID &p_id, const String &p_placeholder) override; + void accessibility_update_set_language(const RID &p_id, const String &p_language) override; + void accessibility_update_set_text_orientation(const RID &p_id, bool p_vertical) override; + void accessibility_update_set_list_orientation(const RID &p_id, bool p_vertical) override; + void accessibility_update_set_shortcut(const RID &p_id, const String &p_shortcut) override; + void accessibility_update_set_url(const RID &p_id, const String &p_url) override; + void accessibility_update_set_role_description(const RID &p_id, const String &p_description) override; + void accessibility_update_set_state_description(const RID &p_id, const String &p_description) override; + void accessibility_update_set_color_value(const RID &p_id, const Color &p_color) override; + void accessibility_update_set_background_color(const RID &p_id, const Color &p_color) override; + void accessibility_update_set_foreground_color(const RID &p_id, const Color &p_color) override; + + AccessibilityDriverAccessKit(); + ~AccessibilityDriverAccessKit(); +}; + +#endif // ACCESSKIT_ENABLED diff --git a/drivers/accesskit/dynwrappers/accesskit-dll_wrap.c b/drivers/accesskit/dynwrappers/accesskit-dll_wrap.c new file mode 100644 index 00000000000..27b23873a87 --- /dev/null +++ b/drivers/accesskit/dynwrappers/accesskit-dll_wrap.c @@ -0,0 +1,4319 @@ +// This file is generated. Do not edit! +// see https://github.com/hpvb/dynload-wrapper for details +// generated by generate-wrapper.py 0.6 on 2024-12-04 13:39:52 +// flags: generate-wrapper.py --include ./accesskit.h --sys-include accesskit.h --soname libaccesskit.dll --init-name libaccesskit --output-header accesskit-dll_wrap.h --output-implementation acceskit-dll_wrap.c +// + +// NOTE: +// This has been handpatched to add WinAPI wrappers for dlfcn functions. + +#include + +#define accesskit_node_role accesskit_node_role_dylibloader_orig_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_orig_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_orig_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_orig_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_orig_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_orig_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_orig_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_orig_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_orig_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_orig_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_orig_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_orig_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_orig_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_orig_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_orig_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_orig_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_orig_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_orig_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_orig_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_orig_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_orig_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_orig_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_orig_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_orig_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_orig_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_orig_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_orig_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_orig_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_orig_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_orig_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_orig_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_orig_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_orig_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_orig_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_orig_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_orig_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_orig_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_orig_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_orig_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_orig_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_orig_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_orig_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_orig_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_orig_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_orig_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_orig_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_orig_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_orig_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_orig_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_orig_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_orig_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_orig_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_orig_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_orig_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_orig_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_orig_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_orig_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_orig_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_orig_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_orig_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_orig_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_orig_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_orig_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_orig_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_orig_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_orig_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_orig_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_orig_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_orig_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_orig_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_orig_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_orig_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_orig_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_orig_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_orig_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_orig_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_orig_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_orig_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_orig_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_orig_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_orig_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_orig_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_orig_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_orig_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_orig_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_orig_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_orig_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_orig_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_orig_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_orig_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_orig_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_orig_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_orig_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_orig_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_orig_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_orig_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_orig_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_orig_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_orig_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_orig_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_orig_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_orig_libaccesskit +#define accesskit_windows_queued_events_raise accesskit_windows_queued_events_raise_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_new accesskit_windows_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_free accesskit_windows_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_update_if_active accesskit_windows_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_update_window_focus_state accesskit_windows_adapter_update_window_focus_state_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_handle_wm_getobject accesskit_windows_adapter_handle_wm_getobject_dylibloader_orig_libaccesskit +#define accesskit_windows_subclassing_adapter_new accesskit_windows_subclassing_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_windows_subclassing_adapter_free accesskit_windows_subclassing_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_windows_subclassing_adapter_update_if_active accesskit_windows_subclassing_adapter_update_if_active_dylibloader_orig_libaccesskit +#include "accesskit.h" +#undef accesskit_node_role +#undef accesskit_node_set_role +#undef accesskit_node_supports_action +#undef accesskit_node_add_action +#undef accesskit_node_remove_action +#undef accesskit_node_clear_actions +#undef accesskit_node_is_hidden +#undef accesskit_node_set_hidden +#undef accesskit_node_clear_hidden +#undef accesskit_node_is_linked +#undef accesskit_node_set_linked +#undef accesskit_node_clear_linked +#undef accesskit_node_is_multiselectable +#undef accesskit_node_set_multiselectable +#undef accesskit_node_clear_multiselectable +#undef accesskit_node_is_required +#undef accesskit_node_set_required +#undef accesskit_node_clear_required +#undef accesskit_node_is_visited +#undef accesskit_node_set_visited +#undef accesskit_node_clear_visited +#undef accesskit_node_is_busy +#undef accesskit_node_set_busy +#undef accesskit_node_clear_busy +#undef accesskit_node_is_live_atomic +#undef accesskit_node_set_live_atomic +#undef accesskit_node_clear_live_atomic +#undef accesskit_node_is_modal +#undef accesskit_node_set_modal +#undef accesskit_node_clear_modal +#undef accesskit_node_is_touch_transparent +#undef accesskit_node_set_touch_transparent +#undef accesskit_node_clear_touch_transparent +#undef accesskit_node_is_read_only +#undef accesskit_node_set_read_only +#undef accesskit_node_clear_read_only +#undef accesskit_node_is_disabled +#undef accesskit_node_set_disabled +#undef accesskit_node_clear_disabled +#undef accesskit_node_is_bold +#undef accesskit_node_set_bold +#undef accesskit_node_clear_bold +#undef accesskit_node_is_italic +#undef accesskit_node_set_italic +#undef accesskit_node_clear_italic +#undef accesskit_node_clips_children +#undef accesskit_node_set_clips_children +#undef accesskit_node_clear_clips_children +#undef accesskit_node_is_line_breaking_object +#undef accesskit_node_set_is_line_breaking_object +#undef accesskit_node_clear_is_line_breaking_object +#undef accesskit_node_is_page_breaking_object +#undef accesskit_node_set_is_page_breaking_object +#undef accesskit_node_clear_is_page_breaking_object +#undef accesskit_node_is_spelling_error +#undef accesskit_node_set_is_spelling_error +#undef accesskit_node_clear_is_spelling_error +#undef accesskit_node_is_grammar_error +#undef accesskit_node_set_is_grammar_error +#undef accesskit_node_clear_is_grammar_error +#undef accesskit_node_is_search_match +#undef accesskit_node_set_is_search_match +#undef accesskit_node_clear_is_search_match +#undef accesskit_node_is_suggestion +#undef accesskit_node_set_is_suggestion +#undef accesskit_node_clear_is_suggestion +#undef accesskit_node_children +#undef accesskit_node_set_children +#undef accesskit_node_push_child +#undef accesskit_node_clear_children +#undef accesskit_node_controls +#undef accesskit_node_set_controls +#undef accesskit_node_push_controlled +#undef accesskit_node_clear_controls +#undef accesskit_node_details +#undef accesskit_node_set_details +#undef accesskit_node_push_detail +#undef accesskit_node_clear_details +#undef accesskit_node_described_by +#undef accesskit_node_set_described_by +#undef accesskit_node_push_described_by +#undef accesskit_node_clear_described_by +#undef accesskit_node_flow_to +#undef accesskit_node_set_flow_to +#undef accesskit_node_push_flow_to +#undef accesskit_node_clear_flow_to +#undef accesskit_node_labelled_by +#undef accesskit_node_set_labelled_by +#undef accesskit_node_push_labelled_by +#undef accesskit_node_clear_labelled_by +#undef accesskit_node_owns +#undef accesskit_node_set_owns +#undef accesskit_node_push_owned +#undef accesskit_node_clear_owns +#undef accesskit_node_radio_group +#undef accesskit_node_set_radio_group +#undef accesskit_node_push_to_radio_group +#undef accesskit_node_clear_radio_group +#undef accesskit_node_active_descendant +#undef accesskit_node_set_active_descendant +#undef accesskit_node_clear_active_descendant +#undef accesskit_node_error_message +#undef accesskit_node_set_error_message +#undef accesskit_node_clear_error_message +#undef accesskit_node_in_page_link_target +#undef accesskit_node_set_in_page_link_target +#undef accesskit_node_clear_in_page_link_target +#undef accesskit_node_member_of +#undef accesskit_node_set_member_of +#undef accesskit_node_clear_member_of +#undef accesskit_node_next_on_line +#undef accesskit_node_set_next_on_line +#undef accesskit_node_clear_next_on_line +#undef accesskit_node_previous_on_line +#undef accesskit_node_set_previous_on_line +#undef accesskit_node_clear_previous_on_line +#undef accesskit_node_popup_for +#undef accesskit_node_set_popup_for +#undef accesskit_node_clear_popup_for +#undef accesskit_string_free +#undef accesskit_node_label +#undef accesskit_node_set_label +#undef accesskit_node_clear_label +#undef accesskit_node_description +#undef accesskit_node_set_description +#undef accesskit_node_clear_description +#undef accesskit_node_value +#undef accesskit_node_set_value +#undef accesskit_node_clear_value +#undef accesskit_node_access_key +#undef accesskit_node_set_access_key +#undef accesskit_node_clear_access_key +#undef accesskit_node_author_id +#undef accesskit_node_set_author_id +#undef accesskit_node_clear_author_id +#undef accesskit_node_class_name +#undef accesskit_node_set_class_name +#undef accesskit_node_clear_class_name +#undef accesskit_node_font_family +#undef accesskit_node_set_font_family +#undef accesskit_node_clear_font_family +#undef accesskit_node_html_tag +#undef accesskit_node_set_html_tag +#undef accesskit_node_clear_html_tag +#undef accesskit_node_inner_html +#undef accesskit_node_set_inner_html +#undef accesskit_node_clear_inner_html +#undef accesskit_node_keyboard_shortcut +#undef accesskit_node_set_keyboard_shortcut +#undef accesskit_node_clear_keyboard_shortcut +#undef accesskit_node_language +#undef accesskit_node_set_language +#undef accesskit_node_clear_language +#undef accesskit_node_placeholder +#undef accesskit_node_set_placeholder +#undef accesskit_node_clear_placeholder +#undef accesskit_node_role_description +#undef accesskit_node_set_role_description +#undef accesskit_node_clear_role_description +#undef accesskit_node_state_description +#undef accesskit_node_set_state_description +#undef accesskit_node_clear_state_description +#undef accesskit_node_tooltip +#undef accesskit_node_set_tooltip +#undef accesskit_node_clear_tooltip +#undef accesskit_node_url +#undef accesskit_node_set_url +#undef accesskit_node_clear_url +#undef accesskit_node_row_index_text +#undef accesskit_node_set_row_index_text +#undef accesskit_node_clear_row_index_text +#undef accesskit_node_column_index_text +#undef accesskit_node_set_column_index_text +#undef accesskit_node_clear_column_index_text +#undef accesskit_node_scroll_x +#undef accesskit_node_set_scroll_x +#undef accesskit_node_clear_scroll_x +#undef accesskit_node_scroll_x_min +#undef accesskit_node_set_scroll_x_min +#undef accesskit_node_clear_scroll_x_min +#undef accesskit_node_scroll_x_max +#undef accesskit_node_set_scroll_x_max +#undef accesskit_node_clear_scroll_x_max +#undef accesskit_node_scroll_y +#undef accesskit_node_set_scroll_y +#undef accesskit_node_clear_scroll_y +#undef accesskit_node_scroll_y_min +#undef accesskit_node_set_scroll_y_min +#undef accesskit_node_clear_scroll_y_min +#undef accesskit_node_scroll_y_max +#undef accesskit_node_set_scroll_y_max +#undef accesskit_node_clear_scroll_y_max +#undef accesskit_node_numeric_value +#undef accesskit_node_set_numeric_value +#undef accesskit_node_clear_numeric_value +#undef accesskit_node_min_numeric_value +#undef accesskit_node_set_min_numeric_value +#undef accesskit_node_clear_min_numeric_value +#undef accesskit_node_max_numeric_value +#undef accesskit_node_set_max_numeric_value +#undef accesskit_node_clear_max_numeric_value +#undef accesskit_node_numeric_value_step +#undef accesskit_node_set_numeric_value_step +#undef accesskit_node_clear_numeric_value_step +#undef accesskit_node_numeric_value_jump +#undef accesskit_node_set_numeric_value_jump +#undef accesskit_node_clear_numeric_value_jump +#undef accesskit_node_font_size +#undef accesskit_node_set_font_size +#undef accesskit_node_clear_font_size +#undef accesskit_node_font_weight +#undef accesskit_node_set_font_weight +#undef accesskit_node_clear_font_weight +#undef accesskit_node_row_count +#undef accesskit_node_set_row_count +#undef accesskit_node_clear_row_count +#undef accesskit_node_column_count +#undef accesskit_node_set_column_count +#undef accesskit_node_clear_column_count +#undef accesskit_node_row_index +#undef accesskit_node_set_row_index +#undef accesskit_node_clear_row_index +#undef accesskit_node_column_index +#undef accesskit_node_set_column_index +#undef accesskit_node_clear_column_index +#undef accesskit_node_row_span +#undef accesskit_node_set_row_span +#undef accesskit_node_clear_row_span +#undef accesskit_node_column_span +#undef accesskit_node_set_column_span +#undef accesskit_node_clear_column_span +#undef accesskit_node_level +#undef accesskit_node_set_level +#undef accesskit_node_clear_level +#undef accesskit_node_size_of_set +#undef accesskit_node_set_size_of_set +#undef accesskit_node_clear_size_of_set +#undef accesskit_node_position_in_set +#undef accesskit_node_set_position_in_set +#undef accesskit_node_clear_position_in_set +#undef accesskit_node_color_value +#undef accesskit_node_set_color_value +#undef accesskit_node_clear_color_value +#undef accesskit_node_background_color +#undef accesskit_node_set_background_color +#undef accesskit_node_clear_background_color +#undef accesskit_node_foreground_color +#undef accesskit_node_set_foreground_color +#undef accesskit_node_clear_foreground_color +#undef accesskit_node_overline +#undef accesskit_node_set_overline +#undef accesskit_node_clear_overline +#undef accesskit_node_strikethrough +#undef accesskit_node_set_strikethrough +#undef accesskit_node_clear_strikethrough +#undef accesskit_node_underline +#undef accesskit_node_set_underline +#undef accesskit_node_clear_underline +#undef accesskit_node_character_lengths +#undef accesskit_node_set_character_lengths +#undef accesskit_node_clear_character_lengths +#undef accesskit_node_word_lengths +#undef accesskit_node_set_word_lengths +#undef accesskit_node_clear_word_lengths +#undef accesskit_node_character_positions +#undef accesskit_node_set_character_positions +#undef accesskit_node_clear_character_positions +#undef accesskit_node_character_widths +#undef accesskit_node_set_character_widths +#undef accesskit_node_clear_character_widths +#undef accesskit_node_is_expanded +#undef accesskit_node_set_expanded +#undef accesskit_node_clear_expanded +#undef accesskit_node_is_selected +#undef accesskit_node_set_selected +#undef accesskit_node_clear_selected +#undef accesskit_node_invalid +#undef accesskit_node_set_invalid +#undef accesskit_node_clear_invalid +#undef accesskit_node_toggled +#undef accesskit_node_set_toggled +#undef accesskit_node_clear_toggled +#undef accesskit_node_live +#undef accesskit_node_set_live +#undef accesskit_node_clear_live +#undef accesskit_node_text_direction +#undef accesskit_node_set_text_direction +#undef accesskit_node_clear_text_direction +#undef accesskit_node_orientation +#undef accesskit_node_set_orientation +#undef accesskit_node_clear_orientation +#undef accesskit_node_sort_direction +#undef accesskit_node_set_sort_direction +#undef accesskit_node_clear_sort_direction +#undef accesskit_node_aria_current +#undef accesskit_node_set_aria_current +#undef accesskit_node_clear_aria_current +#undef accesskit_node_auto_complete +#undef accesskit_node_set_auto_complete +#undef accesskit_node_clear_auto_complete +#undef accesskit_node_has_popup +#undef accesskit_node_set_has_popup +#undef accesskit_node_clear_has_popup +#undef accesskit_node_list_style +#undef accesskit_node_set_list_style +#undef accesskit_node_clear_list_style +#undef accesskit_node_text_align +#undef accesskit_node_set_text_align +#undef accesskit_node_clear_text_align +#undef accesskit_node_vertical_offset +#undef accesskit_node_set_vertical_offset +#undef accesskit_node_clear_vertical_offset +#undef accesskit_node_transform +#undef accesskit_node_set_transform +#undef accesskit_node_clear_transform +#undef accesskit_node_bounds +#undef accesskit_node_set_bounds +#undef accesskit_node_clear_bounds +#undef accesskit_node_text_selection +#undef accesskit_node_set_text_selection +#undef accesskit_node_clear_text_selection +#undef accesskit_custom_action_new +#undef accesskit_custom_actions_free +#undef accesskit_node_custom_actions +#undef accesskit_node_set_custom_actions +#undef accesskit_node_push_custom_action +#undef accesskit_node_clear_custom_actions +#undef accesskit_node_new +#undef accesskit_node_free +#undef accesskit_tree_new +#undef accesskit_tree_free +#undef accesskit_tree_get_toolkit_name +#undef accesskit_tree_set_toolkit_name +#undef accesskit_tree_clear_toolkit_name +#undef accesskit_tree_get_toolkit_version +#undef accesskit_tree_set_toolkit_version +#undef accesskit_tree_clear_toolkit_version +#undef accesskit_tree_update_with_focus +#undef accesskit_tree_update_with_capacity_and_focus +#undef accesskit_tree_update_free +#undef accesskit_tree_update_push_node +#undef accesskit_tree_update_set_tree +#undef accesskit_tree_update_clear_tree +#undef accesskit_tree_update_set_focus +#undef accesskit_action_request_free +#undef accesskit_affine_identity +#undef accesskit_affine_flip_y +#undef accesskit_affine_flip_x +#undef accesskit_affine_scale +#undef accesskit_affine_scale_non_uniform +#undef accesskit_affine_translate +#undef accesskit_affine_map_unit_square +#undef accesskit_affine_determinant +#undef accesskit_affine_inverse +#undef accesskit_affine_transform_rect_bbox +#undef accesskit_affine_is_finite +#undef accesskit_affine_is_nan +#undef accesskit_point_to_vec2 +#undef accesskit_rect_from_points +#undef accesskit_rect_from_origin_size +#undef accesskit_rect_with_origin +#undef accesskit_rect_with_size +#undef accesskit_rect_width +#undef accesskit_rect_height +#undef accesskit_rect_min_x +#undef accesskit_rect_max_x +#undef accesskit_rect_min_y +#undef accesskit_rect_max_y +#undef accesskit_rect_origin +#undef accesskit_rect_size +#undef accesskit_rect_abs +#undef accesskit_rect_area +#undef accesskit_rect_is_empty +#undef accesskit_rect_contains +#undef accesskit_rect_union +#undef accesskit_rect_union_pt +#undef accesskit_rect_intersect +#undef accesskit_size_to_vec2 +#undef accesskit_vec2_to_point +#undef accesskit_vec2_to_size +#undef accesskit_windows_queued_events_raise +#undef accesskit_windows_adapter_new +#undef accesskit_windows_adapter_free +#undef accesskit_windows_adapter_update_if_active +#undef accesskit_windows_adapter_update_window_focus_state +#undef accesskit_windows_adapter_handle_wm_getobject +#undef accesskit_windows_subclassing_adapter_new +#undef accesskit_windows_subclassing_adapter_free +#undef accesskit_windows_subclassing_adapter_update_if_active + +#define RTLD_LAZY 0 + +char *dl_error = NULL; +char dl_error_text[2048]; + +void *dlsym(void *p_handle, const char *p_name) { + dl_error = NULL; + + HMODULE hmodule = (HMODULE)p_handle; + void *f = (void *)GetProcAddress(hmodule, p_name); + if (!f) { + FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), dl_error_text, 2048, NULL); + dl_error = dl_error_text; + } + return f; +} + +char *dlerror() { + return dl_error; +} + +#include +accesskit_role (*accesskit_node_role_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_role_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_role); +bool (*accesskit_node_supports_action_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *, accesskit_action); +void (*accesskit_node_add_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +void (*accesskit_node_remove_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +void (*accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_linked_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_required_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_visited_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_busy_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_modal_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_bold_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_italic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_clips_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_child_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_controls_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_details_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_detail_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_described_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_flow_to_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_owns_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_owned_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_radio_group_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_error_message_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_member_of_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_popup_for_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_string_free_dylibloader_wrapper_libaccesskit)(char *); +char *(*accesskit_node_label_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_access_key_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_author_id_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_class_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_font_family_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_html_tag_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_inner_html_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_language_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_placeholder_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_role_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_state_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_tooltip_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_url_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_font_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_font_weight_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_level_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_color_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_background_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_overline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_underline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_lengths (*accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +void (*accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_lengths (*accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +void (*accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_coords (*accesskit_node_character_positions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +void (*accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_coords (*accesskit_node_character_widths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +void (*accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_bool (*accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +void (*accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_bool (*accesskit_node_is_selected_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +void (*accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_invalid (*accesskit_node_invalid_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_invalid); +void (*accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_toggled (*accesskit_node_toggled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_toggled); +void (*accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_live (*accesskit_node_live_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_live); +void (*accesskit_node_clear_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_direction (*accesskit_node_text_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_direction); +void (*accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_orientation (*accesskit_node_orientation_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_orientation); +void (*accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_sort_direction (*accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_sort_direction); +void (*accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_aria_current (*accesskit_node_aria_current_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_aria_current); +void (*accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_auto_complete (*accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_auto_complete); +void (*accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_has_popup (*accesskit_node_has_popup_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_has_popup); +void (*accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_list_style (*accesskit_node_list_style_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_list_style); +void (*accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_align (*accesskit_node_text_align_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_align); +void (*accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_vertical_offset (*accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_vertical_offset); +void (*accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +const struct accesskit_affine *(*accesskit_node_transform_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_affine); +void (*accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_rect (*accesskit_node_bounds_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_rect); +void (*accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_selection (*accesskit_node_text_selection_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_text_selection); +void (*accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_custom_action (*accesskit_custom_action_new_dylibloader_wrapper_libaccesskit)(int32_t, const char *); +void (*accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit)(struct accesskit_custom_actions *); +const struct accesskit_custom_actions *(*accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const struct accesskit_custom_action *); +void (*accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_custom_action); +void (*accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node *(*accesskit_node_new_dylibloader_wrapper_libaccesskit)(accesskit_role); +void (*accesskit_node_free_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_tree *(*accesskit_tree_new_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +void (*accesskit_tree_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +char *(*accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +void (*accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +void (*accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +char *(*accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +void (*accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +void (*accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +struct accesskit_tree_update *(*accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +struct accesskit_tree_update *(*accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit)(size_t, accesskit_node_id); +void (*accesskit_tree_update_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +void (*accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id, struct accesskit_node *); +void (*accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, struct accesskit_tree *); +void (*accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +void (*accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id); +void (*accesskit_action_request_free_dylibloader_wrapper_libaccesskit)(struct accesskit_action_request *); +struct accesskit_affine (*accesskit_affine_identity_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_scale_dylibloader_wrapper_libaccesskit)(double); +struct accesskit_affine (*accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit)(double, double); +struct accesskit_affine (*accesskit_affine_translate_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +struct accesskit_affine (*accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit)(struct accesskit_rect); +double (*accesskit_affine_determinant_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +struct accesskit_affine (*accesskit_affine_inverse_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +struct accesskit_rect (*accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit)(struct accesskit_affine, struct accesskit_rect); +bool (*accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +bool (*accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +struct accesskit_vec2 (*accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_point); +struct accesskit_rect (*accesskit_rect_from_points_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_size); +struct accesskit_rect (*accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_with_size_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_size); +double (*accesskit_rect_width_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_height_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_min_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_max_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_min_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_max_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_point (*accesskit_rect_origin_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_size (*accesskit_rect_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_rect (*accesskit_rect_abs_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_area_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +bool (*accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +bool (*accesskit_rect_contains_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_union_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +struct accesskit_rect (*accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_intersect_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +struct accesskit_vec2 (*accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_size); +struct accesskit_point (*accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +struct accesskit_size (*accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +void (*accesskit_windows_queued_events_raise_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_queued_events *); +struct accesskit_windows_adapter *(*accesskit_windows_adapter_new_dylibloader_wrapper_libaccesskit)(HWND, bool, accesskit_action_handler_callback, void *); +void (*accesskit_windows_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *); +struct accesskit_windows_queued_events *(*accesskit_windows_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *, accesskit_tree_update_factory, void *); +struct accesskit_windows_queued_events *(*accesskit_windows_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *, bool); +struct accesskit_opt_lresult (*accesskit_windows_adapter_handle_wm_getobject_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *, WPARAM, LPARAM, accesskit_activation_handler_callback, void *); +struct accesskit_windows_subclassing_adapter *(*accesskit_windows_subclassing_adapter_new_dylibloader_wrapper_libaccesskit)(HWND, accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *); +void (*accesskit_windows_subclassing_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_subclassing_adapter *); +struct accesskit_windows_queued_events *(*accesskit_windows_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_subclassing_adapter *, accesskit_tree_update_factory, void *); +int initialize_libaccesskit(int verbose, void *handle) { + char *error; + dlerror(); +// accesskit_node_role + *(void **) (&accesskit_node_role_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_role"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_role + *(void **) (&accesskit_node_set_role_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_role"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_supports_action + *(void **) (&accesskit_node_supports_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_supports_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_add_action + *(void **) (&accesskit_node_add_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_add_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_remove_action + *(void **) (&accesskit_node_remove_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_remove_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_actions + *(void **) (&accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_hidden + *(void **) (&accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_hidden + *(void **) (&accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_hidden + *(void **) (&accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_linked + *(void **) (&accesskit_node_is_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_linked + *(void **) (&accesskit_node_set_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_linked + *(void **) (&accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_multiselectable + *(void **) (&accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_multiselectable + *(void **) (&accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_multiselectable + *(void **) (&accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_required + *(void **) (&accesskit_node_is_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_required + *(void **) (&accesskit_node_set_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_required + *(void **) (&accesskit_node_clear_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_visited + *(void **) (&accesskit_node_is_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_visited + *(void **) (&accesskit_node_set_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_visited + *(void **) (&accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_busy + *(void **) (&accesskit_node_is_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_busy + *(void **) (&accesskit_node_set_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_busy + *(void **) (&accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_live_atomic + *(void **) (&accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_live_atomic + *(void **) (&accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_live_atomic + *(void **) (&accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_modal + *(void **) (&accesskit_node_is_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_modal + *(void **) (&accesskit_node_set_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_modal + *(void **) (&accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_touch_transparent + *(void **) (&accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_touch_transparent + *(void **) (&accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_touch_transparent + *(void **) (&accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_read_only + *(void **) (&accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_read_only + *(void **) (&accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_read_only + *(void **) (&accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_disabled + *(void **) (&accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_disabled + *(void **) (&accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_disabled + *(void **) (&accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_bold + *(void **) (&accesskit_node_is_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_bold + *(void **) (&accesskit_node_set_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_bold + *(void **) (&accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_italic + *(void **) (&accesskit_node_is_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_italic + *(void **) (&accesskit_node_set_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_italic + *(void **) (&accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clips_children + *(void **) (&accesskit_node_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_clips_children + *(void **) (&accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_clips_children + *(void **) (&accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_line_breaking_object + *(void **) (&accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_line_breaking_object + *(void **) (&accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_line_breaking_object + *(void **) (&accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_page_breaking_object + *(void **) (&accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_page_breaking_object + *(void **) (&accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_page_breaking_object + *(void **) (&accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_spelling_error + *(void **) (&accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_spelling_error + *(void **) (&accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_spelling_error + *(void **) (&accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_grammar_error + *(void **) (&accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_grammar_error + *(void **) (&accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_grammar_error + *(void **) (&accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_search_match + *(void **) (&accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_search_match + *(void **) (&accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_search_match + *(void **) (&accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_suggestion + *(void **) (&accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_suggestion + *(void **) (&accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_suggestion + *(void **) (&accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_children + *(void **) (&accesskit_node_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_children + *(void **) (&accesskit_node_set_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_child + *(void **) (&accesskit_node_push_child_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_child"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_children + *(void **) (&accesskit_node_clear_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_controls + *(void **) (&accesskit_node_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_controls + *(void **) (&accesskit_node_set_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_controlled + *(void **) (&accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_controlled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_controls + *(void **) (&accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_details + *(void **) (&accesskit_node_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_details + *(void **) (&accesskit_node_set_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_detail + *(void **) (&accesskit_node_push_detail_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_detail"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_details + *(void **) (&accesskit_node_clear_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_described_by + *(void **) (&accesskit_node_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_described_by + *(void **) (&accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_described_by + *(void **) (&accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_described_by + *(void **) (&accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_flow_to + *(void **) (&accesskit_node_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_flow_to + *(void **) (&accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_flow_to + *(void **) (&accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_flow_to + *(void **) (&accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_labelled_by + *(void **) (&accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_labelled_by + *(void **) (&accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_labelled_by + *(void **) (&accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_labelled_by + *(void **) (&accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_owns + *(void **) (&accesskit_node_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_owns + *(void **) (&accesskit_node_set_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_owned + *(void **) (&accesskit_node_push_owned_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_owned"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_owns + *(void **) (&accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_radio_group + *(void **) (&accesskit_node_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_radio_group + *(void **) (&accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_to_radio_group + *(void **) (&accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_to_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_radio_group + *(void **) (&accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_active_descendant + *(void **) (&accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_active_descendant + *(void **) (&accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_active_descendant + *(void **) (&accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_error_message + *(void **) (&accesskit_node_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_error_message + *(void **) (&accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_error_message + *(void **) (&accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_in_page_link_target + *(void **) (&accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_in_page_link_target + *(void **) (&accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_in_page_link_target + *(void **) (&accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_member_of + *(void **) (&accesskit_node_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_member_of + *(void **) (&accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_member_of + *(void **) (&accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_next_on_line + *(void **) (&accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_next_on_line + *(void **) (&accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_next_on_line + *(void **) (&accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_previous_on_line + *(void **) (&accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_previous_on_line + *(void **) (&accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_previous_on_line + *(void **) (&accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_popup_for + *(void **) (&accesskit_node_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_popup_for + *(void **) (&accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_popup_for + *(void **) (&accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_string_free + *(void **) (&accesskit_string_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_string_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_label + *(void **) (&accesskit_node_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_label + *(void **) (&accesskit_node_set_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_label + *(void **) (&accesskit_node_clear_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_description + *(void **) (&accesskit_node_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_description + *(void **) (&accesskit_node_set_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_description + *(void **) (&accesskit_node_clear_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_value + *(void **) (&accesskit_node_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_value + *(void **) (&accesskit_node_set_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_value + *(void **) (&accesskit_node_clear_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_access_key + *(void **) (&accesskit_node_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_access_key + *(void **) (&accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_access_key + *(void **) (&accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_author_id + *(void **) (&accesskit_node_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_author_id + *(void **) (&accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_author_id + *(void **) (&accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_class_name + *(void **) (&accesskit_node_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_class_name + *(void **) (&accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_class_name + *(void **) (&accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_family + *(void **) (&accesskit_node_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_family + *(void **) (&accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_family + *(void **) (&accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_html_tag + *(void **) (&accesskit_node_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_html_tag + *(void **) (&accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_html_tag + *(void **) (&accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_inner_html + *(void **) (&accesskit_node_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_inner_html + *(void **) (&accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_inner_html + *(void **) (&accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_keyboard_shortcut + *(void **) (&accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_keyboard_shortcut + *(void **) (&accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_keyboard_shortcut + *(void **) (&accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_language + *(void **) (&accesskit_node_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_language + *(void **) (&accesskit_node_set_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_language + *(void **) (&accesskit_node_clear_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_placeholder + *(void **) (&accesskit_node_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_placeholder + *(void **) (&accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_placeholder + *(void **) (&accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_role_description + *(void **) (&accesskit_node_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_role_description + *(void **) (&accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_role_description + *(void **) (&accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_state_description + *(void **) (&accesskit_node_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_state_description + *(void **) (&accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_state_description + *(void **) (&accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_tooltip + *(void **) (&accesskit_node_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_tooltip + *(void **) (&accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_tooltip + *(void **) (&accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_url + *(void **) (&accesskit_node_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_url + *(void **) (&accesskit_node_set_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_url + *(void **) (&accesskit_node_clear_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_index_text + *(void **) (&accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_index_text + *(void **) (&accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_index_text + *(void **) (&accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_index_text + *(void **) (&accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_index_text + *(void **) (&accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_index_text + *(void **) (&accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x + *(void **) (&accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x + *(void **) (&accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x + *(void **) (&accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x_min + *(void **) (&accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x_min + *(void **) (&accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x_min + *(void **) (&accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x_max + *(void **) (&accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x_max + *(void **) (&accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x_max + *(void **) (&accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y + *(void **) (&accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y + *(void **) (&accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y + *(void **) (&accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y_min + *(void **) (&accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y_min + *(void **) (&accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y_min + *(void **) (&accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y_max + *(void **) (&accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y_max + *(void **) (&accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y_max + *(void **) (&accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value + *(void **) (&accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value + *(void **) (&accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value + *(void **) (&accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_min_numeric_value + *(void **) (&accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_min_numeric_value + *(void **) (&accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_min_numeric_value + *(void **) (&accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_max_numeric_value + *(void **) (&accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_max_numeric_value + *(void **) (&accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_max_numeric_value + *(void **) (&accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value_step + *(void **) (&accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value_step + *(void **) (&accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value_step + *(void **) (&accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value_jump + *(void **) (&accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value_jump + *(void **) (&accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value_jump + *(void **) (&accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_size + *(void **) (&accesskit_node_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_size + *(void **) (&accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_size + *(void **) (&accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_weight + *(void **) (&accesskit_node_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_weight + *(void **) (&accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_weight + *(void **) (&accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_count + *(void **) (&accesskit_node_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_count + *(void **) (&accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_count + *(void **) (&accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_count + *(void **) (&accesskit_node_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_count + *(void **) (&accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_count + *(void **) (&accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_index + *(void **) (&accesskit_node_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_index + *(void **) (&accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_index + *(void **) (&accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_index + *(void **) (&accesskit_node_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_index + *(void **) (&accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_index + *(void **) (&accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_span + *(void **) (&accesskit_node_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_span + *(void **) (&accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_span + *(void **) (&accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_span + *(void **) (&accesskit_node_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_span + *(void **) (&accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_span + *(void **) (&accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_level + *(void **) (&accesskit_node_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_level + *(void **) (&accesskit_node_set_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_level + *(void **) (&accesskit_node_clear_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_size_of_set + *(void **) (&accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_size_of_set + *(void **) (&accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_size_of_set + *(void **) (&accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_position_in_set + *(void **) (&accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_position_in_set + *(void **) (&accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_position_in_set + *(void **) (&accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_color_value + *(void **) (&accesskit_node_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_color_value + *(void **) (&accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_color_value + *(void **) (&accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_background_color + *(void **) (&accesskit_node_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_background_color + *(void **) (&accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_background_color + *(void **) (&accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_foreground_color + *(void **) (&accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_foreground_color + *(void **) (&accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_foreground_color + *(void **) (&accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_overline + *(void **) (&accesskit_node_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_overline + *(void **) (&accesskit_node_set_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_overline + *(void **) (&accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_strikethrough + *(void **) (&accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_strikethrough + *(void **) (&accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_strikethrough + *(void **) (&accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_underline + *(void **) (&accesskit_node_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_underline + *(void **) (&accesskit_node_set_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_underline + *(void **) (&accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_lengths + *(void **) (&accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_lengths + *(void **) (&accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_lengths + *(void **) (&accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_word_lengths + *(void **) (&accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_word_lengths + *(void **) (&accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_word_lengths + *(void **) (&accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_positions + *(void **) (&accesskit_node_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_positions + *(void **) (&accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_positions + *(void **) (&accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_widths + *(void **) (&accesskit_node_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_widths + *(void **) (&accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_widths + *(void **) (&accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_expanded + *(void **) (&accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_expanded + *(void **) (&accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_expanded + *(void **) (&accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_selected + *(void **) (&accesskit_node_is_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_selected + *(void **) (&accesskit_node_set_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_selected + *(void **) (&accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_invalid + *(void **) (&accesskit_node_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_invalid + *(void **) (&accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_invalid + *(void **) (&accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_toggled + *(void **) (&accesskit_node_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_toggled + *(void **) (&accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_toggled + *(void **) (&accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_live + *(void **) (&accesskit_node_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_live + *(void **) (&accesskit_node_set_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_live + *(void **) (&accesskit_node_clear_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_direction + *(void **) (&accesskit_node_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_direction + *(void **) (&accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_direction + *(void **) (&accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_orientation + *(void **) (&accesskit_node_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_orientation + *(void **) (&accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_orientation + *(void **) (&accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_sort_direction + *(void **) (&accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_sort_direction + *(void **) (&accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_sort_direction + *(void **) (&accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_aria_current + *(void **) (&accesskit_node_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_aria_current + *(void **) (&accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_aria_current + *(void **) (&accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_auto_complete + *(void **) (&accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_auto_complete + *(void **) (&accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_auto_complete + *(void **) (&accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_has_popup + *(void **) (&accesskit_node_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_has_popup + *(void **) (&accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_has_popup + *(void **) (&accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_list_style + *(void **) (&accesskit_node_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_list_style + *(void **) (&accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_list_style + *(void **) (&accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_align + *(void **) (&accesskit_node_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_align + *(void **) (&accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_align + *(void **) (&accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_vertical_offset + *(void **) (&accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_vertical_offset + *(void **) (&accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_vertical_offset + *(void **) (&accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_transform + *(void **) (&accesskit_node_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_transform + *(void **) (&accesskit_node_set_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_transform + *(void **) (&accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_bounds + *(void **) (&accesskit_node_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_bounds + *(void **) (&accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_bounds + *(void **) (&accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_selection + *(void **) (&accesskit_node_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_selection + *(void **) (&accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_selection + *(void **) (&accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_custom_action_new + *(void **) (&accesskit_custom_action_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_custom_action_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_custom_actions_free + *(void **) (&accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_custom_actions_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_custom_actions + *(void **) (&accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_custom_actions + *(void **) (&accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_custom_action + *(void **) (&accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_custom_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_custom_actions + *(void **) (&accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_new + *(void **) (&accesskit_node_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_free + *(void **) (&accesskit_node_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_new + *(void **) (&accesskit_tree_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_free + *(void **) (&accesskit_tree_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_get_toolkit_name + *(void **) (&accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_get_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_set_toolkit_name + *(void **) (&accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_set_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_clear_toolkit_name + *(void **) (&accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_clear_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_get_toolkit_version + *(void **) (&accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_get_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_set_toolkit_version + *(void **) (&accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_set_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_clear_toolkit_version + *(void **) (&accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_clear_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_with_focus + *(void **) (&accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_with_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_with_capacity_and_focus + *(void **) (&accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_with_capacity_and_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_free + *(void **) (&accesskit_tree_update_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_push_node + *(void **) (&accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_push_node"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_set_tree + *(void **) (&accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_set_tree"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_clear_tree + *(void **) (&accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_clear_tree"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_set_focus + *(void **) (&accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_set_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_action_request_free + *(void **) (&accesskit_action_request_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_action_request_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_identity + *(void **) (&accesskit_affine_identity_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_identity"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_flip_y + *(void **) (&accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_flip_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_flip_x + *(void **) (&accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_flip_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_scale + *(void **) (&accesskit_affine_scale_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_scale"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_scale_non_uniform + *(void **) (&accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_scale_non_uniform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_translate + *(void **) (&accesskit_affine_translate_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_translate"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_map_unit_square + *(void **) (&accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_map_unit_square"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_determinant + *(void **) (&accesskit_affine_determinant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_determinant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_inverse + *(void **) (&accesskit_affine_inverse_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_inverse"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_transform_rect_bbox + *(void **) (&accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_transform_rect_bbox"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_is_finite + *(void **) (&accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_is_finite"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_is_nan + *(void **) (&accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_is_nan"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_point_to_vec2 + *(void **) (&accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_point_to_vec2"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_from_points + *(void **) (&accesskit_rect_from_points_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_from_points"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_from_origin_size + *(void **) (&accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_from_origin_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_with_origin + *(void **) (&accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_with_origin"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_with_size + *(void **) (&accesskit_rect_with_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_with_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_width + *(void **) (&accesskit_rect_width_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_width"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_height + *(void **) (&accesskit_rect_height_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_height"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_min_x + *(void **) (&accesskit_rect_min_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_min_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_max_x + *(void **) (&accesskit_rect_max_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_max_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_min_y + *(void **) (&accesskit_rect_min_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_min_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_max_y + *(void **) (&accesskit_rect_max_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_max_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_origin + *(void **) (&accesskit_rect_origin_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_origin"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_size + *(void **) (&accesskit_rect_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_abs + *(void **) (&accesskit_rect_abs_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_abs"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_area + *(void **) (&accesskit_rect_area_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_area"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_is_empty + *(void **) (&accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_is_empty"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_contains + *(void **) (&accesskit_rect_contains_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_contains"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_union + *(void **) (&accesskit_rect_union_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_union"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_union_pt + *(void **) (&accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_union_pt"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_intersect + *(void **) (&accesskit_rect_intersect_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_intersect"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_size_to_vec2 + *(void **) (&accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_size_to_vec2"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_vec2_to_point + *(void **) (&accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_vec2_to_point"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_vec2_to_size + *(void **) (&accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_vec2_to_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_queued_events_raise + *(void **) (&accesskit_windows_queued_events_raise_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_queued_events_raise"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_adapter_new + *(void **) (&accesskit_windows_adapter_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_adapter_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_adapter_free + *(void **) (&accesskit_windows_adapter_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_adapter_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_adapter_update_if_active + *(void **) (&accesskit_windows_adapter_update_if_active_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_adapter_update_if_active"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_adapter_update_window_focus_state + *(void **) (&accesskit_windows_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_adapter_update_window_focus_state"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_adapter_handle_wm_getobject + *(void **) (&accesskit_windows_adapter_handle_wm_getobject_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_adapter_handle_wm_getobject"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_subclassing_adapter_new + *(void **) (&accesskit_windows_subclassing_adapter_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_subclassing_adapter_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_subclassing_adapter_free + *(void **) (&accesskit_windows_subclassing_adapter_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_subclassing_adapter_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_windows_subclassing_adapter_update_if_active + *(void **) (&accesskit_windows_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_windows_subclassing_adapter_update_if_active"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +return 0; +} diff --git a/drivers/accesskit/dynwrappers/accesskit-dll_wrap.h b/drivers/accesskit/dynwrappers/accesskit-dll_wrap.h new file mode 100644 index 00000000000..1769778ff6e --- /dev/null +++ b/drivers/accesskit/dynwrappers/accesskit-dll_wrap.h @@ -0,0 +1,1574 @@ +#ifndef DYLIBLOAD_WRAPPER_LIBACCESSKIT +#define DYLIBLOAD_WRAPPER_LIBACCESSKIT +// This file is generated. Do not edit! +// see https://github.com/hpvb/dynload-wrapper for details +// generated by generate-wrapper.py 0.6 on 2024-12-04 13:39:52 +// flags: generate-wrapper.py --include ./accesskit.h --sys-include accesskit.h --soname libaccesskit.dll --init-name libaccesskit --output-header accesskit-dll_wrap.h --output-implementation acceskit-dll_wrap.c +// +#include + +#define accesskit_node_role accesskit_node_role_dylibloader_orig_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_orig_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_orig_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_orig_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_orig_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_orig_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_orig_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_orig_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_orig_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_orig_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_orig_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_orig_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_orig_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_orig_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_orig_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_orig_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_orig_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_orig_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_orig_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_orig_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_orig_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_orig_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_orig_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_orig_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_orig_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_orig_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_orig_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_orig_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_orig_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_orig_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_orig_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_orig_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_orig_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_orig_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_orig_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_orig_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_orig_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_orig_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_orig_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_orig_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_orig_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_orig_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_orig_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_orig_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_orig_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_orig_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_orig_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_orig_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_orig_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_orig_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_orig_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_orig_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_orig_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_orig_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_orig_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_orig_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_orig_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_orig_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_orig_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_orig_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_orig_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_orig_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_orig_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_orig_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_orig_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_orig_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_orig_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_orig_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_orig_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_orig_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_orig_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_orig_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_orig_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_orig_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_orig_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_orig_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_orig_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_orig_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_orig_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_orig_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_orig_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_orig_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_orig_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_orig_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_orig_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_orig_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_orig_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_orig_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_orig_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_orig_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_orig_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_orig_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_orig_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_orig_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_orig_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_orig_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_orig_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_orig_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_orig_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_orig_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_orig_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_orig_libaccesskit +#define accesskit_windows_queued_events_raise accesskit_windows_queued_events_raise_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_new accesskit_windows_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_free accesskit_windows_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_update_if_active accesskit_windows_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_update_window_focus_state accesskit_windows_adapter_update_window_focus_state_dylibloader_orig_libaccesskit +#define accesskit_windows_adapter_handle_wm_getobject accesskit_windows_adapter_handle_wm_getobject_dylibloader_orig_libaccesskit +#define accesskit_windows_subclassing_adapter_new accesskit_windows_subclassing_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_windows_subclassing_adapter_free accesskit_windows_subclassing_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_windows_subclassing_adapter_update_if_active accesskit_windows_subclassing_adapter_update_if_active_dylibloader_orig_libaccesskit +#include "accesskit.h" +#undef accesskit_node_role +#undef accesskit_node_set_role +#undef accesskit_node_supports_action +#undef accesskit_node_add_action +#undef accesskit_node_remove_action +#undef accesskit_node_clear_actions +#undef accesskit_node_is_hidden +#undef accesskit_node_set_hidden +#undef accesskit_node_clear_hidden +#undef accesskit_node_is_linked +#undef accesskit_node_set_linked +#undef accesskit_node_clear_linked +#undef accesskit_node_is_multiselectable +#undef accesskit_node_set_multiselectable +#undef accesskit_node_clear_multiselectable +#undef accesskit_node_is_required +#undef accesskit_node_set_required +#undef accesskit_node_clear_required +#undef accesskit_node_is_visited +#undef accesskit_node_set_visited +#undef accesskit_node_clear_visited +#undef accesskit_node_is_busy +#undef accesskit_node_set_busy +#undef accesskit_node_clear_busy +#undef accesskit_node_is_live_atomic +#undef accesskit_node_set_live_atomic +#undef accesskit_node_clear_live_atomic +#undef accesskit_node_is_modal +#undef accesskit_node_set_modal +#undef accesskit_node_clear_modal +#undef accesskit_node_is_touch_transparent +#undef accesskit_node_set_touch_transparent +#undef accesskit_node_clear_touch_transparent +#undef accesskit_node_is_read_only +#undef accesskit_node_set_read_only +#undef accesskit_node_clear_read_only +#undef accesskit_node_is_disabled +#undef accesskit_node_set_disabled +#undef accesskit_node_clear_disabled +#undef accesskit_node_is_bold +#undef accesskit_node_set_bold +#undef accesskit_node_clear_bold +#undef accesskit_node_is_italic +#undef accesskit_node_set_italic +#undef accesskit_node_clear_italic +#undef accesskit_node_clips_children +#undef accesskit_node_set_clips_children +#undef accesskit_node_clear_clips_children +#undef accesskit_node_is_line_breaking_object +#undef accesskit_node_set_is_line_breaking_object +#undef accesskit_node_clear_is_line_breaking_object +#undef accesskit_node_is_page_breaking_object +#undef accesskit_node_set_is_page_breaking_object +#undef accesskit_node_clear_is_page_breaking_object +#undef accesskit_node_is_spelling_error +#undef accesskit_node_set_is_spelling_error +#undef accesskit_node_clear_is_spelling_error +#undef accesskit_node_is_grammar_error +#undef accesskit_node_set_is_grammar_error +#undef accesskit_node_clear_is_grammar_error +#undef accesskit_node_is_search_match +#undef accesskit_node_set_is_search_match +#undef accesskit_node_clear_is_search_match +#undef accesskit_node_is_suggestion +#undef accesskit_node_set_is_suggestion +#undef accesskit_node_clear_is_suggestion +#undef accesskit_node_children +#undef accesskit_node_set_children +#undef accesskit_node_push_child +#undef accesskit_node_clear_children +#undef accesskit_node_controls +#undef accesskit_node_set_controls +#undef accesskit_node_push_controlled +#undef accesskit_node_clear_controls +#undef accesskit_node_details +#undef accesskit_node_set_details +#undef accesskit_node_push_detail +#undef accesskit_node_clear_details +#undef accesskit_node_described_by +#undef accesskit_node_set_described_by +#undef accesskit_node_push_described_by +#undef accesskit_node_clear_described_by +#undef accesskit_node_flow_to +#undef accesskit_node_set_flow_to +#undef accesskit_node_push_flow_to +#undef accesskit_node_clear_flow_to +#undef accesskit_node_labelled_by +#undef accesskit_node_set_labelled_by +#undef accesskit_node_push_labelled_by +#undef accesskit_node_clear_labelled_by +#undef accesskit_node_owns +#undef accesskit_node_set_owns +#undef accesskit_node_push_owned +#undef accesskit_node_clear_owns +#undef accesskit_node_radio_group +#undef accesskit_node_set_radio_group +#undef accesskit_node_push_to_radio_group +#undef accesskit_node_clear_radio_group +#undef accesskit_node_active_descendant +#undef accesskit_node_set_active_descendant +#undef accesskit_node_clear_active_descendant +#undef accesskit_node_error_message +#undef accesskit_node_set_error_message +#undef accesskit_node_clear_error_message +#undef accesskit_node_in_page_link_target +#undef accesskit_node_set_in_page_link_target +#undef accesskit_node_clear_in_page_link_target +#undef accesskit_node_member_of +#undef accesskit_node_set_member_of +#undef accesskit_node_clear_member_of +#undef accesskit_node_next_on_line +#undef accesskit_node_set_next_on_line +#undef accesskit_node_clear_next_on_line +#undef accesskit_node_previous_on_line +#undef accesskit_node_set_previous_on_line +#undef accesskit_node_clear_previous_on_line +#undef accesskit_node_popup_for +#undef accesskit_node_set_popup_for +#undef accesskit_node_clear_popup_for +#undef accesskit_string_free +#undef accesskit_node_label +#undef accesskit_node_set_label +#undef accesskit_node_clear_label +#undef accesskit_node_description +#undef accesskit_node_set_description +#undef accesskit_node_clear_description +#undef accesskit_node_value +#undef accesskit_node_set_value +#undef accesskit_node_clear_value +#undef accesskit_node_access_key +#undef accesskit_node_set_access_key +#undef accesskit_node_clear_access_key +#undef accesskit_node_author_id +#undef accesskit_node_set_author_id +#undef accesskit_node_clear_author_id +#undef accesskit_node_class_name +#undef accesskit_node_set_class_name +#undef accesskit_node_clear_class_name +#undef accesskit_node_font_family +#undef accesskit_node_set_font_family +#undef accesskit_node_clear_font_family +#undef accesskit_node_html_tag +#undef accesskit_node_set_html_tag +#undef accesskit_node_clear_html_tag +#undef accesskit_node_inner_html +#undef accesskit_node_set_inner_html +#undef accesskit_node_clear_inner_html +#undef accesskit_node_keyboard_shortcut +#undef accesskit_node_set_keyboard_shortcut +#undef accesskit_node_clear_keyboard_shortcut +#undef accesskit_node_language +#undef accesskit_node_set_language +#undef accesskit_node_clear_language +#undef accesskit_node_placeholder +#undef accesskit_node_set_placeholder +#undef accesskit_node_clear_placeholder +#undef accesskit_node_role_description +#undef accesskit_node_set_role_description +#undef accesskit_node_clear_role_description +#undef accesskit_node_state_description +#undef accesskit_node_set_state_description +#undef accesskit_node_clear_state_description +#undef accesskit_node_tooltip +#undef accesskit_node_set_tooltip +#undef accesskit_node_clear_tooltip +#undef accesskit_node_url +#undef accesskit_node_set_url +#undef accesskit_node_clear_url +#undef accesskit_node_row_index_text +#undef accesskit_node_set_row_index_text +#undef accesskit_node_clear_row_index_text +#undef accesskit_node_column_index_text +#undef accesskit_node_set_column_index_text +#undef accesskit_node_clear_column_index_text +#undef accesskit_node_scroll_x +#undef accesskit_node_set_scroll_x +#undef accesskit_node_clear_scroll_x +#undef accesskit_node_scroll_x_min +#undef accesskit_node_set_scroll_x_min +#undef accesskit_node_clear_scroll_x_min +#undef accesskit_node_scroll_x_max +#undef accesskit_node_set_scroll_x_max +#undef accesskit_node_clear_scroll_x_max +#undef accesskit_node_scroll_y +#undef accesskit_node_set_scroll_y +#undef accesskit_node_clear_scroll_y +#undef accesskit_node_scroll_y_min +#undef accesskit_node_set_scroll_y_min +#undef accesskit_node_clear_scroll_y_min +#undef accesskit_node_scroll_y_max +#undef accesskit_node_set_scroll_y_max +#undef accesskit_node_clear_scroll_y_max +#undef accesskit_node_numeric_value +#undef accesskit_node_set_numeric_value +#undef accesskit_node_clear_numeric_value +#undef accesskit_node_min_numeric_value +#undef accesskit_node_set_min_numeric_value +#undef accesskit_node_clear_min_numeric_value +#undef accesskit_node_max_numeric_value +#undef accesskit_node_set_max_numeric_value +#undef accesskit_node_clear_max_numeric_value +#undef accesskit_node_numeric_value_step +#undef accesskit_node_set_numeric_value_step +#undef accesskit_node_clear_numeric_value_step +#undef accesskit_node_numeric_value_jump +#undef accesskit_node_set_numeric_value_jump +#undef accesskit_node_clear_numeric_value_jump +#undef accesskit_node_font_size +#undef accesskit_node_set_font_size +#undef accesskit_node_clear_font_size +#undef accesskit_node_font_weight +#undef accesskit_node_set_font_weight +#undef accesskit_node_clear_font_weight +#undef accesskit_node_row_count +#undef accesskit_node_set_row_count +#undef accesskit_node_clear_row_count +#undef accesskit_node_column_count +#undef accesskit_node_set_column_count +#undef accesskit_node_clear_column_count +#undef accesskit_node_row_index +#undef accesskit_node_set_row_index +#undef accesskit_node_clear_row_index +#undef accesskit_node_column_index +#undef accesskit_node_set_column_index +#undef accesskit_node_clear_column_index +#undef accesskit_node_row_span +#undef accesskit_node_set_row_span +#undef accesskit_node_clear_row_span +#undef accesskit_node_column_span +#undef accesskit_node_set_column_span +#undef accesskit_node_clear_column_span +#undef accesskit_node_level +#undef accesskit_node_set_level +#undef accesskit_node_clear_level +#undef accesskit_node_size_of_set +#undef accesskit_node_set_size_of_set +#undef accesskit_node_clear_size_of_set +#undef accesskit_node_position_in_set +#undef accesskit_node_set_position_in_set +#undef accesskit_node_clear_position_in_set +#undef accesskit_node_color_value +#undef accesskit_node_set_color_value +#undef accesskit_node_clear_color_value +#undef accesskit_node_background_color +#undef accesskit_node_set_background_color +#undef accesskit_node_clear_background_color +#undef accesskit_node_foreground_color +#undef accesskit_node_set_foreground_color +#undef accesskit_node_clear_foreground_color +#undef accesskit_node_overline +#undef accesskit_node_set_overline +#undef accesskit_node_clear_overline +#undef accesskit_node_strikethrough +#undef accesskit_node_set_strikethrough +#undef accesskit_node_clear_strikethrough +#undef accesskit_node_underline +#undef accesskit_node_set_underline +#undef accesskit_node_clear_underline +#undef accesskit_node_character_lengths +#undef accesskit_node_set_character_lengths +#undef accesskit_node_clear_character_lengths +#undef accesskit_node_word_lengths +#undef accesskit_node_set_word_lengths +#undef accesskit_node_clear_word_lengths +#undef accesskit_node_character_positions +#undef accesskit_node_set_character_positions +#undef accesskit_node_clear_character_positions +#undef accesskit_node_character_widths +#undef accesskit_node_set_character_widths +#undef accesskit_node_clear_character_widths +#undef accesskit_node_is_expanded +#undef accesskit_node_set_expanded +#undef accesskit_node_clear_expanded +#undef accesskit_node_is_selected +#undef accesskit_node_set_selected +#undef accesskit_node_clear_selected +#undef accesskit_node_invalid +#undef accesskit_node_set_invalid +#undef accesskit_node_clear_invalid +#undef accesskit_node_toggled +#undef accesskit_node_set_toggled +#undef accesskit_node_clear_toggled +#undef accesskit_node_live +#undef accesskit_node_set_live +#undef accesskit_node_clear_live +#undef accesskit_node_text_direction +#undef accesskit_node_set_text_direction +#undef accesskit_node_clear_text_direction +#undef accesskit_node_orientation +#undef accesskit_node_set_orientation +#undef accesskit_node_clear_orientation +#undef accesskit_node_sort_direction +#undef accesskit_node_set_sort_direction +#undef accesskit_node_clear_sort_direction +#undef accesskit_node_aria_current +#undef accesskit_node_set_aria_current +#undef accesskit_node_clear_aria_current +#undef accesskit_node_auto_complete +#undef accesskit_node_set_auto_complete +#undef accesskit_node_clear_auto_complete +#undef accesskit_node_has_popup +#undef accesskit_node_set_has_popup +#undef accesskit_node_clear_has_popup +#undef accesskit_node_list_style +#undef accesskit_node_set_list_style +#undef accesskit_node_clear_list_style +#undef accesskit_node_text_align +#undef accesskit_node_set_text_align +#undef accesskit_node_clear_text_align +#undef accesskit_node_vertical_offset +#undef accesskit_node_set_vertical_offset +#undef accesskit_node_clear_vertical_offset +#undef accesskit_node_transform +#undef accesskit_node_set_transform +#undef accesskit_node_clear_transform +#undef accesskit_node_bounds +#undef accesskit_node_set_bounds +#undef accesskit_node_clear_bounds +#undef accesskit_node_text_selection +#undef accesskit_node_set_text_selection +#undef accesskit_node_clear_text_selection +#undef accesskit_custom_action_new +#undef accesskit_custom_actions_free +#undef accesskit_node_custom_actions +#undef accesskit_node_set_custom_actions +#undef accesskit_node_push_custom_action +#undef accesskit_node_clear_custom_actions +#undef accesskit_node_new +#undef accesskit_node_free +#undef accesskit_tree_new +#undef accesskit_tree_free +#undef accesskit_tree_get_toolkit_name +#undef accesskit_tree_set_toolkit_name +#undef accesskit_tree_clear_toolkit_name +#undef accesskit_tree_get_toolkit_version +#undef accesskit_tree_set_toolkit_version +#undef accesskit_tree_clear_toolkit_version +#undef accesskit_tree_update_with_focus +#undef accesskit_tree_update_with_capacity_and_focus +#undef accesskit_tree_update_free +#undef accesskit_tree_update_push_node +#undef accesskit_tree_update_set_tree +#undef accesskit_tree_update_clear_tree +#undef accesskit_tree_update_set_focus +#undef accesskit_action_request_free +#undef accesskit_affine_identity +#undef accesskit_affine_flip_y +#undef accesskit_affine_flip_x +#undef accesskit_affine_scale +#undef accesskit_affine_scale_non_uniform +#undef accesskit_affine_translate +#undef accesskit_affine_map_unit_square +#undef accesskit_affine_determinant +#undef accesskit_affine_inverse +#undef accesskit_affine_transform_rect_bbox +#undef accesskit_affine_is_finite +#undef accesskit_affine_is_nan +#undef accesskit_point_to_vec2 +#undef accesskit_rect_from_points +#undef accesskit_rect_from_origin_size +#undef accesskit_rect_with_origin +#undef accesskit_rect_with_size +#undef accesskit_rect_width +#undef accesskit_rect_height +#undef accesskit_rect_min_x +#undef accesskit_rect_max_x +#undef accesskit_rect_min_y +#undef accesskit_rect_max_y +#undef accesskit_rect_origin +#undef accesskit_rect_size +#undef accesskit_rect_abs +#undef accesskit_rect_area +#undef accesskit_rect_is_empty +#undef accesskit_rect_contains +#undef accesskit_rect_union +#undef accesskit_rect_union_pt +#undef accesskit_rect_intersect +#undef accesskit_size_to_vec2 +#undef accesskit_vec2_to_point +#undef accesskit_vec2_to_size +#undef accesskit_windows_queued_events_raise +#undef accesskit_windows_adapter_new +#undef accesskit_windows_adapter_free +#undef accesskit_windows_adapter_update_if_active +#undef accesskit_windows_adapter_update_window_focus_state +#undef accesskit_windows_adapter_handle_wm_getobject +#undef accesskit_windows_subclassing_adapter_new +#undef accesskit_windows_subclassing_adapter_free +#undef accesskit_windows_subclassing_adapter_update_if_active +#ifdef __cplusplus +extern "C" { +#endif +#define accesskit_node_role accesskit_node_role_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_wrapper_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_wrapper_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_wrapper_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_wrapper_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_wrapper_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_wrapper_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_wrapper_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_wrapper_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_wrapper_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_wrapper_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_wrapper_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_wrapper_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_wrapper_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_wrapper_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_wrapper_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_wrapper_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_wrapper_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_wrapper_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_wrapper_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_wrapper_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_wrapper_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_wrapper_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_wrapper_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_wrapper_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit +#define accesskit_windows_queued_events_raise accesskit_windows_queued_events_raise_dylibloader_wrapper_libaccesskit +#define accesskit_windows_adapter_new accesskit_windows_adapter_new_dylibloader_wrapper_libaccesskit +#define accesskit_windows_adapter_free accesskit_windows_adapter_free_dylibloader_wrapper_libaccesskit +#define accesskit_windows_adapter_update_if_active accesskit_windows_adapter_update_if_active_dylibloader_wrapper_libaccesskit +#define accesskit_windows_adapter_update_window_focus_state accesskit_windows_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit +#define accesskit_windows_adapter_handle_wm_getobject accesskit_windows_adapter_handle_wm_getobject_dylibloader_wrapper_libaccesskit +#define accesskit_windows_subclassing_adapter_new accesskit_windows_subclassing_adapter_new_dylibloader_wrapper_libaccesskit +#define accesskit_windows_subclassing_adapter_free accesskit_windows_subclassing_adapter_free_dylibloader_wrapper_libaccesskit +#define accesskit_windows_subclassing_adapter_update_if_active accesskit_windows_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit +extern accesskit_role (*accesskit_node_role_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_role_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_role); +extern bool (*accesskit_node_supports_action_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_add_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_remove_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_linked_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_required_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_visited_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_busy_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_modal_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_bold_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_italic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_clips_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_child_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_controls_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_details_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_detail_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_described_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_flow_to_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_owns_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_owned_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_radio_group_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_error_message_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_member_of_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_popup_for_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_string_free_dylibloader_wrapper_libaccesskit)(char *); +extern char *(*accesskit_node_label_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_access_key_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_author_id_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_class_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_font_family_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_html_tag_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_inner_html_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_language_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_placeholder_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_role_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_state_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_tooltip_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_url_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_font_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_font_weight_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_level_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_color_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_background_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_overline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_underline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_lengths (*accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +extern void (*accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_lengths (*accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +extern void (*accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_coords (*accesskit_node_character_positions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +extern void (*accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_coords (*accesskit_node_character_widths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +extern void (*accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_bool (*accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +extern void (*accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_bool (*accesskit_node_is_selected_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +extern void (*accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_invalid (*accesskit_node_invalid_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_invalid); +extern void (*accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_toggled (*accesskit_node_toggled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_toggled); +extern void (*accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_live (*accesskit_node_live_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_live); +extern void (*accesskit_node_clear_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_direction (*accesskit_node_text_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_direction); +extern void (*accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_orientation (*accesskit_node_orientation_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_orientation); +extern void (*accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_sort_direction (*accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_sort_direction); +extern void (*accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_aria_current (*accesskit_node_aria_current_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_aria_current); +extern void (*accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_auto_complete (*accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_auto_complete); +extern void (*accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_has_popup (*accesskit_node_has_popup_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_has_popup); +extern void (*accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_list_style (*accesskit_node_list_style_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_list_style); +extern void (*accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_align (*accesskit_node_text_align_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_align); +extern void (*accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_vertical_offset (*accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_vertical_offset); +extern void (*accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern const struct accesskit_affine *(*accesskit_node_transform_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_affine); +extern void (*accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_rect (*accesskit_node_bounds_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_rect); +extern void (*accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_selection (*accesskit_node_text_selection_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_text_selection); +extern void (*accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_custom_action (*accesskit_custom_action_new_dylibloader_wrapper_libaccesskit)(int32_t, const char *); +extern void (*accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit)(struct accesskit_custom_actions *); +extern const struct accesskit_custom_actions *(*accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const struct accesskit_custom_action *); +extern void (*accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_custom_action); +extern void (*accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node *(*accesskit_node_new_dylibloader_wrapper_libaccesskit)(accesskit_role); +extern void (*accesskit_node_free_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_tree *(*accesskit_tree_new_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +extern void (*accesskit_tree_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern char *(*accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +extern void (*accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +extern void (*accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern char *(*accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +extern void (*accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +extern void (*accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern struct accesskit_tree_update *(*accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +extern struct accesskit_tree_update *(*accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit)(size_t, accesskit_node_id); +extern void (*accesskit_tree_update_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +extern void (*accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id, struct accesskit_node *); +extern void (*accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, struct accesskit_tree *); +extern void (*accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +extern void (*accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id); +extern void (*accesskit_action_request_free_dylibloader_wrapper_libaccesskit)(struct accesskit_action_request *); +extern struct accesskit_affine (*accesskit_affine_identity_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_scale_dylibloader_wrapper_libaccesskit)(double); +extern struct accesskit_affine (*accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit)(double, double); +extern struct accesskit_affine (*accesskit_affine_translate_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern struct accesskit_affine (*accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit)(struct accesskit_rect); +extern double (*accesskit_affine_determinant_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +extern struct accesskit_affine (*accesskit_affine_inverse_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +extern struct accesskit_rect (*accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit)(struct accesskit_affine, struct accesskit_rect); +extern bool (*accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +extern bool (*accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +extern struct accesskit_vec2 (*accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_from_points_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_size); +extern struct accesskit_rect (*accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_with_size_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_size); +extern double (*accesskit_rect_width_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_height_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_min_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_max_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_min_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_max_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_point (*accesskit_rect_origin_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_size (*accesskit_rect_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_rect (*accesskit_rect_abs_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_area_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern bool (*accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern bool (*accesskit_rect_contains_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_union_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +extern struct accesskit_rect (*accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_intersect_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +extern struct accesskit_vec2 (*accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_size); +extern struct accesskit_point (*accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern struct accesskit_size (*accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern void (*accesskit_windows_queued_events_raise_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_queued_events *); +extern struct accesskit_windows_adapter *(*accesskit_windows_adapter_new_dylibloader_wrapper_libaccesskit)(HWND, bool, accesskit_action_handler_callback, void *); +extern void (*accesskit_windows_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *); +extern struct accesskit_windows_queued_events *(*accesskit_windows_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *, accesskit_tree_update_factory, void *); +extern struct accesskit_windows_queued_events *(*accesskit_windows_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *, bool); +extern struct accesskit_opt_lresult (*accesskit_windows_adapter_handle_wm_getobject_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_adapter *, WPARAM, LPARAM, accesskit_activation_handler_callback, void *); +extern struct accesskit_windows_subclassing_adapter *(*accesskit_windows_subclassing_adapter_new_dylibloader_wrapper_libaccesskit)(HWND, accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *); +extern void (*accesskit_windows_subclassing_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_subclassing_adapter *); +extern struct accesskit_windows_queued_events *(*accesskit_windows_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_windows_subclassing_adapter *, accesskit_tree_update_factory, void *); +int initialize_libaccesskit(int verbose, void *handle); +#ifdef __cplusplus +} +#endif +#endif diff --git a/drivers/accesskit/dynwrappers/accesskit-dylib_wrap.c b/drivers/accesskit/dynwrappers/accesskit-dylib_wrap.c new file mode 100644 index 00000000000..602a287f8cf --- /dev/null +++ b/drivers/accesskit/dynwrappers/accesskit-dylib_wrap.c @@ -0,0 +1,4349 @@ +// This file is generated. Do not edit! +// see https://github.com/hpvb/dynload-wrapper for details +// generated by generate-wrapper.py 0.6 on 2024-12-04 13:22:22 +// flags: generate-wrapper.py --include ./accesskit.h --sys-include accesskit.h --soname libaccesskit.dylib --init-name libaccesskit --output-header accesskit-dylib_wrap.h --output-implementation accesskit-dylib_wrap.c +// +#include + +#define accesskit_node_role accesskit_node_role_dylibloader_orig_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_orig_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_orig_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_orig_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_orig_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_orig_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_orig_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_orig_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_orig_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_orig_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_orig_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_orig_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_orig_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_orig_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_orig_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_orig_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_orig_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_orig_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_orig_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_orig_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_orig_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_orig_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_orig_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_orig_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_orig_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_orig_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_orig_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_orig_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_orig_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_orig_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_orig_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_orig_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_orig_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_orig_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_orig_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_orig_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_orig_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_orig_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_orig_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_orig_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_orig_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_orig_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_orig_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_orig_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_orig_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_orig_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_orig_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_orig_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_orig_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_orig_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_orig_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_orig_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_orig_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_orig_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_orig_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_orig_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_orig_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_orig_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_orig_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_orig_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_orig_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_orig_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_orig_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_orig_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_orig_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_orig_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_orig_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_orig_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_orig_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_orig_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_orig_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_orig_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_orig_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_orig_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_orig_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_orig_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_orig_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_orig_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_orig_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_orig_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_orig_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_orig_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_orig_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_orig_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_orig_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_orig_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_orig_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_orig_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_orig_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_orig_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_orig_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_orig_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_orig_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_orig_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_orig_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_orig_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_orig_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_orig_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_orig_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_orig_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_orig_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_orig_libaccesskit +#define accesskit_macos_queued_events_raise accesskit_macos_queued_events_raise_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_new accesskit_macos_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_free accesskit_macos_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_update_if_active accesskit_macos_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_update_view_focus_state accesskit_macos_adapter_update_view_focus_state_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_view_children accesskit_macos_adapter_view_children_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_focus accesskit_macos_adapter_focus_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_hit_test accesskit_macos_adapter_hit_test_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_new accesskit_macos_subclassing_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_for_window accesskit_macos_subclassing_adapter_for_window_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_free accesskit_macos_subclassing_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_update_if_active accesskit_macos_subclassing_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_update_view_focus_state accesskit_macos_subclassing_adapter_update_view_focus_state_dylibloader_orig_libaccesskit +#define accesskit_macos_add_focus_forwarder_to_window_class accesskit_macos_add_focus_forwarder_to_window_class_dylibloader_orig_libaccesskit +#include "accesskit.h" +#undef accesskit_node_role +#undef accesskit_node_set_role +#undef accesskit_node_supports_action +#undef accesskit_node_add_action +#undef accesskit_node_remove_action +#undef accesskit_node_clear_actions +#undef accesskit_node_is_hidden +#undef accesskit_node_set_hidden +#undef accesskit_node_clear_hidden +#undef accesskit_node_is_linked +#undef accesskit_node_set_linked +#undef accesskit_node_clear_linked +#undef accesskit_node_is_multiselectable +#undef accesskit_node_set_multiselectable +#undef accesskit_node_clear_multiselectable +#undef accesskit_node_is_required +#undef accesskit_node_set_required +#undef accesskit_node_clear_required +#undef accesskit_node_is_visited +#undef accesskit_node_set_visited +#undef accesskit_node_clear_visited +#undef accesskit_node_is_busy +#undef accesskit_node_set_busy +#undef accesskit_node_clear_busy +#undef accesskit_node_is_live_atomic +#undef accesskit_node_set_live_atomic +#undef accesskit_node_clear_live_atomic +#undef accesskit_node_is_modal +#undef accesskit_node_set_modal +#undef accesskit_node_clear_modal +#undef accesskit_node_is_touch_transparent +#undef accesskit_node_set_touch_transparent +#undef accesskit_node_clear_touch_transparent +#undef accesskit_node_is_read_only +#undef accesskit_node_set_read_only +#undef accesskit_node_clear_read_only +#undef accesskit_node_is_disabled +#undef accesskit_node_set_disabled +#undef accesskit_node_clear_disabled +#undef accesskit_node_is_bold +#undef accesskit_node_set_bold +#undef accesskit_node_clear_bold +#undef accesskit_node_is_italic +#undef accesskit_node_set_italic +#undef accesskit_node_clear_italic +#undef accesskit_node_clips_children +#undef accesskit_node_set_clips_children +#undef accesskit_node_clear_clips_children +#undef accesskit_node_is_line_breaking_object +#undef accesskit_node_set_is_line_breaking_object +#undef accesskit_node_clear_is_line_breaking_object +#undef accesskit_node_is_page_breaking_object +#undef accesskit_node_set_is_page_breaking_object +#undef accesskit_node_clear_is_page_breaking_object +#undef accesskit_node_is_spelling_error +#undef accesskit_node_set_is_spelling_error +#undef accesskit_node_clear_is_spelling_error +#undef accesskit_node_is_grammar_error +#undef accesskit_node_set_is_grammar_error +#undef accesskit_node_clear_is_grammar_error +#undef accesskit_node_is_search_match +#undef accesskit_node_set_is_search_match +#undef accesskit_node_clear_is_search_match +#undef accesskit_node_is_suggestion +#undef accesskit_node_set_is_suggestion +#undef accesskit_node_clear_is_suggestion +#undef accesskit_node_children +#undef accesskit_node_set_children +#undef accesskit_node_push_child +#undef accesskit_node_clear_children +#undef accesskit_node_controls +#undef accesskit_node_set_controls +#undef accesskit_node_push_controlled +#undef accesskit_node_clear_controls +#undef accesskit_node_details +#undef accesskit_node_set_details +#undef accesskit_node_push_detail +#undef accesskit_node_clear_details +#undef accesskit_node_described_by +#undef accesskit_node_set_described_by +#undef accesskit_node_push_described_by +#undef accesskit_node_clear_described_by +#undef accesskit_node_flow_to +#undef accesskit_node_set_flow_to +#undef accesskit_node_push_flow_to +#undef accesskit_node_clear_flow_to +#undef accesskit_node_labelled_by +#undef accesskit_node_set_labelled_by +#undef accesskit_node_push_labelled_by +#undef accesskit_node_clear_labelled_by +#undef accesskit_node_owns +#undef accesskit_node_set_owns +#undef accesskit_node_push_owned +#undef accesskit_node_clear_owns +#undef accesskit_node_radio_group +#undef accesskit_node_set_radio_group +#undef accesskit_node_push_to_radio_group +#undef accesskit_node_clear_radio_group +#undef accesskit_node_active_descendant +#undef accesskit_node_set_active_descendant +#undef accesskit_node_clear_active_descendant +#undef accesskit_node_error_message +#undef accesskit_node_set_error_message +#undef accesskit_node_clear_error_message +#undef accesskit_node_in_page_link_target +#undef accesskit_node_set_in_page_link_target +#undef accesskit_node_clear_in_page_link_target +#undef accesskit_node_member_of +#undef accesskit_node_set_member_of +#undef accesskit_node_clear_member_of +#undef accesskit_node_next_on_line +#undef accesskit_node_set_next_on_line +#undef accesskit_node_clear_next_on_line +#undef accesskit_node_previous_on_line +#undef accesskit_node_set_previous_on_line +#undef accesskit_node_clear_previous_on_line +#undef accesskit_node_popup_for +#undef accesskit_node_set_popup_for +#undef accesskit_node_clear_popup_for +#undef accesskit_string_free +#undef accesskit_node_label +#undef accesskit_node_set_label +#undef accesskit_node_clear_label +#undef accesskit_node_description +#undef accesskit_node_set_description +#undef accesskit_node_clear_description +#undef accesskit_node_value +#undef accesskit_node_set_value +#undef accesskit_node_clear_value +#undef accesskit_node_access_key +#undef accesskit_node_set_access_key +#undef accesskit_node_clear_access_key +#undef accesskit_node_author_id +#undef accesskit_node_set_author_id +#undef accesskit_node_clear_author_id +#undef accesskit_node_class_name +#undef accesskit_node_set_class_name +#undef accesskit_node_clear_class_name +#undef accesskit_node_font_family +#undef accesskit_node_set_font_family +#undef accesskit_node_clear_font_family +#undef accesskit_node_html_tag +#undef accesskit_node_set_html_tag +#undef accesskit_node_clear_html_tag +#undef accesskit_node_inner_html +#undef accesskit_node_set_inner_html +#undef accesskit_node_clear_inner_html +#undef accesskit_node_keyboard_shortcut +#undef accesskit_node_set_keyboard_shortcut +#undef accesskit_node_clear_keyboard_shortcut +#undef accesskit_node_language +#undef accesskit_node_set_language +#undef accesskit_node_clear_language +#undef accesskit_node_placeholder +#undef accesskit_node_set_placeholder +#undef accesskit_node_clear_placeholder +#undef accesskit_node_role_description +#undef accesskit_node_set_role_description +#undef accesskit_node_clear_role_description +#undef accesskit_node_state_description +#undef accesskit_node_set_state_description +#undef accesskit_node_clear_state_description +#undef accesskit_node_tooltip +#undef accesskit_node_set_tooltip +#undef accesskit_node_clear_tooltip +#undef accesskit_node_url +#undef accesskit_node_set_url +#undef accesskit_node_clear_url +#undef accesskit_node_row_index_text +#undef accesskit_node_set_row_index_text +#undef accesskit_node_clear_row_index_text +#undef accesskit_node_column_index_text +#undef accesskit_node_set_column_index_text +#undef accesskit_node_clear_column_index_text +#undef accesskit_node_scroll_x +#undef accesskit_node_set_scroll_x +#undef accesskit_node_clear_scroll_x +#undef accesskit_node_scroll_x_min +#undef accesskit_node_set_scroll_x_min +#undef accesskit_node_clear_scroll_x_min +#undef accesskit_node_scroll_x_max +#undef accesskit_node_set_scroll_x_max +#undef accesskit_node_clear_scroll_x_max +#undef accesskit_node_scroll_y +#undef accesskit_node_set_scroll_y +#undef accesskit_node_clear_scroll_y +#undef accesskit_node_scroll_y_min +#undef accesskit_node_set_scroll_y_min +#undef accesskit_node_clear_scroll_y_min +#undef accesskit_node_scroll_y_max +#undef accesskit_node_set_scroll_y_max +#undef accesskit_node_clear_scroll_y_max +#undef accesskit_node_numeric_value +#undef accesskit_node_set_numeric_value +#undef accesskit_node_clear_numeric_value +#undef accesskit_node_min_numeric_value +#undef accesskit_node_set_min_numeric_value +#undef accesskit_node_clear_min_numeric_value +#undef accesskit_node_max_numeric_value +#undef accesskit_node_set_max_numeric_value +#undef accesskit_node_clear_max_numeric_value +#undef accesskit_node_numeric_value_step +#undef accesskit_node_set_numeric_value_step +#undef accesskit_node_clear_numeric_value_step +#undef accesskit_node_numeric_value_jump +#undef accesskit_node_set_numeric_value_jump +#undef accesskit_node_clear_numeric_value_jump +#undef accesskit_node_font_size +#undef accesskit_node_set_font_size +#undef accesskit_node_clear_font_size +#undef accesskit_node_font_weight +#undef accesskit_node_set_font_weight +#undef accesskit_node_clear_font_weight +#undef accesskit_node_row_count +#undef accesskit_node_set_row_count +#undef accesskit_node_clear_row_count +#undef accesskit_node_column_count +#undef accesskit_node_set_column_count +#undef accesskit_node_clear_column_count +#undef accesskit_node_row_index +#undef accesskit_node_set_row_index +#undef accesskit_node_clear_row_index +#undef accesskit_node_column_index +#undef accesskit_node_set_column_index +#undef accesskit_node_clear_column_index +#undef accesskit_node_row_span +#undef accesskit_node_set_row_span +#undef accesskit_node_clear_row_span +#undef accesskit_node_column_span +#undef accesskit_node_set_column_span +#undef accesskit_node_clear_column_span +#undef accesskit_node_level +#undef accesskit_node_set_level +#undef accesskit_node_clear_level +#undef accesskit_node_size_of_set +#undef accesskit_node_set_size_of_set +#undef accesskit_node_clear_size_of_set +#undef accesskit_node_position_in_set +#undef accesskit_node_set_position_in_set +#undef accesskit_node_clear_position_in_set +#undef accesskit_node_color_value +#undef accesskit_node_set_color_value +#undef accesskit_node_clear_color_value +#undef accesskit_node_background_color +#undef accesskit_node_set_background_color +#undef accesskit_node_clear_background_color +#undef accesskit_node_foreground_color +#undef accesskit_node_set_foreground_color +#undef accesskit_node_clear_foreground_color +#undef accesskit_node_overline +#undef accesskit_node_set_overline +#undef accesskit_node_clear_overline +#undef accesskit_node_strikethrough +#undef accesskit_node_set_strikethrough +#undef accesskit_node_clear_strikethrough +#undef accesskit_node_underline +#undef accesskit_node_set_underline +#undef accesskit_node_clear_underline +#undef accesskit_node_character_lengths +#undef accesskit_node_set_character_lengths +#undef accesskit_node_clear_character_lengths +#undef accesskit_node_word_lengths +#undef accesskit_node_set_word_lengths +#undef accesskit_node_clear_word_lengths +#undef accesskit_node_character_positions +#undef accesskit_node_set_character_positions +#undef accesskit_node_clear_character_positions +#undef accesskit_node_character_widths +#undef accesskit_node_set_character_widths +#undef accesskit_node_clear_character_widths +#undef accesskit_node_is_expanded +#undef accesskit_node_set_expanded +#undef accesskit_node_clear_expanded +#undef accesskit_node_is_selected +#undef accesskit_node_set_selected +#undef accesskit_node_clear_selected +#undef accesskit_node_invalid +#undef accesskit_node_set_invalid +#undef accesskit_node_clear_invalid +#undef accesskit_node_toggled +#undef accesskit_node_set_toggled +#undef accesskit_node_clear_toggled +#undef accesskit_node_live +#undef accesskit_node_set_live +#undef accesskit_node_clear_live +#undef accesskit_node_text_direction +#undef accesskit_node_set_text_direction +#undef accesskit_node_clear_text_direction +#undef accesskit_node_orientation +#undef accesskit_node_set_orientation +#undef accesskit_node_clear_orientation +#undef accesskit_node_sort_direction +#undef accesskit_node_set_sort_direction +#undef accesskit_node_clear_sort_direction +#undef accesskit_node_aria_current +#undef accesskit_node_set_aria_current +#undef accesskit_node_clear_aria_current +#undef accesskit_node_auto_complete +#undef accesskit_node_set_auto_complete +#undef accesskit_node_clear_auto_complete +#undef accesskit_node_has_popup +#undef accesskit_node_set_has_popup +#undef accesskit_node_clear_has_popup +#undef accesskit_node_list_style +#undef accesskit_node_set_list_style +#undef accesskit_node_clear_list_style +#undef accesskit_node_text_align +#undef accesskit_node_set_text_align +#undef accesskit_node_clear_text_align +#undef accesskit_node_vertical_offset +#undef accesskit_node_set_vertical_offset +#undef accesskit_node_clear_vertical_offset +#undef accesskit_node_transform +#undef accesskit_node_set_transform +#undef accesskit_node_clear_transform +#undef accesskit_node_bounds +#undef accesskit_node_set_bounds +#undef accesskit_node_clear_bounds +#undef accesskit_node_text_selection +#undef accesskit_node_set_text_selection +#undef accesskit_node_clear_text_selection +#undef accesskit_custom_action_new +#undef accesskit_custom_actions_free +#undef accesskit_node_custom_actions +#undef accesskit_node_set_custom_actions +#undef accesskit_node_push_custom_action +#undef accesskit_node_clear_custom_actions +#undef accesskit_node_new +#undef accesskit_node_free +#undef accesskit_tree_new +#undef accesskit_tree_free +#undef accesskit_tree_get_toolkit_name +#undef accesskit_tree_set_toolkit_name +#undef accesskit_tree_clear_toolkit_name +#undef accesskit_tree_get_toolkit_version +#undef accesskit_tree_set_toolkit_version +#undef accesskit_tree_clear_toolkit_version +#undef accesskit_tree_update_with_focus +#undef accesskit_tree_update_with_capacity_and_focus +#undef accesskit_tree_update_free +#undef accesskit_tree_update_push_node +#undef accesskit_tree_update_set_tree +#undef accesskit_tree_update_clear_tree +#undef accesskit_tree_update_set_focus +#undef accesskit_action_request_free +#undef accesskit_affine_identity +#undef accesskit_affine_flip_y +#undef accesskit_affine_flip_x +#undef accesskit_affine_scale +#undef accesskit_affine_scale_non_uniform +#undef accesskit_affine_translate +#undef accesskit_affine_map_unit_square +#undef accesskit_affine_determinant +#undef accesskit_affine_inverse +#undef accesskit_affine_transform_rect_bbox +#undef accesskit_affine_is_finite +#undef accesskit_affine_is_nan +#undef accesskit_point_to_vec2 +#undef accesskit_rect_from_points +#undef accesskit_rect_from_origin_size +#undef accesskit_rect_with_origin +#undef accesskit_rect_with_size +#undef accesskit_rect_width +#undef accesskit_rect_height +#undef accesskit_rect_min_x +#undef accesskit_rect_max_x +#undef accesskit_rect_min_y +#undef accesskit_rect_max_y +#undef accesskit_rect_origin +#undef accesskit_rect_size +#undef accesskit_rect_abs +#undef accesskit_rect_area +#undef accesskit_rect_is_empty +#undef accesskit_rect_contains +#undef accesskit_rect_union +#undef accesskit_rect_union_pt +#undef accesskit_rect_intersect +#undef accesskit_size_to_vec2 +#undef accesskit_vec2_to_point +#undef accesskit_vec2_to_size +#undef accesskit_macos_queued_events_raise +#undef accesskit_macos_adapter_new +#undef accesskit_macos_adapter_free +#undef accesskit_macos_adapter_update_if_active +#undef accesskit_macos_adapter_update_view_focus_state +#undef accesskit_macos_adapter_view_children +#undef accesskit_macos_adapter_focus +#undef accesskit_macos_adapter_hit_test +#undef accesskit_macos_subclassing_adapter_new +#undef accesskit_macos_subclassing_adapter_for_window +#undef accesskit_macos_subclassing_adapter_free +#undef accesskit_macos_subclassing_adapter_update_if_active +#undef accesskit_macos_subclassing_adapter_update_view_focus_state +#undef accesskit_macos_add_focus_forwarder_to_window_class +#include +#include +accesskit_role (*accesskit_node_role_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_role_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_role); +bool (*accesskit_node_supports_action_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *, accesskit_action); +void (*accesskit_node_add_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +void (*accesskit_node_remove_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +void (*accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_linked_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_required_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_visited_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_busy_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_modal_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_bold_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_italic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_clips_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_child_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_controls_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_details_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_detail_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_described_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_flow_to_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_owns_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_owned_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_radio_group_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_error_message_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_member_of_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_popup_for_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_string_free_dylibloader_wrapper_libaccesskit)(char *); +char *(*accesskit_node_label_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_access_key_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_author_id_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_class_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_font_family_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_html_tag_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_inner_html_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_language_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_placeholder_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_role_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_state_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_tooltip_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_url_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_font_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_font_weight_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_level_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_color_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_background_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_overline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_underline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_lengths (*accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +void (*accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_lengths (*accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +void (*accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_coords (*accesskit_node_character_positions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +void (*accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_coords (*accesskit_node_character_widths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +void (*accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_bool (*accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +void (*accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_bool (*accesskit_node_is_selected_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +void (*accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_invalid (*accesskit_node_invalid_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_invalid); +void (*accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_toggled (*accesskit_node_toggled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_toggled); +void (*accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_live (*accesskit_node_live_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_live); +void (*accesskit_node_clear_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_direction (*accesskit_node_text_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_direction); +void (*accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_orientation (*accesskit_node_orientation_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_orientation); +void (*accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_sort_direction (*accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_sort_direction); +void (*accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_aria_current (*accesskit_node_aria_current_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_aria_current); +void (*accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_auto_complete (*accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_auto_complete); +void (*accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_has_popup (*accesskit_node_has_popup_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_has_popup); +void (*accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_list_style (*accesskit_node_list_style_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_list_style); +void (*accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_align (*accesskit_node_text_align_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_align); +void (*accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_vertical_offset (*accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_vertical_offset); +void (*accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +const struct accesskit_affine *(*accesskit_node_transform_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_affine); +void (*accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_rect (*accesskit_node_bounds_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_rect); +void (*accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_selection (*accesskit_node_text_selection_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_text_selection); +void (*accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_custom_action (*accesskit_custom_action_new_dylibloader_wrapper_libaccesskit)(int32_t, const char *); +void (*accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit)(struct accesskit_custom_actions *); +const struct accesskit_custom_actions *(*accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const struct accesskit_custom_action *); +void (*accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_custom_action); +void (*accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node *(*accesskit_node_new_dylibloader_wrapper_libaccesskit)(accesskit_role); +void (*accesskit_node_free_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_tree *(*accesskit_tree_new_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +void (*accesskit_tree_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +char *(*accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +void (*accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +void (*accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +char *(*accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +void (*accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +void (*accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +struct accesskit_tree_update *(*accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +struct accesskit_tree_update *(*accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit)(size_t, accesskit_node_id); +void (*accesskit_tree_update_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +void (*accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id, struct accesskit_node *); +void (*accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, struct accesskit_tree *); +void (*accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +void (*accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id); +void (*accesskit_action_request_free_dylibloader_wrapper_libaccesskit)(struct accesskit_action_request *); +struct accesskit_affine (*accesskit_affine_identity_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_scale_dylibloader_wrapper_libaccesskit)(double); +struct accesskit_affine (*accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit)(double, double); +struct accesskit_affine (*accesskit_affine_translate_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +struct accesskit_affine (*accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit)(struct accesskit_rect); +double (*accesskit_affine_determinant_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +struct accesskit_affine (*accesskit_affine_inverse_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +struct accesskit_rect (*accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit)(struct accesskit_affine, struct accesskit_rect); +bool (*accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +bool (*accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +struct accesskit_vec2 (*accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_point); +struct accesskit_rect (*accesskit_rect_from_points_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_size); +struct accesskit_rect (*accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_with_size_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_size); +double (*accesskit_rect_width_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_height_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_min_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_max_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_min_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_max_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_point (*accesskit_rect_origin_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_size (*accesskit_rect_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_rect (*accesskit_rect_abs_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_area_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +bool (*accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +bool (*accesskit_rect_contains_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_union_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +struct accesskit_rect (*accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_intersect_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +struct accesskit_vec2 (*accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_size); +struct accesskit_point (*accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +struct accesskit_size (*accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +void (*accesskit_macos_queued_events_raise_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_queued_events *); +struct accesskit_macos_adapter *(*accesskit_macos_adapter_new_dylibloader_wrapper_libaccesskit)(void *, bool, accesskit_action_handler_callback, void *); +void (*accesskit_macos_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *); +struct accesskit_macos_queued_events *(*accesskit_macos_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, accesskit_tree_update_factory, void *); +struct accesskit_macos_queued_events *(*accesskit_macos_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, bool); +void *(*accesskit_macos_adapter_view_children_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, accesskit_activation_handler_callback, void *); +void *(*accesskit_macos_adapter_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, accesskit_activation_handler_callback, void *); +void *(*accesskit_macos_adapter_hit_test_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, double, double, accesskit_activation_handler_callback, void *); +struct accesskit_macos_subclassing_adapter *(*accesskit_macos_subclassing_adapter_new_dylibloader_wrapper_libaccesskit)(void *, accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *); +struct accesskit_macos_subclassing_adapter *(*accesskit_macos_subclassing_adapter_for_window_dylibloader_wrapper_libaccesskit)(void *, accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *); +void (*accesskit_macos_subclassing_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_subclassing_adapter *); +struct accesskit_macos_queued_events *(*accesskit_macos_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_subclassing_adapter *, accesskit_tree_update_factory, void *); +struct accesskit_macos_queued_events *(*accesskit_macos_subclassing_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_subclassing_adapter *, bool); +void (*accesskit_macos_add_focus_forwarder_to_window_class_dylibloader_wrapper_libaccesskit)(const char *); +int initialize_libaccesskit(int verbose, void *handle) { + char *error; + dlerror(); +// accesskit_node_role + *(void **) (&accesskit_node_role_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_role"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_role + *(void **) (&accesskit_node_set_role_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_role"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_supports_action + *(void **) (&accesskit_node_supports_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_supports_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_add_action + *(void **) (&accesskit_node_add_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_add_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_remove_action + *(void **) (&accesskit_node_remove_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_remove_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_actions + *(void **) (&accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_hidden + *(void **) (&accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_hidden + *(void **) (&accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_hidden + *(void **) (&accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_linked + *(void **) (&accesskit_node_is_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_linked + *(void **) (&accesskit_node_set_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_linked + *(void **) (&accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_multiselectable + *(void **) (&accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_multiselectable + *(void **) (&accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_multiselectable + *(void **) (&accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_required + *(void **) (&accesskit_node_is_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_required + *(void **) (&accesskit_node_set_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_required + *(void **) (&accesskit_node_clear_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_visited + *(void **) (&accesskit_node_is_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_visited + *(void **) (&accesskit_node_set_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_visited + *(void **) (&accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_busy + *(void **) (&accesskit_node_is_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_busy + *(void **) (&accesskit_node_set_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_busy + *(void **) (&accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_live_atomic + *(void **) (&accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_live_atomic + *(void **) (&accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_live_atomic + *(void **) (&accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_modal + *(void **) (&accesskit_node_is_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_modal + *(void **) (&accesskit_node_set_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_modal + *(void **) (&accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_touch_transparent + *(void **) (&accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_touch_transparent + *(void **) (&accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_touch_transparent + *(void **) (&accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_read_only + *(void **) (&accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_read_only + *(void **) (&accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_read_only + *(void **) (&accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_disabled + *(void **) (&accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_disabled + *(void **) (&accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_disabled + *(void **) (&accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_bold + *(void **) (&accesskit_node_is_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_bold + *(void **) (&accesskit_node_set_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_bold + *(void **) (&accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_italic + *(void **) (&accesskit_node_is_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_italic + *(void **) (&accesskit_node_set_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_italic + *(void **) (&accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clips_children + *(void **) (&accesskit_node_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_clips_children + *(void **) (&accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_clips_children + *(void **) (&accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_line_breaking_object + *(void **) (&accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_line_breaking_object + *(void **) (&accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_line_breaking_object + *(void **) (&accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_page_breaking_object + *(void **) (&accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_page_breaking_object + *(void **) (&accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_page_breaking_object + *(void **) (&accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_spelling_error + *(void **) (&accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_spelling_error + *(void **) (&accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_spelling_error + *(void **) (&accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_grammar_error + *(void **) (&accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_grammar_error + *(void **) (&accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_grammar_error + *(void **) (&accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_search_match + *(void **) (&accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_search_match + *(void **) (&accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_search_match + *(void **) (&accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_suggestion + *(void **) (&accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_suggestion + *(void **) (&accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_suggestion + *(void **) (&accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_children + *(void **) (&accesskit_node_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_children + *(void **) (&accesskit_node_set_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_child + *(void **) (&accesskit_node_push_child_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_child"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_children + *(void **) (&accesskit_node_clear_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_controls + *(void **) (&accesskit_node_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_controls + *(void **) (&accesskit_node_set_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_controlled + *(void **) (&accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_controlled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_controls + *(void **) (&accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_details + *(void **) (&accesskit_node_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_details + *(void **) (&accesskit_node_set_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_detail + *(void **) (&accesskit_node_push_detail_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_detail"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_details + *(void **) (&accesskit_node_clear_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_described_by + *(void **) (&accesskit_node_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_described_by + *(void **) (&accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_described_by + *(void **) (&accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_described_by + *(void **) (&accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_flow_to + *(void **) (&accesskit_node_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_flow_to + *(void **) (&accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_flow_to + *(void **) (&accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_flow_to + *(void **) (&accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_labelled_by + *(void **) (&accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_labelled_by + *(void **) (&accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_labelled_by + *(void **) (&accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_labelled_by + *(void **) (&accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_owns + *(void **) (&accesskit_node_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_owns + *(void **) (&accesskit_node_set_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_owned + *(void **) (&accesskit_node_push_owned_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_owned"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_owns + *(void **) (&accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_radio_group + *(void **) (&accesskit_node_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_radio_group + *(void **) (&accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_to_radio_group + *(void **) (&accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_to_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_radio_group + *(void **) (&accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_active_descendant + *(void **) (&accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_active_descendant + *(void **) (&accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_active_descendant + *(void **) (&accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_error_message + *(void **) (&accesskit_node_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_error_message + *(void **) (&accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_error_message + *(void **) (&accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_in_page_link_target + *(void **) (&accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_in_page_link_target + *(void **) (&accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_in_page_link_target + *(void **) (&accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_member_of + *(void **) (&accesskit_node_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_member_of + *(void **) (&accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_member_of + *(void **) (&accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_next_on_line + *(void **) (&accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_next_on_line + *(void **) (&accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_next_on_line + *(void **) (&accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_previous_on_line + *(void **) (&accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_previous_on_line + *(void **) (&accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_previous_on_line + *(void **) (&accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_popup_for + *(void **) (&accesskit_node_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_popup_for + *(void **) (&accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_popup_for + *(void **) (&accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_string_free + *(void **) (&accesskit_string_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_string_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_label + *(void **) (&accesskit_node_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_label + *(void **) (&accesskit_node_set_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_label + *(void **) (&accesskit_node_clear_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_description + *(void **) (&accesskit_node_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_description + *(void **) (&accesskit_node_set_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_description + *(void **) (&accesskit_node_clear_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_value + *(void **) (&accesskit_node_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_value + *(void **) (&accesskit_node_set_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_value + *(void **) (&accesskit_node_clear_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_access_key + *(void **) (&accesskit_node_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_access_key + *(void **) (&accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_access_key + *(void **) (&accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_author_id + *(void **) (&accesskit_node_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_author_id + *(void **) (&accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_author_id + *(void **) (&accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_class_name + *(void **) (&accesskit_node_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_class_name + *(void **) (&accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_class_name + *(void **) (&accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_family + *(void **) (&accesskit_node_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_family + *(void **) (&accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_family + *(void **) (&accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_html_tag + *(void **) (&accesskit_node_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_html_tag + *(void **) (&accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_html_tag + *(void **) (&accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_inner_html + *(void **) (&accesskit_node_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_inner_html + *(void **) (&accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_inner_html + *(void **) (&accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_keyboard_shortcut + *(void **) (&accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_keyboard_shortcut + *(void **) (&accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_keyboard_shortcut + *(void **) (&accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_language + *(void **) (&accesskit_node_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_language + *(void **) (&accesskit_node_set_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_language + *(void **) (&accesskit_node_clear_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_placeholder + *(void **) (&accesskit_node_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_placeholder + *(void **) (&accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_placeholder + *(void **) (&accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_role_description + *(void **) (&accesskit_node_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_role_description + *(void **) (&accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_role_description + *(void **) (&accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_state_description + *(void **) (&accesskit_node_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_state_description + *(void **) (&accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_state_description + *(void **) (&accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_tooltip + *(void **) (&accesskit_node_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_tooltip + *(void **) (&accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_tooltip + *(void **) (&accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_url + *(void **) (&accesskit_node_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_url + *(void **) (&accesskit_node_set_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_url + *(void **) (&accesskit_node_clear_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_index_text + *(void **) (&accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_index_text + *(void **) (&accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_index_text + *(void **) (&accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_index_text + *(void **) (&accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_index_text + *(void **) (&accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_index_text + *(void **) (&accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x + *(void **) (&accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x + *(void **) (&accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x + *(void **) (&accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x_min + *(void **) (&accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x_min + *(void **) (&accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x_min + *(void **) (&accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x_max + *(void **) (&accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x_max + *(void **) (&accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x_max + *(void **) (&accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y + *(void **) (&accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y + *(void **) (&accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y + *(void **) (&accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y_min + *(void **) (&accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y_min + *(void **) (&accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y_min + *(void **) (&accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y_max + *(void **) (&accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y_max + *(void **) (&accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y_max + *(void **) (&accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value + *(void **) (&accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value + *(void **) (&accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value + *(void **) (&accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_min_numeric_value + *(void **) (&accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_min_numeric_value + *(void **) (&accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_min_numeric_value + *(void **) (&accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_max_numeric_value + *(void **) (&accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_max_numeric_value + *(void **) (&accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_max_numeric_value + *(void **) (&accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value_step + *(void **) (&accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value_step + *(void **) (&accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value_step + *(void **) (&accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value_jump + *(void **) (&accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value_jump + *(void **) (&accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value_jump + *(void **) (&accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_size + *(void **) (&accesskit_node_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_size + *(void **) (&accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_size + *(void **) (&accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_weight + *(void **) (&accesskit_node_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_weight + *(void **) (&accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_weight + *(void **) (&accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_count + *(void **) (&accesskit_node_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_count + *(void **) (&accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_count + *(void **) (&accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_count + *(void **) (&accesskit_node_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_count + *(void **) (&accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_count + *(void **) (&accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_index + *(void **) (&accesskit_node_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_index + *(void **) (&accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_index + *(void **) (&accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_index + *(void **) (&accesskit_node_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_index + *(void **) (&accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_index + *(void **) (&accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_span + *(void **) (&accesskit_node_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_span + *(void **) (&accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_span + *(void **) (&accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_span + *(void **) (&accesskit_node_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_span + *(void **) (&accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_span + *(void **) (&accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_level + *(void **) (&accesskit_node_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_level + *(void **) (&accesskit_node_set_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_level + *(void **) (&accesskit_node_clear_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_size_of_set + *(void **) (&accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_size_of_set + *(void **) (&accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_size_of_set + *(void **) (&accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_position_in_set + *(void **) (&accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_position_in_set + *(void **) (&accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_position_in_set + *(void **) (&accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_color_value + *(void **) (&accesskit_node_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_color_value + *(void **) (&accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_color_value + *(void **) (&accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_background_color + *(void **) (&accesskit_node_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_background_color + *(void **) (&accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_background_color + *(void **) (&accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_foreground_color + *(void **) (&accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_foreground_color + *(void **) (&accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_foreground_color + *(void **) (&accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_overline + *(void **) (&accesskit_node_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_overline + *(void **) (&accesskit_node_set_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_overline + *(void **) (&accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_strikethrough + *(void **) (&accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_strikethrough + *(void **) (&accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_strikethrough + *(void **) (&accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_underline + *(void **) (&accesskit_node_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_underline + *(void **) (&accesskit_node_set_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_underline + *(void **) (&accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_lengths + *(void **) (&accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_lengths + *(void **) (&accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_lengths + *(void **) (&accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_word_lengths + *(void **) (&accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_word_lengths + *(void **) (&accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_word_lengths + *(void **) (&accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_positions + *(void **) (&accesskit_node_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_positions + *(void **) (&accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_positions + *(void **) (&accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_widths + *(void **) (&accesskit_node_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_widths + *(void **) (&accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_widths + *(void **) (&accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_expanded + *(void **) (&accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_expanded + *(void **) (&accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_expanded + *(void **) (&accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_selected + *(void **) (&accesskit_node_is_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_selected + *(void **) (&accesskit_node_set_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_selected + *(void **) (&accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_invalid + *(void **) (&accesskit_node_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_invalid + *(void **) (&accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_invalid + *(void **) (&accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_toggled + *(void **) (&accesskit_node_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_toggled + *(void **) (&accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_toggled + *(void **) (&accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_live + *(void **) (&accesskit_node_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_live + *(void **) (&accesskit_node_set_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_live + *(void **) (&accesskit_node_clear_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_direction + *(void **) (&accesskit_node_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_direction + *(void **) (&accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_direction + *(void **) (&accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_orientation + *(void **) (&accesskit_node_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_orientation + *(void **) (&accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_orientation + *(void **) (&accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_sort_direction + *(void **) (&accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_sort_direction + *(void **) (&accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_sort_direction + *(void **) (&accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_aria_current + *(void **) (&accesskit_node_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_aria_current + *(void **) (&accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_aria_current + *(void **) (&accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_auto_complete + *(void **) (&accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_auto_complete + *(void **) (&accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_auto_complete + *(void **) (&accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_has_popup + *(void **) (&accesskit_node_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_has_popup + *(void **) (&accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_has_popup + *(void **) (&accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_list_style + *(void **) (&accesskit_node_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_list_style + *(void **) (&accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_list_style + *(void **) (&accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_align + *(void **) (&accesskit_node_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_align + *(void **) (&accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_align + *(void **) (&accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_vertical_offset + *(void **) (&accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_vertical_offset + *(void **) (&accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_vertical_offset + *(void **) (&accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_transform + *(void **) (&accesskit_node_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_transform + *(void **) (&accesskit_node_set_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_transform + *(void **) (&accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_bounds + *(void **) (&accesskit_node_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_bounds + *(void **) (&accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_bounds + *(void **) (&accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_selection + *(void **) (&accesskit_node_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_selection + *(void **) (&accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_selection + *(void **) (&accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_custom_action_new + *(void **) (&accesskit_custom_action_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_custom_action_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_custom_actions_free + *(void **) (&accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_custom_actions_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_custom_actions + *(void **) (&accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_custom_actions + *(void **) (&accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_custom_action + *(void **) (&accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_custom_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_custom_actions + *(void **) (&accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_new + *(void **) (&accesskit_node_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_free + *(void **) (&accesskit_node_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_new + *(void **) (&accesskit_tree_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_free + *(void **) (&accesskit_tree_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_get_toolkit_name + *(void **) (&accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_get_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_set_toolkit_name + *(void **) (&accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_set_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_clear_toolkit_name + *(void **) (&accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_clear_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_get_toolkit_version + *(void **) (&accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_get_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_set_toolkit_version + *(void **) (&accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_set_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_clear_toolkit_version + *(void **) (&accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_clear_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_with_focus + *(void **) (&accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_with_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_with_capacity_and_focus + *(void **) (&accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_with_capacity_and_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_free + *(void **) (&accesskit_tree_update_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_push_node + *(void **) (&accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_push_node"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_set_tree + *(void **) (&accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_set_tree"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_clear_tree + *(void **) (&accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_clear_tree"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_set_focus + *(void **) (&accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_set_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_action_request_free + *(void **) (&accesskit_action_request_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_action_request_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_identity + *(void **) (&accesskit_affine_identity_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_identity"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_flip_y + *(void **) (&accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_flip_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_flip_x + *(void **) (&accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_flip_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_scale + *(void **) (&accesskit_affine_scale_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_scale"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_scale_non_uniform + *(void **) (&accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_scale_non_uniform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_translate + *(void **) (&accesskit_affine_translate_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_translate"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_map_unit_square + *(void **) (&accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_map_unit_square"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_determinant + *(void **) (&accesskit_affine_determinant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_determinant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_inverse + *(void **) (&accesskit_affine_inverse_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_inverse"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_transform_rect_bbox + *(void **) (&accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_transform_rect_bbox"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_is_finite + *(void **) (&accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_is_finite"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_is_nan + *(void **) (&accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_is_nan"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_point_to_vec2 + *(void **) (&accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_point_to_vec2"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_from_points + *(void **) (&accesskit_rect_from_points_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_from_points"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_from_origin_size + *(void **) (&accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_from_origin_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_with_origin + *(void **) (&accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_with_origin"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_with_size + *(void **) (&accesskit_rect_with_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_with_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_width + *(void **) (&accesskit_rect_width_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_width"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_height + *(void **) (&accesskit_rect_height_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_height"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_min_x + *(void **) (&accesskit_rect_min_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_min_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_max_x + *(void **) (&accesskit_rect_max_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_max_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_min_y + *(void **) (&accesskit_rect_min_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_min_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_max_y + *(void **) (&accesskit_rect_max_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_max_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_origin + *(void **) (&accesskit_rect_origin_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_origin"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_size + *(void **) (&accesskit_rect_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_abs + *(void **) (&accesskit_rect_abs_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_abs"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_area + *(void **) (&accesskit_rect_area_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_area"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_is_empty + *(void **) (&accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_is_empty"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_contains + *(void **) (&accesskit_rect_contains_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_contains"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_union + *(void **) (&accesskit_rect_union_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_union"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_union_pt + *(void **) (&accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_union_pt"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_intersect + *(void **) (&accesskit_rect_intersect_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_intersect"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_size_to_vec2 + *(void **) (&accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_size_to_vec2"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_vec2_to_point + *(void **) (&accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_vec2_to_point"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_vec2_to_size + *(void **) (&accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_vec2_to_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_queued_events_raise + *(void **) (&accesskit_macos_queued_events_raise_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_queued_events_raise"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_adapter_new + *(void **) (&accesskit_macos_adapter_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_adapter_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_adapter_free + *(void **) (&accesskit_macos_adapter_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_adapter_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_adapter_update_if_active + *(void **) (&accesskit_macos_adapter_update_if_active_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_adapter_update_if_active"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_adapter_update_view_focus_state + *(void **) (&accesskit_macos_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_adapter_update_view_focus_state"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_adapter_view_children + *(void **) (&accesskit_macos_adapter_view_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_adapter_view_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_adapter_focus + *(void **) (&accesskit_macos_adapter_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_adapter_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_adapter_hit_test + *(void **) (&accesskit_macos_adapter_hit_test_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_adapter_hit_test"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_subclassing_adapter_new + *(void **) (&accesskit_macos_subclassing_adapter_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_subclassing_adapter_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_subclassing_adapter_for_window + *(void **) (&accesskit_macos_subclassing_adapter_for_window_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_subclassing_adapter_for_window"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_subclassing_adapter_free + *(void **) (&accesskit_macos_subclassing_adapter_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_subclassing_adapter_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_subclassing_adapter_update_if_active + *(void **) (&accesskit_macos_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_subclassing_adapter_update_if_active"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_subclassing_adapter_update_view_focus_state + *(void **) (&accesskit_macos_subclassing_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_subclassing_adapter_update_view_focus_state"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_macos_add_focus_forwarder_to_window_class + *(void **) (&accesskit_macos_add_focus_forwarder_to_window_class_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_macos_add_focus_forwarder_to_window_class"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +return 0; +} diff --git a/drivers/accesskit/dynwrappers/accesskit-dylib_wrap.h b/drivers/accesskit/dynwrappers/accesskit-dylib_wrap.h new file mode 100644 index 00000000000..b5df5c088d0 --- /dev/null +++ b/drivers/accesskit/dynwrappers/accesskit-dylib_wrap.h @@ -0,0 +1,1594 @@ +#ifndef DYLIBLOAD_WRAPPER_LIBACCESSKIT +#define DYLIBLOAD_WRAPPER_LIBACCESSKIT +// This file is generated. Do not edit! +// see https://github.com/hpvb/dynload-wrapper for details +// generated by generate-wrapper.py 0.6 on 2024-12-04 13:22:22 +// flags: generate-wrapper.py --include ./accesskit.h --sys-include accesskit.h --soname libaccesskit.dylib --init-name libaccesskit --output-header accesskit-dylib_wrap.h --output-implementation accesskit-dylib_wrap.c +// +#include + +#define accesskit_node_role accesskit_node_role_dylibloader_orig_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_orig_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_orig_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_orig_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_orig_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_orig_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_orig_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_orig_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_orig_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_orig_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_orig_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_orig_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_orig_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_orig_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_orig_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_orig_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_orig_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_orig_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_orig_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_orig_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_orig_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_orig_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_orig_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_orig_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_orig_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_orig_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_orig_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_orig_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_orig_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_orig_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_orig_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_orig_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_orig_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_orig_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_orig_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_orig_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_orig_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_orig_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_orig_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_orig_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_orig_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_orig_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_orig_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_orig_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_orig_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_orig_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_orig_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_orig_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_orig_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_orig_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_orig_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_orig_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_orig_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_orig_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_orig_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_orig_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_orig_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_orig_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_orig_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_orig_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_orig_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_orig_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_orig_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_orig_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_orig_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_orig_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_orig_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_orig_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_orig_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_orig_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_orig_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_orig_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_orig_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_orig_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_orig_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_orig_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_orig_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_orig_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_orig_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_orig_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_orig_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_orig_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_orig_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_orig_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_orig_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_orig_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_orig_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_orig_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_orig_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_orig_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_orig_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_orig_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_orig_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_orig_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_orig_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_orig_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_orig_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_orig_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_orig_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_orig_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_orig_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_orig_libaccesskit +#define accesskit_macos_queued_events_raise accesskit_macos_queued_events_raise_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_new accesskit_macos_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_free accesskit_macos_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_update_if_active accesskit_macos_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_update_view_focus_state accesskit_macos_adapter_update_view_focus_state_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_view_children accesskit_macos_adapter_view_children_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_focus accesskit_macos_adapter_focus_dylibloader_orig_libaccesskit +#define accesskit_macos_adapter_hit_test accesskit_macos_adapter_hit_test_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_new accesskit_macos_subclassing_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_for_window accesskit_macos_subclassing_adapter_for_window_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_free accesskit_macos_subclassing_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_update_if_active accesskit_macos_subclassing_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_macos_subclassing_adapter_update_view_focus_state accesskit_macos_subclassing_adapter_update_view_focus_state_dylibloader_orig_libaccesskit +#define accesskit_macos_add_focus_forwarder_to_window_class accesskit_macos_add_focus_forwarder_to_window_class_dylibloader_orig_libaccesskit +#include "accesskit.h" +#undef accesskit_node_role +#undef accesskit_node_set_role +#undef accesskit_node_supports_action +#undef accesskit_node_add_action +#undef accesskit_node_remove_action +#undef accesskit_node_clear_actions +#undef accesskit_node_is_hidden +#undef accesskit_node_set_hidden +#undef accesskit_node_clear_hidden +#undef accesskit_node_is_linked +#undef accesskit_node_set_linked +#undef accesskit_node_clear_linked +#undef accesskit_node_is_multiselectable +#undef accesskit_node_set_multiselectable +#undef accesskit_node_clear_multiselectable +#undef accesskit_node_is_required +#undef accesskit_node_set_required +#undef accesskit_node_clear_required +#undef accesskit_node_is_visited +#undef accesskit_node_set_visited +#undef accesskit_node_clear_visited +#undef accesskit_node_is_busy +#undef accesskit_node_set_busy +#undef accesskit_node_clear_busy +#undef accesskit_node_is_live_atomic +#undef accesskit_node_set_live_atomic +#undef accesskit_node_clear_live_atomic +#undef accesskit_node_is_modal +#undef accesskit_node_set_modal +#undef accesskit_node_clear_modal +#undef accesskit_node_is_touch_transparent +#undef accesskit_node_set_touch_transparent +#undef accesskit_node_clear_touch_transparent +#undef accesskit_node_is_read_only +#undef accesskit_node_set_read_only +#undef accesskit_node_clear_read_only +#undef accesskit_node_is_disabled +#undef accesskit_node_set_disabled +#undef accesskit_node_clear_disabled +#undef accesskit_node_is_bold +#undef accesskit_node_set_bold +#undef accesskit_node_clear_bold +#undef accesskit_node_is_italic +#undef accesskit_node_set_italic +#undef accesskit_node_clear_italic +#undef accesskit_node_clips_children +#undef accesskit_node_set_clips_children +#undef accesskit_node_clear_clips_children +#undef accesskit_node_is_line_breaking_object +#undef accesskit_node_set_is_line_breaking_object +#undef accesskit_node_clear_is_line_breaking_object +#undef accesskit_node_is_page_breaking_object +#undef accesskit_node_set_is_page_breaking_object +#undef accesskit_node_clear_is_page_breaking_object +#undef accesskit_node_is_spelling_error +#undef accesskit_node_set_is_spelling_error +#undef accesskit_node_clear_is_spelling_error +#undef accesskit_node_is_grammar_error +#undef accesskit_node_set_is_grammar_error +#undef accesskit_node_clear_is_grammar_error +#undef accesskit_node_is_search_match +#undef accesskit_node_set_is_search_match +#undef accesskit_node_clear_is_search_match +#undef accesskit_node_is_suggestion +#undef accesskit_node_set_is_suggestion +#undef accesskit_node_clear_is_suggestion +#undef accesskit_node_children +#undef accesskit_node_set_children +#undef accesskit_node_push_child +#undef accesskit_node_clear_children +#undef accesskit_node_controls +#undef accesskit_node_set_controls +#undef accesskit_node_push_controlled +#undef accesskit_node_clear_controls +#undef accesskit_node_details +#undef accesskit_node_set_details +#undef accesskit_node_push_detail +#undef accesskit_node_clear_details +#undef accesskit_node_described_by +#undef accesskit_node_set_described_by +#undef accesskit_node_push_described_by +#undef accesskit_node_clear_described_by +#undef accesskit_node_flow_to +#undef accesskit_node_set_flow_to +#undef accesskit_node_push_flow_to +#undef accesskit_node_clear_flow_to +#undef accesskit_node_labelled_by +#undef accesskit_node_set_labelled_by +#undef accesskit_node_push_labelled_by +#undef accesskit_node_clear_labelled_by +#undef accesskit_node_owns +#undef accesskit_node_set_owns +#undef accesskit_node_push_owned +#undef accesskit_node_clear_owns +#undef accesskit_node_radio_group +#undef accesskit_node_set_radio_group +#undef accesskit_node_push_to_radio_group +#undef accesskit_node_clear_radio_group +#undef accesskit_node_active_descendant +#undef accesskit_node_set_active_descendant +#undef accesskit_node_clear_active_descendant +#undef accesskit_node_error_message +#undef accesskit_node_set_error_message +#undef accesskit_node_clear_error_message +#undef accesskit_node_in_page_link_target +#undef accesskit_node_set_in_page_link_target +#undef accesskit_node_clear_in_page_link_target +#undef accesskit_node_member_of +#undef accesskit_node_set_member_of +#undef accesskit_node_clear_member_of +#undef accesskit_node_next_on_line +#undef accesskit_node_set_next_on_line +#undef accesskit_node_clear_next_on_line +#undef accesskit_node_previous_on_line +#undef accesskit_node_set_previous_on_line +#undef accesskit_node_clear_previous_on_line +#undef accesskit_node_popup_for +#undef accesskit_node_set_popup_for +#undef accesskit_node_clear_popup_for +#undef accesskit_string_free +#undef accesskit_node_label +#undef accesskit_node_set_label +#undef accesskit_node_clear_label +#undef accesskit_node_description +#undef accesskit_node_set_description +#undef accesskit_node_clear_description +#undef accesskit_node_value +#undef accesskit_node_set_value +#undef accesskit_node_clear_value +#undef accesskit_node_access_key +#undef accesskit_node_set_access_key +#undef accesskit_node_clear_access_key +#undef accesskit_node_author_id +#undef accesskit_node_set_author_id +#undef accesskit_node_clear_author_id +#undef accesskit_node_class_name +#undef accesskit_node_set_class_name +#undef accesskit_node_clear_class_name +#undef accesskit_node_font_family +#undef accesskit_node_set_font_family +#undef accesskit_node_clear_font_family +#undef accesskit_node_html_tag +#undef accesskit_node_set_html_tag +#undef accesskit_node_clear_html_tag +#undef accesskit_node_inner_html +#undef accesskit_node_set_inner_html +#undef accesskit_node_clear_inner_html +#undef accesskit_node_keyboard_shortcut +#undef accesskit_node_set_keyboard_shortcut +#undef accesskit_node_clear_keyboard_shortcut +#undef accesskit_node_language +#undef accesskit_node_set_language +#undef accesskit_node_clear_language +#undef accesskit_node_placeholder +#undef accesskit_node_set_placeholder +#undef accesskit_node_clear_placeholder +#undef accesskit_node_role_description +#undef accesskit_node_set_role_description +#undef accesskit_node_clear_role_description +#undef accesskit_node_state_description +#undef accesskit_node_set_state_description +#undef accesskit_node_clear_state_description +#undef accesskit_node_tooltip +#undef accesskit_node_set_tooltip +#undef accesskit_node_clear_tooltip +#undef accesskit_node_url +#undef accesskit_node_set_url +#undef accesskit_node_clear_url +#undef accesskit_node_row_index_text +#undef accesskit_node_set_row_index_text +#undef accesskit_node_clear_row_index_text +#undef accesskit_node_column_index_text +#undef accesskit_node_set_column_index_text +#undef accesskit_node_clear_column_index_text +#undef accesskit_node_scroll_x +#undef accesskit_node_set_scroll_x +#undef accesskit_node_clear_scroll_x +#undef accesskit_node_scroll_x_min +#undef accesskit_node_set_scroll_x_min +#undef accesskit_node_clear_scroll_x_min +#undef accesskit_node_scroll_x_max +#undef accesskit_node_set_scroll_x_max +#undef accesskit_node_clear_scroll_x_max +#undef accesskit_node_scroll_y +#undef accesskit_node_set_scroll_y +#undef accesskit_node_clear_scroll_y +#undef accesskit_node_scroll_y_min +#undef accesskit_node_set_scroll_y_min +#undef accesskit_node_clear_scroll_y_min +#undef accesskit_node_scroll_y_max +#undef accesskit_node_set_scroll_y_max +#undef accesskit_node_clear_scroll_y_max +#undef accesskit_node_numeric_value +#undef accesskit_node_set_numeric_value +#undef accesskit_node_clear_numeric_value +#undef accesskit_node_min_numeric_value +#undef accesskit_node_set_min_numeric_value +#undef accesskit_node_clear_min_numeric_value +#undef accesskit_node_max_numeric_value +#undef accesskit_node_set_max_numeric_value +#undef accesskit_node_clear_max_numeric_value +#undef accesskit_node_numeric_value_step +#undef accesskit_node_set_numeric_value_step +#undef accesskit_node_clear_numeric_value_step +#undef accesskit_node_numeric_value_jump +#undef accesskit_node_set_numeric_value_jump +#undef accesskit_node_clear_numeric_value_jump +#undef accesskit_node_font_size +#undef accesskit_node_set_font_size +#undef accesskit_node_clear_font_size +#undef accesskit_node_font_weight +#undef accesskit_node_set_font_weight +#undef accesskit_node_clear_font_weight +#undef accesskit_node_row_count +#undef accesskit_node_set_row_count +#undef accesskit_node_clear_row_count +#undef accesskit_node_column_count +#undef accesskit_node_set_column_count +#undef accesskit_node_clear_column_count +#undef accesskit_node_row_index +#undef accesskit_node_set_row_index +#undef accesskit_node_clear_row_index +#undef accesskit_node_column_index +#undef accesskit_node_set_column_index +#undef accesskit_node_clear_column_index +#undef accesskit_node_row_span +#undef accesskit_node_set_row_span +#undef accesskit_node_clear_row_span +#undef accesskit_node_column_span +#undef accesskit_node_set_column_span +#undef accesskit_node_clear_column_span +#undef accesskit_node_level +#undef accesskit_node_set_level +#undef accesskit_node_clear_level +#undef accesskit_node_size_of_set +#undef accesskit_node_set_size_of_set +#undef accesskit_node_clear_size_of_set +#undef accesskit_node_position_in_set +#undef accesskit_node_set_position_in_set +#undef accesskit_node_clear_position_in_set +#undef accesskit_node_color_value +#undef accesskit_node_set_color_value +#undef accesskit_node_clear_color_value +#undef accesskit_node_background_color +#undef accesskit_node_set_background_color +#undef accesskit_node_clear_background_color +#undef accesskit_node_foreground_color +#undef accesskit_node_set_foreground_color +#undef accesskit_node_clear_foreground_color +#undef accesskit_node_overline +#undef accesskit_node_set_overline +#undef accesskit_node_clear_overline +#undef accesskit_node_strikethrough +#undef accesskit_node_set_strikethrough +#undef accesskit_node_clear_strikethrough +#undef accesskit_node_underline +#undef accesskit_node_set_underline +#undef accesskit_node_clear_underline +#undef accesskit_node_character_lengths +#undef accesskit_node_set_character_lengths +#undef accesskit_node_clear_character_lengths +#undef accesskit_node_word_lengths +#undef accesskit_node_set_word_lengths +#undef accesskit_node_clear_word_lengths +#undef accesskit_node_character_positions +#undef accesskit_node_set_character_positions +#undef accesskit_node_clear_character_positions +#undef accesskit_node_character_widths +#undef accesskit_node_set_character_widths +#undef accesskit_node_clear_character_widths +#undef accesskit_node_is_expanded +#undef accesskit_node_set_expanded +#undef accesskit_node_clear_expanded +#undef accesskit_node_is_selected +#undef accesskit_node_set_selected +#undef accesskit_node_clear_selected +#undef accesskit_node_invalid +#undef accesskit_node_set_invalid +#undef accesskit_node_clear_invalid +#undef accesskit_node_toggled +#undef accesskit_node_set_toggled +#undef accesskit_node_clear_toggled +#undef accesskit_node_live +#undef accesskit_node_set_live +#undef accesskit_node_clear_live +#undef accesskit_node_text_direction +#undef accesskit_node_set_text_direction +#undef accesskit_node_clear_text_direction +#undef accesskit_node_orientation +#undef accesskit_node_set_orientation +#undef accesskit_node_clear_orientation +#undef accesskit_node_sort_direction +#undef accesskit_node_set_sort_direction +#undef accesskit_node_clear_sort_direction +#undef accesskit_node_aria_current +#undef accesskit_node_set_aria_current +#undef accesskit_node_clear_aria_current +#undef accesskit_node_auto_complete +#undef accesskit_node_set_auto_complete +#undef accesskit_node_clear_auto_complete +#undef accesskit_node_has_popup +#undef accesskit_node_set_has_popup +#undef accesskit_node_clear_has_popup +#undef accesskit_node_list_style +#undef accesskit_node_set_list_style +#undef accesskit_node_clear_list_style +#undef accesskit_node_text_align +#undef accesskit_node_set_text_align +#undef accesskit_node_clear_text_align +#undef accesskit_node_vertical_offset +#undef accesskit_node_set_vertical_offset +#undef accesskit_node_clear_vertical_offset +#undef accesskit_node_transform +#undef accesskit_node_set_transform +#undef accesskit_node_clear_transform +#undef accesskit_node_bounds +#undef accesskit_node_set_bounds +#undef accesskit_node_clear_bounds +#undef accesskit_node_text_selection +#undef accesskit_node_set_text_selection +#undef accesskit_node_clear_text_selection +#undef accesskit_custom_action_new +#undef accesskit_custom_actions_free +#undef accesskit_node_custom_actions +#undef accesskit_node_set_custom_actions +#undef accesskit_node_push_custom_action +#undef accesskit_node_clear_custom_actions +#undef accesskit_node_new +#undef accesskit_node_free +#undef accesskit_tree_new +#undef accesskit_tree_free +#undef accesskit_tree_get_toolkit_name +#undef accesskit_tree_set_toolkit_name +#undef accesskit_tree_clear_toolkit_name +#undef accesskit_tree_get_toolkit_version +#undef accesskit_tree_set_toolkit_version +#undef accesskit_tree_clear_toolkit_version +#undef accesskit_tree_update_with_focus +#undef accesskit_tree_update_with_capacity_and_focus +#undef accesskit_tree_update_free +#undef accesskit_tree_update_push_node +#undef accesskit_tree_update_set_tree +#undef accesskit_tree_update_clear_tree +#undef accesskit_tree_update_set_focus +#undef accesskit_action_request_free +#undef accesskit_affine_identity +#undef accesskit_affine_flip_y +#undef accesskit_affine_flip_x +#undef accesskit_affine_scale +#undef accesskit_affine_scale_non_uniform +#undef accesskit_affine_translate +#undef accesskit_affine_map_unit_square +#undef accesskit_affine_determinant +#undef accesskit_affine_inverse +#undef accesskit_affine_transform_rect_bbox +#undef accesskit_affine_is_finite +#undef accesskit_affine_is_nan +#undef accesskit_point_to_vec2 +#undef accesskit_rect_from_points +#undef accesskit_rect_from_origin_size +#undef accesskit_rect_with_origin +#undef accesskit_rect_with_size +#undef accesskit_rect_width +#undef accesskit_rect_height +#undef accesskit_rect_min_x +#undef accesskit_rect_max_x +#undef accesskit_rect_min_y +#undef accesskit_rect_max_y +#undef accesskit_rect_origin +#undef accesskit_rect_size +#undef accesskit_rect_abs +#undef accesskit_rect_area +#undef accesskit_rect_is_empty +#undef accesskit_rect_contains +#undef accesskit_rect_union +#undef accesskit_rect_union_pt +#undef accesskit_rect_intersect +#undef accesskit_size_to_vec2 +#undef accesskit_vec2_to_point +#undef accesskit_vec2_to_size +#undef accesskit_macos_queued_events_raise +#undef accesskit_macos_adapter_new +#undef accesskit_macos_adapter_free +#undef accesskit_macos_adapter_update_if_active +#undef accesskit_macos_adapter_update_view_focus_state +#undef accesskit_macos_adapter_view_children +#undef accesskit_macos_adapter_focus +#undef accesskit_macos_adapter_hit_test +#undef accesskit_macos_subclassing_adapter_new +#undef accesskit_macos_subclassing_adapter_for_window +#undef accesskit_macos_subclassing_adapter_free +#undef accesskit_macos_subclassing_adapter_update_if_active +#undef accesskit_macos_subclassing_adapter_update_view_focus_state +#undef accesskit_macos_add_focus_forwarder_to_window_class +#ifdef __cplusplus +extern "C" { +#endif +#define accesskit_node_role accesskit_node_role_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_wrapper_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_wrapper_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_wrapper_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_wrapper_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_wrapper_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_wrapper_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_wrapper_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_wrapper_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_wrapper_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_wrapper_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_wrapper_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_wrapper_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_wrapper_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_wrapper_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_wrapper_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_wrapper_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_wrapper_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_wrapper_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_wrapper_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_wrapper_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_wrapper_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_wrapper_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_wrapper_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_wrapper_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit +#define accesskit_macos_queued_events_raise accesskit_macos_queued_events_raise_dylibloader_wrapper_libaccesskit +#define accesskit_macos_adapter_new accesskit_macos_adapter_new_dylibloader_wrapper_libaccesskit +#define accesskit_macos_adapter_free accesskit_macos_adapter_free_dylibloader_wrapper_libaccesskit +#define accesskit_macos_adapter_update_if_active accesskit_macos_adapter_update_if_active_dylibloader_wrapper_libaccesskit +#define accesskit_macos_adapter_update_view_focus_state accesskit_macos_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit +#define accesskit_macos_adapter_view_children accesskit_macos_adapter_view_children_dylibloader_wrapper_libaccesskit +#define accesskit_macos_adapter_focus accesskit_macos_adapter_focus_dylibloader_wrapper_libaccesskit +#define accesskit_macos_adapter_hit_test accesskit_macos_adapter_hit_test_dylibloader_wrapper_libaccesskit +#define accesskit_macos_subclassing_adapter_new accesskit_macos_subclassing_adapter_new_dylibloader_wrapper_libaccesskit +#define accesskit_macos_subclassing_adapter_for_window accesskit_macos_subclassing_adapter_for_window_dylibloader_wrapper_libaccesskit +#define accesskit_macos_subclassing_adapter_free accesskit_macos_subclassing_adapter_free_dylibloader_wrapper_libaccesskit +#define accesskit_macos_subclassing_adapter_update_if_active accesskit_macos_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit +#define accesskit_macos_subclassing_adapter_update_view_focus_state accesskit_macos_subclassing_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit +#define accesskit_macos_add_focus_forwarder_to_window_class accesskit_macos_add_focus_forwarder_to_window_class_dylibloader_wrapper_libaccesskit +extern accesskit_role (*accesskit_node_role_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_role_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_role); +extern bool (*accesskit_node_supports_action_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_add_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_remove_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_linked_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_required_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_visited_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_busy_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_modal_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_bold_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_italic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_clips_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_child_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_controls_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_details_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_detail_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_described_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_flow_to_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_owns_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_owned_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_radio_group_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_error_message_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_member_of_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_popup_for_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_string_free_dylibloader_wrapper_libaccesskit)(char *); +extern char *(*accesskit_node_label_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_access_key_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_author_id_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_class_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_font_family_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_html_tag_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_inner_html_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_language_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_placeholder_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_role_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_state_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_tooltip_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_url_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_font_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_font_weight_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_level_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_color_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_background_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_overline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_underline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_lengths (*accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +extern void (*accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_lengths (*accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +extern void (*accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_coords (*accesskit_node_character_positions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +extern void (*accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_coords (*accesskit_node_character_widths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +extern void (*accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_bool (*accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +extern void (*accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_bool (*accesskit_node_is_selected_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +extern void (*accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_invalid (*accesskit_node_invalid_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_invalid); +extern void (*accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_toggled (*accesskit_node_toggled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_toggled); +extern void (*accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_live (*accesskit_node_live_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_live); +extern void (*accesskit_node_clear_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_direction (*accesskit_node_text_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_direction); +extern void (*accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_orientation (*accesskit_node_orientation_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_orientation); +extern void (*accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_sort_direction (*accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_sort_direction); +extern void (*accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_aria_current (*accesskit_node_aria_current_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_aria_current); +extern void (*accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_auto_complete (*accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_auto_complete); +extern void (*accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_has_popup (*accesskit_node_has_popup_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_has_popup); +extern void (*accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_list_style (*accesskit_node_list_style_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_list_style); +extern void (*accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_align (*accesskit_node_text_align_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_align); +extern void (*accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_vertical_offset (*accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_vertical_offset); +extern void (*accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern const struct accesskit_affine *(*accesskit_node_transform_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_affine); +extern void (*accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_rect (*accesskit_node_bounds_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_rect); +extern void (*accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_selection (*accesskit_node_text_selection_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_text_selection); +extern void (*accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_custom_action (*accesskit_custom_action_new_dylibloader_wrapper_libaccesskit)(int32_t, const char *); +extern void (*accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit)(struct accesskit_custom_actions *); +extern const struct accesskit_custom_actions *(*accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const struct accesskit_custom_action *); +extern void (*accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_custom_action); +extern void (*accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node *(*accesskit_node_new_dylibloader_wrapper_libaccesskit)(accesskit_role); +extern void (*accesskit_node_free_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_tree *(*accesskit_tree_new_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +extern void (*accesskit_tree_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern char *(*accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +extern void (*accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +extern void (*accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern char *(*accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +extern void (*accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +extern void (*accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern struct accesskit_tree_update *(*accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +extern struct accesskit_tree_update *(*accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit)(size_t, accesskit_node_id); +extern void (*accesskit_tree_update_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +extern void (*accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id, struct accesskit_node *); +extern void (*accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, struct accesskit_tree *); +extern void (*accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +extern void (*accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id); +extern void (*accesskit_action_request_free_dylibloader_wrapper_libaccesskit)(struct accesskit_action_request *); +extern struct accesskit_affine (*accesskit_affine_identity_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_scale_dylibloader_wrapper_libaccesskit)(double); +extern struct accesskit_affine (*accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit)(double, double); +extern struct accesskit_affine (*accesskit_affine_translate_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern struct accesskit_affine (*accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit)(struct accesskit_rect); +extern double (*accesskit_affine_determinant_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +extern struct accesskit_affine (*accesskit_affine_inverse_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +extern struct accesskit_rect (*accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit)(struct accesskit_affine, struct accesskit_rect); +extern bool (*accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +extern bool (*accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +extern struct accesskit_vec2 (*accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_from_points_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_size); +extern struct accesskit_rect (*accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_with_size_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_size); +extern double (*accesskit_rect_width_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_height_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_min_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_max_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_min_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_max_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_point (*accesskit_rect_origin_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_size (*accesskit_rect_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_rect (*accesskit_rect_abs_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_area_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern bool (*accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern bool (*accesskit_rect_contains_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_union_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +extern struct accesskit_rect (*accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_intersect_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +extern struct accesskit_vec2 (*accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_size); +extern struct accesskit_point (*accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern struct accesskit_size (*accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern void (*accesskit_macos_queued_events_raise_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_queued_events *); +extern struct accesskit_macos_adapter *(*accesskit_macos_adapter_new_dylibloader_wrapper_libaccesskit)(void *, bool, accesskit_action_handler_callback, void *); +extern void (*accesskit_macos_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *); +extern struct accesskit_macos_queued_events *(*accesskit_macos_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, accesskit_tree_update_factory, void *); +extern struct accesskit_macos_queued_events *(*accesskit_macos_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, bool); +extern void *(*accesskit_macos_adapter_view_children_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, accesskit_activation_handler_callback, void *); +extern void *(*accesskit_macos_adapter_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, accesskit_activation_handler_callback, void *); +extern void *(*accesskit_macos_adapter_hit_test_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_adapter *, double, double, accesskit_activation_handler_callback, void *); +extern struct accesskit_macos_subclassing_adapter *(*accesskit_macos_subclassing_adapter_new_dylibloader_wrapper_libaccesskit)(void *, accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *); +extern struct accesskit_macos_subclassing_adapter *(*accesskit_macos_subclassing_adapter_for_window_dylibloader_wrapper_libaccesskit)(void *, accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *); +extern void (*accesskit_macos_subclassing_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_subclassing_adapter *); +extern struct accesskit_macos_queued_events *(*accesskit_macos_subclassing_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_subclassing_adapter *, accesskit_tree_update_factory, void *); +extern struct accesskit_macos_queued_events *(*accesskit_macos_subclassing_adapter_update_view_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_macos_subclassing_adapter *, bool); +extern void (*accesskit_macos_add_focus_forwarder_to_window_class_dylibloader_wrapper_libaccesskit)(const char *); +int initialize_libaccesskit(int verbose, void *handle); +#ifdef __cplusplus +} +#endif +#endif diff --git a/drivers/accesskit/dynwrappers/accesskit-so_wrap.c b/drivers/accesskit/dynwrappers/accesskit-so_wrap.c new file mode 100644 index 00000000000..e2095e345cc --- /dev/null +++ b/drivers/accesskit/dynwrappers/accesskit-so_wrap.c @@ -0,0 +1,4250 @@ +// This file is generated. Do not edit! +// see https://github.com/hpvb/dynload-wrapper for details +// generated by generate-wrapper.py 0.6 on 2024-12-04 14:03:52 +// flags: generate-wrapper.py --include ./accesskit.h --sys-include accesskit.h --soname libaccesskit.so --init-name libaccesskit --output-header accesskit-so_wrap.h --output-implementation accesskit-so_wrap.c +// +#include + +#define accesskit_node_role accesskit_node_role_dylibloader_orig_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_orig_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_orig_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_orig_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_orig_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_orig_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_orig_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_orig_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_orig_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_orig_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_orig_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_orig_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_orig_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_orig_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_orig_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_orig_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_orig_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_orig_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_orig_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_orig_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_orig_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_orig_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_orig_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_orig_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_orig_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_orig_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_orig_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_orig_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_orig_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_orig_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_orig_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_orig_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_orig_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_orig_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_orig_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_orig_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_orig_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_orig_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_orig_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_orig_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_orig_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_orig_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_orig_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_orig_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_orig_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_orig_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_orig_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_orig_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_orig_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_orig_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_orig_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_orig_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_orig_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_orig_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_orig_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_orig_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_orig_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_orig_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_orig_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_orig_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_orig_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_orig_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_orig_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_orig_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_orig_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_orig_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_orig_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_orig_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_orig_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_orig_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_orig_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_orig_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_orig_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_orig_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_orig_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_orig_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_orig_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_orig_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_orig_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_orig_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_orig_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_orig_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_orig_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_orig_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_orig_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_orig_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_orig_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_orig_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_orig_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_orig_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_orig_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_orig_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_orig_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_orig_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_orig_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_orig_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_orig_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_orig_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_orig_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_orig_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_orig_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_new accesskit_unix_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_free accesskit_unix_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_set_root_window_bounds accesskit_unix_adapter_set_root_window_bounds_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_update_if_active accesskit_unix_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_update_window_focus_state accesskit_unix_adapter_update_window_focus_state_dylibloader_orig_libaccesskit +#include "accesskit.h" +#undef accesskit_node_role +#undef accesskit_node_set_role +#undef accesskit_node_supports_action +#undef accesskit_node_add_action +#undef accesskit_node_remove_action +#undef accesskit_node_clear_actions +#undef accesskit_node_is_hidden +#undef accesskit_node_set_hidden +#undef accesskit_node_clear_hidden +#undef accesskit_node_is_linked +#undef accesskit_node_set_linked +#undef accesskit_node_clear_linked +#undef accesskit_node_is_multiselectable +#undef accesskit_node_set_multiselectable +#undef accesskit_node_clear_multiselectable +#undef accesskit_node_is_required +#undef accesskit_node_set_required +#undef accesskit_node_clear_required +#undef accesskit_node_is_visited +#undef accesskit_node_set_visited +#undef accesskit_node_clear_visited +#undef accesskit_node_is_busy +#undef accesskit_node_set_busy +#undef accesskit_node_clear_busy +#undef accesskit_node_is_live_atomic +#undef accesskit_node_set_live_atomic +#undef accesskit_node_clear_live_atomic +#undef accesskit_node_is_modal +#undef accesskit_node_set_modal +#undef accesskit_node_clear_modal +#undef accesskit_node_is_touch_transparent +#undef accesskit_node_set_touch_transparent +#undef accesskit_node_clear_touch_transparent +#undef accesskit_node_is_read_only +#undef accesskit_node_set_read_only +#undef accesskit_node_clear_read_only +#undef accesskit_node_is_disabled +#undef accesskit_node_set_disabled +#undef accesskit_node_clear_disabled +#undef accesskit_node_is_bold +#undef accesskit_node_set_bold +#undef accesskit_node_clear_bold +#undef accesskit_node_is_italic +#undef accesskit_node_set_italic +#undef accesskit_node_clear_italic +#undef accesskit_node_clips_children +#undef accesskit_node_set_clips_children +#undef accesskit_node_clear_clips_children +#undef accesskit_node_is_line_breaking_object +#undef accesskit_node_set_is_line_breaking_object +#undef accesskit_node_clear_is_line_breaking_object +#undef accesskit_node_is_page_breaking_object +#undef accesskit_node_set_is_page_breaking_object +#undef accesskit_node_clear_is_page_breaking_object +#undef accesskit_node_is_spelling_error +#undef accesskit_node_set_is_spelling_error +#undef accesskit_node_clear_is_spelling_error +#undef accesskit_node_is_grammar_error +#undef accesskit_node_set_is_grammar_error +#undef accesskit_node_clear_is_grammar_error +#undef accesskit_node_is_search_match +#undef accesskit_node_set_is_search_match +#undef accesskit_node_clear_is_search_match +#undef accesskit_node_is_suggestion +#undef accesskit_node_set_is_suggestion +#undef accesskit_node_clear_is_suggestion +#undef accesskit_node_children +#undef accesskit_node_set_children +#undef accesskit_node_push_child +#undef accesskit_node_clear_children +#undef accesskit_node_controls +#undef accesskit_node_set_controls +#undef accesskit_node_push_controlled +#undef accesskit_node_clear_controls +#undef accesskit_node_details +#undef accesskit_node_set_details +#undef accesskit_node_push_detail +#undef accesskit_node_clear_details +#undef accesskit_node_described_by +#undef accesskit_node_set_described_by +#undef accesskit_node_push_described_by +#undef accesskit_node_clear_described_by +#undef accesskit_node_flow_to +#undef accesskit_node_set_flow_to +#undef accesskit_node_push_flow_to +#undef accesskit_node_clear_flow_to +#undef accesskit_node_labelled_by +#undef accesskit_node_set_labelled_by +#undef accesskit_node_push_labelled_by +#undef accesskit_node_clear_labelled_by +#undef accesskit_node_owns +#undef accesskit_node_set_owns +#undef accesskit_node_push_owned +#undef accesskit_node_clear_owns +#undef accesskit_node_radio_group +#undef accesskit_node_set_radio_group +#undef accesskit_node_push_to_radio_group +#undef accesskit_node_clear_radio_group +#undef accesskit_node_active_descendant +#undef accesskit_node_set_active_descendant +#undef accesskit_node_clear_active_descendant +#undef accesskit_node_error_message +#undef accesskit_node_set_error_message +#undef accesskit_node_clear_error_message +#undef accesskit_node_in_page_link_target +#undef accesskit_node_set_in_page_link_target +#undef accesskit_node_clear_in_page_link_target +#undef accesskit_node_member_of +#undef accesskit_node_set_member_of +#undef accesskit_node_clear_member_of +#undef accesskit_node_next_on_line +#undef accesskit_node_set_next_on_line +#undef accesskit_node_clear_next_on_line +#undef accesskit_node_previous_on_line +#undef accesskit_node_set_previous_on_line +#undef accesskit_node_clear_previous_on_line +#undef accesskit_node_popup_for +#undef accesskit_node_set_popup_for +#undef accesskit_node_clear_popup_for +#undef accesskit_string_free +#undef accesskit_node_label +#undef accesskit_node_set_label +#undef accesskit_node_clear_label +#undef accesskit_node_description +#undef accesskit_node_set_description +#undef accesskit_node_clear_description +#undef accesskit_node_value +#undef accesskit_node_set_value +#undef accesskit_node_clear_value +#undef accesskit_node_access_key +#undef accesskit_node_set_access_key +#undef accesskit_node_clear_access_key +#undef accesskit_node_author_id +#undef accesskit_node_set_author_id +#undef accesskit_node_clear_author_id +#undef accesskit_node_class_name +#undef accesskit_node_set_class_name +#undef accesskit_node_clear_class_name +#undef accesskit_node_font_family +#undef accesskit_node_set_font_family +#undef accesskit_node_clear_font_family +#undef accesskit_node_html_tag +#undef accesskit_node_set_html_tag +#undef accesskit_node_clear_html_tag +#undef accesskit_node_inner_html +#undef accesskit_node_set_inner_html +#undef accesskit_node_clear_inner_html +#undef accesskit_node_keyboard_shortcut +#undef accesskit_node_set_keyboard_shortcut +#undef accesskit_node_clear_keyboard_shortcut +#undef accesskit_node_language +#undef accesskit_node_set_language +#undef accesskit_node_clear_language +#undef accesskit_node_placeholder +#undef accesskit_node_set_placeholder +#undef accesskit_node_clear_placeholder +#undef accesskit_node_role_description +#undef accesskit_node_set_role_description +#undef accesskit_node_clear_role_description +#undef accesskit_node_state_description +#undef accesskit_node_set_state_description +#undef accesskit_node_clear_state_description +#undef accesskit_node_tooltip +#undef accesskit_node_set_tooltip +#undef accesskit_node_clear_tooltip +#undef accesskit_node_url +#undef accesskit_node_set_url +#undef accesskit_node_clear_url +#undef accesskit_node_row_index_text +#undef accesskit_node_set_row_index_text +#undef accesskit_node_clear_row_index_text +#undef accesskit_node_column_index_text +#undef accesskit_node_set_column_index_text +#undef accesskit_node_clear_column_index_text +#undef accesskit_node_scroll_x +#undef accesskit_node_set_scroll_x +#undef accesskit_node_clear_scroll_x +#undef accesskit_node_scroll_x_min +#undef accesskit_node_set_scroll_x_min +#undef accesskit_node_clear_scroll_x_min +#undef accesskit_node_scroll_x_max +#undef accesskit_node_set_scroll_x_max +#undef accesskit_node_clear_scroll_x_max +#undef accesskit_node_scroll_y +#undef accesskit_node_set_scroll_y +#undef accesskit_node_clear_scroll_y +#undef accesskit_node_scroll_y_min +#undef accesskit_node_set_scroll_y_min +#undef accesskit_node_clear_scroll_y_min +#undef accesskit_node_scroll_y_max +#undef accesskit_node_set_scroll_y_max +#undef accesskit_node_clear_scroll_y_max +#undef accesskit_node_numeric_value +#undef accesskit_node_set_numeric_value +#undef accesskit_node_clear_numeric_value +#undef accesskit_node_min_numeric_value +#undef accesskit_node_set_min_numeric_value +#undef accesskit_node_clear_min_numeric_value +#undef accesskit_node_max_numeric_value +#undef accesskit_node_set_max_numeric_value +#undef accesskit_node_clear_max_numeric_value +#undef accesskit_node_numeric_value_step +#undef accesskit_node_set_numeric_value_step +#undef accesskit_node_clear_numeric_value_step +#undef accesskit_node_numeric_value_jump +#undef accesskit_node_set_numeric_value_jump +#undef accesskit_node_clear_numeric_value_jump +#undef accesskit_node_font_size +#undef accesskit_node_set_font_size +#undef accesskit_node_clear_font_size +#undef accesskit_node_font_weight +#undef accesskit_node_set_font_weight +#undef accesskit_node_clear_font_weight +#undef accesskit_node_row_count +#undef accesskit_node_set_row_count +#undef accesskit_node_clear_row_count +#undef accesskit_node_column_count +#undef accesskit_node_set_column_count +#undef accesskit_node_clear_column_count +#undef accesskit_node_row_index +#undef accesskit_node_set_row_index +#undef accesskit_node_clear_row_index +#undef accesskit_node_column_index +#undef accesskit_node_set_column_index +#undef accesskit_node_clear_column_index +#undef accesskit_node_row_span +#undef accesskit_node_set_row_span +#undef accesskit_node_clear_row_span +#undef accesskit_node_column_span +#undef accesskit_node_set_column_span +#undef accesskit_node_clear_column_span +#undef accesskit_node_level +#undef accesskit_node_set_level +#undef accesskit_node_clear_level +#undef accesskit_node_size_of_set +#undef accesskit_node_set_size_of_set +#undef accesskit_node_clear_size_of_set +#undef accesskit_node_position_in_set +#undef accesskit_node_set_position_in_set +#undef accesskit_node_clear_position_in_set +#undef accesskit_node_color_value +#undef accesskit_node_set_color_value +#undef accesskit_node_clear_color_value +#undef accesskit_node_background_color +#undef accesskit_node_set_background_color +#undef accesskit_node_clear_background_color +#undef accesskit_node_foreground_color +#undef accesskit_node_set_foreground_color +#undef accesskit_node_clear_foreground_color +#undef accesskit_node_overline +#undef accesskit_node_set_overline +#undef accesskit_node_clear_overline +#undef accesskit_node_strikethrough +#undef accesskit_node_set_strikethrough +#undef accesskit_node_clear_strikethrough +#undef accesskit_node_underline +#undef accesskit_node_set_underline +#undef accesskit_node_clear_underline +#undef accesskit_node_character_lengths +#undef accesskit_node_set_character_lengths +#undef accesskit_node_clear_character_lengths +#undef accesskit_node_word_lengths +#undef accesskit_node_set_word_lengths +#undef accesskit_node_clear_word_lengths +#undef accesskit_node_character_positions +#undef accesskit_node_set_character_positions +#undef accesskit_node_clear_character_positions +#undef accesskit_node_character_widths +#undef accesskit_node_set_character_widths +#undef accesskit_node_clear_character_widths +#undef accesskit_node_is_expanded +#undef accesskit_node_set_expanded +#undef accesskit_node_clear_expanded +#undef accesskit_node_is_selected +#undef accesskit_node_set_selected +#undef accesskit_node_clear_selected +#undef accesskit_node_invalid +#undef accesskit_node_set_invalid +#undef accesskit_node_clear_invalid +#undef accesskit_node_toggled +#undef accesskit_node_set_toggled +#undef accesskit_node_clear_toggled +#undef accesskit_node_live +#undef accesskit_node_set_live +#undef accesskit_node_clear_live +#undef accesskit_node_text_direction +#undef accesskit_node_set_text_direction +#undef accesskit_node_clear_text_direction +#undef accesskit_node_orientation +#undef accesskit_node_set_orientation +#undef accesskit_node_clear_orientation +#undef accesskit_node_sort_direction +#undef accesskit_node_set_sort_direction +#undef accesskit_node_clear_sort_direction +#undef accesskit_node_aria_current +#undef accesskit_node_set_aria_current +#undef accesskit_node_clear_aria_current +#undef accesskit_node_auto_complete +#undef accesskit_node_set_auto_complete +#undef accesskit_node_clear_auto_complete +#undef accesskit_node_has_popup +#undef accesskit_node_set_has_popup +#undef accesskit_node_clear_has_popup +#undef accesskit_node_list_style +#undef accesskit_node_set_list_style +#undef accesskit_node_clear_list_style +#undef accesskit_node_text_align +#undef accesskit_node_set_text_align +#undef accesskit_node_clear_text_align +#undef accesskit_node_vertical_offset +#undef accesskit_node_set_vertical_offset +#undef accesskit_node_clear_vertical_offset +#undef accesskit_node_transform +#undef accesskit_node_set_transform +#undef accesskit_node_clear_transform +#undef accesskit_node_bounds +#undef accesskit_node_set_bounds +#undef accesskit_node_clear_bounds +#undef accesskit_node_text_selection +#undef accesskit_node_set_text_selection +#undef accesskit_node_clear_text_selection +#undef accesskit_custom_action_new +#undef accesskit_custom_actions_free +#undef accesskit_node_custom_actions +#undef accesskit_node_set_custom_actions +#undef accesskit_node_push_custom_action +#undef accesskit_node_clear_custom_actions +#undef accesskit_node_new +#undef accesskit_node_free +#undef accesskit_tree_new +#undef accesskit_tree_free +#undef accesskit_tree_get_toolkit_name +#undef accesskit_tree_set_toolkit_name +#undef accesskit_tree_clear_toolkit_name +#undef accesskit_tree_get_toolkit_version +#undef accesskit_tree_set_toolkit_version +#undef accesskit_tree_clear_toolkit_version +#undef accesskit_tree_update_with_focus +#undef accesskit_tree_update_with_capacity_and_focus +#undef accesskit_tree_update_free +#undef accesskit_tree_update_push_node +#undef accesskit_tree_update_set_tree +#undef accesskit_tree_update_clear_tree +#undef accesskit_tree_update_set_focus +#undef accesskit_action_request_free +#undef accesskit_affine_identity +#undef accesskit_affine_flip_y +#undef accesskit_affine_flip_x +#undef accesskit_affine_scale +#undef accesskit_affine_scale_non_uniform +#undef accesskit_affine_translate +#undef accesskit_affine_map_unit_square +#undef accesskit_affine_determinant +#undef accesskit_affine_inverse +#undef accesskit_affine_transform_rect_bbox +#undef accesskit_affine_is_finite +#undef accesskit_affine_is_nan +#undef accesskit_point_to_vec2 +#undef accesskit_rect_from_points +#undef accesskit_rect_from_origin_size +#undef accesskit_rect_with_origin +#undef accesskit_rect_with_size +#undef accesskit_rect_width +#undef accesskit_rect_height +#undef accesskit_rect_min_x +#undef accesskit_rect_max_x +#undef accesskit_rect_min_y +#undef accesskit_rect_max_y +#undef accesskit_rect_origin +#undef accesskit_rect_size +#undef accesskit_rect_abs +#undef accesskit_rect_area +#undef accesskit_rect_is_empty +#undef accesskit_rect_contains +#undef accesskit_rect_union +#undef accesskit_rect_union_pt +#undef accesskit_rect_intersect +#undef accesskit_size_to_vec2 +#undef accesskit_vec2_to_point +#undef accesskit_vec2_to_size +#undef accesskit_unix_adapter_new +#undef accesskit_unix_adapter_free +#undef accesskit_unix_adapter_set_root_window_bounds +#undef accesskit_unix_adapter_update_if_active +#undef accesskit_unix_adapter_update_window_focus_state +#include +#include +accesskit_role (*accesskit_node_role_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_role_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_role); +bool (*accesskit_node_supports_action_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *, accesskit_action); +void (*accesskit_node_add_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +void (*accesskit_node_remove_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +void (*accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_linked_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_required_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_visited_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_busy_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_modal_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_bold_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_italic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_clips_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +bool (*accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_child_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_controls_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_details_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_detail_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_described_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_flow_to_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_owns_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_owned_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node_ids (*accesskit_node_radio_group_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +void (*accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_error_message_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_member_of_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_node_id (*accesskit_node_popup_for_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +void (*accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +void (*accesskit_string_free_dylibloader_wrapper_libaccesskit)(char *); +char *(*accesskit_node_label_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_access_key_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_author_id_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_class_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_font_family_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_html_tag_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_inner_html_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_language_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_placeholder_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_role_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_state_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_tooltip_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_url_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +char *(*accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +void (*accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_font_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_double (*accesskit_node_font_weight_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +void (*accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_row_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_column_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_level_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_index (*accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +void (*accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_color_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_background_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_color (*accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +void (*accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_overline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_decoration (*accesskit_node_underline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +void (*accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_lengths (*accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +void (*accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_lengths (*accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +void (*accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_coords (*accesskit_node_character_positions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +void (*accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_coords (*accesskit_node_character_widths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +void (*accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_bool (*accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +void (*accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_bool (*accesskit_node_is_selected_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +void (*accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_invalid (*accesskit_node_invalid_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_invalid); +void (*accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_toggled (*accesskit_node_toggled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_toggled); +void (*accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_live (*accesskit_node_live_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_live); +void (*accesskit_node_clear_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_direction (*accesskit_node_text_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_direction); +void (*accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_orientation (*accesskit_node_orientation_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_orientation); +void (*accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_sort_direction (*accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_sort_direction); +void (*accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_aria_current (*accesskit_node_aria_current_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_aria_current); +void (*accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_auto_complete (*accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_auto_complete); +void (*accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_has_popup (*accesskit_node_has_popup_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_has_popup); +void (*accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_list_style (*accesskit_node_list_style_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_list_style); +void (*accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_align (*accesskit_node_text_align_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_align); +void (*accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_vertical_offset (*accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_vertical_offset); +void (*accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +const struct accesskit_affine *(*accesskit_node_transform_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_affine); +void (*accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_rect (*accesskit_node_bounds_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_rect); +void (*accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_opt_text_selection (*accesskit_node_text_selection_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_text_selection); +void (*accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_custom_action (*accesskit_custom_action_new_dylibloader_wrapper_libaccesskit)(int32_t, const char *); +void (*accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit)(struct accesskit_custom_actions *); +const struct accesskit_custom_actions *(*accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +void (*accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const struct accesskit_custom_action *); +void (*accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_custom_action); +void (*accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_node *(*accesskit_node_new_dylibloader_wrapper_libaccesskit)(accesskit_role); +void (*accesskit_node_free_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +struct accesskit_tree *(*accesskit_tree_new_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +void (*accesskit_tree_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +char *(*accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +void (*accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +void (*accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +char *(*accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +void (*accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +void (*accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +struct accesskit_tree_update *(*accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +struct accesskit_tree_update *(*accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit)(size_t, accesskit_node_id); +void (*accesskit_tree_update_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +void (*accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id, struct accesskit_node *); +void (*accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, struct accesskit_tree *); +void (*accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +void (*accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id); +void (*accesskit_action_request_free_dylibloader_wrapper_libaccesskit)(struct accesskit_action_request *); +struct accesskit_affine (*accesskit_affine_identity_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit)(void); +struct accesskit_affine (*accesskit_affine_scale_dylibloader_wrapper_libaccesskit)(double); +struct accesskit_affine (*accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit)(double, double); +struct accesskit_affine (*accesskit_affine_translate_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +struct accesskit_affine (*accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit)(struct accesskit_rect); +double (*accesskit_affine_determinant_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +struct accesskit_affine (*accesskit_affine_inverse_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +struct accesskit_rect (*accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit)(struct accesskit_affine, struct accesskit_rect); +bool (*accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +bool (*accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +struct accesskit_vec2 (*accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_point); +struct accesskit_rect (*accesskit_rect_from_points_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_size); +struct accesskit_rect (*accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_with_size_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_size); +double (*accesskit_rect_width_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_height_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_min_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_max_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_min_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_max_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_point (*accesskit_rect_origin_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_size (*accesskit_rect_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +struct accesskit_rect (*accesskit_rect_abs_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +double (*accesskit_rect_area_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +bool (*accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +bool (*accesskit_rect_contains_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_union_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +struct accesskit_rect (*accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +struct accesskit_rect (*accesskit_rect_intersect_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +struct accesskit_vec2 (*accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_size); +struct accesskit_point (*accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +struct accesskit_size (*accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +struct accesskit_unix_adapter *(*accesskit_unix_adapter_new_dylibloader_wrapper_libaccesskit)(accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *, accesskit_deactivation_handler_callback, void *); +void (*accesskit_unix_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *); +void (*accesskit_unix_adapter_set_root_window_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *, struct accesskit_rect, struct accesskit_rect); +void (*accesskit_unix_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *, accesskit_tree_update_factory, void *); +void (*accesskit_unix_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *, bool); +int initialize_libaccesskit(int verbose, void *handle) { + char *error; + dlerror(); +// accesskit_node_role + *(void **) (&accesskit_node_role_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_role"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_role + *(void **) (&accesskit_node_set_role_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_role"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_supports_action + *(void **) (&accesskit_node_supports_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_supports_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_add_action + *(void **) (&accesskit_node_add_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_add_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_remove_action + *(void **) (&accesskit_node_remove_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_remove_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_actions + *(void **) (&accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_hidden + *(void **) (&accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_hidden + *(void **) (&accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_hidden + *(void **) (&accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_hidden"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_linked + *(void **) (&accesskit_node_is_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_linked + *(void **) (&accesskit_node_set_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_linked + *(void **) (&accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_linked"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_multiselectable + *(void **) (&accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_multiselectable + *(void **) (&accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_multiselectable + *(void **) (&accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_multiselectable"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_required + *(void **) (&accesskit_node_is_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_required + *(void **) (&accesskit_node_set_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_required + *(void **) (&accesskit_node_clear_required_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_required"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_visited + *(void **) (&accesskit_node_is_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_visited + *(void **) (&accesskit_node_set_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_visited + *(void **) (&accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_visited"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_busy + *(void **) (&accesskit_node_is_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_busy + *(void **) (&accesskit_node_set_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_busy + *(void **) (&accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_busy"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_live_atomic + *(void **) (&accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_live_atomic + *(void **) (&accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_live_atomic + *(void **) (&accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_live_atomic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_modal + *(void **) (&accesskit_node_is_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_modal + *(void **) (&accesskit_node_set_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_modal + *(void **) (&accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_modal"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_touch_transparent + *(void **) (&accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_touch_transparent + *(void **) (&accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_touch_transparent + *(void **) (&accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_touch_transparent"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_read_only + *(void **) (&accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_read_only + *(void **) (&accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_read_only + *(void **) (&accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_read_only"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_disabled + *(void **) (&accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_disabled + *(void **) (&accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_disabled + *(void **) (&accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_disabled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_bold + *(void **) (&accesskit_node_is_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_bold + *(void **) (&accesskit_node_set_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_bold + *(void **) (&accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_bold"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_italic + *(void **) (&accesskit_node_is_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_italic + *(void **) (&accesskit_node_set_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_italic + *(void **) (&accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_italic"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clips_children + *(void **) (&accesskit_node_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_clips_children + *(void **) (&accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_clips_children + *(void **) (&accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_clips_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_line_breaking_object + *(void **) (&accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_line_breaking_object + *(void **) (&accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_line_breaking_object + *(void **) (&accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_line_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_page_breaking_object + *(void **) (&accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_page_breaking_object + *(void **) (&accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_page_breaking_object + *(void **) (&accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_page_breaking_object"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_spelling_error + *(void **) (&accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_spelling_error + *(void **) (&accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_spelling_error + *(void **) (&accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_spelling_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_grammar_error + *(void **) (&accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_grammar_error + *(void **) (&accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_grammar_error + *(void **) (&accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_grammar_error"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_search_match + *(void **) (&accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_search_match + *(void **) (&accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_search_match + *(void **) (&accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_search_match"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_suggestion + *(void **) (&accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_is_suggestion + *(void **) (&accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_is_suggestion + *(void **) (&accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_is_suggestion"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_children + *(void **) (&accesskit_node_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_children + *(void **) (&accesskit_node_set_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_child + *(void **) (&accesskit_node_push_child_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_child"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_children + *(void **) (&accesskit_node_clear_children_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_children"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_controls + *(void **) (&accesskit_node_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_controls + *(void **) (&accesskit_node_set_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_controlled + *(void **) (&accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_controlled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_controls + *(void **) (&accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_controls"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_details + *(void **) (&accesskit_node_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_details + *(void **) (&accesskit_node_set_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_detail + *(void **) (&accesskit_node_push_detail_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_detail"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_details + *(void **) (&accesskit_node_clear_details_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_details"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_described_by + *(void **) (&accesskit_node_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_described_by + *(void **) (&accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_described_by + *(void **) (&accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_described_by + *(void **) (&accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_described_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_flow_to + *(void **) (&accesskit_node_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_flow_to + *(void **) (&accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_flow_to + *(void **) (&accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_flow_to + *(void **) (&accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_flow_to"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_labelled_by + *(void **) (&accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_labelled_by + *(void **) (&accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_labelled_by + *(void **) (&accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_labelled_by + *(void **) (&accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_labelled_by"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_owns + *(void **) (&accesskit_node_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_owns + *(void **) (&accesskit_node_set_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_owned + *(void **) (&accesskit_node_push_owned_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_owned"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_owns + *(void **) (&accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_owns"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_radio_group + *(void **) (&accesskit_node_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_radio_group + *(void **) (&accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_to_radio_group + *(void **) (&accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_to_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_radio_group + *(void **) (&accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_radio_group"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_active_descendant + *(void **) (&accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_active_descendant + *(void **) (&accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_active_descendant + *(void **) (&accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_active_descendant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_error_message + *(void **) (&accesskit_node_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_error_message + *(void **) (&accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_error_message + *(void **) (&accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_error_message"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_in_page_link_target + *(void **) (&accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_in_page_link_target + *(void **) (&accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_in_page_link_target + *(void **) (&accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_in_page_link_target"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_member_of + *(void **) (&accesskit_node_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_member_of + *(void **) (&accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_member_of + *(void **) (&accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_member_of"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_next_on_line + *(void **) (&accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_next_on_line + *(void **) (&accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_next_on_line + *(void **) (&accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_next_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_previous_on_line + *(void **) (&accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_previous_on_line + *(void **) (&accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_previous_on_line + *(void **) (&accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_previous_on_line"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_popup_for + *(void **) (&accesskit_node_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_popup_for + *(void **) (&accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_popup_for + *(void **) (&accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_popup_for"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_string_free + *(void **) (&accesskit_string_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_string_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_label + *(void **) (&accesskit_node_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_label + *(void **) (&accesskit_node_set_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_label + *(void **) (&accesskit_node_clear_label_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_label"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_description + *(void **) (&accesskit_node_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_description + *(void **) (&accesskit_node_set_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_description + *(void **) (&accesskit_node_clear_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_value + *(void **) (&accesskit_node_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_value + *(void **) (&accesskit_node_set_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_value + *(void **) (&accesskit_node_clear_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_access_key + *(void **) (&accesskit_node_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_access_key + *(void **) (&accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_access_key + *(void **) (&accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_access_key"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_author_id + *(void **) (&accesskit_node_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_author_id + *(void **) (&accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_author_id + *(void **) (&accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_author_id"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_class_name + *(void **) (&accesskit_node_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_class_name + *(void **) (&accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_class_name + *(void **) (&accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_class_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_family + *(void **) (&accesskit_node_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_family + *(void **) (&accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_family + *(void **) (&accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_family"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_html_tag + *(void **) (&accesskit_node_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_html_tag + *(void **) (&accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_html_tag + *(void **) (&accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_html_tag"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_inner_html + *(void **) (&accesskit_node_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_inner_html + *(void **) (&accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_inner_html + *(void **) (&accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_inner_html"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_keyboard_shortcut + *(void **) (&accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_keyboard_shortcut + *(void **) (&accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_keyboard_shortcut + *(void **) (&accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_keyboard_shortcut"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_language + *(void **) (&accesskit_node_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_language + *(void **) (&accesskit_node_set_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_language + *(void **) (&accesskit_node_clear_language_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_language"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_placeholder + *(void **) (&accesskit_node_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_placeholder + *(void **) (&accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_placeholder + *(void **) (&accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_placeholder"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_role_description + *(void **) (&accesskit_node_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_role_description + *(void **) (&accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_role_description + *(void **) (&accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_role_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_state_description + *(void **) (&accesskit_node_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_state_description + *(void **) (&accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_state_description + *(void **) (&accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_state_description"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_tooltip + *(void **) (&accesskit_node_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_tooltip + *(void **) (&accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_tooltip + *(void **) (&accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_tooltip"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_url + *(void **) (&accesskit_node_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_url + *(void **) (&accesskit_node_set_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_url + *(void **) (&accesskit_node_clear_url_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_url"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_index_text + *(void **) (&accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_index_text + *(void **) (&accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_index_text + *(void **) (&accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_index_text + *(void **) (&accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_index_text + *(void **) (&accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_index_text + *(void **) (&accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_index_text"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x + *(void **) (&accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x + *(void **) (&accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x + *(void **) (&accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x_min + *(void **) (&accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x_min + *(void **) (&accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x_min + *(void **) (&accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_x_max + *(void **) (&accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_x_max + *(void **) (&accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_x_max + *(void **) (&accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_x_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y + *(void **) (&accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y + *(void **) (&accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y + *(void **) (&accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y_min + *(void **) (&accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y_min + *(void **) (&accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y_min + *(void **) (&accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y_min"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_scroll_y_max + *(void **) (&accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_scroll_y_max + *(void **) (&accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_scroll_y_max + *(void **) (&accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_scroll_y_max"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value + *(void **) (&accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value + *(void **) (&accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value + *(void **) (&accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_min_numeric_value + *(void **) (&accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_min_numeric_value + *(void **) (&accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_min_numeric_value + *(void **) (&accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_min_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_max_numeric_value + *(void **) (&accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_max_numeric_value + *(void **) (&accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_max_numeric_value + *(void **) (&accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_max_numeric_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value_step + *(void **) (&accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value_step + *(void **) (&accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value_step + *(void **) (&accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value_step"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_numeric_value_jump + *(void **) (&accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_numeric_value_jump + *(void **) (&accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_numeric_value_jump + *(void **) (&accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_numeric_value_jump"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_size + *(void **) (&accesskit_node_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_size + *(void **) (&accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_size + *(void **) (&accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_font_weight + *(void **) (&accesskit_node_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_font_weight + *(void **) (&accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_font_weight + *(void **) (&accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_font_weight"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_count + *(void **) (&accesskit_node_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_count + *(void **) (&accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_count + *(void **) (&accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_count + *(void **) (&accesskit_node_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_count + *(void **) (&accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_count + *(void **) (&accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_count"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_index + *(void **) (&accesskit_node_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_index + *(void **) (&accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_index + *(void **) (&accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_index + *(void **) (&accesskit_node_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_index + *(void **) (&accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_index + *(void **) (&accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_index"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_row_span + *(void **) (&accesskit_node_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_row_span + *(void **) (&accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_row_span + *(void **) (&accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_row_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_column_span + *(void **) (&accesskit_node_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_column_span + *(void **) (&accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_column_span + *(void **) (&accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_column_span"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_level + *(void **) (&accesskit_node_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_level + *(void **) (&accesskit_node_set_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_level + *(void **) (&accesskit_node_clear_level_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_level"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_size_of_set + *(void **) (&accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_size_of_set + *(void **) (&accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_size_of_set + *(void **) (&accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_size_of_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_position_in_set + *(void **) (&accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_position_in_set + *(void **) (&accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_position_in_set + *(void **) (&accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_position_in_set"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_color_value + *(void **) (&accesskit_node_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_color_value + *(void **) (&accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_color_value + *(void **) (&accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_color_value"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_background_color + *(void **) (&accesskit_node_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_background_color + *(void **) (&accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_background_color + *(void **) (&accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_background_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_foreground_color + *(void **) (&accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_foreground_color + *(void **) (&accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_foreground_color + *(void **) (&accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_foreground_color"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_overline + *(void **) (&accesskit_node_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_overline + *(void **) (&accesskit_node_set_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_overline + *(void **) (&accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_overline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_strikethrough + *(void **) (&accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_strikethrough + *(void **) (&accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_strikethrough + *(void **) (&accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_strikethrough"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_underline + *(void **) (&accesskit_node_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_underline + *(void **) (&accesskit_node_set_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_underline + *(void **) (&accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_underline"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_lengths + *(void **) (&accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_lengths + *(void **) (&accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_lengths + *(void **) (&accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_word_lengths + *(void **) (&accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_word_lengths + *(void **) (&accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_word_lengths + *(void **) (&accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_word_lengths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_positions + *(void **) (&accesskit_node_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_positions + *(void **) (&accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_positions + *(void **) (&accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_positions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_character_widths + *(void **) (&accesskit_node_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_character_widths + *(void **) (&accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_character_widths + *(void **) (&accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_character_widths"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_expanded + *(void **) (&accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_expanded + *(void **) (&accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_expanded + *(void **) (&accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_expanded"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_is_selected + *(void **) (&accesskit_node_is_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_is_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_selected + *(void **) (&accesskit_node_set_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_selected + *(void **) (&accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_selected"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_invalid + *(void **) (&accesskit_node_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_invalid + *(void **) (&accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_invalid + *(void **) (&accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_invalid"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_toggled + *(void **) (&accesskit_node_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_toggled + *(void **) (&accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_toggled + *(void **) (&accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_toggled"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_live + *(void **) (&accesskit_node_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_live + *(void **) (&accesskit_node_set_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_live + *(void **) (&accesskit_node_clear_live_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_live"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_direction + *(void **) (&accesskit_node_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_direction + *(void **) (&accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_direction + *(void **) (&accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_orientation + *(void **) (&accesskit_node_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_orientation + *(void **) (&accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_orientation + *(void **) (&accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_orientation"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_sort_direction + *(void **) (&accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_sort_direction + *(void **) (&accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_sort_direction + *(void **) (&accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_sort_direction"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_aria_current + *(void **) (&accesskit_node_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_aria_current + *(void **) (&accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_aria_current + *(void **) (&accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_aria_current"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_auto_complete + *(void **) (&accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_auto_complete + *(void **) (&accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_auto_complete + *(void **) (&accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_auto_complete"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_has_popup + *(void **) (&accesskit_node_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_has_popup + *(void **) (&accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_has_popup + *(void **) (&accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_has_popup"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_list_style + *(void **) (&accesskit_node_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_list_style + *(void **) (&accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_list_style + *(void **) (&accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_list_style"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_align + *(void **) (&accesskit_node_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_align + *(void **) (&accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_align + *(void **) (&accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_align"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_vertical_offset + *(void **) (&accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_vertical_offset + *(void **) (&accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_vertical_offset + *(void **) (&accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_vertical_offset"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_transform + *(void **) (&accesskit_node_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_transform + *(void **) (&accesskit_node_set_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_transform + *(void **) (&accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_transform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_bounds + *(void **) (&accesskit_node_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_bounds + *(void **) (&accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_bounds + *(void **) (&accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_text_selection + *(void **) (&accesskit_node_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_text_selection + *(void **) (&accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_text_selection + *(void **) (&accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_text_selection"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_custom_action_new + *(void **) (&accesskit_custom_action_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_custom_action_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_custom_actions_free + *(void **) (&accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_custom_actions_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_custom_actions + *(void **) (&accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_set_custom_actions + *(void **) (&accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_set_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_push_custom_action + *(void **) (&accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_push_custom_action"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_clear_custom_actions + *(void **) (&accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_clear_custom_actions"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_new + *(void **) (&accesskit_node_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_node_free + *(void **) (&accesskit_node_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_node_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_new + *(void **) (&accesskit_tree_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_free + *(void **) (&accesskit_tree_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_get_toolkit_name + *(void **) (&accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_get_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_set_toolkit_name + *(void **) (&accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_set_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_clear_toolkit_name + *(void **) (&accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_clear_toolkit_name"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_get_toolkit_version + *(void **) (&accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_get_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_set_toolkit_version + *(void **) (&accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_set_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_clear_toolkit_version + *(void **) (&accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_clear_toolkit_version"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_with_focus + *(void **) (&accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_with_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_with_capacity_and_focus + *(void **) (&accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_with_capacity_and_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_free + *(void **) (&accesskit_tree_update_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_push_node + *(void **) (&accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_push_node"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_set_tree + *(void **) (&accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_set_tree"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_clear_tree + *(void **) (&accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_clear_tree"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_tree_update_set_focus + *(void **) (&accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_tree_update_set_focus"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_action_request_free + *(void **) (&accesskit_action_request_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_action_request_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_identity + *(void **) (&accesskit_affine_identity_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_identity"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_flip_y + *(void **) (&accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_flip_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_flip_x + *(void **) (&accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_flip_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_scale + *(void **) (&accesskit_affine_scale_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_scale"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_scale_non_uniform + *(void **) (&accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_scale_non_uniform"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_translate + *(void **) (&accesskit_affine_translate_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_translate"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_map_unit_square + *(void **) (&accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_map_unit_square"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_determinant + *(void **) (&accesskit_affine_determinant_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_determinant"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_inverse + *(void **) (&accesskit_affine_inverse_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_inverse"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_transform_rect_bbox + *(void **) (&accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_transform_rect_bbox"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_is_finite + *(void **) (&accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_is_finite"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_affine_is_nan + *(void **) (&accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_affine_is_nan"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_point_to_vec2 + *(void **) (&accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_point_to_vec2"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_from_points + *(void **) (&accesskit_rect_from_points_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_from_points"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_from_origin_size + *(void **) (&accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_from_origin_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_with_origin + *(void **) (&accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_with_origin"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_with_size + *(void **) (&accesskit_rect_with_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_with_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_width + *(void **) (&accesskit_rect_width_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_width"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_height + *(void **) (&accesskit_rect_height_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_height"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_min_x + *(void **) (&accesskit_rect_min_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_min_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_max_x + *(void **) (&accesskit_rect_max_x_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_max_x"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_min_y + *(void **) (&accesskit_rect_min_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_min_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_max_y + *(void **) (&accesskit_rect_max_y_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_max_y"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_origin + *(void **) (&accesskit_rect_origin_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_origin"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_size + *(void **) (&accesskit_rect_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_abs + *(void **) (&accesskit_rect_abs_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_abs"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_area + *(void **) (&accesskit_rect_area_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_area"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_is_empty + *(void **) (&accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_is_empty"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_contains + *(void **) (&accesskit_rect_contains_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_contains"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_union + *(void **) (&accesskit_rect_union_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_union"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_union_pt + *(void **) (&accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_union_pt"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_rect_intersect + *(void **) (&accesskit_rect_intersect_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_rect_intersect"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_size_to_vec2 + *(void **) (&accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_size_to_vec2"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_vec2_to_point + *(void **) (&accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_vec2_to_point"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_vec2_to_size + *(void **) (&accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_vec2_to_size"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_unix_adapter_new + *(void **) (&accesskit_unix_adapter_new_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_unix_adapter_new"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_unix_adapter_free + *(void **) (&accesskit_unix_adapter_free_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_unix_adapter_free"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_unix_adapter_set_root_window_bounds + *(void **) (&accesskit_unix_adapter_set_root_window_bounds_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_unix_adapter_set_root_window_bounds"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_unix_adapter_update_if_active + *(void **) (&accesskit_unix_adapter_update_if_active_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_unix_adapter_update_if_active"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +// accesskit_unix_adapter_update_window_focus_state + *(void **) (&accesskit_unix_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit) = dlsym(handle, "accesskit_unix_adapter_update_window_focus_state"); + if (verbose) { + error = dlerror(); + if (error != NULL) { + fprintf(stderr, "%s\n", error); + } + } +return 0; +} diff --git a/drivers/accesskit/dynwrappers/accesskit-so_wrap.h b/drivers/accesskit/dynwrappers/accesskit-so_wrap.h new file mode 100644 index 00000000000..5bad8bbd4fb --- /dev/null +++ b/drivers/accesskit/dynwrappers/accesskit-so_wrap.h @@ -0,0 +1,1558 @@ +#ifndef DYLIBLOAD_WRAPPER_LIBACCESSKIT +#define DYLIBLOAD_WRAPPER_LIBACCESSKIT +// This file is generated. Do not edit! +// see https://github.com/hpvb/dynload-wrapper for details +// generated by generate-wrapper.py 0.6 on 2024-12-04 14:03:52 +// flags: generate-wrapper.py --include ./accesskit.h --sys-include accesskit.h --soname libaccesskit.so --init-name libaccesskit --output-header accesskit-so_wrap.h --output-implementation accesskit-so_wrap.c +// +#include + +#define accesskit_node_role accesskit_node_role_dylibloader_orig_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_orig_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_orig_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_orig_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_orig_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_orig_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_orig_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_orig_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_orig_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_orig_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_orig_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_orig_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_orig_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_orig_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_orig_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_orig_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_orig_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_orig_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_orig_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_orig_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_orig_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_orig_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_orig_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_orig_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_orig_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_orig_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_orig_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_orig_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_orig_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_orig_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_orig_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_orig_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_orig_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_orig_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_orig_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_orig_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_orig_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_orig_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_orig_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_orig_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_orig_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_orig_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_orig_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_orig_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_orig_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_orig_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_orig_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_orig_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_orig_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_orig_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_orig_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_orig_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_orig_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_orig_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_orig_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_orig_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_orig_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_orig_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_orig_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_orig_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_orig_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_orig_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_orig_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_orig_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_orig_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_orig_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_orig_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_orig_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_orig_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_orig_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_orig_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_orig_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_orig_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_orig_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_orig_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_orig_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_orig_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_orig_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_orig_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_orig_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_orig_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_orig_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_orig_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_orig_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_orig_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_orig_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_orig_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_orig_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_orig_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_orig_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_orig_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_orig_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_orig_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_orig_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_orig_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_orig_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_orig_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_orig_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_orig_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_orig_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_orig_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_orig_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_orig_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_orig_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_orig_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_orig_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_orig_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_orig_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_orig_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_orig_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_orig_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_orig_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_orig_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_orig_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_orig_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_orig_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_orig_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_orig_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_orig_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_orig_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_orig_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_orig_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_orig_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_orig_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_orig_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_orig_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_orig_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_orig_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_orig_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_orig_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_orig_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_orig_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_orig_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_orig_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_orig_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_orig_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_orig_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_orig_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_orig_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_orig_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_orig_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_orig_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_orig_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_orig_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_orig_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_orig_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_orig_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_orig_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_orig_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_orig_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_orig_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_orig_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_orig_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_orig_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_orig_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_orig_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_orig_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_orig_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_orig_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_orig_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_orig_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_orig_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_orig_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_orig_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_orig_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_orig_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_orig_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_orig_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_orig_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_orig_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_orig_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_orig_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_orig_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_orig_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_orig_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_orig_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_orig_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_orig_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_orig_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_new accesskit_unix_adapter_new_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_free accesskit_unix_adapter_free_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_set_root_window_bounds accesskit_unix_adapter_set_root_window_bounds_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_update_if_active accesskit_unix_adapter_update_if_active_dylibloader_orig_libaccesskit +#define accesskit_unix_adapter_update_window_focus_state accesskit_unix_adapter_update_window_focus_state_dylibloader_orig_libaccesskit +#include "accesskit.h" +#undef accesskit_node_role +#undef accesskit_node_set_role +#undef accesskit_node_supports_action +#undef accesskit_node_add_action +#undef accesskit_node_remove_action +#undef accesskit_node_clear_actions +#undef accesskit_node_is_hidden +#undef accesskit_node_set_hidden +#undef accesskit_node_clear_hidden +#undef accesskit_node_is_linked +#undef accesskit_node_set_linked +#undef accesskit_node_clear_linked +#undef accesskit_node_is_multiselectable +#undef accesskit_node_set_multiselectable +#undef accesskit_node_clear_multiselectable +#undef accesskit_node_is_required +#undef accesskit_node_set_required +#undef accesskit_node_clear_required +#undef accesskit_node_is_visited +#undef accesskit_node_set_visited +#undef accesskit_node_clear_visited +#undef accesskit_node_is_busy +#undef accesskit_node_set_busy +#undef accesskit_node_clear_busy +#undef accesskit_node_is_live_atomic +#undef accesskit_node_set_live_atomic +#undef accesskit_node_clear_live_atomic +#undef accesskit_node_is_modal +#undef accesskit_node_set_modal +#undef accesskit_node_clear_modal +#undef accesskit_node_is_touch_transparent +#undef accesskit_node_set_touch_transparent +#undef accesskit_node_clear_touch_transparent +#undef accesskit_node_is_read_only +#undef accesskit_node_set_read_only +#undef accesskit_node_clear_read_only +#undef accesskit_node_is_disabled +#undef accesskit_node_set_disabled +#undef accesskit_node_clear_disabled +#undef accesskit_node_is_bold +#undef accesskit_node_set_bold +#undef accesskit_node_clear_bold +#undef accesskit_node_is_italic +#undef accesskit_node_set_italic +#undef accesskit_node_clear_italic +#undef accesskit_node_clips_children +#undef accesskit_node_set_clips_children +#undef accesskit_node_clear_clips_children +#undef accesskit_node_is_line_breaking_object +#undef accesskit_node_set_is_line_breaking_object +#undef accesskit_node_clear_is_line_breaking_object +#undef accesskit_node_is_page_breaking_object +#undef accesskit_node_set_is_page_breaking_object +#undef accesskit_node_clear_is_page_breaking_object +#undef accesskit_node_is_spelling_error +#undef accesskit_node_set_is_spelling_error +#undef accesskit_node_clear_is_spelling_error +#undef accesskit_node_is_grammar_error +#undef accesskit_node_set_is_grammar_error +#undef accesskit_node_clear_is_grammar_error +#undef accesskit_node_is_search_match +#undef accesskit_node_set_is_search_match +#undef accesskit_node_clear_is_search_match +#undef accesskit_node_is_suggestion +#undef accesskit_node_set_is_suggestion +#undef accesskit_node_clear_is_suggestion +#undef accesskit_node_children +#undef accesskit_node_set_children +#undef accesskit_node_push_child +#undef accesskit_node_clear_children +#undef accesskit_node_controls +#undef accesskit_node_set_controls +#undef accesskit_node_push_controlled +#undef accesskit_node_clear_controls +#undef accesskit_node_details +#undef accesskit_node_set_details +#undef accesskit_node_push_detail +#undef accesskit_node_clear_details +#undef accesskit_node_described_by +#undef accesskit_node_set_described_by +#undef accesskit_node_push_described_by +#undef accesskit_node_clear_described_by +#undef accesskit_node_flow_to +#undef accesskit_node_set_flow_to +#undef accesskit_node_push_flow_to +#undef accesskit_node_clear_flow_to +#undef accesskit_node_labelled_by +#undef accesskit_node_set_labelled_by +#undef accesskit_node_push_labelled_by +#undef accesskit_node_clear_labelled_by +#undef accesskit_node_owns +#undef accesskit_node_set_owns +#undef accesskit_node_push_owned +#undef accesskit_node_clear_owns +#undef accesskit_node_radio_group +#undef accesskit_node_set_radio_group +#undef accesskit_node_push_to_radio_group +#undef accesskit_node_clear_radio_group +#undef accesskit_node_active_descendant +#undef accesskit_node_set_active_descendant +#undef accesskit_node_clear_active_descendant +#undef accesskit_node_error_message +#undef accesskit_node_set_error_message +#undef accesskit_node_clear_error_message +#undef accesskit_node_in_page_link_target +#undef accesskit_node_set_in_page_link_target +#undef accesskit_node_clear_in_page_link_target +#undef accesskit_node_member_of +#undef accesskit_node_set_member_of +#undef accesskit_node_clear_member_of +#undef accesskit_node_next_on_line +#undef accesskit_node_set_next_on_line +#undef accesskit_node_clear_next_on_line +#undef accesskit_node_previous_on_line +#undef accesskit_node_set_previous_on_line +#undef accesskit_node_clear_previous_on_line +#undef accesskit_node_popup_for +#undef accesskit_node_set_popup_for +#undef accesskit_node_clear_popup_for +#undef accesskit_string_free +#undef accesskit_node_label +#undef accesskit_node_set_label +#undef accesskit_node_clear_label +#undef accesskit_node_description +#undef accesskit_node_set_description +#undef accesskit_node_clear_description +#undef accesskit_node_value +#undef accesskit_node_set_value +#undef accesskit_node_clear_value +#undef accesskit_node_access_key +#undef accesskit_node_set_access_key +#undef accesskit_node_clear_access_key +#undef accesskit_node_author_id +#undef accesskit_node_set_author_id +#undef accesskit_node_clear_author_id +#undef accesskit_node_class_name +#undef accesskit_node_set_class_name +#undef accesskit_node_clear_class_name +#undef accesskit_node_font_family +#undef accesskit_node_set_font_family +#undef accesskit_node_clear_font_family +#undef accesskit_node_html_tag +#undef accesskit_node_set_html_tag +#undef accesskit_node_clear_html_tag +#undef accesskit_node_inner_html +#undef accesskit_node_set_inner_html +#undef accesskit_node_clear_inner_html +#undef accesskit_node_keyboard_shortcut +#undef accesskit_node_set_keyboard_shortcut +#undef accesskit_node_clear_keyboard_shortcut +#undef accesskit_node_language +#undef accesskit_node_set_language +#undef accesskit_node_clear_language +#undef accesskit_node_placeholder +#undef accesskit_node_set_placeholder +#undef accesskit_node_clear_placeholder +#undef accesskit_node_role_description +#undef accesskit_node_set_role_description +#undef accesskit_node_clear_role_description +#undef accesskit_node_state_description +#undef accesskit_node_set_state_description +#undef accesskit_node_clear_state_description +#undef accesskit_node_tooltip +#undef accesskit_node_set_tooltip +#undef accesskit_node_clear_tooltip +#undef accesskit_node_url +#undef accesskit_node_set_url +#undef accesskit_node_clear_url +#undef accesskit_node_row_index_text +#undef accesskit_node_set_row_index_text +#undef accesskit_node_clear_row_index_text +#undef accesskit_node_column_index_text +#undef accesskit_node_set_column_index_text +#undef accesskit_node_clear_column_index_text +#undef accesskit_node_scroll_x +#undef accesskit_node_set_scroll_x +#undef accesskit_node_clear_scroll_x +#undef accesskit_node_scroll_x_min +#undef accesskit_node_set_scroll_x_min +#undef accesskit_node_clear_scroll_x_min +#undef accesskit_node_scroll_x_max +#undef accesskit_node_set_scroll_x_max +#undef accesskit_node_clear_scroll_x_max +#undef accesskit_node_scroll_y +#undef accesskit_node_set_scroll_y +#undef accesskit_node_clear_scroll_y +#undef accesskit_node_scroll_y_min +#undef accesskit_node_set_scroll_y_min +#undef accesskit_node_clear_scroll_y_min +#undef accesskit_node_scroll_y_max +#undef accesskit_node_set_scroll_y_max +#undef accesskit_node_clear_scroll_y_max +#undef accesskit_node_numeric_value +#undef accesskit_node_set_numeric_value +#undef accesskit_node_clear_numeric_value +#undef accesskit_node_min_numeric_value +#undef accesskit_node_set_min_numeric_value +#undef accesskit_node_clear_min_numeric_value +#undef accesskit_node_max_numeric_value +#undef accesskit_node_set_max_numeric_value +#undef accesskit_node_clear_max_numeric_value +#undef accesskit_node_numeric_value_step +#undef accesskit_node_set_numeric_value_step +#undef accesskit_node_clear_numeric_value_step +#undef accesskit_node_numeric_value_jump +#undef accesskit_node_set_numeric_value_jump +#undef accesskit_node_clear_numeric_value_jump +#undef accesskit_node_font_size +#undef accesskit_node_set_font_size +#undef accesskit_node_clear_font_size +#undef accesskit_node_font_weight +#undef accesskit_node_set_font_weight +#undef accesskit_node_clear_font_weight +#undef accesskit_node_row_count +#undef accesskit_node_set_row_count +#undef accesskit_node_clear_row_count +#undef accesskit_node_column_count +#undef accesskit_node_set_column_count +#undef accesskit_node_clear_column_count +#undef accesskit_node_row_index +#undef accesskit_node_set_row_index +#undef accesskit_node_clear_row_index +#undef accesskit_node_column_index +#undef accesskit_node_set_column_index +#undef accesskit_node_clear_column_index +#undef accesskit_node_row_span +#undef accesskit_node_set_row_span +#undef accesskit_node_clear_row_span +#undef accesskit_node_column_span +#undef accesskit_node_set_column_span +#undef accesskit_node_clear_column_span +#undef accesskit_node_level +#undef accesskit_node_set_level +#undef accesskit_node_clear_level +#undef accesskit_node_size_of_set +#undef accesskit_node_set_size_of_set +#undef accesskit_node_clear_size_of_set +#undef accesskit_node_position_in_set +#undef accesskit_node_set_position_in_set +#undef accesskit_node_clear_position_in_set +#undef accesskit_node_color_value +#undef accesskit_node_set_color_value +#undef accesskit_node_clear_color_value +#undef accesskit_node_background_color +#undef accesskit_node_set_background_color +#undef accesskit_node_clear_background_color +#undef accesskit_node_foreground_color +#undef accesskit_node_set_foreground_color +#undef accesskit_node_clear_foreground_color +#undef accesskit_node_overline +#undef accesskit_node_set_overline +#undef accesskit_node_clear_overline +#undef accesskit_node_strikethrough +#undef accesskit_node_set_strikethrough +#undef accesskit_node_clear_strikethrough +#undef accesskit_node_underline +#undef accesskit_node_set_underline +#undef accesskit_node_clear_underline +#undef accesskit_node_character_lengths +#undef accesskit_node_set_character_lengths +#undef accesskit_node_clear_character_lengths +#undef accesskit_node_word_lengths +#undef accesskit_node_set_word_lengths +#undef accesskit_node_clear_word_lengths +#undef accesskit_node_character_positions +#undef accesskit_node_set_character_positions +#undef accesskit_node_clear_character_positions +#undef accesskit_node_character_widths +#undef accesskit_node_set_character_widths +#undef accesskit_node_clear_character_widths +#undef accesskit_node_is_expanded +#undef accesskit_node_set_expanded +#undef accesskit_node_clear_expanded +#undef accesskit_node_is_selected +#undef accesskit_node_set_selected +#undef accesskit_node_clear_selected +#undef accesskit_node_invalid +#undef accesskit_node_set_invalid +#undef accesskit_node_clear_invalid +#undef accesskit_node_toggled +#undef accesskit_node_set_toggled +#undef accesskit_node_clear_toggled +#undef accesskit_node_live +#undef accesskit_node_set_live +#undef accesskit_node_clear_live +#undef accesskit_node_text_direction +#undef accesskit_node_set_text_direction +#undef accesskit_node_clear_text_direction +#undef accesskit_node_orientation +#undef accesskit_node_set_orientation +#undef accesskit_node_clear_orientation +#undef accesskit_node_sort_direction +#undef accesskit_node_set_sort_direction +#undef accesskit_node_clear_sort_direction +#undef accesskit_node_aria_current +#undef accesskit_node_set_aria_current +#undef accesskit_node_clear_aria_current +#undef accesskit_node_auto_complete +#undef accesskit_node_set_auto_complete +#undef accesskit_node_clear_auto_complete +#undef accesskit_node_has_popup +#undef accesskit_node_set_has_popup +#undef accesskit_node_clear_has_popup +#undef accesskit_node_list_style +#undef accesskit_node_set_list_style +#undef accesskit_node_clear_list_style +#undef accesskit_node_text_align +#undef accesskit_node_set_text_align +#undef accesskit_node_clear_text_align +#undef accesskit_node_vertical_offset +#undef accesskit_node_set_vertical_offset +#undef accesskit_node_clear_vertical_offset +#undef accesskit_node_transform +#undef accesskit_node_set_transform +#undef accesskit_node_clear_transform +#undef accesskit_node_bounds +#undef accesskit_node_set_bounds +#undef accesskit_node_clear_bounds +#undef accesskit_node_text_selection +#undef accesskit_node_set_text_selection +#undef accesskit_node_clear_text_selection +#undef accesskit_custom_action_new +#undef accesskit_custom_actions_free +#undef accesskit_node_custom_actions +#undef accesskit_node_set_custom_actions +#undef accesskit_node_push_custom_action +#undef accesskit_node_clear_custom_actions +#undef accesskit_node_new +#undef accesskit_node_free +#undef accesskit_tree_new +#undef accesskit_tree_free +#undef accesskit_tree_get_toolkit_name +#undef accesskit_tree_set_toolkit_name +#undef accesskit_tree_clear_toolkit_name +#undef accesskit_tree_get_toolkit_version +#undef accesskit_tree_set_toolkit_version +#undef accesskit_tree_clear_toolkit_version +#undef accesskit_tree_update_with_focus +#undef accesskit_tree_update_with_capacity_and_focus +#undef accesskit_tree_update_free +#undef accesskit_tree_update_push_node +#undef accesskit_tree_update_set_tree +#undef accesskit_tree_update_clear_tree +#undef accesskit_tree_update_set_focus +#undef accesskit_action_request_free +#undef accesskit_affine_identity +#undef accesskit_affine_flip_y +#undef accesskit_affine_flip_x +#undef accesskit_affine_scale +#undef accesskit_affine_scale_non_uniform +#undef accesskit_affine_translate +#undef accesskit_affine_map_unit_square +#undef accesskit_affine_determinant +#undef accesskit_affine_inverse +#undef accesskit_affine_transform_rect_bbox +#undef accesskit_affine_is_finite +#undef accesskit_affine_is_nan +#undef accesskit_point_to_vec2 +#undef accesskit_rect_from_points +#undef accesskit_rect_from_origin_size +#undef accesskit_rect_with_origin +#undef accesskit_rect_with_size +#undef accesskit_rect_width +#undef accesskit_rect_height +#undef accesskit_rect_min_x +#undef accesskit_rect_max_x +#undef accesskit_rect_min_y +#undef accesskit_rect_max_y +#undef accesskit_rect_origin +#undef accesskit_rect_size +#undef accesskit_rect_abs +#undef accesskit_rect_area +#undef accesskit_rect_is_empty +#undef accesskit_rect_contains +#undef accesskit_rect_union +#undef accesskit_rect_union_pt +#undef accesskit_rect_intersect +#undef accesskit_size_to_vec2 +#undef accesskit_vec2_to_point +#undef accesskit_vec2_to_size +#undef accesskit_unix_adapter_new +#undef accesskit_unix_adapter_free +#undef accesskit_unix_adapter_set_root_window_bounds +#undef accesskit_unix_adapter_update_if_active +#undef accesskit_unix_adapter_update_window_focus_state +#ifdef __cplusplus +extern "C" { +#endif +#define accesskit_node_role accesskit_node_role_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_role accesskit_node_set_role_dylibloader_wrapper_libaccesskit +#define accesskit_node_supports_action accesskit_node_supports_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_add_action accesskit_node_add_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_remove_action accesskit_node_remove_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_actions accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_hidden accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_hidden accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_hidden accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_linked accesskit_node_is_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_linked accesskit_node_set_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_linked accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_multiselectable accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_multiselectable accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_multiselectable accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_required accesskit_node_is_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_required accesskit_node_set_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_required accesskit_node_clear_required_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_visited accesskit_node_is_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_visited accesskit_node_set_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_visited accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_busy accesskit_node_is_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_busy accesskit_node_set_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_busy accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_live_atomic accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_live_atomic accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_live_atomic accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_modal accesskit_node_is_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_modal accesskit_node_set_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_modal accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_touch_transparent accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_touch_transparent accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_touch_transparent accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_read_only accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_read_only accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_read_only accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_disabled accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_disabled accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_disabled accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_bold accesskit_node_is_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_bold accesskit_node_set_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_bold accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_italic accesskit_node_is_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_italic accesskit_node_set_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_italic accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit +#define accesskit_node_clips_children accesskit_node_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_clips_children accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_clips_children accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_line_breaking_object accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_line_breaking_object accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_line_breaking_object accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_page_breaking_object accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_page_breaking_object accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_page_breaking_object accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_spelling_error accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_spelling_error accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_spelling_error accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_grammar_error accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_grammar_error accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_grammar_error accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_search_match accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_search_match accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_search_match accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_suggestion accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_is_suggestion accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_is_suggestion accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit +#define accesskit_node_children accesskit_node_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_children accesskit_node_set_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_child accesskit_node_push_child_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_children accesskit_node_clear_children_dylibloader_wrapper_libaccesskit +#define accesskit_node_controls accesskit_node_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_controls accesskit_node_set_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_controlled accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_controls accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit +#define accesskit_node_details accesskit_node_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_details accesskit_node_set_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_detail accesskit_node_push_detail_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_details accesskit_node_clear_details_dylibloader_wrapper_libaccesskit +#define accesskit_node_described_by accesskit_node_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_described_by accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_described_by accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_described_by accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_flow_to accesskit_node_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_flow_to accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_flow_to accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_flow_to accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit +#define accesskit_node_labelled_by accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_labelled_by accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_labelled_by accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_labelled_by accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit +#define accesskit_node_owns accesskit_node_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_owns accesskit_node_set_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_owned accesskit_node_push_owned_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_owns accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit +#define accesskit_node_radio_group accesskit_node_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_radio_group accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_to_radio_group accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_radio_group accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit +#define accesskit_node_active_descendant accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_active_descendant accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_active_descendant accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit +#define accesskit_node_error_message accesskit_node_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_error_message accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_error_message accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit +#define accesskit_node_in_page_link_target accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_in_page_link_target accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_in_page_link_target accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit +#define accesskit_node_member_of accesskit_node_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_member_of accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_member_of accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit +#define accesskit_node_next_on_line accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_next_on_line accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_next_on_line accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_previous_on_line accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_previous_on_line accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_previous_on_line accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit +#define accesskit_node_popup_for accesskit_node_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_popup_for accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_popup_for accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit +#define accesskit_string_free accesskit_string_free_dylibloader_wrapper_libaccesskit +#define accesskit_node_label accesskit_node_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_label accesskit_node_set_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_label accesskit_node_clear_label_dylibloader_wrapper_libaccesskit +#define accesskit_node_description accesskit_node_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_description accesskit_node_set_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_description accesskit_node_clear_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_value accesskit_node_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_value accesskit_node_set_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_value accesskit_node_clear_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_access_key accesskit_node_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_access_key accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_access_key accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit +#define accesskit_node_author_id accesskit_node_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_author_id accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_author_id accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit +#define accesskit_node_class_name accesskit_node_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_class_name accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_class_name accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_family accesskit_node_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_family accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_family accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit +#define accesskit_node_html_tag accesskit_node_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_html_tag accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_html_tag accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit +#define accesskit_node_inner_html accesskit_node_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_inner_html accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_inner_html accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit +#define accesskit_node_keyboard_shortcut accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_keyboard_shortcut accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_keyboard_shortcut accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit +#define accesskit_node_language accesskit_node_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_language accesskit_node_set_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_language accesskit_node_clear_language_dylibloader_wrapper_libaccesskit +#define accesskit_node_placeholder accesskit_node_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_placeholder accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_placeholder accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit +#define accesskit_node_role_description accesskit_node_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_role_description accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_role_description accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_state_description accesskit_node_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_state_description accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_state_description accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit +#define accesskit_node_tooltip accesskit_node_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_tooltip accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_tooltip accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit +#define accesskit_node_url accesskit_node_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_url accesskit_node_set_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_url accesskit_node_clear_url_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_index_text accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_index_text accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_index_text accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_index_text accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_index_text accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_index_text accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x_min accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x_min accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x_min accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_x_max accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_x_max accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_x_max accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y_min accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y_min accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y_min accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit +#define accesskit_node_scroll_y_max accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_scroll_y_max accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_scroll_y_max accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_min_numeric_value accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_min_numeric_value accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_min_numeric_value accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_max_numeric_value accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_max_numeric_value accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_max_numeric_value accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value_step accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value_step accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value_step accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit +#define accesskit_node_numeric_value_jump accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_numeric_value_jump accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_numeric_value_jump accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_size accesskit_node_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_size accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_size accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit +#define accesskit_node_font_weight accesskit_node_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_font_weight accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_font_weight accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_count accesskit_node_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_count accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_count accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_count accesskit_node_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_count accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_count accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_index accesskit_node_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_index accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_index accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_index accesskit_node_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_index accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_index accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit +#define accesskit_node_row_span accesskit_node_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_row_span accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_row_span accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_column_span accesskit_node_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_column_span accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_column_span accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit +#define accesskit_node_level accesskit_node_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_level accesskit_node_set_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_level accesskit_node_clear_level_dylibloader_wrapper_libaccesskit +#define accesskit_node_size_of_set accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_size_of_set accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_size_of_set accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_position_in_set accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_position_in_set accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_position_in_set accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit +#define accesskit_node_color_value accesskit_node_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_color_value accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_color_value accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit +#define accesskit_node_background_color accesskit_node_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_background_color accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_background_color accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_foreground_color accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_foreground_color accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_foreground_color accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit +#define accesskit_node_overline accesskit_node_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_overline accesskit_node_set_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_overline accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit +#define accesskit_node_strikethrough accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_strikethrough accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_strikethrough accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit +#define accesskit_node_underline accesskit_node_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_underline accesskit_node_set_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_underline accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_lengths accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_lengths accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_lengths accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_word_lengths accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_word_lengths accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_word_lengths accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_positions accesskit_node_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_positions accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_positions accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit +#define accesskit_node_character_widths accesskit_node_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_character_widths accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_character_widths accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_expanded accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_expanded accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_expanded accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit +#define accesskit_node_is_selected accesskit_node_is_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_selected accesskit_node_set_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_selected accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit +#define accesskit_node_invalid accesskit_node_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_invalid accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_invalid accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit +#define accesskit_node_toggled accesskit_node_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_toggled accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_toggled accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit +#define accesskit_node_live accesskit_node_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_live accesskit_node_set_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_live accesskit_node_clear_live_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_direction accesskit_node_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_direction accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_direction accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_orientation accesskit_node_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_orientation accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_orientation accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit +#define accesskit_node_sort_direction accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_sort_direction accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_sort_direction accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit +#define accesskit_node_aria_current accesskit_node_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_aria_current accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_aria_current accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit +#define accesskit_node_auto_complete accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_auto_complete accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_auto_complete accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit +#define accesskit_node_has_popup accesskit_node_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_has_popup accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_has_popup accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit +#define accesskit_node_list_style accesskit_node_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_list_style accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_list_style accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_align accesskit_node_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_align accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_align accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit +#define accesskit_node_vertical_offset accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_vertical_offset accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_vertical_offset accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit +#define accesskit_node_transform accesskit_node_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_transform accesskit_node_set_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_transform accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit +#define accesskit_node_bounds accesskit_node_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_bounds accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_bounds accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_node_text_selection accesskit_node_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_text_selection accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_text_selection accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit +#define accesskit_custom_action_new accesskit_custom_action_new_dylibloader_wrapper_libaccesskit +#define accesskit_custom_actions_free accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit +#define accesskit_node_custom_actions accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_set_custom_actions accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_push_custom_action accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit +#define accesskit_node_clear_custom_actions accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit +#define accesskit_node_new accesskit_node_new_dylibloader_wrapper_libaccesskit +#define accesskit_node_free accesskit_node_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_new accesskit_tree_new_dylibloader_wrapper_libaccesskit +#define accesskit_tree_free accesskit_tree_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_get_toolkit_name accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_set_toolkit_name accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_clear_toolkit_name accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit +#define accesskit_tree_get_toolkit_version accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_set_toolkit_version accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_clear_toolkit_version accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_with_focus accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_with_capacity_and_focus accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_free accesskit_tree_update_free_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_push_node accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_set_tree accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_clear_tree accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit +#define accesskit_tree_update_set_focus accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit +#define accesskit_action_request_free accesskit_action_request_free_dylibloader_wrapper_libaccesskit +#define accesskit_affine_identity accesskit_affine_identity_dylibloader_wrapper_libaccesskit +#define accesskit_affine_flip_y accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit +#define accesskit_affine_flip_x accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit +#define accesskit_affine_scale accesskit_affine_scale_dylibloader_wrapper_libaccesskit +#define accesskit_affine_scale_non_uniform accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit +#define accesskit_affine_translate accesskit_affine_translate_dylibloader_wrapper_libaccesskit +#define accesskit_affine_map_unit_square accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit +#define accesskit_affine_determinant accesskit_affine_determinant_dylibloader_wrapper_libaccesskit +#define accesskit_affine_inverse accesskit_affine_inverse_dylibloader_wrapper_libaccesskit +#define accesskit_affine_transform_rect_bbox accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit +#define accesskit_affine_is_finite accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit +#define accesskit_affine_is_nan accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit +#define accesskit_point_to_vec2 accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit +#define accesskit_rect_from_points accesskit_rect_from_points_dylibloader_wrapper_libaccesskit +#define accesskit_rect_from_origin_size accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_with_origin accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit +#define accesskit_rect_with_size accesskit_rect_with_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_width accesskit_rect_width_dylibloader_wrapper_libaccesskit +#define accesskit_rect_height accesskit_rect_height_dylibloader_wrapper_libaccesskit +#define accesskit_rect_min_x accesskit_rect_min_x_dylibloader_wrapper_libaccesskit +#define accesskit_rect_max_x accesskit_rect_max_x_dylibloader_wrapper_libaccesskit +#define accesskit_rect_min_y accesskit_rect_min_y_dylibloader_wrapper_libaccesskit +#define accesskit_rect_max_y accesskit_rect_max_y_dylibloader_wrapper_libaccesskit +#define accesskit_rect_origin accesskit_rect_origin_dylibloader_wrapper_libaccesskit +#define accesskit_rect_size accesskit_rect_size_dylibloader_wrapper_libaccesskit +#define accesskit_rect_abs accesskit_rect_abs_dylibloader_wrapper_libaccesskit +#define accesskit_rect_area accesskit_rect_area_dylibloader_wrapper_libaccesskit +#define accesskit_rect_is_empty accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit +#define accesskit_rect_contains accesskit_rect_contains_dylibloader_wrapper_libaccesskit +#define accesskit_rect_union accesskit_rect_union_dylibloader_wrapper_libaccesskit +#define accesskit_rect_union_pt accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit +#define accesskit_rect_intersect accesskit_rect_intersect_dylibloader_wrapper_libaccesskit +#define accesskit_size_to_vec2 accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit +#define accesskit_vec2_to_point accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit +#define accesskit_vec2_to_size accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit +#define accesskit_unix_adapter_new accesskit_unix_adapter_new_dylibloader_wrapper_libaccesskit +#define accesskit_unix_adapter_free accesskit_unix_adapter_free_dylibloader_wrapper_libaccesskit +#define accesskit_unix_adapter_set_root_window_bounds accesskit_unix_adapter_set_root_window_bounds_dylibloader_wrapper_libaccesskit +#define accesskit_unix_adapter_update_if_active accesskit_unix_adapter_update_if_active_dylibloader_wrapper_libaccesskit +#define accesskit_unix_adapter_update_window_focus_state accesskit_unix_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit +extern accesskit_role (*accesskit_node_role_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_role_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_role); +extern bool (*accesskit_node_supports_action_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_add_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_remove_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_action); +extern void (*accesskit_node_clear_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_hidden_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_hidden_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_linked_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_linked_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_multiselectable_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_multiselectable_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_required_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_required_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_visited_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_visited_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_busy_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_busy_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_live_atomic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_live_atomic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_modal_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_modal_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_touch_transparent_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_touch_transparent_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_read_only_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_read_only_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_disabled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_disabled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_bold_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_bold_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_italic_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_italic_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_clips_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_clips_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_line_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_page_breaking_object_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_spelling_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_spelling_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_grammar_error_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_grammar_error_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_search_match_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_search_match_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern bool (*accesskit_node_is_suggestion_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_node_clear_is_suggestion_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_children_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_child_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_children_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_controls_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_controlled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_controls_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_details_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_detail_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_details_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_described_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_described_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_flow_to_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_flow_to_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_labelled_by_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_labelled_by_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_owns_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_owned_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_owns_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node_ids (*accesskit_node_radio_group_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const accesskit_node_id *); +extern void (*accesskit_node_push_to_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_radio_group_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_active_descendant_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_active_descendant_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_error_message_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_error_message_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_in_page_link_target_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_in_page_link_target_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_member_of_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_member_of_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_next_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_next_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_previous_on_line_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_previous_on_line_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_node_id (*accesskit_node_popup_for_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_node_id); +extern void (*accesskit_node_clear_popup_for_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern void (*accesskit_string_free_dylibloader_wrapper_libaccesskit)(char *); +extern char *(*accesskit_node_label_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_label_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_access_key_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_access_key_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_author_id_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_author_id_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_class_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_class_name_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_font_family_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_font_family_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_html_tag_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_html_tag_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_inner_html_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_inner_html_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_keyboard_shortcut_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_language_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_language_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_placeholder_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_placeholder_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_role_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_role_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_state_description_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_state_description_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_tooltip_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_tooltip_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_url_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_url_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_row_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_row_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern char *(*accesskit_node_column_index_text_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, const char *); +extern void (*accesskit_node_clear_column_index_text_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_x_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_x_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_min_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_min_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_scroll_y_max_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_scroll_y_max_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_min_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_min_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_max_numeric_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_max_numeric_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_step_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_step_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_numeric_value_jump_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_numeric_value_jump_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_font_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_font_size_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_double (*accesskit_node_font_weight_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, double); +extern void (*accesskit_node_clear_font_weight_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_count_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_count_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_index_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_index_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_row_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_row_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_column_span_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_column_span_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_level_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_level_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_size_of_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_size_of_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_index (*accesskit_node_position_in_set_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t); +extern void (*accesskit_node_clear_position_in_set_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_color_value_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_color_value_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_background_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_background_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_color (*accesskit_node_foreground_color_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, uint32_t); +extern void (*accesskit_node_clear_foreground_color_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_overline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_overline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_strikethrough_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_strikethrough_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_decoration (*accesskit_node_underline_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_decoration); +extern void (*accesskit_node_clear_underline_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_lengths (*accesskit_node_character_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +extern void (*accesskit_node_clear_character_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_lengths (*accesskit_node_word_lengths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const uint8_t *); +extern void (*accesskit_node_clear_word_lengths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_coords (*accesskit_node_character_positions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +extern void (*accesskit_node_clear_character_positions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_coords (*accesskit_node_character_widths_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const float *); +extern void (*accesskit_node_clear_character_widths_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_bool (*accesskit_node_is_expanded_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +extern void (*accesskit_node_clear_expanded_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_bool (*accesskit_node_is_selected_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, bool); +extern void (*accesskit_node_clear_selected_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_invalid (*accesskit_node_invalid_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_invalid); +extern void (*accesskit_node_clear_invalid_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_toggled (*accesskit_node_toggled_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_toggled); +extern void (*accesskit_node_clear_toggled_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_live (*accesskit_node_live_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_live); +extern void (*accesskit_node_clear_live_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_direction (*accesskit_node_text_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_direction); +extern void (*accesskit_node_clear_text_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_orientation (*accesskit_node_orientation_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_orientation); +extern void (*accesskit_node_clear_orientation_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_sort_direction (*accesskit_node_sort_direction_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_sort_direction); +extern void (*accesskit_node_clear_sort_direction_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_aria_current (*accesskit_node_aria_current_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_aria_current); +extern void (*accesskit_node_clear_aria_current_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_auto_complete (*accesskit_node_auto_complete_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_auto_complete); +extern void (*accesskit_node_clear_auto_complete_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_has_popup (*accesskit_node_has_popup_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_has_popup); +extern void (*accesskit_node_clear_has_popup_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_list_style (*accesskit_node_list_style_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_list_style); +extern void (*accesskit_node_clear_list_style_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_align (*accesskit_node_text_align_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_text_align); +extern void (*accesskit_node_clear_text_align_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_vertical_offset (*accesskit_node_vertical_offset_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, accesskit_vertical_offset); +extern void (*accesskit_node_clear_vertical_offset_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern const struct accesskit_affine *(*accesskit_node_transform_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_affine); +extern void (*accesskit_node_clear_transform_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_rect (*accesskit_node_bounds_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_rect); +extern void (*accesskit_node_clear_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_opt_text_selection (*accesskit_node_text_selection_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_text_selection); +extern void (*accesskit_node_clear_text_selection_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_custom_action (*accesskit_custom_action_new_dylibloader_wrapper_libaccesskit)(int32_t, const char *); +extern void (*accesskit_custom_actions_free_dylibloader_wrapper_libaccesskit)(struct accesskit_custom_actions *); +extern const struct accesskit_custom_actions *(*accesskit_node_custom_actions_dylibloader_wrapper_libaccesskit)(const struct accesskit_node *); +extern void (*accesskit_node_set_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, size_t, const struct accesskit_custom_action *); +extern void (*accesskit_node_push_custom_action_dylibloader_wrapper_libaccesskit)(struct accesskit_node *, struct accesskit_custom_action); +extern void (*accesskit_node_clear_custom_actions_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_node *(*accesskit_node_new_dylibloader_wrapper_libaccesskit)(accesskit_role); +extern void (*accesskit_node_free_dylibloader_wrapper_libaccesskit)(struct accesskit_node *); +extern struct accesskit_tree *(*accesskit_tree_new_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +extern void (*accesskit_tree_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern char *(*accesskit_tree_get_toolkit_name_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +extern void (*accesskit_tree_set_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +extern void (*accesskit_tree_clear_toolkit_name_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern char *(*accesskit_tree_get_toolkit_version_dylibloader_wrapper_libaccesskit)(const struct accesskit_tree *); +extern void (*accesskit_tree_set_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *, const char *); +extern void (*accesskit_tree_clear_toolkit_version_dylibloader_wrapper_libaccesskit)(struct accesskit_tree *); +extern struct accesskit_tree_update *(*accesskit_tree_update_with_focus_dylibloader_wrapper_libaccesskit)(accesskit_node_id); +extern struct accesskit_tree_update *(*accesskit_tree_update_with_capacity_and_focus_dylibloader_wrapper_libaccesskit)(size_t, accesskit_node_id); +extern void (*accesskit_tree_update_free_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +extern void (*accesskit_tree_update_push_node_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id, struct accesskit_node *); +extern void (*accesskit_tree_update_set_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, struct accesskit_tree *); +extern void (*accesskit_tree_update_clear_tree_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *); +extern void (*accesskit_tree_update_set_focus_dylibloader_wrapper_libaccesskit)(struct accesskit_tree_update *, accesskit_node_id); +extern void (*accesskit_action_request_free_dylibloader_wrapper_libaccesskit)(struct accesskit_action_request *); +extern struct accesskit_affine (*accesskit_affine_identity_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_flip_y_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_flip_x_dylibloader_wrapper_libaccesskit)(void); +extern struct accesskit_affine (*accesskit_affine_scale_dylibloader_wrapper_libaccesskit)(double); +extern struct accesskit_affine (*accesskit_affine_scale_non_uniform_dylibloader_wrapper_libaccesskit)(double, double); +extern struct accesskit_affine (*accesskit_affine_translate_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern struct accesskit_affine (*accesskit_affine_map_unit_square_dylibloader_wrapper_libaccesskit)(struct accesskit_rect); +extern double (*accesskit_affine_determinant_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +extern struct accesskit_affine (*accesskit_affine_inverse_dylibloader_wrapper_libaccesskit)(struct accesskit_affine); +extern struct accesskit_rect (*accesskit_affine_transform_rect_bbox_dylibloader_wrapper_libaccesskit)(struct accesskit_affine, struct accesskit_rect); +extern bool (*accesskit_affine_is_finite_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +extern bool (*accesskit_affine_is_nan_dylibloader_wrapper_libaccesskit)(const struct accesskit_affine *); +extern struct accesskit_vec2 (*accesskit_point_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_from_points_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_from_origin_size_dylibloader_wrapper_libaccesskit)(struct accesskit_point, struct accesskit_size); +extern struct accesskit_rect (*accesskit_rect_with_origin_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_with_size_dylibloader_wrapper_libaccesskit)(struct accesskit_rect, struct accesskit_size); +extern double (*accesskit_rect_width_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_height_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_min_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_max_x_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_min_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_max_y_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_point (*accesskit_rect_origin_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_size (*accesskit_rect_size_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern struct accesskit_rect (*accesskit_rect_abs_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern double (*accesskit_rect_area_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern bool (*accesskit_rect_is_empty_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *); +extern bool (*accesskit_rect_contains_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_union_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +extern struct accesskit_rect (*accesskit_rect_union_pt_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_point); +extern struct accesskit_rect (*accesskit_rect_intersect_dylibloader_wrapper_libaccesskit)(const struct accesskit_rect *, struct accesskit_rect); +extern struct accesskit_vec2 (*accesskit_size_to_vec2_dylibloader_wrapper_libaccesskit)(struct accesskit_size); +extern struct accesskit_point (*accesskit_vec2_to_point_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern struct accesskit_size (*accesskit_vec2_to_size_dylibloader_wrapper_libaccesskit)(struct accesskit_vec2); +extern struct accesskit_unix_adapter *(*accesskit_unix_adapter_new_dylibloader_wrapper_libaccesskit)(accesskit_activation_handler_callback, void *, accesskit_action_handler_callback, void *, accesskit_deactivation_handler_callback, void *); +extern void (*accesskit_unix_adapter_free_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *); +extern void (*accesskit_unix_adapter_set_root_window_bounds_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *, struct accesskit_rect, struct accesskit_rect); +extern void (*accesskit_unix_adapter_update_if_active_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *, accesskit_tree_update_factory, void *); +extern void (*accesskit_unix_adapter_update_window_focus_state_dylibloader_wrapper_libaccesskit)(struct accesskit_unix_adapter *, bool); +int initialize_libaccesskit(int verbose, void *handle); +#ifdef __cplusplus +} +#endif +#endif diff --git a/platform/linuxbsd/SCsub b/platform/linuxbsd/SCsub index 4def765e9c5..678fc78015a 100644 --- a/platform/linuxbsd/SCsub +++ b/platform/linuxbsd/SCsub @@ -11,6 +11,7 @@ common_linuxbsd = [ "joypad_linux.cpp", "freedesktop_portal_desktop.cpp", "freedesktop_screensaver.cpp", + "freedesktop_at_spi_monitor.cpp", ] if env["use_sowrap"]: diff --git a/platform/linuxbsd/detect.py b/platform/linuxbsd/detect.py index 75c6e8ab437..82ada66f31c 100644 --- a/platform/linuxbsd/detect.py +++ b/platform/linuxbsd/detect.py @@ -466,6 +466,24 @@ def configure(env: "SConsEnvironment"): env.Append(CPPDEFINES=["WAYLAND_ENABLED"]) env.Append(LIBS=["rt"]) # Needed by glibc, used by _allocate_shm_file + if env["accesskit"]: + if env["accesskit_sdk_path"] != "": + env.Prepend(CPPPATH=[env["accesskit_sdk_path"] + "/include"]) + if env["arch"] == "arm64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/linux/arm64/static/"]) + elif env["arch"] == "arm32": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/linux/arm32/static/"]) + elif env["arch"] == "rv64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/linux/riscv64gc/static/"]) + elif env["arch"] == "x86_64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/linux/x86_64/static/"]) + elif env["arch"] == "x86_32": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/linux/x86/static/"]) + env.Append(LIBS=["accesskit"]) + else: + env.Append(CPPDEFINES=["ACCESSKIT_DYNAMIC"]) + env.Append(CPPDEFINES=["ACCESSKIT_ENABLED"]) + if env["vulkan"]: env.Append(CPPDEFINES=["VULKAN_ENABLED", "RD_ENABLED"]) if not env["use_volk"]: diff --git a/platform/linuxbsd/export/export_plugin.cpp b/platform/linuxbsd/export/export_plugin.cpp index e63193e0c8e..b2a4b5432c6 100644 --- a/platform/linuxbsd/export/export_plugin.cpp +++ b/platform/linuxbsd/export/export_plugin.cpp @@ -72,6 +72,11 @@ Error EditorExportPlatformLinuxBSD::export_project(const Ref } } + Ref da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); + if (da->file_exists(template_path.get_base_dir().path_join("libaccesskit." + arch + ".so"))) { + da->copy(template_path.get_base_dir().path_join("libaccesskit." + arch + ".so"), p_path.get_base_dir().path_join("libaccesskit." + arch + ".so"), get_chmod_flags()); + } + bool export_as_zip = p_path.ends_with("zip"); String pkg_name; diff --git a/platform/linuxbsd/freedesktop_at_spi_monitor.cpp b/platform/linuxbsd/freedesktop_at_spi_monitor.cpp new file mode 100644 index 00000000000..905346abeec --- /dev/null +++ b/platform/linuxbsd/freedesktop_at_spi_monitor.cpp @@ -0,0 +1,157 @@ +/**************************************************************************/ +/* freedesktop_at_spi_monitor.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#include "freedesktop_at_spi_monitor.h" + +#ifdef DBUS_ENABLED + +#include "core/os/os.h" + +#ifdef SOWRAP_ENABLED +#include "dbus-so_wrap.h" +#else +#include +#endif + +#include + +#define BUS_OBJECT_NAME "org.a11y.Bus" +#define BUS_OBJECT_PATH "/org/a11y/bus" + +#define BUS_INTERFACE_PROPERTIES "org.freedesktop.DBus.Properties" + +void FreeDesktopAtSPIMonitor::monitor_thread_func(void *p_userdata) { + FreeDesktopAtSPIMonitor *mon = (FreeDesktopAtSPIMonitor *)p_userdata; + + DBusError error; + dbus_error_init(&error); + + DBusConnection *bus = dbus_bus_get(DBUS_BUS_SESSION, &error); + if (dbus_error_is_set(&error)) { + dbus_error_free(&error); + mon->supported.clear(); + return; + } + + static const char *iface = "org.a11y.Status"; + static const char *member = "IsEnabled"; + + while (!mon->exit_thread.is_set()) { + DBusMessage *message = dbus_message_new_method_call(BUS_OBJECT_NAME, BUS_OBJECT_PATH, BUS_INTERFACE_PROPERTIES, "Get"); + + dbus_message_append_args( + message, + DBUS_TYPE_STRING, &iface, + DBUS_TYPE_STRING, &member, + DBUS_TYPE_INVALID); + + DBusMessage *reply = dbus_connection_send_with_reply_and_block(bus, message, 50, &error); + dbus_message_unref(message); + + if (!dbus_error_is_set(&error)) { + DBusMessageIter iter, iter_variant, iter_struct; + dbus_bool_t result; + dbus_message_iter_init(reply, &iter); + dbus_message_iter_recurse(&iter, &iter_variant); + switch (dbus_message_iter_get_arg_type(&iter_variant)) { + case DBUS_TYPE_STRUCT: { + dbus_message_iter_recurse(&iter_variant, &iter_struct); + if (dbus_message_iter_get_arg_type(&iter_struct) == DBUS_TYPE_BOOLEAN) { + dbus_message_iter_get_basic(&iter_struct, &result); + if (result) { + mon->sr_enabled.set(); + } else { + mon->sr_enabled.clear(); + } + } + } break; + case DBUS_TYPE_BOOLEAN: { + dbus_message_iter_get_basic(&iter_variant, &result); + if (result) { + mon->sr_enabled.set(); + } else { + mon->sr_enabled.clear(); + } + } break; + default: + break; + } + dbus_message_unref(reply); + } else { + dbus_error_free(&error); + } + + usleep(50000); + } + + dbus_connection_unref(bus); +} + +FreeDesktopAtSPIMonitor::FreeDesktopAtSPIMonitor() { +#ifdef SOWRAP_ENABLED +#ifdef DEBUG_ENABLED + int dylibloader_verbose = 1; +#else + int dylibloader_verbose = 0; +#endif + if (initialize_dbus(dylibloader_verbose) != 0) { + print_verbose("AT-SPI2: Failed to load DBus library!"); + supported.clear(); + return; + } +#endif + bool ver_ok = false; + int version_major = 0; + int version_minor = 0; + int version_rev = 0; + dbus_get_version(&version_major, &version_minor, &version_rev); + ver_ok = (version_major == 1 && version_minor >= 10) || (version_major > 1); // 1.10.0 + print_verbose(vformat("AT-SPI2: DBus %d.%d.%d detected.", version_major, version_minor, version_rev)); + if (!ver_ok) { + print_verbose("AT-SPI2: Unsupported DBus library version!"); + supported.clear(); + return; + } + + supported.set(); + sr_enabled.clear(); + exit_thread.clear(); + + thread.start(FreeDesktopAtSPIMonitor::monitor_thread_func, this); +} + +FreeDesktopAtSPIMonitor::~FreeDesktopAtSPIMonitor() { + exit_thread.set(); + if (thread.is_started()) { + thread.wait_to_finish(); + } +} + +#endif // DBUS_ENABLED diff --git a/platform/linuxbsd/freedesktop_at_spi_monitor.h b/platform/linuxbsd/freedesktop_at_spi_monitor.h new file mode 100644 index 00000000000..65cec656852 --- /dev/null +++ b/platform/linuxbsd/freedesktop_at_spi_monitor.h @@ -0,0 +1,56 @@ +/**************************************************************************/ +/* freedesktop_at_spi_monitor.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#pragma once + +#ifdef DBUS_ENABLED + +#include "core/os/thread.h" +#include "core/os/thread_safe.h" + +class FreeDesktopAtSPIMonitor { +private: + Thread thread; + + SafeFlag exit_thread; + SafeFlag sr_enabled; + SafeFlag supported; + + static void monitor_thread_func(void *p_userdata); + +public: + FreeDesktopAtSPIMonitor(); + ~FreeDesktopAtSPIMonitor(); + + bool is_supported() { return supported.is_set(); } + bool is_active() { return sr_enabled.is_set(); } +}; + +#endif // DBUS_ENABLED diff --git a/platform/linuxbsd/freedesktop_portal_desktop.cpp b/platform/linuxbsd/freedesktop_portal_desktop.cpp index cafba278336..d3ea47c05bb 100644 --- a/platform/linuxbsd/freedesktop_portal_desktop.cpp +++ b/platform/linuxbsd/freedesktop_portal_desktop.cpp @@ -101,6 +101,11 @@ bool FreeDesktopPortalDesktop::try_parse_variant(DBusMessage *p_reply_message, R return false; } dbus_message_iter_get_basic(&iter[2], r_value); + } else if (p_type == VAR_TYPE_BOOL) { + if (dbus_message_iter_get_arg_type(&iter[2]) != DBUS_TYPE_BOOLEAN) { + return false; + } + dbus_message_iter_get_basic(&iter[2], r_value); } return true; } @@ -177,6 +182,18 @@ Color FreeDesktopPortalDesktop::get_appearance_accent_color() { } } +uint32_t FreeDesktopPortalDesktop::get_high_contrast() { + if (unsupported) { + return -1; + } + + dbus_bool_t value = false; + if (read_setting("org.gnome.desktop.a11y.interface", "high-contrast", VAR_TYPE_BOOL, &value)) { + return value; + } + return -1; +} + static const char *cs_empty = ""; void FreeDesktopPortalDesktop::append_dbus_string(DBusMessageIter *p_iter, const String &p_string) { diff --git a/platform/linuxbsd/freedesktop_portal_desktop.h b/platform/linuxbsd/freedesktop_portal_desktop.h index 7900ed851d1..5e73a777df1 100644 --- a/platform/linuxbsd/freedesktop_portal_desktop.h +++ b/platform/linuxbsd/freedesktop_portal_desktop.h @@ -46,6 +46,7 @@ private: enum ReadVariantType { VAR_TYPE_UINT32, // u + VAR_TYPE_BOOL, // b VAR_TYPE_COLOR, // (ddd) }; @@ -135,6 +136,12 @@ public: system_theme_changed = p_system_theme_changed; } + // Retrieve high-contrast setting. + // -1: Unknown. + // 0: Disabled. + // 1: Enabled. + uint32_t get_high_contrast(); + // org.freedesktop.portal.Screenshot methods. bool color_picker(const String &p_xid, const Callable &p_callback); }; diff --git a/platform/linuxbsd/wayland/display_server_wayland.cpp b/platform/linuxbsd/wayland/display_server_wayland.cpp index c41c1c594f5..ee09b816ac4 100644 --- a/platform/linuxbsd/wayland/display_server_wayland.cpp +++ b/platform/linuxbsd/wayland/display_server_wayland.cpp @@ -39,6 +39,8 @@ #define DEBUG_LOG_WAYLAND(...) #endif +#include "servers/rendering/dummy/rasterizer_dummy.h" + #ifdef VULKAN_ENABLED #include "servers/rendering/renderer_rd/renderer_compositor_rd.h" #endif @@ -50,6 +52,10 @@ #include "wayland/egl_manager_wayland_gles.h" #endif +#ifdef ACCESSKIT_ENABLED +#include "drivers/accesskit/accessibility_driver_accesskit.h" +#endif + #define WAYLAND_MAX_FRAME_TIME_US (1'000'000) String DisplayServerWayland::_get_app_id_from_context(Context p_context) { @@ -201,6 +207,12 @@ bool DisplayServerWayland::has_feature(Feature p_feature) const { } break; #endif +#ifdef ACCESSKIT_ENABLED + case FEATURE_ACCESSIBILITY_SCREEN_READER: { + return (accessibility_driver != nullptr); + } break; +#endif + default: { return false; } @@ -689,6 +701,16 @@ DisplayServer::WindowID DisplayServerWayland::create_sub_window(WindowMode p_mod wd.flags = p_flags; wd.vsync_mode = p_vsync_mode; +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver && !accessibility_driver->window_create(wd.id, nullptr)) { + if (OS::get_singleton()->is_stdout_verbose()) { + ERR_PRINT("Can't create an accessibility adapter for window, accessibility support disabled!"); + } + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } +#endif + // NOTE: Remember to clear its position if this window will be a toplevel. We // can only know once we show it. wd.rect = p_rect; @@ -840,6 +862,12 @@ void DisplayServerWayland::delete_sub_window(WindowID p_window_id) { popup_menu_list.pop_back(); } +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->window_destroy(p_window_id); + } +#endif + if (wd.visible) { #ifdef VULKAN_ENABLED if (rendering_device) { @@ -1284,6 +1312,22 @@ void DisplayServerWayland::window_set_ime_position(const Point2i &p_pos, Display wayland_thread.window_set_ime_position(p_pos, p_window_id); } +int DisplayServerWayland::accessibility_should_increase_contrast() const { +#ifdef DBUS_ENABLED + return portal_desktop->get_high_contrast(); +#endif + return -1; +} + +int DisplayServerWayland::accessibility_screen_reader_active() const { +#ifdef DBUS_ENABLED + if (atspi_monitor->is_supported()) { + return atspi_monitor->is_active(); + } +#endif + return -1; +} + Point2i DisplayServerWayland::ime_get_selection() const { return ime_selection; } @@ -1557,14 +1601,24 @@ void DisplayServerWayland::process_events() { } Ref winev_msg = msg; - if (winev_msg.is_valid()) { + if (winev_msg.is_valid() && windows.has(winev_msg->id)) { _send_window_event(winev_msg->event, winev_msg->id); if (winev_msg->event == WINDOW_EVENT_FOCUS_IN) { +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->accessibility_set_window_focused(winev_msg->id, true); + } +#endif if (OS::get_singleton()->get_main_loop()) { OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_IN); } } else if (winev_msg->event == WINDOW_EVENT_FOCUS_OUT) { +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->accessibility_set_window_focused(winev_msg->id, false); + } +#endif if (OS::get_singleton()->get_main_loop()) { OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_OUT); } @@ -1775,6 +1829,7 @@ Vector DisplayServerWayland::get_rendering_drivers_func() { drivers.push_back("opengl3"); drivers.push_back("opengl3_es"); #endif + drivers.push_back("dummy"); return drivers; } @@ -1828,11 +1883,26 @@ DisplayServerWayland::DisplayServerWayland(const String &p_rendering_driver, Win } #endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_get_mode() != DisplayServer::AccessibilityMode::ACCESSIBILITY_DISABLED) { + accessibility_driver = memnew(AccessibilityDriverAccessKit); + if (accessibility_driver->init() != OK) { + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } + } +#endif + rendering_driver = p_rendering_driver; bool driver_found = false; String executable_name = OS::get_singleton()->get_executable_path().get_file(); + if (rendering_driver == "dummy") { + RasterizerDummy::make_current(); + driver_found = true; + } + #ifdef RD_ENABLED #ifdef VULKAN_ENABLED if (rendering_driver == "vulkan") { @@ -2021,6 +2091,7 @@ DisplayServerWayland::DisplayServerWayland(const String &p_rendering_driver, Win #ifdef DBUS_ENABLED portal_desktop = memnew(FreeDesktopPortalDesktop); + atspi_monitor = memnew(FreeDesktopAtSPIMonitor); screensaver = memnew(FreeDesktopScreenSaver); #endif // DBUS_ENABLED @@ -2045,12 +2116,17 @@ DisplayServerWayland::~DisplayServerWayland() { if (!window_get_flag(WINDOW_FLAG_POPUP_WM_HINT, id)) { toplevels.push_back(id); +#ifdef ACCESSKIT_ENABLED + } else if (accessibility_driver) { + accessibility_driver->window_destroy(id); +#endif } } for (WindowID &id : toplevels) { delete_sub_window(id); } + windows.clear(); wayland_thread.destroy(); @@ -2071,9 +2147,16 @@ DisplayServerWayland::~DisplayServerWayland() { } #endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + memdelete(accessibility_driver); + } +#endif + #ifdef DBUS_ENABLED if (portal_desktop) { memdelete(portal_desktop); + memdelete(atspi_monitor); memdelete(screensaver); } #endif diff --git a/platform/linuxbsd/wayland/display_server_wayland.h b/platform/linuxbsd/wayland/display_server_wayland.h index 03a90111da2..102fb6739a7 100644 --- a/platform/linuxbsd/wayland/display_server_wayland.h +++ b/platform/linuxbsd/wayland/display_server_wayland.h @@ -52,6 +52,7 @@ #endif #ifdef DBUS_ENABLED +#include "freedesktop_at_spi_monitor.h" #include "freedesktop_portal_desktop.h" #include "freedesktop_screensaver.h" #endif @@ -167,6 +168,7 @@ class DisplayServerWayland : public DisplayServer { #if DBUS_ENABLED FreeDesktopPortalDesktop *portal_desktop = nullptr; + FreeDesktopAtSPIMonitor *atspi_monitor = nullptr; FreeDesktopScreenSaver *screensaver = nullptr; bool screensaver_inhibited = false; @@ -307,6 +309,9 @@ public: virtual void window_set_ime_active(const bool p_active, WindowID p_window_id = MAIN_WINDOW_ID) override; virtual void window_set_ime_position(const Point2i &p_pos, WindowID p_window_id = MAIN_WINDOW_ID) override; + virtual int accessibility_should_increase_contrast() const override; + virtual int accessibility_screen_reader_active() const override; + virtual Point2i ime_get_selection() const override; virtual String ime_get_text() const override; diff --git a/platform/linuxbsd/x11/display_server_x11.cpp b/platform/linuxbsd/x11/display_server_x11.cpp index 5f2850c83c5..9027cfc5cda 100644 --- a/platform/linuxbsd/x11/display_server_x11.cpp +++ b/platform/linuxbsd/x11/display_server_x11.cpp @@ -39,9 +39,12 @@ #include "core/math/math_funcs.h" #include "core/string/print_string.h" #include "core/string/ustring.h" +#include "core/version.h" #include "drivers/png/png_driver_common.h" #include "main/main.h" +#include "servers/rendering/dummy/rasterizer_dummy.h" + #if defined(VULKAN_ENABLED) #include "servers/rendering/renderer_rd/renderer_compositor_rd.h" #endif @@ -50,6 +53,10 @@ #include "drivers/gles3/rasterizer_gles3.h" #endif +#ifdef ACCESSKIT_ENABLED +#include "drivers/accesskit/accessibility_driver_accesskit.h" +#endif + #include #include #include @@ -169,6 +176,12 @@ bool DisplayServerX11::has_feature(Feature p_feature) const { } break; #endif +#ifdef ACCESSKIT_ENABLED + case FEATURE_ACCESSIBILITY_SCREEN_READER: { + return (accessibility_driver != nullptr); + } break; +#endif + default: { return false; } @@ -1943,6 +1956,12 @@ void DisplayServerX11::delete_sub_window(WindowID p_id) { } #endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->window_destroy(p_id); + } +#endif + if (wd.xic) { XDestroyIC(wd.xic); wd.xic = nullptr; @@ -3284,6 +3303,22 @@ void DisplayServerX11::window_set_ime_position(const Point2i &p_pos, WindowID p_ } } +int DisplayServerX11::accessibility_should_increase_contrast() const { +#ifdef DBUS_ENABLED + return portal_desktop->get_high_contrast(); +#endif + return -1; +} + +int DisplayServerX11::accessibility_screen_reader_active() const { +#ifdef DBUS_ENABLED + if (atspi_monitor->is_supported()) { + return atspi_monitor->is_active(); + } +#endif + return -1; +} + Point2i DisplayServerX11::ime_get_selection() const { return im_selection; } @@ -4931,6 +4966,11 @@ void DisplayServerX11::process_events() { static unsigned int focus_order = 0; wd.focus_order = ++focus_order; +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->accessibility_set_window_focused(window_id, true); + } +#endif _send_window_event(wd, WINDOW_EVENT_FOCUS_IN); if (mouse_mode_grab) { @@ -4982,6 +5022,11 @@ void DisplayServerX11::process_events() { wd.focused = false; Input::get_singleton()->release_pressed_events(); +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->accessibility_set_window_focused(window_id, false); + } +#endif _send_window_event(wd, WINDOW_EVENT_FOCUS_OUT); if (mouse_mode_grab) { @@ -6083,6 +6128,7 @@ Vector DisplayServerX11::get_rendering_drivers_func() { drivers.push_back("opengl3"); drivers.push_back("opengl3_es"); #endif + drivers.push_back("dummy"); return drivers; } @@ -6231,6 +6277,15 @@ DisplayServerX11::WindowID DisplayServerX11::_create_window(WindowMode p_mode, V if (dead_tbl && xkb_loaded_v05p) { wd.xkb_state = xkb_compose_state_new(dead_tbl, XKB_COMPOSE_STATE_NO_FLAGS); } +#endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver && !accessibility_driver->window_create(id, nullptr)) { + if (OS::get_singleton()->is_stdout_verbose()) { + ERR_PRINT("Can't create an accessibility adapter for window, accessibility support disabled!"); + } + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } #endif // Enable receiving notification when the window is initialized (MapNotify) // so the focus can be set at the right time. @@ -6818,6 +6873,16 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode } #endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_get_mode() != DisplayServer::AccessibilityMode::ACCESSIBILITY_DISABLED) { + accessibility_driver = memnew(AccessibilityDriverAccessKit); + if (accessibility_driver->init() != OK) { + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } + } +#endif + //!!!!!!!!!!!!!!!!!!!!!!!!!! //TODO - do Vulkan and OpenGL support checks, driver selection and fallback rendering_driver = p_rendering_driver; @@ -6827,6 +6892,11 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode // Initialize context and rendering device. + if (rendering_driver == "dummy") { + RasterizerDummy::make_current(); + driver_found = true; + } + #if defined(RD_ENABLED) #if defined(VULKAN_ENABLED) if (rendering_driver == "vulkan") { @@ -7157,8 +7227,8 @@ DisplayServerX11::DisplayServerX11(const String &p_rendering_driver, WindowMode screen_set_keep_on(GLOBAL_GET("display/window/energy_saving/keep_screen_on")); portal_desktop = memnew(FreeDesktopPortalDesktop); + atspi_monitor = memnew(FreeDesktopAtSPIMonitor); #endif // DBUS_ENABLED - XSetErrorHandler(&default_window_error_handler); r_error = OK; @@ -7198,6 +7268,12 @@ DisplayServerX11::~DisplayServerX11() { } #endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->window_destroy(E.key); + } +#endif + WindowData &wd = E.value; if (wd.xic) { XDestroyIC(wd.xic); @@ -7272,7 +7348,11 @@ DisplayServerX11::~DisplayServerX11() { if (xmbstring) { memfree(xmbstring); } - +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + memdelete(accessibility_driver); + } +#endif #ifdef SPEECHD_ENABLED if (tts) { memdelete(tts); @@ -7282,6 +7362,7 @@ DisplayServerX11::~DisplayServerX11() { #ifdef DBUS_ENABLED memdelete(screensaver); memdelete(portal_desktop); + memdelete(atspi_monitor); #endif } diff --git a/platform/linuxbsd/x11/display_server_x11.h b/platform/linuxbsd/x11/display_server_x11.h index 25bf3111dc2..be19597aea8 100644 --- a/platform/linuxbsd/x11/display_server_x11.h +++ b/platform/linuxbsd/x11/display_server_x11.h @@ -65,6 +65,7 @@ #endif #if defined(DBUS_ENABLED) +#include "freedesktop_at_spi_monitor.h" #include "freedesktop_portal_desktop.h" #include "freedesktop_screensaver.h" #endif @@ -159,6 +160,7 @@ class DisplayServerX11 : public DisplayServer { #if defined(DBUS_ENABLED) FreeDesktopPortalDesktop *portal_desktop = nullptr; + FreeDesktopAtSPIMonitor *atspi_monitor = nullptr; #endif struct WindowData { @@ -533,6 +535,9 @@ public: virtual void window_set_ime_active(const bool p_active, WindowID p_window = MAIN_WINDOW_ID) override; virtual void window_set_ime_position(const Point2i &p_pos, WindowID p_window = MAIN_WINDOW_ID) override; + virtual int accessibility_should_increase_contrast() const override; + virtual int accessibility_screen_reader_active() const override; + virtual Point2i ime_get_selection() const override; virtual String ime_get_text() const override; diff --git a/platform/macos/detect.py b/platform/macos/detect.py index f165dc8d9d5..a635e6b16b5 100644 --- a/platform/macos/detect.py +++ b/platform/macos/detect.py @@ -182,6 +182,18 @@ def configure(env: "SConsEnvironment"): ## Dependencies + if env["accesskit"]: + if env["accesskit_sdk_path"] != "": + env.Prepend(CPPPATH=[env["accesskit_sdk_path"] + "/include"]) + if env["arch"] == "arm64" or env["arch"] == "universal": + env.Append(LINKFLAGS=["-L" + env["accesskit_sdk_path"] + "/lib/macos/arm64/static/"]) + if env["arch"] == "x86_64" or env["arch"] == "universal": + env.Append(LINKFLAGS=["-L" + env["accesskit_sdk_path"] + "/lib/macos/x86_64/static/"]) + env.Append(LINKFLAGS=["-laccesskit"]) + else: + env.Append(CPPDEFINES=["ACCESSKIT_DYNAMIC"]) + env.Append(CPPDEFINES=["ACCESSKIT_ENABLED"]) + if env["builtin_libtheora"] and env["arch"] == "x86_64": env["x86_libtheora_opt_gcc"] = True diff --git a/platform/macos/display_server_macos.h b/platform/macos/display_server_macos.h index e6cfd976ae4..0e75cf38d23 100644 --- a/platform/macos/display_server_macos.h +++ b/platform/macos/display_server_macos.h @@ -425,6 +425,11 @@ public: virtual void window_set_window_buttons_offset(const Vector2i &p_offset, WindowID p_window = MAIN_WINDOW_ID) override; virtual Vector3i window_get_safe_title_margins(WindowID p_window = MAIN_WINDOW_ID) const override; + virtual int accessibility_should_increase_contrast() const override; + virtual int accessibility_should_reduce_animation() const override; + virtual int accessibility_should_reduce_transparency() const override; + virtual int accessibility_screen_reader_active() const override; + virtual Point2i ime_get_selection() const override; virtual String ime_get_text() const override; diff --git a/platform/macos/display_server_macos.mm b/platform/macos/display_server_macos.mm index 942d3a27e3e..a958327fc21 100644 --- a/platform/macos/display_server_macos.mm +++ b/platform/macos/display_server_macos.mm @@ -30,6 +30,7 @@ #import "display_server_macos.h" +#import "godot_application_delegate.h" #import "godot_button_view.h" #import "godot_content_view.h" #import "godot_menu_delegate.h" @@ -52,6 +53,8 @@ #include +#include "servers/rendering/dummy/rasterizer_dummy.h" + #if defined(GLES3_ENABLED) #include "drivers/gles3/rasterizer_gles3.h" #endif @@ -60,6 +63,10 @@ #include "servers/rendering/renderer_rd/renderer_compositor_rd.h" #endif +#if defined(ACCESSKIT_ENABLED) +#include "drivers/accesskit/accessibility_driver_accesskit.h" +#endif + #import #import #import @@ -68,14 +75,15 @@ #import DisplayServerMacOS::WindowID DisplayServerMacOS::_create_window(WindowMode p_mode, VSyncMode p_vsync_mode, const Rect2i &p_rect) { - WindowID id; const float scale = screen_get_max_scale(); + + WindowID id = window_id_counter; { - WindowData wd; + WindowData &wd = windows[id]; wd.window_delegate = [[GodotWindowDelegate alloc] init]; ERR_FAIL_NULL_V_MSG(wd.window_delegate, INVALID_WINDOW_ID, "Can't create a window delegate"); - [wd.window_delegate setWindowID:window_id_counter]; + [wd.window_delegate setWindowID:id]; int rq_screen = get_screen_from_rect(p_rect); if (rq_screen < 0) { @@ -100,12 +108,15 @@ DisplayServerMacOS::WindowID DisplayServerMacOS::_create_window(WindowMode p_mod backing:NSBackingStoreBuffered defer:NO]; ERR_FAIL_NULL_V_MSG(wd.window_object, INVALID_WINDOW_ID, "Can't create a window"); - [wd.window_object setWindowID:window_id_counter]; + [wd.window_object setWindowID:id]; [wd.window_object setReleasedWhenClosed:NO]; wd.window_view = [[GodotContentView alloc] init]; - ERR_FAIL_NULL_V_MSG(wd.window_view, INVALID_WINDOW_ID, "Can't create a window view"); - [wd.window_view setWindowID:window_id_counter]; + if (wd.window_view == nil) { + windows.erase(id); + ERR_FAIL_V_MSG(INVALID_WINDOW_ID, "Can't create a window view"); + } + [wd.window_view setWindowID:id]; [wd.window_view setWantsLayer:TRUE]; [wd.window_object setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary]; @@ -115,6 +126,16 @@ DisplayServerMacOS::WindowID DisplayServerMacOS::_create_window(WindowMode p_mod [wd.window_object setRestorable:NO]; [wd.window_object setColorSpace:[NSColorSpace sRGBColorSpace]]; +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver && !accessibility_driver->window_create(id, (__bridge void *)wd.window_object)) { + if (OS::get_singleton()->is_stdout_verbose()) { + ERR_PRINT("Can't create an accessibility adapter for window, accessibility support disabled!"); + } + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } +#endif + if ([wd.window_object respondsToSelector:@selector(setTabbingMode:)]) { [wd.window_object setTabbingMode:NSWindowTabbingModeDisallowed]; } @@ -156,23 +177,43 @@ DisplayServerMacOS::WindowID DisplayServerMacOS::_create_window(WindowMode p_mod } #endif Error err = rendering_context->window_create(window_id_counter, &wpd); +#ifdef ACCESSKIT_ENABLED + if (err != OK && accessibility_driver) { + accessibility_driver->window_destroy(id); + } +#endif ERR_FAIL_COND_V_MSG(err != OK, INVALID_WINDOW_ID, vformat("Can't create a %s context", rendering_driver)); rendering_context->window_set_size(window_id_counter, p_rect.size.width, p_rect.size.height); rendering_context->window_set_vsync_mode(window_id_counter, p_vsync_mode); } #endif + #if defined(GLES3_ENABLED) + bool gl_failed = false; if (gl_manager_legacy) { Error err = gl_manager_legacy->window_create(window_id_counter, wd.window_view, p_rect.size.width, p_rect.size.height); - ERR_FAIL_COND_V_MSG(err != OK, INVALID_WINDOW_ID, "Can't create an OpenGL context."); + if (err != OK) { + gl_failed = true; + } } if (gl_manager_angle) { CALayer *layer = [(NSView *)wd.window_view layer]; Error err = gl_manager_angle->window_create(window_id_counter, nullptr, (__bridge void *)layer, p_rect.size.width, p_rect.size.height); - ERR_FAIL_COND_V_MSG(err != OK, INVALID_WINDOW_ID, "Can't create an OpenGL context."); + if (err != OK) { + gl_failed = true; + } } - window_set_vsync_mode(p_vsync_mode, window_id_counter); + if (gl_failed) { +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->window_destroy(id); + } +#endif + windows.erase(id); + ERR_FAIL_V_MSG(INVALID_WINDOW_ID, "Can't create an OpenGL context."); + } + window_set_vsync_mode(p_vsync_mode, id); #endif [wd.window_view updateLayerDelegate]; @@ -184,10 +225,8 @@ DisplayServerMacOS::WindowID DisplayServerMacOS::_create_window(WindowMode p_mod offset.y = (nsrect.origin.y + nsrect.size.height); offset.y -= (windowRect.origin.y + windowRect.size.height); [wd.window_object setFrameTopLeftPoint:NSMakePoint(wpos.x - offset.x, wpos.y - offset.y)]; - - id = window_id_counter++; - windows[id] = wd; } + window_id_counter++; WindowData &wd = windows[id]; window_set_mode(p_mode, id); @@ -762,6 +801,8 @@ bool DisplayServerMacOS::get_is_resizing() const { } void DisplayServerMacOS::window_destroy(WindowID p_window) { + ERR_FAIL_COND(!windows.has(p_window)); + #if defined(GLES3_ENABLED) if (gl_manager_legacy) { gl_manager_legacy->window_destroy(p_window); @@ -775,6 +816,11 @@ void DisplayServerMacOS::window_destroy(WindowID p_window) { if (rendering_context) { rendering_context->window_destroy(p_window); } +#endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->window_destroy(p_window); + } #endif windows.erase(p_window); @@ -835,6 +881,11 @@ bool DisplayServerMacOS::has_feature(Feature p_feature) const { case FEATURE_SCREEN_EXCLUDE_FROM_CAPTURE: case FEATURE_EMOJI_AND_SYMBOL_PICKER: return true; +#ifdef ACCESSKIT_ENABLED + case FEATURE_ACCESSIBILITY_SCREEN_READER: { + return (accessibility_driver != nullptr); + } break; +#endif default: { } } @@ -2999,6 +3050,22 @@ DisplayServer::VSyncMode DisplayServerMacOS::window_get_vsync_mode(WindowID p_wi return DisplayServer::VSYNC_ENABLED; } +int DisplayServerMacOS::accessibility_should_increase_contrast() const { + return [(GodotApplicationDelegate *)[[NSApplication sharedApplication] delegate] getHighContrast]; +} + +int DisplayServerMacOS::accessibility_should_reduce_animation() const { + return [(GodotApplicationDelegate *)[[NSApplication sharedApplication] delegate] getReduceMotion]; +} + +int DisplayServerMacOS::accessibility_should_reduce_transparency() const { + return [(GodotApplicationDelegate *)[[NSApplication sharedApplication] delegate] getReduceTransparency]; +} + +int DisplayServerMacOS::accessibility_screen_reader_active() const { + return [(GodotApplicationDelegate *)[[NSApplication sharedApplication] delegate] getVoiceOver]; +} + Point2i DisplayServerMacOS::ime_get_selection() const { return im_selection; } @@ -3592,6 +3659,7 @@ Vector DisplayServerMacOS::get_rendering_drivers_func() { drivers.push_back("opengl3"); drivers.push_back("opengl3_angle"); #endif + drivers.push_back("dummy"); return drivers; } @@ -3783,6 +3851,16 @@ DisplayServerMacOS::DisplayServerMacOS(const String &p_rendering_driver, WindowM native_menu = memnew(NativeMenuMacOS); +#ifdef ACCESSKIT_ENABLED + if (accessibility_get_mode() != DisplayServer::AccessibilityMode::ACCESSIBILITY_DISABLED) { + accessibility_driver = memnew(AccessibilityDriverAccessKit); + if (accessibility_driver->init() != OK) { + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } + } +#endif + NSMenuItem *menu_item; NSString *title; @@ -3974,6 +4052,10 @@ DisplayServerMacOS::DisplayServerMacOS(const String &p_rendering_driver, WindowM } force_process_and_drop_events(); + if (rendering_driver == "dummy") { + RasterizerDummy::make_current(); + } + #if defined(GLES3_ENABLED) if (rendering_driver == "opengl3") { RasterizerGLES3::make_current(true); @@ -4042,7 +4124,11 @@ DisplayServerMacOS::~DisplayServerMacOS() { rendering_context = nullptr; } #endif - +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + memdelete(accessibility_driver); + } +#endif CFNotificationCenterRemoveObserver(CFNotificationCenterGetDistributedCenter(), nullptr, kTISNotifySelectedKeyboardInputSourceChanged, nullptr); CGDisplayRemoveReconfigurationCallback(_displays_arrangement_changed, nullptr); diff --git a/platform/macos/godot_application_delegate.h b/platform/macos/godot_application_delegate.h index c5c3a07b574..eeac379466f 100644 --- a/platform/macos/godot_application_delegate.h +++ b/platform/macos/godot_application_delegate.h @@ -35,9 +35,20 @@ #import #import -@interface GodotApplicationDelegate : NSObject -- (void)activate; +@interface GodotApplicationDelegate : NSObject { + bool high_contrast; + bool reduce_motion; + bool reduce_transparency; + bool voice_over; +} + - (void)forceUnbundledWindowActivationHackStep1; - (void)forceUnbundledWindowActivationHackStep2; - (void)forceUnbundledWindowActivationHackStep3; +- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context; +- (void)accessibilityDisplayOptionsChange:(NSNotification *)notification; +- (bool)getHighContrast; +- (bool)getReduceMotion; +- (bool)getReduceTransparency; +- (bool)getVoiceOver; @end diff --git a/platform/macos/godot_application_delegate.mm b/platform/macos/godot_application_delegate.mm index 90b30c1a446..e7ece517d26 100644 --- a/platform/macos/godot_application_delegate.mm +++ b/platform/macos/godot_application_delegate.mm @@ -143,14 +143,55 @@ [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(system_theme_changed:) name:@"AppleColorPreferencesChangedNotification" object:nil]; } +static const char *godot_ac_ctx = "gd_accessibility_observer_ctx"; + - (id)init { self = [super init]; + + [[NSWorkspace sharedWorkspace] addObserver:self forKeyPath:@"voiceOverEnabled" options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld) context:(void *)godot_ac_ctx]; + [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver:self selector:@selector(accessibilityDisplayOptionsChange:) name:NSWorkspaceAccessibilityDisplayOptionsDidChangeNotification object:nil]; + high_contrast = [[NSWorkspace sharedWorkspace] accessibilityDisplayShouldIncreaseContrast]; + reduce_motion = [[NSWorkspace sharedWorkspace] accessibilityDisplayShouldReduceMotion]; + reduce_transparency = [[NSWorkspace sharedWorkspace] accessibilityDisplayShouldReduceTransparency]; + voice_over = [[NSWorkspace sharedWorkspace] isVoiceOverEnabled]; + return self; } - (void)dealloc { [[NSDistributedNotificationCenter defaultCenter] removeObserver:self name:@"AppleInterfaceThemeChangedNotification" object:nil]; [[NSDistributedNotificationCenter defaultCenter] removeObserver:self name:@"AppleColorPreferencesChangedNotification" object:nil]; + [[NSWorkspace sharedWorkspace] removeObserver:self forKeyPath:@"voiceOverEnabled" context:(void *)godot_ac_ctx]; +} + +- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context { + if (context == (void *)godot_ac_ctx) { + voice_over = [[NSWorkspace sharedWorkspace] isVoiceOverEnabled]; + } else { + [super observeValueForKeyPath:keyPath ofObject:object change:change context:context]; + } +} + +- (void)accessibilityDisplayOptionsChange:(NSNotification *)notification { + high_contrast = [[NSWorkspace sharedWorkspace] accessibilityDisplayShouldIncreaseContrast]; + reduce_motion = [[NSWorkspace sharedWorkspace] accessibilityDisplayShouldReduceMotion]; + reduce_transparency = [[NSWorkspace sharedWorkspace] accessibilityDisplayShouldReduceTransparency]; +} + +- (bool)getHighContrast { + return high_contrast; +} + +- (bool)getReduceMotion { + return reduce_motion; +} + +- (bool)getReduceTransparency { + return reduce_transparency; +} + +- (bool)getVoiceOver { + return voice_over; } - (void)application:(NSApplication *)application openURLs:(NSArray *)urls { diff --git a/platform/macos/godot_window_delegate.mm b/platform/macos/godot_window_delegate.mm index 76b40de3ee7..cc9fa0c4b6e 100644 --- a/platform/macos/godot_window_delegate.mm +++ b/platform/macos/godot_window_delegate.mm @@ -324,6 +324,9 @@ wd.focused = true; ds->set_last_focused_window(window_id); +#ifdef ACCESSKIT_ENABLED + ds->accessibility_set_window_focused(window_id, true); +#endif ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_IN); } @@ -341,6 +344,9 @@ wd.focused = false; ds->release_pressed_events(); +#ifdef ACCESSKIT_ENABLED + ds->accessibility_set_window_focused(window_id, false); +#endif ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_OUT); } @@ -354,6 +360,9 @@ wd.focused = false; ds->release_pressed_events(); +#ifdef ACCESSKIT_ENABLED + ds->accessibility_set_window_focused(window_id, false); +#endif ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_OUT); } @@ -368,6 +377,9 @@ if ([wd.window_object isKeyWindow]) { wd.focused = true; ds->set_last_focused_window(window_id); +#ifdef ACCESSKIT_ENABLED + ds->accessibility_set_window_focused(window_id, true); +#endif ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_IN); } } diff --git a/platform/windows/SCsub b/platform/windows/SCsub index ba02c36dd08..45487118884 100644 --- a/platform/windows/SCsub +++ b/platform/windows/SCsub @@ -60,6 +60,12 @@ env.Depends(res_obj, "#core/version_generated.gen.h") env.add_source_files(sources, common_win) sources += res_obj +if env["accesskit"] and not env.msvc: + def_file = "uiautomationcore." + env["arch"] + ".def" + def_target = "libuiautomationcore." + env["arch"] + ".a" + def_obj = env.DEF(def_target, def_file) + sources += def_obj + prog = env.add_program("#bin/godot", sources, PROGSUFFIX=env["PROGSUFFIX"]) arrange_program_clean(prog) diff --git a/platform/windows/detect.py b/platform/windows/detect.py index a1af39e4290..49f0496aa6f 100644 --- a/platform/windows/detect.py +++ b/platform/windows/detect.py @@ -5,7 +5,7 @@ import sys from typing import TYPE_CHECKING import methods -from methods import print_error, print_warning +from methods import print_error, print_info, print_warning from platform_methods import detect_arch, validate_arch if TYPE_CHECKING: @@ -245,6 +245,44 @@ def get_flags(): } +def build_def_file(target, source, env: "SConsEnvironment"): + arch_aliases = { + "x86_32": "i386", + "x86_64": "i386:x86-64", + "arm32": "arm", + "arm64": "arm64", + } + + cmdbase = "dlltool -m " + arch_aliases[env["arch"]] + if env["arch"] != "x86_32": + cmdbase += " --no-leading-underscore" + + mingw_bin_prefix = get_mingw_bin_prefix(env["mingw_prefix"], env["arch"]) + + for x in range(len(source)): + ok = True + # Try prefixed executable (MinGW on Linux). + cmd = mingw_bin_prefix + cmdbase + " -d " + str(source[x]) + " -l " + str(target[x]) + try: + out = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE).communicate() + if len(out[1]): + ok = False + except Exception: + ok = False + + # Try generic executable (MSYS2). + if not ok: + cmd = cmdbase + " -d " + str(source[x]) + " -l " + str(target[x]) + try: + out = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE).communicate() + if len(out[1]): + return -1 + except Exception: + return -1 + + return 0 + + def configure_msvc(env: "SConsEnvironment"): """Configure env to work with MSVC""" @@ -365,6 +403,11 @@ def configure_msvc(env: "SConsEnvironment"): validate_win_version(env) + if env["accesskit"]: + if int(env["target_win_version"], 16) < 0x0602: + print_info("AcceeKit enabled, targeted Windows version changed to Windows 8 (0x602).") + env["target_win_version"] = "0x0602" # Accessibility API require Windows 8+ + env.AppendUnique( CPPDEFINES=[ "WINDOWS_ENABLED", @@ -421,6 +464,29 @@ def configure_msvc(env: "SConsEnvironment"): if env.debug_features: LIBS += ["psapi", "dbghelp"] + if env["accesskit"]: + if env["accesskit_sdk_path"] != "": + env.Prepend(CPPPATH=[env["accesskit_sdk_path"] + "/include"]) + if env["arch"] == "arm64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/arm64/msvc/static"]) + elif env["arch"] == "x86_64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/x86_64/msvc/static"]) + elif env["arch"] == "x86_32": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/x86/msvc/static"]) + LIBS += [ + "accesskit", + "uiautomationcore", + "runtimeobject", + "propsys", + "oleaut32", + "user32", + "userenv", + "ntdll", + ] + else: + env.Append(CPPDEFINES=["ACCESSKIT_DYNAMIC"]) + env.Append(CPPDEFINES=["ACCESSKIT_ENABLED"]) + if env["vulkan"]: env.AppendUnique(CPPDEFINES=["VULKAN_ENABLED", "RD_ENABLED"]) if not env["use_volk"]: @@ -703,6 +769,11 @@ def configure_mingw(env: "SConsEnvironment"): validate_win_version(env) + if env["accesskit"]: + if int(env["target_win_version"], 16) < 0x0602: + print_info("AcceeKit enabled, targeted Windows version changed to Windows 8 (0x602).") + env["target_win_version"] = "0x0602" # Accessibility API require Windows 8+ + if not env["use_llvm"]: env.Append(CCFLAGS=["-mwindows"]) @@ -767,6 +838,38 @@ def configure_mingw(env: "SConsEnvironment"): ] ) + if env["accesskit"]: + if env["accesskit_sdk_path"] != "": + env.Prepend(CPPPATH=[env["accesskit_sdk_path"] + "/include"]) + if env["use_llvm"]: + if env["arch"] == "arm64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/arm64/mingw-llvm/static/"]) + elif env["arch"] == "x86_64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/x86_64/mingw-llvm/static/"]) + elif env["arch"] == "x86_32": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/x86/mingw-llvm/static/"]) + else: + if env["arch"] == "x86_64": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/x86_64/mingw/static/"]) + elif env["arch"] == "x86_32": + env.Append(LIBPATH=[env["accesskit_sdk_path"] + "/lib/windows/x86/mingw/static/"]) + env.Append( + LIBS=[ + "accesskit", + "uiautomationcore." + env["arch"], + "runtimeobject", + "propsys", + "oleaut32", + "user32", + "userenv", + "ntdll", + ] + ) + else: + env.Append(CPPDEFINES=["ACCESSKIT_DYNAMIC"]) + env.Append(LIBPATH=["#platform/windows"]) + env.Append(CPPDEFINES=["ACCESSKIT_ENABLED"]) + if env.debug_features: env.Append(LIBS=["psapi", "dbghelp"]) @@ -812,6 +915,9 @@ def configure_mingw(env: "SConsEnvironment"): env.Append(CPPDEFINES=["MINGW_ENABLED", ("MINGW_HAS_SECURE_API", 1)]) + # dlltool + env.Append(BUILDERS={"DEF": env.Builder(action=build_def_file, suffix=".a", src_suffix=".def")}) + def configure(env: "SConsEnvironment"): # Validate arch. diff --git a/platform/windows/display_server_windows.cpp b/platform/windows/display_server_windows.cpp index 5d3fe5aa113..20a34fe20d4 100644 --- a/platform/windows/display_server_windows.cpp +++ b/platform/windows/display_server_windows.cpp @@ -43,6 +43,8 @@ #include "main/main.h" #include "scene/resources/texture.h" +#include "servers/rendering/dummy/rasterizer_dummy.h" + #if defined(VULKAN_ENABLED) #include "rendering_context_driver_vulkan_windows.h" #endif @@ -53,6 +55,10 @@ #include "drivers/gles3/rasterizer_gles3.h" #endif +#if defined(ACCESSKIT_ENABLED) +#include "drivers/accesskit/accessibility_driver_accesskit.h" +#endif + #include #include #include @@ -142,6 +148,11 @@ bool DisplayServerWindows::has_feature(Feature p_feature) const { return true; case FEATURE_EMOJI_AND_SYMBOL_PICKER: return (os_ver.dwBuildNumber >= 17134); // Windows 10 Redstone 4 (1803)+ only. +#ifdef ACCESSKIT_ENABLED + case FEATURE_ACCESSIBILITY_SCREEN_READER: { + return (accessibility_driver != nullptr); + } break; +#endif default: return false; } @@ -2735,6 +2746,46 @@ bool DisplayServerWindows::can_any_window_draw() const { return false; } +int DisplayServerWindows::accessibility_should_increase_contrast() const { + HIGHCONTRASTA hc; + hc.cbSize = sizeof(HIGHCONTRAST); + if (!SystemParametersInfoA(SPI_GETHIGHCONTRAST, sizeof(HIGHCONTRAST), &hc, 0)) { + return -1; + } + return (hc.dwFlags & HCF_HIGHCONTRASTON); +} + +int DisplayServerWindows::accessibility_should_reduce_animation() const { + bool anim_enabled = false; + if (!SystemParametersInfoA(SPI_GETCLIENTAREAANIMATION, 0, &anim_enabled, 0)) { + return -1; + } + return (!anim_enabled); +} + +int DisplayServerWindows::accessibility_should_reduce_transparency() const { + bool tr_enabled = false; + if (!SystemParametersInfoA(SPI_GETDISABLEOVERLAPPEDCONTENT, 0, &tr_enabled, 0)) { + return -1; + } + return tr_enabled; +} + +int DisplayServerWindows::accessibility_screen_reader_active() const { + bool sr_enabled = false; + if (SystemParametersInfoA(SPI_GETSCREENREADER, 0, &sr_enabled, 0) && sr_enabled) { + return true; + } + + static const WCHAR *narrator_mutex_name = L"NarratorRunning"; + HANDLE narrator_mutex = OpenMutexW(MUTEX_ALL_ACCESS, false, narrator_mutex_name); + if (narrator_mutex) { + CloseHandle(narrator_mutex); + return true; + } + return false; +} + Vector2i DisplayServerWindows::ime_get_selection() const { _THREAD_SAFE_METHOD_ @@ -4522,6 +4573,16 @@ LRESULT DisplayServerWindows::_handle_early_window_message(HWND hWnd, UINT uMsg, // Fix this up so we can recognize the remaining messages. pWindowData->hWnd = hWnd; + +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver && !accessibility_driver->window_create(pWindowData->id, (void *)hWnd)) { + if (OS::get_singleton()->is_stdout_verbose()) { + ERR_PRINT("Can't create an accessibility adapter for window, accessibility support disabled!"); + } + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } +#endif } break; default: { // Additional messages during window creation should happen after we fixed @@ -4572,6 +4633,9 @@ LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA // Process window messages. switch (uMsg) { + case WM_GETOBJECT: { + get_object_recieved = true; + } break; case WM_MENUCOMMAND: { native_menu->_menu_activate(HMENU(lParam), (int)wParam); } break; @@ -5870,6 +5934,11 @@ LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA joypad->probe_joypads(); } break; case WM_DESTROY: { +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->window_destroy(window_id); + } +#endif Input::get_singleton()->flush_buffered_events(); if (window_mouseover_id == window_id) { window_mouseover_id = INVALID_WINDOW_ID; @@ -5923,6 +5992,11 @@ void DisplayServerWindows::_process_activate_event(WindowID p_window_id) { SetFocus(wd.hWnd); } wd.window_focused = true; +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->accessibility_set_window_focused(p_window_id, true); + } +#endif _send_window_event(wd, WINDOW_EVENT_FOCUS_IN); } else { // WM_INACTIVE. Input::get_singleton()->release_pressed_events(); @@ -5936,6 +6010,11 @@ void DisplayServerWindows::_process_activate_event(WindowID p_window_id) { ReleaseCapture(); } wd.window_focused = false; +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + accessibility_driver->accessibility_set_window_focused(p_window_id, false); + } +#endif _send_window_event(wd, WINDOW_EVENT_FOCUS_OUT); } @@ -6223,6 +6302,7 @@ DisplayServer::WindowID DisplayServerWindows::_create_window(WindowMode p_mode, WindowData &wd = windows[id]; + wd.id = id; wd.hWnd = CreateWindowExW( dwExStyle, L"Engine", L"", @@ -6649,6 +6729,19 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win } native_menu = memnew(NativeMenuWindows); +#ifdef ACCESSKIT_ENABLED + if (accessibility_get_mode() != DisplayServer::AccessibilityMode::ACCESSIBILITY_DISABLED) { + accessibility_driver = memnew(AccessibilityDriverAccessKit); + if (accessibility_driver->init() != OK) { + if (OS::get_singleton()->is_stdout_verbose()) { + ERR_PRINT("Can't create an accessibility driver, accessibility support disabled!"); + } + memdelete(accessibility_driver); + accessibility_driver = nullptr; + } + } +#endif + // Enforce default keep screen on value. screen_set_keep_on(GLOBAL_GET("display/window/energy_saving/keep_screen_on")); @@ -6829,6 +6922,11 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win _register_raw_input_devices(INVALID_WINDOW_ID); + // Init context and rendering device. + if (rendering_driver == "dummy") { + RasterizerDummy::make_current(); + } + #if defined(RD_ENABLED) [[maybe_unused]] bool fallback_to_vulkan = GLOBAL_GET("rendering/rendering_device/fallback_to_vulkan"); [[maybe_unused]] bool fallback_to_d3d12 = GLOBAL_GET("rendering/rendering_device/fallback_to_d3d12"); @@ -6901,7 +6999,7 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win } } #endif -// Init context and rendering device + #if defined(GLES3_ENABLED) bool fallback = GLOBAL_GET("rendering/gl_compatibility/fallback_to_angle"); @@ -7076,6 +7174,24 @@ DisplayServerWindows::DisplayServerWindows(const String &p_rendering_driver, Win windows[MAIN_WINDOW_ID].initialized = true; + if (accessibility_screen_reader_active()) { + _THREAD_SAFE_LOCK_ + uint64_t time_wait = OS::get_singleton()->get_ticks_msec(); + while (true) { + MSG msg = {}; + while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) { + TranslateMessage(&msg); + DispatchMessageW(&msg); + } + + uint64_t delta = OS::get_singleton()->get_ticks_msec() - time_wait; + if (delta > 500 || get_object_recieved) { + break; + } + } + _THREAD_SAFE_UNLOCK_ + } + #if defined(RD_ENABLED) if (rendering_context) { rendering_device = memnew(RenderingDevice); @@ -7133,6 +7249,7 @@ Vector DisplayServerWindows::get_rendering_drivers_func() { drivers.push_back("opengl3"); drivers.push_back("opengl3_angle"); #endif + drivers.push_back("dummy"); return drivers; } @@ -7284,6 +7401,11 @@ DisplayServerWindows::~DisplayServerWindows() { memdelete(gl_manager_native); gl_manager_native = nullptr; } +#endif +#ifdef ACCESSKIT_ENABLED + if (accessibility_driver) { + memdelete(accessibility_driver); + } #endif if (tts) { memdelete(tts); diff --git a/platform/windows/display_server_windows.h b/platform/windows/display_server_windows.h index cf50408f760..87758b06d0d 100644 --- a/platform/windows/display_server_windows.h +++ b/platform/windows/display_server_windows.h @@ -459,6 +459,7 @@ class DisplayServerWindows : public DisplayServer { String rendering_driver; bool app_focused = false; bool keep_screen_on = false; + bool get_object_recieved = false; HANDLE power_request; TTS_Windows *tts = nullptr; @@ -466,6 +467,7 @@ class DisplayServerWindows : public DisplayServer { struct WindowData { HWND hWnd; + WindowID id; Vector mpath; @@ -823,6 +825,11 @@ public: virtual void window_set_ime_active(const bool p_active, WindowID p_window = MAIN_WINDOW_ID) override; virtual void window_set_ime_position(const Point2i &p_pos, WindowID p_window = MAIN_WINDOW_ID) override; + virtual int accessibility_should_increase_contrast() const override; + virtual int accessibility_should_reduce_animation() const override; + virtual int accessibility_should_reduce_transparency() const override; + virtual int accessibility_screen_reader_active() const override; + virtual Point2i ime_get_selection() const override; virtual String ime_get_text() const override; diff --git a/platform/windows/export/export_plugin.cpp b/platform/windows/export/export_plugin.cpp index 964af1f1452..d180a293009 100644 --- a/platform/windows/export/export_plugin.cpp +++ b/platform/windows/export/export_plugin.cpp @@ -244,6 +244,7 @@ Error EditorExportPlatformWindows::export_project(const Ref path = tmp_dir_path.path_join(p_path.get_file().get_basename() + ".exe"); } + Ref da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); int export_angle = p_preset->get("application/export_angle"); bool include_angle_libs = false; if (export_angle == 0) { @@ -252,7 +253,6 @@ Error EditorExportPlatformWindows::export_project(const Ref include_angle_libs = true; } if (include_angle_libs) { - Ref da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); if (da->file_exists(template_path.get_base_dir().path_join("libEGL." + arch + ".dll"))) { da->copy(template_path.get_base_dir().path_join("libEGL." + arch + ".dll"), path.get_base_dir().path_join("libEGL.dll"), get_chmod_flags()); } @@ -260,6 +260,9 @@ Error EditorExportPlatformWindows::export_project(const Ref da->copy(template_path.get_base_dir().path_join("libGLESv2." + arch + ".dll"), path.get_base_dir().path_join("libGLESv2.dll"), get_chmod_flags()); } } + if (da->file_exists(template_path.get_base_dir().path_join("accesskit." + arch + ".dll"))) { + da->copy(template_path.get_base_dir().path_join("accesskit." + arch + ".dll"), path.get_base_dir().path_join("accesskit." + arch + ".dll"), get_chmod_flags()); + } int export_d3d12 = p_preset->get("application/export_d3d12"); bool agility_sdk_multiarch = p_preset->get("application/d3d12_agility_sdk_multiarch"); @@ -270,7 +273,6 @@ Error EditorExportPlatformWindows::export_project(const Ref include_d3d12_extra_libs = true; } if (include_d3d12_extra_libs) { - Ref da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); if (da->file_exists(template_path.get_base_dir().path_join("D3D12Core." + arch + ".dll"))) { if (agility_sdk_multiarch) { da->make_dir_recursive(path.get_base_dir().path_join(arch)); diff --git a/platform/windows/uiautomationcore.arm32.def b/platform/windows/uiautomationcore.arm32.def new file mode 100644 index 00000000000..a83dd7cc7aa --- /dev/null +++ b/platform/windows/uiautomationcore.arm32.def @@ -0,0 +1,115 @@ +; +; Definition file of UIAutomationCore.DLL +; Automatic generated by gendef +; written by Kai Tietz 2008 +; +LIBRARY "UIAutomationCore.DLL" +EXPORTS +DllGetActivationFactory +DllCanUnloadNow +DllGetClassObject +DockPattern_SetDockPosition +ExpandCollapsePattern_Collapse +ExpandCollapsePattern_Expand +GridPattern_GetItem +IgnoreLeaksInCurrentlyTrackedMemory +InitializeChannelBasedConnectionForProviderProxy +InvokePattern_Invoke +IsIgnoringLeaks +ItemContainerPattern_FindItemByProperty +LegacyIAccessiblePattern_DoDefaultAction +LegacyIAccessiblePattern_GetIAccessible +LegacyIAccessiblePattern_Select +LegacyIAccessiblePattern_SetValue +MultipleViewPattern_GetViewName +MultipleViewPattern_SetCurrentView +PostTestCheckForLeaks +RangeValuePattern_SetValue +ScrollItemPattern_ScrollIntoView +ScrollPattern_Scroll +ScrollPattern_SetScrollPercent +SelectionItemPattern_AddToSelection +SelectionItemPattern_RemoveFromSelection +SelectionItemPattern_Select +StartIgnoringLeaks +StopIgnoringLeaks +SynchronizedInputPattern_Cancel +SynchronizedInputPattern_StartListening +TextPattern_GetSelection +TextPattern_GetVisibleRanges +TextPattern_RangeFromChild +TextPattern_RangeFromPoint +TextPattern_get_DocumentRange +TextPattern_get_SupportedTextSelection +TextRange_AddToSelection +TextRange_Clone +TextRange_Compare +TextRange_CompareEndpoints +TextRange_ExpandToEnclosingUnit +TextRange_FindAttribute +TextRange_FindText +TextRange_GetAttributeValue +TextRange_GetBoundingRectangles +TextRange_GetChildren +TextRange_GetEnclosingElement +TextRange_GetText +TextRange_Move +TextRange_MoveEndpointByRange +TextRange_MoveEndpointByUnit +TextRange_RemoveFromSelection +TextRange_ScrollIntoView +TextRange_Select +TogglePattern_Toggle +TransformPattern_Move +TransformPattern_Resize +TransformPattern_Rotate +UiaAddEvent +UiaClientsAreListening +UiaDisconnectAllProviders +UiaDisconnectProvider +UiaEventAddWindow +UiaEventRemoveWindow +UiaFind +UiaGetErrorDescription +UiaGetPatternProvider +UiaGetPropertyValue +UiaGetReservedMixedAttributeValue +UiaGetReservedNotSupportedValue +UiaGetRootNode +UiaGetRuntimeId +UiaGetUpdatedCache +UiaHPatternObjectFromVariant +UiaHTextRangeFromVariant +UiaHUiaNodeFromVariant +UiaHasServerSideProvider +UiaHostProviderFromHwnd +UiaIAccessibleFromProvider +UiaLookupId +UiaNavigate +UiaNodeFromFocus +UiaNodeFromHandle +UiaNodeFromPoint +UiaNodeFromProvider +UiaNodeRelease +UiaPatternRelease +UiaProviderForNonClient +UiaProviderFromIAccessible +UiaRaiseActiveTextPositionChangedEvent +UiaRaiseAsyncContentLoadedEvent +UiaRaiseAutomationEvent +UiaRaiseAutomationPropertyChangedEvent +UiaRaiseChangesEvent +UiaRaiseNotificationEvent +UiaRaiseStructureChangedEvent +UiaRaiseTextEditTextChangedEvent +UiaRegisterProviderCallback +UiaRemoveEvent +UiaReturnRawElementProvider +UiaSetFocus +UiaTextRangeRelease +UpdateErrorLoggingCallback +ValuePattern_SetValue +VirtualizedItemPattern_Realize +WindowPattern_Close +WindowPattern_SetWindowVisualState +WindowPattern_WaitForInputIdle diff --git a/platform/windows/uiautomationcore.arm64.def b/platform/windows/uiautomationcore.arm64.def new file mode 100644 index 00000000000..a83dd7cc7aa --- /dev/null +++ b/platform/windows/uiautomationcore.arm64.def @@ -0,0 +1,115 @@ +; +; Definition file of UIAutomationCore.DLL +; Automatic generated by gendef +; written by Kai Tietz 2008 +; +LIBRARY "UIAutomationCore.DLL" +EXPORTS +DllGetActivationFactory +DllCanUnloadNow +DllGetClassObject +DockPattern_SetDockPosition +ExpandCollapsePattern_Collapse +ExpandCollapsePattern_Expand +GridPattern_GetItem +IgnoreLeaksInCurrentlyTrackedMemory +InitializeChannelBasedConnectionForProviderProxy +InvokePattern_Invoke +IsIgnoringLeaks +ItemContainerPattern_FindItemByProperty +LegacyIAccessiblePattern_DoDefaultAction +LegacyIAccessiblePattern_GetIAccessible +LegacyIAccessiblePattern_Select +LegacyIAccessiblePattern_SetValue +MultipleViewPattern_GetViewName +MultipleViewPattern_SetCurrentView +PostTestCheckForLeaks +RangeValuePattern_SetValue +ScrollItemPattern_ScrollIntoView +ScrollPattern_Scroll +ScrollPattern_SetScrollPercent +SelectionItemPattern_AddToSelection +SelectionItemPattern_RemoveFromSelection +SelectionItemPattern_Select +StartIgnoringLeaks +StopIgnoringLeaks +SynchronizedInputPattern_Cancel +SynchronizedInputPattern_StartListening +TextPattern_GetSelection +TextPattern_GetVisibleRanges +TextPattern_RangeFromChild +TextPattern_RangeFromPoint +TextPattern_get_DocumentRange +TextPattern_get_SupportedTextSelection +TextRange_AddToSelection +TextRange_Clone +TextRange_Compare +TextRange_CompareEndpoints +TextRange_ExpandToEnclosingUnit +TextRange_FindAttribute +TextRange_FindText +TextRange_GetAttributeValue +TextRange_GetBoundingRectangles +TextRange_GetChildren +TextRange_GetEnclosingElement +TextRange_GetText +TextRange_Move +TextRange_MoveEndpointByRange +TextRange_MoveEndpointByUnit +TextRange_RemoveFromSelection +TextRange_ScrollIntoView +TextRange_Select +TogglePattern_Toggle +TransformPattern_Move +TransformPattern_Resize +TransformPattern_Rotate +UiaAddEvent +UiaClientsAreListening +UiaDisconnectAllProviders +UiaDisconnectProvider +UiaEventAddWindow +UiaEventRemoveWindow +UiaFind +UiaGetErrorDescription +UiaGetPatternProvider +UiaGetPropertyValue +UiaGetReservedMixedAttributeValue +UiaGetReservedNotSupportedValue +UiaGetRootNode +UiaGetRuntimeId +UiaGetUpdatedCache +UiaHPatternObjectFromVariant +UiaHTextRangeFromVariant +UiaHUiaNodeFromVariant +UiaHasServerSideProvider +UiaHostProviderFromHwnd +UiaIAccessibleFromProvider +UiaLookupId +UiaNavigate +UiaNodeFromFocus +UiaNodeFromHandle +UiaNodeFromPoint +UiaNodeFromProvider +UiaNodeRelease +UiaPatternRelease +UiaProviderForNonClient +UiaProviderFromIAccessible +UiaRaiseActiveTextPositionChangedEvent +UiaRaiseAsyncContentLoadedEvent +UiaRaiseAutomationEvent +UiaRaiseAutomationPropertyChangedEvent +UiaRaiseChangesEvent +UiaRaiseNotificationEvent +UiaRaiseStructureChangedEvent +UiaRaiseTextEditTextChangedEvent +UiaRegisterProviderCallback +UiaRemoveEvent +UiaReturnRawElementProvider +UiaSetFocus +UiaTextRangeRelease +UpdateErrorLoggingCallback +ValuePattern_SetValue +VirtualizedItemPattern_Realize +WindowPattern_Close +WindowPattern_SetWindowVisualState +WindowPattern_WaitForInputIdle diff --git a/platform/windows/uiautomationcore.x86_32.def b/platform/windows/uiautomationcore.x86_32.def new file mode 100644 index 00000000000..fce8c03fb1e --- /dev/null +++ b/platform/windows/uiautomationcore.x86_32.def @@ -0,0 +1,115 @@ +; +; Definition file of UIAutomationCore.DLL +; Automatic generated by gendef +; written by Kai Tietz 2008 +; +LIBRARY "UIAutomationCore.DLL" +EXPORTS +DllGetActivationFactory@8 +DllCanUnloadNow +DllGetClassObject@12 +DockPattern_SetDockPosition@8 +ExpandCollapsePattern_Collapse@4 +ExpandCollapsePattern_Expand@4 +GridPattern_GetItem@16 +IgnoreLeaksInCurrentlyTrackedMemory +InitializeChannelBasedConnectionForProviderProxy@12 +InvokePattern_Invoke@4 +IsIgnoringLeaks +ItemContainerPattern_FindItemByProperty@32 +LegacyIAccessiblePattern_DoDefaultAction@4 +LegacyIAccessiblePattern_GetIAccessible@8 +LegacyIAccessiblePattern_Select@8 +LegacyIAccessiblePattern_SetValue@8 +MultipleViewPattern_GetViewName@12 +MultipleViewPattern_SetCurrentView@8 +PostTestCheckForLeaks@8 +RangeValuePattern_SetValue@12 +ScrollItemPattern_ScrollIntoView@4 +ScrollPattern_Scroll@12 +ScrollPattern_SetScrollPercent@20 +SelectionItemPattern_AddToSelection@4 +SelectionItemPattern_RemoveFromSelection@4 +SelectionItemPattern_Select@4 +StartIgnoringLeaks@4 +StopIgnoringLeaks +SynchronizedInputPattern_Cancel@4 +SynchronizedInputPattern_StartListening@8 +TextPattern_GetSelection@8 +TextPattern_GetVisibleRanges@8 +TextPattern_RangeFromChild@12 +TextPattern_RangeFromPoint@24 +TextPattern_get_DocumentRange@8 +TextPattern_get_SupportedTextSelection@8 +TextRange_AddToSelection@4 +TextRange_Clone@8 +TextRange_Compare@12 +TextRange_CompareEndpoints@20 +TextRange_ExpandToEnclosingUnit@8 +TextRange_FindAttribute@32 +TextRange_FindText@20 +TextRange_GetAttributeValue@12 +TextRange_GetBoundingRectangles@8 +TextRange_GetChildren@8 +TextRange_GetEnclosingElement@8 +TextRange_GetText@12 +TextRange_Move@16 +TextRange_MoveEndpointByRange@16 +TextRange_MoveEndpointByUnit@20 +TextRange_RemoveFromSelection@4 +TextRange_ScrollIntoView@8 +TextRange_Select@4 +TogglePattern_Toggle@4 +TransformPattern_Move@20 +TransformPattern_Resize@20 +TransformPattern_Rotate@12 +UiaAddEvent@32 +UiaClientsAreListening +UiaDisconnectAllProviders +UiaDisconnectProvider@4 +UiaEventAddWindow@8 +UiaEventRemoveWindow@8 +UiaFind@24 +UiaGetErrorDescription@4 +UiaGetPatternProvider@12 +UiaGetPropertyValue@12 +UiaGetReservedMixedAttributeValue@4 +UiaGetReservedNotSupportedValue@4 +UiaGetRootNode@4 +UiaGetRuntimeId@8 +UiaGetUpdatedCache@24 +UiaHPatternObjectFromVariant@8 +UiaHTextRangeFromVariant@8 +UiaHUiaNodeFromVariant@8 +UiaHasServerSideProvider@4 +UiaHostProviderFromHwnd@8 +UiaIAccessibleFromProvider@16 +UiaLookupId@8 +UiaNavigate@24 +UiaNodeFromFocus@12 +UiaNodeFromHandle@8 +UiaNodeFromPoint@28 +UiaNodeFromProvider@8 +UiaNodeRelease@4 +UiaPatternRelease@4 +UiaProviderForNonClient@16 +UiaProviderFromIAccessible@16 +UiaRaiseActiveTextPositionChangedEvent@8 +UiaRaiseAsyncContentLoadedEvent@16 +UiaRaiseAutomationEvent@8 +UiaRaiseAutomationPropertyChangedEvent@40 +UiaRaiseChangesEvent@12 +UiaRaiseNotificationEvent@20 +UiaRaiseStructureChangedEvent@16 +UiaRaiseTextEditTextChangedEvent@12 +UiaRegisterProviderCallback@4 +UiaRemoveEvent@4 +UiaReturnRawElementProvider@16 +UiaSetFocus@4 +UiaTextRangeRelease@4 +UpdateErrorLoggingCallback@4 +ValuePattern_SetValue@8 +VirtualizedItemPattern_Realize@4 +WindowPattern_Close@4 +WindowPattern_SetWindowVisualState@8 +WindowPattern_WaitForInputIdle@12 diff --git a/platform/windows/uiautomationcore.x86_64.def b/platform/windows/uiautomationcore.x86_64.def new file mode 100644 index 00000000000..a83dd7cc7aa --- /dev/null +++ b/platform/windows/uiautomationcore.x86_64.def @@ -0,0 +1,115 @@ +; +; Definition file of UIAutomationCore.DLL +; Automatic generated by gendef +; written by Kai Tietz 2008 +; +LIBRARY "UIAutomationCore.DLL" +EXPORTS +DllGetActivationFactory +DllCanUnloadNow +DllGetClassObject +DockPattern_SetDockPosition +ExpandCollapsePattern_Collapse +ExpandCollapsePattern_Expand +GridPattern_GetItem +IgnoreLeaksInCurrentlyTrackedMemory +InitializeChannelBasedConnectionForProviderProxy +InvokePattern_Invoke +IsIgnoringLeaks +ItemContainerPattern_FindItemByProperty +LegacyIAccessiblePattern_DoDefaultAction +LegacyIAccessiblePattern_GetIAccessible +LegacyIAccessiblePattern_Select +LegacyIAccessiblePattern_SetValue +MultipleViewPattern_GetViewName +MultipleViewPattern_SetCurrentView +PostTestCheckForLeaks +RangeValuePattern_SetValue +ScrollItemPattern_ScrollIntoView +ScrollPattern_Scroll +ScrollPattern_SetScrollPercent +SelectionItemPattern_AddToSelection +SelectionItemPattern_RemoveFromSelection +SelectionItemPattern_Select +StartIgnoringLeaks +StopIgnoringLeaks +SynchronizedInputPattern_Cancel +SynchronizedInputPattern_StartListening +TextPattern_GetSelection +TextPattern_GetVisibleRanges +TextPattern_RangeFromChild +TextPattern_RangeFromPoint +TextPattern_get_DocumentRange +TextPattern_get_SupportedTextSelection +TextRange_AddToSelection +TextRange_Clone +TextRange_Compare +TextRange_CompareEndpoints +TextRange_ExpandToEnclosingUnit +TextRange_FindAttribute +TextRange_FindText +TextRange_GetAttributeValue +TextRange_GetBoundingRectangles +TextRange_GetChildren +TextRange_GetEnclosingElement +TextRange_GetText +TextRange_Move +TextRange_MoveEndpointByRange +TextRange_MoveEndpointByUnit +TextRange_RemoveFromSelection +TextRange_ScrollIntoView +TextRange_Select +TogglePattern_Toggle +TransformPattern_Move +TransformPattern_Resize +TransformPattern_Rotate +UiaAddEvent +UiaClientsAreListening +UiaDisconnectAllProviders +UiaDisconnectProvider +UiaEventAddWindow +UiaEventRemoveWindow +UiaFind +UiaGetErrorDescription +UiaGetPatternProvider +UiaGetPropertyValue +UiaGetReservedMixedAttributeValue +UiaGetReservedNotSupportedValue +UiaGetRootNode +UiaGetRuntimeId +UiaGetUpdatedCache +UiaHPatternObjectFromVariant +UiaHTextRangeFromVariant +UiaHUiaNodeFromVariant +UiaHasServerSideProvider +UiaHostProviderFromHwnd +UiaIAccessibleFromProvider +UiaLookupId +UiaNavigate +UiaNodeFromFocus +UiaNodeFromHandle +UiaNodeFromPoint +UiaNodeFromProvider +UiaNodeRelease +UiaPatternRelease +UiaProviderForNonClient +UiaProviderFromIAccessible +UiaRaiseActiveTextPositionChangedEvent +UiaRaiseAsyncContentLoadedEvent +UiaRaiseAutomationEvent +UiaRaiseAutomationPropertyChangedEvent +UiaRaiseChangesEvent +UiaRaiseNotificationEvent +UiaRaiseStructureChangedEvent +UiaRaiseTextEditTextChangedEvent +UiaRegisterProviderCallback +UiaRemoveEvent +UiaReturnRawElementProvider +UiaSetFocus +UiaTextRangeRelease +UpdateErrorLoggingCallback +ValuePattern_SetValue +VirtualizedItemPattern_Realize +WindowPattern_Close +WindowPattern_SetWindowVisualState +WindowPattern_WaitForInputIdle diff --git a/thirdparty/README.md b/thirdparty/README.md index 9591ea294ab..e10293134e2 100644 --- a/thirdparty/README.md +++ b/thirdparty/README.md @@ -5,6 +5,18 @@ respective folder names. Use two empty lines to separate categories for readability. +## accesskit + +- Upstream: https://github.com/AccessKit/accesskit-c +- Version: 0.15.1 (0d1da94a33708041b07c61eb702c67cfa3a5f95b, 2025) +- License: MIT + +Files extracted from upstream source: + +- `accesskit.h` +- `LICENSE-MIT` + + ## amd-fsr - Upstream: https://github.com/GPUOpen-Effects/FidelityFX-FSR diff --git a/thirdparty/accesskit/LICENSE-MIT b/thirdparty/accesskit/LICENSE-MIT new file mode 100644 index 00000000000..31aa79387f2 --- /dev/null +++ b/thirdparty/accesskit/LICENSE-MIT @@ -0,0 +1,23 @@ +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/thirdparty/accesskit/include/accesskit.h b/thirdparty/accesskit/include/accesskit.h new file mode 100644 index 00000000000..5b2499a808a --- /dev/null +++ b/thirdparty/accesskit/include/accesskit.h @@ -0,0 +1,2352 @@ +/** + * Copyright 2023 The AccessKit Authors. All rights reserved. + * Licensed under the Apache License, Version 2.0 (found in + * the LICENSE-APACHE file) or the MIT license (found in + * the LICENSE-MIT file), at your option. + */ + +#ifndef ACCESSKIT_H +#define ACCESSKIT_H + +#include +#include +#include +#include +#include +#ifdef _WIN32 +#include +#endif + +/** + * An action to be taken on an accessibility node. + */ +enum accesskit_action +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + /** + * Do the equivalent of a single click or tap. + */ + ACCESSKIT_ACTION_CLICK, + ACCESSKIT_ACTION_FOCUS, + ACCESSKIT_ACTION_BLUR, + ACCESSKIT_ACTION_COLLAPSE, + ACCESSKIT_ACTION_EXPAND, + /** + * Requires [`ActionRequest::data`] to be set to [`ActionData::CustomAction`]. + */ + ACCESSKIT_ACTION_CUSTOM_ACTION, + /** + * Decrement a numeric value by one step. + */ + ACCESSKIT_ACTION_DECREMENT, + /** + * Increment a numeric value by one step. + */ + ACCESSKIT_ACTION_INCREMENT, + ACCESSKIT_ACTION_HIDE_TOOLTIP, + ACCESSKIT_ACTION_SHOW_TOOLTIP, + /** + * Delete any selected text in the control's text value and + * insert the specified value in its place, like when typing or pasting. + * Requires [`ActionRequest::data`] to be set to [`ActionData::Value`]. + */ + ACCESSKIT_ACTION_REPLACE_SELECTED_TEXT, + ACCESSKIT_ACTION_SCROLL_BACKWARD, + ACCESSKIT_ACTION_SCROLL_DOWN, + ACCESSKIT_ACTION_SCROLL_FORWARD, + ACCESSKIT_ACTION_SCROLL_LEFT, + ACCESSKIT_ACTION_SCROLL_RIGHT, + ACCESSKIT_ACTION_SCROLL_UP, + /** + * Scroll any scrollable containers to make the target object visible + * on the screen. Optionally set [`ActionRequest::data`] to + * [`ActionData::ScrollTargetRect`]. + */ + ACCESSKIT_ACTION_SCROLL_INTO_VIEW, + /** + * Scroll the given object to a specified point in the tree's container + * (e.g. window). Requires [`ActionRequest::data`] to be set to + * [`ActionData::ScrollToPoint`]. + */ + ACCESSKIT_ACTION_SCROLL_TO_POINT, + /** + * Requires [`ActionRequest::data`] to be set to + * [`ActionData::SetScrollOffset`]. + */ + ACCESSKIT_ACTION_SET_SCROLL_OFFSET, + /** + * Requires [`ActionRequest::data`] to be set to + * [`ActionData::SetTextSelection`]. + */ + ACCESSKIT_ACTION_SET_TEXT_SELECTION, + /** + * Don't focus this node, but set it as the sequential focus navigation + * starting point, so that pressing Tab moves to the next element + * following this one, for example. + */ + ACCESSKIT_ACTION_SET_SEQUENTIAL_FOCUS_NAVIGATION_STARTING_POINT, + /** + * Replace the value of the control with the specified value and + * reset the selection, if applicable. Requires [`ActionRequest::data`] + * to be set to [`ActionData::Value`] or [`ActionData::NumericValue`]. + */ + ACCESSKIT_ACTION_SET_VALUE, + ACCESSKIT_ACTION_SHOW_CONTEXT_MENU, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_action; +#endif // __cplusplus + +enum accesskit_aria_current +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_ARIA_CURRENT_FALSE, + ACCESSKIT_ARIA_CURRENT_TRUE, + ACCESSKIT_ARIA_CURRENT_PAGE, + ACCESSKIT_ARIA_CURRENT_STEP, + ACCESSKIT_ARIA_CURRENT_LOCATION, + ACCESSKIT_ARIA_CURRENT_DATE, + ACCESSKIT_ARIA_CURRENT_TIME, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_aria_current; +#endif // __cplusplus + +enum accesskit_auto_complete +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_AUTO_COMPLETE_INLINE, + ACCESSKIT_AUTO_COMPLETE_LIST, + ACCESSKIT_AUTO_COMPLETE_BOTH, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_auto_complete; +#endif // __cplusplus + +enum accesskit_has_popup +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_HAS_POPUP_TRUE, + ACCESSKIT_HAS_POPUP_MENU, + ACCESSKIT_HAS_POPUP_LISTBOX, + ACCESSKIT_HAS_POPUP_TREE, + ACCESSKIT_HAS_POPUP_GRID, + ACCESSKIT_HAS_POPUP_DIALOG, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_has_popup; +#endif // __cplusplus + +/** + * Indicates if a form control has invalid input or if a web DOM element has an + * [`aria-invalid`] attribute. + * + * [`aria-invalid`]: https://www.w3.org/TR/wai-aria-1.1/#aria-invalid + */ +enum accesskit_invalid +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_INVALID_TRUE, + ACCESSKIT_INVALID_GRAMMAR, + ACCESSKIT_INVALID_SPELLING, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_invalid; +#endif // __cplusplus + +enum accesskit_list_style +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_LIST_STYLE_CIRCLE, + ACCESSKIT_LIST_STYLE_DISC, + ACCESSKIT_LIST_STYLE_IMAGE, + ACCESSKIT_LIST_STYLE_NUMERIC, + ACCESSKIT_LIST_STYLE_SQUARE, + /** + * Language specific ordering (alpha, roman, cjk-ideographic, etc...) + */ + ACCESSKIT_LIST_STYLE_OTHER, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_list_style; +#endif // __cplusplus + +enum accesskit_live +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_LIVE_OFF, + ACCESSKIT_LIVE_POLITE, + ACCESSKIT_LIVE_ASSERTIVE, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_live; +#endif // __cplusplus + +enum accesskit_orientation +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + /** + * E.g. most toolbars and separators. + */ + ACCESSKIT_ORIENTATION_HORIZONTAL, + /** + * E.g. menu or combo box. + */ + ACCESSKIT_ORIENTATION_VERTICAL, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_orientation; +#endif // __cplusplus + +/** + * The type of an accessibility node. + * + * The majority of these roles come from the ARIA specification. Reference + * the latest draft for proper usage. + * + * Like the AccessKit schema as a whole, this list is largely taken + * from Chromium. However, unlike Chromium's alphabetized list, this list + * is ordered roughly by expected usage frequency (with the notable exception + * of [`Role::Unknown`]). This is more efficient in serialization formats + * where integers use a variable-length encoding. + */ +enum accesskit_role +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_ROLE_UNKNOWN, + ACCESSKIT_ROLE_TEXT_RUN, + ACCESSKIT_ROLE_CELL, + ACCESSKIT_ROLE_LABEL, + ACCESSKIT_ROLE_IMAGE, + ACCESSKIT_ROLE_LINK, + ACCESSKIT_ROLE_ROW, + ACCESSKIT_ROLE_LIST_ITEM, + /** + * Contains the bullet, number, or other marker for a list item. + */ + ACCESSKIT_ROLE_LIST_MARKER, + ACCESSKIT_ROLE_TREE_ITEM, + ACCESSKIT_ROLE_LIST_BOX_OPTION, + ACCESSKIT_ROLE_MENU_ITEM, + ACCESSKIT_ROLE_MENU_LIST_OPTION, + ACCESSKIT_ROLE_PARAGRAPH, + /** + * A generic container that should be ignored by assistive technologies + * and filtered out of platform accessibility trees. Equivalent to the ARIA + * `none` or `presentation` role, or to an HTML `div` with no role. + */ + ACCESSKIT_ROLE_GENERIC_CONTAINER, + ACCESSKIT_ROLE_CHECK_BOX, + ACCESSKIT_ROLE_RADIO_BUTTON, + ACCESSKIT_ROLE_TEXT_INPUT, + ACCESSKIT_ROLE_BUTTON, + ACCESSKIT_ROLE_DEFAULT_BUTTON, + ACCESSKIT_ROLE_PANE, + ACCESSKIT_ROLE_ROW_HEADER, + ACCESSKIT_ROLE_COLUMN_HEADER, + ACCESSKIT_ROLE_ROW_GROUP, + ACCESSKIT_ROLE_LIST, + ACCESSKIT_ROLE_TABLE, + ACCESSKIT_ROLE_LAYOUT_TABLE_CELL, + ACCESSKIT_ROLE_LAYOUT_TABLE_ROW, + ACCESSKIT_ROLE_LAYOUT_TABLE, + ACCESSKIT_ROLE_SWITCH, + ACCESSKIT_ROLE_MENU, + ACCESSKIT_ROLE_MULTILINE_TEXT_INPUT, + ACCESSKIT_ROLE_SEARCH_INPUT, + ACCESSKIT_ROLE_DATE_INPUT, + ACCESSKIT_ROLE_DATE_TIME_INPUT, + ACCESSKIT_ROLE_WEEK_INPUT, + ACCESSKIT_ROLE_MONTH_INPUT, + ACCESSKIT_ROLE_TIME_INPUT, + ACCESSKIT_ROLE_EMAIL_INPUT, + ACCESSKIT_ROLE_NUMBER_INPUT, + ACCESSKIT_ROLE_PASSWORD_INPUT, + ACCESSKIT_ROLE_PHONE_NUMBER_INPUT, + ACCESSKIT_ROLE_URL_INPUT, + ACCESSKIT_ROLE_ABBR, + ACCESSKIT_ROLE_ALERT, + ACCESSKIT_ROLE_ALERT_DIALOG, + ACCESSKIT_ROLE_APPLICATION, + ACCESSKIT_ROLE_ARTICLE, + ACCESSKIT_ROLE_AUDIO, + ACCESSKIT_ROLE_BANNER, + ACCESSKIT_ROLE_BLOCKQUOTE, + ACCESSKIT_ROLE_CANVAS, + ACCESSKIT_ROLE_CAPTION, + ACCESSKIT_ROLE_CARET, + ACCESSKIT_ROLE_CODE, + ACCESSKIT_ROLE_COLOR_WELL, + ACCESSKIT_ROLE_COMBO_BOX, + ACCESSKIT_ROLE_EDITABLE_COMBO_BOX, + ACCESSKIT_ROLE_COMPLEMENTARY, + ACCESSKIT_ROLE_COMMENT, + ACCESSKIT_ROLE_CONTENT_DELETION, + ACCESSKIT_ROLE_CONTENT_INSERTION, + ACCESSKIT_ROLE_CONTENT_INFO, + ACCESSKIT_ROLE_DEFINITION, + ACCESSKIT_ROLE_DESCRIPTION_LIST, + ACCESSKIT_ROLE_DESCRIPTION_LIST_DETAIL, + ACCESSKIT_ROLE_DESCRIPTION_LIST_TERM, + ACCESSKIT_ROLE_DETAILS, + ACCESSKIT_ROLE_DIALOG, + ACCESSKIT_ROLE_DIRECTORY, + ACCESSKIT_ROLE_DISCLOSURE_TRIANGLE, + ACCESSKIT_ROLE_DOCUMENT, + ACCESSKIT_ROLE_EMBEDDED_OBJECT, + ACCESSKIT_ROLE_EMPHASIS, + ACCESSKIT_ROLE_FEED, + ACCESSKIT_ROLE_FIGURE_CAPTION, + ACCESSKIT_ROLE_FIGURE, + ACCESSKIT_ROLE_FOOTER, + ACCESSKIT_ROLE_FOOTER_AS_NON_LANDMARK, + ACCESSKIT_ROLE_FORM, + ACCESSKIT_ROLE_GRID, + ACCESSKIT_ROLE_GROUP, + ACCESSKIT_ROLE_HEADER, + ACCESSKIT_ROLE_HEADER_AS_NON_LANDMARK, + ACCESSKIT_ROLE_HEADING, + ACCESSKIT_ROLE_IFRAME, + ACCESSKIT_ROLE_IFRAME_PRESENTATIONAL, + ACCESSKIT_ROLE_IME_CANDIDATE, + ACCESSKIT_ROLE_KEYBOARD, + ACCESSKIT_ROLE_LEGEND, + ACCESSKIT_ROLE_LINE_BREAK, + ACCESSKIT_ROLE_LIST_BOX, + ACCESSKIT_ROLE_LOG, + ACCESSKIT_ROLE_MAIN, + ACCESSKIT_ROLE_MARK, + ACCESSKIT_ROLE_MARQUEE, + ACCESSKIT_ROLE_MATH, + ACCESSKIT_ROLE_MENU_BAR, + ACCESSKIT_ROLE_MENU_ITEM_CHECK_BOX, + ACCESSKIT_ROLE_MENU_ITEM_RADIO, + ACCESSKIT_ROLE_MENU_LIST_POPUP, + ACCESSKIT_ROLE_METER, + ACCESSKIT_ROLE_NAVIGATION, + ACCESSKIT_ROLE_NOTE, + ACCESSKIT_ROLE_PLUGIN_OBJECT, + ACCESSKIT_ROLE_PORTAL, + ACCESSKIT_ROLE_PRE, + ACCESSKIT_ROLE_PROGRESS_INDICATOR, + ACCESSKIT_ROLE_RADIO_GROUP, + ACCESSKIT_ROLE_REGION, + ACCESSKIT_ROLE_ROOT_WEB_AREA, + ACCESSKIT_ROLE_RUBY, + ACCESSKIT_ROLE_RUBY_ANNOTATION, + ACCESSKIT_ROLE_SCROLL_BAR, + ACCESSKIT_ROLE_SCROLL_VIEW, + ACCESSKIT_ROLE_SEARCH, + ACCESSKIT_ROLE_SECTION, + ACCESSKIT_ROLE_SLIDER, + ACCESSKIT_ROLE_SPIN_BUTTON, + ACCESSKIT_ROLE_SPLITTER, + ACCESSKIT_ROLE_STATUS, + ACCESSKIT_ROLE_STRONG, + ACCESSKIT_ROLE_SUGGESTION, + ACCESSKIT_ROLE_SVG_ROOT, + ACCESSKIT_ROLE_TAB, + ACCESSKIT_ROLE_TAB_LIST, + ACCESSKIT_ROLE_TAB_PANEL, + ACCESSKIT_ROLE_TERM, + ACCESSKIT_ROLE_TIME, + ACCESSKIT_ROLE_TIMER, + ACCESSKIT_ROLE_TITLE_BAR, + ACCESSKIT_ROLE_TOOLBAR, + ACCESSKIT_ROLE_TOOLTIP, + ACCESSKIT_ROLE_TREE, + ACCESSKIT_ROLE_TREE_GRID, + ACCESSKIT_ROLE_VIDEO, + ACCESSKIT_ROLE_WEB_VIEW, + ACCESSKIT_ROLE_WINDOW, + ACCESSKIT_ROLE_PDF_ACTIONABLE_HIGHLIGHT, + ACCESSKIT_ROLE_PDF_ROOT, + ACCESSKIT_ROLE_GRAPHICS_DOCUMENT, + ACCESSKIT_ROLE_GRAPHICS_OBJECT, + ACCESSKIT_ROLE_GRAPHICS_SYMBOL, + ACCESSKIT_ROLE_DOC_ABSTRACT, + ACCESSKIT_ROLE_DOC_ACKNOWLEDGEMENTS, + ACCESSKIT_ROLE_DOC_AFTERWORD, + ACCESSKIT_ROLE_DOC_APPENDIX, + ACCESSKIT_ROLE_DOC_BACK_LINK, + ACCESSKIT_ROLE_DOC_BIBLIO_ENTRY, + ACCESSKIT_ROLE_DOC_BIBLIOGRAPHY, + ACCESSKIT_ROLE_DOC_BIBLIO_REF, + ACCESSKIT_ROLE_DOC_CHAPTER, + ACCESSKIT_ROLE_DOC_COLOPHON, + ACCESSKIT_ROLE_DOC_CONCLUSION, + ACCESSKIT_ROLE_DOC_COVER, + ACCESSKIT_ROLE_DOC_CREDIT, + ACCESSKIT_ROLE_DOC_CREDITS, + ACCESSKIT_ROLE_DOC_DEDICATION, + ACCESSKIT_ROLE_DOC_ENDNOTE, + ACCESSKIT_ROLE_DOC_ENDNOTES, + ACCESSKIT_ROLE_DOC_EPIGRAPH, + ACCESSKIT_ROLE_DOC_EPILOGUE, + ACCESSKIT_ROLE_DOC_ERRATA, + ACCESSKIT_ROLE_DOC_EXAMPLE, + ACCESSKIT_ROLE_DOC_FOOTNOTE, + ACCESSKIT_ROLE_DOC_FOREWORD, + ACCESSKIT_ROLE_DOC_GLOSSARY, + ACCESSKIT_ROLE_DOC_GLOSS_REF, + ACCESSKIT_ROLE_DOC_INDEX, + ACCESSKIT_ROLE_DOC_INTRODUCTION, + ACCESSKIT_ROLE_DOC_NOTE_REF, + ACCESSKIT_ROLE_DOC_NOTICE, + ACCESSKIT_ROLE_DOC_PAGE_BREAK, + ACCESSKIT_ROLE_DOC_PAGE_FOOTER, + ACCESSKIT_ROLE_DOC_PAGE_HEADER, + ACCESSKIT_ROLE_DOC_PAGE_LIST, + ACCESSKIT_ROLE_DOC_PART, + ACCESSKIT_ROLE_DOC_PREFACE, + ACCESSKIT_ROLE_DOC_PROLOGUE, + ACCESSKIT_ROLE_DOC_PULLQUOTE, + ACCESSKIT_ROLE_DOC_QNA, + ACCESSKIT_ROLE_DOC_SUBTITLE, + ACCESSKIT_ROLE_DOC_TIP, + ACCESSKIT_ROLE_DOC_TOC, + /** + * Behaves similar to an ARIA grid but is primarily used by Chromium's + * `TableView` and its subclasses, so they can be exposed correctly + * on certain platforms. + */ + ACCESSKIT_ROLE_LIST_GRID, + /** + * This is just like a multi-line document, but signals that assistive + * technologies should implement behavior specific to a VT-100-style + * terminal. + */ + ACCESSKIT_ROLE_TERMINAL, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_role; +#endif // __cplusplus + +enum accesskit_sort_direction +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_SORT_DIRECTION_ASCENDING, + ACCESSKIT_SORT_DIRECTION_DESCENDING, + ACCESSKIT_SORT_DIRECTION_OTHER, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_sort_direction; +#endif // __cplusplus + +enum accesskit_text_align +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_TEXT_ALIGN_LEFT, + ACCESSKIT_TEXT_ALIGN_RIGHT, + ACCESSKIT_TEXT_ALIGN_CENTER, + ACCESSKIT_TEXT_ALIGN_JUSTIFY, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_text_align; +#endif // __cplusplus + +enum accesskit_text_decoration +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_TEXT_DECORATION_SOLID, + ACCESSKIT_TEXT_DECORATION_DOTTED, + ACCESSKIT_TEXT_DECORATION_DASHED, + ACCESSKIT_TEXT_DECORATION_DOUBLE, + ACCESSKIT_TEXT_DECORATION_WAVY, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_text_decoration; +#endif // __cplusplus + +enum accesskit_text_direction +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_TEXT_DIRECTION_LEFT_TO_RIGHT, + ACCESSKIT_TEXT_DIRECTION_RIGHT_TO_LEFT, + ACCESSKIT_TEXT_DIRECTION_TOP_TO_BOTTOM, + ACCESSKIT_TEXT_DIRECTION_BOTTOM_TO_TOP, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_text_direction; +#endif // __cplusplus + +enum accesskit_toggled +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_TOGGLED_FALSE, + ACCESSKIT_TOGGLED_TRUE, + ACCESSKIT_TOGGLED_MIXED, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_toggled; +#endif // __cplusplus + +enum accesskit_vertical_offset +#ifdef __cplusplus + : uint8_t +#endif // __cplusplus +{ + ACCESSKIT_VERTICAL_OFFSET_SUBSCRIPT, + ACCESSKIT_VERTICAL_OFFSET_SUPERSCRIPT, +}; +#ifndef __cplusplus +typedef uint8_t accesskit_vertical_offset; +#endif // __cplusplus + +#if defined(__APPLE__) +typedef struct accesskit_macos_adapter accesskit_macos_adapter; +#endif + +#if defined(__APPLE__) +typedef struct accesskit_macos_queued_events accesskit_macos_queued_events; +#endif + +#if defined(__APPLE__) +typedef struct accesskit_macos_subclassing_adapter + accesskit_macos_subclassing_adapter; +#endif + +typedef struct accesskit_node accesskit_node; + +typedef struct accesskit_tree accesskit_tree; + +typedef struct accesskit_tree_update accesskit_tree_update; + +#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ + defined(__NetBSD__) || defined(__OpenBSD__)) +typedef struct accesskit_unix_adapter accesskit_unix_adapter; +#endif + +#if defined(_WIN32) +typedef struct accesskit_windows_adapter accesskit_windows_adapter; +#endif + +#if defined(_WIN32) +typedef struct accesskit_windows_queued_events accesskit_windows_queued_events; +#endif + +#if defined(_WIN32) +typedef struct accesskit_windows_subclassing_adapter + accesskit_windows_subclassing_adapter; +#endif + +typedef uint64_t accesskit_node_id; + +typedef struct accesskit_node_ids { + size_t length; + const accesskit_node_id *values; +} accesskit_node_ids; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_node_id { + bool has_value; + accesskit_node_id value; +} accesskit_opt_node_id; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_double { + bool has_value; + double value; +} accesskit_opt_double; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_index { + bool has_value; + size_t value; +} accesskit_opt_index; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_color { + bool has_value; + uint32_t value; +} accesskit_opt_color; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_text_decoration { + bool has_value; + accesskit_text_decoration value; +} accesskit_opt_text_decoration; + +typedef struct accesskit_lengths { + size_t length; + const uint8_t *values; +} accesskit_lengths; + +typedef struct accesskit_opt_coords { + bool has_value; + size_t length; + const float *values; +} accesskit_opt_coords; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_bool { + bool has_value; + bool value; +} accesskit_opt_bool; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_invalid { + bool has_value; + accesskit_invalid value; +} accesskit_opt_invalid; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_toggled { + bool has_value; + accesskit_toggled value; +} accesskit_opt_toggled; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_live { + bool has_value; + accesskit_live value; +} accesskit_opt_live; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_text_direction { + bool has_value; + accesskit_text_direction value; +} accesskit_opt_text_direction; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_orientation { + bool has_value; + accesskit_orientation value; +} accesskit_opt_orientation; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_sort_direction { + bool has_value; + accesskit_sort_direction value; +} accesskit_opt_sort_direction; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_aria_current { + bool has_value; + accesskit_aria_current value; +} accesskit_opt_aria_current; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_auto_complete { + bool has_value; + accesskit_auto_complete value; +} accesskit_opt_auto_complete; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_has_popup { + bool has_value; + accesskit_has_popup value; +} accesskit_opt_has_popup; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_list_style { + bool has_value; + accesskit_list_style value; +} accesskit_opt_list_style; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_text_align { + bool has_value; + accesskit_text_align value; +} accesskit_opt_text_align; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_vertical_offset { + bool has_value; + accesskit_vertical_offset value; +} accesskit_opt_vertical_offset; + +/** + * A 2D affine transform. Derived from + * [kurbo](https://github.com/linebender/kurbo). + */ +typedef struct accesskit_affine { + double _0[6]; +} accesskit_affine; + +/** + * A rectangle. Derived from [kurbo](https://github.com/linebender/kurbo). + */ +typedef struct accesskit_rect { + /** + * The minimum x coordinate (left edge). + */ + double x0; + /** + * The minimum y coordinate (top edge in y-down spaces). + */ + double y0; + /** + * The maximum x coordinate (right edge). + */ + double x1; + /** + * The maximum y coordinate (bottom edge in y-down spaces). + */ + double y1; +} accesskit_rect; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_rect { + bool has_value; + struct accesskit_rect value; +} accesskit_opt_rect; + +typedef struct accesskit_text_position { + accesskit_node_id node; + size_t character_index; +} accesskit_text_position; + +typedef struct accesskit_text_selection { + struct accesskit_text_position anchor; + struct accesskit_text_position focus; +} accesskit_text_selection; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_text_selection { + bool has_value; + struct accesskit_text_selection value; +} accesskit_opt_text_selection; + +/** + * Use `accesskit_custom_action_new` to create this struct. Do not reallocate + * `description`. + * + * When you get this struct, you are responsible for freeing `description`. + */ +typedef struct accesskit_custom_action { + int32_t id; + char *description; +} accesskit_custom_action; + +typedef struct accesskit_custom_actions { + size_t length; + struct accesskit_custom_action *values; +} accesskit_custom_actions; + +/** + * A 2D point. Derived from [kurbo](https://github.com/linebender/kurbo). + */ +typedef struct accesskit_point { + /** + * The x coordinate. + */ + double x; + /** + * The y coordinate. + */ + double y; +} accesskit_point; + +typedef enum accesskit_action_data_Tag { + ACCESSKIT_ACTION_DATA_CUSTOM_ACTION, + ACCESSKIT_ACTION_DATA_VALUE, + ACCESSKIT_ACTION_DATA_NUMERIC_VALUE, + ACCESSKIT_ACTION_DATA_SCROLL_TARGET_RECT, + ACCESSKIT_ACTION_DATA_SCROLL_TO_POINT, + ACCESSKIT_ACTION_DATA_SET_SCROLL_OFFSET, + ACCESSKIT_ACTION_DATA_SET_TEXT_SELECTION, +} accesskit_action_data_Tag; + +typedef struct accesskit_action_data { + accesskit_action_data_Tag tag; + union { + struct { + int32_t custom_action; + }; + struct { + char *value; + }; + struct { + double numeric_value; + }; + struct { + struct accesskit_rect scroll_target_rect; + }; + struct { + struct accesskit_point scroll_to_point; + }; + struct { + struct accesskit_point set_scroll_offset; + }; + struct { + struct accesskit_text_selection set_text_selection; + }; + }; +} accesskit_action_data; + +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_action_data { + bool has_value; + struct accesskit_action_data value; +} accesskit_opt_action_data; + +typedef struct accesskit_action_request { + accesskit_action action; + accesskit_node_id target; + struct accesskit_opt_action_data data; +} accesskit_action_request; + +/** + * A 2D vector. Derived from [kurbo](https://github.com/linebender/kurbo). + * + * This is intended primarily for a vector in the mathematical sense, + * but it can be interpreted as a translation, and converted to and + * from a point (vector relative to the origin) and size. + */ +typedef struct accesskit_vec2 { + /** + * The x-coordinate. + */ + double x; + /** + * The y-coordinate. + */ + double y; +} accesskit_vec2; + +/** + * A 2D size. Derived from [kurbo](https://github.com/linebender/kurbo). + */ +typedef struct accesskit_size { + /** + * The width. + */ + double width; + /** + * The height. + */ + double height; +} accesskit_size; + +/** + * Ownership of `request` is transferred to the callback. `request` must + * be freed using `accesskit_action_request_free`. + */ +typedef void (*accesskit_action_handler_callback)( + struct accesskit_action_request *request, void *userdata); + +typedef void *accesskit_tree_update_factory_userdata; + +/** + * This function can't return a null pointer. Ownership of the returned value + * will be transferred to the caller. + */ +typedef struct accesskit_tree_update *(*accesskit_tree_update_factory)( + accesskit_tree_update_factory_userdata); + +typedef struct accesskit_tree_update *(*accesskit_activation_handler_callback)( + void *userdata); + +typedef void (*accesskit_deactivation_handler_callback)(void *userdata); + +#if defined(_WIN32) +/** + * Represents an optional value. + * + * If `has_value` is false, do not read the `value` field. + */ +typedef struct accesskit_opt_lresult { + bool has_value; + LRESULT value; +} accesskit_opt_lresult; +#endif + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +accesskit_role accesskit_node_role(const struct accesskit_node *node); + +void accesskit_node_set_role(struct accesskit_node *node, accesskit_role value); + +bool accesskit_node_supports_action(const struct accesskit_node *node, + accesskit_action action); + +void accesskit_node_add_action(struct accesskit_node *node, + accesskit_action action); + +void accesskit_node_remove_action(struct accesskit_node *node, + accesskit_action action); + +void accesskit_node_clear_actions(struct accesskit_node *node); + +bool accesskit_node_is_hidden(const struct accesskit_node *node); + +void accesskit_node_set_hidden(struct accesskit_node *node); + +void accesskit_node_clear_hidden(struct accesskit_node *node); + +bool accesskit_node_is_linked(const struct accesskit_node *node); + +void accesskit_node_set_linked(struct accesskit_node *node); + +void accesskit_node_clear_linked(struct accesskit_node *node); + +bool accesskit_node_is_multiselectable(const struct accesskit_node *node); + +void accesskit_node_set_multiselectable(struct accesskit_node *node); + +void accesskit_node_clear_multiselectable(struct accesskit_node *node); + +bool accesskit_node_is_required(const struct accesskit_node *node); + +void accesskit_node_set_required(struct accesskit_node *node); + +void accesskit_node_clear_required(struct accesskit_node *node); + +bool accesskit_node_is_visited(const struct accesskit_node *node); + +void accesskit_node_set_visited(struct accesskit_node *node); + +void accesskit_node_clear_visited(struct accesskit_node *node); + +bool accesskit_node_is_busy(const struct accesskit_node *node); + +void accesskit_node_set_busy(struct accesskit_node *node); + +void accesskit_node_clear_busy(struct accesskit_node *node); + +bool accesskit_node_is_live_atomic(const struct accesskit_node *node); + +void accesskit_node_set_live_atomic(struct accesskit_node *node); + +void accesskit_node_clear_live_atomic(struct accesskit_node *node); + +bool accesskit_node_is_modal(const struct accesskit_node *node); + +void accesskit_node_set_modal(struct accesskit_node *node); + +void accesskit_node_clear_modal(struct accesskit_node *node); + +bool accesskit_node_is_touch_transparent(const struct accesskit_node *node); + +void accesskit_node_set_touch_transparent(struct accesskit_node *node); + +void accesskit_node_clear_touch_transparent(struct accesskit_node *node); + +bool accesskit_node_is_read_only(const struct accesskit_node *node); + +void accesskit_node_set_read_only(struct accesskit_node *node); + +void accesskit_node_clear_read_only(struct accesskit_node *node); + +bool accesskit_node_is_disabled(const struct accesskit_node *node); + +void accesskit_node_set_disabled(struct accesskit_node *node); + +void accesskit_node_clear_disabled(struct accesskit_node *node); + +bool accesskit_node_is_bold(const struct accesskit_node *node); + +void accesskit_node_set_bold(struct accesskit_node *node); + +void accesskit_node_clear_bold(struct accesskit_node *node); + +bool accesskit_node_is_italic(const struct accesskit_node *node); + +void accesskit_node_set_italic(struct accesskit_node *node); + +void accesskit_node_clear_italic(struct accesskit_node *node); + +bool accesskit_node_clips_children(const struct accesskit_node *node); + +void accesskit_node_set_clips_children(struct accesskit_node *node); + +void accesskit_node_clear_clips_children(struct accesskit_node *node); + +bool accesskit_node_is_line_breaking_object(const struct accesskit_node *node); + +void accesskit_node_set_is_line_breaking_object(struct accesskit_node *node); + +void accesskit_node_clear_is_line_breaking_object(struct accesskit_node *node); + +bool accesskit_node_is_page_breaking_object(const struct accesskit_node *node); + +void accesskit_node_set_is_page_breaking_object(struct accesskit_node *node); + +void accesskit_node_clear_is_page_breaking_object(struct accesskit_node *node); + +bool accesskit_node_is_spelling_error(const struct accesskit_node *node); + +void accesskit_node_set_is_spelling_error(struct accesskit_node *node); + +void accesskit_node_clear_is_spelling_error(struct accesskit_node *node); + +bool accesskit_node_is_grammar_error(const struct accesskit_node *node); + +void accesskit_node_set_is_grammar_error(struct accesskit_node *node); + +void accesskit_node_clear_is_grammar_error(struct accesskit_node *node); + +bool accesskit_node_is_search_match(const struct accesskit_node *node); + +void accesskit_node_set_is_search_match(struct accesskit_node *node); + +void accesskit_node_clear_is_search_match(struct accesskit_node *node); + +bool accesskit_node_is_suggestion(const struct accesskit_node *node); + +void accesskit_node_set_is_suggestion(struct accesskit_node *node); + +void accesskit_node_clear_is_suggestion(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_children( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_children(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_child(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_children(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_controls( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_controls(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_controlled(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_controls(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_details( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_details(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_detail(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_details(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_described_by( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_described_by(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_described_by(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_described_by(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_flow_to( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_flow_to(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_flow_to(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_flow_to(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_labelled_by( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_labelled_by(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_labelled_by(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_labelled_by(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_owns( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_owns(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_owned(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_owns(struct accesskit_node *node); + +struct accesskit_node_ids accesskit_node_radio_group( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_radio_group(struct accesskit_node *node, size_t length, + const accesskit_node_id *values); + +void accesskit_node_push_to_radio_group(struct accesskit_node *node, + accesskit_node_id item); + +void accesskit_node_clear_radio_group(struct accesskit_node *node); + +struct accesskit_opt_node_id accesskit_node_active_descendant( + const struct accesskit_node *node); + +void accesskit_node_set_active_descendant(struct accesskit_node *node, + accesskit_node_id value); + +void accesskit_node_clear_active_descendant(struct accesskit_node *node); + +struct accesskit_opt_node_id accesskit_node_error_message( + const struct accesskit_node *node); + +void accesskit_node_set_error_message(struct accesskit_node *node, + accesskit_node_id value); + +void accesskit_node_clear_error_message(struct accesskit_node *node); + +struct accesskit_opt_node_id accesskit_node_in_page_link_target( + const struct accesskit_node *node); + +void accesskit_node_set_in_page_link_target(struct accesskit_node *node, + accesskit_node_id value); + +void accesskit_node_clear_in_page_link_target(struct accesskit_node *node); + +struct accesskit_opt_node_id accesskit_node_member_of( + const struct accesskit_node *node); + +void accesskit_node_set_member_of(struct accesskit_node *node, + accesskit_node_id value); + +void accesskit_node_clear_member_of(struct accesskit_node *node); + +struct accesskit_opt_node_id accesskit_node_next_on_line( + const struct accesskit_node *node); + +void accesskit_node_set_next_on_line(struct accesskit_node *node, + accesskit_node_id value); + +void accesskit_node_clear_next_on_line(struct accesskit_node *node); + +struct accesskit_opt_node_id accesskit_node_previous_on_line( + const struct accesskit_node *node); + +void accesskit_node_set_previous_on_line(struct accesskit_node *node, + accesskit_node_id value); + +void accesskit_node_clear_previous_on_line(struct accesskit_node *node); + +struct accesskit_opt_node_id accesskit_node_popup_for( + const struct accesskit_node *node); + +void accesskit_node_set_popup_for(struct accesskit_node *node, + accesskit_node_id value); + +void accesskit_node_clear_popup_for(struct accesskit_node *node); + +/** + * Only call this function with a string that originated from AccessKit. + */ +void accesskit_string_free(char *string); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_label(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_label(struct accesskit_node *node, const char *value); + +void accesskit_node_clear_label(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_description(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_description(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_description(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_value(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_value(struct accesskit_node *node, const char *value); + +void accesskit_node_clear_value(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_access_key(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_access_key(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_access_key(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_author_id(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_author_id(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_author_id(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_class_name(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_class_name(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_class_name(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_font_family(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_font_family(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_font_family(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_html_tag(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_html_tag(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_html_tag(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_inner_html(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_inner_html(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_inner_html(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_keyboard_shortcut(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_keyboard_shortcut(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_keyboard_shortcut(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_language(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_language(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_language(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_placeholder(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_placeholder(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_placeholder(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_role_description(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_role_description(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_role_description(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_state_description(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_state_description(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_state_description(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_tooltip(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_tooltip(struct accesskit_node *node, const char *value); + +void accesskit_node_clear_tooltip(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_url(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_url(struct accesskit_node *node, const char *value); + +void accesskit_node_clear_url(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_row_index_text(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_row_index_text(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_row_index_text(struct accesskit_node *node); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_node_column_index_text(const struct accesskit_node *node); + +/** + * Caller is responsible for freeing the memory pointed by `value`. + */ +void accesskit_node_set_column_index_text(struct accesskit_node *node, + const char *value); + +void accesskit_node_clear_column_index_text(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_scroll_x( + const struct accesskit_node *node); + +void accesskit_node_set_scroll_x(struct accesskit_node *node, double value); + +void accesskit_node_clear_scroll_x(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_scroll_x_min( + const struct accesskit_node *node); + +void accesskit_node_set_scroll_x_min(struct accesskit_node *node, double value); + +void accesskit_node_clear_scroll_x_min(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_scroll_x_max( + const struct accesskit_node *node); + +void accesskit_node_set_scroll_x_max(struct accesskit_node *node, double value); + +void accesskit_node_clear_scroll_x_max(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_scroll_y( + const struct accesskit_node *node); + +void accesskit_node_set_scroll_y(struct accesskit_node *node, double value); + +void accesskit_node_clear_scroll_y(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_scroll_y_min( + const struct accesskit_node *node); + +void accesskit_node_set_scroll_y_min(struct accesskit_node *node, double value); + +void accesskit_node_clear_scroll_y_min(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_scroll_y_max( + const struct accesskit_node *node); + +void accesskit_node_set_scroll_y_max(struct accesskit_node *node, double value); + +void accesskit_node_clear_scroll_y_max(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_numeric_value( + const struct accesskit_node *node); + +void accesskit_node_set_numeric_value(struct accesskit_node *node, + double value); + +void accesskit_node_clear_numeric_value(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_min_numeric_value( + const struct accesskit_node *node); + +void accesskit_node_set_min_numeric_value(struct accesskit_node *node, + double value); + +void accesskit_node_clear_min_numeric_value(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_max_numeric_value( + const struct accesskit_node *node); + +void accesskit_node_set_max_numeric_value(struct accesskit_node *node, + double value); + +void accesskit_node_clear_max_numeric_value(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_numeric_value_step( + const struct accesskit_node *node); + +void accesskit_node_set_numeric_value_step(struct accesskit_node *node, + double value); + +void accesskit_node_clear_numeric_value_step(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_numeric_value_jump( + const struct accesskit_node *node); + +void accesskit_node_set_numeric_value_jump(struct accesskit_node *node, + double value); + +void accesskit_node_clear_numeric_value_jump(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_font_size( + const struct accesskit_node *node); + +void accesskit_node_set_font_size(struct accesskit_node *node, double value); + +void accesskit_node_clear_font_size(struct accesskit_node *node); + +struct accesskit_opt_double accesskit_node_font_weight( + const struct accesskit_node *node); + +void accesskit_node_set_font_weight(struct accesskit_node *node, double value); + +void accesskit_node_clear_font_weight(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_row_count( + const struct accesskit_node *node); + +void accesskit_node_set_row_count(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_row_count(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_column_count( + const struct accesskit_node *node); + +void accesskit_node_set_column_count(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_column_count(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_row_index( + const struct accesskit_node *node); + +void accesskit_node_set_row_index(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_row_index(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_column_index( + const struct accesskit_node *node); + +void accesskit_node_set_column_index(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_column_index(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_row_span( + const struct accesskit_node *node); + +void accesskit_node_set_row_span(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_row_span(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_column_span( + const struct accesskit_node *node); + +void accesskit_node_set_column_span(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_column_span(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_level( + const struct accesskit_node *node); + +void accesskit_node_set_level(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_level(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_size_of_set( + const struct accesskit_node *node); + +void accesskit_node_set_size_of_set(struct accesskit_node *node, size_t value); + +void accesskit_node_clear_size_of_set(struct accesskit_node *node); + +struct accesskit_opt_index accesskit_node_position_in_set( + const struct accesskit_node *node); + +void accesskit_node_set_position_in_set(struct accesskit_node *node, + size_t value); + +void accesskit_node_clear_position_in_set(struct accesskit_node *node); + +struct accesskit_opt_color accesskit_node_color_value( + const struct accesskit_node *node); + +void accesskit_node_set_color_value(struct accesskit_node *node, + uint32_t value); + +void accesskit_node_clear_color_value(struct accesskit_node *node); + +struct accesskit_opt_color accesskit_node_background_color( + const struct accesskit_node *node); + +void accesskit_node_set_background_color(struct accesskit_node *node, + uint32_t value); + +void accesskit_node_clear_background_color(struct accesskit_node *node); + +struct accesskit_opt_color accesskit_node_foreground_color( + const struct accesskit_node *node); + +void accesskit_node_set_foreground_color(struct accesskit_node *node, + uint32_t value); + +void accesskit_node_clear_foreground_color(struct accesskit_node *node); + +struct accesskit_opt_text_decoration accesskit_node_overline( + const struct accesskit_node *node); + +void accesskit_node_set_overline(struct accesskit_node *node, + accesskit_text_decoration value); + +void accesskit_node_clear_overline(struct accesskit_node *node); + +struct accesskit_opt_text_decoration accesskit_node_strikethrough( + const struct accesskit_node *node); + +void accesskit_node_set_strikethrough(struct accesskit_node *node, + accesskit_text_decoration value); + +void accesskit_node_clear_strikethrough(struct accesskit_node *node); + +struct accesskit_opt_text_decoration accesskit_node_underline( + const struct accesskit_node *node); + +void accesskit_node_set_underline(struct accesskit_node *node, + accesskit_text_decoration value); + +void accesskit_node_clear_underline(struct accesskit_node *node); + +struct accesskit_lengths accesskit_node_character_lengths( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_character_lengths(struct accesskit_node *node, + size_t length, const uint8_t *values); + +void accesskit_node_clear_character_lengths(struct accesskit_node *node); + +struct accesskit_lengths accesskit_node_word_lengths( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_word_lengths(struct accesskit_node *node, size_t length, + const uint8_t *values); + +void accesskit_node_clear_word_lengths(struct accesskit_node *node); + +struct accesskit_opt_coords accesskit_node_character_positions( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_character_positions(struct accesskit_node *node, + size_t length, const float *values); + +void accesskit_node_clear_character_positions(struct accesskit_node *node); + +struct accesskit_opt_coords accesskit_node_character_widths( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_character_widths(struct accesskit_node *node, + size_t length, const float *values); + +void accesskit_node_clear_character_widths(struct accesskit_node *node); + +struct accesskit_opt_bool accesskit_node_is_expanded( + const struct accesskit_node *node); + +void accesskit_node_set_expanded(struct accesskit_node *node, bool value); + +void accesskit_node_clear_expanded(struct accesskit_node *node); + +struct accesskit_opt_bool accesskit_node_is_selected( + const struct accesskit_node *node); + +void accesskit_node_set_selected(struct accesskit_node *node, bool value); + +void accesskit_node_clear_selected(struct accesskit_node *node); + +struct accesskit_opt_invalid accesskit_node_invalid( + const struct accesskit_node *node); + +void accesskit_node_set_invalid(struct accesskit_node *node, + accesskit_invalid value); + +void accesskit_node_clear_invalid(struct accesskit_node *node); + +struct accesskit_opt_toggled accesskit_node_toggled( + const struct accesskit_node *node); + +void accesskit_node_set_toggled(struct accesskit_node *node, + accesskit_toggled value); + +void accesskit_node_clear_toggled(struct accesskit_node *node); + +struct accesskit_opt_live accesskit_node_live( + const struct accesskit_node *node); + +void accesskit_node_set_live(struct accesskit_node *node, accesskit_live value); + +void accesskit_node_clear_live(struct accesskit_node *node); + +struct accesskit_opt_text_direction accesskit_node_text_direction( + const struct accesskit_node *node); + +void accesskit_node_set_text_direction(struct accesskit_node *node, + accesskit_text_direction value); + +void accesskit_node_clear_text_direction(struct accesskit_node *node); + +struct accesskit_opt_orientation accesskit_node_orientation( + const struct accesskit_node *node); + +void accesskit_node_set_orientation(struct accesskit_node *node, + accesskit_orientation value); + +void accesskit_node_clear_orientation(struct accesskit_node *node); + +struct accesskit_opt_sort_direction accesskit_node_sort_direction( + const struct accesskit_node *node); + +void accesskit_node_set_sort_direction(struct accesskit_node *node, + accesskit_sort_direction value); + +void accesskit_node_clear_sort_direction(struct accesskit_node *node); + +struct accesskit_opt_aria_current accesskit_node_aria_current( + const struct accesskit_node *node); + +void accesskit_node_set_aria_current(struct accesskit_node *node, + accesskit_aria_current value); + +void accesskit_node_clear_aria_current(struct accesskit_node *node); + +struct accesskit_opt_auto_complete accesskit_node_auto_complete( + const struct accesskit_node *node); + +void accesskit_node_set_auto_complete(struct accesskit_node *node, + accesskit_auto_complete value); + +void accesskit_node_clear_auto_complete(struct accesskit_node *node); + +struct accesskit_opt_has_popup accesskit_node_has_popup( + const struct accesskit_node *node); + +void accesskit_node_set_has_popup(struct accesskit_node *node, + accesskit_has_popup value); + +void accesskit_node_clear_has_popup(struct accesskit_node *node); + +struct accesskit_opt_list_style accesskit_node_list_style( + const struct accesskit_node *node); + +void accesskit_node_set_list_style(struct accesskit_node *node, + accesskit_list_style value); + +void accesskit_node_clear_list_style(struct accesskit_node *node); + +struct accesskit_opt_text_align accesskit_node_text_align( + const struct accesskit_node *node); + +void accesskit_node_set_text_align(struct accesskit_node *node, + accesskit_text_align value); + +void accesskit_node_clear_text_align(struct accesskit_node *node); + +struct accesskit_opt_vertical_offset accesskit_node_vertical_offset( + const struct accesskit_node *node); + +void accesskit_node_set_vertical_offset(struct accesskit_node *node, + accesskit_vertical_offset value); + +void accesskit_node_clear_vertical_offset(struct accesskit_node *node); + +const struct accesskit_affine *accesskit_node_transform( + const struct accesskit_node *node); + +void accesskit_node_set_transform(struct accesskit_node *node, + struct accesskit_affine value); + +void accesskit_node_clear_transform(struct accesskit_node *node); + +struct accesskit_opt_rect accesskit_node_bounds( + const struct accesskit_node *node); + +void accesskit_node_set_bounds(struct accesskit_node *node, + struct accesskit_rect value); + +void accesskit_node_clear_bounds(struct accesskit_node *node); + +struct accesskit_opt_text_selection accesskit_node_text_selection( + const struct accesskit_node *node); + +void accesskit_node_set_text_selection(struct accesskit_node *node, + struct accesskit_text_selection value); + +void accesskit_node_clear_text_selection(struct accesskit_node *node); + +struct accesskit_custom_action accesskit_custom_action_new( + int32_t id, const char *description); + +void accesskit_custom_actions_free(struct accesskit_custom_actions *value); + +/** + * Caller is responsible for freeing the returned value. + */ +const struct accesskit_custom_actions *accesskit_node_custom_actions( + const struct accesskit_node *node); + +/** + * Caller is responsible for freeing `values`. + */ +void accesskit_node_set_custom_actions( + struct accesskit_node *node, size_t length, + const struct accesskit_custom_action *values); + +void accesskit_node_push_custom_action(struct accesskit_node *node, + struct accesskit_custom_action item); + +void accesskit_node_clear_custom_actions(struct accesskit_node *node); + +struct accesskit_node *accesskit_node_new(accesskit_role role); + +void accesskit_node_free(struct accesskit_node *node); + +struct accesskit_tree *accesskit_tree_new(accesskit_node_id root); + +void accesskit_tree_free(struct accesskit_tree *tree); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_tree_get_toolkit_name(const struct accesskit_tree *tree); + +void accesskit_tree_set_toolkit_name(struct accesskit_tree *tree, + const char *toolkit_name); + +void accesskit_tree_clear_toolkit_name(struct accesskit_tree *tree); + +/** + * Caller must call `accesskit_string_free` with the return value. + */ +char *accesskit_tree_get_toolkit_version(const struct accesskit_tree *tree); + +void accesskit_tree_set_toolkit_version(struct accesskit_tree *tree, + const char *toolkit_version); + +void accesskit_tree_clear_toolkit_version(struct accesskit_tree *tree); + +struct accesskit_tree_update *accesskit_tree_update_with_focus( + accesskit_node_id focus); + +struct accesskit_tree_update *accesskit_tree_update_with_capacity_and_focus( + size_t capacity, accesskit_node_id focus); + +void accesskit_tree_update_free(struct accesskit_tree_update *update); + +/** + * Appends the provided node to the tree update's list of nodes. + * Takes ownership of `node`. + */ +void accesskit_tree_update_push_node(struct accesskit_tree_update *update, + accesskit_node_id id, + struct accesskit_node *node); + +void accesskit_tree_update_set_tree(struct accesskit_tree_update *update, + struct accesskit_tree *tree); + +void accesskit_tree_update_clear_tree(struct accesskit_tree_update *update); + +void accesskit_tree_update_set_focus(struct accesskit_tree_update *update, + accesskit_node_id focus); + +void accesskit_action_request_free(struct accesskit_action_request *request); + +struct accesskit_affine accesskit_affine_identity(void); + +struct accesskit_affine accesskit_affine_flip_y(void); + +struct accesskit_affine accesskit_affine_flip_x(void); + +struct accesskit_affine accesskit_affine_scale(double s); + +struct accesskit_affine accesskit_affine_scale_non_uniform(double s_x, + double s_y); + +struct accesskit_affine accesskit_affine_translate(struct accesskit_vec2 p); + +struct accesskit_affine accesskit_affine_map_unit_square( + struct accesskit_rect rect); + +double accesskit_affine_determinant(struct accesskit_affine affine); + +struct accesskit_affine accesskit_affine_inverse( + struct accesskit_affine affine); + +struct accesskit_rect accesskit_affine_transform_rect_bbox( + struct accesskit_affine affine, struct accesskit_rect rect); + +bool accesskit_affine_is_finite(const struct accesskit_affine *affine); + +bool accesskit_affine_is_nan(const struct accesskit_affine *affine); + +struct accesskit_vec2 accesskit_point_to_vec2(struct accesskit_point point); + +struct accesskit_rect accesskit_rect_from_points(struct accesskit_point p0, + struct accesskit_point p1); + +struct accesskit_rect accesskit_rect_from_origin_size( + struct accesskit_point origin, struct accesskit_size size); + +struct accesskit_rect accesskit_rect_with_origin(struct accesskit_rect rect, + struct accesskit_point origin); + +struct accesskit_rect accesskit_rect_with_size(struct accesskit_rect rect, + struct accesskit_size size); + +double accesskit_rect_width(const struct accesskit_rect *rect); + +double accesskit_rect_height(const struct accesskit_rect *rect); + +double accesskit_rect_min_x(const struct accesskit_rect *rect); + +double accesskit_rect_max_x(const struct accesskit_rect *rect); + +double accesskit_rect_min_y(const struct accesskit_rect *rect); + +double accesskit_rect_max_y(const struct accesskit_rect *rect); + +struct accesskit_point accesskit_rect_origin(const struct accesskit_rect *rect); + +struct accesskit_size accesskit_rect_size(const struct accesskit_rect *rect); + +struct accesskit_rect accesskit_rect_abs(const struct accesskit_rect *rect); + +double accesskit_rect_area(const struct accesskit_rect *rect); + +bool accesskit_rect_is_empty(const struct accesskit_rect *rect); + +bool accesskit_rect_contains(const struct accesskit_rect *rect, + struct accesskit_point point); + +struct accesskit_rect accesskit_rect_union(const struct accesskit_rect *rect, + struct accesskit_rect other); + +struct accesskit_rect accesskit_rect_union_pt(const struct accesskit_rect *rect, + struct accesskit_point pt); + +struct accesskit_rect accesskit_rect_intersect( + const struct accesskit_rect *rect, struct accesskit_rect other); + +struct accesskit_vec2 accesskit_size_to_vec2(struct accesskit_size size); + +struct accesskit_point accesskit_vec2_to_point(struct accesskit_vec2 vec2); + +struct accesskit_size accesskit_vec2_to_size(struct accesskit_vec2 vec2); + +#if defined(__APPLE__) +/** + * Memory is also freed when calling this function. + */ +void accesskit_macos_queued_events_raise( + struct accesskit_macos_queued_events *events); +#endif + +#if defined(__APPLE__) +/** + * # Safety + * + * `view` must be a valid, unreleased pointer to an `NSView`. + */ +struct accesskit_macos_adapter *accesskit_macos_adapter_new( + void *view, bool is_view_focused, + accesskit_action_handler_callback action_handler, + void *action_handler_userdata); +#endif + +#if defined(__APPLE__) +void accesskit_macos_adapter_free(struct accesskit_macos_adapter *adapter); +#endif + +#if defined(__APPLE__) +/** + * You must call `accesskit_macos_queued_events_raise` on the returned pointer. + * It can be null if the adapter is not active. + */ +struct accesskit_macos_queued_events *accesskit_macos_adapter_update_if_active( + struct accesskit_macos_adapter *adapter, + accesskit_tree_update_factory update_factory, + void *update_factory_userdata); +#endif + +#if defined(__APPLE__) +/** + * Update the tree state based on whether the window is focused. + * + * You must call `accesskit_macos_queued_events_raise` on the returned pointer. + * It can be null if the adapter is not active. + */ +struct accesskit_macos_queued_events * +accesskit_macos_adapter_update_view_focus_state( + struct accesskit_macos_adapter *adapter, bool is_focused); +#endif + +#if defined(__APPLE__) +/** + * Returns a pointer to an `NSArray`. Ownership of the pointer is not + * transferred. + */ +void *accesskit_macos_adapter_view_children( + struct accesskit_macos_adapter *adapter, + accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata); +#endif + +#if defined(__APPLE__) +/** + * Returns a pointer to an `NSObject`. Ownership of the pointer is not + * transferred. + */ +void *accesskit_macos_adapter_focus( + struct accesskit_macos_adapter *adapter, + accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata); +#endif + +#if defined(__APPLE__) +/** + * Returns a pointer to an `NSObject`. Ownership of the pointer is not + * transferred. + */ +void *accesskit_macos_adapter_hit_test( + struct accesskit_macos_adapter *adapter, double x, double y, + accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata); +#endif + +#if defined(__APPLE__) +/** + * # Safety + * + * `view` must be a valid, unreleased pointer to an `NSView`. + */ +struct accesskit_macos_subclassing_adapter * +accesskit_macos_subclassing_adapter_new( + void *view, accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata, + accesskit_action_handler_callback action_handler, + void *action_handler_userdata); +#endif + +#if defined(__APPLE__) +/** + * # Safety + * + * `window` must be a valid, unreleased pointer to an `NSWindow`. + * + * # Panics + * + * This function panics if the specified window doesn't currently have + * a content view. + */ +struct accesskit_macos_subclassing_adapter * +accesskit_macos_subclassing_adapter_for_window( + void *window, accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata, + accesskit_action_handler_callback action_handler, + void *action_handler_userdata); +#endif + +#if defined(__APPLE__) +void accesskit_macos_subclassing_adapter_free( + struct accesskit_macos_subclassing_adapter *adapter); +#endif + +#if defined(__APPLE__) +/** + * You must call `accesskit_macos_queued_events_raise` on the returned pointer. + * It can be null if the adapter is not active. + */ +struct accesskit_macos_queued_events * +accesskit_macos_subclassing_adapter_update_if_active( + struct accesskit_macos_subclassing_adapter *adapter, + accesskit_tree_update_factory update_factory, + void *update_factory_userdata); +#endif + +#if defined(__APPLE__) +/** + * Update the tree state based on whether the window is focused. + * + * You must call `accesskit_macos_queued_events_raise` on the returned pointer. + * It can be null if the adapter is not active. + */ +struct accesskit_macos_queued_events * +accesskit_macos_subclassing_adapter_update_view_focus_state( + struct accesskit_macos_subclassing_adapter *adapter, bool is_focused); +#endif + +#if defined(__APPLE__) +/** + * Modifies the specified class, which must be a subclass of `NSWindow`, + * to include an `accessibilityFocusedUIElement` method that calls + * the corresponding method on the window's content view. This is needed + * for windowing libraries such as SDL that place the keyboard focus + * directly on the window rather than the content view. + * + * # Safety + * + * This function is declared unsafe because the caller must ensure that the + * code for this library is never unloaded from the application process, + * since it's not possible to reverse this operation. It's safest + * if this library is statically linked into the application's main executable. + * Also, this function assumes that the specified class is a subclass + * of `NSWindow`. + */ +void accesskit_macos_add_focus_forwarder_to_window_class( + const char *class_name); +#endif + +#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ + defined(__NetBSD__) || defined(__OpenBSD__)) +/** + * All of the handlers will always be called from another thread. + */ +struct accesskit_unix_adapter *accesskit_unix_adapter_new( + accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata, + accesskit_action_handler_callback action_handler, + void *action_handler_userdata, + accesskit_deactivation_handler_callback deactivation_handler, + void *deactivation_handler_userdata); +#endif + +#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ + defined(__NetBSD__) || defined(__OpenBSD__)) +void accesskit_unix_adapter_free(struct accesskit_unix_adapter *adapter); +#endif + +#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ + defined(__NetBSD__) || defined(__OpenBSD__)) +void accesskit_unix_adapter_set_root_window_bounds( + struct accesskit_unix_adapter *adapter, struct accesskit_rect outer, + struct accesskit_rect inner); +#endif + +#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ + defined(__NetBSD__) || defined(__OpenBSD__)) +void accesskit_unix_adapter_update_if_active( + struct accesskit_unix_adapter *adapter, + accesskit_tree_update_factory update_factory, + void *update_factory_userdata); +#endif + +#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) || \ + defined(__NetBSD__) || defined(__OpenBSD__)) +/** + * Update the tree state based on whether the window is focused. + */ +void accesskit_unix_adapter_update_window_focus_state( + struct accesskit_unix_adapter *adapter, bool is_focused); +#endif + +#if defined(_WIN32) +/** + * Memory is also freed when calling this function. + */ +void accesskit_windows_queued_events_raise( + struct accesskit_windows_queued_events *events); +#endif + +#if defined(_WIN32) +struct accesskit_windows_adapter *accesskit_windows_adapter_new( + HWND hwnd, bool is_window_focused, + accesskit_action_handler_callback action_handler, + void *action_handler_userdata); +#endif + +#if defined(_WIN32) +void accesskit_windows_adapter_free(struct accesskit_windows_adapter *adapter); +#endif + +#if defined(_WIN32) +/** + * You must call `accesskit_windows_queued_events_raise` on the returned + * pointer. It can be null if the adapter is not active. + */ +struct accesskit_windows_queued_events * +accesskit_windows_adapter_update_if_active( + struct accesskit_windows_adapter *adapter, + accesskit_tree_update_factory update_factory, + void *update_factory_userdata); +#endif + +#if defined(_WIN32) +/** + * Update the tree state based on whether the window is focused. + * + * You must call `accesskit_windows_queued_events_raise` on the returned + * pointer. + */ +struct accesskit_windows_queued_events * +accesskit_windows_adapter_update_window_focus_state( + struct accesskit_windows_adapter *adapter, bool is_focused); +#endif + +#if defined(_WIN32) +struct accesskit_opt_lresult accesskit_windows_adapter_handle_wm_getobject( + struct accesskit_windows_adapter *adapter, WPARAM wparam, LPARAM lparam, + accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata); +#endif + +#if defined(_WIN32) +/** + * Creates a new Windows platform adapter using window subclassing. + * This must be done before the window is shown or focused + * for the first time. + * + * This must be called on the thread that owns the window. The activation + * handler will always be called on that thread. The action handler + * may or may not be called on that thread. + * + * # Panics + * + * Panics if the window is already visible. + */ +struct accesskit_windows_subclassing_adapter * +accesskit_windows_subclassing_adapter_new( + HWND hwnd, accesskit_activation_handler_callback activation_handler, + void *activation_handler_userdata, + accesskit_action_handler_callback action_handler, + void *action_handler_userdata); +#endif + +#if defined(_WIN32) +void accesskit_windows_subclassing_adapter_free( + struct accesskit_windows_subclassing_adapter *adapter); +#endif + +#if defined(_WIN32) +/** + * You must call `accesskit_windows_queued_events_raise` on the returned + * pointer. It can be null if the adapter is not active. + */ +struct accesskit_windows_queued_events * +accesskit_windows_subclassing_adapter_update_if_active( + struct accesskit_windows_subclassing_adapter *adapter, + accesskit_tree_update_factory update_factory, + void *update_factory_userdata); +#endif + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif /* ACCESSKIT_H */