atk_sys/
lib.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7    clippy::approx_constant,
8    clippy::type_complexity,
9    clippy::unreadable_literal
10)]
11
12extern crate glib_sys as glib;
13extern crate gobject_sys as gobject;
14extern crate libc;
15
16#[allow(unused_imports)]
17use libc::{
18    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
19    intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
20};
21
22#[allow(unused_imports)]
23use glib::{gboolean, gconstpointer, gpointer, GType};
24
25// Aliases
26pub type AtkAttributeSet = glib::GSList;
27pub type AtkState = u64;
28
29// Enums
30pub type AtkCoordType = c_int;
31pub const ATK_XY_SCREEN: AtkCoordType = 0;
32pub const ATK_XY_WINDOW: AtkCoordType = 1;
33pub const ATK_XY_PARENT: AtkCoordType = 2;
34
35pub type AtkKeyEventType = c_int;
36pub const ATK_KEY_EVENT_PRESS: AtkKeyEventType = 0;
37pub const ATK_KEY_EVENT_RELEASE: AtkKeyEventType = 1;
38pub const ATK_KEY_EVENT_LAST_DEFINED: AtkKeyEventType = 2;
39
40pub type AtkLayer = c_int;
41pub const ATK_LAYER_INVALID: AtkLayer = 0;
42pub const ATK_LAYER_BACKGROUND: AtkLayer = 1;
43pub const ATK_LAYER_CANVAS: AtkLayer = 2;
44pub const ATK_LAYER_WIDGET: AtkLayer = 3;
45pub const ATK_LAYER_MDI: AtkLayer = 4;
46pub const ATK_LAYER_POPUP: AtkLayer = 5;
47pub const ATK_LAYER_OVERLAY: AtkLayer = 6;
48pub const ATK_LAYER_WINDOW: AtkLayer = 7;
49
50pub type AtkRelationType = c_int;
51pub const ATK_RELATION_NULL: AtkRelationType = 0;
52pub const ATK_RELATION_CONTROLLED_BY: AtkRelationType = 1;
53pub const ATK_RELATION_CONTROLLER_FOR: AtkRelationType = 2;
54pub const ATK_RELATION_LABEL_FOR: AtkRelationType = 3;
55pub const ATK_RELATION_LABELLED_BY: AtkRelationType = 4;
56pub const ATK_RELATION_MEMBER_OF: AtkRelationType = 5;
57pub const ATK_RELATION_NODE_CHILD_OF: AtkRelationType = 6;
58pub const ATK_RELATION_FLOWS_TO: AtkRelationType = 7;
59pub const ATK_RELATION_FLOWS_FROM: AtkRelationType = 8;
60pub const ATK_RELATION_SUBWINDOW_OF: AtkRelationType = 9;
61pub const ATK_RELATION_EMBEDS: AtkRelationType = 10;
62pub const ATK_RELATION_EMBEDDED_BY: AtkRelationType = 11;
63pub const ATK_RELATION_POPUP_FOR: AtkRelationType = 12;
64pub const ATK_RELATION_PARENT_WINDOW_OF: AtkRelationType = 13;
65pub const ATK_RELATION_DESCRIBED_BY: AtkRelationType = 14;
66pub const ATK_RELATION_DESCRIPTION_FOR: AtkRelationType = 15;
67pub const ATK_RELATION_NODE_PARENT_OF: AtkRelationType = 16;
68pub const ATK_RELATION_DETAILS: AtkRelationType = 17;
69pub const ATK_RELATION_DETAILS_FOR: AtkRelationType = 18;
70pub const ATK_RELATION_ERROR_MESSAGE: AtkRelationType = 19;
71pub const ATK_RELATION_ERROR_FOR: AtkRelationType = 20;
72pub const ATK_RELATION_LAST_DEFINED: AtkRelationType = 21;
73
74pub type AtkRole = c_int;
75pub const ATK_ROLE_INVALID: AtkRole = 0;
76pub const ATK_ROLE_ACCEL_LABEL: AtkRole = 1;
77pub const ATK_ROLE_ALERT: AtkRole = 2;
78pub const ATK_ROLE_ANIMATION: AtkRole = 3;
79pub const ATK_ROLE_ARROW: AtkRole = 4;
80pub const ATK_ROLE_CALENDAR: AtkRole = 5;
81pub const ATK_ROLE_CANVAS: AtkRole = 6;
82pub const ATK_ROLE_CHECK_BOX: AtkRole = 7;
83pub const ATK_ROLE_CHECK_MENU_ITEM: AtkRole = 8;
84pub const ATK_ROLE_COLOR_CHOOSER: AtkRole = 9;
85pub const ATK_ROLE_COLUMN_HEADER: AtkRole = 10;
86pub const ATK_ROLE_COMBO_BOX: AtkRole = 11;
87pub const ATK_ROLE_DATE_EDITOR: AtkRole = 12;
88pub const ATK_ROLE_DESKTOP_ICON: AtkRole = 13;
89pub const ATK_ROLE_DESKTOP_FRAME: AtkRole = 14;
90pub const ATK_ROLE_DIAL: AtkRole = 15;
91pub const ATK_ROLE_DIALOG: AtkRole = 16;
92pub const ATK_ROLE_DIRECTORY_PANE: AtkRole = 17;
93pub const ATK_ROLE_DRAWING_AREA: AtkRole = 18;
94pub const ATK_ROLE_FILE_CHOOSER: AtkRole = 19;
95pub const ATK_ROLE_FILLER: AtkRole = 20;
96pub const ATK_ROLE_FONT_CHOOSER: AtkRole = 21;
97pub const ATK_ROLE_FRAME: AtkRole = 22;
98pub const ATK_ROLE_GLASS_PANE: AtkRole = 23;
99pub const ATK_ROLE_HTML_CONTAINER: AtkRole = 24;
100pub const ATK_ROLE_ICON: AtkRole = 25;
101pub const ATK_ROLE_IMAGE: AtkRole = 26;
102pub const ATK_ROLE_INTERNAL_FRAME: AtkRole = 27;
103pub const ATK_ROLE_LABEL: AtkRole = 28;
104pub const ATK_ROLE_LAYERED_PANE: AtkRole = 29;
105pub const ATK_ROLE_LIST: AtkRole = 30;
106pub const ATK_ROLE_LIST_ITEM: AtkRole = 31;
107pub const ATK_ROLE_MENU: AtkRole = 32;
108pub const ATK_ROLE_MENU_BAR: AtkRole = 33;
109pub const ATK_ROLE_MENU_ITEM: AtkRole = 34;
110pub const ATK_ROLE_OPTION_PANE: AtkRole = 35;
111pub const ATK_ROLE_PAGE_TAB: AtkRole = 36;
112pub const ATK_ROLE_PAGE_TAB_LIST: AtkRole = 37;
113pub const ATK_ROLE_PANEL: AtkRole = 38;
114pub const ATK_ROLE_PASSWORD_TEXT: AtkRole = 39;
115pub const ATK_ROLE_POPUP_MENU: AtkRole = 40;
116pub const ATK_ROLE_PROGRESS_BAR: AtkRole = 41;
117pub const ATK_ROLE_PUSH_BUTTON: AtkRole = 42;
118pub const ATK_ROLE_RADIO_BUTTON: AtkRole = 43;
119pub const ATK_ROLE_RADIO_MENU_ITEM: AtkRole = 44;
120pub const ATK_ROLE_ROOT_PANE: AtkRole = 45;
121pub const ATK_ROLE_ROW_HEADER: AtkRole = 46;
122pub const ATK_ROLE_SCROLL_BAR: AtkRole = 47;
123pub const ATK_ROLE_SCROLL_PANE: AtkRole = 48;
124pub const ATK_ROLE_SEPARATOR: AtkRole = 49;
125pub const ATK_ROLE_SLIDER: AtkRole = 50;
126pub const ATK_ROLE_SPLIT_PANE: AtkRole = 51;
127pub const ATK_ROLE_SPIN_BUTTON: AtkRole = 52;
128pub const ATK_ROLE_STATUSBAR: AtkRole = 53;
129pub const ATK_ROLE_TABLE: AtkRole = 54;
130pub const ATK_ROLE_TABLE_CELL: AtkRole = 55;
131pub const ATK_ROLE_TABLE_COLUMN_HEADER: AtkRole = 56;
132pub const ATK_ROLE_TABLE_ROW_HEADER: AtkRole = 57;
133pub const ATK_ROLE_TEAR_OFF_MENU_ITEM: AtkRole = 58;
134pub const ATK_ROLE_TERMINAL: AtkRole = 59;
135pub const ATK_ROLE_TEXT: AtkRole = 60;
136pub const ATK_ROLE_TOGGLE_BUTTON: AtkRole = 61;
137pub const ATK_ROLE_TOOL_BAR: AtkRole = 62;
138pub const ATK_ROLE_TOOL_TIP: AtkRole = 63;
139pub const ATK_ROLE_TREE: AtkRole = 64;
140pub const ATK_ROLE_TREE_TABLE: AtkRole = 65;
141pub const ATK_ROLE_UNKNOWN: AtkRole = 66;
142pub const ATK_ROLE_VIEWPORT: AtkRole = 67;
143pub const ATK_ROLE_WINDOW: AtkRole = 68;
144pub const ATK_ROLE_HEADER: AtkRole = 69;
145pub const ATK_ROLE_FOOTER: AtkRole = 70;
146pub const ATK_ROLE_PARAGRAPH: AtkRole = 71;
147pub const ATK_ROLE_RULER: AtkRole = 72;
148pub const ATK_ROLE_APPLICATION: AtkRole = 73;
149pub const ATK_ROLE_AUTOCOMPLETE: AtkRole = 74;
150pub const ATK_ROLE_EDITBAR: AtkRole = 75;
151pub const ATK_ROLE_EMBEDDED: AtkRole = 76;
152pub const ATK_ROLE_ENTRY: AtkRole = 77;
153pub const ATK_ROLE_CHART: AtkRole = 78;
154pub const ATK_ROLE_CAPTION: AtkRole = 79;
155pub const ATK_ROLE_DOCUMENT_FRAME: AtkRole = 80;
156pub const ATK_ROLE_HEADING: AtkRole = 81;
157pub const ATK_ROLE_PAGE: AtkRole = 82;
158pub const ATK_ROLE_SECTION: AtkRole = 83;
159pub const ATK_ROLE_REDUNDANT_OBJECT: AtkRole = 84;
160pub const ATK_ROLE_FORM: AtkRole = 85;
161pub const ATK_ROLE_LINK: AtkRole = 86;
162pub const ATK_ROLE_INPUT_METHOD_WINDOW: AtkRole = 87;
163pub const ATK_ROLE_TABLE_ROW: AtkRole = 88;
164pub const ATK_ROLE_TREE_ITEM: AtkRole = 89;
165pub const ATK_ROLE_DOCUMENT_SPREADSHEET: AtkRole = 90;
166pub const ATK_ROLE_DOCUMENT_PRESENTATION: AtkRole = 91;
167pub const ATK_ROLE_DOCUMENT_TEXT: AtkRole = 92;
168pub const ATK_ROLE_DOCUMENT_WEB: AtkRole = 93;
169pub const ATK_ROLE_DOCUMENT_EMAIL: AtkRole = 94;
170pub const ATK_ROLE_COMMENT: AtkRole = 95;
171pub const ATK_ROLE_LIST_BOX: AtkRole = 96;
172pub const ATK_ROLE_GROUPING: AtkRole = 97;
173pub const ATK_ROLE_IMAGE_MAP: AtkRole = 98;
174pub const ATK_ROLE_NOTIFICATION: AtkRole = 99;
175pub const ATK_ROLE_INFO_BAR: AtkRole = 100;
176pub const ATK_ROLE_LEVEL_BAR: AtkRole = 101;
177pub const ATK_ROLE_TITLE_BAR: AtkRole = 102;
178pub const ATK_ROLE_BLOCK_QUOTE: AtkRole = 103;
179pub const ATK_ROLE_AUDIO: AtkRole = 104;
180pub const ATK_ROLE_VIDEO: AtkRole = 105;
181pub const ATK_ROLE_DEFINITION: AtkRole = 106;
182pub const ATK_ROLE_ARTICLE: AtkRole = 107;
183pub const ATK_ROLE_LANDMARK: AtkRole = 108;
184pub const ATK_ROLE_LOG: AtkRole = 109;
185pub const ATK_ROLE_MARQUEE: AtkRole = 110;
186pub const ATK_ROLE_MATH: AtkRole = 111;
187pub const ATK_ROLE_RATING: AtkRole = 112;
188pub const ATK_ROLE_TIMER: AtkRole = 113;
189pub const ATK_ROLE_DESCRIPTION_LIST: AtkRole = 114;
190pub const ATK_ROLE_DESCRIPTION_TERM: AtkRole = 115;
191pub const ATK_ROLE_DESCRIPTION_VALUE: AtkRole = 116;
192pub const ATK_ROLE_STATIC: AtkRole = 117;
193pub const ATK_ROLE_MATH_FRACTION: AtkRole = 118;
194pub const ATK_ROLE_MATH_ROOT: AtkRole = 119;
195pub const ATK_ROLE_SUBSCRIPT: AtkRole = 120;
196pub const ATK_ROLE_SUPERSCRIPT: AtkRole = 121;
197pub const ATK_ROLE_FOOTNOTE: AtkRole = 122;
198pub const ATK_ROLE_LAST_DEFINED: AtkRole = 123;
199
200pub type AtkScrollType = c_int;
201pub const ATK_SCROLL_TOP_LEFT: AtkScrollType = 0;
202pub const ATK_SCROLL_BOTTOM_RIGHT: AtkScrollType = 1;
203pub const ATK_SCROLL_TOP_EDGE: AtkScrollType = 2;
204pub const ATK_SCROLL_BOTTOM_EDGE: AtkScrollType = 3;
205pub const ATK_SCROLL_LEFT_EDGE: AtkScrollType = 4;
206pub const ATK_SCROLL_RIGHT_EDGE: AtkScrollType = 5;
207pub const ATK_SCROLL_ANYWHERE: AtkScrollType = 6;
208
209pub type AtkStateType = c_int;
210pub const ATK_STATE_INVALID: AtkStateType = 0;
211pub const ATK_STATE_ACTIVE: AtkStateType = 1;
212pub const ATK_STATE_ARMED: AtkStateType = 2;
213pub const ATK_STATE_BUSY: AtkStateType = 3;
214pub const ATK_STATE_CHECKED: AtkStateType = 4;
215pub const ATK_STATE_DEFUNCT: AtkStateType = 5;
216pub const ATK_STATE_EDITABLE: AtkStateType = 6;
217pub const ATK_STATE_ENABLED: AtkStateType = 7;
218pub const ATK_STATE_EXPANDABLE: AtkStateType = 8;
219pub const ATK_STATE_EXPANDED: AtkStateType = 9;
220pub const ATK_STATE_FOCUSABLE: AtkStateType = 10;
221pub const ATK_STATE_FOCUSED: AtkStateType = 11;
222pub const ATK_STATE_HORIZONTAL: AtkStateType = 12;
223pub const ATK_STATE_ICONIFIED: AtkStateType = 13;
224pub const ATK_STATE_MODAL: AtkStateType = 14;
225pub const ATK_STATE_MULTI_LINE: AtkStateType = 15;
226pub const ATK_STATE_MULTISELECTABLE: AtkStateType = 16;
227pub const ATK_STATE_OPAQUE: AtkStateType = 17;
228pub const ATK_STATE_PRESSED: AtkStateType = 18;
229pub const ATK_STATE_RESIZABLE: AtkStateType = 19;
230pub const ATK_STATE_SELECTABLE: AtkStateType = 20;
231pub const ATK_STATE_SELECTED: AtkStateType = 21;
232pub const ATK_STATE_SENSITIVE: AtkStateType = 22;
233pub const ATK_STATE_SHOWING: AtkStateType = 23;
234pub const ATK_STATE_SINGLE_LINE: AtkStateType = 24;
235pub const ATK_STATE_STALE: AtkStateType = 25;
236pub const ATK_STATE_TRANSIENT: AtkStateType = 26;
237pub const ATK_STATE_VERTICAL: AtkStateType = 27;
238pub const ATK_STATE_VISIBLE: AtkStateType = 28;
239pub const ATK_STATE_MANAGES_DESCENDANTS: AtkStateType = 29;
240pub const ATK_STATE_INDETERMINATE: AtkStateType = 30;
241pub const ATK_STATE_TRUNCATED: AtkStateType = 31;
242pub const ATK_STATE_REQUIRED: AtkStateType = 32;
243pub const ATK_STATE_INVALID_ENTRY: AtkStateType = 33;
244pub const ATK_STATE_SUPPORTS_AUTOCOMPLETION: AtkStateType = 34;
245pub const ATK_STATE_SELECTABLE_TEXT: AtkStateType = 35;
246pub const ATK_STATE_DEFAULT: AtkStateType = 36;
247pub const ATK_STATE_ANIMATED: AtkStateType = 37;
248pub const ATK_STATE_VISITED: AtkStateType = 38;
249pub const ATK_STATE_CHECKABLE: AtkStateType = 39;
250pub const ATK_STATE_HAS_POPUP: AtkStateType = 40;
251pub const ATK_STATE_HAS_TOOLTIP: AtkStateType = 41;
252pub const ATK_STATE_READ_ONLY: AtkStateType = 42;
253pub const ATK_STATE_LAST_DEFINED: AtkStateType = 43;
254
255pub type AtkTextAttribute = c_int;
256pub const ATK_TEXT_ATTR_INVALID: AtkTextAttribute = 0;
257pub const ATK_TEXT_ATTR_LEFT_MARGIN: AtkTextAttribute = 1;
258pub const ATK_TEXT_ATTR_RIGHT_MARGIN: AtkTextAttribute = 2;
259pub const ATK_TEXT_ATTR_INDENT: AtkTextAttribute = 3;
260pub const ATK_TEXT_ATTR_INVISIBLE: AtkTextAttribute = 4;
261pub const ATK_TEXT_ATTR_EDITABLE: AtkTextAttribute = 5;
262pub const ATK_TEXT_ATTR_PIXELS_ABOVE_LINES: AtkTextAttribute = 6;
263pub const ATK_TEXT_ATTR_PIXELS_BELOW_LINES: AtkTextAttribute = 7;
264pub const ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP: AtkTextAttribute = 8;
265pub const ATK_TEXT_ATTR_BG_FULL_HEIGHT: AtkTextAttribute = 9;
266pub const ATK_TEXT_ATTR_RISE: AtkTextAttribute = 10;
267pub const ATK_TEXT_ATTR_UNDERLINE: AtkTextAttribute = 11;
268pub const ATK_TEXT_ATTR_STRIKETHROUGH: AtkTextAttribute = 12;
269pub const ATK_TEXT_ATTR_SIZE: AtkTextAttribute = 13;
270pub const ATK_TEXT_ATTR_SCALE: AtkTextAttribute = 14;
271pub const ATK_TEXT_ATTR_WEIGHT: AtkTextAttribute = 15;
272pub const ATK_TEXT_ATTR_LANGUAGE: AtkTextAttribute = 16;
273pub const ATK_TEXT_ATTR_FAMILY_NAME: AtkTextAttribute = 17;
274pub const ATK_TEXT_ATTR_BG_COLOR: AtkTextAttribute = 18;
275pub const ATK_TEXT_ATTR_FG_COLOR: AtkTextAttribute = 19;
276pub const ATK_TEXT_ATTR_BG_STIPPLE: AtkTextAttribute = 20;
277pub const ATK_TEXT_ATTR_FG_STIPPLE: AtkTextAttribute = 21;
278pub const ATK_TEXT_ATTR_WRAP_MODE: AtkTextAttribute = 22;
279pub const ATK_TEXT_ATTR_DIRECTION: AtkTextAttribute = 23;
280pub const ATK_TEXT_ATTR_JUSTIFICATION: AtkTextAttribute = 24;
281pub const ATK_TEXT_ATTR_STRETCH: AtkTextAttribute = 25;
282pub const ATK_TEXT_ATTR_VARIANT: AtkTextAttribute = 26;
283pub const ATK_TEXT_ATTR_STYLE: AtkTextAttribute = 27;
284pub const ATK_TEXT_ATTR_LAST_DEFINED: AtkTextAttribute = 28;
285
286pub type AtkTextBoundary = c_int;
287pub const ATK_TEXT_BOUNDARY_CHAR: AtkTextBoundary = 0;
288pub const ATK_TEXT_BOUNDARY_WORD_START: AtkTextBoundary = 1;
289pub const ATK_TEXT_BOUNDARY_WORD_END: AtkTextBoundary = 2;
290pub const ATK_TEXT_BOUNDARY_SENTENCE_START: AtkTextBoundary = 3;
291pub const ATK_TEXT_BOUNDARY_SENTENCE_END: AtkTextBoundary = 4;
292pub const ATK_TEXT_BOUNDARY_LINE_START: AtkTextBoundary = 5;
293pub const ATK_TEXT_BOUNDARY_LINE_END: AtkTextBoundary = 6;
294
295pub type AtkTextClipType = c_int;
296pub const ATK_TEXT_CLIP_NONE: AtkTextClipType = 0;
297pub const ATK_TEXT_CLIP_MIN: AtkTextClipType = 1;
298pub const ATK_TEXT_CLIP_MAX: AtkTextClipType = 2;
299pub const ATK_TEXT_CLIP_BOTH: AtkTextClipType = 3;
300
301pub type AtkTextGranularity = c_int;
302pub const ATK_TEXT_GRANULARITY_CHAR: AtkTextGranularity = 0;
303pub const ATK_TEXT_GRANULARITY_WORD: AtkTextGranularity = 1;
304pub const ATK_TEXT_GRANULARITY_SENTENCE: AtkTextGranularity = 2;
305pub const ATK_TEXT_GRANULARITY_LINE: AtkTextGranularity = 3;
306pub const ATK_TEXT_GRANULARITY_PARAGRAPH: AtkTextGranularity = 4;
307
308pub type AtkValueType = c_int;
309pub const ATK_VALUE_VERY_WEAK: AtkValueType = 0;
310pub const ATK_VALUE_WEAK: AtkValueType = 1;
311pub const ATK_VALUE_ACCEPTABLE: AtkValueType = 2;
312pub const ATK_VALUE_STRONG: AtkValueType = 3;
313pub const ATK_VALUE_VERY_STRONG: AtkValueType = 4;
314pub const ATK_VALUE_VERY_LOW: AtkValueType = 5;
315pub const ATK_VALUE_LOW: AtkValueType = 6;
316pub const ATK_VALUE_MEDIUM: AtkValueType = 7;
317pub const ATK_VALUE_HIGH: AtkValueType = 8;
318pub const ATK_VALUE_VERY_HIGH: AtkValueType = 9;
319pub const ATK_VALUE_VERY_BAD: AtkValueType = 10;
320pub const ATK_VALUE_BAD: AtkValueType = 11;
321pub const ATK_VALUE_GOOD: AtkValueType = 12;
322pub const ATK_VALUE_VERY_GOOD: AtkValueType = 13;
323pub const ATK_VALUE_BEST: AtkValueType = 14;
324pub const ATK_VALUE_LAST_DEFINED: AtkValueType = 15;
325
326// Constants
327
328// Flags
329pub type AtkHyperlinkStateFlags = c_uint;
330pub const ATK_HYPERLINK_IS_INLINE: AtkHyperlinkStateFlags = 1;
331
332// Callbacks
333pub type AtkEventListener = Option<unsafe extern "C" fn(*mut AtkObject)>;
334pub type AtkEventListenerInit = Option<unsafe extern "C" fn()>;
335pub type AtkFocusHandler = Option<unsafe extern "C" fn(*mut AtkObject, gboolean)>;
336pub type AtkFunction = Option<unsafe extern "C" fn(gpointer) -> gboolean>;
337pub type AtkKeySnoopFunc = Option<unsafe extern "C" fn(*mut AtkKeyEventStruct, gpointer) -> c_int>;
338pub type AtkPropertyChangeHandler =
339    Option<unsafe extern "C" fn(*mut AtkObject, *mut AtkPropertyValues)>;
340
341// Records
342#[repr(C)]
343#[derive(Copy, Clone)]
344pub struct AtkActionIface {
345    pub parent: gobject::GTypeInterface,
346    pub do_action: Option<unsafe extern "C" fn(*mut AtkAction, c_int) -> gboolean>,
347    pub get_n_actions: Option<unsafe extern "C" fn(*mut AtkAction) -> c_int>,
348    pub get_description: Option<unsafe extern "C" fn(*mut AtkAction, c_int) -> *const c_char>,
349    pub get_name: Option<unsafe extern "C" fn(*mut AtkAction, c_int) -> *const c_char>,
350    pub get_keybinding: Option<unsafe extern "C" fn(*mut AtkAction, c_int) -> *const c_char>,
351    pub set_description:
352        Option<unsafe extern "C" fn(*mut AtkAction, c_int, *const c_char) -> gboolean>,
353    pub get_localized_name: Option<unsafe extern "C" fn(*mut AtkAction, c_int) -> *const c_char>,
354}
355
356impl ::std::fmt::Debug for AtkActionIface {
357    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
358        f.debug_struct(&format!("AtkActionIface @ {:?}", self as *const _))
359            .field("parent", &self.parent)
360            .field("do_action", &self.do_action)
361            .field("get_n_actions", &self.get_n_actions)
362            .field("get_description", &self.get_description)
363            .field("get_name", &self.get_name)
364            .field("get_keybinding", &self.get_keybinding)
365            .field("set_description", &self.set_description)
366            .field("get_localized_name", &self.get_localized_name)
367            .finish()
368    }
369}
370
371#[repr(C)]
372#[derive(Copy, Clone)]
373pub struct AtkAttribute {
374    pub name: *mut c_char,
375    pub value: *mut c_char,
376}
377
378impl ::std::fmt::Debug for AtkAttribute {
379    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
380        f.debug_struct(&format!("AtkAttribute @ {:?}", self as *const _))
381            .field("name", &self.name)
382            .field("value", &self.value)
383            .finish()
384    }
385}
386
387#[repr(C)]
388#[derive(Copy, Clone)]
389pub struct AtkComponentIface {
390    pub parent: gobject::GTypeInterface,
391    pub add_focus_handler:
392        Option<unsafe extern "C" fn(*mut AtkComponent, AtkFocusHandler) -> c_uint>,
393    pub contains:
394        Option<unsafe extern "C" fn(*mut AtkComponent, c_int, c_int, AtkCoordType) -> gboolean>,
395    pub ref_accessible_at_point: Option<
396        unsafe extern "C" fn(*mut AtkComponent, c_int, c_int, AtkCoordType) -> *mut AtkObject,
397    >,
398    pub get_extents: Option<
399        unsafe extern "C" fn(
400            *mut AtkComponent,
401            *mut c_int,
402            *mut c_int,
403            *mut c_int,
404            *mut c_int,
405            AtkCoordType,
406        ),
407    >,
408    pub get_position:
409        Option<unsafe extern "C" fn(*mut AtkComponent, *mut c_int, *mut c_int, AtkCoordType)>,
410    pub get_size: Option<unsafe extern "C" fn(*mut AtkComponent, *mut c_int, *mut c_int)>,
411    pub grab_focus: Option<unsafe extern "C" fn(*mut AtkComponent) -> gboolean>,
412    pub remove_focus_handler: Option<unsafe extern "C" fn(*mut AtkComponent, c_uint)>,
413    pub set_extents: Option<
414        unsafe extern "C" fn(
415            *mut AtkComponent,
416            c_int,
417            c_int,
418            c_int,
419            c_int,
420            AtkCoordType,
421        ) -> gboolean,
422    >,
423    pub set_position:
424        Option<unsafe extern "C" fn(*mut AtkComponent, c_int, c_int, AtkCoordType) -> gboolean>,
425    pub set_size: Option<unsafe extern "C" fn(*mut AtkComponent, c_int, c_int) -> gboolean>,
426    pub get_layer: Option<unsafe extern "C" fn(*mut AtkComponent) -> AtkLayer>,
427    pub get_mdi_zorder: Option<unsafe extern "C" fn(*mut AtkComponent) -> c_int>,
428    pub bounds_changed: Option<unsafe extern "C" fn(*mut AtkComponent, *mut AtkRectangle)>,
429    pub get_alpha: Option<unsafe extern "C" fn(*mut AtkComponent) -> c_double>,
430    pub scroll_to: Option<unsafe extern "C" fn(*mut AtkComponent, AtkScrollType) -> gboolean>,
431    pub scroll_to_point:
432        Option<unsafe extern "C" fn(*mut AtkComponent, AtkCoordType, c_int, c_int) -> gboolean>,
433}
434
435impl ::std::fmt::Debug for AtkComponentIface {
436    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
437        f.debug_struct(&format!("AtkComponentIface @ {:?}", self as *const _))
438            .field("parent", &self.parent)
439            .field("add_focus_handler", &self.add_focus_handler)
440            .field("contains", &self.contains)
441            .field("ref_accessible_at_point", &self.ref_accessible_at_point)
442            .field("get_extents", &self.get_extents)
443            .field("get_position", &self.get_position)
444            .field("get_size", &self.get_size)
445            .field("grab_focus", &self.grab_focus)
446            .field("remove_focus_handler", &self.remove_focus_handler)
447            .field("set_extents", &self.set_extents)
448            .field("set_position", &self.set_position)
449            .field("set_size", &self.set_size)
450            .field("get_layer", &self.get_layer)
451            .field("get_mdi_zorder", &self.get_mdi_zorder)
452            .field("bounds_changed", &self.bounds_changed)
453            .field("get_alpha", &self.get_alpha)
454            .field("scroll_to", &self.scroll_to)
455            .field("scroll_to_point", &self.scroll_to_point)
456            .finish()
457    }
458}
459
460#[repr(C)]
461#[derive(Copy, Clone)]
462pub struct AtkDocumentIface {
463    pub parent: gobject::GTypeInterface,
464    pub get_document_type: Option<unsafe extern "C" fn(*mut AtkDocument) -> *const c_char>,
465    pub get_document: Option<unsafe extern "C" fn(*mut AtkDocument) -> gpointer>,
466    pub get_document_locale: Option<unsafe extern "C" fn(*mut AtkDocument) -> *const c_char>,
467    pub get_document_attributes:
468        Option<unsafe extern "C" fn(*mut AtkDocument) -> *mut AtkAttributeSet>,
469    pub get_document_attribute_value:
470        Option<unsafe extern "C" fn(*mut AtkDocument, *const c_char) -> *const c_char>,
471    pub set_document_attribute:
472        Option<unsafe extern "C" fn(*mut AtkDocument, *const c_char, *const c_char) -> gboolean>,
473    pub get_current_page_number: Option<unsafe extern "C" fn(*mut AtkDocument) -> c_int>,
474    pub get_page_count: Option<unsafe extern "C" fn(*mut AtkDocument) -> c_int>,
475}
476
477impl ::std::fmt::Debug for AtkDocumentIface {
478    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
479        f.debug_struct(&format!("AtkDocumentIface @ {:?}", self as *const _))
480            .field("parent", &self.parent)
481            .field("get_document_type", &self.get_document_type)
482            .field("get_document", &self.get_document)
483            .field("get_document_locale", &self.get_document_locale)
484            .field("get_document_attributes", &self.get_document_attributes)
485            .field(
486                "get_document_attribute_value",
487                &self.get_document_attribute_value,
488            )
489            .field("set_document_attribute", &self.set_document_attribute)
490            .field("get_current_page_number", &self.get_current_page_number)
491            .field("get_page_count", &self.get_page_count)
492            .finish()
493    }
494}
495
496#[repr(C)]
497#[derive(Copy, Clone)]
498pub struct AtkEditableTextIface {
499    pub parent_interface: gobject::GTypeInterface,
500    pub set_run_attributes: Option<
501        unsafe extern "C" fn(*mut AtkEditableText, *mut AtkAttributeSet, c_int, c_int) -> gboolean,
502    >,
503    pub set_text_contents: Option<unsafe extern "C" fn(*mut AtkEditableText, *const c_char)>,
504    pub insert_text:
505        Option<unsafe extern "C" fn(*mut AtkEditableText, *const c_char, c_int, *mut c_int)>,
506    pub copy_text: Option<unsafe extern "C" fn(*mut AtkEditableText, c_int, c_int)>,
507    pub cut_text: Option<unsafe extern "C" fn(*mut AtkEditableText, c_int, c_int)>,
508    pub delete_text: Option<unsafe extern "C" fn(*mut AtkEditableText, c_int, c_int)>,
509    pub paste_text: Option<unsafe extern "C" fn(*mut AtkEditableText, c_int)>,
510}
511
512impl ::std::fmt::Debug for AtkEditableTextIface {
513    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
514        f.debug_struct(&format!("AtkEditableTextIface @ {:?}", self as *const _))
515            .field("parent_interface", &self.parent_interface)
516            .field("set_run_attributes", &self.set_run_attributes)
517            .field("set_text_contents", &self.set_text_contents)
518            .field("insert_text", &self.insert_text)
519            .field("copy_text", &self.copy_text)
520            .field("cut_text", &self.cut_text)
521            .field("delete_text", &self.delete_text)
522            .field("paste_text", &self.paste_text)
523            .finish()
524    }
525}
526
527#[repr(C)]
528#[derive(Copy, Clone)]
529pub struct AtkGObjectAccessibleClass {
530    pub parent_class: AtkObjectClass,
531    pub pad1: AtkFunction,
532    pub pad2: AtkFunction,
533}
534
535impl ::std::fmt::Debug for AtkGObjectAccessibleClass {
536    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
537        f.debug_struct(&format!(
538            "AtkGObjectAccessibleClass @ {:?}",
539            self as *const _
540        ))
541        .field("parent_class", &self.parent_class)
542        .field("pad1", &self.pad1)
543        .field("pad2", &self.pad2)
544        .finish()
545    }
546}
547
548#[repr(C)]
549#[derive(Copy, Clone)]
550pub struct AtkHyperlinkClass {
551    pub parent: gobject::GObjectClass,
552    pub get_uri: Option<unsafe extern "C" fn(*mut AtkHyperlink, c_int) -> *mut c_char>,
553    pub get_object: Option<unsafe extern "C" fn(*mut AtkHyperlink, c_int) -> *mut AtkObject>,
554    pub get_end_index: Option<unsafe extern "C" fn(*mut AtkHyperlink) -> c_int>,
555    pub get_start_index: Option<unsafe extern "C" fn(*mut AtkHyperlink) -> c_int>,
556    pub is_valid: Option<unsafe extern "C" fn(*mut AtkHyperlink) -> gboolean>,
557    pub get_n_anchors: Option<unsafe extern "C" fn(*mut AtkHyperlink) -> c_int>,
558    pub link_state: Option<unsafe extern "C" fn(*mut AtkHyperlink) -> c_uint>,
559    pub is_selected_link: Option<unsafe extern "C" fn(*mut AtkHyperlink) -> gboolean>,
560    pub link_activated: Option<unsafe extern "C" fn(*mut AtkHyperlink)>,
561    pub pad1: AtkFunction,
562}
563
564impl ::std::fmt::Debug for AtkHyperlinkClass {
565    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
566        f.debug_struct(&format!("AtkHyperlinkClass @ {:?}", self as *const _))
567            .field("parent", &self.parent)
568            .field("get_uri", &self.get_uri)
569            .field("get_object", &self.get_object)
570            .field("get_end_index", &self.get_end_index)
571            .field("get_start_index", &self.get_start_index)
572            .field("is_valid", &self.is_valid)
573            .field("get_n_anchors", &self.get_n_anchors)
574            .field("link_state", &self.link_state)
575            .field("is_selected_link", &self.is_selected_link)
576            .field("link_activated", &self.link_activated)
577            .field("pad1", &self.pad1)
578            .finish()
579    }
580}
581
582#[repr(C)]
583#[derive(Copy, Clone)]
584pub struct AtkHyperlinkImplIface {
585    pub parent: gobject::GTypeInterface,
586    pub get_hyperlink: Option<unsafe extern "C" fn(*mut AtkHyperlinkImpl) -> *mut AtkHyperlink>,
587}
588
589impl ::std::fmt::Debug for AtkHyperlinkImplIface {
590    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
591        f.debug_struct(&format!("AtkHyperlinkImplIface @ {:?}", self as *const _))
592            .field("parent", &self.parent)
593            .field("get_hyperlink", &self.get_hyperlink)
594            .finish()
595    }
596}
597
598#[repr(C)]
599#[derive(Copy, Clone)]
600pub struct AtkHypertextIface {
601    pub parent: gobject::GTypeInterface,
602    pub get_link: Option<unsafe extern "C" fn(*mut AtkHypertext, c_int) -> *mut AtkHyperlink>,
603    pub get_n_links: Option<unsafe extern "C" fn(*mut AtkHypertext) -> c_int>,
604    pub get_link_index: Option<unsafe extern "C" fn(*mut AtkHypertext, c_int) -> c_int>,
605    pub link_selected: Option<unsafe extern "C" fn(*mut AtkHypertext, c_int)>,
606}
607
608impl ::std::fmt::Debug for AtkHypertextIface {
609    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
610        f.debug_struct(&format!("AtkHypertextIface @ {:?}", self as *const _))
611            .field("parent", &self.parent)
612            .field("get_link", &self.get_link)
613            .field("get_n_links", &self.get_n_links)
614            .field("get_link_index", &self.get_link_index)
615            .field("link_selected", &self.link_selected)
616            .finish()
617    }
618}
619
620#[repr(C)]
621#[derive(Copy, Clone)]
622pub struct AtkImageIface {
623    pub parent: gobject::GTypeInterface,
624    pub get_image_position:
625        Option<unsafe extern "C" fn(*mut AtkImage, *mut c_int, *mut c_int, AtkCoordType)>,
626    pub get_image_description: Option<unsafe extern "C" fn(*mut AtkImage) -> *const c_char>,
627    pub get_image_size: Option<unsafe extern "C" fn(*mut AtkImage, *mut c_int, *mut c_int)>,
628    pub set_image_description:
629        Option<unsafe extern "C" fn(*mut AtkImage, *const c_char) -> gboolean>,
630    pub get_image_locale: Option<unsafe extern "C" fn(*mut AtkImage) -> *const c_char>,
631}
632
633impl ::std::fmt::Debug for AtkImageIface {
634    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
635        f.debug_struct(&format!("AtkImageIface @ {:?}", self as *const _))
636            .field("parent", &self.parent)
637            .field("get_image_position", &self.get_image_position)
638            .field("get_image_description", &self.get_image_description)
639            .field("get_image_size", &self.get_image_size)
640            .field("set_image_description", &self.set_image_description)
641            .field("get_image_locale", &self.get_image_locale)
642            .finish()
643    }
644}
645
646#[repr(C)]
647pub struct _AtkImplementor(c_void);
648
649pub type AtkImplementor = *mut _AtkImplementor;
650
651#[repr(C)]
652#[derive(Copy, Clone)]
653pub struct AtkKeyEventStruct {
654    pub type_: c_int,
655    pub state: c_uint,
656    pub keyval: c_uint,
657    pub length: c_int,
658    pub string: *mut c_char,
659    pub keycode: u16,
660    pub timestamp: u32,
661}
662
663impl ::std::fmt::Debug for AtkKeyEventStruct {
664    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
665        f.debug_struct(&format!("AtkKeyEventStruct @ {:?}", self as *const _))
666            .field("type_", &self.type_)
667            .field("state", &self.state)
668            .field("keyval", &self.keyval)
669            .field("length", &self.length)
670            .field("string", &self.string)
671            .field("keycode", &self.keycode)
672            .field("timestamp", &self.timestamp)
673            .finish()
674    }
675}
676
677#[repr(C)]
678#[derive(Copy, Clone)]
679pub struct AtkMiscClass {
680    pub parent: gobject::GObjectClass,
681    pub threads_enter: Option<unsafe extern "C" fn(*mut AtkMisc)>,
682    pub threads_leave: Option<unsafe extern "C" fn(*mut AtkMisc)>,
683    pub vfuncs: [gpointer; 32],
684}
685
686impl ::std::fmt::Debug for AtkMiscClass {
687    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
688        f.debug_struct(&format!("AtkMiscClass @ {:?}", self as *const _))
689            .field("parent", &self.parent)
690            .field("threads_enter", &self.threads_enter)
691            .field("threads_leave", &self.threads_leave)
692            .field("vfuncs", &self.vfuncs)
693            .finish()
694    }
695}
696
697#[repr(C)]
698#[derive(Copy, Clone)]
699pub struct AtkNoOpObjectClass {
700    pub parent_class: AtkObjectClass,
701}
702
703impl ::std::fmt::Debug for AtkNoOpObjectClass {
704    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
705        f.debug_struct(&format!("AtkNoOpObjectClass @ {:?}", self as *const _))
706            .field("parent_class", &self.parent_class)
707            .finish()
708    }
709}
710
711#[repr(C)]
712#[derive(Copy, Clone)]
713pub struct AtkNoOpObjectFactoryClass {
714    pub parent_class: AtkObjectFactoryClass,
715}
716
717impl ::std::fmt::Debug for AtkNoOpObjectFactoryClass {
718    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
719        f.debug_struct(&format!(
720            "AtkNoOpObjectFactoryClass @ {:?}",
721            self as *const _
722        ))
723        .field("parent_class", &self.parent_class)
724        .finish()
725    }
726}
727
728#[repr(C)]
729#[derive(Copy, Clone)]
730pub struct AtkObjectClass {
731    pub parent: gobject::GObjectClass,
732    pub get_name: Option<unsafe extern "C" fn(*mut AtkObject) -> *const c_char>,
733    pub get_description: Option<unsafe extern "C" fn(*mut AtkObject) -> *const c_char>,
734    pub get_parent: Option<unsafe extern "C" fn(*mut AtkObject) -> *mut AtkObject>,
735    pub get_n_children: Option<unsafe extern "C" fn(*mut AtkObject) -> c_int>,
736    pub ref_child: Option<unsafe extern "C" fn(*mut AtkObject, c_int) -> *mut AtkObject>,
737    pub get_index_in_parent: Option<unsafe extern "C" fn(*mut AtkObject) -> c_int>,
738    pub ref_relation_set: Option<unsafe extern "C" fn(*mut AtkObject) -> *mut AtkRelationSet>,
739    pub get_role: Option<unsafe extern "C" fn(*mut AtkObject) -> AtkRole>,
740    pub get_layer: Option<unsafe extern "C" fn(*mut AtkObject) -> AtkLayer>,
741    pub get_mdi_zorder: Option<unsafe extern "C" fn(*mut AtkObject) -> c_int>,
742    pub ref_state_set: Option<unsafe extern "C" fn(*mut AtkObject) -> *mut AtkStateSet>,
743    pub set_name: Option<unsafe extern "C" fn(*mut AtkObject, *const c_char)>,
744    pub set_description: Option<unsafe extern "C" fn(*mut AtkObject, *const c_char)>,
745    pub set_parent: Option<unsafe extern "C" fn(*mut AtkObject, *mut AtkObject)>,
746    pub set_role: Option<unsafe extern "C" fn(*mut AtkObject, AtkRole)>,
747    pub connect_property_change_handler:
748        Option<unsafe extern "C" fn(*mut AtkObject, *mut AtkPropertyChangeHandler) -> c_uint>,
749    pub remove_property_change_handler: Option<unsafe extern "C" fn(*mut AtkObject, c_uint)>,
750    pub initialize: Option<unsafe extern "C" fn(*mut AtkObject, *mut gpointer)>,
751    pub children_changed: Option<unsafe extern "C" fn(*mut AtkObject, c_uint, gpointer)>,
752    pub focus_event: Option<unsafe extern "C" fn(*mut AtkObject, gboolean)>,
753    pub property_change: Option<unsafe extern "C" fn(*mut AtkObject, *mut AtkPropertyValues)>,
754    pub state_change: Option<unsafe extern "C" fn(*mut AtkObject, *const c_char, gboolean)>,
755    pub visible_data_changed: Option<unsafe extern "C" fn(*mut AtkObject)>,
756    pub active_descendant_changed: Option<unsafe extern "C" fn(*mut AtkObject, *mut gpointer)>,
757    pub get_attributes: Option<unsafe extern "C" fn(*mut AtkObject) -> *mut AtkAttributeSet>,
758    pub get_object_locale: Option<unsafe extern "C" fn(*mut AtkObject) -> *const c_char>,
759    pub pad1: AtkFunction,
760}
761
762impl ::std::fmt::Debug for AtkObjectClass {
763    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
764        f.debug_struct(&format!("AtkObjectClass @ {:?}", self as *const _))
765            .field("parent", &self.parent)
766            .field("get_name", &self.get_name)
767            .field("get_description", &self.get_description)
768            .field("get_parent", &self.get_parent)
769            .field("get_n_children", &self.get_n_children)
770            .field("ref_child", &self.ref_child)
771            .field("get_index_in_parent", &self.get_index_in_parent)
772            .field("ref_relation_set", &self.ref_relation_set)
773            .field("get_role", &self.get_role)
774            .field("get_layer", &self.get_layer)
775            .field("get_mdi_zorder", &self.get_mdi_zorder)
776            .field("ref_state_set", &self.ref_state_set)
777            .field("set_name", &self.set_name)
778            .field("set_description", &self.set_description)
779            .field("set_parent", &self.set_parent)
780            .field("set_role", &self.set_role)
781            .field(
782                "connect_property_change_handler",
783                &self.connect_property_change_handler,
784            )
785            .field(
786                "remove_property_change_handler",
787                &self.remove_property_change_handler,
788            )
789            .field("initialize", &self.initialize)
790            .field("children_changed", &self.children_changed)
791            .field("focus_event", &self.focus_event)
792            .field("property_change", &self.property_change)
793            .field("state_change", &self.state_change)
794            .field("visible_data_changed", &self.visible_data_changed)
795            .field("active_descendant_changed", &self.active_descendant_changed)
796            .field("get_attributes", &self.get_attributes)
797            .field("get_object_locale", &self.get_object_locale)
798            .field("pad1", &self.pad1)
799            .finish()
800    }
801}
802
803#[repr(C)]
804#[derive(Copy, Clone)]
805pub struct AtkObjectFactoryClass {
806    pub parent_class: gobject::GObjectClass,
807    pub create_accessible: Option<unsafe extern "C" fn(*mut gobject::GObject) -> *mut AtkObject>,
808    pub invalidate: Option<unsafe extern "C" fn(*mut AtkObjectFactory)>,
809    pub get_accessible_type: Option<unsafe extern "C" fn() -> GType>,
810    pub pad1: AtkFunction,
811    pub pad2: AtkFunction,
812}
813
814impl ::std::fmt::Debug for AtkObjectFactoryClass {
815    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
816        f.debug_struct(&format!("AtkObjectFactoryClass @ {:?}", self as *const _))
817            .field("parent_class", &self.parent_class)
818            .field("create_accessible", &self.create_accessible)
819            .field("invalidate", &self.invalidate)
820            .field("get_accessible_type", &self.get_accessible_type)
821            .field("pad1", &self.pad1)
822            .field("pad2", &self.pad2)
823            .finish()
824    }
825}
826
827#[repr(C)]
828#[derive(Copy, Clone)]
829pub struct AtkPlugClass {
830    pub parent_class: AtkObjectClass,
831    pub get_object_id: Option<unsafe extern "C" fn(*mut AtkPlug) -> *mut c_char>,
832}
833
834impl ::std::fmt::Debug for AtkPlugClass {
835    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
836        f.debug_struct(&format!("AtkPlugClass @ {:?}", self as *const _))
837            .field("parent_class", &self.parent_class)
838            .field("get_object_id", &self.get_object_id)
839            .finish()
840    }
841}
842
843#[repr(C)]
844#[derive(Copy, Clone)]
845pub struct AtkPropertyValues {
846    pub property_name: *const c_char,
847    pub old_value: gobject::GValue,
848    pub new_value: gobject::GValue,
849}
850
851impl ::std::fmt::Debug for AtkPropertyValues {
852    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
853        f.debug_struct(&format!("AtkPropertyValues @ {:?}", self as *const _))
854            .field("property_name", &self.property_name)
855            .field("old_value", &self.old_value)
856            .field("new_value", &self.new_value)
857            .finish()
858    }
859}
860
861#[repr(C)]
862pub struct AtkRange(c_void);
863
864impl ::std::fmt::Debug for AtkRange {
865    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
866        f.debug_struct(&format!("AtkRange @ {:?}", self as *const _))
867            .finish()
868    }
869}
870
871#[repr(C)]
872#[derive(Copy, Clone)]
873pub struct AtkRectangle {
874    pub x: c_int,
875    pub y: c_int,
876    pub width: c_int,
877    pub height: c_int,
878}
879
880impl ::std::fmt::Debug for AtkRectangle {
881    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
882        f.debug_struct(&format!("AtkRectangle @ {:?}", self as *const _))
883            .field("x", &self.x)
884            .field("y", &self.y)
885            .field("width", &self.width)
886            .field("height", &self.height)
887            .finish()
888    }
889}
890
891#[repr(C)]
892#[derive(Copy, Clone)]
893pub struct AtkRegistryClass {
894    pub parent_class: gobject::GObjectClass,
895}
896
897impl ::std::fmt::Debug for AtkRegistryClass {
898    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
899        f.debug_struct(&format!("AtkRegistryClass @ {:?}", self as *const _))
900            .field("parent_class", &self.parent_class)
901            .finish()
902    }
903}
904
905#[repr(C)]
906#[derive(Copy, Clone)]
907pub struct AtkRelationClass {
908    pub parent: gobject::GObjectClass,
909}
910
911impl ::std::fmt::Debug for AtkRelationClass {
912    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
913        f.debug_struct(&format!("AtkRelationClass @ {:?}", self as *const _))
914            .field("parent", &self.parent)
915            .finish()
916    }
917}
918
919#[repr(C)]
920#[derive(Copy, Clone)]
921pub struct AtkRelationSetClass {
922    pub parent: gobject::GObjectClass,
923    pub pad1: AtkFunction,
924    pub pad2: AtkFunction,
925}
926
927impl ::std::fmt::Debug for AtkRelationSetClass {
928    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
929        f.debug_struct(&format!("AtkRelationSetClass @ {:?}", self as *const _))
930            .field("parent", &self.parent)
931            .field("pad1", &self.pad1)
932            .field("pad2", &self.pad2)
933            .finish()
934    }
935}
936
937#[repr(C)]
938#[derive(Copy, Clone)]
939pub struct AtkSelectionIface {
940    pub parent: gobject::GTypeInterface,
941    pub add_selection: Option<unsafe extern "C" fn(*mut AtkSelection, c_int) -> gboolean>,
942    pub clear_selection: Option<unsafe extern "C" fn(*mut AtkSelection) -> gboolean>,
943    pub ref_selection: Option<unsafe extern "C" fn(*mut AtkSelection, c_int) -> *mut AtkObject>,
944    pub get_selection_count: Option<unsafe extern "C" fn(*mut AtkSelection) -> c_int>,
945    pub is_child_selected: Option<unsafe extern "C" fn(*mut AtkSelection, c_int) -> gboolean>,
946    pub remove_selection: Option<unsafe extern "C" fn(*mut AtkSelection, c_int) -> gboolean>,
947    pub select_all_selection: Option<unsafe extern "C" fn(*mut AtkSelection) -> gboolean>,
948    pub selection_changed: Option<unsafe extern "C" fn(*mut AtkSelection)>,
949}
950
951impl ::std::fmt::Debug for AtkSelectionIface {
952    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
953        f.debug_struct(&format!("AtkSelectionIface @ {:?}", self as *const _))
954            .field("parent", &self.parent)
955            .field("add_selection", &self.add_selection)
956            .field("clear_selection", &self.clear_selection)
957            .field("ref_selection", &self.ref_selection)
958            .field("get_selection_count", &self.get_selection_count)
959            .field("is_child_selected", &self.is_child_selected)
960            .field("remove_selection", &self.remove_selection)
961            .field("select_all_selection", &self.select_all_selection)
962            .field("selection_changed", &self.selection_changed)
963            .finish()
964    }
965}
966
967#[repr(C)]
968#[derive(Copy, Clone)]
969pub struct AtkSocketClass {
970    pub parent_class: AtkObjectClass,
971    pub embed: Option<unsafe extern "C" fn(*mut AtkSocket, *mut c_char)>,
972}
973
974impl ::std::fmt::Debug for AtkSocketClass {
975    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
976        f.debug_struct(&format!("AtkSocketClass @ {:?}", self as *const _))
977            .field("parent_class", &self.parent_class)
978            .field("embed", &self.embed)
979            .finish()
980    }
981}
982
983#[repr(C)]
984#[derive(Copy, Clone)]
985pub struct AtkStateSetClass {
986    pub parent: gobject::GObjectClass,
987}
988
989impl ::std::fmt::Debug for AtkStateSetClass {
990    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
991        f.debug_struct(&format!("AtkStateSetClass @ {:?}", self as *const _))
992            .field("parent", &self.parent)
993            .finish()
994    }
995}
996
997#[repr(C)]
998#[derive(Copy, Clone)]
999pub struct AtkStreamableContentIface {
1000    pub parent: gobject::GTypeInterface,
1001    pub get_n_mime_types: Option<unsafe extern "C" fn(*mut AtkStreamableContent) -> c_int>,
1002    pub get_mime_type:
1003        Option<unsafe extern "C" fn(*mut AtkStreamableContent, c_int) -> *const c_char>,
1004    pub get_stream: Option<
1005        unsafe extern "C" fn(*mut AtkStreamableContent, *const c_char) -> *mut glib::GIOChannel,
1006    >,
1007    pub get_uri:
1008        Option<unsafe extern "C" fn(*mut AtkStreamableContent, *const c_char) -> *const c_char>,
1009    pub pad1: AtkFunction,
1010    pub pad2: AtkFunction,
1011    pub pad3: AtkFunction,
1012}
1013
1014impl ::std::fmt::Debug for AtkStreamableContentIface {
1015    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1016        f.debug_struct(&format!(
1017            "AtkStreamableContentIface @ {:?}",
1018            self as *const _
1019        ))
1020        .field("parent", &self.parent)
1021        .field("get_n_mime_types", &self.get_n_mime_types)
1022        .field("get_mime_type", &self.get_mime_type)
1023        .field("get_stream", &self.get_stream)
1024        .field("get_uri", &self.get_uri)
1025        .field("pad1", &self.pad1)
1026        .field("pad2", &self.pad2)
1027        .field("pad3", &self.pad3)
1028        .finish()
1029    }
1030}
1031
1032#[repr(C)]
1033#[derive(Copy, Clone)]
1034pub struct AtkTableCellIface {
1035    pub parent: gobject::GTypeInterface,
1036    pub get_column_span: Option<unsafe extern "C" fn(*mut AtkTableCell) -> c_int>,
1037    pub get_column_header_cells:
1038        Option<unsafe extern "C" fn(*mut AtkTableCell) -> *mut glib::GPtrArray>,
1039    pub get_position:
1040        Option<unsafe extern "C" fn(*mut AtkTableCell, *mut c_int, *mut c_int) -> gboolean>,
1041    pub get_row_span: Option<unsafe extern "C" fn(*mut AtkTableCell) -> c_int>,
1042    pub get_row_header_cells:
1043        Option<unsafe extern "C" fn(*mut AtkTableCell) -> *mut glib::GPtrArray>,
1044    pub get_row_column_span: Option<
1045        unsafe extern "C" fn(
1046            *mut AtkTableCell,
1047            *mut c_int,
1048            *mut c_int,
1049            *mut c_int,
1050            *mut c_int,
1051        ) -> gboolean,
1052    >,
1053    pub get_table: Option<unsafe extern "C" fn(*mut AtkTableCell) -> *mut AtkObject>,
1054}
1055
1056impl ::std::fmt::Debug for AtkTableCellIface {
1057    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1058        f.debug_struct(&format!("AtkTableCellIface @ {:?}", self as *const _))
1059            .field("parent", &self.parent)
1060            .field("get_column_span", &self.get_column_span)
1061            .field("get_column_header_cells", &self.get_column_header_cells)
1062            .field("get_position", &self.get_position)
1063            .field("get_row_span", &self.get_row_span)
1064            .field("get_row_header_cells", &self.get_row_header_cells)
1065            .field("get_row_column_span", &self.get_row_column_span)
1066            .field("get_table", &self.get_table)
1067            .finish()
1068    }
1069}
1070
1071#[repr(C)]
1072#[derive(Copy, Clone)]
1073pub struct AtkTableIface {
1074    pub parent: gobject::GTypeInterface,
1075    pub ref_at: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int) -> *mut AtkObject>,
1076    pub get_index_at: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int) -> c_int>,
1077    pub get_column_at_index: Option<unsafe extern "C" fn(*mut AtkTable, *mut *mut c_int) -> c_int>,
1078    pub get_row_at_index: Option<unsafe extern "C" fn(*mut AtkTable, *mut *mut c_int) -> c_int>,
1079    pub get_n_columns: Option<unsafe extern "C" fn(*mut AtkTable) -> c_int>,
1080    pub get_n_rows: Option<unsafe extern "C" fn(*mut AtkTable) -> c_int>,
1081    pub get_column_extent_at: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int) -> c_int>,
1082    pub get_row_extent_at: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int) -> c_int>,
1083    pub get_caption: Option<unsafe extern "C" fn(*mut AtkTable) -> *mut AtkObject>,
1084    pub get_column_description: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> *const c_char>,
1085    pub get_column_header: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> *mut AtkObject>,
1086    pub get_row_description: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> *const c_char>,
1087    pub get_row_header: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> *mut AtkObject>,
1088    pub get_summary: Option<unsafe extern "C" fn(*mut AtkTable) -> *mut AtkObject>,
1089    pub set_caption: Option<unsafe extern "C" fn(*mut AtkTable, *mut AtkObject)>,
1090    pub set_column_description: Option<unsafe extern "C" fn(*mut AtkTable, c_int, *const c_char)>,
1091    pub set_column_header: Option<unsafe extern "C" fn(*mut AtkTable, c_int, *mut AtkObject)>,
1092    pub set_row_description: Option<unsafe extern "C" fn(*mut AtkTable, c_int, *const c_char)>,
1093    pub set_row_header: Option<unsafe extern "C" fn(*mut AtkTable, c_int, *mut AtkObject)>,
1094    pub set_summary: Option<unsafe extern "C" fn(*mut AtkTable, *mut AtkObject)>,
1095    pub get_selected_columns: Option<unsafe extern "C" fn(*mut AtkTable, *mut *mut c_int) -> c_int>,
1096    pub get_selected_rows: Option<unsafe extern "C" fn(*mut AtkTable, *mut *mut c_int) -> c_int>,
1097    pub is_column_selected: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> gboolean>,
1098    pub is_row_selected: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> gboolean>,
1099    pub is_selected: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int) -> gboolean>,
1100    pub add_row_selection: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> gboolean>,
1101    pub remove_row_selection: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> gboolean>,
1102    pub add_column_selection: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> gboolean>,
1103    pub remove_column_selection: Option<unsafe extern "C" fn(*mut AtkTable, c_int) -> gboolean>,
1104    pub row_inserted: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int)>,
1105    pub column_inserted: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int)>,
1106    pub row_deleted: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int)>,
1107    pub column_deleted: Option<unsafe extern "C" fn(*mut AtkTable, c_int, c_int)>,
1108    pub row_reordered: Option<unsafe extern "C" fn(*mut AtkTable)>,
1109    pub column_reordered: Option<unsafe extern "C" fn(*mut AtkTable)>,
1110    pub model_changed: Option<unsafe extern "C" fn(*mut AtkTable)>,
1111}
1112
1113impl ::std::fmt::Debug for AtkTableIface {
1114    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1115        f.debug_struct(&format!("AtkTableIface @ {:?}", self as *const _))
1116            .field("parent", &self.parent)
1117            .field("ref_at", &self.ref_at)
1118            .field("get_index_at", &self.get_index_at)
1119            .field("get_column_at_index", &self.get_column_at_index)
1120            .field("get_row_at_index", &self.get_row_at_index)
1121            .field("get_n_columns", &self.get_n_columns)
1122            .field("get_n_rows", &self.get_n_rows)
1123            .field("get_column_extent_at", &self.get_column_extent_at)
1124            .field("get_row_extent_at", &self.get_row_extent_at)
1125            .field("get_caption", &self.get_caption)
1126            .field("get_column_description", &self.get_column_description)
1127            .field("get_column_header", &self.get_column_header)
1128            .field("get_row_description", &self.get_row_description)
1129            .field("get_row_header", &self.get_row_header)
1130            .field("get_summary", &self.get_summary)
1131            .field("set_caption", &self.set_caption)
1132            .field("set_column_description", &self.set_column_description)
1133            .field("set_column_header", &self.set_column_header)
1134            .field("set_row_description", &self.set_row_description)
1135            .field("set_row_header", &self.set_row_header)
1136            .field("set_summary", &self.set_summary)
1137            .field("get_selected_columns", &self.get_selected_columns)
1138            .field("get_selected_rows", &self.get_selected_rows)
1139            .field("is_column_selected", &self.is_column_selected)
1140            .field("is_row_selected", &self.is_row_selected)
1141            .field("is_selected", &self.is_selected)
1142            .field("add_row_selection", &self.add_row_selection)
1143            .field("remove_row_selection", &self.remove_row_selection)
1144            .field("add_column_selection", &self.add_column_selection)
1145            .field("remove_column_selection", &self.remove_column_selection)
1146            .field("row_inserted", &self.row_inserted)
1147            .field("column_inserted", &self.column_inserted)
1148            .field("row_deleted", &self.row_deleted)
1149            .field("column_deleted", &self.column_deleted)
1150            .field("row_reordered", &self.row_reordered)
1151            .field("column_reordered", &self.column_reordered)
1152            .field("model_changed", &self.model_changed)
1153            .finish()
1154    }
1155}
1156
1157#[repr(C)]
1158#[derive(Copy, Clone)]
1159pub struct AtkTextIface {
1160    pub parent: gobject::GTypeInterface,
1161    pub get_text: Option<unsafe extern "C" fn(*mut AtkText, c_int, c_int) -> *mut c_char>,
1162    pub get_text_after_offset: Option<
1163        unsafe extern "C" fn(
1164            *mut AtkText,
1165            c_int,
1166            AtkTextBoundary,
1167            *mut c_int,
1168            *mut c_int,
1169        ) -> *mut c_char,
1170    >,
1171    pub get_text_at_offset: Option<
1172        unsafe extern "C" fn(
1173            *mut AtkText,
1174            c_int,
1175            AtkTextBoundary,
1176            *mut c_int,
1177            *mut c_int,
1178        ) -> *mut c_char,
1179    >,
1180    pub get_character_at_offset: Option<unsafe extern "C" fn(*mut AtkText, c_int) -> u32>,
1181    pub get_text_before_offset: Option<
1182        unsafe extern "C" fn(
1183            *mut AtkText,
1184            c_int,
1185            AtkTextBoundary,
1186            *mut c_int,
1187            *mut c_int,
1188        ) -> *mut c_char,
1189    >,
1190    pub get_caret_offset: Option<unsafe extern "C" fn(*mut AtkText) -> c_int>,
1191    pub get_run_attributes: Option<
1192        unsafe extern "C" fn(*mut AtkText, c_int, *mut c_int, *mut c_int) -> *mut AtkAttributeSet,
1193    >,
1194    pub get_default_attributes: Option<unsafe extern "C" fn(*mut AtkText) -> *mut AtkAttributeSet>,
1195    pub get_character_extents: Option<
1196        unsafe extern "C" fn(
1197            *mut AtkText,
1198            c_int,
1199            *mut c_int,
1200            *mut c_int,
1201            *mut c_int,
1202            *mut c_int,
1203            AtkCoordType,
1204        ),
1205    >,
1206    pub get_character_count: Option<unsafe extern "C" fn(*mut AtkText) -> c_int>,
1207    pub get_offset_at_point:
1208        Option<unsafe extern "C" fn(*mut AtkText, c_int, c_int, AtkCoordType) -> c_int>,
1209    pub get_n_selections: Option<unsafe extern "C" fn(*mut AtkText) -> c_int>,
1210    pub get_selection:
1211        Option<unsafe extern "C" fn(*mut AtkText, c_int, *mut c_int, *mut c_int) -> *mut c_char>,
1212    pub add_selection: Option<unsafe extern "C" fn(*mut AtkText, c_int, c_int) -> gboolean>,
1213    pub remove_selection: Option<unsafe extern "C" fn(*mut AtkText, c_int) -> gboolean>,
1214    pub set_selection: Option<unsafe extern "C" fn(*mut AtkText, c_int, c_int, c_int) -> gboolean>,
1215    pub set_caret_offset: Option<unsafe extern "C" fn(*mut AtkText, c_int) -> gboolean>,
1216    pub text_changed: Option<unsafe extern "C" fn(*mut AtkText, c_int, c_int)>,
1217    pub text_caret_moved: Option<unsafe extern "C" fn(*mut AtkText, c_int)>,
1218    pub text_selection_changed: Option<unsafe extern "C" fn(*mut AtkText)>,
1219    pub text_attributes_changed: Option<unsafe extern "C" fn(*mut AtkText)>,
1220    pub get_range_extents: Option<
1221        unsafe extern "C" fn(*mut AtkText, c_int, c_int, AtkCoordType, *mut AtkTextRectangle),
1222    >,
1223    pub get_bounded_ranges: Option<
1224        unsafe extern "C" fn(
1225            *mut AtkText,
1226            *mut AtkTextRectangle,
1227            AtkCoordType,
1228            AtkTextClipType,
1229            AtkTextClipType,
1230        ) -> *mut *mut AtkTextRange,
1231    >,
1232    pub get_string_at_offset: Option<
1233        unsafe extern "C" fn(
1234            *mut AtkText,
1235            c_int,
1236            AtkTextGranularity,
1237            *mut c_int,
1238            *mut c_int,
1239        ) -> *mut c_char,
1240    >,
1241}
1242
1243impl ::std::fmt::Debug for AtkTextIface {
1244    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1245        f.debug_struct(&format!("AtkTextIface @ {:?}", self as *const _))
1246            .field("parent", &self.parent)
1247            .field("get_text", &self.get_text)
1248            .field("get_text_after_offset", &self.get_text_after_offset)
1249            .field("get_text_at_offset", &self.get_text_at_offset)
1250            .field("get_character_at_offset", &self.get_character_at_offset)
1251            .field("get_text_before_offset", &self.get_text_before_offset)
1252            .field("get_caret_offset", &self.get_caret_offset)
1253            .field("get_run_attributes", &self.get_run_attributes)
1254            .field("get_default_attributes", &self.get_default_attributes)
1255            .field("get_character_extents", &self.get_character_extents)
1256            .field("get_character_count", &self.get_character_count)
1257            .field("get_offset_at_point", &self.get_offset_at_point)
1258            .field("get_n_selections", &self.get_n_selections)
1259            .field("get_selection", &self.get_selection)
1260            .field("add_selection", &self.add_selection)
1261            .field("remove_selection", &self.remove_selection)
1262            .field("set_selection", &self.set_selection)
1263            .field("set_caret_offset", &self.set_caret_offset)
1264            .field("text_changed", &self.text_changed)
1265            .field("text_caret_moved", &self.text_caret_moved)
1266            .field("text_selection_changed", &self.text_selection_changed)
1267            .field("text_attributes_changed", &self.text_attributes_changed)
1268            .field("get_range_extents", &self.get_range_extents)
1269            .field("get_bounded_ranges", &self.get_bounded_ranges)
1270            .field("get_string_at_offset", &self.get_string_at_offset)
1271            .finish()
1272    }
1273}
1274
1275#[repr(C)]
1276#[derive(Copy, Clone)]
1277pub struct AtkTextRange {
1278    pub bounds: AtkTextRectangle,
1279    pub start_offset: c_int,
1280    pub end_offset: c_int,
1281    pub content: *mut c_char,
1282}
1283
1284impl ::std::fmt::Debug for AtkTextRange {
1285    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1286        f.debug_struct(&format!("AtkTextRange @ {:?}", self as *const _))
1287            .field("bounds", &self.bounds)
1288            .field("start_offset", &self.start_offset)
1289            .field("end_offset", &self.end_offset)
1290            .field("content", &self.content)
1291            .finish()
1292    }
1293}
1294
1295#[repr(C)]
1296#[derive(Copy, Clone)]
1297pub struct AtkTextRectangle {
1298    pub x: c_int,
1299    pub y: c_int,
1300    pub width: c_int,
1301    pub height: c_int,
1302}
1303
1304impl ::std::fmt::Debug for AtkTextRectangle {
1305    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1306        f.debug_struct(&format!("AtkTextRectangle @ {:?}", self as *const _))
1307            .field("x", &self.x)
1308            .field("y", &self.y)
1309            .field("width", &self.width)
1310            .field("height", &self.height)
1311            .finish()
1312    }
1313}
1314
1315#[repr(C)]
1316#[derive(Copy, Clone)]
1317pub struct AtkUtilClass {
1318    pub parent: gobject::GObjectClass,
1319    pub add_global_event_listener:
1320        Option<unsafe extern "C" fn(gobject::GSignalEmissionHook, *const c_char) -> c_uint>,
1321    pub remove_global_event_listener: Option<unsafe extern "C" fn(c_uint)>,
1322    pub add_key_event_listener: Option<unsafe extern "C" fn(AtkKeySnoopFunc, gpointer) -> c_uint>,
1323    pub remove_key_event_listener: Option<unsafe extern "C" fn(c_uint)>,
1324    pub get_root: Option<unsafe extern "C" fn() -> *mut AtkObject>,
1325    pub get_toolkit_name: Option<unsafe extern "C" fn() -> *const c_char>,
1326    pub get_toolkit_version: Option<unsafe extern "C" fn() -> *const c_char>,
1327}
1328
1329impl ::std::fmt::Debug for AtkUtilClass {
1330    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1331        f.debug_struct(&format!("AtkUtilClass @ {:?}", self as *const _))
1332            .field("parent", &self.parent)
1333            .field("add_global_event_listener", &self.add_global_event_listener)
1334            .field(
1335                "remove_global_event_listener",
1336                &self.remove_global_event_listener,
1337            )
1338            .field("add_key_event_listener", &self.add_key_event_listener)
1339            .field("remove_key_event_listener", &self.remove_key_event_listener)
1340            .field("get_root", &self.get_root)
1341            .field("get_toolkit_name", &self.get_toolkit_name)
1342            .field("get_toolkit_version", &self.get_toolkit_version)
1343            .finish()
1344    }
1345}
1346
1347#[repr(C)]
1348#[derive(Copy, Clone)]
1349pub struct AtkValueIface {
1350    pub parent: gobject::GTypeInterface,
1351    pub get_current_value: Option<unsafe extern "C" fn(*mut AtkValue, *mut gobject::GValue)>,
1352    pub get_maximum_value: Option<unsafe extern "C" fn(*mut AtkValue, *mut gobject::GValue)>,
1353    pub get_minimum_value: Option<unsafe extern "C" fn(*mut AtkValue, *mut gobject::GValue)>,
1354    pub set_current_value:
1355        Option<unsafe extern "C" fn(*mut AtkValue, *const gobject::GValue) -> gboolean>,
1356    pub get_minimum_increment: Option<unsafe extern "C" fn(*mut AtkValue, *mut gobject::GValue)>,
1357    pub get_value_and_text:
1358        Option<unsafe extern "C" fn(*mut AtkValue, *mut c_double, *mut *mut c_char)>,
1359    pub get_range: Option<unsafe extern "C" fn(*mut AtkValue) -> *mut AtkRange>,
1360    pub get_increment: Option<unsafe extern "C" fn(*mut AtkValue) -> c_double>,
1361    pub get_sub_ranges: Option<unsafe extern "C" fn(*mut AtkValue) -> *mut glib::GSList>,
1362    pub set_value: Option<unsafe extern "C" fn(*mut AtkValue, c_double)>,
1363}
1364
1365impl ::std::fmt::Debug for AtkValueIface {
1366    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1367        f.debug_struct(&format!("AtkValueIface @ {:?}", self as *const _))
1368            .field("parent", &self.parent)
1369            .field("get_current_value", &self.get_current_value)
1370            .field("get_maximum_value", &self.get_maximum_value)
1371            .field("get_minimum_value", &self.get_minimum_value)
1372            .field("set_current_value", &self.set_current_value)
1373            .field("get_minimum_increment", &self.get_minimum_increment)
1374            .field("get_value_and_text", &self.get_value_and_text)
1375            .field("get_range", &self.get_range)
1376            .field("get_increment", &self.get_increment)
1377            .field("get_sub_ranges", &self.get_sub_ranges)
1378            .field("set_value", &self.set_value)
1379            .finish()
1380    }
1381}
1382
1383#[repr(C)]
1384#[derive(Copy, Clone)]
1385pub struct AtkWindowIface {
1386    pub parent: gobject::GTypeInterface,
1387}
1388
1389impl ::std::fmt::Debug for AtkWindowIface {
1390    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1391        f.debug_struct(&format!("AtkWindowIface @ {:?}", self as *const _))
1392            .field("parent", &self.parent)
1393            .finish()
1394    }
1395}
1396
1397// Classes
1398#[repr(C)]
1399#[derive(Copy, Clone)]
1400pub struct AtkGObjectAccessible {
1401    pub parent: AtkObject,
1402}
1403
1404impl ::std::fmt::Debug for AtkGObjectAccessible {
1405    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1406        f.debug_struct(&format!("AtkGObjectAccessible @ {:?}", self as *const _))
1407            .field("parent", &self.parent)
1408            .finish()
1409    }
1410}
1411
1412#[repr(C)]
1413#[derive(Copy, Clone)]
1414pub struct AtkHyperlink {
1415    pub parent: gobject::GObject,
1416}
1417
1418impl ::std::fmt::Debug for AtkHyperlink {
1419    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1420        f.debug_struct(&format!("AtkHyperlink @ {:?}", self as *const _))
1421            .field("parent", &self.parent)
1422            .finish()
1423    }
1424}
1425
1426#[repr(C)]
1427#[derive(Copy, Clone)]
1428pub struct AtkMisc {
1429    pub parent: gobject::GObject,
1430}
1431
1432impl ::std::fmt::Debug for AtkMisc {
1433    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1434        f.debug_struct(&format!("AtkMisc @ {:?}", self as *const _))
1435            .field("parent", &self.parent)
1436            .finish()
1437    }
1438}
1439
1440#[repr(C)]
1441#[derive(Copy, Clone)]
1442pub struct AtkNoOpObject {
1443    pub parent: AtkObject,
1444}
1445
1446impl ::std::fmt::Debug for AtkNoOpObject {
1447    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1448        f.debug_struct(&format!("AtkNoOpObject @ {:?}", self as *const _))
1449            .field("parent", &self.parent)
1450            .finish()
1451    }
1452}
1453
1454#[repr(C)]
1455#[derive(Copy, Clone)]
1456pub struct AtkNoOpObjectFactory {
1457    pub parent: AtkObjectFactory,
1458}
1459
1460impl ::std::fmt::Debug for AtkNoOpObjectFactory {
1461    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1462        f.debug_struct(&format!("AtkNoOpObjectFactory @ {:?}", self as *const _))
1463            .field("parent", &self.parent)
1464            .finish()
1465    }
1466}
1467
1468#[repr(C)]
1469#[derive(Copy, Clone)]
1470pub struct AtkObject {
1471    pub parent: gobject::GObject,
1472    pub description: *mut c_char,
1473    pub name: *mut c_char,
1474    pub accessible_parent: *mut AtkObject,
1475    pub role: AtkRole,
1476    pub relation_set: *mut AtkRelationSet,
1477    pub layer: AtkLayer,
1478}
1479
1480impl ::std::fmt::Debug for AtkObject {
1481    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1482        f.debug_struct(&format!("AtkObject @ {:?}", self as *const _))
1483            .field("parent", &self.parent)
1484            .field("description", &self.description)
1485            .field("name", &self.name)
1486            .field("accessible_parent", &self.accessible_parent)
1487            .field("role", &self.role)
1488            .field("relation_set", &self.relation_set)
1489            .field("layer", &self.layer)
1490            .finish()
1491    }
1492}
1493
1494#[repr(C)]
1495#[derive(Copy, Clone)]
1496pub struct AtkObjectFactory {
1497    pub parent: gobject::GObject,
1498}
1499
1500impl ::std::fmt::Debug for AtkObjectFactory {
1501    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1502        f.debug_struct(&format!("AtkObjectFactory @ {:?}", self as *const _))
1503            .field("parent", &self.parent)
1504            .finish()
1505    }
1506}
1507
1508#[repr(C)]
1509#[derive(Copy, Clone)]
1510pub struct AtkPlug {
1511    pub parent: AtkObject,
1512}
1513
1514impl ::std::fmt::Debug for AtkPlug {
1515    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1516        f.debug_struct(&format!("AtkPlug @ {:?}", self as *const _))
1517            .field("parent", &self.parent)
1518            .finish()
1519    }
1520}
1521
1522#[repr(C)]
1523#[derive(Copy, Clone)]
1524pub struct AtkRegistry {
1525    pub parent: gobject::GObject,
1526    pub factory_type_registry: *mut glib::GHashTable,
1527    pub factory_singleton_cache: *mut glib::GHashTable,
1528}
1529
1530impl ::std::fmt::Debug for AtkRegistry {
1531    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1532        f.debug_struct(&format!("AtkRegistry @ {:?}", self as *const _))
1533            .field("parent", &self.parent)
1534            .field("factory_type_registry", &self.factory_type_registry)
1535            .field("factory_singleton_cache", &self.factory_singleton_cache)
1536            .finish()
1537    }
1538}
1539
1540#[repr(C)]
1541#[derive(Copy, Clone)]
1542pub struct AtkRelation {
1543    pub parent: gobject::GObject,
1544    pub target: *mut glib::GPtrArray,
1545    pub relationship: AtkRelationType,
1546}
1547
1548impl ::std::fmt::Debug for AtkRelation {
1549    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1550        f.debug_struct(&format!("AtkRelation @ {:?}", self as *const _))
1551            .field("parent", &self.parent)
1552            .field("target", &self.target)
1553            .field("relationship", &self.relationship)
1554            .finish()
1555    }
1556}
1557
1558#[repr(C)]
1559#[derive(Copy, Clone)]
1560pub struct AtkRelationSet {
1561    pub parent: gobject::GObject,
1562    pub relations: *mut glib::GPtrArray,
1563}
1564
1565impl ::std::fmt::Debug for AtkRelationSet {
1566    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1567        f.debug_struct(&format!("AtkRelationSet @ {:?}", self as *const _))
1568            .field("parent", &self.parent)
1569            .field("relations", &self.relations)
1570            .finish()
1571    }
1572}
1573
1574#[repr(C)]
1575#[derive(Copy, Clone)]
1576pub struct AtkSocket {
1577    pub parent: AtkObject,
1578    pub embedded_plug_id: *mut c_char,
1579}
1580
1581impl ::std::fmt::Debug for AtkSocket {
1582    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1583        f.debug_struct(&format!("AtkSocket @ {:?}", self as *const _))
1584            .field("parent", &self.parent)
1585            .finish()
1586    }
1587}
1588
1589#[repr(C)]
1590#[derive(Copy, Clone)]
1591pub struct AtkStateSet {
1592    pub parent: gobject::GObject,
1593}
1594
1595impl ::std::fmt::Debug for AtkStateSet {
1596    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1597        f.debug_struct(&format!("AtkStateSet @ {:?}", self as *const _))
1598            .field("parent", &self.parent)
1599            .finish()
1600    }
1601}
1602
1603#[repr(C)]
1604#[derive(Copy, Clone)]
1605pub struct AtkUtil {
1606    pub parent: gobject::GObject,
1607}
1608
1609impl ::std::fmt::Debug for AtkUtil {
1610    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1611        f.debug_struct(&format!("AtkUtil @ {:?}", self as *const _))
1612            .field("parent", &self.parent)
1613            .finish()
1614    }
1615}
1616
1617// Interfaces
1618#[repr(C)]
1619pub struct AtkAction(c_void);
1620
1621impl ::std::fmt::Debug for AtkAction {
1622    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1623        write!(f, "AtkAction @ {:?}", self as *const _)
1624    }
1625}
1626
1627#[repr(C)]
1628pub struct AtkComponent(c_void);
1629
1630impl ::std::fmt::Debug for AtkComponent {
1631    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1632        write!(f, "AtkComponent @ {:?}", self as *const _)
1633    }
1634}
1635
1636#[repr(C)]
1637pub struct AtkDocument(c_void);
1638
1639impl ::std::fmt::Debug for AtkDocument {
1640    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1641        write!(f, "AtkDocument @ {:?}", self as *const _)
1642    }
1643}
1644
1645#[repr(C)]
1646pub struct AtkEditableText(c_void);
1647
1648impl ::std::fmt::Debug for AtkEditableText {
1649    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1650        write!(f, "AtkEditableText @ {:?}", self as *const _)
1651    }
1652}
1653
1654#[repr(C)]
1655pub struct AtkHyperlinkImpl(c_void);
1656
1657impl ::std::fmt::Debug for AtkHyperlinkImpl {
1658    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1659        write!(f, "AtkHyperlinkImpl @ {:?}", self as *const _)
1660    }
1661}
1662
1663#[repr(C)]
1664pub struct AtkHypertext(c_void);
1665
1666impl ::std::fmt::Debug for AtkHypertext {
1667    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1668        write!(f, "AtkHypertext @ {:?}", self as *const _)
1669    }
1670}
1671
1672#[repr(C)]
1673pub struct AtkImage(c_void);
1674
1675impl ::std::fmt::Debug for AtkImage {
1676    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1677        write!(f, "AtkImage @ {:?}", self as *const _)
1678    }
1679}
1680
1681#[repr(C)]
1682pub struct AtkImplementorIface(c_void);
1683
1684impl ::std::fmt::Debug for AtkImplementorIface {
1685    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1686        write!(f, "AtkImplementorIface @ {:?}", self as *const _)
1687    }
1688}
1689
1690#[repr(C)]
1691pub struct AtkSelection(c_void);
1692
1693impl ::std::fmt::Debug for AtkSelection {
1694    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1695        write!(f, "AtkSelection @ {:?}", self as *const _)
1696    }
1697}
1698
1699#[repr(C)]
1700pub struct AtkStreamableContent(c_void);
1701
1702impl ::std::fmt::Debug for AtkStreamableContent {
1703    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1704        write!(f, "AtkStreamableContent @ {:?}", self as *const _)
1705    }
1706}
1707
1708#[repr(C)]
1709pub struct AtkTable(c_void);
1710
1711impl ::std::fmt::Debug for AtkTable {
1712    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1713        write!(f, "AtkTable @ {:?}", self as *const _)
1714    }
1715}
1716
1717#[repr(C)]
1718pub struct AtkTableCell(c_void);
1719
1720impl ::std::fmt::Debug for AtkTableCell {
1721    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1722        write!(f, "AtkTableCell @ {:?}", self as *const _)
1723    }
1724}
1725
1726#[repr(C)]
1727pub struct AtkText(c_void);
1728
1729impl ::std::fmt::Debug for AtkText {
1730    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1731        write!(f, "AtkText @ {:?}", self as *const _)
1732    }
1733}
1734
1735#[repr(C)]
1736pub struct AtkValue(c_void);
1737
1738impl ::std::fmt::Debug for AtkValue {
1739    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1740        write!(f, "AtkValue @ {:?}", self as *const _)
1741    }
1742}
1743
1744#[repr(C)]
1745pub struct AtkWindow(c_void);
1746
1747impl ::std::fmt::Debug for AtkWindow {
1748    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1749        write!(f, "AtkWindow @ {:?}", self as *const _)
1750    }
1751}
1752
1753extern "C" {
1754
1755    //=========================================================================
1756    // AtkCoordType
1757    //=========================================================================
1758    pub fn atk_coord_type_get_type() -> GType;
1759
1760    //=========================================================================
1761    // AtkKeyEventType
1762    //=========================================================================
1763    pub fn atk_key_event_type_get_type() -> GType;
1764
1765    //=========================================================================
1766    // AtkLayer
1767    //=========================================================================
1768    pub fn atk_layer_get_type() -> GType;
1769
1770    //=========================================================================
1771    // AtkRelationType
1772    //=========================================================================
1773    pub fn atk_relation_type_get_type() -> GType;
1774    pub fn atk_relation_type_for_name(name: *const c_char) -> AtkRelationType;
1775    pub fn atk_relation_type_get_name(type_: AtkRelationType) -> *const c_char;
1776    pub fn atk_relation_type_register(name: *const c_char) -> AtkRelationType;
1777
1778    //=========================================================================
1779    // AtkRole
1780    //=========================================================================
1781    pub fn atk_role_get_type() -> GType;
1782    pub fn atk_role_for_name(name: *const c_char) -> AtkRole;
1783    pub fn atk_role_get_localized_name(role: AtkRole) -> *const c_char;
1784    pub fn atk_role_get_name(role: AtkRole) -> *const c_char;
1785    pub fn atk_role_register(name: *const c_char) -> AtkRole;
1786
1787    //=========================================================================
1788    // AtkScrollType
1789    //=========================================================================
1790    pub fn atk_scroll_type_get_type() -> GType;
1791
1792    //=========================================================================
1793    // AtkStateType
1794    //=========================================================================
1795    pub fn atk_state_type_get_type() -> GType;
1796    pub fn atk_state_type_for_name(name: *const c_char) -> AtkStateType;
1797    pub fn atk_state_type_get_name(type_: AtkStateType) -> *const c_char;
1798    pub fn atk_state_type_register(name: *const c_char) -> AtkStateType;
1799
1800    //=========================================================================
1801    // AtkTextAttribute
1802    //=========================================================================
1803    pub fn atk_text_attribute_get_type() -> GType;
1804    pub fn atk_text_attribute_for_name(name: *const c_char) -> AtkTextAttribute;
1805    pub fn atk_text_attribute_get_name(attr: AtkTextAttribute) -> *const c_char;
1806    pub fn atk_text_attribute_get_value(attr: AtkTextAttribute, index_: c_int) -> *const c_char;
1807    pub fn atk_text_attribute_register(name: *const c_char) -> AtkTextAttribute;
1808
1809    //=========================================================================
1810    // AtkTextBoundary
1811    //=========================================================================
1812    pub fn atk_text_boundary_get_type() -> GType;
1813
1814    //=========================================================================
1815    // AtkTextClipType
1816    //=========================================================================
1817    pub fn atk_text_clip_type_get_type() -> GType;
1818
1819    //=========================================================================
1820    // AtkTextGranularity
1821    //=========================================================================
1822    pub fn atk_text_granularity_get_type() -> GType;
1823
1824    //=========================================================================
1825    // AtkValueType
1826    //=========================================================================
1827    pub fn atk_value_type_get_type() -> GType;
1828    pub fn atk_value_type_get_localized_name(value_type: AtkValueType) -> *const c_char;
1829    pub fn atk_value_type_get_name(value_type: AtkValueType) -> *const c_char;
1830
1831    //=========================================================================
1832    // AtkHyperlinkStateFlags
1833    //=========================================================================
1834    pub fn atk_hyperlink_state_flags_get_type() -> GType;
1835
1836    //=========================================================================
1837    // AtkAttribute
1838    //=========================================================================
1839    pub fn atk_attribute_set_free(attrib_set: *mut AtkAttributeSet);
1840
1841    //=========================================================================
1842    // AtkImplementor
1843    //=========================================================================
1844    pub fn atk_implementor_ref_accessible(implementor: *mut AtkImplementor) -> *mut AtkObject;
1845
1846    //=========================================================================
1847    // AtkRange
1848    //=========================================================================
1849    pub fn atk_range_get_type() -> GType;
1850    pub fn atk_range_new(
1851        lower_limit: c_double,
1852        upper_limit: c_double,
1853        description: *const c_char,
1854    ) -> *mut AtkRange;
1855    pub fn atk_range_copy(src: *mut AtkRange) -> *mut AtkRange;
1856    pub fn atk_range_free(range: *mut AtkRange);
1857    pub fn atk_range_get_description(range: *mut AtkRange) -> *const c_char;
1858    pub fn atk_range_get_lower_limit(range: *mut AtkRange) -> c_double;
1859    pub fn atk_range_get_upper_limit(range: *mut AtkRange) -> c_double;
1860
1861    //=========================================================================
1862    // AtkRectangle
1863    //=========================================================================
1864    pub fn atk_rectangle_get_type() -> GType;
1865
1866    //=========================================================================
1867    // AtkTextRange
1868    //=========================================================================
1869    pub fn atk_text_range_get_type() -> GType;
1870
1871    //=========================================================================
1872    // AtkGObjectAccessible
1873    //=========================================================================
1874    pub fn atk_gobject_accessible_get_type() -> GType;
1875    pub fn atk_gobject_accessible_for_object(obj: *mut gobject::GObject) -> *mut AtkObject;
1876    pub fn atk_gobject_accessible_get_object(
1877        obj: *mut AtkGObjectAccessible,
1878    ) -> *mut gobject::GObject;
1879
1880    //=========================================================================
1881    // AtkHyperlink
1882    //=========================================================================
1883    pub fn atk_hyperlink_get_type() -> GType;
1884    pub fn atk_hyperlink_get_end_index(link_: *mut AtkHyperlink) -> c_int;
1885    pub fn atk_hyperlink_get_n_anchors(link_: *mut AtkHyperlink) -> c_int;
1886    pub fn atk_hyperlink_get_object(link_: *mut AtkHyperlink, i: c_int) -> *mut AtkObject;
1887    pub fn atk_hyperlink_get_start_index(link_: *mut AtkHyperlink) -> c_int;
1888    pub fn atk_hyperlink_get_uri(link_: *mut AtkHyperlink, i: c_int) -> *mut c_char;
1889    pub fn atk_hyperlink_is_inline(link_: *mut AtkHyperlink) -> gboolean;
1890    pub fn atk_hyperlink_is_selected_link(link_: *mut AtkHyperlink) -> gboolean;
1891    pub fn atk_hyperlink_is_valid(link_: *mut AtkHyperlink) -> gboolean;
1892
1893    //=========================================================================
1894    // AtkMisc
1895    //=========================================================================
1896    pub fn atk_misc_get_type() -> GType;
1897    pub fn atk_misc_get_instance() -> *const AtkMisc;
1898    pub fn atk_misc_threads_enter(misc: *mut AtkMisc);
1899    pub fn atk_misc_threads_leave(misc: *mut AtkMisc);
1900
1901    //=========================================================================
1902    // AtkNoOpObject
1903    //=========================================================================
1904    pub fn atk_no_op_object_get_type() -> GType;
1905    pub fn atk_no_op_object_new(obj: *mut gobject::GObject) -> *mut AtkObject;
1906
1907    //=========================================================================
1908    // AtkNoOpObjectFactory
1909    //=========================================================================
1910    pub fn atk_no_op_object_factory_get_type() -> GType;
1911    pub fn atk_no_op_object_factory_new() -> *mut AtkObjectFactory;
1912
1913    //=========================================================================
1914    // AtkObject
1915    //=========================================================================
1916    pub fn atk_object_get_type() -> GType;
1917    pub fn atk_object_add_relationship(
1918        object: *mut AtkObject,
1919        relationship: AtkRelationType,
1920        target: *mut AtkObject,
1921    ) -> gboolean;
1922    pub fn atk_object_connect_property_change_handler(
1923        accessible: *mut AtkObject,
1924        handler: *mut AtkPropertyChangeHandler,
1925    ) -> c_uint;
1926    pub fn atk_object_get_attributes(accessible: *mut AtkObject) -> *mut AtkAttributeSet;
1927    pub fn atk_object_get_description(accessible: *mut AtkObject) -> *const c_char;
1928    pub fn atk_object_get_index_in_parent(accessible: *mut AtkObject) -> c_int;
1929    pub fn atk_object_get_layer(accessible: *mut AtkObject) -> AtkLayer;
1930    pub fn atk_object_get_mdi_zorder(accessible: *mut AtkObject) -> c_int;
1931    pub fn atk_object_get_n_accessible_children(accessible: *mut AtkObject) -> c_int;
1932    pub fn atk_object_get_name(accessible: *mut AtkObject) -> *const c_char;
1933    pub fn atk_object_get_object_locale(accessible: *mut AtkObject) -> *const c_char;
1934    pub fn atk_object_get_parent(accessible: *mut AtkObject) -> *mut AtkObject;
1935    pub fn atk_object_get_role(accessible: *mut AtkObject) -> AtkRole;
1936    pub fn atk_object_initialize(accessible: *mut AtkObject, data: gpointer);
1937    pub fn atk_object_notify_state_change(
1938        accessible: *mut AtkObject,
1939        state: AtkState,
1940        value: gboolean,
1941    );
1942    pub fn atk_object_peek_parent(accessible: *mut AtkObject) -> *mut AtkObject;
1943    pub fn atk_object_ref_accessible_child(accessible: *mut AtkObject, i: c_int) -> *mut AtkObject;
1944    pub fn atk_object_ref_relation_set(accessible: *mut AtkObject) -> *mut AtkRelationSet;
1945    pub fn atk_object_ref_state_set(accessible: *mut AtkObject) -> *mut AtkStateSet;
1946    pub fn atk_object_remove_property_change_handler(
1947        accessible: *mut AtkObject,
1948        handler_id: c_uint,
1949    );
1950    pub fn atk_object_remove_relationship(
1951        object: *mut AtkObject,
1952        relationship: AtkRelationType,
1953        target: *mut AtkObject,
1954    ) -> gboolean;
1955    pub fn atk_object_set_description(accessible: *mut AtkObject, description: *const c_char);
1956    pub fn atk_object_set_name(accessible: *mut AtkObject, name: *const c_char);
1957    pub fn atk_object_set_parent(accessible: *mut AtkObject, parent: *mut AtkObject);
1958    pub fn atk_object_set_role(accessible: *mut AtkObject, role: AtkRole);
1959
1960    //=========================================================================
1961    // AtkObjectFactory
1962    //=========================================================================
1963    pub fn atk_object_factory_get_type() -> GType;
1964    pub fn atk_object_factory_create_accessible(
1965        factory: *mut AtkObjectFactory,
1966        obj: *mut gobject::GObject,
1967    ) -> *mut AtkObject;
1968    pub fn atk_object_factory_get_accessible_type(factory: *mut AtkObjectFactory) -> GType;
1969    pub fn atk_object_factory_invalidate(factory: *mut AtkObjectFactory);
1970
1971    //=========================================================================
1972    // AtkPlug
1973    //=========================================================================
1974    pub fn atk_plug_get_type() -> GType;
1975    pub fn atk_plug_new() -> *mut AtkObject;
1976    pub fn atk_plug_get_id(plug: *mut AtkPlug) -> *mut c_char;
1977
1978    //=========================================================================
1979    // AtkRegistry
1980    //=========================================================================
1981    pub fn atk_registry_get_type() -> GType;
1982    pub fn atk_registry_get_factory(
1983        registry: *mut AtkRegistry,
1984        type_: GType,
1985    ) -> *mut AtkObjectFactory;
1986    pub fn atk_registry_get_factory_type(registry: *mut AtkRegistry, type_: GType) -> GType;
1987    pub fn atk_registry_set_factory_type(
1988        registry: *mut AtkRegistry,
1989        type_: GType,
1990        factory_type: GType,
1991    );
1992
1993    //=========================================================================
1994    // AtkRelation
1995    //=========================================================================
1996    pub fn atk_relation_get_type() -> GType;
1997    pub fn atk_relation_new(
1998        targets: *mut *mut AtkObject,
1999        n_targets: c_int,
2000        relationship: AtkRelationType,
2001    ) -> *mut AtkRelation;
2002    pub fn atk_relation_add_target(relation: *mut AtkRelation, target: *mut AtkObject);
2003    pub fn atk_relation_get_relation_type(relation: *mut AtkRelation) -> AtkRelationType;
2004    pub fn atk_relation_get_target(relation: *mut AtkRelation) -> *mut glib::GPtrArray;
2005    pub fn atk_relation_remove_target(
2006        relation: *mut AtkRelation,
2007        target: *mut AtkObject,
2008    ) -> gboolean;
2009
2010    //=========================================================================
2011    // AtkRelationSet
2012    //=========================================================================
2013    pub fn atk_relation_set_get_type() -> GType;
2014    pub fn atk_relation_set_new() -> *mut AtkRelationSet;
2015    pub fn atk_relation_set_add(set: *mut AtkRelationSet, relation: *mut AtkRelation);
2016    pub fn atk_relation_set_add_relation_by_type(
2017        set: *mut AtkRelationSet,
2018        relationship: AtkRelationType,
2019        target: *mut AtkObject,
2020    );
2021    pub fn atk_relation_set_contains(
2022        set: *mut AtkRelationSet,
2023        relationship: AtkRelationType,
2024    ) -> gboolean;
2025    pub fn atk_relation_set_contains_target(
2026        set: *mut AtkRelationSet,
2027        relationship: AtkRelationType,
2028        target: *mut AtkObject,
2029    ) -> gboolean;
2030    pub fn atk_relation_set_get_n_relations(set: *mut AtkRelationSet) -> c_int;
2031    pub fn atk_relation_set_get_relation(set: *mut AtkRelationSet, i: c_int) -> *mut AtkRelation;
2032    pub fn atk_relation_set_get_relation_by_type(
2033        set: *mut AtkRelationSet,
2034        relationship: AtkRelationType,
2035    ) -> *mut AtkRelation;
2036    pub fn atk_relation_set_remove(set: *mut AtkRelationSet, relation: *mut AtkRelation);
2037
2038    //=========================================================================
2039    // AtkSocket
2040    //=========================================================================
2041    pub fn atk_socket_get_type() -> GType;
2042    pub fn atk_socket_new() -> *mut AtkObject;
2043    pub fn atk_socket_embed(obj: *mut AtkSocket, plug_id: *mut c_char);
2044    pub fn atk_socket_is_occupied(obj: *mut AtkSocket) -> gboolean;
2045
2046    //=========================================================================
2047    // AtkStateSet
2048    //=========================================================================
2049    pub fn atk_state_set_get_type() -> GType;
2050    pub fn atk_state_set_new() -> *mut AtkStateSet;
2051    pub fn atk_state_set_add_state(set: *mut AtkStateSet, type_: AtkStateType) -> gboolean;
2052    pub fn atk_state_set_add_states(
2053        set: *mut AtkStateSet,
2054        types: *mut AtkStateType,
2055        n_types: c_int,
2056    );
2057    pub fn atk_state_set_and_sets(
2058        set: *mut AtkStateSet,
2059        compare_set: *mut AtkStateSet,
2060    ) -> *mut AtkStateSet;
2061    pub fn atk_state_set_clear_states(set: *mut AtkStateSet);
2062    pub fn atk_state_set_contains_state(set: *mut AtkStateSet, type_: AtkStateType) -> gboolean;
2063    pub fn atk_state_set_contains_states(
2064        set: *mut AtkStateSet,
2065        types: *mut AtkStateType,
2066        n_types: c_int,
2067    ) -> gboolean;
2068    pub fn atk_state_set_is_empty(set: *mut AtkStateSet) -> gboolean;
2069    pub fn atk_state_set_or_sets(
2070        set: *mut AtkStateSet,
2071        compare_set: *mut AtkStateSet,
2072    ) -> *mut AtkStateSet;
2073    pub fn atk_state_set_remove_state(set: *mut AtkStateSet, type_: AtkStateType) -> gboolean;
2074    pub fn atk_state_set_xor_sets(
2075        set: *mut AtkStateSet,
2076        compare_set: *mut AtkStateSet,
2077    ) -> *mut AtkStateSet;
2078
2079    //=========================================================================
2080    // AtkUtil
2081    //=========================================================================
2082    pub fn atk_util_get_type() -> GType;
2083
2084    //=========================================================================
2085    // AtkAction
2086    //=========================================================================
2087    pub fn atk_action_get_type() -> GType;
2088    pub fn atk_action_do_action(action: *mut AtkAction, i: c_int) -> gboolean;
2089    pub fn atk_action_get_description(action: *mut AtkAction, i: c_int) -> *const c_char;
2090    pub fn atk_action_get_keybinding(action: *mut AtkAction, i: c_int) -> *const c_char;
2091    pub fn atk_action_get_localized_name(action: *mut AtkAction, i: c_int) -> *const c_char;
2092    pub fn atk_action_get_n_actions(action: *mut AtkAction) -> c_int;
2093    pub fn atk_action_get_name(action: *mut AtkAction, i: c_int) -> *const c_char;
2094    pub fn atk_action_set_description(
2095        action: *mut AtkAction,
2096        i: c_int,
2097        desc: *const c_char,
2098    ) -> gboolean;
2099
2100    //=========================================================================
2101    // AtkComponent
2102    //=========================================================================
2103    pub fn atk_component_get_type() -> GType;
2104    pub fn atk_component_add_focus_handler(
2105        component: *mut AtkComponent,
2106        handler: AtkFocusHandler,
2107    ) -> c_uint;
2108    pub fn atk_component_contains(
2109        component: *mut AtkComponent,
2110        x: c_int,
2111        y: c_int,
2112        coord_type: AtkCoordType,
2113    ) -> gboolean;
2114    pub fn atk_component_get_alpha(component: *mut AtkComponent) -> c_double;
2115    pub fn atk_component_get_extents(
2116        component: *mut AtkComponent,
2117        x: *mut c_int,
2118        y: *mut c_int,
2119        width: *mut c_int,
2120        height: *mut c_int,
2121        coord_type: AtkCoordType,
2122    );
2123    pub fn atk_component_get_layer(component: *mut AtkComponent) -> AtkLayer;
2124    pub fn atk_component_get_mdi_zorder(component: *mut AtkComponent) -> c_int;
2125    pub fn atk_component_get_position(
2126        component: *mut AtkComponent,
2127        x: *mut c_int,
2128        y: *mut c_int,
2129        coord_type: AtkCoordType,
2130    );
2131    pub fn atk_component_get_size(
2132        component: *mut AtkComponent,
2133        width: *mut c_int,
2134        height: *mut c_int,
2135    );
2136    pub fn atk_component_grab_focus(component: *mut AtkComponent) -> gboolean;
2137    pub fn atk_component_ref_accessible_at_point(
2138        component: *mut AtkComponent,
2139        x: c_int,
2140        y: c_int,
2141        coord_type: AtkCoordType,
2142    ) -> *mut AtkObject;
2143    pub fn atk_component_remove_focus_handler(component: *mut AtkComponent, handler_id: c_uint);
2144    #[cfg(any(feature = "v2_30", feature = "dox"))]
2145    pub fn atk_component_scroll_to(component: *mut AtkComponent, type_: AtkScrollType) -> gboolean;
2146    #[cfg(any(feature = "v2_30", feature = "dox"))]
2147    pub fn atk_component_scroll_to_point(
2148        component: *mut AtkComponent,
2149        coords: AtkCoordType,
2150        x: c_int,
2151        y: c_int,
2152    ) -> gboolean;
2153    pub fn atk_component_set_extents(
2154        component: *mut AtkComponent,
2155        x: c_int,
2156        y: c_int,
2157        width: c_int,
2158        height: c_int,
2159        coord_type: AtkCoordType,
2160    ) -> gboolean;
2161    pub fn atk_component_set_position(
2162        component: *mut AtkComponent,
2163        x: c_int,
2164        y: c_int,
2165        coord_type: AtkCoordType,
2166    ) -> gboolean;
2167    pub fn atk_component_set_size(
2168        component: *mut AtkComponent,
2169        width: c_int,
2170        height: c_int,
2171    ) -> gboolean;
2172
2173    //=========================================================================
2174    // AtkDocument
2175    //=========================================================================
2176    pub fn atk_document_get_type() -> GType;
2177    pub fn atk_document_get_attribute_value(
2178        document: *mut AtkDocument,
2179        attribute_name: *const c_char,
2180    ) -> *const c_char;
2181    pub fn atk_document_get_attributes(document: *mut AtkDocument) -> *mut AtkAttributeSet;
2182    pub fn atk_document_get_current_page_number(document: *mut AtkDocument) -> c_int;
2183    pub fn atk_document_get_document(document: *mut AtkDocument) -> gpointer;
2184    pub fn atk_document_get_document_type(document: *mut AtkDocument) -> *const c_char;
2185    pub fn atk_document_get_locale(document: *mut AtkDocument) -> *const c_char;
2186    pub fn atk_document_get_page_count(document: *mut AtkDocument) -> c_int;
2187    pub fn atk_document_set_attribute_value(
2188        document: *mut AtkDocument,
2189        attribute_name: *const c_char,
2190        attribute_value: *const c_char,
2191    ) -> gboolean;
2192
2193    //=========================================================================
2194    // AtkEditableText
2195    //=========================================================================
2196    pub fn atk_editable_text_get_type() -> GType;
2197    pub fn atk_editable_text_copy_text(
2198        text: *mut AtkEditableText,
2199        start_pos: c_int,
2200        end_pos: c_int,
2201    );
2202    pub fn atk_editable_text_cut_text(text: *mut AtkEditableText, start_pos: c_int, end_pos: c_int);
2203    pub fn atk_editable_text_delete_text(
2204        text: *mut AtkEditableText,
2205        start_pos: c_int,
2206        end_pos: c_int,
2207    );
2208    pub fn atk_editable_text_insert_text(
2209        text: *mut AtkEditableText,
2210        string: *const c_char,
2211        length: c_int,
2212        position: *mut c_int,
2213    );
2214    pub fn atk_editable_text_paste_text(text: *mut AtkEditableText, position: c_int);
2215    pub fn atk_editable_text_set_run_attributes(
2216        text: *mut AtkEditableText,
2217        attrib_set: *mut AtkAttributeSet,
2218        start_offset: c_int,
2219        end_offset: c_int,
2220    ) -> gboolean;
2221    pub fn atk_editable_text_set_text_contents(text: *mut AtkEditableText, string: *const c_char);
2222
2223    //=========================================================================
2224    // AtkHyperlinkImpl
2225    //=========================================================================
2226    pub fn atk_hyperlink_impl_get_type() -> GType;
2227    pub fn atk_hyperlink_impl_get_hyperlink(impl_: *mut AtkHyperlinkImpl) -> *mut AtkHyperlink;
2228
2229    //=========================================================================
2230    // AtkHypertext
2231    //=========================================================================
2232    pub fn atk_hypertext_get_type() -> GType;
2233    pub fn atk_hypertext_get_link(
2234        hypertext: *mut AtkHypertext,
2235        link_index: c_int,
2236    ) -> *mut AtkHyperlink;
2237    pub fn atk_hypertext_get_link_index(hypertext: *mut AtkHypertext, char_index: c_int) -> c_int;
2238    pub fn atk_hypertext_get_n_links(hypertext: *mut AtkHypertext) -> c_int;
2239
2240    //=========================================================================
2241    // AtkImage
2242    //=========================================================================
2243    pub fn atk_image_get_type() -> GType;
2244    pub fn atk_image_get_image_description(image: *mut AtkImage) -> *const c_char;
2245    pub fn atk_image_get_image_locale(image: *mut AtkImage) -> *const c_char;
2246    pub fn atk_image_get_image_position(
2247        image: *mut AtkImage,
2248        x: *mut c_int,
2249        y: *mut c_int,
2250        coord_type: AtkCoordType,
2251    );
2252    pub fn atk_image_get_image_size(image: *mut AtkImage, width: *mut c_int, height: *mut c_int);
2253    pub fn atk_image_set_image_description(
2254        image: *mut AtkImage,
2255        description: *const c_char,
2256    ) -> gboolean;
2257
2258    //=========================================================================
2259    // AtkImplementorIface
2260    //=========================================================================
2261    pub fn atk_implementor_get_type() -> GType;
2262
2263    //=========================================================================
2264    // AtkSelection
2265    //=========================================================================
2266    pub fn atk_selection_get_type() -> GType;
2267    pub fn atk_selection_add_selection(selection: *mut AtkSelection, i: c_int) -> gboolean;
2268    pub fn atk_selection_clear_selection(selection: *mut AtkSelection) -> gboolean;
2269    pub fn atk_selection_get_selection_count(selection: *mut AtkSelection) -> c_int;
2270    pub fn atk_selection_is_child_selected(selection: *mut AtkSelection, i: c_int) -> gboolean;
2271    pub fn atk_selection_ref_selection(selection: *mut AtkSelection, i: c_int) -> *mut AtkObject;
2272    pub fn atk_selection_remove_selection(selection: *mut AtkSelection, i: c_int) -> gboolean;
2273    pub fn atk_selection_select_all_selection(selection: *mut AtkSelection) -> gboolean;
2274
2275    //=========================================================================
2276    // AtkStreamableContent
2277    //=========================================================================
2278    pub fn atk_streamable_content_get_type() -> GType;
2279    pub fn atk_streamable_content_get_mime_type(
2280        streamable: *mut AtkStreamableContent,
2281        i: c_int,
2282    ) -> *const c_char;
2283    pub fn atk_streamable_content_get_n_mime_types(streamable: *mut AtkStreamableContent) -> c_int;
2284    pub fn atk_streamable_content_get_stream(
2285        streamable: *mut AtkStreamableContent,
2286        mime_type: *const c_char,
2287    ) -> *mut glib::GIOChannel;
2288    pub fn atk_streamable_content_get_uri(
2289        streamable: *mut AtkStreamableContent,
2290        mime_type: *const c_char,
2291    ) -> *const c_char;
2292
2293    //=========================================================================
2294    // AtkTable
2295    //=========================================================================
2296    pub fn atk_table_get_type() -> GType;
2297    pub fn atk_table_add_column_selection(table: *mut AtkTable, column: c_int) -> gboolean;
2298    pub fn atk_table_add_row_selection(table: *mut AtkTable, row: c_int) -> gboolean;
2299    pub fn atk_table_get_caption(table: *mut AtkTable) -> *mut AtkObject;
2300    pub fn atk_table_get_column_at_index(table: *mut AtkTable, index_: c_int) -> c_int;
2301    pub fn atk_table_get_column_description(table: *mut AtkTable, column: c_int) -> *const c_char;
2302    pub fn atk_table_get_column_extent_at(table: *mut AtkTable, row: c_int, column: c_int)
2303        -> c_int;
2304    pub fn atk_table_get_column_header(table: *mut AtkTable, column: c_int) -> *mut AtkObject;
2305    pub fn atk_table_get_index_at(table: *mut AtkTable, row: c_int, column: c_int) -> c_int;
2306    pub fn atk_table_get_n_columns(table: *mut AtkTable) -> c_int;
2307    pub fn atk_table_get_n_rows(table: *mut AtkTable) -> c_int;
2308    pub fn atk_table_get_row_at_index(table: *mut AtkTable, index_: c_int) -> c_int;
2309    pub fn atk_table_get_row_description(table: *mut AtkTable, row: c_int) -> *const c_char;
2310    pub fn atk_table_get_row_extent_at(table: *mut AtkTable, row: c_int, column: c_int) -> c_int;
2311    pub fn atk_table_get_row_header(table: *mut AtkTable, row: c_int) -> *mut AtkObject;
2312    pub fn atk_table_get_selected_columns(table: *mut AtkTable, selected: *mut *mut c_int)
2313        -> c_int;
2314    pub fn atk_table_get_selected_rows(table: *mut AtkTable, selected: *mut *mut c_int) -> c_int;
2315    pub fn atk_table_get_summary(table: *mut AtkTable) -> *mut AtkObject;
2316    pub fn atk_table_is_column_selected(table: *mut AtkTable, column: c_int) -> gboolean;
2317    pub fn atk_table_is_row_selected(table: *mut AtkTable, row: c_int) -> gboolean;
2318    pub fn atk_table_is_selected(table: *mut AtkTable, row: c_int, column: c_int) -> gboolean;
2319    pub fn atk_table_ref_at(table: *mut AtkTable, row: c_int, column: c_int) -> *mut AtkObject;
2320    pub fn atk_table_remove_column_selection(table: *mut AtkTable, column: c_int) -> gboolean;
2321    pub fn atk_table_remove_row_selection(table: *mut AtkTable, row: c_int) -> gboolean;
2322    pub fn atk_table_set_caption(table: *mut AtkTable, caption: *mut AtkObject);
2323    pub fn atk_table_set_column_description(
2324        table: *mut AtkTable,
2325        column: c_int,
2326        description: *const c_char,
2327    );
2328    pub fn atk_table_set_column_header(table: *mut AtkTable, column: c_int, header: *mut AtkObject);
2329    pub fn atk_table_set_row_description(
2330        table: *mut AtkTable,
2331        row: c_int,
2332        description: *const c_char,
2333    );
2334    pub fn atk_table_set_row_header(table: *mut AtkTable, row: c_int, header: *mut AtkObject);
2335    pub fn atk_table_set_summary(table: *mut AtkTable, accessible: *mut AtkObject);
2336
2337    //=========================================================================
2338    // AtkTableCell
2339    //=========================================================================
2340    pub fn atk_table_cell_get_type() -> GType;
2341    pub fn atk_table_cell_get_column_header_cells(cell: *mut AtkTableCell) -> *mut glib::GPtrArray;
2342    pub fn atk_table_cell_get_column_span(cell: *mut AtkTableCell) -> c_int;
2343    pub fn atk_table_cell_get_position(
2344        cell: *mut AtkTableCell,
2345        row: *mut c_int,
2346        column: *mut c_int,
2347    ) -> gboolean;
2348    pub fn atk_table_cell_get_row_column_span(
2349        cell: *mut AtkTableCell,
2350        row: *mut c_int,
2351        column: *mut c_int,
2352        row_span: *mut c_int,
2353        column_span: *mut c_int,
2354    ) -> gboolean;
2355    pub fn atk_table_cell_get_row_header_cells(cell: *mut AtkTableCell) -> *mut glib::GPtrArray;
2356    pub fn atk_table_cell_get_row_span(cell: *mut AtkTableCell) -> c_int;
2357    pub fn atk_table_cell_get_table(cell: *mut AtkTableCell) -> *mut AtkObject;
2358
2359    //=========================================================================
2360    // AtkText
2361    //=========================================================================
2362    pub fn atk_text_get_type() -> GType;
2363    pub fn atk_text_free_ranges(ranges: *mut *mut AtkTextRange);
2364    pub fn atk_text_add_selection(
2365        text: *mut AtkText,
2366        start_offset: c_int,
2367        end_offset: c_int,
2368    ) -> gboolean;
2369    pub fn atk_text_get_bounded_ranges(
2370        text: *mut AtkText,
2371        rect: *mut AtkTextRectangle,
2372        coord_type: AtkCoordType,
2373        x_clip_type: AtkTextClipType,
2374        y_clip_type: AtkTextClipType,
2375    ) -> *mut *mut AtkTextRange;
2376    pub fn atk_text_get_caret_offset(text: *mut AtkText) -> c_int;
2377    pub fn atk_text_get_character_at_offset(text: *mut AtkText, offset: c_int) -> u32;
2378    pub fn atk_text_get_character_count(text: *mut AtkText) -> c_int;
2379    pub fn atk_text_get_character_extents(
2380        text: *mut AtkText,
2381        offset: c_int,
2382        x: *mut c_int,
2383        y: *mut c_int,
2384        width: *mut c_int,
2385        height: *mut c_int,
2386        coords: AtkCoordType,
2387    );
2388    pub fn atk_text_get_default_attributes(text: *mut AtkText) -> *mut AtkAttributeSet;
2389    pub fn atk_text_get_n_selections(text: *mut AtkText) -> c_int;
2390    pub fn atk_text_get_offset_at_point(
2391        text: *mut AtkText,
2392        x: c_int,
2393        y: c_int,
2394        coords: AtkCoordType,
2395    ) -> c_int;
2396    pub fn atk_text_get_range_extents(
2397        text: *mut AtkText,
2398        start_offset: c_int,
2399        end_offset: c_int,
2400        coord_type: AtkCoordType,
2401        rect: *mut AtkTextRectangle,
2402    );
2403    pub fn atk_text_get_run_attributes(
2404        text: *mut AtkText,
2405        offset: c_int,
2406        start_offset: *mut c_int,
2407        end_offset: *mut c_int,
2408    ) -> *mut AtkAttributeSet;
2409    pub fn atk_text_get_selection(
2410        text: *mut AtkText,
2411        selection_num: c_int,
2412        start_offset: *mut c_int,
2413        end_offset: *mut c_int,
2414    ) -> *mut c_char;
2415    pub fn atk_text_get_string_at_offset(
2416        text: *mut AtkText,
2417        offset: c_int,
2418        granularity: AtkTextGranularity,
2419        start_offset: *mut c_int,
2420        end_offset: *mut c_int,
2421    ) -> *mut c_char;
2422    pub fn atk_text_get_text(
2423        text: *mut AtkText,
2424        start_offset: c_int,
2425        end_offset: c_int,
2426    ) -> *mut c_char;
2427    pub fn atk_text_get_text_after_offset(
2428        text: *mut AtkText,
2429        offset: c_int,
2430        boundary_type: AtkTextBoundary,
2431        start_offset: *mut c_int,
2432        end_offset: *mut c_int,
2433    ) -> *mut c_char;
2434    pub fn atk_text_get_text_at_offset(
2435        text: *mut AtkText,
2436        offset: c_int,
2437        boundary_type: AtkTextBoundary,
2438        start_offset: *mut c_int,
2439        end_offset: *mut c_int,
2440    ) -> *mut c_char;
2441    pub fn atk_text_get_text_before_offset(
2442        text: *mut AtkText,
2443        offset: c_int,
2444        boundary_type: AtkTextBoundary,
2445        start_offset: *mut c_int,
2446        end_offset: *mut c_int,
2447    ) -> *mut c_char;
2448    pub fn atk_text_remove_selection(text: *mut AtkText, selection_num: c_int) -> gboolean;
2449    pub fn atk_text_set_caret_offset(text: *mut AtkText, offset: c_int) -> gboolean;
2450    pub fn atk_text_set_selection(
2451        text: *mut AtkText,
2452        selection_num: c_int,
2453        start_offset: c_int,
2454        end_offset: c_int,
2455    ) -> gboolean;
2456
2457    //=========================================================================
2458    // AtkValue
2459    //=========================================================================
2460    pub fn atk_value_get_type() -> GType;
2461    pub fn atk_value_get_current_value(obj: *mut AtkValue, value: *mut gobject::GValue);
2462    pub fn atk_value_get_increment(obj: *mut AtkValue) -> c_double;
2463    pub fn atk_value_get_maximum_value(obj: *mut AtkValue, value: *mut gobject::GValue);
2464    pub fn atk_value_get_minimum_increment(obj: *mut AtkValue, value: *mut gobject::GValue);
2465    pub fn atk_value_get_minimum_value(obj: *mut AtkValue, value: *mut gobject::GValue);
2466    pub fn atk_value_get_range(obj: *mut AtkValue) -> *mut AtkRange;
2467    pub fn atk_value_get_sub_ranges(obj: *mut AtkValue) -> *mut glib::GSList;
2468    pub fn atk_value_get_value_and_text(
2469        obj: *mut AtkValue,
2470        value: *mut c_double,
2471        text: *mut *mut c_char,
2472    );
2473    pub fn atk_value_set_current_value(
2474        obj: *mut AtkValue,
2475        value: *const gobject::GValue,
2476    ) -> gboolean;
2477    pub fn atk_value_set_value(obj: *mut AtkValue, new_value: c_double);
2478
2479    //=========================================================================
2480    // AtkWindow
2481    //=========================================================================
2482    pub fn atk_window_get_type() -> GType;
2483
2484    //=========================================================================
2485    // Other functions
2486    //=========================================================================
2487    pub fn atk_add_focus_tracker(focus_tracker: AtkEventListener) -> c_uint;
2488    pub fn atk_add_global_event_listener(
2489        listener: gobject::GSignalEmissionHook,
2490        event_type: *const c_char,
2491    ) -> c_uint;
2492    pub fn atk_add_key_event_listener(listener: AtkKeySnoopFunc, data: gpointer) -> c_uint;
2493    pub fn atk_focus_tracker_init(init: AtkEventListenerInit);
2494    pub fn atk_focus_tracker_notify(object: *mut AtkObject);
2495    pub fn atk_get_binary_age() -> c_uint;
2496    pub fn atk_get_default_registry() -> *mut AtkRegistry;
2497    pub fn atk_get_focus_object() -> *mut AtkObject;
2498    pub fn atk_get_interface_age() -> c_uint;
2499    pub fn atk_get_major_version() -> c_uint;
2500    pub fn atk_get_micro_version() -> c_uint;
2501    pub fn atk_get_minor_version() -> c_uint;
2502    pub fn atk_get_root() -> *mut AtkObject;
2503    pub fn atk_get_toolkit_name() -> *const c_char;
2504    pub fn atk_get_toolkit_version() -> *const c_char;
2505    pub fn atk_get_version() -> *const c_char;
2506    pub fn atk_remove_focus_tracker(tracker_id: c_uint);
2507    pub fn atk_remove_global_event_listener(listener_id: c_uint);
2508    pub fn atk_remove_key_event_listener(listener_id: c_uint);
2509
2510}