1#![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
25pub type AtkAttributeSet = glib::GSList;
27pub type AtkState = u64;
28
29pub 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
326pub type AtkHyperlinkStateFlags = c_uint;
330pub const ATK_HYPERLINK_IS_INLINE: AtkHyperlinkStateFlags = 1;
331
332pub 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#[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#[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#[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 pub fn atk_coord_type_get_type() -> GType;
1759
1760 pub fn atk_key_event_type_get_type() -> GType;
1764
1765 pub fn atk_layer_get_type() -> GType;
1769
1770 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 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 pub fn atk_scroll_type_get_type() -> GType;
1791
1792 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 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 pub fn atk_text_boundary_get_type() -> GType;
1813
1814 pub fn atk_text_clip_type_get_type() -> GType;
1818
1819 pub fn atk_text_granularity_get_type() -> GType;
1823
1824 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 pub fn atk_hyperlink_state_flags_get_type() -> GType;
1835
1836 pub fn atk_attribute_set_free(attrib_set: *mut AtkAttributeSet);
1840
1841 pub fn atk_implementor_ref_accessible(implementor: *mut AtkImplementor) -> *mut AtkObject;
1845
1846 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 pub fn atk_rectangle_get_type() -> GType;
1865
1866 pub fn atk_text_range_get_type() -> GType;
1870
1871 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 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 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 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 pub fn atk_no_op_object_factory_get_type() -> GType;
1911 pub fn atk_no_op_object_factory_new() -> *mut AtkObjectFactory;
1912
1913 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 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 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 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 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 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 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 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 pub fn atk_util_get_type() -> GType;
2083
2084 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 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 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 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 pub fn atk_hyperlink_impl_get_type() -> GType;
2227 pub fn atk_hyperlink_impl_get_hyperlink(impl_: *mut AtkHyperlinkImpl) -> *mut AtkHyperlink;
2228
2229 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 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 pub fn atk_implementor_get_type() -> GType;
2262
2263 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 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 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 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 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 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 pub fn atk_window_get_type() -> GType;
2483
2484 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}