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