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