diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml index 39f4f0b67eb6..4539f1b77cf4 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 1244ce25e47e..93189b2e4ef7 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 535756025a45..1a93e66cd0e5 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 a8100f0ed2eb..8c9f033afbcc 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ default_language_version: exclude: | (?x)^( .*thirdparty/.*| - .*-so_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 6fdfacc552e9..380090935ee6 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 aaebea97a9d6..03990864310e 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/core/config/project_settings.cpp b/core/config/project_settings.cpp index c328332387d9..34a4cab8015c 100644 --- a/core/config/project_settings.cpp +++ b/core/config/project_settings.cpp @@ -1491,6 +1491,9 @@ ProjectSettings::ProjectSettings() { GLOBAL_DEF("application/config/auto_accept_quit", true); GLOBAL_DEF("application/config/quit_on_go_back", true); + GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "accessibility/general/accessibility_support", PROPERTY_HINT_ENUM, "Auto (When Screen Reader is Running),Always Active,Disabled"), 0); + GLOBAL_DEF_BASIC(PropertyInfo(Variant::INT, "accessibility/general/updates_per_second", PROPERTY_HINT_RANGE, "1,100,1"), 60); + // The default window size is tuned to: // - Have a 16:9 aspect ratio, // - Have both dimensions divisible by 8 to better play along with video recording, diff --git a/core/input/input_map.cpp b/core/input/input_map.cpp index a15e4f187612..ea03c25c7299 100644 --- a/core/input/input_map.cpp +++ b/core/input/input_map.cpp @@ -47,6 +47,8 @@ void InputMap::_bind_methods() { ClassDB::bind_method(D_METHOD("add_action", "action", "deadzone"), &InputMap::add_action, DEFVAL(DEFAULT_DEADZONE)); ClassDB::bind_method(D_METHOD("erase_action", "action"), &InputMap::erase_action); + ClassDB::bind_method(D_METHOD("get_action_description", "action"), &InputMap::get_action_description); + ClassDB::bind_method(D_METHOD("action_set_deadzone", "action", "deadzone"), &InputMap::action_set_deadzone); ClassDB::bind_method(D_METHOD("action_get_deadzone", "action"), &InputMap::action_get_deadzone); ClassDB::bind_method(D_METHOD("action_add_event", "action", "event"), &InputMap::action_add_event); @@ -181,6 +183,25 @@ bool InputMap::has_action(const StringName &p_action) const { return input_map.has(p_action); } +String InputMap::get_action_description(const StringName &p_action) const { + ERR_FAIL_COND_V_MSG(!input_map.has(p_action), String(), suggest_actions(p_action)); + + String ret; + const List> &inputs = input_map[p_action].inputs; + for (Ref iek : inputs) { + if (iek.is_valid()) { + if (!ret.is_empty()) { + ret += RTR(" or "); + } + ret += iek->as_text(); + } + } + if (ret.is_empty()) { + ret = RTR("Action has no bound inputs"); + } + return ret; +} + float InputMap::action_get_deadzone(const StringName &p_action) { ERR_FAIL_COND_V_MSG(!input_map.has(p_action), 0.0f, suggest_actions(p_action)); @@ -344,6 +365,7 @@ static const _BuiltinActionDisplayName _builtin_action_display_names[] = { { "ui_cut", TTRC("Cut") }, { "ui_copy", TTRC("Copy") }, { "ui_paste", TTRC("Paste") }, + { "ui_focus_mode", TTRC("Toggle Tab Focus Mode") }, { "ui_undo", TTRC("Undo") }, { "ui_redo", TTRC("Redo") }, { "ui_text_completion_query", TTRC("Completion Query") }, @@ -397,12 +419,15 @@ static const _BuiltinActionDisplayName _builtin_action_display_names[] = { { "ui_text_submit", TTRC("Submit Text") }, { "ui_graph_duplicate", TTRC("Duplicate Nodes") }, { "ui_graph_delete", TTRC("Delete Nodes") }, + { "ui_graph_follow_left", TTRC("Follow Input Port Connection") }, + { "ui_graph_follow_right", TTRC("Follow Output Port Connection") }, { "ui_filedialog_up_one_level", TTRC("Go Up One Level") }, { "ui_filedialog_refresh", TTRC("Refresh") }, { "ui_filedialog_show_hidden", TTRC("Show Hidden") }, { "ui_swap_input_direction ", TTRC("Swap Input Direction") }, { "ui_unicode_start", TTRC("Start Unicode Character Input") }, - { "ui_colorpicker_delete_preset", TTRC("Toggle License Notices") }, + { "ui_colorpicker_delete_preset", TTRC("Toggle License Notices") }, + { "ui_accessibility_drag_and_drop", TTRC("Accessibility: Keyboard Drag and Drop") }, { "", ""} /* clang-format on */ }; @@ -488,6 +513,9 @@ const HashMap>> &InputMap::get_builtins() { inputs.push_back(InputEventKey::create_reference(Key::END)); default_builtin_cache.insert("ui_end", inputs); + inputs = List>(); + default_builtin_cache.insert("ui_accessibility_drag_and_drop", inputs); + // ///// UI basic Shortcuts ///// inputs = List>(); @@ -500,6 +528,10 @@ const HashMap>> &InputMap::get_builtins() { inputs.push_back(InputEventKey::create_reference(Key::INSERT | KeyModifierMask::CMD_OR_CTRL)); default_builtin_cache.insert("ui_copy", inputs); + inputs = List>(); + inputs.push_back(InputEventKey::create_reference(Key::M | KeyModifierMask::CTRL)); + default_builtin_cache.insert("ui_focus_mode", inputs); + inputs = List>(); inputs.push_back(InputEventKey::create_reference(Key::V | KeyModifierMask::CMD_OR_CTRL)); inputs.push_back(InputEventKey::create_reference(Key::INSERT | KeyModifierMask::SHIFT)); @@ -773,6 +805,22 @@ const HashMap>> &InputMap::get_builtins() { inputs.push_back(InputEventKey::create_reference(Key::KEY_DELETE)); default_builtin_cache.insert("ui_graph_delete", inputs); + inputs = List>(); + inputs.push_back(InputEventKey::create_reference(Key::LEFT | KeyModifierMask::CMD_OR_CTRL)); + default_builtin_cache.insert("ui_graph_follow_left", inputs); + + inputs = List>(); + inputs.push_back(InputEventKey::create_reference(Key::LEFT | KeyModifierMask::ALT)); + default_builtin_cache.insert("ui_graph_follow_left.macos", inputs); + + inputs = List>(); + inputs.push_back(InputEventKey::create_reference(Key::RIGHT | KeyModifierMask::CMD_OR_CTRL)); + default_builtin_cache.insert("ui_graph_follow_right", inputs); + + inputs = List>(); + inputs.push_back(InputEventKey::create_reference(Key::RIGHT | KeyModifierMask::ALT)); + default_builtin_cache.insert("ui_graph_follow_right.macos", inputs); + // ///// UI File Dialog Shortcuts ///// inputs = List>(); inputs.push_back(InputEventKey::create_reference(Key::BACKSPACE)); diff --git a/core/input/input_map.h b/core/input/input_map.h index 9b89281b5cf0..00bc1550a2ba 100644 --- a/core/input/input_map.h +++ b/core/input/input_map.h @@ -85,6 +85,8 @@ class InputMap : public Object { void add_action(const StringName &p_action, float p_deadzone = DEFAULT_DEADZONE); void erase_action(const StringName &p_action); + String get_action_description(const StringName &p_action) const; + float action_get_deadzone(const StringName &p_action); void action_set_deadzone(const StringName &p_action, float p_deadzone); void action_add_event(const StringName &p_action, const Ref &p_event); diff --git a/core/string/ustring.cpp b/core/string/ustring.cpp index 854d32af9676..a7ec4d17e99d 100644 --- a/core/string/ustring.cpp +++ b/core/string/ustring.cpp @@ -2073,34 +2073,45 @@ Error String::append_utf8(const char *p_utf8, int p_len, bool p_skip_cr) { return result; } -CharString String::utf8() const { +CharString String::utf8(Vector *r_ch_length_map) const { int l = length(); if (!l) { return CharString(); } + uint8_t *map_ptr = nullptr; + if (r_ch_length_map) { + r_ch_length_map->resize(l); + map_ptr = r_ch_length_map->ptrw(); + } + const char32_t *d = &operator[](0); int fl = 0; for (int i = 0; i < l; i++) { uint32_t c = d[i]; + int ch_w = 1; if (c <= 0x7f) { // 7 bits. - fl += 1; + ch_w = 1; } else if (c <= 0x7ff) { // 11 bits - fl += 2; + ch_w = 2; } else if (c <= 0xffff) { // 16 bits - fl += 3; + ch_w = 3; } else if (c <= 0x001fffff) { // 21 bits - fl += 4; + ch_w = 4; } else if (c <= 0x03ffffff) { // 26 bits - fl += 5; + ch_w = 5; print_unicode_error(vformat("Invalid unicode codepoint (%x)", c)); } else if (c <= 0x7fffffff) { // 31 bits - fl += 6; + ch_w = 6; print_unicode_error(vformat("Invalid unicode codepoint (%x)", c)); } else { - fl += 1; + ch_w = 1; print_unicode_error(vformat("Invalid unicode codepoint (%x), cannot represent as UTF-8", c), true); } + fl += ch_w; + if (map_ptr) { + map_ptr[i] = ch_w; + } } CharString utf8s; diff --git a/core/string/ustring.h b/core/string/ustring.h index e828456df120..145240e4d545 100644 --- a/core/string/ustring.h +++ b/core/string/ustring.h @@ -511,7 +511,7 @@ class String { return string; } - CharString utf8() const; + CharString utf8(Vector *r_ch_length_map = nullptr) const; Error append_utf8(const char *p_utf8, int p_len = -1, bool p_skip_cr = false); Error append_utf8(const Span &p_range, bool p_skip_cr = false) { return append_utf8(p_range.ptr(), p_range.size(), p_skip_cr); diff --git a/doc/classes/Control.xml b/doc/classes/Control.xml index 63c13437327b..5cc12077acb4 100644 --- a/doc/classes/Control.xml +++ b/doc/classes/Control.xml @@ -24,6 +24,12 @@ https://github.com/godotengine/godot-demo-projects/tree/master/gui + + + + Return the description of the keyboard shortcuts and other contextual help for this control. + + @@ -31,6 +37,7 @@ Godot calls this method to test if [param data] from a control's [method _get_drag_data] can be dropped at [param at_position]. [param at_position] is local to this control. This method should only be used to test the data. Process the data in [method _drop_data]. + [b]Note:[/b] If drag was initiated by keyboard shortcut or [method accessibility_drag], [param at_position] is set to [code]Vector2(INFINITY, INFINITY)[/code] and the currently selected item/text position should be used as drop position. [codeblocks] [gdscript] func _can_drop_data(position, data): @@ -55,6 +62,7 @@ Godot calls this method to pass you the [param data] from a control's [method _get_drag_data] result. Godot first calls [method _can_drop_data] to test if [param data] is allowed to drop at [param at_position] where [param at_position] is local to this control. + [b]Note:[/b] If drag was initiated by keyboard shortcut or [method accessibility_drag], [param at_position] is set to [code]Vector2(INFINITY, INFINITY)[/code] and the currently selected item/text position should be used as drop position. [codeblocks] [gdscript] func _can_drop_data(position, data): @@ -83,6 +91,7 @@ Godot calls this method to get data that can be dragged and dropped onto controls that expect drop data. Returns [code]null[/code] if there is no data to drag. Controls that want to receive drop data should implement [method _can_drop_data] and [method _drop_data]. [param at_position] is local to this control. Drag may be forced with [method force_drag]. A preview that will follow the mouse that should represent the data can be set with [method set_drag_preview]. A good time to set the preview is in this method. + [b]Note:[/b] If drag was initiated by keyboard shortcut or [method accessibility_drag], [param at_position] is set to [code]Vector2(INFINITY, INFINITY)[/code] and the currently selected item/text position should be used as drop position. [codeblocks] [gdscript] func _get_drag_data(position): @@ -223,6 +232,18 @@ [b]Note:[/b] This does not affect the methods in [Input], only the way events are propagated. + + + + Starts drag-and-drop operation without using a mouse. + + + + + + Ends drag-and-drop operation without using a mouse. + + @@ -1174,6 +1195,9 @@ The node can grab focus on mouse click, using the arrows and the Tab keys on the keyboard, or using the D-pad buttons on a gamepad. Use with [member focus_mode]. + + The node can grab focus only when screen reader is active. Use with [member focus_mode]. + Inherits the associated behavior from the control's parent. This is the default for any newly created control. diff --git a/doc/classes/DisplayServer.xml b/doc/classes/DisplayServer.xml index 0103cff1df49..1cb908e3e300 100644 --- a/doc/classes/DisplayServer.xml +++ b/doc/classes/DisplayServer.xml @@ -10,6 +10,630 @@ + + + + + + Creates a new, empty accessibility element resource. + [b]Note:[/b] An accessibility element is created and freed automatically for each [Node]. In general, this function should not be called manually. + + + + + + + + + Creates a new, empty accessibility sub-element resource. Sub-elements can be used to provide accessibility information for objects which are not [Node]s, such as list items, table cells, or menu items. Sub-elements are freed automatically when the parent element is freed, or can be freed early using the [method accessibility_free_element] method. + + + + + + + + + + Creates a new, empty accessibility sub-element from the shaped text buffer. Sub-elements are freed automatically when the parent element is freed, or can be freed early using the [method accessibility_free_element] method. + + + + + + + Returns the metadata of the accessibility element. + + + + + + + + Sets the metadata of the accessibility element. + + + + + + + Frees an object created by [method accessibility_create_element], [method accessibility_create_sub_element], or [method accessibility_create_sub_text_edit_elements]. + + + + + + + Returns the main accessibility element of the OS native window. + + + + + + + Returns [code]true[/code] if [param id] is a valid accessibility element. + + + + + + Returns [code]1[/code] if a screen reader, Braille display or other assistive app is active, [code]0[/code] otherwise. Returns [code]-1[/code] if status is unknown. + [b]Note:[/b] This method is implemented on Linux, macOS, and Windows. + [b]Note:[/b] Accessibility debugging tools, such as Accessibility Insights for Windows, macOS Accessibility Inspector, or AT-SPI Browser do not count as assistive apps and will not affect this value. To test your app with these tools, set [member ProjectSettings.accessibility/general/accessibility_support] to [code]1[/code]. + + + + + + + + Sets the window focused state for assistive apps. + [b]Note:[/b] This method is implemented on Linux, macOS, and Windows. + [b]Note:[/b] Advanced users only! [Window] objects call this method automatically. + + + + + + + + + Sets window outer (with decorations) and inner (without decorations) bounds for assistive apps. + [b]Note:[/b] This method is implemented on Linux, macOS, and Windows. + [b]Note:[/b] Advanced users only! [Window] objects call this method automatically. + + + + + + Returns [code]1[/code] if a high-contrast user interface theme should be used, [code]0[/code] otherwise. Returns [code]-1[/code] if status is unknown. + [b]Note:[/b] This method is implemented on Linux (X11/Wayland, GNOME), macOS, and Windows. + + + + + + Returns [code]1[/code] if flashing, blinking, and other moving content that can cause seizures in users with photosensitive epilepsy should be disabled, [code]0[/code] otherwise. Returns [code]-1[/code] if status is unknown. + [b]Note:[/b] This method is implemented on macOS and Windows. + + + + + + Returns [code]1[/code] if background images, transparency, and other features that can reduce the contrast between the foreground and background should be disabled, [code]0[/code] otherwise. Returns [code]-1[/code] if status is unknown. + [b]Note:[/b] This method is implemented on macOS and Windows. + + + + + + + + + Adds a callback for the accessibility action (action which can be performed by using a special screen reader command or buttons on the Braille display), and marks this action as supported. The action callback receives one [Variant] argument, which value depends on action type. + + + + + + + + Adds a child accessibility element. + [b]Note:[/b] [Node] children and sub-elements are added to the child list automatically. + + + + + + + + + Adds support for a custom accessibility action. [param action_id] is passed as an argument to the callback of [constant ACTION_CUSTOM] action. + + + + + + + + Adds an element that is controlled by this element. + + + + + + + + Adds an element that describes this element. + + + + + + + + Adds an element that details this element. + + + + + + + + Adds an element that this element flow into. + + + + + + + + Adds an element that labels this element. + + + + + + + + Adds an element that is part of the same radio group. + [b]Note:[/b] This method should be called on each element of the group, using all other elements as [param related_id]. + + + + + + + + Adds an element that is an active descendant of this element. + + + + + + + + Sets element background color. + + + + + + + + Sets element bounding box, relative to the node position. + + + + + + + + Sets element checked state. + + + + + + + + Sets element class name. + + + + + + + + Sets element color value. + + + + + + + + Sets element accessibility description. + + + + + + + + Sets an element which contains an error message for this element. + + + + + + + + Sets element accessibility extra information added to the element name. + + + + + + + + + Sets element flag, see [enum DisplayServer.AccessibilityFlags]. + + + + + + + Sets currently focused element. + + + + + + + + Sets element foreground color. + + + + + + + + Sets target element for the link. + + + + + + + + Sets element text language. + + + + + + + + Sets number of items in the list. + + + + + + + + Sets list/tree item expanded status. + + + + + + + + Sets the position of the element in the list. + + + + + + + + Sets the hierarchical level of the element in the list. + + + + + + + + Sets list/tree item selected status. + + + + + + + + Sets the orientation of the list elements. + + + + + + + + Sets the priority of the live region updates. + + + + + + + + Sets the element to be a member of the group. + + + + + + + + Sets element accessibility name. + + + + + + + + Sets next element on the line. + + + + + + + + Sets numeric value jump. + + + + + + + + + Sets numeric value range. + + + + + + + + Sets numeric value step. + + + + + + + + Sets numeric value. + + + + + + + + Sets placeholder text. + + + + + + + + Sets popup type for popup buttons. + + + + + + + + Sets previous element on the line. + + + + + + + + Sets element accessibility role. + + + + + + + + Sets element accessibility role description text. + + + + + + + + Sets scroll bar x position. + + + + + + + + + Sets scroll bar x range. + + + + + + + + Sets scroll bar y position. + + + + + + + + + Sets scroll bar y range. + + + + + + + + Sets the list of keyboard shortcuts used by element. + + + + + + + + Sets human-readable description of the current checked state. + + + + + + + + + Sets cell position in the table. + + + + + + + + + Sets cell row/column span. + + + + + + + + Sets number of columns in the table. + + + + + + + + Sets position of the column. + + + + + + + + Sets number of rows in the table. + + + + + + + + Sets position of the row in the table. + + + + + + + + Sets element text alignment. + + + + + + + + + + Sets text underline/overline/strikethrough. + + + + + + + + Sets text orientation. + + + + + + + + + + + Sets text selection to the text field. [param text_start_id] and [param text_end_id] should be elements created by [method accessibility_create_sub_text_edit_elements]. Character offsets are relative to the corresponding element. + + + + + + + + Sets tooltip text. + + + + + + + + Sets element 2D transform. + + + + + + + + Sets link URL. + + + + + + + + Sets element text value. + + @@ -1969,6 +2593,276 @@ Display server automatically fits popups according to the screen boundaries. Window nodes should not attempt to do that themselves. + + Display server supports interaction with screen reader or Braille display. [b]Linux (X11/Wayland), macOS, Windows[/b] + + + Unknown or custom role. + + + Default dialog button element. + + + Audio player element. + + + Video player element. + + + Non-editable text label. + + + Container element. Elements with this role are used for internal structure and ignored by screen readers. + + + Panel container element. + + + Button element. + + + Link element. + + + Check box element. + + + Radio button element. + + + Check button element. + + + Scroll bar element. + + + Scroll container element. + + + Container splitter handle element. + + + Slider element. + + + Spin box element. + + + Progress indicator element. + + + Editable text field element. + + + Multiline editable text field element. + + + Color picker element. + + + Table element. + + + Table/tree cell element. + + + Table/tree row element. + + + Table/tree row group element. + + + Table/tree row header element. + + + Table/tree column header element. + + + Tree view element. + + + Tree view item element. + + + List element. + + + List item element. + + + List view element. + + + List view item element. + + + Tab bar element. + + + Tab bar item element. + + + Tab panel element. + + + Menu bar element. + + + Popup menu element. + + + Popup menu item element. + + + Popup menu check button item element. + + + Popup menu radio button item element. + + + Image element. + + + Window element. + + + Embedded window title bar element. + + + Dialog window element. + + + Tooltip element. + + + Other/unknown popup type. + + + Popup menu. + + + Popup list. + + + Popup tree view. + + + Popup dialog. + + + Element is hidden for accessibility tools. + + + + + Element is support multiple item selection. + + + Element require user input. + + + Element is a visited link. + + + Element content is not ready (e.g. loading). + + + Element is modal window. + + + Element allows touches to be passed through when a screen reader is in touch exploration mode. + + + Element is text field with selectable but read-only text. + + + Element is disabled. + + + Element clips children. + + + Single click action, callback argument is not set. + + + Focus action, callback argument is not set. + + + Blur action, callback argument is not set. + + + Collapse action, callback argument is not set. + + + Expand action, callback argument is not set. + + + Decrement action, callback argument is not set. + + + Increment action, callback argument is not set. + + + Hide tooltip action, callback argument is not set. + + + Show tooltip action, callback argument is not set. + + + Set text selection action, callback argument is set to [Dictionary] with the following keys: + - [code]"start_element"[/code] accessibility element of the selection start. + - [code]"start_char"[/code] character offset relative to the accessibility element of the selection start. + - [code]"end_element"[/code] accessibility element of the selection end. + - [code]"end_char"[/code] character offset relative to the accessibility element of the selection end. + + + Replace text action, callback argument is set to [String] with the replacement text. + + + Scroll backward action, callback argument is not set. + + + Scroll down action, callback argument is not set. + + + Scroll forward action, callback argument is not set. + + + Scroll left action, callback argument is not set. + + + Scroll right action, callback argument is not set. + + + Scroll up action, callback argument is not set. + + + Scroll into view action, callback argument is not set. + + + Scroll to point action, callback argument is set to [Vector2] with the relative point coordinates. + + + Set scroll offset action, callback argument is set to [Vector2] with the scroll offset. + + + Set value action action, callback argument is set to [String] or number with the new value. + + + Show context menu action, callback argument is not set. + + + Custom action, callback argument is set to the integer action id. + + + Indicates that updates to the live region should not be presented. + + + Indicates that updates to the live region should be presented at the next opportunity (for example at the end of speaking the current sentence). + + + Indicates that updates to the live region have the highest priority and should be presented immediately. + Makes the mouse cursor visible if it is hidden. diff --git a/doc/classes/EditorProperty.xml b/doc/classes/EditorProperty.xml index cf8296841d44..aea0a2189291 100644 --- a/doc/classes/EditorProperty.xml +++ b/doc/classes/EditorProperty.xml @@ -118,6 +118,7 @@ Used by the inspector, set to [code]true[/code] when the property is drawn with the editor theme's warning color. This is used for editable children's properties. + Used by the inspector, set to [code]true[/code] when the property can add keys for animation. diff --git a/doc/classes/EditorSettings.xml b/doc/classes/EditorSettings.xml index 5a765d56f8ef..bc86d9e1c560 100644 --- a/doc/classes/EditorSettings.xml +++ b/doc/classes/EditorSettings.xml @@ -233,6 +233,9 @@ The tint intensity to use for the subresources background in the Inspector dock. The tint is used to distinguish between different subresources in the inspector. Higher values result in a more noticeable background color difference. + + If [code]true[/code], accessibility related warnings are displayed alongside other configuration warnings. + If [code]true[/code], when a node is deleted with animation tracks referencing it, a confirmation dialog appears before the tracks are deleted. The dialog will appear even when using the "Delete (No Confirm)" shortcut. diff --git a/doc/classes/GraphEdit.xml b/doc/classes/GraphEdit.xml index 4c0847871b4c..39d3af920f9f 100644 --- a/doc/classes/GraphEdit.xml +++ b/doc/classes/GraphEdit.xml @@ -391,6 +391,9 @@ If [code]true[/code], enables snapping. + + [Dictionary] of human readable port type names. + The current zoom value. @@ -603,5 +606,8 @@ The background drawn under the grid. + + [StyleBox] used when the [GraphEdit] is focused (when used with assistive apps). + diff --git a/doc/classes/GraphNode.xml b/doc/classes/GraphNode.xml index fc8bc15b5c25..a9445c331973 100644 --- a/doc/classes/GraphNode.xml +++ b/doc/classes/GraphNode.xml @@ -267,6 +267,7 @@ + If [code]true[/code], you can connect ports with different types, even if the connection was not explicitly allowed in the parent [GraphEdit]. @@ -299,12 +300,18 @@ The default background for the slot area of the [GraphNode]. + + [StyleBox] used when the [GraphNode] is focused (when used with assistive apps). + The [StyleBox] used for the slot area when selected. The [StyleBox] used for each slot of the [GraphNode]. + + [StyleBox] used when the slot is focused (when used with assistive apps). + The [StyleBox] used for the title bar of the [GraphNode]. diff --git a/doc/classes/InputMap.xml b/doc/classes/InputMap.xml index 0abd7c69742f..c4b9695a164b 100644 --- a/doc/classes/InputMap.xml +++ b/doc/classes/InputMap.xml @@ -90,6 +90,13 @@ If [param exact_match] is [code]false[/code], it ignores additional input modifiers for [InputEventKey] and [InputEventMouseButton] events, and the direction for [InputEventJoypadMotion] events. + + + + + Returns the human-readable description of the given action. + + diff --git a/doc/classes/Label.xml b/doc/classes/Label.xml index 6f99d27cb16d..2e39d9539c15 100644 --- a/doc/classes/Label.xml +++ b/doc/classes/Label.xml @@ -58,6 +58,7 @@ Ellipsis character used for text clipping. + Controls the text's horizontal alignment. Supports left, center, right, and fill, or justify. Set it to one of the [enum HorizontalAlignment] constants. @@ -153,6 +154,9 @@ Font size of the [Label]'s text. + + [StyleBox] used when the [Label] is focused (when used with assistive apps). + Background [StyleBox] for the [Label]. diff --git a/doc/classes/LinkButton.xml b/doc/classes/LinkButton.xml index b1b3d7471118..802899858acc 100644 --- a/doc/classes/LinkButton.xml +++ b/doc/classes/LinkButton.xml @@ -10,7 +10,7 @@ - + Language code used for line-breaking and text shaping algorithms, if left empty current locale is used instead. diff --git a/doc/classes/MenuBar.xml b/doc/classes/MenuBar.xml index d2303622bfa2..2fecdd2381b0 100644 --- a/doc/classes/MenuBar.xml +++ b/doc/classes/MenuBar.xml @@ -100,6 +100,7 @@ Flat [MenuBar] don't display item decoration. + Language code used for line-breaking and text shaping algorithms, if left empty current locale is used instead. diff --git a/doc/classes/MenuButton.xml b/doc/classes/MenuButton.xml index 16b3772fa90d..a1e0b34ffc4a 100644 --- a/doc/classes/MenuButton.xml +++ b/doc/classes/MenuButton.xml @@ -34,7 +34,7 @@ - + The number of items currently in the list. diff --git a/doc/classes/Node.xml b/doc/classes/Node.xml index 1e27ed486027..8521acd22234 100644 --- a/doc/classes/Node.xml +++ b/doc/classes/Node.xml @@ -36,6 +36,20 @@ Corresponds to the [constant NOTIFICATION_EXIT_TREE] notification in [method Object._notification] and signal [signal tree_exiting]. To get notified when the node has already left the active tree, connect to the [signal tree_exited]. + + + + The elements in the array returned from this method are displayed as warnings in the Scene dock if the script that overrides it is a [code]tool[/code] script, and accessibility warnings are enabled in the editor settings. + Returning an empty array produces no warnings. + + + + + + + Return a human-readable description of the position of [param node] child in the custom container, added to the node name. + + @@ -56,6 +70,12 @@ [/codeblock] + + + + Called during accessibility information updates to determine the currently focused sub-element, should return a sub-element RID or the value returned by [method get_accessibility_element]. + + @@ -299,6 +319,13 @@ [b]Note:[/b] As this method walks upwards in the scene tree, it can be slow in large, deeply nested nodes. Consider storing a reference to the found node in a variable. Alternatively, use [method get_node] with unique names (see [member unique_name_in_owner]). + + + + Returns main accessibility element RID. + [b]Note:[/b] This method should be called only during accessibility information updates ([constant NOTIFICATION_ACCESSIBILITY_UPDATE]). + + @@ -777,6 +804,12 @@ Calls [method Object.notification] with [param what] on this node and all of its children, recursively. + + + + Queues an accessibility information update for this node. + + @@ -994,6 +1027,27 @@ + + The list of nodes which are controlled by this node. + + + The list of nodes which are describing this node. + + + The human-readable node description that is reported to assistive apps. + + + The list of nodes which this node flows into. + + + The list of nodes which label this node. + + + Live region update mode, a live region is [Node] that is updated as a result of an external event when user focus may be elsewhere. + + + The human-readable node name that is reported to assistive apps. + Defines if any text should automatically change to its translated version depending on the current locale (for nodes such as [Label], [RichTextLabel], [Window], etc.). Also decides if the node's strings should be parsed for POT generation. [b]Note:[/b] For the root node, auto translate mode can also be set via [member ProjectSettings.internationalization/rendering/root_node_auto_translate]. @@ -1276,6 +1330,12 @@ Notification received when the [TextServer] is changed. + + Notification received when an accessibility information update is required. + + + Notification received when accessibility elements are invalidated. All node accessibility elements are automatically deleted after receiving this message, therefore all existing references to such elements should be discarded. + Inherits [member process_mode] from the node's parent. This is the default for any newly created node. diff --git a/doc/classes/ProjectSettings.xml b/doc/classes/ProjectSettings.xml index a156c0ad2756..e878c245e789 100644 --- a/doc/classes/ProjectSettings.xml +++ b/doc/classes/ProjectSettings.xml @@ -235,6 +235,16 @@ + + Accessibility support mode: + - [b]Auto[/b] ([code]0[/code]): accessibility support is enabled, but accessibility information updates are processed only if an assistive app (e.g. screen reader or Braille display) is active (default). + - [b]Always Active[/b] ([code]1[/code]): accessibility support is enabled, and accessibility information updates are processed regardless of current assistive apps' status. + - [b]Disabled[/b] ([code]2[/code]): accessibility support is fully disabled. + [b]Note:[/b] Accessibility debugging tools, such as Accessibility Insights for Windows, macOS Accessibility Inspector, or AT-SPI Browser do not count as assistive apps. To test your app with these tools, use [code]1[/code]. + + + The number of accessibility information updates per second. + If [code]true[/code], [AnimationMixer] prints the warning of interpolation being forced to choose the shortest rotation path due to multiple angle interpolation types being mixed in the [AnimationMixer] cache. @@ -1191,6 +1201,10 @@ Default [InputEventAction] to confirm a focused button, menu or list item, or validate input. [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. + + Default [InputEventAction] to start or end a drag-and-drop operation without using mouse. + [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. + Default [InputEventAction] to discard a modal or pending input. [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. @@ -1227,6 +1241,10 @@ Default [InputEventAction] to go up one directory in a [FileDialog]. [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. + + Default [InputEventAction] to switch [TextEdit] [member input/ui_text_indent] between moving keyboard focus to the next [Control] in the scene and inputting a [code]Tab[/code] character. + [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. + Default [InputEventAction] to focus the next [Control] in the scene. The focus behavior can be configured via [member Control.focus_next]. [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. @@ -1243,6 +1261,20 @@ Default [InputEventAction] to duplicate a [GraphNode] in a [GraphEdit]. [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. + + Default [InputEventAction] to follow a [GraphNode] input port connection. + [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. + + + macOS specific override for the shortcut to follow a [GraphNode] input port connection. + + + Default [InputEventAction] to follow a [GraphNode] output port connection. + [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. + + + macOS specific override for the shortcut to follow a [GraphNode] output port connection. + Default [InputEventAction] to go to the start position of a [Control] (e.g. first item in an [ItemList] or a [Tree]), matching the behavior of [constant KEY_HOME] on typical desktop UI systems. [b]Note:[/b] Default [code]ui_*[/code] actions cannot be removed as they are necessary for the internal logic of several [Control]s. The events assigned to the action can however be modified. diff --git a/doc/classes/RichTextLabel.xml b/doc/classes/RichTextLabel.xml index 8ef40f777bcd..2786879d352a 100644 --- a/doc/classes/RichTextLabel.xml +++ b/doc/classes/RichTextLabel.xml @@ -29,6 +29,7 @@ + Adds an image's opening and closing tags to the tag stack, optionally providing a [param width] and [param height] to resize the image, a [param color] to tint the image and a [param region] to only use parts of the image. If [param width] or [param height] is set to 0, the image size will be adjusted in order to keep the original aspect ratio. @@ -36,6 +37,7 @@ [param key] is an optional identifier, that can be used to modify the image via [method update_image]. If [param pad] is set, and the image is smaller than the size specified by [param width] and [param height], the image padding is added to match the size instead of upscaling. If [param size_in_percent] is set, [param width] and [param height] values are percentages of the control width instead of pixels. + [param alt_text] is used as the image description for assistive apps. @@ -517,8 +519,9 @@ + - Adds a [code skip-lint][table=columns,inline_align][/code] tag to the tag stack. Use [method set_table_column_expand] to set column expansion ratio. Use [method push_cell] to add cells. + Adds a [code skip-lint][table=columns,inline_align][/code] tag to the tag stack. Use [method set_table_column_expand] to set column expansion ratio. Use [method push_cell] to add cells. [param name] is used as the table name for assistive apps. @@ -612,6 +615,14 @@ If [param expand] is [code]false[/code], the column will not contribute to the total ratio. + + + + + + Sets table column name for assistive apps. + + @@ -658,6 +669,7 @@ If [code]true[/code], the label's minimum size will be automatically updated to fit its content, matching the behavior of [Label]. + If [code]true[/code], the label underlines hint tags such as [code skip-lint][hint=description]{text}[/hint][/code]. diff --git a/doc/classes/SceneTree.xml b/doc/classes/SceneTree.xml index 5ae21ad138d5..31459dcdddd6 100644 --- a/doc/classes/SceneTree.xml +++ b/doc/classes/SceneTree.xml @@ -152,6 +152,18 @@ Returns [code]true[/code] if a node added to the given group [param name] exists in the tree. + + + + Returns [code]true[/code] if accessibility features are enabled, and accessibility information updates are actively processed. + + + + + + Returns [code]true[/code] if accessibility features are supported by the OS and enabled in project settings. + + diff --git a/doc/classes/ScrollBar.xml b/doc/classes/ScrollBar.xml index 4ee05632a59d..d9f0217638a3 100644 --- a/doc/classes/ScrollBar.xml +++ b/doc/classes/ScrollBar.xml @@ -12,6 +12,7 @@ Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the [ScrollBar] is focused. + diff --git a/doc/classes/TextEdit.xml b/doc/classes/TextEdit.xml index 330ea49292fe..aa591c2e38ab 100644 --- a/doc/classes/TextEdit.xml +++ b/doc/classes/TextEdit.xml @@ -1380,6 +1380,9 @@ The syntax highlighter to use. [b]Note:[/b] A [SyntaxHighlighter] instance should not be used across multiple [TextEdit] nodes. + + If [code]true[/code], [member ProjectSettings.input/ui_text_indent] input [code]Tab[/code] character, otherwise it moves keyboard focus to the next [Control] in the scene. + String value of the [TextEdit]. diff --git a/doc/classes/TextLine.xml b/doc/classes/TextLine.xml index 2e4a3f7e4c82..f5164ad61c95 100644 --- a/doc/classes/TextLine.xml +++ b/doc/classes/TextLine.xml @@ -56,6 +56,12 @@ Draw text into a canvas item at a given position, with [param color]. [param pos] specifies the top left corner of the bounding box. + + + + Returns the text writing direction inferred by the BiDi algorithm. + + diff --git a/doc/classes/TextParagraph.xml b/doc/classes/TextParagraph.xml index c9ac660b8c49..2b590f32db4c 100644 --- a/doc/classes/TextParagraph.xml +++ b/doc/classes/TextParagraph.xml @@ -122,6 +122,12 @@ Returns drop cap bounding box size. + + + + Returns the text writing direction inferred by the BiDi algorithm. + + @@ -205,6 +211,12 @@ Returns the size of the bounding box of the paragraph, without line breaks. + + + + Returns the character range of the paragraph. + + diff --git a/doc/classes/TextServer.xml b/doc/classes/TextServer.xml index 2d6c3445aa0e..09b3300a488d 100644 --- a/doc/classes/TextServer.xml +++ b/doc/classes/TextServer.xml @@ -1215,6 +1215,69 @@ [b]Note:[/b] This function is used by during project export, to include TextServer database. + + + + + Returns the number of uniform text runs in the buffer. + + + + + + + + Returns the direction of the [param index] text run (in visual order). + + + + + + + + Returns the font RID of the [param index] text run (in visual order). + + + + + + + + Returns the font size of the [param index] text run (in visual order). + + + + + + + + Returns the language of the [param index] text run (in visual order). + + + + + + + + Returns the embedded object of the [param index] text run (in visual order). + + + + + + + + Returns the source text range of the [param index] text run (in visual order). + + + + + + + + Returns the source text of the [param index] text run (in visual order). + + @@ -1238,6 +1301,29 @@ Returns text span metadata. + + + + + + Returns the text span embedded object key. + + + + + + + + Returns the text span source text. + + + + + + + Returns the text buffer source text, including object replacement characters. + + diff --git a/doc/classes/TextServerExtension.xml b/doc/classes/TextServerExtension.xml index 22bc39a4f184..ef00e7cf78fe 100644 --- a/doc/classes/TextServerExtension.xml +++ b/doc/classes/TextServerExtension.xml @@ -1323,6 +1323,77 @@ Saves optional TextServer database (e.g. ICU break iterators and dictionaries) to the file. + + + + + [b]Required.[/b] + Returns the number of uniform text runs in the buffer. + + + + + + + + [b]Required.[/b] + Returns the direction of the [param index] text run (in visual order). + + + + + + + + [b]Required.[/b] + Returns the font RID of the [param index] text run (in visual order). + + + + + + + + [b]Required.[/b] + Returns the font size of the [param index] text run (in visual order). + + + + + + + + [b]Required.[/b] + Returns the language of the [param index] text run (in visual order). + + + + + + + + [b]Required.[/b] + Returns the embedded object of the [param index] text run (in visual order). + + + + + + + + [b]Required.[/b] + Returns the source text range of the [param index] text run (in visual order). + + + + + + + + [b]Required.[/b] + Returns the source text of the [param index] text run (in visual order). + + @@ -1349,6 +1420,32 @@ Returns text span metadata. + + + + + + [b]Required.[/b] + Returns the text span embedded object key. + + + + + + + + [b]Required.[/b] + Returns the text span source text. + + + + + + + [b]Required.[/b] + Returns the text buffer source text, including object replacement characters. + + diff --git a/doc/classes/TreeItem.xml b/doc/classes/TreeItem.xml index cce31b4bb1d4..7901d3d09137 100644 --- a/doc/classes/TreeItem.xml +++ b/doc/classes/TreeItem.xml @@ -18,8 +18,9 @@ + - Adds a button with [Texture2D] [param button] to the end of the cell at column [param column]. The [param id] is used to identify the button in the according [signal Tree.button_clicked] signal and can be different from the buttons index. If not specified, the next available index is used, which may be retrieved by calling [method get_button_count] immediately before this method. Optionally, the button can be [param disabled] and have a [param tooltip_text]. + Adds a button with [Texture2D] [param button] to the end of the cell at column [param column]. The [param id] is used to identify the button in the according [signal Tree.button_clicked] signal and can be different from the buttons index. If not specified, the next available index is used, which may be retrieved by calling [method get_button_count] immediately before this method. Optionally, the button can be [param disabled] and have a [param tooltip_text]. [param alt_text] is used as the button description for assistive apps. @@ -79,6 +80,13 @@ Removes the button at index [param button_index] in column [param column]. + + + + + Returns the given column's alternative text. + + @@ -506,6 +514,14 @@ Selects the given [param column]. + + + + + + Sets the given column's alternative (description) text for assistive apps. + + @@ -532,6 +548,15 @@ Sets the given column's button [Texture2D] at index [param button_index] to [param button]. + + + + + + + Sets the given column's button alternative text (description) at index [param button_index] for assistive apps. + + diff --git a/doc/classes/Viewport.xml b/doc/classes/Viewport.xml index 644aa8e1784b..87462cabc787 100644 --- a/doc/classes/Viewport.xml +++ b/doc/classes/Viewport.xml @@ -148,6 +148,12 @@ Returns the drag data from the GUI, that was previously returned by [method Control._get_drag_data]. + + + + Returns the drag data human-readable description. + + @@ -180,6 +186,13 @@ Removes the focus from the currently focused [Control] within this viewport. If no [Control] has the focus, does nothing. + + + + + Sets the drag data human-readable description. + + diff --git a/doc/classes/Window.xml b/doc/classes/Window.xml index 4016f05628f4..29e9b61c6ac2 100644 --- a/doc/classes/Window.xml +++ b/doc/classes/Window.xml @@ -108,6 +108,12 @@ Returns [code]true[/code] if the [param flag] is set. + + + + Returns the focused window. + + diff --git a/drivers/SCsub b/drivers/SCsub index cc07a40f0912..b5624b177809 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 000000000000..6365898a81c0 --- /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 000000000000..1ab3137d89ee --- /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 000000000000..5676ebe84069 --- /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 000000000000..27b23873a871 --- /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 000000000000..1769778ff6eb --- /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 000000000000..602a287f8cfa --- /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 000000000000..b5df5c088d03 --- /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 000000000000..e2095e345cc3 --- /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 000000000000..5bad8bbd4fb7 --- /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/editor/action_map_editor.cpp b/editor/action_map_editor.cpp index b830c71c615f..2958ffc23bcd 100644 --- a/editor/action_map_editor.cpp +++ b/editor/action_map_editor.cpp @@ -257,6 +257,8 @@ Variant ActionMapEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from label->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); action_tree->set_drag_preview(label); + get_viewport()->gui_set_drag_description(vformat(RTR("Action %s"), name)); + Dictionary drag_data; if (selected->has_meta("__action")) { @@ -267,6 +269,8 @@ Variant ActionMapEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from drag_data["input_type"] = "event"; } + drag_data["source"] = selected->get_instance_id(); + action_tree->set_drop_mode_flags(Tree::DROP_MODE_INBETWEEN); return drag_data; @@ -278,9 +282,11 @@ bool ActionMapEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_d return false; } + TreeItem *source = Object::cast_to(ObjectDB::get_instance(d["source"].operator ObjectID())); TreeItem *selected = action_tree->get_selected(); - TreeItem *item = action_tree->get_item_at_position(p_point); - if (!selected || !item || item == selected) { + + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? selected : action_tree->get_item_at_position(p_point); + if (!selected || !item || item == source) { return false; } @@ -303,13 +309,13 @@ void ActionMapEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, } TreeItem *selected = action_tree->get_selected(); - TreeItem *target = action_tree->get_item_at_position(p_point); - bool drop_above = action_tree->get_drop_section_at_position(p_point) == -1; - + TreeItem *target = (p_point == Vector2(INFINITY, INFINITY)) ? selected : action_tree->get_item_at_position(p_point); if (!target) { return; } + bool drop_above = ((p_point == Vector2(INFINITY, INFINITY)) ? action_tree->get_drop_section_at_position(action_tree->get_item_rect(target).position) : action_tree->get_drop_section_at_position(p_point)) == -1; + Dictionary d = p_data; if (d["input_type"] == "action") { // Change action order. @@ -501,8 +507,8 @@ void ActionMapEditor::update_action_list(const Vector &p_action_info } // Third Column - Buttons - event_item->add_button(2, action_tree->get_editor_theme_icon(SNAME("Edit")), BUTTON_EDIT_EVENT, false, TTR("Edit Event")); - event_item->add_button(2, action_tree->get_editor_theme_icon(SNAME("Remove")), BUTTON_REMOVE_EVENT, false, TTR("Remove Event")); + event_item->add_button(2, action_tree->get_editor_theme_icon(SNAME("Edit")), BUTTON_EDIT_EVENT, false, TTR("Edit Event"), TTR("Edit Event")); + event_item->add_button(2, action_tree->get_editor_theme_icon(SNAME("Remove")), BUTTON_REMOVE_EVENT, false, TTR("Remove Event"), TTR("Remove Event")); event_item->set_button_color(2, 0, Color(1, 1, 1, 0.75)); event_item->set_button_color(2, 1, Color(1, 1, 1, 0.75)); } @@ -543,6 +549,7 @@ ActionMapEditor::ActionMapEditor() { action_list_search = memnew(LineEdit); action_list_search->set_h_size_flags(Control::SIZE_EXPAND_FILL); action_list_search->set_placeholder(TTR("Filter by Name")); + action_list_search->set_accessibility_name(TTRC("Filter by Name")); action_list_search->set_clear_button_enabled(true); action_list_search->connect(SceneStringName(text_changed), callable_mp(this, &ActionMapEditor::_search_term_updated)); top_hbox->add_child(action_list_search); @@ -550,6 +557,7 @@ ActionMapEditor::ActionMapEditor() { action_list_search_by_event = memnew(EventListenerLineEdit); action_list_search_by_event->set_h_size_flags(Control::SIZE_EXPAND_FILL); action_list_search_by_event->set_stretch_ratio(0.75); + action_list_search_by_event->set_accessibility_name(TTRC("Action Event")); action_list_search_by_event->connect("event_changed", callable_mp(this, &ActionMapEditor::_search_by_event)); action_list_search_by_event->connect(SceneStringName(focus_entered), callable_mp(this, &ActionMapEditor::_on_filter_focused)); action_list_search_by_event->connect(SceneStringName(focus_exited), callable_mp(this, &ActionMapEditor::_on_filter_unfocused)); @@ -569,6 +577,7 @@ ActionMapEditor::ActionMapEditor() { add_edit = memnew(LineEdit); add_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); add_edit->set_placeholder(TTR("Add New Action")); + add_edit->set_accessibility_name(TTRC("Add New Action")); add_edit->set_clear_button_enabled(true); add_edit->set_keep_editing_on_text_submit(true); add_edit->connect(SceneStringName(text_changed), callable_mp(this, &ActionMapEditor::_add_edit_text_changed)); @@ -597,6 +606,7 @@ ActionMapEditor::ActionMapEditor() { // Action Editor Tree action_tree = memnew(Tree); action_tree->set_v_size_flags(Control::SIZE_EXPAND_FILL); + action_tree->set_accessibility_name(TTRC("Action Map")); action_tree->set_columns(3); action_tree->set_hide_root(true); action_tree->set_column_titles_visible(true); diff --git a/editor/add_metadata_dialog.cpp b/editor/add_metadata_dialog.cpp index b9136d2f00bf..921df2919c6e 100644 --- a/editor/add_metadata_dialog.cpp +++ b/editor/add_metadata_dialog.cpp @@ -41,11 +41,13 @@ AddMetadataDialog::AddMetadataDialog() { hbc->add_child(memnew(Label(TTR("Name:")))); add_meta_name = memnew(LineEdit); + add_meta_name->set_accessibility_name(TTRC("Name:")); add_meta_name->set_custom_minimum_size(Size2(200 * EDSCALE, 1)); hbc->add_child(add_meta_name); hbc->add_child(memnew(Label(TTR("Type:")))); add_meta_type = memnew(OptionButton); + add_meta_type->set_accessibility_name(TTRC("Type:")); hbc->add_child(add_meta_type); diff --git a/editor/animation_bezier_editor.cpp b/editor/animation_bezier_editor.cpp index 240ea7179195..7e2179748435 100644 --- a/editor/animation_bezier_editor.cpp +++ b/editor/animation_bezier_editor.cpp @@ -245,6 +245,15 @@ void AnimationBezierTrackEdit::_notification(int p_what) { selected_icon = get_editor_theme_icon(SNAME("KeyBezierSelected")); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Animation bezier track editor"))); + } break; + case NOTIFICATION_DRAW: { if (animation.is_null()) { return; diff --git a/editor/animation_track_editor.cpp b/editor/animation_track_editor.cpp index a2b24ffab34a..8380e56f1629 100644 --- a/editor/animation_track_editor.cpp +++ b/editor/animation_track_editor.cpp @@ -1485,6 +1485,15 @@ void AnimationTimelineEdit::_notification(int p_what) { len_hb->set_size(Size2(get_buttons_width(), get_size().height)); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Animation timeline editor"))); + } break; + case NOTIFICATION_DRAW: { int key_range = get_size().width - get_buttons_width() - get_name_limit(); @@ -2008,10 +2017,12 @@ AnimationTimelineEdit::AnimationTimelineEdit() { expander->set_h_size_flags(SIZE_EXPAND_FILL); expander->set_mouse_filter(MOUSE_FILTER_IGNORE); len_hb->add_child(expander); + time_icon = memnew(TextureRect); time_icon->set_v_size_flags(SIZE_SHRINK_CENTER); time_icon->set_tooltip_text(TTR("Animation length (seconds)")); len_hb->add_child(time_icon); + length = memnew(EditorSpinSlider); length->set_min(SECOND_DECIMAL); length->set_max(36000); @@ -2020,11 +2031,14 @@ AnimationTimelineEdit::AnimationTimelineEdit() { length->set_custom_minimum_size(Vector2(70 * EDSCALE, 0)); length->set_hide_slider(true); length->set_tooltip_text(TTR("Animation length (seconds)")); + length->set_accessibility_name(TTRC("Animation length")); length->connect(SceneStringName(value_changed), callable_mp(this, &AnimationTimelineEdit::_anim_length_changed)); len_hb->add_child(length); + loop = memnew(Button); loop->set_flat(true); loop->set_tooltip_text(TTR("Animation Looping")); + loop->set_accessibility_name(TTRC("Animation Looping")); loop->connect(SceneStringName(pressed), callable_mp(this, &AnimationTimelineEdit::_anim_loop_pressed)); loop->set_toggle_mode(true); len_hb->add_child(loop); @@ -2056,6 +2070,15 @@ void AnimationTrackEdit::_notification(int p_what) { selected_icon = get_editor_theme_icon(SNAME("KeySelected")); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Animation track editor"))); + } break; + case NOTIFICATION_DRAW: { if (animation.is_null()) { return; @@ -3604,6 +3627,15 @@ void AnimationTrackEditGroup::_notification(int p_what) { icon_size = Vector2(1, 1) * get_theme_constant(SNAME("class_icon_size"), EditorStringName(Editor)); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Animation track group"))); + } break; + case NOTIFICATION_DRAW: { const Ref font = get_theme_font(SceneStringName(font), SNAME("Label")); const int font_size = get_theme_font_size(SceneStringName(font_size), SNAME("Label")); @@ -7674,6 +7706,7 @@ AnimationTrackEditor::AnimationTrackEditor() { bezier_edit_icon->set_toggle_mode(true); bezier_edit_icon->connect(SceneStringName(pressed), callable_mp(this, &AnimationTrackEditor::_toggle_bezier_edit)); bezier_edit_icon->set_tooltip_text(TTR("Toggle between the bezier curve editor and track editor.")); + bezier_edit_icon->set_accessibility_name(TTRC("Bezier Curve Editor")); bottom_hf->add_child(bezier_edit_icon); @@ -7692,6 +7725,7 @@ AnimationTrackEditor::AnimationTrackEditor() { selected_filter->connect(SceneStringName(pressed), callable_mp(this, &AnimationTrackEditor::_view_group_toggle)); // Same function works the same. selected_filter->set_toggle_mode(true); selected_filter->set_tooltip_text(TTR("Only show tracks from nodes selected in tree.")); + selected_filter->set_accessibility_name(TTRC("Show Tracks from Selected Nodes")); bottom_hf->add_child(selected_filter); @@ -7700,6 +7734,7 @@ AnimationTrackEditor::AnimationTrackEditor() { view_group->connect(SceneStringName(pressed), callable_mp(this, &AnimationTrackEditor::_view_group_toggle)); view_group->set_toggle_mode(true); view_group->set_tooltip_text(TTR("Group tracks by node or display them as plain list.")); + view_group->set_accessibility_name(TTRC("Group Tracks by Node")); bottom_hf->add_child(view_group); bottom_hf->add_child(memnew(VSeparator)); @@ -7711,6 +7746,7 @@ AnimationTrackEditor::AnimationTrackEditor() { snap_timeline->set_toggle_mode(true); snap_timeline->set_pressed(false); snap_timeline->set_tooltip_text(TTR("Apply snapping to timeline cursor.")); + snap_timeline->set_accessibility_name(TTRC("Apply Snapping to Cursor")); snap_keys = memnew(Button); snap_keys->set_flat(true); @@ -7719,6 +7755,7 @@ AnimationTrackEditor::AnimationTrackEditor() { snap_keys->set_toggle_mode(true); snap_keys->set_pressed(true); snap_keys->set_tooltip_text(TTR("Apply snapping to selected key(s).")); + snap_keys->set_accessibility_name(TTRC("Apply Snapping to Selected Key")); fps_compat = memnew(Button); fps_compat->set_flat(true); @@ -7727,6 +7764,7 @@ AnimationTrackEditor::AnimationTrackEditor() { fps_compat->set_toggle_mode(true); fps_compat->set_pressed(true); fps_compat->set_tooltip_text(TTR("Apply snapping to the nearest integer FPS.")); + fps_compat->set_accessibility_name(TTRC("Apply Snapping to Nearest Integer FPS")); fps_compat->connect(SceneStringName(toggled), callable_mp(this, &AnimationTrackEditor::_update_fps_compat_mode)); nearest_fps_label = memnew(Label); @@ -7740,6 +7778,7 @@ AnimationTrackEditor::AnimationTrackEditor() { step->set_hide_slider(true); step->set_custom_minimum_size(Size2(100, 0) * EDSCALE); step->set_tooltip_text(TTR("Animation step value.")); + step->set_accessibility_name(TTRC("Animation Step Value")); bottom_hf->add_child(step); step->connect(SceneStringName(value_changed), callable_mp(this, &AnimationTrackEditor::_update_step)); step->set_read_only(true); @@ -7747,6 +7786,7 @@ AnimationTrackEditor::AnimationTrackEditor() { snap_mode = memnew(OptionButton); snap_mode->add_item(TTR("Seconds")); snap_mode->add_item(TTR("FPS")); + snap_mode->set_accessibility_name(TTRC("Snap Mode")); snap_mode->set_disabled(true); bottom_hf->add_child(snap_mode); snap_mode->connect(SceneStringName(item_selected), callable_mp(this, &AnimationTrackEditor::_snap_mode_changed)); @@ -7764,6 +7804,7 @@ AnimationTrackEditor::AnimationTrackEditor() { zoom->set_value(1.0); zoom->set_custom_minimum_size(Size2(200, 0) * EDSCALE); zoom->set_v_size_flags(SIZE_SHRINK_CENTER); + zoom->set_accessibility_name(TTRC("Zoom")); zoom_hb->add_child(zoom); bottom_hf->add_child(zoom_hb); timeline->set_zoom(zoom); @@ -7774,6 +7815,7 @@ AnimationTrackEditor::AnimationTrackEditor() { auto_fit->set_flat(true); auto_fit->connect(SceneStringName(pressed), callable_mp(this, &AnimationTrackEditor::_auto_fit)); auto_fit->set_shortcut(ED_GET_SHORTCUT("animation_editor/auto_fit")); + auto_fit->set_accessibility_name(TTRC("Auto Fit")); bottom_hf->add_child(auto_fit); auto_fit_bezier = memnew(Button); @@ -7781,6 +7823,7 @@ AnimationTrackEditor::AnimationTrackEditor() { auto_fit_bezier->set_visible(false); auto_fit_bezier->connect(SceneStringName(pressed), callable_mp(this, &AnimationTrackEditor::_auto_fit_bezier)); auto_fit_bezier->set_shortcut(ED_GET_SHORTCUT("animation_editor/auto_fit")); + auto_fit_bezier->set_accessibility_name(TTRC("Auto Fit Bezier")); bottom_hf->add_child(auto_fit_bezier); edit = memnew(MenuButton); @@ -7789,6 +7832,7 @@ AnimationTrackEditor::AnimationTrackEditor() { edit->set_flat(false); edit->set_disabled(true); edit->set_tooltip_text(TTR("Animation properties.")); + edit->set_accessibility_name(TTRC("Animation Properties")); edit->get_popup()->add_item(TTR("Copy Tracks..."), EDIT_COPY_TRACKS); edit->get_popup()->add_item(TTR("Paste Tracks"), EDIT_PASTE_TRACKS); edit->get_popup()->add_separator(); @@ -7833,10 +7877,12 @@ AnimationTrackEditor::AnimationTrackEditor() { prop_selector = memnew(PropertySelector); add_child(prop_selector); prop_selector->connect("selected", callable_mp(this, &AnimationTrackEditor::_new_track_property_selected)); + prop_selector->set_accessibility_name(TTRC("Track Property")); method_selector = memnew(PropertySelector); add_child(method_selector); method_selector->connect("selected", callable_mp(this, &AnimationTrackEditor::_add_method_key)); + method_selector->set_accessibility_name(TTRC("Method Key")); insert_confirm = memnew(ConfirmationDialog); add_child(insert_confirm); @@ -7881,18 +7927,21 @@ AnimationTrackEditor::AnimationTrackEditor() { optimize_velocity_error->set_min(0.001); optimize_velocity_error->set_step(0.001); optimize_velocity_error->set_value(0.01); + optimize_velocity_error->set_accessibility_name(TTRC("Max Velocity Error")); optimize_vb->add_margin_child(TTR("Max Velocity Error:"), optimize_velocity_error); optimize_angular_error = memnew(SpinBox); optimize_angular_error->set_max(1.0); optimize_angular_error->set_min(0.001); optimize_angular_error->set_step(0.001); optimize_angular_error->set_value(0.01); + optimize_angular_error->set_accessibility_name(TTRC("Max Angular Error")); optimize_vb->add_margin_child(TTR("Max Angular Error:"), optimize_angular_error); optimize_precision_error = memnew(SpinBox); optimize_precision_error->set_max(6); optimize_precision_error->set_min(1); optimize_precision_error->set_step(1); optimize_precision_error->set_value(3); + optimize_precision_error->set_accessibility_name(TTRC("Max Precision Error")); optimize_vb->add_margin_child(TTR("Max Precision Error:"), optimize_precision_error); optimize_dialog->set_ok_button_text(TTR("Optimize")); @@ -7943,6 +7992,7 @@ AnimationTrackEditor::AnimationTrackEditor() { scale->set_max(99999); scale->set_step(0.001); scale->set_select_all_on_focus(true); + scale->set_accessibility_name(TTRC("Scale Ratio")); vbc->add_margin_child(TTR("Scale Ratio:"), scale); scale_dialog->connect(SceneStringName(confirmed), callable_mp(this, &AnimationTrackEditor::_edit_menu_pressed).bind(EDIT_SCALE_CONFIRM), CONNECT_DEFERRED); add_child(scale_dialog); @@ -7958,6 +8008,7 @@ AnimationTrackEditor::AnimationTrackEditor() { ease_grid->set_columns(2); ease_dialog->add_child(ease_grid); transition_selection = memnew(OptionButton); + transition_selection->set_accessibility_name(TTRC("Transition Type")); transition_selection->add_item(TTR("Linear", "Transition Type"), Tween::TRANS_LINEAR); transition_selection->add_item(TTR("Sine", "Transition Type"), Tween::TRANS_SINE); transition_selection->add_item(TTR("Quint", "Transition Type"), Tween::TRANS_QUINT); @@ -7973,6 +8024,7 @@ AnimationTrackEditor::AnimationTrackEditor() { transition_selection->select(Tween::TRANS_LINEAR); // Default transition_selection->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); // Translation context is needed. ease_selection = memnew(OptionButton); + ease_selection->set_accessibility_name(TTRC("Ease Type")); ease_selection->add_item(TTR("In", "Ease Type"), Tween::EASE_IN); ease_selection->add_item(TTR("Out", "Ease Type"), Tween::EASE_OUT); ease_selection->add_item(TTR("InOut", "Ease Type"), Tween::EASE_IN_OUT); @@ -7984,6 +8036,7 @@ AnimationTrackEditor::AnimationTrackEditor() { ease_fps->set_max(999); ease_fps->set_step(FPS_DECIMAL); ease_fps->set_value(30); // Default + ease_fps->set_accessibility_name(TTRC("FPS")); ease_grid->add_child(memnew(Label(TTR("Transition Type:")))); ease_grid->add_child(transition_selection); ease_grid->add_child(memnew(Label(TTR("Ease Type:")))); @@ -8000,12 +8053,16 @@ AnimationTrackEditor::AnimationTrackEditor() { bake_grid->set_columns(2); bake_dialog->add_child(bake_grid); bake_trs = memnew(CheckBox); + bake_trs->set_accessibility_name(TTRC("3D Pos/Rot/Scl Track")); bake_trs->set_pressed(true); bake_blendshape = memnew(CheckBox); + bake_blendshape->set_accessibility_name(TTRC("Blendshape Track")); bake_blendshape->set_pressed(true); bake_value = memnew(CheckBox); + bake_value->set_accessibility_name(TTRC("Value Track")); bake_value->set_pressed(true); bake_fps = memnew(SpinBox); + bake_fps->set_accessibility_name(TTRC("FPS")); bake_fps->set_min(FPS_DECIMAL); bake_fps->set_max(999); bake_fps->set_step(FPS_DECIMAL); @@ -8033,6 +8090,7 @@ AnimationTrackEditor::AnimationTrackEditor() { track_copy_vbox->add_child(select_all_button); track_copy_select = memnew(Tree); + track_copy_select->set_accessibility_name(TTRC("Copy Selection")); track_copy_select->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); track_copy_select->set_h_size_flags(SIZE_EXPAND_FILL); track_copy_select->set_v_size_flags(SIZE_EXPAND_FILL); @@ -8369,6 +8427,15 @@ void AnimationMarkerEdit::_notification(int p_what) { selected_icon = get_editor_theme_icon(SNAME("MarkerSelected")); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Animation marker editor"))); + } break; + case NOTIFICATION_DRAW: { if (animation.is_null()) { return; diff --git a/editor/code_editor.cpp b/editor/code_editor.cpp index f9e397e05fa1..38e1e869c0f7 100644 --- a/editor/code_editor.cpp +++ b/editor/code_editor.cpp @@ -123,6 +123,7 @@ GotoLinePopup::GotoLinePopup() { line_input->set_select_all_on_focus(true); line_input->connect(SceneStringName(text_changed), callable_mp(this, &GotoLinePopup::_goto_line).unbind(1)); line_input->connect(SceneStringName(text_submitted), callable_mp(this, &GotoLinePopup::_submit).unbind(1)); + line_input->set_accessibility_name(TTRC("Line Number")); vbc->add_child(line_input); } @@ -753,6 +754,7 @@ void FindReplaceBar::_bind_methods() { FindReplaceBar::FindReplaceBar() { toggle_replace_button = memnew(Button); add_child(toggle_replace_button); + toggle_replace_button->set_accessibility_name(TTRC("Replace Mode")); toggle_replace_button->set_flat(true); toggle_replace_button->set_focus_mode(FOCUS_NONE); toggle_replace_button->connect(SceneStringName(pressed), callable_mp(this, &FindReplaceBar::_toggle_replace_pressed)); @@ -784,6 +786,7 @@ FindReplaceBar::FindReplaceBar() { vbc_lineedit->add_child(search_text); search_text->set_placeholder(TTR("Find")); search_text->set_tooltip_text(TTR("Find")); + search_text->set_accessibility_name(TTRC("Find")); search_text->set_custom_minimum_size(Size2(100 * EDSCALE, 0)); search_text->connect(SceneStringName(text_changed), callable_mp(this, &FindReplaceBar::_search_text_changed)); search_text->connect(SceneStringName(text_submitted), callable_mp(this, &FindReplaceBar::_search_text_submitted)); @@ -795,6 +798,7 @@ FindReplaceBar::FindReplaceBar() { find_prev = memnew(Button); find_prev->set_flat(true); find_prev->set_tooltip_text(TTR("Previous Match")); + find_prev->set_accessibility_name(TTRC("Previous Match")); hbc_button_search->add_child(find_prev); find_prev->set_focus_mode(FOCUS_NONE); find_prev->connect(SceneStringName(pressed), callable_mp(this, &FindReplaceBar::search_prev)); @@ -802,6 +806,7 @@ FindReplaceBar::FindReplaceBar() { find_next = memnew(Button); find_next->set_flat(true); find_next->set_tooltip_text(TTR("Next Match")); + find_next->set_accessibility_name(TTRC("Next Match")); hbc_button_search->add_child(find_next); find_next->set_focus_mode(FOCUS_NONE); find_next->connect(SceneStringName(pressed), callable_mp(this, &FindReplaceBar::search_next)); @@ -823,6 +828,7 @@ FindReplaceBar::FindReplaceBar() { vbc_lineedit->add_child(replace_text); replace_text->set_placeholder(TTR("Replace")); replace_text->set_tooltip_text(TTR("Replace")); + replace_text->set_accessibility_name(TTRC("Replace")); replace_text->set_custom_minimum_size(Size2(100 * EDSCALE, 0)); replace_text->connect(SceneStringName(text_submitted), callable_mp(this, &FindReplaceBar::_replace_text_submitted)); @@ -845,6 +851,7 @@ FindReplaceBar::FindReplaceBar() { hide_button = memnew(TextureButton); add_child(hide_button); hide_button->set_tooltip_text(TTR("Hide")); + hide_button->set_accessibility_name(TTRC("Hide")); hide_button->set_focus_mode(FOCUS_NONE); hide_button->connect(SceneStringName(pressed), callable_mp(this, &FindReplaceBar::_hide_bar)); hide_button->set_v_size_flags(SIZE_SHRINK_CENTER); @@ -1872,6 +1879,7 @@ CodeTextEditor::CodeTextEditor() { toggle_scripts_button->set_flat(true); toggle_scripts_button->set_v_size_flags(SIZE_EXPAND | SIZE_SHRINK_CENTER); toggle_scripts_button->connect(SceneStringName(pressed), callable_mp(this, &CodeTextEditor::_toggle_scripts_pressed)); + toggle_scripts_button->set_accessibility_name(TTRC("Scripts")); status_bar->add_child(toggle_scripts_button); toggle_scripts_button->hide(); @@ -1896,6 +1904,7 @@ CodeTextEditor::CodeTextEditor() { error_button->set_default_cursor_shape(CURSOR_POINTING_HAND); error_button->connect(SceneStringName(pressed), callable_mp(this, &CodeTextEditor::_error_button_pressed)); error_button->set_tooltip_text(TTR("Errors")); + error_button->set_accessibility_name(TTRC("Errors")); // Warnings warning_button = memnew(Button); @@ -1905,6 +1914,7 @@ CodeTextEditor::CodeTextEditor() { warning_button->set_default_cursor_shape(CURSOR_POINTING_HAND); warning_button->connect(SceneStringName(pressed), callable_mp(this, &CodeTextEditor::_warning_button_pressed)); warning_button->set_tooltip_text(TTR("Warnings")); + warning_button->set_accessibility_name(TTRC("Warnings")); status_bar->add_child(memnew(VSeparator)); @@ -1918,6 +1928,7 @@ CodeTextEditor::CodeTextEditor() { // TRANSLATORS: The placeholders are keyboard shortcuts. The first one is in the form of "Ctrl+"/"Cmd+". vformat(TTR("%sMouse wheel, %s/%s: Finetune\n%s: Reset"), keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL), ED_GET_SHORTCUT("script_editor/zoom_in")->get_as_text(), ED_GET_SHORTCUT("script_editor/zoom_out")->get_as_text(), ED_GET_SHORTCUT("script_editor/reset_zoom")->get_as_text())); zoom_button->set_text("100 %"); + zoom_button->set_accessibility_name(TTRC("Zoom Factor")); PopupMenu *zoom_menu = zoom_button->get_popup(); constexpr int preset_count = std::size(ZOOM_FACTOR_PRESETS); @@ -1937,6 +1948,7 @@ CodeTextEditor::CodeTextEditor() { status_bar->add_child(line_and_col_txt); line_and_col_txt->set_v_size_flags(SIZE_EXPAND | SIZE_SHRINK_CENTER); line_and_col_txt->set_tooltip_text(TTR("Line and column numbers.")); + line_and_col_txt->set_accessibility_name(TTRC("Line and Column Numbers")); line_and_col_txt->set_mouse_filter(MOUSE_FILTER_STOP); status_bar->add_child(memnew(VSeparator)); @@ -1946,6 +1958,7 @@ CodeTextEditor::CodeTextEditor() { status_bar->add_child(indentation_txt); indentation_txt->set_v_size_flags(SIZE_EXPAND | SIZE_SHRINK_CENTER); indentation_txt->set_tooltip_text(TTR("Indentation")); + indentation_txt->set_accessibility_name(TTRC("Indentation")); indentation_txt->set_mouse_filter(MOUSE_FILTER_STOP); text_editor->connect(SceneStringName(gui_input), callable_mp(this, &CodeTextEditor::_text_editor_gui_input)); diff --git a/editor/connections_dialog.cpp b/editor/connections_dialog.cpp index 23c7484476fc..b787667d821b 100644 --- a/editor/connections_dialog.cpp +++ b/editor/connections_dialog.cpp @@ -736,6 +736,7 @@ ConnectDialog::ConnectDialog() { vbc_left->set_custom_minimum_size(Vector2(400 * EDSCALE, 0)); from_signal = memnew(LineEdit); + from_signal->set_accessibility_name(TTRC("From Signal")); vbc_left->add_margin_child(TTR("From Signal:"), from_signal); from_signal->set_editable(false); @@ -754,6 +755,7 @@ ConnectDialog::ConnectDialog() { hbc_filter->add_child(filter_nodes); filter_nodes->set_h_size_flags(Control::SIZE_FILL | Control::SIZE_EXPAND); filter_nodes->set_placeholder(TTR("Filter Nodes")); + filter_nodes->set_accessibility_name(TTRC("Filter Nodes")); filter_nodes->set_clear_button_enabled(true); filter_nodes->connect(SceneStringName(text_changed), callable_mp(tree, &SceneTreeEditor::set_filter)); @@ -786,11 +788,13 @@ ConnectDialog::ConnectDialog() { method_search = memnew(LineEdit); method_vbc->add_child(method_search); method_search->set_placeholder(TTR("Filter Methods")); + method_search->set_accessibility_name(TTRC("Filter Methods")); method_search->set_clear_button_enabled(true); method_search->connect(SceneStringName(text_changed), callable_mp(this, &ConnectDialog::_update_method_tree).unbind(1)); method_tree = memnew(Tree); method_vbc->add_child(method_tree); + method_tree->set_accessibility_name(TTRC("Methods")); method_tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); method_tree->set_v_size_flags(Control::SIZE_EXPAND_FILL); method_tree->set_hide_root(true); @@ -824,6 +828,7 @@ ConnectDialog::ConnectDialog() { HBoxContainer *add_bind_hb = memnew(HBoxContainer); type_list = memnew(OptionButton); + type_list->set_accessibility_name(TTRC("Type")); type_list->set_h_size_flags(Control::SIZE_EXPAND_FILL); add_bind_hb->add_child(type_list); for (int i = 0; i < Variant::VARIANT_MAX; i++) { @@ -851,12 +856,14 @@ ConnectDialog::ConnectDialog() { vbc_right->add_margin_child(TTR("Add Extra Call Argument:"), add_bind_hb); bind_editor = memnew(EditorInspector); + bind_editor->set_accessibility_name(TTRC("Extra Call Arguments")); bind_controls.push_back(bind_editor); vbc_right->add_margin_child(TTR("Extra Call Arguments:"), bind_editor, true); unbind_count = memnew(SpinBox); unbind_count->set_tooltip_text(TTR("Allows to drop arguments sent by signal emitter.")); + unbind_count->set_accessibility_name(TTRC("Unbind Signal Arguments")); unbind_count->connect(SceneStringName(value_changed), callable_mp(this, &ConnectDialog::_unbind_count_changed)); vbc_right->add_margin_child(TTR("Unbind Signal Arguments:"), unbind_count); @@ -865,6 +872,7 @@ ConnectDialog::ConnectDialog() { vbc_left->add_margin_child(TTR("Receiver Method:"), hbc_method); dst_method = memnew(LineEdit); + dst_method->set_accessibility_name(TTRC("Receiver Method")); dst_method->set_h_size_flags(Control::SIZE_EXPAND_FILL); dst_method->connect(SceneStringName(text_changed), callable_mp(method_tree, &Tree::deselect_all).unbind(1)); hbc_method->add_child(dst_method); @@ -1291,11 +1299,14 @@ void ConnectionsDock::_slot_menu_about_to_popup() { } void ConnectionsDock::_tree_gui_input(const Ref &p_event) { + TreeItem *item = nullptr; + Point2 item_pos; + const Ref &key = p_event; if (key.is_valid() && key->is_pressed() && !key->is_echo()) { if (ED_IS_SHORTCUT("connections_editor/disconnect", p_event)) { - TreeItem *item = tree->get_selected(); + item = tree->get_selected(); if (item && _get_item_type(*item) == TREE_ITEM_TYPE_CONNECTION) { Connection connection = item->get_metadata(0); _disconnect(connection); @@ -1313,22 +1324,32 @@ void ConnectionsDock::_tree_gui_input(const Ref &p_event) { return; } } + if (key.is_valid() && key->is_pressed() && key->is_action("ui_menu", true)) { + item = tree->get_selected(); + if (!item) { + return; + } + item_pos = tree->get_item_rect(item).position; + } // Handle RMB press. const Ref &mb_event = p_event; if (mb_event.is_valid() && mb_event->is_pressed() && mb_event->get_button_index() == MouseButton::RIGHT) { - TreeItem *item = tree->get_item_at_position(mb_event->get_position()); + item = tree->get_item_at_position(mb_event->get_position()); if (!item) { return; } + item_pos = mb_event->get_position(); + } + if (item) { if (item->is_selectable(0)) { // Update selection now, before `about_to_popup` signal. Needed for SIGNAL and CONNECTION context menus. tree->set_selected(item); } - Vector2 screen_position = tree->get_screen_position() + mb_event->get_position(); + Vector2 screen_position = tree->get_screen_position() + item_pos; switch (_get_item_type(*item)) { case TREE_ITEM_TYPE_ROOT: @@ -1601,11 +1622,13 @@ ConnectionsDock::ConnectionsDock() { search_box = memnew(LineEdit); search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); search_box->set_placeholder(TTR("Filter Signals")); + search_box->set_accessibility_name(TTRC("Filter Signals")); search_box->set_clear_button_enabled(true); search_box->connect(SceneStringName(text_changed), callable_mp(this, &ConnectionsDock::_filter_changed)); vbc->add_child(search_box); tree = memnew(ConnectionsDockTree); + tree->set_accessibility_name(TTRC("Connections")); tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); tree->set_columns(1); tree->set_select_mode(Tree::SELECT_ROW); @@ -1616,6 +1639,7 @@ ConnectionsDock::ConnectionsDock() { tree->set_allow_rmb_select(true); connect_button = memnew(Button); + connect_button->set_accessibility_name(TTRC("Connect")); HBoxContainer *hb = memnew(HBoxContainer); vbc->add_child(hb); hb->add_spacer(); diff --git a/editor/create_dialog.cpp b/editor/create_dialog.cpp index 0e75ec45b731..55b5524c6e5d 100644 --- a/editor/create_dialog.cpp +++ b/editor/create_dialog.cpp @@ -635,7 +635,7 @@ void CreateDialog::_favorite_activated() { } Variant CreateDialog::get_drag_data_fw(const Point2 &p_point, Control *p_from) { - TreeItem *ti = favorites->get_item_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? favorites->get_selected() : favorites->get_item_at_position(p_point); if (ti) { Dictionary d; d["type"] = "create_favorite_drag"; @@ -667,13 +667,13 @@ bool CreateDialog::can_drop_data_fw(const Point2 &p_point, const Variant &p_data void CreateDialog::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { Dictionary d = p_data; - TreeItem *ti = favorites->get_item_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? favorites->get_selected() : favorites->get_item_at_position(p_point); if (!ti) { return; } String drop_at = ti->get_text(0); - int ds = favorites->get_drop_section_at_position(p_point); + int ds = (p_point == Vector2(INFINITY, INFINITY)) ? favorites->get_drop_section_at_position(favorites->get_item_rect(ti).position) : favorites->get_drop_section_at_position(p_point); int drop_idx = favorite_list.find(drop_at); if (drop_idx < 0) { @@ -787,6 +787,7 @@ CreateDialog::CreateDialog() { vsc->add_child(fav_vb); favorites = memnew(Tree); + favorites->set_accessibility_name(TTRC("Favorites")); favorites->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); favorites->set_hide_root(true); favorites->set_hide_folding(true); @@ -804,6 +805,7 @@ CreateDialog::CreateDialog() { rec_vb->set_v_size_flags(Control::SIZE_EXPAND_FILL); recent = memnew(ItemList); + recent->set_accessibility_name(TTRC("Recent")); recent->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); rec_vb->add_margin_child(TTR("Recent:"), recent, true); recent->set_allow_reselect(true); @@ -818,6 +820,7 @@ CreateDialog::CreateDialog() { hsc->add_child(vbc); search_box = memnew(LineEdit); + search_box->set_accessibility_name(TTRC("Search")); search_box->set_clear_button_enabled(true); search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); search_box->connect(SceneStringName(text_changed), callable_mp(this, &CreateDialog::_text_changed)); @@ -829,11 +832,13 @@ CreateDialog::CreateDialog() { favorite = memnew(Button); favorite->set_toggle_mode(true); favorite->set_tooltip_text(TTR("(Un)favorite selected item.")); + favorite->set_accessibility_name(TTRC("(Un)favorite")); favorite->connect(SceneStringName(pressed), callable_mp(this, &CreateDialog::_favorite_toggled)); search_hb->add_child(favorite); vbc->add_margin_child(TTR("Search:"), search_hb); search_options = memnew(Tree); + search_options->set_accessibility_name(TTRC("Matches")); search_options->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); search_options->connect("item_activated", callable_mp(this, &CreateDialog::_confirmed)); search_options->connect("cell_selected", callable_mp(this, &CreateDialog::_item_selected)); @@ -841,6 +846,7 @@ CreateDialog::CreateDialog() { vbc->add_margin_child(TTR("Matches:"), search_options, true); help_bit = memnew(EditorHelpBit); + help_bit->set_accessibility_name(TTRC("Description")); help_bit->set_content_height_limits(80 * EDSCALE, 80 * EDSCALE); help_bit->connect("request_hide", callable_mp(this, &CreateDialog::_hide_requested)); vbc->add_margin_child(TTR("Description:"), help_bit); diff --git a/editor/debugger/editor_expression_evaluator.cpp b/editor/debugger/editor_expression_evaluator.cpp index 950dd0b868fd..2c6a6df68a0a 100644 --- a/editor/debugger/editor_expression_evaluator.cpp +++ b/editor/debugger/editor_expression_evaluator.cpp @@ -110,6 +110,7 @@ EditorExpressionEvaluator::EditorExpressionEvaluator() { expression_input = memnew(LineEdit); expression_input->set_h_size_flags(Control::SIZE_EXPAND_FILL); expression_input->set_placeholder(TTR("Expression to evaluate")); + expression_input->set_accessibility_name(TTRC("Expression")); expression_input->set_clear_button_enabled(true); expression_input->connect(SceneStringName(text_submitted), callable_mp(this, &EditorExpressionEvaluator::_evaluate).unbind(1)); expression_input->connect(SceneStringName(text_changed), callable_mp(this, &EditorExpressionEvaluator::_on_expression_input_changed)); diff --git a/editor/debugger/editor_profiler.cpp b/editor/debugger/editor_profiler.cpp index 53793f35251f..741c2cfa8d72 100644 --- a/editor/debugger/editor_profiler.cpp +++ b/editor/debugger/editor_profiler.cpp @@ -694,6 +694,7 @@ EditorProfiler::EditorProfiler() { hb_measure->add_child(memnew(Label(TTR("Measure:")))); display_mode = memnew(OptionButton); + display_mode->set_accessibility_name(TTRC("Measure")); display_mode->add_item(TTR("Frame Time (ms)")); display_mode->add_item(TTR("Average Time (ms)")); display_mode->add_item(TTR("Frame %")); @@ -709,6 +710,7 @@ EditorProfiler::EditorProfiler() { hb_time->add_child(memnew(Label(TTR("Time:")))); display_time = memnew(OptionButton); + display_time->set_accessibility_name(TTRC("Time")); // TRANSLATORS: This is an option in the profiler to display the time spent in a function, including the time spent in other functions called by that function. display_time->add_item(TTR("Inclusive")); // TRANSLATORS: This is an option in the profiler to display the time spent in a function, exincluding the time spent in other functions called by that function. @@ -731,6 +733,7 @@ EditorProfiler::EditorProfiler() { hb_frame->add_child(memnew(Label(TTR("Frame #:")))); cursor_metric_edit = memnew(SpinBox); + cursor_metric_edit->set_accessibility_name(TTRC("Frame")); cursor_metric_edit->set_h_size_flags(SIZE_FILL); cursor_metric_edit->set_value(0); cursor_metric_edit->set_editable(false); diff --git a/editor/debugger/editor_visual_profiler.cpp b/editor/debugger/editor_visual_profiler.cpp index e6c43ffe19de..1f41ee2b64b8 100644 --- a/editor/debugger/editor_visual_profiler.cpp +++ b/editor/debugger/editor_visual_profiler.cpp @@ -778,6 +778,7 @@ EditorVisualProfiler::EditorVisualProfiler() { hb_measure->add_child(memnew(Label(TTR("Measure:")))); display_mode = memnew(OptionButton); + display_mode->set_accessibility_name(TTRC("Measure")); display_mode->add_item(TTR("Frame Time (ms)")); display_mode->add_item(TTR("Frame %")); display_mode->connect(SceneStringName(item_selected), callable_mp(this, &EditorVisualProfiler::_combo_changed)); @@ -801,6 +802,7 @@ EditorVisualProfiler::EditorVisualProfiler() { hb_frame->add_child(memnew(Label(TTR("Frame #:")))); cursor_metric_edit = memnew(SpinBox); + cursor_metric_edit->set_accessibility_name(TTRC("Frame")); cursor_metric_edit->set_h_size_flags(SIZE_FILL); hb_frame->add_child(cursor_metric_edit); cursor_metric_edit->connect(SceneStringName(value_changed), callable_mp(this, &EditorVisualProfiler::_cursor_metric_changed)); diff --git a/editor/debugger/script_editor_debugger.cpp b/editor/debugger/script_editor_debugger.cpp index 44cc7986c785..6efe1be8d372 100644 --- a/editor/debugger/script_editor_debugger.cpp +++ b/editor/debugger/script_editor_debugger.cpp @@ -1957,11 +1957,13 @@ ScriptEditorDebugger::ScriptEditorDebugger() { skip_breakpoints->set_theme_type_variation(SceneStringName(FlatButton)); hbc->add_child(skip_breakpoints); skip_breakpoints->set_tooltip_text(TTR("Skip Breakpoints")); + skip_breakpoints->set_accessibility_name(TTRC("Skip Breakpoints")); skip_breakpoints->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditorDebugger::debug_skip_breakpoints)); ignore_error_breaks = memnew(Button); ignore_error_breaks->set_flat(true); ignore_error_breaks->set_tooltip_text(TTR("Ignore Error Breaks")); + ignore_error_breaks->set_accessibility_name(TTRC("Ignore Error Breaks")); hbc->add_child(ignore_error_breaks); ignore_error_breaks->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_ignore_error_breaks)); @@ -1971,6 +1973,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() { copy->set_theme_type_variation(SceneStringName(FlatButton)); hbc->add_child(copy); copy->set_tooltip_text(TTR("Copy Error")); + copy->set_accessibility_name(TTRC("Copy Error")); copy->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditorDebugger::debug_copy)); hbc->add_child(memnew(VSeparator)); @@ -1979,6 +1982,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() { step->set_theme_type_variation(SceneStringName(FlatButton)); hbc->add_child(step); step->set_tooltip_text(TTR("Step Into")); + step->set_accessibility_name(TTRC("Step Into")); step->set_shortcut(ED_GET_SHORTCUT("debugger/step_into")); step->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditorDebugger::debug_step)); @@ -1986,6 +1990,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() { next->set_theme_type_variation(SceneStringName(FlatButton)); hbc->add_child(next); next->set_tooltip_text(TTR("Step Over")); + next->set_accessibility_name(TTRC("Step Over")); next->set_shortcut(ED_GET_SHORTCUT("debugger/step_over")); next->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditorDebugger::debug_next)); @@ -1995,6 +2000,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() { dobreak->set_theme_type_variation(SceneStringName(FlatButton)); hbc->add_child(dobreak); dobreak->set_tooltip_text(TTR("Break")); + dobreak->set_accessibility_name(TTRC("Break")); dobreak->set_shortcut(ED_GET_SHORTCUT("debugger/break")); dobreak->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditorDebugger::debug_break)); @@ -2002,6 +2008,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() { docontinue->set_theme_type_variation(SceneStringName(FlatButton)); hbc->add_child(docontinue); docontinue->set_tooltip_text(TTR("Continue")); + docontinue->set_accessibility_name(TTRC("Continue")); docontinue->set_shortcut(ED_GET_SHORTCUT("debugger/continue")); docontinue->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditorDebugger::debug_continue)); @@ -2050,6 +2057,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() { search = memnew(LineEdit); search->set_h_size_flags(Control::SIZE_EXPAND_FILL); search->set_placeholder(TTR("Filter Stack Variables")); + search->set_accessibility_name(TTRC("Filter Stack Variables")); search->set_clear_button_enabled(true); tools_hb->add_child(search); @@ -2184,14 +2192,17 @@ ScriptEditorDebugger::ScriptEditorDebugger() { vmem_hb->add_child(memnew(Label(TTR("Total:") + " "))); vmem_total = memnew(LineEdit); vmem_total->set_editable(false); + vmem_total->set_accessibility_name(TTRC("Video RAM Total")); vmem_total->set_custom_minimum_size(Size2(100, 0) * EDSCALE); vmem_hb->add_child(vmem_total); vmem_refresh = memnew(Button); + vmem_refresh->set_accessibility_name(TTRC("Refresh Video RAM")); vmem_refresh->set_theme_type_variation(SceneStringName(FlatButton)); vmem_hb->add_child(vmem_refresh); vmem_export = memnew(Button); vmem_export->set_theme_type_variation(SceneStringName(FlatButton)); vmem_export->set_tooltip_text(TTR("Export list to a CSV file")); + vmem_export->set_accessibility_name(TTRC("Export to CSV")); vmem_hb->add_child(vmem_export); vmem_vb->add_child(vmem_hb); vmem_refresh->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditorDebugger::_video_mem_request)); @@ -2235,11 +2246,13 @@ ScriptEditorDebugger::ScriptEditorDebugger() { misc->add_child(info_left); clicked_ctrl = memnew(LineEdit); clicked_ctrl->set_editable(false); + clicked_ctrl->set_accessibility_name(TTRC("Clicked Control")); clicked_ctrl->set_h_size_flags(SIZE_EXPAND_FILL); info_left->add_child(memnew(Label(TTR("Clicked Control:")))); info_left->add_child(clicked_ctrl); clicked_ctrl_type = memnew(LineEdit); clicked_ctrl_type->set_editable(false); + clicked_ctrl_type->set_accessibility_name(TTRC("Clicked Control Type")); info_left->add_child(memnew(Label(TTR("Clicked Control Type:")))); info_left->add_child(clicked_ctrl_type); @@ -2247,6 +2260,7 @@ ScriptEditorDebugger::ScriptEditorDebugger() { live_edit_root = memnew(LineEdit); live_edit_root->set_editable(false); live_edit_root->set_h_size_flags(SIZE_EXPAND_FILL); + live_edit_root->set_accessibility_name(TTRC("Live Edit Root")); { HBoxContainer *lehb = memnew(HBoxContainer); diff --git a/editor/dependency_editor.cpp b/editor/dependency_editor.cpp index a962a4b5592d..e8182052335d 100644 --- a/editor/dependency_editor.cpp +++ b/editor/dependency_editor.cpp @@ -678,6 +678,7 @@ DependencyRemoveDialog::DependencyRemoveDialog() { files_to_delete_list->set_h_size_flags(Control::SIZE_EXPAND_FILL); files_to_delete_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); files_to_delete_list->set_custom_minimum_size(Size2(0, 94) * EDSCALE); + files_to_delete_list->set_accessibility_name(TTRC("Files to be Deleted")); vb->add_child(files_to_delete_list); vb_owners = memnew(VBoxContainer); @@ -694,6 +695,7 @@ DependencyRemoveDialog::DependencyRemoveDialog() { owners->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); owners->set_hide_root(true); owners->set_custom_minimum_size(Size2(0, 94) * EDSCALE); + owners->set_accessibility_name(TTRC("Dependencies")); vb_owners->add_child(owners); owners->set_v_size_flags(Control::SIZE_EXPAND_FILL); diff --git a/editor/directory_create_dialog.cpp b/editor/directory_create_dialog.cpp index 43c85134be97..69198a375714 100644 --- a/editor/directory_create_dialog.cpp +++ b/editor/directory_create_dialog.cpp @@ -166,6 +166,7 @@ DirectoryCreateDialog::DirectoryCreateDialog() { vb->add_child(name_label); dir_path = memnew(LineEdit); + dir_path->set_accessibility_name(TTRC("Name")); vb->add_child(dir_path); register_text_enter(dir_path); diff --git a/editor/editor_asset_installer.cpp b/editor/editor_asset_installer.cpp index 5035900fe87e..26393e03d3df 100644 --- a/editor/editor_asset_installer.cpp +++ b/editor/editor_asset_installer.cpp @@ -684,6 +684,7 @@ EditorAssetInstaller::EditorAssetInstaller() { show_source_files_button = memnew(Button); show_source_files_button->set_toggle_mode(true); show_source_files_button->set_tooltip_text(TTR("Open the list of the asset contents and select which files to install.")); + show_source_files_button->set_accessibility_name(TTRC("Show Asset Contents")); remapping_tools->add_child(show_source_files_button); show_source_files_button->connect(SceneStringName(toggled), callable_mp(this, &EditorAssetInstaller::_toggle_source_tree).bind(false)); @@ -708,6 +709,7 @@ EditorAssetInstaller::EditorAssetInstaller() { asset_conflicts_label->set_text(TTR("No files conflict with your project")); remapping_tools->add_child(asset_conflicts_label); asset_conflicts_link = memnew(LinkButton); + asset_conflicts_link->set_accessibility_name(TTRC("Show Conflicting Files")); asset_conflicts_link->set_theme_type_variation("HeaderSmallLink"); asset_conflicts_link->set_v_size_flags(Control::SIZE_SHRINK_CENTER); asset_conflicts_link->set_tooltip_text(TTR("Show contents of the asset and conflicting files.")); @@ -732,6 +734,7 @@ EditorAssetInstaller::EditorAssetInstaller() { source_tree_vb->add_child(source_tree_label); source_tree = memnew(Tree); + source_tree->set_accessibility_name(TTRC("Source Files")); source_tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); source_tree->set_v_size_flags(Control::SIZE_EXPAND_FILL); source_tree->connect("item_edited", callable_mp(this, &EditorAssetInstaller::_item_checked_cbk)); @@ -748,6 +751,7 @@ EditorAssetInstaller::EditorAssetInstaller() { destination_tree_vb->add_child(destination_tree_label); destination_tree = memnew(Tree); + destination_tree->set_accessibility_name(TTRC("Destination Files")); destination_tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); destination_tree->set_v_size_flags(Control::SIZE_EXPAND_FILL); destination_tree->connect("item_edited", callable_mp(this, &EditorAssetInstaller::_item_checked_cbk)); diff --git a/editor/editor_audio_buses.cpp b/editor/editor_audio_buses.cpp index a5ffac21d468..b7054fe461a2 100644 --- a/editor/editor_audio_buses.cpp +++ b/editor/editor_audio_buses.cpp @@ -130,6 +130,14 @@ void EditorAudioBus::_notification(int p_what) { set_process(true); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Audio bus editor"))); + } break; + case NOTIFICATION_DRAW: { if (is_master) { draw_style_box(get_theme_stylebox(SNAME("disabled"), SNAME("Button")), Rect2(Vector2(), get_size())); @@ -583,6 +591,15 @@ void EditorAudioBus::gui_input(const Ref &p_event) { bus_popup->reset_size(); bus_popup->popup(); } + + Ref k = p_event; + if (k.is_valid() && k->is_pressed() && k->is_action("ui_menu", true)) { + bus_popup->set_position(get_screen_position()); + bus_popup->reset_size(); + bus_popup->popup(); + + accept_event(); + } } void EditorAudioBus::_effects_gui_input(Ref p_event) { @@ -619,7 +636,7 @@ Variant EditorAudioBus::get_drag_data(const Point2 &p_point) { p->set_modulate(Color(1, 1, 1, 0.7)); p->add_theme_style_override(SceneStringName(panel), get_theme_stylebox(SNAME("focus"), SNAME("Button"))); p->set_size(get_size()); - p->set_position(-p_point); + p->set_position((p_point == Vector2(INFINITY, INFINITY)) ? Vector2() : -p_point); set_drag_preview(c); Dictionary d; d["type"] = "move_audio_bus"; @@ -652,7 +669,7 @@ void EditorAudioBus::drop_data(const Point2 &p_point, const Variant &p_data) { } Variant EditorAudioBus::get_drag_data_fw(const Point2 &p_point, Control *p_from) { - TreeItem *item = effects->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? effects->get_selected() : effects->get_item_at_position(p_point); if (!item) { return Variant(); } @@ -681,7 +698,7 @@ bool EditorAudioBus::can_drop_data_fw(const Point2 &p_point, const Variant &p_da return false; } - TreeItem *item = effects->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? effects->get_selected() : effects->get_item_at_position(p_point); if (!item) { return false; } @@ -694,11 +711,11 @@ bool EditorAudioBus::can_drop_data_fw(const Point2 &p_point, const Variant &p_da void EditorAudioBus::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { Dictionary d = p_data; - TreeItem *item = effects->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? effects->get_selected() : effects->get_item_at_position(p_point); if (!item) { return; } - int pos = effects->get_drop_section_at_position(p_point); + int pos = (p_point == Vector2(INFINITY, INFINITY)) ? effects->get_drop_section_at_position(effects->get_item_rect(item).position) : effects->get_drop_section_at_position(p_point); Variant md = item->get_metadata(0); int paste_at; @@ -815,6 +832,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { set_v_size_flags(SIZE_EXPAND_FILL); track_name = memnew(LineEdit); + track_name->set_accessibility_name(TTRC("Track Name")); track_name->connect(SceneStringName(text_submitted), callable_mp(this, &EditorAudioBus::_name_changed)); track_name->connect(SceneStringName(focus_exited), callable_mp(this, &EditorAudioBus::_name_focus_exit)); vb->add_child(track_name); @@ -825,6 +843,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { solo->set_theme_type_variation(SceneStringName(FlatButton)); solo->set_toggle_mode(true); solo->set_tooltip_text(TTR("Solo")); + solo->set_accessibility_name(TTRC("Solo")); solo->set_focus_mode(FOCUS_NONE); solo->connect(SceneStringName(pressed), callable_mp(this, &EditorAudioBus::_solo_toggled)); hbc->add_child(solo); @@ -832,6 +851,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { mute->set_theme_type_variation(SceneStringName(FlatButton)); mute->set_toggle_mode(true); mute->set_tooltip_text(TTR("Mute")); + mute->set_accessibility_name(TTRC("Mute")); mute->set_focus_mode(FOCUS_NONE); mute->connect(SceneStringName(pressed), callable_mp(this, &EditorAudioBus::_mute_toggled)); hbc->add_child(mute); @@ -839,6 +859,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { bypass->set_theme_type_variation(SceneStringName(FlatButton)); bypass->set_toggle_mode(true); bypass->set_tooltip_text(TTR("Bypass")); + bypass->set_accessibility_name(TTRC("Bypass")); bypass->set_focus_mode(FOCUS_NONE); bypass->connect(SceneStringName(pressed), callable_mp(this, &EditorAudioBus::_bypass_toggled)); hbc->add_child(bypass); @@ -886,6 +907,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { slider->set_max(1.0); slider->set_step(0.0001); slider->set_clip_contents(false); + slider->set_accessibility_name(TTRC("Volume")); audio_value_preview_box = memnew(Panel); slider->add_child(audio_value_preview_box); @@ -922,6 +944,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { channel[i].vu_l->set_min(-80); channel[i].vu_l->set_max(24); channel[i].vu_l->set_step(0.1); + channel[i].vu_l->set_accessibility_name(vformat(TTR("Channel %d, Left VU"), i)); channel[i].vu_r = memnew(TextureProgressBar); channel[i].vu_r->set_fill_mode(TextureProgressBar::FILL_BOTTOM_TO_TOP); @@ -929,6 +952,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { channel[i].vu_r->set_min(-80); channel[i].vu_r->set_max(24); channel[i].vu_r->set_step(0.1); + channel[i].vu_r->set_accessibility_name(vformat(TTR("Channel %d, Right VU"), i)); channel[i].peak_l = 0.0f; channel[i].peak_r = 0.0f; @@ -944,6 +968,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { hb->add_child(scale); effects = memnew(Tree); + effects->set_accessibility_name(TTRC("Effects")); effects->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); effects->set_hide_root(true); effects->set_custom_minimum_size(Size2(0, 80) * EDSCALE); @@ -963,6 +988,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { effects->connect(SceneStringName(gui_input), callable_mp(this, &EditorAudioBus::_effects_gui_input)); send = memnew(OptionButton); + send->set_accessibility_name(TTRC("Send")); send->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); send->set_clip_text(true); send->connect(SceneStringName(item_selected), callable_mp(this, &EditorAudioBus::_send_selected)); @@ -992,6 +1018,7 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) { bus_options->set_h_size_flags(SIZE_SHRINK_END); bus_options->set_anchor(SIDE_RIGHT, 0.0); bus_options->set_tooltip_text(TTR("Bus Options")); + bus_options->set_accessibility_name(TTRC("Bus Options")); hbc->add_child(bus_options); bus_popup = bus_options->get_popup(); diff --git a/editor/editor_autoload_settings.cpp b/editor/editor_autoload_settings.cpp index f1430c54836c..cb5a9d0cc206 100644 --- a/editor/editor_autoload_settings.cpp +++ b/editor/editor_autoload_settings.cpp @@ -659,13 +659,13 @@ bool EditorAutoloadSettings::can_drop_data_fw(const Point2 &p_point, const Varia } if (drop_data.has("type")) { - TreeItem *ti = tree->get_item_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); if (!ti) { return false; } - int section = tree->get_drop_section_at_position(p_point); + int section = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_drop_section_at_position(tree->get_item_rect(ti).position) : tree->get_drop_section_at_position(p_point); return section >= -1; } @@ -674,13 +674,13 @@ bool EditorAutoloadSettings::can_drop_data_fw(const Point2 &p_point, const Varia } void EditorAutoloadSettings::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_control) { - TreeItem *ti = tree->get_item_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); if (!ti) { return; } - int section = tree->get_drop_section_at_position(p_point); + int section = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_drop_section_at_position(tree->get_item_rect(ti).position) : tree->get_drop_section_at_position(p_point); if (section < -1) { return; @@ -901,6 +901,7 @@ EditorAutoloadSettings::EditorAutoloadSettings() { autoload_add_path = memnew(LineEdit); hbc->add_child(autoload_add_path); + autoload_add_path->set_accessibility_name(TTRC("Autoload Path")); autoload_add_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); autoload_add_path->set_clear_button_enabled(true); autoload_add_path->set_placeholder(vformat(TTR("Set path or press \"%s\" to create a script."), TTR("Add"))); @@ -908,6 +909,7 @@ EditorAutoloadSettings::EditorAutoloadSettings() { browse_button = memnew(Button); hbc->add_child(browse_button); + browse_button->set_accessibility_name(TTRC("Select Autoload Path")); browse_button->connect(SceneStringName(pressed), callable_mp(this, &EditorAutoloadSettings::_browse_autoload_add_path)); file_dialog = memnew(EditorFileDialog); @@ -925,6 +927,7 @@ EditorAutoloadSettings::EditorAutoloadSettings() { hbc->add_child(l); autoload_add_name = memnew(LineEdit); + autoload_add_name->set_accessibility_name(TTRC("Node Name")); autoload_add_name->set_h_size_flags(SIZE_EXPAND_FILL); autoload_add_name->connect(SceneStringName(text_submitted), callable_mp(this, &EditorAutoloadSettings::_autoload_text_submitted)); autoload_add_name->connect(SceneStringName(text_changed), callable_mp(this, &EditorAutoloadSettings::_autoload_text_changed)); @@ -938,6 +941,7 @@ EditorAutoloadSettings::EditorAutoloadSettings() { hbc->add_child(add_autoload); tree = memnew(Tree); + tree->set_accessibility_name(TTRC("Autoloads")); tree->set_hide_root(true); tree->set_select_mode(Tree::SELECT_MULTI); tree->set_allow_reselect(true); diff --git a/editor/editor_build_profile.cpp b/editor/editor_build_profile.cpp index ebb8e9ebb513..75b67fa78dc6 100644 --- a/editor/editor_build_profile.cpp +++ b/editor/editor_build_profile.cpp @@ -808,6 +808,7 @@ EditorBuildProfileManager::EditorBuildProfileManager() { HBoxContainer *path_hbc = memnew(HBoxContainer); profile_path = memnew(LineEdit); path_hbc->add_child(profile_path); + profile_path->set_accessibility_name(TTRC("Profile Path")); profile_path->set_editable(true); profile_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); @@ -880,6 +881,7 @@ EditorBuildProfileManager::EditorBuildProfileManager() { export_profile->set_access(EditorFileDialog::ACCESS_FILESYSTEM); force_detect_classes = memnew(LineEdit); + force_detect_classes->set_accessibility_name(TTRC("Forced Classes")); main_vbc->add_margin_child(TTR("Forced Classes on Detect:"), force_detect_classes); force_detect_classes->connect(SceneStringName(text_changed), callable_mp(this, &EditorBuildProfileManager::_force_detect_classes_changed)); diff --git a/editor/editor_command_palette.cpp b/editor/editor_command_palette.cpp index 76e90d46dbba..9adff60d0175 100644 --- a/editor/editor_command_palette.cpp +++ b/editor/editor_command_palette.cpp @@ -344,6 +344,7 @@ EditorCommandPalette::EditorCommandPalette() { command_search_box = memnew(LineEdit); command_search_box->set_placeholder(TTR("Filter Commands")); + command_search_box->set_accessibility_name(TTRC("Filter Commands")); command_search_box->connect(SceneStringName(gui_input), callable_mp(this, &EditorCommandPalette::_sbox_input)); command_search_box->connect(SceneStringName(text_changed), callable_mp(this, &EditorCommandPalette::_update_command_search)); command_search_box->set_v_size_flags(Control::SIZE_EXPAND_FILL); diff --git a/editor/editor_dock_manager.cpp b/editor/editor_dock_manager.cpp index 308301eaf3e7..ca99cb6cf062 100644 --- a/editor/editor_dock_manager.cpp +++ b/editor/editor_dock_manager.cpp @@ -1092,6 +1092,7 @@ DockContextPopup::DockContextPopup() { HBoxContainer *header_hb = memnew(HBoxContainer); tab_move_left_button = memnew(Button); + tab_move_left_button->set_accessibility_name(TTRC("Move Tab Left")); tab_move_left_button->set_flat(true); tab_move_left_button->set_focus_mode(Control::FOCUS_NONE); tab_move_left_button->connect(SceneStringName(pressed), callable_mp(this, &DockContextPopup::_tab_move_left)); @@ -1104,6 +1105,7 @@ DockContextPopup::DockContextPopup() { header_hb->add_child(position_label); tab_move_right_button = memnew(Button); + tab_move_right_button->set_accessibility_name(TTRC("Move Tab Right")); tab_move_right_button->set_flat(true); tab_move_right_button->set_focus_mode(Control::FOCUS_NONE); tab_move_right_button->connect(SceneStringName(pressed), callable_mp(this, &DockContextPopup::_tab_move_right)); diff --git a/editor/editor_feature_profile.cpp b/editor/editor_feature_profile.cpp index ed6bfbc3c492..81fdf08168b4 100644 --- a/editor/editor_feature_profile.cpp +++ b/editor/editor_feature_profile.cpp @@ -924,6 +924,7 @@ EditorFeatureProfileManager::EditorFeatureProfileManager() { HBoxContainer *name_hbc = memnew(HBoxContainer); current_profile_name = memnew(LineEdit); name_hbc->add_child(current_profile_name); + current_profile_name->set_accessibility_name(TTRC("Current Profile")); current_profile_name->set_text(TTR("(none)")); current_profile_name->set_editable(false); current_profile_name->set_h_size_flags(Control::SIZE_EXPAND_FILL); @@ -938,6 +939,7 @@ EditorFeatureProfileManager::EditorFeatureProfileManager() { HBoxContainer *profiles_hbc = memnew(HBoxContainer); profile_list = memnew(OptionButton); + profile_list->set_accessibility_name(TTRC("Profiles")); profile_list->set_h_size_flags(Control::SIZE_EXPAND_FILL); profile_list->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); profiles_hbc->add_child(profile_list); @@ -1031,6 +1033,7 @@ EditorFeatureProfileManager::EditorFeatureProfileManager() { new_profile_name = memnew(LineEdit); new_profile_vb->add_child(new_profile_name); new_profile_name->set_custom_minimum_size(Size2(300 * EDSCALE, 1)); + new_profile_name->set_accessibility_name(TTRC("Profile Name")); add_child(new_profile_dialog); new_profile_dialog->connect(SceneStringName(confirmed), callable_mp(this, &EditorFeatureProfileManager::_create_new_profile)); new_profile_dialog->register_text_enter(new_profile_name); diff --git a/editor/editor_help.cpp b/editor/editor_help.cpp index 54fee4e46f98..f1181044d109 100644 --- a/editor/editor_help.cpp +++ b/editor/editor_help.cpp @@ -3358,6 +3358,7 @@ EditorHelp::EditorHelp() { status_bar->set_custom_minimum_size(Size2(0, 24 * EDSCALE)); toggle_scripts_button = memnew(Button); + toggle_scripts_button->set_accessibility_name(TTRC("Scripts")); toggle_scripts_button->set_flat(true); toggle_scripts_button->connect(SceneStringName(pressed), callable_mp(this, &EditorHelp::_toggle_scripts_pressed)); status_bar->add_child(toggle_scripts_button); @@ -4744,6 +4745,7 @@ EditorHelpHighlighter::~EditorHelpHighlighter() { FindBar::FindBar() { search_text = memnew(LineEdit); + search_text->set_accessibility_name(TTRC("Search help")); add_child(search_text); search_text->set_keep_editing_on_text_submit(true); search_text->set_custom_minimum_size(Size2(100 * EDSCALE, 0)); @@ -4756,12 +4758,14 @@ FindBar::FindBar() { matches_label->hide(); find_prev = memnew(Button); + find_prev->set_accessibility_name(TTRC("Find Previous")); find_prev->set_flat(true); add_child(find_prev); find_prev->set_focus_mode(FOCUS_NONE); find_prev->connect(SceneStringName(pressed), callable_mp(this, &FindBar::search_prev)); find_next = memnew(Button); + find_next->set_accessibility_name(TTRC("Find Next")); find_next->set_flat(true); add_child(find_next); find_next->set_focus_mode(FOCUS_NONE); @@ -4773,6 +4777,7 @@ FindBar::FindBar() { hide_button = memnew(TextureButton); add_child(hide_button); + hide_button->set_accessibility_name(TTRC("Hide")); hide_button->set_focus_mode(FOCUS_NONE); hide_button->set_ignore_texture_size(true); hide_button->set_stretch_mode(TextureButton::STRETCH_KEEP_CENTERED); diff --git a/editor/editor_help_search.cpp b/editor/editor_help_search.cpp index 3845d4b8afc2..72d875893356 100644 --- a/editor/editor_help_search.cpp +++ b/editor/editor_help_search.cpp @@ -328,6 +328,7 @@ EditorHelpSearch::EditorHelpSearch() { vbox->add_child(hbox); search_box = memnew(LineEdit); + search_box->set_accessibility_name(TTRC("Search")); search_box->set_custom_minimum_size(Size2(200, 0) * EDSCALE); search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); search_box->set_clear_button_enabled(true); @@ -339,6 +340,7 @@ EditorHelpSearch::EditorHelpSearch() { case_sensitive_button = memnew(Button); case_sensitive_button->set_theme_type_variation(SceneStringName(FlatButton)); case_sensitive_button->set_tooltip_text(TTR("Case Sensitive")); + case_sensitive_button->set_accessibility_name(TTRC("Case Sensitive")); case_sensitive_button->connect(SceneStringName(pressed), callable_mp(this, &EditorHelpSearch::_update_results)); case_sensitive_button->set_toggle_mode(true); case_sensitive_button->set_focus_mode(Control::FOCUS_NONE); @@ -347,6 +349,7 @@ EditorHelpSearch::EditorHelpSearch() { hierarchy_button = memnew(Button); hierarchy_button->set_theme_type_variation(SceneStringName(FlatButton)); hierarchy_button->set_tooltip_text(TTR("Show Hierarchy")); + hierarchy_button->set_accessibility_name(TTRC("Show Hierarchy")); hierarchy_button->connect(SceneStringName(pressed), callable_mp(this, &EditorHelpSearch::_update_results)); hierarchy_button->set_toggle_mode(true); hierarchy_button->set_pressed(true); @@ -354,6 +357,7 @@ EditorHelpSearch::EditorHelpSearch() { hbox->add_child(hierarchy_button); filter_combo = memnew(OptionButton); + filter_combo->set_accessibility_name(TTRC("Filter")); filter_combo->set_custom_minimum_size(Size2(200, 0) * EDSCALE); filter_combo->set_stretch_ratio(0); // Fixed width. filter_combo->add_item(TTR("Display All"), SEARCH_ALL); @@ -372,6 +376,7 @@ EditorHelpSearch::EditorHelpSearch() { // Create the results tree. results_tree = memnew(Tree); + results_tree->set_accessibility_name(TTRC("Search Results")); results_tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); results_tree->set_v_size_flags(Control::SIZE_EXPAND_FILL); results_tree->set_columns(2); diff --git a/editor/editor_inspector.cpp b/editor/editor_inspector.cpp index 45a708037532..43a90616b7de 100644 --- a/editor/editor_inspector.cpp +++ b/editor/editor_inspector.cpp @@ -253,6 +253,25 @@ void EditorProperty::emit_changed(const StringName &p_property, const Variant &p void EditorProperty::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + + DisplayServer::get_singleton()->accessibility_update_set_name(ae, vformat(TTR("Property: %s"), label)); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, vformat(TTR("Property: %s"), label)); + + DisplayServer::get_singleton()->accessibility_update_set_popup_type(ae, DisplayServer::AccessibilityPopupType::POPUP_MENU); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SHOW_CONTEXT_MENU, callable_mp(this, &EditorProperty::_accessibility_action_menu)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &EditorProperty::_accessibility_action_click)); + + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_READONLY, read_only); + if (checkable) { + DisplayServer::get_singleton()->accessibility_update_set_checked(ae, checked); + } + } break; + case NOTIFICATION_SORT_CHILDREN: { Size2 size = get_size(); Rect2 rect; @@ -401,6 +420,11 @@ void EditorProperty::_notification(int p_what) { draw_style_box(bg_stylebox, bottom_child_rect); } + Ref focus_sb = get_theme_stylebox(SNAME("Focus"), EditorStringName(EditorStyles)); + if (focus_sb.is_valid() && has_focus()) { + draw_style_box(focus_sb, Rect2(Vector2(), get_size())); + } + Color color; if (draw_warning || draw_prop_warning) { color = get_theme_color(is_read_only() ? SNAME("readonly_warning_color") : SNAME("warning_color")); @@ -1031,6 +1055,22 @@ void EditorProperty::gui_input(const Ref &p_event) { } } +void EditorProperty::_accessibility_action_click(const Variant &p_data) { + select(); + if (checkable) { + checked = !checked; + queue_redraw(); + emit_signal(SNAME("property_checked"), property, checked); + } +} + +void EditorProperty::_accessibility_action_menu(const Variant &p_data) { + _update_popup(); + menu->set_position(get_screen_position()); + menu->reset_size(); + menu->popup(); +} + void EditorProperty::shortcut_input(const Ref &p_event) { if (!selected || !p_event->is_pressed()) { return; @@ -1268,6 +1308,19 @@ void EditorProperty::menu_option(int p_option) { emit_signal(SNAME("property_pinned"), property, !pinned); queue_redraw(); } break; + case MENU_DELETE: { + accept_event(); + emit_signal(SNAME("property_deleted"), property); + } break; + case MENU_REVERT_VALUE: { + accept_event(); + get_viewport()->gui_release_focus(); + bool is_valid_revert = false; + Variant revert_value = EditorPropertyRevert::get_property_revert_value(object, property, &is_valid_revert); + ERR_FAIL_COND(!is_valid_revert); + emit_changed(_get_revert_property(), revert_value); + update_property(); + } break; case MENU_OPEN_DOCUMENTATION: { ScriptEditor::get_singleton()->goto_help(doc_path); EditorNode::get_singleton()->get_editor_main_screen()->select(EditorMainScreen::EDITOR_SCRIPT); @@ -1361,6 +1414,8 @@ void EditorProperty::_bind_methods() { } EditorProperty::EditorProperty() { + set_focus_mode(FOCUS_ACCESSIBILITY); + object = nullptr; split_ratio = 0.5; text_size = 0; @@ -1411,7 +1466,15 @@ void EditorProperty::_update_popup() { } menu->set_item_tooltip(menu->get_item_index(MENU_PIN_VALUE), TTR("Pinning a value forces it to be saved even if it's equal to the default.")); } - + if (deletable || can_revert) { + menu->add_separator(); + if (deletable) { + menu->add_icon_item(get_editor_theme_icon(SNAME("Remove")), TTR("Delete Property"), MENU_PIN_VALUE); + } + if (can_revert) { + menu->add_icon_item(get_editor_theme_icon(SNAME("Reload")), TTR("Revert Value"), MENU_REVERT_VALUE); + } + } if (!doc_path.is_empty()) { menu->add_separator(); menu->add_icon_item(get_editor_theme_icon(SNAME("Help")), TTR("Open Documentation"), MENU_OPEN_DOCUMENTATION); @@ -1490,6 +1553,19 @@ void EditorInspectorPlugin::_bind_methods() { void EditorInspectorCategory::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + + DisplayServer::get_singleton()->accessibility_update_set_name(ae, vformat(TTR("Category: %s"), label)); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, vformat(TTR("Category: %s"), label)); + + DisplayServer::get_singleton()->accessibility_update_set_popup_type(ae, DisplayServer::AccessibilityPopupType::POPUP_MENU); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SHOW_CONTEXT_MENU, callable_mp(this, &EditorInspectorCategory::_accessibility_action_menu)); + } break; + case NOTIFICATION_THEME_CHANGED: { if (menu) { if (is_favorite) { @@ -1504,6 +1580,11 @@ void EditorInspectorCategory::_notification(int p_what) { draw_style_box(sb, Rect2(Vector2(), get_size())); + Ref focus_sb = get_theme_stylebox(SNAME("Focus"), EditorStringName(EditorStyles)); + if (focus_sb.is_valid() && has_focus()) { + draw_style_box(focus_sb, Rect2(Vector2(), get_size())); + } + Ref font = get_theme_font(SNAME("bold"), EditorStringName(EditorFonts)); int font_size = get_theme_font_size(SNAME("bold_size"), EditorStringName(EditorFonts)); @@ -1543,6 +1624,22 @@ void EditorInspectorCategory::_notification(int p_what) { } } +void EditorInspectorCategory::_accessibility_action_menu(const Variant &p_data) { + if (!is_favorite) { + if (!menu) { + menu = memnew(PopupMenu); + menu->add_icon_item(get_editor_theme_icon(SNAME("Help")), TTR("Open Documentation"), MENU_OPEN_DOCS); + add_child(menu); + menu->connect(SceneStringName(id_pressed), callable_mp(this, &EditorInspectorCategory::_handle_menu_option)); + } + menu->set_item_disabled(menu->get_item_index(MENU_OPEN_DOCS), !EditorHelp::get_doc_data()->class_list.has(doc_class_name)); + } + + menu->set_position(get_screen_position()); + menu->reset_size(); + menu->popup(); +} + Control *EditorInspectorCategory::make_custom_tooltip(const String &p_text) const { // If it's not a doc tooltip, fallback to the default one. if (doc_class_name.is_empty()) { @@ -1613,6 +1710,10 @@ void EditorInspectorCategory::gui_input(const Ref &p_event) { menu->popup(); } +EditorInspectorCategory::EditorInspectorCategory() { + set_focus_mode(FOCUS_ACCESSIBILITY); +} + //////////////////////////////////////////////// //////////////////////////////////////////////// @@ -1656,6 +1757,18 @@ int EditorInspectorSection::_get_header_height() { void EditorInspectorSection::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + + DisplayServer::get_singleton()->accessibility_update_set_name(ae, vformat(TTR("Section: %s"), label)); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, vformat(TTR("Section: %s"), label)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_COLLAPSE, callable_mp(this, &EditorInspectorSection::_accessibility_action_collapse)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_EXPAND, callable_mp(this, &EditorInspectorSection::_accessibility_action_expand)); + } break; + case NOTIFICATION_THEME_CHANGED: { update_minimum_size(); bg_color = get_theme_color(SNAME("prop_subsection"), EditorStringName(Editor)); @@ -1719,6 +1832,12 @@ void EditorInspectorSection::_notification(int p_what) { } draw_rect(header_rect, c); + // Draw focus. + Ref focus_sb = get_theme_stylebox(SNAME("Focus"), EditorStringName(EditorStyles)); + if (focus_sb.is_valid() && has_focus()) { + draw_style_box(focus_sb, Rect2(Vector2(), get_size())); + } + // Draw header title, folding arrow and count of revertable properties. { int outer_margin = Math::round(2 * EDSCALE); @@ -1885,6 +2004,20 @@ void EditorInspectorSection::gui_input(const Ref &p_event) { return; } + Ref k = p_event; + if (k.is_valid() && k->is_pressed()) { + if (k->is_action("ui_accept", true)) { + accept_event(); + + bool should_unfold = !object->editor_is_section_unfolded(section); + if (should_unfold) { + unfold(); + } else { + fold(); + } + } + } + Ref mb = p_event; if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == MouseButton::LEFT) { if (object->editor_is_section_unfolded(section)) { @@ -1925,6 +2058,14 @@ VBoxContainer *EditorInspectorSection::get_vbox() { return vbox; } +void EditorInspectorSection::_accessibility_action_collapse(const Variant &p_data) { + fold(); +} + +void EditorInspectorSection::_accessibility_action_expand(const Variant &p_data) { + unfold(); +} + void EditorInspectorSection::unfold() { if (!foldable) { return; @@ -1986,6 +2127,8 @@ void EditorInspectorSection::_bind_methods() { } EditorInspectorSection::EditorInspectorSection() { + set_focus_mode(FOCUS_ACCESSIBILITY); + vbox = memnew(VBoxContainer); dropping_unfold_timer = memnew(Timer); @@ -2099,6 +2242,18 @@ void EditorInspectorArray::_panel_draw(int p_index) { } } +void EditorInspectorArray::_panel_gui_focus(int p_index) { + array_elements[p_index].panel->queue_redraw(); + selected = p_index; +} + +void EditorInspectorArray::_panel_gui_unfocus(int p_index) { + array_elements[p_index].panel->queue_redraw(); + if (selected == p_index) { + selected = -1; + } +} + void EditorInspectorArray::_panel_gui_input(Ref p_event, int p_index) { ERR_FAIL_INDEX(p_index, (int)array_elements.size()); @@ -2130,6 +2285,15 @@ void EditorInspectorArray::_panel_gui_input(Ref p_event, int p_index } } +void EditorInspectorArray::show_menu(int p_index, const Vector2 &p_offset) { + popup_array_index_pressed = begin_array_index + p_index; + rmb_popup->set_item_disabled(OPTION_MOVE_UP, popup_array_index_pressed == 0); + rmb_popup->set_item_disabled(OPTION_MOVE_DOWN, popup_array_index_pressed == count - 1); + rmb_popup->set_position(get_screen_position() + p_offset); + rmb_popup->reset_size(); + rmb_popup->popup(); +} + void EditorInspectorArray::_move_element(int p_element_index, int p_to_pos) { String action_name; if (p_element_index < 0) { @@ -2490,16 +2654,20 @@ void EditorInspectorArray::_setup() { ArrayElement &ae = array_elements[i]; // Panel and its hbox. - ae.panel = memnew(PanelContainer); + ae.panel = memnew(ArrayPanelContainer); ae.panel->set_focus_mode(FOCUS_ALL); ae.panel->set_mouse_filter(MOUSE_FILTER_PASS); SET_DRAG_FORWARDING_GCD(ae.panel, EditorInspectorArray); int element_position = begin_array_index + i; + String ae_name = vformat(TTR("Element %d: %s%d*"), element_position, array_element_prefix, element_position); + ae.panel->set_meta("index", element_position); - ae.panel->set_tooltip_text(vformat(TTR("Element %d: %s%d*"), element_position, array_element_prefix, element_position)); - ae.panel->connect(SceneStringName(focus_entered), callable_mp((CanvasItem *)ae.panel, &PanelContainer::queue_redraw)); - ae.panel->connect(SceneStringName(focus_exited), callable_mp((CanvasItem *)ae.panel, &PanelContainer::queue_redraw)); + ae.panel->set_meta("name", ae_name); + ae.panel->set_meta("element", this); + ae.panel->set_tooltip_text(ae_name); + ae.panel->connect(SceneStringName(focus_entered), callable_mp(this, &EditorInspectorArray::_panel_gui_focus).bind(i)); + ae.panel->connect(SceneStringName(focus_exited), callable_mp(this, &EditorInspectorArray::_panel_gui_unfocus).bind(i)); ae.panel->connect(SceneStringName(draw), callable_mp(this, &EditorInspectorArray::_panel_draw).bind(i)); ae.panel->connect(SceneStringName(gui_input), callable_mp(this, &EditorInspectorArray::_panel_gui_input).bind(i)); ae.panel->add_theme_style_override(SceneStringName(panel), i % 2 ? odd_style : even_style); @@ -2532,6 +2700,7 @@ void EditorInspectorArray::_setup() { if (element_position > 0) { ae.move_up = memnew(Button); + ae.move_up->set_accessibility_name(TTRC("Move Up")); ae.move_up->set_button_icon(get_editor_theme_icon(SNAME("MoveUp"))); ae.move_up->connect(SceneStringName(pressed), callable_mp(this, &EditorInspectorArray::_move_element).bind(element_position, element_position - 1)); move_vbox->add_child(ae.move_up); @@ -2548,6 +2717,7 @@ void EditorInspectorArray::_setup() { if (element_position < count - 1) { ae.move_down = memnew(Button); + ae.move_down->set_accessibility_name(TTRC("Move Down")); ae.move_down->set_button_icon(get_editor_theme_icon(SNAME("MoveDown"))); ae.move_down->connect(SceneStringName(pressed), callable_mp(this, &EditorInspectorArray::_move_element).bind(element_position, element_position + 2)); move_vbox->add_child(ae.move_down); @@ -2572,6 +2742,7 @@ void EditorInspectorArray::_setup() { if (!unresizable) { ae.erase = memnew(Button); + ae.erase->set_accessibility_name(TTRC("Remove")); ae.erase->set_button_icon(get_editor_theme_icon(SNAME("Remove"))); ae.erase->set_v_size_flags(SIZE_SHRINK_CENTER); ae.erase->connect(SceneStringName(pressed), callable_mp(this, &EditorInspectorArray::_remove_item).bind(element_position)); @@ -2612,7 +2783,7 @@ void EditorInspectorArray::drop_data_fw(const Point2 &p_point, const Variant &p_ Dictionary dict = p_data; int to_drop = dict["index"]; - int drop_position = _drop_position(); + int drop_position = (p_point == Vector2(INFINITY, INFINITY)) ? selected : _drop_position(); if (drop_position < 0) { return; } @@ -2630,7 +2801,7 @@ bool EditorInspectorArray::can_drop_data_fw(const Point2 &p_point, const Variant return false; } Dictionary dict = p_data; - int drop_position = _drop_position(); + int drop_position = (p_point == Vector2(INFINITY, INFINITY)) ? selected : _drop_position(); if (!dict.has("type") || dict["type"] != "property_array_element" || String(dict["property_array_prefix"]) != array_element_prefix || drop_position < 0) { return false; } @@ -2642,8 +2813,45 @@ bool EditorInspectorArray::can_drop_data_fw(const Point2 &p_point, const Variant return drop_array_index != moved_array_index && drop_array_index - 1 != moved_array_index; } +void ArrayPanelContainer::_accessibility_action_menu(const Variant &p_data) { + EditorInspectorArray *el = Object::cast_to(get_meta("element")); + if (el) { + int index = get_meta("index"); + el->show_menu(index, Vector2()); + } +} + +void ArrayPanelContainer::_notification(int p_what) { + switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + + DisplayServer::get_singleton()->accessibility_update_set_name(ae, get_meta("text")); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, get_meta("text")); + + DisplayServer::get_singleton()->accessibility_update_set_popup_type(ae, DisplayServer::AccessibilityPopupType::POPUP_MENU); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SHOW_CONTEXT_MENU, callable_mp(this, &ArrayPanelContainer::_accessibility_action_menu)); + } break; + } +} + +ArrayPanelContainer::ArrayPanelContainer() { + set_focus_mode(FOCUS_ACCESSIBILITY); +} + void EditorInspectorArray::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_name(ae, vformat(TTR("Array: %s"), get_label())); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, vformat(TTR("Array: %s"), get_label())); + } break; + case NOTIFICATION_ENTER_TREE: case NOTIFICATION_THEME_CHANGED: { Color color = get_theme_color(SNAME("dark_color_1"), EditorStringName(Editor)); @@ -2747,6 +2955,7 @@ EditorInspectorArray::EditorInspectorArray(bool p_read_only) { even_style.instantiate(); rmb_popup = memnew(PopupMenu); + rmb_popup->set_accessibility_name(TTRC("Move")); rmb_popup->add_item(TTR("Move Up"), OPTION_MOVE_UP); rmb_popup->add_item(TTR("Move Down"), OPTION_MOVE_DOWN); rmb_popup->add_separator(); @@ -2784,6 +2993,7 @@ EditorInspectorArray::EditorInspectorArray(bool p_read_only) { resize_dialog->add_child(resize_dialog_vbox); new_size_spin_box = memnew(SpinBox); + new_size_spin_box->set_accessibility_name(TTRC("Size")); new_size_spin_box->set_max(16384); new_size_spin_box->connect(SceneStringName(value_changed), callable_mp(this, &EditorInspectorArray::_new_size_spin_box_value_changed)); new_size_spin_box->get_line_edit()->connect(SceneStringName(text_submitted), callable_mp(this, &EditorInspectorArray::_new_size_spin_box_text_submitted)); @@ -2859,16 +3069,19 @@ EditorPaginator::EditorPaginator() { set_alignment(ALIGNMENT_CENTER); first_page_button = memnew(Button); + first_page_button->set_accessibility_name(TTRC("First Page")); first_page_button->set_flat(true); first_page_button->connect(SceneStringName(pressed), callable_mp(this, &EditorPaginator::_first_page_button_pressed)); add_child(first_page_button); prev_page_button = memnew(Button); + prev_page_button->set_accessibility_name(TTRC("Previuos Page")); prev_page_button->set_flat(true); prev_page_button->connect(SceneStringName(pressed), callable_mp(this, &EditorPaginator::_prev_page_button_pressed)); add_child(prev_page_button); page_line_edit = memnew(LineEdit); + page_line_edit->set_accessibility_name(TTRC("Page")); page_line_edit->connect(SceneStringName(text_submitted), callable_mp(this, &EditorPaginator::_page_line_edit_text_submitted)); page_line_edit->add_theme_constant_override("minimum_character_width", 2); add_child(page_line_edit); @@ -2877,11 +3090,13 @@ EditorPaginator::EditorPaginator() { add_child(page_count_label); next_page_button = memnew(Button); + prev_page_button->set_accessibility_name(TTRC("Next Page")); next_page_button->set_flat(true); next_page_button->connect(SceneStringName(pressed), callable_mp(this, &EditorPaginator::_next_page_button_pressed)); add_child(next_page_button); last_page_button = memnew(Button); + last_page_button->set_accessibility_name(TTRC("Last Page")); last_page_button->set_flat(true); last_page_button->connect(SceneStringName(pressed), callable_mp(this, &EditorPaginator::_last_page_button_pressed)); add_child(last_page_button); diff --git a/editor/editor_inspector.h b/editor/editor_inspector.h index 866dad40cb2a..be47809c4b01 100644 --- a/editor/editor_inspector.h +++ b/editor/editor_inspector.h @@ -66,6 +66,8 @@ class EditorProperty : public Container { MENU_COPY_PROPERTY_PATH, MENU_FAVORITE_PROPERTY, MENU_PIN_VALUE, + MENU_DELETE, + MENU_REVERT_VALUE, MENU_OPEN_DOCUMENTATION, }; @@ -158,6 +160,9 @@ class EditorProperty : public Container { void _update_property_bg(); + void _accessibility_action_menu(const Variant &p_data); + void _accessibility_action_click(const Variant &p_data); + public: void emit_changed(const StringName &p_property, const Variant &p_value, const StringName &p_field = StringName(), bool p_changing = false); @@ -314,11 +319,15 @@ class EditorInspectorCategory : public Control { void _notification(int p_what); virtual void gui_input(const Ref &p_event) override; + void _accessibility_action_menu(const Variant &p_data); + public: void set_as_favorite(EditorInspector *p_for_inspector); virtual Size2 get_minimum_size() const override; virtual Control *make_custom_tooltip(const String &p_text) const override; + + EditorInspectorCategory(); }; class EditorInspectorSection : public Container { @@ -349,11 +358,15 @@ class EditorInspectorSection : public Container { static void _bind_methods(); virtual void gui_input(const Ref &p_event) override; + void _accessibility_action_collapse(const Variant &p_data); + void _accessibility_action_expand(const Variant &p_data); + public: virtual Size2 get_minimum_size() const override; void setup(const String &p_section, const String &p_label, Object *p_object, const Color &p_bg_color, bool p_foldable, int p_indent_depth = 0, int p_level = 1); String get_section() const; + String get_label() const { return label; } VBoxContainer *get_vbox(); void unfold(); void fold(); @@ -367,6 +380,18 @@ class EditorInspectorSection : public Container { ~EditorInspectorSection(); }; +class ArrayPanelContainer : public PanelContainer { + GDCLASS(ArrayPanelContainer, PanelContainer); + +protected: + void _notification(int p_what); + + void _accessibility_action_menu(const Variant &p_data); + +public: + ArrayPanelContainer(); +}; + class EditorInspectorArray : public EditorInspectorSection { GDCLASS(EditorInspectorArray, EditorInspectorSection); @@ -380,6 +405,7 @@ class EditorInspectorArray : public EditorInspectorSection { String swap_method; int count = 0; + int selected = -1; VBoxContainer *elements_vbox = nullptr; @@ -443,6 +469,8 @@ class EditorInspectorArray : public EditorInspectorSection { void _panel_draw(int p_index); void _panel_gui_input(Ref p_event, int p_index); + void _panel_gui_focus(int p_index); + void _panel_gui_unfocus(int p_index); void _move_element(int p_element_index, int p_to_pos); void _clear_array(); void _resize_array(int p_size); @@ -471,6 +499,8 @@ class EditorInspectorArray : public EditorInspectorSection { void setup_with_count_property(Object *p_object, const String &p_label, const StringName &p_count_property, const StringName &p_array_element_prefix, int p_page, const Color &p_bg_color, bool p_foldable, bool p_movable = true, bool p_is_const = false, bool p_numbered = false, int p_page_length = 5, const String &p_add_item_text = "", const String &p_swap_method = ""); VBoxContainer *get_vbox(int p_index); + void show_menu(int p_index, const Vector2 &p_offset); + EditorInspectorArray(bool p_read_only); }; diff --git a/editor/editor_layouts_dialog.cpp b/editor/editor_layouts_dialog.cpp index 60326056842c..0ba5fb1f944b 100644 --- a/editor/editor_layouts_dialog.cpp +++ b/editor/editor_layouts_dialog.cpp @@ -128,6 +128,7 @@ EditorLayoutsDialog::EditorLayoutsDialog() { name = memnew(LineEdit); makevb->add_child(name); name->set_placeholder(TTR("Or enter new layout name")); + name->set_accessibility_name(TTRC("Layout Name")); name->set_offset(SIDE_TOP, 5); name->set_anchor_and_offset(SIDE_LEFT, Control::ANCHOR_BEGIN, 5); name->set_anchor_and_offset(SIDE_RIGHT, Control::ANCHOR_END, -5); diff --git a/editor/editor_locale_dialog.cpp b/editor/editor_locale_dialog.cpp index c36792c9e31b..006211207f64 100644 --- a/editor/editor_locale_dialog.cpp +++ b/editor/editor_locale_dialog.cpp @@ -396,6 +396,7 @@ EditorLocaleDialog::EditorLocaleDialog() { HBoxContainer *hb_filter = memnew(HBoxContainer); { filter_mode = memnew(OptionButton); + filter_mode->set_accessibility_name(TTRC("Locale Filter")); filter_mode->add_item(TTR("Show All Locales"), SHOW_ALL_LOCALES); filter_mode->set_h_size_flags(Control::SIZE_EXPAND_FILL); filter_mode->add_item(TTR("Show Selected Locales Only"), SHOW_ONLY_SELECTED_LOCALES); @@ -434,6 +435,7 @@ EditorLocaleDialog::EditorLocaleDialog() { } { lang_list = memnew(Tree); + lang_list->set_accessibility_name(TTRC("Language")); lang_list->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); lang_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); lang_list->connect("cell_selected", callable_mp(this, &EditorLocaleDialog::_item_selected)); @@ -454,6 +456,7 @@ EditorLocaleDialog::EditorLocaleDialog() { } { script_list = memnew(Tree); + script_list->set_accessibility_name(TTR("Script", "Locale")); script_list->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); script_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); script_list->connect("cell_selected", callable_mp(this, &EditorLocaleDialog::_item_selected)); @@ -473,6 +476,7 @@ EditorLocaleDialog::EditorLocaleDialog() { } { cnt_list = memnew(Tree); + cnt_list->set_accessibility_name(TTRC("Country")); cnt_list->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); cnt_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); cnt_list->connect("cell_selected", callable_mp(this, &EditorLocaleDialog::_item_selected)); @@ -499,7 +503,7 @@ EditorLocaleDialog::EditorLocaleDialog() { { lang_code = memnew(LineEdit); lang_code->set_max_length(3); - lang_code->set_tooltip_text("Language"); + lang_code->set_accessibility_name("Language"); vb_language->add_child(lang_code); } hb_locale->add_child(vb_language); @@ -516,7 +520,7 @@ EditorLocaleDialog::EditorLocaleDialog() { { script_code = memnew(LineEdit); script_code->set_max_length(4); - script_code->set_tooltip_text("Script"); + script_code->set_accessibility_name("Script"); vb_script->add_child(script_code); } hb_locale->add_child(vb_script); @@ -549,7 +553,7 @@ EditorLocaleDialog::EditorLocaleDialog() { variant_code = memnew(LineEdit); variant_code->set_h_size_flags(Control::SIZE_EXPAND_FILL); variant_code->set_placeholder("Variant"); - variant_code->set_tooltip_text("Variant"); + variant_code->set_accessibility_name("Variant"); vb_variant->add_child(variant_code); } hb_locale->add_child(vb_variant); diff --git a/editor/editor_log.cpp b/editor/editor_log.cpp index d33bd6a931f4..9a76b24ea85e 100644 --- a/editor/editor_log.cpp +++ b/editor/editor_log.cpp @@ -466,6 +466,7 @@ EditorLog::EditorLog() { search_box = memnew(LineEdit); search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); search_box->set_placeholder(TTR("Filter Messages")); + search_box->set_accessibility_name(TTRC("Filter Messages")); search_box->set_clear_button_enabled(true); search_box->set_visible(true); search_box->connect(SceneStringName(text_changed), callable_mp(this, &EditorLog::_search_changed)); @@ -481,6 +482,7 @@ EditorLog::EditorLog() { // Clear. clear_button = memnew(Button); + clear_button->set_accessibility_name(TTRC("Clear Log")); clear_button->set_theme_type_variation(SceneStringName(FlatButton)); clear_button->set_focus_mode(FOCUS_NONE); clear_button->set_shortcut(ED_SHORTCUT("editor/clear_output", TTRC("Clear Output"), KeyModifierMask::CMD_OR_CTRL | KeyModifierMask::ALT | Key::K)); @@ -489,6 +491,7 @@ EditorLog::EditorLog() { // Copy. copy_button = memnew(Button); + copy_button->set_accessibility_name(TTRC("Copy Selection")); copy_button->set_theme_type_variation(SceneStringName(FlatButton)); copy_button->set_focus_mode(FOCUS_NONE); copy_button->set_shortcut(ED_SHORTCUT("editor/copy_output", TTRC("Copy Selection"), KeyModifierMask::CMD_OR_CTRL | Key::C)); @@ -509,6 +512,7 @@ EditorLog::EditorLog() { collapse_button->set_theme_type_variation(SceneStringName(FlatButton)); collapse_button->set_focus_mode(FOCUS_NONE); collapse_button->set_tooltip_text(TTR("Collapse duplicate messages into one log entry. Shows number of occurrences.")); + collapse_button->set_accessibility_name(TTRC("Collapse Duplicate Messages")); collapse_button->set_toggle_mode(true); collapse_button->set_pressed(false); collapse_button->connect(SceneStringName(toggled), callable_mp(this, &EditorLog::_set_collapse)); @@ -516,6 +520,7 @@ EditorLog::EditorLog() { // Show Search. show_search_button = memnew(Button); + show_search_button->set_accessibility_name(TTRC("Show Search")); show_search_button->set_theme_type_variation(SceneStringName(FlatButton)); show_search_button->set_focus_mode(FOCUS_NONE); show_search_button->set_toggle_mode(true); @@ -529,23 +534,23 @@ EditorLog::EditorLog() { vb_right->add_child(memnew(HSeparator)); LogFilter *std_filter = memnew(LogFilter(MSG_TYPE_STD)); - std_filter->initialize_button(TTR("Toggle visibility of standard output messages."), callable_mp(this, &EditorLog::_set_filter_active)); + std_filter->initialize_button(TTRC("Standard Messages"), TTRC("Toggle visibility of standard output messages."), callable_mp(this, &EditorLog::_set_filter_active)); vb_right->add_child(std_filter->toggle_button); type_filter_map.insert(MSG_TYPE_STD, std_filter); type_filter_map.insert(MSG_TYPE_STD_RICH, std_filter); LogFilter *error_filter = memnew(LogFilter(MSG_TYPE_ERROR)); - error_filter->initialize_button(TTR("Toggle visibility of errors."), callable_mp(this, &EditorLog::_set_filter_active)); + error_filter->initialize_button(TTRC("Errors"), TTRC("Toggle visibility of errors."), callable_mp(this, &EditorLog::_set_filter_active)); vb_right->add_child(error_filter->toggle_button); type_filter_map.insert(MSG_TYPE_ERROR, error_filter); LogFilter *warning_filter = memnew(LogFilter(MSG_TYPE_WARNING)); - warning_filter->initialize_button(TTR("Toggle visibility of warnings."), callable_mp(this, &EditorLog::_set_filter_active)); + warning_filter->initialize_button(TTRC("Warnings"), TTRC("Toggle visibility of warnings."), callable_mp(this, &EditorLog::_set_filter_active)); vb_right->add_child(warning_filter->toggle_button); type_filter_map.insert(MSG_TYPE_WARNING, warning_filter); LogFilter *editor_filter = memnew(LogFilter(MSG_TYPE_EDITOR)); - editor_filter->initialize_button(TTR("Toggle visibility of editor messages."), callable_mp(this, &EditorLog::_set_filter_active)); + editor_filter->initialize_button(TTRC("Editor Messages"), TTRC("Toggle visibility of editor messages."), callable_mp(this, &EditorLog::_set_filter_active)); vb_right->add_child(editor_filter->toggle_button); type_filter_map.insert(MSG_TYPE_EDITOR, editor_filter); diff --git a/editor/editor_log.h b/editor/editor_log.h index 3ec3dd796a9c..498357f5ba9a 100644 --- a/editor/editor_log.h +++ b/editor/editor_log.h @@ -87,12 +87,13 @@ class EditorLog : public HBoxContainer { MessageType type; Button *toggle_button = nullptr; - void initialize_button(const String &p_tooltip, Callable p_toggled_callback) { + void initialize_button(const String &p_name, const String &p_tooltip, Callable p_toggled_callback) { toggle_button = memnew(Button); toggle_button->set_toggle_mode(true); toggle_button->set_pressed(true); toggle_button->set_text(itos(message_count)); - toggle_button->set_tooltip_text(TTR(p_tooltip)); + toggle_button->set_accessibility_name(TTRGET(p_name)); + toggle_button->set_tooltip_text(TTRGET(p_tooltip)); toggle_button->set_focus_mode(FOCUS_NONE); // When toggled call the callback and pass the MessageType this button is for. toggle_button->connect(SceneStringName(toggled), p_toggled_callback.bind(type)); diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp index b0d21c58dc52..a8697b0b1eef 100644 --- a/editor/editor_node.cpp +++ b/editor/editor_node.cpp @@ -7506,6 +7506,7 @@ EditorNode::EditorNode() { ED_SHORTCUT_AND_COMMAND("editor/toggle_last_opened_bottom_panel", TTRC("Toggle Last Opened Bottom Panel"), KeyModifierMask::CMD_OR_CTRL | Key::J); distraction_free->set_shortcut(ED_GET_SHORTCUT("editor/distraction_free_mode")); distraction_free->set_tooltip_text(TTRC("Toggle distraction-free mode.")); + distraction_free->set_accessibility_name(TTRC("Distraction-free Mode")); distraction_free->set_toggle_mode(true); scene_tabs->add_extra_button(distraction_free); distraction_free->connect(SceneStringName(pressed), callable_mp(this, &EditorNode::_toggle_distraction_free_mode)); @@ -7831,6 +7832,7 @@ EditorNode::EditorNode() { renderer->set_fit_to_longest_item(false); renderer->set_focus_mode(Control::FOCUS_NONE); renderer->set_tooltip_text(TTR("Choose a rendering method.\n\nNotes:\n- On mobile platforms, the Mobile rendering method is used if Forward+ is selected here.\n- On the web platform, the Compatibility rendering method is always used.")); + renderer->set_accessibility_name(TTRC("Rendering Method")); right_menu_hb->add_child(renderer); @@ -7888,6 +7890,7 @@ EditorNode::EditorNode() { right_menu_hb->add_child(update_spinner); update_spinner->set_button_icon(theme->get_icon(SNAME("Progress1"), EditorStringName(EditorIcons))); update_spinner->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &EditorNode::_menu_option)); + update_spinner->set_accessibility_name(TTRC("Update Mode")); PopupMenu *p = update_spinner->get_popup(); p->add_radio_check_item(TTR("Update Continuously"), SPINNER_UPDATE_CONTINUOUSLY); p->add_radio_check_item(TTR("Update When Changed"), SPINNER_UPDATE_WHEN_CHANGED); diff --git a/editor/editor_properties.cpp b/editor/editor_properties.cpp index 22ca6299c343..68c54de2b837 100644 --- a/editor/editor_properties.cpp +++ b/editor/editor_properties.cpp @@ -236,6 +236,7 @@ EditorPropertyMultilineText::EditorPropertyMultilineText(bool p_expression) { hb->add_child(text); text->set_h_size_flags(SIZE_EXPAND_FILL); open_big_text = memnew(Button); + open_big_text->set_accessibility_name(TTRC("Open Text Edit Dialog")); open_big_text->set_flat(true); open_big_text->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyMultilineText::_open_big_text)); hb->add_child(open_big_text); @@ -373,6 +374,7 @@ EditorPropertyTextEnum::EditorPropertyTextEnum() { hb->add_child(edit_custom_layout); option_button = memnew(OptionButton); + option_button->set_accessibility_name(TTRC("Enum Options")); option_button->set_h_size_flags(SIZE_EXPAND_FILL); option_button->set_clip_text(true); option_button->set_flat(true); @@ -381,22 +383,26 @@ EditorPropertyTextEnum::EditorPropertyTextEnum() { option_button->connect(SceneStringName(item_selected), callable_mp(this, &EditorPropertyTextEnum::_option_selected)); edit_button = memnew(Button); + edit_button->set_accessibility_name(TTRC("Edit")); edit_button->set_flat(true); edit_button->hide(); default_layout->add_child(edit_button); edit_button->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyTextEnum::_edit_custom_value)); custom_value_edit = memnew(LineEdit); + custom_value_edit->set_accessibility_name(TTRC("Custom Value")); custom_value_edit->set_h_size_flags(SIZE_EXPAND_FILL); edit_custom_layout->add_child(custom_value_edit); custom_value_edit->connect(SceneStringName(text_submitted), callable_mp(this, &EditorPropertyTextEnum::_custom_value_submitted)); accept_button = memnew(Button); + accept_button->set_accessibility_name(TTRC("Accept Custom Value Edit")); accept_button->set_flat(true); edit_custom_layout->add_child(accept_button); accept_button->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyTextEnum::_custom_value_accepted)); cancel_button = memnew(Button); + cancel_button->set_accessibility_name(TTRC("Cancel Custom Value Edit")); cancel_button->set_flat(true); edit_custom_layout->add_child(cancel_button); cancel_button->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyTextEnum::_custom_value_canceled)); @@ -453,12 +459,14 @@ EditorPropertyLocale::EditorPropertyLocale() { HBoxContainer *locale_hb = memnew(HBoxContainer); add_child(locale_hb); locale = memnew(LineEdit); + locale->set_accessibility_name(TTRC("Locale")); locale_hb->add_child(locale); locale->connect(SceneStringName(text_submitted), callable_mp(this, &EditorPropertyLocale::_locale_selected)); locale->connect(SceneStringName(focus_exited), callable_mp(this, &EditorPropertyLocale::_locale_focus_exited)); locale->set_h_size_flags(SIZE_EXPAND_FILL); locale_edit = memnew(Button); + locale_edit->set_accessibility_name(TTRC("Edit")); locale_edit->set_clip_text(true); locale_hb->add_child(locale_edit); add_focusable(locale); @@ -606,6 +614,7 @@ EditorPropertyPath::EditorPropertyPath() { HBoxContainer *path_hb = memnew(HBoxContainer); add_child(path_hb); path = memnew(LineEdit); + path->set_accessibility_name(TTRC("Path")); SET_DRAG_FORWARDING_CDU(path, EditorPropertyPath); path->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); path_hb->add_child(path); @@ -614,6 +623,7 @@ EditorPropertyPath::EditorPropertyPath() { path->set_h_size_flags(SIZE_EXPAND_FILL); path_edit = memnew(Button); + path_edit->set_accessibility_name(TTRC("Edit")); path_edit->set_clip_text(true); path_hb->add_child(path_edit); add_focusable(path); @@ -993,6 +1003,15 @@ void EditorPropertyLayersGrid::gui_input(const Ref &p_ev) { void EditorPropertyLayersGrid::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Layers grid property editor"))); + } break; + case NOTIFICATION_DRAW: { Size2 grid_size = get_grid_size(); grid_size.x = get_size().x; @@ -1300,6 +1319,7 @@ EditorPropertyLayers::EditorPropertyLayers() { hb->add_child(grid); button = memnew(TextureButton); + button->set_accessibility_name(TTRC("Layers")); button->set_stretch_mode(TextureButton::STRETCH_KEEP_CENTERED); button->set_toggle_mode(true); button->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyLayers::_button_pressed)); @@ -1391,6 +1411,7 @@ void EditorPropertyObjectID::setup(const String &p_base_type) { EditorPropertyObjectID::EditorPropertyObjectID() { edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); add_child(edit); add_focusable(edit); edit->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS); @@ -1416,6 +1437,7 @@ void EditorPropertySignal::update_property() { EditorPropertySignal::EditorPropertySignal() { edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); add_child(edit); add_focusable(edit); edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertySignal::_edit_pressed)); @@ -1435,6 +1457,7 @@ void EditorPropertyCallable::update_property() { EditorPropertyCallable::EditorPropertyCallable() { edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); add_child(edit); add_focusable(edit); } @@ -1766,6 +1789,7 @@ EditorPropertyRect2::EditorPropertyRect2(bool p_force_wide) { for (int i = 0; i < 4; i++) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); spin[i]->set_flat(true); if (grid) { @@ -1860,6 +1884,7 @@ EditorPropertyRect2i::EditorPropertyRect2i(bool p_force_wide) { for (int i = 0; i < 4; i++) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); spin[i]->set_flat(true); if (grid) { @@ -1951,6 +1976,7 @@ EditorPropertyPlane::EditorPropertyPlane(bool p_force_wide) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_flat(true); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); bc->add_child(spin[i]); add_focusable(spin[i]); spin[i]->connect(SceneStringName(value_changed), callable_mp(this, &EditorPropertyPlane::_value_changed).bind(desc[i])); @@ -2121,6 +2147,7 @@ EditorPropertyQuaternion::EditorPropertyQuaternion() { spin[i] = memnew(EditorSpinSlider); spin[i]->set_flat(true); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); default_layout->add_child(spin[i]); add_focusable(spin[i]); spin[i]->connect(SceneStringName(value_changed), callable_mp(this, &EditorPropertyQuaternion::_value_changed).bind(desc[i])); @@ -2148,6 +2175,7 @@ EditorPropertyQuaternion::EditorPropertyQuaternion() { euler[i] = memnew(EditorSpinSlider); euler[i]->set_flat(true); euler[i]->set_label(desc[i]); + euler[i]->set_accessibility_name(vformat(TTR("Temporary Euler %s"), desc[i])); edit_custom_layout->add_child(euler[i]); add_focusable(euler[i]); euler[i]->connect(SceneStringName(value_changed), callable_mp(this, &EditorPropertyQuaternion::_custom_value_changed)); @@ -2157,6 +2185,7 @@ EditorPropertyQuaternion::EditorPropertyQuaternion() { } edit_button = memnew(Button); + edit_button->set_accessibility_name(TTRC("Edit")); edit_button->set_flat(true); edit_button->set_toggle_mode(true); default_layout->add_child(edit_button); @@ -2231,6 +2260,7 @@ EditorPropertyAABB::EditorPropertyAABB() { for (int i = 0; i < 6; i++) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); spin[i]->set_flat(true); g->add_child(spin[i]); @@ -2311,6 +2341,7 @@ EditorPropertyTransform2D::EditorPropertyTransform2D(bool p_include_origin) { for (int i = 0; i < 6; i++) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); spin[i]->set_flat(true); if (p_include_origin || i % 3 != 2) { g->add_child(spin[i]); @@ -2393,6 +2424,7 @@ EditorPropertyBasis::EditorPropertyBasis() { for (int i = 0; i < 9; i++) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); spin[i]->set_flat(true); g->add_child(spin[i]); spin[i]->set_h_size_flags(SIZE_EXPAND_FILL); @@ -2482,6 +2514,7 @@ EditorPropertyTransform3D::EditorPropertyTransform3D() { for (int i = 0; i < 12; i++) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); spin[i]->set_flat(true); g->add_child(spin[i]); spin[i]->set_h_size_flags(SIZE_EXPAND_FILL); @@ -2579,6 +2612,7 @@ EditorPropertyProjection::EditorPropertyProjection() { for (int i = 0; i < 16; i++) { spin[i] = memnew(EditorSpinSlider); spin[i]->set_label(desc[i]); + spin[i]->set_accessibility_name(desc[i]); spin[i]->set_flat(true); g->add_child(spin[i]); spin[i]->set_h_size_flags(SIZE_EXPAND_FILL); @@ -2964,6 +2998,7 @@ EditorPropertyNodePath::EditorPropertyNodePath() { hbc->add_theme_constant_override("separation", 0); add_child(hbc); assign = memnew(Button); + assign->set_accessibility_name(TTRC("Assign Node")); assign->set_flat(true); assign->set_h_size_flags(SIZE_EXPAND_FILL); assign->set_clip_text(true); @@ -2986,6 +3021,7 @@ EditorPropertyNodePath::EditorPropertyNodePath() { menu->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &EditorPropertyNodePath::_menu_option)); edit = memnew(LineEdit); + edit->set_accessibility_name(TTRC("Node Path")); edit->set_h_size_flags(SIZE_EXPAND_FILL); edit->hide(); edit->connect(SceneStringName(focus_exited), callable_mp(this, &EditorPropertyNodePath::_accept_text)); diff --git a/editor/editor_properties_array_dict.cpp b/editor/editor_properties_array_dict.cpp index f8f21120364d..b10bd992377f 100644 --- a/editor/editor_properties_array_dict.cpp +++ b/editor/editor_properties_array_dict.cpp @@ -305,6 +305,7 @@ void EditorPropertyArray::_create_new_property_slot() { HBoxContainer *hbox = memnew(HBoxContainer); Button *reorder_button = memnew(Button); + reorder_button->set_accessibility_name(TTRC("Reorder")); reorder_button->set_button_icon(get_editor_theme_icon(SNAME("TripleBar"))); reorder_button->set_default_cursor_shape(Control::CURSOR_MOVE); reorder_button->set_disabled(is_read_only()); @@ -320,12 +321,14 @@ void EditorPropertyArray::_create_new_property_slot() { if (is_untyped_array) { Button *edit_btn = memnew(Button); + edit_btn->set_accessibility_name(TTRC("Edit")); edit_btn->set_button_icon(get_editor_theme_icon(SNAME("Edit"))); edit_btn->set_disabled(is_read_only()); edit_btn->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyArray::_change_type).bind(edit_btn, idx)); hbox->add_child(edit_btn); } else { Button *remove_btn = memnew(Button); + remove_btn->set_accessibility_name(TTRC("Remove")); remove_btn->set_button_icon(get_editor_theme_icon(SNAME("Remove"))); remove_btn->set_disabled(is_read_only()); remove_btn->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyArray::_remove_pressed).bind(idx)); @@ -444,6 +447,7 @@ void EditorPropertyArray::update_property() { size_slider->set_editing_integer(true); size_slider->set_h_size_flags(SIZE_EXPAND_FILL); size_slider->set_read_only(is_read_only()); + size_slider->set_accessibility_name(TTRC("Size")); size_slider->connect(SceneStringName(value_changed), callable_mp(this, &EditorPropertyArray::_length_changed)); hbox->add_child(size_slider); @@ -457,6 +461,7 @@ void EditorPropertyArray::update_property() { button_add_item->connect(SceneStringName(draw), callable_mp(this, &EditorPropertyArray::_button_add_item_draw)); SET_DRAG_FORWARDING_CD(button_add_item, EditorPropertyArray); button_add_item->set_disabled(is_read_only()); + button_add_item->set_accessibility_name(TTRC("Add")); vbox->add_child(button_add_item); paginator = memnew(EditorPaginator); @@ -955,6 +960,7 @@ EditorPropertyArray::EditorPropertyArray() { page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page")); edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); edit->set_h_size_flags(SIZE_EXPAND_FILL); edit->set_clip_text(true); edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyArray::_edit_pressed)); @@ -1068,12 +1074,14 @@ void EditorPropertyDictionary::_create_new_property_slot(int p_idx) { if (is_untyped_dict) { Button *edit_btn = memnew(Button); + edit_btn->set_accessibility_name(TTRC("Edit")); edit_btn->set_button_icon(get_editor_theme_icon(SNAME("Edit"))); edit_btn->set_disabled(is_read_only()); edit_btn->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyDictionary::_change_type).bind(edit_btn, slots.size())); hbox->add_child(edit_btn); } else if (p_idx >= 0) { Button *remove_btn = memnew(Button); + remove_btn->set_accessibility_name(TTRC("Remove")); remove_btn->set_button_icon(get_editor_theme_icon(SNAME("Remove"))); remove_btn->set_disabled(is_read_only()); remove_btn->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyDictionary::_remove_pressed).bind(slots.size())); @@ -1288,6 +1296,7 @@ void EditorPropertyDictionary::update_property() { button_add_item = EditorInspector::create_inspector_action_button(TTR("Add Key/Value Pair")); button_add_item->set_button_icon(get_theme_icon(SNAME("Add"), EditorStringName(EditorIcons))); button_add_item->set_disabled(is_read_only()); + button_add_item->set_accessibility_name(TTRC("Add")); button_add_item->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyDictionary::_add_key_value)); add_vbox->add_child(button_add_item); } @@ -1482,6 +1491,7 @@ EditorPropertyDictionary::EditorPropertyDictionary() { page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page")); edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); edit->set_h_size_flags(SIZE_EXPAND_FILL); edit->set_clip_text(true); edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyDictionary::_edit_pressed)); @@ -1637,6 +1647,7 @@ void EditorPropertyLocalizableString::update_property() { hbox->add_child(prop); prop->set_h_size_flags(SIZE_EXPAND_FILL); Button *edit_btn = memnew(Button); + edit_btn->set_accessibility_name(TTRC("Remove Translation")); edit_btn->set_button_icon(get_editor_theme_icon(SNAME("Remove"))); hbox->add_child(edit_btn); edit_btn->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyLocalizableString::_remove_item).bind(edit_btn, remove_index)); @@ -1646,6 +1657,7 @@ void EditorPropertyLocalizableString::update_property() { if (page_index == max_page) { button_add_item = EditorInspector::create_inspector_action_button(TTR("Add Translation")); + button_add_item->set_accessibility_name(TTRC("Add Translation")); button_add_item->set_button_icon(get_editor_theme_icon(SNAME("Add"))); button_add_item->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyLocalizableString::_add_locale_popup)); property_vbox->add_child(button_add_item); @@ -1702,6 +1714,7 @@ EditorPropertyLocalizableString::EditorPropertyLocalizableString() { page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page")); edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); edit->set_h_size_flags(SIZE_EXPAND_FILL); edit->set_clip_text(true); edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyLocalizableString::_edit_pressed)); diff --git a/editor/editor_properties_vector.cpp b/editor/editor_properties_vector.cpp index 0ec7cf518a4c..0cd0fdd8b313 100644 --- a/editor/editor_properties_vector.cpp +++ b/editor/editor_properties_vector.cpp @@ -222,6 +222,7 @@ EditorPropertyVectorN::EditorPropertyVectorN(Variant::Type p_type, bool p_force_ bc->add_child(spin[i]); spin[i]->set_flat(true); spin[i]->set_label(String(COMPONENT_LABELS[i])); + spin[i]->set_accessibility_name(String(COMPONENT_LABELS[i])); if (horizontal) { spin[i]->set_h_size_flags(SIZE_EXPAND_FILL); } @@ -238,6 +239,7 @@ EditorPropertyVectorN::EditorPropertyVectorN(Variant::Type p_type, bool p_force_ linked->set_toggle_mode(true); linked->set_stretch_mode(TextureButton::STRETCH_KEEP_CENTERED); linked->set_tooltip_text(TTR("Lock/Unlock Component Ratio")); + linked->set_accessibility_name(TTRC("Lock/Unlock Component Ratio")); linked->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyVectorN::_update_ratio)); linked->connect(SceneStringName(toggled), callable_mp(this, &EditorPropertyVectorN::_store_link)); hb->add_child(linked); diff --git a/editor/editor_resource_picker.cpp b/editor/editor_resource_picker.cpp index 846bf46e5b38..21ccb078e1a5 100644 --- a/editor/editor_resource_picker.cpp +++ b/editor/editor_resource_picker.cpp @@ -398,6 +398,7 @@ void EditorResourcePicker::_edit_menu_cbk(int p_which) { vb->add_child(label); duplicate_resources_tree = memnew(Tree); + duplicate_resources_tree->set_accessibility_name(TTRC("Duplicate resources")); duplicate_resources_tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); vb->add_child(duplicate_resources_tree); duplicate_resources_tree->set_columns(2); @@ -1103,6 +1104,7 @@ EditorResourcePicker::EditorResourcePicker(bool p_hide_assign_button_controls) { assign_button = memnew(Button); assign_button->set_flat(true); assign_button->set_h_size_flags(SIZE_EXPAND_FILL); + assign_button->set_accessibility_name(TTRC("Assign Resource")); assign_button->set_expand_icon(true); assign_button->set_clip_text(true); assign_button->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); @@ -1127,8 +1129,9 @@ EditorResourcePicker::EditorResourcePicker(bool p_hide_assign_button_controls) { edit_button->set_flat(false); edit_button->set_toggle_mode(true); edit_button->set_action_mode(BaseButton::ACTION_MODE_BUTTON_PRESS); - edit_button->connect(SceneStringName(pressed), callable_mp(this, &EditorResourcePicker::_update_menu)); + edit_button->set_accessibility_name(TTRC("Edit")); add_child(edit_button); + edit_button->connect(SceneStringName(pressed), callable_mp(this, &EditorResourcePicker::_update_menu)); edit_button->connect(SceneStringName(gui_input), callable_mp(this, &EditorResourcePicker::_button_input)); add_theme_constant_override("separation", 0); diff --git a/editor/editor_run_native.cpp b/editor/editor_run_native.cpp index 5f237943c73e..91cbe4edbd5c 100644 --- a/editor/editor_run_native.cpp +++ b/editor/editor_run_native.cpp @@ -201,6 +201,7 @@ EditorRunNative::EditorRunNative() { remote_debug->set_theme_type_variation("RunBarButton"); remote_debug->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &EditorRunNative::start_run_native)); remote_debug->set_tooltip_text(TTR("Remote Deploy")); + remote_debug->set_accessibility_name(TTRC("Remote Deploy")); remote_debug->set_disabled(true); add_child(remote_debug); diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp index 0a293144001f..44d01dc5d9b6 100644 --- a/editor/editor_settings.cpp +++ b/editor/editor_settings.cpp @@ -661,6 +661,7 @@ void EditorSettings::_load_defaults(Ref p_extra_config) { _initial_set("docks/scene_tree/auto_expand_to_selected", true); _initial_set("docks/scene_tree/center_node_on_reparent", false); _initial_set("docks/scene_tree/hide_filtered_out_parents", true); + _initial_set("docks/scene_tree/accessibility_warnings", false); // FileSystem EDITOR_SETTING(Variant::INT, PROPERTY_HINT_RANGE, "docks/filesystem/thumbnail_size", 64, "32,128,16") diff --git a/editor/editor_settings_dialog.cpp b/editor/editor_settings_dialog.cpp index 658e733d3a89..d497bfab5d65 100644 --- a/editor/editor_settings_dialog.cpp +++ b/editor/editor_settings_dialog.cpp @@ -759,7 +759,7 @@ Variant EditorSettingsDialog::get_drag_data_fw(const Point2 &p_point, Control *p bool EditorSettingsDialog::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const { TreeItem *selected = shortcuts->get_selected(); - TreeItem *item = shortcuts->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? shortcuts->get_selected() : shortcuts->get_item_at_position(p_point); if (!selected || !item || item == selected || (String)item->get_meta("type", "") != "event") { return false; } @@ -778,7 +778,7 @@ void EditorSettingsDialog::drop_data_fw(const Point2 &p_point, const Variant &p_ } TreeItem *selected = shortcuts->get_selected(); - TreeItem *target = shortcuts->get_item_at_position(p_point); + TreeItem *target = (p_point == Vector2(INFINITY, INFINITY)) ? shortcuts->get_selected() : shortcuts->get_item_at_position(p_point); if (!target) { return; @@ -901,6 +901,7 @@ EditorSettingsDialog::EditorSettingsDialog() { search_box = memnew(LineEdit); search_box->set_placeholder(TTR("Filter Settings")); + search_box->set_accessibility_name(TTRC("Filter Settings")); search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); hbc->add_child(search_box); @@ -936,6 +937,7 @@ EditorSettingsDialog::EditorSettingsDialog() { restart_hb->add_child(restart_button); restart_button->set_text(TTR("Save & Restart")); restart_close_button = memnew(Button); + restart_close_button->set_accessibility_name(TTRC("Close")); restart_close_button->set_flat(true); restart_close_button->connect(SceneStringName(pressed), callable_mp(this, &EditorSettingsDialog::_editor_restart_close)); restart_hb->add_child(restart_close_button); @@ -954,6 +956,7 @@ EditorSettingsDialog::EditorSettingsDialog() { shortcut_search_box = memnew(LineEdit); shortcut_search_box->set_placeholder(TTR("Filter by Name")); + shortcut_search_box->set_accessibility_name(TTRC("Filter by Name")); shortcut_search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); top_hbox->add_child(shortcut_search_box); shortcut_search_box->connect(SceneStringName(text_changed), callable_mp(this, &EditorSettingsDialog::_filter_shortcuts)); @@ -975,6 +978,7 @@ EditorSettingsDialog::EditorSettingsDialog() { top_hbox->add_child(clear_all_search); shortcuts = memnew(Tree); + shortcuts->set_accessibility_name(TTRC("Shortcuts")); shortcuts->set_v_size_flags(Control::SIZE_EXPAND_FILL); shortcuts->set_columns(2); shortcuts->set_hide_root(true); diff --git a/editor/engine_update_label.cpp b/editor/engine_update_label.cpp index b03d1d8d34fb..831459cdcb14 100644 --- a/editor/engine_update_label.cpp +++ b/editor/engine_update_label.cpp @@ -184,17 +184,20 @@ void EngineUpdateLabel::_set_status(UpdateStatus p_status) { } else { _set_message(TTR("Update checks disabled."), theme_cache.disabled_color); } + set_accessibility_live(DisplayServer::AccessibilityLiveMode::LIVE_OFF); set_tooltip_text(""); break; } case UpdateStatus::ERROR: { set_disabled(false); + set_accessibility_live(DisplayServer::AccessibilityLiveMode::LIVE_POLITE); set_tooltip_text(TTR("An error has occurred. Click to try again.")); } break; case UpdateStatus::UPDATE_AVAILABLE: { set_disabled(false); + set_accessibility_live(DisplayServer::AccessibilityLiveMode::LIVE_POLITE); set_tooltip_text(TTR("Click to open download page.")); } break; diff --git a/editor/event_listener_line_edit.cpp b/editor/event_listener_line_edit.cpp index a6b30233fc20..c8151ed9f984 100644 --- a/editor/event_listener_line_edit.cpp +++ b/editor/event_listener_line_edit.cpp @@ -162,8 +162,26 @@ void EventListenerLineEdit::gui_input(const Ref &p_event) { return; } + // Allow releasing focus by holding "ui_cancel" action. + bool accept_release = false; + uint64_t hold_to_unfocus_timeout = 3000; + if (p_event->is_action_pressed(SNAME("ui_cancel"), true, true)) { + if ((OS::get_singleton()->get_ticks_msec() - hold_next) < hold_to_unfocus_timeout) { + hold_next = 0; + Control *next = find_next_valid_focus(); + next->grab_focus(); + } else { + hold_next = OS::get_singleton()->get_ticks_msec(); + } + accept_event(); + return; + } else if (p_event->is_action_released(SNAME("ui_cancel"), true)) { + accept_release = true; + } + hold_next = 0; + accept_event(); - if (!p_event->is_pressed() || p_event->is_echo() || p_event->is_match(event) || !_is_event_allowed(p_event)) { + if (!(p_event->is_pressed() || accept_release) || p_event->is_echo() || p_event->is_match(event) || !_is_event_allowed(p_event)) { return; } @@ -215,6 +233,12 @@ void EventListenerLineEdit::grab_focus() { void EventListenerLineEdit::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_extra_info(ae, vformat(TTR("Listening for Input. Hold %s to release focus."), InputMap::get_singleton()->get_action_description("ui_cancel"))); + } break; case NOTIFICATION_ENTER_TREE: { connect(SceneStringName(text_changed), callable_mp(this, &EventListenerLineEdit::_on_text_changed)); connect(SceneStringName(focus_entered), callable_mp(this, &EventListenerLineEdit::_on_focus)); diff --git a/editor/event_listener_line_edit.h b/editor/event_listener_line_edit.h index aaf987943d13..ca2744162e6e 100644 --- a/editor/event_listener_line_edit.h +++ b/editor/event_listener_line_edit.h @@ -42,6 +42,8 @@ enum InputType { class EventListenerLineEdit : public LineEdit { GDCLASS(EventListenerLineEdit, LineEdit) + uint64_t hold_next = 0; + int allowed_input_types = INPUT_KEY | INPUT_MOUSE_BUTTON | INPUT_JOY_BUTTON | INPUT_JOY_MOTION; bool ignore_next_event = true; bool share_keycodes = false; diff --git a/editor/export/export_template_manager.cpp b/editor/export/export_template_manager.cpp index 8a5fe43ff445..71dd2f583a73 100644 --- a/editor/export/export_template_manager.cpp +++ b/editor/export/export_template_manager.cpp @@ -1017,6 +1017,7 @@ ExportTemplateManager::ExportTemplateManager() { current_installed_path = memnew(LineEdit); current_installed_path->set_editable(false); current_installed_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); + current_installed_path->set_accessibility_name(TTRC("Installed Path")); current_installed_hb->add_child(current_installed_path); #ifndef ANDROID_ENABLED @@ -1052,6 +1053,7 @@ ExportTemplateManager::ExportTemplateManager() { download_install_hb->add_child(mirrors_label); mirrors_list = memnew(OptionButton); + mirrors_list->set_accessibility_name(TTRC("Mirror")); mirrors_list->set_custom_minimum_size(Size2(280, 0) * EDSCALE); download_install_hb->add_child(mirrors_list); @@ -1060,6 +1062,7 @@ ExportTemplateManager::ExportTemplateManager() { request_mirrors->connect("request_completed", callable_mp(this, &ExportTemplateManager::_refresh_mirrors_completed)); mirror_options_button = memnew(MenuButton); + mirror_options_button->set_accessibility_name(TTRC("Mirror Options")); mirror_options_button->get_popup()->add_item(TTR("Open in Web Browser"), VISIT_WEB_MIRROR); mirror_options_button->get_popup()->add_item(TTR("Copy Mirror URL"), COPY_MIRROR_URL); download_install_hb->add_child(mirror_options_button); diff --git a/editor/export/project_export.cpp b/editor/export/project_export.cpp index e8b36959d7b0..2db79dfc2ee4 100644 --- a/editor/export/project_export.cpp +++ b/editor/export/project_export.cpp @@ -745,7 +745,14 @@ void ProjectExportDialog::_delete_preset_confirm() { Variant ProjectExportDialog::get_drag_data_fw(const Point2 &p_point, Control *p_from) { if (p_from == presets) { - int pos = presets->get_item_at_position(p_point, true); + int pos = -1; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (presets->is_anything_selected()) { + pos = presets->get_selected_items()[0]; + } + } else { + pos = presets->get_item_at_position(p_point, true); + } if (pos >= 0) { Dictionary d; @@ -766,7 +773,7 @@ Variant ProjectExportDialog::get_drag_data_fw(const Point2 &p_point, Control *p_ return d; } } else if (p_from == patches) { - TreeItem *item = patches->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? patches->get_selected() : patches->get_item_at_position(p_point); if (item) { int item_metadata = item->get_metadata(0); @@ -791,7 +798,18 @@ bool ProjectExportDialog::can_drop_data_fw(const Point2 &p_point, const Variant return false; } - if (presets->get_item_at_position(p_point, true) < 0 && !presets->is_pos_at_end_of_items(p_point)) { + int pos = -1; + bool end = true; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (presets->is_anything_selected()) { + pos = presets->get_selected_items()[0]; + } + } else { + pos = presets->get_item_at_position(p_point, true); + end = presets->is_pos_at_end_of_items(p_point); + } + + if (pos < 0 && !end) { return false; } } else if (p_from == patches) { @@ -800,7 +818,7 @@ bool ProjectExportDialog::can_drop_data_fw(const Point2 &p_point, const Variant return false; } - TreeItem *item = patches->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? patches->get_selected() : patches->get_item_at_position(p_point); if (!item) { return false; } @@ -818,11 +836,22 @@ void ProjectExportDialog::drop_data_fw(const Point2 &p_point, const Variant &p_d int to_pos = -1; - if (presets->get_item_at_position(p_point, true) >= 0) { - to_pos = presets->get_item_at_position(p_point, true); + int pos = -1; + bool end = true; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (presets->is_anything_selected()) { + pos = presets->get_selected_items()[0]; + } + } else { + pos = presets->get_item_at_position(p_point, true); + end = presets->is_pos_at_end_of_items(p_point); } - if (to_pos == -1 && !presets->is_pos_at_end_of_items(p_point)) { + if (pos >= 0) { + to_pos = pos; + } + + if (to_pos == -1 && !end) { return; } @@ -846,14 +875,20 @@ void ProjectExportDialog::drop_data_fw(const Point2 &p_point, const Variant &p_d Dictionary d = p_data; int from_pos = d["patch"]; - TreeItem *item = patches->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? patches->get_selected() : patches->get_item_at_position(p_point); if (!item) { return; } int to_pos = item->get_metadata(0); - if (patches->get_drop_section_at_position(p_point) > 0) { + int pos = -1; + if (p_point == Vector2(INFINITY, INFINITY)) { + pos = patches->get_drop_section_at_position(patches->get_item_rect(item).position); + } else { + pos = patches->get_drop_section_at_position(p_point); + } + if (pos > 0) { to_pos++; } @@ -1428,11 +1463,13 @@ ProjectExportDialog::ProjectExportDialog() { presets->connect(SceneStringName(item_selected), callable_mp(this, &ProjectExportDialog::_edit_preset)); duplicate_preset = memnew(Button); duplicate_preset->set_tooltip_text(TTR("Duplicate")); + duplicate_preset->set_accessibility_name(TTRC("Duplicate")); duplicate_preset->set_flat(true); preset_hb->add_child(duplicate_preset); duplicate_preset->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_duplicate_preset)); delete_preset = memnew(Button); delete_preset->set_tooltip_text(TTR("Delete")); + delete_preset->set_accessibility_name(TTRC("Delete")); delete_preset->set_flat(true); preset_hb->add_child(delete_preset); delete_preset->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_delete_preset)); @@ -1501,6 +1538,7 @@ ProjectExportDialog::ProjectExportDialog() { resources_scroll_container->add_child(resources_vb); export_filter = memnew(OptionButton); + export_filter->set_accessibility_name(TTRC("Export Mode")); export_filter->add_item(TTR("Export all resources in the project")); export_filter->add_item(TTR("Export selected scenes (and dependencies)")); export_filter->add_item(TTR("Export selected resources (and dependencies)")); @@ -1555,12 +1593,14 @@ ProjectExportDialog::ProjectExportDialog() { file_mode_popup->connect(SceneStringName(id_pressed), callable_mp(this, &ProjectExportDialog::_set_file_export_mode)); include_filters = memnew(LineEdit); + include_filters->set_accessibility_name(TTRC("Include Filters")); resources_vb->add_margin_child( TTR("Filters to export non-resource files/folders\n(comma-separated, e.g: *.json, *.txt, docs/*)"), include_filters); include_filters->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_filter_changed)); exclude_filters = memnew(LineEdit); + exclude_filters->set_accessibility_name(TTRC("Exclude Filters")); resources_vb->add_margin_child( TTR("Filters to exclude files/folders from project\n(comma-separated, e.g: *.json, *.txt, docs/*)"), exclude_filters); @@ -1635,18 +1675,21 @@ ProjectExportDialog::ProjectExportDialog() { sec_vb->add_child(enc_directory); enc_in_filters = memnew(LineEdit); + enc_in_filters->set_accessibility_name(TTRC("Include Filters")); enc_in_filters->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_enc_filters_changed)); sec_vb->add_margin_child( TTR("Filters to include files/folders\n(comma-separated, e.g: *.tscn, *.tres, scenes/*)"), enc_in_filters); enc_ex_filters = memnew(LineEdit); + enc_ex_filters->set_accessibility_name(TTRC("Exclude Filters")); enc_ex_filters->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_enc_filters_changed)); sec_vb->add_margin_child( TTR("Filters to exclude files/folders\n(comma-separated, e.g: *.ctex, *.import, music/*)"), enc_ex_filters); script_key = memnew(LineEdit); + script_key->set_accessibility_name(TTRC("Encryption Key")); script_key->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_script_encryption_key_changed)); script_key_error = memnew(Label); script_key_error->set_text(String::utf8("• ") + TTR("Invalid Encryption Key (must be 64 hexadecimal characters long)")); @@ -1656,6 +1699,7 @@ ProjectExportDialog::ProjectExportDialog() { sections->add_child(sec_scroll_container); seed_input = memnew(LineEdit); + seed_input->set_accessibility_name(TTRC("Encryption Seed")); seed_input->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_seed_input_changed)); sec_vb->add_margin_child(TTR("Initialization vector seed"), seed_input); @@ -1674,6 +1718,7 @@ ProjectExportDialog::ProjectExportDialog() { script_vb->set_name(TTR("Scripts")); script_mode = memnew(OptionButton); + script_mode->set_accessibility_name(TTRC("GDScript Export Mode")); script_vb->add_margin_child(TTR("GDScript Export Mode:"), script_mode); script_mode->add_item(TTR("Text (easier debugging)"), (int)EditorExportPreset::MODE_SCRIPT_TEXT); script_mode->add_item(TTR("Binary tokens (faster loading)"), (int)EditorExportPreset::MODE_SCRIPT_BINARY_TOKENS); diff --git a/editor/fbx_importer_manager.cpp b/editor/fbx_importer_manager.cpp index f612c3bd8113..72806ad64a90 100644 --- a/editor/fbx_importer_manager.cpp +++ b/editor/fbx_importer_manager.cpp @@ -150,6 +150,7 @@ FBXImporterManager::FBXImporterManager() { fbx_path = memnew(LineEdit); fbx_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); + fbx_path->set_accessibility_name(TTRC("Path")); hb->add_child(fbx_path); fbx_path_browse = memnew(Button); fbx_path_browse->set_text(TTR("Browse")); diff --git a/editor/filesystem_dock.cpp b/editor/filesystem_dock.cpp index 388abafc01f1..aea97507eb2c 100644 --- a/editor/filesystem_dock.cpp +++ b/editor/filesystem_dock.cpp @@ -2857,12 +2857,12 @@ bool FileSystemDock::can_drop_data_fw(const Point2 &p_point, const Variant &p_da } // Moving favorite around. - TreeItem *ti = tree->get_item_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); if (!ti) { return false; } - int drop_section = tree->get_drop_section_at_position(p_point); + int drop_section = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_drop_section_at_position(tree->get_item_rect(ti).position) : tree->get_drop_section_at_position(p_point); if (ti == favorites_item) { return (drop_section == 1); // The parent, first fav. } @@ -2935,11 +2935,11 @@ void FileSystemDock::drop_data_fw(const Point2 &p_point, const Variant &p_data, return; } // Moving favorite around. - TreeItem *ti = tree->get_item_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); if (!ti) { return; } - int drop_section = tree->get_drop_section_at_position(p_point); + int drop_section = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_drop_section_at_position(tree->get_item_rect(ti).position) : tree->get_drop_section_at_position(p_point); int drop_position; Vector drag_files = drag_data["files"]; @@ -3059,7 +3059,7 @@ void FileSystemDock::_get_drag_target_folder(String &target, bool &target_favori // In the file list. if (p_from == files) { - int pos = files->get_item_at_position(p_point, true); + int pos = (p_point == Vector2(INFINITY, INFINITY)) ? -1 : files->get_item_at_position(p_point, true); if (pos == -1) { target = get_current_directory(); return; @@ -3072,8 +3072,8 @@ void FileSystemDock::_get_drag_target_folder(String &target, bool &target_favori // In the tree. if (p_from == tree) { - TreeItem *ti = tree->get_item_at_position(p_point); - int section = tree->get_drop_section_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); + int section = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_drop_section_at_position(tree->get_item_rect(ti).position) : tree->get_drop_section_at_position(p_point); if (ti) { // Check the favorites first. if (ti == tree->get_root()->get_first_child() && section >= 0) { @@ -3887,6 +3887,7 @@ MenuButton *FileSystemDock::_create_file_menu_button() { button->set_flat(false); button->set_theme_type_variation("FlatMenuButton"); button->set_tooltip_text(TTRC("Sort Files")); + button->set_accessibility_name(TTRC("Sort Files")); PopupMenu *p = button->get_popup(); p->connect(SceneStringName(id_pressed), callable_mp(this, &FileSystemDock::_file_sort_popup)); @@ -4081,6 +4082,7 @@ FileSystemDock::FileSystemDock() { button_hist_prev->set_disabled(true); button_hist_prev->set_focus_mode(FOCUS_NONE); button_hist_prev->set_tooltip_text(TTRC("Go to previous selected folder/file.")); + button_hist_prev->set_accessibility_name(TTRC("Previous")); nav_hbc->add_child(button_hist_prev); button_hist_next = memnew(Button); @@ -4088,10 +4090,12 @@ FileSystemDock::FileSystemDock() { button_hist_next->set_disabled(true); button_hist_next->set_focus_mode(FOCUS_NONE); button_hist_next->set_tooltip_text(TTRC("Go to next selected folder/file.")); + button_hist_next->set_accessibility_name(TTRC("Next")); nav_hbc->add_child(button_hist_next); current_path_line_edit = memnew(LineEdit); current_path_line_edit->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); + current_path_line_edit->set_accessibility_name(TTRC("Path")); current_path_line_edit->set_h_size_flags(SIZE_EXPAND_FILL); _set_current_path_line_edit_text(current_path); toolbar_hbc->add_child(current_path_line_edit); @@ -4100,11 +4104,13 @@ FileSystemDock::FileSystemDock() { button_toggle_display_mode->connect(SceneStringName(pressed), callable_mp(this, &FileSystemDock::_change_split_mode)); button_toggle_display_mode->set_focus_mode(FOCUS_NONE); button_toggle_display_mode->set_tooltip_text(TTRC("Change Split Mode")); + button_toggle_display_mode->set_accessibility_name(TTRC("Change Split Mode")); button_toggle_display_mode->set_theme_type_variation("FlatMenuButton"); toolbar_hbc->add_child(button_toggle_display_mode); button_dock_placement = memnew(Button); button_dock_placement->set_theme_type_variation("FlatMenuButton"); + button_dock_placement->set_accessibility_name(TTRC("Dock Placement")); button_dock_placement->connect(SceneStringName(pressed), callable_mp(this, &FileSystemDock::_change_bottom_dock_placement)); button_dock_placement->hide(); toolbar_hbc->add_child(button_dock_placement); @@ -4115,6 +4121,7 @@ FileSystemDock::FileSystemDock() { tree_search_box = memnew(LineEdit); tree_search_box->set_h_size_flags(SIZE_EXPAND_FILL); tree_search_box->set_placeholder(TTRC("Filter Files")); + tree_search_box->set_accessibility_name(TTRC("Filter Files")); tree_search_box->set_clear_button_enabled(true); tree_search_box->connect(SceneStringName(text_changed), callable_mp(this, &FileSystemDock::_search_changed).bind(tree_search_box)); toolbar2_hbc->add_child(tree_search_box); @@ -4137,6 +4144,7 @@ FileSystemDock::FileSystemDock() { add_child(split_box); tree = memnew(FileSystemTree); + tree->set_accessibility_name(TTRC("Directories")); tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); @@ -4167,6 +4175,7 @@ FileSystemDock::FileSystemDock() { file_list_search_box = memnew(LineEdit); file_list_search_box->set_h_size_flags(SIZE_EXPAND_FILL); file_list_search_box->set_placeholder(TTRC("Filter Files")); + file_list_search_box->set_accessibility_name(TTRC("Filter Files")); file_list_search_box->set_clear_button_enabled(true); file_list_search_box->connect(SceneStringName(text_changed), callable_mp(this, &FileSystemDock::_search_changed).bind(file_list_search_box)); path_hb->add_child(file_list_search_box); @@ -4175,11 +4184,13 @@ FileSystemDock::FileSystemDock() { path_hb->add_child(file_list_button_sort); button_file_list_display_mode = memnew(Button); + button_file_list_display_mode->set_accessibility_name(TTRC("Display Mode")); button_file_list_display_mode->set_theme_type_variation("FlatMenuButton"); path_hb->add_child(button_file_list_display_mode); files = memnew(FileSystemList); files->set_v_size_flags(SIZE_EXPAND_FILL); + files->set_accessibility_name(TTRC("Files")); files->set_select_mode(ItemList::SELECT_MULTI); files->set_theme_type_variation("ItemListSecondary"); SET_DRAG_FORWARDING_GCD(files, FileSystemDock); @@ -4202,6 +4213,7 @@ FileSystemDock::FileSystemDock() { scanning_vb->add_child(slabel); scanning_progress = memnew(ProgressBar); + scanning_progress->set_accessibility_name(TTRC("Filesystem Scan")); scanning_vb->add_child(scanning_progress); deps_editor = memnew(DependencyEditor); diff --git a/editor/find_in_files.cpp b/editor/find_in_files.cpp index fb9c16871843..bb79e0ea0495 100644 --- a/editor/find_in_files.cpp +++ b/editor/find_in_files.cpp @@ -319,6 +319,7 @@ FindInFilesDialog::FindInFilesDialog() { _search_text_line_edit = memnew(LineEdit); _search_text_line_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); + _search_text_line_edit->set_accessibility_name(TTRC("Search")); _search_text_line_edit->connect(SceneStringName(text_changed), callable_mp(this, &FindInFilesDialog::_on_search_text_modified)); _search_text_line_edit->connect(SceneStringName(text_submitted), callable_mp(this, &FindInFilesDialog::_on_search_text_submitted)); gc->add_child(_search_text_line_edit); @@ -330,6 +331,7 @@ FindInFilesDialog::FindInFilesDialog() { _replace_text_line_edit = memnew(LineEdit); _replace_text_line_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); + _replace_text_line_edit->set_accessibility_name(TTRC("Replace")); _replace_text_line_edit->connect(SceneStringName(text_submitted), callable_mp(this, &FindInFilesDialog::_on_replace_text_submitted)); _replace_text_line_edit->hide(); gc->add_child(_replace_text_line_edit); @@ -366,6 +368,7 @@ FindInFilesDialog::FindInFilesDialog() { hbc->add_child(_folder_line_edit); Button *folder_button = memnew(Button); + folder_button->set_accessibility_name(TTRC("Select Folder")); folder_button->set_text("..."); folder_button->connect(SceneStringName(pressed), callable_mp(this, &FindInFilesDialog::_on_folder_button_pressed)); hbc->add_child(folder_button); @@ -622,6 +625,7 @@ FindInFilesPanel::FindInFilesPanel() { } _results_display = memnew(Tree); + _results_display->set_accessibility_name(TTRC("Search Results")); _results_display->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); _results_display->set_v_size_flags(SIZE_EXPAND_FILL); _results_display->connect(SceneStringName(item_selected), callable_mp(this, &FindInFilesPanel::_on_result_selected)); @@ -644,6 +648,7 @@ FindInFilesPanel::FindInFilesPanel() { _replace_container->add_child(replace_label); _replace_line_edit = memnew(LineEdit); + _replace_line_edit->set_accessibility_name(TTRC("Replace")); _replace_line_edit->set_h_size_flags(SIZE_EXPAND_FILL); _replace_line_edit->connect(SceneStringName(text_changed), callable_mp(this, &FindInFilesPanel::_on_replace_text_changed)); _replace_container->add_child(_replace_line_edit); diff --git a/editor/group_settings_editor.cpp b/editor/group_settings_editor.cpp index b7482cdfff51..33d29819612f 100644 --- a/editor/group_settings_editor.cpp +++ b/editor/group_settings_editor.cpp @@ -499,6 +499,7 @@ GroupSettingsEditor::GroupSettingsEditor() { group_name = memnew(LineEdit); group_name->set_h_size_flags(SIZE_EXPAND_FILL); group_name->set_clear_button_enabled(true); + group_name->set_accessibility_name(TTRC("Group Name")); group_name->connect(SceneStringName(text_changed), callable_mp(this, &GroupSettingsEditor::_group_name_text_changed)); group_name->connect(SceneStringName(text_submitted), callable_mp(this, &GroupSettingsEditor::_text_submitted)); hbc->add_child(group_name); @@ -509,6 +510,7 @@ GroupSettingsEditor::GroupSettingsEditor() { group_description = memnew(LineEdit); group_description->set_clear_button_enabled(true); + group_description->set_accessibility_name(TTRC("Group Description")); group_description->set_h_size_flags(SIZE_EXPAND_FILL); group_description->connect(SceneStringName(text_submitted), callable_mp(this, &GroupSettingsEditor::_text_submitted)); hbc->add_child(group_description); diff --git a/editor/groups_editor.cpp b/editor/groups_editor.cpp index 756f09e97b81..3534f16554e6 100644 --- a/editor/groups_editor.cpp +++ b/editor/groups_editor.cpp @@ -633,6 +633,7 @@ void GroupsEditor::_show_add_group_dialog() { add_group_name = memnew(LineEdit); add_group_name->set_custom_minimum_size(Size2(200 * EDSCALE, 0)); add_group_name->set_h_size_flags(SIZE_EXPAND_FILL); + add_group_name->set_accessibility_name(TTRC("Name")); hbc->add_child(add_group_name); global_group_button = memnew(CheckButton); @@ -646,6 +647,7 @@ void GroupsEditor::_show_add_group_dialog() { add_group_description = memnew(LineEdit); add_group_description->set_h_size_flags(SIZE_EXPAND_FILL); add_group_description->set_editable(false); + add_group_description->set_accessibility_name(TTRC("Description")); gc->add_child(add_group_description); global_group_button->connect(SceneStringName(toggled), callable_mp(add_group_description, &LineEdit::set_editable)); @@ -841,6 +843,7 @@ GroupsEditor::GroupsEditor() { add = memnew(Button); add->set_theme_type_variation("FlatMenuButton"); + add->set_accessibility_name(TTRC("Add Group")); add->set_tooltip_text(TTR("Add a new group.")); add->connect(SceneStringName(pressed), callable_mp(this, &GroupsEditor::_show_add_group_dialog)); hbc->add_child(add); @@ -848,6 +851,7 @@ GroupsEditor::GroupsEditor() { filter = memnew(LineEdit); filter->set_clear_button_enabled(true); filter->set_placeholder(TTR("Filter Groups")); + filter->set_accessibility_name(TTRC("Filter Groups")); filter->set_h_size_flags(SIZE_EXPAND_FILL); filter->connect(SceneStringName(text_changed), callable_mp(this, &GroupsEditor::_update_tree).unbind(1)); hbc->add_child(filter); diff --git a/editor/gui/editor_bottom_panel.cpp b/editor/gui/editor_bottom_panel.cpp index e984f196fbb1..f0e3bef09191 100644 --- a/editor/gui/editor_bottom_panel.cpp +++ b/editor/gui/editor_bottom_panel.cpp @@ -307,6 +307,7 @@ EditorBottomPanel::EditorBottomPanel() { left_button = memnew(Button); left_button->set_tooltip_text(TTR("Scroll Left\nHold Ctrl to scroll to the begin.\nHold Shift to scroll one page.")); + left_button->set_accessibility_name(TTRC("Scroll Left")); left_button->set_theme_type_variation("BottomPanelButton"); left_button->set_focus_mode(Control::FOCUS_NONE); left_button->connect(SceneStringName(pressed), callable_mp(this, &EditorBottomPanel::_scroll).bind(false)); @@ -323,6 +324,7 @@ EditorBottomPanel::EditorBottomPanel() { right_button = memnew(Button); right_button->set_tooltip_text(TTR("Scroll Right\nHold Ctrl to scroll to the end.\nHold Shift to scroll one page.")); + right_button->set_accessibility_name(TTRC("Scroll Right")); right_button->set_theme_type_variation("BottomPanelButton"); right_button->set_focus_mode(Control::FOCUS_NONE); right_button->connect(SceneStringName(pressed), callable_mp(this, &EditorBottomPanel::_scroll).bind(true)); @@ -354,6 +356,7 @@ EditorBottomPanel::EditorBottomPanel() { pin_button->set_theme_type_variation("FlatMenuButton"); pin_button->set_toggle_mode(true); pin_button->set_tooltip_text(TTR("Pin Bottom Panel Switching")); + pin_button->set_accessibility_name(TTRC("Pin Bottom Panel")); pin_button->connect(SceneStringName(toggled), callable_mp(this, &EditorBottomPanel::_pin_button_toggled)); expand_button = memnew(Button); @@ -361,6 +364,7 @@ EditorBottomPanel::EditorBottomPanel() { expand_button->hide(); expand_button->set_theme_type_variation("FlatMenuButton"); expand_button->set_toggle_mode(true); + expand_button->set_accessibility_name(TTRC("Expand Bottom Panel")); expand_button->set_shortcut(ED_SHORTCUT_AND_COMMAND("editor/bottom_panel_expand", TTRC("Expand Bottom Panel"), KeyModifierMask::SHIFT | Key::F12)); expand_button->connect(SceneStringName(toggled), callable_mp(this, &EditorBottomPanel::_expand_button_toggled)); } diff --git a/editor/gui/editor_file_dialog.cpp b/editor/gui/editor_file_dialog.cpp index f7db59d50a54..1a8c7def0416 100644 --- a/editor/gui/editor_file_dialog.cpp +++ b/editor/gui/editor_file_dialog.cpp @@ -2048,6 +2048,7 @@ void EditorFileDialog::_update_option_controls() { for (const EditorFileDialog::Option &opt : options) { if (opt.values.is_empty()) { CheckBox *cb = memnew(CheckBox); + cb->set_accessibility_name(opt.name); cb->set_pressed(opt.default_idx); cb->set_text(opt.name); flow_checkbox_options->add_child(cb); @@ -2056,12 +2057,14 @@ void EditorFileDialog::_update_option_controls() { } else { Label *lbl = memnew(Label); lbl->set_text(opt.name); + lbl->set_focus_mode(Control::FOCUS_NONE); grid_select_options->add_child(lbl); OptionButton *ob = memnew(OptionButton); for (const String &val : opt.values) { ob->add_item(val); } + ob->set_accessibility_name(opt.name); ob->select(opt.default_idx); grid_select_options->add_child(ob); ob->connect(SceneStringName(item_selected), callable_mp(this, &EditorFileDialog::_option_changed_item_selected).bind(opt.name)); @@ -2401,12 +2404,15 @@ EditorFileDialog::EditorFileDialog() { dir_prev = memnew(Button); dir_prev->set_theme_type_variation(SceneStringName(FlatButton)); + dir_prev->set_accessibility_name(TTRC("Previous")); dir_prev->set_tooltip_text(TTR("Go to previous folder.")); dir_next = memnew(Button); dir_next->set_theme_type_variation(SceneStringName(FlatButton)); + dir_next->set_accessibility_name(TTRC("Next")); dir_next->set_tooltip_text(TTR("Go to next folder.")); dir_up = memnew(Button); dir_up->set_theme_type_variation(SceneStringName(FlatButton)); + dir_up->set_accessibility_name(TTRC("Parent Folder")); dir_up->set_tooltip_text(TTR("Go to parent folder.")); pathhb->add_child(dir_prev); @@ -2418,6 +2424,7 @@ EditorFileDialog::EditorFileDialog() { dir_up->connect(SceneStringName(pressed), callable_mp(this, &EditorFileDialog::_go_up)); Label *l = memnew(Label(TTR("Path:"))); + l->set_focus_mode(Control::FOCUS_NONE); l->set_theme_type_variation("HeaderSmall"); pathhb->add_child(l); @@ -2426,10 +2433,12 @@ EditorFileDialog::EditorFileDialog() { dir = memnew(LineEdit); dir->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); + dir->set_accessibility_name(TTRC("Directory Path")); pathhb->add_child(dir); refresh = memnew(Button); refresh->set_theme_type_variation(SceneStringName(FlatButton)); + refresh->set_accessibility_name(TTRC("Refresh Files")); refresh->set_tooltip_text(TTR("Refresh files.")); refresh->connect(SceneStringName(pressed), callable_mp(this, &EditorFileDialog::update_file_list)); pathhb->add_child(refresh); @@ -2437,6 +2446,7 @@ EditorFileDialog::EditorFileDialog() { favorite = memnew(Button); favorite->set_theme_type_variation(SceneStringName(FlatButton)); favorite->set_toggle_mode(true); + favorite->set_accessibility_name(TTRC("(Un)favorite Folder")); favorite->set_tooltip_text(TTR("(Un)favorite current folder.")); favorite->connect(SceneStringName(pressed), callable_mp(this, &EditorFileDialog::_favorite_pressed)); pathhb->add_child(favorite); @@ -2446,6 +2456,7 @@ EditorFileDialog::EditorFileDialog() { drives = memnew(OptionButton); drives->connect(SceneStringName(item_selected), callable_mp(this, &EditorFileDialog::_select_drive)); + drives->set_accessibility_name(TTRC("Current Drive")); pathhb->add_child(drives); makedir_sep = memnew(VSeparator); @@ -2453,6 +2464,7 @@ EditorFileDialog::EditorFileDialog() { makedir = memnew(Button); makedir->set_theme_type_variation(SceneStringName(FlatButton)); + makedir->set_accessibility_name(TTRC("Create Folder")); makedir->set_tooltip_text(TTR("Create a new folder.")); makedir->connect(SceneStringName(pressed), callable_mp(this, &EditorFileDialog::_make_dir)); pathhb->add_child(makedir); @@ -2488,16 +2500,19 @@ EditorFileDialog::EditorFileDialog() { fav_vb->add_child(fav_hb); l = memnew(Label(TTR("Favorites:"))); + l->set_focus_mode(Control::FOCUS_NONE); l->set_theme_type_variation("HeaderSmall"); fav_hb->add_child(l); fav_hb->add_spacer(); fav_up = memnew(Button); fav_up->set_theme_type_variation(SceneStringName(FlatButton)); + fav_up->set_accessibility_name(TTRC("Move Up")); fav_hb->add_child(fav_up); fav_up->connect(SceneStringName(pressed), callable_mp(this, &EditorFileDialog::_favorite_move_up)); fav_down = memnew(Button); fav_down->set_theme_type_variation(SceneStringName(FlatButton)); + fav_down->set_accessibility_name(TTRC("Move Down")); fav_hb->add_child(fav_down); fav_down->connect(SceneStringName(pressed), callable_mp(this, &EditorFileDialog::_favorite_move_down)); @@ -2506,6 +2521,7 @@ EditorFileDialog::EditorFileDialog() { fav_vb->add_child(favorites); favorites->set_v_size_flags(Control::SIZE_EXPAND_FILL); favorites->set_theme_type_variation("ItemListSecondary"); + favorites->set_accessibility_name(TTRC("Favorites")); favorites->connect(SceneStringName(item_selected), callable_mp(this, &EditorFileDialog::_favorite_selected)); VBoxContainer *rec_vb = memnew(VBoxContainer); @@ -2516,6 +2532,7 @@ EditorFileDialog::EditorFileDialog() { recent->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); recent->set_allow_reselect(true); recent->set_theme_type_variation("ItemListSecondary"); + recent->set_accessibility_name(TTRC("Recent")); rec_vb->add_margin_child(TTR("Recent:"), recent, true); recent->connect(SceneStringName(item_selected), callable_mp(this, &EditorFileDialog::_recent_selected)); @@ -2534,6 +2551,7 @@ EditorFileDialog::EditorFileDialog() { lower_hb->set_h_size_flags(Control::SIZE_EXPAND_FILL); l = memnew(Label(TTR("Directories & Files:"))); + l->set_focus_mode(Control::FOCUS_NONE); l->set_theme_type_variation("HeaderSmall"); l->set_h_size_flags(Control::SIZE_EXPAND_FILL); @@ -2543,6 +2561,7 @@ EditorFileDialog::EditorFileDialog() { show_hidden->set_theme_type_variation(SceneStringName(FlatButton)); show_hidden->set_toggle_mode(true); show_hidden->set_pressed(is_showing_hidden_files()); + show_hidden->set_accessibility_name(TTRC("Show Hidden Files")); show_hidden->set_tooltip_text(TTR("Toggle the visibility of hidden files.")); show_hidden->connect(SceneStringName(toggled), callable_mp(this, &EditorFileDialog::set_show_hidden_files)); lower_hb->add_child(show_hidden); @@ -2558,6 +2577,7 @@ EditorFileDialog::EditorFileDialog() { mode_thumbnails->set_toggle_mode(true); mode_thumbnails->set_pressed(display_mode == DISPLAY_THUMBNAILS); mode_thumbnails->set_button_group(view_mode_group); + mode_thumbnails->set_accessibility_name(TTRC("View as Thumbnails")); mode_thumbnails->set_tooltip_text(TTR("View items as a grid of thumbnails.")); lower_hb->add_child(mode_thumbnails); @@ -2567,6 +2587,7 @@ EditorFileDialog::EditorFileDialog() { mode_list->set_toggle_mode(true); mode_list->set_pressed(display_mode == DISPLAY_LIST); mode_list->set_button_group(view_mode_group); + mode_list->set_accessibility_name(TTRC("View as List")); mode_list->set_tooltip_text(TTR("View items as a list.")); lower_hb->add_child(mode_list); @@ -2576,12 +2597,14 @@ EditorFileDialog::EditorFileDialog() { file_sort_button->set_flat(false); file_sort_button->set_theme_type_variation("FlatMenuButton"); file_sort_button->set_tooltip_text(TTR("Sort files")); + file_sort_button->set_accessibility_name(TTRC("Sort Files")); show_search_filter_button = memnew(Button); show_search_filter_button->set_theme_type_variation(SceneStringName(FlatButton)); show_search_filter_button->set_toggle_mode(true); show_search_filter_button->set_pressed(false); show_search_filter_button->set_tooltip_text(TTR("Toggle the visibility of the filter for file names.")); + show_search_filter_button->set_accessibility_name(TTRC("Show Search Filters")); show_search_filter_button->connect(SceneStringName(toggled), callable_mp(this, &EditorFileDialog::set_show_search_filter)); lower_hb->add_child(show_search_filter_button); @@ -2607,6 +2630,7 @@ EditorFileDialog::EditorFileDialog() { item_list->connect("item_clicked", callable_mp(this, &EditorFileDialog::_item_list_item_rmb_clicked)); item_list->connect("empty_clicked", callable_mp(this, &EditorFileDialog::_item_list_empty_clicked)); item_list->set_allow_rmb_select(true); + item_list->set_accessibility_name(TTRC("Directories and Files")); list_vb->add_child(item_list); @@ -2629,6 +2653,7 @@ EditorFileDialog::EditorFileDialog() { filter_box = memnew(LineEdit); filter_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); filter_box->set_placeholder(TTR("Filter")); + filter_box->set_accessibility_name(TTRC("Filename Filter")); filter_hb->add_child(filter_box); filter_hb->set_visible(false); item_vb->add_child(filter_hb); @@ -2636,6 +2661,7 @@ EditorFileDialog::EditorFileDialog() { file_box = memnew(HBoxContainer); l = memnew(Label(TTR("File:"))); + l->set_focus_mode(Control::FOCUS_NONE); l->set_theme_type_variation("HeaderSmall"); file_box->add_child(l); @@ -2643,11 +2669,13 @@ EditorFileDialog::EditorFileDialog() { file->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); file->set_stretch_ratio(4); file->set_h_size_flags(Control::SIZE_EXPAND_FILL); + file->set_accessibility_name(TTRC("File Name")); file_box->add_child(file); filter = memnew(OptionButton); filter->set_stretch_ratio(3); filter->set_h_size_flags(Control::SIZE_EXPAND_FILL); filter->set_clip_text(true); // Too many extensions overflow it. + filter->set_accessibility_name(TTRC("File Type Filter")); file_box->add_child(filter); file_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); item_vb->add_child(file_box); @@ -2685,6 +2713,7 @@ EditorFileDialog::EditorFileDialog() { makedirname = memnew(LineEdit); makedirname->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); + makedirname->set_accessibility_name(TTRC("Name")); makevb->add_margin_child(TTR("Name:"), makedirname); add_child(makedialog); makedialog->register_text_enter(makedirname); diff --git a/editor/gui/editor_quick_open_dialog.cpp b/editor/gui/editor_quick_open_dialog.cpp index e95e15176faf..01d49b4ea1a2 100644 --- a/editor/gui/editor_quick_open_dialog.cpp +++ b/editor/gui/editor_quick_open_dialog.cpp @@ -115,6 +115,7 @@ EditorQuickOpenDialog::EditorQuickOpenDialog() { search_box = memnew(LineEdit); search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); search_box->set_placeholder(TTR("Search files...")); + search_box->set_accessibility_name(TTRC("Search")); search_box->set_clear_button_enabled(true); mc->add_child(search_box); } @@ -278,6 +279,7 @@ QuickOpenResultContainer::QuickOpenResultContainer() { bottom_bar->add_child(vsep); display_mode_toggle = memnew(Button); + display_mode_toggle->set_accessibility_name(TTRC("Display Mode")); style_button(display_mode_toggle); display_mode_toggle->connect(SceneStringName(pressed), callable_mp(this, &QuickOpenResultContainer::_toggle_display_mode)); bottom_bar->add_child(display_mode_toggle); diff --git a/editor/gui/editor_run_bar.cpp b/editor/gui/editor_run_bar.cpp index 9a1223322fcd..96c49f287a78 100644 --- a/editor/gui/editor_run_bar.cpp +++ b/editor/gui/editor_run_bar.cpp @@ -530,6 +530,7 @@ EditorRunBar::EditorRunBar() { recovery_mode_reload_button->set_theme_type_variation("RunBarButton"); recovery_mode_reload_button->set_focus_mode(Control::FOCUS_NONE); recovery_mode_reload_button->set_tooltip_text(TTR("Disable recovery mode and reload the project.")); + recovery_mode_reload_button->set_accessibility_name(TTRC("Disable Recovery Mode")); recovery_mode_reload_button->connect(SceneStringName(pressed), callable_mp(this, &EditorRunBar::recovery_mode_reload_project)); recovery_mode_panel = memnew(PanelContainer); @@ -552,6 +553,7 @@ EditorRunBar::EditorRunBar() { play_button->set_toggle_mode(true); play_button->set_focus_mode(Control::FOCUS_NONE); play_button->set_tooltip_text(TTRC("Run the project's default scene.")); + play_button->set_accessibility_name(TTRC("Run Default Scene")); play_button->connect(SceneStringName(pressed), callable_mp(this, &EditorRunBar::play_main_scene).bind(false)); ED_SHORTCUT_AND_COMMAND("editor/run_project", TTRC("Run Project"), Key::F5); @@ -564,6 +566,7 @@ EditorRunBar::EditorRunBar() { pause_button->set_toggle_mode(true); pause_button->set_focus_mode(Control::FOCUS_NONE); pause_button->set_tooltip_text(TTRC("Pause the running project's execution for debugging.")); + pause_button->set_accessibility_name(TTRC("Pause")); pause_button->set_disabled(true); ED_SHORTCUT("editor/pause_running_project", TTRC("Pause Running Project"), Key::F7); @@ -575,6 +578,7 @@ EditorRunBar::EditorRunBar() { stop_button->set_theme_type_variation("RunBarButton"); stop_button->set_focus_mode(Control::FOCUS_NONE); stop_button->set_tooltip_text(TTRC("Stop the currently running project.")); + stop_button->set_accessibility_name(TTRC("Stop")); stop_button->set_disabled(true); stop_button->connect(SceneStringName(pressed), callable_mp(this, &EditorRunBar::stop_playing)); @@ -614,6 +618,7 @@ EditorRunBar::EditorRunBar() { play_scene_button->set_theme_type_variation("RunBarButton"); play_scene_button->set_focus_mode(Control::FOCUS_NONE); play_scene_button->set_tooltip_text(TTRC("Run the currently edited scene.")); + play_scene_button->set_accessibility_name(TTRC("Run Edited Scene")); ED_SHORTCUT_AND_COMMAND("editor/run_current_scene", TTRC("Run Current Scene"), Key::F6); ED_SHORTCUT_OVERRIDE("editor/run_current_scene", "macos", KeyModifierMask::META | Key::R); @@ -635,6 +640,7 @@ EditorRunBar::EditorRunBar() { play_custom_scene_button->set_theme_type_variation("RunBarButton"); play_custom_scene_button->set_focus_mode(Control::FOCUS_NONE); play_custom_scene_button->set_tooltip_text(TTRC("Run a specific scene.")); + play_custom_scene_button->set_accessibility_name(TTRC("Run Specific Scene")); ED_SHORTCUT_AND_COMMAND("editor/run_specific_scene", TTRC("Run Specific Scene"), KeyModifierMask::CTRL | KeyModifierMask::SHIFT | Key::F5); ED_SHORTCUT_OVERRIDE("editor/run_specific_scene", "macos", KeyModifierMask::META | KeyModifierMask::SHIFT | Key::R); @@ -650,5 +656,6 @@ EditorRunBar::EditorRunBar() { write_movie_button->set_pressed(false); write_movie_button->set_focus_mode(Control::FOCUS_NONE); write_movie_button->set_tooltip_text(TTR("Enable Movie Maker mode.\nThe project will run at stable FPS and the visual and audio output will be recorded to a video file.")); + write_movie_button->set_accessibility_name(TTRC("Enable Movie Maker Mode")); write_movie_button->connect(SceneStringName(toggled), callable_mp(this, &EditorRunBar::_write_movie_toggled)); } diff --git a/editor/gui/editor_scene_tabs.cpp b/editor/gui/editor_scene_tabs.cpp index 01343c334d74..cbbba20a5644 100644 --- a/editor/gui/editor_scene_tabs.cpp +++ b/editor/gui/editor_scene_tabs.cpp @@ -442,6 +442,7 @@ EditorSceneTabs::EditorSceneTabs() { scene_tab_add = memnew(Button); scene_tab_add->set_flat(true); scene_tab_add->set_tooltip_text(TTR("Add a new scene.")); + scene_tab_add->set_accessibility_name(TTRC("Add Scene")); scene_tabs->add_child(scene_tab_add); scene_tab_add->connect(SceneStringName(pressed), callable_mp(EditorNode::get_singleton(), &EditorNode::trigger_menu_option).bind(EditorNode::FILE_NEW_SCENE, false)); diff --git a/editor/gui/editor_toaster.cpp b/editor/gui/editor_toaster.cpp index a05f8f5d391f..e4707b40b823 100644 --- a/editor/gui/editor_toaster.cpp +++ b/editor/gui/editor_toaster.cpp @@ -374,11 +374,13 @@ Control *EditorToaster::popup(Control *p_control, Severity p_severity, double p_ // Add buttons. if (p_time > 0.0) { Button *copy_button = memnew(Button); + copy_button->set_accessibility_name(TTRC("Copy")); copy_button->set_flat(true); copy_button->connect(SceneStringName(pressed), callable_mp(this, &EditorToaster::copy).bind(panel)); hbox_container->add_child(copy_button); Button *close_button = memnew(Button); + close_button->set_accessibility_name(TTRC("Close")); close_button->set_flat(true); close_button->connect(SceneStringName(pressed), callable_mp(this, &EditorToaster::instant_close).bind(panel)); hbox_container->add_child(close_button); @@ -572,6 +574,7 @@ EditorToaster::EditorToaster() { // Main button. main_button = memnew(Button); + main_button->set_accessibility_name(TTRC("Notifications")); main_button->set_tooltip_text(TTR("No notifications.")); main_button->set_modulate(Color(0.5, 0.5, 0.5)); main_button->set_disabled(true); @@ -588,6 +591,7 @@ EditorToaster::EditorToaster() { add_child(disable_notifications_panel); disable_notifications_button = memnew(Button); + disable_notifications_button->set_accessibility_name(TTRC("Silence Notifications")); disable_notifications_button->set_tooltip_text(TTR("Silence the notifications.")); disable_notifications_button->set_flat(true); disable_notifications_button->connect(SceneStringName(pressed), callable_mp(this, &EditorToaster::_set_notifications_enabled).bind(false)); diff --git a/editor/gui/editor_zoom_widget.cpp b/editor/gui/editor_zoom_widget.cpp index 085a87333c95..ccf1bd18846f 100644 --- a/editor/gui/editor_zoom_widget.cpp +++ b/editor/gui/editor_zoom_widget.cpp @@ -187,6 +187,7 @@ void EditorZoomWidget::set_shortcut_context(Node *p_node) const { EditorZoomWidget::EditorZoomWidget() { // Zoom buttons zoom_minus = memnew(Button); + zoom_minus->set_accessibility_name(TTRC("Zoom Out")); zoom_minus->set_flat(true); zoom_minus->set_shortcut(ED_SHORTCUT_ARRAY("canvas_item_editor/zoom_minus", TTRC("Zoom Out"), { int32_t(KeyModifierMask::CMD_OR_CTRL | Key::MINUS), int32_t(KeyModifierMask::CMD_OR_CTRL | Key::KP_SUBTRACT) })); zoom_minus->set_shortcut_context(this); @@ -196,6 +197,7 @@ EditorZoomWidget::EditorZoomWidget() { zoom_reset = memnew(Button); zoom_reset->set_flat(true); + zoom_reset->set_accessibility_name(TTRC("Reset Zoom")); Ref empty_stylebox = memnew(StyleBoxEmpty); zoom_reset->add_theme_style_override(CoreStringName(normal), empty_stylebox); @@ -216,6 +218,7 @@ EditorZoomWidget::EditorZoomWidget() { zoom_reset->connect(SceneStringName(pressed), callable_mp(this, &EditorZoomWidget::_button_zoom_reset)); zoom_plus = memnew(Button); + zoom_plus->set_accessibility_name(TTRC("Zoom In")); zoom_plus->set_flat(true); zoom_plus->set_shortcut(ED_SHORTCUT_ARRAY("canvas_item_editor/zoom_plus", TTRC("Zoom In"), { int32_t(KeyModifierMask::CMD_OR_CTRL | Key::EQUAL), int32_t(KeyModifierMask::CMD_OR_CTRL | Key::KP_ADD) })); zoom_plus->set_shortcut_context(this); diff --git a/editor/gui/scene_tree_editor.cpp b/editor/gui/scene_tree_editor.cpp index de1100f115ed..7f1b0a9fcd33 100644 --- a/editor/gui/scene_tree_editor.cpp +++ b/editor/gui/scene_tree_editor.cpp @@ -77,6 +77,12 @@ PackedStringArray SceneTreeEditor::_get_node_configuration_warnings(Node *p_node return warnings; } +PackedStringArray SceneTreeEditor::_get_node_accessibility_configuration_warnings(Node *p_node) { + PackedStringArray warnings = p_node->get_accessibility_configuration_warnings(); + + return warnings; +} + void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_id, MouseButton p_button) { if (p_button != MouseButton::LEFT) { return; @@ -151,8 +157,10 @@ void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_i } undo_redo->commit_action(); } else if (p_id == BUTTON_WARNING) { - const PackedStringArray warnings = _get_node_configuration_warnings(n); - + PackedStringArray warnings = _get_node_configuration_warnings(n); + if (accessibility_warnings) { + warnings.append_array(_get_node_accessibility_configuration_warnings(n)); + } if (warnings.is_empty()) { return; } @@ -473,7 +481,11 @@ void SceneTreeEditor::_update_node(Node *p_node, TreeItem *p_item, bool p_part_o } if (can_rename) { // TODO Should be can edit.. - const PackedStringArray warnings = _get_node_configuration_warnings(p_node); + PackedStringArray warnings = _get_node_configuration_warnings(p_node); + if (accessibility_warnings) { + warnings.append_array(_get_node_accessibility_configuration_warnings(p_node)); + } + const int num_warnings = warnings.size(); if (num_warnings > 0) { StringName warning_icon; @@ -1852,12 +1864,12 @@ bool SceneTreeEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_d return false; } - TreeItem *item = tree->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); if (!item) { return false; } - int section = tree->get_drop_section_at_position(p_point); + int section = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_drop_section_at_position(tree->get_item_rect(item).position) : tree->get_drop_section_at_position(p_point); if (section < -1 || (section == -1 && !item->get_parent())) { return false; } @@ -1941,11 +1953,11 @@ void SceneTreeEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, return; } - TreeItem *item = tree->get_item_at_position(p_point); + TreeItem *item = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); if (!item) { return; } - int section = tree->get_drop_section_at_position(p_point); + int section = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_drop_section_at_position(tree->get_item_rect(item).position) : tree->get_drop_section_at_position(p_point); if (section < -1) { return; } @@ -2035,6 +2047,13 @@ void SceneTreeEditor::set_hide_filtered_out_parents(bool p_hide, bool p_update_s } } +void SceneTreeEditor::set_accessibility_warnings(bool p_enable, bool p_update_settings) { + if (p_update_settings) { + EditorSettings::get_singleton()->set("docks/scene_tree/accessibility_warnings", p_enable); + } + accessibility_warnings = p_enable; +} + void SceneTreeEditor::set_connect_to_script_mode(bool p_enable) { connect_to_script_mode = p_enable; _update_tree(); diff --git a/editor/gui/scene_tree_editor.h b/editor/gui/scene_tree_editor.h index 0cc18223e1db..d7eda45d3bf0 100644 --- a/editor/gui/scene_tree_editor.h +++ b/editor/gui/scene_tree_editor.h @@ -127,6 +127,7 @@ class SceneTreeEditor : public Control { bool auto_expand_selected = true; bool hide_filtered_out_parents = false; + bool accessibility_warnings = false; bool connect_to_script_mode = false; bool connecting_signal = false; bool update_when_invisible = true; @@ -136,6 +137,7 @@ class SceneTreeEditor : public Control { void _compute_hash(Node *p_node, uint64_t &hash); void _reset(); PackedStringArray _get_node_configuration_warnings(Node *p_node); + PackedStringArray _get_node_accessibility_configuration_warnings(Node *p_node); void _update_node_path(Node *p_node, bool p_recursive = true); void _update_node_subtree(Node *p_node, TreeItem *p_parent, bool p_force = false); @@ -248,6 +250,7 @@ class SceneTreeEditor : public Control { void set_auto_expand_selected(bool p_auto, bool p_update_settings); void set_hide_filtered_out_parents(bool p_hide, bool p_update_settings); + void set_accessibility_warnings(bool p_enable, bool p_update_settings); void set_connect_to_script_mode(bool p_enable); void set_connecting_signal(bool p_enable); void set_update_when_invisible(bool p_enable); diff --git a/editor/gui/touch_actions_panel.cpp b/editor/gui/touch_actions_panel.cpp index ba61bb3e16dd..bc6576e519e9 100644 --- a/editor/gui/touch_actions_panel.cpp +++ b/editor/gui/touch_actions_panel.cpp @@ -81,11 +81,12 @@ void TouchActionsPanel::_simulate_key_press(Key p_keycode) { Input::get_singleton()->parse_input_event(event); } -Button *TouchActionsPanel::_add_new_action_button(const String &p_shortcut, Key p_keycode) { +Button *TouchActionsPanel::_add_new_action_button(const String &p_shortcut, const String &p_name, Key p_keycode) { Button *action_button = memnew(Button); action_button->set_focus_mode(Control::FOCUS_NONE); action_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER); action_button->set_v_size_flags(Control::SIZE_SHRINK_CENTER); + action_button->set_accessibility_name(p_name); if (p_keycode == Key::NONE) { action_button->connect(SceneStringName(pressed), callable_mp(this, &TouchActionsPanel::_simulate_editor_shortcut).bind(p_shortcut)); } else { @@ -154,6 +155,7 @@ TouchActionsPanel::TouchActionsPanel() { box->add_child(drag_handle); layout_toggle_button = memnew(Button); + layout_toggle_button->set_accessibility_name(TTRC("Switch Layout")); layout_toggle_button->set_focus_mode(Control::FOCUS_NONE); layout_toggle_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER); layout_toggle_button->set_v_size_flags(Control::SIZE_SHRINK_CENTER); @@ -162,6 +164,7 @@ TouchActionsPanel::TouchActionsPanel() { lock_panel_button = memnew(Button); lock_panel_button->set_toggle_mode(true); + lock_panel_button->set_accessibility_name(TTRC("Lock Panel")); lock_panel_button->set_focus_mode(Control::FOCUS_NONE); lock_panel_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER); lock_panel_button->set_v_size_flags(Control::SIZE_SHRINK_CENTER); @@ -174,8 +177,8 @@ TouchActionsPanel::TouchActionsPanel() { box->add_child(separator); // Add action buttons. - save_button = _add_new_action_button("editor/save_scene"); - delete_button = _add_new_action_button("", Key::KEY_DELETE); - undo_button = _add_new_action_button("ui_undo"); - redo_button = _add_new_action_button("ui_redo"); + save_button = _add_new_action_button("editor/save_scene", TTR("Save")); + delete_button = _add_new_action_button("", TTR("Delete"), Key::KEY_DELETE); + undo_button = _add_new_action_button("ui_undo", TTR("Undo")); + redo_button = _add_new_action_button("ui_redo", TTR("Redo")); } diff --git a/editor/gui/touch_actions_panel.h b/editor/gui/touch_actions_panel.h index ddb637b1dc34..8fde9f8af552 100644 --- a/editor/gui/touch_actions_panel.h +++ b/editor/gui/touch_actions_panel.h @@ -61,7 +61,7 @@ class TouchActionsPanel : public PanelContainer { void _on_drag_handle_gui_input(const Ref &p_event); void _switch_layout(); void _lock_panel_toggled(bool p_pressed); - Button *_add_new_action_button(const String &p_shortcut, Key p_keycode = Key::NONE); + Button *_add_new_action_button(const String &p_shortcut, const String &p_name, Key p_keycode = Key::NONE); void _hardware_keyboard_connected(bool p_connected); diff --git a/editor/import/3d/scene_import_settings.cpp b/editor/import/3d/scene_import_settings.cpp index 609835385b1e..0beeb3f7f62d 100644 --- a/editor/import/3d/scene_import_settings.cpp +++ b/editor/import/3d/scene_import_settings.cpp @@ -1724,6 +1724,7 @@ SceneImportSettingsDialog::SceneImportSettingsDialog() { animation_play_button = memnew(Button); animation_hbox->add_child(animation_play_button); animation_play_button->set_flat(true); + animation_play_button->set_accessibility_name(TTRC("Play")); animation_play_button->set_focus_mode(Control::FOCUS_NONE); animation_play_button->set_shortcut(ED_SHORTCUT("scene_import_settings/play_selected_animation", TTRC("Selected Animation Play/Pause"), Key::SPACE)); animation_play_button->connect(SceneStringName(pressed), callable_mp(this, &SceneImportSettingsDialog::_play_animation)); @@ -1731,6 +1732,7 @@ SceneImportSettingsDialog::SceneImportSettingsDialog() { animation_stop_button = memnew(Button); animation_hbox->add_child(animation_stop_button); animation_stop_button->set_flat(true); + animation_stop_button->set_accessibility_name(TTRC("Stop")); animation_stop_button->set_focus_mode(Control::FOCUS_NONE); animation_stop_button->set_tooltip_text(TTR("Selected Animation Stop")); animation_stop_button->connect(SceneStringName(pressed), callable_mp(this, &SceneImportSettingsDialog::_stop_current_animation)); @@ -1743,6 +1745,7 @@ SceneImportSettingsDialog::SceneImportSettingsDialog() { animation_slider->set_step(1.0 / 100.0); animation_slider->set_value_no_signal(0.0); animation_slider->set_focus_mode(Control::FOCUS_NONE); + animation_slider->set_accessibility_name(TTRC("Animation")); animation_slider->connect(SceneStringName(value_changed), callable_mp(this, &SceneImportSettingsDialog::_animation_slider_value_changed)); animation_toggle_skeleton_visibility = memnew(Button); @@ -1751,6 +1754,7 @@ SceneImportSettingsDialog::SceneImportSettingsDialog() { animation_toggle_skeleton_visibility->set_theme_type_variation("FlatButton"); animation_toggle_skeleton_visibility->set_focus_mode(Control::FOCUS_NONE); animation_toggle_skeleton_visibility->set_tooltip_text(TTR("Toggle Animation Skeleton Visibility")); + animation_toggle_skeleton_visibility->set_accessibility_name(TTRC("Skeleton Visibility")); animation_toggle_skeleton_visibility->connect(SceneStringName(pressed), callable_mp(this, &SceneImportSettingsDialog::_animation_update_skeleton_visibility)); @@ -1771,6 +1775,7 @@ SceneImportSettingsDialog::SceneImportSettingsDialog() { light_rotate_switch->set_toggle_mode(true); light_rotate_switch->set_pressed(true); light_rotate_switch->set_tooltip_text(TTR("Rotate Lights With Model")); + light_rotate_switch->set_accessibility_name(TTRC("Rotate Lights With Model")); light_rotate_switch->connect(SceneStringName(pressed), callable_mp(this, &SceneImportSettingsDialog::_on_light_rotate_switch_pressed)); vb_light->add_child(light_rotate_switch); @@ -1779,6 +1784,7 @@ SceneImportSettingsDialog::SceneImportSettingsDialog() { light_1_switch->set_toggle_mode(true); light_1_switch->set_pressed(true); light_1_switch->set_tooltip_text(TTR("Primary Light")); + light_1_switch->set_accessibility_name(TTRC("Primary Light")); light_1_switch->connect(SceneStringName(pressed), callable_mp(this, &SceneImportSettingsDialog::_on_light_1_switch_pressed)); vb_light->add_child(light_1_switch); @@ -1787,6 +1793,7 @@ SceneImportSettingsDialog::SceneImportSettingsDialog() { light_2_switch->set_toggle_mode(true); light_2_switch->set_pressed(true); light_2_switch->set_tooltip_text(TTR("Secondary Light")); + light_2_switch->set_accessibility_name(TTRC("Secondary Light")); light_2_switch->connect(SceneStringName(pressed), callable_mp(this, &SceneImportSettingsDialog::_on_light_2_switch_pressed)); vb_light->add_child(light_2_switch); diff --git a/editor/import/audio_stream_import_settings.cpp b/editor/import/audio_stream_import_settings.cpp index 34ebfff7392e..3c6e2d427934 100644 --- a/editor/import/audio_stream_import_settings.cpp +++ b/editor/import/audio_stream_import_settings.cpp @@ -536,12 +536,14 @@ AudioStreamImportSettingsDialog::AudioStreamImportSettingsDialog() { loop_hb->add_theme_constant_override("separation", 4 * EDSCALE); loop = memnew(CheckBox); loop->set_text(TTR("Enable")); + loop->set_accessibility_name(TTRC("Enable looping")); loop->set_tooltip_text(TTR("Enable looping.")); loop->connect(SceneStringName(toggled), callable_mp(this, &AudioStreamImportSettingsDialog::_settings_changed).unbind(1)); loop_hb->add_child(loop); loop_hb->add_spacer(); loop_hb->add_child(memnew(Label(TTR("Offset:")))); loop_offset = memnew(SpinBox); + loop_offset->set_accessibility_name(TTRC("Loop Offset")); loop_offset->set_max(10000); loop_offset->set_step(0.001); loop_offset->set_suffix("sec"); @@ -559,6 +561,7 @@ AudioStreamImportSettingsDialog::AudioStreamImportSettingsDialog() { bpm_edit = memnew(SpinBox); bpm_edit->set_max(400); bpm_edit->set_step(0.01); + bpm_edit->set_accessibility_name(TTRC("BPM")); bpm_edit->set_tooltip_text(TTR("Configure the Beats Per Measure (tempo) used for the interactive streams.\nThis is required in order to configure beat information.")); bpm_edit->connect(SceneStringName(value_changed), callable_mp(this, &AudioStreamImportSettingsDialog::_settings_changed).unbind(1)); interactive_hb->add_child(bpm_edit); @@ -570,6 +573,7 @@ AudioStreamImportSettingsDialog::AudioStreamImportSettingsDialog() { beats_edit = memnew(SpinBox); beats_edit->set_tooltip_text(TTR("Configure the amount of Beats used for music-aware looping. If zero, it will be autodetected from the length.\nIt is recommended to set this value (either manually or by clicking on a beat number in the preview) to ensure looping works properly.")); beats_edit->set_max(99999); + beats_edit->set_accessibility_name(TTRC("Beat Count")); beats_edit->connect(SceneStringName(value_changed), callable_mp(this, &AudioStreamImportSettingsDialog::_settings_changed).unbind(1)); interactive_hb->add_child(beats_edit); bar_beats_label = memnew(Label(TTR("Bar Beats:"))); @@ -578,6 +582,7 @@ AudioStreamImportSettingsDialog::AudioStreamImportSettingsDialog() { bar_beats_edit->set_tooltip_text(TTR("Configure the Beats Per Bar. This used for music-aware transitions between AudioStreams.")); bar_beats_edit->set_min(2); bar_beats_edit->set_max(32); + bar_beats_edit->set_accessibility_name(TTRC("Bar Beats")); bar_beats_edit->connect(SceneStringName(value_changed), callable_mp(this, &AudioStreamImportSettingsDialog::_settings_changed).unbind(1)); interactive_hb->add_child(bar_beats_edit); main_vbox->add_margin_child(TTR("Music Playback:"), interactive_hb); @@ -605,10 +610,13 @@ AudioStreamImportSettingsDialog::AudioStreamImportSettingsDialog() { HBoxContainer *zoom_hbox = memnew(HBoxContainer); zoom_bar = memnew(HScrollBar); zoom_in = memnew(Button); + zoom_in->set_accessibility_name(TTRC("Zoom In")); zoom_in->set_flat(true); zoom_reset = memnew(Button); + zoom_reset->set_accessibility_name(TTRC("Reset Zoom")); zoom_reset->set_flat(true); zoom_out = memnew(Button); + zoom_out->set_accessibility_name(TTRC("Zoom Out")); zoom_out->set_flat(true); zoom_hbox->add_child(zoom_bar); zoom_bar->set_h_size_flags(Control::SIZE_EXPAND_FILL); @@ -634,12 +642,14 @@ AudioStreamImportSettingsDialog::AudioStreamImportSettingsDialog() { vbox->add_child(hbox); _play_button = memnew(Button); + _play_button->set_accessibility_name(TTRC("Play")); _play_button->set_flat(true); hbox->add_child(_play_button); _play_button->set_focus_mode(Control::FOCUS_NONE); _play_button->connect(SceneStringName(pressed), callable_mp(this, &AudioStreamImportSettingsDialog::_play)); _stop_button = memnew(Button); + _stop_button->set_accessibility_name(TTRC("Stop")); _stop_button->set_flat(true); hbox->add_child(_stop_button); _stop_button->set_focus_mode(Control::FOCUS_NONE); diff --git a/editor/import/dynamic_font_import_settings.cpp b/editor/import/dynamic_font_import_settings.cpp index 06dc5398e707..23c02b40a2ed 100644 --- a/editor/import/dynamic_font_import_settings.cpp +++ b/editor/import/dynamic_font_import_settings.cpp @@ -1444,7 +1444,8 @@ DynamicFontImportSettingsDialog::DynamicFontImportSettingsDialog() { page2_hb_vars->add_child(label_vars); add_var = memnew(Button); - add_var->set_tooltip_text(TTR("Add configuration")); + add_var->set_tooltip_text(TTR("Add new font variation configuration.")); + add_var->set_accessibility_name(TTRC("Add Configuration")); page2_hb_vars->add_child(add_var); add_var->connect(SceneStringName(pressed), callable_mp(this, &DynamicFontImportSettingsDialog::_variation_add)); diff --git a/editor/import/resource_importer_shader_file.cpp b/editor/import/resource_importer_shader_file.cpp index 3846717b2a6e..6cfca20a05b6 100644 --- a/editor/import/resource_importer_shader_file.cpp +++ b/editor/import/resource_importer_shader_file.cpp @@ -91,6 +91,7 @@ static String _include_function(const String &p_path, void *userpointer) { Error ResourceImporterShaderFile::import(ResourceUID::ID p_source_id, const String &p_source_file, const String &p_save_path, const HashMap &p_options, List *r_platform_variants, List *r_gen_files, Variant *r_metadata) { /* STEP 1, Read shader code */ ERR_FAIL_COND_V_EDMSG((OS::get_singleton()->get_current_rendering_method() == "gl_compatibility"), ERR_UNAVAILABLE, "Cannot import custom .glsl shaders when using the Compatibility renderer. Please switch to the Forward+ or Mobile renderer to use custom shaders."); + ERR_FAIL_COND_V_EDMSG((OS::get_singleton()->get_current_rendering_method() == "dummy"), ERR_UNAVAILABLE, "Cannot import custom .glsl shaders when using the Dummy renderer. Please switch to the Forward+ or Mobile renderer to use custom shaders."); ERR_FAIL_COND_V_EDMSG((DisplayServer::get_singleton()->get_name() == "headless"), ERR_UNAVAILABLE, "Cannot import custom .glsl shaders when running in headless mode."); Error err; diff --git a/editor/import_dock.cpp b/editor/import_dock.cpp index 6c8571369ad8..2188d68aa552 100644 --- a/editor/import_dock.cpp +++ b/editor/import_dock.cpp @@ -763,6 +763,7 @@ ImportDock::ImportDock() { import_as->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS); import_as->set_h_size_flags(SIZE_EXPAND_FILL); import_as->connect(SceneStringName(item_selected), callable_mp(this, &ImportDock::_importer_selected)); + import_as->set_accessibility_name(TTRC("Import As")); hb->add_child(import_as); import_as->set_h_size_flags(SIZE_EXPAND_FILL); preset = memnew(MenuButton); diff --git a/editor/input_event_configuration_dialog.cpp b/editor/input_event_configuration_dialog.cpp index 41a41e68f09a..84168e11423f 100644 --- a/editor/input_event_configuration_dialog.cpp +++ b/editor/input_event_configuration_dialog.cpp @@ -668,6 +668,7 @@ InputEventConfigurationDialog::InputEventConfigurationDialog() { input_list_search = memnew(LineEdit); input_list_search->set_h_size_flags(Control::SIZE_EXPAND_FILL); input_list_search->set_placeholder(TTR("Filter Inputs")); + input_list_search->set_accessibility_name(TTRC("Filter Inputs")); input_list_search->set_clear_button_enabled(true); input_list_search->connect(SceneStringName(text_changed), callable_mp(this, &InputEventConfigurationDialog::_search_term_updated)); manual_vbox->add_child(input_list_search); @@ -708,6 +709,7 @@ InputEventConfigurationDialog::InputEventConfigurationDialog() { device_id_option->add_item(EventListenerLineEdit::get_device_string(i)); } device_id_option->connect(SceneStringName(item_selected), callable_mp(this, &InputEventConfigurationDialog::_device_selection_changed)); + device_id_option->set_accessibility_name(TTRC("Device")); _set_current_device(InputMap::ALL_DEVICES); device_container->add_child(device_id_option); @@ -762,6 +764,7 @@ InputEventConfigurationDialog::InputEventConfigurationDialog() { key_location->add_item(TTR("Left"), (int)KeyLocation::LEFT); key_location->add_item(TTR("Right"), (int)KeyLocation::RIGHT); key_location->connect(SceneStringName(item_selected), callable_mp(this, &InputEventConfigurationDialog::_key_location_selected)); + key_location->set_accessibility_name(TTRC("Location")); location_container->add_child(key_location); additional_options_container->add_child(location_container); diff --git a/editor/inspector_dock.cpp b/editor/inspector_dock.cpp index 3178bab6d95d..a94afbf55034 100644 --- a/editor/inspector_dock.cpp +++ b/editor/inspector_dock.cpp @@ -689,6 +689,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { resource_new_button = memnew(Button); resource_new_button->set_theme_type_variation("FlatMenuButton"); resource_new_button->set_tooltip_text(TTRC("Create a new resource in memory and edit it.")); + resource_new_button->set_accessibility_name(TTRC("New Resource")); general_options_hb->add_child(resource_new_button); resource_new_button->connect(SceneStringName(pressed), callable_mp(this, &InspectorDock::_new_resource)); resource_new_button->set_focus_mode(Control::FOCUS_NONE); @@ -696,6 +697,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { resource_load_button = memnew(Button); resource_load_button->set_theme_type_variation("FlatMenuButton"); resource_load_button->set_tooltip_text(TTRC("Load an existing resource from disk and edit it.")); + resource_load_button->set_accessibility_name(TTRC("Load Resource")); general_options_hb->add_child(resource_load_button); resource_load_button->connect(SceneStringName(pressed), callable_mp(this, &InspectorDock::_open_resource_selector)); resource_load_button->set_focus_mode(Control::FOCUS_NONE); @@ -704,6 +706,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { resource_save_button->set_flat(false); resource_save_button->set_theme_type_variation("FlatMenuButton"); resource_save_button->set_tooltip_text(TTRC("Save the currently edited resource.")); + resource_save_button->set_accessibility_name(TTRC("Save Resource")); general_options_hb->add_child(resource_save_button); resource_save_button->get_popup()->add_item(TTRC("Save"), RESOURCE_SAVE); resource_save_button->get_popup()->add_item(TTRC("Save As..."), RESOURCE_SAVE_AS); @@ -715,6 +718,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { resource_extra_button->set_flat(false); resource_extra_button->set_theme_type_variation("FlatMenuButton"); resource_extra_button->set_tooltip_text(TTRC("Extra resource options.")); + resource_extra_button->set_accessibility_name(TTRC("Resource Options")); general_options_hb->add_child(resource_extra_button); resource_extra_button->connect("about_to_popup", callable_mp(this, &InspectorDock::_prepare_resource_extra_popup)); resource_extra_button->get_popup()->add_shortcut(ED_SHORTCUT("property_editor/paste_resource", TTRC("Edit Resource from Clipboard")), RESOURCE_EDIT_CLIPBOARD); @@ -732,6 +736,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { backward_button->set_flat(true); general_options_hb->add_child(backward_button); backward_button->set_tooltip_text(TTRC("Go to previous edited object in history.")); + backward_button->set_accessibility_name(TTRC("Previous Edited Object")); backward_button->set_disabled(true); backward_button->connect(SceneStringName(pressed), callable_mp(this, &InspectorDock::_edit_back)); @@ -739,6 +744,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { forward_button->set_flat(true); general_options_hb->add_child(forward_button); forward_button->set_tooltip_text(TTRC("Go to next edited object in history.")); + forward_button->set_accessibility_name(TTRC("Next Edited Object")); forward_button->set_disabled(true); forward_button->connect(SceneStringName(pressed), callable_mp(this, &InspectorDock::_edit_forward)); @@ -747,6 +753,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { history_menu->set_flat(false); history_menu->set_theme_type_variation("FlatMenuButton"); history_menu->set_tooltip_text(TTRC("History of recently edited objects.")); + history_menu->set_accessibility_name(TTRC("Edit History")); general_options_hb->add_child(history_menu); history_menu->connect("about_to_popup", callable_mp(this, &InspectorDock::_prepare_history)); history_menu->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &InspectorDock::_select_history)); @@ -761,6 +768,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { open_docs_button->set_theme_type_variation("FlatMenuButton"); open_docs_button->set_disabled(true); open_docs_button->set_tooltip_text(TTRC("Open documentation for this object.")); + open_docs_button->set_accessibility_name(TTRC("Open Documentation")); open_docs_button->set_shortcut(ED_SHORTCUT("property_editor/open_help", TTRC("Open Documentation"))); subresource_hb->add_child(open_docs_button); open_docs_button->connect(SceneStringName(pressed), callable_mp(this, &InspectorDock::_menu_option).bind(OBJECT_REQUEST_HELP)); @@ -776,6 +784,7 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { search = memnew(LineEdit); search->set_h_size_flags(Control::SIZE_EXPAND_FILL); search->set_placeholder(TTRC("Filter Properties")); + search->set_accessibility_name(TTRC("Filter Properties")); search->set_clear_button_enabled(true); property_tools_hb->add_child(search); @@ -784,12 +793,14 @@ InspectorDock::InspectorDock(EditorData &p_editor_data) { object_menu->set_theme_type_variation("FlatMenuButton"); property_tools_hb->add_child(object_menu); object_menu->set_tooltip_text(TTRC("Manage object properties.")); + object_menu->set_accessibility_name(TTRC("Object Properties")); object_menu->get_popup()->connect("about_to_popup", callable_mp(this, &InspectorDock::_prepare_menu)); object_menu->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &InspectorDock::_menu_option)); info = memnew(Button); add_child(info); info->set_clip_text(true); + info->set_accessibility_name(TTRC("Information")); info->hide(); info->connect(SceneStringName(pressed), callable_mp(this, &InspectorDock::_info_pressed)); diff --git a/editor/plugins/abstract_polygon_2d_editor.cpp b/editor/plugins/abstract_polygon_2d_editor.cpp index 6cdfb08e7fd8..3d5ffa0c0e25 100644 --- a/editor/plugins/abstract_polygon_2d_editor.cpp +++ b/editor/plugins/abstract_polygon_2d_editor.cpp @@ -737,18 +737,21 @@ AbstractPolygon2DEditor::AbstractPolygon2DEditor(bool p_wip_destructive) { button_create = memnew(Button); button_create->set_theme_type_variation(SceneStringName(FlatButton)); + button_create->set_accessibility_name(TTRC("Create Polygon Points")); add_child(button_create); button_create->connect(SceneStringName(pressed), callable_mp(this, &AbstractPolygon2DEditor::_menu_option).bind(MODE_CREATE)); button_create->set_toggle_mode(true); button_edit = memnew(Button); button_edit->set_theme_type_variation(SceneStringName(FlatButton)); + button_edit->set_accessibility_name(TTRC("Edit Polygon Points")); add_child(button_edit); button_edit->connect(SceneStringName(pressed), callable_mp(this, &AbstractPolygon2DEditor::_menu_option).bind(MODE_EDIT)); button_edit->set_toggle_mode(true); button_delete = memnew(Button); button_delete->set_theme_type_variation(SceneStringName(FlatButton)); + button_delete->set_accessibility_name(TTRC("Delete Polygon Points")); add_child(button_delete); button_delete->connect(SceneStringName(pressed), callable_mp(this, &AbstractPolygon2DEditor::_menu_option).bind(MODE_DELETE)); button_delete->set_toggle_mode(true); diff --git a/editor/plugins/animation_blend_space_1d_editor.cpp b/editor/plugins/animation_blend_space_1d_editor.cpp index 80c7e605cf5d..407a9bec97f9 100644 --- a/editor/plugins/animation_blend_space_1d_editor.cpp +++ b/editor/plugins/animation_blend_space_1d_editor.cpp @@ -667,6 +667,7 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { top_hb->add_child(tool_blend); tool_blend->set_pressed(true); tool_blend->set_tooltip_text(TTR("Set the blending position within the space")); + tool_blend->set_accessibility_name(TTRC("Set Blending Position")); tool_blend->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_tool_switch).bind(3)); tool_select = memnew(Button); @@ -675,6 +676,7 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { tool_select->set_button_group(bg); top_hb->add_child(tool_select); tool_select->set_tooltip_text(TTR("Select and move points, create points with RMB.")); + tool_select->set_accessibility_name(TTRC("Edit Points")); tool_select->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_tool_switch).bind(0)); tool_create = memnew(Button); @@ -683,6 +685,7 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { tool_create->set_button_group(bg); top_hb->add_child(tool_create); tool_create->set_tooltip_text(TTR("Create points.")); + tool_create->set_accessibility_name(TTRC("Create Points")); tool_create->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_tool_switch).bind(1)); tool_erase_sep = memnew(VSeparator); @@ -691,6 +694,7 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { tool_erase->set_theme_type_variation(SceneStringName(FlatButton)); top_hb->add_child(tool_erase); tool_erase->set_tooltip_text(TTR("Erase points.")); + tool_erase->set_accessibility_name(TTRC("Erase Points")); tool_erase->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_erase_selected)); top_hb->add_child(memnew(VSeparator)); @@ -701,6 +705,7 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { top_hb->add_child(snap); snap->set_pressed(true); snap->set_tooltip_text(TTR("Enable snap and show grid.")); + snap->set_accessibility_name(TTRC("Snap to Grid")); snap->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_snap_toggled)); snap_value = memnew(SpinBox); @@ -708,6 +713,7 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { snap_value->set_min(0.01); snap_value->set_step(0.01); snap_value->set_max(1000); + snap_value->set_accessibility_name(TTRC("Grid Step")); top_hb->add_child(memnew(VSeparator)); top_hb->add_child(memnew(Label(TTR("Sync:")))); @@ -732,6 +738,7 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { edit_value->set_min(-1000); edit_value->set_max(1000); edit_value->set_step(0.01); + edit_value->set_accessibility_name(TTRC("Blend Value")); edit_value->connect(SceneStringName(value_changed), callable_mp(this, &AnimationNodeBlendSpace1DEditor::_edit_point_pos)); open_editor = memnew(Button); @@ -768,14 +775,17 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() { min_value->set_min(-10000); min_value->set_max(0); min_value->set_step(0.01); + min_value->set_accessibility_name(TTRC("Min")); max_value = memnew(SpinBox); max_value->set_min(0.01); max_value->set_max(10000); max_value->set_step(0.01); + max_value->set_accessibility_name(TTRC("Max")); label_value = memnew(LineEdit); label_value->set_expand_to_text_length_enabled(true); + label_value->set_accessibility_name(TTRC("Value")); // now add diff --git a/editor/plugins/animation_blend_space_2d_editor.cpp b/editor/plugins/animation_blend_space_2d_editor.cpp index 34586b9ba2b0..5dde9d52a041 100644 --- a/editor/plugins/animation_blend_space_2d_editor.cpp +++ b/editor/plugins/animation_blend_space_2d_editor.cpp @@ -886,6 +886,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { top_hb->add_child(tool_blend); tool_blend->set_pressed(true); tool_blend->set_tooltip_text(TTR("Set the blending position within the space")); + tool_blend->set_accessibility_name(TTRC("Set Blending Position")); tool_blend->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_tool_switch).bind(3)); tool_select = memnew(Button); @@ -894,6 +895,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { tool_select->set_button_group(bg); top_hb->add_child(tool_select); tool_select->set_tooltip_text(TTR("Select and move points, create points with RMB.")); + tool_select->set_accessibility_name(TTRC("Edit Points")); tool_select->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_tool_switch).bind(0)); tool_create = memnew(Button); @@ -902,6 +904,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { tool_create->set_button_group(bg); top_hb->add_child(tool_create); tool_create->set_tooltip_text(TTR("Create points.")); + tool_create->set_accessibility_name(TTRC("Create Points")); tool_create->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_tool_switch).bind(1)); tool_triangle = memnew(Button); @@ -910,6 +913,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { tool_triangle->set_button_group(bg); top_hb->add_child(tool_triangle); tool_triangle->set_tooltip_text(TTR("Create triangles by connecting points.")); + tool_triangle->set_accessibility_name(TTRC("Create Triangles")); tool_triangle->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_tool_switch).bind(2)); tool_erase_sep = memnew(VSeparator); @@ -918,6 +922,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { tool_erase->set_theme_type_variation(SceneStringName(FlatButton)); top_hb->add_child(tool_erase); tool_erase->set_tooltip_text(TTR("Erase points and triangles.")); + tool_erase->set_accessibility_name(TTRC("Erase Points")); tool_erase->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_erase_selected)); tool_erase->set_disabled(true); @@ -929,6 +934,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { auto_triangles->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_auto_triangles_toggled)); auto_triangles->set_toggle_mode(true); auto_triangles->set_tooltip_text(TTR("Generate blend triangles automatically (instead of manually)")); + auto_triangles->set_accessibility_name(TTRC("Generate Triangles")); top_hb->add_child(memnew(VSeparator)); @@ -938,6 +944,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { top_hb->add_child(snap); snap->set_pressed(true); snap->set_tooltip_text(TTR("Enable snap and show grid.")); + snap->set_accessibility_name(TTRC("Snap to Grid")); snap->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_snap_toggled)); snap_x = memnew(SpinBox); @@ -946,6 +953,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { snap_x->set_min(0.01); snap_x->set_step(0.01); snap_x->set_max(1000); + snap_x->set_accessibility_name(TTRC("Grid X Step")); snap_y = memnew(SpinBox); top_hb->add_child(snap_y); @@ -953,6 +961,7 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { snap_y->set_min(0.01); snap_y->set_step(0.01); snap_y->set_max(1000); + snap_y->set_accessibility_name(TTRC("Grid Y Step")); top_hb->add_child(memnew(VSeparator)); @@ -977,12 +986,14 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { edit_x->set_min(-1000); edit_x->set_step(0.01); edit_x->set_max(1000); + edit_x->set_accessibility_name(TTRC("Blend X Value")); edit_x->connect(SceneStringName(value_changed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_edit_point_pos)); edit_y = memnew(SpinBox); edit_hb->add_child(edit_y); edit_y->set_min(-1000); edit_y->set_step(0.01); edit_y->set_max(1000); + edit_y->set_accessibility_name(TTRC("Blend X Value")); edit_y->connect(SceneStringName(value_changed), callable_mp(this, &AnimationNodeBlendSpace2DEditor::_edit_point_pos)); open_editor = memnew(Button); edit_hb->add_child(open_editor); @@ -1004,13 +1015,16 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { main_grid->add_child(left_vbox); left_vbox->set_v_size_flags(SIZE_EXPAND_FILL); max_y_value = memnew(SpinBox); + max_y_value->set_accessibility_name(TTRC("Max Y")); left_vbox->add_child(max_y_value); left_vbox->add_spacer(); label_y = memnew(LineEdit); + label_y->set_accessibility_name(TTRC("Y Value")); left_vbox->add_child(label_y); label_y->set_expand_to_text_length_enabled(true); left_vbox->add_spacer(); min_y_value = memnew(SpinBox); + min_y_value->set_accessibility_name(TTRC("Min Y")); left_vbox->add_child(min_y_value); max_y_value->set_max(10000); @@ -1040,13 +1054,16 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() { main_grid->add_child(bottom_vbox); bottom_vbox->set_h_size_flags(SIZE_EXPAND_FILL); min_x_value = memnew(SpinBox); + min_x_value->set_accessibility_name(TTRC("Min X")); bottom_vbox->add_child(min_x_value); bottom_vbox->add_spacer(); label_x = memnew(LineEdit); + label_y->set_accessibility_name(TTRC("X Value")); bottom_vbox->add_child(label_x); label_x->set_expand_to_text_length_enabled(true); bottom_vbox->add_spacer(); max_x_value = memnew(SpinBox); + max_x_value->set_accessibility_name(TTRC("Max Y")); bottom_vbox->add_child(max_x_value); max_x_value->set_max(10000); diff --git a/editor/plugins/animation_blend_tree_editor_plugin.cpp b/editor/plugins/animation_blend_tree_editor_plugin.cpp index b69ef298bacd..137dffc031b5 100644 --- a/editor/plugins/animation_blend_tree_editor_plugin.cpp +++ b/editor/plugins/animation_blend_tree_editor_plugin.cpp @@ -176,6 +176,7 @@ void AnimationNodeBlendTreeEditor::update_graph() { delete_button->set_flat(true); delete_button->set_focus_mode(FOCUS_NONE); delete_button->set_button_icon(get_editor_theme_icon(SNAME("Close"))); + delete_button->set_accessibility_name(TTRC("Delete")); delete_button->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeBlendTreeEditor::_delete_node_request).bind(E), CONNECT_DEFERRED); node->get_titlebar_hbox()->add_child(delete_button); } @@ -1406,6 +1407,7 @@ AnimationNodeAnimationEditorDialog::AnimationNodeAnimationEditorDialog() { label_start->set_stretch_ratio(1); select_start = memnew(OptionButton); select_start->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); + select_start->set_accessibility_name(TTRC("Start Marker")); grid->add_child(select_start); select_start->set_h_size_flags(Control::SIZE_EXPAND_FILL); select_start->set_stretch_ratio(2); @@ -1416,6 +1418,7 @@ AnimationNodeAnimationEditorDialog::AnimationNodeAnimationEditorDialog() { label_end->set_stretch_ratio(1); select_end = memnew(OptionButton); select_end->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); + select_end->set_accessibility_name(TTRC("End Marker")); grid->add_child(select_end); select_end->set_h_size_flags(Control::SIZE_EXPAND_FILL); select_end->set_stretch_ratio(2); diff --git a/editor/plugins/animation_player_editor_plugin.cpp b/editor/plugins/animation_player_editor_plugin.cpp index ae10f0af9a70..8495d9810302 100644 --- a/editor/plugins/animation_player_editor_plugin.cpp +++ b/editor/plugins/animation_player_editor_plugin.cpp @@ -2019,26 +2019,31 @@ AnimationPlayerEditor::AnimationPlayerEditor(AnimationPlayerEditorPlugin *p_plug play_bw_from = memnew(Button); play_bw_from->set_theme_type_variation(SceneStringName(FlatButton)); play_bw_from->set_tooltip_text(TTR("Play Animation Backwards")); + play_bw_from->set_accessibility_name(TTRC("Play Backwards")); playback_container->add_child(play_bw_from); play_bw = memnew(Button); play_bw->set_theme_type_variation(SceneStringName(FlatButton)); play_bw->set_tooltip_text(TTR("Play Animation Backwards from End")); + play_bw->set_accessibility_name(TTRC("Play Backwards from End")); playback_container->add_child(play_bw); stop = memnew(Button); stop->set_theme_type_variation(SceneStringName(FlatButton)); stop->set_tooltip_text(TTR("Pause/Stop Animation")); + stop->set_accessibility_name(TTRC("Pause/Stop")); playback_container->add_child(stop); play = memnew(Button); play->set_theme_type_variation(SceneStringName(FlatButton)); play->set_tooltip_text(TTR("Play Animation from Start")); + play->set_accessibility_name(TTRC("Play from Start")); playback_container->add_child(play); play_from = memnew(Button); play_from->set_theme_type_variation(SceneStringName(FlatButton)); play_from->set_tooltip_text(TTR("Play Animation")); + play_from->set_accessibility_name(TTRC("Play")); playback_container->add_child(play_from); frame = memnew(SpinBox); @@ -2047,6 +2052,7 @@ AnimationPlayerEditor::AnimationPlayerEditor(AnimationPlayerEditorPlugin *p_plug frame->set_stretch_ratio(2); frame->set_step(0.0001); frame->set_tooltip_text(TTR("Animation position (in seconds).")); + frame->set_accessibility_name(TTRC("Frame")); hb->add_child(memnew(VSeparator)); @@ -2055,6 +2061,7 @@ AnimationPlayerEditor::AnimationPlayerEditor(AnimationPlayerEditorPlugin *p_plug scale->set_h_size_flags(SIZE_EXPAND_FILL); scale->set_stretch_ratio(1); scale->set_tooltip_text(TTR("Scale animation playback globally for the node.")); + scale->set_accessibility_name(TTRC("Scale")); scale->hide(); delete_dialog = memnew(ConfirmationDialog); @@ -2082,6 +2089,7 @@ AnimationPlayerEditor::AnimationPlayerEditor(AnimationPlayerEditorPlugin *p_plug animation = memnew(OptionButton); hb->add_child(animation); + animation->set_accessibility_name(TTRC("Animation")); animation->set_h_size_flags(SIZE_EXPAND_FILL); animation->set_tooltip_text(TTR("Display list of animations in player.")); animation->set_clip_text(true); @@ -2091,6 +2099,7 @@ AnimationPlayerEditor::AnimationPlayerEditor(AnimationPlayerEditorPlugin *p_plug autoplay->set_theme_type_variation(SceneStringName(FlatButton)); hb->add_child(autoplay); autoplay->set_tooltip_text(TTR("Autoplay on Load")); + autoplay->set_accessibility_name(TTRC("Autoplay on Load")); hb->add_child(memnew(VSeparator)); @@ -2103,10 +2112,12 @@ AnimationPlayerEditor::AnimationPlayerEditor(AnimationPlayerEditorPlugin *p_plug onion_toggle->set_theme_type_variation(SceneStringName(FlatButton)); onion_toggle->set_toggle_mode(true); onion_toggle->set_tooltip_text(TTR("Enable Onion Skinning")); + onion_toggle->set_accessibility_name(TTRC("Onion Skinning")); onion_toggle->connect(SceneStringName(pressed), callable_mp(this, &AnimationPlayerEditor::_onion_skinning_menu).bind(ONION_SKINNING_ENABLE)); hb->add_child(onion_toggle); onion_skinning = memnew(MenuButton); + onion_skinning->set_accessibility_name(TTRC("Onion Skinning Options")); onion_skinning->set_flat(false); onion_skinning->set_theme_type_variation("FlatMenuButton"); onion_skinning->set_tooltip_text(TTR("Onion Skinning Options")); @@ -2133,6 +2144,7 @@ AnimationPlayerEditor::AnimationPlayerEditor(AnimationPlayerEditorPlugin *p_plug pin->set_theme_type_variation(SceneStringName(FlatButton)); pin->set_toggle_mode(true); pin->set_tooltip_text(TTR("Pin AnimationPlayer")); + pin->set_accessibility_name(TTRC("Pin AnimationPlayer")); hb->add_child(pin); pin->connect(SceneStringName(pressed), callable_mp(this, &AnimationPlayerEditor::_pin_pressed)); diff --git a/editor/plugins/animation_state_machine_editor.cpp b/editor/plugins/animation_state_machine_editor.cpp index aa886d9a8644..adaf70bf82b6 100644 --- a/editor/plugins/animation_state_machine_editor.cpp +++ b/editor/plugins/animation_state_machine_editor.cpp @@ -1814,6 +1814,7 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() { tool_select->set_button_group(bg); tool_select->set_pressed(true); tool_select->set_tooltip_text(TTR("Select and move nodes.\nRMB: Add node at position clicked.\nShift+LMB+Drag: Connects the selected node with another node or creates a new node if you select an area without nodes.")); + tool_select->set_accessibility_name(TTRC("Edit Nodes")); tool_select->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), CONNECT_DEFERRED); tool_create = memnew(Button); @@ -1822,6 +1823,7 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() { tool_create->set_toggle_mode(true); tool_create->set_button_group(bg); tool_create->set_tooltip_text(TTR("Create new nodes.")); + tool_create->set_accessibility_name(TTRC("Create Nodes")); tool_create->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), CONNECT_DEFERRED); tool_connect = memnew(Button); @@ -1830,6 +1832,7 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() { tool_connect->set_toggle_mode(true); tool_connect->set_button_group(bg); tool_connect->set_tooltip_text(TTR("Connect nodes.")); + tool_connect->set_accessibility_name(TTRC("Connect Nodes")); tool_connect->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), CONNECT_DEFERRED); // Context-sensitive selection tools: @@ -1842,6 +1845,7 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() { tool_erase->set_tooltip_text(TTR("Remove selected node or transition.")); tool_erase->connect(SceneStringName(pressed), callable_mp(this, &AnimationNodeStateMachineEditor::_erase_selected).bind(false)); tool_erase->set_disabled(true); + tool_erase->set_accessibility_name(TTRC("Erase")); selection_tools_hb->add_child(tool_erase); transition_tools_hb = memnew(HBoxContainer); @@ -1857,6 +1861,7 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() { auto_advance->set_tooltip_text(TTR("New Transitions Should Auto Advance")); auto_advance->set_toggle_mode(true); auto_advance->set_pressed(true); + auto_advance->set_accessibility_name(TTRC("Transitions Auto Advance")); transition_tools_hb->add_child(auto_advance); // diff --git a/editor/plugins/asset_library_editor_plugin.cpp b/editor/plugins/asset_library_editor_plugin.cpp index 74a4d354ec04..394622ac9922 100644 --- a/editor/plugins/asset_library_editor_plugin.cpp +++ b/editor/plugins/asset_library_editor_plugin.cpp @@ -136,6 +136,7 @@ EditorAssetLibraryItem::EditorAssetLibraryItem(bool p_clickable) { add_child(hb); icon = memnew(TextureButton); + icon->set_accessibility_name(TTRC("Open asset details")); icon->set_custom_minimum_size(Size2(64, 64) * EDSCALE); hb->add_child(icon); @@ -145,11 +146,13 @@ EditorAssetLibraryItem::EditorAssetLibraryItem(bool p_clickable) { vb->set_h_size_flags(Control::SIZE_EXPAND_FILL); title = memnew(LinkButton); + title->set_accessibility_name(TTRC("Title")); title->set_auto_translate_mode(AutoTranslateMode::AUTO_TRANSLATE_MODE_DISABLED); title->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); vb->add_child(title); category = memnew(LinkButton); + category->set_accessibility_name(TTRC("Category")); category->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); vb->add_child(category); @@ -159,6 +162,7 @@ EditorAssetLibraryItem::EditorAssetLibraryItem(bool p_clickable) { author = memnew(LinkButton); author->set_tooltip_text(TTR("Author")); + author->set_accessibility_name(TTRC("Author")); author_price_hbox->add_child(author); author_price_hbox->add_child(memnew(HSeparator)); @@ -184,6 +188,7 @@ EditorAssetLibraryItem::EditorAssetLibraryItem(bool p_clickable) { price = memnew(Label); price->add_theme_style_override(CoreStringName(normal), label_margin); price->set_tooltip_text(TTR("License")); + price->set_accessibility_name(TTRC("License")); price->set_mouse_filter(MOUSE_FILTER_PASS); author_price_hbox->add_child(price); @@ -579,6 +584,7 @@ EditorAssetLibraryItemDownload::EditorAssetLibraryItemDownload() { dismiss_button = memnew(TextureButton); dismiss_button->connect(SceneStringName(pressed), callable_mp(this, &EditorAssetLibraryItemDownload::_close)); + dismiss_button->set_accessibility_name(TTRC("Close")); title_hb->add_child(dismiss_button); title->set_clip_text(true); diff --git a/editor/plugins/audio_stream_editor_plugin.cpp b/editor/plugins/audio_stream_editor_plugin.cpp index 814cb3d2636c..44b9c4256352 100644 --- a/editor/plugins/audio_stream_editor_plugin.cpp +++ b/editor/plugins/audio_stream_editor_plugin.cpp @@ -246,12 +246,14 @@ AudioStreamEditor::AudioStreamEditor() { _play_button->set_focus_mode(Control::FOCUS_NONE); _play_button->connect(SceneStringName(pressed), callable_mp(this, &AudioStreamEditor::_play)); _play_button->set_shortcut(ED_SHORTCUT("audio_stream_editor/audio_preview_play_pause", TTRC("Audio Preview Play/Pause"), Key::SPACE)); + _play_button->set_accessibility_name(TTRC("Play")); _stop_button = memnew(Button); hbox->add_child(_stop_button); _stop_button->set_flat(true); _stop_button->set_focus_mode(Control::FOCUS_NONE); _stop_button->connect(SceneStringName(pressed), callable_mp(this, &AudioStreamEditor::_stop)); + _stop_button->set_accessibility_name(TTRC("Stop")); _current_label = memnew(Label); _current_label->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_RIGHT); diff --git a/editor/plugins/bone_map_editor_plugin.cpp b/editor/plugins/bone_map_editor_plugin.cpp index 01b149d24fbe..1f73920ad9f7 100644 --- a/editor/plugins/bone_map_editor_plugin.cpp +++ b/editor/plugins/bone_map_editor_plugin.cpp @@ -291,6 +291,7 @@ void BoneMapper::create_editor() { clear_mapping_button = memnew(Button); clear_mapping_button->set_button_icon(get_editor_theme_icon(SNAME("Clear"))); clear_mapping_button->set_tooltip_text(TTR("Clear mappings in current group.")); + clear_mapping_button->set_accessibility_name(TTRC("Clear Mappings")); clear_mapping_button->connect(SceneStringName(pressed), callable_mp(this, &BoneMapper::_clear_mapping_current_group)); group_hbox->add_child(clear_mapping_button); diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp index fc1dc981ad9f..011d561d59cd 100644 --- a/editor/plugins/canvas_item_editor_plugin.cpp +++ b/editor/plugins/canvas_item_editor_plugin.cpp @@ -118,6 +118,7 @@ class SnapDialog : public ConfirmationDialog { grid_offset_x->set_suffix("px"); grid_offset_x->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid_offset_x->set_select_all_on_focus(true); + grid_offset_x->set_accessibility_name(TTRC("X Offset")); child_container->add_child(grid_offset_x); grid_offset_y = memnew(SpinBox); @@ -128,6 +129,7 @@ class SnapDialog : public ConfirmationDialog { grid_offset_y->set_suffix("px"); grid_offset_y->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid_offset_y->set_select_all_on_focus(true); + grid_offset_y->set_accessibility_name(TTRC("Y Offset")); child_container->add_child(grid_offset_y); label = memnew(Label); @@ -142,6 +144,7 @@ class SnapDialog : public ConfirmationDialog { grid_step_x->set_suffix("px"); grid_step_x->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid_step_x->set_select_all_on_focus(true); + grid_step_x->set_accessibility_name(TTRC("X Step")); child_container->add_child(grid_step_x); grid_step_y = memnew(SpinBox); @@ -151,6 +154,7 @@ class SnapDialog : public ConfirmationDialog { grid_step_y->set_suffix("px"); grid_step_y->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid_step_y->set_select_all_on_focus(true); + grid_step_y->set_accessibility_name(TTRC("X Step")); child_container->add_child(grid_step_y); label = memnew(Label); @@ -166,6 +170,7 @@ class SnapDialog : public ConfirmationDialog { primary_grid_step_x->set_suffix("steps"); primary_grid_step_x->set_h_size_flags(Control::SIZE_EXPAND_FILL); primary_grid_step_x->set_select_all_on_focus(true); + primary_grid_step_x->set_accessibility_name(TTRC("X Primary Step")); child_container->add_child(primary_grid_step_x); primary_grid_step_y = memnew(SpinBox); @@ -176,6 +181,7 @@ class SnapDialog : public ConfirmationDialog { primary_grid_step_y->set_suffix("steps"); primary_grid_step_y->set_h_size_flags(Control::SIZE_EXPAND_FILL); primary_grid_step_y->set_select_all_on_focus(true); + primary_grid_step_y->set_accessibility_name(TTRC("Y Primary Step")); child_container->add_child(primary_grid_step_y); container->add_child(memnew(HSeparator)); @@ -197,6 +203,7 @@ class SnapDialog : public ConfirmationDialog { rotation_offset->set_suffix("deg"); rotation_offset->set_h_size_flags(Control::SIZE_EXPAND_FILL); rotation_offset->set_select_all_on_focus(true); + rotation_offset->set_accessibility_name(TTRC("Rotation Offset")); child_container->add_child(rotation_offset); label = memnew(Label); @@ -210,6 +217,7 @@ class SnapDialog : public ConfirmationDialog { rotation_step->set_suffix("deg"); rotation_step->set_h_size_flags(Control::SIZE_EXPAND_FILL); rotation_step->set_select_all_on_focus(true); + rotation_step->set_accessibility_name(TTRC("Rotation Step")); child_container->add_child(rotation_step); container->add_child(memnew(HSeparator)); @@ -229,6 +237,7 @@ class SnapDialog : public ConfirmationDialog { scale_step->set_h_size_flags(Control::SIZE_EXPAND_FILL); scale_step->set_step(0.01f); scale_step->set_select_all_on_focus(true); + scale_step->set_accessibility_name(TTRC("Scale Step")); child_container->add_child(scale_step); } @@ -4128,6 +4137,15 @@ void CanvasItemEditor::_notification(int p_what) { ProjectSettings::get_singleton()->connect("settings_changed", callable_mp(this, &CanvasItemEditor::_project_settings_changed)); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Canvas item editor"))); + } break; + case NOTIFICATION_PROCESS: { // Update the viewport if the canvas_item changes List selection = _get_edited_canvas_items(true); @@ -5360,6 +5378,7 @@ CanvasItemEditor::CanvasItemEditor() { controls_hb->add_child(button_center_view); button_center_view->set_flat(true); button_center_view->set_tooltip_text(TTR("Center View")); + button_center_view->set_accessibility_name(TTRC("Center View")); button_center_view->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(VIEW_CENTER_TO_SELECTION)); zoom_widget = memnew(EditorZoomWidget); @@ -5402,6 +5421,7 @@ CanvasItemEditor::CanvasItemEditor() { select_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/select_mode", TTRC("Select Mode"), Key::Q)); select_button->set_shortcut_context(this); select_button->set_tooltip_text(keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Drag: Rotate selected node around pivot.") + "\n" + TTR("Alt+Drag: Move selected node.") + "\n" + keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Alt+Drag: Scale selected node.") + "\n" + TTR("V: Set selected node's pivot position.") + "\n" + TTR("Alt+RMB: Show list of all nodes at position clicked, including locked.") + "\n" + TTR("(Available in all modes.)") + "\n" + TTR("RMB: Add node at position clicked.")); + select_button->set_accessibility_name(TTRC("Select Mode")); main_menu_hbox->add_child(memnew(VSeparator)); @@ -5413,6 +5433,7 @@ CanvasItemEditor::CanvasItemEditor() { move_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/move_mode", TTRC("Move Mode"), Key::W)); move_button->set_shortcut_context(this); move_button->set_tooltip_text(TTRC("Move Mode")); + move_button->set_accessibility_name(TTRC("Move Mode")); rotate_button = memnew(Button); rotate_button->set_theme_type_variation(SceneStringName(FlatButton)); @@ -5422,6 +5443,7 @@ CanvasItemEditor::CanvasItemEditor() { rotate_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/rotate_mode", TTRC("Rotate Mode"), Key::E)); rotate_button->set_shortcut_context(this); rotate_button->set_tooltip_text(TTRC("Rotate Mode")); + rotate_button->set_accessibility_name(TTRC("Rotate Mode")); scale_button = memnew(Button); scale_button->set_theme_type_variation(SceneStringName(FlatButton)); @@ -5431,6 +5453,7 @@ CanvasItemEditor::CanvasItemEditor() { scale_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/scale_mode", TTRC("Scale Mode"), Key::S)); scale_button->set_shortcut_context(this); scale_button->set_tooltip_text(TTRC("Shift: Scale proportionally.")); + scale_button->set_accessibility_name(TTRC("Scale Mode")); main_menu_hbox->add_child(memnew(VSeparator)); @@ -5440,6 +5463,7 @@ CanvasItemEditor::CanvasItemEditor() { list_select_button->set_toggle_mode(true); list_select_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_button_tool_select).bind(TOOL_LIST_SELECT)); list_select_button->set_tooltip_text(TTR("Show list of selectable nodes at position clicked.")); + list_select_button->set_accessibility_name(TTRC("List Selectable Nodes")); pivot_button = memnew(Button); pivot_button->set_theme_type_variation(SceneStringName(FlatButton)); @@ -5447,6 +5471,7 @@ CanvasItemEditor::CanvasItemEditor() { pivot_button->set_toggle_mode(true); pivot_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_button_tool_select).bind(TOOL_EDIT_PIVOT)); pivot_button->set_tooltip_text(TTR("Click to change object's pivot.") + "\n" + TTR("Shift: Set temporary pivot.") + "\n" + TTR("Click this button while holding Shift to put the temporary pivot in the center of the selected nodes.")); + pivot_button->set_accessibility_name(TTRC("Change Pivot")); pan_button = memnew(Button); pan_button->set_theme_type_variation(SceneStringName(FlatButton)); @@ -5456,6 +5481,7 @@ CanvasItemEditor::CanvasItemEditor() { pan_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/pan_mode", TTRC("Pan Mode"), Key::G)); pan_button->set_shortcut_context(this); pan_button->set_tooltip_text(TTRC("You can also use Pan View shortcut (Space by default) to pan in any mode.")); + pan_button->set_accessibility_name(TTRC("Pan View")); ruler_button = memnew(Button); ruler_button->set_theme_type_variation(SceneStringName(FlatButton)); @@ -5465,6 +5491,7 @@ CanvasItemEditor::CanvasItemEditor() { ruler_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/ruler_mode", TTRC("Ruler Mode"), Key::R)); ruler_button->set_shortcut_context(this); ruler_button->set_tooltip_text(TTRC("Ruler Mode")); + ruler_button->set_accessibility_name(TTRC("Ruler Mode")); main_menu_hbox->add_child(memnew(VSeparator)); @@ -5476,6 +5503,7 @@ CanvasItemEditor::CanvasItemEditor() { smart_snap_button->set_tooltip_text(TTRC("Toggle smart snapping.")); smart_snap_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/use_smart_snap", TTRC("Use Smart Snap"), KeyModifierMask::SHIFT | Key::S)); smart_snap_button->set_shortcut_context(this); + smart_snap_button->set_accessibility_name(TTRC("Smart Snap")); grid_snap_button = memnew(Button); grid_snap_button->set_theme_type_variation(SceneStringName(FlatButton)); @@ -5485,6 +5513,7 @@ CanvasItemEditor::CanvasItemEditor() { grid_snap_button->set_tooltip_text(TTRC("Toggle grid snapping.")); grid_snap_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/use_grid_snap", TTRC("Use Grid Snap"), KeyModifierMask::SHIFT | Key::G)); grid_snap_button->set_shortcut_context(this); + grid_snap_button->set_accessibility_name(TTRC("Grid Snap")); snap_config_menu = memnew(MenuButton); snap_config_menu->set_flat(false); @@ -5494,6 +5523,7 @@ CanvasItemEditor::CanvasItemEditor() { snap_config_menu->set_h_size_flags(SIZE_SHRINK_END); snap_config_menu->set_tooltip_text(TTR("Snapping Options")); snap_config_menu->set_switch_on_hover(true); + snap_config_menu->set_accessibility_name(TTRC("Snapping Options")); PopupMenu *p = snap_config_menu->get_popup(); p->connect(SceneStringName(id_pressed), callable_mp(this, &CanvasItemEditor::_popup_callback)); @@ -5521,6 +5551,7 @@ CanvasItemEditor::CanvasItemEditor() { lock_button = memnew(Button); lock_button->set_theme_type_variation(SceneStringName(FlatButton)); + lock_button->set_accessibility_name(TTRC("Lock")); main_menu_hbox->add_child(lock_button); lock_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(LOCK_SELECTED)); @@ -5529,6 +5560,7 @@ CanvasItemEditor::CanvasItemEditor() { lock_button->set_shortcut(ED_GET_SHORTCUT("editor/lock_selected_nodes")); unlock_button = memnew(Button); + unlock_button->set_accessibility_name(TTRC("Unlock")); unlock_button->set_theme_type_variation(SceneStringName(FlatButton)); main_menu_hbox->add_child(unlock_button); unlock_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(UNLOCK_SELECTED)); @@ -5537,6 +5569,7 @@ CanvasItemEditor::CanvasItemEditor() { unlock_button->set_shortcut(ED_GET_SHORTCUT("editor/unlock_selected_nodes")); group_button = memnew(Button); + group_button->set_accessibility_name(TTRC("Group")); group_button->set_theme_type_variation(SceneStringName(FlatButton)); main_menu_hbox->add_child(group_button); group_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(GROUP_SELECTED)); @@ -5545,6 +5578,7 @@ CanvasItemEditor::CanvasItemEditor() { group_button->set_shortcut(ED_GET_SHORTCUT("editor/group_selected_nodes")); ungroup_button = memnew(Button); + ungroup_button->set_accessibility_name(TTRC("Ungroup")); ungroup_button->set_theme_type_variation(SceneStringName(FlatButton)); main_menu_hbox->add_child(ungroup_button); ungroup_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(UNGROUP_SELECTED)); @@ -5561,6 +5595,7 @@ CanvasItemEditor::CanvasItemEditor() { main_menu_hbox->add_child(skeleton_menu); skeleton_menu->set_tooltip_text(TTR("Skeleton Options")); skeleton_menu->set_switch_on_hover(true); + skeleton_menu->set_accessibility_name(TTRC("Skeleton Options")); p = skeleton_menu->get_popup(); p->set_hide_on_checkable_item_selection(false); @@ -5652,6 +5687,7 @@ CanvasItemEditor::CanvasItemEditor() { key_loc_button->set_focus_mode(FOCUS_NONE); key_loc_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(ANIM_INSERT_POS)); key_loc_button->set_tooltip_text(TTR("Translation mask for inserting keys.")); + key_loc_button->set_accessibility_name(TTRC("Translation Mask")); animation_hb->add_child(key_loc_button); key_rot_button = memnew(Button); @@ -5661,6 +5697,7 @@ CanvasItemEditor::CanvasItemEditor() { key_rot_button->set_focus_mode(FOCUS_NONE); key_rot_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(ANIM_INSERT_ROT)); key_rot_button->set_tooltip_text(TTR("Rotation mask for inserting keys.")); + key_rot_button->set_accessibility_name(TTRC("Rotation Mask")); animation_hb->add_child(key_rot_button); key_scale_button = memnew(Button); @@ -5669,6 +5706,7 @@ CanvasItemEditor::CanvasItemEditor() { key_scale_button->set_focus_mode(FOCUS_NONE); key_scale_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(ANIM_INSERT_SCALE)); key_scale_button->set_tooltip_text(TTR("Scale mask for inserting keys.")); + key_scale_button->set_accessibility_name(TTRC("Scale Mask")); animation_hb->add_child(key_scale_button); key_insert_button = memnew(Button); @@ -5677,6 +5715,7 @@ CanvasItemEditor::CanvasItemEditor() { key_insert_button->connect(SceneStringName(pressed), callable_mp(this, &CanvasItemEditor::_popup_callback).bind(ANIM_INSERT_KEY)); key_insert_button->set_tooltip_text(TTRC("Insert keys (based on mask).")); key_insert_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/anim_insert_key", TTRC("Insert Key"), Key::INSERT)); + key_insert_button->set_accessibility_name(TTRC("Insert Keys")); key_insert_button->set_shortcut_context(this); animation_hb->add_child(key_insert_button); @@ -5686,6 +5725,7 @@ CanvasItemEditor::CanvasItemEditor() { key_auto_insert_button->set_focus_mode(FOCUS_NONE); key_auto_insert_button->set_tooltip_text(TTRC("Auto insert keys when objects are translated, rotated or scaled (based on mask).\nKeys are only added to existing tracks, no new tracks will be created.\nKeys must be inserted manually for the first time.")); key_auto_insert_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/anim_auto_insert_key", TTRC("Auto Insert Key"))); + key_auto_insert_button->set_accessibility_name(TTRC("Auto Insert Keys")); key_auto_insert_button->set_shortcut_context(this); animation_hb->add_child(key_auto_insert_button); @@ -5694,6 +5734,7 @@ CanvasItemEditor::CanvasItemEditor() { animation_menu->set_theme_type_variation("FlatMenuButton"); animation_menu->set_shortcut_context(this); animation_menu->set_tooltip_text(TTR("Animation Key and Pose Options")); + animation_menu->set_accessibility_name(TTRC("Animation Key and Pose")); animation_hb->add_child(animation_menu); animation_menu->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &CanvasItemEditor::_popup_callback)); animation_menu->set_switch_on_hover(true); @@ -6134,6 +6175,9 @@ void CanvasItemEditorViewport::_perform_drop_data() { } bool CanvasItemEditorViewport::can_drop_data(const Point2 &p_point, const Variant &p_data) const { + if (p_point == Vector2(INFINITY, INFINITY)) { + return false; + } Dictionary d = p_data; if (!d.has("type") || (String(d["type"]) != "files")) { label->hide(); @@ -6265,6 +6309,9 @@ bool CanvasItemEditorViewport::_is_any_texture_selected() const { } void CanvasItemEditorViewport::drop_data(const Point2 &p_point, const Variant &p_data) { + if (p_point == Vector2(INFINITY, INFINITY)) { + return; + } bool is_shift = Input::get_singleton()->is_key_pressed(Key::SHIFT); bool is_alt = Input::get_singleton()->is_key_pressed(Key::ALT); diff --git a/editor/plugins/control_editor_plugin.cpp b/editor/plugins/control_editor_plugin.cpp index e5fdbca33dc6..e146dd166d75 100644 --- a/editor/plugins/control_editor_plugin.cpp +++ b/editor/plugins/control_editor_plugin.cpp @@ -552,6 +552,7 @@ void ControlEditorPresetPicker::_add_row_button(HBoxContainer *p_row, const int b->set_custom_minimum_size(Size2i(36, 36) * EDSCALE); b->set_icon_alignment(HORIZONTAL_ALIGNMENT_CENTER); b->set_tooltip_text(p_name); + b->set_accessibility_name(p_name); b->set_flat(true); p_row->add_child(b); b->connect(SceneStringName(pressed), callable_mp(this, &ControlEditorPresetPicker::_preset_button_pressed).bind(p_preset)); @@ -1085,6 +1086,7 @@ ControlEditorToolbar::ControlEditorToolbar() { anchor_mode_button->set_theme_type_variation(SceneStringName(FlatButton)); anchor_mode_button->set_toggle_mode(true); anchor_mode_button->set_tooltip_text(TTR("When active, moving Control nodes changes their anchors instead of their offsets.")); + anchor_mode_button->set_accessibility_name(TTRC("Change Anchors")); add_child(anchor_mode_button); anchor_mode_button->connect(SceneStringName(toggled), callable_mp(this, &ControlEditorToolbar::_anchor_mode_toggled)); diff --git a/editor/plugins/curve_editor_plugin.cpp b/editor/plugins/curve_editor_plugin.cpp index aaf7c427f0fe..7b99546a6366 100644 --- a/editor/plugins/curve_editor_plugin.cpp +++ b/editor/plugins/curve_editor_plugin.cpp @@ -128,6 +128,14 @@ void CurveEdit::_notification(int p_what) { tangent_hover_radius = Math::round(BASE_TANGENT_HOVER_RADIUS * get_theme_default_base_scale() * gizmo_scale); tangent_length = Math::round(BASE_TANGENT_LENGTH * get_theme_default_base_scale()); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Curve editor"))); + } break; case NOTIFICATION_DRAW: { _redraw(); } break; @@ -989,6 +997,7 @@ CurveEditor::CurveEditor() { snap_button = memnew(Button); snap_button->set_tooltip_text(TTR("Toggle Grid Snap")); + snap_button->set_accessibility_name(TTRC("Grid Snap")); snap_button->set_toggle_mode(true); toolbar->add_child(snap_button); snap_button->connect(SceneStringName(toggled), callable_mp(this, &CurveEditor::_set_snap_enabled)); @@ -998,6 +1007,7 @@ CurveEditor::CurveEditor() { snap_count_edit = memnew(EditorSpinSlider); snap_count_edit->set_min(2); snap_count_edit->set_max(100); + snap_count_edit->set_accessibility_name(TTRC("Snap Step")); snap_count_edit->set_value(DEFAULT_SNAP); snap_count_edit->set_custom_minimum_size(Size2(65 * EDSCALE, 0)); toolbar->add_child(snap_count_edit); diff --git a/editor/plugins/font_config_plugin.cpp b/editor/plugins/font_config_plugin.cpp index ff11160b5588..c52b96cba909 100644 --- a/editor/plugins/font_config_plugin.cpp +++ b/editor/plugins/font_config_plugin.cpp @@ -295,6 +295,7 @@ void EditorPropertyFontMetaOverride::update_property() { hbox->add_child(prop); prop->set_h_size_flags(SIZE_EXPAND_FILL); Button *remove = memnew(Button); + remove->set_accessibility_name(TTRC("Remove")); remove->set_button_icon(get_editor_theme_icon(SNAME("Remove"))); hbox->add_child(remove); remove->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyFontMetaOverride::_remove).bind(remove, name)); @@ -349,6 +350,7 @@ EditorPropertyFontMetaOverride::EditorPropertyFontMetaOverride(bool p_script) { page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page")); edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); edit->set_h_size_flags(SIZE_EXPAND_FILL); edit->set_clip_text(true); edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyFontMetaOverride::_edit_pressed)); @@ -535,6 +537,7 @@ EditorPropertyOTVariation::EditorPropertyOTVariation() { page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page")); edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); edit->set_h_size_flags(SIZE_EXPAND_FILL); edit->set_clip_text(true); edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyOTVariation::_edit_pressed)); @@ -789,6 +792,7 @@ void EditorPropertyOTFeatures::update_property() { hbox->add_child(prop); prop->set_h_size_flags(SIZE_EXPAND_FILL); Button *remove = memnew(Button); + remove->set_accessibility_name(TTRC("Remove")); remove->set_button_icon(get_editor_theme_icon(SNAME("Remove"))); hbox->add_child(remove); remove->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyOTFeatures::_remove).bind(remove, name_tag)); @@ -838,6 +842,7 @@ EditorPropertyOTFeatures::EditorPropertyOTFeatures() { page_length = int(EDITOR_GET("interface/inspector/max_array_dictionary_items_per_page")); edit = memnew(Button); + edit->set_accessibility_name(TTRC("Edit")); edit->set_h_size_flags(SIZE_EXPAND_FILL); edit->set_clip_text(true); edit->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyOTFeatures::_edit_pressed)); diff --git a/editor/plugins/game_view_plugin.cpp b/editor/plugins/game_view_plugin.cpp index 0bdd98321deb..c6b9dee78a92 100644 --- a/editor/plugins/game_view_plugin.cpp +++ b/editor/plugins/game_view_plugin.cpp @@ -926,12 +926,14 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { suspend_button->set_theme_type_variation(SceneStringName(FlatButton)); suspend_button->connect(SceneStringName(toggled), callable_mp(this, &GameView::_suspend_button_toggled)); suspend_button->set_tooltip_text(TTR("Suspend")); + suspend_button->set_accessibility_name(TTRC("Suspend")); next_frame_button = memnew(Button); main_menu_hbox->add_child(next_frame_button); next_frame_button->set_theme_type_variation(SceneStringName(FlatButton)); next_frame_button->connect(SceneStringName(pressed), callable_mp(*debugger, &GameViewDebugger::next_frame)); next_frame_button->set_tooltip_text(TTR("Next Frame")); + next_frame_button->set_accessibility_name(TTRC("Next Frame")); main_menu_hbox->add_child(memnew(VSeparator)); @@ -968,6 +970,7 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { hide_selection->set_theme_type_variation(SceneStringName(FlatButton)); hide_selection->connect(SceneStringName(toggled), callable_mp(this, &GameView::_hide_selection_toggled)); hide_selection->set_tooltip_text(TTR("Toggle Selection Visibility")); + hide_selection->set_accessibility_name(TTRC("Selection Visibility")); hide_selection->set_pressed(EditorSettings::get_singleton()->get_project_metadata("game_view", "hide_selection", false)); main_menu_hbox->add_child(memnew(VSeparator)); @@ -1006,6 +1009,7 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { camera_override_button->set_toggle_mode(true); camera_override_button->set_theme_type_variation(SceneStringName(FlatButton)); camera_override_button->set_tooltip_text(TTR("Override the in-game camera.")); + camera_override_button->set_accessibility_name(TTRC("Override In-game Camera")); camera_override_button->connect(SceneStringName(toggled), callable_mp(this, &GameView::_camera_override_button_toggled)); camera_override_menu = memnew(MenuButton); @@ -1014,6 +1018,7 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { camera_override_menu->set_theme_type_variation("FlatMenuButton"); camera_override_menu->set_h_size_flags(SIZE_SHRINK_END); camera_override_menu->set_tooltip_text(TTR("Camera Override Options")); + camera_override_menu->set_accessibility_name(TTRC("Camera Override Options")); _camera_override_menu_id_pressed(EditorSettings::get_singleton()->get_project_metadata("game_view", "camera_override_mode", 0)); PopupMenu *menu = camera_override_menu->get_popup(); @@ -1033,6 +1038,7 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { fixed_size_button->set_toggle_mode(true); fixed_size_button->set_theme_type_variation("FlatButton"); fixed_size_button->set_tooltip_text(TTR("Embedded game size is based on project settings.\nThe 'Keep Aspect' mode is used when the Game Workspace is smaller than the desired size.")); + fixed_size_button->set_accessibility_name(TTRC("Fixed Size")); fixed_size_button->connect(SceneStringName(pressed), callable_mp(this, &GameView::_size_mode_button_pressed).bind(SIZE_MODE_FIXED)); keep_aspect_button = memnew(Button); @@ -1040,6 +1046,7 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { keep_aspect_button->set_toggle_mode(true); keep_aspect_button->set_theme_type_variation("FlatButton"); keep_aspect_button->set_tooltip_text(TTR("Keep the aspect ratio of the embedded game.")); + keep_aspect_button->set_accessibility_name(TTRC("Keep Aspect Ratio")); keep_aspect_button->connect(SceneStringName(pressed), callable_mp(this, &GameView::_size_mode_button_pressed).bind(SIZE_MODE_KEEP_ASPECT)); stretch_button = memnew(Button); @@ -1047,6 +1054,7 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { stretch_button->set_toggle_mode(true); stretch_button->set_theme_type_variation("FlatButton"); stretch_button->set_tooltip_text(TTR("Embedded game size stretches to fit the Game Workspace.")); + stretch_button->set_accessibility_name(TTRC("Stretch")); stretch_button->connect(SceneStringName(pressed), callable_mp(this, &GameView::_size_mode_button_pressed).bind(SIZE_MODE_STRETCH)); embed_options_menu = memnew(MenuButton); @@ -1055,6 +1063,7 @@ GameView::GameView(Ref p_debugger, WindowWrapper *p_wrapper) { embed_options_menu->set_theme_type_variation("FlatMenuButton"); embed_options_menu->set_h_size_flags(SIZE_SHRINK_END); embed_options_menu->set_tooltip_text(TTR("Embedding Options")); + embed_options_menu->set_accessibility_name(TTRC("Embedding Options")); menu = embed_options_menu->get_popup(); menu->connect(SceneStringName(id_pressed), callable_mp(this, &GameView::_embed_options_menu_menu_id_pressed)); diff --git a/editor/plugins/gradient_editor_plugin.cpp b/editor/plugins/gradient_editor_plugin.cpp index ad9894a9775d..6dc429974e14 100644 --- a/editor/plugins/gradient_editor_plugin.cpp +++ b/editor/plugins/gradient_editor_plugin.cpp @@ -544,6 +544,14 @@ void GradientEdit::_notification(int p_what) { draw_spacing = BASE_SPACING * get_theme_default_base_scale(); handle_width = BASE_HANDLE_WIDTH * get_theme_default_base_scale(); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "Gradient editor"))); + } break; case NOTIFICATION_DRAW: { _redraw(); } break; @@ -630,6 +638,7 @@ GradientEditor::GradientEditor() { snap_button = memnew(Button); snap_button->set_tooltip_text(TTR("Toggle Grid Snap")); + snap_button->set_accessibility_name(TTRC("Snap to Grid")); snap_button->set_toggle_mode(true); toolbar->add_child(snap_button); snap_button->connect(SceneStringName(toggled), callable_mp(this, &GradientEditor::_set_snap_enabled)); @@ -637,6 +646,7 @@ GradientEditor::GradientEditor() { snap_count_edit = memnew(EditorSpinSlider); snap_count_edit->set_min(2); snap_count_edit->set_max(100); + snap_count_edit->set_accessibility_name(TTRC("Grid Step")); snap_count_edit->set_value(DEFAULT_SNAP); snap_count_edit->set_custom_minimum_size(Size2(65 * EDSCALE, 0)); toolbar->add_child(snap_count_edit); diff --git a/editor/plugins/gradient_texture_2d_editor_plugin.cpp b/editor/plugins/gradient_texture_2d_editor_plugin.cpp index 65951724a1b7..4b3c7903a5f6 100644 --- a/editor/plugins/gradient_texture_2d_editor_plugin.cpp +++ b/editor/plugins/gradient_texture_2d_editor_plugin.cpp @@ -279,6 +279,7 @@ GradientTexture2DEditor::GradientTexture2DEditor() { reverse_button = memnew(Button); reverse_button->set_tooltip_text(TTR("Swap Gradient Fill Points")); + reverse_button->set_accessibility_name(TTRC("Swap Gradient Fill Points")); toolbar->add_child(reverse_button); reverse_button->connect(SceneStringName(pressed), callable_mp(this, &GradientTexture2DEditor::_reverse_button_pressed)); @@ -286,6 +287,7 @@ GradientTexture2DEditor::GradientTexture2DEditor() { snap_button = memnew(Button); snap_button->set_tooltip_text(TTR("Toggle Grid Snap")); + snap_button->set_accessibility_name(TTRC("Snap to Grid")); snap_button->set_toggle_mode(true); toolbar->add_child(snap_button); snap_button->connect(SceneStringName(toggled), callable_mp(this, &GradientTexture2DEditor::_set_snap_enabled)); @@ -294,6 +296,7 @@ GradientTexture2DEditor::GradientTexture2DEditor() { snap_count_edit->set_min(2); snap_count_edit->set_max(100); snap_count_edit->set_value(DEFAULT_SNAP); + snap_count_edit->set_accessibility_name(TTRC("Grid Step")); snap_count_edit->set_custom_minimum_size(Size2(65 * EDSCALE, 0)); toolbar->add_child(snap_count_edit); snap_count_edit->connect(SceneStringName(value_changed), callable_mp(this, &GradientTexture2DEditor::_set_snap_count)); diff --git a/editor/plugins/material_editor_plugin.cpp b/editor/plugins/material_editor_plugin.cpp index b17e9927ab8b..14c7f15251f3 100644 --- a/editor/plugins/material_editor_plugin.cpp +++ b/editor/plugins/material_editor_plugin.cpp @@ -310,18 +310,21 @@ MaterialEditor::MaterialEditor() { sphere_switch = memnew(Button); sphere_switch->set_theme_type_variation("PreviewLightButton"); sphere_switch->set_toggle_mode(true); + sphere_switch->set_accessibility_name(TTRC("Sphere")); vb_shape->add_child(sphere_switch); sphere_switch->connect(SceneStringName(pressed), callable_mp(this, &MaterialEditor::_on_sphere_switch_pressed)); box_switch = memnew(Button); box_switch->set_theme_type_variation("PreviewLightButton"); box_switch->set_toggle_mode(true); + box_switch->set_accessibility_name(TTRC("Box")); vb_shape->add_child(box_switch); box_switch->connect(SceneStringName(pressed), callable_mp(this, &MaterialEditor::_on_box_switch_pressed)); quad_switch = memnew(Button); quad_switch->set_theme_type_variation("PreviewLightButton"); quad_switch->set_toggle_mode(true); + quad_switch->set_accessibility_name(TTRC("Quad")); vb_shape->add_child(quad_switch); quad_switch->connect(SceneStringName(pressed), callable_mp(this, &MaterialEditor::_on_quad_switch_pressed)); @@ -334,6 +337,7 @@ MaterialEditor::MaterialEditor() { light_1_switch->set_theme_type_variation("PreviewLightButton"); light_1_switch->set_toggle_mode(true); light_1_switch->set_pressed(true); + light_1_switch->set_accessibility_name(TTRC("First Light")); vb_light->add_child(light_1_switch); light_1_switch->connect(SceneStringName(pressed), callable_mp(this, &MaterialEditor::_on_light_1_switch_pressed)); @@ -341,6 +345,7 @@ MaterialEditor::MaterialEditor() { light_2_switch->set_theme_type_variation("PreviewLightButton"); light_2_switch->set_toggle_mode(true); light_2_switch->set_pressed(true); + light_2_switch->set_accessibility_name(TTRC("Second Light")); vb_light->add_child(light_2_switch); light_2_switch->connect(SceneStringName(pressed), callable_mp(this, &MaterialEditor::_on_light_2_switch_pressed)); diff --git a/editor/plugins/mesh_editor_plugin.cpp b/editor/plugins/mesh_editor_plugin.cpp index 645dd1784e53..d6e0a30bfdca 100644 --- a/editor/plugins/mesh_editor_plugin.cpp +++ b/editor/plugins/mesh_editor_plugin.cpp @@ -149,6 +149,7 @@ MeshEditor::MeshEditor() { light_1_switch->set_theme_type_variation("PreviewLightButton"); light_1_switch->set_toggle_mode(true); light_1_switch->set_pressed(true); + light_1_switch->set_accessibility_name(TTRC("First Light")); vb_light->add_child(light_1_switch); light_1_switch->connect(SceneStringName(pressed), callable_mp(this, &MeshEditor::_on_light_1_switch_pressed)); @@ -156,6 +157,7 @@ MeshEditor::MeshEditor() { light_2_switch->set_theme_type_variation("PreviewLightButton"); light_2_switch->set_toggle_mode(true); light_2_switch->set_pressed(true); + light_2_switch->set_accessibility_name(TTRC("Second Light")); vb_light->add_child(light_2_switch); light_2_switch->connect(SceneStringName(pressed), callable_mp(this, &MeshEditor::_on_light_2_switch_pressed)); diff --git a/editor/plugins/mesh_instance_3d_editor_plugin.cpp b/editor/plugins/mesh_instance_3d_editor_plugin.cpp index 66179b31a4a8..70200f921b26 100644 --- a/editor/plugins/mesh_instance_3d_editor_plugin.cpp +++ b/editor/plugins/mesh_instance_3d_editor_plugin.cpp @@ -593,6 +593,7 @@ MeshInstance3DEditor::MeshInstance3DEditor() { //outline_dialog->set_child_rect(outline_dialog_vbc); outline_size = memnew(SpinBox); + outline_size->set_accessibility_name(TTRC("Outline Size")); outline_size->set_min(0.001); outline_size->set_max(1024); outline_size->set_step(0.001); @@ -610,10 +611,11 @@ MeshInstance3DEditor::MeshInstance3DEditor() { shape_dialog->add_child(shape_dialog_vbc); Label *l = memnew(Label); - l->set_text(TTR("Collision Shape placement")); + l->set_text(TTR("Collision Shape Placement")); shape_dialog_vbc->add_child(l); shape_placement = memnew(OptionButton); + shape_placement->set_accessibility_name(TTRC("Collision Shape Placement")); shape_placement->set_h_size_flags(SIZE_EXPAND_FILL); shape_placement->add_item(TTR("Sibling"), SHAPE_PLACEMENT_SIBLING); shape_placement->set_item_tooltip(-1, TTR("Creates collision shapes as Sibling.")); @@ -626,6 +628,7 @@ MeshInstance3DEditor::MeshInstance3DEditor() { shape_dialog_vbc->add_child(l); shape_type = memnew(OptionButton); + shape_type->set_accessibility_name(TTRC("Collision Shape Type")); shape_type->set_h_size_flags(SIZE_EXPAND_FILL); shape_type->add_item(TTR("Trimesh"), SHAPE_TYPE_TRIMESH); shape_type->set_item_tooltip(-1, TTR("Creates a polygon-based collision shape.\nThis is the most accurate (but slowest) option for collision detection.")); diff --git a/editor/plugins/multimesh_editor_plugin.cpp b/editor/plugins/multimesh_editor_plugin.cpp index afee61ef4091..c96c81b50575 100644 --- a/editor/plugins/multimesh_editor_plugin.cpp +++ b/editor/plugins/multimesh_editor_plugin.cpp @@ -290,8 +290,10 @@ MultiMeshEditor::MultiMeshEditor() { surface_source = memnew(LineEdit); hbc->add_child(surface_source); surface_source->set_h_size_flags(SIZE_EXPAND_FILL); + surface_source->set_accessibility_name(TTRC("Surface Source")); Button *b = memnew(Button); hbc->add_child(b); + b->set_accessibility_name(TTRC("Browse")); b->set_text(".."); b->connect(SceneStringName(pressed), callable_mp(this, &MultiMeshEditor::_browse).bind(false)); @@ -301,13 +303,16 @@ MultiMeshEditor::MultiMeshEditor() { mesh_source = memnew(LineEdit); hbc->add_child(mesh_source); mesh_source->set_h_size_flags(SIZE_EXPAND_FILL); + mesh_source->set_accessibility_name(TTRC("Mesh Source")); b = memnew(Button); hbc->add_child(b); + b->set_accessibility_name(TTRC("Browse")); b->set_text(".."); vbc->add_margin_child(TTR("Source Mesh:"), hbc); b->connect(SceneStringName(pressed), callable_mp(this, &MultiMeshEditor::_browse).bind(true)); populate_axis = memnew(OptionButton); + populate_axis->set_accessibility_name(TTRC("Up Axis")); populate_axis->add_item(TTR("X-Axis")); populate_axis->add_item(TTR("Y-Axis")); populate_axis->add_item(TTR("Z-Axis")); @@ -317,11 +322,13 @@ MultiMeshEditor::MultiMeshEditor() { populate_rotate_random = memnew(HSlider); populate_rotate_random->set_max(1); populate_rotate_random->set_step(0.01); + populate_rotate_random->set_accessibility_name(TTRC("Random Rotation")); vbc->add_margin_child(TTR("Random Rotation:"), populate_rotate_random); populate_tilt_random = memnew(HSlider); populate_tilt_random->set_max(1); populate_tilt_random->set_step(0.01); + populate_tilt_random->set_accessibility_name(TTRC("Random Tilt")); vbc->add_margin_child(TTR("Random Tilt:"), populate_tilt_random); populate_scale_random = memnew(SpinBox); @@ -329,7 +336,7 @@ MultiMeshEditor::MultiMeshEditor() { populate_scale_random->set_max(1); populate_scale_random->set_value(0); populate_scale_random->set_step(0.01); - + populate_scale_random->set_accessibility_name(TTRC("Random Scale")); vbc->add_margin_child(TTR("Random Scale:"), populate_scale_random); populate_scale = memnew(SpinBox); @@ -337,7 +344,7 @@ MultiMeshEditor::MultiMeshEditor() { populate_scale->set_max(4096); populate_scale->set_value(1); populate_scale->set_step(0.01); - + populate_scale->set_accessibility_name(TTRC("Scale")); vbc->add_margin_child(TTR("Scale:"), populate_scale); populate_amount = memnew(SpinBox); @@ -347,6 +354,7 @@ MultiMeshEditor::MultiMeshEditor() { populate_amount->set_min(1); populate_amount->set_max(65536); populate_amount->set_value(128); + populate_amount->set_accessibility_name(TTRC("Amount")); vbc->add_margin_child(TTR("Amount:"), populate_amount); populate_dialog->set_ok_button_text(TTR("Populate")); diff --git a/editor/plugins/navigation_obstacle_3d_editor_plugin.cpp b/editor/plugins/navigation_obstacle_3d_editor_plugin.cpp index 3505e66aa0a4..48df1eb1a43e 100644 --- a/editor/plugins/navigation_obstacle_3d_editor_plugin.cpp +++ b/editor/plugins/navigation_obstacle_3d_editor_plugin.cpp @@ -830,12 +830,14 @@ NavigationObstacle3DEditorPlugin::NavigationObstacle3DEditorPlugin() { button_create->set_theme_type_variation(SceneStringName(FlatButton)); obstacle_editor->add_child(button_create); button_create->set_tooltip_text(TTR("Add Vertex")); + button_create->set_accessibility_name(TTRC("Add Vertex")); button_create->connect(SceneStringName(pressed), callable_mp(this, &NavigationObstacle3DEditorPlugin::set_mode).bind(NavigationObstacle3DEditorPlugin::MODE_CREATE)); button_create->set_toggle_mode(true); button_create->set_button_group(bg); button_edit = memnew(Button); button_edit->set_theme_type_variation(SceneStringName(FlatButton)); + button_edit->set_accessibility_name(TTRC("Edit")); obstacle_editor->add_child(button_edit); button_edit->connect(SceneStringName(pressed), callable_mp(this, &NavigationObstacle3DEditorPlugin::set_mode).bind(NavigationObstacle3DEditorPlugin::MODE_EDIT)); button_edit->set_toggle_mode(true); @@ -843,6 +845,7 @@ NavigationObstacle3DEditorPlugin::NavigationObstacle3DEditorPlugin() { button_delete = memnew(Button); button_delete->set_theme_type_variation(SceneStringName(FlatButton)); + button_delete->set_accessibility_name(TTRC("Delete")); obstacle_editor->add_child(button_delete); button_delete->connect(SceneStringName(pressed), callable_mp(this, &NavigationObstacle3DEditorPlugin::set_mode).bind(NavigationObstacle3DEditorPlugin::MODE_DELETE)); button_delete->set_toggle_mode(true); @@ -850,12 +853,14 @@ NavigationObstacle3DEditorPlugin::NavigationObstacle3DEditorPlugin() { button_flip = memnew(Button); button_flip->set_theme_type_variation(SceneStringName(FlatButton)); + button_flip->set_accessibility_name(TTRC("Flip")); obstacle_editor->add_child(button_flip); button_flip->connect(SceneStringName(pressed), callable_mp(this, &NavigationObstacle3DEditorPlugin::set_mode).bind(NavigationObstacle3DEditorPlugin::ACTION_FLIP)); button_flip->set_toggle_mode(true); button_clear = memnew(Button); button_clear->set_theme_type_variation(SceneStringName(FlatButton)); + button_clear->set_accessibility_name(TTRC("Clear")); obstacle_editor->add_child(button_clear); button_clear->connect(SceneStringName(pressed), callable_mp(this, &NavigationObstacle3DEditorPlugin::set_mode).bind(NavigationObstacle3DEditorPlugin::ACTION_CLEAR)); button_clear->set_toggle_mode(true); diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp index ef67c7a2a709..6d8bb9d3db16 100644 --- a/editor/plugins/node_3d_editor_plugin.cpp +++ b/editor/plugins/node_3d_editor_plugin.cpp @@ -4909,6 +4909,9 @@ void Node3DEditorViewport::_perform_drop_data() { } bool Node3DEditorViewport::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { + if (p_point == Vector2(INFINITY, INFINITY)) { + return false; + } preview_node_viewport_pos = p_point; bool can_instantiate = false; @@ -5587,6 +5590,7 @@ Node3DEditorViewport::Node3DEditorViewport(Node3DEditor *p_spatial_editor, int p view_display_menu->set_flat(false); view_display_menu->set_h_size_flags(0); view_display_menu->set_shortcut_context(this); + view_display_menu->set_accessibility_name(TTRC("View")); vbox->add_child(view_display_menu); view_display_menu->get_popup()->set_hide_on_checkable_item_selection(false); @@ -8305,6 +8309,15 @@ void Node3DEditor::_notification(int p_what) { ProjectSettings::get_singleton()->connect("settings_changed", callable_mp(this, &Node3DEditor::update_all_gizmos).bind(Variant())); } break; + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + //TODO + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, TTR(vformat("The %s is not accessible at this time.", "3D editor"))); + } break; + case NOTIFICATION_ENTER_TREE: { _update_theme(); _register_all_gizmos(); @@ -8823,7 +8836,7 @@ void Node3DEditor::_load_default_preview_settings() { environ_sky_color->set_pick_color(Color(0.385, 0.454, 0.55)); environ_ground_color->set_pick_color(Color(0.2, 0.169, 0.133)); environ_energy->set_value_no_signal(1.0); - if (OS::get_singleton()->get_current_rendering_method() != "gl_compatibility") { + if (OS::get_singleton()->get_current_rendering_method() != "gl_compatibility" && OS::get_singleton()->get_current_rendering_method() != "dummy") { environ_glow_button->set_pressed_no_signal(true); } environ_tonemap_button->set_pressed_no_signal(true); @@ -9099,6 +9112,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_MODE_SELECT]->set_shortcut(ED_SHORTCUT("spatial_editor/tool_select", TTRC("Select Mode"), Key::Q, true)); tool_button[TOOL_MODE_SELECT]->set_shortcut_context(this); tool_button[TOOL_MODE_SELECT]->set_tooltip_text(keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Drag: Rotate selected node around pivot.") + "\n" + TTR("Alt+RMB: Show list of all nodes at position clicked, including locked.") + "\n" + TTR("(Available in all modes.)")); + tool_button[TOOL_MODE_SELECT]->set_accessibility_name(TTRC("Select Mode")); main_menu_hbox->add_child(memnew(VSeparator)); tool_button[TOOL_MODE_MOVE] = memnew(Button); @@ -9110,6 +9124,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_MODE_MOVE]->set_shortcut(ED_SHORTCUT("spatial_editor/tool_move", TTRC("Move Mode"), Key::W, true)); tool_button[TOOL_MODE_MOVE]->set_shortcut_context(this); tool_button[TOOL_MODE_MOVE]->set_tooltip_text(keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Drag: Use snap.") + "\n" + TTR("Alt+RMB: Show list of all nodes at position clicked, including locked.")); + tool_button[TOOL_MODE_MOVE]->set_accessibility_name(TTRC("Move Mode")); tool_button[TOOL_MODE_ROTATE] = memnew(Button); main_menu_hbox->add_child(tool_button[TOOL_MODE_ROTATE]); @@ -9119,6 +9134,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_MODE_ROTATE]->set_shortcut(ED_SHORTCUT("spatial_editor/tool_rotate", TTRC("Rotate Mode"), Key::E, true)); tool_button[TOOL_MODE_ROTATE]->set_shortcut_context(this); tool_button[TOOL_MODE_ROTATE]->set_tooltip_text(keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Drag: Use snap.") + "\n" + TTR("Alt+RMB: Show list of all nodes at position clicked, including locked.")); + tool_button[TOOL_MODE_ROTATE]->set_accessibility_name(TTRC("Rotate Mode")); tool_button[TOOL_MODE_SCALE] = memnew(Button); main_menu_hbox->add_child(tool_button[TOOL_MODE_SCALE]); @@ -9128,6 +9144,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_MODE_SCALE]->set_shortcut(ED_SHORTCUT("spatial_editor/tool_scale", TTRC("Scale Mode"), Key::R, true)); tool_button[TOOL_MODE_SCALE]->set_shortcut_context(this); tool_button[TOOL_MODE_SCALE]->set_tooltip_text(keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Drag: Use snap.") + "\n" + TTR("Alt+RMB: Show list of all nodes at position clicked, including locked.")); + tool_button[TOOL_MODE_SCALE]->set_accessibility_name(TTRC("Scale Mode")); main_menu_hbox->add_child(memnew(VSeparator)); @@ -9137,6 +9154,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_MODE_LIST_SELECT]->set_theme_type_variation(SceneStringName(FlatButton)); tool_button[TOOL_MODE_LIST_SELECT]->connect(SceneStringName(pressed), callable_mp(this, &Node3DEditor::_menu_item_pressed).bind(MENU_TOOL_LIST_SELECT)); tool_button[TOOL_MODE_LIST_SELECT]->set_tooltip_text(TTR("Show list of selectable nodes at position clicked.")); + tool_button[TOOL_MODE_LIST_SELECT]->set_accessibility_name(TTRC("Show List of Selectable Nodes")); tool_button[TOOL_LOCK_SELECTED] = memnew(Button); main_menu_hbox->add_child(tool_button[TOOL_LOCK_SELECTED]); @@ -9145,6 +9163,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_LOCK_SELECTED]->set_tooltip_text(TTRC("Lock selected node, preventing selection and movement.")); // Define the shortcut globally (without a context) so that it works if the Scene tree dock is currently focused. tool_button[TOOL_LOCK_SELECTED]->set_shortcut(ED_GET_SHORTCUT("editor/lock_selected_nodes")); + tool_button[TOOL_LOCK_SELECTED]->set_accessibility_name(TTRC("Lock")); tool_button[TOOL_UNLOCK_SELECTED] = memnew(Button); main_menu_hbox->add_child(tool_button[TOOL_UNLOCK_SELECTED]); @@ -9153,6 +9172,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_UNLOCK_SELECTED]->set_tooltip_text(TTRC("Unlock selected node, allowing selection and movement.")); // Define the shortcut globally (without a context) so that it works if the Scene tree dock is currently focused. tool_button[TOOL_UNLOCK_SELECTED]->set_shortcut(ED_GET_SHORTCUT("editor/unlock_selected_nodes")); + tool_button[TOOL_UNLOCK_SELECTED]->set_accessibility_name(TTRC("Unlock")); tool_button[TOOL_GROUP_SELECTED] = memnew(Button); main_menu_hbox->add_child(tool_button[TOOL_GROUP_SELECTED]); @@ -9161,6 +9181,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_GROUP_SELECTED]->set_tooltip_text(TTRC("Groups the selected node with its children. This selects the parent when any child node is clicked in 2D and 3D view.")); // Define the shortcut globally (without a context) so that it works if the Scene tree dock is currently focused. tool_button[TOOL_GROUP_SELECTED]->set_shortcut(ED_GET_SHORTCUT("editor/group_selected_nodes")); + tool_button[TOOL_GROUP_SELECTED]->set_accessibility_name(TTRC("Group")); tool_button[TOOL_UNGROUP_SELECTED] = memnew(Button); main_menu_hbox->add_child(tool_button[TOOL_UNGROUP_SELECTED]); @@ -9169,6 +9190,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_UNGROUP_SELECTED]->set_tooltip_text(TTRC("Ungroups the selected node from its children. Child nodes will be individual items in 2D and 3D view.")); // Define the shortcut globally (without a context) so that it works if the Scene tree dock is currently focused. tool_button[TOOL_UNGROUP_SELECTED]->set_shortcut(ED_GET_SHORTCUT("editor/ungroup_selected_nodes")); + tool_button[TOOL_UNGROUP_SELECTED]->set_accessibility_name(TTRC("Ungroup")); tool_button[TOOL_RULER] = memnew(Button); main_menu_hbox->add_child(tool_button[TOOL_RULER]); @@ -9178,6 +9200,7 @@ Node3DEditor::Node3DEditor() { tool_button[TOOL_RULER]->set_tooltip_text(TTRC("LMB+Drag: Measure the distance between two points in 3D space.")); // Define the shortcut globally (without a context) so that it works if the Scene tree dock is currently focused. tool_button[TOOL_RULER]->set_shortcut(ED_SHORTCUT("spatial_editor/measure", TTRC("Ruler Mode"), Key::M)); + tool_button[TOOL_RULER]->set_accessibility_name(TTRC("Ruler Mode")); main_menu_hbox->add_child(memnew(VSeparator)); @@ -9188,6 +9211,7 @@ Node3DEditor::Node3DEditor() { tool_option_button[TOOL_OPT_LOCAL_COORDS]->connect(SceneStringName(toggled), callable_mp(this, &Node3DEditor::_menu_item_toggled).bind(MENU_TOOL_LOCAL_COORDS)); tool_option_button[TOOL_OPT_LOCAL_COORDS]->set_shortcut(ED_SHORTCUT("spatial_editor/local_coords", TTRC("Use Local Space"), Key::T)); tool_option_button[TOOL_OPT_LOCAL_COORDS]->set_shortcut_context(this); + tool_option_button[TOOL_OPT_LOCAL_COORDS]->set_accessibility_name(TTRC("Use Local Space")); tool_option_button[TOOL_OPT_USE_SNAP] = memnew(Button); main_menu_hbox->add_child(tool_option_button[TOOL_OPT_USE_SNAP]); @@ -9196,11 +9220,13 @@ Node3DEditor::Node3DEditor() { tool_option_button[TOOL_OPT_USE_SNAP]->connect(SceneStringName(toggled), callable_mp(this, &Node3DEditor::_menu_item_toggled).bind(MENU_TOOL_USE_SNAP)); tool_option_button[TOOL_OPT_USE_SNAP]->set_shortcut(ED_SHORTCUT("spatial_editor/snap", TTRC("Use Snap"), Key::Y)); tool_option_button[TOOL_OPT_USE_SNAP]->set_shortcut_context(this); + tool_option_button[TOOL_OPT_USE_SNAP]->set_accessibility_name(TTRC("Use Snap")); main_menu_hbox->add_child(memnew(VSeparator)); sun_button = memnew(Button); sun_button->set_tooltip_text(TTR("Toggle preview sunlight.\nIf a DirectionalLight3D node is added to the scene, preview sunlight is disabled.")); sun_button->set_toggle_mode(true); + sun_button->set_accessibility_name(TTRC("Preview Sunlight")); sun_button->set_theme_type_variation(SceneStringName(FlatButton)); sun_button->connect(SceneStringName(pressed), callable_mp(this, &Node3DEditor::_update_preview_environment), CONNECT_DEFERRED); // Preview is enabled by default - ensure this applies on editor startup when there is no state yet. @@ -9211,6 +9237,7 @@ Node3DEditor::Node3DEditor() { environ_button = memnew(Button); environ_button->set_tooltip_text(TTR("Toggle preview environment.\nIf a WorldEnvironment node is added to the scene, preview environment is disabled.")); environ_button->set_toggle_mode(true); + environ_button->set_accessibility_name(TTRC("Preview Environment")); environ_button->set_theme_type_variation(SceneStringName(FlatButton)); environ_button->connect(SceneStringName(pressed), callable_mp(this, &Node3DEditor::_update_preview_environment), CONNECT_DEFERRED); // Preview is enabled by default - ensure this applies on editor startup when there is no state yet. @@ -9221,6 +9248,7 @@ Node3DEditor::Node3DEditor() { sun_environ_settings = memnew(Button); sun_environ_settings->set_tooltip_text(TTR("Edit Sun and Environment settings.")); sun_environ_settings->set_theme_type_variation(SceneStringName(FlatButton)); + sun_environ_settings->set_accessibility_name(TTRC("Edit Sun and Environment")); sun_environ_settings->connect(SceneStringName(pressed), callable_mp(this, &Node3DEditor::_sun_environ_settings_pressed)); main_menu_hbox->add_child(sun_environ_settings); @@ -9363,14 +9391,17 @@ Node3DEditor::Node3DEditor() { snap_translate = memnew(LineEdit); snap_translate->set_select_all_on_focus(true); + snap_translate->set_accessibility_name(TTRC("Translate Snap")); snap_dialog_vbc->add_margin_child(TTR("Translate Snap:"), snap_translate); snap_rotate = memnew(LineEdit); snap_rotate->set_select_all_on_focus(true); + snap_rotate->set_accessibility_name(TTRC("Rotate Snap")); snap_dialog_vbc->add_margin_child(TTR("Rotate Snap (deg.):"), snap_rotate); snap_scale = memnew(LineEdit); snap_scale->set_select_all_on_focus(true); + snap_scale->set_accessibility_name(TTRC("Scale Snap")); snap_dialog_vbc->add_margin_child(TTR("Scale Snap (%):"), snap_scale); /* SETTINGS DIALOG */ @@ -9389,12 +9420,14 @@ Node3DEditor::Node3DEditor() { settings_fov->set_value(EDITOR_GET("editors/3d/default_fov")); settings_fov->set_select_all_on_focus(true); settings_fov->set_tooltip_text(TTR("FOV is defined as a vertical value, as the editor camera always uses the Keep Height aspect mode.")); + settings_fov->set_accessibility_name(TTRC("Perspective VFOV")); settings_vbc->add_margin_child(TTR("Perspective VFOV (deg.):"), settings_fov); settings_znear = memnew(SpinBox); settings_znear->set_max(MAX_Z); settings_znear->set_min(MIN_Z); settings_znear->set_step(0.01); + settings_znear->set_accessibility_name(TTRC("View Z-Near")); settings_znear->set_value(EDITOR_GET("editors/3d/default_z_near")); settings_znear->set_select_all_on_focus(true); settings_vbc->add_margin_child(TTR("View Z-Near:"), settings_znear); @@ -9403,6 +9436,7 @@ Node3DEditor::Node3DEditor() { settings_zfar->set_max(MAX_Z); settings_zfar->set_min(MIN_Z); settings_zfar->set_step(0.1); + settings_zfar->set_accessibility_name(TTRC("View Z-Far")); settings_zfar->set_value(EDITOR_GET("editors/3d/default_z_far")); settings_zfar->set_select_all_on_focus(true); settings_vbc->add_margin_child(TTR("View Z-Far:"), settings_zfar); @@ -9468,6 +9502,7 @@ Node3DEditor::Node3DEditor() { xform_type = memnew(OptionButton); xform_type->set_h_size_flags(SIZE_EXPAND_FILL); + xform_type->set_accessibility_name(TTRC("Transform Type")); xform_type->add_item(TTR("Pre")); xform_type->add_item(TTR("Post")); xform_vbc->add_child(xform_type); diff --git a/editor/plugins/particle_process_material_editor_plugin.cpp b/editor/plugins/particle_process_material_editor_plugin.cpp index 52cc2e658bdd..f4db0e3daaa7 100644 --- a/editor/plugins/particle_process_material_editor_plugin.cpp +++ b/editor/plugins/particle_process_material_editor_plugin.cpp @@ -435,6 +435,7 @@ ParticleProcessMaterialMinMaxPropertyEditor::ParticleProcessMaterialMinMaxProper toggle_mode_button = memnew(Button); toggle_mode_button->set_toggle_mode(true); toggle_mode_button->set_tooltip_text(TTR("Toggle between minimum/maximum and base value/spread modes.")); + toggle_mode_button->set_accessibility_name(TTRC("Spread mode")); hb->add_child(toggle_mode_button); toggle_mode_button->connect(SceneStringName(toggled), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_toggle_mode)); diff --git a/editor/plugins/particles_editor_plugin.cpp b/editor/plugins/particles_editor_plugin.cpp index 156cbbd2a61c..500988694c23 100644 --- a/editor/plugins/particles_editor_plugin.cpp +++ b/editor/plugins/particles_editor_plugin.cpp @@ -826,6 +826,7 @@ Particles3DEditorPlugin::Particles3DEditorPlugin() { generate_aabb->add_child(genvb); generate_seconds = memnew(SpinBox); + generate_seconds->set_accessibility_name(TTRC("Generation Time")); generate_seconds->set_min(0.1); generate_seconds->set_max(25); generate_seconds->set_value(2); @@ -850,12 +851,14 @@ Particles3DEditorPlugin::Particles3DEditorPlugin() { emission_dialog->add_child(emd_vb); emission_amount = memnew(SpinBox); + emission_amount->set_accessibility_name(TTRC("Emission Points")); emission_amount->set_min(1); emission_amount->set_max(100000); emission_amount->set_value(512); emd_vb->add_margin_child(TTR("Emission Points:"), emission_amount); emission_fill = memnew(OptionButton); + emission_fill->set_accessibility_name(TTRC("Emission Source")); emission_fill->add_item(TTR("Surface Points")); emission_fill->add_item(TTR("Surface Points+Normal (Directed)")); emission_fill->add_item(TTR("Volume")); diff --git a/editor/plugins/path_2d_editor_plugin.cpp b/editor/plugins/path_2d_editor_plugin.cpp index 85d491662bea..794aa1512b31 100644 --- a/editor/plugins/path_2d_editor_plugin.cpp +++ b/editor/plugins/path_2d_editor_plugin.cpp @@ -722,6 +722,7 @@ Path2DEditor::Path2DEditor() { curve_edit->set_pressed(true); curve_edit->set_focus_mode(Control::FOCUS_NONE); curve_edit->set_tooltip_text(TTR("Select Points") + "\n" + TTR("Shift+Drag: Select Control Points") + "\n" + keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Click: Add Point") + "\n" + TTR("Left Click: Split Segment (in curve)") + "\n" + TTR("Right Click: Delete Point")); + curve_edit->set_accessibility_name(TTRC("Select Points")); curve_edit->connect(SceneStringName(pressed), callable_mp(this, &Path2DEditor::_mode_selected).bind(MODE_EDIT)); toolbar->add_child(curve_edit); @@ -730,6 +731,7 @@ Path2DEditor::Path2DEditor() { curve_edit_curve->set_toggle_mode(true); curve_edit_curve->set_focus_mode(Control::FOCUS_NONE); curve_edit_curve->set_tooltip_text(TTR("Select Control Points (Shift+Drag)")); + curve_edit_curve->set_accessibility_name(TTRC("Select Control Points")); curve_edit_curve->connect(SceneStringName(pressed), callable_mp(this, &Path2DEditor::_mode_selected).bind(MODE_EDIT_CURVE)); toolbar->add_child(curve_edit_curve); @@ -738,6 +740,7 @@ Path2DEditor::Path2DEditor() { curve_create->set_toggle_mode(true); curve_create->set_focus_mode(Control::FOCUS_NONE); curve_create->set_tooltip_text(TTR("Add Point (in empty space)") + "\n" + TTR("Right Click: Delete Point")); + curve_create->set_accessibility_name(TTRC("Add Point")); curve_create->connect(SceneStringName(pressed), callable_mp(this, &Path2DEditor::_mode_selected).bind(MODE_CREATE)); toolbar->add_child(curve_create); @@ -746,6 +749,7 @@ Path2DEditor::Path2DEditor() { curve_del->set_toggle_mode(true); curve_del->set_focus_mode(Control::FOCUS_NONE); curve_del->set_tooltip_text(TTR("Delete Point")); + curve_del->set_accessibility_name(TTRC("Delete Point")); curve_del->connect(SceneStringName(pressed), callable_mp(this, &Path2DEditor::_mode_selected).bind(MODE_DELETE)); toolbar->add_child(curve_del); @@ -753,6 +757,7 @@ Path2DEditor::Path2DEditor() { curve_close->set_theme_type_variation(SceneStringName(FlatButton)); curve_close->set_focus_mode(Control::FOCUS_NONE); curve_close->set_tooltip_text(TTR("Close Curve")); + curve_close->set_accessibility_name(TTRC("Close Curve")); curve_close->connect(SceneStringName(pressed), callable_mp(this, &Path2DEditor::_mode_selected).bind(MODE_CLOSE)); toolbar->add_child(curve_close); @@ -760,6 +765,7 @@ Path2DEditor::Path2DEditor() { curve_clear_points->set_theme_type_variation(SceneStringName(FlatButton)); curve_clear_points->set_focus_mode(Control::FOCUS_NONE); curve_clear_points->set_tooltip_text(TTR("Clear Points")); + curve_clear_points->set_accessibility_name(TTRC("Clear Points")); curve_clear_points->connect(SceneStringName(pressed), callable_mp(this, &Path2DEditor::_confirm_clear_points)); toolbar->add_child(curve_clear_points); diff --git a/editor/plugins/path_3d_editor_plugin.cpp b/editor/plugins/path_3d_editor_plugin.cpp index 3ff97ca63d99..22baf34069d1 100644 --- a/editor/plugins/path_3d_editor_plugin.cpp +++ b/editor/plugins/path_3d_editor_plugin.cpp @@ -919,6 +919,7 @@ Path3DEditorPlugin::Path3DEditorPlugin() { curve_edit->set_toggle_mode(true); curve_edit->set_focus_mode(Control::FOCUS_NONE); curve_edit->set_tooltip_text(TTR("Select Points") + "\n" + TTR("Shift+Click: Select multiple Points") + "\n" + keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Click: Add Point") + "\n" + TTR("Right Click: Delete Point")); + curve_edit->set_accessibility_name(TTRC("Select Points")); toolbar->add_child(curve_edit); curve_edit->connect(SceneStringName(pressed), callable_mp(this, &Path3DEditorPlugin::_mode_changed).bind(MODE_EDIT)); @@ -927,6 +928,7 @@ Path3DEditorPlugin::Path3DEditorPlugin() { curve_edit_curve->set_toggle_mode(true); curve_edit_curve->set_focus_mode(Control::FOCUS_NONE); curve_edit_curve->set_tooltip_text(TTR("Select Control Points") + "\n" + TTR("Shift+Click: Drag out Control Points")); + curve_edit_curve->set_accessibility_name(TTRC("Select Control Points")); toolbar->add_child(curve_edit_curve); curve_edit_curve->connect(SceneStringName(pressed), callable_mp(this, &Path3DEditorPlugin::_mode_changed).bind(MODE_EDIT_CURVE)); @@ -935,6 +937,7 @@ Path3DEditorPlugin::Path3DEditorPlugin() { curve_edit_tilt->set_toggle_mode(true); curve_edit_tilt->set_focus_mode(Control::FOCUS_NONE); curve_edit_tilt->set_tooltip_text(TTR("Select Tilt Handles")); + curve_edit_tilt->set_accessibility_name(TTRC("Select Tilt Handles")); toolbar->add_child(curve_edit_tilt); curve_edit_tilt->connect(SceneStringName(pressed), callable_mp(this, &Path3DEditorPlugin::_mode_changed).bind(MODE_EDIT_TILT)); @@ -943,6 +946,7 @@ Path3DEditorPlugin::Path3DEditorPlugin() { curve_create->set_toggle_mode(true); curve_create->set_focus_mode(Control::FOCUS_NONE); curve_create->set_tooltip_text(TTR("Add Point (in empty space)") + "\n" + TTR("Split Segment (in curve)")); + curve_create->set_accessibility_name(TTRC("Add Point")); toolbar->add_child(curve_create); curve_create->connect(SceneStringName(pressed), callable_mp(this, &Path3DEditorPlugin::_mode_changed).bind(MODE_CREATE)); @@ -951,6 +955,7 @@ Path3DEditorPlugin::Path3DEditorPlugin() { curve_del->set_toggle_mode(true); curve_del->set_focus_mode(Control::FOCUS_NONE); curve_del->set_tooltip_text(TTR("Delete Point")); + curve_del->set_accessibility_name(TTRC("Delete Point")); toolbar->add_child(curve_del); curve_del->connect(SceneStringName(pressed), callable_mp(this, &Path3DEditorPlugin::_mode_changed).bind(MODE_DELETE)); @@ -958,6 +963,7 @@ Path3DEditorPlugin::Path3DEditorPlugin() { curve_closed->set_theme_type_variation(SceneStringName(FlatButton)); curve_closed->set_focus_mode(Control::FOCUS_NONE); curve_closed->set_tooltip_text(TTR("Close Curve")); + curve_closed->set_accessibility_name(TTRC("Close Curve")); toolbar->add_child(curve_closed); curve_closed->connect(SceneStringName(pressed), callable_mp(this, &Path3DEditorPlugin::_toggle_closed_curve)); @@ -965,6 +971,7 @@ Path3DEditorPlugin::Path3DEditorPlugin() { curve_clear_points->set_theme_type_variation(SceneStringName(FlatButton)); curve_clear_points->set_focus_mode(Control::FOCUS_NONE); curve_clear_points->set_tooltip_text(TTR("Clear Points")); + curve_clear_points->set_accessibility_name(TTRC("Clear Points")); curve_clear_points->connect(SceneStringName(pressed), callable_mp(this, &Path3DEditorPlugin::_confirm_clear_points)); toolbar->add_child(curve_clear_points); diff --git a/editor/plugins/plugin_config_dialog.cpp b/editor/plugins/plugin_config_dialog.cpp index d70aa30bfbc2..2e7f75346921 100644 --- a/editor/plugins/plugin_config_dialog.cpp +++ b/editor/plugins/plugin_config_dialog.cpp @@ -224,6 +224,7 @@ PluginConfigDialog::PluginConfigDialog() { name_edit = memnew(LineEdit); name_edit->set_placeholder("MyPlugin"); name_edit->set_tooltip_text(TTR("Required. This name will be displayed in the list of plugins.")); + name_edit->set_accessibility_name(TTRC("Name")); name_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid->add_child(name_edit); @@ -237,6 +238,7 @@ PluginConfigDialog::PluginConfigDialog() { subfolder_edit = memnew(LineEdit); subfolder_edit->set_placeholder("\"my_plugin\" -> res://addons/my_plugin"); subfolder_edit->set_tooltip_text(TTR("Optional. The folder name should generally use `snake_case` naming (avoid spaces and special characters).\nIf left empty, the folder will be named after the plugin name converted to `snake_case`.")); + subfolder_edit->set_accessibility_name(TTRC("Subfolder")); subfolder_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid->add_child(subfolder_edit); plugin_edit_hidden_controls.push_back(subfolder_edit); @@ -249,6 +251,7 @@ PluginConfigDialog::PluginConfigDialog() { desc_edit = memnew(TextEdit); desc_edit->set_tooltip_text(TTR("Optional. This description should be kept relatively short (up to 5 lines).\nIt will display when hovering the plugin in the list of plugins.")); + desc_edit->set_accessibility_name(TTRC("Description")); desc_edit->set_custom_minimum_size(Size2(400, 80) * EDSCALE); desc_edit->set_line_wrapping_mode(TextEdit::LineWrappingMode::LINE_WRAPPING_BOUNDARY); desc_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); @@ -263,6 +266,7 @@ PluginConfigDialog::PluginConfigDialog() { author_edit = memnew(LineEdit); author_edit->set_placeholder("Godette"); + author_edit->set_accessibility_name(TTRC("Author")); author_edit->set_tooltip_text(TTR("Optional. The author's username, full name, or organization name.")); author_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid->add_child(author_edit); @@ -276,6 +280,7 @@ PluginConfigDialog::PluginConfigDialog() { version_edit = memnew(LineEdit); version_edit->set_tooltip_text(TTR("Optional. A human-readable version identifier used for informational purposes only.")); version_edit->set_placeholder("1.0"); + version_edit->set_accessibility_name(TTRC("Version")); version_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid->add_child(version_edit); @@ -287,6 +292,7 @@ PluginConfigDialog::PluginConfigDialog() { script_option_edit = memnew(OptionButton); script_option_edit->set_tooltip_text(TTR("Required. The scripting language to use for the script.\nNote that a plugin may use several languages at once by adding more scripts to the plugin.")); + script_option_edit->set_accessibility_name(TTRC("Scripting Language")); int default_lang = 0; for (int i = 0; i < ScriptServer::get_language_count(); i++) { ScriptLanguage *lang = ScriptServer::get_language(i); @@ -307,6 +313,7 @@ PluginConfigDialog::PluginConfigDialog() { script_edit = memnew(LineEdit); script_edit->set_tooltip_text(TTR("Optional. The name of the script file. If left empty, will default to the subfolder name.")); script_edit->set_placeholder("\"plugin.gd\" -> res://addons/my_plugin/plugin.gd"); + script_edit->set_accessibility_name(TTRC("Script")); script_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); grid->add_child(script_edit); @@ -319,6 +326,7 @@ PluginConfigDialog::PluginConfigDialog() { active_edit = memnew(CheckBox); active_edit->set_pressed(true); + active_edit->set_accessibility_name(TTRC("Active")); grid->add_child(active_edit); plugin_edit_hidden_controls.push_back(active_edit); diff --git a/editor/plugins/polygon_2d_editor_plugin.cpp b/editor/plugins/polygon_2d_editor_plugin.cpp index dbfded66bc65..9848a51ece52 100644 --- a/editor/plugins/polygon_2d_editor_plugin.cpp +++ b/editor/plugins/polygon_2d_editor_plugin.cpp @@ -1319,6 +1319,18 @@ Polygon2DEditor::Polygon2DEditor() { action_buttons[ACTION_PAINT_WEIGHT]->set_tooltip_text(TTR("Paint weights with specified intensity.")); action_buttons[ACTION_CLEAR_WEIGHT]->set_tooltip_text(TTR("Unpaint weights with specified intensity.")); + action_buttons[ACTION_CREATE]->set_accessibility_name(TTRC("Create Polygon")); + action_buttons[ACTION_CREATE_INTERNAL]->set_accessibility_name(TTRC("Create Internal Vertex")); + action_buttons[ACTION_REMOVE_INTERNAL]->set_accessibility_name(TTRC("Remove Internal Vertex")); + action_buttons[ACTION_EDIT_POINT]->set_accessibility_name(TTRC("Move Points")); + action_buttons[ACTION_MOVE]->set_accessibility_name(TTRC("Move Polygon")); + action_buttons[ACTION_ROTATE]->set_accessibility_name(TTRC("Rotate Polygon")); + action_buttons[ACTION_SCALE]->set_accessibility_name(TTRC("Scale Polygon")); + action_buttons[ACTION_ADD_POLYGON]->set_accessibility_name(TTRC("Create Custom Polygon")); + action_buttons[ACTION_REMOVE_POLYGON]->set_accessibility_name(TTRC("Remove Custom Polygon")); + action_buttons[ACTION_PAINT_WEIGHT]->set_accessibility_name(TTRC("Paint Weights")); + action_buttons[ACTION_CLEAR_WEIGHT]->set_accessibility_name(TTRC("Unpaint Weights")); + bone_paint_strength = memnew(HSlider); toolbar->add_child(bone_paint_strength); bone_paint_strength->set_custom_minimum_size(Size2(75 * EDSCALE, 0)); @@ -1327,6 +1339,7 @@ Polygon2DEditor::Polygon2DEditor() { bone_paint_strength->set_max(1); bone_paint_strength->set_step(0.01); bone_paint_strength->set_value(0.5); + bone_paint_strength->set_accessibility_name(TTRC("Strength")); bone_paint_radius_label = memnew(Label(TTR("Radius:"))); toolbar->add_child(bone_paint_radius_label); @@ -1337,6 +1350,7 @@ Polygon2DEditor::Polygon2DEditor() { bone_paint_radius->set_max(100); bone_paint_radius->set_step(1); bone_paint_radius->set_value(32); + bone_paint_radius->set_accessibility_name(TTRC("Radius")); HSplitContainer *uv_main_hsc = memnew(HSplitContainer); polygon_edit->add_child(uv_main_hsc); @@ -1407,6 +1421,7 @@ Polygon2DEditor::Polygon2DEditor() { sb_off_x->set_value(snap_offset.x); sb_off_x->set_suffix("px"); sb_off_x->connect(SceneStringName(value_changed), callable_mp(this, &Polygon2DEditor::_set_snap_off_x)); + sb_off_x->set_accessibility_name(TTRC("Grid Offset X")); grid_settings_vb->add_margin_child(TTR("Grid Offset X:"), sb_off_x); SpinBox *sb_off_y = memnew(SpinBox); @@ -1416,6 +1431,7 @@ Polygon2DEditor::Polygon2DEditor() { sb_off_y->set_value(snap_offset.y); sb_off_y->set_suffix("px"); sb_off_y->connect(SceneStringName(value_changed), callable_mp(this, &Polygon2DEditor::_set_snap_off_y)); + sb_off_y->set_accessibility_name(TTRC("Grid Offset Y")); grid_settings_vb->add_margin_child(TTR("Grid Offset Y:"), sb_off_y); SpinBox *sb_step_x = memnew(SpinBox); @@ -1425,6 +1441,7 @@ Polygon2DEditor::Polygon2DEditor() { sb_step_x->set_value(snap_step.x); sb_step_x->set_suffix("px"); sb_step_x->connect(SceneStringName(value_changed), callable_mp(this, &Polygon2DEditor::_set_snap_step_x)); + sb_step_x->set_accessibility_name(TTRC("Grid Step X")); grid_settings_vb->add_margin_child(TTR("Grid Step X:"), sb_step_x); SpinBox *sb_step_y = memnew(SpinBox); @@ -1434,6 +1451,7 @@ Polygon2DEditor::Polygon2DEditor() { sb_step_y->set_value(snap_step.y); sb_step_y->set_suffix("px"); sb_step_y->connect(SceneStringName(value_changed), callable_mp(this, &Polygon2DEditor::_set_snap_step_y)); + sb_step_y->set_accessibility_name(TTRC("Grid Step Y")); grid_settings_vb->add_margin_child(TTR("Grid Step Y:"), sb_step_y); zoom_widget = memnew(EditorZoomWidget); diff --git a/editor/plugins/polygon_3d_editor_plugin.cpp b/editor/plugins/polygon_3d_editor_plugin.cpp index 49fca7f7ea7e..ee1bdeef8d6f 100644 --- a/editor/plugins/polygon_3d_editor_plugin.cpp +++ b/editor/plugins/polygon_3d_editor_plugin.cpp @@ -533,6 +533,7 @@ Polygon3DEditor::Polygon3DEditor() { button_create = memnew(Button); button_create->set_theme_type_variation(SceneStringName(FlatButton)); + button_create->set_accessibility_name(TTRC("Create Polygon")); button_create->set_tooltip_text(TTRC("Create Polygon")); add_child(button_create); button_create->connect(SceneStringName(pressed), callable_mp(this, &Polygon3DEditor::_menu_option).bind(MODE_CREATE)); @@ -540,6 +541,7 @@ Polygon3DEditor::Polygon3DEditor() { button_edit = memnew(Button); button_edit->set_theme_type_variation(SceneStringName(FlatButton)); + button_edit->set_accessibility_name(TTRC("Edit Polygon")); button_edit->set_tooltip_text(TTRC("Edit Polygon")); add_child(button_edit); button_edit->connect(SceneStringName(pressed), callable_mp(this, &Polygon3DEditor::_menu_option).bind(MODE_EDIT)); diff --git a/editor/plugins/resource_preloader_editor_plugin.cpp b/editor/plugins/resource_preloader_editor_plugin.cpp index 8f11c11a5c60..ec35b4f8b5ac 100644 --- a/editor/plugins/resource_preloader_editor_plugin.cpp +++ b/editor/plugins/resource_preloader_editor_plugin.cpp @@ -253,7 +253,7 @@ void ResourcePreloaderEditor::edit(ResourcePreloader *p_preloader) { } Variant ResourcePreloaderEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from) { - TreeItem *ti = tree->get_item_at_position(p_point); + TreeItem *ti = (p_point == Vector2(INFINITY, INFINITY)) ? tree->get_selected() : tree->get_item_at_position(p_point); if (!ti) { return Variant(); } @@ -356,6 +356,7 @@ ResourcePreloaderEditor::ResourcePreloaderEditor() { vbc->add_child(hbc); load = memnew(Button); + load->set_accessibility_name(TTRC("Load Resource")); load->set_tooltip_text(TTR("Load Resource")); hbc->add_child(load); diff --git a/editor/plugins/root_motion_editor_plugin.cpp b/editor/plugins/root_motion_editor_plugin.cpp index 9016c65008fd..f4bc2a81d6c0 100644 --- a/editor/plugins/root_motion_editor_plugin.cpp +++ b/editor/plugins/root_motion_editor_plugin.cpp @@ -196,12 +196,14 @@ EditorPropertyRootMotion::EditorPropertyRootMotion() { HBoxContainer *hbc = memnew(HBoxContainer); add_child(hbc); assign = memnew(Button); + assign->set_accessibility_name(TTRC("Assign")); assign->set_h_size_flags(SIZE_EXPAND_FILL); assign->set_clip_text(true); assign->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyRootMotion::_node_assign)); hbc->add_child(assign); clear = memnew(Button); + clear->set_accessibility_name(TTRC("Clear")); clear->connect(SceneStringName(pressed), callable_mp(this, &EditorPropertyRootMotion::_node_clear)); hbc->add_child(clear); diff --git a/editor/plugins/script_editor_plugin.cpp b/editor/plugins/script_editor_plugin.cpp index 01ff2aa905a0..ad0905ac888f 100644 --- a/editor/plugins/script_editor_plugin.cpp +++ b/editor/plugins/script_editor_plugin.cpp @@ -3272,7 +3272,15 @@ void ScriptEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Co if (se || eh) { int new_index = 0; if (script_list->get_item_count() > 0) { - new_index = script_list->get_item_metadata(script_list->get_item_at_position(p_point)); + int pos = 0; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (script_list->is_anything_selected()) { + pos = script_list->get_selected_items()[0]; + } + } else { + pos = script_list->get_item_at_position(p_point); + } + new_index = script_list->get_item_metadata(pos); } tab_container->move_child(node, new_index); tab_container->set_current_tab(new_index); @@ -3292,7 +3300,15 @@ void ScriptEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Co if (se || eh) { int new_index = 0; if (script_list->get_item_count() > 0) { - new_index = script_list->get_item_metadata(script_list->get_item_at_position(p_point)); + int pos = 0; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (script_list->is_anything_selected()) { + pos = script_list->get_selected_items()[0]; + } + } else { + pos = script_list->get_item_at_position(p_point); + } + new_index = script_list->get_item_metadata(pos); } tab_container->move_child(node, new_index); tab_container->set_current_tab(new_index); @@ -3305,7 +3321,15 @@ void ScriptEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Co int new_index = 0; if (script_list->get_item_count() > 0) { - new_index = script_list->get_item_metadata(script_list->get_item_at_position(p_point)); + int pos = 0; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (script_list->is_anything_selected()) { + pos = script_list->get_selected_items()[0]; + } + } else { + pos = script_list->get_item_at_position(p_point); + } + new_index = script_list->get_item_metadata(pos); } int num_tabs_before = tab_container->get_tab_count(); for (int i = 0; i < files.size(); i++) { @@ -4172,6 +4196,7 @@ ScriptEditor::ScriptEditor(WindowWrapper *p_wrapper) { filter_scripts = memnew(LineEdit); filter_scripts->set_placeholder(TTR("Filter Scripts")); + filter_scripts->set_accessibility_name(TTRC("Filter Scripts")); filter_scripts->set_clear_button_enabled(true); filter_scripts->connect(SceneStringName(text_changed), callable_mp(this, &ScriptEditor::_filter_scripts_text_changed)); scripts_vbox->add_child(filter_scripts); @@ -4211,6 +4236,7 @@ ScriptEditor::ScriptEditor(WindowWrapper *p_wrapper) { members_overview_alphabeta_sort_button = memnew(Button); members_overview_alphabeta_sort_button->set_flat(true); + members_overview_alphabeta_sort_button->set_accessibility_name(TTRC("Alphabetical Sorting")); members_overview_alphabeta_sort_button->set_tooltip_text(TTR("Toggle alphabetical sorting of the method list.")); members_overview_alphabeta_sort_button->set_toggle_mode(true); members_overview_alphabeta_sort_button->set_pressed(EDITOR_GET("text_editor/script_list/sort_members_outline_alphabetically")); @@ -4220,6 +4246,7 @@ ScriptEditor::ScriptEditor(WindowWrapper *p_wrapper) { filter_methods = memnew(LineEdit); filter_methods->set_placeholder(TTR("Filter Methods")); + filter_methods->set_accessibility_name(TTRC("Filter Methods")); filter_methods->set_clear_button_enabled(true); filter_methods->connect(SceneStringName(text_changed), callable_mp(this, &ScriptEditor::_filter_methods_text_changed)); overview_vbox->add_child(filter_methods); @@ -4366,6 +4393,7 @@ ScriptEditor::ScriptEditor(WindowWrapper *p_wrapper) { menu_hb->add_spacer(); site_search = memnew(Button); + site_search->set_accessibility_name(TTRC("Site Search")); site_search->set_flat(true); site_search->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditor::_menu_option).bind(SEARCH_WEBSITE)); menu_hb->add_child(site_search); @@ -4380,6 +4408,7 @@ ScriptEditor::ScriptEditor(WindowWrapper *p_wrapper) { menu_hb->add_child(memnew(VSeparator)); script_back = memnew(Button); + script_back->set_accessibility_name(TTRC("Previous")); script_back->set_flat(true); script_back->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditor::_history_back)); menu_hb->add_child(script_back); @@ -4387,6 +4416,7 @@ ScriptEditor::ScriptEditor(WindowWrapper *p_wrapper) { script_back->set_tooltip_text(TTR("Go to previous edited document.")); script_forward = memnew(Button); + script_forward->set_accessibility_name(TTRC("Next")); script_forward->set_flat(true); script_forward->connect(SceneStringName(pressed), callable_mp(this, &ScriptEditor::_history_forward)); menu_hb->add_child(script_forward); diff --git a/editor/plugins/script_text_editor.cpp b/editor/plugins/script_text_editor.cpp index 72466f915a04..3f1979eb7f57 100644 --- a/editor/plugins/script_text_editor.cpp +++ b/editor/plugins/script_text_editor.cpp @@ -1958,7 +1958,7 @@ void ScriptTextEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data Dictionary d = p_data; CodeEdit *te = code_editor->get_text_editor(); - Point2i pos = te->get_line_column_at_pos(p_point); + Point2i pos = (p_point == Vector2(INFINITY, INFINITY)) ? Point2i(te->get_caret_line(0), te->get_caret_column(0)) : te->get_line_column_at_pos(p_point); int drop_at_line = pos.y; int drop_at_column = pos.x; int selection_index = te->get_selection_at_line_column(drop_at_line, drop_at_column); diff --git a/editor/plugins/shader_editor_plugin.cpp b/editor/plugins/shader_editor_plugin.cpp index 71917fde0872..e88985ac3431 100644 --- a/editor/plugins/shader_editor_plugin.cpp +++ b/editor/plugins/shader_editor_plugin.cpp @@ -641,7 +641,14 @@ Variant ShaderEditorPlugin::get_drag_data_fw(const Point2 &p_point, Control *p_f return Variant(); } - int idx = shader_list->get_item_at_position(p_point); + int idx = 0; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (shader_list->is_anything_selected()) { + idx = shader_list->get_selected_items()[0]; + } + } else { + idx = shader_list->get_item_at_position(p_point); + } if (idx < 0) { return Variant(); } @@ -718,7 +725,14 @@ void ShaderEditorPlugin::drop_data_fw(const Point2 &p_point, const Variant &p_da if (String(d["type"]) == "shader_list_element") { int idx = d["shader_list_element"]; - int new_idx = shader_list->get_item_at_position(p_point); + int new_idx = 0; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (shader_list->is_anything_selected()) { + new_idx = shader_list->get_selected_items()[0]; + } + } else { + new_idx = shader_list->get_item_at_position(p_point); + } _move_shader_tab(idx, new_idx); return; } diff --git a/editor/plugins/skeleton_3d_editor_plugin.cpp b/editor/plugins/skeleton_3d_editor_plugin.cpp index 6b701251ad55..496214e2f278 100644 --- a/editor/plugins/skeleton_3d_editor_plugin.cpp +++ b/editor/plugins/skeleton_3d_editor_plugin.cpp @@ -701,7 +701,7 @@ Variant Skeleton3DEditor::get_drag_data_fw(const Point2 &p_point, Control *p_fro } bool Skeleton3DEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const { - TreeItem *target = joint_tree->get_item_at_position(p_point); + TreeItem *target = (p_point == Vector2(INFINITY, INFINITY)) ? joint_tree->get_selected() : joint_tree->get_item_at_position(p_point); if (!target) { return false; } @@ -729,7 +729,7 @@ void Skeleton3DEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data return; } - TreeItem *target = joint_tree->get_item_at_position(p_point); + TreeItem *target = (p_point == Vector2(INFINITY, INFINITY)) ? joint_tree->get_selected() : joint_tree->get_item_at_position(p_point); TreeItem *selected = Object::cast_to(Dictionary(p_data)["node"]); const BoneId target_boneidx = String(target->get_metadata(0)).get_slicec('/', 1).to_int(); @@ -1026,6 +1026,7 @@ void Skeleton3DEditor::create_editors() { edit_mode_button->set_toggle_mode(true); edit_mode_button->set_focus_mode(FOCUS_NONE); edit_mode_button->set_tooltip_text(TTR("Edit Mode\nShow buttons on joints.")); + edit_mode_button->set_accessibility_name(TTRC("Edit Mode")); edit_mode_button->connect(SceneStringName(toggled), callable_mp(this, &Skeleton3DEditor::edit_mode_toggled)); edit_mode = false; @@ -1047,6 +1048,7 @@ void Skeleton3DEditor::create_editors() { key_loc_button->set_pressed(false); key_loc_button->set_focus_mode(FOCUS_NONE); key_loc_button->set_tooltip_text(TTR("Translation mask for inserting keys.")); + key_loc_button->set_accessibility_name(TTRC("Translation Mask")); animation_hb->add_child(key_loc_button); key_rot_button = memnew(Button); @@ -1055,6 +1057,7 @@ void Skeleton3DEditor::create_editors() { key_rot_button->set_pressed(true); key_rot_button->set_focus_mode(FOCUS_NONE); key_rot_button->set_tooltip_text(TTR("Rotation mask for inserting keys.")); + key_rot_button->set_accessibility_name(TTRC("Rotation Mask")); animation_hb->add_child(key_rot_button); key_scale_button = memnew(Button); @@ -1063,6 +1066,7 @@ void Skeleton3DEditor::create_editors() { key_scale_button->set_pressed(false); key_scale_button->set_focus_mode(FOCUS_NONE); key_scale_button->set_tooltip_text(TTR("Scale mask for inserting keys.")); + key_scale_button->set_accessibility_name(TTRC("Scale Mask")); animation_hb->add_child(key_scale_button); key_insert_button = memnew(Button); @@ -1071,6 +1075,7 @@ void Skeleton3DEditor::create_editors() { key_insert_button->connect(SceneStringName(pressed), callable_mp(this, &Skeleton3DEditor::insert_keys).bind(false)); key_insert_button->set_tooltip_text(TTRC("Insert key (based on mask) for bones with an existing track.")); key_insert_button->set_shortcut(ED_SHORTCUT("skeleton_3d_editor/insert_key_to_existing_tracks", TTRC("Insert Key (Existing Tracks)"), Key::INSERT)); + key_insert_button->set_accessibility_name(TTRC("Insert Key")); animation_hb->add_child(key_insert_button); key_insert_all_button = memnew(Button); @@ -1078,6 +1083,7 @@ void Skeleton3DEditor::create_editors() { key_insert_all_button->set_focus_mode(FOCUS_NONE); key_insert_all_button->connect(SceneStringName(pressed), callable_mp(this, &Skeleton3DEditor::insert_keys).bind(true)); key_insert_all_button->set_tooltip_text(TTRC("Insert key (based on mask) for all bones.")); + key_insert_all_button->set_accessibility_name(TTRC("Insert Key for All Bones")); key_insert_all_button->set_shortcut(ED_SHORTCUT("skeleton_3d_editor/insert_key_of_all_bones", TTRC("Insert Key (All Bones)"), KeyModifierMask::CMD_OR_CTRL + Key::INSERT)); animation_hb->add_child(key_insert_all_button); diff --git a/editor/plugins/sprite_2d_editor_plugin.cpp b/editor/plugins/sprite_2d_editor_plugin.cpp index 0c9e7520982d..c1b966b135bf 100644 --- a/editor/plugins/sprite_2d_editor_plugin.cpp +++ b/editor/plugins/sprite_2d_editor_plugin.cpp @@ -633,6 +633,7 @@ Sprite2DEditor::Sprite2DEditor() { simplification->set_max(10.00); simplification->set_step(0.01); simplification->set_value(2); + simplification->set_accessibility_name(TTRC("Simplification")); hb->add_child(simplification); hb->add_spacer(); hb->add_child(memnew(Label(TTR("Shrink (Pixels):")))); @@ -641,6 +642,7 @@ Sprite2DEditor::Sprite2DEditor() { shrink_pixels->set_max(10); shrink_pixels->set_step(1); shrink_pixels->set_value(0); + shrink_pixels->set_accessibility_name(TTRC("Shrink")); hb->add_child(shrink_pixels); hb->add_spacer(); hb->add_child(memnew(Label(TTR("Grow (Pixels):")))); @@ -649,6 +651,7 @@ Sprite2DEditor::Sprite2DEditor() { grow_pixels->set_max(10); grow_pixels->set_step(1); grow_pixels->set_value(2); + grow_pixels->set_accessibility_name(TTRC("Grow")); hb->add_child(grow_pixels); hb->add_spacer(); update_preview = memnew(Button); diff --git a/editor/plugins/sprite_frames_editor_plugin.cpp b/editor/plugins/sprite_frames_editor_plugin.cpp index 1ed85b856452..c3f961935753 100644 --- a/editor/plugins/sprite_frames_editor_plugin.cpp +++ b/editor/plugins/sprite_frames_editor_plugin.cpp @@ -1653,7 +1653,14 @@ Variant SpriteFramesEditor::get_drag_data_fw(const Point2 &p_point, Control *p_f return false; } - int idx = frame_list->get_item_at_position(p_point, true); + int idx = -1; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (frame_list->is_anything_selected()) { + idx = frame_list->get_selected_items()[0]; + } + } else { + idx = frame_list->get_item_at_position(p_point, true); + } if (idx < 0 || idx >= frames->get_frame_count(edited_anim)) { return Variant(); @@ -1728,7 +1735,14 @@ void SpriteFramesEditor::drop_data_fw(const Point2 &p_point, const Variant &p_da return; } - int at_pos = frame_list->get_item_at_position(p_point, true); + int at_pos = -1; + if (p_point == Vector2(INFINITY, INFINITY)) { + if (frame_list->is_anything_selected()) { + at_pos = frame_list->get_selected_items()[0]; + } + } else { + at_pos = frame_list->get_item_at_position(p_point, true); + } if (String(d["type"]) == "resource" && d.has("resource")) { Ref r = d["resource"]; @@ -1946,16 +1960,19 @@ SpriteFramesEditor::SpriteFramesEditor() { add_anim = memnew(Button); add_anim->set_theme_type_variation(SceneStringName(FlatButton)); + add_anim->set_accessibility_name(TTRC("Add Animation")); hbc_animlist->add_child(add_anim); add_anim->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_animation_add)); duplicate_anim = memnew(Button); duplicate_anim->set_theme_type_variation(SceneStringName(FlatButton)); + duplicate_anim->set_accessibility_name(TTRC("Duplicate Animation")); hbc_animlist->add_child(duplicate_anim); duplicate_anim->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_animation_duplicate)); delete_anim = memnew(Button); delete_anim->set_theme_type_variation(SceneStringName(FlatButton)); + delete_anim->set_accessibility_name(TTRC("Delete Animation")); hbc_animlist->add_child(delete_anim); delete_anim->set_disabled(true); delete_anim->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_animation_remove)); @@ -1967,6 +1984,7 @@ SpriteFramesEditor::SpriteFramesEditor() { autoplay = memnew(Button); autoplay->set_theme_type_variation(SceneStringName(FlatButton)); + autoplay->set_accessibility_name(TTRC("Autoplay on Load")); autoplay->set_tooltip_text(TTR("Autoplay on Load")); autoplay_container->add_child(autoplay); @@ -1975,6 +1993,7 @@ SpriteFramesEditor::SpriteFramesEditor() { anim_loop = memnew(Button); anim_loop->set_toggle_mode(true); anim_loop->set_theme_type_variation(SceneStringName(FlatButton)); + anim_loop->set_accessibility_name(TTRC("Animation Looping")); anim_loop->set_tooltip_text(TTR("Animation Looping")); anim_loop->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_animation_loop_changed)); hbc_animlist->add_child(anim_loop); @@ -1986,6 +2005,7 @@ SpriteFramesEditor::SpriteFramesEditor() { anim_speed->set_step(0.01); anim_speed->set_custom_arrow_step(1); anim_speed->set_tooltip_text(TTR("Animation Speed")); + anim_speed->set_accessibility_name(TTRC("Animation Speed")); anim_speed->get_line_edit()->set_expand_to_text_length_enabled(true); anim_speed->get_line_edit()->connect(SceneStringName(resized), callable_mp(this, &SpriteFramesEditor::_animation_speed_resized)); anim_speed->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_animation_speed_changed)); @@ -1995,6 +2015,7 @@ SpriteFramesEditor::SpriteFramesEditor() { sub_vb->add_child(anim_search_box); anim_search_box->set_h_size_flags(SIZE_EXPAND_FILL); anim_search_box->set_placeholder(TTR("Filter Animations")); + anim_search_box->set_accessibility_name(TTRC("Filter Animations")); anim_search_box->set_clear_button_enabled(true); anim_search_box->connect(SceneStringName(text_changed), callable_mp(this, &SpriteFramesEditor::_animation_search_text_changed)); @@ -2042,26 +2063,31 @@ SpriteFramesEditor::SpriteFramesEditor() { play_bw_from = memnew(Button); play_bw_from->set_theme_type_variation(SceneStringName(FlatButton)); play_bw_from->set_tooltip_text(TTR("Play selected animation backwards from current pos. (A)")); + play_bw_from->set_accessibility_name(TTRC("Play Backwards")); playback_container->add_child(play_bw_from); play_bw = memnew(Button); play_bw->set_theme_type_variation(SceneStringName(FlatButton)); play_bw->set_tooltip_text(TTR("Play selected animation backwards from end. (Shift+A)")); + play_bw->set_accessibility_name(TTRC("Play Backwards from End")); playback_container->add_child(play_bw); stop = memnew(Button); stop->set_theme_type_variation(SceneStringName(FlatButton)); stop->set_tooltip_text(TTR("Pause/stop animation playback. (S)")); + stop->set_accessibility_name(TTRC("Pause/Stop")); playback_container->add_child(stop); play = memnew(Button); play->set_theme_type_variation(SceneStringName(FlatButton)); play->set_tooltip_text(TTR("Play selected animation from start. (Shift+D)")); + play->set_accessibility_name(TTRC("Play from Start")); playback_container->add_child(play); play_from = memnew(Button); play_from->set_theme_type_variation(SceneStringName(FlatButton)); play_from->set_tooltip_text(TTR("Play selected animation from current pos. (D)")); + play_from->set_accessibility_name(TTRC("Play")); playback_container->add_child(play_from); hfc->add_child(memnew(VSeparator)); @@ -2078,44 +2104,53 @@ SpriteFramesEditor::SpriteFramesEditor() { hfc->add_child(hbc_actions); load = memnew(Button); + load->set_accessibility_name(TTRC("Load")); load->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(load); load_sheet = memnew(Button); + load_sheet->set_accessibility_name(TTRC("Load Sheet")); load_sheet->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(load_sheet); hbc_actions->add_child(memnew(VSeparator)); copy = memnew(Button); + copy->set_accessibility_name(TTRC("Copy")); copy->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(copy); paste = memnew(Button); + paste->set_accessibility_name(TTRC("Paste")); paste->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(paste); hbc_actions->add_child(memnew(VSeparator)); empty_before = memnew(Button); + empty_before->set_accessibility_name(TTRC("Empty Before")); empty_before->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(empty_before); empty_after = memnew(Button); + empty_after->set_accessibility_name(TTRC("Empty After")); empty_after->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(empty_after); hbc_actions->add_child(memnew(VSeparator)); move_up = memnew(Button); + move_up->set_accessibility_name(TTRC("Move Up")); move_up->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(move_up); move_down = memnew(Button); + move_down->set_accessibility_name(TTRC("Move Down")); move_down->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(move_down); delete_frame = memnew(Button); + delete_frame->set_accessibility_name(TTRC("Delete Frame")); delete_frame->set_theme_type_variation(SceneStringName(FlatButton)); hbc_actions->add_child(delete_frame); @@ -2137,6 +2172,7 @@ SpriteFramesEditor::SpriteFramesEditor() { frame_duration->set_allow_lesser(false); frame_duration->set_allow_greater(true); frame_duration->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_frame_duration_changed)); + frame_duration->set_accessibility_name(TTRC("Frame Duration")); hbc_frame_duration->add_child(frame_duration); // Wide empty separation control. (like BoxContainer::add_spacer()) @@ -2152,18 +2188,21 @@ SpriteFramesEditor::SpriteFramesEditor() { zoom_out->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_zoom_out)); zoom_out->set_flat(true); zoom_out->set_tooltip_text(TTRC("Zoom Out")); + zoom_out->set_accessibility_name(TTRC("Zoom Out")); hbc_zoom->add_child(zoom_out); zoom_reset = memnew(Button); zoom_reset->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_zoom_reset)); zoom_reset->set_flat(true); zoom_reset->set_tooltip_text(TTRC("Zoom Reset")); + zoom_reset->set_accessibility_name(TTRC("Reset Zoom")); hbc_zoom->add_child(zoom_reset); zoom_in = memnew(Button); zoom_in->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_zoom_in)); zoom_in->set_flat(true); zoom_in->set_tooltip_text(TTRC("Zoom In")); + zoom_in->set_accessibility_name(TTRC("Zoom In")); hbc_zoom->add_child(zoom_in); file = memnew(EditorFileDialog); @@ -2286,6 +2325,7 @@ SpriteFramesEditor::SpriteFramesEditor() { toggle_settings_button->set_theme_type_variation(SceneStringName(FlatButton)); toggle_settings_button->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_toggle_show_settings)); toggle_settings_button->set_tooltip_text(TTR("Toggle Settings Panel")); + toggle_settings_button->set_accessibility_name(TTRC("Settings Panel")); split_sheet_menu_hb->add_child(toggle_settings_button); split_sheet_vb->add_child(split_sheet_menu_hb); @@ -2324,6 +2364,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_zoom_out->set_theme_type_variation(SceneStringName(FlatButton)); split_sheet_zoom_out->set_focus_mode(FOCUS_NONE); split_sheet_zoom_out->set_tooltip_text(TTR("Zoom Out")); + split_sheet_zoom_out->set_accessibility_name(TTRC("Zoom Out")); split_sheet_zoom_out->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_sheet_zoom_out)); split_sheet_zoom_hb->add_child(split_sheet_zoom_out); @@ -2331,6 +2372,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_zoom_reset->set_theme_type_variation(SceneStringName(FlatButton)); split_sheet_zoom_reset->set_focus_mode(FOCUS_NONE); split_sheet_zoom_reset->set_tooltip_text(TTR("Zoom Reset")); + split_sheet_zoom_reset->set_accessibility_name(TTRC("Reset Zoom")); split_sheet_zoom_reset->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_sheet_zoom_reset)); split_sheet_zoom_hb->add_child(split_sheet_zoom_reset); @@ -2338,6 +2380,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_zoom_in->set_theme_type_variation(SceneStringName(FlatButton)); split_sheet_zoom_in->set_focus_mode(FOCUS_NONE); split_sheet_zoom_in->set_tooltip_text(TTR("Zoom In")); + split_sheet_zoom_in->set_accessibility_name(TTRC("Zoom In")); split_sheet_zoom_in->connect(SceneStringName(pressed), callable_mp(this, &SpriteFramesEditor::_sheet_zoom_in)); split_sheet_zoom_hb->add_child(split_sheet_zoom_in); @@ -2357,6 +2400,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_h->set_max(128); split_sheet_h->set_step(1); split_sheet_h->set_select_all_on_focus(true); + split_sheet_h->set_accessibility_name(TTRC("Horizontal")); split_sheet_h_hb->add_child(split_sheet_h); split_sheet_h->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_FRAME_COUNT)); split_sheet_settings_vb->add_child(split_sheet_h_hb); @@ -2374,6 +2418,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_v->set_max(128); split_sheet_v->set_step(1); split_sheet_v->set_select_all_on_focus(true); + split_sheet_v->set_accessibility_name(TTRC("Vertical")); split_sheet_v_hb->add_child(split_sheet_v); split_sheet_v->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_FRAME_COUNT)); split_sheet_settings_vb->add_child(split_sheet_v_hb); @@ -2394,6 +2439,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_size_x->set_step(1); split_sheet_size_x->set_suffix("px"); split_sheet_size_x->set_select_all_on_focus(true); + split_sheet_size_x->set_accessibility_name(TTRC("X Size")); split_sheet_size_x->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_SIZE)); split_sheet_size_vb->add_child(split_sheet_size_x); split_sheet_size_y = memnew(SpinBox); @@ -2402,6 +2448,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_size_y->set_step(1); split_sheet_size_y->set_suffix("px"); split_sheet_size_y->set_select_all_on_focus(true); + split_sheet_size_y->set_accessibility_name(TTRC("Y Size")); split_sheet_size_y->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_SIZE)); split_sheet_size_vb->add_child(split_sheet_size_y); split_sheet_size_hb->add_child(split_sheet_size_vb); @@ -2422,6 +2469,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_sep_x->set_step(1); split_sheet_sep_x->set_suffix("px"); split_sheet_sep_x->set_select_all_on_focus(true); + split_sheet_sep_x->set_accessibility_name(TTRC("X Separation")); split_sheet_sep_x->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_USE_CURRENT)); split_sheet_sep_vb->add_child(split_sheet_sep_x); split_sheet_sep_y = memnew(SpinBox); @@ -2429,6 +2477,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_sep_y->set_step(1); split_sheet_sep_y->set_suffix("px"); split_sheet_sep_y->set_select_all_on_focus(true); + split_sheet_sep_y->set_accessibility_name(TTRC("Y Separation")); split_sheet_sep_y->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_USE_CURRENT)); split_sheet_sep_vb->add_child(split_sheet_sep_y); split_sheet_sep_hb->add_child(split_sheet_sep_vb); @@ -2449,6 +2498,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_offset_x->set_step(1); split_sheet_offset_x->set_suffix("px"); split_sheet_offset_x->set_select_all_on_focus(true); + split_sheet_offset_x->set_accessibility_name(TTRC("X Offset")); split_sheet_offset_x->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_USE_CURRENT)); split_sheet_offset_vb->add_child(split_sheet_offset_x); split_sheet_offset_y = memnew(SpinBox); @@ -2456,6 +2506,7 @@ SpriteFramesEditor::SpriteFramesEditor() { split_sheet_offset_y->set_step(1); split_sheet_offset_y->set_suffix("px"); split_sheet_offset_y->set_select_all_on_focus(true); + split_sheet_offset_y->set_accessibility_name(TTRC("Y Offset")); split_sheet_offset_y->connect(SceneStringName(value_changed), callable_mp(this, &SpriteFramesEditor::_sheet_spin_changed).bind(PARAM_USE_CURRENT)); split_sheet_offset_vb->add_child(split_sheet_offset_y); split_sheet_offset_hb->add_child(split_sheet_offset_vb); diff --git a/editor/plugins/style_box_editor_plugin.cpp b/editor/plugins/style_box_editor_plugin.cpp index 8098b9be70bb..b7ce74d838b7 100644 --- a/editor/plugins/style_box_editor_plugin.cpp +++ b/editor/plugins/style_box_editor_plugin.cpp @@ -113,6 +113,7 @@ StyleBoxPreview::StyleBoxPreview() { // This theme variation works better than the normal theme because there's no focus highlight. grid_preview->set_theme_type_variation("PreviewLightButton"); grid_preview->set_tooltip_text(TTRC("Toggle margins preview grid.")); + grid_preview->set_accessibility_name(TTRC("Margins Preview Grid")); grid_preview->set_toggle_mode(true); grid_preview->connect(SceneStringName(toggled), callable_mp(this, &StyleBoxPreview::_grid_preview_toggled)); grid_preview->set_pressed(grid_preview_enabled); diff --git a/editor/plugins/texture_region_editor_plugin.cpp b/editor/plugins/texture_region_editor_plugin.cpp index 980e739fc571..bcc55fbb2812 100644 --- a/editor/plugins/texture_region_editor_plugin.cpp +++ b/editor/plugins/texture_region_editor_plugin.cpp @@ -1154,6 +1154,7 @@ TextureRegionEditor::TextureRegionEditor() { snap_mode_button = memnew(OptionButton); hb_tools->add_child(snap_mode_button); + snap_mode_button->set_accessibility_name(TTRC("Snap Mode")); snap_mode_button->add_item(TTR("None"), 0); snap_mode_button->add_item(TTR("Pixel Snap"), 1); snap_mode_button->add_item(TTR("Grid Snap"), 2); @@ -1171,12 +1172,14 @@ TextureRegionEditor::TextureRegionEditor() { sb_off_x->set_step(1); sb_off_x->set_suffix("px"); sb_off_x->connect(SceneStringName(value_changed), callable_mp(this, &TextureRegionEditor::_set_snap_off_x)); + sb_off_x->set_accessibility_name(TTRC("Offset X")); hb_grid->add_child(sb_off_x); sb_off_y = memnew(SpinBox); sb_off_y->set_step(1); sb_off_y->set_suffix("px"); sb_off_y->connect(SceneStringName(value_changed), callable_mp(this, &TextureRegionEditor::_set_snap_off_y)); + sb_off_y->set_accessibility_name(TTRC("Offset Y")); hb_grid->add_child(sb_off_y); hb_grid->add_child(memnew(VSeparator)); @@ -1187,6 +1190,7 @@ TextureRegionEditor::TextureRegionEditor() { sb_step_x->set_step(1); sb_step_x->set_suffix("px"); sb_step_x->connect(SceneStringName(value_changed), callable_mp(this, &TextureRegionEditor::_set_snap_step_x)); + sb_step_x->set_accessibility_name(TTRC("Step X")); hb_grid->add_child(sb_step_x); sb_step_y = memnew(SpinBox); @@ -1194,6 +1198,7 @@ TextureRegionEditor::TextureRegionEditor() { sb_step_y->set_step(1); sb_step_y->set_suffix("px"); sb_step_y->connect(SceneStringName(value_changed), callable_mp(this, &TextureRegionEditor::_set_snap_step_y)); + sb_step_y->set_accessibility_name(TTRC("Step Y")); hb_grid->add_child(sb_step_y); hb_grid->add_child(memnew(VSeparator)); @@ -1204,6 +1209,7 @@ TextureRegionEditor::TextureRegionEditor() { sb_sep_x->set_step(1); sb_sep_x->set_suffix("px"); sb_sep_x->connect(SceneStringName(value_changed), callable_mp(this, &TextureRegionEditor::_set_snap_sep_x)); + sb_sep_x->set_accessibility_name(TTRC("Separation X")); hb_grid->add_child(sb_sep_x); sb_sep_y = memnew(SpinBox); @@ -1211,6 +1217,7 @@ TextureRegionEditor::TextureRegionEditor() { sb_sep_y->set_step(1); sb_sep_y->set_suffix("px"); sb_sep_y->connect(SceneStringName(value_changed), callable_mp(this, &TextureRegionEditor::_set_snap_sep_y)); + sb_sep_y->set_accessibility_name(TTRC("Separation Y")); hb_grid->add_child(sb_sep_y); hb_grid->hide(); @@ -1249,18 +1256,21 @@ TextureRegionEditor::TextureRegionEditor() { zoom_out = memnew(Button); zoom_out->set_flat(true); zoom_out->set_tooltip_text(TTR("Zoom Out")); + zoom_out->set_accessibility_name(TTRC("Zoom Out")); zoom_out->connect(SceneStringName(pressed), callable_mp(this, &TextureRegionEditor::_zoom_out)); zoom_hb->add_child(zoom_out); zoom_reset = memnew(Button); zoom_reset->set_flat(true); zoom_reset->set_tooltip_text(TTR("Zoom Reset")); + zoom_reset->set_accessibility_name(TTRC("Reset Zoom")); zoom_reset->connect(SceneStringName(pressed), callable_mp(this, &TextureRegionEditor::_zoom_reset)); zoom_hb->add_child(zoom_reset); zoom_in = memnew(Button); zoom_in->set_flat(true); zoom_in->set_tooltip_text(TTR("Zoom In")); + zoom_in->set_accessibility_name(TTRC("Zoom In")); zoom_in->connect(SceneStringName(pressed), callable_mp(this, &TextureRegionEditor::_zoom_in)); zoom_hb->add_child(zoom_in); diff --git a/editor/plugins/theme_editor_plugin.cpp b/editor/plugins/theme_editor_plugin.cpp index f2e092390d50..690571cd49f0 100644 --- a/editor/plugins/theme_editor_plugin.cpp +++ b/editor/plugins/theme_editor_plugin.cpp @@ -1957,6 +1957,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_add_color = memnew(Button); edit_items_add_color->set_tooltip_text(TTR("Add Color Item")); + edit_items_add_color->set_accessibility_name(TTRC("Add Color Item")); edit_items_add_color->set_flat(true); edit_items_add_color->set_disabled(true); edit_items_toolbar->add_child(edit_items_add_color); @@ -1964,6 +1965,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_add_constant = memnew(Button); edit_items_add_constant->set_tooltip_text(TTR("Add Constant Item")); + edit_items_add_constant->set_accessibility_name(TTRC("Add Constant Item")); edit_items_add_constant->set_flat(true); edit_items_add_constant->set_disabled(true); edit_items_toolbar->add_child(edit_items_add_constant); @@ -1971,6 +1973,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_add_font = memnew(Button); edit_items_add_font->set_tooltip_text(TTR("Add Font Item")); + edit_items_add_font->set_accessibility_name(TTRC("Add Font Item")); edit_items_add_font->set_flat(true); edit_items_add_font->set_disabled(true); edit_items_toolbar->add_child(edit_items_add_font); @@ -1978,6 +1981,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_add_font_size = memnew(Button); edit_items_add_font_size->set_tooltip_text(TTR("Add Font Size Item")); + edit_items_add_font_size->set_accessibility_name(TTRC("Add Font Size Item")); edit_items_add_font_size->set_flat(true); edit_items_add_font_size->set_disabled(true); edit_items_toolbar->add_child(edit_items_add_font_size); @@ -1985,6 +1989,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_add_icon = memnew(Button); edit_items_add_icon->set_tooltip_text(TTR("Add Icon Item")); + edit_items_add_icon->set_accessibility_name(TTRC("Add Icon Item")); edit_items_add_icon->set_flat(true); edit_items_add_icon->set_disabled(true); edit_items_toolbar->add_child(edit_items_add_icon); @@ -1992,6 +1997,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_add_stylebox = memnew(Button); edit_items_add_stylebox->set_tooltip_text(TTR("Add StyleBox Item")); + edit_items_add_stylebox->set_accessibility_name(TTRC("Add StyleBox Item")); edit_items_add_stylebox->set_flat(true); edit_items_add_stylebox->set_disabled(true); edit_items_toolbar->add_child(edit_items_add_stylebox); @@ -2005,6 +2011,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_remove_class = memnew(Button); edit_items_remove_class->set_tooltip_text(TTR("Remove Class Items")); + edit_items_remove_class->set_accessibility_name(TTRC("Remove Class Items")); edit_items_remove_class->set_flat(true); edit_items_remove_class->set_disabled(true); edit_items_toolbar->add_child(edit_items_remove_class); @@ -2012,6 +2019,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_remove_custom = memnew(Button); edit_items_remove_custom->set_tooltip_text(TTR("Remove Custom Items")); + edit_items_remove_custom->set_accessibility_name(TTRC("Remove Custom Items")); edit_items_remove_custom->set_flat(true); edit_items_remove_custom->set_disabled(true); edit_items_toolbar->add_child(edit_items_remove_custom); @@ -2019,6 +2027,7 @@ ThemeItemEditorDialog::ThemeItemEditorDialog(ThemeTypeEditor *p_theme_type_edito edit_items_remove_all = memnew(Button); edit_items_remove_all->set_tooltip_text(TTR("Remove All Items")); + edit_items_remove_all->set_accessibility_name(TTRC("Remove All Items")); edit_items_remove_all->set_flat(true); edit_items_remove_all->set_disabled(true); edit_items_toolbar->add_child(edit_items_remove_all); @@ -2473,6 +2482,7 @@ HBoxContainer *ThemeTypeEditor::_create_property_control(Theme::DataType p_data_ Button *item_rename_button = memnew(Button); item_rename_button->set_button_icon(get_editor_theme_icon(SNAME("Edit"))); item_rename_button->set_tooltip_text(TTR("Rename Item")); + item_rename_button->set_accessibility_name(TTRC("Rename Item")); item_rename_button->set_flat(true); item_name_container->add_child(item_rename_button); item_rename_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_item_rename_cbk).bind(p_data_type, p_item_name, item_name_container)); @@ -2480,6 +2490,7 @@ HBoxContainer *ThemeTypeEditor::_create_property_control(Theme::DataType p_data_ Button *item_remove_button = memnew(Button); item_remove_button->set_button_icon(get_editor_theme_icon(SNAME("Remove"))); item_remove_button->set_tooltip_text(TTR("Remove Item")); + item_remove_button->set_accessibility_name(TTRC("Remove Item")); item_remove_button->set_flat(true); item_name_container->add_child(item_remove_button); item_remove_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_item_remove_cbk).bind(p_data_type, p_item_name)); @@ -2487,6 +2498,7 @@ HBoxContainer *ThemeTypeEditor::_create_property_control(Theme::DataType p_data_ Button *item_rename_confirm_button = memnew(Button); item_rename_confirm_button->set_button_icon(get_editor_theme_icon(SNAME("ImportCheck"))); item_rename_confirm_button->set_tooltip_text(TTR("Confirm Item Rename")); + item_rename_confirm_button->set_accessibility_name(TTRC("Confirm Item Rename")); item_rename_confirm_button->set_flat(true); item_name_container->add_child(item_rename_confirm_button); item_rename_confirm_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_item_rename_confirmed).bind(p_data_type, p_item_name, item_name_container)); @@ -2495,6 +2507,7 @@ HBoxContainer *ThemeTypeEditor::_create_property_control(Theme::DataType p_data_ Button *item_rename_cancel_button = memnew(Button); item_rename_cancel_button->set_button_icon(get_editor_theme_icon(SNAME("ImportFail"))); item_rename_cancel_button->set_tooltip_text(TTR("Cancel Item Rename")); + item_rename_cancel_button->set_accessibility_name(TTRC("Cancel Item Rename")); item_rename_cancel_button->set_flat(true); item_name_container->add_child(item_rename_cancel_button); item_rename_cancel_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_item_rename_canceled).bind(p_data_type, p_item_name, item_name_container)); @@ -2505,6 +2518,7 @@ HBoxContainer *ThemeTypeEditor::_create_property_control(Theme::DataType p_data_ Button *item_override_button = memnew(Button); item_override_button->set_button_icon(get_editor_theme_icon(SNAME("Add"))); item_override_button->set_tooltip_text(TTR("Override Item")); + item_override_button->set_accessibility_name(TTRC("Override Item")); item_override_button->set_flat(true); item_name_container->add_child(item_override_button); item_override_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_item_override_cbk).bind(p_data_type, p_item_name)); @@ -2714,6 +2728,7 @@ void ThemeTypeEditor::_update_type_items() { pin_leader_button->set_pressed(true); pin_leader_button->set_button_icon(get_editor_theme_icon(SNAME("Pin"))); pin_leader_button->set_tooltip_text(TTR("Unpin this StyleBox as a main style.")); + pin_leader_button->set_accessibility_name(TTRC("Unpin StyleBox")); item_control->add_child(pin_leader_button); pin_leader_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_on_unpin_leader_button_pressed)); @@ -2757,6 +2772,7 @@ void ThemeTypeEditor::_update_type_items() { pin_leader_button->set_toggle_mode(true); pin_leader_button->set_button_icon(get_editor_theme_icon(SNAME("Pin"))); pin_leader_button->set_tooltip_text(TTR("Pin this StyleBox as a main style. Editing its properties will update the same properties in all other StyleBoxes of this type.")); + pin_leader_button->set_accessibility_name(TTRC("Pin StyleBox as a Main Style")); item_control->add_child(pin_leader_button); pin_leader_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_on_pin_leader_button_pressed).bind(item_editor, E.key)); } else { @@ -3443,11 +3459,13 @@ ThemeTypeEditor::ThemeTypeEditor() { theme_type_list->set_h_size_flags(SIZE_EXPAND_FILL); theme_type_list->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS); theme_type_list->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); + theme_type_list->set_accessibility_name(TTRC("Type")); type_list_hb->add_child(theme_type_list); theme_type_list->connect(SceneStringName(item_selected), callable_mp(this, &ThemeTypeEditor::_list_type_selected)); add_type_button = memnew(Button); add_type_button->set_tooltip_text(TTR("Add a type from a list of available types or create a new one.")); + add_type_button->set_accessibility_name(TTRC("Add Type")); type_list_hb->add_child(add_type_button); add_type_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_add_type_button_cbk)); @@ -3510,9 +3528,11 @@ ThemeTypeEditor::ThemeTypeEditor() { type_variation_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); type_variation_edit->connect(SceneStringName(text_changed), callable_mp(this, &ThemeTypeEditor::_type_variation_changed)); type_variation_edit->connect(SceneStringName(focus_exited), callable_mp(this, &ThemeTypeEditor::_update_type_items)); + type_variation_edit->set_accessibility_name(TTRC("Base Type")); type_variation_button = memnew(Button); type_variation_hb->add_child(type_variation_button); type_variation_button->set_tooltip_text(TTR("Select the variation base type from a list of available types.")); + type_variation_button->set_accessibility_name(TTRC("Select Base Type")); type_variation_button->connect(SceneStringName(pressed), callable_mp(this, &ThemeTypeEditor::_add_type_variation_cbk)); type_variation_locked = memnew(Label); diff --git a/editor/plugins/tiles/tile_atlas_view.cpp b/editor/plugins/tiles/tile_atlas_view.cpp index cca6ffe1cf38..1fb89945aa29 100644 --- a/editor/plugins/tiles/tile_atlas_view.cpp +++ b/editor/plugins/tiles/tile_atlas_view.cpp @@ -650,6 +650,7 @@ TileAtlasView::TileAtlasView() { button_center_view->set_flat(true); button_center_view->set_disabled(true); button_center_view->set_tooltip_text(TTR("Center View")); + button_center_view->set_accessibility_name(TTRC("Center View")); add_child(button_center_view); panner.instantiate(); diff --git a/editor/plugins/tiles/tile_data_editors.cpp b/editor/plugins/tiles/tile_data_editors.cpp index 5a28e6176522..653cb990ff2d 100644 --- a/editor/plugins/tiles/tile_data_editors.cpp +++ b/editor/plugins/tiles/tile_data_editors.cpp @@ -924,6 +924,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() { button_expand->set_toggle_mode(true); button_expand->set_pressed(false); button_expand->set_tooltip_text(TTR("Expand editor")); + button_expand->set_accessibility_name(TTRC("Expand editor")); button_expand->connect(SceneStringName(toggled), callable_mp(this, &GenericTilePolygonEditor::_toggle_expand)); toolbar->add_child(button_expand); @@ -935,6 +936,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() { button_create->set_button_group(tools_button_group); button_create->set_pressed(true); button_create->set_tooltip_text(TTR("Add polygon tool")); + button_create->set_accessibility_name(TTRC("Add Points")); toolbar->add_child(button_create); button_edit = memnew(Button); @@ -942,6 +944,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() { button_edit->set_toggle_mode(true); button_edit->set_button_group(tools_button_group); button_edit->set_tooltip_text(TTR("Edit points tool")); + button_edit->set_accessibility_name(TTRC("Edit Points")); toolbar->add_child(button_edit); button_delete = memnew(Button); @@ -949,10 +952,12 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() { button_delete->set_toggle_mode(true); button_delete->set_button_group(tools_button_group); button_delete->set_tooltip_text(TTR("Delete points tool")); + button_delete->set_accessibility_name(TTRC("Delete Points")); toolbar->add_child(button_delete); button_advanced_menu = memnew(MenuButton); button_advanced_menu->set_flat(false); + button_advanced_menu->set_accessibility_name(TTRC("Advanced")); button_advanced_menu->set_theme_type_variation("FlatMenuButton"); button_advanced_menu->set_toggle_mode(true); button_advanced_menu->get_popup()->add_item(TTR("Reset to default tile shape"), RESET_TO_DEFAULT_TILE, Key::F); @@ -971,6 +976,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() { button_pixel_snap = memnew(MenuButton); toolbar->add_child(button_pixel_snap); button_pixel_snap->set_flat(false); + button_pixel_snap->set_accessibility_name(TTRC("Snap")); button_pixel_snap->set_theme_type_variation("FlatMenuButton"); button_pixel_snap->set_tooltip_text(TTR("Toggle Grid Snap")); button_pixel_snap->get_popup()->add_item(TTR("Disable Snap"), SNAP_NONE); @@ -980,6 +986,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() { snap_subdivision = memnew(SpinBox); toolbar->add_child(snap_subdivision); + snap_subdivision->set_accessibility_name(TTRC("Subdivision")); snap_subdivision->get_line_edit()->add_theme_constant_override("minimum_character_width", 2); snap_subdivision->set_min(1); snap_subdivision->set_max(99); @@ -1019,6 +1026,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() { button_center_view->connect(SceneStringName(pressed), callable_mp(this, &GenericTilePolygonEditor::_center_view)); button_center_view->set_theme_type_variation(SceneStringName(FlatButton)); button_center_view->set_tooltip_text(TTR("Center View")); + button_center_view->set_accessibility_name(TTRC("Center View")); button_center_view->set_disabled(true); root->add_child(button_center_view); @@ -2880,6 +2888,7 @@ TileDataTerrainsEditor::TileDataTerrainsEditor() { picker_button->set_theme_type_variation(SceneStringName(FlatButton)); picker_button->set_toggle_mode(true); picker_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/picker")); + picker_button->set_accessibility_name(TTRC("Pick")); toolbar->add_child(picker_button); // Setup diff --git a/editor/plugins/tiles/tile_map_layer_editor.cpp b/editor/plugins/tiles/tile_map_layer_editor.cpp index bfcae65e1d98..4bd0ae138b77 100644 --- a/editor/plugins/tiles/tile_map_layer_editor.cpp +++ b/editor/plugins/tiles/tile_map_layer_editor.cpp @@ -2219,6 +2219,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { select_tool_button->set_button_group(tool_buttons_group); select_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/selection_tool", TTRC("Selection Tool"), Key::S)); select_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_update_toolbar)); + select_tool_button->set_accessibility_name(TTRC("Selection Tool")); tilemap_tiles_tools_buttons->add_child(select_tool_button); viewport_shortcut_buttons.push_back(select_tool_button); @@ -2229,6 +2230,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { paint_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/paint_tool")); paint_tool_button->set_tooltip_text(TTR("Shift: Draw line.") + "\n" + keycode_get_string((Key)KeyModifierMask::CMD_OR_CTRL) + TTR("Shift: Draw rectangle.")); paint_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_update_toolbar)); + paint_tool_button->set_accessibility_name(TTRC("Paint Tool")); tilemap_tiles_tools_buttons->add_child(paint_tool_button); viewport_shortcut_buttons.push_back(paint_tool_button); @@ -2239,6 +2241,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { // TRANSLATORS: This refers to the line tool in the tilemap editor. line_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/line_tool")); line_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_update_toolbar)); + line_tool_button->set_accessibility_name(TTRC("Line Tool")); tilemap_tiles_tools_buttons->add_child(line_tool_button); viewport_shortcut_buttons.push_back(line_tool_button); @@ -2248,6 +2251,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { rect_tool_button->set_button_group(tool_buttons_group); rect_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/rect_tool")); rect_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_update_toolbar)); + rect_tool_button->set_accessibility_name(TTRC("Rect Tool")); tilemap_tiles_tools_buttons->add_child(rect_tool_button); viewport_shortcut_buttons.push_back(rect_tool_button); @@ -2257,6 +2261,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { bucket_tool_button->set_button_group(tool_buttons_group); bucket_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/bucket_tool")); bucket_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_update_toolbar)); + bucket_tool_button->set_accessibility_name(TTRC("Bucket Tool")); tilemap_tiles_tools_buttons->add_child(bucket_tool_button); toolbar->add_child(tilemap_tiles_tools_buttons); viewport_shortcut_buttons.push_back(bucket_tool_button); @@ -2276,6 +2281,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { Key key = (OS::get_singleton()->has_feature("macos") || OS::get_singleton()->has_feature("web_macos") || OS::get_singleton()->has_feature("web_ios")) ? Key::META : Key::CTRL; picker_button->set_tooltip_text(vformat(TTR("Alternatively hold %s with other tools to pick tile."), find_keycode_name(key))); picker_button->connect(SceneStringName(pressed), callable_mp(CanvasItemEditor::get_singleton(), &CanvasItemEditor::update_viewport)); + picker_button->set_accessibility_name(TTRC("Pick")); tools_settings->add_child(picker_button); viewport_shortcut_buttons.push_back(picker_button); @@ -2286,6 +2292,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { erase_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/eraser")); erase_button->set_tooltip_text(TTRC("Alternatively use RMB to erase tiles.")); erase_button->connect(SceneStringName(pressed), callable_mp(CanvasItemEditor::get_singleton(), &CanvasItemEditor::update_viewport)); + erase_button->set_accessibility_name(TTRC("Erase")); tools_settings->add_child(erase_button); viewport_shortcut_buttons.push_back(erase_button); @@ -2299,6 +2306,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { transform_button_rotate_left->set_shortcut(ED_SHORTCUT("tiles_editor/rotate_tile_left", TTRC("Rotate Tile Left"), Key::Z)); transform_toolbar->add_child(transform_button_rotate_left); transform_button_rotate_left->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_ROTATE_LEFT)); + transform_button_rotate_left->set_accessibility_name(TTRC("Rotate Tile Left")); viewport_shortcut_buttons.push_back(transform_button_rotate_left); transform_button_rotate_right = memnew(Button); @@ -2306,6 +2314,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { transform_button_rotate_right->set_shortcut(ED_SHORTCUT("tiles_editor/rotate_tile_right", TTRC("Rotate Tile Right"), Key::X)); transform_toolbar->add_child(transform_button_rotate_right); transform_button_rotate_right->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_ROTATE_RIGHT)); + transform_button_rotate_right->set_accessibility_name(TTRC("Rotate Tile Right")); viewport_shortcut_buttons.push_back(transform_button_rotate_right); transform_button_flip_h = memnew(Button); @@ -2313,6 +2322,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { transform_button_flip_h->set_shortcut(ED_SHORTCUT("tiles_editor/flip_tile_horizontal", TTRC("Flip Tile Horizontally"), Key::C)); transform_toolbar->add_child(transform_button_flip_h); transform_button_flip_h->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_FLIP_H)); + transform_button_flip_h->set_accessibility_name(TTRC("Flip Tile Horizontally")); viewport_shortcut_buttons.push_back(transform_button_flip_h); transform_button_flip_v = memnew(Button); @@ -2320,6 +2330,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { transform_button_flip_v->set_shortcut(ED_SHORTCUT("tiles_editor/flip_tile_vertical", TTRC("Flip Tile Vertically"), Key::V)); transform_toolbar->add_child(transform_button_flip_v); transform_button_flip_v->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_FLIP_V)); + transform_button_flip_v->set_accessibility_name(TTRC("Flip Tile Vertically")); viewport_shortcut_buttons.push_back(transform_button_flip_v); // Separator 2. @@ -2339,6 +2350,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { random_tile_toggle->set_toggle_mode(true); random_tile_toggle->set_tooltip_text(TTR("Place Random Tile")); random_tile_toggle->connect(SceneStringName(toggled), callable_mp(this, &TileMapLayerEditorTilesPlugin::_on_random_tile_checkbox_toggled)); + random_tile_toggle->set_accessibility_name(TTRC("Place Random Tile")); tools_settings->add_child(random_tile_toggle); // Random tile scattering. @@ -2356,6 +2368,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { scatter_spinbox->set_tooltip_text(TTR("Modifies the chance of painting nothing instead of a randomly selected tile.")); scatter_spinbox->get_line_edit()->add_theme_constant_override("minimum_character_width", 4); scatter_spinbox->connect(SceneStringName(value_changed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_on_scattering_spinbox_changed)); + scatter_spinbox->set_accessibility_name(TTRC("Scattering")); scatter_controls_container->add_child(scatter_spinbox); tools_settings->add_child(scatter_controls_container); @@ -2404,6 +2417,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() { source_sort_button->set_flat(false); source_sort_button->set_theme_type_variation("FlatMenuButton"); source_sort_button->set_tooltip_text(TTR("Sort sources")); + source_sort_button->set_accessibility_name(TTRC("Sort sources")); PopupMenu *p = source_sort_button->get_popup(); p->connect(SceneStringName(id_pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_set_source_sort)); @@ -3571,6 +3585,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() { paint_tool_button->set_pressed(true); paint_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/paint_tool")); paint_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTerrainsPlugin::_update_toolbar)); + paint_tool_button->set_accessibility_name(TTRC("Paint Tool")); tilemap_tiles_tools_buttons->add_child(paint_tool_button); viewport_shortcut_buttons.push_back(paint_tool_button); @@ -3580,6 +3595,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() { line_tool_button->set_button_group(tool_buttons_group); line_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/line_tool")); line_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTerrainsPlugin::_update_toolbar)); + line_tool_button->set_accessibility_name(TTRC("Line Tool")); tilemap_tiles_tools_buttons->add_child(line_tool_button); viewport_shortcut_buttons.push_back(line_tool_button); @@ -3589,6 +3605,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() { rect_tool_button->set_button_group(tool_buttons_group); rect_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/rect_tool")); rect_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTerrainsPlugin::_update_toolbar)); + rect_tool_button->set_accessibility_name(TTRC("Rect Tool")); tilemap_tiles_tools_buttons->add_child(rect_tool_button); viewport_shortcut_buttons.push_back(rect_tool_button); @@ -3598,6 +3615,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() { bucket_tool_button->set_button_group(tool_buttons_group); bucket_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/bucket_tool")); bucket_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTerrainsPlugin::_update_toolbar)); + bucket_tool_button->set_accessibility_name(TTRC("Bucket Tool")); tilemap_tiles_tools_buttons->add_child(bucket_tool_button); viewport_shortcut_buttons.push_back(bucket_tool_button); @@ -3616,6 +3634,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() { picker_button->set_toggle_mode(true); picker_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/picker")); picker_button->connect(SceneStringName(pressed), callable_mp(CanvasItemEditor::get_singleton(), &CanvasItemEditor::update_viewport)); + picker_button->set_accessibility_name(TTRC("Pick")); tools_settings->add_child(picker_button); viewport_shortcut_buttons.push_back(picker_button); @@ -3625,6 +3644,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() { erase_button->set_toggle_mode(true); erase_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/eraser")); erase_button->connect(SceneStringName(pressed), callable_mp(CanvasItemEditor::get_singleton(), &CanvasItemEditor::update_viewport)); + erase_button->set_accessibility_name(TTRC("Erase")); tools_settings->add_child(erase_button); viewport_shortcut_buttons.push_back(erase_button); @@ -4476,18 +4496,21 @@ TileMapLayerEditor::TileMapLayerEditor() { layers_selection_button->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS); layers_selection_button->set_tooltip_text(TTR("TileMap Layers")); layers_selection_button->connect(SceneStringName(item_selected), callable_mp(this, &TileMapLayerEditor::_layers_selection_item_selected)); + layers_selection_button->set_accessibility_name(TTRC("TileMap Layers")); layer_selection_hbox->add_child(layers_selection_button); select_previous_layer = memnew(Button); select_previous_layer->set_theme_type_variation(SceneStringName(FlatButton)); select_previous_layer->set_tooltip_text(TTR("Select previous layer")); select_previous_layer->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditor::_select_previous_layer_pressed)); + select_previous_layer->set_accessibility_name(TTRC("Previous")); layer_selection_hbox->add_child(select_previous_layer); select_next_layer = memnew(Button); select_next_layer->set_theme_type_variation(SceneStringName(FlatButton)); select_next_layer->set_tooltip_text(TTR("Select next layer")); select_next_layer->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditor::_select_next_layer_pressed)); + select_next_layer->set_accessibility_name(TTRC("Next")); layer_selection_hbox->add_child(select_next_layer); select_all_layers = memnew(Button); @@ -4503,6 +4526,7 @@ TileMapLayerEditor::TileMapLayerEditor() { toggle_highlight_selected_layer_button->set_toggle_mode(true); toggle_highlight_selected_layer_button->connect(SceneStringName(toggled), callable_mp(this, &TileMapLayerEditor::_highlight_selected_layer_button_toggled)); toggle_highlight_selected_layer_button->set_tooltip_text(TTR("Highlight Selected TileMap Layer")); + toggle_highlight_selected_layer_button->set_accessibility_name(TTRC("Highlight Selected TileMap Layer")); tile_map_toolbar->add_child(toggle_highlight_selected_layer_button); tile_map_toolbar->add_child(memnew(VSeparator)); @@ -4513,11 +4537,13 @@ TileMapLayerEditor::TileMapLayerEditor() { toggle_grid_button->set_toggle_mode(true); toggle_grid_button->set_tooltip_text(TTR("Toggle grid visibility.")); toggle_grid_button->connect(SceneStringName(toggled), callable_mp(this, &TileMapLayerEditor::_on_grid_toggled)); + toggle_grid_button->set_accessibility_name(TTRC("Grid")); tile_map_toolbar->add_child(toggle_grid_button); // Advanced settings menu button. advanced_menu_button = memnew(MenuButton); advanced_menu_button->set_flat(false); + advanced_menu_button->set_accessibility_name(TTRC("Advanced")); advanced_menu_button->set_theme_type_variation(SceneStringName(FlatButton)); advanced_menu_button->get_popup()->add_item(TTR("Automatically Replace Tiles with Proxies"), ADVANCED_MENU_REPLACE_WITH_PROXIES); advanced_menu_button->get_popup()->add_item(TTR("Extract TileMap layers as individual TileMapLayer nodes"), ADVANCED_MENU_EXTRACT_TILE_MAP_LAYERS); diff --git a/editor/plugins/tiles/tile_set_editor.cpp b/editor/plugins/tiles/tile_set_editor.cpp index bcef4508cb34..e30527efaf12 100644 --- a/editor/plugins/tiles/tile_set_editor.cpp +++ b/editor/plugins/tiles/tile_set_editor.cpp @@ -846,6 +846,7 @@ TileSetEditor::TileSetEditor() { source_sort_button->set_flat(false); source_sort_button->set_theme_type_variation(SceneStringName(FlatButton)); source_sort_button->set_tooltip_text(TTR("Sort Sources")); + source_sort_button->set_accessibility_name(TTRC("Sort Sources")); PopupMenu *p = source_sort_button->get_popup(); p->connect(SceneStringName(id_pressed), callable_mp(this, &TileSetEditor::_set_source_sort)); @@ -896,6 +897,7 @@ TileSetEditor::TileSetEditor() { sources_advanced_menu_button->get_popup()->add_item(TTR("Open Atlas Merging Tool")); sources_advanced_menu_button->get_popup()->add_item(TTR("Manage Tile Proxies")); sources_advanced_menu_button->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &TileSetEditor::_sources_advanced_menu_id_pressed)); + sources_advanced_menu_button->set_accessibility_name(TTRC("Advanced")); sources_bottom_actions->add_child(sources_advanced_menu_button); sources_bottom_actions->add_child(source_sort_button); diff --git a/editor/plugins/tiles/tile_set_scenes_collection_source_editor.cpp b/editor/plugins/tiles/tile_set_scenes_collection_source_editor.cpp index a48ebbc08ba4..06b7be6c9882 100644 --- a/editor/plugins/tiles/tile_set_scenes_collection_source_editor.cpp +++ b/editor/plugins/tiles/tile_set_scenes_collection_source_editor.cpp @@ -573,12 +573,14 @@ TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() { scene_tile_add_button = memnew(Button); scene_tile_add_button->set_theme_type_variation(SceneStringName(FlatButton)); scene_tile_add_button->connect(SceneStringName(pressed), callable_mp(this, &TileSetScenesCollectionSourceEditor::_source_add_pressed)); + scene_tile_add_button->set_accessibility_name(TTRC("Add")); scenes_bottom_actions->add_child(scene_tile_add_button); scene_tile_delete_button = memnew(Button); scene_tile_delete_button->set_theme_type_variation(SceneStringName(FlatButton)); scene_tile_delete_button->set_disabled(true); scene_tile_delete_button->connect(SceneStringName(pressed), callable_mp(this, &TileSetScenesCollectionSourceEditor::_source_delete_pressed)); + scene_tile_delete_button->set_accessibility_name(TTRC("Delete")); scenes_bottom_actions->add_child(scene_tile_delete_button); EditorInspector::add_inspector_plugin(memnew(TileSourceInspectorPlugin)); diff --git a/editor/plugins/version_control_editor_plugin.cpp b/editor/plugins/version_control_editor_plugin.cpp index b42ab330a7af..ecf7eafe59b1 100644 --- a/editor/plugins/version_control_editor_plugin.cpp +++ b/editor/plugins/version_control_editor_plugin.cpp @@ -1067,6 +1067,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { set_up_ssh_public_key_path = memnew(LineEdit); set_up_ssh_public_key_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); + set_up_ssh_public_key_path->set_accessibility_name(TTRC("SSH Public Key Path")); set_up_ssh_public_key_path->set_text(EDITOR_GET("version_control/ssh_public_key_path")); set_up_ssh_public_key_path->connect(SceneStringName(text_changed), callable_mp(this, &VersionControlEditorPlugin::_update_set_up_warning)); set_up_ssh_public_key_input_hbc->add_child(set_up_ssh_public_key_path); @@ -1083,6 +1084,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { select_public_path_button->set_button_icon(EditorNode::get_singleton()->get_gui_base()->get_editor_theme_icon("Folder")); select_public_path_button->connect(SceneStringName(pressed), callable_mp(this, &VersionControlEditorPlugin::_popup_file_dialog).bind(set_up_ssh_public_key_file_dialog)); select_public_path_button->set_tooltip_text(TTR("Select SSH public key path")); + select_public_path_button->set_accessibility_name(TTRC("Select SSH public key path")); set_up_ssh_public_key_input_hbc->add_child(select_public_path_button); HBoxContainer *set_up_ssh_private_key_input = memnew(HBoxContainer); @@ -1102,6 +1104,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { set_up_ssh_private_key_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); set_up_ssh_private_key_path->set_text(EDITOR_GET("version_control/ssh_private_key_path")); set_up_ssh_private_key_path->connect(SceneStringName(text_changed), callable_mp(this, &VersionControlEditorPlugin::_update_set_up_warning)); + set_up_ssh_private_key_path->set_accessibility_name(TTRC("SSH Private Key Path")); set_up_ssh_private_key_input_hbc->add_child(set_up_ssh_private_key_path); set_up_ssh_private_key_file_dialog = memnew(FileDialog); @@ -1116,6 +1119,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { select_private_path_button->set_button_icon(EditorNode::get_singleton()->get_gui_base()->get_editor_theme_icon("Folder")); select_private_path_button->connect(SceneStringName(pressed), callable_mp(this, &VersionControlEditorPlugin::_popup_file_dialog).bind(set_up_ssh_private_key_file_dialog)); select_private_path_button->set_tooltip_text(TTR("Select SSH private key path")); + select_private_path_button->set_accessibility_name(TTRC("Select SSH private key path")); set_up_ssh_private_key_input_hbc->add_child(select_private_path_button); HBoxContainer *set_up_ssh_passphrase_input = memnew(HBoxContainer); @@ -1131,6 +1135,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { set_up_ssh_passphrase->set_h_size_flags(Control::SIZE_EXPAND_FILL); set_up_ssh_passphrase->set_secret(true); set_up_ssh_passphrase->connect(SceneStringName(text_changed), callable_mp(this, &VersionControlEditorPlugin::_update_set_up_warning)); + set_up_ssh_passphrase->set_accessibility_name(TTRC("SSH Passphrase")); set_up_ssh_passphrase_input->add_child(set_up_ssh_passphrase); set_up_warning_text = memnew(Label); @@ -1156,6 +1161,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { unstage_title->add_child(unstage_label); refresh_button = memnew(Button); + refresh_button->set_accessibility_name(TTRC("Detect new changes")); refresh_button->set_tooltip_text(TTR("Detect new changes")); refresh_button->set_theme_type_variation(SceneStringName(FlatButton)); refresh_button->set_button_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("Reload"), EditorStringName(EditorIcons))); @@ -1177,6 +1183,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { discard_all_confirm->get_ok_button()->connect(SceneStringName(pressed), callable_mp(this, &VersionControlEditorPlugin::_discard_all)); discard_all_button = memnew(Button); + discard_all_button->set_accessibility_name(TTRC("Discard all changes")); discard_all_button->set_tooltip_text(TTR("Discard all changes")); discard_all_button->set_button_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("Close"), EditorStringName(EditorIcons))); discard_all_button->connect(SceneStringName(pressed), callable_mp(this, &VersionControlEditorPlugin::_confirm_discard_all)); @@ -1184,6 +1191,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { unstage_title->add_child(discard_all_button); stage_all_button = memnew(Button); + stage_all_button->set_accessibility_name(TTRC("Stage all changes")); stage_all_button->set_theme_type_variation(SceneStringName(FlatButton)); stage_all_button->set_button_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("MoveDown"), EditorStringName(EditorIcons))); stage_all_button->set_tooltip_text(TTR("Stage all changes")); @@ -1214,6 +1222,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { stage_title->add_child(stage_label); unstage_all_button = memnew(Button); + unstage_all_button->set_accessibility_name(TTRC("Unstage all changes")); unstage_all_button->set_theme_type_variation(SceneStringName(FlatButton)); unstage_all_button->set_button_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("MoveUp"), EditorStringName(EditorIcons))); unstage_all_button->set_tooltip_text(TTR("Unstage all changes")); @@ -1245,6 +1254,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { commit_area->add_child(commit_label); commit_message = memnew(TextEdit); + commit_message->set_accessibility_name(TTRC("Commit Message")); commit_message->set_h_size_flags(Control::SIZE_EXPAND_FILL); commit_message->set_h_grow_direction(Control::GrowDirection::GROW_DIRECTION_BEGIN); commit_message->set_v_grow_direction(Control::GrowDirection::GROW_DIRECTION_END); @@ -1273,6 +1283,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { commit_list_hbc->add_child(commit_list_label); commit_list_size_button = memnew(OptionButton); + commit_list_size_button->set_accessibility_name(TTRC("Commit list size")); commit_list_size_button->set_tooltip_text(TTR("Commit list size")); commit_list_size_button->add_item("10"); commit_list_size_button->set_item_metadata(0, 10); @@ -1305,6 +1316,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { version_commit_dock->add_child(menu_bar); branch_select = memnew(OptionButton); + branch_select->set_accessibility_name(TTRC("Branches")); branch_select->set_tooltip_text(TTR("Branches")); branch_select->set_h_size_flags(Control::SIZE_EXPAND_FILL); branch_select->set_clip_text(true); @@ -1346,11 +1358,13 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { branch_create_hbc->add_child(branch_create_name_label); branch_create_name_input = memnew(LineEdit); + branch_create_name_input->set_accessibility_name(TTRC("Branch Name")); branch_create_name_input->set_h_size_flags(Control::SIZE_EXPAND_FILL); branch_create_name_input->connect(SceneStringName(text_changed), callable_mp(this, &VersionControlEditorPlugin::_update_branch_create_button)); branch_create_hbc->add_child(branch_create_name_input); remote_select = memnew(OptionButton); + remote_select->set_accessibility_name(TTRC("Remote")); remote_select->set_tooltip_text(TTR("Remotes")); remote_select->set_h_size_flags(Control::SIZE_EXPAND_FILL); remote_select->set_clip_text(true); @@ -1392,6 +1406,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { remote_create_name_hbc->add_child(remote_create_name_label); remote_create_name_input = memnew(LineEdit); + remote_create_name_input->set_accessibility_name(TTRC("Remote Name")); remote_create_name_input->set_h_size_flags(Control::SIZE_EXPAND_FILL); remote_create_name_input->connect(SceneStringName(text_changed), callable_mp(this, &VersionControlEditorPlugin::_update_remote_create_button)); remote_create_name_hbc->add_child(remote_create_name_input); @@ -1406,12 +1421,14 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { remote_create_hbc->add_child(remote_create_url_label); remote_create_url_input = memnew(LineEdit); + remote_create_url_input->set_accessibility_name(TTRC("Remote URL")); remote_create_url_input->set_h_size_flags(Control::SIZE_EXPAND_FILL); remote_create_url_input->connect(SceneStringName(text_changed), callable_mp(this, &VersionControlEditorPlugin::_update_remote_create_button)); remote_create_hbc->add_child(remote_create_url_input); fetch_button = memnew(Button); fetch_button->set_theme_type_variation(SceneStringName(FlatButton)); + fetch_button->set_accessibility_name(TTRC("Fetch")); fetch_button->set_tooltip_text(TTR("Fetch")); fetch_button->set_button_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("Reload"), EditorStringName(EditorIcons))); fetch_button->connect(SceneStringName(pressed), callable_mp(this, &VersionControlEditorPlugin::_fetch)); @@ -1419,6 +1436,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { pull_button = memnew(Button); pull_button->set_theme_type_variation(SceneStringName(FlatButton)); + pull_button->set_accessibility_name(TTRC("Pull")); pull_button->set_tooltip_text(TTR("Pull")); pull_button->set_button_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("MoveDown"), EditorStringName(EditorIcons))); pull_button->connect(SceneStringName(pressed), callable_mp(this, &VersionControlEditorPlugin::_pull)); @@ -1426,6 +1444,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { push_button = memnew(Button); push_button->set_theme_type_variation(SceneStringName(FlatButton)); + push_button->set_accessibility_name(TTRC("Push")); push_button->set_tooltip_text(TTR("Push")); push_button->set_button_icon(EditorNode::get_singleton()->get_editor_theme()->get_icon(SNAME("MoveUp"), EditorStringName(EditorIcons))); push_button->connect(SceneStringName(pressed), callable_mp(this, &VersionControlEditorPlugin::_push)); @@ -1492,6 +1511,7 @@ VersionControlEditorPlugin::VersionControlEditorPlugin() { diff_heading->add_child(view); diff_view_type_select = memnew(OptionButton); + diff_view_type_select->set_accessibility_name(TTRC("View")); diff_view_type_select->add_item(TTR("Split"), DIFF_VIEW_TYPE_SPLIT); diff_view_type_select->add_item(TTR("Unified"), DIFF_VIEW_TYPE_UNIFIED); diff_view_type_select->connect(SceneStringName(item_selected), callable_mp(this, &VersionControlEditorPlugin::_display_diff)); diff --git a/editor/plugins/visual_shader_editor_plugin.cpp b/editor/plugins/visual_shader_editor_plugin.cpp index 4f6336de8a62..9db24d488568 100644 --- a/editor/plugins/visual_shader_editor_plugin.cpp +++ b/editor/plugins/visual_shader_editor_plugin.cpp @@ -1212,6 +1212,7 @@ void VisualShaderGraphPlugin::add_node(VisualShader::Type p_type, int p_id, bool if (valid_right) { if (expanded_port_counter == 0 && vsnode->is_output_port_expandable(i)) { TextureButton *expand = memnew(TextureButton); + expand->set_accessibility_name(TTRC("Expand output port")); expand->set_toggle_mode(true); expand->set_texture_normal(editor->get_editor_theme_icon(SNAME("GuiTreeArrowRight"))); expand->set_texture_pressed(editor->get_editor_theme_icon(SNAME("GuiTreeArrowDown"))); @@ -1222,6 +1223,7 @@ void VisualShaderGraphPlugin::add_node(VisualShader::Type p_type, int p_id, bool } if (vsnode->has_output_port_preview(i) && port_right != VisualShaderNode::PORT_TYPE_TRANSFORM && port_right != VisualShaderNode::PORT_TYPE_SAMPLER) { TextureButton *preview = memnew(TextureButton); + preview->set_accessibility_name(TTRC("Select preview port")); preview->set_toggle_mode(true); preview->set_texture_normal(editor->get_editor_theme_icon(SNAME("GuiVisibilityHidden"))); preview->set_texture_pressed(editor->get_editor_theme_icon(SNAME("GuiVisibilityVisible"))); @@ -6121,6 +6123,10 @@ void VisualShaderEditor::_connection_menu_id_pressed(int p_idx) { } Variant VisualShaderEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from) { + if (p_point == Vector2(INFINITY, INFINITY)) { + return Variant(); + } + if (p_from == members) { TreeItem *it = members->get_item_at_position(p_point); if (!it) { @@ -6146,6 +6152,10 @@ Variant VisualShaderEditor::get_drag_data_fw(const Point2 &p_point, Control *p_f } bool VisualShaderEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const { + if (p_point == Vector2(INFINITY, INFINITY)) { + return false; + } + if (p_from == graph) { Dictionary d = p_data; @@ -6161,6 +6171,10 @@ bool VisualShaderEditor::can_drop_data_fw(const Point2 &p_point, const Variant & } void VisualShaderEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { + if (p_point == Vector2(INFINITY, INFINITY)) { + return; + } + if (p_from == graph) { Dictionary d = p_data; @@ -6746,6 +6760,7 @@ VisualShaderEditor::VisualShaderEditor() { preview_tools = memnew(MenuButton); filter_hbox->add_child(preview_tools); preview_tools->set_tooltip_text(TTR("Options")); + preview_tools->set_accessibility_name(TTRC("Options")); preview_tools->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &VisualShaderEditor::_preview_tools_menu_option)); preview_tools->get_popup()->add_item(TTR("Copy Parameters From Material"), COPY_PARAMS_FROM_MATERIAL); preview_tools->get_popup()->add_item(TTR("Paste Parameters To Material"), PASTE_PARAMS_TO_MATERIAL); @@ -6795,10 +6810,12 @@ VisualShaderEditor::VisualShaderEditor() { node_filter->connect(SceneStringName(gui_input), callable_mp(this, &VisualShaderEditor::_sbox_input)); node_filter->set_h_size_flags(SIZE_EXPAND_FILL); node_filter->set_placeholder(TTR("Search")); + node_filter->set_accessibility_name(TTRC("Search")); tools = memnew(MenuButton); filter_hb->add_child(tools); tools->set_tooltip_text(TTR("Options")); + tools->set_accessibility_name(TTRC("Options")); tools->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &VisualShaderEditor::_tools_menu_option)); tools->get_popup()->add_item(TTR("Expand All"), EXPAND_ALL); tools->get_popup()->add_item(TTR("Collapse All"), COLLAPSE_ALL); @@ -6874,6 +6891,7 @@ VisualShaderEditor::VisualShaderEditor() { varying_type->add_item("Vector4"); varying_type->add_item("Boolean"); varying_type->add_item("Transform"); + varying_type->set_accessibility_name(TTRC("Varying Type")); varying_type->connect(SceneStringName(item_selected), callable_mp(this, &VisualShaderEditor::_varying_type_changed)); varying_name = memnew(LineEdit); @@ -6887,6 +6905,7 @@ VisualShaderEditor::VisualShaderEditor() { hb->add_child(varying_mode); varying_mode->add_item("Vertex -> [Fragment, Light]"); varying_mode->add_item("Fragment -> Light"); + varying_mode->set_accessibility_name(TTRC("Varying Mode")); varying_mode->connect(SceneStringName(item_selected), callable_mp(this, &VisualShaderEditor::_varying_mode_changed)); varying_error_label = memnew(Label); diff --git a/editor/project_manager.cpp b/editor/project_manager.cpp index 16c3721060fd..19f4293b09e4 100644 --- a/editor/project_manager.cpp +++ b/editor/project_manager.cpp @@ -1294,6 +1294,8 @@ ProjectManager::ProjectManager() { title_bar_logo = memnew(Button); title_bar_logo->set_flat(true); + title_bar_logo->set_tooltip_text(TTR("About Godot")); + title_bar_logo->set_accessibility_name(TTRC("About Godot")); left_hbox->add_child(title_bar_logo); title_bar_logo->connect(SceneStringName(pressed), callable_mp(this, &ProjectManager::_show_about)); @@ -1374,12 +1376,14 @@ ProjectManager::ProjectManager() { hb->add_child(scan_btn); loading_label = memnew(Label(TTR("Loading, please wait..."))); + loading_label->set_accessibility_live(DisplayServer::AccessibilityLiveMode::LIVE_ASSERTIVE); loading_label->set_h_size_flags(Control::SIZE_EXPAND_FILL); loading_label->hide(); hb->add_child(loading_label); search_box = memnew(LineEdit); search_box->set_placeholder(TTR("Filter Projects")); + search_box->set_accessibility_name(TTRC("Filter Projects")); search_box->set_tooltip_text(TTR("This field filters projects by name and last path component.\nTo filter projects by name and full path, the query must contain at least one `/` character.")); search_box->set_clear_button_enabled(true); search_box->connect(SceneStringName(text_changed), callable_mp(this, &ProjectManager::_on_search_term_changed)); @@ -1387,14 +1391,16 @@ ProjectManager::ProjectManager() { search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); hb->add_child(search_box); - Label *sort_label = memnew(Label); + sort_label = memnew(Label); sort_label->set_text(TTR("Sort:")); + sort_label->set_focus_mode(Control::FOCUS_NONE); hb->add_child(sort_label); filter_option = memnew(OptionButton); filter_option->set_clip_text(true); filter_option->set_h_size_flags(Control::SIZE_EXPAND_FILL); filter_option->set_stretch_ratio(0.3); + filter_option->set_accessibility_name(TTRC("Sort")); filter_option->connect(SceneStringName(item_selected), callable_mp(this, &ProjectManager::_on_order_option_changed)); hb->add_child(filter_option); @@ -1493,6 +1499,7 @@ ProjectManager::ProjectManager() { open_btn_container->add_child(memnew(VSeparator)); open_options_btn = memnew(Button); + open_options_btn->set_accessibility_name(TTRC("Options")); open_options_btn->set_icon_alignment(HorizontalAlignment::HORIZONTAL_ALIGNMENT_CENTER); open_options_btn->connect(SceneStringName(pressed), callable_mp(this, &ProjectManager::_open_options_popup)); open_btn_container->add_child(open_options_btn); @@ -1520,6 +1527,7 @@ ProjectManager::ProjectManager() { manage_tags_btn = memnew(Button); manage_tags_btn->set_text(TTR("Manage Tags")); + manage_tags_btn->set_shortcut(ED_SHORTCUT("project_manager/project_tags", TTR("Manage Tags"), KeyModifierMask::CMD_OR_CTRL | Key::T)); project_list_sidebar->add_child(manage_tags_btn); erase_btn = memnew(Button); @@ -1713,6 +1721,7 @@ ProjectManager::ProjectManager() { new_tag_name = memnew(LineEdit); tag_vb->add_child(new_tag_name); + new_tag_name->set_accessibility_name(TTRC("New Tag Name")); new_tag_name->connect(SceneStringName(text_changed), callable_mp(this, &ProjectManager::_set_new_tag_name)); new_tag_name->connect(SceneStringName(text_submitted), callable_mp(this, &ProjectManager::_create_new_tag).unbind(1)); create_tag_dialog->connect("about_to_popup", callable_mp(new_tag_name, &LineEdit::clear)); @@ -1722,6 +1731,7 @@ ProjectManager::ProjectManager() { tag_vb->add_child(tag_error); create_tag_btn = memnew(Button); + create_tag_btn->set_accessibility_name(TTRC("Create Tag")); all_tags->add_child(create_tag_btn); create_tag_btn->connect(SceneStringName(pressed), callable_mp((Window *)create_tag_dialog, &Window::popup_centered).bind(Vector2i(500, 0) * EDSCALE)); } diff --git a/editor/project_manager.h b/editor/project_manager.h index 088bbc9e25ed..841ee6e988e3 100644 --- a/editor/project_manager.h +++ b/editor/project_manager.h @@ -138,6 +138,7 @@ class ProjectManager : public Control { LineEdit *search_box = nullptr; Label *loading_label = nullptr; + Label *sort_label = nullptr; OptionButton *filter_option = nullptr; PanelContainer *project_list_panel = nullptr; diff --git a/editor/project_manager/project_dialog.cpp b/editor/project_manager/project_dialog.cpp index a2aca198035f..07ad4e9fa952 100644 --- a/editor/project_manager/project_dialog.cpp +++ b/editor/project_manager/project_dialog.cpp @@ -921,6 +921,7 @@ ProjectDialog::ProjectDialog() { project_path = memnew(LineEdit); project_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); + project_path->set_accessibility_name(TTRC("Project Path")); project_path->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); pphb->add_child(project_path); @@ -936,6 +937,7 @@ ProjectDialog::ProjectDialog() { install_path = memnew(LineEdit); install_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); + install_path->set_accessibility_name(TTRC("Install Path")); install_path->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); iphb->add_child(install_path); diff --git a/editor/project_manager/project_list.cpp b/editor/project_manager/project_list.cpp index 839bf5852481..590115e18b21 100644 --- a/editor/project_manager/project_list.cpp +++ b/editor/project_manager/project_list.cpp @@ -49,6 +49,10 @@ #include "scene/gui/texture_rect.h" #include "scene/resources/image_texture.h" +const char *ProjectList::SIGNAL_LIST_CHANGED = "list_changed"; +const char *ProjectList::SIGNAL_SELECTION_CHANGED = "selection_changed"; +const char *ProjectList::SIGNAL_PROJECT_ASK_OPEN = "project_ask_open"; + void ProjectListItemControl::_notification(int p_what) { switch (p_what) { case NOTIFICATION_THEME_CHANGED: { @@ -81,11 +85,47 @@ void ProjectListItemControl::_notification(int p_what) { case NOTIFICATION_MOUSE_ENTER: { is_hovering = true; queue_redraw(); + queue_accessibility_update(); } break; case NOTIFICATION_MOUSE_EXIT: { is_hovering = false; queue_redraw(); + queue_accessibility_update(); + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_LIST_BOX_OPTION); + DisplayServer::get_singleton()->accessibility_update_set_name(ae, TTR("Project") + " " + project_title->get_text()); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, project_title->get_text()); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &ProjectListItemControl::_accessibility_action_open)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &ProjectListItemControl::_accessibility_action_scroll_into_view)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &ProjectListItemControl::_accessibility_action_focus)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_BLUR, callable_mp(this, &ProjectListItemControl::_accessibility_action_blur)); + + ProjectList *pl = get_list(); + if (pl) { + DisplayServer::get_singleton()->accessibility_update_set_list_item_index(ae, pl->get_index(this)); + } + DisplayServer::get_singleton()->accessibility_update_set_list_item_level(ae, 0); + DisplayServer::get_singleton()->accessibility_update_set_list_item_selected(ae, is_selected); + } break; + + case NOTIFICATION_FOCUS_ENTER: { + ProjectList *pl = get_list(); + if (pl) { + int idx = pl->get_index(this); + if (idx >= 0) { + pl->ensure_project_visible(idx); + pl->select_project(idx); + + pl->emit_signal(SNAME(ProjectList::SIGNAL_SELECTION_CHANGED)); + } + } } break; case NOTIFICATION_DRAW: { @@ -101,6 +141,53 @@ void ProjectListItemControl::_notification(int p_what) { } } +ProjectList *ProjectListItemControl::get_list() const { + if (!is_inside_tree()) { + return nullptr; + } + ProjectList *pl = Object::cast_to(get_parent()->get_parent()); + return pl; +} + +void ProjectListItemControl::_accessibility_action_scroll_into_view(const Variant &p_data) { + ProjectList *pl = get_list(); + if (pl) { + int idx = pl->get_index(this); + if (idx >= 0) { + pl->ensure_project_visible(idx); + } + } +} + +void ProjectListItemControl::_accessibility_action_open(const Variant &p_data) { + ProjectList *pl = get_list(); + if (pl && !pl->project_opening_initiated) { + pl->emit_signal(SNAME(ProjectList::SIGNAL_PROJECT_ASK_OPEN)); + } +} + +void ProjectListItemControl::_accessibility_action_focus(const Variant &p_data) { + ProjectList *pl = get_list(); + if (pl) { + int idx = pl->get_index(this); + if (idx >= 0) { + pl->ensure_project_visible(idx); + pl->select_project(idx); + } + } +} + +void ProjectListItemControl::_accessibility_action_blur(const Variant &p_data) { + ProjectList *pl = get_list(); + if (pl) { + int idx = pl->get_index(this); + if (idx >= 0) { + pl->ensure_project_visible(idx); + pl->deselect_project(idx); + } + } +} + void ProjectListItemControl::_favorite_button_pressed() { emit_signal(SNAME("favorite_pressed")); } @@ -111,10 +198,14 @@ void ProjectListItemControl::_explore_button_pressed() { void ProjectListItemControl::set_project_title(const String &p_title) { project_title->set_text(p_title); + project_title->set_accessibility_name(TTRC("Project Name")); + queue_accessibility_update(); } void ProjectListItemControl::set_project_path(const String &p_path) { project_path->set_text(p_path); + project_path->set_accessibility_name(TTRC("Project Path")); + queue_accessibility_update(); } void ProjectListItemControl::set_tags(const PackedStringArray &p_tags, ProjectList *p_parent_list) { @@ -172,6 +263,8 @@ void ProjectListItemControl::set_unsupported_features(PackedStringArray p_featur return; } project_version->set_tooltip_text(tooltip_text); + project_unsupported_features->set_focus_mode(FOCUS_ACCESSIBILITY); + project_unsupported_features->set_accessibility_name(tooltip_text); project_unsupported_features->set_tooltip_text(tooltip_text); project_unsupported_features->show(); } else { @@ -186,6 +279,7 @@ bool ProjectListItemControl::should_load_project_icon() const { void ProjectListItemControl::set_selected(bool p_selected) { is_selected = p_selected; queue_redraw(); + queue_accessibility_update(); } void ProjectListItemControl::set_is_favorite(bool p_favorite) { @@ -236,6 +330,8 @@ ProjectListItemControl::ProjectListItemControl() { favorite_button = memnew(TextureButton); favorite_button->set_name("FavoriteButton"); + favorite_button->set_tooltip_text(TTR("Add to favorites")); + favorite_button->set_accessibility_name(TTRC("Add to favorites")); // This makes the project's "hover" style display correctly when hovering the favorite icon. favorite_button->set_mouse_filter(MOUSE_FILTER_PASS); favorite_box->add_child(favorite_button); @@ -283,6 +379,8 @@ ProjectListItemControl::ProjectListItemControl() { explore_button = memnew(Button); explore_button->set_name("ExploreButton"); + explore_button->set_tooltip_text(TTR("Open in file manager")); + explore_button->set_accessibility_name(TTRC("Open in file manager")); explore_button->set_flat(true); path_hb->add_child(explore_button); explore_button->connect(SceneStringName(pressed), callable_mp(this, &ProjectListItemControl::_explore_button_pressed)); @@ -343,10 +441,6 @@ struct ProjectListComparator { } }; -const char *ProjectList::SIGNAL_LIST_CHANGED = "list_changed"; -const char *ProjectList::SIGNAL_SELECTION_CHANGED = "selection_changed"; -const char *ProjectList::SIGNAL_PROJECT_ASK_OPEN = "project_ask_open"; - // Helpers. bool ProjectList::project_feature_looks_like_version(const String &p_feature) { @@ -376,6 +470,15 @@ void ProjectList::_notification(int p_what) { } } } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_LIST_BOX); + DisplayServer::get_singleton()->accessibility_update_set_list_item_count(ae, _projects.size()); + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_MULTISELECTABLE, false); + } } } @@ -635,6 +738,7 @@ void ProjectList::update_project_list() { set_v_scroll(0); emit_signal(SNAME(SIGNAL_LIST_CHANGED)); + queue_accessibility_update(); } void ProjectList::sort_projects() { @@ -699,6 +803,7 @@ void ProjectList::sort_projects() { // Rewind the coroutine because order of projects changed _update_icons_async(); update_dock_menu(); + queue_accessibility_update(); } int ProjectList::get_project_count() const { @@ -789,6 +894,7 @@ void ProjectList::add_project(const String &dir_path, bool favorite) { if (!_config.has_section(dir_path)) { _config.set_value(dir_path, "favorite", favorite); } + queue_accessibility_update(); } void ProjectList::set_project_version(const String &p_project_path, int p_version) { @@ -848,6 +954,15 @@ int ProjectList::refresh_project(const String &dir_path) { return index; } +int ProjectList::get_index(const ProjectListItemControl *p_control) const { + for (int i = 0; i < _projects.size(); ++i) { + if (_projects[i].control == p_control) { + return i; + } + } + return -1; +} + void ProjectList::ensure_project_visible(int p_index) { const Item &item = _projects[p_index]; ensure_control_visible(item.control); @@ -915,6 +1030,7 @@ void ProjectList::_remove_project(int p_index, bool p_update_config) { // Not actually saving the file, in case you are doing more changes to settings } + queue_accessibility_update(); update_dock_menu(); } @@ -996,18 +1112,21 @@ void ProjectList::_clear_project_selection() { for (int i = 0; i < previous_selected_items.size(); ++i) { previous_selected_items[i].control->set_selected(false); } + queue_accessibility_update(); } void ProjectList::_select_project_nocheck(int p_index) { Item &item = _projects.write[p_index]; _selected_project_paths.insert(item.path); item.control->set_selected(true); + queue_accessibility_update(); } void ProjectList::_deselect_project_nocheck(int p_index) { Item &item = _projects.write[p_index]; _selected_project_paths.erase(item.path); item.control->set_selected(false); + queue_accessibility_update(); } inline void _sort_project_range(int &a, int &b) { @@ -1033,6 +1152,10 @@ void ProjectList::select_project(int p_index) { _select_project_nocheck(p_index); } +void ProjectList::deselect_project(int p_index) { + _deselect_project_nocheck(p_index); +} + void ProjectList::select_first_visible_project() { _clear_project_selection(); diff --git a/editor/project_manager/project_list.h b/editor/project_manager/project_list.h index 265660a53b44..552ea11b945d 100644 --- a/editor/project_manager/project_list.h +++ b/editor/project_manager/project_list.h @@ -64,6 +64,13 @@ class ProjectListItemControl : public HBoxContainer { void _favorite_button_pressed(); void _explore_button_pressed(); + ProjectList *get_list() const; + + void _accessibility_action_open(const Variant &p_data); + void _accessibility_action_scroll_into_view(const Variant &p_data); + void _accessibility_action_focus(const Variant &p_data); + void _accessibility_action_blur(const Variant &p_data); + protected: void _notification(int p_what); static void _bind_methods(); @@ -91,6 +98,7 @@ class ProjectList : public ScrollContainer { GDCLASS(ProjectList, ScrollContainer) friend class ProjectManager; + friend class ProjectListItemControl; public: enum FilterOption { @@ -258,10 +266,12 @@ class ProjectList : public ScrollContainer { void set_project_version(const String &p_project_path, int version); int refresh_project(const String &dir_path); void ensure_project_visible(int p_index); + int get_index(const ProjectListItemControl *p_control) const; // Project list selection. void select_project(int p_index); + void deselect_project(int p_index); void select_first_visible_project(); Vector get_selected_projects() const; const HashSet &get_selected_project_keys() const; diff --git a/editor/project_manager/project_tag.cpp b/editor/project_manager/project_tag.cpp index fe4e5999ffb2..8b36d41bff08 100644 --- a/editor/project_manager/project_tag.cpp +++ b/editor/project_manager/project_tag.cpp @@ -68,7 +68,8 @@ ProjectTag::ProjectTag(const String &p_text, bool p_display_close) { add_child(button); button->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); button->set_text(p_text.capitalize()); - button->set_focus_mode(FOCUS_NONE); + button->set_focus_mode(FOCUS_ACCESSIBILITY); + button->set_accessibility_name(vformat(TTR("Project Tag: %s"), p_text)); button->set_icon_alignment(HORIZONTAL_ALIGNMENT_RIGHT); button->set_theme_type_variation(SNAME("ProjectTagButton")); } diff --git a/editor/project_settings_editor.cpp b/editor/project_settings_editor.cpp index 91d0dbe739cb..db5113fa7035 100644 --- a/editor/project_settings_editor.cpp +++ b/editor/project_settings_editor.cpp @@ -659,6 +659,7 @@ ProjectSettingsEditor::ProjectSettingsEditor(EditorData *p_data) { search_box = memnew(LineEdit); search_box->set_placeholder(TTR("Filter Settings")); + search_box->set_accessibility_name(TTRC("Filter Settings")); search_box->set_clear_button_enabled(true); search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); search_bar->add_child(search_box); @@ -672,17 +673,20 @@ ProjectSettingsEditor::ProjectSettingsEditor(EditorData *p_data) { property_box = memnew(LineEdit); property_box->set_placeholder(TTR("Select a Setting or Type its Name")); + property_box->set_accessibility_name(TTRC("Setting Name")); property_box->set_h_size_flags(Control::SIZE_EXPAND_FILL); property_box->connect(SceneStringName(text_changed), callable_mp(this, &ProjectSettingsEditor::_property_box_changed)); custom_properties->add_child(property_box); feature_box = memnew(OptionButton); feature_box->set_custom_minimum_size(Size2(120, 0) * EDSCALE); + feature_box->set_accessibility_name(TTRC("Feature")); feature_box->connect(SceneStringName(item_selected), callable_mp(this, &ProjectSettingsEditor::_feature_selected)); custom_properties->add_child(feature_box); type_box = memnew(OptionButton); type_box->set_custom_minimum_size(Size2(120, 0) * EDSCALE); + type_box->set_accessibility_name(TTRC("Type")); custom_properties->add_child(type_box); add_button = memnew(Button); @@ -731,6 +735,7 @@ ProjectSettingsEditor::ProjectSettingsEditor(EditorData *p_data) { restart_close_button = memnew(Button); restart_close_button->set_flat(true); restart_close_button->connect(SceneStringName(pressed), callable_mp(this, &ProjectSettingsEditor::_editor_restart_close)); + restart_close_button->set_accessibility_name(TTRC("Close")); restart_hb->add_child(restart_close_button); action_map_editor = memnew(ActionMapEditor); diff --git a/editor/rename_dialog.cpp b/editor/rename_dialog.cpp index e334c63fba28..153d663691f8 100644 --- a/editor/rename_dialog.cpp +++ b/editor/rename_dialog.cpp @@ -69,6 +69,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { lne_search = memnew(LineEdit); lne_search->set_name("lne_search"); + lne_search->set_accessibility_name(TTRC("Search")); lne_search->set_h_size_flags(Control::SIZE_EXPAND_FILL); Label *lbl_replace = memnew(Label); @@ -76,6 +77,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { lne_replace = memnew(LineEdit); lne_replace->set_name("lne_replace"); + lne_replace->set_accessibility_name(TTRC("Replace")); lne_replace->set_h_size_flags(Control::SIZE_EXPAND_FILL); grd_main->add_child(lbl_search); @@ -90,6 +92,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { lne_prefix = memnew(LineEdit); lne_prefix->set_name("lne_prefix"); + lne_prefix->set_accessibility_name(TTRC("Prefix")); lne_prefix->set_h_size_flags(Control::SIZE_EXPAND_FILL); Label *lbl_suffix = memnew(Label); @@ -97,6 +100,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { lne_suffix = memnew(LineEdit); lne_suffix->set_name("lne_suffix"); + lne_prefix->set_accessibility_name(TTRC("Suffix")); lne_suffix->set_h_size_flags(Control::SIZE_EXPAND_FILL); grd_main->add_child(lbl_prefix); @@ -209,6 +213,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { spn_count_start = memnew(SpinBox); spn_count_start->set_tooltip_text(TTR("Initial value for the counter.")); + spn_count_start->set_accessibility_name(TTRC("Counter Initial Value")); spn_count_start->set_step(1); spn_count_start->set_min(0); hbc_count_options->add_child(spn_count_start); @@ -220,6 +225,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { spn_count_step = memnew(SpinBox); spn_count_step->set_tooltip_text(TTR("Amount by which counter is incremented for each node.")); + spn_count_step->set_accessibility_name(TTRC("Counter Step")); spn_count_step->set_step(1); hbc_count_options->add_child(spn_count_step); @@ -230,6 +236,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { spn_count_padding = memnew(SpinBox); spn_count_padding->set_tooltip_text(TTR("Minimum number of digits for the counter.\nMissing digits are padded with leading zeros.")); + spn_count_padding->set_accessibility_name(TTRC("Minimum Number of Digits")); spn_count_padding->set_step(1); hbc_count_options->add_child(spn_count_padding); @@ -254,6 +261,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { hbc_style->add_child(lbl_style); opt_style = memnew(OptionButton); + opt_style->set_accessibility_name(TTRC("Style")); opt_style->add_item(TTR("Keep")); opt_style->add_item(TTR("PascalCase to snake_case")); opt_style->add_item(TTR("snake_case to PascalCase")); @@ -269,6 +277,7 @@ RenameDialog::RenameDialog(SceneTreeEditor *p_scene_tree_editor) { hbc_case->add_child(lbl_case); opt_case = memnew(OptionButton); + opt_case->set_accessibility_name(TTRC("Case")); opt_case->add_item(TTR("Keep")); opt_case->add_item(TTR("To Lowercase")); opt_case->add_item(TTR("To Uppercase")); diff --git a/editor/run_instances_dialog.cpp b/editor/run_instances_dialog.cpp index 2811ada54103..1e2d598c73e6 100644 --- a/editor/run_instances_dialog.cpp +++ b/editor/run_instances_dialog.cpp @@ -339,6 +339,7 @@ RunInstancesDialog::RunInstancesDialog() { instance_count->set_min(1); instance_count->set_max(20); instance_count->set_value(EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_instance_count", stored_data.size())); + instance_count->set_accessibility_name(TTRC("Number of Instances")); args_gc->add_child(instance_count); instance_count->connect(SceneStringName(value_changed), callable_mp(this, &RunInstancesDialog::_start_instance_timer).unbind(1)); @@ -349,6 +350,7 @@ RunInstancesDialog::RunInstancesDialog() { main_args_edit = memnew(LineEdit); main_args_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); main_args_edit->set_placeholder(TTR("Space-separated arguments, example: host player1 blue")); + main_args_edit->set_accessibility_name(TTRC("Launch Arguments")); args_gc->add_child(main_args_edit); _fetch_main_args(); ProjectSettings::get_singleton()->connect("settings_changed", callable_mp(this, &RunInstancesDialog::_fetch_main_args)); @@ -358,6 +360,7 @@ RunInstancesDialog::RunInstancesDialog() { main_features_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); main_features_edit->set_placeholder(TTR("Comma-separated tags, example: demo, steam, event")); main_features_edit->set_text(EditorSettings::get_singleton()->get_project_metadata("debug_options", "run_main_feature_tags", "")); + main_features_edit->set_accessibility_name(TTRC("Feature Tags")); args_gc->add_child(main_features_edit); main_features_edit->connect(SceneStringName(text_changed), callable_mp(this, &RunInstancesDialog::_start_main_timer).unbind(1)); diff --git a/editor/scene_create_dialog.cpp b/editor/scene_create_dialog.cpp index 971735760b9a..24ad3064e9ac 100644 --- a/editor/scene_create_dialog.cpp +++ b/editor/scene_create_dialog.cpp @@ -226,6 +226,7 @@ SceneCreateDialog::SceneCreateDialog() { node_type_other = memnew(CheckBox); hb->add_child(node_type_other); + node_type_other->set_accessibility_name(TTRC("Other Type")); node_type_other->set_button_group(node_type_group); node_type_other->set_meta(type_meta, ROOT_OTHER); @@ -234,12 +235,14 @@ SceneCreateDialog::SceneCreateDialog() { spacing->set_custom_minimum_size(Size2(4 * EDSCALE, 0)); other_type_display = memnew(LineEdit); + other_type_display->set_accessibility_name(TTRC("Other Type")); hb->add_child(other_type_display); other_type_display->set_h_size_flags(Control::SIZE_EXPAND_FILL); other_type_display->set_editable(false); other_type_display->set_text("Node"); select_node_button = memnew(Button); + select_node_button->set_accessibility_name(TTRC("Select Node")); hb->add_child(select_node_button); select_node_button->connect(SceneStringName(pressed), callable_mp(this, &SceneCreateDialog::browse_types)); } @@ -253,6 +256,7 @@ SceneCreateDialog::SceneCreateDialog() { scene_name_edit = memnew(LineEdit); hb->add_child(scene_name_edit); + scene_name_edit->set_accessibility_name(TTRC("Scene Name:")); scene_name_edit->set_h_size_flags(Control::SIZE_EXPAND_FILL); scene_name_edit->connect(SceneStringName(text_submitted), callable_mp(this, &SceneCreateDialog::accept_create).unbind(1)); diff --git a/editor/scene_tree_dock.cpp b/editor/scene_tree_dock.cpp index 651f43497339..21317593c160 100644 --- a/editor/scene_tree_dock.cpp +++ b/editor/scene_tree_dock.cpp @@ -1249,6 +1249,9 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) { case TOOL_HIDE_FILTERED_OUT_PARENTS: { scene_tree->set_hide_filtered_out_parents(!EDITOR_GET("docks/scene_tree/hide_filtered_out_parents"), true); } break; + case TOOL_ACCESSIBILITY_WARNINGS: { + scene_tree->set_accessibility_warnings(!EDITOR_GET("docks/scene_tree/accessibility_warnings"), true); + } break; case TOOL_SCENE_EDITABLE_CHILDREN: { if (!profile_allow_editing) { break; @@ -1617,6 +1620,7 @@ void SceneTreeDock::_notification(int p_what) { node_shortcuts_toggle = memnew(Button); node_shortcuts_toggle->set_flat(true); + node_shortcuts_toggle->set_accessibility_name(TTRC("Favorite Nodes")); node_shortcuts_toggle->set_button_icon(get_editor_theme_icon(SNAME("Favorites"))); node_shortcuts_toggle->set_toggle_mode(true); node_shortcuts_toggle->set_tooltip_text(TTR("Toggle the display of favorite nodes.")); @@ -1679,6 +1683,7 @@ void SceneTreeDock::_notification(int p_what) { clear_inherit_confirm->connect(SceneStringName(confirmed), callable_mp(this, &SceneTreeDock::_tool_selected).bind(TOOL_SCENE_CLEAR_INHERITANCE_CONFIRM, false)); scene_tree->set_auto_expand_selected(EDITOR_GET("docks/scene_tree/auto_expand_to_selected"), false); scene_tree->set_hide_filtered_out_parents(EDITOR_GET("docks/scene_tree/hide_filtered_out_parents"), false); + scene_tree->set_accessibility_warnings(EDITOR_GET("docks/scene_tree/accessibility_warnings"), false); } break; case NOTIFICATION_EXIT_TREE: { @@ -1689,6 +1694,7 @@ void SceneTreeDock::_notification(int p_what) { if (EditorSettings::get_singleton()->check_changed_settings_in_group("docks/scene_tree")) { scene_tree->set_auto_expand_selected(EDITOR_GET("docks/scene_tree/auto_expand_to_selected"), false); scene_tree->set_hide_filtered_out_parents(EDITOR_GET("docks/scene_tree/hide_filtered_out_parents"), false); + scene_tree->set_accessibility_warnings(EDITOR_GET("docks/scene_tree/accessibility_warnings"), false); } } break; @@ -3981,6 +3987,9 @@ void SceneTreeDock::_update_tree_menu() { tree_menu->set_item_checked(-1, EDITOR_GET("docks/scene_tree/hide_filtered_out_parents")); tree_menu->add_separator(); + tree_menu->add_check_item(TTR("Show Accessibility Warnings"), TOOL_ACCESSIBILITY_WARNINGS); + tree_menu->set_item_checked(tree_menu->get_item_index(TOOL_ACCESSIBILITY_WARNINGS), EDITOR_GET("docks/scene_tree/accessibility_warnings")); + PopupMenu *resource_list = memnew(PopupMenu); resource_list->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); resource_list->connect("about_to_popup", callable_mp(this, &SceneTreeDock::_list_all_subresources).bind(resource_list)); @@ -4674,6 +4683,7 @@ SceneTreeDock::SceneTreeDock(Node *p_scene_root, EditorSelection *p_editor_selec button_add->set_theme_type_variation("FlatMenuButton"); button_add->connect(SceneStringName(pressed), callable_mp(this, &SceneTreeDock::_tool_selected).bind(TOOL_NEW, false)); button_add->set_tooltip_text(TTRC("Add/Create a New Node.")); + button_add->set_accessibility_name(TTRC("Add/Create")); button_add->set_shortcut(ED_GET_SHORTCUT("scene_tree/add_child_node")); filter_hbc->add_child(button_add); @@ -4681,6 +4691,7 @@ SceneTreeDock::SceneTreeDock(Node *p_scene_root, EditorSelection *p_editor_selec button_instance->set_theme_type_variation("FlatMenuButton"); button_instance->connect(SceneStringName(pressed), callable_mp(this, &SceneTreeDock::_tool_selected).bind(TOOL_INSTANTIATE, false)); button_instance->set_tooltip_text(TTRC("Instantiate a scene file as a Node. Creates an inherited scene if no root node exists.")); + button_instance->set_accessibility_name(TTRC("Instantiate Scene File")); button_instance->set_shortcut(ED_GET_SHORTCUT("scene_tree/instantiate_scene")); filter_hbc->add_child(button_instance); vbc->add_child(filter_hbc); @@ -4689,6 +4700,7 @@ SceneTreeDock::SceneTreeDock(Node *p_scene_root, EditorSelection *p_editor_selec filter = memnew(LineEdit); filter->set_h_size_flags(SIZE_EXPAND_FILL); filter->set_placeholder(TTR("Filter: name, t:type, g:group")); + filter->set_accessibility_name(TTRC("Filter")); filter->set_tooltip_text(TTR("Filter nodes by entering a part of their name, type (if prefixed with \"type:\" or \"t:\")\nor group (if prefixed with \"group:\" or \"g:\"). Filtering is case-insensitive.")); filter_hbc->add_child(filter); filter->add_theme_constant_override("minimum_character_width", 0); @@ -4706,6 +4718,7 @@ SceneTreeDock::SceneTreeDock(Node *p_scene_root, EditorSelection *p_editor_selec button_create_script->set_theme_type_variation("FlatMenuButton"); button_create_script->connect(SceneStringName(pressed), callable_mp(this, &SceneTreeDock::_tool_selected).bind(TOOL_ATTACH_SCRIPT, false)); button_create_script->set_tooltip_text(TTRC("Attach a new or existing script to the selected node.")); + button_create_script->set_accessibility_name(TTRC("Attach Script")); button_create_script->set_shortcut(ED_GET_SHORTCUT("scene_tree/attach_script")); filter_hbc->add_child(button_create_script); button_create_script->hide(); @@ -4714,6 +4727,7 @@ SceneTreeDock::SceneTreeDock(Node *p_scene_root, EditorSelection *p_editor_selec button_detach_script->set_theme_type_variation("FlatMenuButton"); button_detach_script->connect(SceneStringName(pressed), callable_mp(this, &SceneTreeDock::_tool_selected).bind(TOOL_DETACH_SCRIPT, false)); button_detach_script->set_tooltip_text(TTRC("Detach the script from the selected node.")); + button_detach_script->set_accessibility_name(TTRC("Detach Script")); button_detach_script->set_shortcut(ED_GET_SHORTCUT("scene_tree/detach_script")); filter_hbc->add_child(button_detach_script); button_detach_script->hide(); @@ -4722,6 +4736,7 @@ SceneTreeDock::SceneTreeDock(Node *p_scene_root, EditorSelection *p_editor_selec button_extend_script->set_flat(true); button_extend_script->connect(SceneStringName(pressed), callable_mp(this, &SceneTreeDock::_tool_selected).bind(TOOL_EXTEND_SCRIPT, false)); button_extend_script->set_tooltip_text(TTRC("Extend the script of the selected node.")); + button_extend_script->set_accessibility_name(TTRC("Extend Script")); button_extend_script->set_shortcut(ED_GET_SHORTCUT("scene_tree/extend_script")); filter_hbc->add_child(button_extend_script); button_extend_script->hide(); @@ -4730,6 +4745,7 @@ SceneTreeDock::SceneTreeDock(Node *p_scene_root, EditorSelection *p_editor_selec button_tree_menu->set_flat(false); button_tree_menu->set_theme_type_variation("FlatMenuButton"); button_tree_menu->set_tooltip_text(TTR("Extra scene options.")); + button_tree_menu->set_accessibility_name(TTRC("Scene Options")); button_tree_menu->connect("about_to_popup", callable_mp(this, &SceneTreeDock::_update_tree_menu)); filter_hbc->add_child(button_tree_menu); diff --git a/editor/scene_tree_dock.h b/editor/scene_tree_dock.h index 164d971b7dda..8968d33b8ccc 100644 --- a/editor/scene_tree_dock.h +++ b/editor/scene_tree_dock.h @@ -88,6 +88,7 @@ class SceneTreeDock : public VBoxContainer { TOOL_CREATE_FAVORITE, TOOL_CENTER_PARENT, TOOL_HIDE_FILTERED_OUT_PARENTS, + TOOL_ACCESSIBILITY_WARNINGS, }; enum { diff --git a/editor/script_create_dialog.cpp b/editor/script_create_dialog.cpp index 4850b4cc1e39..2bb12e739062 100644 --- a/editor/script_create_dialog.cpp +++ b/editor/script_create_dialog.cpp @@ -874,6 +874,7 @@ ScriptCreateDialog::ScriptCreateDialog() { language_menu->set_custom_minimum_size(Size2(350, 0) * EDSCALE); language_menu->set_expand_icon(true); language_menu->set_h_size_flags(Control::SIZE_EXPAND_FILL); + language_menu->set_accessibility_name(TTRC("Language")); gc->add_child(memnew(Label(TTR("Language:")))); gc->add_child(language_menu); @@ -898,14 +899,17 @@ ScriptCreateDialog::ScriptCreateDialog() { HBoxContainer *hb = memnew(HBoxContainer); hb->set_h_size_flags(Control::SIZE_EXPAND_FILL); parent_name = memnew(LineEdit); + parent_name->set_accessibility_name(TTRC("Parent Name")); parent_name->connect(SceneStringName(text_changed), callable_mp(this, &ScriptCreateDialog::_parent_name_changed)); parent_name->set_h_size_flags(Control::SIZE_EXPAND_FILL); hb->add_child(parent_name); register_text_enter(parent_name); parent_search_button = memnew(Button); + parent_search_button->set_accessibility_name(TTRC("Search Parent")); parent_search_button->connect(SceneStringName(pressed), callable_mp(this, &ScriptCreateDialog::_browse_class_in_tree)); hb->add_child(parent_search_button); parent_browse_button = memnew(Button); + parent_browse_button->set_accessibility_name(TTRC("Select Parent")); parent_browse_button->connect(SceneStringName(pressed), callable_mp(this, &ScriptCreateDialog::_browse_path).bind(true, false)); hb->add_child(parent_browse_button); gc->add_child(memnew(Label(TTR("Inherits:")))); @@ -918,6 +922,7 @@ ScriptCreateDialog::ScriptCreateDialog() { use_templates = memnew(CheckBox); use_templates->set_pressed(is_using_templates); + use_templates->set_accessibility_name(TTRC("Use Template")); use_templates->connect(SceneStringName(pressed), callable_mp(this, &ScriptCreateDialog::_use_template_pressed)); template_hb->add_child(use_templates); @@ -925,6 +930,7 @@ ScriptCreateDialog::ScriptCreateDialog() { template_menu = memnew(OptionButton); template_menu->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); + template_menu->set_accessibility_name(TTRC("Template")); template_menu->set_h_size_flags(Control::SIZE_EXPAND_FILL); template_menu->connect(SceneStringName(item_selected), callable_mp(this, &ScriptCreateDialog::_template_changed)); template_hb->add_child(template_menu); @@ -935,6 +941,7 @@ ScriptCreateDialog::ScriptCreateDialog() { built_in = memnew(CheckBox); built_in->set_text(TTR("On")); + built_in->set_accessibility_name(TTRC("Built-in Script")); built_in->connect(SceneStringName(pressed), callable_mp(this, &ScriptCreateDialog::_built_in_pressed)); gc->add_child(memnew(Label(TTR("Built-in Script:")))); gc->add_child(built_in); @@ -944,11 +951,13 @@ ScriptCreateDialog::ScriptCreateDialog() { hb = memnew(HBoxContainer); hb->connect(SceneStringName(sort_children), callable_mp(this, &ScriptCreateDialog::_path_hbox_sorted)); file_path = memnew(LineEdit); + file_path->set_accessibility_name(TTRC("File Path")); file_path->connect(SceneStringName(text_changed), callable_mp(this, &ScriptCreateDialog::_path_changed)); file_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); hb->add_child(file_path); register_text_enter(file_path); path_button = memnew(Button); + path_button->set_accessibility_name(TTRC("Select File")); path_button->connect(SceneStringName(pressed), callable_mp(this, &ScriptCreateDialog::_browse_path).bind(false, true)); hb->add_child(path_button); Label *label = memnew(Label(TTR("Path:"))); @@ -961,6 +970,7 @@ ScriptCreateDialog::ScriptCreateDialog() { built_in_name = memnew(LineEdit); built_in_name->set_h_size_flags(Control::SIZE_EXPAND_FILL); + built_in_name->set_accessibility_name(TTRC("Name")); register_text_enter(built_in_name); label = memnew(Label(TTR("Name:"))); gc->add_child(label); diff --git a/editor/shader_create_dialog.cpp b/editor/shader_create_dialog.cpp index 684208f64a3c..f3d59b85799e 100644 --- a/editor/shader_create_dialog.cpp +++ b/editor/shader_create_dialog.cpp @@ -573,6 +573,7 @@ ShaderCreateDialog::ShaderCreateDialog() { type_menu = memnew(OptionButton); type_menu->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); + type_menu->set_accessibility_name(TTRC("Type")); type_menu->set_custom_minimum_size(Size2(250, 0) * EDSCALE); type_menu->set_h_size_flags(Control::SIZE_EXPAND_FILL); gc->add_child(memnew(Label(TTR("Type:")))); @@ -614,6 +615,7 @@ ShaderCreateDialog::ShaderCreateDialog() { mode_menu = memnew(OptionButton); mode_menu->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); + mode_menu->set_accessibility_name(TTRC("Mode")); for (const String &type_name : ShaderTypes::get_singleton()->get_types_list()) { mode_menu->add_item(type_name.capitalize()); } @@ -624,6 +626,7 @@ ShaderCreateDialog::ShaderCreateDialog() { // Templates. template_menu = memnew(OptionButton); + template_menu->set_accessibility_name(TTRC("Template")); gc->add_child(memnew(Label(TTR("Template:")))); gc->add_child(template_menu); template_menu->connect(SceneStringName(item_selected), callable_mp(this, &ShaderCreateDialog::_template_changed)); @@ -632,6 +635,7 @@ ShaderCreateDialog::ShaderCreateDialog() { internal = memnew(CheckBox); internal->set_text(TTR("On")); + internal->set_accessibility_name(TTRC("Built-in Shader")); internal->connect(SceneStringName(toggled), callable_mp(this, &ShaderCreateDialog::_built_in_toggled)); gc->add_child(memnew(Label(TTR("Built-in Shader:")))); gc->add_child(internal); @@ -647,6 +651,7 @@ ShaderCreateDialog::ShaderCreateDialog() { hb->add_child(file_path); register_text_enter(file_path); path_button = memnew(Button); + path_button->set_accessibility_name(TTRC("Select")); path_button->connect(SceneStringName(pressed), callable_mp(this, &ShaderCreateDialog::_browse_path)); hb->add_child(path_button); gc->add_child(memnew(Label(TTR("Path:")))); diff --git a/editor/themes/editor_theme_manager.cpp b/editor/themes/editor_theme_manager.cpp index 6bfe8816f945..6c7363de60d0 100644 --- a/editor/themes/editor_theme_manager.cpp +++ b/editor/themes/editor_theme_manager.cpp @@ -1480,6 +1480,7 @@ void EditorThemeManager::_populate_standard_styles(const Ref &p_the // Label. p_theme->set_stylebox(CoreStringName(normal), "Label", p_config.base_empty_style); + p_theme->set_stylebox("focus", "Label", p_config.button_style_focus); p_theme->set_color(SceneStringName(font_color), "Label", p_config.font_color); p_theme->set_color("font_shadow_color", "Label", Color(0, 0, 0, 0)); @@ -1546,6 +1547,7 @@ void EditorThemeManager::_populate_standard_styles(const Ref &p_the // GraphEdit. p_theme->set_stylebox(SceneStringName(panel), "GraphEdit", p_config.tree_panel_style); + p_theme->set_stylebox("panel_focus", "GraphEdit", p_config.button_style_focus); p_theme->set_stylebox("menu_panel", "GraphEdit", make_flat_stylebox(p_config.dark_color_1 * Color(1, 1, 1, 0.6), 4, 2, 4, 2, 3)); float grid_base_brightness = p_config.dark_theme ? 1.0 : 0.0; @@ -1677,9 +1679,11 @@ void EditorThemeManager::_populate_standard_styles(const Ref &p_the p_theme->set_stylebox(SceneStringName(panel), "GraphNode", gn_panel_style); p_theme->set_stylebox("panel_selected", "GraphNode", gn_panel_selected_style); + p_theme->set_stylebox("panel_focus", "GraphNode", p_config.button_style_focus); p_theme->set_stylebox("titlebar", "GraphNode", gn_titlebar_style); p_theme->set_stylebox("titlebar_selected", "GraphNode", gn_titlebar_selected_style); p_theme->set_stylebox("slot", "GraphNode", gn_slot_style); + p_theme->set_stylebox("slot_selected", "GraphNode", p_config.button_style_focus); p_theme->set_color("resizer_color", "GraphNode", gn_decoration_color); diff --git a/main/main.cpp b/main/main.cpp index 0cea51cacf99..fdc04b86dd28 100644 --- a/main/main.cpp +++ b/main/main.cpp @@ -202,6 +202,8 @@ static int audio_driver_idx = -1; // Engine config/tools +static DisplayServer::AccessibilityMode accessibility_mode = DisplayServer::AccessibilityMode::ACCESSIBILITY_AUTO; +static bool accessibility_mode_set = false; static bool single_window = false; static bool editor = false; static bool project_manager = false; @@ -616,6 +618,7 @@ void Main::print_help(const char *p_binary) { print_help_option("--xr-mode ", "Select XR (Extended Reality) mode [\"default\", \"off\", \"on\"].\n"); #endif print_help_option("--wid ", "Request parented to window.\n"); + print_help_option("--accessibility ", "Select accessibility mode ['auto' (when screen reader is running, default), 'always', 'disabled'].\n"); print_help_title("Debug options"); print_help_option("-d, --debug", "Debug (local stdout debugger).\n"); @@ -1300,6 +1303,27 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph } else if (arg == "--single-window") { // force single window single_window = true; + } else if (arg == "--accessibility") { + if (N) { + String string = N->get(); + if (string == "auto") { + accessibility_mode = DisplayServer::AccessibilityMode::ACCESSIBILITY_AUTO; + accessibility_mode_set = true; + } else if (string == "always") { + accessibility_mode = DisplayServer::AccessibilityMode::ACCESSIBILITY_ALWAYS; + accessibility_mode_set = true; + } else if (string == "disabled") { + accessibility_mode = DisplayServer::AccessibilityMode::ACCESSIBILITY_DISABLED; + accessibility_mode_set = true; + } else { + OS::get_singleton()->print("Accessibility mode argument not recognized, aborting.\n"); + goto error; + } + N = N->next(); + } else { + OS::get_singleton()->print("Missing accessibility mode argument, aborting.\n"); + goto error; + } } else if (arg == "-t" || arg == "--always-on-top") { // force always-on-top window init_always_on_top = true; @@ -2360,14 +2384,16 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph default_renderer_mobile = "gl_compatibility"; } #endif - if (renderer_hints.is_empty()) { - ERR_PRINT("No renderers available."); + if (!renderer_hints.is_empty()) { + renderer_hints += ","; } + renderer_hints += "dummy"; if (!rendering_method.is_empty()) { if (rendering_method != "forward_plus" && rendering_method != "mobile" && - rendering_method != "gl_compatibility") { + rendering_method != "gl_compatibility" && + rendering_method != "dummy") { OS::get_singleton()->print("Unknown rendering method '%s', aborting.\nValid options are ", rendering_method.utf8().get_data()); @@ -2435,7 +2461,9 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph // Set a default renderer if none selected. Try to choose one that matches the driver. if (rendering_method.is_empty()) { - if (rendering_driver == "opengl3" || rendering_driver == "opengl3_angle" || rendering_driver == "opengl3_es") { + if (rendering_driver == "dummy") { + rendering_method = "dummy"; + } else if (rendering_driver == "opengl3" || rendering_driver == "opengl3_angle" || rendering_driver == "opengl3_es") { rendering_method = "gl_compatibility"; } else { rendering_method = "forward_plus"; @@ -2463,6 +2491,9 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph available_drivers.push_back("opengl3_es"); } #endif + if (rendering_method == "dummy") { + available_drivers.push_back("dummy"); + } if (available_drivers.is_empty()) { OS::get_singleton()->print("Unknown renderer name '%s', aborting.\n", rendering_method.utf8().get_data()); goto error; @@ -2499,7 +2530,9 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph } if (rendering_driver.is_empty()) { - if (rendering_method == "gl_compatibility") { + if (rendering_method == "dummy") { + rendering_driver = "dummy"; + } else if (rendering_method == "gl_compatibility") { rendering_driver = GLOBAL_GET("rendering/gl_compatibility/driver"); } else { rendering_driver = GLOBAL_GET("rendering/rendering_device/driver"); @@ -3095,6 +3128,11 @@ Error Main::setup2(bool p_show_boot_logo) { } #endif + if (!accessibility_mode_set) { + accessibility_mode = (DisplayServer::AccessibilityMode)GLOBAL_GET("accessibility/general/accessibility_support").operator int64_t(); + } + DisplayServer::accessibility_set_mode(accessibility_mode); + // rendering_driver now held in static global String in main and initialized in setup() Error err; display_server = DisplayServer::create(display_driver_idx, rendering_driver, window_mode, window_vsync_mode, window_flags, window_position, window_size, init_screen, context, init_embed_parent_window_id, err); @@ -4791,7 +4829,12 @@ bool Main::iteration() { return exit; } - OS::get_singleton()->add_frame_delay(DisplayServer::get_singleton()->window_can_draw()); + SceneTree *scene_tree = SceneTree::get_singleton(); + bool skip_delay = scene_tree && scene_tree->is_accessibility_enabled(); + + if (!skip_delay) { + OS::get_singleton()->add_frame_delay(DisplayServer::get_singleton()->window_can_draw()); + } #ifdef TOOLS_ENABLED if (auto_build_solutions) { diff --git a/misc/extension_api_validation/4.4-stable.expected b/misc/extension_api_validation/4.4-stable.expected index a7b4de861847..ceafe8269b53 100644 --- a/misc/extension_api_validation/4.4-stable.expected +++ b/misc/extension_api_validation/4.4-stable.expected @@ -31,3 +31,13 @@ GH-104890 Validate extension JSON: API was removed: classes/JSONRPC/methods/set_scope Replaced `set_scope` with `set_method`. Compatibility method registered for binary compatibility. Manual upgrade required by users to retain functionality. + + +GH-76829 +-------- +Validate extension JSON: Error: Field 'classes/RichTextLabel/methods/add_image/arguments': size changed value in new API, from 6 to 11. +Validate extension JSON: Error: Field 'classes/RichTextLabel/methods/add_image/arguments': size changed value in new API, from 10 to 11. +Validate extension JSON: Error: Field 'classes/RichTextLabel/methods/push_table/arguments': size changed value in new API, from 3 to 4. +Validate extension JSON: Error: Field 'classes/TreeItem/methods/add_button/arguments': size changed value in new API, from 5 to 6. + +Added optional arguments. Compatibility methods registered. diff --git a/modules/gltf/editor/editor_scene_importer_blend.cpp b/modules/gltf/editor/editor_scene_importer_blend.cpp index d56a3be73829..c55b9ba20f5d 100644 --- a/modules/gltf/editor/editor_scene_importer_blend.cpp +++ b/modules/gltf/editor/editor_scene_importer_blend.cpp @@ -515,6 +515,7 @@ bool EditorFileSystemImportFormatSupportQueryBlend::query() { blender_path = memnew(LineEdit); blender_path->set_h_size_flags(Control::SIZE_EXPAND_FILL); + blender_path->set_accessibility_name(TTRC("Path")); hb->add_child(blender_path); blender_path_browse = memnew(Button); diff --git a/modules/gridmap/editor/grid_map_editor_plugin.cpp b/modules/gridmap/editor/grid_map_editor_plugin.cpp index b1f0cfd3f61d..bcd46b549144 100644 --- a/modules/gridmap/editor/grid_map_editor_plugin.cpp +++ b/modules/gridmap/editor/grid_map_editor_plugin.cpp @@ -1365,6 +1365,7 @@ GridMapEditor::GridMapEditor() { settings_pick_distance->set_min(500.0f); settings_pick_distance->set_step(1.0f); settings_pick_distance->set_value(EDITOR_GET("editors/grid_map/pick_distance")); + settings_pick_distance->set_accessibility_name(TTRC("Pick Distance")); settings_vbc->add_margin_child(TTR("Pick Distance:"), settings_pick_distance); options->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &GridMapEditor::_menu_option)); @@ -1382,6 +1383,7 @@ GridMapEditor::GridMapEditor() { transform_mode_button->set_toggle_mode(true); transform_mode_button->set_button_group(mode_buttons_group); transform_mode_button->set_shortcut(ED_SHORTCUT("grid_map/transform_tool", TTRC("Transform"), Key::T, true)); + transform_mode_button->set_accessibility_name(TTRC("Transform")); transform_mode_button->connect(SceneStringName(toggled), callable_mp(this, &GridMapEditor::_on_tool_mode_changed).unbind(1)); mode_buttons->add_child(transform_mode_button); @@ -1394,6 +1396,7 @@ GridMapEditor::GridMapEditor() { select_mode_button->set_toggle_mode(true); select_mode_button->set_button_group(mode_buttons_group); select_mode_button->set_shortcut(ED_SHORTCUT("grid_map/selection_tool", TTRC("Selection"), Key::Q, true)); + select_mode_button->set_accessibility_name(TTRC("Select")); select_mode_button->connect(SceneStringName(toggled), callable_mp(this, &GridMapEditor::_on_tool_mode_changed).unbind(1)); mode_buttons->add_child(select_mode_button); @@ -1404,6 +1407,7 @@ GridMapEditor::GridMapEditor() { erase_mode_button->set_toggle_mode(true); erase_mode_button->set_button_group(mode_buttons_group); erase_mode_button->set_shortcut(ED_SHORTCUT("grid_map/erase_tool", TTRC("Erase"), Key::W, true)); + erase_mode_button->set_accessibility_name(TTRC("Erase")); mode_buttons->add_child(erase_mode_button); erase_mode_button->connect(SceneStringName(toggled), callable_mp(this, &GridMapEditor::_on_tool_mode_changed).unbind(1)); @@ -1414,6 +1418,7 @@ GridMapEditor::GridMapEditor() { paint_mode_button->set_toggle_mode(true); paint_mode_button->set_button_group(mode_buttons_group); paint_mode_button->set_shortcut(ED_SHORTCUT("grid_map/paint_tool", TTRC("Paint"), Key::E, true)); + paint_mode_button->set_accessibility_name(TTRC("Paint")); paint_mode_button->connect(SceneStringName(toggled), callable_mp(this, &GridMapEditor::_on_tool_mode_changed).unbind(1)); mode_buttons->add_child(paint_mode_button); @@ -1424,6 +1429,7 @@ GridMapEditor::GridMapEditor() { pick_mode_button->set_toggle_mode(true); pick_mode_button->set_button_group(mode_buttons_group); pick_mode_button->set_shortcut(ED_SHORTCUT("grid_map/pick_tool", TTRC("Pick"), Key::R, true)); + pick_mode_button->set_accessibility_name(TTRC("Pick")); pick_mode_button->connect(SceneStringName(toggled), callable_mp(this, &GridMapEditor::_on_tool_mode_changed).unbind(1)); mode_buttons->add_child(pick_mode_button); @@ -1438,6 +1444,7 @@ GridMapEditor::GridMapEditor() { fill_action_button = memnew(Button); fill_action_button->set_theme_type_variation(SceneStringName(FlatButton)); fill_action_button->set_shortcut(ED_SHORTCUT("grid_map/fill_tool", TTRC("Fill"), Key::Z, true)); + fill_action_button->set_accessibility_name(TTRC("Fill")); fill_action_button->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_menu_option).bind(MENU_OPTION_SELECTION_FILL)); action_buttons->add_child(fill_action_button); @@ -1446,6 +1453,7 @@ GridMapEditor::GridMapEditor() { move_action_button = memnew(Button); move_action_button->set_theme_type_variation(SceneStringName(FlatButton)); move_action_button->set_shortcut(ED_SHORTCUT("grid_map/move_tool", TTRC("Move"), Key::X, true)); + fill_action_button->set_accessibility_name(TTRC("Move")); move_action_button->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_menu_option).bind(MENU_OPTION_SELECTION_CUT)); action_buttons->add_child(move_action_button); @@ -1454,6 +1462,7 @@ GridMapEditor::GridMapEditor() { duplicate_action_button = memnew(Button); duplicate_action_button->set_theme_type_variation(SceneStringName(FlatButton)); duplicate_action_button->set_shortcut(ED_SHORTCUT("grid_map/duplicate_tool", TTRC("Duplicate"), Key::C, true)); + duplicate_action_button->set_accessibility_name(TTRC("Duplicate")); duplicate_action_button->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_menu_option).bind(MENU_OPTION_SELECTION_DUPLICATE)); action_buttons->add_child(duplicate_action_button); @@ -1462,6 +1471,7 @@ GridMapEditor::GridMapEditor() { delete_action_button = memnew(Button); delete_action_button->set_theme_type_variation(SceneStringName(FlatButton)); delete_action_button->set_shortcut(ED_SHORTCUT("grid_map/delete_tool", TTRC("Delete"), Key::V, true)); + delete_action_button->set_accessibility_name(TTRC("Delete")); delete_action_button->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_menu_option).bind(MENU_OPTION_SELECTION_CLEAR)); action_buttons->add_child(delete_action_button); @@ -1476,6 +1486,7 @@ GridMapEditor::GridMapEditor() { rotate_x_button = memnew(Button); rotate_x_button->set_theme_type_variation(SceneStringName(FlatButton)); rotate_x_button->set_shortcut(ED_SHORTCUT("grid_map/cursor_rotate_x", TTRC("Cursor Rotate X"), Key::A, true)); + rotate_x_button->set_accessibility_name(TTRC("Rotate X")); rotate_x_button->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_menu_option).bind(MENU_OPTION_CURSOR_ROTATE_X)); rotation_buttons->add_child(rotate_x_button); @@ -1484,6 +1495,7 @@ GridMapEditor::GridMapEditor() { rotate_y_button = memnew(Button); rotate_y_button->set_theme_type_variation(SceneStringName(FlatButton)); rotate_y_button->set_shortcut(ED_SHORTCUT("grid_map/cursor_rotate_y", TTRC("Cursor Rotate Y"), Key::S, true)); + rotate_y_button->set_accessibility_name(TTRC("Rotate Y")); rotate_y_button->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_menu_option).bind(MENU_OPTION_CURSOR_ROTATE_Y)); rotation_buttons->add_child(rotate_y_button); @@ -1507,6 +1519,7 @@ GridMapEditor::GridMapEditor() { floor->set_min(-32767); floor->set_max(32767); floor->set_step(1); + floor->set_accessibility_name(TTRC("Grid Floor")); floor->set_tooltip_text( vformat(TTR("Change Grid Floor:\nPrevious Plane (%s)\nNext Plane (%s)"), ED_GET_SHORTCUT("grid_map/previous_floor")->get_as_text(), @@ -1521,6 +1534,7 @@ GridMapEditor::GridMapEditor() { search_box = memnew(LineEdit); search_box->add_theme_constant_override("minimum_character_width", 10); search_box->set_placeholder(TTR("Filter Meshes")); + search_box->set_accessibility_name(TTRC("Filter Meshes")); search_box->set_clear_button_enabled(true); toolbar->add_child(search_box); search_box->connect(SceneStringName(text_changed), callable_mp(this, &GridMapEditor::_text_changed)); @@ -1537,6 +1551,7 @@ GridMapEditor::GridMapEditor() { mode_thumbnail = memnew(Button); mode_thumbnail->set_theme_type_variation(SceneStringName(FlatButton)); mode_thumbnail->set_toggle_mode(true); + mode_thumbnail->set_accessibility_name(TTRC("View as Thumbnails")); mode_thumbnail->set_pressed(true); toolbar->add_child(mode_thumbnail); mode_thumbnail->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_set_display_mode).bind(DISPLAY_THUMBNAIL)); @@ -1544,6 +1559,7 @@ GridMapEditor::GridMapEditor() { mode_list = memnew(Button); mode_list->set_theme_type_variation(SceneStringName(FlatButton)); mode_list->set_toggle_mode(true); + mode_list->set_accessibility_name(TTRC("View as List")); mode_list->set_pressed(false); toolbar->add_child(mode_list); mode_list->connect(SceneStringName(pressed), callable_mp(this, &GridMapEditor::_set_display_mode).bind(DISPLAY_LIST)); diff --git a/modules/interactive_music/editor/audio_stream_interactive_editor_plugin.cpp b/modules/interactive_music/editor/audio_stream_interactive_editor_plugin.cpp index 71a2fcd2f96f..36d2913d8b3a 100644 --- a/modules/interactive_music/editor/audio_stream_interactive_editor_plugin.cpp +++ b/modules/interactive_music/editor/audio_stream_interactive_editor_plugin.cpp @@ -341,6 +341,7 @@ AudioStreamInteractiveTransitionEditor::AudioStreamInteractiveTransitionEditor() transition_enabled = memnew(CheckBox); transition_enabled->set_text(TTR("Enabled")); + transition_enabled->set_accessibility_name(TTRC("Use Transition")); edit_vb->add_margin_child(TTR("Use Transition:"), transition_enabled); transition_enabled->connect(SceneStringName(pressed), callable_mp(this, &AudioStreamInteractiveTransitionEditor::_edited)); @@ -350,6 +351,7 @@ AudioStreamInteractiveTransitionEditor::AudioStreamInteractiveTransitionEditor() transition_from->add_item(TTR("Next Beat"), AudioStreamInteractive::TRANSITION_FROM_TIME_NEXT_BEAT); transition_from->add_item(TTR("Next Bar"), AudioStreamInteractive::TRANSITION_FROM_TIME_NEXT_BAR); transition_from->add_item(TTR("Clip End"), AudioStreamInteractive::TRANSITION_FROM_TIME_END); + transition_from->set_accessibility_name(TTRC("Transition From")); transition_from->connect(SceneStringName(item_selected), callable_mp(this, &AudioStreamInteractiveTransitionEditor::_edited).unbind(1)); @@ -358,25 +360,30 @@ AudioStreamInteractiveTransitionEditor::AudioStreamInteractiveTransitionEditor() transition_to->add_item(TTR("Same Position"), AudioStreamInteractive::TRANSITION_TO_TIME_SAME_POSITION); transition_to->add_item(TTR("Clip Start"), AudioStreamInteractive::TRANSITION_TO_TIME_START); transition_to->add_item(TTR("Prev Position"), AudioStreamInteractive::TRANSITION_TO_TIME_PREVIOUS_POSITION); + transition_to->set_accessibility_name(TTRC("Transition To")); transition_to->connect(SceneStringName(item_selected), callable_mp(this, &AudioStreamInteractiveTransitionEditor::_edited).unbind(1)); fade_mode = memnew(OptionButton); edit_vb->add_margin_child(TTR("Fade Mode:"), fade_mode); fade_mode->connect(SceneStringName(item_selected), callable_mp(this, &AudioStreamInteractiveTransitionEditor::_edited).unbind(1)); + fade_mode->set_accessibility_name(TTRC("Fade Mode")); fade_beats = memnew(SpinBox); edit_vb->add_margin_child(TTR("Fade Beats:"), fade_beats); fade_beats->set_max(16); fade_beats->set_step(0.1); fade_beats->connect(SceneStringName(value_changed), callable_mp(this, &AudioStreamInteractiveTransitionEditor::_edited).unbind(1)); + fade_beats->set_accessibility_name(TTRC("Fade Beats")); filler_clip = memnew(OptionButton); edit_vb->add_margin_child(TTR("Filler Clip:"), filler_clip); filler_clip->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); filler_clip->connect(SceneStringName(item_selected), callable_mp(this, &AudioStreamInteractiveTransitionEditor::_edited).unbind(1)); + filler_clip->set_accessibility_name(TTRC("Filler Clip")); hold_previous = memnew(CheckBox); hold_previous->set_text(TTR("Enabled")); + hold_previous->set_accessibility_name(TTRC("Hold Previous")); hold_previous->connect(SceneStringName(pressed), callable_mp(this, &AudioStreamInteractiveTransitionEditor::_edited)); edit_vb->add_margin_child(TTR("Hold Previous:"), hold_previous); diff --git a/modules/multiplayer/editor/editor_network_profiler.cpp b/modules/multiplayer/editor/editor_network_profiler.cpp index 5a2611added9..0c0f5a45d1e1 100644 --- a/modules/multiplayer/editor/editor_network_profiler.cpp +++ b/modules/multiplayer/editor/editor_network_profiler.cpp @@ -339,6 +339,7 @@ EditorNetworkProfiler::EditorNetworkProfiler() { incoming_bandwidth_text->set_editable(false); incoming_bandwidth_text->set_custom_minimum_size(Size2(120, 0) * EDSCALE); incoming_bandwidth_text->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_RIGHT); + incoming_bandwidth_text->set_accessibility_name(TTRC("Incoming Bandwidth")); hb->add_child(incoming_bandwidth_text); Control *down_up_spacer = memnew(Control); @@ -354,6 +355,7 @@ EditorNetworkProfiler::EditorNetworkProfiler() { outgoing_bandwidth_text->set_editable(false); outgoing_bandwidth_text->set_custom_minimum_size(Size2(120, 0) * EDSCALE); outgoing_bandwidth_text->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_RIGHT); + outgoing_bandwidth_text->set_accessibility_name(TTRC("Outgoing Bandwidth")); hb->add_child(outgoing_bandwidth_text); // Set initial texts in the incoming/outgoing bandwidth labels diff --git a/modules/multiplayer/editor/replication_editor.cpp b/modules/multiplayer/editor/replication_editor.cpp index e861acc83f62..797d2cf320f5 100644 --- a/modules/multiplayer/editor/replication_editor.cpp +++ b/modules/multiplayer/editor/replication_editor.cpp @@ -234,6 +234,7 @@ ReplicationEditor::ReplicationEditor() { np_line_edit = memnew(LineEdit); np_line_edit->set_placeholder(":property"); + np_line_edit->set_accessibility_name(TTRC("Path")); np_line_edit->set_h_size_flags(SIZE_EXPAND_FILL); np_line_edit->connect(SceneStringName(text_submitted), callable_mp(this, &ReplicationEditor::_np_text_submitted)); hb->add_child(np_line_edit); @@ -251,6 +252,7 @@ ReplicationEditor::ReplicationEditor() { pin->set_theme_type_variation(SceneStringName(FlatButton)); pin->set_toggle_mode(true); pin->set_tooltip_text(TTR("Pin replication editor")); + pin->set_accessibility_name(TTRC("Pin")); hb->add_child(pin); tree = memnew(Tree); diff --git a/modules/openxr/editor/openxr_action_editor.cpp b/modules/openxr/editor/openxr_action_editor.cpp index cca814a4e8e5..b4bb6d2f439a 100644 --- a/modules/openxr/editor/openxr_action_editor.cpp +++ b/modules/openxr/editor/openxr_action_editor.cpp @@ -137,6 +137,7 @@ OpenXRActionEditor::OpenXRActionEditor(Ref p_action) { action_name->set_tooltip_text(TTR("Internal name of the action. Some XR runtimes don't allow spaces or special characters.")); action_name->set_custom_minimum_size(Size2(150.0 * EDSCALE, 0.0)); action_name->connect(SceneStringName(text_changed), callable_mp(this, &OpenXRActionEditor::_on_action_name_changed)); + action_name->set_accessibility_name(TTRC("Action Name")); add_child(action_name); action_localized_name = memnew(LineEdit); @@ -145,6 +146,7 @@ OpenXRActionEditor::OpenXRActionEditor(Ref p_action) { action_localized_name->set_custom_minimum_size(Size2(150.0 * EDSCALE, 0.0)); action_localized_name->set_h_size_flags(Control::SIZE_EXPAND_FILL); action_localized_name->connect(SceneStringName(text_changed), callable_mp(this, &OpenXRActionEditor::_on_action_localized_name_changed)); + action_localized_name->set_accessibility_name(TTRC("Action Localized Name")); add_child(action_localized_name); action_type_button = memnew(OptionButton); @@ -154,6 +156,7 @@ OpenXRActionEditor::OpenXRActionEditor(Ref p_action) { action_type_button->add_item("Vector2", OpenXRAction::OPENXR_ACTION_VECTOR2); action_type_button->add_item("Pose", OpenXRAction::OPENXR_ACTION_POSE); action_type_button->add_item("Haptic", OpenXRAction::OPENXR_ACTION_HAPTIC); + action_type_button->set_accessibility_name(TTRC("Action Type")); action_type_button->select(int(action->get_action_type())); action_type_button->set_custom_minimum_size(Size2(100.0 * EDSCALE, 0.0)); action_type_button->connect(SceneStringName(item_selected), callable_mp(this, &OpenXRActionEditor::_on_item_selected)); @@ -163,6 +166,7 @@ OpenXRActionEditor::OpenXRActionEditor(Ref p_action) { rem_action = memnew(Button); rem_action->set_tooltip_text(TTR("Remove action")); + rem_action->set_accessibility_name(TTRC("Remove action")); rem_action->connect(SceneStringName(pressed), callable_mp(this, &OpenXRActionEditor::_on_remove_action)); rem_action->set_flat(true); add_child(rem_action); diff --git a/modules/openxr/editor/openxr_action_set_editor.cpp b/modules/openxr/editor/openxr_action_set_editor.cpp index c26255d73b4c..06c5d48d159e 100644 --- a/modules/openxr/editor/openxr_action_set_editor.cpp +++ b/modules/openxr/editor/openxr_action_set_editor.cpp @@ -231,6 +231,7 @@ OpenXRActionSetEditor::OpenXRActionSetEditor(Ref p_action_map, fold_btn = memnew(Button); fold_btn->set_v_size_flags(Control::SIZE_SHRINK_BEGIN); fold_btn->connect(SceneStringName(pressed), callable_mp(this, &OpenXRActionSetEditor::_on_toggle_expand)); + fold_btn->set_accessibility_name(TTRC("Fold")); fold_btn->set_flat(true); panel_hb->add_child(fold_btn); @@ -247,6 +248,7 @@ OpenXRActionSetEditor::OpenXRActionSetEditor(Ref p_action_map, action_set_name->set_tooltip_text(TTR("Internal name of the action. Some XR runtimes don't allow spaces or special characters.")); action_set_name->set_custom_minimum_size(Size2(150.0 * EDSCALE, 0.0)); action_set_name->connect(SceneStringName(text_changed), callable_mp(this, &OpenXRActionSetEditor::_on_action_set_name_changed)); + action_set_name->set_accessibility_name(TTRC("Action Set Name")); action_set_hb->add_child(action_set_name); action_set_localized_name = memnew(LineEdit); @@ -255,6 +257,7 @@ OpenXRActionSetEditor::OpenXRActionSetEditor(Ref p_action_map, action_set_localized_name->set_custom_minimum_size(Size2(150.0 * EDSCALE, 0.0)); action_set_localized_name->set_h_size_flags(Control::SIZE_EXPAND_FILL); action_set_localized_name->connect(SceneStringName(text_changed), callable_mp(this, &OpenXRActionSetEditor::_on_action_set_localized_name_changed)); + action_set_localized_name->set_accessibility_name(TTRC("Action Set Localized Name")); action_set_hb->add_child(action_set_localized_name); action_set_priority = memnew(TextEdit); @@ -262,17 +265,20 @@ OpenXRActionSetEditor::OpenXRActionSetEditor(Ref p_action_map, action_set_priority->set_tooltip_text(TTR("Priority of the action set. If multiple action sets bind to the same input, the action set with the highest priority will be updated.")); action_set_priority->set_custom_minimum_size(Size2(50.0 * EDSCALE, 0.0)); action_set_priority->connect(SceneStringName(text_changed), callable_mp(this, &OpenXRActionSetEditor::_on_action_set_priority_changed)); + action_set_priority->set_accessibility_name(TTRC("Action Set Priority")); action_set_hb->add_child(action_set_priority); add_action = memnew(Button); add_action->set_tooltip_text(TTR("Add action.")); add_action->connect(SceneStringName(pressed), callable_mp(this, &OpenXRActionSetEditor::_on_add_action)); + add_action->set_accessibility_name(TTRC("Add")); add_action->set_flat(true); action_set_hb->add_child(add_action); rem_action_set = memnew(Button); rem_action_set->set_tooltip_text(TTR("Remove action set.")); rem_action_set->connect(SceneStringName(pressed), callable_mp(this, &OpenXRActionSetEditor::_on_remove_action_set)); + rem_action_set->set_accessibility_name(TTRC("Remove")); rem_action_set->set_flat(true); action_set_hb->add_child(rem_action_set); diff --git a/modules/openxr/editor/openxr_binding_modifier_editor.cpp b/modules/openxr/editor/openxr_binding_modifier_editor.cpp index 94d5b8d5f3fb..172dc686077f 100644 --- a/modules/openxr/editor/openxr_binding_modifier_editor.cpp +++ b/modules/openxr/editor/openxr_binding_modifier_editor.cpp @@ -263,6 +263,7 @@ OpenXRBindingModifierEditor::OpenXRBindingModifierEditor() { rem_binding_modifier_btn = memnew(Button); rem_binding_modifier_btn->set_tooltip_text(TTR("Remove this binding modifier.")); rem_binding_modifier_btn->connect(SceneStringName(pressed), callable_mp(this, &OpenXRBindingModifierEditor::_on_remove_binding_modifier)); + rem_binding_modifier_btn->set_accessibility_name(TTRC("Remove")); rem_binding_modifier_btn->set_flat(true); header_hb->add_child(rem_binding_modifier_btn); diff --git a/modules/openxr/editor/openxr_interaction_profile_editor.cpp b/modules/openxr/editor/openxr_interaction_profile_editor.cpp index 1e9fe3cadcc0..f4f26aebff38 100644 --- a/modules/openxr/editor/openxr_interaction_profile_editor.cpp +++ b/modules/openxr/editor/openxr_interaction_profile_editor.cpp @@ -181,6 +181,7 @@ OpenXRInteractionProfileEditorBase::OpenXRInteractionProfileEditorBase() { binding_modifiers_btn = memnew(Button); binding_modifiers_btn->set_tooltip_text(TTR("Edit binding modifiers")); binding_modifiers_btn->connect("pressed", callable_mp(this, &OpenXRInteractionProfileEditorBase::_on_open_binding_modifiers)); + binding_modifiers_btn->set_accessibility_name(TTRC("Edit")); // TODO show visual difference if there are binding modifiers for this interaction profile toolbar_vb->add_child(binding_modifiers_btn); } @@ -308,6 +309,7 @@ void OpenXRInteractionProfileEditor::_add_io_path(VBoxContainer *p_container, co action_binding_modifiers_btn->set_flat(true); action_binding_modifiers_btn->set_button_icon(get_theme_icon(SNAME("Modifiers"), EditorStringName(EditorIcons))); action_binding_modifiers_btn->connect(SceneStringName(pressed), callable_mp((Window *)action_binding_modifiers_dialog, &Window::popup_centered).bind(Size2i(500, 400))); + action_binding_modifiers_btn->set_accessibility_name(TTRC("Modifiers")); // TODO change style of button if there are binding modifiers action_hb->add_child(action_binding_modifiers_btn); @@ -315,6 +317,7 @@ void OpenXRInteractionProfileEditor::_add_io_path(VBoxContainer *p_container, co action_rem->set_flat(true); action_rem->set_button_icon(get_theme_icon(SNAME("Remove"), EditorStringName(EditorIcons))); action_rem->connect(SceneStringName(pressed), callable_mp((OpenXRInteractionProfileEditor *)this, &OpenXRInteractionProfileEditor::_on_remove_pressed).bind(action->get_name_with_set(), String(p_io_path->openxr_path))); + action_rem->set_accessibility_name(TTRC("Remove")); action_hb->add_child(action_rem); } } diff --git a/modules/text_server_adv/text_server_adv.cpp b/modules/text_server_adv/text_server_adv.cpp index e229af0418f2..68db69d3960a 100644 --- a/modules/text_server_adv/text_server_adv.cpp +++ b/modules/text_server_adv/text_server_adv.cpp @@ -4210,6 +4210,8 @@ void TextServerAdvanced::invalidate(TextServerAdvanced::ShapedTextDataAdvanced * p_shaped->uthk = 0.0; p_shaped->glyphs.clear(); p_shaped->glyphs_logical.clear(); + p_shaped->runs.clear(); + p_shaped->runs_dirty = true; p_shaped->overrun_trim_data = TrimData(); p_shaped->utf16 = Char16String(); for (int i = 0; i < p_shaped->bidi_iter.size(); i++) { @@ -4492,6 +4494,213 @@ Variant TextServerAdvanced::_shaped_get_span_embedded_object(const RID &p_shaped } } +String TextServerAdvanced::_shaped_get_span_text(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + ShapedTextDataAdvanced *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, String()); + } + ERR_FAIL_INDEX_V(p_index, span_sd->spans.size(), String()); + return span_sd->text.substr(span_sd->spans[p_index].start, span_sd->spans[p_index].end - span_sd->spans[p_index].start); +} + +Variant TextServerAdvanced::_shaped_get_span_object(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, Variant()); + ShapedTextDataAdvanced *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, Variant()); + } + ERR_FAIL_INDEX_V(p_index, span_sd->spans.size(), Variant()); + return span_sd->spans[p_index].embedded_key; +} + +void TextServerAdvanced::_generate_runs(ShapedTextDataAdvanced *p_sd) const { + ERR_FAIL_NULL(p_sd); + p_sd->runs.clear(); + + ShapedTextDataAdvanced *span_sd = p_sd; + if (p_sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(p_sd->parent); + ERR_FAIL_NULL(span_sd); + } + + int sd_size = p_sd->glyphs.size(); + const Glyph *sd_gl = p_sd->glyphs.ptr(); + + int span_count = span_sd->spans.size(); + int span = -1; + int span_start = -1; + int span_end = -1; + + TextRun run; + for (int i = 0; i < sd_size; i += sd_gl[i].count) { + const Glyph &gl = sd_gl[i]; + if (gl.start < 0 || gl.end < 0) { + continue; + } + if (gl.start < span_start || gl.start >= span_end) { + span = -1; + span_start = -1; + span_end = -1; + for (int j = 0; j < span_count; j++) { + if (gl.start >= span_sd->spans[j].start && gl.end <= span_sd->spans[j].end) { + span = j; + span_start = span_sd->spans[j].start; + span_end = span_sd->spans[j].end; + break; + } + } + } + if (run.font_rid != gl.font_rid || run.font_size != gl.font_size || run.span_index != span || run.rtl != bool(gl.flags & GRAPHEME_IS_RTL)) { + if (run.span_index >= 0) { + p_sd->runs.push_back(run); + } + run.range = Vector2i(gl.start, gl.end); + run.font_rid = gl.font_rid; + run.font_size = gl.font_size; + run.rtl = bool(gl.flags & GRAPHEME_IS_RTL); + run.span_index = span; + } + run.range.x = MIN(run.range.x, gl.start); + run.range.y = MAX(run.range.y, gl.end); + } + if (run.span_index >= 0) { + p_sd->runs.push_back(run); + } + p_sd->runs_dirty = false; +} + +int64_t TextServerAdvanced::_shaped_get_run_count(const RID &p_shaped) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, 0); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + return sd->runs.size(); +} + +String TextServerAdvanced::_shaped_get_run_text(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), String()); + return sd->text.substr(sd->runs[p_index].range.x - sd->start, sd->runs[p_index].range.y - sd->runs[p_index].range.x); +} + +Vector2i TextServerAdvanced::_shaped_get_run_range(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, Vector2i()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), Vector2i()); + return sd->runs[p_index].range; +} + +RID TextServerAdvanced::_shaped_get_run_font_rid(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, RID()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), RID()); + return sd->runs[p_index].font_rid; +} + +int TextServerAdvanced::_shaped_get_run_font_size(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, 0); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), 0); + return sd->runs[p_index].font_size; +} + +String TextServerAdvanced::_shaped_get_run_language(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), String()); + + int span_idx = sd->runs[p_index].span_index; + ShapedTextDataAdvanced *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, String()); + } + ERR_FAIL_INDEX_V(span_idx, span_sd->spans.size(), String()); + return span_sd->spans[span_idx].language; +} + +TextServer::Direction TextServerAdvanced::_shaped_get_run_direction(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, TextServer::DIRECTION_LTR); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), TextServer::DIRECTION_LTR); + return sd->runs[p_index].rtl ? TextServer::DIRECTION_RTL : TextServer::DIRECTION_LTR; +} + +Variant TextServerAdvanced::_shaped_get_run_object(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, Variant()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), Variant()); + + int span_idx = sd->runs[p_index].span_index; + ShapedTextDataAdvanced *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, Variant()); + } + ERR_FAIL_INDEX_V(span_idx, span_sd->spans.size(), Variant()); + return span_sd->spans[span_idx].embedded_key; +} + void TextServerAdvanced::_shaped_set_span_update_font(const RID &p_shaped, int64_t p_index, const TypedArray &p_fonts, int64_t p_size, const Dictionary &p_opentype_features) { ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); ERR_FAIL_NULL(sd); @@ -4575,6 +4784,13 @@ bool TextServerAdvanced::_shaped_text_add_object(const RID &p_shaped, const Vari return true; } +String TextServerAdvanced::_shaped_get_text(const RID &p_shaped) const { + const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + + return sd->text; +} + bool TextServerAdvanced::_shaped_text_resize_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align, double p_baseline) { ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped); ERR_FAIL_NULL_V(sd, false); @@ -4771,6 +4987,8 @@ bool TextServerAdvanced::_shape_substr(ShapedTextDataAdvanced *p_new_sd, const S p_new_sd->sort_valid = false; p_new_sd->upos = p_sd->upos; p_new_sd->uthk = p_sd->uthk; + p_new_sd->runs.clear(); + p_new_sd->runs_dirty = true; if (p_length > 0) { p_new_sd->text = p_sd->text.substr(p_start - p_sd->start, p_length); @@ -6560,6 +6778,8 @@ bool TextServerAdvanced::_shaped_text_shape(const RID &p_shaped) { } else { bidi_ranges = sd->bidi_override; } + sd->runs.clear(); + sd->runs_dirty = true; for (int ov = 0; ov < bidi_ranges.size(); ov++) { // Create BiDi iterator. diff --git a/modules/text_server_adv/text_server_adv.h b/modules/text_server_adv/text_server_adv.h index 2c2b52bc34d2..deb6e675c0ec 100644 --- a/modules/text_server_adv/text_server_adv.h +++ b/modules/text_server_adv/text_server_adv.h @@ -458,6 +458,14 @@ class TextServerAdvanced : public TextServerExtension { Vector ellipsis_glyph_buf; }; + struct TextRun { + Vector2i range; + RID font_rid; + int font_size = 0; + bool rtl = false; + int64_t span_index = -1; + }; + struct ShapedTextDataAdvanced { Mutex mutex; @@ -489,6 +497,9 @@ class TextServerAdvanced : public TextServerExtension { int first_span = 0; // First span in the parent ShapedTextData. int last_span = 0; + Vector runs; + bool runs_dirty = true; + struct EmbeddedObject { int start = -1; int end = -1; @@ -664,6 +675,7 @@ class TextServerAdvanced : public TextServerExtension { mutable HashMap system_font_data; void _update_chars(ShapedTextDataAdvanced *p_sd) const; + void _generate_runs(ShapedTextDataAdvanced *p_sd) const; void _realign(ShapedTextDataAdvanced *p_sd) const; int64_t _convert_pos(const String &p_utf32, const Char16String &p_utf16, int64_t p_pos) const; int64_t _convert_pos(const ShapedTextDataAdvanced *p_sd, int64_t p_pos) const; @@ -956,12 +968,24 @@ class TextServerAdvanced : public TextServerExtension { MODBIND7R(bool, shaped_text_add_string, const RID &, const String &, const TypedArray &, int64_t, const Dictionary &, const String &, const Variant &); MODBIND6R(bool, shaped_text_add_object, const RID &, const Variant &, const Size2 &, InlineAlignment, int64_t, double); MODBIND5R(bool, shaped_text_resize_object, const RID &, const Variant &, const Size2 &, InlineAlignment, double); + MODBIND1RC(String, shaped_get_text, const RID &); MODBIND1RC(int64_t, shaped_get_span_count, const RID &); MODBIND2RC(Variant, shaped_get_span_meta, const RID &, int64_t); MODBIND2RC(Variant, shaped_get_span_embedded_object, const RID &, int64_t); + MODBIND2RC(String, shaped_get_span_text, const RID &, int64_t); + MODBIND2RC(Variant, shaped_get_span_object, const RID &, int64_t); MODBIND5(shaped_set_span_update_font, const RID &, int64_t, const TypedArray &, int64_t, const Dictionary &); + MODBIND1RC(int64_t, shaped_get_run_count, const RID &); + MODBIND2RC(String, shaped_get_run_text, const RID &, int64_t); + MODBIND2RC(Vector2i, shaped_get_run_range, const RID &, int64_t); + MODBIND2RC(RID, shaped_get_run_font_rid, const RID &, int64_t); + MODBIND2RC(int, shaped_get_run_font_size, const RID &, int64_t); + MODBIND2RC(String, shaped_get_run_language, const RID &, int64_t); + MODBIND2RC(Direction, shaped_get_run_direction, const RID &, int64_t); + MODBIND2RC(Variant, shaped_get_run_object, const RID &, int64_t); + MODBIND3RC(RID, shaped_text_substr, const RID &, int64_t, int64_t); MODBIND1RC(RID, shaped_text_get_parent, const RID &); diff --git a/modules/text_server_fb/text_server_fb.cpp b/modules/text_server_fb/text_server_fb.cpp index 7e31ae17c8c6..541ad65f55b6 100644 --- a/modules/text_server_fb/text_server_fb.cpp +++ b/modules/text_server_fb/text_server_fb.cpp @@ -3105,6 +3105,8 @@ void TextServerFallback::invalidate(ShapedTextDataFallback *p_shaped) { p_shaped->uthk = 0.0; p_shaped->glyphs.clear(); p_shaped->glyphs_logical.clear(); + p_shaped->runs.clear(); + p_shaped->runs_dirty = true; } void TextServerFallback::full_copy(ShapedTextDataFallback *p_shaped) { @@ -3339,6 +3341,212 @@ Variant TextServerFallback::_shaped_get_span_embedded_object(const RID &p_shaped } } +String TextServerFallback::_shaped_get_span_text(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + ShapedTextDataFallback *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, String()); + } + ERR_FAIL_INDEX_V(p_index, span_sd->spans.size(), String()); + return span_sd->text.substr(span_sd->spans[p_index].start, span_sd->spans[p_index].end - span_sd->spans[p_index].start); +} + +Variant TextServerFallback::_shaped_get_span_object(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, Variant()); + ShapedTextDataFallback *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, Variant()); + } + ERR_FAIL_INDEX_V(p_index, span_sd->spans.size(), Variant()); + return span_sd->spans[p_index].embedded_key; +} + +void TextServerFallback::_generate_runs(ShapedTextDataFallback *p_sd) const { + ERR_FAIL_NULL(p_sd); + p_sd->runs.clear(); + + ShapedTextDataFallback *span_sd = p_sd; + if (p_sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(p_sd->parent); + ERR_FAIL_NULL(span_sd); + } + + int sd_size = p_sd->glyphs.size(); + Glyph *sd_gl = p_sd->glyphs.ptrw(); + + int span_count = span_sd->spans.size(); + int span = -1; + int span_start = -1; + int span_end = -1; + + TextRun run; + for (int i = 0; i < sd_size; i += sd_gl[i].count) { + const Glyph &gl = sd_gl[i]; + if (gl.start < 0 || gl.end < 0) { + continue; + } + if (gl.start < span_start || gl.start >= span_end) { + span = -1; + span_start = -1; + span_end = -1; + for (int j = 0; j < span_count; j++) { + if (gl.start >= span_sd->spans[j].start && gl.end <= span_sd->spans[j].end) { + span = j; + span_start = span_sd->spans[j].start; + span_end = span_sd->spans[j].end; + break; + } + } + } + if (run.font_rid != gl.font_rid || run.font_size != gl.font_size || run.span_index != span) { + if (run.span_index >= 0) { + p_sd->runs.push_back(run); + } + run.range = Vector2i(gl.start, gl.end); + run.font_rid = gl.font_rid; + run.font_size = gl.font_size; + run.span_index = span; + } + run.range.x = MIN(run.range.x, gl.start); + run.range.y = MAX(run.range.y, gl.end); + } + if (run.span_index >= 0) { + p_sd->runs.push_back(run); + } + p_sd->runs_dirty = false; +} + +int64_t TextServerFallback::_shaped_get_run_count(const RID &p_shaped) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, 0); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + return sd->runs.size(); +} + +String TextServerFallback::_shaped_get_run_text(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), String()); + return sd->text.substr(sd->runs[p_index].range.x - sd->start, sd->runs[p_index].range.y - sd->runs[p_index].range.x); +} + +Vector2i TextServerFallback::_shaped_get_run_range(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, Vector2i()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), Vector2i()); + return sd->runs[p_index].range; +} + +RID TextServerFallback::_shaped_get_run_font_rid(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, RID()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), RID()); + return sd->runs[p_index].font_rid; +} + +int TextServerFallback::_shaped_get_run_font_size(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, 0); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), 0); + return sd->runs[p_index].font_size; +} + +String TextServerFallback::_shaped_get_run_language(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), String()); + + int span_idx = sd->runs[p_index].span_index; + ShapedTextDataFallback *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, String()); + } + ERR_FAIL_INDEX_V(span_idx, span_sd->spans.size(), String()); + return span_sd->spans[span_idx].language; +} + +TextServer::Direction TextServerFallback::_shaped_get_run_direction(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, TextServer::DIRECTION_LTR); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), TextServer::DIRECTION_LTR); + return TextServer::DIRECTION_LTR; +} + +Variant TextServerFallback::_shaped_get_run_object(const RID &p_shaped, int64_t p_index) const { + ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, Variant()); + MutexLock lock(sd->mutex); + if (!sd->valid.is_set()) { + const_cast(this)->_shaped_text_shape(p_shaped); + } + if (sd->runs_dirty) { + _generate_runs(sd); + } + ERR_FAIL_INDEX_V(p_index, sd->runs.size(), Variant()); + + int span_idx = sd->runs[p_index].span_index; + ShapedTextDataFallback *span_sd = sd; + if (sd->parent.is_valid()) { + span_sd = shaped_owner.get_or_null(sd->parent); + ERR_FAIL_NULL_V(span_sd, Variant()); + } + ERR_FAIL_INDEX_V(span_idx, span_sd->spans.size(), Variant()); + return span_sd->spans[span_idx].embedded_key; +} + void TextServerFallback::_shaped_set_span_update_font(const RID &p_shaped, int64_t p_index, const TypedArray &p_fonts, int64_t p_size, const Dictionary &p_opentype_features) { ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); ERR_FAIL_NULL(sd); @@ -3450,6 +3658,13 @@ bool TextServerFallback::_shaped_text_add_object(const RID &p_shaped, const Vari return true; } +String TextServerFallback::_shaped_get_text(const RID &p_shaped) const { + const ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); + ERR_FAIL_NULL_V(sd, String()); + + return sd->text; +} + bool TextServerFallback::_shaped_text_resize_object(const RID &p_shaped, const Variant &p_key, const Size2 &p_size, InlineAlignment p_inline_align, double p_baseline) { ShapedTextDataFallback *sd = shaped_owner.get_or_null(p_shaped); ERR_FAIL_NULL_V(sd, false); @@ -4385,6 +4600,8 @@ bool TextServerFallback::_shaped_text_shape(const RID &p_shaped) { sd->descent = 0.0; sd->width = 0.0; sd->glyphs.clear(); + sd->runs.clear(); + sd->runs_dirty = true; if (sd->text.length() == 0) { sd->valid.set(); diff --git a/modules/text_server_fb/text_server_fb.h b/modules/text_server_fb/text_server_fb.h index 971ae2cb7f81..28ce1789c41e 100644 --- a/modules/text_server_fb/text_server_fb.h +++ b/modules/text_server_fb/text_server_fb.h @@ -400,6 +400,13 @@ class TextServerFallback : public TextServerExtension { Vector ellipsis_glyph_buf; }; + struct TextRun { + Vector2i range; + RID font_rid; + int font_size = 0; + int64_t span_index = -1; + }; + struct ShapedTextDataFallback { Mutex mutex; @@ -431,6 +438,9 @@ class TextServerFallback : public TextServerExtension { int first_span = 0; // First span in the parent ShapedTextData. int last_span = 0; + Vector runs; + bool runs_dirty = true; + struct EmbeddedObject { int start = -1; int end = -1; @@ -575,6 +585,7 @@ class TextServerFallback : public TextServerExtension { mutable HashMap system_fonts; mutable HashMap system_font_data; + void _generate_runs(ShapedTextDataFallback *p_sd) const; void _realign(ShapedTextDataFallback *p_sd) const; _FORCE_INLINE_ RID _find_sys_font_for_text(const RID &p_fdef, const String &p_script_code, const String &p_language, const String &p_text); @@ -820,12 +831,24 @@ class TextServerFallback : public TextServerExtension { MODBIND7R(bool, shaped_text_add_string, const RID &, const String &, const TypedArray &, int64_t, const Dictionary &, const String &, const Variant &); MODBIND6R(bool, shaped_text_add_object, const RID &, const Variant &, const Size2 &, InlineAlignment, int64_t, double); MODBIND5R(bool, shaped_text_resize_object, const RID &, const Variant &, const Size2 &, InlineAlignment, double); + MODBIND1RC(String, shaped_get_text, const RID &); MODBIND1RC(int64_t, shaped_get_span_count, const RID &); MODBIND2RC(Variant, shaped_get_span_meta, const RID &, int64_t); MODBIND2RC(Variant, shaped_get_span_embedded_object, const RID &, int64_t); + MODBIND2RC(String, shaped_get_span_text, const RID &, int64_t); + MODBIND2RC(Variant, shaped_get_span_object, const RID &, int64_t); MODBIND5(shaped_set_span_update_font, const RID &, int64_t, const TypedArray &, int64_t, const Dictionary &); + MODBIND1RC(int64_t, shaped_get_run_count, const RID &); + MODBIND2RC(String, shaped_get_run_text, const RID &, int64_t); + MODBIND2RC(Vector2i, shaped_get_run_range, const RID &, int64_t); + MODBIND2RC(RID, shaped_get_run_font_rid, const RID &, int64_t); + MODBIND2RC(int, shaped_get_run_font_size, const RID &, int64_t); + MODBIND2RC(String, shaped_get_run_language, const RID &, int64_t); + MODBIND2RC(Direction, shaped_get_run_direction, const RID &, int64_t); + MODBIND2RC(Variant, shaped_get_run_object, const RID &, int64_t); + MODBIND3RC(RID, shaped_text_substr, const RID &, int64_t, int64_t); MODBIND1RC(RID, shaped_text_get_parent, const RID &); diff --git a/platform/linuxbsd/SCsub b/platform/linuxbsd/SCsub index 4def765e9c50..678fc78015a9 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 75c6e8ab4371..82ada66f31cb 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 e63193e0c8e7..b2a4b5432c6e 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 000000000000..905346abeec9 --- /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 000000000000..65cec6568526 --- /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 cafba278336a..d3ea47c05bb8 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 7900ed851d11..5e73a777df13 100644 --- a/platform/linuxbsd/freedesktop_portal_desktop.h +++ b/platform/linuxbsd/freedesktop_portal_desktop.h @@ -46,6 +46,7 @@ class FreeDesktopPortalDesktop : public Object { enum ReadVariantType { VAR_TYPE_UINT32, // u + VAR_TYPE_BOOL, // b VAR_TYPE_COLOR, // (ddd) }; @@ -135,6 +136,12 @@ class FreeDesktopPortalDesktop : public Object { 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 c41c1c594f55..ee09b816ac47 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 03a90111da2b..102fb6739a7b 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 @@ class DisplayServerWayland : public DisplayServer { 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 5f2850c83c52..9027cfc5cda9 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 25bf3111dc29..be19597aea80 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 @@ class DisplayServerX11 : public DisplayServer { 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 f165dc8d9d53..a635e6b16b5a 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 e6cfd976ae43..0e75cf38d239 100644 --- a/platform/macos/display_server_macos.h +++ b/platform/macos/display_server_macos.h @@ -425,6 +425,11 @@ class DisplayServerMacOS : public DisplayServer { 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 942d3a27e3e9..a958327fc21e 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 @@ 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 @@ [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 @@ } #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; + } + } + 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, window_id_counter); + window_set_vsync_mode(p_vsync_mode, id); #endif [wd.window_view updateLayerDelegate]; @@ -184,10 +225,8 @@ 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 @@ } 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 @@ 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 @@ 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 @@ 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 @@ drivers.push_back("opengl3"); drivers.push_back("opengl3_angle"); #endif + drivers.push_back("dummy"); return drivers; } @@ -3783,6 +3851,16 @@ 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 @@ } 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 @@ 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 c5c3a07b574d..eeac379466f8 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 90b30c1a4462..e7ece517d263 100644 --- a/platform/macos/godot_application_delegate.mm +++ b/platform/macos/godot_application_delegate.mm @@ -143,14 +143,55 @@ - (void)activate { [[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 76b40de3ee70..cc9fa0c4b6eb 100644 --- a/platform/macos/godot_window_delegate.mm +++ b/platform/macos/godot_window_delegate.mm @@ -324,6 +324,9 @@ - (void)windowDidBecomeKey:(NSNotification *)notification { 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 @@ - (void)windowDidResignKey:(NSNotification *)notification { 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 @@ - (void)windowDidMiniaturize:(NSNotification *)notification { 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 @@ - (void)windowDidDeminiaturize:(NSNotification *)notification { 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 ba02c36dd082..45487118884c 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 a1af39e42903..49f0496aa6f8 100644 --- a/platform/windows/detect.py +++ b/platform/windows/detect.py @@ -5,7 +5,7 @@ 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 spawn_capture(sh, escape, cmd, args, env): 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 spawn_capture(sh, escape, cmd, args, env): 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 5d3fe5aa1136..20a34fe20d48 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 cf50408f760a..87758b06d0d5 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 @@ class DisplayServerWindows : public DisplayServer { 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 964af1f14528..d180a293009c 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 000000000000..a83dd7cc7aa5 --- /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 000000000000..a83dd7cc7aa5 --- /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 000000000000..fce8c03fb1e4 --- /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 000000000000..a83dd7cc7aa5 --- /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/scene/2d/animated_sprite_2d.cpp b/scene/2d/animated_sprite_2d.cpp index e9a8c11b2a51..bdcb2b83d0b0 100644 --- a/scene/2d/animated_sprite_2d.cpp +++ b/scene/2d/animated_sprite_2d.cpp @@ -167,6 +167,17 @@ void AnimatedSprite2D::_validate_property(PropertyInfo &p_property) const { void AnimatedSprite2D::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + Rect2 dst_rect = _get_rect(); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_IMAGE); + DisplayServer::get_singleton()->accessibility_update_set_transform(ae, get_transform()); + DisplayServer::get_singleton()->accessibility_update_set_bounds(ae, dst_rect); + } break; + case NOTIFICATION_READY: { if (!Engine::get_singleton()->is_editor_hint() && frames.is_valid() && frames->has_animation(autoplay)) { play(autoplay); diff --git a/scene/2d/gpu_particles_2d.cpp b/scene/2d/gpu_particles_2d.cpp index 5a3cb7be0ad4..73ccf953d243 100644 --- a/scene/2d/gpu_particles_2d.cpp +++ b/scene/2d/gpu_particles_2d.cpp @@ -388,11 +388,11 @@ PackedStringArray GPUParticles2D::get_configuration_warnings() const { } } - if (trail_enabled && OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { + if (trail_enabled && (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" || OS::get_singleton()->get_current_rendering_method() == "dummy")) { warnings.push_back(RTR("Particle trails are only available when using the Forward+ or Mobile renderers.")); } - if (sub_emitter != NodePath() && OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { + if (sub_emitter != NodePath() && (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" || OS::get_singleton()->get_current_rendering_method() == "dummy")) { warnings.push_back(RTR("Particle sub-emitters are not available when using the Compatibility renderer.")); } diff --git a/scene/2d/node_2d.cpp b/scene/2d/node_2d.cpp index 304e29253e68..e970656c4af2 100644 --- a/scene/2d/node_2d.cpp +++ b/scene/2d/node_2d.cpp @@ -429,6 +429,13 @@ Point2 Node2D::to_global(Point2 p_local) const { void Node2D::_notification(int p_notification) { switch (p_notification) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + } break; + case NOTIFICATION_ENTER_TREE: { ERR_MAIN_THREAD_GUARD; diff --git a/scene/2d/physics/touch_screen_button.cpp b/scene/2d/physics/touch_screen_button.cpp index 88fe2bc7055f..93ff87d7590a 100644 --- a/scene/2d/physics/touch_screen_button.cpp +++ b/scene/2d/physics/touch_screen_button.cpp @@ -112,8 +112,27 @@ bool TouchScreenButton::is_shape_centered() const { return shape_centered; } +void TouchScreenButton::_accessibility_action_click(const Variant &p_data) { + _press(0); + _release(); +} + void TouchScreenButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + Rect2 dst_rect(Point2(), texture_normal.is_valid() ? texture_normal->get_size() : Size2()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &TouchScreenButton::_accessibility_action_click)); + + DisplayServer::get_singleton()->accessibility_update_set_transform(ae, get_transform()); + DisplayServer::get_singleton()->accessibility_update_set_bounds(ae, dst_rect); + } break; + case NOTIFICATION_DRAW: { if (!is_inside_tree()) { return; diff --git a/scene/2d/physics/touch_screen_button.h b/scene/2d/physics/touch_screen_button.h index bee5715b651e..d9474ec830f0 100644 --- a/scene/2d/physics/touch_screen_button.h +++ b/scene/2d/physics/touch_screen_button.h @@ -74,6 +74,8 @@ class TouchScreenButton : public Node2D { bool _set(const StringName &p_name, const Variant &p_value); #endif // DISABLE_DEPRECATED + void _accessibility_action_click(const Variant &p_data); + public: #ifdef DEBUG_ENABLED virtual Rect2 _edit_get_rect() const override; diff --git a/scene/2d/sprite_2d.cpp b/scene/2d/sprite_2d.cpp index 01b3c6cef09c..4114720b77fb 100644 --- a/scene/2d/sprite_2d.cpp +++ b/scene/2d/sprite_2d.cpp @@ -115,6 +115,17 @@ void Sprite2D::_get_rects(Rect2 &r_src_rect, Rect2 &r_dst_rect, bool &r_filter_c void Sprite2D::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + Rect2 dst_rect = get_rect(); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_IMAGE); + DisplayServer::get_singleton()->accessibility_update_set_transform(ae, get_transform()); + DisplayServer::get_singleton()->accessibility_update_set_bounds(ae, dst_rect); + } break; + case NOTIFICATION_DRAW: { if (texture.is_null()) { return; diff --git a/scene/3d/decal.cpp b/scene/3d/decal.cpp index 82d72f876d9e..0e2dce743178 100644 --- a/scene/3d/decal.cpp +++ b/scene/3d/decal.cpp @@ -179,7 +179,7 @@ void Decal::_validate_property(PropertyInfo &p_property) const { PackedStringArray Decal::get_configuration_warnings() const { PackedStringArray warnings = VisualInstance3D::get_configuration_warnings(); - if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { + if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" || OS::get_singleton()->get_current_rendering_method() == "dummy") { warnings.push_back(RTR("Decals are only available when using the Forward+ or Mobile renderers.")); return warnings; } diff --git a/scene/3d/gpu_particles_3d.cpp b/scene/3d/gpu_particles_3d.cpp index 4ae2ca3f8f77..4ed17df02f16 100644 --- a/scene/3d/gpu_particles_3d.cpp +++ b/scene/3d/gpu_particles_3d.cpp @@ -421,12 +421,12 @@ PackedStringArray GPUParticles3D::get_configuration_warnings() const { if ((dp_count || skin.is_valid()) && (missing_trails || no_materials)) { warnings.push_back(RTR("Trails enabled, but one or more mesh materials are either missing or not set for trails rendering.")); } - if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { + if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" || OS::get_singleton()->get_current_rendering_method() == "dummy") { warnings.push_back(RTR("Particle trails are only available when using the Forward+ or Mobile renderers.")); } } - if (sub_emitter != NodePath() && OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { + if (sub_emitter != NodePath() && (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" || OS::get_singleton()->get_current_rendering_method() == "dummy")) { warnings.push_back(RTR("Particle sub-emitters are only available when using the Forward+ or Mobile renderers.")); } diff --git a/scene/3d/light_3d.cpp b/scene/3d/light_3d.cpp index f4e7815e03f3..51826f7597a9 100644 --- a/scene/3d/light_3d.cpp +++ b/scene/3d/light_3d.cpp @@ -632,7 +632,7 @@ PackedStringArray OmniLight3D::get_configuration_warnings() const { warnings.push_back(RTR("Projector texture only works with shadows active.")); } - if (get_projector().is_valid() && OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { + if (get_projector().is_valid() && (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" || OS::get_singleton()->get_current_rendering_method() == "dummy")) { warnings.push_back(RTR("Projector textures are not supported when using the Compatibility renderer yet. Support will be added in a future release.")); } @@ -668,7 +668,7 @@ PackedStringArray SpotLight3D::get_configuration_warnings() const { warnings.push_back(RTR("Projector texture only works with shadows active.")); } - if (get_projector().is_valid() && OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { + if (get_projector().is_valid() && (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" || OS::get_singleton()->get_current_rendering_method() == "dummy")) { warnings.push_back(RTR("Projector textures are not supported when using the Compatibility renderer yet. Support will be added in a future release.")); } diff --git a/scene/3d/node_3d.cpp b/scene/3d/node_3d.cpp index 1efa1d9457b2..4d8037b1406a 100644 --- a/scene/3d/node_3d.cpp +++ b/scene/3d/node_3d.cpp @@ -131,6 +131,13 @@ void Node3D::_propagate_transform_changed(Node3D *p_origin) { void Node3D::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + } break; + case NOTIFICATION_ENTER_TREE: { ERR_MAIN_THREAD_GUARD; ERR_FAIL_NULL(get_tree()); diff --git a/scene/3d/voxel_gi.cpp b/scene/3d/voxel_gi.cpp index 25f5d13f0ce0..232df7ce858e 100644 --- a/scene/3d/voxel_gi.cpp +++ b/scene/3d/voxel_gi.cpp @@ -542,6 +542,8 @@ PackedStringArray VoxelGI::get_configuration_warnings() const { if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility") { warnings.push_back(RTR("VoxelGI nodes are not supported when using the Compatibility renderer yet. Support will be added in a future release.")); + } else if (OS::get_singleton()->get_current_rendering_method() == "dummy") { + warnings.push_back(RTR("VoxelGI nodes are not supported when using the Dummy renderer.")); } else if (probe_data.is_null()) { warnings.push_back(RTR("No VoxelGI data set, so this node is disabled. Bake static objects to enable GI.")); } diff --git a/scene/audio/audio_stream_player.cpp b/scene/audio/audio_stream_player.cpp index 4fc0f23d5dbe..6fbfd25451b5 100644 --- a/scene/audio/audio_stream_player.cpp +++ b/scene/audio/audio_stream_player.cpp @@ -35,7 +35,14 @@ #include "servers/audio/audio_stream.h" void AudioStreamPlayer::_notification(int p_what) { - internal->notification(p_what); + if (p_what == NOTIFICATION_ACCESSIBILITY_UPDATE) { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_AUDIO); + } else { + internal->notification(p_what); + } } void AudioStreamPlayer::set_stream(Ref p_stream) { diff --git a/scene/gui/base_button.cpp b/scene/gui/base_button.cpp index 1502579a6a36..9ec61494efa9 100644 --- a/scene/gui/base_button.cpp +++ b/scene/gui/base_button.cpp @@ -41,6 +41,7 @@ void BaseButton::_unpress_group() { if (toggle_mode && !button_group->is_allow_unpress()) { status.pressed = true; + queue_accessibility_update(); } for (BaseButton *E : button_group->buttons) { @@ -83,15 +84,66 @@ void BaseButton::gui_input(const Ref &p_event) { } } +void BaseButton::_accessibility_action_click(const Variant &p_data) { + if (toggle_mode) { + status.pressed = !status.pressed; + + if (status.pressed) { + _unpress_group(); + if (button_group.is_valid()) { + button_group->emit_signal(SceneStringName(pressed), this); + } + } + + _toggled(status.pressed); + _pressed(); + } else { + _pressed(); + } + queue_accessibility_update(); + queue_redraw(); +} + void BaseButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &BaseButton::_accessibility_action_click)); + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_DISABLED, status.disabled); + if (toggle_mode) { + DisplayServer::get_singleton()->accessibility_update_set_checked(ae, status.pressed); + } + if (button_group.is_valid()) { + for (const BaseButton *btn : button_group->buttons) { + if (btn->is_part_of_edited_scene()) { + continue; + } + DisplayServer::get_singleton()->accessibility_update_add_related_radio_group(ae, btn->get_accessibility_element()); + } + } + if (shortcut_in_tooltip && shortcut.is_valid() && shortcut->has_valid_event()) { + String text = atr(shortcut->get_name()) + " (" + shortcut->get_as_text() + ")"; + String tooltip = get_tooltip_text(); + if (!tooltip.is_empty() && shortcut->get_name().nocasecmp_to(tooltip) != 0) { + text += "\n" + atr(tooltip); + } + DisplayServer::get_singleton()->accessibility_update_set_tooltip(ae, text); + } + } break; + case NOTIFICATION_MOUSE_ENTER: { status.hovering = true; + queue_accessibility_update(); queue_redraw(); } break; case NOTIFICATION_MOUSE_EXIT: { status.hovering = false; + queue_accessibility_update(); queue_redraw(); } break; @@ -175,6 +227,7 @@ void BaseButton::on_action_event(Ref p_event) { } _toggled(status.pressed); _pressed(); + queue_accessibility_update(); } } else { if ((p_event->is_pressed() && action_mode == ACTION_MODE_BUTTON_PRESS) || (!p_event->is_pressed() && action_mode == ACTION_MODE_BUTTON_RELEASE)) { @@ -214,6 +267,7 @@ void BaseButton::set_disabled(bool p_disabled) { status.press_attempt = false; status.pressing_inside = false; } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -247,7 +301,7 @@ void BaseButton::set_pressed_no_signal(bool p_pressed) { return; } status.pressed = p_pressed; - + queue_accessibility_update(); queue_redraw(); } @@ -303,6 +357,7 @@ void BaseButton::set_toggle_mode(bool p_on) { if (!p_on) { set_pressed(false); } + queue_accessibility_update(); toggle_mode = p_on; update_configuration_warnings(); @@ -313,7 +368,10 @@ bool BaseButton::is_toggle_mode() const { } void BaseButton::set_shortcut_in_tooltip(bool p_on) { - shortcut_in_tooltip = p_on; + if (shortcut_in_tooltip != p_on) { + shortcut_in_tooltip = p_on; + queue_accessibility_update(); + } } bool BaseButton::is_shortcut_in_tooltip_enabled() const { @@ -353,8 +411,11 @@ bool BaseButton::is_shortcut_feedback() const { } void BaseButton::set_shortcut(const Ref &p_shortcut) { - shortcut = p_shortcut; - set_process_shortcut_input(shortcut.is_valid()); + if (shortcut != p_shortcut) { + shortcut = p_shortcut; + set_process_shortcut_input(shortcut.is_valid()); + queue_accessibility_update(); + } } Ref BaseButton::get_shortcut() const { @@ -380,7 +441,7 @@ void BaseButton::shortcut_input(const Ref &p_event) { _toggled(status.pressed); _pressed(); - + queue_accessibility_update(); } else { _pressed(); } @@ -440,6 +501,7 @@ void BaseButton::set_button_group(const Ref &p_group) { button_group->buttons.insert(this); } + queue_accessibility_update(); queue_redraw(); //checkbox changes to radio if set a buttongroup update_configuration_warnings(); } diff --git a/scene/gui/base_button.h b/scene/gui/base_button.h index 76dba0badfe6..60e5a8ab7945 100644 --- a/scene/gui/base_button.h +++ b/scene/gui/base_button.h @@ -86,6 +86,7 @@ class BaseButton : public Control { void _notification(int p_what); bool _was_pressed_by_mouse() const; + void _accessibility_action_click(const Variant &p_data); GDVIRTUAL0(_pressed) GDVIRTUAL1(_toggled, bool) diff --git a/scene/gui/button.cpp b/scene/gui/button.cpp index 958e1f3a270c..4c090cb1f603 100644 --- a/scene/gui/button.cpp +++ b/scene/gui/button.cpp @@ -30,6 +30,8 @@ #include "button.h" +#include "scene/gui/dialogs.h" + #include "scene/theme/theme_db.h" Size2 Button::get_minimum_size() const { @@ -185,6 +187,21 @@ Ref Button::_get_current_stylebox() const { void Button::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + if (!xl_text.is_empty() && get_accessibility_name().is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_name(ae, xl_text); + } else if (!xl_text.is_empty() && !get_accessibility_name().is_empty() && get_accessibility_name() != xl_text) { + DisplayServer::get_singleton()->accessibility_update_set_name(ae, get_accessibility_name() + ": " + xl_text); + } + AcceptDialog *dlg = Object::cast_to(get_parent()); + if (dlg && dlg->get_ok_button() == this) { + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_DEFAULT_BUTTON); + } + } break; + case NOTIFICATION_LAYOUT_DIRECTION_CHANGED: { queue_redraw(); } break; @@ -194,6 +211,7 @@ void Button::_notification(int p_what) { _shape(); update_minimum_size(); + queue_accessibility_update(); queue_redraw(); } break; @@ -610,6 +628,7 @@ void Button::set_text(const String &p_text) { xl_text = translated_text; _shape(); + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -649,6 +668,7 @@ void Button::set_text_direction(Control::TextDirection p_text_direction) { if (text_direction != p_text_direction) { text_direction = p_text_direction; _shape(); + queue_accessibility_update(); queue_redraw(); } } @@ -661,6 +681,7 @@ void Button::set_language(const String &p_language) { if (language != p_language) { language = p_language; _shape(); + queue_accessibility_update(); queue_redraw(); } } @@ -738,6 +759,7 @@ bool Button::get_clip_text() const { void Button::set_text_alignment(HorizontalAlignment p_alignment) { if (alignment != p_alignment) { alignment = p_alignment; + queue_accessibility_update(); queue_redraw(); } } diff --git a/scene/gui/check_box.cpp b/scene/gui/check_box.cpp index 475dd1f4652e..03dab7448beb 100644 --- a/scene/gui/check_box.cpp +++ b/scene/gui/check_box.cpp @@ -81,6 +81,17 @@ Size2 CheckBox::get_minimum_size() const { void CheckBox::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + if (is_radio()) { + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_RADIO_BUTTON); + } else { + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_CHECK_BOX); + } + } break; + case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_LAYOUT_DIRECTION_CHANGED: case NOTIFICATION_TRANSLATION_CHANGED: { @@ -134,7 +145,7 @@ void CheckBox::_notification(int p_what) { } } -bool CheckBox::is_radio() { +bool CheckBox::is_radio() const { return get_button_group().is_valid(); } diff --git a/scene/gui/check_box.h b/scene/gui/check_box.h index 62f6aa853220..fcbacfcb18ba 100644 --- a/scene/gui/check_box.h +++ b/scene/gui/check_box.h @@ -60,7 +60,7 @@ class CheckBox : public Button { void _notification(int p_what); static void _bind_methods(); - bool is_radio(); + bool is_radio() const; public: CheckBox(const String &p_text = String()); diff --git a/scene/gui/check_button.cpp b/scene/gui/check_button.cpp index 78daaf2629e6..d90f12e48e7f 100644 --- a/scene/gui/check_button.cpp +++ b/scene/gui/check_button.cpp @@ -85,6 +85,13 @@ Size2 CheckButton::get_minimum_size() const { void CheckButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_CHECK_BUTTON); + } break; + case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_LAYOUT_DIRECTION_CHANGED: case NOTIFICATION_TRANSLATION_CHANGED: { diff --git a/scene/gui/color_picker.cpp b/scene/gui/color_picker.cpp index 91195b429630..162d1409e051 100644 --- a/scene/gui/color_picker.cpp +++ b/scene/gui/color_picker.cpp @@ -56,20 +56,31 @@ void ColorPicker::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_COLOR_PICKER); + DisplayServer::get_singleton()->accessibility_update_set_color_value(ae, color); + } break; + case NOTIFICATION_ENTER_TREE: { _update_color(); } break; case NOTIFICATION_READY: { - // FIXME: The embedding check is needed to fix a bug in single-window mode (GH-93718). if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_NATIVE_COLOR_PICKER)) { + btn_pick->set_accessibility_name(ETR("Pick Color From Screen")); btn_pick->set_tooltip_text(ETR("Pick a color from the screen.")); btn_pick->connect(SceneStringName(pressed), callable_mp(this, &ColorPicker::_pick_button_pressed_native)); } else if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_SCREEN_CAPTURE) && !get_tree()->get_root()->is_embedding_subwindows()) { + // FIXME: The embedding check is needed to fix a bug in single-window mode (GH-93718). + btn_pick->set_accessibility_name(ETR("Pick Color From Screen")); btn_pick->set_tooltip_text(ETR("Pick a color from the screen.")); btn_pick->connect(SceneStringName(pressed), callable_mp(this, &ColorPicker::_pick_button_pressed)); } else { // On unsupported platforms, use a legacy method for color picking. + btn_pick->set_accessibility_name(ETR("Pick Color From Window")); btn_pick->set_tooltip_text(ETR("Pick a color from the application window.")); btn_pick->connect(SceneStringName(pressed), callable_mp(this, &ColorPicker::_pick_button_pressed_legacy)); } @@ -338,8 +349,12 @@ void ColorPicker::_update_controls() { for (int i = 0; i < current_slider_count; i++) { labels[i]->set_text(modes[current_mode]->get_slider_label(i)); + sliders[i]->set_accessibility_name(modes[current_mode]->get_slider_label(i)); + values[i]->set_accessibility_name(modes[current_mode]->get_slider_label(i)); } alpha_label->set_text("A"); + alpha_slider->set_accessibility_name(ETR("Alpha")); + alpha_value->set_accessibility_name(ETR("Alpha")); slider_theme_modified = modes[current_mode]->apply_theme(); @@ -726,6 +741,7 @@ void ColorPicker::_update_color(bool p_update_sliders) { } alpha_slider->queue_redraw(); updating = false; + queue_accessibility_update(); } void ColorPicker::_update_presets() { @@ -862,6 +878,7 @@ inline int ColorPicker::_get_preset_size() { void ColorPicker::_add_preset_button(int p_size, const Color &p_color) { ColorPresetButton *btn_preset_new = memnew(ColorPresetButton(p_color, p_size)); btn_preset_new->set_tooltip_text(vformat(atr(ETR("Color: #%s\nLMB: Apply color\nRMB: Remove preset")), p_color.to_html(p_color.a < 1))); + btn_preset_new->set_accessibility_name(vformat(atr(ETR("Color: #%")), p_color.to_html(p_color.a < 1))); SET_DRAG_FORWARDING_GCDU(btn_preset_new, ColorPicker); btn_preset_new->set_button_group(preset_group); preset_container->add_child(btn_preset_new); @@ -872,6 +889,7 @@ void ColorPicker::_add_preset_button(int p_size, const Color &p_color) { void ColorPicker::_add_recent_preset_button(int p_size, const Color &p_color) { ColorPresetButton *btn_preset_new = memnew(ColorPresetButton(p_color, p_size)); btn_preset_new->set_tooltip_text(vformat(atr(ETR("Color: #%s\nLMB: Apply color")), p_color.to_html(p_color.a < 1))); + btn_preset_new->set_accessibility_name(vformat(atr(ETR("Color: #%s")), p_color.to_html(p_color.a < 1))); btn_preset_new->set_button_group(recent_preset_group); recent_preset_hbc->add_child(btn_preset_new); recent_preset_hbc->move_child(btn_preset_new, 0); @@ -2000,6 +2018,7 @@ ColorPicker::ColorPicker() { btn_pick = memnew(Button); btn_pick->set_icon_alignment(HORIZONTAL_ALIGNMENT_CENTER); + btn_pick->set_accessibility_name(ETR("Pick")); sample_hbc->add_child(btn_pick); sample = memnew(TextureRect); @@ -2012,6 +2031,7 @@ ColorPicker::ColorPicker() { btn_shape->set_flat(false); sample_hbc->add_child(btn_shape); btn_shape->set_toggle_mode(true); + btn_shape->set_accessibility_name(ETR("Picker Shape")); btn_shape->set_tooltip_text(ETR("Select a picker shape.")); btn_shape->set_icon_alignment(HORIZONTAL_ALIGNMENT_CENTER); btn_shape->set_focus_mode(FOCUS_ALL); @@ -2061,6 +2081,7 @@ ColorPicker::ColorPicker() { btn_mode->set_flat(false); mode_hbc->add_child(btn_mode); btn_mode->set_toggle_mode(true); + btn_mode->set_accessibility_name(ETR("Picker Mode")); btn_mode->set_tooltip_text(ETR("Select a picker mode.")); btn_mode->set_focus_mode(FOCUS_ALL); @@ -2101,7 +2122,8 @@ ColorPicker::ColorPicker() { text_type = memnew(Button); hex_hbc->add_child(text_type); text_type->set_text("#"); - text_type->set_tooltip_text(RTR("Switch between hexadecimal and code values.")); + text_type->set_accessibility_name(ETR("Hexadecimal/Code Values")); + text_type->set_tooltip_text(ETR("Switch between hexadecimal and code values.")); if (Engine::get_singleton()->is_editor_hint()) { text_type->connect(SceneStringName(pressed), callable_mp(this, &ColorPicker::_text_type_toggled)); } else { @@ -2114,6 +2136,7 @@ ColorPicker::ColorPicker() { hex_hbc->add_child(c_text); c_text->set_h_size_flags(SIZE_EXPAND_FILL); c_text->set_select_all_on_focus(true); + c_text->set_accessibility_name(ETR("Hex Code or Name")); c_text->set_tooltip_text(ETR("Enter a hex code (\"#ff0000\") or named color (\"red\").")); c_text->set_placeholder(ETR("Hex code or named color")); c_text->connect(SceneStringName(text_submitted), callable_mp(this, &ColorPicker::_html_submitted)); @@ -2151,6 +2174,7 @@ ColorPicker::ColorPicker() { menu_btn->set_flat(true); menu_btn->set_focus_mode(FOCUS_ALL); menu_btn->set_tooltip_text(ETR("Show all options available.")); + menu_btn->set_accessibility_name(ETR("All Options")); menu_btn->connect("about_to_popup", callable_mp(this, &ColorPicker::_update_menu_items)); palette_box->add_child(menu_btn); @@ -2187,6 +2211,7 @@ ColorPicker::ColorPicker() { btn_add_preset = memnew(Button); btn_add_preset->set_icon_alignment(HORIZONTAL_ALIGNMENT_CENTER); btn_add_preset->set_tooltip_text(ETR("Add current color as a preset.")); + btn_add_preset->set_accessibility_name(ETR("Add Preset")); btn_add_preset->connect(SceneStringName(pressed), callable_mp(this, &ColorPicker::_add_preset_pressed)); preset_container->add_child(btn_add_preset); } @@ -2223,6 +2248,7 @@ void ColorPickerButton::_about_to_popup() { void ColorPickerButton::_color_changed(const Color &p_color) { color = p_color; + queue_accessibility_update(); queue_redraw(); emit_signal(SNAME("color_changed"), color); } @@ -2269,6 +2295,15 @@ void ColorPickerButton::pressed() { void ColorPickerButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + DisplayServer::get_singleton()->accessibility_update_set_popup_type(ae, DisplayServer::AccessibilityPopupType::POPUP_DIALOG); + DisplayServer::get_singleton()->accessibility_update_set_color_value(ae, color); + } break; + case NOTIFICATION_DRAW: { const Rect2 r = Rect2(theme_cache.normal_style->get_offset(), get_size() - theme_cache.normal_style->get_minimum_size()); draw_texture_rect(theme_cache.background_icon, r, true); @@ -2302,7 +2337,7 @@ void ColorPickerButton::set_pick_color(const Color &p_color) { if (picker) { picker->set_pick_color(p_color); } - + queue_accessibility_update(); queue_redraw(); } @@ -2382,6 +2417,14 @@ ColorPickerButton::ColorPickerButton(const String &p_text) : void ColorPresetButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + DisplayServer::get_singleton()->accessibility_update_set_color_value(ae, preset_color); + } break; + case NOTIFICATION_DRAW: { const Rect2 r = Rect2(Point2(0, 0), get_size()); Ref sb_raw = theme_cache.foreground_style->duplicate(); @@ -2439,6 +2482,7 @@ void ColorPresetButton::_notification(int p_what) { void ColorPresetButton::set_preset_color(const Color &p_color) { preset_color = p_color; + queue_accessibility_update(); } Color ColorPresetButton::get_preset_color() const { diff --git a/scene/gui/color_rect.cpp b/scene/gui/color_rect.cpp index fc334325b674..141581c22d6d 100644 --- a/scene/gui/color_rect.cpp +++ b/scene/gui/color_rect.cpp @@ -35,6 +35,7 @@ void ColorRect::set_color(const Color &p_color) { return; } color = p_color; + queue_accessibility_update(); queue_redraw(); } @@ -44,6 +45,13 @@ Color ColorRect::get_color() const { void ColorRect::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_color_value(ae, color); + } break; + case NOTIFICATION_DRAW: { draw_rect(Rect2(Point2(), get_size()), color); } break; diff --git a/scene/gui/container.cpp b/scene/gui/container.cpp index eb69b2dfb8b2..303ceb8d3a2f 100644 --- a/scene/gui/container.cpp +++ b/scene/gui/container.cpp @@ -184,6 +184,13 @@ Vector Container::get_allowed_size_flags_vertical() const { void Container::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + } break; + case NOTIFICATION_RESIZED: case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_ENTER_TREE: { diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp index 6f004dae7b7b..c8bbb3db4f29 100644 --- a/scene/gui/control.cpp +++ b/scene/gui/control.cpp @@ -32,8 +32,12 @@ #include "container.h" #include "core/config/project_settings.h" +#include "core/input/input_map.h" +#include "core/math/geometry_2d.h" #include "core/os/os.h" #include "core/string/translation_server.h" +#include "scene/gui/label.h" +#include "scene/gui/panel.h" #include "scene/gui/scroll_container.h" #include "scene/main/canvas_layer.h" #include "scene/main/window.h" @@ -246,6 +250,27 @@ PackedStringArray Control::get_configuration_warnings() const { return warnings; } +PackedStringArray Control::get_accessibility_configuration_warnings() const { + ERR_READ_THREAD_GUARD_V(PackedStringArray()); + PackedStringArray warnings = Node::get_accessibility_configuration_warnings(); + + String ac_name = get_accessibility_name().strip_edges(); + if (ac_name.is_empty()) { + warnings.push_back(RTR("Accessibility Name must not be empty, or contain only spaces.")); + } + if (ac_name.contains(get_class_name())) { + warnings.push_back(RTR("Accessibility Name must not include Node class name.")); + } + for (int i = 0; i < ac_name.length(); i++) { + if (is_control(ac_name[i])) { + warnings.push_back(RTR("Accessibility Name must not include control character.")); + break; + } + } + + return warnings; +} + bool Control::is_text_field() const { ERR_READ_THREAD_GUARD_V(false); return false; @@ -1534,6 +1559,7 @@ void Control::set_scale(const Vector2 &p_scale) { } queue_redraw(); _notify_transform(); + queue_accessibility_update(); } Vector2 Control::get_scale() const { @@ -1550,6 +1576,7 @@ void Control::set_rotation(real_t p_radians) { data.rotation = p_radians; queue_redraw(); _notify_transform(); + queue_accessibility_update(); } void Control::set_rotation_degrees(real_t p_degrees) { @@ -1576,6 +1603,7 @@ void Control::set_pivot_offset(const Vector2 &p_pivot) { data.pivot_offset = p_pivot; queue_redraw(); _notify_transform(); + queue_accessibility_update(); } Vector2 Control::get_pivot_offset() const { @@ -1749,6 +1777,8 @@ void Control::_size_changed() { if (pos_changed && !size_changed) { _update_canvas_item_transform(); } + + queue_accessibility_update(); } else if (pos_changed) { _notify_transform(); } @@ -2018,7 +2048,40 @@ void Control::force_drag(const Variant &p_data, Control *p_control) { ERR_FAIL_COND(!is_inside_tree()); ERR_FAIL_COND(p_data.get_type() == Variant::NIL); - get_viewport()->_gui_force_drag(this, p_data, p_control); + Viewport *vp = get_viewport(); + + vp->_gui_force_drag_start(); + vp->_gui_force_drag(this, p_data, p_control); +} + +void Control::accessibility_drag() { + ERR_MAIN_THREAD_GUARD; + ERR_FAIL_COND(!is_inside_tree()); + + Viewport *vp = get_viewport(); + + vp->_gui_force_drag_start(); + Variant dnd_data = get_drag_data(Vector2(INFINITY, INFINITY)); + if (dnd_data.get_type() != Variant::NIL) { + Window *w = Window::get_from_id(get_window()->get_window_id()); + if (w) { + w->accessibility_announcement(vformat(RTR("%s grabbed. Select target and use %s to drop, use %s to cancel."), vp->gui_get_drag_description(), InputMap::get_singleton()->get_action_description("ui_accessibility_drag_and_drop"), InputMap::get_singleton()->get_action_description("ui_cancel"))); + } + vp->_gui_force_drag(this, dnd_data, nullptr); + queue_accessibility_update(); + } else { + vp->_gui_force_drag_cancel(); + } +} + +void Control::accessibility_drop() { + ERR_MAIN_THREAD_GUARD; + ERR_FAIL_COND(!is_inside_tree()); + ERR_FAIL_COND(!get_viewport()->gui_is_dragging()); + + get_viewport()->gui_perform_drop_at(Vector2(INFINITY, INFINITY), this); + + queue_accessibility_update(); } void Control::set_drag_preview(Control *p_control) { @@ -2037,7 +2100,7 @@ bool Control::is_drag_successful() const { void Control::set_focus_mode(FocusMode p_focus_mode) { ERR_MAIN_THREAD_GUARD; - ERR_FAIL_INDEX((int)p_focus_mode, 3); + ERR_FAIL_INDEX((int)p_focus_mode, 4); if (is_inside_tree() && p_focus_mode == FOCUS_NONE && data.focus_mode != FOCUS_NONE && has_focus()) { release_focus(); @@ -2163,6 +2226,10 @@ Control *Control::find_next_valid_focus() const { } Control *from = const_cast(this); + bool ac_enabled = get_tree() && get_tree()->is_accessibility_enabled(); + + // Index of the current `Control` subtree within the containing `Window`. + int window_next = -1; while (true) { // Find next child. @@ -2194,6 +2261,25 @@ Control *Control::find_next_valid_focus() const { } next_child = next_child->data.parent_control; } + + Window *win = next_child == nullptr ? nullptr : next_child->data.parent_window; + if (win) { // Cycle through `Control` subtrees of the parent window + if (window_next == -1) { + window_next = next_child->get_index(); + ERR_FAIL_INDEX_V(window_next, win->get_child_count(), nullptr); + } + + for (int i = 1; i < win->get_child_count() + 1; i++) { + int next = Math::wrapi(window_next + i, 0, win->get_child_count()); + Control *c = Object::cast_to(win->get_child(next)); + if (!c || !c->is_visible_in_tree() || c->is_set_as_top_level()) { + continue; + } + window_next = next; + next_child = c; + break; + } + } } } @@ -2201,7 +2287,7 @@ Control *Control::find_next_valid_focus() const { break; } - if (next_child->get_focus_mode_with_recursive() == FOCUS_ALL) { + if ((next_child->get_focus_mode_with_recursive() == FOCUS_ALL) || (ac_enabled && next_child->get_focus_mode_with_recursive() == FOCUS_ACCESSIBILITY)) { return next_child; } @@ -2244,6 +2330,10 @@ Control *Control::find_prev_valid_focus() const { } Control *from = const_cast(this); + bool ac_enabled = get_tree() && get_tree()->is_accessibility_enabled(); + + // Index of the current `Control` subtree within the containing `Window`. + int window_prev = -1; while (true) { // Find prev child. @@ -2253,7 +2343,28 @@ Control *Control::find_prev_valid_focus() const { if (from->is_set_as_top_level() || !from->data.parent_control) { // Find last of the children. - prev_child = _prev_control(from); // Wrap start here. + Window *win = from->data.parent_window; + if (win) { // Cycle through `Control` subtrees of the parent window + if (window_prev == -1) { + window_prev = from->get_index(); + ERR_FAIL_INDEX_V(window_prev, win->get_child_count(), nullptr); + } + + for (int i = 1; i < win->get_child_count() + 1; i++) { + int prev = Math::wrapi(window_prev - i, 0, win->get_child_count()); + Control *c = Object::cast_to(win->get_child(prev)); + if (!c || !c->is_visible_in_tree() || c->is_set_as_top_level()) { + continue; + } + window_prev = prev; + prev_child = _prev_control(c); + break; + } + } + + if (!prev_child) { + prev_child = _prev_control(from); // Wrap start here. + } } else { for (int i = (from->get_index() - 1); i >= 0; i--) { @@ -2274,7 +2385,7 @@ Control *Control::find_prev_valid_focus() const { } } - if (prev_child->get_focus_mode_with_recursive() == FOCUS_ALL) { + if ((prev_child->get_focus_mode_with_recursive() == FOCUS_ALL) || (ac_enabled && prev_child->get_focus_mode_with_recursive() == FOCUS_ACCESSIBILITY)) { return prev_child; } @@ -2509,11 +2620,13 @@ void Control::_window_find_focus_neighbor(const Vector2 &p_dir, Node *p_at, cons return; // Bye. } + bool ac_enabled = get_tree() && get_tree()->is_accessibility_enabled(); + Control *c = Object::cast_to(p_at); Container *container = Object::cast_to(p_at); bool in_container = container ? container->is_ancestor_of(this) : false; - if (c && c != this && c->get_focus_mode_with_recursive() == FOCUS_ALL && !in_container && p_clamp.intersects(c->get_global_rect())) { + if (c && c != this && ((c->get_focus_mode_with_recursive() == FOCUS_ALL) || (ac_enabled && c->get_focus_mode_with_recursive() == FOCUS_ACCESSIBILITY)) && !in_container && p_clamp.intersects(c->get_global_rect())) { Rect2 r_c = c->get_global_rect(); r_c = r_c.intersection(p_clamp); real_t begin_d = p_dir.dot(r_c.get_position()); @@ -3419,6 +3532,13 @@ String Control::get_tooltip(const Point2 &p_pos) const { return data.tooltip; } +String Control::accessibility_get_contextual_info() const { + ERR_READ_THREAD_GUARD_V(String()); + String ret; + GDVIRTUAL_CALL(_accessibility_get_contextual_info, ret); + return ret; +} + Control *Control::make_custom_tooltip(const String &p_text) const { ERR_READ_THREAD_GUARD_V(nullptr); Object *ret = nullptr; @@ -3428,6 +3548,35 @@ Control *Control::make_custom_tooltip(const String &p_text) const { // Base object overrides. +void Control::_accessibility_action_foucs(const Variant &p_data) { + grab_focus(); +} + +void Control::_accessibility_action_blur(const Variant &p_data) { + release_focus(); +} + +void Control::_accessibility_action_show_tooltip(const Variant &p_data) { + Viewport *vp = get_viewport(); + if (vp) { + vp->show_tooltip(this); + } +} + +void Control::_accessibility_action_hide_tooltip(const Variant &p_data) { + Viewport *vp = get_viewport(); + if (vp) { + vp->cancel_tooltip(); + } +} + +void Control::_accessibility_action_scroll_into_view(const Variant &p_data) { + ScrollContainer *sc = Object::cast_to(get_parent()); + if (sc) { + sc->ensure_control_visible(this); + } +} + void Control::_notification(int p_notification) { ERR_MAIN_THREAD_GUARD; switch (p_notification) { @@ -3439,6 +3588,31 @@ void Control::_notification(int p_notification) { saving = false; } break; #endif // TOOLS_ENABLED + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_transform(ae, get_transform()); + DisplayServer::get_singleton()->accessibility_update_set_bounds(ae, Rect2(Vector2(), data.size_cache)); + DisplayServer::get_singleton()->accessibility_update_set_tooltip(ae, data.tooltip); + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_CLIPS_CHILDREN, data.clip_contents); + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_TOUCH_PASSTHROUGH, data.mouse_filter == MOUSE_FILTER_PASS); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &Control::_accessibility_action_foucs)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_BLUR, callable_mp(this, &Control::_accessibility_action_blur)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SHOW_TOOLTIP, callable_mp(this, &Control::_accessibility_action_show_tooltip)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_HIDE_TOOLTIP, callable_mp(this, &Control::_accessibility_action_hide_tooltip)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &Control::_accessibility_action_scroll_into_view)); + if (is_inside_tree() && get_viewport()->gui_is_dragging()) { + if (can_drop_data(Vector2(INFINITY, INFINITY), get_viewport()->gui_get_drag_data())) { + DisplayServer::get_singleton()->accessibility_update_set_extra_info(ae, vformat(RTR("%s can be dropped here. Use %s to drop, use %s to cancel."), get_viewport()->gui_get_drag_description(), InputMap::get_singleton()->get_action_description("ui_accessibility_drag_and_drop"), InputMap::get_singleton()->get_action_description("ui_cancel"))); + } else { + DisplayServer::get_singleton()->accessibility_update_set_extra_info(ae, vformat(RTR("%s can not be dropped here. Use %s to cancel."), get_viewport()->gui_get_drag_description(), InputMap::get_singleton()->get_action_description("ui_cancel"))); + } + } + } break; + case NOTIFICATION_POSTINITIALIZE: { data.initialized = true; @@ -3773,6 +3947,9 @@ void Control::_bind_methods() { ClassDB::bind_method(D_METHOD("force_drag", "data", "preview"), &Control::force_drag); + ClassDB::bind_method(D_METHOD("accessibility_drag"), &Control::accessibility_drag); + ClassDB::bind_method(D_METHOD("accessibility_drop"), &Control::accessibility_drop); + ClassDB::bind_method(D_METHOD("set_mouse_filter", "filter"), &Control::set_mouse_filter); ClassDB::bind_method(D_METHOD("get_mouse_filter"), &Control::get_mouse_filter); ClassDB::bind_method(D_METHOD("get_mouse_filter_with_recursive"), &Control::get_mouse_filter_with_recursive); @@ -3874,7 +4051,7 @@ void Control::_bind_methods() { ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_bottom", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", SIDE_BOTTOM); ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "focus_next", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_next", "get_focus_next"); ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "focus_previous", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_previous", "get_focus_previous"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "focus_mode", PROPERTY_HINT_ENUM, "None,Click,All"), "set_focus_mode", "get_focus_mode"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "focus_mode", PROPERTY_HINT_ENUM, "None,Click,All,Accessibility"), "set_focus_mode", "get_focus_mode"); ADD_PROPERTY(PropertyInfo(Variant::INT, "focus_recursive_behavior", PROPERTY_HINT_ENUM, "Inherited,Disabled,Enabled"), "set_focus_recursive_behavior", "get_focus_recursive_behavior"); ADD_GROUP("Mouse", "mouse_"); @@ -3893,6 +4070,7 @@ void Control::_bind_methods() { BIND_ENUM_CONSTANT(FOCUS_NONE); BIND_ENUM_CONSTANT(FOCUS_CLICK); BIND_ENUM_CONSTANT(FOCUS_ALL); + BIND_ENUM_CONSTANT(FOCUS_ACCESSIBILITY); BIND_ENUM_CONSTANT(RECURSIVE_BEHAVIOR_INHERITED); BIND_ENUM_CONSTANT(RECURSIVE_BEHAVIOR_DISABLED); @@ -4003,6 +4181,8 @@ void Control::_bind_methods() { GDVIRTUAL_BIND(_drop_data, "at_position", "data"); GDVIRTUAL_BIND(_make_custom_tooltip, "for_text"); + GDVIRTUAL_BIND(_accessibility_get_contextual_info); + GDVIRTUAL_BIND(_gui_input, "event"); } diff --git a/scene/gui/control.h b/scene/gui/control.h index b2001fdd259f..1e35b064a686 100644 --- a/scene/gui/control.h +++ b/scene/gui/control.h @@ -64,7 +64,8 @@ class Control : public CanvasItem { enum FocusMode { FOCUS_NONE, FOCUS_CLICK, - FOCUS_ALL + FOCUS_ALL, + FOCUS_ACCESSIBILITY, }; enum RecursiveBehavior { @@ -345,8 +346,6 @@ class Control : public CanvasItem { static int root_layout_direction; - String get_tooltip_text() const; - protected: // Dynamic properties. @@ -371,6 +370,12 @@ class Control : public CanvasItem { void _notification(int p_notification); static void _bind_methods(); + void _accessibility_action_foucs(const Variant &p_data); + void _accessibility_action_blur(const Variant &p_data); + void _accessibility_action_show_tooltip(const Variant &p_data); + void _accessibility_action_hide_tooltip(const Variant &p_data); + void _accessibility_action_scroll_into_view(const Variant &p_data); + // Exposed virtual methods. GDVIRTUAL1RC(bool, _has_point, Vector2) @@ -383,6 +388,8 @@ class Control : public CanvasItem { GDVIRTUAL2(_drop_data, Vector2, Variant) GDVIRTUAL1RC(Object *, _make_custom_tooltip, String) + GDVIRTUAL0RC(String, _accessibility_get_contextual_info); + GDVIRTUAL1(_gui_input, Ref) public: @@ -438,6 +445,7 @@ class Control : public CanvasItem { static void set_root_layout_direction(int p_root_dir); PackedStringArray get_configuration_warnings() const override; + PackedStringArray get_accessibility_configuration_warnings() const override; #ifdef TOOLS_ENABLED virtual void get_argument_options(const StringName &p_function, int p_idx, List *r_options) const override; #endif //TOOLS_ENABLED @@ -556,6 +564,8 @@ class Control : public CanvasItem { virtual void drop_data(const Point2 &p_point, const Variant &p_data); void set_drag_preview(Control *p_control); void force_drag(const Variant &p_data, Control *p_control); + void accessibility_drag(); + void accessibility_drop(); bool is_drag_successful() const; // Focus. @@ -674,10 +684,13 @@ class Control : public CanvasItem { // Extra properties. + String get_tooltip_text() const; void set_tooltip_text(const String &text); virtual String get_tooltip(const Point2 &p_pos) const; virtual Control *make_custom_tooltip(const String &p_text) const; + virtual String accessibility_get_contextual_info() const; + Control(); ~Control(); }; diff --git a/scene/gui/dialogs.cpp b/scene/gui/dialogs.cpp index feea863e5ae4..3c88da752735 100644 --- a/scene/gui/dialogs.cpp +++ b/scene/gui/dialogs.cpp @@ -51,6 +51,12 @@ void AcceptDialog::_parent_focused() { void AcceptDialog::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_DIALOG); + } break; case NOTIFICATION_POST_ENTER_TREE: { if (is_visible()) { get_ok_button()->grab_focus(); diff --git a/scene/gui/file_dialog.cpp b/scene/gui/file_dialog.cpp index c33eea4b8796..4fe705cdd565 100644 --- a/scene/gui/file_dialog.cpp +++ b/scene/gui/file_dialog.cpp @@ -1442,9 +1442,11 @@ void FileDialog::_update_option_controls() { for (const FileDialog::Option &opt : options) { Label *lbl = memnew(Label); lbl->set_text(opt.name); + lbl->set_focus_mode(Control::FOCUS_NONE); grid_options->add_child(lbl); if (opt.values.is_empty()) { CheckBox *cb = memnew(CheckBox); + cb->set_accessibility_name(opt.name); cb->set_pressed(opt.default_idx); grid_options->add_child(cb); cb->connect(SceneStringName(toggled), callable_mp(this, &FileDialog::_option_changed_checkbox_toggled).bind(opt.name)); @@ -1454,6 +1456,7 @@ void FileDialog::_update_option_controls() { for (const String &val : opt.values) { ob->add_item(val); } + ob->set_accessibility_name(opt.name); ob->select(opt.default_idx); grid_options->add_child(ob); ob->connect(SceneStringName(item_selected), callable_mp(this, &FileDialog::_option_changed_item_selected).bind(opt.name)); @@ -1732,11 +1735,14 @@ FileDialog::FileDialog() { dir_prev = memnew(Button); dir_prev->set_theme_type_variation(SceneStringName(FlatButton)); + dir_prev->set_accessibility_name(ETR("Previous")); dir_prev->set_tooltip_text(ETR("Go to previous folder.")); dir_next = memnew(Button); + dir_next->set_accessibility_name(ETR("Next")); dir_next->set_theme_type_variation(SceneStringName(FlatButton)); dir_next->set_tooltip_text(ETR("Go to next folder.")); dir_up = memnew(Button); + dir_up->set_accessibility_name(ETR("Parent Folder")); dir_up->set_theme_type_variation(SceneStringName(FlatButton)); dir_up->set_tooltip_text(ETR("Go to parent folder.")); hbc->add_child(dir_prev); @@ -1746,22 +1752,27 @@ FileDialog::FileDialog() { dir_next->connect(SceneStringName(pressed), callable_mp(this, &FileDialog::_go_forward)); dir_up->connect(SceneStringName(pressed), callable_mp(this, &FileDialog::_go_up)); - hbc->add_child(memnew(Label(ETR("Path:")))); + Label *lbl_path = memnew(Label(ETR("Path:"))); + lbl_path->set_focus_mode(Control::FOCUS_NONE); + hbc->add_child(lbl_path); drives_container = memnew(HBoxContainer); hbc->add_child(drives_container); drives = memnew(OptionButton); drives->connect(SceneStringName(item_selected), callable_mp(this, &FileDialog::_select_drive)); + drives->set_accessibility_name(ETR("Drive")); hbc->add_child(drives); dir = memnew(LineEdit); + dir->set_accessibility_name(ETR("Directory Path")); dir->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); hbc->add_child(dir); dir->set_h_size_flags(Control::SIZE_EXPAND_FILL); refresh = memnew(Button); refresh->set_theme_type_variation(SceneStringName(FlatButton)); + refresh->set_accessibility_name(ETR("Refresh")); refresh->set_tooltip_text(ETR("Refresh files.")); refresh->connect(SceneStringName(pressed), callable_mp(this, &FileDialog::update_file_list)); hbc->add_child(refresh); @@ -1770,6 +1781,7 @@ FileDialog::FileDialog() { show_hidden->set_theme_type_variation(SceneStringName(FlatButton)); show_hidden->set_toggle_mode(true); show_hidden->set_pressed(is_showing_hidden_files()); + show_hidden->set_accessibility_name(ETR("Show Hidden Files")); show_hidden->set_tooltip_text(ETR("Toggle the visibility of hidden files.")); show_hidden->connect(SceneStringName(toggled), callable_mp(this, &FileDialog::set_show_hidden_files)); hbc->add_child(show_hidden); @@ -1778,6 +1790,7 @@ FileDialog::FileDialog() { show_filename_filter_button->set_theme_type_variation(SceneStringName(FlatButton)); show_filename_filter_button->set_toggle_mode(true); show_filename_filter_button->set_pressed(false); + show_filename_filter_button->set_accessibility_name(ETR("Filter File Names")); show_filename_filter_button->set_tooltip_text(ETR("Toggle the visibility of the filter for file names.")); show_filename_filter_button->connect(SceneStringName(toggled), callable_mp(this, &FileDialog::set_show_filename_filter)); hbc->add_child(show_filename_filter_button); @@ -1787,6 +1800,7 @@ FileDialog::FileDialog() { makedir = memnew(Button); makedir->set_theme_type_variation(SceneStringName(FlatButton)); + makedir->set_accessibility_name(ETR("Create New Folder")); makedir->set_tooltip_text(ETR("Create a new folder.")); makedir->connect(SceneStringName(pressed), callable_mp(this, &FileDialog::_make_dir)); hbc->add_child(makedir); @@ -1794,6 +1808,7 @@ FileDialog::FileDialog() { tree = memnew(Tree); tree->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); + tree->set_accessibility_name(ETR("Directories and Files")); tree->set_hide_root(true); vbox->add_margin_child(ETR("Directories & Files:"), tree, true); @@ -1811,13 +1826,18 @@ FileDialog::FileDialog() { filename_filter->set_stretch_ratio(4); filename_filter->set_h_size_flags(Control::SIZE_EXPAND_FILL); filename_filter->set_clear_button_enabled(true); + filename_filter->set_accessibility_name(ETR("Filename Filter")); filename_filter_box->add_child(filename_filter); filename_filter_box->set_visible(false); vbox->add_child(filename_filter_box); file_box = memnew(HBoxContainer); - file_box->add_child(memnew(Label(ETR("File:")))); + Label *lbl_file = memnew(Label(ETR("File:"))); + lbl_file->set_focus_mode(Control::FOCUS_NONE); + file_box->add_child(lbl_file); + file = memnew(LineEdit); + file->set_accessibility_name(ETR("File Name")); file->set_structured_text_bidi_override(TextServer::STRUCTURED_TEXT_FILE); file->set_stretch_ratio(4); file->set_h_size_flags(Control::SIZE_EXPAND_FILL); diff --git a/scene/gui/graph_edit.cpp b/scene/gui/graph_edit.cpp index ccca775f0a91..c1ab57ecb77c 100644 --- a/scene/gui/graph_edit.cpp +++ b/scene/gui/graph_edit.cpp @@ -353,6 +353,62 @@ int GraphEdit::get_connection_count(const StringName &p_node, int p_port) { return count; } +GraphNode *GraphEdit::get_input_connection_target(const StringName &p_node, int p_port) { + for (const Ref &conn : connections) { + if (conn->to_node == p_node && conn->to_port == p_port) { + GraphNode *from = Object::cast_to(get_node(NodePath(conn->from_node))); + if (from) { + return from; + } + } + } + return nullptr; +} + +GraphNode *GraphEdit::get_output_connection_target(const StringName &p_node, int p_port) { + for (const Ref &conn : connections) { + if (conn->from_node == p_node && conn->from_port == p_port) { + GraphNode *to = Object::cast_to(get_node(NodePath(conn->to_node))); + if (to) { + return to; + } + } + } + return nullptr; +} + +String GraphEdit::get_connections_description(const StringName &p_node, int p_port) { + String out; + for (const Ref &conn : connections) { + if (conn->from_node == p_node && conn->from_port == p_port) { + GraphNode *to = Object::cast_to(get_node(NodePath(conn->to_node))); + if (to) { + if (!out.is_empty()) { + out += ", "; + } + String name = to->get_accessibility_name(); + if (name.is_empty()) { + name = to->get_name(); + } + out += vformat(ETR("connection to %s (%s) port %d"), name, to->get_title(), conn->to_port); + } + } else if (conn->to_node == p_node && conn->to_port == p_port) { + GraphNode *from = Object::cast_to(get_node(NodePath(conn->from_node))); + if (from) { + if (!out.is_empty()) { + out += ", "; + } + String name = from->get_accessibility_name(); + if (name.is_empty()) { + name = from->get_name(); + } + out += vformat(ETR("connection from %s (%s) port %d"), name, from->get_title(), conn->from_port); + } + } + } + return out; +} + void GraphEdit::set_scroll_offset(const Vector2 &p_offset) { setting_scroll_offset = true; h_scrollbar->set_value(p_offset.x); @@ -780,6 +836,10 @@ void GraphEdit::_notification(int p_what) { // Draw background fill. draw_style_box(theme_cache.panel, Rect2(Point2(), get_size())); + if (has_focus()) { + draw_style_box(theme_cache.panel_focus, Rect2(Point2(), get_size())); + } + // Draw background grid. if (show_grid) { _draw_grid(); @@ -958,9 +1018,172 @@ bool GraphEdit::_filter_input(const Point2 &p_point) { return false; } +void GraphEdit::start_keyboard_connecting(GraphNode *p_node, int p_in_port, int p_out_port) { + if (!p_node || p_in_port == p_out_port || (p_in_port != -1 && p_out_port != -1)) { + return; + } + connecting_valid = false; + keyboard_connecting = true; + if (p_in_port != -1) { + Vector2 pos = p_node->get_input_port_position(p_in_port) * zoom + p_node->get_position(); + + if (right_disconnects || valid_right_disconnect_types.has(p_node->get_input_port_type(p_in_port))) { + // Check disconnect. + for (const Ref &conn : connection_map[p_node->get_name()]) { + if (conn->to_node == p_node->get_name() && conn->to_port == p_in_port) { + Node *fr = get_node(NodePath(conn->from_node)); + if (Object::cast_to(fr)) { + connecting_from_node = conn->from_node; + connecting_from_port_index = conn->from_port; + connecting_from_output = true; + connecting_type = Object::cast_to(fr)->get_output_port_type(conn->from_port); + connecting_color = Object::cast_to(fr)->get_output_port_color(conn->from_port); + connecting_target_valid = false; + connecting_to_point = pos; + just_disconnected = true; + + if (connecting_type >= 0) { + emit_signal(SNAME("disconnection_request"), conn->from_node, conn->from_port, conn->to_node, conn->to_port); + fr = get_node(NodePath(connecting_from_node)); + if (Object::cast_to(fr)) { + connecting = true; + emit_signal(SNAME("connection_drag_started"), connecting_from_node, connecting_from_port_index, true); + } + } + return; + } + } + } + } + + connecting_from_node = p_node->get_name(); + connecting_from_port_index = p_in_port; + connecting_from_output = false; + connecting_type = p_node->get_input_port_type(p_in_port); + connecting_color = p_node->get_input_port_color(p_in_port); + connecting_target_valid = false; + connecting_to_point = pos; + if (connecting_type >= 0) { + connecting = true; + just_disconnected = false; + emit_signal(SNAME("connection_drag_started"), connecting_from_node, connecting_from_port_index, false); + } + return; + } + if (p_out_port != -1) { + Vector2 pos = p_node->get_output_port_position(p_out_port) * zoom + p_node->get_position(); + + if (valid_left_disconnect_types.has(p_node->get_output_port_type(p_out_port))) { + // Check disconnect. + for (const Ref &conn : connection_map[p_node->get_name()]) { + if (conn->from_node == p_node->get_name() && conn->from_port == p_out_port) { + Node *to = get_node(NodePath(conn->to_node)); + if (Object::cast_to(to)) { + connecting_from_node = conn->to_node; + connecting_from_port_index = conn->to_port; + connecting_from_output = false; + connecting_type = Object::cast_to(to)->get_input_port_type(conn->to_port); + connecting_color = Object::cast_to(to)->get_input_port_color(conn->to_port); + connecting_target_valid = false; + connecting_to_point = pos; + + if (connecting_type >= 0) { + just_disconnected = true; + + emit_signal(SNAME("disconnection_request"), conn->from_node, conn->from_port, conn->to_node, conn->to_port); + to = get_node(NodePath(connecting_from_node)); // Maybe it was erased. + if (Object::cast_to(to)) { + connecting = true; + emit_signal(SNAME("connection_drag_started"), connecting_from_node, connecting_from_port_index, false); + } + } + return; + } + } + } + } + + connecting_from_node = p_node->get_name(); + connecting_from_port_index = p_out_port; + connecting_from_output = true; + connecting_type = p_node->get_output_port_type(p_out_port); + connecting_color = p_node->get_output_port_color(p_out_port); + connecting_target_valid = false; + connecting_to_point = pos; + if (connecting_type >= 0) { + connecting = true; + just_disconnected = false; + emit_signal(SNAME("connection_drag_started"), connecting_from_node, connecting_from_port_index, true); + } + return; + } +} + +void GraphEdit::end_keyboard_connecting(GraphNode *p_node, int p_in_port, int p_out_port) { + if (!p_node) { + return; + } + connecting_valid = true; + connecting_target_valid = false; + if (p_in_port != -1) { + Vector2 pos = p_node->get_input_port_position(p_in_port) * zoom + p_node->get_position(); + + int type = p_node->get_input_port_type(p_in_port); + if (type == connecting_type || p_node->is_ignoring_valid_connection_type() || valid_connection_types.has(ConnectionType(connecting_type, type))) { + connecting_target_valid = true; + connecting_to_point = pos; + connecting_target_node = p_node->get_name(); + connecting_target_port_index = p_in_port; + } + } + if (p_out_port != -1) { + Vector2 pos = p_node->get_output_port_position(p_out_port) * zoom + p_node->get_position(); + + int type = p_node->get_output_port_type(p_out_port); + if (type == connecting_type || p_node->is_ignoring_valid_connection_type() || valid_connection_types.has(ConnectionType(type, connecting_type))) { + connecting_target_valid = true; + connecting_to_point = pos; + connecting_target_node = p_node->get_name(); + connecting_target_port_index = p_out_port; + } + } + if (connecting_valid) { + if (connecting && connecting_target_valid) { + if (connecting_from_output) { + emit_signal(SNAME("connection_request"), connecting_from_node, connecting_from_port_index, connecting_target_node, connecting_target_port_index); + } else { + emit_signal(SNAME("connection_request"), connecting_target_node, connecting_target_port_index, connecting_from_node, connecting_from_port_index); + } + } else if (!just_disconnected) { + if (connecting_from_output) { + emit_signal(SNAME("connection_to_empty"), connecting_from_node, connecting_from_port_index, Vector2()); + } else { + emit_signal(SNAME("connection_from_empty"), connecting_from_node, connecting_from_port_index, Vector2()); + } + } + } + + keyboard_connecting = false; + if (connecting) { + force_connection_drag_end(); + } +} + +Dictionary GraphEdit::get_type_names() const { + return type_names; +} + +void GraphEdit::set_type_names(const Dictionary &p_names) { + type_names = p_names; +} + void GraphEdit::_top_connection_layer_input(const Ref &p_ev) { Ref mb = p_ev; if (mb.is_valid() && mb->get_button_index() == MouseButton::LEFT && mb->is_pressed()) { + if (keyboard_connecting) { + force_connection_drag_end(); + keyboard_connecting = false; + } connecting_valid = false; click_pos = mb->get_position() / zoom; for (int i = get_child_count() - 1; i >= 0; i--) { @@ -1086,7 +1309,7 @@ void GraphEdit::_top_connection_layer_input(const Ref &p_ev) { } Ref mm = p_ev; - if (mm.is_valid() && connecting) { + if (mm.is_valid() && connecting && !keyboard_connecting) { connecting_to_point = mm->get_position(); minimap->queue_redraw(); callable_mp(this, &GraphEdit::_update_top_connection_layer).call_deferred(); @@ -2142,6 +2365,7 @@ void GraphEdit::force_connection_drag_end() { connecting = false; connecting_valid = false; + keyboard_connecting = false; minimap->queue_redraw(); queue_redraw(); connections_layer->queue_redraw(); @@ -2793,6 +3017,9 @@ void GraphEdit::_bind_methods() { ClassDB::bind_method(D_METHOD("set_right_disconnects", "enable"), &GraphEdit::set_right_disconnects); ClassDB::bind_method(D_METHOD("is_right_disconnects_enabled"), &GraphEdit::is_right_disconnects_enabled); + ClassDB::bind_method(D_METHOD("set_type_names", "type_names"), &GraphEdit::set_type_names); + ClassDB::bind_method(D_METHOD("get_type_names"), &GraphEdit::get_type_names); + GDVIRTUAL_BIND(_is_in_input_hotzone, "in_node", "in_port", "mouse_position"); GDVIRTUAL_BIND(_is_in_output_hotzone, "in_node", "in_port", "mouse_position"); @@ -2813,6 +3040,8 @@ void GraphEdit::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::INT, "panning_scheme", PROPERTY_HINT_ENUM, "Scroll Zooms,Scroll Pans"), "set_panning_scheme", "get_panning_scheme"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "right_disconnects"), "set_right_disconnects", "is_right_disconnects_enabled"); + ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "type_names", PROPERTY_HINT_DICTIONARY_TYPE, "int;String"), "set_type_names", "get_type_names"); + ADD_GROUP("Connection Lines", "connection_lines"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "connection_lines_curvature"), "set_connection_lines_curvature", "get_connection_lines_curvature"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "connection_lines_thickness", PROPERTY_HINT_RANGE, "0,100,0.1,suffix:px"), "set_connection_lines_thickness", "get_connection_lines_thickness"); @@ -2869,6 +3098,7 @@ void GraphEdit::_bind_methods() { BIND_ENUM_CONSTANT(GRID_PATTERN_DOTS); BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphEdit, panel); + BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphEdit, panel_focus); BIND_THEME_ITEM(Theme::DATA_TYPE_COLOR, GraphEdit, grid_major); BIND_THEME_ITEM(Theme::DATA_TYPE_COLOR, GraphEdit, grid_minor); @@ -2977,7 +3207,8 @@ GraphEdit::GraphEdit() { zoom_minus_button->set_theme_type_variation(SceneStringName(FlatButton)); zoom_minus_button->set_visible(show_zoom_buttons); zoom_minus_button->set_tooltip_text(ETR("Zoom Out")); - zoom_minus_button->set_focus_mode(FOCUS_NONE); + zoom_minus_button->set_accessibility_name(ETR("Zoom Out")); + zoom_minus_button->set_focus_mode(FOCUS_ACCESSIBILITY); menu_hbox->add_child(zoom_minus_button); zoom_minus_button->connect(SceneStringName(pressed), callable_mp(this, &GraphEdit::_zoom_minus)); @@ -2985,7 +3216,8 @@ GraphEdit::GraphEdit() { zoom_reset_button->set_theme_type_variation(SceneStringName(FlatButton)); zoom_reset_button->set_visible(show_zoom_buttons); zoom_reset_button->set_tooltip_text(ETR("Zoom Reset")); - zoom_reset_button->set_focus_mode(FOCUS_NONE); + zoom_reset_button->set_accessibility_name(ETR("Zoom Reset")); + zoom_reset_button->set_focus_mode(FOCUS_ACCESSIBILITY); menu_hbox->add_child(zoom_reset_button); zoom_reset_button->connect(SceneStringName(pressed), callable_mp(this, &GraphEdit::_zoom_reset)); @@ -2993,7 +3225,8 @@ GraphEdit::GraphEdit() { zoom_plus_button->set_theme_type_variation(SceneStringName(FlatButton)); zoom_plus_button->set_visible(show_zoom_buttons); zoom_plus_button->set_tooltip_text(ETR("Zoom In")); - zoom_plus_button->set_focus_mode(FOCUS_NONE); + zoom_plus_button->set_accessibility_name(ETR("Zoom In")); + zoom_plus_button->set_focus_mode(FOCUS_ACCESSIBILITY); menu_hbox->add_child(zoom_plus_button); zoom_plus_button->connect(SceneStringName(pressed), callable_mp(this, &GraphEdit::_zoom_plus)); @@ -3005,6 +3238,7 @@ GraphEdit::GraphEdit() { toggle_grid_button->set_toggle_mode(true); toggle_grid_button->set_pressed(true); toggle_grid_button->set_tooltip_text(ETR("Toggle the visual grid.")); + toggle_grid_button->set_accessibility_name(ETR("Grid")); toggle_grid_button->set_focus_mode(FOCUS_NONE); menu_hbox->add_child(toggle_grid_button); toggle_grid_button->connect(SceneStringName(pressed), callable_mp(this, &GraphEdit::_show_grid_toggled)); @@ -3014,6 +3248,7 @@ GraphEdit::GraphEdit() { toggle_snapping_button->set_visible(show_grid_buttons); toggle_snapping_button->set_toggle_mode(true); toggle_snapping_button->set_tooltip_text(ETR("Toggle snapping to the grid.")); + toggle_snapping_button->set_accessibility_name(ETR("Snap to Grid")); toggle_snapping_button->set_pressed(snapping_enabled); toggle_snapping_button->set_focus_mode(FOCUS_NONE); menu_hbox->add_child(toggle_snapping_button); @@ -3026,6 +3261,7 @@ GraphEdit::GraphEdit() { snapping_distance_spinbox->set_step(1); snapping_distance_spinbox->set_value(snapping_distance); snapping_distance_spinbox->set_tooltip_text(ETR("Change the snapping distance.")); + snapping_distance_spinbox->set_accessibility_name(ETR("Snapping Distance")); menu_hbox->add_child(snapping_distance_spinbox); snapping_distance_spinbox->connect(SceneStringName(value_changed), callable_mp(this, &GraphEdit::_snapping_distance_changed)); @@ -3036,6 +3272,7 @@ GraphEdit::GraphEdit() { minimap_button->set_visible(show_minimap_button); minimap_button->set_toggle_mode(true); minimap_button->set_tooltip_text(ETR("Toggle the graph minimap.")); + minimap_button->set_accessibility_name(ETR("Minimap")); minimap_button->set_pressed(show_grid); minimap_button->set_focus_mode(FOCUS_NONE); menu_hbox->add_child(minimap_button); @@ -3044,6 +3281,7 @@ GraphEdit::GraphEdit() { arrange_button = memnew(Button); arrange_button->set_theme_type_variation(SceneStringName(FlatButton)); arrange_button->set_visible(show_arrange_button); + arrange_button->set_accessibility_name(ETR("Auto Arrange")); arrange_button->connect(SceneStringName(pressed), callable_mp(this, &GraphEdit::arrange_nodes)); arrange_button->set_focus_mode(FOCUS_NONE); menu_hbox->add_child(arrange_button); diff --git a/scene/gui/graph_edit.h b/scene/gui/graph_edit.h index 303b5637494c..cbc719970589 100644 --- a/scene/gui/graph_edit.h +++ b/scene/gui/graph_edit.h @@ -30,6 +30,7 @@ #pragma once +#include "core/variant/typed_dictionary.h" #include "scene/gui/box_container.h" #include "scene/gui/graph_frame.h" #include "scene/gui/graph_node.h" @@ -198,6 +199,7 @@ class GraphEdit : public Control { bool show_grid = true; GridPattern grid_pattern = GRID_PATTERN_LINES; + bool keyboard_connecting = false; bool connecting = false; StringName connecting_from_node; bool connecting_from_output = false; @@ -269,6 +271,7 @@ class GraphEdit : public Control { float base_scale = 1.0; Ref panel; + Ref panel_focus; Color grid_major; Color grid_minor; @@ -303,6 +306,8 @@ class GraphEdit : public Control { HashMap> frame_attached_nodes; HashMap linked_parent_map; + Dictionary type_names; + void _pan_callback(Vector2 p_scroll_vec, Ref p_event); void _zoom_callback(float p_zoom_factor, Vector2 p_origin, Ref p_event); @@ -404,6 +409,9 @@ class GraphEdit : public Control { Error connect_node(const StringName &p_from, int p_from_port, const StringName &p_to, int p_to_port, bool keep_alive = false); bool is_node_connected(const StringName &p_from, int p_from_port, const StringName &p_to, int p_to_port); int get_connection_count(const StringName &p_node, int p_port); + GraphNode *get_input_connection_target(const StringName &p_node, int p_port); + GraphNode *get_output_connection_target(const StringName &p_node, int p_port); + String get_connections_description(const StringName &p_node, int p_port); void disconnect_node(const StringName &p_from, int p_from_port, const StringName &p_to, int p_to_port); void force_connection_drag_end(); @@ -413,6 +421,13 @@ class GraphEdit : public Control { Ref get_closest_connection_at_point(const Vector2 &p_point, float p_max_distance = 4.0) const; List> get_connections_intersecting_with_rect(const Rect2 &p_rect) const; + bool is_keyboard_connecting() const { return keyboard_connecting; } + void start_keyboard_connecting(GraphNode *p_node, int p_in_port, int p_out_port); + void end_keyboard_connecting(GraphNode *p_node, int p_in_port, int p_out_port); + + Dictionary get_type_names() const; + void set_type_names(const Dictionary &p_names); + virtual bool is_node_hover_valid(const StringName &p_from, int p_from_port, const StringName &p_to, int p_to_port); void set_connection_activity(const StringName &p_from, int p_from_port, const StringName &p_to, int p_to_port, float p_activity); diff --git a/scene/gui/graph_node.cpp b/scene/gui/graph_node.cpp index 3e0803eb6f15..69b26173d67c 100644 --- a/scene/gui/graph_node.cpp +++ b/scene/gui/graph_node.cpp @@ -31,6 +31,7 @@ #include "graph_node.h" #include "scene/gui/box_container.h" +#include "scene/gui/graph_edit.h" #include "scene/gui/label.h" #include "scene/theme/theme_db.h" @@ -196,6 +197,10 @@ void GraphNode::_resort() { children_count++; } + slot_count = children_count; + if (selected_slot >= slot_count) { + selected_slot = -1; + } if (children_count == 0) { return; @@ -285,6 +290,7 @@ void GraphNode::_resort() { valid_children_idx++; } + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; } @@ -306,8 +312,308 @@ void GraphNode::draw_port(int p_slot_index, Point2i p_pos, bool p_left, const Co port_icon->draw(get_canvas_item(), p_pos + icon_offset, p_color); } +void GraphNode::_accessibility_action_slot(const Variant &p_data) { + CustomAccessibilityAction action = (CustomAccessibilityAction)p_data.operator int(); + switch (action) { + case ACTION_CONNECT_INPUT: { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_left) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < left_port_cache.size(); i++) { + if (left_port_cache[i].slot_index == selected_slot) { + if (graph->is_keyboard_connecting()) { + graph->end_keyboard_connecting(this, i, -1); + } else { + graph->start_keyboard_connecting(this, i, -1); + } + queue_accessibility_update(); + queue_redraw(); + break; + } + } + } + } + } + } break; + + case ACTION_CONNECT_OUTPUT: { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_right) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < right_port_cache.size(); i++) { + if (right_port_cache[i].slot_index == selected_slot) { + if (graph->is_keyboard_connecting()) { + graph->end_keyboard_connecting(this, -1, i); + } else { + graph->start_keyboard_connecting(this, -1, i); + } + queue_accessibility_update(); + queue_redraw(); + break; + } + } + } + } + } + } break; + + case ACTION_FOLLOW_INPUT: { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_left) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < left_port_cache.size(); i++) { + if (left_port_cache[i].slot_index == selected_slot) { + GraphNode *target = graph->get_input_connection_target(get_name(), i); + if (target) { + target->grab_focus(); + break; + } + } + } + } + } + } + } break; + + case ACTION_FOLLOW_OUTPUT: { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_right) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < right_port_cache.size(); i++) { + if (right_port_cache[i].slot_index == selected_slot) { + GraphNode *target = graph->get_output_connection_target(get_name(), i); + if (target) { + target->grab_focus(); + break; + } + } + } + } + } + } + } break; + } +} + +void GraphNode::gui_input(const Ref &p_event) { + if (port_pos_dirty) { + _port_pos_update(); + } + + if (p_event->is_pressed() && slot_count > 0) { + if (p_event->is_action("ui_up", true)) { + selected_slot--; + if (selected_slot < 0) { + selected_slot = -1; + } else { + accept_event(); + } + } else if (p_event->is_action("ui_down", true)) { + selected_slot++; + if (selected_slot >= slot_count) { + selected_slot = -1; + } else { + accept_event(); + } + } else if (p_event->is_action("ui_cancel", true)) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph && graph->is_keyboard_connecting()) { + graph->force_connection_drag_end(); + accept_event(); + } + } else if (p_event->is_action("ui_graph_delete", true)) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph && graph->is_keyboard_connecting()) { + graph->end_keyboard_connecting(this, -1, -1); + accept_event(); + } + } else if (p_event->is_action("ui_graph_follow_left", true)) { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_left) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < left_port_cache.size(); i++) { + if (left_port_cache[i].slot_index == selected_slot) { + GraphNode *target = graph->get_input_connection_target(get_name(), i); + if (target) { + target->grab_focus(); + accept_event(); + break; + } + } + } + } + } + } + } else if (p_event->is_action("ui_graph_follow_right", true)) { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_right) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < right_port_cache.size(); i++) { + if (right_port_cache[i].slot_index == selected_slot) { + GraphNode *target = graph->get_output_connection_target(get_name(), i); + if (target) { + target->grab_focus(); + accept_event(); + break; + } + } + } + } + } + } + } else if (p_event->is_action("ui_left", true)) { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_left) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < left_port_cache.size(); i++) { + if (left_port_cache[i].slot_index == selected_slot) { + if (graph->is_keyboard_connecting()) { + graph->end_keyboard_connecting(this, i, -1); + } else { + graph->start_keyboard_connecting(this, i, -1); + } + accept_event(); + break; + } + } + } + } + } + } else if (p_event->is_action("ui_right", true)) { + if (slot_table.has(selected_slot)) { + const Slot &slot = slot_table[selected_slot]; + if (slot.enable_right) { + GraphEdit *graph = Object::cast_to(get_parent()); + if (graph) { + for (int i = 0; i < right_port_cache.size(); i++) { + if (right_port_cache[i].slot_index == selected_slot) { + if (graph->is_keyboard_connecting()) { + graph->end_keyboard_connecting(this, -1, i); + } else { + graph->start_keyboard_connecting(this, -1, i); + } + accept_event(); + break; + } + } + } + } + } + } else if (p_event->is_action("ui_accept", true)) { + if (slot_table.has(selected_slot)) { + int idx = 0; + for (int i = 0; i < get_child_count(false); i++) { + Control *child = as_sortable_control(get_child(i, false), SortableVisibilityMode::IGNORE); + if (!child) { + continue; + } + if (idx == selected_slot) { + selected_slot = -1; + child->grab_focus(); + break; + } + idx++; + } + accept_event(); + } + } + queue_accessibility_update(); + queue_redraw(); + } +} + void GraphNode::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + String name = get_accessibility_name(); + if (name.is_empty()) { + name = get_name(); + } + name = vformat(ETR("graph node %s (%s)"), name, get_title()); + + if (slot_table.has(selected_slot)) { + GraphEdit *graph = Object::cast_to(get_parent()); + Dictionary type_info; + if (graph) { + type_info = graph->get_type_names(); + } + const Slot &slot = slot_table[selected_slot]; + name += ", " + vformat(ETR("slot %d of %d"), selected_slot + 1, slot_count); + if (slot.enable_left) { + if (type_info.has(slot.type_left)) { + name += "," + vformat(ETR("input port, type: %s"), type_info[slot.type_left]); + } else { + name += "," + vformat(ETR("input port, type: %d"), slot.type_left); + } + if (graph) { + for (int i = 0; i < left_port_cache.size(); i++) { + if (left_port_cache[i].slot_index == selected_slot) { + String cd = graph->get_connections_description(get_name(), i); + if (cd.is_empty()) { + name += " " + ETR("no connections"); + } else { + name += " " + cd; + } + break; + } + } + } + } + if (slot.enable_left) { + if (type_info.has(slot.type_right)) { + name += "," + vformat(ETR("output port, type: %s"), type_info[slot.type_right]); + } else { + name += "," + vformat(ETR("output port, type: %d"), slot.type_right); + } + if (graph) { + for (int i = 0; i < right_port_cache.size(); i++) { + if (right_port_cache[i].slot_index == selected_slot) { + String cd = graph->get_connections_description(get_name(), i); + if (cd.is_empty()) { + name += " " + ETR("no connections"); + } else { + name += " " + cd; + } + break; + } + } + } + } + if (graph && graph->is_keyboard_connecting()) { + name += ", " + ETR("currently selecting target port"); + } + } else { + name += ", " + vformat(ETR("has %d slots"), slot_count); + } + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_LIST); + DisplayServer::get_singleton()->accessibility_update_set_name(ae, name); + DisplayServer::get_singleton()->accessibility_update_add_custom_action(ae, CustomAccessibilityAction::ACTION_CONNECT_INPUT, ETR("Edit Input Port Connection")); + DisplayServer::get_singleton()->accessibility_update_add_custom_action(ae, CustomAccessibilityAction::ACTION_CONNECT_OUTPUT, ETR("Edit Output Port Connection")); + DisplayServer::get_singleton()->accessibility_update_add_custom_action(ae, CustomAccessibilityAction::ACTION_FOLLOW_INPUT, ETR("Follow Input Port Connection")); + DisplayServer::get_singleton()->accessibility_update_add_custom_action(ae, CustomAccessibilityAction::ACTION_FOLLOW_OUTPUT, ETR("Follow Output Port Connection")); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_CUSTOM, callable_mp(this, &GraphNode::_accessibility_action_slot)); + } break; + case NOTIFICATION_FOCUS_EXIT: { + selected_slot = -1; + queue_redraw(); + } break; case NOTIFICATION_DRAW: { // Used for layout calculations. Ref sb_panel = theme_cache.panel; @@ -317,6 +623,7 @@ void GraphNode::_notification(int p_what) { Ref sb_to_draw_titlebar = selected ? theme_cache.titlebar_selected : theme_cache.titlebar; Ref sb_slot = theme_cache.slot; + Ref sb_slot_selected = theme_cache.slot_selected; int port_h_offset = theme_cache.port_h_offset; @@ -329,6 +636,10 @@ void GraphNode::_notification(int p_what) { // Draw body (slots area) stylebox. draw_style_box(sb_to_draw_panel, body_rect); + if (has_focus()) { + draw_style_box(theme_cache.panel_focus, body_rect); + } + // Draw title bar stylebox above. draw_style_box(sb_to_draw_titlebar, titlebar_rect); @@ -356,6 +667,12 @@ void GraphNode::_notification(int p_what) { draw_port(slot_index, Point2i(get_size().x - port_h_offset, slot_y_cache[E.key]), false, slot.color_right); } + if (slot_index == selected_slot) { + Size2i port_sz = theme_cache.port->get_size(); + draw_style_box(sb_slot_selected, Rect2i(port_h_offset - port_sz.x, slot_y_cache[E.key] + sb_panel->get_margin(SIDE_TOP) - port_sz.y, port_sz.x * 2, port_sz.y * 2)); + draw_style_box(sb_slot_selected, Rect2i(get_size().x - port_h_offset - port_sz.x, slot_y_cache[E.key] + sb_panel->get_margin(SIDE_TOP) - port_sz.y, port_sz.x * 2, port_sz.y * 2)); + } + // Draw slot stylebox. if (slot.draw_stylebox) { Control *child = Object::cast_to(get_child(E.key, false)); @@ -400,6 +717,8 @@ void GraphNode::set_slot(int p_slot_index, bool p_enable_left, int p_type_left, slot.custom_port_icon_right = p_custom_right; slot.draw_stylebox = p_draw_stylebox; slot_table[p_slot_index] = slot; + + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; @@ -408,12 +727,16 @@ void GraphNode::set_slot(int p_slot_index, bool p_enable_left, int p_type_left, void GraphNode::clear_slot(int p_slot_index) { slot_table.erase(p_slot_index); + + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; } void GraphNode::clear_all_slots() { slot_table.clear(); + + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; } @@ -433,6 +756,8 @@ void GraphNode::set_slot_enabled_left(int p_slot_index, bool p_enable) { } slot_table[p_slot_index].enable_left = p_enable; + + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; @@ -447,6 +772,8 @@ void GraphNode::set_slot_type_left(int p_slot_index, int p_type) { } slot_table[p_slot_index].type_left = p_type; + + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; @@ -517,6 +844,8 @@ void GraphNode::set_slot_enabled_right(int p_slot_index, bool p_enable) { } slot_table[p_slot_index].enable_right = p_enable; + + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; @@ -531,6 +860,8 @@ void GraphNode::set_slot_type_right(int p_slot_index, int p_type) { } slot_table[p_slot_index].type_right = p_type; + + queue_accessibility_update(); queue_redraw(); port_pos_dirty = true; @@ -681,6 +1012,10 @@ void GraphNode::_port_pos_update() { slot_index++; } + slot_count = slot_index; + if (selected_slot >= slot_count) { + selected_slot = -1; + } port_pos_dirty = false; } @@ -775,6 +1110,25 @@ int GraphNode::get_output_port_slot(int p_port_idx) { return right_port_cache[p_port_idx].slot_index; } +String GraphNode::get_accessibility_container_name(const Node *p_node) const { + int idx = 0; + for (int i = 0; i < get_child_count(false); i++) { + Control *child = as_sortable_control(get_child(i, false), SortableVisibilityMode::IGNORE); + if (!child) { + continue; + } + if (child == p_node) { + String name = get_accessibility_name(); + if (name.is_empty()) { + name = get_name(); + } + return vformat(ETR(", in slot %d of graph node %s (%s)"), idx + 1, name, get_title()); + } + idx++; + } + return String(); +} + void GraphNode::set_title(const String &p_title) { if (title == p_title) { return; @@ -884,9 +1238,11 @@ void GraphNode::_bind_methods() { BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphNode, panel); BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphNode, panel_selected); + BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphNode, panel_focus); BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphNode, titlebar); BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphNode, titlebar_selected); BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphNode, slot); + BIND_THEME_ITEM(Theme::DATA_TYPE_STYLEBOX, GraphNode, slot_selected); BIND_THEME_ITEM(Theme::DATA_TYPE_CONSTANT, GraphNode, separation); BIND_THEME_ITEM(Theme::DATA_TYPE_CONSTANT, GraphNode, port_h_offset); @@ -904,7 +1260,9 @@ GraphNode::GraphNode() { title_label = memnew(Label); title_label->set_theme_type_variation("GraphNodeTitleLabel"); title_label->set_h_size_flags(SIZE_EXPAND_FILL); + title_label->set_focus_mode(Control::FOCUS_NONE); titlebar_hbox->add_child(title_label); set_mouse_filter(MOUSE_FILTER_STOP); + set_focus_mode(FOCUS_ACCESSIBILITY); } diff --git a/scene/gui/graph_node.h b/scene/gui/graph_node.h index 01196da2cba3..f1831cc9ca02 100644 --- a/scene/gui/graph_node.h +++ b/scene/gui/graph_node.h @@ -66,6 +66,14 @@ class GraphNode : public GraphElement { int final_size = 0; }; + enum CustomAccessibilityAction { + ACTION_CONNECT_INPUT, + ACTION_CONNECT_OUTPUT, + ACTION_FOLLOW_INPUT, + ACTION_FOLLOW_OUTPUT, + }; + void _accessibility_action_slot(const Variant &p_data); + HBoxContainer *titlebar_hbox = nullptr; Label *title_label = nullptr; @@ -77,12 +85,17 @@ class GraphNode : public GraphElement { HashMap slot_table; Vector slot_y_cache; + int slot_count = 0; + int selected_slot = -1; + struct ThemeCache { Ref panel; Ref panel_selected; + Ref panel_focus; Ref titlebar; Ref titlebar_selected; Ref slot; + Ref slot_selected; int separation = 0; int port_h_offset = 0; @@ -112,6 +125,9 @@ class GraphNode : public GraphElement { void _get_property_list(List *p_list) const; public: + virtual String get_accessibility_container_name(const Node *p_node) const override; + virtual void gui_input(const Ref &p_event) override; + void set_title(const String &p_title); String get_title() const; diff --git a/scene/gui/item_list.cpp b/scene/gui/item_list.cpp index b40746562c5a..7f2604b4a076 100644 --- a/scene/gui/item_list.cpp +++ b/scene/gui/item_list.cpp @@ -64,6 +64,7 @@ int ItemList::add_item(const String &p_item, const Ref &p_texture, bo items.write[item_id].xl_text = _atr(item_id, p_item); _shape_text(item_id); + queue_accessibility_update(); queue_redraw(); shape_changed = true; notify_property_list_changed(); @@ -77,6 +78,7 @@ int ItemList::add_icon_item(const Ref &p_item, bool p_selectable) { items.push_back(item); int item_id = items.size() - 1; + queue_accessibility_update(); queue_redraw(); shape_changed = true; notify_property_list_changed(); @@ -96,6 +98,7 @@ void ItemList::set_item_text(int p_idx, const String &p_text) { items.write[p_idx].text = p_text; items.write[p_idx].xl_text = _atr(p_idx, p_text); _shape_text(p_idx); + queue_accessibility_update(); queue_redraw(); shape_changed = true; } @@ -114,6 +117,7 @@ void ItemList::set_item_text_direction(int p_idx, Control::TextDirection p_text_ if (items[p_idx].text_direction != p_text_direction) { items.write[p_idx].text_direction = p_text_direction; _shape_text(p_idx); + queue_accessibility_update(); queue_redraw(); } } @@ -131,6 +135,7 @@ void ItemList::set_item_language(int p_idx, const String &p_language) { if (items[p_idx].language != p_language) { items.write[p_idx].language = p_language; _shape_text(p_idx); + queue_accessibility_update(); queue_redraw(); } } @@ -149,6 +154,7 @@ void ItemList::set_item_auto_translate_mode(int p_idx, AutoTranslateMode p_mode) items.write[p_idx].auto_translate_mode = p_mode; items.write[p_idx].xl_text = _atr(p_idx, items[p_idx].text); _shape_text(p_idx); + queue_accessibility_update(); queue_redraw(); } } @@ -163,7 +169,11 @@ void ItemList::set_item_tooltip_enabled(int p_idx, const bool p_enabled) { p_idx += get_item_count(); } ERR_FAIL_INDEX(p_idx, items.size()); - items.write[p_idx].tooltip_enabled = p_enabled; + if (items[p_idx].tooltip_enabled != p_enabled) { + items.write[p_idx].tooltip_enabled = p_enabled; + items.write[p_idx].accessibility_item_dirty = true; + queue_accessibility_update(); + } } bool ItemList::is_item_tooltip_enabled(int p_idx) const { @@ -182,6 +192,7 @@ void ItemList::set_item_tooltip(int p_idx, const String &p_tooltip) { } items.write[p_idx].tooltip = p_tooltip; + queue_accessibility_update(); queue_redraw(); shape_changed = true; } @@ -348,6 +359,8 @@ void ItemList::set_item_selectable(int p_idx, bool p_selectable) { ERR_FAIL_INDEX(p_idx, items.size()); items.write[p_idx].selectable = p_selectable; + items.write[p_idx].accessibility_item_dirty = true; + queue_accessibility_update(); } bool ItemList::is_item_selectable(int p_idx) const { @@ -366,6 +379,8 @@ void ItemList::set_item_disabled(int p_idx, bool p_disabled) { } items.write[p_idx].disabled = p_disabled; + items.write[p_idx].accessibility_item_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -403,7 +418,10 @@ void ItemList::select(int p_idx, bool p_single) { } for (int i = 0; i < items.size(); i++) { - items.write[i].selected = p_idx == i; + if (items.write[i].selected != (p_idx == i)) { + items.write[i].selected = (p_idx == i); + items.write[i].accessibility_item_dirty = true; + } } current = p_idx; @@ -411,8 +429,10 @@ void ItemList::select(int p_idx, bool p_single) { } else { if (items[p_idx].selectable && !items[p_idx].disabled) { items.write[p_idx].selected = true; + items.write[p_idx].accessibility_item_dirty = true; } } + queue_accessibility_update(); queue_redraw(); } @@ -425,6 +445,8 @@ void ItemList::deselect(int p_idx) { } else { items.write[p_idx].selected = false; } + items.write[p_idx].accessibility_item_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -434,9 +456,13 @@ void ItemList::deselect_all() { } for (int i = 0; i < items.size(); i++) { - items.write[i].selected = false; + if (items.write[i].selected) { + items.write[i].selected = false; + items.write[i].accessibility_item_dirty = true; + } } current = -1; + queue_accessibility_update(); queue_redraw(); } @@ -457,6 +483,7 @@ void ItemList::set_current(int p_current) { select(p_current, true); } else { current = p_current; + queue_accessibility_update(); queue_redraw(); } } @@ -477,6 +504,7 @@ void ItemList::move_item(int p_from_idx, int p_to_idx) { items.remove_at(p_from_idx); items.insert(p_to_idx, item); + queue_accessibility_update(); queue_redraw(); shape_changed = true; notify_property_list_changed(); @@ -489,7 +517,17 @@ void ItemList::set_item_count(int p_count) { return; } + if (items.size() > p_count) { + for (int i = p_count; i < items.size(); i++) { + if (items[i].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(items.write[i].accessibility_item_element); + items.write[i].accessibility_item_element = RID(); + } + } + } + items.resize(p_count); + queue_accessibility_update(); queue_redraw(); shape_changed = true; notify_property_list_changed(); @@ -502,10 +540,15 @@ int ItemList::get_item_count() const { void ItemList::remove_item(int p_idx) { ERR_FAIL_INDEX(p_idx, items.size()); + if (items[p_idx].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(items.write[p_idx].accessibility_item_element); + items.write[p_idx].accessibility_item_element = RID(); + } items.remove_at(p_idx); if (current == p_idx) { current = -1; } + queue_accessibility_update(); queue_redraw(); shape_changed = true; defer_select_single = -1; @@ -513,9 +556,16 @@ void ItemList::remove_item(int p_idx) { } void ItemList::clear() { + for (int i = 0; i < items.size(); i++) { + if (items[i].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(items.write[i].accessibility_item_element); + items.write[i].accessibility_item_element = RID(); + } + } items.clear(); current = -1; ensure_selected_visible = false; + queue_accessibility_update(); queue_redraw(); shape_changed = true; defer_select_single = -1; @@ -565,6 +615,7 @@ void ItemList::set_max_text_lines(int p_lines) { } } shape_changed = true; + queue_accessibility_update(); queue_redraw(); } } @@ -581,6 +632,7 @@ void ItemList::set_max_columns(int p_amount) { } max_columns = p_amount; + queue_accessibility_update(); queue_redraw(); shape_changed = true; } @@ -595,6 +647,7 @@ void ItemList::set_select_mode(SelectMode p_mode) { } select_mode = p_mode; + queue_accessibility_update(); queue_redraw(); } @@ -694,7 +747,9 @@ void ItemList::gui_input(const Ref &p_event) { if (mm.is_valid()) { int closest = get_item_at_position(mm->get_position(), true); if (closest != hovered) { + prev_hovered = hovered; hovered = closest; + queue_accessibility_update(); queue_redraw(); } } @@ -834,6 +889,21 @@ void ItemList::gui_input(const Ref &p_event) { } if (p_event->is_pressed() && items.size() > 0) { + if (p_event->is_action("ui_menu", true)) { + if (current != -1 && allow_rmb_select) { + int i = current; + + if (items[i].disabled) { + // Don't emit any signal or do any action with clicked item when disabled. + return; + } + + emit_signal(SNAME("item_clicked"), i, get_item_rect(i).position, MouseButton::RIGHT); + + accept_event(); + return; + } + } if (p_event->is_action("ui_up", true)) { if (!search_string.is_empty()) { uint64_t now = OS::get_singleton()->get_ticks_msec(); @@ -1076,8 +1146,131 @@ static Rect2 _adjust_to_max_size(Size2 p_size, Size2 p_max_size) { return Rect2(ofs_x, ofs_y, tex_width, tex_height); } +RID ItemList::get_focused_accessibility_element() const { + if (current == -1) { + return get_accessibility_element(); + } else { + const Item &item = items[current]; + return item.accessibility_item_element; + } +} + +void ItemList::_accessibility_action_scroll_set(const Variant &p_data) { + const Point2 &pos = p_data; + scroll_bar_h->set_value(pos.x); + scroll_bar_v->set_value(pos.y); +} + +void ItemList::_accessibility_action_scroll_up(const Variant &p_data) { + scroll_bar_v->set_value(scroll_bar_v->get_value() - scroll_bar_v->get_page() / 4); +} + +void ItemList::_accessibility_action_scroll_down(const Variant &p_data) { + scroll_bar_v->set_value(scroll_bar_v->get_value() + scroll_bar_v->get_page() / 4); +} + +void ItemList::_accessibility_action_scroll_left(const Variant &p_data) { + scroll_bar_h->set_value(scroll_bar_h->get_value() - scroll_bar_h->get_page() / 4); +} + +void ItemList::_accessibility_action_scroll_right(const Variant &p_data) { + scroll_bar_h->set_value(scroll_bar_h->get_value() + scroll_bar_h->get_page() / 4); +} + +void ItemList::_accessibility_action_scroll_into_view(const Variant &p_data, int p_index) { + ERR_FAIL_INDEX(p_index, items.size()); + + Rect2 r = items[p_index].rect_cache; + int from_v = scroll_bar_v->get_value(); + int to_v = from_v + scroll_bar_v->get_page(); + int from_h = scroll_bar_h->get_value(); + int to_h = from_h + scroll_bar_h->get_page(); + + if (r.position.y < from_v) { + scroll_bar_v->set_value(r.position.y); + } else if (r.position.y + r.size.y > to_v) { + scroll_bar_v->set_value(r.position.y + r.size.y - (to_v - from_v)); + } + if (r.position.x < from_h) { + scroll_bar_h->set_value(r.position.x); + } else if (r.position.x + r.size.x > to_h) { + scroll_bar_h->set_value(r.position.x + r.size.x - (to_h - from_h)); + } +} + +void ItemList::_accessibility_action_focus(const Variant &p_data, int p_index) { + select(p_index); +} + +void ItemList::_accessibility_action_blur(const Variant &p_data, int p_index) { + deselect(p_index); +} + void ItemList::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_EXIT_TREE: + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + for (int i = 0; i < items.size(); i++) { + items.write[i].accessibility_item_element = RID(); + } + accessibility_scroll_element = RID(); + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + force_update_list_size(); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_LIST_BOX); + DisplayServer::get_singleton()->accessibility_update_set_list_item_count(ae, items.size()); + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_MULTISELECTABLE, select_mode == SELECT_MULTI); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_DOWN, callable_mp(this, &ItemList::_accessibility_action_scroll_down)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_UP, callable_mp(this, &ItemList::_accessibility_action_scroll_up)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_LEFT, callable_mp(this, &ItemList::_accessibility_action_scroll_left)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_RIGHT, callable_mp(this, &ItemList::_accessibility_action_scroll_right)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_SCROLL_OFFSET, callable_mp(this, &ItemList::_accessibility_action_scroll_set)); + + if (accessibility_scroll_element.is_null()) { + accessibility_scroll_element = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + } + + Transform2D scroll_xform; + scroll_xform.set_origin(Vector2i(-scroll_bar_h->get_value(), -scroll_bar_v->get_value())); + DisplayServer::get_singleton()->accessibility_update_set_transform(accessibility_scroll_element, scroll_xform); + DisplayServer::get_singleton()->accessibility_update_set_bounds(accessibility_scroll_element, Rect2(0, 0, scroll_bar_h->get_max(), scroll_bar_v->get_max())); + + for (int i = 0; i < items.size(); i++) { + const Item &item = items.write[i]; + + if (item.accessibility_item_element.is_null()) { + item.accessibility_item_element = DisplayServer::get_singleton()->accessibility_create_sub_element(accessibility_scroll_element, DisplayServer::AccessibilityRole::ROLE_LIST_BOX_OPTION); + item.accessibility_item_dirty = true; + } + if (item.accessibility_item_dirty || i == hovered || i == prev_hovered) { + DisplayServer::get_singleton()->accessibility_update_add_action(item.accessibility_item_element, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &ItemList::_accessibility_action_scroll_into_view).bind(i)); + DisplayServer::get_singleton()->accessibility_update_add_action(item.accessibility_item_element, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &ItemList::_accessibility_action_focus).bind(i)); + DisplayServer::get_singleton()->accessibility_update_add_action(item.accessibility_item_element, DisplayServer::AccessibilityAction::ACTION_BLUR, callable_mp(this, &ItemList::_accessibility_action_blur).bind(i)); + + DisplayServer::get_singleton()->accessibility_update_set_list_item_index(item.accessibility_item_element, i); + DisplayServer::get_singleton()->accessibility_update_set_list_item_level(item.accessibility_item_element, 0); + DisplayServer::get_singleton()->accessibility_update_set_list_item_selected(item.accessibility_item_element, item.selected); + DisplayServer::get_singleton()->accessibility_update_set_name(item.accessibility_item_element, item.xl_text); + DisplayServer::get_singleton()->accessibility_update_set_flag(item.accessibility_item_element, DisplayServer::AccessibilityFlags::FLAG_DISABLED, item.disabled); + if (item.tooltip_enabled) { + DisplayServer::get_singleton()->accessibility_update_set_tooltip(item.accessibility_item_element, item.tooltip); + } + + Rect2 r = get_item_rect(i); + DisplayServer::get_singleton()->accessibility_update_set_bounds(item.accessibility_item_element, Rect2(r.position, r.size)); + + item.accessibility_item_dirty = false; + } + } + prev_hovered = -1; + + } break; + case NOTIFICATION_RESIZED: { shape_changed = true; queue_redraw(); @@ -1089,6 +1282,7 @@ void ItemList::_notification(int p_what) { _shape_text(i); } shape_changed = true; + queue_accessibility_update(); queue_redraw(); } break; case NOTIFICATION_TRANSLATION_CHANGED: { @@ -1097,6 +1291,7 @@ void ItemList::_notification(int p_what) { _shape_text(i); } shape_changed = true; + queue_accessibility_update(); queue_redraw(); } break; @@ -1537,6 +1732,8 @@ void ItemList::force_update_list_size() { items.write[i].rect_cache.size = minsize; items.write[i].min_rect_cache.size = minsize; + + items.write[i].accessibility_item_dirty = true; } int fit_size = size.x - theme_cache.panel_style->get_minimum_size().width; @@ -1661,7 +1858,9 @@ void ItemList::_scroll_changed(double) { void ItemList::_mouse_exited() { if (hovered > -1) { + prev_hovered = hovered; hovered = -1; + queue_accessibility_update(); queue_redraw(); } } @@ -1763,6 +1962,7 @@ String ItemList::get_tooltip(const Point2 &p_pos) const { void ItemList::sort_items_by_text() { items.sort(); + queue_accessibility_update(); queue_redraw(); shape_changed = true; @@ -1872,6 +2072,7 @@ void ItemList::set_auto_width(bool p_enable) { auto_width = p_enable; shape_changed = true; + queue_accessibility_update(); queue_redraw(); } @@ -1886,6 +2087,7 @@ void ItemList::set_auto_height(bool p_enable) { auto_height = p_enable; shape_changed = true; + queue_accessibility_update(); queue_redraw(); } diff --git a/scene/gui/item_list.h b/scene/gui/item_list.h index 5180222512ad..26f21410fe89 100644 --- a/scene/gui/item_list.h +++ b/scene/gui/item_list.h @@ -52,6 +52,9 @@ class ItemList : public Control { private: struct Item { + mutable RID accessibility_item_element; + mutable bool accessibility_item_dirty = true; + Ref icon; bool icon_transposed = false; Rect2i icon_region; @@ -87,12 +90,14 @@ class ItemList : public Control { Item(bool p_dummy) {} }; + RID accessibility_scroll_element; static inline PropertyListHelper base_property_helper; PropertyListHelper property_helper; int current = -1; int hovered = -1; + int prev_hovered = -1; bool shape_changed = true; @@ -180,7 +185,18 @@ class ItemList : public Control { bool _property_get_revert(const StringName &p_name, Variant &r_property) const { return property_helper.property_get_revert(p_name, r_property); } static void _bind_methods(); + void _accessibility_action_scroll_set(const Variant &p_data); + void _accessibility_action_scroll_up(const Variant &p_data); + void _accessibility_action_scroll_down(const Variant &p_data); + void _accessibility_action_scroll_left(const Variant &p_data); + void _accessibility_action_scroll_right(const Variant &p_data); + void _accessibility_action_scroll_into_view(const Variant &p_data, int p_index); + void _accessibility_action_focus(const Variant &p_data, int p_index); + void _accessibility_action_blur(const Variant &p_data, int p_index); + public: + virtual RID get_focused_accessibility_element() const override; + virtual void gui_input(const Ref &p_event) override; int add_item(const String &p_item, const Ref &p_texture = Ref(), bool p_selectable = true); diff --git a/scene/gui/label.cpp b/scene/gui/label.cpp index f763cad51cc9..6418125fc50c 100644 --- a/scene/gui/label.cpp +++ b/scene/gui/label.cpp @@ -100,6 +100,7 @@ void Label::set_uppercase(bool p_uppercase) { uppercase = p_uppercase; text_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -692,6 +693,15 @@ PackedStringArray Label::get_configuration_warnings() const { void Label::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(ae, xl_text); + DisplayServer::get_singleton()->accessibility_update_set_text_align(ae, horizontal_alignment); + } break; + case NOTIFICATION_TRANSLATION_CHANGED: { String new_text = atr(text); if (new_text == xl_text) { @@ -703,6 +713,7 @@ void Label::_notification(int p_what) { } text_dirty = true; + queue_accessibility_update(); queue_redraw(); update_configuration_warnings(); } break; @@ -749,7 +760,11 @@ void Label::_notification(int p_what) { int shadow_outline_size = has_settings ? settings->get_shadow_size() : theme_cache.font_shadow_outline_size; bool rtl_layout = is_layout_rtl(); - style->draw(ci, Rect2(Point2(0, 0), get_size())); + if (has_focus()) { + theme_cache.focus_style->draw(ci, Rect2(Point2(0, 0), get_size())); + } else { + theme_cache.normal_style->draw(ci, Rect2(Point2(0, 0), get_size())); + } bool trim_chars = (visible_chars >= 0) && (visible_chars_behavior == TextServer::VC_CHARS_AFTER_SHAPING); bool trim_glyphs_ltr = (visible_chars >= 0) && ((visible_chars_behavior == TextServer::VC_GLYPHS_LTR) || ((visible_chars_behavior == TextServer::VC_GLYPHS_AUTO) && !rtl_layout)); @@ -1070,7 +1085,7 @@ void Label::set_horizontal_alignment(HorizontalAlignment p_alignment) { } } horizontal_alignment = p_alignment; - + queue_accessibility_update(); queue_redraw(); } @@ -1103,6 +1118,7 @@ void Label::set_text(const String &p_string) { if (visible_ratio < 1) { visible_chars = get_total_character_count() * visible_ratio; } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); update_configuration_warnings(); @@ -1193,6 +1209,7 @@ void Label::set_paragraph_separator(const String &p_paragraph_separator) { if (paragraph_separator != p_paragraph_separator) { paragraph_separator = p_paragraph_separator; text_dirty = true; + queue_accessibility_update(); queue_redraw(); } } @@ -1285,6 +1302,7 @@ void Label::set_visible_characters(int p_amount) { } if (visible_chars_behavior == TextServer::VC_CHARS_BEFORE_SHAPING) { text_dirty = true; + queue_accessibility_update(); } queue_redraw(); } @@ -1309,6 +1327,7 @@ void Label::set_visible_ratio(float p_ratio) { if (visible_chars_behavior == TextServer::VC_CHARS_BEFORE_SHAPING) { text_dirty = true; + queue_accessibility_update(); } queue_redraw(); } @@ -1326,6 +1345,7 @@ void Label::set_visible_characters_behavior(TextServer::VisibleCharactersBehavio if (visible_chars_behavior != p_behavior) { if (visible_chars_behavior == TextServer::VC_CHARS_BEFORE_SHAPING || p_behavior == TextServer::VC_CHARS_BEFORE_SHAPING) { text_dirty = true; + queue_accessibility_update(); } visible_chars_behavior = p_behavior; queue_redraw(); @@ -1448,6 +1468,7 @@ void Label::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "structured_text_bidi_override_options"), "set_structured_text_bidi_override_options", "get_structured_text_bidi_override_options"); BIND_THEME_ITEM_CUSTOM(Theme::DATA_TYPE_STYLEBOX, Label, normal_style, "normal"); + BIND_THEME_ITEM_CUSTOM(Theme::DATA_TYPE_STYLEBOX, Label, focus_style, "focus"); BIND_THEME_ITEM(Theme::DATA_TYPE_CONSTANT, Label, line_spacing); BIND_THEME_ITEM(Theme::DATA_TYPE_CONSTANT, Label, paragraph_spacing); @@ -1463,6 +1484,7 @@ void Label::_bind_methods() { } Label::Label(const String &p_text) { + set_focus_mode(FOCUS_ACCESSIBILITY); set_mouse_filter(MOUSE_FILTER_IGNORE); set_text(p_text); set_v_size_flags(SIZE_SHRINK_CENTER); diff --git a/scene/gui/label.h b/scene/gui/label.h index 34b25d772626..b4fa53e1b23e 100644 --- a/scene/gui/label.h +++ b/scene/gui/label.h @@ -90,6 +90,7 @@ class Label : public Control { struct ThemeCache { Ref normal_style; + Ref focus_style; Ref font; int font_size = 0; diff --git a/scene/gui/line_edit.cpp b/scene/gui/line_edit.cpp index 4eace744e1cc..d0993c554cea 100644 --- a/scene/gui/line_edit.cpp +++ b/scene/gui/line_edit.cpp @@ -33,6 +33,7 @@ #include "core/input/input_map.h" #include "core/os/keyboard.h" #include "core/os/os.h" +#include "core/string/translation_server.h" #include "scene/gui/label.h" #include "scene/main/window.h" #include "scene/theme/theme_db.h" @@ -486,6 +487,7 @@ void LineEdit::gui_input(const Ref &p_event) { if (!pass && DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_CLIPBOARD_PRIMARY)) { DisplayServer::get_singleton()->clipboard_set_primary(text); } + queue_accessibility_update(); } else if (b->is_double_click()) { // Double-click select word. last_dblclk = OS::get_singleton()->get_ticks_msec(); @@ -500,6 +502,7 @@ void LineEdit::gui_input(const Ref &p_event) { selection.creating = true; selection.start_column = caret_column; set_caret_column(selection.end); + queue_accessibility_update(); break; } } @@ -973,7 +976,9 @@ void LineEdit::drop_data(const Point2 &p_point, const Variant &p_data) { if (p_data.is_string() && is_editable()) { apply_ime(); - set_caret_at_pixel_pos(p_point.x); + if (p_point != Vector2(INFINITY, INFINITY)) { + set_caret_at_pixel_pos(p_point.x); + } int caret_column_tmp = caret_column; bool is_inside_sel = selection.enabled && caret_column >= selection.begin && caret_column <= selection.end; if (Input::get_singleton()->is_key_pressed(Key::CMD_OR_CTRL)) { @@ -1009,6 +1014,7 @@ void LineEdit::drop_data(const Point2 &p_point, const Variant &p_data) { } text_changed_dirty = true; } + queue_accessibility_update(); queue_redraw(); } } @@ -1035,6 +1041,33 @@ void LineEdit::_update_theme_item_cache() { theme_cache.base_scale = get_theme_default_base_scale(); } +void LineEdit::_accessibility_action_set_selection(const Variant &p_data) { + Dictionary new_selection = p_data; + int sel_start_pos = new_selection["start_char"]; + int sel_end_pos = new_selection["end_char"]; + select(sel_start_pos, sel_end_pos); +} + +void LineEdit::_accessibility_action_replace_selected(const Variant &p_data) { + String new_text = p_data; + insert_text_at_caret(new_text); +} + +void LineEdit::_accessibility_action_set_value(const Variant &p_data) { + String new_text = p_data; + set_text(new_text); +} + +void LineEdit::_accessibility_action_menu(const Variant &p_data) { + _update_context_menu(); + + Point2 pos = Point2(get_caret_pixel_pos().x, (get_size().y + theme_cache.font->get_height(theme_cache.font_size)) / 2); + menu->set_position(get_screen_position() + pos); + menu->reset_size(); + menu->popup(); + menu->grab_focus(); +} + void LineEdit::_notification(int p_what) { switch (p_what) { #ifdef TOOLS_ENABLED @@ -1049,6 +1082,98 @@ void LineEdit::_notification(int p_what) { } } break; #endif + case NOTIFICATION_EXIT_TREE: + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + accessibility_text_root_element = RID(); + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_TEXT_FIELD); + bool using_placeholder = text.is_empty() && ime_text.is_empty(); + if (using_placeholder && !placeholder.is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_placeholder(ae, atr(placeholder)); + } + if (!placeholder.is_empty() && get_accessibility_name().is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_name(ae, atr(placeholder)); + } + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_READONLY, !editable); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_TEXT_SELECTION, callable_mp(this, &LineEdit::_accessibility_action_set_selection)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_REPLACE_SELECTED_TEXT, callable_mp(this, &LineEdit::_accessibility_action_replace_selected)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_VALUE, callable_mp(this, &LineEdit::_accessibility_action_set_value)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SHOW_CONTEXT_MENU, callable_mp(this, &LineEdit::_accessibility_action_menu)); + if (!language.is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_language(ae, language); + } else { + DisplayServer::get_singleton()->accessibility_update_set_language(ae, TranslationServer::get_singleton()->get_tool_locale()); + } + + bool rtl = is_layout_rtl(); + Ref style = theme_cache.normal; + Ref font = theme_cache.font; + + Size2 size = get_size(); + + int x_ofs = 0; + float text_width = TS->shaped_text_get_size(text_rid).x; + float text_height = TS->shaped_text_get_size(text_rid).y; + int y_area = size.height - style->get_minimum_size().height; + int y_ofs = style->get_offset().y + (y_area - text_height) / 2; + + switch (alignment) { + case HORIZONTAL_ALIGNMENT_FILL: + case HORIZONTAL_ALIGNMENT_LEFT: { + if (rtl) { + x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - Math::ceil(style->get_margin(SIDE_RIGHT) + (text_width)))); + } else { + x_ofs = style->get_offset().x; + } + } break; + case HORIZONTAL_ALIGNMENT_CENTER: { + if (!Math::is_zero_approx(scroll_offset)) { + x_ofs = style->get_offset().x; + } else { + x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - (text_width)) / 2); + } + } break; + case HORIZONTAL_ALIGNMENT_RIGHT: { + if (rtl) { + x_ofs = style->get_offset().x; + } else { + x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - Math::ceil(style->get_margin(SIDE_RIGHT) + (text_width)))); + } + } break; + } + bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled; + if (right_icon.is_valid() || display_clear_icon) { + Ref r_icon = display_clear_icon ? theme_cache.clear_icon : right_icon; + if (alignment == HORIZONTAL_ALIGNMENT_CENTER) { + if (Math::is_zero_approx(scroll_offset)) { + x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2); + } + } else { + x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT)); + } + } + + float text_off_x = x_ofs + scroll_offset; + + if (accessibility_text_root_element.is_null()) { + accessibility_text_root_element = DisplayServer::get_singleton()->accessibility_create_sub_text_edit_elements(ae, using_placeholder ? RID() : text_rid, text_height); + } + + Transform2D text_xform; + text_xform.set_origin(Vector2i(text_off_x, y_ofs)); + DisplayServer::get_singleton()->accessibility_update_set_transform(accessibility_text_root_element, text_xform); + if (selection.enabled) { + DisplayServer::get_singleton()->accessibility_update_set_text_selection(ae, accessibility_text_root_element, selection.begin, accessibility_text_root_element, selection.end); + } else { + DisplayServer::get_singleton()->accessibility_update_set_text_selection(ae, accessibility_text_root_element, caret_column, accessibility_text_root_element, caret_column); + } + } break; case NOTIFICATION_RESIZED: { _fit_to_width(); @@ -1209,6 +1334,7 @@ void LineEdit::_notification(int p_what) { RenderingServer::get_singleton()->canvas_item_add_rect(ci, rect, selection_color); } } + const Glyph *glyphs = TS->shaped_text_get_glyphs(text_rid); int gl_size = TS->shaped_text_get_glyph_count(text_rid); @@ -1921,6 +2047,8 @@ void LineEdit::set_caret_column(int p_column) { caret_column = p_column; + queue_accessibility_update(); + // Fit to window. if (!is_inside_tree()) { @@ -1989,6 +2117,7 @@ void LineEdit::set_caret_column(int p_column) { scroll_offset = MIN(0, scroll_offset); + queue_accessibility_update(); queue_redraw(); } @@ -2083,6 +2212,7 @@ void LineEdit::deselect() { selection.enabled = false; selection.creating = false; selection.double_click = false; + queue_accessibility_update(); queue_redraw(); } @@ -2141,6 +2271,7 @@ void LineEdit::selection_fill_at_caret() { } selection.enabled = (selection.begin != selection.end); + queue_accessibility_update(); } void LineEdit::select_all() { @@ -2156,6 +2287,7 @@ void LineEdit::select_all() { selection.begin = 0; selection.end = text.length(); selection.enabled = true; + queue_accessibility_update(); queue_redraw(); } @@ -2173,6 +2305,7 @@ void LineEdit::set_editable(bool p_editable) { _validate_caret_can_draw(); update_minimum_size(); + queue_accessibility_update(); queue_redraw(); } @@ -2242,6 +2375,7 @@ void LineEdit::select(int p_from, int p_to) { selection.end = p_to; selection.creating = false; selection.double_click = false; + queue_accessibility_update(); queue_redraw(); } @@ -2635,6 +2769,13 @@ void LineEdit::_shape() { if ((expand_to_text_length && old_size.x != size.x) || (old_size.y != size.y)) { update_minimum_size(); } + + if (accessibility_text_root_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(accessibility_text_root_element); + accessibility_text_root_element = RID(); + } + + queue_accessibility_update(); } void LineEdit::_fit_to_width() { diff --git a/scene/gui/line_edit.h b/scene/gui/line_edit.h index b9d2fa4ee54a..13affe6a5605 100644 --- a/scene/gui/line_edit.h +++ b/scene/gui/line_edit.h @@ -105,6 +105,7 @@ class LineEdit : public Control { Point2 ime_selection; RID text_rid; + RID accessibility_text_root_element; float full_width = 0.0; bool selecting_enabled = true; @@ -264,6 +265,11 @@ class LineEdit : public Control { virtual void unhandled_key_input(const Ref &p_event) override; virtual void gui_input(const Ref &p_event) override; + void _accessibility_action_set_selection(const Variant &p_data); + void _accessibility_action_replace_selected(const Variant &p_data); + void _accessibility_action_set_value(const Variant &p_data); + void _accessibility_action_menu(const Variant &p_data); + public: void edit(); void unedit(); diff --git a/scene/gui/link_button.cpp b/scene/gui/link_button.cpp index 8b3305552215..46f364f0c731 100644 --- a/scene/gui/link_button.cpp +++ b/scene/gui/link_button.cpp @@ -44,6 +44,8 @@ void LinkButton::_shape() { } TS->shaped_text_set_bidi_override(text_buf->get_rid(), structured_text_parser(st_parser, st_args, xl_text)); text_buf->add_string(xl_text, font, font_size, language); + + queue_accessibility_update(); } void LinkButton::set_text(const String &p_text) { @@ -109,7 +111,10 @@ String LinkButton::get_language() const { } void LinkButton::set_uri(const String &p_uri) { - uri = p_uri; + if (uri != p_uri) { + uri = p_uri; + queue_accessibility_update(); + } } String LinkButton::get_uri() const { @@ -147,6 +152,17 @@ Size2 LinkButton::get_minimum_size() const { void LinkButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_LINK); + if (!xl_text.is_empty() && get_accessibility_name().is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_name(ae, xl_text); + } + DisplayServer::get_singleton()->accessibility_update_set_url(ae, uri); + } break; + case NOTIFICATION_TRANSLATION_CHANGED: { xl_text = atr(text); _shape(); @@ -288,7 +304,7 @@ void LinkButton::_bind_methods() { LinkButton::LinkButton(const String &p_text) { text_buf.instantiate(); - set_focus_mode(FOCUS_NONE); + set_focus_mode(FOCUS_ACCESSIBILITY); set_default_cursor_shape(CURSOR_POINTING_HAND); set_text(p_text); diff --git a/scene/gui/menu_bar.cpp b/scene/gui/menu_bar.cpp index 81742fc9165e..16a13812f629 100644 --- a/scene/gui/menu_bar.cpp +++ b/scene/gui/menu_bar.cpp @@ -85,6 +85,15 @@ void MenuBar::gui_input(const Ref &p_event) { _open_popup(selected_menu, true); } return; + } else if (p_event->is_action("ui_accept", true) && p_event->is_pressed()) { + if (focused_menu == -1) { + focused_menu = 0; + } + selected_menu = focused_menu; + if (active_menu >= 0) { + get_menu_popup(active_menu)->hide(); + } + _open_popup(selected_menu, true); } Ref mm = p_event; @@ -276,6 +285,12 @@ void MenuBar::unbind_global_menu() { void MenuBar::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_MENU_BAR); + } break; case NOTIFICATION_ENTER_TREE: { if (get_menu_count() > 0) { _refresh_menu_names(); @@ -408,6 +423,10 @@ void MenuBar::_draw_menu_item(int p_index) { bool pressed = (active_menu == p_index); bool rtl = is_layout_rtl(); + if (has_focus() && focused_menu == -1 && p_index == 0) { + hovered = true; + } + if (menu_cache[p_index].hidden) { return; } @@ -950,6 +969,7 @@ String MenuBar::get_tooltip(const Point2 &p_pos) const { } MenuBar::MenuBar() { + set_focus_mode(FOCUS_ALL); set_process_shortcut_input(true); } diff --git a/scene/gui/menu_button.cpp b/scene/gui/menu_button.cpp index dee54d9b7283..d9f35f44d377 100644 --- a/scene/gui/menu_button.cpp +++ b/scene/gui/menu_button.cpp @@ -126,6 +126,14 @@ int MenuButton::get_item_count() const { void MenuButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + DisplayServer::get_singleton()->accessibility_update_set_popup_type(ae, DisplayServer::AccessibilityPopupType::POPUP_MENU); + } break; + case NOTIFICATION_LAYOUT_DIRECTION_CHANGED: { popup->set_layout_direction((Window::LayoutDirection)get_layout_direction()); } break; @@ -218,7 +226,7 @@ MenuButton::MenuButton(const String &p_text) : set_toggle_mode(true); set_disable_shortcuts(false); set_process_shortcut_input(true); - set_focus_mode(FOCUS_NONE); + set_focus_mode(FOCUS_ACCESSIBILITY); set_action_mode(ACTION_MODE_BUTTON_PRESS); popup = memnew(PopupMenu); diff --git a/scene/gui/option_button.cpp b/scene/gui/option_button.cpp index af2cc8ffde47..9d9d04424b90 100644 --- a/scene/gui/option_button.cpp +++ b/scene/gui/option_button.cpp @@ -73,6 +73,14 @@ Size2 OptionButton::get_minimum_size() const { void OptionButton::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_BUTTON); + DisplayServer::get_singleton()->accessibility_update_set_popup_type(ae, DisplayServer::AccessibilityPopupType::POPUP_LIST); + } break; + case NOTIFICATION_POSTINITIALIZE: { _refresh_size_cache(); if (has_theme_icon(SNAME("arrow"))) { diff --git a/scene/gui/panel.cpp b/scene/gui/panel.cpp index 8096191933db..9f175ea34fee 100644 --- a/scene/gui/panel.cpp +++ b/scene/gui/panel.cpp @@ -33,6 +33,13 @@ void Panel::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_PANEL); + } break; + case NOTIFICATION_DRAW: { RID ci = get_canvas_item(); theme_cache.panel_style->draw(ci, Rect2(Point2(), get_size())); diff --git a/scene/gui/popup.cpp b/scene/gui/popup.cpp index cb88492d2c38..22323e1890c6 100644 --- a/scene/gui/popup.cpp +++ b/scene/gui/popup.cpp @@ -38,7 +38,7 @@ #include "scene/theme/theme_db.h" void Popup::_input_from_window(const Ref &p_event) { - if (get_flag(FLAG_POPUP) && p_event->is_action_pressed(SNAME("ui_cancel"), false, true)) { + if ((ac_popup || get_flag(FLAG_POPUP)) && p_event->is_action_pressed(SNAME("ui_cancel"), false, true)) { hide_reason = HIDE_REASON_CANCELED; // ESC pressed, mark as canceled unconditionally. _close_pressed(); } @@ -115,7 +115,7 @@ void Popup::_notification(int p_what) { } break; case NOTIFICATION_APPLICATION_FOCUS_OUT: { - if (!is_in_edited_scene_root() && get_flag(FLAG_POPUP)) { + if (!is_in_edited_scene_root() && (get_flag(FLAG_POPUP) || ac_popup)) { if (hide_reason == HIDE_REASON_NONE) { hide_reason = HIDE_REASON_UNFOCUSED; } @@ -126,7 +126,7 @@ void Popup::_notification(int p_what) { } void Popup::_parent_focused() { - if (popped_up && get_flag(FLAG_POPUP)) { + if (popped_up && (get_flag(FLAG_POPUP) || ac_popup)) { if (hide_reason == HIDE_REASON_NONE) { hide_reason = HIDE_REASON_UNFOCUSED; } diff --git a/scene/gui/popup.h b/scene/gui/popup.h index 1afc9a745868..de03ec64b720 100644 --- a/scene/gui/popup.h +++ b/scene/gui/popup.h @@ -40,6 +40,7 @@ class Popup : public Window { GDCLASS(Popup, Window); LocalVector visible_parents; + bool ac_popup = false; bool popped_up = false; public: @@ -59,6 +60,7 @@ class Popup : public Window { void _close_pressed(); virtual Rect2i _popup_adjust_rect() const override; virtual void _input_from_window(const Ref &p_event) override; + void set_ac_popup() { ac_popup = true; } void _notification(int p_what); void _validate_property(PropertyInfo &p_property) const; diff --git a/scene/gui/popup_menu.cpp b/scene/gui/popup_menu.cpp index 2baaa580c0c8..3ce639696577 100644 --- a/scene/gui/popup_menu.cpp +++ b/scene/gui/popup_menu.cpp @@ -499,9 +499,11 @@ void PopupMenu::_input_from_window_internal(const Ref &p_event) { bool match_found = false; for (int i = search_from; i < items.size(); i++) { if (!items[i].separator && !items[i].disabled) { + prev_mouse_over = mouse_over; mouse_over = i; emit_signal(SNAME("id_focused"), items[i].id); scroll_to_item(i); + queue_accessibility_update(); control->queue_redraw(); set_input_as_handled(); match_found = true; @@ -513,9 +515,11 @@ void PopupMenu::_input_from_window_internal(const Ref &p_event) { // If the last item is not selectable, try re-searching from the start. for (int i = 0; i < search_from; i++) { if (!items[i].separator && !items[i].disabled) { + prev_mouse_over = mouse_over; mouse_over = i; emit_signal(SNAME("id_focused"), items[i].id); scroll_to_item(i); + queue_accessibility_update(); control->queue_redraw(); set_input_as_handled(); break; @@ -537,9 +541,11 @@ void PopupMenu::_input_from_window_internal(const Ref &p_event) { bool match_found = false; for (int i = search_from; i >= 0; i--) { if (!items[i].separator && !items[i].disabled) { + prev_mouse_over = mouse_over; mouse_over = i; emit_signal(SNAME("id_focused"), items[i].id); scroll_to_item(i); + queue_accessibility_update(); control->queue_redraw(); set_input_as_handled(); match_found = true; @@ -551,9 +557,11 @@ void PopupMenu::_input_from_window_internal(const Ref &p_event) { // If the first item is not selectable, try re-searching from the end. for (int i = items.size() - 1; i >= search_from; i--) { if (!items[i].separator && !items[i].disabled) { + prev_mouse_over = mouse_over; mouse_over = i; emit_signal(SNAME("id_focused"), items[i].id); scroll_to_item(i); + queue_accessibility_update(); control->queue_redraw(); set_input_as_handled(); break; @@ -738,9 +746,11 @@ void PopupMenu::_input_from_window_internal(const Ref &p_event) { } if (items[i].text.findn(search_string) == 0) { + prev_mouse_over = mouse_over; mouse_over = i; emit_signal(SNAME("id_focused"), items[i].id); scroll_to_item(i); + queue_accessibility_update(); control->queue_redraw(); set_input_as_handled(); break; @@ -755,6 +765,7 @@ void PopupMenu::_mouse_over_update(const Point2 &p_over) { if (id < 0) { mouse_over = -1; + queue_accessibility_update(); control->queue_redraw(); return; } @@ -766,6 +777,7 @@ void PopupMenu::_mouse_over_update(const Point2 &p_over) { if (over != mouse_over) { mouse_over = over; + queue_accessibility_update(); control->queue_redraw(); } } @@ -1104,8 +1116,105 @@ void PopupMenu::remove_child_notify(Node *p_child) { _menu_changed(); } +void PopupMenu::_accessibility_action_click(const Variant &p_data, int p_idx) { + activate_item(p_idx); +} + +RID PopupMenu::get_focused_accessibility_element() const { + if (mouse_over == -1) { + return get_accessibility_element(); + } else { + const Item &item = items[mouse_over]; + return item.accessibility_item_element; + } +} + void PopupMenu::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_EXIT_TREE: { + if (system_menu_id != NativeMenu::INVALID_MENU_ID) { + unbind_global_menu(); + } + [[fallthrough]]; + } + + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + for (int i = 0; i < items.size(); i++) { + items.write[i].accessibility_item_element = RID(); + } + accessibility_scroll_element = RID(); + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + if (has_meta("_menu_name")) { + DisplayServer::get_singleton()->accessibility_update_set_name(ae, get_meta("_menu_name", get_name())); + } + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_MENU); + DisplayServer::get_singleton()->accessibility_update_set_list_item_count(ae, items.size()); + + if (accessibility_scroll_element.is_null()) { + accessibility_scroll_element = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + } + + Transform2D scroll_xform; + scroll_xform.set_origin(Vector2i(0, -scroll_container->get_v_scroll_bar()->get_value())); + DisplayServer::get_singleton()->accessibility_update_set_transform(accessibility_scroll_element, scroll_xform); + DisplayServer::get_singleton()->accessibility_update_set_bounds(accessibility_scroll_element, Rect2(0, 0, get_size().x, scroll_container->get_v_scroll_bar()->get_max())); + + float scroll_width = scroll_container->get_v_scroll_bar()->is_visible_in_tree() ? scroll_container->get_v_scroll_bar()->get_size().width : 0; + float display_width = control->get_size().width - scroll_width; + Point2 ofs; + + for (int i = 0; i < items.size(); i++) { + const Item &item = items.write[i]; + + ofs.y += i > 0 ? theme_cache.v_separation : (float)theme_cache.v_separation / 2; + + Point2 item_ofs = ofs; + if (item.accessibility_item_element.is_null()) { + item.accessibility_item_element = DisplayServer::get_singleton()->accessibility_create_sub_element(accessibility_scroll_element, DisplayServer::AccessibilityRole::ROLE_MENU_ITEM); + item.accessibility_item_dirty = true; + } + + item_ofs.x += item.indent * theme_cache.indent; + float h = _get_item_height(i); + + if (item.accessibility_item_dirty || i == prev_mouse_over || i == mouse_over) { + switch (item.checkable_type) { + case Item::CHECKABLE_TYPE_NONE: { + DisplayServer::get_singleton()->accessibility_update_set_role(item.accessibility_item_element, DisplayServer::AccessibilityRole::ROLE_MENU_ITEM); + } break; + case Item::CHECKABLE_TYPE_CHECK_BOX: { + DisplayServer::get_singleton()->accessibility_update_set_role(item.accessibility_item_element, DisplayServer::AccessibilityRole::ROLE_MENU_ITEM_CHECK_BOX); + DisplayServer::get_singleton()->accessibility_update_set_checked(item.accessibility_item_element, item.checked); + } break; + case Item::CHECKABLE_TYPE_RADIO_BUTTON: { + DisplayServer::get_singleton()->accessibility_update_set_role(item.accessibility_item_element, DisplayServer::AccessibilityRole::ROLE_MENU_ITEM_RADIO); + DisplayServer::get_singleton()->accessibility_update_set_checked(item.accessibility_item_element, item.checked); + } break; + } + + DisplayServer::get_singleton()->accessibility_update_add_action(item.accessibility_item_element, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &PopupMenu::_accessibility_action_click).bind(i)); + DisplayServer::get_singleton()->accessibility_update_set_list_item_index(item.accessibility_item_element, i); + DisplayServer::get_singleton()->accessibility_update_set_list_item_level(item.accessibility_item_element, 0); + DisplayServer::get_singleton()->accessibility_update_set_list_item_selected(item.accessibility_item_element, i == mouse_over); + DisplayServer::get_singleton()->accessibility_update_set_name(item.accessibility_item_element, item.xl_text); + DisplayServer::get_singleton()->accessibility_update_set_flag(item.accessibility_item_element, DisplayServer::AccessibilityFlags::FLAG_DISABLED, item.disabled); + DisplayServer::get_singleton()->accessibility_update_set_tooltip(item.accessibility_item_element, item.tooltip); + + DisplayServer::get_singleton()->accessibility_update_set_bounds(item.accessibility_item_element, Rect2(item_ofs, Size2(display_width, h + theme_cache.v_separation))); + + item.accessibility_item_dirty = false; + } + ofs.y += h; + } + prev_mouse_over = -1; + + } break; + case NOTIFICATION_ENTER_TREE: { PopupMenu *pm = Object::cast_to(get_parent()); if (pm) { @@ -1118,12 +1227,6 @@ void PopupMenu::_notification(int p_what) { } } break; - case NOTIFICATION_EXIT_TREE: { - if (system_menu_id != NativeMenu::INVALID_MENU_ID) { - unbind_global_menu(); - } - } break; - case Control::NOTIFICATION_LAYOUT_DIRECTION_CHANGED: case NOTIFICATION_THEME_CHANGED: { panel->add_theme_style_override(SceneStringName(panel), theme_cache.panel_style); @@ -1151,7 +1254,9 @@ void PopupMenu::_notification(int p_what) { if (is_global) { nmenu->set_item_text(global_menu, i, item.xl_text); } + item.accessibility_item_dirty = true; _shape_item(i); + queue_accessibility_update(); } child_controls_changed(); @@ -1166,6 +1271,7 @@ void PopupMenu::_notification(int p_what) { case NOTIFICATION_WM_MOUSE_EXIT: { if (mouse_over >= 0 && (!items[mouse_over].submenu || submenu_over != -1)) { mouse_over = -1; + queue_accessibility_update(); control->queue_redraw(); } } break; @@ -1281,7 +1387,9 @@ void PopupMenu::_notification(int p_what) { case NOTIFICATION_VISIBILITY_CHANGED: { if (!is_visible()) { if (mouse_over >= 0) { + prev_mouse_over = mouse_over; mouse_over = -1; + queue_accessibility_update(); control->queue_redraw(); } @@ -1341,6 +1449,7 @@ void PopupMenu::add_item(const String &p_label, int p_id, Key p_accel) { } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1364,6 +1473,7 @@ void PopupMenu::add_icon_item(const Ref &p_icon, const String &p_labe } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1387,6 +1497,7 @@ void PopupMenu::add_check_item(const String &p_label, int p_id, Key p_accel) { } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1412,6 +1523,7 @@ void PopupMenu::add_icon_check_item(const Ref &p_icon, const String & } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1435,6 +1547,7 @@ void PopupMenu::add_radio_check_item(const String &p_label, int p_id, Key p_acce } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1460,6 +1573,7 @@ void PopupMenu::add_icon_radio_check_item(const Ref &p_icon, const St } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1485,6 +1599,7 @@ void PopupMenu::add_multistate_item(const String &p_label, int p_max_states, int } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1522,6 +1637,7 @@ void PopupMenu::add_shortcut(const Ref &p_shortcut, int p_id, bool p_g } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1551,6 +1667,7 @@ void PopupMenu::add_icon_shortcut(const Ref &p_icon, const Refqueue_redraw(); child_controls_changed(); @@ -1580,6 +1697,7 @@ void PopupMenu::add_check_shortcut(const Ref &p_shortcut, int p_id, bo } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1611,6 +1729,7 @@ void PopupMenu::add_icon_check_shortcut(const Ref &p_icon, const Ref< } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1640,6 +1759,7 @@ void PopupMenu::add_radio_check_shortcut(const Ref &p_shortcut, int p_ } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1671,6 +1791,7 @@ void PopupMenu::add_icon_radio_check_shortcut(const Ref &p_icon, cons } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1697,6 +1818,7 @@ void PopupMenu::add_submenu_node_item(const String &p_label, PopupMenu *p_submen item.text = p_label; item.xl_text = atr(p_label); item.id = p_id == -1 ? items.size() : p_id; + item.accessibility_item_dirty = true; item.submenu = p_submenu; item.submenu_name = p_submenu->get_name(); items.push_back(item); @@ -1710,6 +1832,7 @@ void PopupMenu::add_submenu_node_item(const String &p_label, PopupMenu *p_submen } _shape_item(items.size() - 1); + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); @@ -1733,13 +1856,16 @@ void PopupMenu::set_item_text(int p_idx, const String &p_text) { items.write[p_idx].text = p_text; items.write[p_idx].xl_text = _atr(p_idx, p_text); items.write[p_idx].dirty = true; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_text(global_menu, p_idx, items[p_idx].xl_text); } - _shape_item(p_idx); + _shape_item(p_idx); + queue_accessibility_update(); control->queue_redraw(); + child_controls_changed(); _menu_changed(); } @@ -1750,9 +1876,14 @@ void PopupMenu::set_item_text_direction(int p_idx, Control::TextDirection p_text } ERR_FAIL_INDEX(p_idx, items.size()); ERR_FAIL_COND((int)p_text_direction < -1 || (int)p_text_direction > 3); + if (items[p_idx].text_direction != p_text_direction) { items.write[p_idx].text_direction = p_text_direction; items.write[p_idx].dirty = true; + items.write[p_idx].accessibility_item_dirty = true; + + _shape_item(p_idx); + queue_accessibility_update(); control->queue_redraw(); } } @@ -1765,6 +1896,10 @@ void PopupMenu::set_item_language(int p_idx, const String &p_language) { if (items[p_idx].language != p_language) { items.write[p_idx].language = p_language; items.write[p_idx].dirty = true; + items.write[p_idx].accessibility_item_dirty = true; + + _shape_item(p_idx); + queue_accessibility_update(); control->queue_redraw(); } } @@ -1846,11 +1981,13 @@ void PopupMenu::set_item_checked(int p_idx, bool p_checked) { } items.write[p_idx].checked = p_checked; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_checked(global_menu, p_idx, p_checked); } + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); _menu_changed(); @@ -1889,11 +2026,13 @@ void PopupMenu::set_item_accelerator(int p_idx, Key p_accel) { items.write[p_idx].accel = p_accel; items.write[p_idx].dirty = true; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_accelerator(global_menu, p_idx, p_accel); } + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); _menu_changed(); @@ -1925,11 +2064,13 @@ void PopupMenu::set_item_disabled(int p_idx, bool p_disabled) { } items.write[p_idx].disabled = p_disabled; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_disabled(global_menu, p_idx, p_disabled); } + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); _menu_changed(); @@ -1993,11 +2134,13 @@ void PopupMenu::set_item_submenu_node(int p_idx, PopupMenu *p_submenu) { void PopupMenu::toggle_item_checked(int p_idx) { ERR_FAIL_INDEX(p_idx, items.size()); items.write[p_idx].checked = !items[p_idx].checked; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_checked(global_menu, p_idx, items[p_idx].checked); } + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); _menu_changed(); @@ -2134,6 +2277,9 @@ void PopupMenu::set_item_as_separator(int p_idx, bool p_separator) { } items.write[p_idx].separator = p_separator; + items.write[p_idx].accessibility_item_dirty = true; + + queue_accessibility_update(); control->queue_redraw(); } @@ -2154,11 +2300,13 @@ void PopupMenu::set_item_as_checkable(int p_idx, bool p_checkable) { } items.write[p_idx].checkable_type = p_checkable ? Item::CHECKABLE_TYPE_CHECK_BOX : Item::CHECKABLE_TYPE_NONE; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_checkable(global_menu, p_idx, p_checkable); } + queue_accessibility_update(); control->queue_redraw(); _menu_changed(); } @@ -2175,11 +2323,13 @@ void PopupMenu::set_item_as_radio_checkable(int p_idx, bool p_radio_checkable) { } items.write[p_idx].checkable_type = p_radio_checkable ? Item::CHECKABLE_TYPE_RADIO_BUTTON : Item::CHECKABLE_TYPE_NONE; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_radio_checkable(global_menu, p_idx, p_radio_checkable); } + queue_accessibility_update(); control->queue_redraw(); _menu_changed(); } @@ -2195,11 +2345,13 @@ void PopupMenu::set_item_tooltip(int p_idx, const String &p_tooltip) { } items.write[p_idx].tooltip = p_tooltip; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_tooltip(global_menu, p_idx, p_tooltip); } + queue_accessibility_update(); control->queue_redraw(); _menu_changed(); } @@ -2299,11 +2451,13 @@ void PopupMenu::set_item_multistate(int p_idx, int p_state) { } items.write[p_idx].state = p_state; + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_state(global_menu, p_idx, p_state); } + queue_accessibility_update(); control->queue_redraw(); _menu_changed(); } @@ -2348,11 +2502,13 @@ void PopupMenu::toggle_item_multistate(int p_idx) { if (items.write[p_idx].max_states <= items[p_idx].state) { items.write[p_idx].state = 0; } + items.write[p_idx].accessibility_item_dirty = true; if (global_menu.is_valid()) { NativeMenu::get_singleton()->set_item_state(global_menu, p_idx, items[p_idx].state); } + queue_accessibility_update(); control->queue_redraw(); _menu_changed(); } @@ -2386,11 +2542,12 @@ void PopupMenu::set_focused_item(int p_idx) { return; } + prev_mouse_over = mouse_over; mouse_over = p_idx; if (mouse_over != -1) { scroll_to_item(mouse_over); } - + queue_accessibility_update(); control->queue_redraw(); } @@ -2412,6 +2569,10 @@ void PopupMenu::set_item_count(int p_count) { if (is_global && prev_size > p_count) { for (int i = prev_size - 1; i >= p_count; i--) { nmenu->remove_item(global_menu, i); + if (items[i].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(items.write[i].accessibility_item_element); + items.write[i].accessibility_item_element = RID(); + } } } @@ -2592,6 +2753,10 @@ void PopupMenu::activate_item(int p_idx) { void PopupMenu::remove_item(int p_idx) { ERR_FAIL_INDEX(p_idx, items.size()); + if (items[p_idx].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(items.write[p_idx].accessibility_item_element); + items.write[p_idx].accessibility_item_element = RID(); + } if (items[p_idx].shortcut.is_valid()) { _unref_shortcut(items[p_idx].shortcut); } @@ -2611,6 +2776,7 @@ void PopupMenu::add_separator(const String &p_text, int p_id) { Item sep; sep.separator = true; sep.id = p_id; + sep.accessibility_item_dirty = true; if (!p_text.is_empty()) { sep.text = p_text; sep.xl_text = atr(p_text); @@ -2626,7 +2792,11 @@ void PopupMenu::add_separator(const String &p_text, int p_id) { } void PopupMenu::clear(bool p_free_submenus) { - for (const Item &I : items) { + for (Item &I : items) { + if (I.accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(I.accessibility_item_element); + I.accessibility_item_element = RID(); + } if (I.shortcut.is_valid()) { _unref_shortcut(I.shortcut); } @@ -2650,7 +2820,9 @@ void PopupMenu::clear(bool p_free_submenus) { } items.clear(); + prev_mouse_over = -1; mouse_over = -1; + queue_accessibility_update(); control->queue_redraw(); child_controls_changed(); notify_property_list_changed(); @@ -3032,7 +3204,15 @@ void PopupMenu::popup(const Rect2i &p_bounds) { if (native) { _native_popup(p_bounds != Rect2i() ? p_bounds : Rect2i(get_position(), Size2i())); } else { - set_flag(FLAG_NO_FOCUS, !is_embedded()); + if (is_inside_tree()) { + bool ac = get_tree()->is_accessibility_enabled(); + // Note: Native popup menus need keyboard focus to work with screen reader. + set_flag(FLAG_POPUP, !ac); + set_flag(FLAG_NO_FOCUS, !is_embedded() && !ac); + if (ac) { + set_ac_popup(); + } + } moved = Vector2(); popup_time_msec = OS::get_singleton()->get_ticks_msec(); @@ -3065,7 +3245,15 @@ void PopupMenu::set_visible(bool p_visible) { _native_popup(Rect2i(get_position(), get_size())); } } else { - set_flag(FLAG_NO_FOCUS, !is_embedded()); + if (is_inside_tree()) { + bool ac = get_tree()->is_accessibility_enabled(); + // Note: Native popup menus need keyboard focus to work with screen reader. + set_flag(FLAG_POPUP, !ac); + set_flag(FLAG_NO_FOCUS, !is_embedded() && !ac); + if (ac) { + set_ac_popup(); + } + } Popup::set_visible(p_visible); } diff --git a/scene/gui/popup_menu.h b/scene/gui/popup_menu.h index b014b76fd0ec..076eb5638c93 100644 --- a/scene/gui/popup_menu.h +++ b/scene/gui/popup_menu.h @@ -44,6 +44,9 @@ class PopupMenu : public Popup { static HashMap system_menus; struct Item { + mutable RID accessibility_item_element; + mutable bool accessibility_item_dirty = true; + Ref icon; int icon_max_width = 0; Color icon_modulate = Color(1, 1, 1, 1); @@ -95,6 +98,7 @@ class PopupMenu : public Popup { Item(bool p_dummy) {} }; + RID accessibility_scroll_element; mutable Rect2i pre_popup_rect; void _update_shadow_offsets() const; @@ -122,6 +126,7 @@ class PopupMenu : public Popup { bool during_grabbed_click = false; bool is_scrolling = false; int mouse_over = -1; + int prev_mouse_over = -1; int submenu_over = -1; String _get_accel_text(const Item &p_item) const; int _get_mouse_over(const Point2 &p_over) const; @@ -134,6 +139,8 @@ class PopupMenu : public Popup { void _shape_item(int p_idx) const; + void _accessibility_action_click(const Variant &p_data, int p_idx); + void _activate_submenu(int p_over, bool p_by_keyboard = false); void _submenu_timeout(); @@ -249,6 +256,8 @@ class PopupMenu : public Popup { // this value should be updated to reflect the new size. static const int ITEM_PROPERTY_SIZE = 10; + virtual RID get_focused_accessibility_element() const override; + virtual void _parent_focused() override; RID bind_global_menu(); diff --git a/scene/gui/progress_bar.cpp b/scene/gui/progress_bar.cpp index baf0c394ac93..0e2e18ce1790 100644 --- a/scene/gui/progress_bar.cpp +++ b/scene/gui/progress_bar.cpp @@ -54,6 +54,14 @@ void ProgressBar::_notification(int p_what) { queue_redraw(); } } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_PROGRESS_INDICATOR); + } break; + case NOTIFICATION_DRAW: { draw_style_box(theme_cache.background_style, Rect2(Point2(), get_size())); diff --git a/scene/gui/range.cpp b/scene/gui/range.cpp index d7c8d19b6fcf..dfecc1765f45 100644 --- a/scene/gui/range.cpp +++ b/scene/gui/range.cpp @@ -43,12 +43,51 @@ PackedStringArray Range::get_configuration_warnings() const { void Range::_value_changed(double p_value) { GDVIRTUAL_CALL(_value_changed, p_value); } + void Range::_value_changed_notify() { _value_changed(shared->val); emit_signal(SceneStringName(value_changed), shared->val); + queue_accessibility_update(); queue_redraw(); } +void Range::_accessibility_action_inc(const Variant &p_data) { + double step = ((shared->step > 0) ? shared->step : 1); + set_value(shared->val + step); +} + +void Range::_accessibility_action_dec(const Variant &p_data) { + double step = ((shared->step > 0) ? shared->step : 1); + set_value(shared->val - step); +} + +void Range::_accessibility_action_set_value(const Variant &p_data) { + double new_val = p_data; + set_value(new_val); +} + +void Range::_notification(int p_what) { + ERR_MAIN_THREAD_GUARD; + switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_SPIN_BUTTON); + DisplayServer::get_singleton()->accessibility_update_set_num_value(ae, shared->val); + DisplayServer::get_singleton()->accessibility_update_set_num_range(ae, shared->min, shared->max); + if (shared->step > 0) { + DisplayServer::get_singleton()->accessibility_update_set_num_step(ae, shared->step); + } else { + DisplayServer::get_singleton()->accessibility_update_set_num_step(ae, 1); + } + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_DECREMENT, callable_mp(this, &Range::_accessibility_action_dec)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_INCREMENT, callable_mp(this, &Range::_accessibility_action_inc)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_VALUE, callable_mp(this, &Range::_accessibility_action_set_value)); + } break; + } +} + void Range::Shared::emit_value_changed() { for (Range *E : owners) { Range *r = E; @@ -80,6 +119,7 @@ void Range::Shared::redraw_owners() { if (!r->is_inside_tree()) { continue; } + r->queue_accessibility_update(); r->queue_redraw(); } } @@ -91,6 +131,7 @@ void Range::set_value(double p_val) { if (shared->val != prev_val) { shared->emit_value_changed(); } + queue_accessibility_update(); } void Range::_set_value_no_signal(double p_val) { @@ -143,6 +184,8 @@ void Range::set_min(double p_min) { shared->emit_changed("min"); update_configuration_warnings(); + + queue_accessibility_update(); } void Range::set_max(double p_max) { @@ -156,6 +199,8 @@ void Range::set_max(double p_max) { set_value(shared->val); shared->emit_changed("max"); + + queue_accessibility_update(); } void Range::set_step(double p_step) { @@ -165,6 +210,8 @@ void Range::set_step(double p_step) { shared->step = p_step; shared->emit_changed("step"); + + queue_accessibility_update(); } void Range::set_page(double p_page) { @@ -177,6 +224,8 @@ void Range::set_page(double p_page) { set_value(shared->val); shared->emit_changed("page"); + + queue_accessibility_update(); } double Range::get_value() const { @@ -264,6 +313,7 @@ void Range::unshare() { nshared->allow_lesser = shared->allow_lesser; _unref_shared(); _ref_shared(nshared); + queue_accessibility_update(); } void Range::_ref_shared(Shared *p_shared) { diff --git a/scene/gui/range.h b/scene/gui/range.h index 4f3fefeff04c..165d6693b914 100644 --- a/scene/gui/range.h +++ b/scene/gui/range.h @@ -64,9 +64,14 @@ class Range : public Control { protected: virtual void _value_changed(double p_value); void _notify_shared_value_changed() { shared->emit_value_changed(); } + void _notification(int p_what); static void _bind_methods(); + void _accessibility_action_inc(const Variant &p_data); + void _accessibility_action_dec(const Variant &p_data); + void _accessibility_action_set_value(const Variant &p_data); + bool _rounded_values = false; GDVIRTUAL1(_value_changed, double) diff --git a/scene/gui/rich_text_label.compat.inc b/scene/gui/rich_text_label.compat.inc index c3a6e114f292..41a944b83c57 100644 --- a/scene/gui/rich_text_label.compat.inc +++ b/scene/gui/rich_text_label.compat.inc @@ -51,7 +51,15 @@ void RichTextLabel::_push_meta_bind_compat_89024(const Variant &p_meta) { } void RichTextLabel::_add_image_bind_compat_80410(const Ref &p_image, const int p_width, const int p_height, const Color &p_color, InlineAlignment p_alignment, const Rect2 &p_region) { - add_image(p_image, p_width, p_height, p_color, p_alignment, p_region, Variant(), false, String(), false); + add_image(p_image, p_width, p_height, p_color, p_alignment, p_region, Variant(), false, String(), false, String()); +} + +void RichTextLabel::_add_image_bind_compat_76829(const Ref &p_image, const int p_width, const int p_height, const Color &p_color, InlineAlignment p_alignment, const Rect2 &p_region, const Variant &p_key, bool p_pad, const String &p_tooltip, bool p_size_in_percent) { + add_image(p_image, p_width, p_height, p_color, p_alignment, p_region, p_key, p_pad, p_tooltip, p_size_in_percent, String()); +} + +void RichTextLabel::_push_table_bind_compat_76829(int p_columns, InlineAlignment p_alignment, int p_align_to_row) { + push_table(p_columns, p_alignment, p_align_to_row, String()); } bool RichTextLabel::_remove_paragraph_bind_compat_91098(int p_paragraph) { @@ -65,6 +73,8 @@ void RichTextLabel::_bind_compatibility_methods() { ClassDB::bind_compatibility_method(D_METHOD("push_meta", "data", "underline_mode"), &RichTextLabel::_push_meta_bind_compat_99481, DEFVAL(META_UNDERLINE_ALWAYS)); ClassDB::bind_compatibility_method(D_METHOD("push_meta", "data"), &RichTextLabel::_push_meta_bind_compat_89024); ClassDB::bind_compatibility_method(D_METHOD("add_image", "image", "width", "height", "color", "inline_align", "region"), &RichTextLabel::_add_image_bind_compat_80410, DEFVAL(0), DEFVAL(0), DEFVAL(Color(1.0, 1.0, 1.0)), DEFVAL(INLINE_ALIGNMENT_CENTER), DEFVAL(Rect2())); + ClassDB::bind_compatibility_method(D_METHOD("add_image", "image", "width", "height", "color", "inline_align", "region", "key", "pad", "tooltip", "size_in_percent"), &RichTextLabel::_add_image_bind_compat_76829, DEFVAL(0), DEFVAL(0), DEFVAL(Color(1.0, 1.0, 1.0)), DEFVAL(INLINE_ALIGNMENT_CENTER), DEFVAL(Rect2()), DEFVAL(Variant()), DEFVAL(false), DEFVAL(String()), DEFVAL(false)); + ClassDB::bind_compatibility_method(D_METHOD("push_table", "columns", "inline_align", "align_to_row"), &RichTextLabel::_push_table_bind_compat_76829, DEFVAL(INLINE_ALIGNMENT_TOP), DEFVAL(-1)); ClassDB::bind_compatibility_method(D_METHOD("remove_paragraph", "paragraph"), &RichTextLabel::_remove_paragraph_bind_compat_91098); } diff --git a/scene/gui/rich_text_label.cpp b/scene/gui/rich_text_label.cpp index 6f3c5961e13f..f80c1483cc13 100644 --- a/scene/gui/rich_text_label.cpp +++ b/scene/gui/rich_text_label.cpp @@ -59,6 +59,9 @@ RichTextLabel::ItemCustomFX::~ItemCustomFX() { } RichTextLabel::Item *RichTextLabel::_get_next_item(Item *p_item, bool p_free) const { + if (!p_item) { + return nullptr; + } if (p_free) { if (p_item->subitems.size()) { return p_item->subitems.front()->get(); @@ -88,7 +91,7 @@ RichTextLabel::Item *RichTextLabel::_get_next_item(Item *p_item, bool p_free) co return p_item->E->next()->get(); } else { // Go up until something with a next is found. - while (p_item->type != ITEM_FRAME && !p_item->E->next()) { + while (p_item->parent && p_item->type != ITEM_FRAME && !p_item->E->next()) { p_item = p_item->parent; } @@ -102,41 +105,38 @@ RichTextLabel::Item *RichTextLabel::_get_next_item(Item *p_item, bool p_free) co } RichTextLabel::Item *RichTextLabel::_get_prev_item(Item *p_item, bool p_free) const { + if (!p_item) { + return nullptr; + } if (p_free) { - if (p_item->subitems.size()) { - return p_item->subitems.back()->get(); - } else if (!p_item->parent) { + if (!p_item->parent) { return nullptr; } else if (p_item->E->prev()) { - return p_item->E->prev()->get(); - } else { - // Go back until something with a prev is found. - while (p_item->parent && !p_item->E->prev()) { - p_item = p_item->parent; + p_item = p_item->E->prev()->get(); + while (p_item->subitems.size()) { + p_item = p_item->subitems.back()->get(); } - + return p_item; + } else { if (p_item->parent) { - return p_item->E->prev()->get(); + return p_item->parent; } else { return nullptr; } } } else { - if (p_item->subitems.size() && p_item->type != ITEM_TABLE) { - return p_item->subitems.back()->get(); - } else if (p_item->type == ITEM_FRAME) { + if (p_item->type == ITEM_FRAME) { return nullptr; } else if (p_item->E->prev()) { - return p_item->E->prev()->get(); - } else { - // Go back until something with a prev is found. - while (p_item->type != ITEM_FRAME && !p_item->E->prev()) { - p_item = p_item->parent; + p_item = p_item->E->prev()->get(); + while (p_item->subitems.size() && p_item->type != ITEM_TABLE) { + p_item = p_item->subitems.back()->get(); } - - if (p_item->type != ITEM_FRAME) { - return p_item->E->prev()->get(); + return p_item; + } else { + if (p_item->parent && p_item->type != ITEM_FRAME) { + return p_item->parent; } else { return nullptr; } @@ -361,6 +361,7 @@ float RichTextLabel::_resize_line(ItemFrame *p_frame, int p_line, const Ref= (int)p_frame->lines.size(), p_h); Line &l = p_frame->lines[p_line]; + MutexLock lock(l.text_buf->get_mutex()); l.indent = _find_margin(l.from, p_base_font, p_base_font_size) + l.prefix_width; @@ -430,6 +431,7 @@ float RichTextLabel::_shape_line(ItemFrame *p_frame, int p_line, const Ref ERR_FAIL_COND_V(p_line < 0 || p_line >= (int)p_frame->lines.size(), p_h); Line &l = p_frame->lines[p_line]; + MutexLock lock(l.text_buf->get_mutex()); BitField autowrap_flags = TextServer::BREAK_MANDATORY; @@ -449,6 +451,7 @@ float RichTextLabel::_shape_line(ItemFrame *p_frame, int p_line, const Ref autowrap_flags = autowrap_flags | autowrap_flags_trim; // Clear cache. + l.dc_item = nullptr; l.text_buf->clear(); l.text_buf->set_break_flags(autowrap_flags); l.text_buf->set_justification_flags(_find_jst_flags(l.from)); @@ -527,8 +530,9 @@ float RichTextLabel::_shape_line(ItemFrame *p_frame, int p_line, const Ref switch (it->type) { case ITEM_DROPCAP: { // Add dropcap. - const ItemDropcap *dc = static_cast(it); + ItemDropcap *dc = static_cast(it); l.text_buf->set_dropcap(dc->text, dc->font, dc->font_size, dc->dropcap_margins); + l.dc_item = dc; l.dc_color = dc->color; l.dc_ol_size = dc->ol_size; l.dc_ol_color = dc->ol_color; @@ -1879,8 +1883,431 @@ void RichTextLabel::_update_theme_item_cache() { use_selected_font_color = theme_cache.font_selected_color != Color(0, 0, 0, 0); } +PackedStringArray RichTextLabel::get_accessibility_configuration_warnings() const { + PackedStringArray warnings = Control::get_accessibility_configuration_warnings(); + + Item *it = main; + while (it) { + if (it->type == ITEM_IMAGE) { + ItemImage *img = static_cast(it); + if (img && img->alt_text.strip_edges().is_empty()) { + warnings.push_back(RTR("Image alternative text must not be empty.")); + } + } + it = _get_next_item(it, true); + } + + return warnings; +} + +void RichTextLabel::_accessibility_update_line(RID p_id, ItemFrame *p_frame, int p_line, const Vector2 &p_ofs, int p_width, float p_vsep) { + ERR_FAIL_NULL(p_frame); + ERR_FAIL_COND(p_line < 0 || p_line >= (int)p_frame->lines.size()); + + Line &l = p_frame->lines[p_line]; + + if (l.accessibility_line_element.is_valid()) { + return; + } + l.accessibility_line_element = DisplayServer::get_singleton()->accessibility_create_sub_element(p_id, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + + MutexLock lock(l.text_buf->get_mutex()); + + const RID &line_ae = l.accessibility_line_element; + + Rect2 ae_rect = Rect2(p_ofs, Size2(p_width, l.text_buf->get_size().y + l.text_buf->get_line_count() * theme_cache.line_separation)); + DisplayServer::get_singleton()->accessibility_update_set_bounds(line_ae, ae_rect); + ac_element_bounds_cache[line_ae] = ae_rect; + + Item *it_from = l.from; + if (it_from == nullptr) { + return; + } + + bool rtl = (l.text_buf->get_direction() == TextServer::DIRECTION_RTL); + bool lrtl = is_layout_rtl(); + + // Process dropcap. + int dc_lines = l.text_buf->get_dropcap_lines(); + float h_off = l.text_buf->get_dropcap_size().x; + + // Process text. + const RID ¶_rid = l.text_buf->get_rid(); + + String l_text = TS->shaped_get_text(para_rid).replace(String::chr(0xfffc), "").strip_edges(); + if (l.dc_item) { + ItemDropcap *dc = static_cast(l.dc_item); + l_text = dc->text + l_text; + } + if (!l_text.is_empty()) { + Vector2 off; + if (rtl) { + off.x = p_width - l.offset.x - l.text_buf->get_width(); + if (!lrtl && p_frame == main) { // Skip Scrollbar. + off.x -= scroll_w; + } + } else { + off.x = l.offset.x; + if (lrtl && p_frame == main) { // Skip Scrollbar. + off.x += scroll_w; + } + } + + l.accessibility_text_element = DisplayServer::get_singleton()->accessibility_create_sub_element(line_ae, DisplayServer::AccessibilityRole::ROLE_STATIC_TEXT); + DisplayServer::get_singleton()->accessibility_update_set_value(l.accessibility_text_element, l_text); + ae_rect = Rect2(p_ofs + off, l.text_buf->get_size()); + DisplayServer::get_singleton()->accessibility_update_set_bounds(l.accessibility_text_element, ae_rect); + ac_element_bounds_cache[l.accessibility_text_element] = ae_rect; + + DisplayServer::get_singleton()->accessibility_update_add_action(l.accessibility_text_element, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &RichTextLabel::_accessibility_focus_item).bind((uint64_t)l.from, true, true)); + DisplayServer::get_singleton()->accessibility_update_add_action(l.accessibility_text_element, DisplayServer::AccessibilityAction::ACTION_BLUR, callable_mp(this, &RichTextLabel::_accessibility_focus_item).bind((uint64_t)l.from, true, false)); + DisplayServer::get_singleton()->accessibility_update_add_action(l.accessibility_text_element, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &RichTextLabel::_accessibility_scroll_to_item).bind((uint64_t)l.from)); + } + + Vector2 off; + for (int line = 0; line < l.text_buf->get_line_count(); line++) { + if (line > 0) { + off.y += (theme_cache.line_separation + p_vsep); + } + + const Size2 line_size = l.text_buf->get_line_size(line); + + float width = l.text_buf->get_width(); + float length = line_size.x; + + // Process line. + + if (rtl) { + off.x = p_width - l.offset.x - width; + if (!lrtl && p_frame == main) { // Skip Scrollbar. + off.x -= scroll_w; + } + } else { + off.x = l.offset.x; + if (lrtl && p_frame == main) { // Skip Scrollbar. + off.x += scroll_w; + } + } + + // Process text. + switch (l.text_buf->get_alignment()) { + case HORIZONTAL_ALIGNMENT_FILL: + case HORIZONTAL_ALIGNMENT_LEFT: { + if (rtl) { + off.x += width - length; + } + } break; + case HORIZONTAL_ALIGNMENT_CENTER: { + off.x += Math::floor((width - length) / 2.0); + } break; + case HORIZONTAL_ALIGNMENT_RIGHT: { + if (!rtl) { + off.x += width - length; + } + } break; + } + + if (line <= dc_lines) { + if (rtl) { + off.x -= h_off; + } else { + off.x += h_off; + } + } + + const RID &rid = l.text_buf->get_line_rid(line); + + Array objects = TS->shaped_text_get_objects(rid); + for (int i = 0; i < objects.size(); i++) { + Item *it = reinterpret_cast((uint64_t)objects[i]); + if (it != nullptr) { + Rect2 rect = TS->shaped_text_get_object_rect(rid, objects[i]); + switch (it->type) { + case ITEM_IMAGE: { + ItemImage *img = static_cast(it); + RID img_ae = DisplayServer::get_singleton()->accessibility_create_sub_element(line_ae, DisplayServer::AccessibilityRole::ROLE_IMAGE); + + DisplayServer::get_singleton()->accessibility_update_set_name(img_ae, img->alt_text); + if (img->pad) { + Size2 pad_size = rect.size.min(img->image->get_size()); + Vector2 pad_off = (rect.size - pad_size) / 2; + ae_rect = Rect2(p_ofs + rect.position + off + pad_off, pad_size); + } else { + ae_rect = Rect2(p_ofs + rect.position + off, rect.size); + } + DisplayServer::get_singleton()->accessibility_update_set_bounds(img_ae, ae_rect); + ac_element_bounds_cache[img_ae] = ae_rect; + + DisplayServer::get_singleton()->accessibility_update_add_action(img_ae, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &RichTextLabel::_accessibility_focus_item).bind((uint64_t)it, false, true)); + DisplayServer::get_singleton()->accessibility_update_add_action(img_ae, DisplayServer::AccessibilityAction::ACTION_BLUR, callable_mp(this, &RichTextLabel::_accessibility_focus_item).bind((uint64_t)it, false, false)); + DisplayServer::get_singleton()->accessibility_update_add_action(img_ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &RichTextLabel::_accessibility_scroll_to_item).bind((uint64_t)it)); + + it->accessibility_item_element = img_ae; + } break; + case ITEM_TABLE: { + ItemTable *table = static_cast(it); + float h_separation = theme_cache.table_h_separation; + float v_separation = theme_cache.table_v_separation; + + RID table_ae = DisplayServer::get_singleton()->accessibility_create_sub_element(line_ae, DisplayServer::AccessibilityRole::ROLE_TABLE); + + int col_count = table->columns.size(); + int row_count = table->rows.size(); + + DisplayServer::get_singleton()->accessibility_update_set_name(table_ae, table->name); + DisplayServer::get_singleton()->accessibility_update_set_role(table_ae, DisplayServer::AccessibilityRole::ROLE_TABLE); + DisplayServer::get_singleton()->accessibility_update_set_table_column_count(table_ae, col_count); + DisplayServer::get_singleton()->accessibility_update_set_table_row_count(table_ae, row_count); + ae_rect = Rect2(p_ofs + rect.position + off + Vector2(0, TS->shaped_text_get_ascent(rid)), rect.size); + DisplayServer::get_singleton()->accessibility_update_set_bounds(table_ae, ae_rect); + ac_element_bounds_cache[table_ae] = ae_rect; + + DisplayServer::get_singleton()->accessibility_update_add_action(table_ae, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &RichTextLabel::_accessibility_focus_item).bind((uint64_t)it, false, true)); + DisplayServer::get_singleton()->accessibility_update_add_action(table_ae, DisplayServer::AccessibilityAction::ACTION_BLUR, callable_mp(this, &RichTextLabel::_accessibility_focus_item).bind((uint64_t)it, false, false)); + DisplayServer::get_singleton()->accessibility_update_add_action(table_ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &RichTextLabel::_accessibility_scroll_to_item).bind((uint64_t)it)); + + Vector row_aes; + Vector2 row_off = Vector2(0, TS->shaped_text_get_ascent(rid)); + for (int j = 0; j < row_count; j++) { + RID row_ae = DisplayServer::get_singleton()->accessibility_create_sub_element(table_ae, DisplayServer::AccessibilityRole::ROLE_ROW); + + DisplayServer::get_singleton()->accessibility_update_set_table_row_index(row_ae, j); + ae_rect = Rect2(p_ofs + rect.position + off + row_off, Size2(rect.size.x, table->rows[j])); + DisplayServer::get_singleton()->accessibility_update_set_bounds(row_ae, ae_rect); + ac_element_bounds_cache[row_ae] = ae_rect; + row_off.y += table->rows[j]; + + row_aes.push_back(row_ae); + } + + int idx = 0; + for (Item *E : table->subitems) { + ItemFrame *frame = static_cast(E); + + int col = idx % col_count; + int row = idx / col_count; + + for (int j = 0; j < (int)frame->lines.size(); j++) { + RID cell_ae = DisplayServer::get_singleton()->accessibility_create_sub_element(row_aes[row], DisplayServer::AccessibilityRole::ROLE_CELL); + + if (frame->lines.size() != 0 && row < row_count) { + Vector2 coff = frame->lines[0].offset; + coff.x -= frame->lines[0].indent; + if (rtl) { + coff.x = rect.size.width - table->columns[col].width - coff.x; + } + ae_rect = Rect2(p_ofs + rect.position + off + coff - frame->padding.position - Vector2(h_separation * 0.5, v_separation * 0.5).floor(), Size2(table->columns[col].width + h_separation + frame->padding.position.x + frame->padding.size.x, table->rows[row])); + DisplayServer::get_singleton()->accessibility_update_set_bounds(cell_ae, ae_rect); + ac_element_bounds_cache[cell_ae] = ae_rect; + } + DisplayServer::get_singleton()->accessibility_update_set_table_cell_position(cell_ae, row, col); + + _accessibility_update_line(cell_ae, frame, j, p_ofs + rect.position + off + Vector2(0, frame->lines[j].offset.y), rect.size.x, p_vsep); + } + idx++; + } + + it->accessibility_item_element = table_ae; + } break; + default: + break; + } + } + } + + off.y += TS->shaped_text_get_descent(rid) + TS->shaped_text_get_ascent(rid); + } +} + +void RichTextLabel::_accessibility_action_menu(const Variant &p_data) { + if (context_menu_enabled) { + _update_context_menu(); + menu->set_position(get_screen_position()); + menu->reset_size(); + menu->popup(); + menu->grab_focus(); + } +} + +void RichTextLabel::_accessibility_scroll_down(const Variant &p_data) { + vscroll->set_value(vscroll->get_value() + vscroll->get_page() / 4); +} + +void RichTextLabel::_accessibility_scroll_up(const Variant &p_data) { + vscroll->set_value(vscroll->get_value() - vscroll->get_page() / 4); +} + +void RichTextLabel::_accessibility_scroll_set(const Variant &p_data) { + const Point2 &pos = p_data; + vscroll->set_value(pos.y); +} + +void RichTextLabel::_accessibility_focus_item(const Variant &p_data, uint64_t p_item, bool p_line, bool p_foucs) { + Item *it = reinterpret_cast(p_item); + if (p_foucs) { + ItemFrame *f = nullptr; + _find_frame(it, &f, nullptr); + + if (f && it) { + keyboard_focus_frame = f; + keyboard_focus_line = it->line; + keyboard_focus_item = it; + keyboard_focus_on_text = p_line; + } + } else { + keyboard_focus_frame = nullptr; + keyboard_focus_line = 0; + keyboard_focus_item = nullptr; + keyboard_focus_on_text = true; + } +} + +void RichTextLabel::_accessibility_scroll_to_item(const Variant &p_data, uint64_t p_item) { + Item *it = reinterpret_cast(p_item); + ItemFrame *f = nullptr; + _find_frame(it, &f, nullptr); + + if (f && it) { + vscroll->set_value(f->lines[it->line].offset.y); + } +} + +void RichTextLabel::_invalidate_accessibility() { + if (accessibility_scroll_element.is_null()) { + return; + } + + Item *it = main; + while (it) { + if (it->type == ITEM_FRAME) { + ItemFrame *fr = static_cast(it); + for (size_t i = 0; i < fr->lines.size(); i++) { + if (fr->lines[i].accessibility_line_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(fr->lines[i].accessibility_line_element); + } + fr->lines[i].accessibility_line_element = RID(); + fr->lines[i].accessibility_text_element = RID(); + } + } + it->accessibility_item_element = RID(); + it = _get_next_item(it, true); + } +} + +RID RichTextLabel::get_focused_accessibility_element() const { + if (keyboard_focus_frame && keyboard_focus_item) { + if (keyboard_focus_on_text) { + return keyboard_focus_frame->lines[keyboard_focus_line].accessibility_text_element; + } else { + if (keyboard_focus_item->accessibility_item_element.is_valid()) { + return keyboard_focus_item->accessibility_item_element; + } + } + } else { + if (!main->lines.is_empty()) { + return main->lines[0].accessibility_text_element; + } + } + return get_accessibility_element(); +} + void RichTextLabel::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + accessibility_scroll_element = RID(); + Item *it = main; + while (it) { + if (it->type == ITEM_FRAME) { + ItemFrame *fr = static_cast(it); + for (size_t i = 0; i < fr->lines.size(); i++) { + fr->lines[i].accessibility_line_element = RID(); + fr->lines[i].accessibility_text_element = RID(); + } + } + it->accessibility_item_element = RID(); + it = _get_next_item(it, true); + } + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SHOW_CONTEXT_MENU, callable_mp(this, &RichTextLabel::_accessibility_action_menu)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_DOWN, callable_mp(this, &RichTextLabel::_accessibility_scroll_down)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_UP, callable_mp(this, &RichTextLabel::_accessibility_scroll_up)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_SCROLL_OFFSET, callable_mp(this, &RichTextLabel::_accessibility_scroll_set)); + + if (_validate_line_caches()) { + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_BUSY, false); + } else { + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_BUSY, true); + return; // Do not update internal elements if threaded procesisng is not done. + } + + if (accessibility_scroll_element.is_null()) { + accessibility_scroll_element = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + } + Rect2 text_rect = _get_text_rect(); + + Transform2D scroll_xform; + scroll_xform.set_origin(Vector2i(0, -vscroll->get_value())); + DisplayServer::get_singleton()->accessibility_update_set_transform(accessibility_scroll_element, scroll_xform); + DisplayServer::get_singleton()->accessibility_update_set_bounds(accessibility_scroll_element, text_rect); + + MutexLock data_lock(data_mutex); + + int to_line = main->first_invalid_line.load(); + int from_line = 0; + + int total_height = INT32_MAX; + if (to_line && vertical_alignment != VERTICAL_ALIGNMENT_TOP) { + MutexLock lock(main->lines[to_line - 1].text_buf->get_mutex()); + if (theme_cache.line_separation < 0) { + // Do not apply to the last line to avoid cutting text. + total_height = main->lines[to_line - 1].offset.y + main->lines[to_line - 1].text_buf->get_size().y + (main->lines[to_line - 1].text_buf->get_line_count() - 1) * theme_cache.line_separation; + } else { + total_height = main->lines[to_line - 1].offset.y + main->lines[to_line - 1].text_buf->get_size().y + main->lines[to_line - 1].text_buf->get_line_count() * theme_cache.line_separation; + } + } + float vbegin = 0, vsep = 0; + if (text_rect.size.y > total_height) { + switch (vertical_alignment) { + case VERTICAL_ALIGNMENT_TOP: { + // Nothing. + } break; + case VERTICAL_ALIGNMENT_CENTER: { + vbegin = (text_rect.size.y - total_height) / 2; + } break; + case VERTICAL_ALIGNMENT_BOTTOM: { + vbegin = text_rect.size.y - total_height; + } break; + case VERTICAL_ALIGNMENT_FILL: { + int lines = 0; + for (int l = from_line; l < to_line; l++) { + MutexLock lock(main->lines[l].text_buf->get_mutex()); + lines += main->lines[l].text_buf->get_line_count(); + } + if (lines > 1) { + vsep = (text_rect.size.y - total_height) / (lines - 1); + } + } break; + } + } + + ac_element_bounds_cache.clear(); + Point2 ofs = text_rect.get_position() + Vector2(0, vbegin + main->lines[from_line].offset.y); + while (from_line < to_line) { + MutexLock lock(main->lines[from_line].text_buf->get_mutex()); + + _accessibility_update_line(accessibility_scroll_element, main, from_line, ofs, text_rect.size.x, vsep); + ofs.y += main->lines[from_line].text_buf->get_size().y + main->lines[from_line].text_buf->get_line_count() * (theme_cache.line_separation + vsep); + from_line++; + } + } break; + case NOTIFICATION_MOUSE_EXIT: { if (meta_hovering) { meta_hovering = nullptr; @@ -1893,12 +2320,16 @@ void RichTextLabel::_notification(int p_what) { case NOTIFICATION_RESIZED: { _stop_thread(); main->first_resized_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); + queue_accessibility_update(); queue_redraw(); } break; case NOTIFICATION_THEME_CHANGED: { _stop_thread(); main->first_invalid_font_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); + queue_accessibility_update(); queue_redraw(); } break; @@ -1909,12 +2340,27 @@ void RichTextLabel::_notification(int p_what) { } main->first_invalid_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); + queue_accessibility_update(); queue_redraw(); } break; case NOTIFICATION_PREDELETE: case NOTIFICATION_EXIT_TREE: { _stop_thread(); + + accessibility_scroll_element = RID(); + Item *it = main; + while (it) { + if (it->type == ITEM_FRAME) { + ItemFrame *fr = static_cast(it); + for (size_t i = 0; i < fr->lines.size(); i++) { + fr->lines[i].accessibility_line_element = RID(); + fr->lines[i].accessibility_text_element = RID(); + } + } + it = _get_next_item(it, true); + } } break; case NOTIFICATION_LAYOUT_DIRECTION_CHANGED: @@ -2030,6 +2476,25 @@ void RichTextLabel::_notification(int p_what) { ofs.y += main->lines[from_line].text_buf->get_size().y + main->lines[from_line].text_buf->get_line_count() * (theme_cache.line_separation + vsep); from_line++; } + if (has_focus() && get_tree()->is_accessibility_enabled()) { + RID ae; + if (keyboard_focus_frame && keyboard_focus_item) { + if (keyboard_focus_on_text) { + ae = keyboard_focus_frame->lines[keyboard_focus_line].accessibility_text_element; + } else { + if (keyboard_focus_item->accessibility_item_element.is_valid()) { + ae = keyboard_focus_item->accessibility_item_element; + } + } + } else { + if (!main->lines.is_empty()) { + ae = main->lines[0].accessibility_text_element; + } + } + if (ac_element_bounds_cache.has(ae)) { + draw_style_box(theme_cache.focus_style, ac_element_bounds_cache[ae]); + } + } } break; case NOTIFICATION_INTERNAL_PROCESS: { @@ -2148,6 +2613,7 @@ void RichTextLabel::gui_input(const Ref &p_event) { if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_CLIPBOARD_PRIMARY)) { DisplayServer::get_singleton()->clipboard_set_primary(get_selected_text()); } + queue_accessibility_update(); queue_redraw(); break; } @@ -2230,6 +2696,7 @@ void RichTextLabel::gui_input(const Ref &p_event) { if (pan_gesture.is_valid()) { if (scroll_active) { vscroll->scroll(vscroll->get_page() * pan_gesture->get_delta().y * 0.5 / 8); + queue_accessibility_update(); } return; @@ -2243,28 +2710,111 @@ void RichTextLabel::gui_input(const Ref &p_event) { if (k->is_action("ui_page_up", true) && vscroll->is_visible_in_tree()) { vscroll->scroll(-vscroll->get_page()); + queue_accessibility_update(); handled = true; } if (k->is_action("ui_page_down", true) && vscroll->is_visible_in_tree()) { vscroll->scroll(vscroll->get_page()); + queue_accessibility_update(); handled = true; } if (k->is_action("ui_up", true) && vscroll->is_visible_in_tree()) { vscroll->scroll(-theme_cache.normal_font->get_height(theme_cache.normal_font_size)); + queue_accessibility_update(); handled = true; } if (k->is_action("ui_down", true) && vscroll->is_visible_in_tree()) { vscroll->scroll(theme_cache.normal_font->get_height(theme_cache.normal_font_size)); + queue_accessibility_update(); handled = true; } if (k->is_action("ui_home", true) && vscroll->is_visible_in_tree()) { vscroll->scroll_to(0); + queue_accessibility_update(); handled = true; } if (k->is_action("ui_end", true) && vscroll->is_visible_in_tree()) { vscroll->scroll_to(vscroll->get_max()); + queue_accessibility_update(); handled = true; } + if (get_tree()->is_accessibility_enabled()) { + if (k->is_action("ui_left", true)) { + if (keyboard_focus_frame != nullptr) { + if (!keyboard_focus_on_text && keyboard_focus_line < (int)keyboard_focus_frame->lines.size() && keyboard_focus_frame->lines[keyboard_focus_line].from == keyboard_focus_item) { + keyboard_focus_on_text = true; + } else { + Item *it = keyboard_focus_item; + while (it) { + it = _get_prev_item(it, true); + if (it) { + ItemFrame *f = nullptr; + _find_frame(it, &f, nullptr); + if (it->type == ITEM_IMAGE || it->type == ITEM_TABLE) { + keyboard_focus_frame = f; + keyboard_focus_line = it->line; + keyboard_focus_item = it; + keyboard_focus_on_text = false; + break; + } + if (f && !f->lines.is_empty()) { + if (f->lines[it->line].from == it) { + keyboard_focus_frame = f; + keyboard_focus_line = it->line; + keyboard_focus_item = it; + keyboard_focus_on_text = true; + break; + } + } + } + } + } + } + queue_accessibility_update(); + queue_redraw(); + handled = true; + } + if (k->is_action("ui_right", true)) { + if (keyboard_focus_frame == nullptr) { + keyboard_focus_frame = main; + keyboard_focus_line = 0; + keyboard_focus_item = main->lines.is_empty() ? nullptr : main->lines[0].from; + keyboard_focus_on_text = true; + } else { + if (keyboard_focus_on_text && keyboard_focus_item && (keyboard_focus_item->type == ITEM_IMAGE || keyboard_focus_item->type == ITEM_TABLE)) { + keyboard_focus_on_text = false; + } else { + Item *it = keyboard_focus_item; + while (it) { + it = _get_next_item(it, true); + if (it) { + ItemFrame *f = nullptr; + _find_frame(it, &f, nullptr); + if (f && !f->lines.is_empty()) { + if (f->lines[it->line].from == it) { + keyboard_focus_frame = f; + keyboard_focus_line = it->line; + keyboard_focus_item = it; + keyboard_focus_on_text = true; + break; + } + } + if (it->type == ITEM_IMAGE || it->type == ITEM_TABLE) { + keyboard_focus_frame = f; + keyboard_focus_line = it->line; + keyboard_focus_item = it; + keyboard_focus_on_text = false; + break; + } + } + } + } + } + queue_accessibility_update(); + queue_redraw(); + handled = true; + } + } if (is_shortcut_keys_enabled()) { if (k->is_action("ui_text_select_all", true)) { select_all(); @@ -2355,6 +2905,7 @@ void RichTextLabel::gui_input(const Ref &p_event) { } selection.active = true; + queue_accessibility_update(); queue_redraw(); } @@ -2451,7 +3002,7 @@ RichTextLabel::ItemFont *RichTextLabel::_find_font(Item *p_item) { if (fontitem->type == ITEM_FONT) { ItemFont *fi = static_cast(fontitem); switch (fi->def_font) { - case NORMAL_FONT: { + case RTL_NORMAL_FONT: { if (fi->variation) { Ref fc = fi->font; if (fc.is_valid()) { @@ -2464,7 +3015,7 @@ RichTextLabel::ItemFont *RichTextLabel::_find_font(Item *p_item) { fi->font_size = theme_cache.normal_font_size; } } break; - case BOLD_FONT: { + case RTL_BOLD_FONT: { if (fi->variation) { Ref fc = fi->font; if (fc.is_valid()) { @@ -2477,7 +3028,7 @@ RichTextLabel::ItemFont *RichTextLabel::_find_font(Item *p_item) { fi->font_size = theme_cache.bold_font_size; } } break; - case ITALICS_FONT: { + case RTL_ITALICS_FONT: { if (fi->variation) { Ref fc = fi->font; if (fc.is_valid()) { @@ -2490,7 +3041,7 @@ RichTextLabel::ItemFont *RichTextLabel::_find_font(Item *p_item) { fi->font_size = theme_cache.italics_font_size; } } break; - case BOLD_ITALICS_FONT: { + case RTL_BOLD_ITALICS_FONT: { if (fi->variation) { Ref fc = fi->font; if (fc.is_valid()) { @@ -2503,7 +3054,7 @@ RichTextLabel::ItemFont *RichTextLabel::_find_font(Item *p_item) { fi->font_size = theme_cache.bold_italics_font_size; } } break; - case MONO_FONT: { + case RTL_MONO_FONT: { if (fi->variation) { Ref fc = fi->font; if (fc.is_valid()) { @@ -2952,6 +3503,7 @@ void RichTextLabel::_thread_end() { vscroll->hide(); } if (is_visible_in_tree()) { + queue_accessibility_update(); queue_redraw(); } } @@ -3074,6 +3626,7 @@ bool RichTextLabel::_validate_line_caches() { if (!scroll_visible) { vscroll->hide(); } + queue_accessibility_update(); return true; } @@ -3096,6 +3649,7 @@ bool RichTextLabel::_validate_line_caches() { if (!scroll_visible) { vscroll->hide(); } + queue_accessibility_update(); return true; } validating.store(false); @@ -3106,6 +3660,7 @@ bool RichTextLabel::_validate_line_caches() { task = WorkerThreadPool::get_singleton()->add_template_task(this, &RichTextLabel::_thread_function, nullptr, true, vformat("RichTextLabelShape:%x", (int64_t)get_instance_id())); set_physics_process_internal(true); loading_started = OS::get_singleton()->get_ticks_msec(); + queue_accessibility_update(); return false; } else { updating.store(true); @@ -3113,6 +3668,7 @@ bool RichTextLabel::_validate_line_caches() { if (!scroll_visible) { vscroll->hide(); } + queue_accessibility_update(); queue_redraw(); return true; } @@ -3197,6 +3753,7 @@ void RichTextLabel::_process_line_caches() { void RichTextLabel::_invalidate_current_line(ItemFrame *p_frame) { if ((int)p_frame->lines.size() - 1 <= p_frame->first_invalid_line) { p_frame->first_invalid_line = (int)p_frame->lines.size() - 1; + queue_accessibility_update(); } } @@ -3320,6 +3877,7 @@ void RichTextLabel::_add_item(Item *p_item, bool p_enter, bool p_ensure_newline) if (fit_content) { update_minimum_size(); } + queue_accessibility_update(); queue_redraw(); } @@ -3362,7 +3920,7 @@ Size2 RichTextLabel::_get_image_size(const Ref &p_image, int p_width, return ret; } -void RichTextLabel::add_image(const Ref &p_image, int p_width, int p_height, const Color &p_color, InlineAlignment p_alignment, const Rect2 &p_region, const Variant &p_key, bool p_pad, const String &p_tooltip, bool p_size_in_percent) { +void RichTextLabel::add_image(const Ref &p_image, int p_width, int p_height, const Color &p_color, InlineAlignment p_alignment, const Rect2 &p_region, const Variant &p_key, bool p_pad, const String &p_tooltip, bool p_size_in_percent, const String &p_alt_text) { _stop_thread(); MutexLock data_lock(data_mutex); @@ -3397,10 +3955,12 @@ void RichTextLabel::add_image(const Ref &p_image, int p_width, int p_ item->pad = p_pad; item->key = p_key; item->tooltip = p_tooltip; + item->alt_text = p_alt_text; item->image->connect_changed(callable_mp(this, &RichTextLabel::_texture_changed).bind(item->rid), CONNECT_REFERENCE_COUNTED); _add_item(item, false); + update_configuration_warnings(); } void RichTextLabel::update_image(const Variant &p_key, BitField p_mask, const Ref &p_image, int p_width, int p_height, const Color &p_color, InlineAlignment p_alignment, const Rect2 &p_region, bool p_pad, const String &p_tooltip, bool p_size_in_percent) { @@ -3663,7 +4223,13 @@ bool RichTextLabel::invalidate_paragraph(int p_paragraph) { main->first_invalid_line.store(MIN(main->first_invalid_line.load(), p_paragraph)); main->first_resized_line.store(MIN(main->first_resized_line.load(), p_paragraph)); main->first_invalid_font_line.store(MIN(main->first_invalid_font_line.load(), p_paragraph)); + + _invalidate_accessibility(); + if (is_inside_tree()) { + queue_accessibility_update(); + } queue_redraw(); + update_configuration_warnings(); return true; } @@ -3736,33 +4302,33 @@ void RichTextLabel::push_font(const Ref &p_font, int p_size) { void RichTextLabel::push_normal() { ERR_FAIL_COND(theme_cache.normal_font.is_null()); - _push_def_font(NORMAL_FONT); + _push_def_font(RTL_NORMAL_FONT); } void RichTextLabel::push_bold() { ERR_FAIL_COND(theme_cache.bold_font.is_null()); ItemFont *item_font = _find_font(current); - _push_def_font((item_font && item_font->def_font == ITALICS_FONT) ? BOLD_ITALICS_FONT : BOLD_FONT); + _push_def_font((item_font && item_font->def_font == RTL_ITALICS_FONT) ? RTL_BOLD_ITALICS_FONT : RTL_BOLD_FONT); } void RichTextLabel::push_bold_italics() { ERR_FAIL_COND(theme_cache.bold_italics_font.is_null()); - _push_def_font(BOLD_ITALICS_FONT); + _push_def_font(RTL_BOLD_ITALICS_FONT); } void RichTextLabel::push_italics() { ERR_FAIL_COND(theme_cache.italics_font.is_null()); ItemFont *item_font = _find_font(current); - _push_def_font((item_font && item_font->def_font == BOLD_FONT) ? BOLD_ITALICS_FONT : ITALICS_FONT); + _push_def_font((item_font && item_font->def_font == RTL_BOLD_FONT) ? RTL_BOLD_ITALICS_FONT : RTL_ITALICS_FONT); } void RichTextLabel::push_mono() { ERR_FAIL_COND(theme_cache.mono_font.is_null()); - _push_def_font(MONO_FONT); + _push_def_font(RTL_MONO_FONT); } void RichTextLabel::push_font_size(int p_font_size) { @@ -3924,7 +4490,7 @@ void RichTextLabel::push_hint(const String &p_string) { _add_item(item, true); } -void RichTextLabel::push_table(int p_columns, InlineAlignment p_alignment, int p_align_to_row) { +void RichTextLabel::push_table(int p_columns, InlineAlignment p_alignment, int p_align_to_row, const String &p_alt_text) { _stop_thread(); MutexLock data_lock(data_mutex); @@ -3933,6 +4499,7 @@ void RichTextLabel::push_table(int p_columns, InlineAlignment p_alignment, int p ItemTable *item = memnew(ItemTable); item->owner = get_instance_id(); item->rid = items.make_rid(item); + item->name = p_alt_text; item->columns.resize(p_columns); item->total_width = 0; item->inline_align = p_alignment; @@ -4091,6 +4658,17 @@ void RichTextLabel::set_table_column_expand(int p_column, bool p_expand, int p_r table->columns[p_column].expand_ratio = p_ratio; } +void RichTextLabel::set_table_column_name(int p_column, const String &p_name) { + _stop_thread(); + MutexLock data_lock(data_mutex); + + ERR_FAIL_COND(current->type != ITEM_TABLE); + + ItemTable *table = static_cast(current); + ERR_FAIL_INDEX(p_column, (int)table->columns.size()); + table->columns[p_column].name = p_name; +} + void RichTextLabel::set_cell_row_background_color(const Color &p_odd_row_bg, const Color &p_even_row_bg) { _stop_thread(); MutexLock data_lock(data_mutex); @@ -4153,6 +4731,7 @@ void RichTextLabel::push_cell() { item->lines.resize(1); item->lines[0].from = nullptr; item->first_invalid_line.store(0); // parent frame last line ??? + queue_accessibility_update(); } int RichTextLabel::get_current_table_column() const { @@ -4222,6 +4801,11 @@ void RichTextLabel::clear() { main->lines.clear(); main->lines.resize(1); main->first_invalid_line.store(0); + _invalidate_accessibility(); + + keyboard_focus_frame = nullptr; + keyboard_focus_line = 0; + keyboard_focus_item = nullptr; selection.click_frame = nullptr; selection.click_item = nullptr; @@ -4236,6 +4820,8 @@ void RichTextLabel::clear() { if (fit_content) { update_minimum_size(); } + queue_accessibility_update(); + update_configuration_warnings(); } void RichTextLabel::set_tab_size(int p_spaces) { @@ -4247,6 +4833,8 @@ void RichTextLabel::set_tab_size(int p_spaces) { tab_size = p_spaces; main->first_resized_line.store(0); + _invalidate_accessibility(); + queue_accessibility_update(); queue_redraw(); } @@ -4291,6 +4879,7 @@ bool RichTextLabel::is_hint_underlined() const { void RichTextLabel::set_offset(int p_pixel) { vscroll->set_value(p_pixel); + queue_accessibility_update(); } void RichTextLabel::set_scroll_active(bool p_active) { @@ -4540,9 +5129,9 @@ void RichTextLabel::append_text(const String &p_bbcode) { //use bold font in_bold = true; if (in_italics) { - _push_def_font(BOLD_ITALICS_FONT); + _push_def_font(RTL_BOLD_ITALICS_FONT); } else { - _push_def_font(BOLD_FONT); + _push_def_font(RTL_BOLD_FONT); } pos = brk_end + 1; tag_stack.push_front(tag); @@ -4550,15 +5139,15 @@ void RichTextLabel::append_text(const String &p_bbcode) { //use italics font in_italics = true; if (in_bold) { - _push_def_font(BOLD_ITALICS_FONT); + _push_def_font(RTL_BOLD_ITALICS_FONT); } else { - _push_def_font(ITALICS_FONT); + _push_def_font(RTL_ITALICS_FONT); } pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "code") { //use monospace font - _push_def_font(MONO_FONT); + _push_def_font(RTL_MONO_FONT); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag.begins_with("table=")) { @@ -4604,7 +5193,13 @@ void RichTextLabel::append_text(const String &p_bbcode) { row = subtag[3].to_int(); } - push_table(columns, (InlineAlignment)alignment, row); + OptionMap::Iterator alt_text_option = bbcode_options.find("name"); + String alt_text; + if (alt_text_option) { + alt_text = alt_text_option->value; + } + + push_table(columns, (InlineAlignment)alignment, row, alt_text); pos = brk_end + 1; tag_stack.push_front("table"); } else if (tag == "cell") { @@ -5052,6 +5647,7 @@ void RichTextLabel::append_text(const String &p_bbcode) { } String image = bbcode.substr(brk_end + 1, end - brk_end - 1); + String alt_text; Ref texture = ResourceLoader::load(image, "Texture2D"); if (texture.is_valid()) { @@ -5073,6 +5669,11 @@ void RichTextLabel::append_text(const String &p_bbcode) { color = Color::from_string(color_option->value, color); } + OptionMap::Iterator alt_text_option = bbcode_options.find("alt"); + if (alt_text_option) { + alt_text = alt_text_option->value; + } + int width = 0; int height = 0; bool pad = false; @@ -5146,7 +5747,7 @@ void RichTextLabel::append_text(const String &p_bbcode) { } } - add_image(texture, width, height, color, (InlineAlignment)alignment, region, Variant(), pad, tooltip, size_in_percent); + add_image(texture, width, height, color, (InlineAlignment)alignment, region, Variant(), pad, tooltip, size_in_percent, alt_text); } pos = end; @@ -5179,7 +5780,7 @@ void RichTextLabel::append_text(const String &p_bbcode) { if (subtag.size() > 0) { Ref font = theme_cache.normal_font; - DefaultFont def_font = NORMAL_FONT; + DefaultFont def_font = RTL_NORMAL_FONT; ItemFont *font_it = _find_font(current); if (font_it) { @@ -5206,7 +5807,7 @@ void RichTextLabel::append_text(const String &p_bbcode) { fc->set_base_font(font); fc->set_opentype_features(features); - if (def_font != CUSTOM_FONT) { + if (def_font != RTL_CUSTOM_FONT) { _push_def_font_var(def_font, fc); } else { push_font(fc); @@ -5228,7 +5829,7 @@ void RichTextLabel::append_text(const String &p_bbcode) { } else if (tag.begins_with("font ")) { Ref font = theme_cache.normal_font; - DefaultFont def_font = NORMAL_FONT; + DefaultFont def_font = RTL_NORMAL_FONT; int fnt_size = -1; ItemFont *font_it = _find_font(current); @@ -5251,7 +5852,7 @@ void RichTextLabel::append_text(const String &p_bbcode) { Ref font_data = ResourceLoader::load(fnt, "Font"); if (font_data.is_valid()) { font = font_data; - def_font = CUSTOM_FONT; + def_font = RTL_CUSTOM_FONT; } } OptionMap::Iterator size_option = bbcode_options.find("size"); @@ -5360,7 +5961,7 @@ void RichTextLabel::append_text(const String &p_bbcode) { fc->set_base_font(font); - if (def_font != CUSTOM_FONT) { + if (def_font != RTL_CUSTOM_FONT) { _push_def_font_var(def_font, fc, fnt_size); } else { push_font(fc, fnt_size); @@ -5560,6 +6161,7 @@ void RichTextLabel::scroll_to_selection() { float line_offset = get_selection_line_offset(); if (line_offset != -1.0) { vscroll->set_value(line_offset); + queue_accessibility_update(); } } @@ -5573,6 +6175,7 @@ void RichTextLabel::scroll_to_paragraph(int p_paragraph) { } else { vscroll->set_value(main->lines[p_paragraph].offset.y); } + queue_accessibility_update(); } int RichTextLabel::get_paragraph_count() const { @@ -5591,6 +6194,7 @@ int RichTextLabel::get_visible_paragraph_count() const { void RichTextLabel::scroll_to_line(int p_line) { if (p_line <= 0) { vscroll->set_value(0); + queue_accessibility_update(); return; } _validate_line_caches(); @@ -5605,11 +6209,13 @@ void RichTextLabel::scroll_to_line(int p_line) { line_offset += main->lines[i].text_buf->get_line_ascent(j) + main->lines[i].text_buf->get_line_descent(j) + theme_cache.line_separation; } vscroll->set_value(main->lines[i].offset.y + line_offset); + queue_accessibility_update(); return; } line_count += main->lines[i].text_buf->get_line_count(); } vscroll->set_value(vscroll->get_max()); + queue_accessibility_update(); } float RichTextLabel::get_line_offset(int p_line) { @@ -5692,10 +6298,11 @@ void RichTextLabel::set_selection_enabled(bool p_enabled) { if (selection.active) { deselect(); } - set_focus_mode(FOCUS_NONE); + set_focus_mode(FOCUS_ACCESSIBILITY); } else { set_focus_mode(FOCUS_ALL); } + queue_accessibility_update(); } void RichTextLabel::set_deselect_on_focus_loss_enabled(const bool p_enabled) { @@ -5810,6 +6417,7 @@ bool RichTextLabel::_search_line(ItemFrame *p_frame, int p_line, const String &p selection.to_item = _get_item_at_pos(l.from, it_to, sp + p_string.length()); selection.to_char = sp + p_string.length(); selection.active = true; + queue_accessibility_update(); return true; } @@ -5821,6 +6429,7 @@ bool RichTextLabel::search(const String &p_string, bool p_from_selection, bool p if (p_string.is_empty()) { selection.active = false; + queue_accessibility_update(); return false; } @@ -6003,6 +6612,7 @@ String RichTextLabel::get_selected_text() const { void RichTextLabel::deselect() { selection.active = false; + queue_accessibility_update(); queue_redraw(); } @@ -6059,6 +6669,7 @@ void RichTextLabel::select_all() { selection.to_char = to_frame->lines[to_line].char_count; selection.to_item = to_item; selection.active = true; + queue_accessibility_update(); queue_redraw(); } @@ -6206,6 +6817,7 @@ void RichTextLabel::set_text_direction(Control::TextDirection p_text_direction) _apply_translation(); } else { main->first_invalid_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); _validate_line_caches(); } queue_redraw(); @@ -6298,6 +6910,7 @@ void RichTextLabel::set_structured_text_bidi_override(TextServer::StructuredText _apply_translation(); } else { main->first_invalid_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); _validate_line_caches(); } queue_redraw(); @@ -6314,6 +6927,7 @@ void RichTextLabel::set_structured_text_bidi_override_options(Array p_args) { st_args = p_args; main->first_invalid_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); _validate_line_caches(); queue_redraw(); } @@ -6332,6 +6946,7 @@ void RichTextLabel::set_language(const String &p_language) { _apply_translation(); } else { main->first_invalid_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); _validate_line_caches(); } queue_redraw(); @@ -6348,6 +6963,7 @@ void RichTextLabel::set_autowrap_mode(TextServer::AutowrapMode p_mode) { autowrap_mode = p_mode; main->first_invalid_line = 0; // Invalidate all lines. + _invalidate_accessibility(); _validate_line_caches(); queue_redraw(); } @@ -6389,6 +7005,7 @@ void RichTextLabel::set_visible_ratio(float p_ratio) { if (visible_chars_behavior == TextServer::VC_CHARS_BEFORE_SHAPING) { main->first_invalid_line.store(0); // Invalidate all lines.. + _invalidate_accessibility(); _validate_line_caches(); } queue_redraw(); @@ -6470,7 +7087,7 @@ void RichTextLabel::_bind_methods() { ClassDB::bind_method(D_METHOD("get_parsed_text"), &RichTextLabel::get_parsed_text); ClassDB::bind_method(D_METHOD("add_text", "text"), &RichTextLabel::add_text); ClassDB::bind_method(D_METHOD("set_text", "text"), &RichTextLabel::set_text); - ClassDB::bind_method(D_METHOD("add_image", "image", "width", "height", "color", "inline_align", "region", "key", "pad", "tooltip", "size_in_percent"), &RichTextLabel::add_image, DEFVAL(0), DEFVAL(0), DEFVAL(Color(1.0, 1.0, 1.0)), DEFVAL(INLINE_ALIGNMENT_CENTER), DEFVAL(Rect2()), DEFVAL(Variant()), DEFVAL(false), DEFVAL(String()), DEFVAL(false)); + ClassDB::bind_method(D_METHOD("add_image", "image", "width", "height", "color", "inline_align", "region", "key", "pad", "tooltip", "size_in_percent", "alt_text"), &RichTextLabel::add_image, DEFVAL(0), DEFVAL(0), DEFVAL(Color(1.0, 1.0, 1.0)), DEFVAL(INLINE_ALIGNMENT_CENTER), DEFVAL(Rect2()), DEFVAL(Variant()), DEFVAL(false), DEFVAL(String()), DEFVAL(false), DEFVAL(String())); ClassDB::bind_method(D_METHOD("update_image", "key", "mask", "image", "width", "height", "color", "inline_align", "region", "pad", "tooltip", "size_in_percent"), &RichTextLabel::update_image, DEFVAL(0), DEFVAL(0), DEFVAL(Color(1.0, 1.0, 1.0)), DEFVAL(INLINE_ALIGNMENT_CENTER), DEFVAL(Rect2()), DEFVAL(false), DEFVAL(String()), DEFVAL(false)); ClassDB::bind_method(D_METHOD("newline"), &RichTextLabel::add_newline); ClassDB::bind_method(D_METHOD("remove_paragraph", "paragraph", "no_invalidate"), &RichTextLabel::remove_paragraph, DEFVAL(false)); @@ -6493,9 +7110,10 @@ void RichTextLabel::_bind_methods() { ClassDB::bind_method(D_METHOD("push_language", "language"), &RichTextLabel::push_language); ClassDB::bind_method(D_METHOD("push_underline"), &RichTextLabel::push_underline); ClassDB::bind_method(D_METHOD("push_strikethrough"), &RichTextLabel::push_strikethrough); - ClassDB::bind_method(D_METHOD("push_table", "columns", "inline_align", "align_to_row"), &RichTextLabel::push_table, DEFVAL(INLINE_ALIGNMENT_TOP), DEFVAL(-1)); + ClassDB::bind_method(D_METHOD("push_table", "columns", "inline_align", "align_to_row", "name"), &RichTextLabel::push_table, DEFVAL(INLINE_ALIGNMENT_TOP), DEFVAL(-1), DEFVAL(String())); ClassDB::bind_method(D_METHOD("push_dropcap", "string", "font", "size", "dropcap_margins", "color", "outline_size", "outline_color"), &RichTextLabel::push_dropcap, DEFVAL(Rect2()), DEFVAL(Color(1, 1, 1)), DEFVAL(0), DEFVAL(Color(0, 0, 0, 0))); ClassDB::bind_method(D_METHOD("set_table_column_expand", "column", "expand", "ratio", "shrink"), &RichTextLabel::set_table_column_expand, DEFVAL(1), DEFVAL(true)); + ClassDB::bind_method(D_METHOD("set_table_column_name", "column", "name"), &RichTextLabel::set_table_column_name); ClassDB::bind_method(D_METHOD("set_cell_row_background_color", "odd_row_bg", "even_row_bg"), &RichTextLabel::set_cell_row_background_color); ClassDB::bind_method(D_METHOD("set_cell_border_color", "color"), &RichTextLabel::set_cell_border_color); ClassDB::bind_method(D_METHOD("set_cell_size_override", "min_size", "max_size"), &RichTextLabel::set_cell_size_override); @@ -6759,6 +7377,7 @@ void RichTextLabel::set_visible_characters_behavior(TextServer::VisibleCharacter visible_chars_behavior = p_behavior; main->first_invalid_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); _validate_line_caches(); queue_redraw(); } @@ -6779,6 +7398,7 @@ void RichTextLabel::set_visible_characters(int p_visible) { } if (visible_chars_behavior == TextServer::VC_CHARS_BEFORE_SHAPING) { main->first_invalid_line.store(0); // Invalidate all lines. + _invalidate_accessibility(); _validate_line_caches(); } queue_redraw(); @@ -7046,6 +7666,7 @@ RichTextLabel::RichTextLabel(const String &p_text) { vscroll->set_step(1); vscroll->hide(); + set_focus_mode(FOCUS_ACCESSIBILITY); set_text(p_text); updating.store(false); validating.store(false); diff --git a/scene/gui/rich_text_label.h b/scene/gui/rich_text_label.h index 8d81a86a7d80..3ff7d2b8f5d0 100644 --- a/scene/gui/rich_text_label.h +++ b/scene/gui/rich_text_label.h @@ -106,12 +106,12 @@ class RichTextLabel : public Control { }; enum DefaultFont { - NORMAL_FONT, - BOLD_FONT, - ITALICS_FONT, - BOLD_ITALICS_FONT, - MONO_FONT, - CUSTOM_FONT, + RTL_NORMAL_FONT, + RTL_BOLD_FONT, + RTL_ITALICS_FONT, + RTL_BOLD_ITALICS_FONT, + RTL_MONO_FONT, + RTL_CUSTOM_FONT, }; enum ImageUpdateMask { @@ -137,8 +137,11 @@ class RichTextLabel : public Control { void _push_meta_bind_compat_99481(const Variant &p_meta, MetaUnderline p_underline_mode); void _push_meta_bind_compat_89024(const Variant &p_meta); void _add_image_bind_compat_80410(const Ref &p_image, const int p_width, const int p_height, const Color &p_color, InlineAlignment p_alignment, const Rect2 &p_region); + void _add_image_bind_compat_76829(const Ref &p_image, const int p_width, const int p_height, const Color &p_color, InlineAlignment p_alignment, const Rect2 &p_region, const Variant &p_key, bool p_pad, const String &p_tooltip, bool p_size_in_percent); + void _push_table_bind_compat_76829(int p_columns, InlineAlignment p_alignment, int p_align_to_row); bool _remove_paragraph_bind_compat_91098(int p_paragraph); void _set_table_column_expand_bind_compat_101482(int p_column, bool p_expand, int p_ratio); + static void _bind_compatibility_methods(); #endif @@ -151,6 +154,11 @@ class RichTextLabel : public Control { Ref text_prefix; float prefix_width = 0; Ref text_buf; + + RID accessibility_line_element; + RID accessibility_text_element; + + Item *dc_item = nullptr; Color dc_color; int dc_ol_size = 0; Color dc_ol_color; @@ -160,7 +168,16 @@ class RichTextLabel : public Control { int char_offset = 0; int char_count = 0; - Line() { text_buf.instantiate(); } + Line() { + text_buf.instantiate(); + } + ~Line() { + if (accessibility_line_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(accessibility_line_element); + accessibility_line_element = RID(); + accessibility_text_element = RID(); + } + } _FORCE_INLINE_ float get_height(float line_separation) const { return offset.y + text_buf->get_size().y + text_buf->get_line_count() * line_separation; @@ -178,6 +195,8 @@ class RichTextLabel : public Control { int line = 0; RID rid; + RID accessibility_item_element; + void _clear_children() { RichTextLabel *owner_rtl = ObjectDB::get_instance(owner); while (subitems.size()) { @@ -237,6 +256,7 @@ class RichTextLabel : public Control { struct ItemImage : public Item { Ref image; + String alt_text; InlineAlignment inline_align = INLINE_ALIGNMENT_CENTER; bool pad = false; bool size_in_percent = false; @@ -258,7 +278,7 @@ class RichTextLabel : public Control { }; struct ItemFont : public Item { - DefaultFont def_font = CUSTOM_FONT; + DefaultFont def_font = RTL_CUSTOM_FONT; Ref font; bool variation = false; bool def_size = false; @@ -341,6 +361,7 @@ class RichTextLabel : public Control { struct ItemTable : public Item { struct Column { + String name; bool expand = false; bool shrink = true; int expand_ratio = 0; @@ -354,6 +375,7 @@ class RichTextLabel : public Control { LocalVector rows; LocalVector rows_no_padding; LocalVector rows_baseline; + String name; int align_to_row = -1; int total_width = 0; @@ -503,6 +525,9 @@ class RichTextLabel : public Control { Array custom_effects; + HashMap ac_element_bounds_cache; + + void _invalidate_accessibility(); void _invalidate_current_line(ItemFrame *p_frame); void _thread_function(void *p_userdata); @@ -552,6 +577,11 @@ class RichTextLabel : public Control { bool deselect_on_focus_loss_enabled = true; bool drag_and_drop_selection_enabled = true; + ItemFrame *keyboard_focus_frame = nullptr; + int keyboard_focus_line = 0; + Item *keyboard_focus_item = nullptr; + bool keyboard_focus_on_text = true; + bool context_menu_enabled = false; bool shortcut_keys_enabled = true; @@ -580,6 +610,7 @@ class RichTextLabel : public Control { void _update_line_font(ItemFrame *p_frame, int p_line, const Ref &p_base_font, int p_base_font_size); int _draw_line(ItemFrame *p_frame, int p_line, const Vector2 &p_ofs, int p_width, float p_vsep, const Color &p_base_color, int p_outline_size, const Color &p_outline_color, const Color &p_font_shadow_color, int p_shadow_outline_size, const Point2 &p_shadow_ofs, int &r_processed_glyphs); float _find_click_in_line(ItemFrame *p_frame, int p_line, const Vector2 &p_ofs, int p_width, float p_vsep, const Point2i &p_click, ItemFrame **r_click_frame = nullptr, int *r_click_line = nullptr, Item **r_click_item = nullptr, int *r_click_char = nullptr, bool p_table = false, bool p_meta = false); + void _accessibility_update_line(RID p_id, ItemFrame *p_frame, int p_line, const Vector2 &p_ofs, int p_width, float p_vsep); String _roman(int p_num, bool p_capitalize) const; String _letters(int p_num, bool p_capitalize) const; @@ -646,6 +677,15 @@ class RichTextLabel : public Control { bool internal_stack_editing = false; bool stack_externally_modified = false; + void _accessibility_action_menu(const Variant &p_data); + void _accessibility_scroll_down(const Variant &p_data); + void _accessibility_scroll_up(const Variant &p_data); + void _accessibility_scroll_set(const Variant &p_data); + void _accessibility_focus_item(const Variant &p_data, uint64_t p_item, bool p_line, bool p_foucs); + void _accessibility_scroll_to_item(const Variant &p_data, uint64_t p_item); + + RID accessibility_scroll_element; + bool fit_content = false; struct ThemeCache { @@ -692,9 +732,12 @@ class RichTextLabel : public Control { } theme_cache; public: + virtual RID get_focused_accessibility_element() const override; + PackedStringArray get_accessibility_configuration_warnings() const override; + String get_parsed_text() const; void add_text(const String &p_text); - void add_image(const Ref &p_image, int p_width = 0, int p_height = 0, const Color &p_color = Color(1.0, 1.0, 1.0), InlineAlignment p_alignment = INLINE_ALIGNMENT_CENTER, const Rect2 &p_region = Rect2(), const Variant &p_key = Variant(), bool p_pad = false, const String &p_tooltip = String(), bool p_size_in_percent = false); + void add_image(const Ref &p_image, int p_width = 0, int p_height = 0, const Color &p_color = Color(1.0, 1.0, 1.0), InlineAlignment p_alignment = INLINE_ALIGNMENT_CENTER, const Rect2 &p_region = Rect2(), const Variant &p_key = Variant(), bool p_pad = false, const String &p_tooltip = String(), bool p_size_in_percent = false, const String &p_alt_text = String()); void update_image(const Variant &p_key, BitField p_mask, const Ref &p_image, int p_width = 0, int p_height = 0, const Color &p_color = Color(1.0, 1.0, 1.0), InlineAlignment p_alignment = INLINE_ALIGNMENT_CENTER, const Rect2 &p_region = Rect2(), bool p_pad = false, const String &p_tooltip = String(), bool p_size_in_percent = false); void add_newline(); bool remove_paragraph(int p_paragraph, bool p_no_invalidate = false); @@ -720,7 +763,7 @@ class RichTextLabel : public Control { void push_list(int p_level, ListType p_list, bool p_capitalize, const String &p_bullet = String::utf8("•")); void push_meta(const Variant &p_meta, MetaUnderline p_underline_mode = META_UNDERLINE_ALWAYS, const String &p_tooltip = String()); void push_hint(const String &p_string); - void push_table(int p_columns, InlineAlignment p_alignment = INLINE_ALIGNMENT_TOP, int p_align_to_row = -1); + void push_table(int p_columns, InlineAlignment p_alignment = INLINE_ALIGNMENT_TOP, int p_align_to_row = -1, const String &p_name = String()); void push_fade(int p_start_index, int p_length); void push_shake(int p_strength, float p_rate, bool p_connected); void push_wave(float p_frequency, float p_amplitude, bool p_connected); @@ -732,6 +775,7 @@ class RichTextLabel : public Control { void push_customfx(Ref p_custom_effect, Dictionary p_environment); void push_context(); void set_table_column_expand(int p_column, bool p_expand, int p_ratio = 1, bool p_shrink = true); + void set_table_column_name(int p_column, const String &p_name); void set_cell_row_background_color(const Color &p_odd_row_bg, const Color &p_even_row_bg); void set_cell_border_color(const Color &p_color); void set_cell_size_override(const Size2 &p_min_size, const Size2 &p_max_size); diff --git a/scene/gui/scroll_bar.cpp b/scene/gui/scroll_bar.cpp index b81927f1e00f..39c86b766b4a 100644 --- a/scene/gui/scroll_bar.cpp +++ b/scene/gui/scroll_bar.cpp @@ -224,6 +224,13 @@ void ScrollBar::gui_input(const Ref &p_event) { void ScrollBar::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_SCROLL_BAR); + } break; + case NOTIFICATION_DRAW: { RID ci = get_canvas_item(); @@ -654,6 +661,8 @@ ScrollBar::ScrollBar(Orientation p_orientation) { if (focus_by_default) { set_focus_mode(FOCUS_ALL); + } else { + set_focus_mode(FOCUS_ACCESSIBILITY); } set_step(0); } diff --git a/scene/gui/scroll_container.cpp b/scene/gui/scroll_container.cpp index ca7b730e1249..00a2e8e01fd8 100644 --- a/scene/gui/scroll_container.cpp +++ b/scene/gui/scroll_container.cpp @@ -353,8 +353,43 @@ void ScrollContainer::_reposition_children() { queue_redraw(); } +void ScrollContainer::_accessibility_action_scroll_set(const Variant &p_data) { + const Point2 &pos = p_data; + h_scroll->set_value(pos.x); + v_scroll->set_value(pos.y); +} + +void ScrollContainer::_accessibility_action_scroll_up(const Variant &p_data) { + v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() / 8); +} + +void ScrollContainer::_accessibility_action_scroll_down(const Variant &p_data) { + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() / 8); +} + +void ScrollContainer::_accessibility_action_scroll_left(const Variant &p_data) { + h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() / 8); +} + +void ScrollContainer::_accessibility_action_scroll_right(const Variant &p_data) { + h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() / 8); +} + void ScrollContainer::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_SCROLL_VIEW); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_DOWN, callable_mp(this, &ScrollContainer::_accessibility_action_scroll_down)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_LEFT, callable_mp(this, &ScrollContainer::_accessibility_action_scroll_left)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_RIGHT, callable_mp(this, &ScrollContainer::_accessibility_action_scroll_right)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_UP, callable_mp(this, &ScrollContainer::_accessibility_action_scroll_up)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_SCROLL_OFFSET, callable_mp(this, &ScrollContainer::_accessibility_action_scroll_set)); + } break; + case NOTIFICATION_ENTER_TREE: case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_LAYOUT_DIRECTION_CHANGED: diff --git a/scene/gui/scroll_container.h b/scene/gui/scroll_container.h index 7309c9ea6133..7f2352704114 100644 --- a/scene/gui/scroll_container.h +++ b/scene/gui/scroll_container.h @@ -99,6 +99,12 @@ class ScrollContainer : public Container { void _update_scrollbar_position(); void _scroll_moved(float); + void _accessibility_action_scroll_set(const Variant &p_data); + void _accessibility_action_scroll_up(const Variant &p_data); + void _accessibility_action_scroll_down(const Variant &p_data); + void _accessibility_action_scroll_left(const Variant &p_data); + void _accessibility_action_scroll_right(const Variant &p_data); + public: virtual void gui_input(const Ref &p_gui_input) override; diff --git a/scene/gui/slider.cpp b/scene/gui/slider.cpp index a393ed926af3..4d848cd63595 100644 --- a/scene/gui/slider.cpp +++ b/scene/gui/slider.cpp @@ -237,7 +237,13 @@ void Slider::_notification(int p_what) { } } } + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_SLIDER); } break; case NOTIFICATION_THEME_CHANGED: { diff --git a/scene/gui/spin_box.cpp b/scene/gui/spin_box.cpp index 5e8a9f88d62f..29aac75ba25b 100644 --- a/scene/gui/spin_box.cpp +++ b/scene/gui/spin_box.cpp @@ -34,6 +34,50 @@ #include "core/math/expression.h" #include "scene/theme/theme_db.h" +void SpinBoxLineEdit::_accessibility_action_inc(const Variant &p_data) { + SpinBox *parent_sb = Object::cast_to(get_parent()); + if (parent_sb) { + double step = ((parent_sb->get_step() > 0) ? parent_sb->get_step() : 1); + parent_sb->set_value(parent_sb->get_value() + step); + } +} + +void SpinBoxLineEdit::_accessibility_action_dec(const Variant &p_data) { + SpinBox *parent_sb = Object::cast_to(get_parent()); + if (parent_sb) { + double step = ((parent_sb->get_step() > 0) ? parent_sb->get_step() : 1); + parent_sb->set_value(parent_sb->get_value() - step); + } +} + +void SpinBoxLineEdit::_notification(int p_what) { + ERR_MAIN_THREAD_GUARD; + switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + SpinBox *parent_sb = Object::cast_to(get_parent()); + if (parent_sb) { + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_SPIN_BUTTON); + DisplayServer::get_singleton()->accessibility_update_set_name(ae, parent_sb->get_accessibility_name()); + DisplayServer::get_singleton()->accessibility_update_set_description(ae, parent_sb->get_accessibility_description()); + DisplayServer::get_singleton()->accessibility_update_set_live(ae, parent_sb->get_accessibility_live()); + DisplayServer::get_singleton()->accessibility_update_set_num_value(ae, parent_sb->get_value()); + DisplayServer::get_singleton()->accessibility_update_set_num_range(ae, parent_sb->get_min(), parent_sb->get_max()); + if (parent_sb->get_step() > 0) { + DisplayServer::get_singleton()->accessibility_update_set_num_step(ae, parent_sb->get_step()); + } else { + DisplayServer::get_singleton()->accessibility_update_set_num_step(ae, 1); + } + //DisplayServer::get_singleton()->accessibility_update_set_num_jump(ae, ???); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_DECREMENT, callable_mp(this, &SpinBoxLineEdit::_accessibility_action_dec)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_INCREMENT, callable_mp(this, &SpinBoxLineEdit::_accessibility_action_inc)); + } + } break; + } +} + Size2 SpinBox::get_minimum_size() const { Size2 ms = line_edit->get_combined_minimum_size(); ms.width += sizing_cache.buttons_block_width; @@ -650,7 +694,7 @@ void SpinBox::_bind_methods() { } SpinBox::SpinBox() { - line_edit = memnew(LineEdit); + line_edit = memnew(SpinBoxLineEdit); line_edit->set_emoji_menu_enabled(false); add_child(line_edit, false, INTERNAL_MODE_FRONT); diff --git a/scene/gui/spin_box.h b/scene/gui/spin_box.h index e7dbf655c28b..977b1f50410c 100644 --- a/scene/gui/spin_box.h +++ b/scene/gui/spin_box.h @@ -34,10 +34,25 @@ #include "scene/gui/range.h" #include "scene/main/timer.h" +class SpinBoxLineEdit : public LineEdit { + GDCLASS(SpinBoxLineEdit, LineEdit); + +protected: + void _notification(int p_what); + + static void _bind_methods() {} + + void _accessibility_action_inc(const Variant &p_data); + void _accessibility_action_dec(const Variant &p_data); + +public: + SpinBoxLineEdit() {} +}; + class SpinBox : public Range { GDCLASS(SpinBox, Range); - LineEdit *line_edit = nullptr; + SpinBoxLineEdit *line_edit = nullptr; bool update_on_text_changed = false; bool accepted = true; diff --git a/scene/gui/split_container.cpp b/scene/gui/split_container.cpp index 78d7fea9bbfb..1ab37597226f 100644 --- a/scene/gui/split_container.cpp +++ b/scene/gui/split_container.cpp @@ -91,8 +91,59 @@ Control::CursorShape SplitContainerDragger::get_cursor_shape(const Point2 &p_pos return Control::get_cursor_shape(p_pos); } +void SplitContainerDragger::_accessibility_action_inc(const Variant &p_data) { + SplitContainer *sc = Object::cast_to(get_parent()); + + if (sc->collapsed || !sc->_get_sortable_child(0) || !sc->_get_sortable_child(1) || !sc->dragging_enabled) { + return; + } + sc->split_offset -= 10; + sc->_compute_split_offset(true); + sc->queue_sort(); +} + +void SplitContainerDragger::_accessibility_action_dec(const Variant &p_data) { + SplitContainer *sc = Object::cast_to(get_parent()); + + if (sc->collapsed || !sc->_get_sortable_child(0) || !sc->_get_sortable_child(1) || !sc->dragging_enabled) { + return; + } + sc->split_offset += 10; + sc->_compute_split_offset(true); + sc->queue_sort(); +} + +void SplitContainerDragger::_accessibility_action_set_value(const Variant &p_data) { + SplitContainer *sc = Object::cast_to(get_parent()); + + if (sc->collapsed || !sc->_get_sortable_child(0) || !sc->_get_sortable_child(1) || !sc->dragging_enabled) { + return; + } + sc->split_offset = p_data; + sc->_compute_split_offset(true); + sc->queue_sort(); +} + void SplitContainerDragger::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_SPLITTER); + + SplitContainer *sc = Object::cast_to(get_parent()); + if (sc->collapsed || !sc->_get_sortable_child(0) || !sc->_get_sortable_child(1) || !sc->dragging_enabled) { + return; + } + sc->_compute_split_offset(true); + DisplayServer::get_singleton()->accessibility_update_set_num_value(ae, sc->split_offset); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_DECREMENT, callable_mp(this, &SplitContainerDragger::_accessibility_action_dec)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_INCREMENT, callable_mp(this, &SplitContainerDragger::_accessibility_action_inc)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_VALUE, callable_mp(this, &SplitContainerDragger::_accessibility_action_set_value)); + } break; + case NOTIFICATION_MOUSE_ENTER: { mouse_inside = true; SplitContainer *sc = Object::cast_to(get_parent()); @@ -124,6 +175,10 @@ void SplitContainerDragger::_notification(int p_what) { } } +SplitContainerDragger::SplitContainerDragger() { + set_focus_mode(FOCUS_ACCESSIBILITY); +} + Control *SplitContainer::_get_sortable_child(int p_idx, SortableVisibilityMode p_visibility_mode) const { int idx = 0; for (int i = 0; i < get_child_count(false); i++) { diff --git a/scene/gui/split_container.h b/scene/gui/split_container.h index 51cc331c48bc..139612908108 100644 --- a/scene/gui/split_container.h +++ b/scene/gui/split_container.h @@ -41,6 +41,10 @@ class SplitContainerDragger : public Control { void _notification(int p_what); virtual void gui_input(const Ref &p_event) override; + void _accessibility_action_inc(const Variant &p_data); + void _accessibility_action_dec(const Variant &p_data); + void _accessibility_action_set_value(const Variant &p_data); + private: bool dragging = false; int drag_from = 0; @@ -49,6 +53,8 @@ class SplitContainerDragger : public Control { public: virtual CursorShape get_cursor_shape(const Point2 &p_pos = Point2i()) const override; + + SplitContainerDragger(); }; class SplitContainer : public Container { diff --git a/scene/gui/tab_bar.cpp b/scene/gui/tab_bar.cpp index a8d9adc453d3..36621de4531a 100644 --- a/scene/gui/tab_bar.cpp +++ b/scene/gui/tab_bar.cpp @@ -351,6 +351,35 @@ void TabBar::_shape(int p_tab) { tabs.write[p_tab].text_buf->add_string(atr(tabs[p_tab].text), theme_cache.font, theme_cache.font_size, tabs[p_tab].language); } +RID TabBar::get_tab_accessibility_element(int p_tab) const { + RID ae = get_accessibility_element(); + ERR_FAIL_COND_V(ae.is_null(), RID()); + + const Tab &item = tabs[p_tab]; + if (item.accessibility_item_element.is_null()) { + item.accessibility_item_element = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_TAB); + item.accessibility_item_dirty = true; + } + return item.accessibility_item_element; +} + +RID TabBar::get_focused_accessibility_element() const { + if (current == -1) { + return get_accessibility_element(); + } else { + const Tab &item = tabs[current]; + return item.accessibility_item_element; + } +} + +void TabBar::_accessibility_action_scroll_into_view(const Variant &p_data, int p_index) { + ensure_tab_visible(p_index); +} + +void TabBar::_accessibility_action_focus(const Variant &p_data, int p_index) { + set_current_tab(p_index); +} + void TabBar::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { @@ -383,6 +412,46 @@ void TabBar::_notification(int p_what) { } } break; + case NOTIFICATION_EXIT_TREE: + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + for (int i = 0; i < tabs.size(); i++) { + tabs.write[i].accessibility_item_element = RID(); + } + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_TAB_BAR); + DisplayServer::get_singleton()->accessibility_update_set_list_item_count(ae, tabs.size()); + + for (int i = 0; i < tabs.size(); i++) { + const Tab &item = tabs[i]; + + if (item.accessibility_item_element.is_null()) { + item.accessibility_item_element = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_TAB); + item.accessibility_item_dirty = true; + } + + if (item.accessibility_item_dirty) { + DisplayServer::get_singleton()->accessibility_update_add_action(item.accessibility_item_element, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &TabBar::_accessibility_action_scroll_into_view).bind(i)); + DisplayServer::get_singleton()->accessibility_update_add_action(item.accessibility_item_element, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &TabBar::_accessibility_action_focus).bind(i)); + + DisplayServer::get_singleton()->accessibility_update_set_list_item_index(item.accessibility_item_element, i); + DisplayServer::get_singleton()->accessibility_update_set_name(item.accessibility_item_element, atr(item.text)); + DisplayServer::get_singleton()->accessibility_update_set_list_item_selected(item.accessibility_item_element, i == current); + DisplayServer::get_singleton()->accessibility_update_set_flag(item.accessibility_item_element, DisplayServer::AccessibilityFlags::FLAG_DISABLED, item.disabled); + DisplayServer::get_singleton()->accessibility_update_set_flag(item.accessibility_item_element, DisplayServer::AccessibilityFlags::FLAG_HIDDEN, item.hidden); + DisplayServer::get_singleton()->accessibility_update_set_tooltip(item.accessibility_item_element, item.tooltip); + + DisplayServer::get_singleton()->accessibility_update_set_bounds(item.accessibility_item_element, Rect2(Point2(item.ofs_cache, 0), Size2(item.size_cache, get_size().height))); + + item.accessibility_item_dirty = false; + } + } + } break; + case NOTIFICATION_LAYOUT_DIRECTION_CHANGED: { queue_redraw(); } break; @@ -393,6 +462,7 @@ void TabBar::_notification(int p_what) { _shape(i); } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); @@ -672,6 +742,15 @@ void TabBar::set_tab_count(int p_count) { } ERR_FAIL_COND(p_count < 0); + + if (tabs.size() > p_count) { + for (int i = p_count; i < tabs.size(); i++) { + if (tabs[i].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(tabs.write[i].accessibility_item_element); + tabs.write[i].accessibility_item_element = RID(); + } + } + } tabs.resize(p_count); if (p_count == 0) { @@ -702,6 +781,7 @@ void TabBar::set_tab_count(int p_count) { } } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); notify_property_list_changed(); @@ -737,6 +817,7 @@ void TabBar::set_current_tab(int p_current) { if (scroll_to_selected) { ensure_tab_visible(current); } + queue_accessibility_update(); queue_redraw(); emit_signal(SNAME("tab_changed"), p_current); @@ -785,6 +866,7 @@ void TabBar::set_tab_offset(int p_offset) { ERR_FAIL_INDEX(p_offset, tabs.size()); offset = p_offset; _update_cache(); + queue_accessibility_update(); queue_redraw(); } @@ -811,6 +893,7 @@ void TabBar::set_tab_title(int p_tab, const String &p_title) { if (scroll_to_selected) { ensure_tab_visible(current); } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -823,6 +906,7 @@ String TabBar::get_tab_title(int p_tab) const { void TabBar::set_tab_tooltip(int p_tab, const String &p_tooltip) { ERR_FAIL_INDEX(p_tab, tabs.size()); tabs.write[p_tab].tooltip = p_tooltip; + queue_accessibility_update(); } String TabBar::get_tab_tooltip(int p_tab) const { @@ -836,7 +920,9 @@ void TabBar::set_tab_text_direction(int p_tab, Control::TextDirection p_text_dir if (tabs[p_tab].text_direction != p_text_direction) { tabs.write[p_tab].text_direction = p_text_direction; + _shape(p_tab); + queue_accessibility_update(); queue_redraw(); } } @@ -851,12 +937,14 @@ void TabBar::set_tab_language(int p_tab, const String &p_language) { if (tabs[p_tab].language != p_language) { tabs.write[p_tab].language = p_language; + _shape(p_tab); _update_cache(); _ensure_no_over_offset(); if (scroll_to_selected) { ensure_tab_visible(current); } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -927,6 +1015,7 @@ void TabBar::set_tab_disabled(int p_tab, bool p_disabled) { if (scroll_to_selected) { ensure_tab_visible(current); } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -950,6 +1039,7 @@ void TabBar::set_tab_hidden(int p_tab, bool p_hidden) { if (scroll_to_selected) { ensure_tab_visible(current); } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -1117,6 +1207,8 @@ void TabBar::_update_cache(bool p_update_hover) { max_drawn_tab--; } } + + tabs.write[i].accessibility_item_dirty = true; } missing_right = max_drawn_tab < tabs.size() - 1; @@ -1171,6 +1263,7 @@ void TabBar::add_tab(const String &p_str, const Ref &p_icon) { if (scroll_to_selected) { ensure_tab_visible(current); } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); @@ -1189,12 +1282,19 @@ void TabBar::clear_tabs() { return; } + for (int i = 0; i < tabs.size(); i++) { + if (tabs[i].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(tabs.write[i].accessibility_item_element); + tabs.write[i].accessibility_item_element = RID(); + } + } tabs.clear(); offset = 0; max_drawn_tab = 0; current = -1; previous = -1; + queue_accessibility_update(); queue_redraw(); update_minimum_size(); notify_property_list_changed(); @@ -1202,6 +1302,11 @@ void TabBar::clear_tabs() { void TabBar::remove_tab(int p_idx) { ERR_FAIL_INDEX(p_idx, tabs.size()); + + if (tabs[p_idx].accessibility_item_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(tabs.write[p_idx].accessibility_item_element); + tabs.write[p_idx].accessibility_item_element = RID(); + } tabs.remove_at(p_idx); bool is_tab_changing = current == p_idx; @@ -1251,6 +1356,7 @@ void TabBar::remove_tab(int p_idx) { } } + queue_accessibility_update(); queue_redraw(); update_minimum_size(); notify_property_list_changed(); @@ -1284,7 +1390,7 @@ void TabBar::drop_data(const Point2 &p_point, const Variant &p_data) { } Variant TabBar::_handle_get_drag_data(const String &p_type, const Point2 &p_point) { - int tab_over = get_tab_idx_at_point(p_point); + int tab_over = (p_point == Vector2(INFINITY, INFINITY)) ? current : get_tab_idx_at_point(p_point); if (tab_over < 0) { return Variant(); } @@ -1349,7 +1455,7 @@ void TabBar::_handle_drop_data(const String &p_type, const Point2 &p_point, cons if (String(d["type"]) == p_type) { int tab_from_id = d["tab_index"]; - int hover_now = get_closest_tab_idx_to_point(p_point); + int hover_now = (p_point == Vector2(INFINITY, INFINITY)) ? current : get_closest_tab_idx_to_point(p_point); NodePath from_path = d["from_path"]; NodePath to_path = get_path(); @@ -1407,6 +1513,8 @@ void TabBar::_handle_drop_data(const String &p_type, const Point2 &p_point, cons void TabBar::_move_tab_from(TabBar *p_from_tabbar, int p_from_index, int p_to_index) { Tab moving_tab = p_from_tabbar->tabs[p_from_index]; + moving_tab.accessibility_item_element = RID(); + moving_tab.accessibility_item_dirty = true; p_from_tabbar->remove_tab(p_from_index); tabs.insert(p_to_index, moving_tab); @@ -1426,6 +1534,7 @@ void TabBar::_move_tab_from(TabBar *p_from_tabbar, int p_from_index, int p_to_in queue_redraw(); } + queue_accessibility_update(); update_minimum_size(); } @@ -1515,6 +1624,8 @@ void TabBar::move_tab(int p_from, int p_to) { ERR_FAIL_INDEX(p_to, tabs.size()); Tab tab_from = tabs[p_from]; + tab_from.accessibility_item_dirty = true; + tabs.remove_at(p_from); tabs.insert(p_to, tab_from); @@ -1539,6 +1650,7 @@ void TabBar::move_tab(int p_from, int p_to) { if (scroll_to_selected) { ensure_tab_visible(current); } + queue_accessibility_update(); queue_redraw(); notify_property_list_changed(); } @@ -1957,6 +2069,7 @@ void TabBar::_bind_methods() { } TabBar::TabBar() { + set_focus_mode(FOCUS_ACCESSIBILITY); set_size(Size2(get_size().width, get_minimum_size().height)); set_focus_mode(FOCUS_ALL); connect(SceneStringName(mouse_exited), callable_mp(this, &TabBar::_on_mouse_exited)); diff --git a/scene/gui/tab_bar.h b/scene/gui/tab_bar.h index ead45269c24e..a97fdfd53192 100644 --- a/scene/gui/tab_bar.h +++ b/scene/gui/tab_bar.h @@ -54,6 +54,9 @@ class TabBar : public Control { private: struct Tab { + mutable RID accessibility_item_element; + mutable bool accessibility_item_dirty = true; + String text; String tooltip; @@ -170,6 +173,9 @@ class TabBar : public Control { void _shape(int p_tab); void _draw_tab(Ref &p_tab_style, Color &p_font_color, int p_index, float p_x, bool p_focus); + void _accessibility_action_scroll_into_view(const Variant &p_data, int p_index); + void _accessibility_action_focus(const Variant &p_data, int p_index); + protected: virtual void gui_input(const Ref &p_event) override; virtual String get_tooltip(const Point2 &p_pos) const override; @@ -188,6 +194,9 @@ class TabBar : public Control { void _move_tab_from(TabBar *p_from_tabbar, int p_from_index, int p_to_index); public: + RID get_tab_accessibility_element(int p_tab) const; + virtual RID get_focused_accessibility_element() const override; + Variant _handle_get_drag_data(const String &p_type, const Point2 &p_point); bool _handle_can_drop_data(const String &p_type, const Point2 &p_point, const Variant &p_data) const; void _handle_drop_data(const String &p_type, const Point2 &p_point, const Variant &p_data, const Callable &p_move_tab_callback, const Callable &p_move_tab_from_other_callback); diff --git a/scene/gui/tab_container.cpp b/scene/gui/tab_container.cpp index 4a77347b1c03..3c8921f7e8ab 100644 --- a/scene/gui/tab_container.cpp +++ b/scene/gui/tab_container.cpp @@ -142,6 +142,45 @@ void TabContainer::gui_input(const Ref &p_event) { void TabContainer::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + tab_panels.clear(); + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + int tab_index = 0; + int tab_cur = tab_bar->get_current_tab(); + for (int i = 0; i < get_child_count(); i++) { + Node *child_node = get_child(i); + Window *child_wnd = Object::cast_to(child_node); + if (child_wnd && !child_wnd->is_embedded()) { + continue; + } + if (child_node->is_part_of_edited_scene()) { + continue; + } + Control *control = as_sortable_control(child_node, SortableVisibilityMode::IGNORE); + if (!control || control == tab_bar || children_removing.has(control)) { + DisplayServer::get_singleton()->accessibility_update_add_child(ae, child_node->get_accessibility_element()); + } else { + if (!tab_panels.has(child_node)) { + tab_panels[child_node] = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_TAB_PANEL); + } + RID panel = tab_panels[child_node]; + RID tab = tab_bar->get_tab_accessibility_element(tab_index); + + DisplayServer::get_singleton()->accessibility_update_add_related_controls(tab, panel); + DisplayServer::get_singleton()->accessibility_update_add_related_labeled_by(panel, tab); + DisplayServer::get_singleton()->accessibility_update_set_flag(panel, DisplayServer::AccessibilityFlags::FLAG_HIDDEN, tab_index != tab_cur); + DisplayServer::get_singleton()->accessibility_update_add_child(panel, child_node->get_accessibility_element()); + + tab_index++; + } + } + } break; + case NOTIFICATION_ENTER_TREE: { // If some nodes happen to be renamed outside the tree, the tab names need to be updated manually. if (get_tab_count() > 0) { @@ -556,6 +595,7 @@ void TabContainer::add_child_notify(Node *p_child) { if (get_tab_count() == 1) { queue_redraw(); } + queue_accessibility_update(); p_child->connect("renamed", callable_mp(this, &TabContainer::_refresh_tab_names)); p_child->connect(SceneStringName(visibility_changed), callable_mp(this, &TabContainer::_on_tab_visibility_changed).bind(c)); @@ -579,11 +619,17 @@ void TabContainer::move_child_notify(Node *p_child) { } _refresh_tab_indices(); + queue_accessibility_update(); } void TabContainer::remove_child_notify(Node *p_child) { Container::remove_child_notify(p_child); + if (tab_panels.has(p_child)) { + DisplayServer::get_singleton()->accessibility_free_element(tab_panels[p_child]); + tab_panels.erase(p_child); + } + if (p_child == tab_bar) { return; } @@ -607,6 +653,7 @@ void TabContainer::remove_child_notify(Node *p_child) { if (get_tab_count() == 0) { queue_redraw(); } + queue_accessibility_update(); p_child->remove_meta("_tab_index"); p_child->remove_meta("_tab_name"); diff --git a/scene/gui/tab_container.h b/scene/gui/tab_container.h index 3a0e5c40fb76..7a392cb63845 100644 --- a/scene/gui/tab_container.h +++ b/scene/gui/tab_container.h @@ -97,6 +97,8 @@ class TabContainer : public Container { int tab_font_size; } theme_cache; + HashMap tab_panels; + int _get_tab_height() const; Vector _get_tab_controls() const; void _on_theme_changed(); @@ -129,6 +131,8 @@ class TabContainer : public Container { static void _bind_methods(); public: + virtual bool accessibility_override_tree_hierarchy() const override { return true; } + TabBar *get_tab_bar() const; int get_tab_idx_at_point(const Point2 &p_point) const; diff --git a/scene/gui/text_edit.cpp b/scene/gui/text_edit.cpp index 47b0befa29d6..b41e613e1cd1 100644 --- a/scene/gui/text_edit.cpp +++ b/scene/gui/text_edit.cpp @@ -224,9 +224,35 @@ _FORCE_INLINE_ const String &TextEdit::Text::get_text_with_ime(int p_line) const } } +const Vector TextEdit::Text::get_accessibility_elements(int p_line) { + ERR_FAIL_INDEX_V(p_line, text.size(), Vector()); + + return text[p_line].accessibility_text_root_element; +} + +void TextEdit::Text::update_accessibility(int p_line, RID p_root) { + ERR_FAIL_INDEX(p_line, text.size()); + + Line &l = text.write[p_line]; + if (l.accessibility_text_root_element.is_empty()) { + for (int i = 0; i < l.data_buf->get_line_count(); i++) { + RID rid = DisplayServer::get_singleton()->accessibility_create_sub_text_edit_elements(p_root, l.data_buf->get_line_rid(i), max_line_height, p_line); + l.accessibility_text_root_element.push_back(rid); + } + } +} + void TextEdit::Text::invalidate_cache(int p_line, bool p_text_changed) { ERR_FAIL_INDEX(p_line, text.size()); + Line &l = text.write[p_line]; + for (const RID rid : l.accessibility_text_root_element) { + if (rid.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(rid); + } + } + l.accessibility_text_root_element.clear(); + if (font.is_null()) { return; // Not in tree? } @@ -564,8 +590,173 @@ String TextEdit::Text::get_enabled_word_separators() const { /// TEXT EDIT /// /////////////////////////////////////////////////////////////////////////////// +void TextEdit::_accessibility_action_set_selection(const Variant &p_data) { + Dictionary new_selection = p_data; + RID sel_start = new_selection["start_element"]; + Vector2i sel_start_line = DisplayServer::get_singleton()->accessibility_element_get_meta(sel_start); + int sel_start_pos = new_selection["start_char"]; + + RID sel_end = new_selection["end_element"]; + Vector2i sel_end_line = DisplayServer::get_singleton()->accessibility_element_get_meta(sel_end); + int sel_end_pos = new_selection["end_char"]; + + remove_secondary_carets(); + select(sel_start_line.x, sel_start_pos, sel_end_line.x, sel_end_pos, 0); +} + +void TextEdit::_accessibility_action_replace_selected(const Variant &p_data) { + String new_text = p_data; + insert_text_at_caret(new_text); +} + +void TextEdit::_accessibility_action_set_value(const Variant &p_data) { + String new_text = p_data; + set_text(new_text); +} + +void TextEdit::_accessibility_action_menu(const Variant &p_data) { + if (context_menu_enabled) { + _update_context_menu(); + adjust_viewport_to_caret(); + menu->set_position(get_screen_position() + get_caret_draw_pos()); + menu->reset_size(); + menu->popup(); + menu->grab_focus(); + } +} + +void TextEdit::_accessibility_scroll_down(const Variant &p_data) { + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() / 4); + queue_accessibility_update(); +} + +void TextEdit::_accessibility_scroll_left(const Variant &p_data) { + h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() / 4); + queue_accessibility_update(); +} + +void TextEdit::_accessibility_scroll_right(const Variant &p_data) { + h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() / 4); + queue_accessibility_update(); +} + +void TextEdit::_accessibility_scroll_up(const Variant &p_data) { + v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() / 4); + queue_accessibility_update(); +} + +void TextEdit::_accessibility_scroll_set(const Variant &p_data) { + const Point2 &pos = p_data; + h_scroll->set_value(pos.x); + v_scroll->set_value(pos.y); + queue_accessibility_update(); +} + +void TextEdit::_accessibility_action_scroll_into_view(const Variant &p_data, int p_line, int p_wrap) { + double delta = get_scroll_pos_for_line(p_line, p_wrap) - get_v_scroll(); + if (delta < 0) { + _scroll_up(-delta, false); + } else { + _scroll_down(delta, false); + } +} + void TextEdit::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_EXIT_TREE: + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + text.clear_accessibility(); + accessibility_text_root_element_nl = RID(); + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_MULTILINE_TEXT_FIELD); + if (text.size() == 1 && text[0].is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_placeholder(ae, atr(placeholder_text)); + } + if (!placeholder_text.is_empty() && get_accessibility_name().is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_name(ae, atr(placeholder_text)); + } + DisplayServer::get_singleton()->accessibility_update_set_flag(ae, DisplayServer::AccessibilityFlags::FLAG_READONLY, !editable); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_TEXT_SELECTION, callable_mp(this, &TextEdit::_accessibility_action_set_selection)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_REPLACE_SELECTED_TEXT, callable_mp(this, &TextEdit::_accessibility_action_replace_selected)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_VALUE, callable_mp(this, &TextEdit::_accessibility_action_set_value)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SHOW_CONTEXT_MENU, callable_mp(this, &TextEdit::_accessibility_action_menu)); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_DOWN, callable_mp(this, &TextEdit::_accessibility_scroll_down)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_LEFT, callable_mp(this, &TextEdit::_accessibility_scroll_left)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_RIGHT, callable_mp(this, &TextEdit::_accessibility_scroll_right)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_UP, callable_mp(this, &TextEdit::_accessibility_scroll_up)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_SCROLL_OFFSET, callable_mp(this, &TextEdit::_accessibility_scroll_set)); + + int first_vis_line = get_first_visible_line(); + int row_height = get_line_height(); + int xmargin_beg = theme_cache.style_normal->get_margin(SIDE_LEFT) + gutters_width + gutter_padding; + Size2 size = get_size(); + bool rtl = is_layout_rtl(); + int lines_drawn = 0; + + RID selection_start; + RID selection_end; + + for (int i = 0; i < text.size(); i++) { + text.update_accessibility(i, ae); + const Ref &ac_buf = text.get_line_data(i); + const Vector &text_aes = text.get_accessibility_elements(i); + for (int j = 0; j < text_aes.size(); j++) { + float text_off_x = 0.0; + float text_off_y = 0.0; + if (!editable) { + text_off_x = theme_cache.style_readonly->get_offset().x / 2; + text_off_x -= theme_cache.style_normal->get_offset().x / 2; + text_off_y = theme_cache.style_readonly->get_offset().y / 2; + } else { + text_off_y = theme_cache.style_normal->get_offset().y / 2; + } + + text_off_y += (lines_drawn + j) * row_height + theme_cache.line_spacing / 2; + text_off_y -= (first_vis_line + first_visible_line_wrap_ofs) * row_height; + text_off_y -= _get_v_scroll_offset() * row_height; + + int char_margin = xmargin_beg - first_visible_col; + if (rtl) { + char_margin = size.width - char_margin - ac_buf->get_line_width(j); + } + + DisplayServer::get_singleton()->accessibility_update_set_flag(text_aes[j], DisplayServer::AccessibilityFlags::FLAG_HIDDEN, _is_line_hidden(i)); + Transform2D tr; + tr.set_origin(Point2(char_margin + text_off_x, text_off_y)); + DisplayServer::get_singleton()->accessibility_update_set_transform(text_aes[j], tr); + DisplayServer::get_singleton()->accessibility_update_set_name(text_aes[j], vformat(RTR("Line %d"), i)); + DisplayServer::get_singleton()->accessibility_element_set_meta(text_aes[j], Vector2i(i, j)); + DisplayServer::get_singleton()->accessibility_update_add_action(text_aes[j], DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &TextEdit::_accessibility_action_scroll_into_view).bind(i, j)); + } + lines_drawn += ac_buf->get_line_count(); + } + if (accessibility_text_root_element_nl.is_null()) { + accessibility_text_root_element_nl = DisplayServer::get_singleton()->accessibility_create_sub_text_edit_elements(ae, RID(), get_line_height()); + } + + // Selection. + if (carets.size() > 0) { + if (carets[0].selection.active) { + int start_wrap = get_line_wrap_index_at_column(carets[0].selection.origin_line, carets[0].selection.origin_column); + RID start_rid = text.get_accessibility_elements(carets[0].selection.origin_line)[start_wrap]; + + int end_wrap = get_line_wrap_index_at_column(carets[0].line, carets[0].column); + RID end_rid = text.get_accessibility_elements(carets[0].line)[end_wrap]; + DisplayServer::get_singleton()->accessibility_update_set_text_selection(ae, start_rid, carets[0].selection.origin_column, end_rid, carets[0].column); + } else { + int caret_wrap = get_line_wrap_index_at_column(carets[0].line, carets[0].column); + RID caret_rid = text.get_accessibility_elements(carets[0].line)[caret_wrap]; + DisplayServer::get_singleton()->accessibility_update_set_text_selection(ae, caret_rid, carets[0].column, caret_rid, carets[0].column); + } + } + } break; + case NOTIFICATION_POSTINITIALIZE: { _update_caches(); } break; @@ -1694,6 +1885,8 @@ void TextEdit::_notification(int p_what) { _update_ime_text(); adjust_viewport_to_caret(0); + + queue_accessibility_update(); queue_redraw(); } } break; @@ -1864,6 +2057,7 @@ void TextEdit::gui_input(const Ref &p_gui_input) { if (mb->get_button_index() == MouseButton::WHEEL_UP && !mb->is_command_or_control_pressed()) { if (mb->is_shift_pressed()) { h_scroll->set_value(h_scroll->get_value() - (100 * mb->get_factor())); + queue_accessibility_update(); } else if (mb->is_alt_pressed()) { // Scroll 5 times as fast as normal (like in Visual Studio Code). _scroll_up(15 * mb->get_factor(), true); @@ -1875,6 +2069,7 @@ void TextEdit::gui_input(const Ref &p_gui_input) { if (mb->get_button_index() == MouseButton::WHEEL_DOWN && !mb->is_command_or_control_pressed()) { if (mb->is_shift_pressed()) { h_scroll->set_value(h_scroll->get_value() + (100 * mb->get_factor())); + queue_accessibility_update(); } else if (mb->is_alt_pressed()) { // Scroll 5 times as fast as normal (like in Visual Studio Code). _scroll_down(15 * mb->get_factor(), true); @@ -1885,9 +2080,11 @@ void TextEdit::gui_input(const Ref &p_gui_input) { } if (mb->get_button_index() == MouseButton::WHEEL_LEFT) { h_scroll->set_value(h_scroll->get_value() - (100 * mb->get_factor())); + queue_accessibility_update(); } if (mb->get_button_index() == MouseButton::WHEEL_RIGHT) { h_scroll->set_value(h_scroll->get_value() + (100 * mb->get_factor())); + queue_accessibility_update(); } if (mb->get_button_index() == MouseButton::LEFT) { @@ -1961,6 +2158,8 @@ void TextEdit::gui_input(const Ref &p_gui_input) { return; } + queue_accessibility_update(); + last_dblclk = 0; } else if (!mb->is_shift_pressed()) { if (drag_and_drop_selection_enabled && mouse_over_selection_caret >= 0) { @@ -2005,6 +2204,7 @@ void TextEdit::gui_input(const Ref &p_gui_input) { last_dblclk = OS::get_singleton()->get_ticks_msec(); last_dblclk_pos = mb->get_position(); } + queue_accessibility_update(); queue_redraw(); } @@ -2086,6 +2286,7 @@ void TextEdit::gui_input(const Ref &p_gui_input) { if (v_scroll->get_value() != prev_v_scroll || h_scroll->get_value() != prev_h_scroll) { accept_event(); // Accept event if scroll changed. } + queue_accessibility_update(); return; } @@ -2417,8 +2618,15 @@ void TextEdit::gui_input(const Ref &p_gui_input) { return; } + // Toggle Tab mode. + if (k->is_action("ui_focus_mode", true)) { + tab_input_mode = !tab_input_mode; + accept_event(); + return; + } + // Handle tab as it has no set unicode value. - if (k->is_action("ui_text_indent", true)) { + if (tab_input_mode && k->is_action("ui_text_indent", true)) { if (editable) { insert_text_at_caret("\t"); } @@ -2996,6 +3204,7 @@ void TextEdit::_update_caches() { syntax_highlighter->set_text_edit(this); } _clear_syntax_highlighting_cache(); + queue_accessibility_update(); } void TextEdit::_close_ime_window() { @@ -3039,6 +3248,7 @@ void TextEdit::_update_ime_text() { } } _clear_syntax_highlighting_cache(); + queue_accessibility_update(); queue_redraw(); } @@ -3111,7 +3321,9 @@ bool TextEdit::can_drop_data(const Point2 &p_point, const Variant &p_data) const void TextEdit::drop_data(const Point2 &p_point, const Variant &p_data) { Control::drop_data(p_point, p_data); - if (p_data.is_string() && is_editable()) { + if (p_point == Vector2(INFINITY, INFINITY)) { + insert_text_at_caret(p_data); + } else if (p_data.is_string() && is_editable()) { Point2i pos = get_line_column_at_pos(get_local_mouse_pos()); int drop_at_line = pos.y; int drop_at_column = pos.x; @@ -3215,6 +3427,7 @@ String TextEdit::get_tooltip(const Point2 &p_pos) const { void TextEdit::set_tooltip_request_func(const Callable &p_tooltip_callback) { tooltip_callback = p_tooltip_callback; + queue_accessibility_update(); } /* Text */ @@ -3261,7 +3474,7 @@ void TextEdit::set_editable(bool p_editable) { } editable = p_editable; - + queue_accessibility_update(); queue_redraw(); } @@ -3292,6 +3505,7 @@ void TextEdit::set_text_direction(Control::TextDirection p_text_direction) { menu_dir->set_item_checked(menu_dir->get_item_index(MENU_DIR_LTR), text_direction == TEXT_DIRECTION_LTR); menu_dir->set_item_checked(menu_dir->get_item_index(MENU_DIR_RTL), text_direction == TEXT_DIRECTION_RTL); } + queue_accessibility_update(); queue_redraw(); } } @@ -3312,6 +3526,7 @@ void TextEdit::set_language(const String &p_language) { text.set_direction_and_language(dir, (!language.is_empty()) ? language : TranslationServer::get_singleton()->get_tool_locale()); text.invalidate_all(); _update_placeholder(); + queue_accessibility_update(); queue_redraw(); } } @@ -3326,6 +3541,7 @@ void TextEdit::set_structured_text_bidi_override(TextServer::StructuredTextParse for (int i = 0; i < text.size(); i++) { text.set(i, text[i], structured_text_parser(st_parser, st_args, text[i])); } + queue_accessibility_update(); queue_redraw(); } } @@ -3343,6 +3559,7 @@ void TextEdit::set_structured_text_bidi_override_options(Array p_args) { for (int i = 0; i < text.size(); i++) { text.set(i, text[i], structured_text_parser(st_parser, st_args, text[i])); } + queue_accessibility_update(); queue_redraw(); } @@ -3358,6 +3575,7 @@ void TextEdit::set_tab_size(const int p_size) { text.set_tab_size(p_size); text.invalidate_all_lines(); _update_placeholder(); + queue_accessibility_update(); queue_redraw(); } @@ -3379,6 +3597,14 @@ bool TextEdit::is_indent_wrapped_lines() const { return text.is_indent_wrapped_lines(); } +void TextEdit::set_tab_input_mode(bool p_enabled) { + tab_input_mode = p_enabled; +} + +bool TextEdit::get_tab_input_mode() const { + return tab_input_mode; +} + // User controls void TextEdit::set_overtype_mode_enabled(bool p_enabled) { if (overtype_mode == p_enabled) { @@ -3508,7 +3734,7 @@ void TextEdit::set_text(const String &p_text) { set_caret_line(0); set_caret_column(0); - + queue_accessibility_update(); queue_redraw(); setting_text = false; emit_signal(SNAME("text_set")); @@ -3537,6 +3763,7 @@ void TextEdit::set_placeholder(const String &p_text) { placeholder_text = p_text; _update_placeholder(); + queue_accessibility_update(); queue_redraw(); } @@ -3773,6 +4000,9 @@ void TextEdit::remove_line_at(int p_line, bool p_move_carets_down) { _offset_carets_after(next_line, next_column, from_line, from_column); end_multicaret_edit(); end_complex_operation(); + + queue_accessibility_update(); + queue_redraw(); } void TextEdit::insert_text_at_caret(const String &p_text, int p_caret) { @@ -4153,6 +4383,7 @@ void TextEdit::start_action(EditAction p_action) { void TextEdit::end_action() { if (current_action != EditAction::ACTION_NONE) { pending_action_end = true; + queue_accessibility_update(); } } @@ -4172,6 +4403,8 @@ void TextEdit::begin_complex_operation() { void TextEdit::end_complex_operation() { _push_current_op(); + queue_accessibility_update(); + complex_operation_count = MAX(complex_operation_count - 1, 0); if (complex_operation_count > 0) { return; @@ -4264,6 +4497,7 @@ void TextEdit::undo() { _selection_changed(); } adjust_viewport_to_caret(); + queue_accessibility_update(); } void TextEdit::redo() { @@ -4320,6 +4554,7 @@ void TextEdit::redo() { _selection_changed(); } adjust_viewport_to_caret(); + queue_accessibility_update(); } void TextEdit::clear_undo_history() { @@ -4591,7 +4826,7 @@ Rect2i TextEdit::get_rect_at_line_column(int p_line, int p_column) const { ERR_FAIL_COND_V(p_column < 0, Rect2i(-1, -1, 0, 0)); ERR_FAIL_COND_V(p_column > text[p_line].length(), Rect2i(-1, -1, 0, 0)); - if (text.size() == 1 && text[0].length() == 0) { + if (text.size() == 1 && text[0].is_empty()) { // The TextEdit is empty. return Rect2i(); } @@ -4841,6 +5076,7 @@ void TextEdit::remove_secondary_carets() { if (drag_caret_index >= 0) { drag_caret_index = -1; } + queue_accessibility_update(); } int TextEdit::get_caret_count() const { @@ -5262,6 +5498,7 @@ void TextEdit::set_caret_line(int p_line, bool p_adjust_viewport, bool p_can_be_ if (caret_moved) { _caret_changed(p_caret); } + queue_accessibility_update(); } int TextEdit::get_caret_line(int p_caret) const { @@ -5296,6 +5533,7 @@ void TextEdit::set_caret_column(int p_column, bool p_adjust_viewport, int p_care if (caret_moved) { _caret_changed(p_caret); } + queue_accessibility_update(); } int TextEdit::get_caret_column(int p_caret) const { @@ -5384,7 +5622,7 @@ void TextEdit::select_all() { return; } - if (text.size() == 1 && text[0].length() == 0) { + if (text.size() == 1 && text[0].is_empty()) { return; } @@ -5401,7 +5639,7 @@ void TextEdit::select_word_under_caret(int p_caret) { return; } - if (text.size() == 1 && text[0].length() == 0) { + if (text.size() == 1 && text[0].is_empty()) { return; } @@ -5446,7 +5684,7 @@ void TextEdit::add_selection_for_next_occurrence() { return; } - if (text.size() == 1 && text[0].length() == 0) { + if (text.size() == 1 && text[0].is_empty()) { return; } @@ -5489,7 +5727,7 @@ void TextEdit::skip_selection_for_next_occurrence() { return; } - if (text.size() == 1 && text[0].length() == 0) { + if (text.size() == 1 && text[0].is_empty()) { return; } @@ -5558,6 +5796,9 @@ void TextEdit::select(int p_origin_line, int p_origin_column, int p_caret_line, if (had_selection != activate) { _selection_changed(p_caret); } + + queue_accessibility_update(); + queue_redraw(); } bool TextEdit::has_selection(int p_caret) const { @@ -5802,6 +6043,9 @@ void TextEdit::deselect(int p_caret) { if (selection_changed) { _selection_changed(p_caret); } + + queue_accessibility_update(); + queue_redraw(); } void TextEdit::delete_selection(int p_caret) { @@ -5843,6 +6087,7 @@ void TextEdit::set_line_wrapping_mode(LineWrappingMode p_wrapping_mode) { if (line_wrapping_mode != p_wrapping_mode) { line_wrapping_mode = p_wrapping_mode; _update_wrap_at_column(true); + queue_accessibility_update(); queue_redraw(); } } @@ -5859,6 +6104,7 @@ void TextEdit::set_autowrap_mode(TextServer::AutowrapMode p_mode) { autowrap_mode = p_mode; if (get_line_wrapping_mode() != LineWrappingMode::LINE_WRAPPING_NONE) { _update_wrap_at_column(true); + queue_accessibility_update(); queue_redraw(); } } @@ -5964,6 +6210,7 @@ void TextEdit::set_v_scroll(double p_scroll) { if (p_scroll >= max_v_scroll - 1.0) { _scroll_moved(v_scroll->get_value()); } + queue_accessibility_update(); } double TextEdit::get_v_scroll() const { @@ -5975,6 +6222,7 @@ void TextEdit::set_h_scroll(int p_scroll) { p_scroll = 0; } h_scroll->set_value(p_scroll); + queue_accessibility_update(); } int TextEdit::get_h_scroll() const { @@ -6550,6 +6798,7 @@ void TextEdit::set_draw_control_chars(bool p_enabled) { text.set_draw_control_chars(draw_control_chars); text.invalidate_font(); _update_placeholder(); + queue_accessibility_update(); queue_redraw(); } } @@ -6615,6 +6864,9 @@ void TextEdit::_bind_methods() { ClassDB::bind_method(D_METHOD("set_indent_wrapped_lines", "enabled"), &TextEdit::set_indent_wrapped_lines); ClassDB::bind_method(D_METHOD("is_indent_wrapped_lines"), &TextEdit::is_indent_wrapped_lines); + ClassDB::bind_method(D_METHOD("set_tab_input_mode", "enabled"), &TextEdit::set_tab_input_mode); + ClassDB::bind_method(D_METHOD("get_tab_input_mode"), &TextEdit::get_tab_input_mode); + // User controls ClassDB::bind_method(D_METHOD("set_overtype_mode_enabled", "enabled"), &TextEdit::set_overtype_mode_enabled); ClassDB::bind_method(D_METHOD("is_overtype_mode_enabled"), &TextEdit::is_overtype_mode_enabled); @@ -7037,6 +7289,7 @@ void TextEdit::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::INT, "wrap_mode", PROPERTY_HINT_ENUM, "None,Boundary"), "set_line_wrapping_mode", "get_line_wrapping_mode"); ADD_PROPERTY(PropertyInfo(Variant::INT, "autowrap_mode", PROPERTY_HINT_ENUM, "Arbitrary:1,Word:2,Word (Smart):3"), "set_autowrap_mode", "get_autowrap_mode"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "indent_wrapped_lines"), "set_indent_wrapped_lines", "is_indent_wrapped_lines"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "tab_input_mode"), "set_tab_input_mode", "get_tab_input_mode"); ADD_GROUP("Scroll", "scroll_"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "scroll_smooth"), "set_smooth_scroll_enabled", "is_smooth_scroll_enabled"); @@ -7147,6 +7400,7 @@ void TextEdit::_set_hiding_enabled(bool p_enabled) { _unhide_all_lines(); } hiding_enabled = p_enabled; + queue_accessibility_update(); queue_redraw(); } @@ -7164,6 +7418,7 @@ void TextEdit::_unhide_all_lines() { text.set_hidden(i, false); } _update_scrollbars(); + queue_accessibility_update(); queue_redraw(); } @@ -7181,6 +7436,7 @@ void TextEdit::_set_line_as_hidden(int p_line, bool p_hidden) { if (_is_hiding_enabled() || !p_hidden) { text.set_hidden(p_line, p_hidden); } + queue_accessibility_update(); queue_redraw(); } @@ -7833,6 +8089,7 @@ void TextEdit::_selection_changed(int p_caret) { } _cancel_drag_and_drop_text(); + queue_accessibility_update(); queue_redraw(); } @@ -8035,6 +8292,7 @@ void TextEdit::_update_wrap_at_column(bool p_force) { first_visible_line_wrap_ofs = 0; } set_line_as_first_visible(first_visible_line, first_visible_line_wrap_ofs); + queue_accessibility_update(); } /* Viewport. */ @@ -8151,6 +8409,7 @@ void TextEdit::_scroll_moved(double p_to_val) { first_visible_line = n_line; first_visible_line_wrap_ofs = wi; } + queue_accessibility_update(); queue_redraw(); } @@ -8185,6 +8444,7 @@ void TextEdit::_scroll_up(real_t p_delta, bool p_animate) { } if (!p_animate || Math::abs(target_v_scroll - v_scroll->get_value()) < 1.0) { v_scroll->set_value(target_v_scroll); + queue_accessibility_update(); } else { scrolling = true; set_physics_process_internal(true); @@ -8213,6 +8473,7 @@ void TextEdit::_scroll_down(real_t p_delta, bool p_animate) { } if (!p_animate || Math::abs(target_v_scroll - v_scroll->get_value()) < 1.0) { v_scroll->set_value(target_v_scroll); + queue_accessibility_update(); } else { scrolling = true; set_physics_process_internal(true); @@ -8326,6 +8587,8 @@ void TextEdit::_adjust_viewport_to_caret_horizontally(int p_caret, bool p_maximi } h_scroll->set_value(first_visible_col); + + queue_accessibility_update(); queue_redraw(); } @@ -8418,6 +8681,7 @@ void TextEdit::_update_gutter_width() { if (get_viewport()) { hovered_gutter = _get_hovered_gutter(get_local_mouse_position()); } + queue_accessibility_update(); queue_redraw(); } diff --git a/scene/gui/text_edit.h b/scene/gui/text_edit.h index e4948decdf0e..df8d73f66cb5 100644 --- a/scene/gui/text_edit.h +++ b/scene/gui/text_edit.h @@ -144,12 +144,15 @@ class TextEdit : public Control { Color color = Color(1, 1, 1); }; + mutable int64_t next_item_id = 0; + struct Line { Vector gutters; String data; Array bidi_override; Ref data_buf; + Vector accessibility_text_root_element; String ime_data; Array ime_bidi_override; @@ -227,6 +230,14 @@ class TextEdit : public Control { BitField get_brk_flags() const; int get_line_wrap_amount(int p_line) const; + const Vector get_accessibility_elements(int p_line); + void update_accessibility(int p_line, RID p_root); + void clear_accessibility() { + for (int i = 0; i < text.size(); i++) { + text.write[i].accessibility_text_root_element.clear(); + } + } + Vector get_line_wrap_ranges(int p_line) const; const Ref get_line_data(int p_line) const; float get_indent_offset(int p_line, bool p_rtl) const; @@ -275,13 +286,14 @@ class TextEdit : public Control { /* Text */ Text text; - bool setting_text = false; bool alt_start = false; bool alt_start_no_hold = false; uint32_t alt_code = 0; + bool tab_input_mode = true; + // Text properties. String ime_text = ""; Point2 ime_selection; @@ -628,6 +640,8 @@ class TextEdit : public Control { bool draw_tabs = false; bool draw_spaces = false; + RID accessibility_text_root_element_nl; + /*** Super internal Core API. Everything builds on it. ***/ bool text_changed_dirty = false; void _text_changed(); @@ -718,6 +732,17 @@ class TextEdit : public Control { virtual void _paste_internal(int p_caret); virtual void _paste_primary_clipboard_internal(int p_caret); + void _accessibility_action_set_selection(const Variant &p_data); + void _accessibility_action_replace_selected(const Variant &p_data); + void _accessibility_action_set_value(const Variant &p_data); + void _accessibility_action_menu(const Variant &p_data); + void _accessibility_scroll_down(const Variant &p_data); + void _accessibility_scroll_left(const Variant &p_data); + void _accessibility_scroll_right(const Variant &p_data); + void _accessibility_scroll_up(const Variant &p_data); + void _accessibility_scroll_set(const Variant &p_data); + void _accessibility_action_scroll_into_view(const Variant &p_data, int p_line, int p_wrap); + GDVIRTUAL2(_handle_unicode_input, int, int) GDVIRTUAL1(_backspace, int) GDVIRTUAL1(_cut, int) @@ -765,6 +790,9 @@ class TextEdit : public Control { void set_indent_wrapped_lines(bool p_enabled); bool is_indent_wrapped_lines() const; + void set_tab_input_mode(bool p_enabled); + bool get_tab_input_mode() const; + // User controls void set_overtype_mode_enabled(bool p_enabled); bool is_overtype_mode_enabled() const; diff --git a/scene/gui/texture_progress_bar.cpp b/scene/gui/texture_progress_bar.cpp index 3ed7bf2f511d..dd754de720b3 100644 --- a/scene/gui/texture_progress_bar.cpp +++ b/scene/gui/texture_progress_bar.cpp @@ -429,6 +429,13 @@ void TextureProgressBar::draw_nine_patch_stretched(const Ref &p_textu void TextureProgressBar::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_PROGRESS_INDICATOR); + } break; + case NOTIFICATION_DRAW: { if (under.is_valid()) { if (nine_patch_stretch) { diff --git a/scene/gui/tree.compat.inc b/scene/gui/tree.compat.inc new file mode 100644 index 000000000000..f4355764643a --- /dev/null +++ b/scene/gui/tree.compat.inc @@ -0,0 +1,41 @@ +/**************************************************************************/ +/* tree.compat.inc */ +/**************************************************************************/ +/* 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. */ +/**************************************************************************/ + +#ifndef DISABLE_DEPRECATED + +void TreeItem::_add_button_bind_compat_76829(int p_column, const Ref &p_button, int p_id, bool p_disabled, const String &p_tooltip) { + add_button(p_column, p_button, p_id, p_disabled, p_tooltip, String()); +} + +void TreeItem::_bind_compatibility_methods() { + ClassDB::bind_compatibility_method(D_METHOD("add_button", "column", "button", "id", "disabled", "tooltip_text"), &TreeItem::_add_button_bind_compat_76829, DEFVAL(-1), DEFVAL(false), DEFVAL("")); +} + +#endif // DISABLE_DEPRECATED diff --git a/scene/gui/tree.cpp b/scene/gui/tree.cpp index d14300482e33..9ea1130e4d90 100644 --- a/scene/gui/tree.cpp +++ b/scene/gui/tree.cpp @@ -29,6 +29,7 @@ /**************************************************************************/ #include "tree.h" +#include "tree.compat.inc" #include "core/config/project_settings.h" #include "core/input/input.h" @@ -102,6 +103,7 @@ void TreeItem::_change_tree(Tree *p_tree) { if (p_tree == tree) { return; } + accessibility_row_dirty = true; TreeItem *c = first_child; while (c) { @@ -144,13 +146,31 @@ void TreeItem::_change_tree(Tree *p_tree) { tree->edited_item = nullptr; tree->pressing_for_editor = false; } - + tree->queue_accessibility_update(); tree->queue_redraw(); } tree = p_tree; + if (accessibility_row_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(accessibility_row_element); + accessibility_row_element = RID(); + } + for (Cell &cell : cells) { + if (cell.accessibility_cell_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(cell.accessibility_cell_element); + cell.accessibility_cell_element = RID(); + } + for (Cell::Button &btn : cell.buttons) { + if (btn.accessibility_button_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(btn.accessibility_button_element); + btn.accessibility_button_element = RID(); + } + } + } + if (tree) { + tree->queue_accessibility_update(); tree->queue_redraw(); cells.resize(tree->columns.size()); } @@ -366,6 +386,9 @@ void TreeItem::set_text(int p_column, String p_text) { cells.write[p_column].cached_minimum_size_dirty = true; _changed_notify(p_column); + if (get_tree()) { + get_tree()->update_configuration_warnings(); + } } String TreeItem::get_text(int p_column) const { @@ -373,6 +396,26 @@ String TreeItem::get_text(int p_column) const { return cells[p_column].text; } +void TreeItem::set_alt_text(int p_column, String p_text) { + ERR_FAIL_INDEX(p_column, cells.size()); + + if (cells[p_column].alt_text == p_text) { + return; + } + + cells.write[p_column].alt_text = p_text; + + _changed_notify(p_column); + if (get_tree()) { + get_tree()->update_configuration_warnings(); + } +} + +String TreeItem::get_alt_text(int p_column) const { + ERR_FAIL_INDEX_V(p_column, cells.size(), ""); + return cells[p_column].alt_text; +} + void TreeItem::set_text_direction(int p_column, Control::TextDirection p_text_direction) { ERR_FAIL_INDEX(p_column, cells.size()); ERR_FAIL_COND((int)p_text_direction < -1 || (int)p_text_direction > 3); @@ -696,6 +739,7 @@ void TreeItem::set_collapsed(bool p_collapsed) { select(tree->selected_col); } + tree->queue_accessibility_update(); tree->queue_redraw(); } } @@ -765,6 +809,7 @@ void TreeItem::set_visible(bool p_visible) { } visible = p_visible; if (tree) { + tree->queue_accessibility_update(); tree->queue_redraw(); _changed_notify(); } @@ -823,6 +868,7 @@ TreeItem *TreeItem::create_child(int p_index) { TreeItem *ti = memnew(TreeItem(tree)); if (tree) { ti->cells.resize(tree->columns.size()); + tree->queue_accessibility_update(); tree->queue_redraw(); } @@ -1160,6 +1206,7 @@ void TreeItem::move_before(TreeItem *p_item) { p_item->prev = this; if (tree && old_tree == tree) { + tree->queue_accessibility_update(); tree->queue_redraw(); } @@ -1205,6 +1252,7 @@ void TreeItem::move_after(TreeItem *p_item) { } if (tree && old_tree == tree) { + tree->queue_accessibility_update(); tree->queue_redraw(); } validate_cache(); @@ -1238,6 +1286,8 @@ void TreeItem::set_as_cursor(int p_column) { } tree->selected_item = this; tree->selected_col = p_column; + tree->selected_button = -1; + tree->queue_accessibility_update(); tree->queue_redraw(); } @@ -1255,6 +1305,11 @@ void TreeItem::clear_buttons() { int i = 0; for (Cell &cell : cells) { if (!cell.buttons.is_empty()) { + for (Cell::Button &btn : cell.buttons) { + if (btn.accessibility_button_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(btn.accessibility_button_element); + } + } cell.buttons.clear(); cell.cached_minimum_size_dirty = true; _changed_notify(i); @@ -1263,7 +1318,7 @@ void TreeItem::clear_buttons() { } } -void TreeItem::add_button(int p_column, const Ref &p_button, int p_id, bool p_disabled, const String &p_tooltip) { +void TreeItem::add_button(int p_column, const Ref &p_button, int p_id, bool p_disabled, const String &p_tooltip, const String &p_alt_text) { ERR_FAIL_INDEX(p_column, cells.size()); ERR_FAIL_COND(p_button.is_null()); TreeItem::Cell::Button button; @@ -1274,10 +1329,14 @@ void TreeItem::add_button(int p_column, const Ref &p_button, int p_id button.id = p_id; button.disabled = p_disabled; button.tooltip = p_tooltip; + button.alt_text = p_alt_text; cells.write[p_column].buttons.push_back(button); cells.write[p_column].cached_minimum_size_dirty = true; _changed_notify(p_column); + if (get_tree()) { + get_tree()->update_configuration_warnings(); + } } int TreeItem::get_button_count(int p_column) const { @@ -1306,8 +1365,14 @@ int TreeItem::get_button_id(int p_column, int p_index) const { void TreeItem::erase_button(int p_column, int p_index) { ERR_FAIL_INDEX(p_column, cells.size()); ERR_FAIL_INDEX(p_index, cells[p_column].buttons.size()); + if (cells[p_column].buttons[p_index].accessibility_button_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(cells.write[p_column].buttons.write[p_index].accessibility_button_element); + } cells.write[p_column].buttons.remove_at(p_index); _changed_notify(p_column); + if (get_tree()) { + get_tree()->update_configuration_warnings(); + } } int TreeItem::get_button_by_id(int p_column, int p_id) const { @@ -1331,6 +1396,8 @@ void TreeItem::set_button_tooltip_text(int p_column, int p_index, const String & ERR_FAIL_INDEX(p_column, cells.size()); ERR_FAIL_INDEX(p_index, cells[p_column].buttons.size()); cells.write[p_column].buttons.write[p_index].tooltip = p_tooltip; + + _changed_notify(p_column); } void TreeItem::set_button(int p_column, int p_index, const Ref &p_button) { @@ -1348,6 +1415,21 @@ void TreeItem::set_button(int p_column, int p_index, const Ref &p_but _changed_notify(p_column); } +void TreeItem::set_button_alt_text(int p_column, int p_index, const String &p_alt_text) { + ERR_FAIL_INDEX(p_column, cells.size()); + ERR_FAIL_INDEX(p_index, cells[p_column].buttons.size()); + + if (cells[p_column].buttons[p_index].alt_text == p_alt_text) { + return; + } + + cells.write[p_column].buttons.write[p_index].alt_text = p_alt_text; + _changed_notify(p_column); + if (get_tree()) { + get_tree()->update_configuration_warnings(); + } +} + void TreeItem::set_button_color(int p_column, int p_index, const Color &p_color) { ERR_FAIL_INDEX(p_column, cells.size()); ERR_FAIL_INDEX(p_index, cells[p_column].buttons.size()); @@ -1681,6 +1763,9 @@ void TreeItem::_bind_methods() { ClassDB::bind_method(D_METHOD("set_text", "column", "text"), &TreeItem::set_text); ClassDB::bind_method(D_METHOD("get_text", "column"), &TreeItem::get_text); + ClassDB::bind_method(D_METHOD("set_alt_text", "column", "text"), &TreeItem::set_alt_text); + ClassDB::bind_method(D_METHOD("get_alt_text", "column"), &TreeItem::get_alt_text); + ClassDB::bind_method(D_METHOD("set_text_direction", "column", "direction"), &TreeItem::set_text_direction); ClassDB::bind_method(D_METHOD("get_text_direction", "column"), &TreeItem::get_text_direction); @@ -1774,7 +1859,7 @@ void TreeItem::_bind_methods() { ClassDB::bind_method(D_METHOD("is_custom_set_as_button", "column"), &TreeItem::is_custom_set_as_button); ClassDB::bind_method(D_METHOD("clear_buttons"), &TreeItem::clear_buttons); - ClassDB::bind_method(D_METHOD("add_button", "column", "button", "id", "disabled", "tooltip_text"), &TreeItem::add_button, DEFVAL(-1), DEFVAL(false), DEFVAL("")); + ClassDB::bind_method(D_METHOD("add_button", "column", "button", "id", "disabled", "tooltip_text", "alt_text"), &TreeItem::add_button, DEFVAL(-1), DEFVAL(false), DEFVAL(""), DEFVAL("")); ClassDB::bind_method(D_METHOD("get_button_count", "column"), &TreeItem::get_button_count); ClassDB::bind_method(D_METHOD("get_button_tooltip_text", "column", "button_index"), &TreeItem::get_button_tooltip_text); ClassDB::bind_method(D_METHOD("get_button_id", "column", "button_index"), &TreeItem::get_button_id); @@ -1784,6 +1869,7 @@ void TreeItem::_bind_methods() { ClassDB::bind_method(D_METHOD("set_button_tooltip_text", "column", "button_index", "tooltip"), &TreeItem::set_button_tooltip_text); ClassDB::bind_method(D_METHOD("set_button", "column", "button_index", "button"), &TreeItem::set_button); ClassDB::bind_method(D_METHOD("erase_button", "column", "button_index"), &TreeItem::erase_button); + ClassDB::bind_method(D_METHOD("set_button_alt_text", "column", "button_index", "alt_text"), &TreeItem::set_button_alt_text); ClassDB::bind_method(D_METHOD("set_button_disabled", "column", "button_index", "disabled"), &TreeItem::set_button_disabled); ClassDB::bind_method(D_METHOD("set_button_color", "column", "button_index", "color"), &TreeItem::set_button_color); ClassDB::bind_method(D_METHOD("is_button_disabled", "column", "button_index"), &TreeItem::is_button_disabled); @@ -2544,6 +2630,13 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2 theme_cache.button_hover->draw(get_canvas_item(), Rect2(od.x, od.y, button_size.width, MAX(button_size.height, label_h))); } } + if (selected_item == p_item && selected_col == i && selected_button == j) { + Point2 od = button_ofs; + if (rtl) { + od.x = get_size().width - od.x - button_size.x; + } + theme_cache.button_hover->draw(get_canvas_item(), Rect2(od.x, od.y, button_size.width, MAX(button_size.height, label_h))); + } button_ofs.y += (label_h - button_size.height) / 2; button_ofs += theme_cache.button_pressed->get_offset(); @@ -2831,6 +2924,7 @@ void Tree::select_single_item(TreeItem *p_selected, TreeItem *p_current, int p_c selected_item = p_selected; selected_col = i; + selected_button = -1; emit_signal(SNAME("cell_selected")); if (select_mode == SELECT_MULTI) { @@ -2842,6 +2936,7 @@ void Tree::select_single_item(TreeItem *p_selected, TreeItem *p_current, int p_c } else if (select_mode == SELECT_MULTI && (selected_item != p_selected || selected_col != i)) { selected_item = p_selected; selected_col = i; + selected_button = -1; emit_signal(SNAME("cell_selected")); } } else { @@ -2873,6 +2968,7 @@ void Tree::select_single_item(TreeItem *p_selected, TreeItem *p_current, int p_c } c = c->next; } + queue_accessibility_update(); } Rect2 Tree::search_item_rect(TreeItem *p_from, TreeItem *p_item) { @@ -3051,6 +3147,7 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, int emit_signal(SNAME("item_mouse_selected"), get_local_mouse_position(), p_button); } } + queue_accessibility_update(); queue_redraw(); } } @@ -3356,7 +3453,10 @@ void Tree::popup_select(int p_option) { } void Tree::_go_left() { - if (selected_col == 0) { + if (get_tree()->is_accessibility_enabled() && selected_button >= 0) { + selected_button--; + } else if (selected_col == 0) { + selected_button = -1; if (selected_item->get_first_child() != nullptr && !selected_item->is_collapsed()) { selected_item->set_collapsed(true); } else { @@ -3371,6 +3471,7 @@ void Tree::_go_left() { } } } else { + selected_button = -1; if (select_mode == SELECT_MULTI) { selected_col--; emit_signal(SNAME("cell_selected")); @@ -3378,13 +3479,18 @@ void Tree::_go_left() { selected_item->select(selected_col - 1); } } + queue_accessibility_update(); queue_redraw(); accept_event(); ensure_cursor_is_visible(); } void Tree::_go_right() { - if (selected_col == (columns.size() - 1)) { + int buttons = (selected_item && selected_col >= 0 && selected_col < columns.size()) ? selected_item->cells[selected_col].buttons.size() : 0; + if (get_tree()->is_accessibility_enabled() && selected_button < buttons - 1) { + selected_button++; + } else if (selected_col == (columns.size() - 1)) { + selected_button = -1; if (selected_item->get_first_child() != nullptr && selected_item->is_collapsed()) { selected_item->set_collapsed(false); } else if (selected_item->get_next_visible()) { @@ -3392,6 +3498,7 @@ void Tree::_go_right() { _go_down(); } } else { + selected_button = -1; if (select_mode == SELECT_MULTI) { selected_col++; emit_signal(SNAME("cell_selected")); @@ -3399,6 +3506,7 @@ void Tree::_go_right() { selected_item->select(selected_col + 1); } } + queue_accessibility_update(); queue_redraw(); ensure_cursor_is_visible(); accept_event(); @@ -3409,6 +3517,7 @@ void Tree::_go_up() { if (!selected_item) { prev = get_last_item(); selected_col = 0; + selected_button = -1; } else { prev = selected_item->get_prev_visible(); } @@ -3433,6 +3542,7 @@ void Tree::_go_up() { prev->select(col); } + queue_accessibility_update(); ensure_cursor_is_visible(); accept_event(); } @@ -3467,6 +3577,7 @@ void Tree::_go_down() { next->select(col); } + queue_accessibility_update(); ensure_cursor_is_visible(); accept_event(); } @@ -3575,7 +3686,12 @@ void Tree::gui_input(const Ref &p_event) { } _go_down(); + } else if (p_event->is_action("ui_menu") && p_event->is_pressed()) { + if (allow_rmb_select && selected_item) { + emit_signal(SNAME("item_mouse_selected"), get_item_rect(selected_item).position, MouseButton::RIGHT); + } + accept_event(); } else if (p_event->is_action("ui_page_down") && p_event->is_pressed()) { if (!cursor_can_exit_tree) { accept_event(); @@ -3602,6 +3718,7 @@ void Tree::gui_input(const Ref &p_event) { if (select_mode == SELECT_MULTI) { selected_item = next; emit_signal(SNAME("cell_selected")); + queue_accessibility_update(); queue_redraw(); } else { while (next && !next->cells[selected_col].selectable) { @@ -3640,6 +3757,7 @@ void Tree::gui_input(const Ref &p_event) { if (select_mode == SELECT_MULTI) { selected_item = prev; emit_signal(SNAME("cell_selected")); + queue_accessibility_update(); queue_redraw(); } else { while (prev && !prev->cells[selected_col].selectable) { @@ -3656,19 +3774,28 @@ void Tree::gui_input(const Ref &p_event) { if (!selected_item) { return; } - if (selected_item->is_selected(selected_col)) { + if (selected_item && selected_col != -1 && selected_button != -1) { + const TreeItem::Cell &c = selected_item->cells[selected_col]; + emit_signal("button_clicked", selected_item, selected_col, c.buttons[selected_button].id, MouseButton::LEFT); + } else if (selected_item->is_selected(selected_col)) { selected_item->deselect(selected_col); emit_signal(SNAME("multi_selected"), selected_item, selected_col, false); } else if (selected_item->is_selectable(selected_col)) { selected_item->select(selected_col); emit_signal(SNAME("multi_selected"), selected_item, selected_col, true); } + } else if (selected_item && selected_col != -1 && selected_button != -1) { + const TreeItem::Cell &c = selected_item->cells[selected_col]; + emit_signal("button_clicked", selected_item, selected_col, c.buttons[selected_button].id, MouseButton::LEFT); } accept_event(); } else if (p_event->is_action("ui_accept") && p_event->is_pressed()) { if (selected_item) { // Bring up editor if possible. - if (!edit_selected()) { + if (selected_item && selected_col != -1 && selected_button != -1) { + const TreeItem::Cell &c = selected_item->cells[selected_col]; + emit_signal("button_clicked", selected_item, selected_col, c.buttons[selected_button].id, MouseButton::LEFT); + } else if (!edit_selected()) { emit_signal(SNAME("item_activated")); incr_search.clear(); } @@ -4312,8 +4439,360 @@ int Tree::_get_title_button_height() const { return h; } +void Tree::_check_item_accessibility(TreeItem *p_item, PackedStringArray &r_warnings, int &r_row) const { + for (int i = 0; i < p_item->cells.size(); i++) { + const TreeItem::Cell &cell = p_item->cells[i]; + if (cell.alt_text.strip_edges().is_empty() && cell.text.strip_edges().is_empty()) { + r_warnings.push_back(vformat(RTR("Cell %d x %d: either text or alternative text must not be empty."), r_row, i)); + } + for (int j = 0; j < cell.buttons.size(); j++) { + if (cell.buttons[j].alt_text.strip_edges().is_empty()) { + r_warnings.push_back(vformat(RTR("Button %d in %d x %d: alternative text must not be empty."), j, r_row, i)); + } + } + } + r_row++; + + // Children. + if (!p_item->collapsed) { + TreeItem *c = p_item->first_child; + while (c) { + _check_item_accessibility(c, r_warnings, r_row); + c = c->next; + } + } +} + +PackedStringArray Tree::get_accessibility_configuration_warnings() const { + PackedStringArray warnings = Control::get_accessibility_configuration_warnings(); + + if (root) { + int row = 1; + _check_item_accessibility(root, warnings, row); + } + + return warnings; +} + +void Tree::_accessibility_action_scroll_down(const Variant &p_data) { + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() / 4); +} + +void Tree::_accessibility_action_scroll_left(const Variant &p_data) { + h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() / 4); +} + +void Tree::_accessibility_action_scroll_right(const Variant &p_data) { + h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() / 4); +} + +void Tree::_accessibility_action_scroll_up(const Variant &p_data) { + v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() / 4); +} + +void Tree::_accessibility_action_scroll_set(const Variant &p_data) { + const Point2 &pos = p_data; + h_scroll->set_value(pos.x); + v_scroll->set_value(pos.y); +} + +void Tree::_accessibility_action_scroll_into_view(const Variant &p_data, TreeItem *p_item, int p_col) { + scroll_to_item(p_item); +} + +void Tree::_accessibility_action_focus(const Variant &p_data, TreeItem *p_item, int p_col) { + p_item->select(p_col); +} + +void Tree::_accessibility_action_blur(const Variant &p_data, TreeItem *p_item, int p_col) { + p_item->deselect(p_col); +} + +void Tree::_accessibility_action_collapse(const Variant &p_data, TreeItem *p_item) { + p_item->set_collapsed(true); +} + +void Tree::_accessibility_action_expand(const Variant &p_data, TreeItem *p_item) { + p_item->set_collapsed(false); +} + +void Tree::_accessibility_action_set_text_value(const Variant &p_data, TreeItem *p_item, int p_col) { + p_item->set_text(p_col, p_data); +} + +void Tree::_accessibility_action_set_num_value(const Variant &p_data, TreeItem *p_item, int p_col) { + p_item->set_range(p_col, p_data); +} + +void Tree::_accessibility_action_set_bool_value(const Variant &p_data, TreeItem *p_item, int p_col) { + p_item->set_checked(p_col, !p_item->cells[p_col].checked); +} + +void Tree::_accessibility_action_edit_custom(const Variant &p_data, TreeItem *p_item, int p_col) { + float popup_scale = popup_editor->is_embedded() ? 1.0 : popup_editor->get_parent_visible_window()->get_content_scale_factor(); + Rect2 rect; + if (select_mode == SELECT_ROW) { + rect = p_item->get_meta("__focus_col_" + itos(p_col)); + } else { + rect = p_item->get_meta("__focus_rect"); + } + rect.position *= popup_scale; + + edited_item = p_item; + edited_col = p_col; + custom_popup_rect = Rect2i(get_global_position() + rect.position, rect.size); + emit_signal(SNAME("custom_popup_edited"), false); + item_edited(p_col, p_item); +} + +void Tree::_accessibility_action_set_inc(const Variant &p_data, TreeItem *p_item, int p_col) { + p_item->set_range(p_col, p_item->cells[p_col].val + p_item->cells[p_col].step); +} + +void Tree::_accessibility_action_set_dec(const Variant &p_data, TreeItem *p_item, int p_col) { + p_item->set_range(p_col, p_item->cells[p_col].val - p_item->cells[p_col].step); +} + +void Tree::_accessibility_action_button_press(const Variant &p_data, TreeItem *p_item, int p_col, int p_btn) { + emit_signal("button_clicked", p_item, p_col, p_btn, MouseButton::LEFT); +} + +RID Tree::get_focused_accessibility_element() const { + if (selected_item) { + if (selected_col >= 0) { + if (selected_button >= 0) { + return selected_item->cells[selected_col].buttons[selected_button].accessibility_button_element; + } else { + return selected_item->cells[selected_col].accessibility_cell_element; + } + } else { + return selected_item->accessibility_row_element; + } + } else { + return get_accessibility_element(); + } +} + +void Tree::_accessibility_clean_info(TreeItem *p_item) { + p_item->accessibility_row_element = RID(); + for (TreeItem::Cell &cell : p_item->cells) { + cell.accessibility_cell_element = RID(); + for (TreeItem::Cell::Button &btn : cell.buttons) { + btn.accessibility_button_element = RID(); + } + } + + // Children. + TreeItem *c = p_item->first_child; + while (c) { + _accessibility_clean_info(c); + c = c->next; + } +} + +void Tree::_accessibility_update_item(Point2 &r_ofs, TreeItem *p_item, int &r_row, int p_level) { + // Row. + if ((p_item != root || !hide_root) && p_item->is_visible()) { + if (p_item->accessibility_row_element.is_null()) { + p_item->accessibility_row_element = DisplayServer::get_singleton()->accessibility_create_sub_element(accessibility_scroll_element, DisplayServer::AccessibilityRole::ROLE_TREE_ITEM); + p_item->accessibility_row_dirty = true; + } + + DisplayServer::get_singleton()->accessibility_update_set_table_row_index(p_item->accessibility_row_element, r_row); + DisplayServer::get_singleton()->accessibility_update_set_list_item_level(p_item->accessibility_row_element, p_level); + DisplayServer::get_singleton()->accessibility_update_set_list_item_expanded(p_item->accessibility_row_element, !p_item->collapsed); + DisplayServer::get_singleton()->accessibility_update_set_flag(p_item->accessibility_row_element, DisplayServer::AccessibilityFlags::FLAG_HIDDEN, !(p_item->visible && !p_item->parent_visible_in_tree)); + DisplayServer::get_singleton()->accessibility_update_add_action(p_item->accessibility_row_element, DisplayServer::AccessibilityAction::ACTION_COLLAPSE, callable_mp(this, &Tree::_accessibility_action_collapse).bind(p_item)); + DisplayServer::get_singleton()->accessibility_update_add_action(p_item->accessibility_row_element, DisplayServer::AccessibilityAction::ACTION_EXPAND, callable_mp(this, &Tree::_accessibility_action_expand).bind(p_item)); + + DisplayServer::get_singleton()->accessibility_update_set_list_item_selected(p_item->accessibility_row_element, selected_item == p_item); + if (p_item == root && is_root_hidden()) { + DisplayServer::get_singleton()->accessibility_update_set_flag(p_item->accessibility_row_element, DisplayServer::AccessibilityFlags::FLAG_HIDDEN, true); + } + Transform2D row_xform; + row_xform.set_origin(r_ofs); + DisplayServer::get_singleton()->accessibility_update_set_transform(p_item->accessibility_row_element, row_xform); + + Size2 item_size = Size2(get_size().width, compute_item_height(p_item)); + DisplayServer::get_singleton()->accessibility_update_set_bounds(p_item->accessibility_row_element, Rect2(Vector2(), item_size)); + + if (p_item->accessibility_row_dirty) { + // Cells. + int col_offset = 0; + for (int i = 0; i < p_item->cells.size(); i++) { + TreeItem::Cell &cell = p_item->cells.write[i]; + + if (cell.accessibility_cell_element.is_null()) { + cell.accessibility_cell_element = DisplayServer::get_singleton()->accessibility_create_sub_element(p_item->accessibility_row_element, DisplayServer::AccessibilityRole::ROLE_CELL); + } + + float cw = get_column_width(i); + + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_SCROLL_INTO_VIEW, callable_mp(this, &Tree::_accessibility_action_scroll_into_view).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_FOCUS, callable_mp(this, &Tree::_accessibility_action_focus).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_BLUR, callable_mp(this, &Tree::_accessibility_action_blur).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_COLLAPSE, callable_mp(this, &Tree::_accessibility_action_collapse).bind(p_item)); + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_EXPAND, callable_mp(this, &Tree::_accessibility_action_expand).bind(p_item)); + + DisplayServer::get_singleton()->accessibility_update_set_table_cell_position(cell.accessibility_cell_element, r_row, i); + DisplayServer::get_singleton()->accessibility_update_set_list_item_selected(cell.accessibility_cell_element, cell.selected); + if (cell.alt_text.is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_name(cell.accessibility_cell_element, cell.xl_text); + } else { + DisplayServer::get_singleton()->accessibility_update_set_name(cell.accessibility_cell_element, cell.alt_text); + } + + DisplayServer::get_singleton()->accessibility_update_set_text_align(cell.accessibility_cell_element, cell.text_alignment); + DisplayServer::get_singleton()->accessibility_update_set_flag(cell.accessibility_cell_element, DisplayServer::AccessibilityFlags::FLAG_HIDDEN, !(p_item->visible && !p_item->parent_visible_in_tree)); + DisplayServer::get_singleton()->accessibility_update_set_flag(cell.accessibility_cell_element, DisplayServer::AccessibilityFlags::FLAG_READONLY, !cell.editable); + DisplayServer::get_singleton()->accessibility_update_set_tooltip(cell.accessibility_cell_element, cell.tooltip); + switch (cell.mode) { + case TreeItem::CELL_MODE_STRING: { + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_SET_VALUE, callable_mp(this, &Tree::_accessibility_action_set_text_value).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_set_value(cell.accessibility_cell_element, cell.xl_text); + } break; + case TreeItem::CELL_MODE_CHECK: { + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &Tree::_accessibility_action_set_bool_value).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_set_checked(cell.accessibility_cell_element, cell.checked); + } break; + case TreeItem::CELL_MODE_RANGE: { + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_DECREMENT, callable_mp(this, &Tree::_accessibility_action_set_dec).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_INCREMENT, callable_mp(this, &Tree::_accessibility_action_set_inc).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_SET_VALUE, callable_mp(this, &Tree::_accessibility_action_set_num_value).bind(p_item, i)); + DisplayServer::get_singleton()->accessibility_update_set_num_value(cell.accessibility_cell_element, cell.val); + DisplayServer::get_singleton()->accessibility_update_set_num_range(cell.accessibility_cell_element, cell.min, cell.max); + if (cell.step > 0) { + DisplayServer::get_singleton()->accessibility_update_set_num_step(cell.accessibility_cell_element, cell.step); + } else { + DisplayServer::get_singleton()->accessibility_update_set_num_step(cell.accessibility_cell_element, 1); + } + } break; + case TreeItem::CELL_MODE_ICON: { + // NOP + } break; + case TreeItem::CELL_MODE_CUSTOM: { + DisplayServer::get_singleton()->accessibility_update_add_action(cell.accessibility_cell_element, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &Tree::_accessibility_action_edit_custom).bind(p_item, i)); + } break; + } + DisplayServer::get_singleton()->accessibility_update_set_background_color(cell.accessibility_cell_element, cell.color); + DisplayServer::get_singleton()->accessibility_update_set_foreground_color(cell.accessibility_cell_element, cell.bg_color); + + DisplayServer::get_singleton()->accessibility_update_set_bounds(cell.accessibility_cell_element, Rect2(Point2(col_offset, 0), Size2(cw, item_size.y))); + + Vector2 ofst = Vector2(col_offset + cw, 0); + for (int j = cell.buttons.size() - 1; j >= 0; j--) { + if (cell.buttons[j].accessibility_button_element.is_null()) { + cell.buttons[j].accessibility_button_element = DisplayServer::get_singleton()->accessibility_create_sub_element(cell.accessibility_cell_element, DisplayServer::AccessibilityRole::ROLE_BUTTON); + } + + DisplayServer::get_singleton()->accessibility_update_add_action(cell.buttons[j].accessibility_button_element, DisplayServer::AccessibilityAction::ACTION_CLICK, callable_mp(this, &Tree::_accessibility_action_button_press).bind(p_item, i, j)); + DisplayServer::get_singleton()->accessibility_update_set_flag(cell.buttons[j].accessibility_button_element, DisplayServer::AccessibilityFlags::FLAG_DISABLED, cell.buttons[j].disabled); + DisplayServer::get_singleton()->accessibility_update_set_tooltip(cell.buttons[j].accessibility_button_element, cell.buttons[j].tooltip); + if (cell.buttons[j].alt_text.is_empty()) { + DisplayServer::get_singleton()->accessibility_update_set_name(cell.buttons[j].accessibility_button_element, cell.buttons[j].tooltip); + } else { + DisplayServer::get_singleton()->accessibility_update_set_name(cell.buttons[j].accessibility_button_element, cell.buttons[j].alt_text); + } + + Ref b = cell.buttons[j].texture; + Size2 b_size = b->get_size() + theme_cache.button_pressed->get_minimum_size(); + ofst.x -= b_size.x; + + DisplayServer::get_singleton()->accessibility_update_set_bounds(cell.buttons[j].accessibility_button_element, Rect2(ofst, b_size)); + } + col_offset += cw; + } + } + + r_ofs.y += item_size.y; + r_ofs.y += theme_cache.v_separation; + + p_item->accessibility_row_dirty = false; + r_row++; + } + + // Children. + if (!p_item->collapsed) { + TreeItem *c = p_item->first_child; + while (c) { + _accessibility_update_item(r_ofs, c, r_row, p_level + 1); + c = c->next; + } + } +} + void Tree::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_EXIT_TREE: + case NOTIFICATION_ACCESSIBILITY_INVALIDATE: { + if (root) { + _accessibility_clean_info(root); + } + for (ColumnInfo &col : columns) { + col.accessibility_col_element = RID(); + } + accessibility_scroll_element = RID(); + } break; + + case NOTIFICATION_ACCESSIBILITY_UPDATE: { + RID ae = get_accessibility_element(); + ERR_FAIL_COND(ae.is_null()); + + DisplayServer::get_singleton()->accessibility_update_set_role(ae, DisplayServer::AccessibilityRole::ROLE_TREE); + + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_DOWN, callable_mp(this, &Tree::_accessibility_action_scroll_down)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_LEFT, callable_mp(this, &Tree::_accessibility_action_scroll_left)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_RIGHT, callable_mp(this, &Tree::_accessibility_action_scroll_right)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SCROLL_UP, callable_mp(this, &Tree::_accessibility_action_scroll_up)); + DisplayServer::get_singleton()->accessibility_update_add_action(ae, DisplayServer::AccessibilityAction::ACTION_SET_SCROLL_OFFSET, callable_mp(this, &Tree::_accessibility_action_scroll_set)); + + Ref bg = theme_cache.panel_style; + int tbh = _get_title_button_height(); + + // Columns. + int ofs = theme_cache.panel_style->get_margin(SIDE_LEFT); + int cs = columns.size(); + for (int i = 0; i < cs; i++) { + ColumnInfo &column = columns.write[i]; + + if (column.accessibility_col_element.is_null()) { + column.accessibility_col_element = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_COLUMN_HEADER); + } + + DisplayServer::get_singleton()->accessibility_update_set_table_column_index(column.accessibility_col_element, i); + DisplayServer::get_singleton()->accessibility_update_set_name(column.accessibility_col_element, column.xl_title); + DisplayServer::get_singleton()->accessibility_update_set_text_align(column.accessibility_col_element, column.title_alignment); + + Rect2 tbrect = Rect2(ofs - theme_cache.offset.x, bg->get_margin(SIDE_TOP), get_column_width(i), tbh); + if (cache.rtl) { + tbrect.position.x = get_size().width - tbrect.size.x - tbrect.position.x; + } + ofs += tbrect.size.width; + DisplayServer::get_singleton()->accessibility_update_set_bounds(column.accessibility_col_element, Rect2(tbrect.position, tbrect.size)); + } + + DisplayServer::get_singleton()->accessibility_update_set_table_column_count(ae, cs); + + // Scroll container. + if (accessibility_scroll_element.is_null()) { + accessibility_scroll_element = DisplayServer::get_singleton()->accessibility_create_sub_element(ae, DisplayServer::AccessibilityRole::ROLE_CONTAINER); + } + + Transform2D scroll_xform; + scroll_xform.set_origin(Vector2i(-h_scroll->get_value(), -v_scroll->get_value())); + DisplayServer::get_singleton()->accessibility_update_set_transform(accessibility_scroll_element, scroll_xform); + DisplayServer::get_singleton()->accessibility_update_set_bounds(accessibility_scroll_element, Rect2(0, 0, h_scroll->get_max(), v_scroll->get_max())); + + // Rows (and cells). + Point2 origin = Point2(theme_cache.panel_style->get_margin(SIDE_LEFT) - theme_cache.offset.x, bg->get_margin(SIDE_TOP) + tbh); + int rows = 0; + if (root) { + _accessibility_update_item(origin, root, rows, 0); + } + DisplayServer::get_singleton()->accessibility_update_set_table_row_count(ae, rows); + + } break; + case NOTIFICATION_FOCUS_ENTER: { if (get_viewport()) { focus_in_id = get_viewport()->get_processed_events_count(); @@ -4565,6 +5044,7 @@ TreeItem *Tree::create_item(TreeItem *p_parent, int p_index) { _determine_hovered_item(); + queue_accessibility_update(); return ti; } @@ -4592,6 +5072,7 @@ void Tree::item_edited(int p_column, TreeItem *p_item, MouseButton p_custom_mous if (p_custom_mouse_index != MouseButton::NONE) { emit_signal(SNAME("custom_item_clicked"), p_custom_mouse_index); } + queue_accessibility_update(); } void Tree::item_changed(int p_column, TreeItem *p_item) { @@ -4605,7 +5086,9 @@ void Tree::item_changed(int p_column, TreeItem *p_item) { columns.write[i].cached_minimum_width_dirty = true; } } + p_item->accessibility_row_dirty = true; } + queue_accessibility_update(); queue_redraw(); } @@ -4620,9 +5103,12 @@ void Tree::item_selected(int p_column, TreeItem *p_item) { selected_col = p_column; selected_item = p_item; + selected_button = -1; } else { select_single_item(p_item, root, p_column); } + p_item->accessibility_row_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -4641,6 +5127,7 @@ void Tree::item_deselected(int p_column, TreeItem *p_item) { } } } + selected_button = -1; if (select_mode == SELECT_MULTI || select_mode == SELECT_SINGLE) { p_item->cells.write[p_column].selected = false; @@ -4649,6 +5136,8 @@ void Tree::item_deselected(int p_column, TreeItem *p_item) { p_item->cells.write[i].selected = false; } } + p_item->accessibility_row_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -4679,7 +5168,8 @@ void Tree::deselect_all() { selected_item = nullptr; selected_col = -1; - + selected_button = -1; + queue_accessibility_update(); queue_redraw(); } @@ -4711,6 +5201,7 @@ void Tree::clear() { _determine_hovered_item(); + queue_accessibility_update(); queue_redraw(); } @@ -4720,6 +5211,7 @@ void Tree::set_hide_root(bool p_enabled) { } hide_root = p_enabled; + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -4740,6 +5232,7 @@ void Tree::set_column_custom_minimum_width(int p_column, int p_min_width) { } columns.write[p_column].custom_min_width = p_min_width; columns.write[p_column].cached_minimum_width_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -4752,6 +5245,7 @@ void Tree::set_column_expand(int p_column, bool p_expand) { columns.write[p_column].expand = p_expand; columns.write[p_column].cached_minimum_width_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -4764,6 +5258,7 @@ void Tree::set_column_expand_ratio(int p_column, int p_ratio) { columns.write[p_column].expand_ratio = p_ratio; columns.write[p_column].cached_minimum_width_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -4776,6 +5271,7 @@ void Tree::set_column_clip_content(int p_column, bool p_fit) { columns.write[p_column].clip_content = p_fit; columns.write[p_column].cached_minimum_width_dirty = true; + queue_accessibility_update(); queue_redraw(); } @@ -4936,6 +5432,19 @@ int Tree::get_column_width(int p_column) const { void Tree::propagate_set_columns(TreeItem *p_item) { p_item->cells.resize(columns.size()); + p_item->accessibility_row_dirty = true; + for (TreeItem::Cell &cell : p_item->cells) { + if (cell.accessibility_cell_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(cell.accessibility_cell_element); + cell.accessibility_cell_element = RID(); + } + for (TreeItem::Cell::Button &btn : cell.buttons) { + if (btn.accessibility_button_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(btn.accessibility_button_element); + btn.accessibility_button_element = RID(); + } + } + } TreeItem *c = p_item->get_first_child(); while (c) { @@ -4947,6 +5456,16 @@ void Tree::propagate_set_columns(TreeItem *p_item) { void Tree::set_columns(int p_columns) { ERR_FAIL_COND(p_columns < 1); ERR_FAIL_COND(blocked > 0); + + if (columns.size() > p_columns) { + for (int i = p_columns; i < columns.size(); i++) { + if (columns[i].accessibility_col_element.is_valid()) { + DisplayServer::get_singleton()->accessibility_free_element(columns[i].accessibility_col_element); + columns.write[i].accessibility_col_element = RID(); + } + } + } + columns.resize(p_columns); if (root) { @@ -4954,7 +5473,9 @@ void Tree::set_columns(int p_columns) { } if (selected_col >= p_columns) { selected_col = p_columns - 1; + selected_button = -1; } + queue_accessibility_update(); queue_redraw(); } @@ -5053,6 +5574,8 @@ void Tree::ensure_cursor_is_visible() { h_scroll->set_value(x_offset); } } + + queue_accessibility_update(); } int Tree::get_pressed_button() const { @@ -5139,6 +5662,7 @@ void Tree::set_column_titles_visible(bool p_show) { } show_column_titles = p_show; + queue_accessibility_update(); queue_redraw(); update_minimum_size(); } @@ -5157,6 +5681,7 @@ void Tree::set_column_title(int p_column, const String &p_title) { columns.write[p_column].title = p_title; columns.write[p_column].xl_title = atr(p_title); update_column(p_column); + queue_accessibility_update(); queue_redraw(); } @@ -5178,6 +5703,7 @@ void Tree::set_column_title_alignment(int p_column, HorizontalAlignment p_alignm columns.write[p_column].title_alignment = p_alignment; update_column(p_column); + queue_accessibility_update(); queue_redraw(); } @@ -5192,6 +5718,7 @@ void Tree::set_column_title_direction(int p_column, Control::TextDirection p_tex if (columns[p_column].text_direction != p_text_direction) { columns.write[p_column].text_direction = p_text_direction; update_column(p_column); + queue_accessibility_update(); queue_redraw(); } } @@ -5206,6 +5733,7 @@ void Tree::set_column_title_language(int p_column, const String &p_language) { if (columns[p_column].language != p_language) { columns.write[p_column].language = p_language; update_column(p_column); + queue_accessibility_update(); queue_redraw(); } } @@ -5256,6 +5784,7 @@ void Tree::scroll_to_item(TreeItem *p_item, bool p_center_on_item) { } } } + queue_accessibility_update(); } void Tree::set_h_scroll_enabled(bool p_enable) { @@ -5694,18 +6223,29 @@ TreeItem *Tree::get_item_at_position(const Point2 &p_pos) const { } int Tree::get_button_id_at_position(const Point2 &p_pos) const { - if (!root || !Rect2(Vector2(), get_size()).has_point(p_pos)) { + if (!root) { return -1; } - TreeItem *it; - int col, index, section; - _find_button_at_pos(p_pos, it, col, index, section); + if (p_pos == Vector2(INFINITY, INFINITY)) { + if (selected_item && selected_button >= 0) { + return selected_item->cells[selected_col].buttons[selected_button].id; + } + } else { + if (!Rect2(Vector2(), get_size()).has_point(p_pos)) { + return -1; + } - if (index == -1) { - return -1; + TreeItem *it; + int col, index, section; + _find_button_at_pos(p_pos, it, col, index, section); + + if (index == -1) { + return -1; + } + return it->cells[col].buttons[index].id; } - return it->cells[col].buttons[index].id; + return -1; } String Tree::get_tooltip(const Point2 &p_pos) const { diff --git a/scene/gui/tree.h b/scene/gui/tree.h index 784c264663bd..979b7ac2da3a 100644 --- a/scene/gui/tree.h +++ b/scene/gui/tree.h @@ -56,6 +56,7 @@ class TreeItem : public Object { friend class Tree; struct Cell { + mutable RID accessibility_cell_element; TreeCellMode mode = TreeItem::CELL_MODE_STRING; Ref icon; @@ -64,6 +65,7 @@ class TreeItem : public Object { String text; String xl_text; Node::AutoTranslateMode auto_translate_mode = Node::AUTO_TRANSLATE_MODE_INHERIT; + String alt_text; bool edit_multiline = false; String suffix; Ref text_buf; @@ -104,11 +106,13 @@ class TreeItem : public Object { Callable custom_draw_callback; struct Button { + mutable RID accessibility_button_element; int id = 0; bool disabled = false; Ref texture; Color color = Color(1, 1, 1, 1); String tooltip; + String alt_text; }; Vector