atk-sys-0.14.0/.cargo_vcs_info.json0000644000000001120000000000100125030ustar { "git": { "sha1": "329b4e09f5c8ee9aac3c284c0149206bbe5e8670" } } atk-sys-0.14.0/Cargo.toml0000644000000027320000000000100105130ustar # 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 believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] edition = "2018" name = "atk-sys" version = "0.14.0" authors = ["The gtk-rs Project Developers"] build = "build.rs" links = "atk-1.0" description = "FFI bindings to libatk-1" homepage = "http://gtk-rs.org/" keywords = ["atk", "ffi", "gtk-rs", "gnome"] license = "MIT" repository = "https://github.com/gtk-rs/gtk3-rs" [package.metadata.docs.rs] features = ["dox"] [package.metadata.system-deps.atk] name = "atk" version = "2.18" [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" [lib] name = "atk_sys" [dependencies.glib-sys] version = "0.14.0" [dependencies.gobject-sys] version = "0.14.0" [dependencies.libc] version = "0.2" [dev-dependencies.shell-words] version = "1.0.0" [dev-dependencies.tempfile] version = "3" [build-dependencies.system-deps] version = "3" [features] dox = [] v2_30 = [] v2_32 = ["v2_30"] v2_34 = ["v2_32"] atk-sys-0.14.0/Cargo.toml.orig000064400000000000000000000016360072674642500142260ustar 00000000000000[build-dependencies] system-deps = "3" [dependencies] libc = "0.2" [dependencies.glib-sys] version = "0.14.0" [dependencies.gobject-sys] version = "0.14.0" [dev-dependencies] shell-words = "1.0.0" tempfile = "3" [features] v2_30 = [] v2_32 = ["v2_30"] v2_34 = ["v2_32"] dox = [] [lib] name = "atk_sys" [package] authors = ["The gtk-rs Project Developers"] build = "build.rs" description = "FFI bindings to libatk-1" homepage = "http://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.14.0" edition = "2018" [package.metadata.docs.rs] features = ["dox"] [package.metadata.system-deps.atk] name = "atk" version = "2.18" [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" atk-sys-0.14.0/Gir.toml000064400000000000000000000005630072674642500127530ustar 00000000000000[options] work_mode = "sys" library = "Atk" version = "1.0" min_cfg_version = "2.18" 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", ] atk-sys-0.14.0/build.rs000064400000000000000000000007110072674642500127750ustar 00000000000000// 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(feature = "dox"))] use std::process; #[cfg(feature = "dox")] fn main() {} // prevent linking libraries to avoid documentation failure #[cfg(not(feature = "dox"))] fn main() { if let Err(s) = system_deps::Config::new().probe() { println!("cargo:warning={}", s); process::exit(1); } } atk-sys-0.14.0/src/lib.rs000064400000000000000000003200430072674642500132360ustar 00000000000000// 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(feature = "dox", feature(doc_cfg))] use glib_sys as glib; use gobject_sys as gobject; #[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, time_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 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_LAST_DEFINED: AtkRole = 127; 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; pub const ATK_STATE_LAST_DEFINED: 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 #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("name", &self.name) .field("value", &self.value) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .field("pad1", &self.pad1) .field("pad2", &self.pad2) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("get_hyperlink", &self.get_hyperlink) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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(c_void); pub type AtkImplementor = *mut _AtkImplementor; #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("threads_enter", &self.threads_enter) .field("threads_leave", &self.threads_leave) .field("vfuncs", &self.vfuncs) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .field("get_object_id", &self.get_object_id) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("property_name", &self.property_name) .field("old_value", &self.old_value) .field("new_value", &self.new_value) .finish() } } #[repr(C)] pub struct AtkRange(c_void); impl ::std::fmt::Debug for AtkRange { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("AtkRange @ {:p}", self)).finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("x", &self.x) .field("y", &self.y) .field("width", &self.width) .field("height", &self.height) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("pad1", &self.pad1) .field("pad2", &self.pad2) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent_class", &self.parent_class) .field("embed", &self.embed) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("bounds", &self.bounds) .field("start_offset", &self.start_offset) .field("end_offset", &self.end_offset) .field("content", &self.content) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("x", &self.x) .field("y", &self.y) .field("width", &self.width) .field("height", &self.height) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } // Classes #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .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() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("factory_type_registry", &self.factory_type_registry) .field("factory_singleton_cache", &self.factory_singleton_cache) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("target", &self.target) .field("relationship", &self.relationship) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .field("relations", &self.relations) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } #[repr(C)] #[derive(Copy, Clone)] 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 @ {:p}", self)) .field("parent", &self.parent) .finish() } } // Interfaces #[repr(C)] pub struct AtkAction(c_void); impl ::std::fmt::Debug for AtkAction { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkAction @ {:p}", self) } } #[repr(C)] pub struct AtkComponent(c_void); impl ::std::fmt::Debug for AtkComponent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkComponent @ {:p}", self) } } #[repr(C)] pub struct AtkDocument(c_void); impl ::std::fmt::Debug for AtkDocument { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkDocument @ {:p}", self) } } #[repr(C)] pub struct AtkEditableText(c_void); impl ::std::fmt::Debug for AtkEditableText { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkEditableText @ {:p}", self) } } #[repr(C)] pub struct AtkHyperlinkImpl(c_void); impl ::std::fmt::Debug for AtkHyperlinkImpl { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkHyperlinkImpl @ {:p}", self) } } #[repr(C)] pub struct AtkHypertext(c_void); impl ::std::fmt::Debug for AtkHypertext { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkHypertext @ {:p}", self) } } #[repr(C)] pub struct AtkImage(c_void); impl ::std::fmt::Debug for AtkImage { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkImage @ {:p}", self) } } #[repr(C)] pub struct AtkImplementorIface(c_void); impl ::std::fmt::Debug for AtkImplementorIface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkImplementorIface @ {:p}", self) } } #[repr(C)] pub struct AtkSelection(c_void); impl ::std::fmt::Debug for AtkSelection { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkSelection @ {:p}", self) } } #[repr(C)] pub struct AtkStreamableContent(c_void); impl ::std::fmt::Debug for AtkStreamableContent { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkStreamableContent @ {:p}", self) } } #[repr(C)] pub struct AtkTable(c_void); impl ::std::fmt::Debug for AtkTable { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkTable @ {:p}", self) } } #[repr(C)] pub struct AtkTableCell(c_void); impl ::std::fmt::Debug for AtkTableCell { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkTableCell @ {:p}", self) } } #[repr(C)] pub struct AtkText(c_void); impl ::std::fmt::Debug for AtkText { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkText @ {:p}", self) } } #[repr(C)] pub struct AtkValue(c_void); impl ::std::fmt::Debug for AtkValue { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkValue @ {:p}", self) } } #[repr(C)] pub struct AtkWindow(c_void); impl ::std::fmt::Debug for AtkWindow { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "AtkWindow @ {:p}", self) } } #[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; //========================================================================= // 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(any(feature = "v2_30", feature = "dox"))] #[cfg_attr(feature = "dox", 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(any(feature = "v2_34", feature = "dox"))] #[cfg_attr(feature = "dox", 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(any(feature = "v2_34", feature = "dox"))] #[cfg_attr(feature = "dox", 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(any(feature = "v2_30", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_30")))] pub fn atk_component_scroll_to(component: *mut AtkComponent, type_: AtkScrollType) -> gboolean; #[cfg(any(feature = "v2_30", feature = "dox"))] #[cfg_attr(feature = "dox", 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(any(feature = "v2_32", feature = "dox"))] #[cfg_attr(feature = "dox", 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(any(feature = "v2_32", feature = "dox"))] #[cfg_attr(feature = "dox", 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); } atk-sys-0.14.0/tests/abi.rs000064400000000000000000000701430072674642500136010ustar 00000000000000// 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 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 {:?} failed, {}", &cmd, 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 {:?} returned {}", &cmd, 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 mut words = l.trim().split(';'); let name = words.next().expect("Failed to parse name").to_owned(); let value = words .next() .and_then(|s| s.parse().ok()) .expect("Failed to parse value"); c_constants.push((name, value)); } 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: {:?}\nC: {:?}", rust_name, c_name,); continue; } if rust_value != c_value { results.record_failed(); eprintln!( "Constant value mismatch for {}\nRust: {:?}\nC: {:?}", rust_name, rust_value, &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 mut words = l.trim().split(';'); let name = words.next().expect("Failed to parse name").to_owned(); let size = words .next() .and_then(|s| s.parse().ok()) .expect("Failed to parse size"); let alignment = words .next() .and_then(|s| s.parse().ok()) .expect("Failed to parse alignment"); c_layouts.push((name, 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: {:?}\nC: {:?}", rust_name, c_name,); continue; } if rust_layout != c_layout { results.record_failed(); eprintln!( "Layout mismatch for {}\nRust: {:?}\nC: {:?}", rust_name, rust_layout, &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 {:?} failed, {:?}", &abi_cmd, &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::(), }, ), ( "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_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", "127"), ("(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_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_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", "43"), ("(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"), ]; atk-sys-0.14.0/tests/constant.c000064400000000000000000000344000072674642500144710ustar 00000000000000// 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_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_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_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; } atk-sys-0.14.0/tests/layout.c000064400000000000000000000142760072674642500141660ustar 00000000000000// 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", "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; } atk-sys-0.14.0/tests/manual.h000064400000000000000000000001570072674642500141240ustar 00000000000000// Feel free to edit this file, it won't be regenerated by gir generator unless removed. #include atk-sys-0.14.0/versions.txt000064400000000000000000000001720072674642500137420ustar 00000000000000Generated by gir (https://github.com/gtk-rs/gir @ 6ed30fc) from gir-files (https://github.com/gtk-rs/gir-files @ 7d95377)