1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gtkc.atktypes;
26 
27 public import gtkc.glibtypes;
28 public import gtkc.gobjecttypes;
29 
30 /**
31  * This is a singly-linked list (a #GSList) of #AtkAttribute. It is
32  * used by atk_text_get_run_attributes(),
33  * atk_text_get_default_attributes(),
34  * atk_editable_text_set_run_attributes(),
35  * atk_document_get_attributes() and atk_object_get_attributes()
36  */
37 public alias GSList AtkAttributeSet;
38 
39 public alias ulong AtkState;
40 
41 /**
42  * Specifies how xy coordinates are to be interpreted. Used by functions such
43  * as atk_component_get_position() and atk_text_get_character_extents()
44  */
45 public enum AtkCoordType
46 {
47 	/**
48 	 * specifies xy coordinates relative to the screen
49 	 */
50 	SCREEN = 0,
51 	/**
52 	 * specifies xy coordinates relative to the widget's
53 	 * top-level window
54 	 */
55 	WINDOW = 1,
56 }
57 alias AtkCoordType CoordType;
58 
59 /**
60  * Describes the type of link
61  */
62 public enum AtkHyperlinkStateFlags
63 {
64 	/**
65 	 * Link is inline
66 	 */
67 	INLINE = 1,
68 }
69 alias AtkHyperlinkStateFlags HyperlinkStateFlags;
70 
71 /**
72  * Specifies the type of a keyboard evemt.
73  */
74 public enum AtkKeyEventType
75 {
76 	/**
77 	 * specifies a key press event
78 	 */
79 	PRESS = 0,
80 	/**
81 	 * specifies a key release event
82 	 */
83 	RELEASE = 1,
84 	/**
85 	 * Not a valid value; specifies end of enumeration
86 	 */
87 	LAST_DEFINED = 2,
88 }
89 alias AtkKeyEventType KeyEventType;
90 
91 /**
92  * Describes the layer of a component
93  *
94  * These enumerated "layer values" are used when determining which UI
95  * rendering layer a component is drawn into, which can help in making
96  * determinations of when components occlude one another.
97  */
98 public enum AtkLayer
99 {
100 	/**
101 	 * The object does not have a layer
102 	 */
103 	INVALID = 0,
104 	/**
105 	 * This layer is reserved for the desktop background
106 	 */
107 	BACKGROUND = 1,
108 	/**
109 	 * This layer is used for Canvas components
110 	 */
111 	CANVAS = 2,
112 	/**
113 	 * This layer is normally used for components
114 	 */
115 	WIDGET = 3,
116 	/**
117 	 * This layer is used for layered components
118 	 */
119 	MDI = 4,
120 	/**
121 	 * This layer is used for popup components, such as menus
122 	 */
123 	POPUP = 5,
124 	/**
125 	 * This layer is reserved for future use.
126 	 */
127 	OVERLAY = 6,
128 	/**
129 	 * This layer is used for toplevel windows.
130 	 */
131 	WINDOW = 7,
132 }
133 alias AtkLayer Layer;
134 
135 /**
136  * Describes the type of the relation
137  */
138 public enum AtkRelationType
139 {
140 	/**
141 	 * Not used, represens "no relationship" or an error condition.
142 	 */
143 	NULL = 0,
144 	/**
145 	 * Indicates an object controlled by one or more target objects.
146 	 */
147 	CONTROLLED_BY = 1,
148 	/**
149 	 * Indicates an object is an controller for one or more target objects.
150 	 */
151 	CONTROLLER_FOR = 2,
152 	/**
153 	 * Indicates an object is a label for one or more target objects.
154 	 */
155 	LABEL_FOR = 3,
156 	/**
157 	 * Indicates an object is labelled by one or more target objects.
158 	 */
159 	LABELLED_BY = 4,
160 	/**
161 	 * Indicates an object is a member of a group of one or more target objects.
162 	 */
163 	MEMBER_OF = 5,
164 	/**
165 	 * Indicates an object is a cell in a treetable which is displayed because a cell in the same column is expanded and identifies that cell.
166 	 */
167 	NODE_CHILD_OF = 6,
168 	/**
169 	 * Indicates that the object has content that flows logically to another
170 	 * AtkObject in a sequential way, (for instance text-flow).
171 	 */
172 	FLOWS_TO = 7,
173 	/**
174 	 * Indicates that the object has content that flows logically from
175 	 * another AtkObject in a sequential way, (for instance text-flow).
176 	 */
177 	FLOWS_FROM = 8,
178 	/**
179 	 * Indicates a subwindow attached to a component but otherwise has no connection in  the UI heirarchy to that component.
180 	 */
181 	SUBWINDOW_OF = 9,
182 	/**
183 	 * Indicates that the object visually embeds
184 	 * another object's content, i.e. this object's content flows around
185 	 * another's content.
186 	 */
187 	EMBEDS = 10,
188 	/**
189 	 * Inverse of %ATK_RELATION_EMBEDS, indicates that
190 	 * this object's content is visualy embedded in another object.
191 	 */
192 	EMBEDDED_BY = 11,
193 	/**
194 	 * Indicates that an object is a popup for another object.
195 	 */
196 	POPUP_FOR = 12,
197 	/**
198 	 * Indicates that an object is a parent window of another object.
199 	 */
200 	PARENT_WINDOW_OF = 13,
201 	/**
202 	 * Indicates that another object provides descriptive information about this object; more verbose than ATK_RELATION_LABELLED_BY.
203 	 */
204 	DESCRIBED_BY = 14,
205 	/**
206 	 * Indicates that an object provides descriptive information about another object; more verbose than ATK_RELATION_LABEL_FOR.
207 	 */
208 	DESCRIPTION_FOR = 15,
209 	/**
210 	 * Indicates an object is a cell in a treetable and is expanded to display other cells in the same column.
211 	 */
212 	NODE_PARENT_OF = 16,
213 	/**
214 	 * Not used, this value indicates the end of the enumeration.
215 	 */
216 	LAST_DEFINED = 17,
217 }
218 alias AtkRelationType RelationType;
219 
220 /**
221  * Describes the role of an object
222  *
223  * These are the built-in enumerated roles that UI components can have in
224  * ATK.  Other roles may be added at runtime, so an AtkRole >=
225  * ATK_ROLE_LAST_DEFINED is not necessarily an error.
226  */
227 public enum AtkRole
228 {
229 	/**
230 	 * Invalid role
231 	 */
232 	INVALID = 0,
233 	/**
234 	 * A label which represents an accelerator
235 	 */
236 	ACCELERATOR_LABEL = 1,
237 	/**
238 	 * An object which is an alert to the user. Assistive Technologies typically respond to ATK_ROLE_ALERT by reading the entire onscreen contents of containers advertising this role.  Should be used for warning dialogs, etc.
239 	 */
240 	ALERT = 2,
241 	/**
242 	 * An object which is an animated image
243 	 */
244 	ANIMATION = 3,
245 	/**
246 	 * An arrow in one of the four cardinal directions
247 	 */
248 	ARROW = 4,
249 	/**
250 	 * An object that displays a calendar and allows the user to select a date
251 	 */
252 	CALENDAR = 5,
253 	/**
254 	 * An object that can be drawn into and is used to trap events
255 	 */
256 	CANVAS = 6,
257 	/**
258 	 * A choice that can be checked or unchecked and provides a separate indicator for the current state
259 	 */
260 	CHECK_BOX = 7,
261 	/**
262 	 * A menu item with a check box
263 	 */
264 	CHECK_MENU_ITEM = 8,
265 	/**
266 	 * A specialized dialog that lets the user choose a color
267 	 */
268 	COLOR_CHOOSER = 9,
269 	/**
270 	 * The header for a column of data
271 	 */
272 	COLUMN_HEADER = 10,
273 	/**
274 	 * A collapsible list of choices the user can select from
275 	 */
276 	COMBO_BOX = 11,
277 	/**
278 	 * An object whose purpose is to allow a user to edit a date
279 	 */
280 	DATE_EDITOR = 12,
281 	/**
282 	 * An inconifed internal frame within a DESKTOP_PANE
283 	 */
284 	DESKTOP_ICON = 13,
285 	/**
286 	 * A pane that supports internal frames and iconified versions of those internal frames
287 	 */
288 	DESKTOP_FRAME = 14,
289 	/**
290 	 * An object whose purpose is to allow a user to set a value
291 	 */
292 	DIAL = 15,
293 	/**
294 	 * A top level window with title bar and a border
295 	 */
296 	DIALOG = 16,
297 	/**
298 	 * A pane that allows the user to navigate through and select the contents of a directory
299 	 */
300 	DIRECTORY_PANE = 17,
301 	/**
302 	 * An object used for drawing custom user interface elements
303 	 */
304 	DRAWING_AREA = 18,
305 	/**
306 	 * A specialized dialog that lets the user choose a file
307 	 */
308 	FILE_CHOOSER = 19,
309 	/**
310 	 * A object that fills up space in a user interface
311 	 */
312 	FILLER = 20,
313 	/**
314 	 * A specialized dialog that lets the user choose a font
315 	 */
316 	FONT_CHOOSER = 21,
317 	/**
318 	 * A top level window with a title bar, border, menubar, etc.
319 	 */
320 	FRAME = 22,
321 	/**
322 	 * A pane that is guaranteed to be painted on top of all panes beneath it
323 	 */
324 	GLASS_PANE = 23,
325 	/**
326 	 * A document container for HTML, whose children represent the document content
327 	 */
328 	HTML_CONTAINER = 24,
329 	/**
330 	 * A small fixed size picture, typically used to decorate components
331 	 */
332 	ICON = 25,
333 	/**
334 	 * An object whose primary purpose is to display an image
335 	 */
336 	IMAGE = 26,
337 	/**
338 	 * A frame-like object that is clipped by a desktop pane
339 	 */
340 	INTERNAL_FRAME = 27,
341 	/**
342 	 * An object used to present an icon or short string in an interface
343 	 */
344 	LABEL = 28,
345 	/**
346 	 * A specialized pane that allows its children to be drawn in layers, providing a form of stacking order
347 	 */
348 	LAYERED_PANE = 29,
349 	/**
350 	 * An object that presents a list of objects to the user and allows the user to select one or more of them
351 	 */
352 	LIST = 30,
353 	/**
354 	 * An object that represents an element of a list
355 	 */
356 	LIST_ITEM = 31,
357 	/**
358 	 * An object usually found inside a menu bar that contains a list of actions the user can choose from
359 	 */
360 	MENU = 32,
361 	/**
362 	 * An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from
363 	 */
364 	MENU_BAR = 33,
365 	/**
366 	 * An object usually contained in a menu that presents an action the user can choose
367 	 */
368 	MENU_ITEM = 34,
369 	/**
370 	 * A specialized pane whose primary use is inside a DIALOG
371 	 */
372 	OPTION_PANE = 35,
373 	/**
374 	 * An object that is a child of a page tab list
375 	 */
376 	PAGE_TAB = 36,
377 	/**
378 	 * An object that presents a series of panels (or page tabs), one at a time, through some mechanism provided by the object
379 	 */
380 	PAGE_TAB_LIST = 37,
381 	/**
382 	 * A generic container that is often used to group objects
383 	 */
384 	PANEL = 38,
385 	/**
386 	 * A text object uses for passwords, or other places where the text content is not shown visibly to the user
387 	 */
388 	PASSWORD_TEXT = 39,
389 	/**
390 	 * A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices
391 	 */
392 	POPUP_MENU = 40,
393 	/**
394 	 * An object used to indicate how much of a task has been completed
395 	 */
396 	PROGRESS_BAR = 41,
397 	/**
398 	 * An object the user can manipulate to tell the application to do something
399 	 */
400 	PUSH_BUTTON = 42,
401 	/**
402 	 * A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked
403 	 */
404 	RADIO_BUTTON = 43,
405 	/**
406 	 * A check menu item which belongs to a group. At each instant exactly one of the radio menu items from a group is selected
407 	 */
408 	RADIO_MENU_ITEM = 44,
409 	/**
410 	 * A specialized pane that has a glass pane and a layered pane as its children
411 	 */
412 	ROOT_PANE = 45,
413 	/**
414 	 * The header for a row of data
415 	 */
416 	ROW_HEADER = 46,
417 	/**
418 	 * An object usually used to allow a user to incrementally view a large amount of data.
419 	 */
420 	SCROLL_BAR = 47,
421 	/**
422 	 * An object that allows a user to incrementally view a large amount of information
423 	 */
424 	SCROLL_PANE = 48,
425 	/**
426 	 * An object usually contained in a menu to provide a visible and logical separation of the contents in a menu
427 	 */
428 	SEPARATOR = 49,
429 	/**
430 	 * An object that allows the user to select from a bounded range
431 	 */
432 	SLIDER = 50,
433 	/**
434 	 * A specialized panel that presents two other panels at the same time
435 	 */
436 	SPLIT_PANE = 51,
437 	/**
438 	 * An object used to get an integer or floating point number from the user
439 	 */
440 	SPIN_BUTTON = 52,
441 	/**
442 	 * An object which reports messages of minor importance to the user
443 	 */
444 	STATUSBAR = 53,
445 	/**
446 	 * An object used to represent information in terms of rows and columns
447 	 */
448 	TABLE = 54,
449 	/**
450 	 * A cell in a table
451 	 */
452 	TABLE_CELL = 55,
453 	/**
454 	 * The header for a column of a table
455 	 */
456 	TABLE_COLUMN_HEADER = 56,
457 	/**
458 	 * The header for a row of a table
459 	 */
460 	TABLE_ROW_HEADER = 57,
461 	/**
462 	 * A menu item used to tear off and reattach its menu
463 	 */
464 	TEAR_OFF_MENU_ITEM = 58,
465 	/**
466 	 * An object that represents an accessible terminal.  @Since: ATK-0.6
467 	 */
468 	TERMINAL = 59,
469 	/**
470 	 * An interactive widget that supports multiple lines of text and
471 	 * optionally accepts user input, but whose purpose is not to solicit user input.
472 	 * Thus ATK_ROLE_TEXT is appropriate for the text view in a plain text editor
473 	 * but inappropriate for an input field in a dialog box or web form. For widgets
474 	 * whose purpose is to solicit input from the user, see ATK_ROLE_ENTRY and
475 	 * ATK_ROLE_PASSWORD_TEXT. For generic objects which display a brief amount of
476 	 * textual information, see ATK_ROLE_STATIC.
477 	 */
478 	TEXT = 60,
479 	/**
480 	 * A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state
481 	 */
482 	TOGGLE_BUTTON = 61,
483 	/**
484 	 * A bar or palette usually composed of push buttons or toggle buttons
485 	 */
486 	TOOL_BAR = 62,
487 	/**
488 	 * An object that provides information about another object
489 	 */
490 	TOOL_TIP = 63,
491 	/**
492 	 * An object used to represent hierarchical information to the user
493 	 */
494 	TREE = 64,
495 	/**
496 	 * An object capable of expanding and collapsing rows as well as showing multiple columns of data.   @Since: ATK-0.7
497 	 */
498 	TREE_TABLE = 65,
499 	/**
500 	 * The object contains some Accessible information, but its role is not known
501 	 */
502 	UNKNOWN = 66,
503 	/**
504 	 * An object usually used in a scroll pane
505 	 */
506 	VIEWPORT = 67,
507 	/**
508 	 * A top level window with no title or border.
509 	 */
510 	WINDOW = 68,
511 	/**
512 	 * An object that serves as a document header. @Since: ATK-1.1.1
513 	 */
514 	HEADER = 69,
515 	/**
516 	 * An object that serves as a document footer.  @Since: ATK-1.1.1
517 	 */
518 	FOOTER = 70,
519 	/**
520 	 * An object which is contains a paragraph of text content.   @Since: ATK-1.1.1
521 	 */
522 	PARAGRAPH = 71,
523 	/**
524 	 * An object which describes margins and tab stops, etc. for text objects which it controls (should have CONTROLLER_FOR relation to such).   @Since: ATK-1.1.1
525 	 */
526 	RULER = 72,
527 	/**
528 	 * The object is an application object, which may contain @ATK_ROLE_FRAME objects or other types of accessibles.  The root accessible of any application's ATK hierarchy should have ATK_ROLE_APPLICATION.   @Since: ATK-1.1.4
529 	 */
530 	APPLICATION = 73,
531 	/**
532 	 * The object is a dialog or list containing items for insertion into an entry widget, for instance a list of words for completion of a text entry.   @Since: ATK-1.3
533 	 */
534 	AUTOCOMPLETE = 74,
535 	/**
536 	 * The object is an editable text object in a toolbar.  @Since: ATK-1.5
537 	 */
538 	EDIT_BAR = 75,
539 	/**
540 	 * The object is an embedded container within a document or panel.  This role is a grouping "hint" indicating that the contained objects share a context.  @Since: ATK-1.7.2
541 	 */
542 	EMBEDDED = 76,
543 	/**
544 	 * The object is a component whose textual content may be entered or modified by the user, provided @ATK_STATE_EDITABLE is present.   @Since: ATK-1.11
545 	 */
546 	ENTRY = 77,
547 	/**
548 	 * The object is a graphical depiction of quantitative data. It may contain multiple subelements whose attributes and/or description may be queried to obtain both the quantitative data and information about how the data is being presented. The LABELLED_BY relation is particularly important in interpreting objects of this type, as is the accessible-description property.  @Since: ATK-1.11
549 	 */
550 	CHART = 78,
551 	/**
552 	 * The object contains descriptive information, usually textual, about another user interface element such as a table, chart, or image.  @Since: ATK-1.11
553 	 */
554 	CAPTION = 79,
555 	/**
556 	 * The object is a visual frame or container which contains a view of document content. Document frames may occur within another Document instance, in which case the second document may be said to be embedded in the containing instance. HTML frames are often ROLE_DOCUMENT_FRAME. Either this object, or a singleton descendant, should implement the Document interface.  @Since: ATK-1.11
557 	 */
558 	DOCUMENT_FRAME = 80,
559 	/**
560 	 * The object serves as a heading for content which follows it in a document. The 'heading level' of the heading, if availabe, may be obtained by querying the object's attributes.
561 	 */
562 	HEADING = 81,
563 	/**
564 	 * The object is a containing instance which encapsulates a page of information. @ATK_ROLE_PAGE is used in documents and content which support a paginated navigation model.  @Since: ATK-1.11
565 	 */
566 	PAGE = 82,
567 	/**
568 	 * The object is a containing instance of document content which constitutes a particular 'logical' section of the document. The type of content within a section, and the nature of the section division itself, may be obtained by querying the object's attributes. Sections may be nested. @Since: ATK-1.11
569 	 */
570 	SECTION = 83,
571 	/**
572 	 * The object is redundant with another object in the hierarchy, and is exposed for purely technical reasons.  Objects of this role should normally be ignored by clients. @Since: ATK-1.11
573 	 */
574 	REDUNDANT_OBJECT = 84,
575 	/**
576 	 * The object is a container for form controls, for instance as part of a
577 	 * web form or user-input form within a document.  This role is primarily a tag/convenience for
578 	 * clients when navigating complex documents, it is not expected that ordinary GUI containers will
579 	 * always have ATK_ROLE_FORM. @Since: ATK-1.12.0
580 	 */
581 	FORM = 85,
582 	/**
583 	 * The object is a hypertext anchor, i.e. a "link" in a
584 	 * hypertext document.  Such objects are distinct from 'inline'
585 	 * content which may also use the Hypertext/Hyperlink interfaces
586 	 * to indicate the range/location within a text object where
587 	 * an inline or embedded object lies.  @Since: ATK-1.12.1
588 	 */
589 	LINK = 86,
590 	/**
591 	 * The object is a window or similar viewport
592 	 * which is used to allow composition or input of a 'complex character',
593 	 * in other words it is an "input method window." @Since: ATK-1.12.1
594 	 */
595 	INPUT_METHOD_WINDOW = 87,
596 	/**
597 	 * A row in a table.  @Since: ATK-2.1.0
598 	 */
599 	TABLE_ROW = 88,
600 	/**
601 	 * An object that represents an element of a tree.  @Since: ATK-2.1.0
602 	 */
603 	TREE_ITEM = 89,
604 	/**
605 	 * A document frame which contains a spreadsheet.  @Since: ATK-2.1.0
606 	 */
607 	DOCUMENT_SPREADSHEET = 90,
608 	/**
609 	 * A document frame which contains a presentation or slide content.  @Since: ATK-2.1.0
610 	 */
611 	DOCUMENT_PRESENTATION = 91,
612 	/**
613 	 * A document frame which contains textual content, such as found in a word processing application.  @Since: ATK-2.1.0
614 	 */
615 	DOCUMENT_TEXT = 92,
616 	/**
617 	 * A document frame which contains HTML or other markup suitable for display in a web browser.  @Since: ATK-2.1.0
618 	 */
619 	DOCUMENT_WEB = 93,
620 	/**
621 	 * A document frame which contains email content to be displayed or composed either in plain text or HTML.  @Since: ATK-2.1.0
622 	 */
623 	DOCUMENT_EMAIL = 94,
624 	/**
625 	 * An object found within a document and designed to present a comment, note, or other annotation. In some cases, this object might not be visible until activated.  @Since: ATK-2.1.0
626 	 */
627 	COMMENT = 95,
628 	/**
629 	 * A non-collapsible list of choices the user can select from. @Since: ATK-2.1.0
630 	 */
631 	LIST_BOX = 96,
632 	/**
633 	 * A group of related widgets. This group typically has a label. @Since: ATK-2.1.0
634 	 */
635 	GROUPING = 97,
636 	/**
637 	 * An image map object. Usually a graphic with multiple hotspots, where each hotspot can be activated resulting in the loading of another document or section of a document. @Since: ATK-2.1.0
638 	 */
639 	IMAGE_MAP = 98,
640 	/**
641 	 * A transitory object designed to present a message to the user, typically at the desktop level rather than inside a particular application.  @Since: ATK-2.1.0
642 	 */
643 	NOTIFICATION = 99,
644 	/**
645 	 * An object designed to present a message to the user within an existing window. @Since: ATK-2.1.0
646 	 */
647 	INFO_BAR = 100,
648 	/**
649 	 * A bar that serves as a level indicator to, for instance, show the strength of a password or the state of a battery.  @Since: ATK-2.7.3
650 	 */
651 	LEVEL_BAR = 101,
652 	/**
653 	 * A bar that serves as the title of a window or a
654 	 * dialog. @Since: ATK-2.12
655 	 */
656 	TITLE_BAR = 102,
657 	/**
658 	 * An object which contains a text section
659 	 * that is quoted from another source. @Since: ATK-2.12
660 	 */
661 	BLOCK_QUOTE = 103,
662 	/**
663 	 * An object which represents an audio element. @Since: ATK-2.12
664 	 */
665 	AUDIO = 104,
666 	/**
667 	 * An object which represents a video element. @Since: ATK-2.12
668 	 */
669 	VIDEO = 105,
670 	/**
671 	 * A definition of a term or concept. @Since: ATK-2.12
672 	 */
673 	DEFINITION = 106,
674 	/**
675 	 * A section of a page that consists of a
676 	 * composition that forms an independent part of a document, page, or
677 	 * site. Examples: A blog entry, a news story, a forum post. @Since:
678 	 * ATK-2.12
679 	 */
680 	ARTICLE = 107,
681 	/**
682 	 * A region of a web page intended as a
683 	 * navigational landmark. This is designed to allow Assistive
684 	 * Technologies to provide quick navigation among key regions within a
685 	 * document. @Since: ATK-2.12
686 	 */
687 	LANDMARK = 108,
688 	/**
689 	 * A text widget or container holding log content, such
690 	 * as chat history and error logs. In this role there is a
691 	 * relationship between the arrival of new items in the log and the
692 	 * reading order. The log contains a meaningful sequence and new
693 	 * information is added only to the end of the log, not at arbitrary
694 	 * points. @Since: ATK-2.12
695 	 */
696 	LOG = 109,
697 	/**
698 	 * A container where non-essential information
699 	 * changes frequently. Common usages of marquee include stock tickers
700 	 * and ad banners. The primary difference between a marquee and a log
701 	 * is that logs usually have a meaningful order or sequence of
702 	 * important content changes. @Since: ATK-2.12
703 	 */
704 	MARQUEE = 110,
705 	/**
706 	 * A text widget or container that holds a mathematical
707 	 * expression. @Since: ATK-2.12
708 	 */
709 	MATH = 111,
710 	/**
711 	 * A widget whose purpose is to display a rating,
712 	 * such as the number of stars associated with a song in a media
713 	 * player. Objects of this role should also implement
714 	 * AtkValue. @Since: ATK-2.12
715 	 */
716 	RATING = 112,
717 	/**
718 	 * An object containing a numerical counter which
719 	 * indicates an amount of elapsed time from a start point, or the time
720 	 * remaining until an end point. @Since: ATK-2.12
721 	 */
722 	TIMER = 113,
723 	/**
724 	 * An object that represents a list of
725 	 * term-value groups. A term-value group represents a individual
726 	 * description and consist of one or more names
727 	 * (ATK_ROLE_DESCRIPTION_TERM) followed by one or more values
728 	 * (ATK_ROLE_DESCRIPTION_VALUE). For each list, there should not be
729 	 * more than one group with the same term name. @Since: ATK-2.12
730 	 */
731 	DESCRIPTION_LIST = 114,
732 	/**
733 	 * An object that represents the term, or
734 	 * name, part of a term-description group in a description
735 	 * list. @Since: ATK-2.12
736 	 */
737 	DESCRIPTION_TERM = 115,
738 	/**
739 	 * An object that represents the
740 	 * description, definition or value of a term-description group in a
741 	 * description list. The values within a group are alternatives,
742 	 * meaning that you can have several ATK_ROLE_DESCRIPTION_VALUE for a
743 	 * given ATK_ROLE_DESCRIPTION_TERM. @Since: ATK-2.12
744 	 */
745 	DESCRIPTION_VALUE = 116,
746 	/**
747 	 * A generic non-container object whose purpose is to display a
748 	 * brief amount of information to the user and whose role is known by the
749 	 * implementor but lacks semantic value for the user. Examples in which
750 	 * ATK_ROLE_STATIC is appropriate include the message displayed in a message box
751 	 * and an image used as an alternative means to display text. ATK_ROLE_STATIC
752 	 * should not be applied to widgets which are traditionally interactive, objects
753 	 * which display a significant amount of content, or any object which has an
754 	 * accessible relation pointing to another object. Implementors should expose the
755 	 * displayed information through the accessible name of the object. If doing so seems
756 	 * inappropriate, it may indicate that a different role should be used. For
757 	 * labels which describe another widget, see ATK_ROLE_LABEL. For text views, see
758 	 * ATK_ROLE_TEXT. For generic containers, see ATK_ROLE_PANEL. For objects whose
759 	 * role is not known by the implementor, see ATK_ROLE_UNKNOWN. @Since: ATK-2.16.
760 	 */
761 	STATIC = 117,
762 	/**
763 	 * An object that represents a mathematical fraction.
764 	 */
765 	MATH_FRACTION = 118,
766 	/**
767 	 * An object that represents a mathematical expression
768 	 * displayed with a radical. @Since: ATK-2.16.
769 	 */
770 	MATH_ROOT = 119,
771 	/**
772 	 * An object that contains text that is displayed as a
773 	 * subscript. @Since: ATK-2.16.
774 	 */
775 	SUBSCRIPT = 120,
776 	/**
777 	 * An object that contains text that is displayed as a
778 	 * superscript. @Since: ATK-2.16.
779 	 */
780 	SUPERSCRIPT = 121,
781 	/**
782 	 * not a valid role, used for finding end of the enumeration
783 	 */
784 	LAST_DEFINED = 122,
785 }
786 alias AtkRole Role;
787 
788 /**
789  * The possible types of states of an object
790  */
791 public enum AtkStateType
792 {
793 	/**
794 	 * Indicates an invalid state - probably an error condition.
795 	 */
796 	INVALID = 0,
797 	/**
798 	 * Indicates a window is currently the active window, or an object is the active subelement within a container or table. ATK_STATE_ACTIVE should not be used for objects which have ATK_STATE_FOCUSABLE or ATK_STATE_SELECTABLE: Those objects should use ATK_STATE_FOCUSED and ATK_STATE_SELECTED respectively. ATK_STATE_ACTIVE is a means to indicate that an object which is not focusable and not selectable is the currently-active item within its parent container.
799 	 */
800 	ACTIVE = 1,
801 	/**
802 	 * Indicates that the object is 'armed', i.e. will be activated by if a pointer button-release event occurs within its bounds.  Buttons often enter this state when a pointer click occurs within their bounds, as a precursor to activation. ATK_STATE_ARMED has been deprecated since ATK-2.16 and should not be used in newly-written code.
803 	 */
804 	ARMED = 2,
805 	/**
806 	 * Indicates the current object is busy, i.e. onscreen representation is in the process of changing, or the object is temporarily unavailable for interaction due to activity already in progress.  This state may be used by implementors of Document to indicate that content loading is underway.  It also may indicate other 'pending' conditions; clients may wish to interrogate this object when the ATK_STATE_BUSY flag is removed.
807 	 */
808 	BUSY = 3,
809 	/**
810 	 * Indicates this object is currently checked, for instance a checkbox is 'non-empty'.
811 	 */
812 	CHECKED = 4,
813 	/**
814 	 * Indicates that this object no longer has a valid backing widget (for instance, if its peer object has been destroyed)
815 	 */
816 	DEFUNCT = 5,
817 	/**
818 	 * Indicates that this object can contain text, and that the
819 	 * user can change the textual contents of this object by editing those contents
820 	 * directly. For an object which is expected to be editable due to its type, but
821 	 * which cannot be edited due to the application or platform preventing the user
822 	 * from doing so, that object's #AtkStateSet should lack ATK_STATE_EDITABLE and
823 	 * should contain ATK_STATE_READ_ONLY.
824 	 */
825 	EDITABLE = 6,
826 	/**
827 	 * Indicates that this object is enabled, i.e. that it currently reflects some application state. Objects that are "greyed out" may lack this state, and may lack the STATE_SENSITIVE if direct user interaction cannot cause them to acquire STATE_ENABLED. See also: ATK_STATE_SENSITIVE
828 	 */
829 	ENABLED = 7,
830 	/**
831 	 * Indicates this object allows progressive disclosure of its children
832 	 */
833 	EXPANDABLE = 8,
834 	/**
835 	 * Indicates this object its expanded - see ATK_STATE_EXPANDABLE above
836 	 */
837 	EXPANDED = 9,
838 	/**
839 	 * Indicates this object can accept keyboard focus, which means all events resulting from typing on the keyboard will normally be passed to it when it has focus
840 	 */
841 	FOCUSABLE = 10,
842 	/**
843 	 * Indicates this object currently has the keyboard focus
844 	 */
845 	FOCUSED = 11,
846 	/**
847 	 * Indicates the orientation of this object is horizontal; used, for instance, by objects of ATK_ROLE_SCROLL_BAR.  For objects where vertical/horizontal orientation is especially meaningful.
848 	 */
849 	HORIZONTAL = 12,
850 	/**
851 	 * Indicates this object is minimized and is represented only by an icon
852 	 */
853 	ICONIFIED = 13,
854 	/**
855 	 * Indicates something must be done with this object before the user can interact with an object in a different window
856 	 */
857 	MODAL = 14,
858 	/**
859 	 * Indicates this (text) object can contain multiple lines of text
860 	 */
861 	MULTI_LINE = 15,
862 	/**
863 	 * Indicates this object allows more than one of its children to be selected at the same time, or in the case of text objects, that the object supports non-contiguous text selections.
864 	 */
865 	MULTISELECTABLE = 16,
866 	/**
867 	 * Indicates this object paints every pixel within its rectangular region.
868 	 */
869 	OPAQUE = 17,
870 	/**
871 	 * Indicates this object is currently pressed.
872 	 */
873 	PRESSED = 18,
874 	/**
875 	 * Indicates the size of this object is not fixed
876 	 */
877 	RESIZABLE = 19,
878 	/**
879 	 * Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that can be selected
880 	 */
881 	SELECTABLE = 20,
882 	/**
883 	 * Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that has been selected
884 	 */
885 	SELECTED = 21,
886 	/**
887 	 * Indicates this object is sensitive, e.g. to user interaction.
888 	 * STATE_SENSITIVE usually accompanies STATE_ENABLED for user-actionable controls,
889 	 * but may be found in the absence of STATE_ENABLED if the current visible state of the
890 	 * control is "disconnected" from the application state.  In such cases, direct user interaction
891 	 * can often result in the object gaining STATE_SENSITIVE, for instance if a user makes
892 	 * an explicit selection using an object whose current state is ambiguous or undefined.
893 	 * @see STATE_ENABLED, STATE_INDETERMINATE.
894 	 */
895 	SENSITIVE = 22,
896 	/**
897 	 * Indicates this object, the object's parent, the object's parent's parent, and so on,
898 	 * are all 'shown' to the end-user, i.e. subject to "exposure" if blocking or obscuring objects do not interpose
899 	 * between this object and the top of the window stack.
900 	 */
901 	SHOWING = 23,
902 	/**
903 	 * Indicates this (text) object can contain only a single line of text
904 	 */
905 	SINGLE_LINE = 24,
906 	/**
907 	 * Indicates that the information returned for this object may no longer be
908 	 * synchronized with the application state.  This is implied if the object has STATE_TRANSIENT,
909 	 * and can also occur towards the end of the object peer's lifecycle. It can also be used to indicate that
910 	 * the index associated with this object has changed since the user accessed the object (in lieu of
911 	 * "index-in-parent-changed" events).
912 	 */
913 	STALE = 25,
914 	/**
915 	 * Indicates this object is transient, i.e. a snapshot which may not emit events when its
916 	 * state changes.  Data from objects with ATK_STATE_TRANSIENT should not be cached, since there may be no
917 	 * notification given when the cached data becomes obsolete.
918 	 */
919 	TRANSIENT = 26,
920 	/**
921 	 * Indicates the orientation of this object is vertical
922 	 */
923 	VERTICAL = 27,
924 	/**
925 	 * Indicates this object is visible, e.g. has been explicitly marked for exposure to the user.
926 	 */
927 	VISIBLE = 28,
928 	/**
929 	 * Indicates that "active-descendant-changed" event
930 	 * is sent when children become 'active' (i.e. are selected or navigated to onscreen).
931 	 * Used to prevent need to enumerate all children in very large containers, like tables.
932 	 * The presence of STATE_MANAGES_DESCENDANTS is an indication to the client.
933 	 * that the children should not, and need not, be enumerated by the client.
934 	 * Objects implementing this state are expected to provide relevant state
935 	 * notifications to listening clients, for instance notifications of visibility
936 	 * changes and activation of their contained child objects, without the client
937 	 * having previously requested references to those children.
938 	 */
939 	MANAGES_DESCENDANTS = 29,
940 	/**
941 	 * Indicates that the value, or some other quantifiable
942 	 * property, of this AtkObject cannot be fully determined. In the case of a large
943 	 * data set in which the total number of items in that set is unknown (e.g. 1 of
944 	 * 999+), implementors should expose the currently-known set size (999) along
945 	 * with this state. In the case of a check box, this state should be used to
946 	 * indicate that the check box is a tri-state check box which is currently
947 	 * neither checked nor unchecked.
948 	 */
949 	INDETERMINATE = 30,
950 	/**
951 	 * Indicates that an object is truncated, e.g. a text value in a speradsheet cell.
952 	 */
953 	TRUNCATED = 31,
954 	/**
955 	 * Indicates that explicit user interaction with an object is required by the user interface, e.g. a required field in a "web-form" interface.
956 	 */
957 	REQUIRED = 32,
958 	/**
959 	 * Indicates that the object has encountered an error condition due to failure of input validation. For instance, a form control may acquire this state in response to invalid or malformed user input.
960 	 */
961 	INVALID_ENTRY = 33,
962 	/**
963 	 * Indicates that the object in question implements some form of ¨typeahead¨ or
964 	 * pre-selection behavior whereby entering the first character of one or more sub-elements
965 	 * causes those elements to scroll into view or become selected.  Subsequent character input
966 	 * may narrow the selection further as long as one or more sub-elements match the string.
967 	 * This state is normally only useful and encountered on objects that implement Selection.
968 	 * In some cases the typeahead behavior may result in full or partial ¨completion¨ of
969 	 * the data in the input field, in which case these input events may trigger text-changed
970 	 * events from the AtkText interface.  This state supplants @ATK_ROLE_AUTOCOMPLETE.
971 	 */
972 	SUPPORTS_AUTOCOMPLETION = 34,
973 	/**
974 	 * Indicates that the object in question supports text selection. It should only be exposed on objects which implement the Text interface, in order to distinguish this state from @ATK_STATE_SELECTABLE, which infers that the object in question is a selectable child of an object which implements Selection. While similar, text selection and subelement selection are distinct operations.
975 	 */
976 	SELECTABLE_TEXT = 35,
977 	/**
978 	 * Indicates that the object is the "default" active component, i.e. the object which is activated by an end-user press of the "Enter" or "Return" key.  Typically a "close" or "submit" button.
979 	 */
980 	DEFAULT = 36,
981 	/**
982 	 * Indicates that the object changes its appearance dynamically as an inherent part of its presentation.  This state may come and go if an object is only temporarily animated on the way to a 'final' onscreen presentation.
983 	 * @note some applications, notably content viewers, may not be able to detect
984 	 * all kinds of animated content.  Therefore the absence of this state should not
985 	 * be taken as definitive evidence that the object's visual representation is
986 	 * static; this state is advisory.
987 	 */
988 	ANIMATED = 37,
989 	/**
990 	 * Indicates that the object (typically a hyperlink) has already been 'activated', and/or its backing data has already been downloaded, rendered, or otherwise "visited".
991 	 */
992 	VISITED = 38,
993 	/**
994 	 * Indicates this object has the potential to be
995 	 * checked, such as a checkbox or toggle-able table cell. @Since:
996 	 * ATK-2.12
997 	 */
998 	CHECKABLE = 39,
999 	/**
1000 	 * Indicates that the object has a popup context
1001 	 * menu or sub-level menu which may or may not be showing. This means
1002 	 * that activation renders conditional content.  Note that ordinary
1003 	 * tooltips are not considered popups in this context. @Since: ATK-2.12
1004 	 */
1005 	HAS_POPUP = 40,
1006 	/**
1007 	 * Indicates this object has a tooltip. @Since: ATK-2.16
1008 	 */
1009 	HAS_TOOLTIP = 41,
1010 	/**
1011 	 * Indicates that a widget which is ENABLED and SENSITIVE
1012 	 * has a value which can be read, but not modified, by the user. Note that this
1013 	 * state should only be applied to widget types whose value is normally directly
1014 	 * user modifiable, such as check boxes, radio buttons, spin buttons, text input
1015 	 * fields, and combo boxes, as a means to convey that the expected interaction
1016 	 * with that widget is not possible. When the expected interaction with a
1017 	 * widget does not include modification by the user, as is the case with
1018 	 * labels and containers, ATK_STATE_READ_ONLY should not be applied. See also
1019 	 * ATK_STATE_EDITABLE. @Since: ATK-2-16
1020 	 */
1021 	READ_ONLY = 42,
1022 	/**
1023 	 * Not a valid state, used for finding end of enumeration
1024 	 */
1025 	LAST_DEFINED = 43,
1026 }
1027 alias AtkStateType StateType;
1028 
1029 /**
1030  * Describes the text attributes supported
1031  */
1032 public enum AtkTextAttribute
1033 {
1034 	/**
1035 	 * Invalid attribute, like bad spelling or grammar.
1036 	 */
1037 	INVALID = 0,
1038 	/**
1039 	 * The pixel width of the left margin
1040 	 */
1041 	LEFT_MARGIN = 1,
1042 	/**
1043 	 * The pixel width of the right margin
1044 	 */
1045 	RIGHT_MARGIN = 2,
1046 	/**
1047 	 * The number of pixels that the text is indented
1048 	 */
1049 	INDENT = 3,
1050 	/**
1051 	 * Either "true" or "false" indicating whether text is visible or not
1052 	 */
1053 	INVISIBLE = 4,
1054 	/**
1055 	 * Either "true" or "false" indicating whether text is editable or not
1056 	 */
1057 	EDITABLE = 5,
1058 	/**
1059 	 * Pixels of blank space to leave above each newline-terminated line.
1060 	 */
1061 	PIXELS_ABOVE_LINES = 6,
1062 	/**
1063 	 * Pixels of blank space to leave below each newline-terminated line.
1064 	 */
1065 	PIXELS_BELOW_LINES = 7,
1066 	/**
1067 	 * Pixels of blank space to leave between wrapped lines inside the same newline-terminated line (paragraph).
1068 	 */
1069 	PIXELS_INSIDE_WRAP = 8,
1070 	/**
1071 	 * "true" or "false" whether to make the background color for each character the height of the highest font used on the current line, or the height of the font used for the current character.
1072 	 */
1073 	BG_FULL_HEIGHT = 9,
1074 	/**
1075 	 * Number of pixels that the characters are risen above the baseline
1076 	 */
1077 	RISE = 10,
1078 	/**
1079 	 * "none", "single", "double", "low", or "error"
1080 	 */
1081 	UNDERLINE = 11,
1082 	/**
1083 	 * "true" or "false" whether the text is strikethrough
1084 	 */
1085 	STRIKETHROUGH = 12,
1086 	/**
1087 	 * The size of the characters in points. eg: 10
1088 	 */
1089 	SIZE = 13,
1090 	/**
1091 	 * The scale of the characters. The value is a string representation of a double
1092 	 */
1093 	SCALE = 14,
1094 	/**
1095 	 * The weight of the characters.
1096 	 */
1097 	WEIGHT = 15,
1098 	/**
1099 	 * The language used
1100 	 */
1101 	LANGUAGE = 16,
1102 	/**
1103 	 * The font family name
1104 	 */
1105 	FAMILY_NAME = 17,
1106 	/**
1107 	 * The background color. The value is an RGB value of the format "%u,%u,%u"
1108 	 */
1109 	BG_COLOR = 18,
1110 	/**
1111 	 * The foreground color. The value is an RGB value of the format "%u,%u,%u"
1112 	 */
1113 	FG_COLOR = 19,
1114 	/**
1115 	 * "true" if a #GdkBitmap is set for stippling the background color.
1116 	 */
1117 	BG_STIPPLE = 20,
1118 	/**
1119 	 * "true" if a #GdkBitmap is set for stippling the foreground color.
1120 	 */
1121 	FG_STIPPLE = 21,
1122 	/**
1123 	 * The wrap mode of the text, if any. Values are "none", "char", "word", or "word_char".
1124 	 */
1125 	WRAP_MODE = 22,
1126 	/**
1127 	 * The direction of the text, if set. Values are "none", "ltr" or "rtl"
1128 	 */
1129 	DIRECTION = 23,
1130 	/**
1131 	 * The justification of the text, if set. Values are "left", "right", "center" or "fill"
1132 	 */
1133 	JUSTIFICATION = 24,
1134 	/**
1135 	 * The stretch of the text, if set. Values are "ultra_condensed", "extra_condensed", "condensed", "semi_condensed", "normal", "semi_expanded", "expanded", "extra_expanded" or "ultra_expanded"
1136 	 */
1137 	STRETCH = 25,
1138 	/**
1139 	 * The capitalization variant of the text, if set. Values are "normal" or "small_caps"
1140 	 */
1141 	VARIANT = 26,
1142 	/**
1143 	 * The slant style of the text, if set. Values are "normal", "oblique" or "italic"
1144 	 */
1145 	STYLE = 27,
1146 	/**
1147 	 * not a valid text attribute, used for finding end of enumeration
1148 	 */
1149 	LAST_DEFINED = 28,
1150 }
1151 alias AtkTextAttribute TextAttribute;
1152 
1153 /**
1154  * Text boundary types used for specifying boundaries for regions of text.
1155  * This enumerationis deprecated since 2.9.4 and should not be used. Use
1156  * AtkTextGranularity with #atk_text_get_string_at_offset instead.
1157  */
1158 public enum AtkTextBoundary
1159 {
1160 	/**
1161 	 * Boundary is the boundary between characters
1162 	 * (including non-printing characters)
1163 	 */
1164 	CHAR = 0,
1165 	/**
1166 	 * Boundary is the start (i.e. first character) of a word.
1167 	 */
1168 	WORD_START = 1,
1169 	/**
1170 	 * Boundary is the end (i.e. last
1171 	 * character) of a word.
1172 	 */
1173 	WORD_END = 2,
1174 	/**
1175 	 * Boundary is the first character in a sentence.
1176 	 */
1177 	SENTENCE_START = 3,
1178 	/**
1179 	 * Boundary is the last (terminal)
1180 	 * character in a sentence; in languages which use "sentence stop"
1181 	 * punctuation such as English, the boundary is thus the '.', '?', or
1182 	 * similar terminal punctuation character.
1183 	 */
1184 	SENTENCE_END = 4,
1185 	/**
1186 	 * Boundary is the initial character of the content or a
1187 	 * character immediately following a newline, linefeed, or return character.
1188 	 */
1189 	LINE_START = 5,
1190 	/**
1191 	 * Boundary is the linefeed, or return
1192 	 * character.
1193 	 */
1194 	LINE_END = 6,
1195 }
1196 alias AtkTextBoundary TextBoundary;
1197 
1198 /**
1199  * Describes the type of clipping required.
1200  */
1201 public enum AtkTextClipType
1202 {
1203 	/**
1204 	 * No clipping to be done
1205 	 */
1206 	NONE = 0,
1207 	/**
1208 	 * Text clipped by min coordinate is omitted
1209 	 */
1210 	MIN = 1,
1211 	/**
1212 	 * Text clipped by max coordinate is omitted
1213 	 */
1214 	MAX = 2,
1215 	/**
1216 	 * Only text fully within mix/max bound is retained
1217 	 */
1218 	BOTH = 3,
1219 }
1220 alias AtkTextClipType TextClipType;
1221 
1222 /**
1223  * Text granularity types used for specifying the granularity of the region of
1224  * text we are interested in.
1225  */
1226 public enum AtkTextGranularity
1227 {
1228 	/**
1229 	 * Granularity is defined by the boundaries between characters
1230 	 * (including non-printing characters)
1231 	 */
1232 	CHAR = 0,
1233 	/**
1234 	 * Granularity is defined by the boundaries of a word,
1235 	 * starting at the beginning of the current word and finishing at the beginning of
1236 	 * the following one, if present.
1237 	 */
1238 	WORD = 1,
1239 	/**
1240 	 * Granularity is defined by the boundaries of a sentence,
1241 	 * starting at the beginning of the current sentence and finishing at the beginning of
1242 	 * the following one, if present.
1243 	 */
1244 	SENTENCE = 2,
1245 	/**
1246 	 * Granularity is defined by the boundaries of a line,
1247 	 * starting at the beginning of the current line and finishing at the beginning of
1248 	 * the following one, if present.
1249 	 */
1250 	LINE = 3,
1251 	/**
1252 	 * Granularity is defined by the boundaries of a paragraph,
1253 	 * starting at the beginning of the current paragraph and finishing at the beginning of
1254 	 * the following one, if present.
1255 	 */
1256 	PARAGRAPH = 4,
1257 }
1258 alias AtkTextGranularity TextGranularity;
1259 
1260 /**
1261  * Default types for a given value. Those are defined in order to
1262  * easily get localized strings to describe a given value or a given
1263  * subrange, using atk_value_type_get_localized_name().
1264  */
1265 public enum AtkValueType
1266 {
1267 	VERY_WEAK = 0,
1268 	WEAK = 1,
1269 	ACCEPTABLE = 2,
1270 	STRONG = 3,
1271 	VERY_STRONG = 4,
1272 	VERY_LOW = 5,
1273 	LOW = 6,
1274 	MEDIUM = 7,
1275 	HIGH = 8,
1276 	VERY_HIGH = 9,
1277 	VERY_BAD = 10,
1278 	BAD = 11,
1279 	GOOD = 12,
1280 	VERY_GOOD = 13,
1281 	BEST = 14,
1282 	LAST_DEFINED = 15,
1283 }
1284 alias AtkValueType ValueType;
1285 
1286 struct AtkAction;
1287 
1288 struct AtkActionIface
1289 {
1290 	GTypeInterface parent;
1291 	/**
1292 	 *
1293 	 * Params:
1294 	 *     action = a #GObject instance that implements AtkActionIface
1295 	 *     i = the action index corresponding to the action to be performed
1296 	 * Return: %TRUE if success, %FALSE otherwise
1297 	 */
1298 	extern(C) int function(AtkAction* action, int i) doAction;
1299 	/**
1300 	 *
1301 	 * Params:
1302 	 *     action = a #GObject instance that implements AtkActionIface
1303 	 * Return: a the number of actions, or 0 if @action does not
1304 	 *     implement this interface.
1305 	 */
1306 	extern(C) int function(AtkAction* action) getNActions;
1307 	/**
1308 	 *
1309 	 * Params:
1310 	 *     action = a #GObject instance that implements AtkActionIface
1311 	 *     i = the action index corresponding to the action to be performed
1312 	 * Return: a description string, or %NULL if @action does
1313 	 *     not implement this interface.
1314 	 */
1315 	extern(C) const(char)* function(AtkAction* action, int i) getDescription;
1316 	/**
1317 	 *
1318 	 * Params:
1319 	 *     action = a #GObject instance that implements AtkActionIface
1320 	 *     i = the action index corresponding to the action to be performed
1321 	 * Return: a name string, or %NULL if @action does not
1322 	 *     implement this interface.
1323 	 */
1324 	extern(C) const(char)* function(AtkAction* action, int i) getName;
1325 	/**
1326 	 *
1327 	 * Params:
1328 	 *     action = a #GObject instance that implements AtkActionIface
1329 	 *     i = the action index corresponding to the action to be performed
1330 	 * Return: the keybinding which can be used to activate
1331 	 *     this action, or %NULL if there is no keybinding for this action.
1332 	 */
1333 	extern(C) const(char)* function(AtkAction* action, int i) getKeybinding;
1334 	/**
1335 	 *
1336 	 * Params:
1337 	 *     action = a #GObject instance that implements AtkActionIface
1338 	 *     i = the action index corresponding to the action to be performed
1339 	 *     desc = the description to be assigned to this action
1340 	 * Return: a gboolean representing if the description was successfully set;
1341 	 */
1342 	extern(C) int function(AtkAction* action, int i, const(char)* desc) setDescription;
1343 	/**
1344 	 *
1345 	 * Params:
1346 	 *     action = a #GObject instance that implements AtkActionIface
1347 	 *     i = the action index corresponding to the action to be performed
1348 	 * Return: a name string, or %NULL if @action does not
1349 	 *     implement this interface.
1350 	 */
1351 	extern(C) const(char)* function(AtkAction* action, int i) getLocalizedName;
1352 }
1353 
1354 struct AtkComponent;
1355 
1356 struct AtkComponentIface
1357 {
1358 	GTypeInterface parent;
1359 	/**
1360 	 *
1361 	 * Params:
1362 	 *     component = The #AtkComponent to attach the @handler to
1363 	 *     handler = The #AtkFocusHandler to be attached to @component
1364 	 * Return: a handler id which can be used in atk_component_remove_focus_handler()
1365 	 *     or zero if the handler was already added.
1366 	 */
1367 	extern(C) uint function(AtkComponent* component, AtkFocusHandler handler) addFocusHandler;
1368 	/**
1369 	 *
1370 	 * Params:
1371 	 *     component = the #AtkComponent
1372 	 *     x = x coordinate
1373 	 *     y = y coordinate
1374 	 *     coordType = specifies whether the coordinates are relative to the screen
1375 	 *         or to the components top level window
1376 	 * Return: %TRUE or %FALSE indicating whether the specified point is within
1377 	 *     the extent of the @component or not
1378 	 */
1379 	extern(C) int function(AtkComponent* component, int x, int y, AtkCoordType coordType) contains;
1380 	/**
1381 	 *
1382 	 * Params:
1383 	 *     component = the #AtkComponent
1384 	 *     x = x coordinate
1385 	 *     y = y coordinate
1386 	 *     coordType = specifies whether the coordinates are relative to the screen
1387 	 *         or to the components top level window
1388 	 * Return: a reference to the accessible
1389 	 *     child, if one exists
1390 	 */
1391 	extern(C) AtkObject* function(AtkComponent* component, int x, int y, AtkCoordType coordType) refAccessibleAtPoint;
1392 	/** */
1393 	extern(C) void function(AtkComponent* component, int* x, int* y, int* width, int* height, AtkCoordType coordType) getExtents;
1394 	/** */
1395 	extern(C) void function(AtkComponent* component, int* x, int* y, AtkCoordType coordType) getPosition;
1396 	/** */
1397 	extern(C) void function(AtkComponent* component, int* width, int* height) getSize;
1398 	/**
1399 	 *
1400 	 * Params:
1401 	 *     component = an #AtkComponent
1402 	 * Return: %TRUE if successful, %FALSE otherwise.
1403 	 */
1404 	extern(C) int function(AtkComponent* component) grabFocus;
1405 	/** */
1406 	extern(C) void function(AtkComponent* component, uint handlerId) removeFocusHandler;
1407 	/**
1408 	 *
1409 	 * Params:
1410 	 *     component = an #AtkComponent
1411 	 *     x = x coordinate
1412 	 *     y = y coordinate
1413 	 *     width = width to set for @component
1414 	 *     height = height to set for @component
1415 	 *     coordType = specifies whether the coordinates are relative to the screen
1416 	 *         or to the components top level window
1417 	 * Return: %TRUE or %FALSE whether the extents were set or not
1418 	 */
1419 	extern(C) int function(AtkComponent* component, int x, int y, int width, int height, AtkCoordType coordType) setExtents;
1420 	/**
1421 	 *
1422 	 * Params:
1423 	 *     component = an #AtkComponent
1424 	 *     x = x coordinate
1425 	 *     y = y coordinate
1426 	 *     coordType = specifies whether the coordinates are relative to the screen
1427 	 *         or to the components top level window
1428 	 * Return: %TRUE or %FALSE whether or not the position was set or not
1429 	 */
1430 	extern(C) int function(AtkComponent* component, int x, int y, AtkCoordType coordType) setPosition;
1431 	/**
1432 	 *
1433 	 * Params:
1434 	 *     component = an #AtkComponent
1435 	 *     width = width to set for @component
1436 	 *     height = height to set for @component
1437 	 * Return: %TRUE or %FALSE whether the size was set or not
1438 	 */
1439 	extern(C) int function(AtkComponent* component, int width, int height) setSize;
1440 	/**
1441 	 *
1442 	 * Params:
1443 	 *     component = an #AtkComponent
1444 	 * Return: an #AtkLayer which is the layer of the component
1445 	 */
1446 	extern(C) AtkLayer function(AtkComponent* component) getLayer;
1447 	/**
1448 	 *
1449 	 * Params:
1450 	 *     component = an #AtkComponent
1451 	 * Return: a gint which is the zorder of the component, i.e. the depth at
1452 	 *     which the component is shown in relation to other components in the same
1453 	 *     container.
1454 	 */
1455 	extern(C) int function(AtkComponent* component) getMdiZorder;
1456 	/** */
1457 	extern(C) void function(AtkComponent* component, AtkRectangle* bounds) boundsChanged;
1458 	/**
1459 	 *
1460 	 * Params:
1461 	 *     component = an #AtkComponent
1462 	 * Return: An alpha value from 0 to 1.0, inclusive.
1463 	 */
1464 	extern(C) double function(AtkComponent* component) getAlpha;
1465 }
1466 
1467 struct AtkDocument;
1468 
1469 struct AtkDocumentIface
1470 {
1471 	GTypeInterface parent;
1472 	/**
1473 	 *
1474 	 * Params:
1475 	 *     document = a #GObject instance that implements AtkDocumentIface
1476 	 * Return: a string indicating the document type
1477 	 */
1478 	extern(C) const(char)* function(AtkDocument* document) getDocumentType;
1479 	/**
1480 	 *
1481 	 * Params:
1482 	 *     document = a #GObject instance that implements AtkDocumentIface
1483 	 * Return: a %gpointer that points to an instance of the DOM.
1484 	 */
1485 	extern(C) void* function(AtkDocument* document) getDocument;
1486 	/** */
1487 	extern(C) const(char)* function(AtkDocument* document) getDocumentLocale;
1488 	/** */
1489 	extern(C) AtkAttributeSet* function(AtkDocument* document) getDocumentAttributes;
1490 	/** */
1491 	extern(C) const(char)* function(AtkDocument* document, const(char)* attributeName) getDocumentAttributeValue;
1492 	/** */
1493 	extern(C) int function(AtkDocument* document, const(char)* attributeName, const(char)* attributeValue) setDocumentAttribute;
1494 	/**
1495 	 *
1496 	 * Params:
1497 	 *     document = the #AtkDocument
1498 	 * Return: current page number inside @document. -1 if not
1499 	 *     implemented, not know by the implementor or irrelevant.
1500 	 */
1501 	extern(C) int function(AtkDocument* document) getCurrentPageNumber;
1502 	/**
1503 	 *
1504 	 * Params:
1505 	 *     document = the #AtkDocument
1506 	 * Return: total page count of @document. -1 if not implemented, not
1507 	 *     know by the implementor or irrelevant.
1508 	 */
1509 	extern(C) int function(AtkDocument* document) getPageCount;
1510 }
1511 
1512 struct AtkEditableText;
1513 
1514 struct AtkEditableTextIface
1515 {
1516 	GTypeInterface parentInterface;
1517 	/**
1518 	 *
1519 	 * Params:
1520 	 *     text = an #AtkEditableText
1521 	 *     attribSet = an #AtkAttributeSet
1522 	 *     startOffset = start of range in which to set attributes
1523 	 *     endOffset = end of range in which to set attributes
1524 	 * Return: %TRUE if attributes successfully set for the specified
1525 	 *     range, otherwise %FALSE
1526 	 */
1527 	extern(C) int function(AtkEditableText* text, AtkAttributeSet* attribSet, int startOffset, int endOffset) setRunAttributes;
1528 	/** */
1529 	extern(C) void function(AtkEditableText* text, const(char)* str) setTextContents;
1530 	/** */
1531 	extern(C) void function(AtkEditableText* text, const(char)* str, int length, int* position) insertText;
1532 	/** */
1533 	extern(C) void function(AtkEditableText* text, int startPos, int endPos) copyText;
1534 	/** */
1535 	extern(C) void function(AtkEditableText* text, int startPos, int endPos) cutText;
1536 	/** */
1537 	extern(C) void function(AtkEditableText* text, int startPos, int endPos) deleteText;
1538 	/** */
1539 	extern(C) void function(AtkEditableText* text, int position) pasteText;
1540 }
1541 
1542 struct AtkGObjectAccessible
1543 {
1544 	AtkObject parent;
1545 }
1546 
1547 struct AtkGObjectAccessibleClass
1548 {
1549 	AtkObjectClass parentClass;
1550 	AtkFunction pad1;
1551 	AtkFunction pad2;
1552 }
1553 
1554 struct AtkHyperlink
1555 {
1556 	GObject parent;
1557 }
1558 
1559 struct AtkHyperlinkClass
1560 {
1561 	GObjectClass parent;
1562 	/**
1563 	 *
1564 	 * Params:
1565 	 *     link = an #AtkHyperlink
1566 	 *     i = a (zero-index) integer specifying the desired anchor
1567 	 * Return: a string specifying the URI
1568 	 */
1569 	extern(C) char* function(AtkHyperlink* link, int i) getUri;
1570 	/**
1571 	 *
1572 	 * Params:
1573 	 *     link = an #AtkHyperlink
1574 	 *     i = a (zero-index) integer specifying the desired anchor
1575 	 * Return: an #AtkObject associated with this hyperlinks
1576 	 *     i-th anchor
1577 	 */
1578 	extern(C) AtkObject* function(AtkHyperlink* link, int i) getObject;
1579 	/**
1580 	 *
1581 	 * Params:
1582 	 *     link = an #AtkHyperlink
1583 	 * Return: the index with the hypertext document at which this link ends
1584 	 */
1585 	extern(C) int function(AtkHyperlink* link) getEndIndex;
1586 	/**
1587 	 *
1588 	 * Params:
1589 	 *     link = an #AtkHyperlink
1590 	 * Return: the index with the hypertext document at which this link begins
1591 	 */
1592 	extern(C) int function(AtkHyperlink* link) getStartIndex;
1593 	/**
1594 	 *
1595 	 * Params:
1596 	 *     link = an #AtkHyperlink
1597 	 * Return: whether or not this link is still valid
1598 	 */
1599 	extern(C) int function(AtkHyperlink* link) isValid;
1600 	/**
1601 	 *
1602 	 * Params:
1603 	 *     link = an #AtkHyperlink
1604 	 * Return: the number of anchors associated with this hyperlink
1605 	 */
1606 	extern(C) int function(AtkHyperlink* link) getNAnchors;
1607 	/** */
1608 	extern(C) uint function(AtkHyperlink* link) linkState;
1609 	/**
1610 	 *
1611 	 * Params:
1612 	 *     link = an #AtkHyperlink
1613 	 * Return: True if the AtkHyperlink is selected, False otherwise
1614 	 */
1615 	extern(C) int function(AtkHyperlink* link) isSelectedLink;
1616 	/** */
1617 	extern(C) void function(AtkHyperlink* link) linkActivated;
1618 	AtkFunction pad1;
1619 }
1620 
1621 struct AtkHyperlinkImpl;
1622 
1623 struct AtkHyperlinkImplIface
1624 {
1625 	GTypeInterface parent;
1626 	/**
1627 	 *
1628 	 * Params:
1629 	 *     impl = a #GObject instance that implements AtkHyperlinkImplIface
1630 	 * Return: an AtkHyperlink object which points to this
1631 	 *     implementing AtkObject.
1632 	 */
1633 	extern(C) AtkHyperlink* function(AtkHyperlinkImpl* impl) getHyperlink;
1634 }
1635 
1636 struct AtkHypertext;
1637 
1638 struct AtkHypertextIface
1639 {
1640 	GTypeInterface parent;
1641 	/**
1642 	 *
1643 	 * Params:
1644 	 *     hypertext = an #AtkHypertext
1645 	 *     linkIndex = an integer specifying the desired link
1646 	 * Return: the link in this hypertext document at
1647 	 *     index @link_index
1648 	 */
1649 	extern(C) AtkHyperlink* function(AtkHypertext* hypertext, int linkIndex) getLink;
1650 	/**
1651 	 *
1652 	 * Params:
1653 	 *     hypertext = an #AtkHypertext
1654 	 * Return: the number of links within this hypertext document
1655 	 */
1656 	extern(C) int function(AtkHypertext* hypertext) getNLinks;
1657 	/**
1658 	 *
1659 	 * Params:
1660 	 *     hypertext = an #AtkHypertext
1661 	 *     charIndex = a character index
1662 	 * Return: an index into the array of hyperlinks in @hypertext,
1663 	 *     or -1 if there is no hyperlink associated with this character.
1664 	 */
1665 	extern(C) int function(AtkHypertext* hypertext, int charIndex) getLinkIndex;
1666 	/** */
1667 	extern(C) void function(AtkHypertext* hypertext, int linkIndex) linkSelected;
1668 }
1669 
1670 struct AtkImage;
1671 
1672 struct AtkImageIface
1673 {
1674 	GTypeInterface parent;
1675 	/** */
1676 	extern(C) void function(AtkImage* image, int* x, int* y, AtkCoordType coordType) getImagePosition;
1677 	/**
1678 	 *
1679 	 * Params:
1680 	 *     image = a #GObject instance that implements AtkImageIface
1681 	 * Return: a string representing the image description
1682 	 */
1683 	extern(C) const(char)* function(AtkImage* image) getImageDescription;
1684 	/** */
1685 	extern(C) void function(AtkImage* image, int* width, int* height) getImageSize;
1686 	/**
1687 	 *
1688 	 * Params:
1689 	 *     image = a #GObject instance that implements AtkImageIface
1690 	 *     description = a string description to set for @image
1691 	 * Return: boolean TRUE, or FALSE if operation could
1692 	 *     not be completed.
1693 	 */
1694 	extern(C) int function(AtkImage* image, const(char)* description) setImageDescription;
1695 	/**
1696 	 *
1697 	 * Params:
1698 	 *     image = An #AtkImage
1699 	 * Return: a string corresponding to the POSIX
1700 	 *     LC_MESSAGES locale used by the image description, or %NULL if the
1701 	 *     image does not specify a locale.
1702 	 */
1703 	extern(C) const(char)* function(AtkImage* image) getImageLocale;
1704 }
1705 
1706 struct AtkImplementor;
1707 
1708 /**
1709  * Encapsulates information about a key event.
1710  */
1711 struct AtkKeyEventStruct
1712 {
1713 	/**
1714 	 * An AtkKeyEventType, generally one of ATK_KEY_EVENT_PRESS or ATK_KEY_EVENT_RELEASE
1715 	 */
1716 	int type;
1717 	/**
1718 	 * A bitmask representing the state of the modifier keys immediately after the event takes place.
1719 	 * The meaning of the bits is currently defined to match the bitmask used by GDK in
1720 	 * GdkEventType.state, see
1721 	 * http://developer.gnome.org/doc/API/2.0/gdk/gdk-Event-Structures.html#GdkEventKey
1722 	 */
1723 	uint state;
1724 	/**
1725 	 * A guint representing a keysym value corresponding to those used by GDK and X11: see
1726 	 * /usr/X11/include/keysymdef.h.
1727 	 */
1728 	uint keyval;
1729 	/**
1730 	 * The length of member #string.
1731 	 */
1732 	int length;
1733 	/**
1734 	 * A string containing one of the following: either a string approximating the text that would
1735 	 * result from this keypress, if the key is a control or graphic character, or a symbolic name for this keypress.
1736 	 * Alphanumeric and printable keys will have the symbolic key name in this string member, for instance "A". "0",
1737 	 * "semicolon", "aacute".  Keypad keys have the prefix "KP".
1738 	 */
1739 	char* str;
1740 	/**
1741 	 * The raw hardware code that generated the key event.  This field is raraly useful.
1742 	 */
1743 	ushort keycode;
1744 	/**
1745 	 * A timestamp in milliseconds indicating when the event occurred.
1746 	 * These timestamps are relative to a starting point which should be considered arbitrary,
1747 	 * and only used to compare the dispatch times of events to one another.
1748 	 */
1749 	uint timestamp;
1750 }
1751 
1752 struct AtkMisc
1753 {
1754 	GObject parent;
1755 }
1756 
1757 /**
1758  * Usage of AtkMisc is deprecated since 2.12 and heavily discouraged.
1759  */
1760 struct AtkMiscClass
1761 {
1762 	GObjectClass parent;
1763 	/** */
1764 	extern(C) void function(AtkMisc* misc) threadsEnter;
1765 	/** */
1766 	extern(C) void function(AtkMisc* misc) threadsLeave;
1767 	void*[32] vfuncs;
1768 }
1769 
1770 struct AtkNoOpObject
1771 {
1772 	AtkObject parent;
1773 }
1774 
1775 struct AtkNoOpObjectClass
1776 {
1777 	AtkObjectClass parentClass;
1778 }
1779 
1780 struct AtkNoOpObjectFactory
1781 {
1782 	AtkObjectFactory parent;
1783 }
1784 
1785 struct AtkNoOpObjectFactoryClass
1786 {
1787 	AtkObjectFactoryClass parentClass;
1788 }
1789 
1790 struct AtkObject
1791 {
1792 	GObject parent;
1793 	char* description;
1794 	char* name;
1795 	AtkObject* accessibleParent;
1796 	AtkRole role;
1797 	AtkRelationSet* relationSet;
1798 	AtkLayer layer;
1799 }
1800 
1801 struct AtkObjectClass
1802 {
1803 	GObjectClass parent;
1804 	/**
1805 	 *
1806 	 * Params:
1807 	 *     accessible = an #AtkObject
1808 	 * Return: a character string representing the accessible name of the object.
1809 	 */
1810 	extern(C) const(char)* function(AtkObject* accessible) getName;
1811 	/**
1812 	 *
1813 	 * Params:
1814 	 *     accessible = an #AtkObject
1815 	 * Return: a character string representing the accessible description
1816 	 *     of the accessible.
1817 	 */
1818 	extern(C) const(char)* function(AtkObject* accessible) getDescription;
1819 	/**
1820 	 *
1821 	 * Params:
1822 	 *     accessible = an #AtkObject
1823 	 * Return: an #AtkObject representing the accessible
1824 	 *     parent of the accessible
1825 	 */
1826 	extern(C) AtkObject* function(AtkObject* accessible) getParent;
1827 	/** */
1828 	extern(C) int function(AtkObject* accessible) getNChildren;
1829 	/** */
1830 	extern(C) AtkObject* function(AtkObject* accessible, int i) refChild;
1831 	/**
1832 	 *
1833 	 * Params:
1834 	 *     accessible = an #AtkObject
1835 	 * Return: an integer which is the index of the accessible in its parent
1836 	 */
1837 	extern(C) int function(AtkObject* accessible) getIndexInParent;
1838 	/**
1839 	 *
1840 	 * Params:
1841 	 *     accessible = an #AtkObject
1842 	 * Return: an #AtkRelationSet representing the relation set
1843 	 *     of the object.
1844 	 */
1845 	extern(C) AtkRelationSet* function(AtkObject* accessible) refRelationSet;
1846 	/**
1847 	 *
1848 	 * Params:
1849 	 *     accessible = an #AtkObject
1850 	 * Return: an #AtkRole which is the role of the accessible
1851 	 */
1852 	extern(C) AtkRole function(AtkObject* accessible) getRole;
1853 	/**
1854 	 *
1855 	 * Params:
1856 	 *     accessible = an #AtkObject
1857 	 * Return: an #AtkLayer which is the layer of the accessible
1858 	 */
1859 	extern(C) AtkLayer function(AtkObject* accessible) getLayer;
1860 	/**
1861 	 *
1862 	 * Params:
1863 	 *     accessible = an #AtkObject
1864 	 * Return: a gint which is the zorder of the accessible, i.e. the depth at
1865 	 *     which the component is shown in relation to other components in the same
1866 	 *     container.
1867 	 */
1868 	extern(C) int function(AtkObject* accessible) getMdiZorder;
1869 	/**
1870 	 *
1871 	 * Params:
1872 	 *     accessible = an #AtkObject
1873 	 * Return: a reference to an #AtkStateSet which is the state
1874 	 *     set of the accessible
1875 	 */
1876 	extern(C) AtkStateSet* function(AtkObject* accessible) refStateSet;
1877 	/** */
1878 	extern(C) void function(AtkObject* accessible, const(char)* name) setName;
1879 	/** */
1880 	extern(C) void function(AtkObject* accessible, const(char)* description) setDescription;
1881 	/** */
1882 	extern(C) void function(AtkObject* accessible, AtkObject* parent) setParent;
1883 	/** */
1884 	extern(C) void function(AtkObject* accessible, AtkRole role) setRole;
1885 	/**
1886 	 *
1887 	 * Params:
1888 	 *     accessible = an #AtkObject
1889 	 *     handler = a function to be called when a property changes its value
1890 	 * Return: a #guint which is the handler id used in
1891 	 *     atk_object_remove_property_change_handler()
1892 	 */
1893 	extern(C) uint function(AtkObject* accessible, AtkPropertyChangeHandler* handler) connectPropertyChangeHandler;
1894 	/** */
1895 	extern(C) void function(AtkObject* accessible, uint handlerId) removePropertyChangeHandler;
1896 	/** */
1897 	extern(C) void function(AtkObject* accessible, void* data) initialize;
1898 	/** */
1899 	extern(C) void function(AtkObject* accessible, uint changeIndex, void* changedChild) childrenChanged;
1900 	/** */
1901 	extern(C) void function(AtkObject* accessible, int focusIn) focusEvent;
1902 	/** */
1903 	extern(C) void function(AtkObject* accessible, AtkPropertyValues* values) propertyChange;
1904 	/** */
1905 	extern(C) void function(AtkObject* accessible, const(char)* name, int stateSet) stateChange;
1906 	/** */
1907 	extern(C) void function(AtkObject* accessible) visibleDataChanged;
1908 	/** */
1909 	extern(C) void function(AtkObject* accessible, void** child) activeDescendantChanged;
1910 	/**
1911 	 *
1912 	 * Params:
1913 	 *     accessible = An #AtkObject.
1914 	 * Return: an #AtkAttributeSet consisting of all
1915 	 *     explicit properties/annotations applied to the object, or an empty
1916 	 *     set if the object has no name-value pair attributes assigned to
1917 	 *     it. This #atkattributeset should be freed by a call to
1918 	 *     atk_attribute_set_free().
1919 	 */
1920 	extern(C) AtkAttributeSet* function(AtkObject* accessible) getAttributes;
1921 	/**
1922 	 *
1923 	 * Params:
1924 	 *     accessible = an #AtkObject
1925 	 * Return: a UTF-8 string indicating the POSIX-style LC_MESSAGES
1926 	 *     locale of @accessible.
1927 	 */
1928 	extern(C) const(char)* function(AtkObject* accessible) getObjectLocale;
1929 	AtkFunction pad1;
1930 }
1931 
1932 struct AtkObjectFactory
1933 {
1934 	GObject parent;
1935 }
1936 
1937 struct AtkObjectFactoryClass
1938 {
1939 	GObjectClass parentClass;
1940 	/** */
1941 	extern(C) AtkObject* function(GObject* obj) createAccessible;
1942 	/** */
1943 	extern(C) void function(AtkObjectFactory* factory) invalidate;
1944 	/** */
1945 	extern(C) GType function() getAccessibleType;
1946 	AtkFunction pad1;
1947 	AtkFunction pad2;
1948 }
1949 
1950 struct AtkPlug
1951 {
1952 	AtkObject parent;
1953 }
1954 
1955 struct AtkPlugClass
1956 {
1957 	AtkObjectClass parentClass;
1958 	/** */
1959 	extern(C) char* function(AtkPlug* obj) getObjectId;
1960 }
1961 
1962 /**
1963  * Note: @old_value field of #AtkPropertyValues will not contain a
1964  * valid value. This is a field defined with the purpose of contain
1965  * the previous value of the property, but is not used anymore.
1966  */
1967 struct AtkPropertyValues
1968 {
1969 	/**
1970 	 * The name of the ATK property which has changed.
1971 	 */
1972 	const(char)* propertyName;
1973 	/**
1974 	 * NULL. This field is not used anymore.
1975 	 */
1976 	GValue oldValue;
1977 	/**
1978 	 * The new value of the named property.
1979 	 */
1980 	GValue newValue;
1981 }
1982 
1983 struct AtkRange;
1984 
1985 /**
1986  * A data structure for holding a rectangle. Those coordinates are
1987  * relative to the component top-level parent.
1988  */
1989 struct AtkRectangle
1990 {
1991 	/**
1992 	 * X coordinate of the left side of the rectangle.
1993 	 */
1994 	int x;
1995 	/**
1996 	 * Y coordinate of the top side of the rectangle.
1997 	 */
1998 	int y;
1999 	/**
2000 	 * width of the rectangle.
2001 	 */
2002 	int width;
2003 	/**
2004 	 * height of the rectangle.
2005 	 */
2006 	int height;
2007 }
2008 
2009 struct AtkRegistry
2010 {
2011 	GObject parent;
2012 	GHashTable* factoryTypeRegistry;
2013 	GHashTable* factorySingletonCache;
2014 }
2015 
2016 struct AtkRegistryClass
2017 {
2018 	GObjectClass parentClass;
2019 }
2020 
2021 struct AtkRelation
2022 {
2023 	GObject parent;
2024 	GPtrArray* target;
2025 	AtkRelationType relationship;
2026 }
2027 
2028 struct AtkRelationClass
2029 {
2030 	GObjectClass parent;
2031 }
2032 
2033 struct AtkRelationSet
2034 {
2035 	GObject parent;
2036 	GPtrArray* relations;
2037 }
2038 
2039 struct AtkRelationSetClass
2040 {
2041 	GObjectClass parent;
2042 	AtkFunction pad1;
2043 	AtkFunction pad2;
2044 }
2045 
2046 struct AtkSelection;
2047 
2048 struct AtkSelectionIface
2049 {
2050 	GTypeInterface parent;
2051 	/**
2052 	 *
2053 	 * Params:
2054 	 *     selection = a #GObject instance that implements AtkSelectionIface
2055 	 *     i = a #gint specifying the child index.
2056 	 * Return: TRUE if success, FALSE otherwise.
2057 	 */
2058 	extern(C) int function(AtkSelection* selection, int i) addSelection;
2059 	/**
2060 	 *
2061 	 * Params:
2062 	 *     selection = a #GObject instance that implements AtkSelectionIface
2063 	 * Return: TRUE if success, FALSE otherwise.
2064 	 */
2065 	extern(C) int function(AtkSelection* selection) clearSelection;
2066 	/**
2067 	 *
2068 	 * Params:
2069 	 *     selection = a #GObject instance that implements AtkSelectionIface
2070 	 *     i = a #gint specifying the index in the selection set.  (e.g. the
2071 	 *         ith selection as opposed to the ith child).
2072 	 * Return: an #AtkObject representing the
2073 	 *     selected accessible, or %NULL if @selection does not implement this
2074 	 *     interface.
2075 	 */
2076 	extern(C) AtkObject* function(AtkSelection* selection, int i) refSelection;
2077 	/**
2078 	 *
2079 	 * Params:
2080 	 *     selection = a #GObject instance that implements AtkSelectionIface
2081 	 * Return: a gint representing the number of items selected, or 0
2082 	 *     if @selection does not implement this interface.
2083 	 */
2084 	extern(C) int function(AtkSelection* selection) getSelectionCount;
2085 	/**
2086 	 *
2087 	 * Params:
2088 	 *     selection = a #GObject instance that implements AtkSelectionIface
2089 	 *     i = a #gint specifying the child index.
2090 	 * Return: a gboolean representing the specified child is selected, or 0
2091 	 *     if @selection does not implement this interface.
2092 	 */
2093 	extern(C) int function(AtkSelection* selection, int i) isChildSelected;
2094 	/**
2095 	 *
2096 	 * Params:
2097 	 *     selection = a #GObject instance that implements AtkSelectionIface
2098 	 *     i = a #gint specifying the index in the selection set.  (e.g. the
2099 	 *         ith selection as opposed to the ith child).
2100 	 * Return: TRUE if success, FALSE otherwise.
2101 	 */
2102 	extern(C) int function(AtkSelection* selection, int i) removeSelection;
2103 	/**
2104 	 *
2105 	 * Params:
2106 	 *     selection = a #GObject instance that implements AtkSelectionIface
2107 	 * Return: TRUE if success, FALSE otherwise.
2108 	 */
2109 	extern(C) int function(AtkSelection* selection) selectAllSelection;
2110 	/** */
2111 	extern(C) void function(AtkSelection* selection) selectionChanged;
2112 }
2113 
2114 struct AtkSocket
2115 {
2116 	AtkObject parent;
2117 	char* embeddedPlugId;
2118 }
2119 
2120 struct AtkSocketClass
2121 {
2122 	AtkObjectClass parentClass;
2123 	/** */
2124 	extern(C) void function(AtkSocket* obj, char* plugId) embed;
2125 }
2126 
2127 struct AtkStateSet
2128 {
2129 	GObject parent;
2130 }
2131 
2132 struct AtkStateSetClass
2133 {
2134 	GObjectClass parent;
2135 }
2136 
2137 struct AtkStreamableContent;
2138 
2139 struct AtkStreamableContentIface
2140 {
2141 	GTypeInterface parent;
2142 	/**
2143 	 *
2144 	 * Params:
2145 	 *     streamable = a GObject instance that implements AtkStreamableContentIface
2146 	 * Return: a gint which is the number of mime types supported by the object.
2147 	 */
2148 	extern(C) int function(AtkStreamableContent* streamable) getNMimeTypes;
2149 	/**
2150 	 *
2151 	 * Params:
2152 	 *     streamable = a GObject instance that implements AtkStreamableContent
2153 	 *     i = a gint representing the position of the mime type starting from 0
2154 	 * Return: a gchar* representing the specified mime type; the caller
2155 	 *     should not free the character string.
2156 	 */
2157 	extern(C) const(char)* function(AtkStreamableContent* streamable, int i) getMimeType;
2158 	/**
2159 	 *
2160 	 * Params:
2161 	 *     streamable = a GObject instance that implements AtkStreamableContentIface
2162 	 *     mimeType = a gchar* representing the mime type
2163 	 * Return: A #GIOChannel which contains the content in the
2164 	 *     specified mime type.
2165 	 */
2166 	extern(C) GIOChannel* function(AtkStreamableContent* streamable, const(char)* mimeType) getStream;
2167 	/**
2168 	 *
2169 	 * Params:
2170 	 *     streamable = a GObject instance that implements AtkStreamableContentIface
2171 	 *     mimeType = a gchar* representing the mime type, or NULL to request a URI
2172 	 *         for the default mime type.
2173 	 * Return: Returns a string representing a URI, or %NULL
2174 	 *     if no corresponding URI can be constructed.
2175 	 */
2176 	extern(C) const(char)* function(AtkStreamableContent* streamable, const(char)* mimeType) getUri;
2177 	AtkFunction pad1;
2178 	AtkFunction pad2;
2179 	AtkFunction pad3;
2180 }
2181 
2182 struct AtkTable;
2183 
2184 struct AtkTableCell;
2185 
2186 struct AtkTableCellIface
2187 {
2188 	GTypeInterface parent;
2189 	/**
2190 	 *
2191 	 * Params:
2192 	 *     cell = a GObject instance that implements AtkTableCellIface
2193 	 * Return: a gint representing the number of columns occupied by this cell,
2194 	 *     or 0 if the cell does not implement this method.
2195 	 */
2196 	extern(C) int function(AtkTableCell* cell) getColumnSpan;
2197 	/**
2198 	 *
2199 	 * Params:
2200 	 *     cell = a GObject instance that implements AtkTableCellIface
2201 	 * Return: a GPtrArray of AtkObjects
2202 	 *     representing the column header cells.
2203 	 */
2204 	extern(C) GPtrArray* function(AtkTableCell* cell) getColumnHeaderCells;
2205 	/**
2206 	 *
2207 	 * Params:
2208 	 *     cell = a GObject instance that implements AtkTableCellIface
2209 	 *     row = the row of the given cell.
2210 	 *     column = the column of the given cell.
2211 	 * Return: TRUE if successful; FALSE otherwise.
2212 	 */
2213 	extern(C) int function(AtkTableCell* cell, int* row, int* column) getPosition;
2214 	/**
2215 	 *
2216 	 * Params:
2217 	 *     cell = a GObject instance that implements AtkTableCellIface
2218 	 * Return: a gint representing the number of rows occupied by this cell,
2219 	 *     or 0 if the cell does not implement this method.
2220 	 */
2221 	extern(C) int function(AtkTableCell* cell) getRowSpan;
2222 	/**
2223 	 *
2224 	 * Params:
2225 	 *     cell = a GObject instance that implements AtkTableCellIface
2226 	 * Return: a GPtrArray of AtkObjects
2227 	 *     representing the row header cells.
2228 	 */
2229 	extern(C) GPtrArray* function(AtkTableCell* cell) getRowHeaderCells;
2230 	/**
2231 	 *
2232 	 * Params:
2233 	 *     cell = a GObject instance that implements AtkTableCellIface
2234 	 *     row = the row index of the given cell.
2235 	 *     column = the column index of the given cell.
2236 	 *     rowSpan = the number of rows occupied by this cell.
2237 	 *     columnSpan = the number of columns occupied by this cell.
2238 	 * Return: TRUE if successful; FALSE otherwise.
2239 	 */
2240 	extern(C) int function(AtkTableCell* cell, int* row, int* column, int* rowSpan, int* columnSpan) getRowColumnSpan;
2241 	/**
2242 	 *
2243 	 * Params:
2244 	 *     cell = a GObject instance that implements AtkTableCellIface
2245 	 * Return: the atk object for the containing table.
2246 	 */
2247 	extern(C) AtkObject* function(AtkTableCell* cell) getTable;
2248 }
2249 
2250 struct AtkTableIface
2251 {
2252 	GTypeInterface parent;
2253 	/**
2254 	 *
2255 	 * Params:
2256 	 *     table = a GObject instance that implements AtkTableIface
2257 	 *     row = a #gint representing a row in @table
2258 	 *     column = a #gint representing a column in @table
2259 	 * Return: an #AtkObject representing the referred
2260 	 *     to accessible
2261 	 */
2262 	extern(C) AtkObject* function(AtkTable* table, int row, int column) refAt;
2263 	/**
2264 	 *
2265 	 * Params:
2266 	 *     table = a GObject instance that implements AtkTableIface
2267 	 *     row = a #gint representing a row in @table
2268 	 *     column = a #gint representing a column in @table
2269 	 * Return: a #gint representing the index at specified position.
2270 	 *     The value -1 is returned if the object at row,column is not a child
2271 	 *     of table or table does not implement this interface.
2272 	 */
2273 	extern(C) int function(AtkTable* table, int row, int column) getIndexAt;
2274 	/**
2275 	 *
2276 	 * Params:
2277 	 *     table = a GObject instance that implements AtkTableInterface
2278 	 *     index = a #gint representing an index in @table
2279 	 * Return: a gint representing the column at the specified index,
2280 	 *     or -1 if the table does not implement this method.
2281 	 */
2282 	extern(C) int function(AtkTable* table, int index) getColumnAtIndex;
2283 	/**
2284 	 *
2285 	 * Params:
2286 	 *     table = a GObject instance that implements AtkTableInterface
2287 	 *     index = a #gint representing an index in @table
2288 	 * Return: a gint representing the row at the specified index,
2289 	 *     or -1 if the table does not implement this method.
2290 	 */
2291 	extern(C) int function(AtkTable* table, int index) getRowAtIndex;
2292 	/**
2293 	 *
2294 	 * Params:
2295 	 *     table = a GObject instance that implements AtkTableIface
2296 	 * Return: a gint representing the number of columns, or 0
2297 	 *     if value does not implement this interface.
2298 	 */
2299 	extern(C) int function(AtkTable* table) getNColumns;
2300 	/**
2301 	 *
2302 	 * Params:
2303 	 *     table = a GObject instance that implements AtkTableIface
2304 	 * Return: a gint representing the number of rows, or 0
2305 	 *     if value does not implement this interface.
2306 	 */
2307 	extern(C) int function(AtkTable* table) getNRows;
2308 	/**
2309 	 *
2310 	 * Params:
2311 	 *     table = a GObject instance that implements AtkTableIface
2312 	 *     row = a #gint representing a row in @table
2313 	 *     column = a #gint representing a column in @table
2314 	 * Return: a gint representing the column extent at specified position, or 0
2315 	 *     if value does not implement this interface.
2316 	 */
2317 	extern(C) int function(AtkTable* table, int row, int column) getColumnExtentAt;
2318 	/**
2319 	 *
2320 	 * Params:
2321 	 *     table = a GObject instance that implements AtkTableIface
2322 	 *     row = a #gint representing a row in @table
2323 	 *     column = a #gint representing a column in @table
2324 	 * Return: a gint representing the row extent at specified position, or 0
2325 	 *     if value does not implement this interface.
2326 	 */
2327 	extern(C) int function(AtkTable* table, int row, int column) getRowExtentAt;
2328 	/**
2329 	 *
2330 	 * Params:
2331 	 *     table = a GObject instance that implements AtkTableInterface
2332 	 * Return: a AtkObject* representing the
2333 	 *     table caption, or %NULL if value does not implement this interface.
2334 	 */
2335 	extern(C) AtkObject* function(AtkTable* table) getCaption;
2336 	/**
2337 	 *
2338 	 * Params:
2339 	 *     table = a GObject instance that implements AtkTableIface
2340 	 *     column = a #gint representing a column in @table
2341 	 * Return: a gchar* representing the column description, or %NULL
2342 	 *     if value does not implement this interface.
2343 	 */
2344 	extern(C) const(char)* function(AtkTable* table, int column) getColumnDescription;
2345 	/**
2346 	 *
2347 	 * Params:
2348 	 *     table = a GObject instance that implements AtkTableIface
2349 	 *     column = a #gint representing a column in the table
2350 	 * Return: a AtkObject* representing the
2351 	 *     specified column header, or %NULL if value does not implement this
2352 	 *     interface.
2353 	 */
2354 	extern(C) AtkObject* function(AtkTable* table, int column) getColumnHeader;
2355 	/**
2356 	 *
2357 	 * Params:
2358 	 *     table = a GObject instance that implements AtkTableIface
2359 	 *     row = a #gint representing a row in @table
2360 	 * Return: a gchar* representing the row description, or
2361 	 *     %NULL if value does not implement this interface.
2362 	 */
2363 	extern(C) const(char)* function(AtkTable* table, int row) getRowDescription;
2364 	/**
2365 	 *
2366 	 * Params:
2367 	 *     table = a GObject instance that implements AtkTableIface
2368 	 *     row = a #gint representing a row in the table
2369 	 * Return: a AtkObject* representing the
2370 	 *     specified row header, or %NULL if value does not implement this
2371 	 *     interface.
2372 	 */
2373 	extern(C) AtkObject* function(AtkTable* table, int row) getRowHeader;
2374 	/**
2375 	 *
2376 	 * Params:
2377 	 *     table = a GObject instance that implements AtkTableIface
2378 	 * Return: a AtkObject* representing a summary description
2379 	 *     of the table, or zero if value does not implement this interface.
2380 	 */
2381 	extern(C) AtkObject* function(AtkTable* table) getSummary;
2382 	/** */
2383 	extern(C) void function(AtkTable* table, AtkObject* caption) setCaption;
2384 	/** */
2385 	extern(C) void function(AtkTable* table, int column, const(char)* description) setColumnDescription;
2386 	/** */
2387 	extern(C) void function(AtkTable* table, int column, AtkObject* header) setColumnHeader;
2388 	/** */
2389 	extern(C) void function(AtkTable* table, int row, const(char)* description) setRowDescription;
2390 	/** */
2391 	extern(C) void function(AtkTable* table, int row, AtkObject* header) setRowHeader;
2392 	/** */
2393 	extern(C) void function(AtkTable* table, AtkObject* accessible) setSummary;
2394 	/**
2395 	 *
2396 	 * Params:
2397 	 *     table = a GObject instance that implements AtkTableIface
2398 	 *     selected = a #gint** that is to contain the selected columns numbers
2399 	 * Return: a gint representing the number of selected columns,
2400 	 *     or %0 if value does not implement this interface.
2401 	 */
2402 	extern(C) int function(AtkTable* table, int** selected) getSelectedColumns;
2403 	/**
2404 	 *
2405 	 * Params:
2406 	 *     table = a GObject instance that implements AtkTableIface
2407 	 *     selected = a #gint** that is to contain the selected row numbers
2408 	 * Return: a gint representing the number of selected rows,
2409 	 *     or zero if value does not implement this interface.
2410 	 */
2411 	extern(C) int function(AtkTable* table, int** selected) getSelectedRows;
2412 	/**
2413 	 *
2414 	 * Params:
2415 	 *     table = a GObject instance that implements AtkTableIface
2416 	 *     column = a #gint representing a column in @table
2417 	 * Return: a gboolean representing if the column is selected, or 0
2418 	 *     if value does not implement this interface.
2419 	 */
2420 	extern(C) int function(AtkTable* table, int column) isColumnSelected;
2421 	/**
2422 	 *
2423 	 * Params:
2424 	 *     table = a GObject instance that implements AtkTableIface
2425 	 *     row = a #gint representing a row in @table
2426 	 * Return: a gboolean representing if the row is selected, or 0
2427 	 *     if value does not implement this interface.
2428 	 */
2429 	extern(C) int function(AtkTable* table, int row) isRowSelected;
2430 	/**
2431 	 *
2432 	 * Params:
2433 	 *     table = a GObject instance that implements AtkTableIface
2434 	 *     row = a #gint representing a row in @table
2435 	 *     column = a #gint representing a column in @table
2436 	 * Return: a gboolean representing if the cell is selected, or 0
2437 	 *     if value does not implement this interface.
2438 	 */
2439 	extern(C) int function(AtkTable* table, int row, int column) isSelected;
2440 	/**
2441 	 *
2442 	 * Params:
2443 	 *     table = a GObject instance that implements AtkTableIface
2444 	 *     row = a #gint representing a row in @table
2445 	 * Return: a gboolean representing if row was successfully added to selection,
2446 	 *     or 0 if value does not implement this interface.
2447 	 */
2448 	extern(C) int function(AtkTable* table, int row) addRowSelection;
2449 	/**
2450 	 *
2451 	 * Params:
2452 	 *     table = a GObject instance that implements AtkTableIface
2453 	 *     row = a #gint representing a row in @table
2454 	 * Return: a gboolean representing if the row was successfully removed from
2455 	 *     the selection, or 0 if value does not implement this interface.
2456 	 */
2457 	extern(C) int function(AtkTable* table, int row) removeRowSelection;
2458 	/**
2459 	 *
2460 	 * Params:
2461 	 *     table = a GObject instance that implements AtkTableIface
2462 	 *     column = a #gint representing a column in @table
2463 	 * Return: a gboolean representing if the column was successfully added to
2464 	 *     the selection, or 0 if value does not implement this interface.
2465 	 */
2466 	extern(C) int function(AtkTable* table, int column) addColumnSelection;
2467 	/**
2468 	 *
2469 	 * Params:
2470 	 *     table = a GObject instance that implements AtkTableIface
2471 	 *     column = a #gint representing a column in @table
2472 	 * Return: a gboolean representing if the column was successfully removed from
2473 	 *     the selection, or 0 if value does not implement this interface.
2474 	 */
2475 	extern(C) int function(AtkTable* table, int column) removeColumnSelection;
2476 	/** */
2477 	extern(C) void function(AtkTable* table, int row, int numInserted) rowInserted;
2478 	/** */
2479 	extern(C) void function(AtkTable* table, int column, int numInserted) columnInserted;
2480 	/** */
2481 	extern(C) void function(AtkTable* table, int row, int numDeleted) rowDeleted;
2482 	/** */
2483 	extern(C) void function(AtkTable* table, int column, int numDeleted) columnDeleted;
2484 	/** */
2485 	extern(C) void function(AtkTable* table) rowReordered;
2486 	/** */
2487 	extern(C) void function(AtkTable* table) columnReordered;
2488 	/** */
2489 	extern(C) void function(AtkTable* table) modelChanged;
2490 }
2491 
2492 struct AtkText;
2493 
2494 struct AtkTextIface
2495 {
2496 	GTypeInterface parent;
2497 	/**
2498 	 *
2499 	 * Params:
2500 	 *     text = an #AtkText
2501 	 *     startOffset = start position
2502 	 *     endOffset = end position, or -1 for the end of the string.
2503 	 * Return: a newly allocated string containing the text from @start_offset up
2504 	 *     to, but not including @end_offset. Use g_free() to free the returned string.
2505 	 */
2506 	extern(C) char* function(AtkText* text, int startOffset, int endOffset) getText;
2507 	/**
2508 	 *
2509 	 * Params:
2510 	 *     text = an #AtkText
2511 	 *     offset = position
2512 	 *     boundaryType = An #AtkTextBoundary
2513 	 *     startOffset = the start offset of the returned string
2514 	 *     endOffset = the offset of the first character after the
2515 	 *         returned substring
2516 	 * Return: a newly allocated string containing the text after @offset bounded
2517 	 *     by the specified @boundary_type. Use g_free() to free the returned string.
2518 	 */
2519 	extern(C) char* function(AtkText* text, int offset, AtkTextBoundary boundaryType, int* startOffset, int* endOffset) getTextAfterOffset;
2520 	/**
2521 	 *
2522 	 * Params:
2523 	 *     text = an #AtkText
2524 	 *     offset = position
2525 	 *     boundaryType = An #AtkTextBoundary
2526 	 *     startOffset = the start offset of the returned string
2527 	 *     endOffset = the offset of the first character after the
2528 	 *         returned substring
2529 	 * Return: a newly allocated string containing the text at @offset bounded by
2530 	 *     the specified @boundary_type. Use g_free() to free the returned string.
2531 	 */
2532 	extern(C) char* function(AtkText* text, int offset, AtkTextBoundary boundaryType, int* startOffset, int* endOffset) getTextAtOffset;
2533 	/**
2534 	 *
2535 	 * Params:
2536 	 *     text = an #AtkText
2537 	 *     offset = position
2538 	 * Return: the character at @offset.
2539 	 */
2540 	extern(C) dchar function(AtkText* text, int offset) getCharacterAtOffset;
2541 	/**
2542 	 *
2543 	 * Params:
2544 	 *     text = an #AtkText
2545 	 *     offset = position
2546 	 *     boundaryType = An #AtkTextBoundary
2547 	 *     startOffset = the start offset of the returned string
2548 	 *     endOffset = the offset of the first character after the
2549 	 *         returned substring
2550 	 * Return: a newly allocated string containing the text before @offset bounded
2551 	 *     by the specified @boundary_type. Use g_free() to free the returned string.
2552 	 */
2553 	extern(C) char* function(AtkText* text, int offset, AtkTextBoundary boundaryType, int* startOffset, int* endOffset) getTextBeforeOffset;
2554 	/**
2555 	 *
2556 	 * Params:
2557 	 *     text = an #AtkText
2558 	 * Return: the offset position of the caret (cursor).
2559 	 */
2560 	extern(C) int function(AtkText* text) getCaretOffset;
2561 	/**
2562 	 *
2563 	 * Params:
2564 	 *     text = an #AtkText
2565 	 *     offset = the offset at which to get the attributes, -1 means the offset of
2566 	 *         the character to be inserted at the caret location.
2567 	 *     startOffset = the address to put the start offset of the range
2568 	 *     endOffset = the address to put the end offset of the range
2569 	 * Return: an #AtkAttributeSet which contains the attributes
2570 	 *     explicitly set at @offset. This #AtkAttributeSet should be freed by a call
2571 	 *     to atk_attribute_set_free().
2572 	 */
2573 	extern(C) AtkAttributeSet* function(AtkText* text, int offset, int* startOffset, int* endOffset) getRunAttributes;
2574 	/**
2575 	 *
2576 	 * Params:
2577 	 *     text = an #AtkText
2578 	 * Return: an #AtkAttributeSet which contains the default
2579 	 *     values of attributes.  at @offset. this #atkattributeset should be freed by
2580 	 *     a call to atk_attribute_set_free().
2581 	 */
2582 	extern(C) AtkAttributeSet* function(AtkText* text) getDefaultAttributes;
2583 	/** */
2584 	extern(C) void function(AtkText* text, int offset, int* x, int* y, int* width, int* height, AtkCoordType coords) getCharacterExtents;
2585 	/**
2586 	 *
2587 	 * Params:
2588 	 *     text = an #AtkText
2589 	 * Return: the number of characters.
2590 	 */
2591 	extern(C) int function(AtkText* text) getCharacterCount;
2592 	/**
2593 	 *
2594 	 * Params:
2595 	 *     text = an #AtkText
2596 	 *     x = screen x-position of character
2597 	 *     y = screen y-position of character
2598 	 *     coords = specify whether coordinates are relative to the screen or
2599 	 *         widget window
2600 	 * Return: the offset to the character which is located at
2601 	 *     the specified @x and @y coordinates.
2602 	 */
2603 	extern(C) int function(AtkText* text, int x, int y, AtkCoordType coords) getOffsetAtPoint;
2604 	/**
2605 	 *
2606 	 * Params:
2607 	 *     text = an #AtkText
2608 	 * Return: The number of selected regions, or -1 if a failure
2609 	 *     occurred.
2610 	 */
2611 	extern(C) int function(AtkText* text) getNSelections;
2612 	/**
2613 	 *
2614 	 * Params:
2615 	 *     text = an #AtkText
2616 	 *     selectionNum = The selection number.  The selected regions are
2617 	 *         assigned numbers that correspond to how far the region is from the
2618 	 *         start of the text.  The selected region closest to the beginning
2619 	 *         of the text region is assigned the number 0, etc.  Note that adding,
2620 	 *         moving or deleting a selected region can change the numbering.
2621 	 *     startOffset = passes back the start position of the selected region
2622 	 *     endOffset = passes back the end position of (e.g. offset immediately past)
2623 	 *         the selected region
2624 	 * Return: a newly allocated string containing the selected text. Use g_free()
2625 	 *     to free the returned string.
2626 	 */
2627 	extern(C) char* function(AtkText* text, int selectionNum, int* startOffset, int* endOffset) getSelection;
2628 	/**
2629 	 *
2630 	 * Params:
2631 	 *     text = an #AtkText
2632 	 *     startOffset = the start position of the selected region
2633 	 *     endOffset = the offset of the first character after the selected region.
2634 	 * Return: %TRUE if success, %FALSE otherwise
2635 	 */
2636 	extern(C) int function(AtkText* text, int startOffset, int endOffset) addSelection;
2637 	/**
2638 	 *
2639 	 * Params:
2640 	 *     text = an #AtkText
2641 	 *     selectionNum = The selection number.  The selected regions are
2642 	 *         assigned numbers that correspond to how far the region is from the
2643 	 *         start of the text.  The selected region closest to the beginning
2644 	 *         of the text region is assigned the number 0, etc.  Note that adding,
2645 	 *         moving or deleting a selected region can change the numbering.
2646 	 * Return: %TRUE if success, %FALSE otherwise
2647 	 */
2648 	extern(C) int function(AtkText* text, int selectionNum) removeSelection;
2649 	/**
2650 	 *
2651 	 * Params:
2652 	 *     text = an #AtkText
2653 	 *     selectionNum = The selection number.  The selected regions are
2654 	 *         assigned numbers that correspond to how far the region is from the
2655 	 *         start of the text.  The selected region closest to the beginning
2656 	 *         of the text region is assigned the number 0, etc.  Note that adding,
2657 	 *         moving or deleting a selected region can change the numbering.
2658 	 *     startOffset = the new start position of the selection
2659 	 *     endOffset = the new end position of (e.g. offset immediately past)
2660 	 *         the selection
2661 	 * Return: %TRUE if success, %FALSE otherwise
2662 	 */
2663 	extern(C) int function(AtkText* text, int selectionNum, int startOffset, int endOffset) setSelection;
2664 	/**
2665 	 *
2666 	 * Params:
2667 	 *     text = an #AtkText
2668 	 *     offset = position
2669 	 * Return: %TRUE if success, %FALSE otherwise.
2670 	 */
2671 	extern(C) int function(AtkText* text, int offset) setCaretOffset;
2672 	/** */
2673 	extern(C) void function(AtkText* text, int position, int length) textChanged;
2674 	/** */
2675 	extern(C) void function(AtkText* text, int location) textCaretMoved;
2676 	/** */
2677 	extern(C) void function(AtkText* text) textSelectionChanged;
2678 	/** */
2679 	extern(C) void function(AtkText* text) textAttributesChanged;
2680 	/** */
2681 	extern(C) void function(AtkText* text, int startOffset, int endOffset, AtkCoordType coordType, AtkTextRectangle* rect) getRangeExtents;
2682 	/** */
2683 	extern(C) AtkTextRange** function(AtkText* text, AtkTextRectangle* rect, AtkCoordType coordType, AtkTextClipType xClipType, AtkTextClipType yClipType) getBoundedRanges;
2684 	/**
2685 	 *
2686 	 * Params:
2687 	 *     text = an #AtkText
2688 	 *     offset = position
2689 	 *     granularity = An #AtkTextGranularity
2690 	 *     startOffset = the start offset of the returned string, or -1
2691 	 *         if an error has occurred (e.g. invalid offset, not implemented)
2692 	 *     endOffset = the offset of the first character after the returned string,
2693 	 *         or -1 if an error has occurred (e.g. invalid offset, not implemented)
2694 	 * Return: a newly allocated string containing the text
2695 	 *     at the @offset bounded by the specified @granularity. Use
2696 	 *     g_free() to free the returned string.  Returns %NULL if the
2697 	 *     offset is invalid or no implementation is available.
2698 	 */
2699 	extern(C) char* function(AtkText* text, int offset, AtkTextGranularity granularity, int* startOffset, int* endOffset) getStringAtOffset;
2700 }
2701 
2702 /**
2703  * A structure used to describe a text range.
2704  */
2705 struct AtkTextRange
2706 {
2707 	/**
2708 	 * A rectangle giving the bounds of the text range
2709 	 */
2710 	AtkTextRectangle bounds;
2711 	/**
2712 	 * The start offset of a AtkTextRange
2713 	 */
2714 	int startOffset;
2715 	/**
2716 	 * The end offset of a AtkTextRange
2717 	 */
2718 	int endOffset;
2719 	/**
2720 	 * The text in the text range
2721 	 */
2722 	char* content;
2723 }
2724 
2725 /**
2726  * A structure used to store a rectangle used by AtkText.
2727  */
2728 struct AtkTextRectangle
2729 {
2730 	/**
2731 	 * The horizontal coordinate of a rectangle
2732 	 */
2733 	int x;
2734 	/**
2735 	 * The vertical coordinate of a rectangle
2736 	 */
2737 	int y;
2738 	/**
2739 	 * The width of a rectangle
2740 	 */
2741 	int width;
2742 	/**
2743 	 * The height of a rectangle
2744 	 */
2745 	int height;
2746 }
2747 
2748 /**
2749  * A set of ATK utility functions which are used to support event
2750  * registration of various types, and obtaining the 'root' accessible
2751  * of a process and information about the current ATK implementation
2752  * and toolkit version.
2753  */
2754 struct AtkUtil
2755 {
2756 	GObject parent;
2757 }
2758 
2759 struct AtkUtilClass
2760 {
2761 	GObjectClass parent;
2762 	/** */
2763 	extern(C) uint function(GSignalEmissionHook listener, const(char)* eventType) addGlobalEventListener;
2764 	/** */
2765 	extern(C) void function(uint listenerId) removeGlobalEventListener;
2766 	/** */
2767 	extern(C) uint function(AtkKeySnoopFunc listener, void* data) addKeyEventListener;
2768 	/** */
2769 	extern(C) void function(uint listenerId) removeKeyEventListener;
2770 	/** */
2771 	extern(C) AtkObject* function() getRoot;
2772 	/** */
2773 	extern(C) const(char)* function() getToolkitName;
2774 	/** */
2775 	extern(C) const(char)* function() getToolkitVersion;
2776 }
2777 
2778 struct AtkValue;
2779 
2780 struct AtkValueIface
2781 {
2782 	GTypeInterface parent;
2783 	/** */
2784 	extern(C) void function(AtkValue* obj, GValue* value) getCurrentValue;
2785 	/** */
2786 	extern(C) void function(AtkValue* obj, GValue* value) getMaximumValue;
2787 	/** */
2788 	extern(C) void function(AtkValue* obj, GValue* value) getMinimumValue;
2789 	/**
2790 	 *
2791 	 * Params:
2792 	 *     obj = a GObject instance that implements AtkValueIface
2793 	 *     value = a #GValue which is the desired new accessible value.
2794 	 * Return: %TRUE if new value is successfully set, %FALSE otherwise.
2795 	 */
2796 	extern(C) int function(AtkValue* obj, GValue* value) setCurrentValue;
2797 	/** */
2798 	extern(C) void function(AtkValue* obj, GValue* value) getMinimumIncrement;
2799 	/** */
2800 	extern(C) void function(AtkValue* obj, double* value, char** text) getValueAndText;
2801 	/**
2802 	 *
2803 	 * Params:
2804 	 *     obj = a GObject instance that implements AtkValueIface
2805 	 * Return: a newly allocated #AtkRange
2806 	 *     that represents the minimum, maximum and descriptor (if available)
2807 	 *     of @obj. NULL if that range is not defined.
2808 	 */
2809 	extern(C) AtkRange* function(AtkValue* obj) getRange;
2810 	/**
2811 	 *
2812 	 * Params:
2813 	 *     obj = a GObject instance that implements AtkValueIface
2814 	 * Return: the minimum increment by which the value of this
2815 	 *     object may be changed. zero if undefined.
2816 	 */
2817 	extern(C) double function(AtkValue* obj) getIncrement;
2818 	/**
2819 	 *
2820 	 * Params:
2821 	 *     obj = a GObject instance that implements AtkValueIface
2822 	 * Return: an #GSList of
2823 	 *     #AtkRange which each of the subranges defined for this object. Free
2824 	 *     the returns list with g_slist_free().
2825 	 */
2826 	extern(C) GSList* function(AtkValue* obj) getSubRanges;
2827 	/** */
2828 	extern(C) void function(AtkValue* obj, double newValue) setValue;
2829 }
2830 
2831 struct AtkWindow;
2832 
2833 struct AtkWindowIface
2834 {
2835 	GTypeInterface parent;
2836 }
2837 
2838 /**
2839  * A function which is called when an object emits a matching event,
2840  * as used in #atk_add_focus_tracker.
2841  * Currently the only events for which object-specific handlers are
2842  * supported are events of type "focus:".  Most clients of ATK will prefer to
2843  * attach signal handlers for the various ATK signals instead.
2844  *
2845  * see atk_add_focus_tracker.
2846  *
2847  * Params:
2848  *     obj = An #AtkObject instance for whom the callback will be called when
2849  *         the specified event (e.g. 'focus:') takes place.
2850  */
2851 public alias extern(C) void function(AtkObject* obj) AtkEventListener;
2852 
2853 /**
2854  * An #AtkEventListenerInit function is a special function that is
2855  * called in order to initialize the per-object event registration system
2856  * used by #AtkEventListener, if any preparation is required.
2857  *
2858  * see atk_focus_tracker_init.
2859  */
2860 public alias extern(C) void function() AtkEventListenerInit;
2861 
2862 /**
2863  * The type of callback function used for
2864  * atk_component_add_focus_handler() and
2865  * atk_component_remove_focus_handler()
2866  *
2867  * Deprecated: Deprecated with atk_component_add_focus_handler()
2868  * and atk_component_remove_focus_handler(). See those
2869  * methods for more information.
2870  *
2871  * Params:
2872  *     object = the #AtkObject that receives/lose the focus
2873  *     focusIn = TRUE if the object receives the focus
2874  */
2875 public alias extern(C) void function(AtkObject* object, int focusIn) AtkFocusHandler;
2876 
2877 /**
2878  * An AtkFunction is a function definition used for padding which has
2879  * been added to class and interface structures to allow for expansion
2880  * in the future.
2881  *
2882  * Params:
2883  *     userData = custom data defined by the user
2884  *
2885  * Return: not used
2886  */
2887 public alias extern(C) int function(void* userData) AtkFunction;
2888 
2889 /**
2890  * An #AtkKeySnoopFunc is a type of callback which is called whenever a key event occurs,
2891  * if registered via atk_add_key_event_listener.  It allows for pre-emptive
2892  * interception of key events via the return code as described below.
2893  *
2894  * Params:
2895  *     event = an AtkKeyEventStruct containing information about the key event for which
2896  *         notification is being given.
2897  *     userData = a block of data which will be passed to the event listener, on notification.
2898  *
2899  * Return: TRUE (nonzero) if the event emission should be stopped and the event
2900  *     discarded without being passed to the normal GUI recipient; FALSE (zero) if the
2901  *     event dispatch to the client application should proceed as normal.
2902  *
2903  *     see atk_add_key_event_listener.
2904  */
2905 public alias extern(C) int function(AtkKeyEventStruct* event, void* userData) AtkKeySnoopFunc;
2906 
2907 /**
2908  * An AtkPropertyChangeHandler is a function which is executed when an
2909  * AtkObject's property changes value. It is specified in a call to
2910  * atk_object_connect_property_change_handler().
2911  *
2912  * Deprecated: Since 2.12.
2913  *
2914  * Params:
2915  *     obj = atkobject which property changes
2916  *     vals = values changed
2917  */
2918 public alias extern(C) void function(AtkObject* obj, AtkPropertyValues* vals) AtkPropertyChangeHandler;