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