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