pax_global_header00006660000000000000000000000064146750615100014517gustar00rootroot0000000000000052 comment=13a53e1a48e34f5fc46e5e7f96ab4cff1f758197 rust-atk-sys-0.18-0.18.0/000077500000000000000000000000001467506151000145575ustar00rootroot00000000000000rust-atk-sys-0.18-0.18.0/.cargo_vcs_info.json000066400000000000000000000001451467506151000205110ustar00rootroot00000000000000{ "git": { "sha1": "3ec2253489cded691d0ac63cba492c379287ee9a" }, "path_in_vcs": "atk/sys" }rust-atk-sys-0.18-0.18.0/Cargo.toml000066400000000000000000000034621467506151000165140ustar00rootroot00000000000000# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" rust-version = "1.70" name = "atk-sys" version = "0.18.0" authors = ["The gtk-rs Project Developers"] build = "build.rs" links = "atk-1.0" description = "FFI bindings to libatk-1" homepage = "https://gtk-rs.org/" keywords = [ "atk", "ffi", "gtk-rs", "gnome", ] license = "MIT" repository = "https://github.com/gtk-rs/gtk3-rs" resolver = "1" [package.metadata.docs.rs] features = [] rustc-args = [ "--cfg", "docsrs", ] rustdoc-args = [ "--cfg", "docsrs", ] [package.metadata.system-deps.atk] name = "atk" version = "2.28" [package.metadata.system-deps.atk.v2_30] version = "2.30" [package.metadata.system-deps.atk.v2_32] version = "2.32" [package.metadata.system-deps.atk.v2_34] version = "2.34" [package.metadata.system-deps.atk.v2_38] version = "2.38" [package.metadata.system-deps.atk.v2_46] version = "2.46" [package.metadata.system-deps.atk.v2_50] version = "2.50" [lib] name = "atk_sys" [dependencies.glib] version = "0.18" package = "glib-sys" [dependencies.gobject] version = "0.18" package = "gobject-sys" [dependencies.libc] version = "0.2" [dev-dependencies.shell-words] version = "1.0.0" [dev-dependencies.tempfile] version = "3" [build-dependencies.system-deps] version = "6" [features] v2_30 = [] v2_32 = ["v2_30"] v2_34 = ["v2_32"] v2_38 = ["v2_34"] v2_46 = ["v2_38"] v2_50 = ["v2_46"] rust-atk-sys-0.18-0.18.0/Cargo.toml.orig000066400000000000000000000025571467506151000174570ustar00rootroot00000000000000[build-dependencies] system-deps = "6" [dependencies] libc = "0.2" [dependencies.glib] package = "glib-sys" version = "0.18" branch = "0.18" git = "https://github.com/gtk-rs/gtk-rs-core" [dependencies.gobject] package = "gobject-sys" version = "0.18" branch = "0.18" git = "https://github.com/gtk-rs/gtk-rs-core" [dev-dependencies] shell-words = "1.0.0" tempfile = "3" [features] v2_30 = [] v2_32 = ["v2_30"] v2_34 = ["v2_32"] v2_38 = ["v2_34"] v2_46 = ["v2_38"] v2_50 = ["v2_46"] [lib] name = "atk_sys" [package] authors = ["The gtk-rs Project Developers"] build = "build.rs" description = "FFI bindings to libatk-1" homepage = "https://gtk-rs.org/" keywords = ["atk", "ffi", "gtk-rs", "gnome"] license = "MIT" links = "atk-1.0" name = "atk-sys" repository = "https://github.com/gtk-rs/gtk3-rs" version = "0.18.0" edition = "2021" rust-version = "1.70" [package.metadata.docs.rs] rustdoc-args = ["--cfg", "docsrs"] features = [] rustc-args = ["--cfg", "docsrs"] [package.metadata.system-deps.atk] name = "atk" version = "2.28" [package.metadata.system-deps.atk.v2_30] version = "2.30" [package.metadata.system-deps.atk.v2_32] version = "2.32" [package.metadata.system-deps.atk.v2_34] version = "2.34" [package.metadata.system-deps.atk.v2_38] version = "2.38" [package.metadata.system-deps.atk.v2_46] version = "2.46" [package.metadata.system-deps.atk.v2_50] version = "2.50" rust-atk-sys-0.18-0.18.0/Gir.toml000066400000000000000000000012701467506151000161750ustar00rootroot00000000000000[options] work_mode = "sys" library = "Atk" version = "1.0" min_cfg_version = "2.28" single_version_file = "." girs_directories = ["../../gir-files"] external_libraries = [ "GLib", "GObject", ] ignore = [ "Atk.BINARY_AGE", "Atk.INTERFACE_AGE", "Atk.MAJOR_VERSION", "Atk.MICRO_VERSION", "Atk.MINOR_VERSION", "Atk.VERSION_MIN_REQUIRED", ] extra_versions = [ "2.38" ] [[object]] name = "Atk.Live" status = "generate" version = "2.50" [[object]] name = "Atk.StateType" status = "generate" [[object.member]] name = "collapsed" version = "2.38" [[object.member]] name = "last_defined" alias = true # not useful and should fix -sys tests rust-atk-sys-0.18-0.18.0/LICENSE000066400000000000000000000020001467506151000155540ustar00rootroot00000000000000Permission 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. rust-atk-sys-0.18-0.18.0/build.rs000066400000000000000000000006541467506151000162310ustar00rootroot00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT #[cfg(not(docsrs))] use std::process; #[cfg(docsrs)] fn main() {} // prevent linking libraries to avoid documentation failure #[cfg(not(docsrs))] fn main() { if let Err(s) = system_deps::Config::new().probe() { println!("cargo:warning={s}"); process::exit(1); } } rust-atk-sys-0.18-0.18.0/src/000077500000000000000000000000001467506151000153465ustar00rootroot00000000000000rust-atk-sys-0.18-0.18.0/src/lib.rs000066400000000000000000003234211467506151000164670ustar00rootroot00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT #![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] #![allow( clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms )] #![cfg_attr(docsrs, feature(doc_cfg))] #[allow(unused_imports)] use libc::{ c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void, intptr_t, size_t, ssize_t, uintptr_t, FILE, }; #[allow(unused_imports)] use glib::{gboolean, gconstpointer, gpointer, GType}; // Aliases pub type AtkAttributeSet = glib::GSList; pub type AtkState = u64; // Enums pub type AtkCoordType = c_int; pub const ATK_XY_SCREEN: AtkCoordType = 0; pub const ATK_XY_WINDOW: AtkCoordType = 1; pub const ATK_XY_PARENT: AtkCoordType = 2; pub type AtkKeyEventType = c_int; pub const ATK_KEY_EVENT_PRESS: AtkKeyEventType = 0; pub const ATK_KEY_EVENT_RELEASE: AtkKeyEventType = 1; pub const ATK_KEY_EVENT_LAST_DEFINED: AtkKeyEventType = 2; pub type AtkLayer = c_int; pub const ATK_LAYER_INVALID: AtkLayer = 0; pub const ATK_LAYER_BACKGROUND: AtkLayer = 1; pub const ATK_LAYER_CANVAS: AtkLayer = 2; pub const ATK_LAYER_WIDGET: AtkLayer = 3; pub const ATK_LAYER_MDI: AtkLayer = 4; pub const ATK_LAYER_POPUP: AtkLayer = 5; pub const ATK_LAYER_OVERLAY: AtkLayer = 6; pub const ATK_LAYER_WINDOW: AtkLayer = 7; pub type AtkLive = c_int; pub const ATK_LIVE_NONE: AtkLive = 0; pub const ATK_LIVE_POLITE: AtkLive = 1; pub const ATK_LIVE_ASSERTIVE: AtkLive = 2; pub type AtkRelationType = c_int; pub const ATK_RELATION_NULL: AtkRelationType = 0; pub const ATK_RELATION_CONTROLLED_BY: AtkRelationType = 1; pub const ATK_RELATION_CONTROLLER_FOR: AtkRelationType = 2; pub const ATK_RELATION_LABEL_FOR: AtkRelationType = 3; pub const ATK_RELATION_LABELLED_BY: AtkRelationType = 4; pub const ATK_RELATION_MEMBER_OF: AtkRelationType = 5; pub const ATK_RELATION_NODE_CHILD_OF: AtkRelationType = 6; pub const ATK_RELATION_FLOWS_TO: AtkRelationType = 7; pub const ATK_RELATION_FLOWS_FROM: AtkRelationType = 8; pub const ATK_RELATION_SUBWINDOW_OF: AtkRelationType = 9; pub const ATK_RELATION_EMBEDS: AtkRelationType = 10; pub const ATK_RELATION_EMBEDDED_BY: AtkRelationType = 11; pub const ATK_RELATION_POPUP_FOR: AtkRelationType = 12; pub const ATK_RELATION_PARENT_WINDOW_OF: AtkRelationType = 13; pub const ATK_RELATION_DESCRIBED_BY: AtkRelationType = 14; pub const ATK_RELATION_DESCRIPTION_FOR: AtkRelationType = 15; pub const ATK_RELATION_NODE_PARENT_OF: AtkRelationType = 16; pub const ATK_RELATION_DETAILS: AtkRelationType = 17; pub const ATK_RELATION_DETAILS_FOR: AtkRelationType = 18; pub const ATK_RELATION_ERROR_MESSAGE: AtkRelationType = 19; pub const ATK_RELATION_ERROR_FOR: AtkRelationType = 20; pub const ATK_RELATION_LAST_DEFINED: AtkRelationType = 21; pub type AtkRole = c_int; pub const ATK_ROLE_INVALID: AtkRole = 0; pub const ATK_ROLE_ACCEL_LABEL: AtkRole = 1; pub const ATK_ROLE_ALERT: AtkRole = 2; pub const ATK_ROLE_ANIMATION: AtkRole = 3; pub const ATK_ROLE_ARROW: AtkRole = 4; pub const ATK_ROLE_CALENDAR: AtkRole = 5; pub const ATK_ROLE_CANVAS: AtkRole = 6; pub const ATK_ROLE_CHECK_BOX: AtkRole = 7; pub const ATK_ROLE_CHECK_MENU_ITEM: AtkRole = 8; pub const ATK_ROLE_COLOR_CHOOSER: AtkRole = 9; pub const ATK_ROLE_COLUMN_HEADER: AtkRole = 10; pub const ATK_ROLE_COMBO_BOX: AtkRole = 11; pub const ATK_ROLE_DATE_EDITOR: AtkRole = 12; pub const ATK_ROLE_DESKTOP_ICON: AtkRole = 13; pub const ATK_ROLE_DESKTOP_FRAME: AtkRole = 14; pub const ATK_ROLE_DIAL: AtkRole = 15; pub const ATK_ROLE_DIALOG: AtkRole = 16; pub const ATK_ROLE_DIRECTORY_PANE: AtkRole = 17; pub const ATK_ROLE_DRAWING_AREA: AtkRole = 18; pub const ATK_ROLE_FILE_CHOOSER: AtkRole = 19; pub const ATK_ROLE_FILLER: AtkRole = 20; pub const ATK_ROLE_FONT_CHOOSER: AtkRole = 21; pub const ATK_ROLE_FRAME: AtkRole = 22; pub const ATK_ROLE_GLASS_PANE: AtkRole = 23; pub const ATK_ROLE_HTML_CONTAINER: AtkRole = 24; pub const ATK_ROLE_ICON: AtkRole = 25; pub const ATK_ROLE_IMAGE: AtkRole = 26; pub const ATK_ROLE_INTERNAL_FRAME: AtkRole = 27; pub const ATK_ROLE_LABEL: AtkRole = 28; pub const ATK_ROLE_LAYERED_PANE: AtkRole = 29; pub const ATK_ROLE_LIST: AtkRole = 30; pub const ATK_ROLE_LIST_ITEM: AtkRole = 31; pub const ATK_ROLE_MENU: AtkRole = 32; pub const ATK_ROLE_MENU_BAR: AtkRole = 33; pub const ATK_ROLE_MENU_ITEM: AtkRole = 34; pub const ATK_ROLE_OPTION_PANE: AtkRole = 35; pub const ATK_ROLE_PAGE_TAB: AtkRole = 36; pub const ATK_ROLE_PAGE_TAB_LIST: AtkRole = 37; pub const ATK_ROLE_PANEL: AtkRole = 38; pub const ATK_ROLE_PASSWORD_TEXT: AtkRole = 39; pub const ATK_ROLE_POPUP_MENU: AtkRole = 40; pub const ATK_ROLE_PROGRESS_BAR: AtkRole = 41; pub const ATK_ROLE_PUSH_BUTTON: AtkRole = 42; pub const ATK_ROLE_RADIO_BUTTON: AtkRole = 43; pub const ATK_ROLE_RADIO_MENU_ITEM: AtkRole = 44; pub const ATK_ROLE_ROOT_PANE: AtkRole = 45; pub const ATK_ROLE_ROW_HEADER: AtkRole = 46; pub const ATK_ROLE_SCROLL_BAR: AtkRole = 47; pub const ATK_ROLE_SCROLL_PANE: AtkRole = 48; pub const ATK_ROLE_SEPARATOR: AtkRole = 49; pub const ATK_ROLE_SLIDER: AtkRole = 50; pub const ATK_ROLE_SPLIT_PANE: AtkRole = 51; pub const ATK_ROLE_SPIN_BUTTON: AtkRole = 52; pub const ATK_ROLE_STATUSBAR: AtkRole = 53; pub const ATK_ROLE_TABLE: AtkRole = 54; pub const ATK_ROLE_TABLE_CELL: AtkRole = 55; pub const ATK_ROLE_TABLE_COLUMN_HEADER: AtkRole = 56; pub const ATK_ROLE_TABLE_ROW_HEADER: AtkRole = 57; pub const ATK_ROLE_TEAR_OFF_MENU_ITEM: AtkRole = 58; pub const ATK_ROLE_TERMINAL: AtkRole = 59; pub const ATK_ROLE_TEXT: AtkRole = 60; pub const ATK_ROLE_TOGGLE_BUTTON: AtkRole = 61; pub const ATK_ROLE_TOOL_BAR: AtkRole = 62; pub const ATK_ROLE_TOOL_TIP: AtkRole = 63; pub const ATK_ROLE_TREE: AtkRole = 64; pub const ATK_ROLE_TREE_TABLE: AtkRole = 65; pub const ATK_ROLE_UNKNOWN: AtkRole = 66; pub const ATK_ROLE_VIEWPORT: AtkRole = 67; pub const ATK_ROLE_WINDOW: AtkRole = 68; pub const ATK_ROLE_HEADER: AtkRole = 69; pub const ATK_ROLE_FOOTER: AtkRole = 70; pub const ATK_ROLE_PARAGRAPH: AtkRole = 71; pub const ATK_ROLE_RULER: AtkRole = 72; pub const ATK_ROLE_APPLICATION: AtkRole = 73; pub const ATK_ROLE_AUTOCOMPLETE: AtkRole = 74; pub const ATK_ROLE_EDITBAR: AtkRole = 75; pub const ATK_ROLE_EMBEDDED: AtkRole = 76; pub const ATK_ROLE_ENTRY: AtkRole = 77; pub const ATK_ROLE_CHART: AtkRole = 78; pub const ATK_ROLE_CAPTION: AtkRole = 79; pub const ATK_ROLE_DOCUMENT_FRAME: AtkRole = 80; pub const ATK_ROLE_HEADING: AtkRole = 81; pub const ATK_ROLE_PAGE: AtkRole = 82; pub const ATK_ROLE_SECTION: AtkRole = 83; pub const ATK_ROLE_REDUNDANT_OBJECT: AtkRole = 84; pub const ATK_ROLE_FORM: AtkRole = 85; pub const ATK_ROLE_LINK: AtkRole = 86; pub const ATK_ROLE_INPUT_METHOD_WINDOW: AtkRole = 87; pub const ATK_ROLE_TABLE_ROW: AtkRole = 88; pub const ATK_ROLE_TREE_ITEM: AtkRole = 89; pub const ATK_ROLE_DOCUMENT_SPREADSHEET: AtkRole = 90; pub const ATK_ROLE_DOCUMENT_PRESENTATION: AtkRole = 91; pub const ATK_ROLE_DOCUMENT_TEXT: AtkRole = 92; pub const ATK_ROLE_DOCUMENT_WEB: AtkRole = 93; pub const ATK_ROLE_DOCUMENT_EMAIL: AtkRole = 94; pub const ATK_ROLE_COMMENT: AtkRole = 95; pub const ATK_ROLE_LIST_BOX: AtkRole = 96; pub const ATK_ROLE_GROUPING: AtkRole = 97; pub const ATK_ROLE_IMAGE_MAP: AtkRole = 98; pub const ATK_ROLE_NOTIFICATION: AtkRole = 99; pub const ATK_ROLE_INFO_BAR: AtkRole = 100; pub const ATK_ROLE_LEVEL_BAR: AtkRole = 101; pub const ATK_ROLE_TITLE_BAR: AtkRole = 102; pub const ATK_ROLE_BLOCK_QUOTE: AtkRole = 103; pub const ATK_ROLE_AUDIO: AtkRole = 104; pub const ATK_ROLE_VIDEO: AtkRole = 105; pub const ATK_ROLE_DEFINITION: AtkRole = 106; pub const ATK_ROLE_ARTICLE: AtkRole = 107; pub const ATK_ROLE_LANDMARK: AtkRole = 108; pub const ATK_ROLE_LOG: AtkRole = 109; pub const ATK_ROLE_MARQUEE: AtkRole = 110; pub const ATK_ROLE_MATH: AtkRole = 111; pub const ATK_ROLE_RATING: AtkRole = 112; pub const ATK_ROLE_TIMER: AtkRole = 113; pub const ATK_ROLE_DESCRIPTION_LIST: AtkRole = 114; pub const ATK_ROLE_DESCRIPTION_TERM: AtkRole = 115; pub const ATK_ROLE_DESCRIPTION_VALUE: AtkRole = 116; pub const ATK_ROLE_STATIC: AtkRole = 117; pub const ATK_ROLE_MATH_FRACTION: AtkRole = 118; pub const ATK_ROLE_MATH_ROOT: AtkRole = 119; pub const ATK_ROLE_SUBSCRIPT: AtkRole = 120; pub const ATK_ROLE_SUPERSCRIPT: AtkRole = 121; pub const ATK_ROLE_FOOTNOTE: AtkRole = 122; pub const ATK_ROLE_CONTENT_DELETION: AtkRole = 123; pub const ATK_ROLE_CONTENT_INSERTION: AtkRole = 124; pub const ATK_ROLE_MARK: AtkRole = 125; pub const ATK_ROLE_SUGGESTION: AtkRole = 126; pub const ATK_ROLE_PUSH_BUTTON_MENU: AtkRole = 127; pub const ATK_ROLE_LAST_DEFINED: AtkRole = 128; pub type AtkScrollType = c_int; pub const ATK_SCROLL_TOP_LEFT: AtkScrollType = 0; pub const ATK_SCROLL_BOTTOM_RIGHT: AtkScrollType = 1; pub const ATK_SCROLL_TOP_EDGE: AtkScrollType = 2; pub const ATK_SCROLL_BOTTOM_EDGE: AtkScrollType = 3; pub const ATK_SCROLL_LEFT_EDGE: AtkScrollType = 4; pub const ATK_SCROLL_RIGHT_EDGE: AtkScrollType = 5; pub const ATK_SCROLL_ANYWHERE: AtkScrollType = 6; pub type AtkStateType = c_int; pub const ATK_STATE_INVALID: AtkStateType = 0; pub const ATK_STATE_ACTIVE: AtkStateType = 1; pub const ATK_STATE_ARMED: AtkStateType = 2; pub const ATK_STATE_BUSY: AtkStateType = 3; pub const ATK_STATE_CHECKED: AtkStateType = 4; pub const ATK_STATE_DEFUNCT: AtkStateType = 5; pub const ATK_STATE_EDITABLE: AtkStateType = 6; pub const ATK_STATE_ENABLED: AtkStateType = 7; pub const ATK_STATE_EXPANDABLE: AtkStateType = 8; pub const ATK_STATE_EXPANDED: AtkStateType = 9; pub const ATK_STATE_FOCUSABLE: AtkStateType = 10; pub const ATK_STATE_FOCUSED: AtkStateType = 11; pub const ATK_STATE_HORIZONTAL: AtkStateType = 12; pub const ATK_STATE_ICONIFIED: AtkStateType = 13; pub const ATK_STATE_MODAL: AtkStateType = 14; pub const ATK_STATE_MULTI_LINE: AtkStateType = 15; pub const ATK_STATE_MULTISELECTABLE: AtkStateType = 16; pub const ATK_STATE_OPAQUE: AtkStateType = 17; pub const ATK_STATE_PRESSED: AtkStateType = 18; pub const ATK_STATE_RESIZABLE: AtkStateType = 19; pub const ATK_STATE_SELECTABLE: AtkStateType = 20; pub const ATK_STATE_SELECTED: AtkStateType = 21; pub const ATK_STATE_SENSITIVE: AtkStateType = 22; pub const ATK_STATE_SHOWING: AtkStateType = 23; pub const ATK_STATE_SINGLE_LINE: AtkStateType = 24; pub const ATK_STATE_STALE: AtkStateType = 25; pub const ATK_STATE_TRANSIENT: AtkStateType = 26; pub const ATK_STATE_VERTICAL: AtkStateType = 27; pub const ATK_STATE_VISIBLE: AtkStateType = 28; pub const ATK_STATE_MANAGES_DESCENDANTS: AtkStateType = 29; pub const ATK_STATE_INDETERMINATE: AtkStateType = 30; pub const ATK_STATE_TRUNCATED: AtkStateType = 31; pub const ATK_STATE_REQUIRED: AtkStateType = 32; pub const ATK_STATE_INVALID_ENTRY: AtkStateType = 33; pub const ATK_STATE_SUPPORTS_AUTOCOMPLETION: AtkStateType = 34; pub const ATK_STATE_SELECTABLE_TEXT: AtkStateType = 35; pub const ATK_STATE_DEFAULT: AtkStateType = 36; pub const ATK_STATE_ANIMATED: AtkStateType = 37; pub const ATK_STATE_VISITED: AtkStateType = 38; pub const ATK_STATE_CHECKABLE: AtkStateType = 39; pub const ATK_STATE_HAS_POPUP: AtkStateType = 40; pub const ATK_STATE_HAS_TOOLTIP: AtkStateType = 41; pub const ATK_STATE_READ_ONLY: AtkStateType = 42; #[cfg(feature = "v2_38")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_38")))] pub const ATK_STATE_COLLAPSED: AtkStateType = 43; pub type AtkTextAttribute = c_int; pub const ATK_TEXT_ATTR_INVALID: AtkTextAttribute = 0; pub const ATK_TEXT_ATTR_LEFT_MARGIN: AtkTextAttribute = 1; pub const ATK_TEXT_ATTR_RIGHT_MARGIN: AtkTextAttribute = 2; pub const ATK_TEXT_ATTR_INDENT: AtkTextAttribute = 3; pub const ATK_TEXT_ATTR_INVISIBLE: AtkTextAttribute = 4; pub const ATK_TEXT_ATTR_EDITABLE: AtkTextAttribute = 5; pub const ATK_TEXT_ATTR_PIXELS_ABOVE_LINES: AtkTextAttribute = 6; pub const ATK_TEXT_ATTR_PIXELS_BELOW_LINES: AtkTextAttribute = 7; pub const ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP: AtkTextAttribute = 8; pub const ATK_TEXT_ATTR_BG_FULL_HEIGHT: AtkTextAttribute = 9; pub const ATK_TEXT_ATTR_RISE: AtkTextAttribute = 10; pub const ATK_TEXT_ATTR_UNDERLINE: AtkTextAttribute = 11; pub const ATK_TEXT_ATTR_STRIKETHROUGH: AtkTextAttribute = 12; pub const ATK_TEXT_ATTR_SIZE: AtkTextAttribute = 13; pub const ATK_TEXT_ATTR_SCALE: AtkTextAttribute = 14; pub const ATK_TEXT_ATTR_WEIGHT: AtkTextAttribute = 15; pub const ATK_TEXT_ATTR_LANGUAGE: AtkTextAttribute = 16; pub const ATK_TEXT_ATTR_FAMILY_NAME: AtkTextAttribute = 17; pub const ATK_TEXT_ATTR_BG_COLOR: AtkTextAttribute = 18; pub const ATK_TEXT_ATTR_FG_COLOR: AtkTextAttribute = 19; pub const ATK_TEXT_ATTR_BG_STIPPLE: AtkTextAttribute = 20; pub const ATK_TEXT_ATTR_FG_STIPPLE: AtkTextAttribute = 21; pub const ATK_TEXT_ATTR_WRAP_MODE: AtkTextAttribute = 22; pub const ATK_TEXT_ATTR_DIRECTION: AtkTextAttribute = 23; pub const ATK_TEXT_ATTR_JUSTIFICATION: AtkTextAttribute = 24; pub const ATK_TEXT_ATTR_STRETCH: AtkTextAttribute = 25; pub const ATK_TEXT_ATTR_VARIANT: AtkTextAttribute = 26; pub const ATK_TEXT_ATTR_STYLE: AtkTextAttribute = 27; pub const ATK_TEXT_ATTR_TEXT_POSITION: AtkTextAttribute = 28; pub const ATK_TEXT_ATTR_LAST_DEFINED: AtkTextAttribute = 29; pub type AtkTextBoundary = c_int; pub const ATK_TEXT_BOUNDARY_CHAR: AtkTextBoundary = 0; pub const ATK_TEXT_BOUNDARY_WORD_START: AtkTextBoundary = 1; pub const ATK_TEXT_BOUNDARY_WORD_END: AtkTextBoundary = 2; pub const ATK_TEXT_BOUNDARY_SENTENCE_START: AtkTextBoundary = 3; pub const ATK_TEXT_BOUNDARY_SENTENCE_END: AtkTextBoundary = 4; pub const ATK_TEXT_BOUNDARY_LINE_START: AtkTextBoundary = 5; pub const ATK_TEXT_BOUNDARY_LINE_END: AtkTextBoundary = 6; pub type AtkTextClipType = c_int; pub const ATK_TEXT_CLIP_NONE: AtkTextClipType = 0; pub const ATK_TEXT_CLIP_MIN: AtkTextClipType = 1; pub const ATK_TEXT_CLIP_MAX: AtkTextClipType = 2; pub const ATK_TEXT_CLIP_BOTH: AtkTextClipType = 3; pub type AtkTextGranularity = c_int; pub const ATK_TEXT_GRANULARITY_CHAR: AtkTextGranularity = 0; pub const ATK_TEXT_GRANULARITY_WORD: AtkTextGranularity = 1; pub const ATK_TEXT_GRANULARITY_SENTENCE: AtkTextGranularity = 2; pub const ATK_TEXT_GRANULARITY_LINE: AtkTextGranularity = 3; pub const ATK_TEXT_GRANULARITY_PARAGRAPH: AtkTextGranularity = 4; pub type AtkValueType = c_int; pub const ATK_VALUE_VERY_WEAK: AtkValueType = 0; pub const ATK_VALUE_WEAK: AtkValueType = 1; pub const ATK_VALUE_ACCEPTABLE: AtkValueType = 2; pub const ATK_VALUE_STRONG: AtkValueType = 3; pub const ATK_VALUE_VERY_STRONG: AtkValueType = 4; pub const ATK_VALUE_VERY_LOW: AtkValueType = 5; pub const ATK_VALUE_LOW: AtkValueType = 6; pub const ATK_VALUE_MEDIUM: AtkValueType = 7; pub const ATK_VALUE_HIGH: AtkValueType = 8; pub const ATK_VALUE_VERY_HIGH: AtkValueType = 9; pub const ATK_VALUE_VERY_BAD: AtkValueType = 10; pub const ATK_VALUE_BAD: AtkValueType = 11; pub const ATK_VALUE_GOOD: AtkValueType = 12; pub const ATK_VALUE_VERY_GOOD: AtkValueType = 13; pub const ATK_VALUE_BEST: AtkValueType = 14; pub const ATK_VALUE_LAST_DEFINED: AtkValueType = 15; // Constants // Flags pub type AtkHyperlinkStateFlags = c_uint; pub const ATK_HYPERLINK_IS_INLINE: AtkHyperlinkStateFlags = 1; // Callbacks pub type AtkEventListener = Option; pub type AtkEventListenerInit = Option; pub type AtkFocusHandler = Option; pub type AtkFunction = Option gboolean>; pub type AtkKeySnoopFunc = Option c_int>; pub type AtkPropertyChangeHandler = Option; // Records #[derive(Copy, Clone)] #[repr(C)] pub struct AtkActionIface { pub parent: gobject::GTypeInterface, pub do_action: Option gboolean>, pub get_n_actions: Option c_int>, pub get_description: Option *const c_char>, pub get_name: Option *const c_char>, pub get_keybinding: Option *const c_char>, pub set_description: Option gboolean>, pub get_localized_name: Option *const c_char>, } impl ::std::fmt::Debug for AtkActionIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkActionIface @ {self:p}")) .field("do_action", &self.do_action) .field("get_n_actions", &self.get_n_actions) .field("get_description", &self.get_description) .field("get_name", &self.get_name) .field("get_keybinding", &self.get_keybinding) .field("set_description", &self.set_description) .field("get_localized_name", &self.get_localized_name) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkAttribute { pub name: *mut c_char, pub value: *mut c_char, } impl ::std::fmt::Debug for AtkAttribute { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkAttribute @ {self:p}")) .field("name", &self.name) .field("value", &self.value) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkComponentIface { pub parent: gobject::GTypeInterface, pub add_focus_handler: Option c_uint>, pub contains: Option gboolean>, pub ref_accessible_at_point: Option< unsafe extern "C" fn(*mut AtkComponent, c_int, c_int, AtkCoordType) -> *mut AtkObject, >, pub get_extents: Option< unsafe extern "C" fn( *mut AtkComponent, *mut c_int, *mut c_int, *mut c_int, *mut c_int, AtkCoordType, ), >, pub get_position: Option, pub get_size: Option, pub grab_focus: Option gboolean>, pub remove_focus_handler: Option, pub set_extents: Option< unsafe extern "C" fn( *mut AtkComponent, c_int, c_int, c_int, c_int, AtkCoordType, ) -> gboolean, >, pub set_position: Option gboolean>, pub set_size: Option gboolean>, pub get_layer: Option AtkLayer>, pub get_mdi_zorder: Option c_int>, pub bounds_changed: Option, pub get_alpha: Option c_double>, pub scroll_to: Option gboolean>, pub scroll_to_point: Option gboolean>, } impl ::std::fmt::Debug for AtkComponentIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkComponentIface @ {self:p}")) .field("add_focus_handler", &self.add_focus_handler) .field("contains", &self.contains) .field("ref_accessible_at_point", &self.ref_accessible_at_point) .field("get_extents", &self.get_extents) .field("get_position", &self.get_position) .field("get_size", &self.get_size) .field("grab_focus", &self.grab_focus) .field("remove_focus_handler", &self.remove_focus_handler) .field("set_extents", &self.set_extents) .field("set_position", &self.set_position) .field("set_size", &self.set_size) .field("get_layer", &self.get_layer) .field("get_mdi_zorder", &self.get_mdi_zorder) .field("bounds_changed", &self.bounds_changed) .field("get_alpha", &self.get_alpha) .field("scroll_to", &self.scroll_to) .field("scroll_to_point", &self.scroll_to_point) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkDocumentIface { pub parent: gobject::GTypeInterface, pub get_document_type: Option *const c_char>, pub get_document: Option gpointer>, pub get_document_locale: Option *const c_char>, pub get_document_attributes: Option *mut AtkAttributeSet>, pub get_document_attribute_value: Option *const c_char>, pub set_document_attribute: Option gboolean>, pub get_current_page_number: Option c_int>, pub get_page_count: Option c_int>, } impl ::std::fmt::Debug for AtkDocumentIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkDocumentIface @ {self:p}")) .field("parent", &self.parent) .field("get_document_type", &self.get_document_type) .field("get_document", &self.get_document) .field("get_document_locale", &self.get_document_locale) .field("get_document_attributes", &self.get_document_attributes) .field( "get_document_attribute_value", &self.get_document_attribute_value, ) .field("set_document_attribute", &self.set_document_attribute) .field("get_current_page_number", &self.get_current_page_number) .field("get_page_count", &self.get_page_count) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkEditableTextIface { pub parent_interface: gobject::GTypeInterface, pub set_run_attributes: Option< unsafe extern "C" fn(*mut AtkEditableText, *mut AtkAttributeSet, c_int, c_int) -> gboolean, >, pub set_text_contents: Option, pub insert_text: Option, pub copy_text: Option, pub cut_text: Option, pub delete_text: Option, pub paste_text: Option, } impl ::std::fmt::Debug for AtkEditableTextIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkEditableTextIface @ {self:p}")) .field("parent_interface", &self.parent_interface) .field("set_run_attributes", &self.set_run_attributes) .field("set_text_contents", &self.set_text_contents) .field("insert_text", &self.insert_text) .field("copy_text", &self.copy_text) .field("cut_text", &self.cut_text) .field("delete_text", &self.delete_text) .field("paste_text", &self.paste_text) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkGObjectAccessibleClass { pub parent_class: AtkObjectClass, pub pad1: AtkFunction, pub pad2: AtkFunction, } impl ::std::fmt::Debug for AtkGObjectAccessibleClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkGObjectAccessibleClass @ {self:p}")) .field("parent_class", &self.parent_class) .field("pad1", &self.pad1) .field("pad2", &self.pad2) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkHyperlinkClass { pub parent: gobject::GObjectClass, pub get_uri: Option *mut c_char>, pub get_object: Option *mut AtkObject>, pub get_end_index: Option c_int>, pub get_start_index: Option c_int>, pub is_valid: Option gboolean>, pub get_n_anchors: Option c_int>, pub link_state: Option c_uint>, pub is_selected_link: Option gboolean>, pub link_activated: Option, pub pad1: AtkFunction, } impl ::std::fmt::Debug for AtkHyperlinkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkHyperlinkClass @ {self:p}")) .field("parent", &self.parent) .field("get_uri", &self.get_uri) .field("get_object", &self.get_object) .field("get_end_index", &self.get_end_index) .field("get_start_index", &self.get_start_index) .field("is_valid", &self.is_valid) .field("get_n_anchors", &self.get_n_anchors) .field("link_state", &self.link_state) .field("is_selected_link", &self.is_selected_link) .field("link_activated", &self.link_activated) .field("pad1", &self.pad1) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkHyperlinkImplIface { pub parent: gobject::GTypeInterface, pub get_hyperlink: Option *mut AtkHyperlink>, } impl ::std::fmt::Debug for AtkHyperlinkImplIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkHyperlinkImplIface @ {self:p}")) .field("parent", &self.parent) .field("get_hyperlink", &self.get_hyperlink) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkHypertextIface { pub parent: gobject::GTypeInterface, pub get_link: Option *mut AtkHyperlink>, pub get_n_links: Option c_int>, pub get_link_index: Option c_int>, pub link_selected: Option, } impl ::std::fmt::Debug for AtkHypertextIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkHypertextIface @ {self:p}")) .field("parent", &self.parent) .field("get_link", &self.get_link) .field("get_n_links", &self.get_n_links) .field("get_link_index", &self.get_link_index) .field("link_selected", &self.link_selected) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkImageIface { pub parent: gobject::GTypeInterface, pub get_image_position: Option, pub get_image_description: Option *const c_char>, pub get_image_size: Option, pub set_image_description: Option gboolean>, pub get_image_locale: Option *const c_char>, } impl ::std::fmt::Debug for AtkImageIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkImageIface @ {self:p}")) .field("parent", &self.parent) .field("get_image_position", &self.get_image_position) .field("get_image_description", &self.get_image_description) .field("get_image_size", &self.get_image_size) .field("set_image_description", &self.set_image_description) .field("get_image_locale", &self.get_image_locale) .finish() } } #[repr(C)] pub struct _AtkImplementor { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } pub type AtkImplementor = *mut _AtkImplementor; #[derive(Copy, Clone)] #[repr(C)] pub struct AtkKeyEventStruct { pub type_: c_int, pub state: c_uint, pub keyval: c_uint, pub length: c_int, pub string: *mut c_char, pub keycode: u16, pub timestamp: u32, } impl ::std::fmt::Debug for AtkKeyEventStruct { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkKeyEventStruct @ {self:p}")) .field("type_", &self.type_) .field("state", &self.state) .field("keyval", &self.keyval) .field("length", &self.length) .field("string", &self.string) .field("keycode", &self.keycode) .field("timestamp", &self.timestamp) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkMiscClass { pub parent: gobject::GObjectClass, pub threads_enter: Option, pub threads_leave: Option, pub vfuncs: [gpointer; 32], } impl ::std::fmt::Debug for AtkMiscClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkMiscClass @ {self:p}")) .field("parent", &self.parent) .field("threads_enter", &self.threads_enter) .field("threads_leave", &self.threads_leave) .field("vfuncs", &self.vfuncs) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkNoOpObjectClass { pub parent_class: AtkObjectClass, } impl ::std::fmt::Debug for AtkNoOpObjectClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkNoOpObjectClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkNoOpObjectFactoryClass { pub parent_class: AtkObjectFactoryClass, } impl ::std::fmt::Debug for AtkNoOpObjectFactoryClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkNoOpObjectFactoryClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkObjectClass { pub parent: gobject::GObjectClass, pub get_name: Option *const c_char>, pub get_description: Option *const c_char>, pub get_parent: Option *mut AtkObject>, pub get_n_children: Option c_int>, pub ref_child: Option *mut AtkObject>, pub get_index_in_parent: Option c_int>, pub ref_relation_set: Option *mut AtkRelationSet>, pub get_role: Option AtkRole>, pub get_layer: Option AtkLayer>, pub get_mdi_zorder: Option c_int>, pub ref_state_set: Option *mut AtkStateSet>, pub set_name: Option, pub set_description: Option, pub set_parent: Option, pub set_role: Option, pub connect_property_change_handler: Option c_uint>, pub remove_property_change_handler: Option, pub initialize: Option, pub children_changed: Option, pub focus_event: Option, pub property_change: Option, pub state_change: Option, pub visible_data_changed: Option, pub active_descendant_changed: Option, pub get_attributes: Option *mut AtkAttributeSet>, pub get_object_locale: Option *const c_char>, pub pad1: AtkFunction, } impl ::std::fmt::Debug for AtkObjectClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkObjectClass @ {self:p}")) .field("parent", &self.parent) .field("get_name", &self.get_name) .field("get_description", &self.get_description) .field("get_parent", &self.get_parent) .field("get_n_children", &self.get_n_children) .field("ref_child", &self.ref_child) .field("get_index_in_parent", &self.get_index_in_parent) .field("ref_relation_set", &self.ref_relation_set) .field("get_role", &self.get_role) .field("get_layer", &self.get_layer) .field("get_mdi_zorder", &self.get_mdi_zorder) .field("ref_state_set", &self.ref_state_set) .field("set_name", &self.set_name) .field("set_description", &self.set_description) .field("set_parent", &self.set_parent) .field("set_role", &self.set_role) .field( "connect_property_change_handler", &self.connect_property_change_handler, ) .field( "remove_property_change_handler", &self.remove_property_change_handler, ) .field("initialize", &self.initialize) .field("children_changed", &self.children_changed) .field("focus_event", &self.focus_event) .field("property_change", &self.property_change) .field("state_change", &self.state_change) .field("visible_data_changed", &self.visible_data_changed) .field("active_descendant_changed", &self.active_descendant_changed) .field("get_attributes", &self.get_attributes) .field("get_object_locale", &self.get_object_locale) .field("pad1", &self.pad1) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkObjectFactoryClass { pub parent_class: gobject::GObjectClass, pub create_accessible: Option *mut AtkObject>, pub invalidate: Option, pub get_accessible_type: Option GType>, pub pad1: AtkFunction, pub pad2: AtkFunction, } impl ::std::fmt::Debug for AtkObjectFactoryClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkObjectFactoryClass @ {self:p}")) .field("parent_class", &self.parent_class) .field("create_accessible", &self.create_accessible) .field("invalidate", &self.invalidate) .field("get_accessible_type", &self.get_accessible_type) .field("pad1", &self.pad1) .field("pad2", &self.pad2) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkPlugClass { pub parent_class: AtkObjectClass, pub get_object_id: Option *mut c_char>, } impl ::std::fmt::Debug for AtkPlugClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkPlugClass @ {self:p}")) .field("parent_class", &self.parent_class) .field("get_object_id", &self.get_object_id) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkPropertyValues { pub property_name: *const c_char, pub old_value: gobject::GValue, pub new_value: gobject::GValue, } impl ::std::fmt::Debug for AtkPropertyValues { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkPropertyValues @ {self:p}")) .field("property_name", &self.property_name) .field("old_value", &self.old_value) .field("new_value", &self.new_value) .finish() } } #[repr(C)] pub struct AtkRange { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkRange { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRange @ {self:p}")).finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkRectangle { pub x: c_int, pub y: c_int, pub width: c_int, pub height: c_int, } impl ::std::fmt::Debug for AtkRectangle { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRectangle @ {self:p}")) .field("x", &self.x) .field("y", &self.y) .field("width", &self.width) .field("height", &self.height) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkRegistryClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for AtkRegistryClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRegistryClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkRelationClass { pub parent: gobject::GObjectClass, } impl ::std::fmt::Debug for AtkRelationClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRelationClass @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkRelationSetClass { pub parent: gobject::GObjectClass, pub pad1: AtkFunction, pub pad2: AtkFunction, } impl ::std::fmt::Debug for AtkRelationSetClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRelationSetClass @ {self:p}")) .field("parent", &self.parent) .field("pad1", &self.pad1) .field("pad2", &self.pad2) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkSelectionIface { pub parent: gobject::GTypeInterface, pub add_selection: Option gboolean>, pub clear_selection: Option gboolean>, pub ref_selection: Option *mut AtkObject>, pub get_selection_count: Option c_int>, pub is_child_selected: Option gboolean>, pub remove_selection: Option gboolean>, pub select_all_selection: Option gboolean>, pub selection_changed: Option, } impl ::std::fmt::Debug for AtkSelectionIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkSelectionIface @ {self:p}")) .field("parent", &self.parent) .field("add_selection", &self.add_selection) .field("clear_selection", &self.clear_selection) .field("ref_selection", &self.ref_selection) .field("get_selection_count", &self.get_selection_count) .field("is_child_selected", &self.is_child_selected) .field("remove_selection", &self.remove_selection) .field("select_all_selection", &self.select_all_selection) .field("selection_changed", &self.selection_changed) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkSocketClass { pub parent_class: AtkObjectClass, pub embed: Option, } impl ::std::fmt::Debug for AtkSocketClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkSocketClass @ {self:p}")) .field("parent_class", &self.parent_class) .field("embed", &self.embed) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkStateSetClass { pub parent: gobject::GObjectClass, } impl ::std::fmt::Debug for AtkStateSetClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkStateSetClass @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkStreamableContentIface { pub parent: gobject::GTypeInterface, pub get_n_mime_types: Option c_int>, pub get_mime_type: Option *const c_char>, pub get_stream: Option< unsafe extern "C" fn(*mut AtkStreamableContent, *const c_char) -> *mut glib::GIOChannel, >, pub get_uri: Option *const c_char>, pub pad1: AtkFunction, pub pad2: AtkFunction, pub pad3: AtkFunction, } impl ::std::fmt::Debug for AtkStreamableContentIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkStreamableContentIface @ {self:p}")) .field("parent", &self.parent) .field("get_n_mime_types", &self.get_n_mime_types) .field("get_mime_type", &self.get_mime_type) .field("get_stream", &self.get_stream) .field("get_uri", &self.get_uri) .field("pad1", &self.pad1) .field("pad2", &self.pad2) .field("pad3", &self.pad3) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkTableCellIface { pub parent: gobject::GTypeInterface, pub get_column_span: Option c_int>, pub get_column_header_cells: Option *mut glib::GPtrArray>, pub get_position: Option gboolean>, pub get_row_span: Option c_int>, pub get_row_header_cells: Option *mut glib::GPtrArray>, pub get_row_column_span: Option< unsafe extern "C" fn( *mut AtkTableCell, *mut c_int, *mut c_int, *mut c_int, *mut c_int, ) -> gboolean, >, pub get_table: Option *mut AtkObject>, } impl ::std::fmt::Debug for AtkTableCellIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkTableCellIface @ {self:p}")) .field("get_column_span", &self.get_column_span) .field("get_column_header_cells", &self.get_column_header_cells) .field("get_position", &self.get_position) .field("get_row_span", &self.get_row_span) .field("get_row_header_cells", &self.get_row_header_cells) .field("get_row_column_span", &self.get_row_column_span) .field("get_table", &self.get_table) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkTableIface { pub parent: gobject::GTypeInterface, pub ref_at: Option *mut AtkObject>, pub get_index_at: Option c_int>, pub get_column_at_index: Option c_int>, pub get_row_at_index: Option c_int>, pub get_n_columns: Option c_int>, pub get_n_rows: Option c_int>, pub get_column_extent_at: Option c_int>, pub get_row_extent_at: Option c_int>, pub get_caption: Option *mut AtkObject>, pub get_column_description: Option *const c_char>, pub get_column_header: Option *mut AtkObject>, pub get_row_description: Option *const c_char>, pub get_row_header: Option *mut AtkObject>, pub get_summary: Option *mut AtkObject>, pub set_caption: Option, pub set_column_description: Option, pub set_column_header: Option, pub set_row_description: Option, pub set_row_header: Option, pub set_summary: Option, pub get_selected_columns: Option c_int>, pub get_selected_rows: Option c_int>, pub is_column_selected: Option gboolean>, pub is_row_selected: Option gboolean>, pub is_selected: Option gboolean>, pub add_row_selection: Option gboolean>, pub remove_row_selection: Option gboolean>, pub add_column_selection: Option gboolean>, pub remove_column_selection: Option gboolean>, pub row_inserted: Option, pub column_inserted: Option, pub row_deleted: Option, pub column_deleted: Option, pub row_reordered: Option, pub column_reordered: Option, pub model_changed: Option, } impl ::std::fmt::Debug for AtkTableIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkTableIface @ {self:p}")) .field("parent", &self.parent) .field("ref_at", &self.ref_at) .field("get_index_at", &self.get_index_at) .field("get_column_at_index", &self.get_column_at_index) .field("get_row_at_index", &self.get_row_at_index) .field("get_n_columns", &self.get_n_columns) .field("get_n_rows", &self.get_n_rows) .field("get_column_extent_at", &self.get_column_extent_at) .field("get_row_extent_at", &self.get_row_extent_at) .field("get_caption", &self.get_caption) .field("get_column_description", &self.get_column_description) .field("get_column_header", &self.get_column_header) .field("get_row_description", &self.get_row_description) .field("get_row_header", &self.get_row_header) .field("get_summary", &self.get_summary) .field("set_caption", &self.set_caption) .field("set_column_description", &self.set_column_description) .field("set_column_header", &self.set_column_header) .field("set_row_description", &self.set_row_description) .field("set_row_header", &self.set_row_header) .field("set_summary", &self.set_summary) .field("get_selected_columns", &self.get_selected_columns) .field("get_selected_rows", &self.get_selected_rows) .field("is_column_selected", &self.is_column_selected) .field("is_row_selected", &self.is_row_selected) .field("is_selected", &self.is_selected) .field("add_row_selection", &self.add_row_selection) .field("remove_row_selection", &self.remove_row_selection) .field("add_column_selection", &self.add_column_selection) .field("remove_column_selection", &self.remove_column_selection) .field("row_inserted", &self.row_inserted) .field("column_inserted", &self.column_inserted) .field("row_deleted", &self.row_deleted) .field("column_deleted", &self.column_deleted) .field("row_reordered", &self.row_reordered) .field("column_reordered", &self.column_reordered) .field("model_changed", &self.model_changed) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkTextIface { pub parent: gobject::GTypeInterface, pub get_text: Option *mut c_char>, pub get_text_after_offset: Option< unsafe extern "C" fn( *mut AtkText, c_int, AtkTextBoundary, *mut c_int, *mut c_int, ) -> *mut c_char, >, pub get_text_at_offset: Option< unsafe extern "C" fn( *mut AtkText, c_int, AtkTextBoundary, *mut c_int, *mut c_int, ) -> *mut c_char, >, pub get_character_at_offset: Option u32>, pub get_text_before_offset: Option< unsafe extern "C" fn( *mut AtkText, c_int, AtkTextBoundary, *mut c_int, *mut c_int, ) -> *mut c_char, >, pub get_caret_offset: Option c_int>, pub get_run_attributes: Option< unsafe extern "C" fn(*mut AtkText, c_int, *mut c_int, *mut c_int) -> *mut AtkAttributeSet, >, pub get_default_attributes: Option *mut AtkAttributeSet>, pub get_character_extents: Option< unsafe extern "C" fn( *mut AtkText, c_int, *mut c_int, *mut c_int, *mut c_int, *mut c_int, AtkCoordType, ), >, pub get_character_count: Option c_int>, pub get_offset_at_point: Option c_int>, pub get_n_selections: Option c_int>, pub get_selection: Option *mut c_char>, pub add_selection: Option gboolean>, pub remove_selection: Option gboolean>, pub set_selection: Option gboolean>, pub set_caret_offset: Option gboolean>, pub text_changed: Option, pub text_caret_moved: Option, pub text_selection_changed: Option, pub text_attributes_changed: Option, pub get_range_extents: Option< unsafe extern "C" fn(*mut AtkText, c_int, c_int, AtkCoordType, *mut AtkTextRectangle), >, pub get_bounded_ranges: Option< unsafe extern "C" fn( *mut AtkText, *mut AtkTextRectangle, AtkCoordType, AtkTextClipType, AtkTextClipType, ) -> *mut *mut AtkTextRange, >, pub get_string_at_offset: Option< unsafe extern "C" fn( *mut AtkText, c_int, AtkTextGranularity, *mut c_int, *mut c_int, ) -> *mut c_char, >, pub scroll_substring_to: Option gboolean>, pub scroll_substring_to_point: Option< unsafe extern "C" fn(*mut AtkText, c_int, c_int, AtkCoordType, c_int, c_int) -> gboolean, >, } impl ::std::fmt::Debug for AtkTextIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkTextIface @ {self:p}")) .field("parent", &self.parent) .field("get_text", &self.get_text) .field("get_text_after_offset", &self.get_text_after_offset) .field("get_text_at_offset", &self.get_text_at_offset) .field("get_character_at_offset", &self.get_character_at_offset) .field("get_text_before_offset", &self.get_text_before_offset) .field("get_caret_offset", &self.get_caret_offset) .field("get_run_attributes", &self.get_run_attributes) .field("get_default_attributes", &self.get_default_attributes) .field("get_character_extents", &self.get_character_extents) .field("get_character_count", &self.get_character_count) .field("get_offset_at_point", &self.get_offset_at_point) .field("get_n_selections", &self.get_n_selections) .field("get_selection", &self.get_selection) .field("add_selection", &self.add_selection) .field("remove_selection", &self.remove_selection) .field("set_selection", &self.set_selection) .field("set_caret_offset", &self.set_caret_offset) .field("text_changed", &self.text_changed) .field("text_caret_moved", &self.text_caret_moved) .field("text_selection_changed", &self.text_selection_changed) .field("text_attributes_changed", &self.text_attributes_changed) .field("get_range_extents", &self.get_range_extents) .field("get_bounded_ranges", &self.get_bounded_ranges) .field("get_string_at_offset", &self.get_string_at_offset) .field("scroll_substring_to", &self.scroll_substring_to) .field("scroll_substring_to_point", &self.scroll_substring_to_point) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkTextRange { pub bounds: AtkTextRectangle, pub start_offset: c_int, pub end_offset: c_int, pub content: *mut c_char, } impl ::std::fmt::Debug for AtkTextRange { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkTextRange @ {self:p}")) .field("bounds", &self.bounds) .field("start_offset", &self.start_offset) .field("end_offset", &self.end_offset) .field("content", &self.content) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkTextRectangle { pub x: c_int, pub y: c_int, pub width: c_int, pub height: c_int, } impl ::std::fmt::Debug for AtkTextRectangle { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkTextRectangle @ {self:p}")) .field("x", &self.x) .field("y", &self.y) .field("width", &self.width) .field("height", &self.height) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkUtilClass { pub parent: gobject::GObjectClass, pub add_global_event_listener: Option c_uint>, pub remove_global_event_listener: Option, pub add_key_event_listener: Option c_uint>, pub remove_key_event_listener: Option, pub get_root: Option *mut AtkObject>, pub get_toolkit_name: Option *const c_char>, pub get_toolkit_version: Option *const c_char>, } impl ::std::fmt::Debug for AtkUtilClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkUtilClass @ {self:p}")) .field("parent", &self.parent) .field("add_global_event_listener", &self.add_global_event_listener) .field( "remove_global_event_listener", &self.remove_global_event_listener, ) .field("add_key_event_listener", &self.add_key_event_listener) .field("remove_key_event_listener", &self.remove_key_event_listener) .field("get_root", &self.get_root) .field("get_toolkit_name", &self.get_toolkit_name) .field("get_toolkit_version", &self.get_toolkit_version) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkValueIface { pub parent: gobject::GTypeInterface, pub get_current_value: Option, pub get_maximum_value: Option, pub get_minimum_value: Option, pub set_current_value: Option gboolean>, pub get_minimum_increment: Option, pub get_value_and_text: Option, pub get_range: Option *mut AtkRange>, pub get_increment: Option c_double>, pub get_sub_ranges: Option *mut glib::GSList>, pub set_value: Option, } impl ::std::fmt::Debug for AtkValueIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkValueIface @ {self:p}")) .field("parent", &self.parent) .field("get_current_value", &self.get_current_value) .field("get_maximum_value", &self.get_maximum_value) .field("get_minimum_value", &self.get_minimum_value) .field("set_current_value", &self.set_current_value) .field("get_minimum_increment", &self.get_minimum_increment) .field("get_value_and_text", &self.get_value_and_text) .field("get_range", &self.get_range) .field("get_increment", &self.get_increment) .field("get_sub_ranges", &self.get_sub_ranges) .field("set_value", &self.set_value) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkWindowIface { pub parent: gobject::GTypeInterface, } impl ::std::fmt::Debug for AtkWindowIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkWindowIface @ {self:p}")) .field("parent", &self.parent) .finish() } } // Classes #[derive(Copy, Clone)] #[repr(C)] pub struct AtkGObjectAccessible { pub parent: AtkObject, } impl ::std::fmt::Debug for AtkGObjectAccessible { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkGObjectAccessible @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkHyperlink { pub parent: gobject::GObject, } impl ::std::fmt::Debug for AtkHyperlink { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkHyperlink @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkMisc { pub parent: gobject::GObject, } impl ::std::fmt::Debug for AtkMisc { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkMisc @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkNoOpObject { pub parent: AtkObject, } impl ::std::fmt::Debug for AtkNoOpObject { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkNoOpObject @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkNoOpObjectFactory { pub parent: AtkObjectFactory, } impl ::std::fmt::Debug for AtkNoOpObjectFactory { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkNoOpObjectFactory @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkObject { pub parent: gobject::GObject, pub description: *mut c_char, pub name: *mut c_char, pub accessible_parent: *mut AtkObject, pub role: AtkRole, pub relation_set: *mut AtkRelationSet, pub layer: AtkLayer, } impl ::std::fmt::Debug for AtkObject { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkObject @ {self:p}")) .field("parent", &self.parent) .field("description", &self.description) .field("name", &self.name) .field("accessible_parent", &self.accessible_parent) .field("role", &self.role) .field("relation_set", &self.relation_set) .field("layer", &self.layer) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkObjectFactory { pub parent: gobject::GObject, } impl ::std::fmt::Debug for AtkObjectFactory { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkObjectFactory @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkPlug { pub parent: AtkObject, } impl ::std::fmt::Debug for AtkPlug { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkPlug @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkRegistry { pub parent: gobject::GObject, pub factory_type_registry: *mut glib::GHashTable, pub factory_singleton_cache: *mut glib::GHashTable, } impl ::std::fmt::Debug for AtkRegistry { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRegistry @ {self:p}")) .field("parent", &self.parent) .field("factory_type_registry", &self.factory_type_registry) .field("factory_singleton_cache", &self.factory_singleton_cache) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkRelation { pub parent: gobject::GObject, pub target: *mut glib::GPtrArray, pub relationship: AtkRelationType, } impl ::std::fmt::Debug for AtkRelation { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRelation @ {self:p}")) .field("parent", &self.parent) .field("target", &self.target) .field("relationship", &self.relationship) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkRelationSet { pub parent: gobject::GObject, pub relations: *mut glib::GPtrArray, } impl ::std::fmt::Debug for AtkRelationSet { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRelationSet @ {self:p}")) .field("parent", &self.parent) .field("relations", &self.relations) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkSocket { pub parent: AtkObject, pub embedded_plug_id: *mut c_char, } impl ::std::fmt::Debug for AtkSocket { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkSocket @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkStateSet { pub parent: gobject::GObject, } impl ::std::fmt::Debug for AtkStateSet { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkStateSet @ {self:p}")) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct AtkUtil { pub parent: gobject::GObject, } impl ::std::fmt::Debug for AtkUtil { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkUtil @ {self:p}")) .field("parent", &self.parent) .finish() } } // Interfaces #[repr(C)] pub struct AtkAction { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkAction { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkAction @ {self:p}") } } #[repr(C)] pub struct AtkComponent { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkComponent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkComponent @ {self:p}") } } #[repr(C)] pub struct AtkDocument { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkDocument { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkDocument @ {self:p}") } } #[repr(C)] pub struct AtkEditableText { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkEditableText { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkEditableText @ {self:p}") } } #[repr(C)] pub struct AtkHyperlinkImpl { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkHyperlinkImpl { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkHyperlinkImpl @ {self:p}") } } #[repr(C)] pub struct AtkHypertext { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkHypertext { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkHypertext @ {self:p}") } } #[repr(C)] pub struct AtkImage { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkImage { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkImage @ {self:p}") } } #[repr(C)] pub struct AtkImplementorIface { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkImplementorIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkImplementorIface @ {self:p}") } } #[repr(C)] pub struct AtkSelection { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkSelection { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkSelection @ {self:p}") } } #[repr(C)] pub struct AtkStreamableContent { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkStreamableContent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkStreamableContent @ {self:p}") } } #[repr(C)] pub struct AtkTable { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkTable { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkTable @ {self:p}") } } #[repr(C)] pub struct AtkTableCell { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkTableCell { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkTableCell @ {self:p}") } } #[repr(C)] pub struct AtkText { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkText { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkText @ {self:p}") } } #[repr(C)] pub struct AtkValue { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkValue { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkValue @ {self:p}") } } #[repr(C)] pub struct AtkWindow { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for AtkWindow { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkWindow @ {self:p}") } } #[link(name = "atk-1.0")] extern "C" { //========================================================================= // AtkCoordType //========================================================================= pub fn atk_coord_type_get_type() -> GType; //========================================================================= // AtkKeyEventType //========================================================================= pub fn atk_key_event_type_get_type() -> GType; //========================================================================= // AtkLayer //========================================================================= pub fn atk_layer_get_type() -> GType; //========================================================================= // AtkLive //========================================================================= #[cfg(feature = "v2_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_50")))] pub fn atk_live_get_type() -> GType; //========================================================================= // AtkRelationType //========================================================================= pub fn atk_relation_type_get_type() -> GType; pub fn atk_relation_type_for_name(name: *const c_char) -> AtkRelationType; pub fn atk_relation_type_get_name(type_: AtkRelationType) -> *const c_char; pub fn atk_relation_type_register(name: *const c_char) -> AtkRelationType; //========================================================================= // AtkRole //========================================================================= pub fn atk_role_get_type() -> GType; pub fn atk_role_for_name(name: *const c_char) -> AtkRole; pub fn atk_role_get_localized_name(role: AtkRole) -> *const c_char; pub fn atk_role_get_name(role: AtkRole) -> *const c_char; pub fn atk_role_register(name: *const c_char) -> AtkRole; //========================================================================= // AtkScrollType //========================================================================= #[cfg(feature = "v2_30")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_30")))] pub fn atk_scroll_type_get_type() -> GType; //========================================================================= // AtkStateType //========================================================================= pub fn atk_state_type_get_type() -> GType; pub fn atk_state_type_for_name(name: *const c_char) -> AtkStateType; pub fn atk_state_type_get_name(type_: AtkStateType) -> *const c_char; pub fn atk_state_type_register(name: *const c_char) -> AtkStateType; //========================================================================= // AtkTextAttribute //========================================================================= pub fn atk_text_attribute_get_type() -> GType; pub fn atk_text_attribute_for_name(name: *const c_char) -> AtkTextAttribute; pub fn atk_text_attribute_get_name(attr: AtkTextAttribute) -> *const c_char; pub fn atk_text_attribute_get_value(attr: AtkTextAttribute, index_: c_int) -> *const c_char; pub fn atk_text_attribute_register(name: *const c_char) -> AtkTextAttribute; //========================================================================= // AtkTextBoundary //========================================================================= pub fn atk_text_boundary_get_type() -> GType; //========================================================================= // AtkTextClipType //========================================================================= pub fn atk_text_clip_type_get_type() -> GType; //========================================================================= // AtkTextGranularity //========================================================================= pub fn atk_text_granularity_get_type() -> GType; //========================================================================= // AtkValueType //========================================================================= pub fn atk_value_type_get_type() -> GType; pub fn atk_value_type_get_localized_name(value_type: AtkValueType) -> *const c_char; pub fn atk_value_type_get_name(value_type: AtkValueType) -> *const c_char; //========================================================================= // AtkHyperlinkStateFlags //========================================================================= pub fn atk_hyperlink_state_flags_get_type() -> GType; //========================================================================= // AtkAttribute //========================================================================= pub fn atk_attribute_set_free(attrib_set: *mut AtkAttributeSet); //========================================================================= // AtkImplementor //========================================================================= pub fn atk_implementor_ref_accessible(implementor: *mut AtkImplementor) -> *mut AtkObject; //========================================================================= // AtkRange //========================================================================= pub fn atk_range_get_type() -> GType; pub fn atk_range_new( lower_limit: c_double, upper_limit: c_double, description: *const c_char, ) -> *mut AtkRange; pub fn atk_range_copy(src: *mut AtkRange) -> *mut AtkRange; pub fn atk_range_free(range: *mut AtkRange); pub fn atk_range_get_description(range: *mut AtkRange) -> *const c_char; pub fn atk_range_get_lower_limit(range: *mut AtkRange) -> c_double; pub fn atk_range_get_upper_limit(range: *mut AtkRange) -> c_double; //========================================================================= // AtkRectangle //========================================================================= pub fn atk_rectangle_get_type() -> GType; //========================================================================= // AtkTextRange //========================================================================= pub fn atk_text_range_get_type() -> GType; //========================================================================= // AtkGObjectAccessible //========================================================================= pub fn atk_gobject_accessible_get_type() -> GType; pub fn atk_gobject_accessible_for_object(obj: *mut gobject::GObject) -> *mut AtkObject; pub fn atk_gobject_accessible_get_object( obj: *mut AtkGObjectAccessible, ) -> *mut gobject::GObject; //========================================================================= // AtkHyperlink //========================================================================= pub fn atk_hyperlink_get_type() -> GType; pub fn atk_hyperlink_get_end_index(link_: *mut AtkHyperlink) -> c_int; pub fn atk_hyperlink_get_n_anchors(link_: *mut AtkHyperlink) -> c_int; pub fn atk_hyperlink_get_object(link_: *mut AtkHyperlink, i: c_int) -> *mut AtkObject; pub fn atk_hyperlink_get_start_index(link_: *mut AtkHyperlink) -> c_int; pub fn atk_hyperlink_get_uri(link_: *mut AtkHyperlink, i: c_int) -> *mut c_char; pub fn atk_hyperlink_is_inline(link_: *mut AtkHyperlink) -> gboolean; pub fn atk_hyperlink_is_selected_link(link_: *mut AtkHyperlink) -> gboolean; pub fn atk_hyperlink_is_valid(link_: *mut AtkHyperlink) -> gboolean; //========================================================================= // AtkMisc //========================================================================= pub fn atk_misc_get_type() -> GType; pub fn atk_misc_get_instance() -> *const AtkMisc; pub fn atk_misc_threads_enter(misc: *mut AtkMisc); pub fn atk_misc_threads_leave(misc: *mut AtkMisc); //========================================================================= // AtkNoOpObject //========================================================================= pub fn atk_no_op_object_get_type() -> GType; pub fn atk_no_op_object_new(obj: *mut gobject::GObject) -> *mut AtkObject; //========================================================================= // AtkNoOpObjectFactory //========================================================================= pub fn atk_no_op_object_factory_get_type() -> GType; pub fn atk_no_op_object_factory_new() -> *mut AtkObjectFactory; //========================================================================= // AtkObject //========================================================================= pub fn atk_object_get_type() -> GType; pub fn atk_object_add_relationship( object: *mut AtkObject, relationship: AtkRelationType, target: *mut AtkObject, ) -> gboolean; pub fn atk_object_connect_property_change_handler( accessible: *mut AtkObject, handler: *mut AtkPropertyChangeHandler, ) -> c_uint; #[cfg(feature = "v2_34")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_34")))] pub fn atk_object_get_accessible_id(accessible: *mut AtkObject) -> *const c_char; pub fn atk_object_get_attributes(accessible: *mut AtkObject) -> *mut AtkAttributeSet; pub fn atk_object_get_description(accessible: *mut AtkObject) -> *const c_char; pub fn atk_object_get_index_in_parent(accessible: *mut AtkObject) -> c_int; pub fn atk_object_get_layer(accessible: *mut AtkObject) -> AtkLayer; pub fn atk_object_get_mdi_zorder(accessible: *mut AtkObject) -> c_int; pub fn atk_object_get_n_accessible_children(accessible: *mut AtkObject) -> c_int; pub fn atk_object_get_name(accessible: *mut AtkObject) -> *const c_char; pub fn atk_object_get_object_locale(accessible: *mut AtkObject) -> *const c_char; pub fn atk_object_get_parent(accessible: *mut AtkObject) -> *mut AtkObject; pub fn atk_object_get_role(accessible: *mut AtkObject) -> AtkRole; pub fn atk_object_initialize(accessible: *mut AtkObject, data: gpointer); pub fn atk_object_notify_state_change( accessible: *mut AtkObject, state: AtkState, value: gboolean, ); pub fn atk_object_peek_parent(accessible: *mut AtkObject) -> *mut AtkObject; pub fn atk_object_ref_accessible_child(accessible: *mut AtkObject, i: c_int) -> *mut AtkObject; pub fn atk_object_ref_relation_set(accessible: *mut AtkObject) -> *mut AtkRelationSet; pub fn atk_object_ref_state_set(accessible: *mut AtkObject) -> *mut AtkStateSet; pub fn atk_object_remove_property_change_handler( accessible: *mut AtkObject, handler_id: c_uint, ); pub fn atk_object_remove_relationship( object: *mut AtkObject, relationship: AtkRelationType, target: *mut AtkObject, ) -> gboolean; #[cfg(feature = "v2_34")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_34")))] pub fn atk_object_set_accessible_id(accessible: *mut AtkObject, name: *const c_char); pub fn atk_object_set_description(accessible: *mut AtkObject, description: *const c_char); pub fn atk_object_set_name(accessible: *mut AtkObject, name: *const c_char); pub fn atk_object_set_parent(accessible: *mut AtkObject, parent: *mut AtkObject); pub fn atk_object_set_role(accessible: *mut AtkObject, role: AtkRole); //========================================================================= // AtkObjectFactory //========================================================================= pub fn atk_object_factory_get_type() -> GType; pub fn atk_object_factory_create_accessible( factory: *mut AtkObjectFactory, obj: *mut gobject::GObject, ) -> *mut AtkObject; pub fn atk_object_factory_get_accessible_type(factory: *mut AtkObjectFactory) -> GType; pub fn atk_object_factory_invalidate(factory: *mut AtkObjectFactory); //========================================================================= // AtkPlug //========================================================================= pub fn atk_plug_get_type() -> GType; pub fn atk_plug_new() -> *mut AtkObject; pub fn atk_plug_get_id(plug: *mut AtkPlug) -> *mut c_char; //========================================================================= // AtkRegistry //========================================================================= pub fn atk_registry_get_type() -> GType; pub fn atk_registry_get_factory( registry: *mut AtkRegistry, type_: GType, ) -> *mut AtkObjectFactory; pub fn atk_registry_get_factory_type(registry: *mut AtkRegistry, type_: GType) -> GType; pub fn atk_registry_set_factory_type( registry: *mut AtkRegistry, type_: GType, factory_type: GType, ); //========================================================================= // AtkRelation //========================================================================= pub fn atk_relation_get_type() -> GType; pub fn atk_relation_new( targets: *mut *mut AtkObject, n_targets: c_int, relationship: AtkRelationType, ) -> *mut AtkRelation; pub fn atk_relation_add_target(relation: *mut AtkRelation, target: *mut AtkObject); pub fn atk_relation_get_relation_type(relation: *mut AtkRelation) -> AtkRelationType; pub fn atk_relation_get_target(relation: *mut AtkRelation) -> *mut glib::GPtrArray; pub fn atk_relation_remove_target( relation: *mut AtkRelation, target: *mut AtkObject, ) -> gboolean; //========================================================================= // AtkRelationSet //========================================================================= pub fn atk_relation_set_get_type() -> GType; pub fn atk_relation_set_new() -> *mut AtkRelationSet; pub fn atk_relation_set_add(set: *mut AtkRelationSet, relation: *mut AtkRelation); pub fn atk_relation_set_add_relation_by_type( set: *mut AtkRelationSet, relationship: AtkRelationType, target: *mut AtkObject, ); pub fn atk_relation_set_contains( set: *mut AtkRelationSet, relationship: AtkRelationType, ) -> gboolean; pub fn atk_relation_set_contains_target( set: *mut AtkRelationSet, relationship: AtkRelationType, target: *mut AtkObject, ) -> gboolean; pub fn atk_relation_set_get_n_relations(set: *mut AtkRelationSet) -> c_int; pub fn atk_relation_set_get_relation(set: *mut AtkRelationSet, i: c_int) -> *mut AtkRelation; pub fn atk_relation_set_get_relation_by_type( set: *mut AtkRelationSet, relationship: AtkRelationType, ) -> *mut AtkRelation; pub fn atk_relation_set_remove(set: *mut AtkRelationSet, relation: *mut AtkRelation); //========================================================================= // AtkSocket //========================================================================= pub fn atk_socket_get_type() -> GType; pub fn atk_socket_new() -> *mut AtkObject; pub fn atk_socket_embed(obj: *mut AtkSocket, plug_id: *const c_char); pub fn atk_socket_is_occupied(obj: *mut AtkSocket) -> gboolean; //========================================================================= // AtkStateSet //========================================================================= pub fn atk_state_set_get_type() -> GType; pub fn atk_state_set_new() -> *mut AtkStateSet; pub fn atk_state_set_add_state(set: *mut AtkStateSet, type_: AtkStateType) -> gboolean; pub fn atk_state_set_add_states( set: *mut AtkStateSet, types: *mut AtkStateType, n_types: c_int, ); pub fn atk_state_set_and_sets( set: *mut AtkStateSet, compare_set: *mut AtkStateSet, ) -> *mut AtkStateSet; pub fn atk_state_set_clear_states(set: *mut AtkStateSet); pub fn atk_state_set_contains_state(set: *mut AtkStateSet, type_: AtkStateType) -> gboolean; pub fn atk_state_set_contains_states( set: *mut AtkStateSet, types: *mut AtkStateType, n_types: c_int, ) -> gboolean; pub fn atk_state_set_is_empty(set: *mut AtkStateSet) -> gboolean; pub fn atk_state_set_or_sets( set: *mut AtkStateSet, compare_set: *mut AtkStateSet, ) -> *mut AtkStateSet; pub fn atk_state_set_remove_state(set: *mut AtkStateSet, type_: AtkStateType) -> gboolean; pub fn atk_state_set_xor_sets( set: *mut AtkStateSet, compare_set: *mut AtkStateSet, ) -> *mut AtkStateSet; //========================================================================= // AtkUtil //========================================================================= pub fn atk_util_get_type() -> GType; //========================================================================= // AtkAction //========================================================================= pub fn atk_action_get_type() -> GType; pub fn atk_action_do_action(action: *mut AtkAction, i: c_int) -> gboolean; pub fn atk_action_get_description(action: *mut AtkAction, i: c_int) -> *const c_char; pub fn atk_action_get_keybinding(action: *mut AtkAction, i: c_int) -> *const c_char; pub fn atk_action_get_localized_name(action: *mut AtkAction, i: c_int) -> *const c_char; pub fn atk_action_get_n_actions(action: *mut AtkAction) -> c_int; pub fn atk_action_get_name(action: *mut AtkAction, i: c_int) -> *const c_char; pub fn atk_action_set_description( action: *mut AtkAction, i: c_int, desc: *const c_char, ) -> gboolean; //========================================================================= // AtkComponent //========================================================================= pub fn atk_component_get_type() -> GType; pub fn atk_component_add_focus_handler( component: *mut AtkComponent, handler: AtkFocusHandler, ) -> c_uint; pub fn atk_component_contains( component: *mut AtkComponent, x: c_int, y: c_int, coord_type: AtkCoordType, ) -> gboolean; pub fn atk_component_get_alpha(component: *mut AtkComponent) -> c_double; pub fn atk_component_get_extents( component: *mut AtkComponent, x: *mut c_int, y: *mut c_int, width: *mut c_int, height: *mut c_int, coord_type: AtkCoordType, ); pub fn atk_component_get_layer(component: *mut AtkComponent) -> AtkLayer; pub fn atk_component_get_mdi_zorder(component: *mut AtkComponent) -> c_int; pub fn atk_component_get_position( component: *mut AtkComponent, x: *mut c_int, y: *mut c_int, coord_type: AtkCoordType, ); pub fn atk_component_get_size( component: *mut AtkComponent, width: *mut c_int, height: *mut c_int, ); pub fn atk_component_grab_focus(component: *mut AtkComponent) -> gboolean; pub fn atk_component_ref_accessible_at_point( component: *mut AtkComponent, x: c_int, y: c_int, coord_type: AtkCoordType, ) -> *mut AtkObject; pub fn atk_component_remove_focus_handler(component: *mut AtkComponent, handler_id: c_uint); #[cfg(feature = "v2_30")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_30")))] pub fn atk_component_scroll_to(component: *mut AtkComponent, type_: AtkScrollType) -> gboolean; #[cfg(feature = "v2_30")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_30")))] pub fn atk_component_scroll_to_point( component: *mut AtkComponent, coords: AtkCoordType, x: c_int, y: c_int, ) -> gboolean; pub fn atk_component_set_extents( component: *mut AtkComponent, x: c_int, y: c_int, width: c_int, height: c_int, coord_type: AtkCoordType, ) -> gboolean; pub fn atk_component_set_position( component: *mut AtkComponent, x: c_int, y: c_int, coord_type: AtkCoordType, ) -> gboolean; pub fn atk_component_set_size( component: *mut AtkComponent, width: c_int, height: c_int, ) -> gboolean; //========================================================================= // AtkDocument //========================================================================= pub fn atk_document_get_type() -> GType; pub fn atk_document_get_attribute_value( document: *mut AtkDocument, attribute_name: *const c_char, ) -> *const c_char; pub fn atk_document_get_attributes(document: *mut AtkDocument) -> *mut AtkAttributeSet; pub fn atk_document_get_current_page_number(document: *mut AtkDocument) -> c_int; pub fn atk_document_get_document(document: *mut AtkDocument) -> gpointer; pub fn atk_document_get_document_type(document: *mut AtkDocument) -> *const c_char; pub fn atk_document_get_locale(document: *mut AtkDocument) -> *const c_char; pub fn atk_document_get_page_count(document: *mut AtkDocument) -> c_int; pub fn atk_document_set_attribute_value( document: *mut AtkDocument, attribute_name: *const c_char, attribute_value: *const c_char, ) -> gboolean; //========================================================================= // AtkEditableText //========================================================================= pub fn atk_editable_text_get_type() -> GType; pub fn atk_editable_text_copy_text( text: *mut AtkEditableText, start_pos: c_int, end_pos: c_int, ); pub fn atk_editable_text_cut_text(text: *mut AtkEditableText, start_pos: c_int, end_pos: c_int); pub fn atk_editable_text_delete_text( text: *mut AtkEditableText, start_pos: c_int, end_pos: c_int, ); pub fn atk_editable_text_insert_text( text: *mut AtkEditableText, string: *const c_char, length: c_int, position: *mut c_int, ); pub fn atk_editable_text_paste_text(text: *mut AtkEditableText, position: c_int); pub fn atk_editable_text_set_run_attributes( text: *mut AtkEditableText, attrib_set: *mut AtkAttributeSet, start_offset: c_int, end_offset: c_int, ) -> gboolean; pub fn atk_editable_text_set_text_contents(text: *mut AtkEditableText, string: *const c_char); //========================================================================= // AtkHyperlinkImpl //========================================================================= pub fn atk_hyperlink_impl_get_type() -> GType; pub fn atk_hyperlink_impl_get_hyperlink(impl_: *mut AtkHyperlinkImpl) -> *mut AtkHyperlink; //========================================================================= // AtkHypertext //========================================================================= pub fn atk_hypertext_get_type() -> GType; pub fn atk_hypertext_get_link( hypertext: *mut AtkHypertext, link_index: c_int, ) -> *mut AtkHyperlink; pub fn atk_hypertext_get_link_index(hypertext: *mut AtkHypertext, char_index: c_int) -> c_int; pub fn atk_hypertext_get_n_links(hypertext: *mut AtkHypertext) -> c_int; //========================================================================= // AtkImage //========================================================================= pub fn atk_image_get_type() -> GType; pub fn atk_image_get_image_description(image: *mut AtkImage) -> *const c_char; pub fn atk_image_get_image_locale(image: *mut AtkImage) -> *const c_char; pub fn atk_image_get_image_position( image: *mut AtkImage, x: *mut c_int, y: *mut c_int, coord_type: AtkCoordType, ); pub fn atk_image_get_image_size(image: *mut AtkImage, width: *mut c_int, height: *mut c_int); pub fn atk_image_set_image_description( image: *mut AtkImage, description: *const c_char, ) -> gboolean; //========================================================================= // AtkImplementorIface //========================================================================= pub fn atk_implementor_get_type() -> GType; //========================================================================= // AtkSelection //========================================================================= pub fn atk_selection_get_type() -> GType; pub fn atk_selection_add_selection(selection: *mut AtkSelection, i: c_int) -> gboolean; pub fn atk_selection_clear_selection(selection: *mut AtkSelection) -> gboolean; pub fn atk_selection_get_selection_count(selection: *mut AtkSelection) -> c_int; pub fn atk_selection_is_child_selected(selection: *mut AtkSelection, i: c_int) -> gboolean; pub fn atk_selection_ref_selection(selection: *mut AtkSelection, i: c_int) -> *mut AtkObject; pub fn atk_selection_remove_selection(selection: *mut AtkSelection, i: c_int) -> gboolean; pub fn atk_selection_select_all_selection(selection: *mut AtkSelection) -> gboolean; //========================================================================= // AtkStreamableContent //========================================================================= pub fn atk_streamable_content_get_type() -> GType; pub fn atk_streamable_content_get_mime_type( streamable: *mut AtkStreamableContent, i: c_int, ) -> *const c_char; pub fn atk_streamable_content_get_n_mime_types(streamable: *mut AtkStreamableContent) -> c_int; pub fn atk_streamable_content_get_stream( streamable: *mut AtkStreamableContent, mime_type: *const c_char, ) -> *mut glib::GIOChannel; pub fn atk_streamable_content_get_uri( streamable: *mut AtkStreamableContent, mime_type: *const c_char, ) -> *const c_char; //========================================================================= // AtkTable //========================================================================= pub fn atk_table_get_type() -> GType; pub fn atk_table_add_column_selection(table: *mut AtkTable, column: c_int) -> gboolean; pub fn atk_table_add_row_selection(table: *mut AtkTable, row: c_int) -> gboolean; pub fn atk_table_get_caption(table: *mut AtkTable) -> *mut AtkObject; pub fn atk_table_get_column_at_index(table: *mut AtkTable, index_: c_int) -> c_int; pub fn atk_table_get_column_description(table: *mut AtkTable, column: c_int) -> *const c_char; pub fn atk_table_get_column_extent_at(table: *mut AtkTable, row: c_int, column: c_int) -> c_int; pub fn atk_table_get_column_header(table: *mut AtkTable, column: c_int) -> *mut AtkObject; pub fn atk_table_get_index_at(table: *mut AtkTable, row: c_int, column: c_int) -> c_int; pub fn atk_table_get_n_columns(table: *mut AtkTable) -> c_int; pub fn atk_table_get_n_rows(table: *mut AtkTable) -> c_int; pub fn atk_table_get_row_at_index(table: *mut AtkTable, index_: c_int) -> c_int; pub fn atk_table_get_row_description(table: *mut AtkTable, row: c_int) -> *const c_char; pub fn atk_table_get_row_extent_at(table: *mut AtkTable, row: c_int, column: c_int) -> c_int; pub fn atk_table_get_row_header(table: *mut AtkTable, row: c_int) -> *mut AtkObject; pub fn atk_table_get_selected_columns(table: *mut AtkTable, selected: *mut *mut c_int) -> c_int; pub fn atk_table_get_selected_rows(table: *mut AtkTable, selected: *mut *mut c_int) -> c_int; pub fn atk_table_get_summary(table: *mut AtkTable) -> *mut AtkObject; pub fn atk_table_is_column_selected(table: *mut AtkTable, column: c_int) -> gboolean; pub fn atk_table_is_row_selected(table: *mut AtkTable, row: c_int) -> gboolean; pub fn atk_table_is_selected(table: *mut AtkTable, row: c_int, column: c_int) -> gboolean; pub fn atk_table_ref_at(table: *mut AtkTable, row: c_int, column: c_int) -> *mut AtkObject; pub fn atk_table_remove_column_selection(table: *mut AtkTable, column: c_int) -> gboolean; pub fn atk_table_remove_row_selection(table: *mut AtkTable, row: c_int) -> gboolean; pub fn atk_table_set_caption(table: *mut AtkTable, caption: *mut AtkObject); pub fn atk_table_set_column_description( table: *mut AtkTable, column: c_int, description: *const c_char, ); pub fn atk_table_set_column_header(table: *mut AtkTable, column: c_int, header: *mut AtkObject); pub fn atk_table_set_row_description( table: *mut AtkTable, row: c_int, description: *const c_char, ); pub fn atk_table_set_row_header(table: *mut AtkTable, row: c_int, header: *mut AtkObject); pub fn atk_table_set_summary(table: *mut AtkTable, accessible: *mut AtkObject); //========================================================================= // AtkTableCell //========================================================================= pub fn atk_table_cell_get_type() -> GType; pub fn atk_table_cell_get_column_header_cells(cell: *mut AtkTableCell) -> *mut glib::GPtrArray; pub fn atk_table_cell_get_column_span(cell: *mut AtkTableCell) -> c_int; pub fn atk_table_cell_get_position( cell: *mut AtkTableCell, row: *mut c_int, column: *mut c_int, ) -> gboolean; pub fn atk_table_cell_get_row_column_span( cell: *mut AtkTableCell, row: *mut c_int, column: *mut c_int, row_span: *mut c_int, column_span: *mut c_int, ) -> gboolean; pub fn atk_table_cell_get_row_header_cells(cell: *mut AtkTableCell) -> *mut glib::GPtrArray; pub fn atk_table_cell_get_row_span(cell: *mut AtkTableCell) -> c_int; pub fn atk_table_cell_get_table(cell: *mut AtkTableCell) -> *mut AtkObject; //========================================================================= // AtkText //========================================================================= pub fn atk_text_get_type() -> GType; pub fn atk_text_free_ranges(ranges: *mut *mut AtkTextRange); pub fn atk_text_add_selection( text: *mut AtkText, start_offset: c_int, end_offset: c_int, ) -> gboolean; pub fn atk_text_get_bounded_ranges( text: *mut AtkText, rect: *mut AtkTextRectangle, coord_type: AtkCoordType, x_clip_type: AtkTextClipType, y_clip_type: AtkTextClipType, ) -> *mut *mut AtkTextRange; pub fn atk_text_get_caret_offset(text: *mut AtkText) -> c_int; pub fn atk_text_get_character_at_offset(text: *mut AtkText, offset: c_int) -> u32; pub fn atk_text_get_character_count(text: *mut AtkText) -> c_int; pub fn atk_text_get_character_extents( text: *mut AtkText, offset: c_int, x: *mut c_int, y: *mut c_int, width: *mut c_int, height: *mut c_int, coords: AtkCoordType, ); pub fn atk_text_get_default_attributes(text: *mut AtkText) -> *mut AtkAttributeSet; pub fn atk_text_get_n_selections(text: *mut AtkText) -> c_int; pub fn atk_text_get_offset_at_point( text: *mut AtkText, x: c_int, y: c_int, coords: AtkCoordType, ) -> c_int; pub fn atk_text_get_range_extents( text: *mut AtkText, start_offset: c_int, end_offset: c_int, coord_type: AtkCoordType, rect: *mut AtkTextRectangle, ); pub fn atk_text_get_run_attributes( text: *mut AtkText, offset: c_int, start_offset: *mut c_int, end_offset: *mut c_int, ) -> *mut AtkAttributeSet; pub fn atk_text_get_selection( text: *mut AtkText, selection_num: c_int, start_offset: *mut c_int, end_offset: *mut c_int, ) -> *mut c_char; pub fn atk_text_get_string_at_offset( text: *mut AtkText, offset: c_int, granularity: AtkTextGranularity, start_offset: *mut c_int, end_offset: *mut c_int, ) -> *mut c_char; pub fn atk_text_get_text( text: *mut AtkText, start_offset: c_int, end_offset: c_int, ) -> *mut c_char; pub fn atk_text_get_text_after_offset( text: *mut AtkText, offset: c_int, boundary_type: AtkTextBoundary, start_offset: *mut c_int, end_offset: *mut c_int, ) -> *mut c_char; pub fn atk_text_get_text_at_offset( text: *mut AtkText, offset: c_int, boundary_type: AtkTextBoundary, start_offset: *mut c_int, end_offset: *mut c_int, ) -> *mut c_char; pub fn atk_text_get_text_before_offset( text: *mut AtkText, offset: c_int, boundary_type: AtkTextBoundary, start_offset: *mut c_int, end_offset: *mut c_int, ) -> *mut c_char; pub fn atk_text_remove_selection(text: *mut AtkText, selection_num: c_int) -> gboolean; #[cfg(feature = "v2_32")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_32")))] pub fn atk_text_scroll_substring_to( text: *mut AtkText, start_offset: c_int, end_offset: c_int, type_: AtkScrollType, ) -> gboolean; #[cfg(feature = "v2_32")] #[cfg_attr(docsrs, doc(cfg(feature = "v2_32")))] pub fn atk_text_scroll_substring_to_point( text: *mut AtkText, start_offset: c_int, end_offset: c_int, coords: AtkCoordType, x: c_int, y: c_int, ) -> gboolean; pub fn atk_text_set_caret_offset(text: *mut AtkText, offset: c_int) -> gboolean; pub fn atk_text_set_selection( text: *mut AtkText, selection_num: c_int, start_offset: c_int, end_offset: c_int, ) -> gboolean; //========================================================================= // AtkValue //========================================================================= pub fn atk_value_get_type() -> GType; pub fn atk_value_get_current_value(obj: *mut AtkValue, value: *mut gobject::GValue); pub fn atk_value_get_increment(obj: *mut AtkValue) -> c_double; pub fn atk_value_get_maximum_value(obj: *mut AtkValue, value: *mut gobject::GValue); pub fn atk_value_get_minimum_increment(obj: *mut AtkValue, value: *mut gobject::GValue); pub fn atk_value_get_minimum_value(obj: *mut AtkValue, value: *mut gobject::GValue); pub fn atk_value_get_range(obj: *mut AtkValue) -> *mut AtkRange; pub fn atk_value_get_sub_ranges(obj: *mut AtkValue) -> *mut glib::GSList; pub fn atk_value_get_value_and_text( obj: *mut AtkValue, value: *mut c_double, text: *mut *mut c_char, ); pub fn atk_value_set_current_value( obj: *mut AtkValue, value: *const gobject::GValue, ) -> gboolean; pub fn atk_value_set_value(obj: *mut AtkValue, new_value: c_double); //========================================================================= // AtkWindow //========================================================================= pub fn atk_window_get_type() -> GType; //========================================================================= // Other functions //========================================================================= pub fn atk_add_focus_tracker(focus_tracker: AtkEventListener) -> c_uint; pub fn atk_add_global_event_listener( listener: gobject::GSignalEmissionHook, event_type: *const c_char, ) -> c_uint; pub fn atk_add_key_event_listener(listener: AtkKeySnoopFunc, data: gpointer) -> c_uint; pub fn atk_focus_tracker_init(init: AtkEventListenerInit); pub fn atk_focus_tracker_notify(object: *mut AtkObject); pub fn atk_get_binary_age() -> c_uint; pub fn atk_get_default_registry() -> *mut AtkRegistry; pub fn atk_get_focus_object() -> *mut AtkObject; pub fn atk_get_interface_age() -> c_uint; pub fn atk_get_major_version() -> c_uint; pub fn atk_get_micro_version() -> c_uint; pub fn atk_get_minor_version() -> c_uint; pub fn atk_get_root() -> *mut AtkObject; pub fn atk_get_toolkit_name() -> *const c_char; pub fn atk_get_toolkit_version() -> *const c_char; pub fn atk_get_version() -> *const c_char; pub fn atk_remove_focus_tracker(tracker_id: c_uint); pub fn atk_remove_global_event_listener(listener_id: c_uint); pub fn atk_remove_key_event_listener(listener_id: c_uint); } rust-atk-sys-0.18-0.18.0/tests/000077500000000000000000000000001467506151000157215ustar00rootroot00000000000000rust-atk-sys-0.18-0.18.0/tests/abi.rs000066400000000000000000000702231467506151000170260ustar00rootroot00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT #![cfg(unix)] use atk_sys::*; use std::env; use std::error::Error; use std::ffi::OsString; use std::mem::{align_of, size_of}; use std::path::Path; use std::process::Command; use std::str; use tempfile::Builder; static PACKAGES: &[&str] = &["atk"]; #[derive(Clone, Debug)] struct Compiler { pub args: Vec, } impl Compiler { pub fn new() -> Result> { let mut args = get_var("CC", "cc")?; args.push("-Wno-deprecated-declarations".to_owned()); // For _Generic args.push("-std=c11".to_owned()); // For %z support in printf when using MinGW. args.push("-D__USE_MINGW_ANSI_STDIO".to_owned()); args.extend(get_var("CFLAGS", "")?); args.extend(get_var("CPPFLAGS", "")?); args.extend(pkg_config_cflags(PACKAGES)?); Ok(Self { args }) } pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box> { let mut cmd = self.to_command(); cmd.arg(src); cmd.arg("-o"); cmd.arg(out); let status = cmd.spawn()?.wait()?; if !status.success() { return Err(format!("compilation command {cmd:?} failed, {status}").into()); } Ok(()) } fn to_command(&self) -> Command { let mut cmd = Command::new(&self.args[0]); cmd.args(&self.args[1..]); cmd } } fn get_var(name: &str, default: &str) -> Result, Box> { match env::var(name) { Ok(value) => Ok(shell_words::split(&value)?), Err(env::VarError::NotPresent) => Ok(shell_words::split(default)?), Err(err) => Err(format!("{name} {err}").into()), } } fn pkg_config_cflags(packages: &[&str]) -> Result, Box> { if packages.is_empty() { return Ok(Vec::new()); } let pkg_config = env::var_os("PKG_CONFIG").unwrap_or_else(|| OsString::from("pkg-config")); let mut cmd = Command::new(pkg_config); cmd.arg("--cflags"); cmd.args(packages); let out = cmd.output()?; if !out.status.success() { return Err(format!("command {cmd:?} returned {}", out.status).into()); } let stdout = str::from_utf8(&out.stdout)?; Ok(shell_words::split(stdout.trim())?) } #[derive(Copy, Clone, Debug, Eq, PartialEq)] struct Layout { size: usize, alignment: usize, } #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] struct Results { /// Number of successfully completed tests. passed: usize, /// Total number of failed tests (including those that failed to compile). failed: usize, } impl Results { fn record_passed(&mut self) { self.passed += 1; } fn record_failed(&mut self) { self.failed += 1; } fn summary(&self) -> String { format!("{} passed; {} failed", self.passed, self.failed) } fn expect_total_success(&self) { if self.failed == 0 { println!("OK: {}", self.summary()); } else { panic!("FAILED: {}", self.summary()); }; } } #[test] fn cross_validate_constants_with_c() { let mut c_constants: Vec<(String, String)> = Vec::new(); for l in get_c_output("constant").unwrap().lines() { let (name, value) = l.split_once(';').expect("Missing ';' separator"); c_constants.push((name.to_owned(), value.to_owned())); } let mut results = Results::default(); for ((rust_name, rust_value), (c_name, c_value)) in RUST_CONSTANTS.iter().zip(c_constants.iter()) { if rust_name != c_name { results.record_failed(); eprintln!("Name mismatch:\nRust: {rust_name:?}\nC: {c_name:?}"); continue; } if rust_value != c_value { results.record_failed(); eprintln!( "Constant value mismatch for {rust_name}\nRust: {rust_value:?}\nC: {c_value:?}", ); continue; } results.record_passed(); } results.expect_total_success(); } #[test] fn cross_validate_layout_with_c() { let mut c_layouts = Vec::new(); for l in get_c_output("layout").unwrap().lines() { let (name, value) = l.split_once(';').expect("Missing first ';' separator"); let (size, alignment) = value.split_once(';').expect("Missing second ';' separator"); let size = size.parse().expect("Failed to parse size"); let alignment = alignment.parse().expect("Failed to parse alignment"); c_layouts.push((name.to_owned(), Layout { size, alignment })); } let mut results = Results::default(); for ((rust_name, rust_layout), (c_name, c_layout)) in RUST_LAYOUTS.iter().zip(c_layouts.iter()) { if rust_name != c_name { results.record_failed(); eprintln!("Name mismatch:\nRust: {rust_name:?}\nC: {c_name:?}"); continue; } if rust_layout != c_layout { results.record_failed(); eprintln!("Layout mismatch for {rust_name}\nRust: {rust_layout:?}\nC: {c_layout:?}",); continue; } results.record_passed(); } results.expect_total_success(); } fn get_c_output(name: &str) -> Result> { let tmpdir = Builder::new().prefix("abi").tempdir()?; let exe = tmpdir.path().join(name); let c_file = Path::new("tests").join(name).with_extension("c"); let cc = Compiler::new().expect("configured compiler"); cc.compile(&c_file, &exe)?; let mut abi_cmd = Command::new(exe); let output = abi_cmd.output()?; if !output.status.success() { return Err(format!("command {abi_cmd:?} failed, {output:?}").into()); } Ok(String::from_utf8(output.stdout)?) } const RUST_LAYOUTS: &[(&str, Layout)] = &[ ( "AtkActionIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkAttribute", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkAttributeSet", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkComponentIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkCoordType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkDocumentIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkEditableTextIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkGObjectAccessible", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkGObjectAccessibleClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkHyperlink", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkHyperlinkClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkHyperlinkImplIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkHyperlinkStateFlags", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkHypertextIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkImageIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkKeyEventStruct", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkKeyEventType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkLayer", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkLive", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkMisc", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkMiscClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkNoOpObject", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkNoOpObjectClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkNoOpObjectFactory", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkNoOpObjectFactoryClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkObject", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkObjectClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkObjectFactory", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkObjectFactoryClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkPlug", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkPlugClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkPropertyValues", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRectangle", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRegistry", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRegistryClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRelation", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRelationClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRelationSet", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRelationSetClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRelationType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkRole", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkScrollType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkSelectionIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkSocket", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkSocketClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkState", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkStateSet", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkStateSetClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkStateType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkStreamableContentIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTableCellIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTableIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTextAttribute", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTextBoundary", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTextClipType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTextGranularity", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTextIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTextRange", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkTextRectangle", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkUtil", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkUtilClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkValueIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkValueType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "AtkWindowIface", Layout { size: size_of::(), alignment: align_of::(), }, ), ]; const RUST_CONSTANTS: &[(&str, &str)] = &[ ("(guint) ATK_HYPERLINK_IS_INLINE", "1"), ("(gint) ATK_KEY_EVENT_LAST_DEFINED", "2"), ("(gint) ATK_KEY_EVENT_PRESS", "0"), ("(gint) ATK_KEY_EVENT_RELEASE", "1"), ("(gint) ATK_LAYER_BACKGROUND", "1"), ("(gint) ATK_LAYER_CANVAS", "2"), ("(gint) ATK_LAYER_INVALID", "0"), ("(gint) ATK_LAYER_MDI", "4"), ("(gint) ATK_LAYER_OVERLAY", "6"), ("(gint) ATK_LAYER_POPUP", "5"), ("(gint) ATK_LAYER_WIDGET", "3"), ("(gint) ATK_LAYER_WINDOW", "7"), ("(gint) ATK_LIVE_ASSERTIVE", "2"), ("(gint) ATK_LIVE_NONE", "0"), ("(gint) ATK_LIVE_POLITE", "1"), ("(gint) ATK_RELATION_CONTROLLED_BY", "1"), ("(gint) ATK_RELATION_CONTROLLER_FOR", "2"), ("(gint) ATK_RELATION_DESCRIBED_BY", "14"), ("(gint) ATK_RELATION_DESCRIPTION_FOR", "15"), ("(gint) ATK_RELATION_DETAILS", "17"), ("(gint) ATK_RELATION_DETAILS_FOR", "18"), ("(gint) ATK_RELATION_EMBEDDED_BY", "11"), ("(gint) ATK_RELATION_EMBEDS", "10"), ("(gint) ATK_RELATION_ERROR_FOR", "20"), ("(gint) ATK_RELATION_ERROR_MESSAGE", "19"), ("(gint) ATK_RELATION_FLOWS_FROM", "8"), ("(gint) ATK_RELATION_FLOWS_TO", "7"), ("(gint) ATK_RELATION_LABELLED_BY", "4"), ("(gint) ATK_RELATION_LABEL_FOR", "3"), ("(gint) ATK_RELATION_LAST_DEFINED", "21"), ("(gint) ATK_RELATION_MEMBER_OF", "5"), ("(gint) ATK_RELATION_NODE_CHILD_OF", "6"), ("(gint) ATK_RELATION_NODE_PARENT_OF", "16"), ("(gint) ATK_RELATION_NULL", "0"), ("(gint) ATK_RELATION_PARENT_WINDOW_OF", "13"), ("(gint) ATK_RELATION_POPUP_FOR", "12"), ("(gint) ATK_RELATION_SUBWINDOW_OF", "9"), ("(gint) ATK_ROLE_ACCEL_LABEL", "1"), ("(gint) ATK_ROLE_ALERT", "2"), ("(gint) ATK_ROLE_ANIMATION", "3"), ("(gint) ATK_ROLE_APPLICATION", "73"), ("(gint) ATK_ROLE_ARROW", "4"), ("(gint) ATK_ROLE_ARTICLE", "107"), ("(gint) ATK_ROLE_AUDIO", "104"), ("(gint) ATK_ROLE_AUTOCOMPLETE", "74"), ("(gint) ATK_ROLE_BLOCK_QUOTE", "103"), ("(gint) ATK_ROLE_CALENDAR", "5"), ("(gint) ATK_ROLE_CANVAS", "6"), ("(gint) ATK_ROLE_CAPTION", "79"), ("(gint) ATK_ROLE_CHART", "78"), ("(gint) ATK_ROLE_CHECK_BOX", "7"), ("(gint) ATK_ROLE_CHECK_MENU_ITEM", "8"), ("(gint) ATK_ROLE_COLOR_CHOOSER", "9"), ("(gint) ATK_ROLE_COLUMN_HEADER", "10"), ("(gint) ATK_ROLE_COMBO_BOX", "11"), ("(gint) ATK_ROLE_COMMENT", "95"), ("(gint) ATK_ROLE_CONTENT_DELETION", "123"), ("(gint) ATK_ROLE_CONTENT_INSERTION", "124"), ("(gint) ATK_ROLE_DATE_EDITOR", "12"), ("(gint) ATK_ROLE_DEFINITION", "106"), ("(gint) ATK_ROLE_DESCRIPTION_LIST", "114"), ("(gint) ATK_ROLE_DESCRIPTION_TERM", "115"), ("(gint) ATK_ROLE_DESCRIPTION_VALUE", "116"), ("(gint) ATK_ROLE_DESKTOP_FRAME", "14"), ("(gint) ATK_ROLE_DESKTOP_ICON", "13"), ("(gint) ATK_ROLE_DIAL", "15"), ("(gint) ATK_ROLE_DIALOG", "16"), ("(gint) ATK_ROLE_DIRECTORY_PANE", "17"), ("(gint) ATK_ROLE_DOCUMENT_EMAIL", "94"), ("(gint) ATK_ROLE_DOCUMENT_FRAME", "80"), ("(gint) ATK_ROLE_DOCUMENT_PRESENTATION", "91"), ("(gint) ATK_ROLE_DOCUMENT_SPREADSHEET", "90"), ("(gint) ATK_ROLE_DOCUMENT_TEXT", "92"), ("(gint) ATK_ROLE_DOCUMENT_WEB", "93"), ("(gint) ATK_ROLE_DRAWING_AREA", "18"), ("(gint) ATK_ROLE_EDITBAR", "75"), ("(gint) ATK_ROLE_EMBEDDED", "76"), ("(gint) ATK_ROLE_ENTRY", "77"), ("(gint) ATK_ROLE_FILE_CHOOSER", "19"), ("(gint) ATK_ROLE_FILLER", "20"), ("(gint) ATK_ROLE_FONT_CHOOSER", "21"), ("(gint) ATK_ROLE_FOOTER", "70"), ("(gint) ATK_ROLE_FOOTNOTE", "122"), ("(gint) ATK_ROLE_FORM", "85"), ("(gint) ATK_ROLE_FRAME", "22"), ("(gint) ATK_ROLE_GLASS_PANE", "23"), ("(gint) ATK_ROLE_GROUPING", "97"), ("(gint) ATK_ROLE_HEADER", "69"), ("(gint) ATK_ROLE_HEADING", "81"), ("(gint) ATK_ROLE_HTML_CONTAINER", "24"), ("(gint) ATK_ROLE_ICON", "25"), ("(gint) ATK_ROLE_IMAGE", "26"), ("(gint) ATK_ROLE_IMAGE_MAP", "98"), ("(gint) ATK_ROLE_INFO_BAR", "100"), ("(gint) ATK_ROLE_INPUT_METHOD_WINDOW", "87"), ("(gint) ATK_ROLE_INTERNAL_FRAME", "27"), ("(gint) ATK_ROLE_INVALID", "0"), ("(gint) ATK_ROLE_LABEL", "28"), ("(gint) ATK_ROLE_LANDMARK", "108"), ("(gint) ATK_ROLE_LAST_DEFINED", "128"), ("(gint) ATK_ROLE_LAYERED_PANE", "29"), ("(gint) ATK_ROLE_LEVEL_BAR", "101"), ("(gint) ATK_ROLE_LINK", "86"), ("(gint) ATK_ROLE_LIST", "30"), ("(gint) ATK_ROLE_LIST_BOX", "96"), ("(gint) ATK_ROLE_LIST_ITEM", "31"), ("(gint) ATK_ROLE_LOG", "109"), ("(gint) ATK_ROLE_MARK", "125"), ("(gint) ATK_ROLE_MARQUEE", "110"), ("(gint) ATK_ROLE_MATH", "111"), ("(gint) ATK_ROLE_MATH_FRACTION", "118"), ("(gint) ATK_ROLE_MATH_ROOT", "119"), ("(gint) ATK_ROLE_MENU", "32"), ("(gint) ATK_ROLE_MENU_BAR", "33"), ("(gint) ATK_ROLE_MENU_ITEM", "34"), ("(gint) ATK_ROLE_NOTIFICATION", "99"), ("(gint) ATK_ROLE_OPTION_PANE", "35"), ("(gint) ATK_ROLE_PAGE", "82"), ("(gint) ATK_ROLE_PAGE_TAB", "36"), ("(gint) ATK_ROLE_PAGE_TAB_LIST", "37"), ("(gint) ATK_ROLE_PANEL", "38"), ("(gint) ATK_ROLE_PARAGRAPH", "71"), ("(gint) ATK_ROLE_PASSWORD_TEXT", "39"), ("(gint) ATK_ROLE_POPUP_MENU", "40"), ("(gint) ATK_ROLE_PROGRESS_BAR", "41"), ("(gint) ATK_ROLE_PUSH_BUTTON", "42"), ("(gint) ATK_ROLE_PUSH_BUTTON_MENU", "127"), ("(gint) ATK_ROLE_RADIO_BUTTON", "43"), ("(gint) ATK_ROLE_RADIO_MENU_ITEM", "44"), ("(gint) ATK_ROLE_RATING", "112"), ("(gint) ATK_ROLE_REDUNDANT_OBJECT", "84"), ("(gint) ATK_ROLE_ROOT_PANE", "45"), ("(gint) ATK_ROLE_ROW_HEADER", "46"), ("(gint) ATK_ROLE_RULER", "72"), ("(gint) ATK_ROLE_SCROLL_BAR", "47"), ("(gint) ATK_ROLE_SCROLL_PANE", "48"), ("(gint) ATK_ROLE_SECTION", "83"), ("(gint) ATK_ROLE_SEPARATOR", "49"), ("(gint) ATK_ROLE_SLIDER", "50"), ("(gint) ATK_ROLE_SPIN_BUTTON", "52"), ("(gint) ATK_ROLE_SPLIT_PANE", "51"), ("(gint) ATK_ROLE_STATIC", "117"), ("(gint) ATK_ROLE_STATUSBAR", "53"), ("(gint) ATK_ROLE_SUBSCRIPT", "120"), ("(gint) ATK_ROLE_SUGGESTION", "126"), ("(gint) ATK_ROLE_SUPERSCRIPT", "121"), ("(gint) ATK_ROLE_TABLE", "54"), ("(gint) ATK_ROLE_TABLE_CELL", "55"), ("(gint) ATK_ROLE_TABLE_COLUMN_HEADER", "56"), ("(gint) ATK_ROLE_TABLE_ROW", "88"), ("(gint) ATK_ROLE_TABLE_ROW_HEADER", "57"), ("(gint) ATK_ROLE_TEAR_OFF_MENU_ITEM", "58"), ("(gint) ATK_ROLE_TERMINAL", "59"), ("(gint) ATK_ROLE_TEXT", "60"), ("(gint) ATK_ROLE_TIMER", "113"), ("(gint) ATK_ROLE_TITLE_BAR", "102"), ("(gint) ATK_ROLE_TOGGLE_BUTTON", "61"), ("(gint) ATK_ROLE_TOOL_BAR", "62"), ("(gint) ATK_ROLE_TOOL_TIP", "63"), ("(gint) ATK_ROLE_TREE", "64"), ("(gint) ATK_ROLE_TREE_ITEM", "89"), ("(gint) ATK_ROLE_TREE_TABLE", "65"), ("(gint) ATK_ROLE_UNKNOWN", "66"), ("(gint) ATK_ROLE_VIDEO", "105"), ("(gint) ATK_ROLE_VIEWPORT", "67"), ("(gint) ATK_ROLE_WINDOW", "68"), ("(gint) ATK_SCROLL_ANYWHERE", "6"), ("(gint) ATK_SCROLL_BOTTOM_EDGE", "3"), ("(gint) ATK_SCROLL_BOTTOM_RIGHT", "1"), ("(gint) ATK_SCROLL_LEFT_EDGE", "4"), ("(gint) ATK_SCROLL_RIGHT_EDGE", "5"), ("(gint) ATK_SCROLL_TOP_EDGE", "2"), ("(gint) ATK_SCROLL_TOP_LEFT", "0"), ("(gint) ATK_STATE_ACTIVE", "1"), ("(gint) ATK_STATE_ANIMATED", "37"), ("(gint) ATK_STATE_ARMED", "2"), ("(gint) ATK_STATE_BUSY", "3"), ("(gint) ATK_STATE_CHECKABLE", "39"), ("(gint) ATK_STATE_CHECKED", "4"), ("(gint) ATK_STATE_COLLAPSED", "43"), ("(gint) ATK_STATE_DEFAULT", "36"), ("(gint) ATK_STATE_DEFUNCT", "5"), ("(gint) ATK_STATE_EDITABLE", "6"), ("(gint) ATK_STATE_ENABLED", "7"), ("(gint) ATK_STATE_EXPANDABLE", "8"), ("(gint) ATK_STATE_EXPANDED", "9"), ("(gint) ATK_STATE_FOCUSABLE", "10"), ("(gint) ATK_STATE_FOCUSED", "11"), ("(gint) ATK_STATE_HAS_POPUP", "40"), ("(gint) ATK_STATE_HAS_TOOLTIP", "41"), ("(gint) ATK_STATE_HORIZONTAL", "12"), ("(gint) ATK_STATE_ICONIFIED", "13"), ("(gint) ATK_STATE_INDETERMINATE", "30"), ("(gint) ATK_STATE_INVALID", "0"), ("(gint) ATK_STATE_INVALID_ENTRY", "33"), ("(gint) ATK_STATE_LAST_DEFINED", "44"), ("(gint) ATK_STATE_MANAGES_DESCENDANTS", "29"), ("(gint) ATK_STATE_MODAL", "14"), ("(gint) ATK_STATE_MULTISELECTABLE", "16"), ("(gint) ATK_STATE_MULTI_LINE", "15"), ("(gint) ATK_STATE_OPAQUE", "17"), ("(gint) ATK_STATE_PRESSED", "18"), ("(gint) ATK_STATE_READ_ONLY", "42"), ("(gint) ATK_STATE_REQUIRED", "32"), ("(gint) ATK_STATE_RESIZABLE", "19"), ("(gint) ATK_STATE_SELECTABLE", "20"), ("(gint) ATK_STATE_SELECTABLE_TEXT", "35"), ("(gint) ATK_STATE_SELECTED", "21"), ("(gint) ATK_STATE_SENSITIVE", "22"), ("(gint) ATK_STATE_SHOWING", "23"), ("(gint) ATK_STATE_SINGLE_LINE", "24"), ("(gint) ATK_STATE_STALE", "25"), ("(gint) ATK_STATE_SUPPORTS_AUTOCOMPLETION", "34"), ("(gint) ATK_STATE_TRANSIENT", "26"), ("(gint) ATK_STATE_TRUNCATED", "31"), ("(gint) ATK_STATE_VERTICAL", "27"), ("(gint) ATK_STATE_VISIBLE", "28"), ("(gint) ATK_STATE_VISITED", "38"), ("(gint) ATK_TEXT_ATTR_BG_COLOR", "18"), ("(gint) ATK_TEXT_ATTR_BG_FULL_HEIGHT", "9"), ("(gint) ATK_TEXT_ATTR_BG_STIPPLE", "20"), ("(gint) ATK_TEXT_ATTR_DIRECTION", "23"), ("(gint) ATK_TEXT_ATTR_EDITABLE", "5"), ("(gint) ATK_TEXT_ATTR_FAMILY_NAME", "17"), ("(gint) ATK_TEXT_ATTR_FG_COLOR", "19"), ("(gint) ATK_TEXT_ATTR_FG_STIPPLE", "21"), ("(gint) ATK_TEXT_ATTR_INDENT", "3"), ("(gint) ATK_TEXT_ATTR_INVALID", "0"), ("(gint) ATK_TEXT_ATTR_INVISIBLE", "4"), ("(gint) ATK_TEXT_ATTR_JUSTIFICATION", "24"), ("(gint) ATK_TEXT_ATTR_LANGUAGE", "16"), ("(gint) ATK_TEXT_ATTR_LAST_DEFINED", "29"), ("(gint) ATK_TEXT_ATTR_LEFT_MARGIN", "1"), ("(gint) ATK_TEXT_ATTR_PIXELS_ABOVE_LINES", "6"), ("(gint) ATK_TEXT_ATTR_PIXELS_BELOW_LINES", "7"), ("(gint) ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP", "8"), ("(gint) ATK_TEXT_ATTR_RIGHT_MARGIN", "2"), ("(gint) ATK_TEXT_ATTR_RISE", "10"), ("(gint) ATK_TEXT_ATTR_SCALE", "14"), ("(gint) ATK_TEXT_ATTR_SIZE", "13"), ("(gint) ATK_TEXT_ATTR_STRETCH", "25"), ("(gint) ATK_TEXT_ATTR_STRIKETHROUGH", "12"), ("(gint) ATK_TEXT_ATTR_STYLE", "27"), ("(gint) ATK_TEXT_ATTR_TEXT_POSITION", "28"), ("(gint) ATK_TEXT_ATTR_UNDERLINE", "11"), ("(gint) ATK_TEXT_ATTR_VARIANT", "26"), ("(gint) ATK_TEXT_ATTR_WEIGHT", "15"), ("(gint) ATK_TEXT_ATTR_WRAP_MODE", "22"), ("(gint) ATK_TEXT_BOUNDARY_CHAR", "0"), ("(gint) ATK_TEXT_BOUNDARY_LINE_END", "6"), ("(gint) ATK_TEXT_BOUNDARY_LINE_START", "5"), ("(gint) ATK_TEXT_BOUNDARY_SENTENCE_END", "4"), ("(gint) ATK_TEXT_BOUNDARY_SENTENCE_START", "3"), ("(gint) ATK_TEXT_BOUNDARY_WORD_END", "2"), ("(gint) ATK_TEXT_BOUNDARY_WORD_START", "1"), ("(gint) ATK_TEXT_CLIP_BOTH", "3"), ("(gint) ATK_TEXT_CLIP_MAX", "2"), ("(gint) ATK_TEXT_CLIP_MIN", "1"), ("(gint) ATK_TEXT_CLIP_NONE", "0"), ("(gint) ATK_TEXT_GRANULARITY_CHAR", "0"), ("(gint) ATK_TEXT_GRANULARITY_LINE", "3"), ("(gint) ATK_TEXT_GRANULARITY_PARAGRAPH", "4"), ("(gint) ATK_TEXT_GRANULARITY_SENTENCE", "2"), ("(gint) ATK_TEXT_GRANULARITY_WORD", "1"), ("(gint) ATK_VALUE_ACCEPTABLE", "2"), ("(gint) ATK_VALUE_BAD", "11"), ("(gint) ATK_VALUE_BEST", "14"), ("(gint) ATK_VALUE_GOOD", "12"), ("(gint) ATK_VALUE_HIGH", "8"), ("(gint) ATK_VALUE_LAST_DEFINED", "15"), ("(gint) ATK_VALUE_LOW", "6"), ("(gint) ATK_VALUE_MEDIUM", "7"), ("(gint) ATK_VALUE_STRONG", "3"), ("(gint) ATK_VALUE_VERY_BAD", "10"), ("(gint) ATK_VALUE_VERY_GOOD", "13"), ("(gint) ATK_VALUE_VERY_HIGH", "9"), ("(gint) ATK_VALUE_VERY_LOW", "5"), ("(gint) ATK_VALUE_VERY_STRONG", "4"), ("(gint) ATK_VALUE_VERY_WEAK", "0"), ("(gint) ATK_VALUE_WEAK", "1"), ("(gint) ATK_XY_PARENT", "2"), ("(gint) ATK_XY_SCREEN", "0"), ("(gint) ATK_XY_WINDOW", "1"), ]; rust-atk-sys-0.18-0.18.0/tests/constant.c000066400000000000000000000347531467506151000177320ustar00rootroot00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT #include "manual.h" #include #define PRINT_CONSTANT(CONSTANT_NAME) \ printf("%s;", #CONSTANT_NAME); \ printf(_Generic((CONSTANT_NAME), \ char *: "%s", \ const char *: "%s", \ char: "%c", \ signed char: "%hhd", \ unsigned char: "%hhu", \ short int: "%hd", \ unsigned short int: "%hu", \ int: "%d", \ unsigned int: "%u", \ long: "%ld", \ unsigned long: "%lu", \ long long: "%lld", \ unsigned long long: "%llu", \ float: "%f", \ double: "%f", \ long double: "%ld"), \ CONSTANT_NAME); \ printf("\n"); int main() { PRINT_CONSTANT((guint) ATK_HYPERLINK_IS_INLINE); PRINT_CONSTANT((gint) ATK_KEY_EVENT_LAST_DEFINED); PRINT_CONSTANT((gint) ATK_KEY_EVENT_PRESS); PRINT_CONSTANT((gint) ATK_KEY_EVENT_RELEASE); PRINT_CONSTANT((gint) ATK_LAYER_BACKGROUND); PRINT_CONSTANT((gint) ATK_LAYER_CANVAS); PRINT_CONSTANT((gint) ATK_LAYER_INVALID); PRINT_CONSTANT((gint) ATK_LAYER_MDI); PRINT_CONSTANT((gint) ATK_LAYER_OVERLAY); PRINT_CONSTANT((gint) ATK_LAYER_POPUP); PRINT_CONSTANT((gint) ATK_LAYER_WIDGET); PRINT_CONSTANT((gint) ATK_LAYER_WINDOW); PRINT_CONSTANT((gint) ATK_LIVE_ASSERTIVE); PRINT_CONSTANT((gint) ATK_LIVE_NONE); PRINT_CONSTANT((gint) ATK_LIVE_POLITE); PRINT_CONSTANT((gint) ATK_RELATION_CONTROLLED_BY); PRINT_CONSTANT((gint) ATK_RELATION_CONTROLLER_FOR); PRINT_CONSTANT((gint) ATK_RELATION_DESCRIBED_BY); PRINT_CONSTANT((gint) ATK_RELATION_DESCRIPTION_FOR); PRINT_CONSTANT((gint) ATK_RELATION_DETAILS); PRINT_CONSTANT((gint) ATK_RELATION_DETAILS_FOR); PRINT_CONSTANT((gint) ATK_RELATION_EMBEDDED_BY); PRINT_CONSTANT((gint) ATK_RELATION_EMBEDS); PRINT_CONSTANT((gint) ATK_RELATION_ERROR_FOR); PRINT_CONSTANT((gint) ATK_RELATION_ERROR_MESSAGE); PRINT_CONSTANT((gint) ATK_RELATION_FLOWS_FROM); PRINT_CONSTANT((gint) ATK_RELATION_FLOWS_TO); PRINT_CONSTANT((gint) ATK_RELATION_LABELLED_BY); PRINT_CONSTANT((gint) ATK_RELATION_LABEL_FOR); PRINT_CONSTANT((gint) ATK_RELATION_LAST_DEFINED); PRINT_CONSTANT((gint) ATK_RELATION_MEMBER_OF); PRINT_CONSTANT((gint) ATK_RELATION_NODE_CHILD_OF); PRINT_CONSTANT((gint) ATK_RELATION_NODE_PARENT_OF); PRINT_CONSTANT((gint) ATK_RELATION_NULL); PRINT_CONSTANT((gint) ATK_RELATION_PARENT_WINDOW_OF); PRINT_CONSTANT((gint) ATK_RELATION_POPUP_FOR); PRINT_CONSTANT((gint) ATK_RELATION_SUBWINDOW_OF); PRINT_CONSTANT((gint) ATK_ROLE_ACCEL_LABEL); PRINT_CONSTANT((gint) ATK_ROLE_ALERT); PRINT_CONSTANT((gint) ATK_ROLE_ANIMATION); PRINT_CONSTANT((gint) ATK_ROLE_APPLICATION); PRINT_CONSTANT((gint) ATK_ROLE_ARROW); PRINT_CONSTANT((gint) ATK_ROLE_ARTICLE); PRINT_CONSTANT((gint) ATK_ROLE_AUDIO); PRINT_CONSTANT((gint) ATK_ROLE_AUTOCOMPLETE); PRINT_CONSTANT((gint) ATK_ROLE_BLOCK_QUOTE); PRINT_CONSTANT((gint) ATK_ROLE_CALENDAR); PRINT_CONSTANT((gint) ATK_ROLE_CANVAS); PRINT_CONSTANT((gint) ATK_ROLE_CAPTION); PRINT_CONSTANT((gint) ATK_ROLE_CHART); PRINT_CONSTANT((gint) ATK_ROLE_CHECK_BOX); PRINT_CONSTANT((gint) ATK_ROLE_CHECK_MENU_ITEM); PRINT_CONSTANT((gint) ATK_ROLE_COLOR_CHOOSER); PRINT_CONSTANT((gint) ATK_ROLE_COLUMN_HEADER); PRINT_CONSTANT((gint) ATK_ROLE_COMBO_BOX); PRINT_CONSTANT((gint) ATK_ROLE_COMMENT); PRINT_CONSTANT((gint) ATK_ROLE_CONTENT_DELETION); PRINT_CONSTANT((gint) ATK_ROLE_CONTENT_INSERTION); PRINT_CONSTANT((gint) ATK_ROLE_DATE_EDITOR); PRINT_CONSTANT((gint) ATK_ROLE_DEFINITION); PRINT_CONSTANT((gint) ATK_ROLE_DESCRIPTION_LIST); PRINT_CONSTANT((gint) ATK_ROLE_DESCRIPTION_TERM); PRINT_CONSTANT((gint) ATK_ROLE_DESCRIPTION_VALUE); PRINT_CONSTANT((gint) ATK_ROLE_DESKTOP_FRAME); PRINT_CONSTANT((gint) ATK_ROLE_DESKTOP_ICON); PRINT_CONSTANT((gint) ATK_ROLE_DIAL); PRINT_CONSTANT((gint) ATK_ROLE_DIALOG); PRINT_CONSTANT((gint) ATK_ROLE_DIRECTORY_PANE); PRINT_CONSTANT((gint) ATK_ROLE_DOCUMENT_EMAIL); PRINT_CONSTANT((gint) ATK_ROLE_DOCUMENT_FRAME); PRINT_CONSTANT((gint) ATK_ROLE_DOCUMENT_PRESENTATION); PRINT_CONSTANT((gint) ATK_ROLE_DOCUMENT_SPREADSHEET); PRINT_CONSTANT((gint) ATK_ROLE_DOCUMENT_TEXT); PRINT_CONSTANT((gint) ATK_ROLE_DOCUMENT_WEB); PRINT_CONSTANT((gint) ATK_ROLE_DRAWING_AREA); PRINT_CONSTANT((gint) ATK_ROLE_EDITBAR); PRINT_CONSTANT((gint) ATK_ROLE_EMBEDDED); PRINT_CONSTANT((gint) ATK_ROLE_ENTRY); PRINT_CONSTANT((gint) ATK_ROLE_FILE_CHOOSER); PRINT_CONSTANT((gint) ATK_ROLE_FILLER); PRINT_CONSTANT((gint) ATK_ROLE_FONT_CHOOSER); PRINT_CONSTANT((gint) ATK_ROLE_FOOTER); PRINT_CONSTANT((gint) ATK_ROLE_FOOTNOTE); PRINT_CONSTANT((gint) ATK_ROLE_FORM); PRINT_CONSTANT((gint) ATK_ROLE_FRAME); PRINT_CONSTANT((gint) ATK_ROLE_GLASS_PANE); PRINT_CONSTANT((gint) ATK_ROLE_GROUPING); PRINT_CONSTANT((gint) ATK_ROLE_HEADER); PRINT_CONSTANT((gint) ATK_ROLE_HEADING); PRINT_CONSTANT((gint) ATK_ROLE_HTML_CONTAINER); PRINT_CONSTANT((gint) ATK_ROLE_ICON); PRINT_CONSTANT((gint) ATK_ROLE_IMAGE); PRINT_CONSTANT((gint) ATK_ROLE_IMAGE_MAP); PRINT_CONSTANT((gint) ATK_ROLE_INFO_BAR); PRINT_CONSTANT((gint) ATK_ROLE_INPUT_METHOD_WINDOW); PRINT_CONSTANT((gint) ATK_ROLE_INTERNAL_FRAME); PRINT_CONSTANT((gint) ATK_ROLE_INVALID); PRINT_CONSTANT((gint) ATK_ROLE_LABEL); PRINT_CONSTANT((gint) ATK_ROLE_LANDMARK); PRINT_CONSTANT((gint) ATK_ROLE_LAST_DEFINED); PRINT_CONSTANT((gint) ATK_ROLE_LAYERED_PANE); PRINT_CONSTANT((gint) ATK_ROLE_LEVEL_BAR); PRINT_CONSTANT((gint) ATK_ROLE_LINK); PRINT_CONSTANT((gint) ATK_ROLE_LIST); PRINT_CONSTANT((gint) ATK_ROLE_LIST_BOX); PRINT_CONSTANT((gint) ATK_ROLE_LIST_ITEM); PRINT_CONSTANT((gint) ATK_ROLE_LOG); PRINT_CONSTANT((gint) ATK_ROLE_MARK); PRINT_CONSTANT((gint) ATK_ROLE_MARQUEE); PRINT_CONSTANT((gint) ATK_ROLE_MATH); PRINT_CONSTANT((gint) ATK_ROLE_MATH_FRACTION); PRINT_CONSTANT((gint) ATK_ROLE_MATH_ROOT); PRINT_CONSTANT((gint) ATK_ROLE_MENU); PRINT_CONSTANT((gint) ATK_ROLE_MENU_BAR); PRINT_CONSTANT((gint) ATK_ROLE_MENU_ITEM); PRINT_CONSTANT((gint) ATK_ROLE_NOTIFICATION); PRINT_CONSTANT((gint) ATK_ROLE_OPTION_PANE); PRINT_CONSTANT((gint) ATK_ROLE_PAGE); PRINT_CONSTANT((gint) ATK_ROLE_PAGE_TAB); PRINT_CONSTANT((gint) ATK_ROLE_PAGE_TAB_LIST); PRINT_CONSTANT((gint) ATK_ROLE_PANEL); PRINT_CONSTANT((gint) ATK_ROLE_PARAGRAPH); PRINT_CONSTANT((gint) ATK_ROLE_PASSWORD_TEXT); PRINT_CONSTANT((gint) ATK_ROLE_POPUP_MENU); PRINT_CONSTANT((gint) ATK_ROLE_PROGRESS_BAR); PRINT_CONSTANT((gint) ATK_ROLE_PUSH_BUTTON); PRINT_CONSTANT((gint) ATK_ROLE_PUSH_BUTTON_MENU); PRINT_CONSTANT((gint) ATK_ROLE_RADIO_BUTTON); PRINT_CONSTANT((gint) ATK_ROLE_RADIO_MENU_ITEM); PRINT_CONSTANT((gint) ATK_ROLE_RATING); PRINT_CONSTANT((gint) ATK_ROLE_REDUNDANT_OBJECT); PRINT_CONSTANT((gint) ATK_ROLE_ROOT_PANE); PRINT_CONSTANT((gint) ATK_ROLE_ROW_HEADER); PRINT_CONSTANT((gint) ATK_ROLE_RULER); PRINT_CONSTANT((gint) ATK_ROLE_SCROLL_BAR); PRINT_CONSTANT((gint) ATK_ROLE_SCROLL_PANE); PRINT_CONSTANT((gint) ATK_ROLE_SECTION); PRINT_CONSTANT((gint) ATK_ROLE_SEPARATOR); PRINT_CONSTANT((gint) ATK_ROLE_SLIDER); PRINT_CONSTANT((gint) ATK_ROLE_SPIN_BUTTON); PRINT_CONSTANT((gint) ATK_ROLE_SPLIT_PANE); PRINT_CONSTANT((gint) ATK_ROLE_STATIC); PRINT_CONSTANT((gint) ATK_ROLE_STATUSBAR); PRINT_CONSTANT((gint) ATK_ROLE_SUBSCRIPT); PRINT_CONSTANT((gint) ATK_ROLE_SUGGESTION); PRINT_CONSTANT((gint) ATK_ROLE_SUPERSCRIPT); PRINT_CONSTANT((gint) ATK_ROLE_TABLE); PRINT_CONSTANT((gint) ATK_ROLE_TABLE_CELL); PRINT_CONSTANT((gint) ATK_ROLE_TABLE_COLUMN_HEADER); PRINT_CONSTANT((gint) ATK_ROLE_TABLE_ROW); PRINT_CONSTANT((gint) ATK_ROLE_TABLE_ROW_HEADER); PRINT_CONSTANT((gint) ATK_ROLE_TEAR_OFF_MENU_ITEM); PRINT_CONSTANT((gint) ATK_ROLE_TERMINAL); PRINT_CONSTANT((gint) ATK_ROLE_TEXT); PRINT_CONSTANT((gint) ATK_ROLE_TIMER); PRINT_CONSTANT((gint) ATK_ROLE_TITLE_BAR); PRINT_CONSTANT((gint) ATK_ROLE_TOGGLE_BUTTON); PRINT_CONSTANT((gint) ATK_ROLE_TOOL_BAR); PRINT_CONSTANT((gint) ATK_ROLE_TOOL_TIP); PRINT_CONSTANT((gint) ATK_ROLE_TREE); PRINT_CONSTANT((gint) ATK_ROLE_TREE_ITEM); PRINT_CONSTANT((gint) ATK_ROLE_TREE_TABLE); PRINT_CONSTANT((gint) ATK_ROLE_UNKNOWN); PRINT_CONSTANT((gint) ATK_ROLE_VIDEO); PRINT_CONSTANT((gint) ATK_ROLE_VIEWPORT); PRINT_CONSTANT((gint) ATK_ROLE_WINDOW); PRINT_CONSTANT((gint) ATK_SCROLL_ANYWHERE); PRINT_CONSTANT((gint) ATK_SCROLL_BOTTOM_EDGE); PRINT_CONSTANT((gint) ATK_SCROLL_BOTTOM_RIGHT); PRINT_CONSTANT((gint) ATK_SCROLL_LEFT_EDGE); PRINT_CONSTANT((gint) ATK_SCROLL_RIGHT_EDGE); PRINT_CONSTANT((gint) ATK_SCROLL_TOP_EDGE); PRINT_CONSTANT((gint) ATK_SCROLL_TOP_LEFT); PRINT_CONSTANT((gint) ATK_STATE_ACTIVE); PRINT_CONSTANT((gint) ATK_STATE_ANIMATED); PRINT_CONSTANT((gint) ATK_STATE_ARMED); PRINT_CONSTANT((gint) ATK_STATE_BUSY); PRINT_CONSTANT((gint) ATK_STATE_CHECKABLE); PRINT_CONSTANT((gint) ATK_STATE_CHECKED); PRINT_CONSTANT((gint) ATK_STATE_COLLAPSED); PRINT_CONSTANT((gint) ATK_STATE_DEFAULT); PRINT_CONSTANT((gint) ATK_STATE_DEFUNCT); PRINT_CONSTANT((gint) ATK_STATE_EDITABLE); PRINT_CONSTANT((gint) ATK_STATE_ENABLED); PRINT_CONSTANT((gint) ATK_STATE_EXPANDABLE); PRINT_CONSTANT((gint) ATK_STATE_EXPANDED); PRINT_CONSTANT((gint) ATK_STATE_FOCUSABLE); PRINT_CONSTANT((gint) ATK_STATE_FOCUSED); PRINT_CONSTANT((gint) ATK_STATE_HAS_POPUP); PRINT_CONSTANT((gint) ATK_STATE_HAS_TOOLTIP); PRINT_CONSTANT((gint) ATK_STATE_HORIZONTAL); PRINT_CONSTANT((gint) ATK_STATE_ICONIFIED); PRINT_CONSTANT((gint) ATK_STATE_INDETERMINATE); PRINT_CONSTANT((gint) ATK_STATE_INVALID); PRINT_CONSTANT((gint) ATK_STATE_INVALID_ENTRY); PRINT_CONSTANT((gint) ATK_STATE_LAST_DEFINED); PRINT_CONSTANT((gint) ATK_STATE_MANAGES_DESCENDANTS); PRINT_CONSTANT((gint) ATK_STATE_MODAL); PRINT_CONSTANT((gint) ATK_STATE_MULTISELECTABLE); PRINT_CONSTANT((gint) ATK_STATE_MULTI_LINE); PRINT_CONSTANT((gint) ATK_STATE_OPAQUE); PRINT_CONSTANT((gint) ATK_STATE_PRESSED); PRINT_CONSTANT((gint) ATK_STATE_READ_ONLY); PRINT_CONSTANT((gint) ATK_STATE_REQUIRED); PRINT_CONSTANT((gint) ATK_STATE_RESIZABLE); PRINT_CONSTANT((gint) ATK_STATE_SELECTABLE); PRINT_CONSTANT((gint) ATK_STATE_SELECTABLE_TEXT); PRINT_CONSTANT((gint) ATK_STATE_SELECTED); PRINT_CONSTANT((gint) ATK_STATE_SENSITIVE); PRINT_CONSTANT((gint) ATK_STATE_SHOWING); PRINT_CONSTANT((gint) ATK_STATE_SINGLE_LINE); PRINT_CONSTANT((gint) ATK_STATE_STALE); PRINT_CONSTANT((gint) ATK_STATE_SUPPORTS_AUTOCOMPLETION); PRINT_CONSTANT((gint) ATK_STATE_TRANSIENT); PRINT_CONSTANT((gint) ATK_STATE_TRUNCATED); PRINT_CONSTANT((gint) ATK_STATE_VERTICAL); PRINT_CONSTANT((gint) ATK_STATE_VISIBLE); PRINT_CONSTANT((gint) ATK_STATE_VISITED); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_BG_COLOR); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_BG_FULL_HEIGHT); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_BG_STIPPLE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_DIRECTION); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_EDITABLE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_FAMILY_NAME); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_FG_COLOR); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_FG_STIPPLE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_INDENT); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_INVALID); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_INVISIBLE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_JUSTIFICATION); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_LANGUAGE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_LAST_DEFINED); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_LEFT_MARGIN); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_PIXELS_ABOVE_LINES); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_PIXELS_BELOW_LINES); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_RIGHT_MARGIN); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_RISE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_SCALE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_SIZE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_STRETCH); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_STRIKETHROUGH); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_STYLE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_TEXT_POSITION); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_UNDERLINE); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_VARIANT); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_WEIGHT); PRINT_CONSTANT((gint) ATK_TEXT_ATTR_WRAP_MODE); PRINT_CONSTANT((gint) ATK_TEXT_BOUNDARY_CHAR); PRINT_CONSTANT((gint) ATK_TEXT_BOUNDARY_LINE_END); PRINT_CONSTANT((gint) ATK_TEXT_BOUNDARY_LINE_START); PRINT_CONSTANT((gint) ATK_TEXT_BOUNDARY_SENTENCE_END); PRINT_CONSTANT((gint) ATK_TEXT_BOUNDARY_SENTENCE_START); PRINT_CONSTANT((gint) ATK_TEXT_BOUNDARY_WORD_END); PRINT_CONSTANT((gint) ATK_TEXT_BOUNDARY_WORD_START); PRINT_CONSTANT((gint) ATK_TEXT_CLIP_BOTH); PRINT_CONSTANT((gint) ATK_TEXT_CLIP_MAX); PRINT_CONSTANT((gint) ATK_TEXT_CLIP_MIN); PRINT_CONSTANT((gint) ATK_TEXT_CLIP_NONE); PRINT_CONSTANT((gint) ATK_TEXT_GRANULARITY_CHAR); PRINT_CONSTANT((gint) ATK_TEXT_GRANULARITY_LINE); PRINT_CONSTANT((gint) ATK_TEXT_GRANULARITY_PARAGRAPH); PRINT_CONSTANT((gint) ATK_TEXT_GRANULARITY_SENTENCE); PRINT_CONSTANT((gint) ATK_TEXT_GRANULARITY_WORD); PRINT_CONSTANT((gint) ATK_VALUE_ACCEPTABLE); PRINT_CONSTANT((gint) ATK_VALUE_BAD); PRINT_CONSTANT((gint) ATK_VALUE_BEST); PRINT_CONSTANT((gint) ATK_VALUE_GOOD); PRINT_CONSTANT((gint) ATK_VALUE_HIGH); PRINT_CONSTANT((gint) ATK_VALUE_LAST_DEFINED); PRINT_CONSTANT((gint) ATK_VALUE_LOW); PRINT_CONSTANT((gint) ATK_VALUE_MEDIUM); PRINT_CONSTANT((gint) ATK_VALUE_STRONG); PRINT_CONSTANT((gint) ATK_VALUE_VERY_BAD); PRINT_CONSTANT((gint) ATK_VALUE_VERY_GOOD); PRINT_CONSTANT((gint) ATK_VALUE_VERY_HIGH); PRINT_CONSTANT((gint) ATK_VALUE_VERY_LOW); PRINT_CONSTANT((gint) ATK_VALUE_VERY_STRONG); PRINT_CONSTANT((gint) ATK_VALUE_VERY_WEAK); PRINT_CONSTANT((gint) ATK_VALUE_WEAK); PRINT_CONSTANT((gint) ATK_XY_PARENT); PRINT_CONSTANT((gint) ATK_XY_SCREEN); PRINT_CONSTANT((gint) ATK_XY_WINDOW); return 0; } rust-atk-sys-0.18-0.18.0/tests/layout.c000066400000000000000000000144101467506151000174020ustar00rootroot00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT #include "manual.h" #include #include int main() { printf("%s;%zu;%zu\n", "AtkActionIface", sizeof(AtkActionIface), alignof(AtkActionIface)); printf("%s;%zu;%zu\n", "AtkAttribute", sizeof(AtkAttribute), alignof(AtkAttribute)); printf("%s;%zu;%zu\n", "AtkAttributeSet", sizeof(AtkAttributeSet), alignof(AtkAttributeSet)); printf("%s;%zu;%zu\n", "AtkComponentIface", sizeof(AtkComponentIface), alignof(AtkComponentIface)); printf("%s;%zu;%zu\n", "AtkCoordType", sizeof(AtkCoordType), alignof(AtkCoordType)); printf("%s;%zu;%zu\n", "AtkDocumentIface", sizeof(AtkDocumentIface), alignof(AtkDocumentIface)); printf("%s;%zu;%zu\n", "AtkEditableTextIface", sizeof(AtkEditableTextIface), alignof(AtkEditableTextIface)); printf("%s;%zu;%zu\n", "AtkGObjectAccessible", sizeof(AtkGObjectAccessible), alignof(AtkGObjectAccessible)); printf("%s;%zu;%zu\n", "AtkGObjectAccessibleClass", sizeof(AtkGObjectAccessibleClass), alignof(AtkGObjectAccessibleClass)); printf("%s;%zu;%zu\n", "AtkHyperlink", sizeof(AtkHyperlink), alignof(AtkHyperlink)); printf("%s;%zu;%zu\n", "AtkHyperlinkClass", sizeof(AtkHyperlinkClass), alignof(AtkHyperlinkClass)); printf("%s;%zu;%zu\n", "AtkHyperlinkImplIface", sizeof(AtkHyperlinkImplIface), alignof(AtkHyperlinkImplIface)); printf("%s;%zu;%zu\n", "AtkHyperlinkStateFlags", sizeof(AtkHyperlinkStateFlags), alignof(AtkHyperlinkStateFlags)); printf("%s;%zu;%zu\n", "AtkHypertextIface", sizeof(AtkHypertextIface), alignof(AtkHypertextIface)); printf("%s;%zu;%zu\n", "AtkImageIface", sizeof(AtkImageIface), alignof(AtkImageIface)); printf("%s;%zu;%zu\n", "AtkKeyEventStruct", sizeof(AtkKeyEventStruct), alignof(AtkKeyEventStruct)); printf("%s;%zu;%zu\n", "AtkKeyEventType", sizeof(AtkKeyEventType), alignof(AtkKeyEventType)); printf("%s;%zu;%zu\n", "AtkLayer", sizeof(AtkLayer), alignof(AtkLayer)); printf("%s;%zu;%zu\n", "AtkLive", sizeof(AtkLive), alignof(AtkLive)); printf("%s;%zu;%zu\n", "AtkMisc", sizeof(AtkMisc), alignof(AtkMisc)); printf("%s;%zu;%zu\n", "AtkMiscClass", sizeof(AtkMiscClass), alignof(AtkMiscClass)); printf("%s;%zu;%zu\n", "AtkNoOpObject", sizeof(AtkNoOpObject), alignof(AtkNoOpObject)); printf("%s;%zu;%zu\n", "AtkNoOpObjectClass", sizeof(AtkNoOpObjectClass), alignof(AtkNoOpObjectClass)); printf("%s;%zu;%zu\n", "AtkNoOpObjectFactory", sizeof(AtkNoOpObjectFactory), alignof(AtkNoOpObjectFactory)); printf("%s;%zu;%zu\n", "AtkNoOpObjectFactoryClass", sizeof(AtkNoOpObjectFactoryClass), alignof(AtkNoOpObjectFactoryClass)); printf("%s;%zu;%zu\n", "AtkObject", sizeof(AtkObject), alignof(AtkObject)); printf("%s;%zu;%zu\n", "AtkObjectClass", sizeof(AtkObjectClass), alignof(AtkObjectClass)); printf("%s;%zu;%zu\n", "AtkObjectFactory", sizeof(AtkObjectFactory), alignof(AtkObjectFactory)); printf("%s;%zu;%zu\n", "AtkObjectFactoryClass", sizeof(AtkObjectFactoryClass), alignof(AtkObjectFactoryClass)); printf("%s;%zu;%zu\n", "AtkPlug", sizeof(AtkPlug), alignof(AtkPlug)); printf("%s;%zu;%zu\n", "AtkPlugClass", sizeof(AtkPlugClass), alignof(AtkPlugClass)); printf("%s;%zu;%zu\n", "AtkPropertyValues", sizeof(AtkPropertyValues), alignof(AtkPropertyValues)); printf("%s;%zu;%zu\n", "AtkRectangle", sizeof(AtkRectangle), alignof(AtkRectangle)); printf("%s;%zu;%zu\n", "AtkRegistry", sizeof(AtkRegistry), alignof(AtkRegistry)); printf("%s;%zu;%zu\n", "AtkRegistryClass", sizeof(AtkRegistryClass), alignof(AtkRegistryClass)); printf("%s;%zu;%zu\n", "AtkRelation", sizeof(AtkRelation), alignof(AtkRelation)); printf("%s;%zu;%zu\n", "AtkRelationClass", sizeof(AtkRelationClass), alignof(AtkRelationClass)); printf("%s;%zu;%zu\n", "AtkRelationSet", sizeof(AtkRelationSet), alignof(AtkRelationSet)); printf("%s;%zu;%zu\n", "AtkRelationSetClass", sizeof(AtkRelationSetClass), alignof(AtkRelationSetClass)); printf("%s;%zu;%zu\n", "AtkRelationType", sizeof(AtkRelationType), alignof(AtkRelationType)); printf("%s;%zu;%zu\n", "AtkRole", sizeof(AtkRole), alignof(AtkRole)); printf("%s;%zu;%zu\n", "AtkScrollType", sizeof(AtkScrollType), alignof(AtkScrollType)); printf("%s;%zu;%zu\n", "AtkSelectionIface", sizeof(AtkSelectionIface), alignof(AtkSelectionIface)); printf("%s;%zu;%zu\n", "AtkSocket", sizeof(AtkSocket), alignof(AtkSocket)); printf("%s;%zu;%zu\n", "AtkSocketClass", sizeof(AtkSocketClass), alignof(AtkSocketClass)); printf("%s;%zu;%zu\n", "AtkState", sizeof(AtkState), alignof(AtkState)); printf("%s;%zu;%zu\n", "AtkStateSet", sizeof(AtkStateSet), alignof(AtkStateSet)); printf("%s;%zu;%zu\n", "AtkStateSetClass", sizeof(AtkStateSetClass), alignof(AtkStateSetClass)); printf("%s;%zu;%zu\n", "AtkStateType", sizeof(AtkStateType), alignof(AtkStateType)); printf("%s;%zu;%zu\n", "AtkStreamableContentIface", sizeof(AtkStreamableContentIface), alignof(AtkStreamableContentIface)); printf("%s;%zu;%zu\n", "AtkTableCellIface", sizeof(AtkTableCellIface), alignof(AtkTableCellIface)); printf("%s;%zu;%zu\n", "AtkTableIface", sizeof(AtkTableIface), alignof(AtkTableIface)); printf("%s;%zu;%zu\n", "AtkTextAttribute", sizeof(AtkTextAttribute), alignof(AtkTextAttribute)); printf("%s;%zu;%zu\n", "AtkTextBoundary", sizeof(AtkTextBoundary), alignof(AtkTextBoundary)); printf("%s;%zu;%zu\n", "AtkTextClipType", sizeof(AtkTextClipType), alignof(AtkTextClipType)); printf("%s;%zu;%zu\n", "AtkTextGranularity", sizeof(AtkTextGranularity), alignof(AtkTextGranularity)); printf("%s;%zu;%zu\n", "AtkTextIface", sizeof(AtkTextIface), alignof(AtkTextIface)); printf("%s;%zu;%zu\n", "AtkTextRange", sizeof(AtkTextRange), alignof(AtkTextRange)); printf("%s;%zu;%zu\n", "AtkTextRectangle", sizeof(AtkTextRectangle), alignof(AtkTextRectangle)); printf("%s;%zu;%zu\n", "AtkUtil", sizeof(AtkUtil), alignof(AtkUtil)); printf("%s;%zu;%zu\n", "AtkUtilClass", sizeof(AtkUtilClass), alignof(AtkUtilClass)); printf("%s;%zu;%zu\n", "AtkValueIface", sizeof(AtkValueIface), alignof(AtkValueIface)); printf("%s;%zu;%zu\n", "AtkValueType", sizeof(AtkValueType), alignof(AtkValueType)); printf("%s;%zu;%zu\n", "AtkWindowIface", sizeof(AtkWindowIface), alignof(AtkWindowIface)); return 0; } rust-atk-sys-0.18-0.18.0/tests/manual.h000066400000000000000000000001571467506151000173520ustar00rootroot00000000000000// Feel free to edit this file, it won't be regenerated by gir generator unless removed. #include rust-atk-sys-0.18-0.18.0/versions.txt000066400000000000000000000002041467506151000171640ustar00rootroot00000000000000Generated by gir (https://github.com/gtk-rs/gir @ 76bbe9b90aaa) from gir-files (https://github.com/gtk-rs/gir-files @ 307566e1ab58)