gtkD/src/gtkc/atktypes.d

   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 as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 module gtkc.atktypes;
  24
  25
  26 public import gtkc.glibtypes;
  27 public import gtkc.gobjecttypes;
  28 public alias void* AtkFocusHandler;
  29 public struct AtkStateSet;
  30 public struct AtkRectangle;
  31
  32
  33 /**
  34  * typedef guint64 AtkState;
  35  * The AtkState value should not be referenceed directly.
  36  */
  37 public alias ulong AtkState;
  38
  39 /**
  40  * typedef GSList AtkAttributeSet;
  41  * This is a singly-linked list (a GSList) of AtkAttribute. It is
  42  * used by atk_text_get_run_attributes(), atk_text_get_default_attributes()
  43  * and atk_editable_text_set_run_attributes()
  44  */
  45 public alias GSList AtkAttributeSet;
  46 /**
  47  * Describes the type of link
  48  * ATK_HYPERLINK_IS_INLINE
  49  */
  50 public enum AtkHyperlinkStateFlags
  51 {
  52         IS_INLINE = 1 << 0
  53 }
  54 /**
  55  * Describes the role of an object
  56  * These are the built-in enumerated roles that UI components can have in
  57  * ATK. Other roles may be added at runtime, so an AtkRole >=
  58  * ATK_ROLE_LAST_DEFINED is not necessarily an error.
  59  * ATK_ROLE_INVALID
  60  */
  61 public enum AtkRole
  62 {
  63         INVALID = 0,
  64         ACCEL_LABEL,
  65         ALERT,
  66         ANIMATION,
  67         ARROW,
  68         CALENDAR,
  69         CANVAS,
  70         CHECK_BOX,
  71         CHECK_MENU_ITEM,
  72         COLOR_CHOOSER,
  73         COLUMN_HEADER,
  74         COMBO_BOX,
  75         DATE_EDITOR,
  76         DESKTOP_ICON,
  77         DESKTOP_FRAME,
  78         DIAL,
  79         DIALOG,
  80         DIRECTORY_PANE,
  81         DRAWING_AREA,
  82         FILE_CHOOSER,
  83         FILLER,
  84         FONT_CHOOSER,
  85         FRAME,
  86         GLASS_PANE,
  87         HTML_CONTAINER,
  88         ICON,
  89         IMAGE,
  90         INTERNAL_FRAME,
  91         LABEL,
  92         LAYERED_PANE,
  93         LIST,
  94         LIST_ITEM,
  95         MENU,
  96         MENU_BAR,
  97         MENU_ITEM,
  98         OPTION_PANE,
  99         PAGE_TAB,
 100         PAGE_TAB_LIST,
 101         PANEL,
 102         PASSWORD_TEXT,
 103         POPUP_MENU,
 104         PROGRESS_BAR,
 105         PUSH_BUTTON,
 106         RADIO_BUTTON,
 107         RADIO_MENU_ITEM,
 108         ROOT_PANE,
 109         ROW_HEADER,
 110         SCROLL_BAR,
 111         SCROLL_PANE,
 112         SEPARATOR,
 113         SLIDER,
 114         SPLIT_PANE,
 115         SPIN_BUTTON,
 116         STATUSBAR,
 117         TABLE,
 118         TABLE_CELL,
 119         TABLE_COLUMN_HEADER,
 120         TABLE_ROW_HEADER,
 121         TEAR_OFF_MENU_ITEM,
 122         TERMINAL,
 123         TEXT,
 124         TOGGLE_BUTTON,
 125         TOOL_BAR,
 126         TOOL_TIP,
 127         TREE,
 128         TREE_TABLE,
 129         UNKNOWN,
 130         VIEWPORT,
 131         WINDOW,
 132         HEADER,
 133         FOOTER,
 134         PARAGRAPH,
 135         RULER,
 136         APPLICATION,
 137         AUTOCOMPLETE,
 138         EDITBAR,
 139         EMBEDDED,
 140         ENTRY,
 141         CHART,
 142         CAPTION,
 143         DOCUMENT_FRAME,
 144         HEADING,
 145         PAGE,
 146         SECTION,
 147         REDUNDANT_OBJECT,
 148         FORM,
 149         LINK,
 150         INPUT_METHOD_WINDOW,
 151         LAST_DEFINED
 152 }
 153 /**
 154  * Describes the layer of a component
 155  * These enumerated "layer values" are used when determining which UI
 156  * rendering layer a component is drawn into, which can help in making
 157  * determinations of when components occlude one another.
 158  * ATK_LAYER_INVALID
 159  */
 160 public enum AtkLayer
 161 {
 162         INVALID,
 163         BACKGROUND,
 164         CANVAS,
 165         WIDGET,
 166         MDI,
 167         POPUP,
 168         OVERLAY,
 169         WINDOW
 170 }
 171 /**
 172  * Describes the type of the relation
 173  * ATK_RELATION_NULL
 174  */
 175 public enum AtkRelationType
 176 {
 177         NULL = 0,
 178         CONTROLLED_BY,
 179         CONTROLLER_FOR,
 180         LABEL_FOR,
 181         LABELLED_BY,
 182         MEMBER_OF,
 183         NODE_CHILD_OF,
 184         FLOWS_TO,
 185         FLOWS_FROM,
 186         SUBWINDOW_OF,
 187         EMBEDS,
 188         EMBEDDED_BY,
 189         POPUP_FOR,
 190         PARENT_WINDOW_OF,
 191         DESCRIBED_BY,
 192         DESCRIPTION_FOR,
 193         LAST_DEFINED
 194 }
 195 /**
 196  * The possible types of states of an object
 197  * ATK_STATE_INVALID
 198  */
 199 public enum AtkStateType
 200 {
 201         INVALID,
 202         ACTIVE,
 203         ARMED,
 204         BUSY,
 205         CHECKED,
 206         DEFUNCT,
 207         EDITABLE,
 208         ENABLED,
 209         EXPANDABLE,
 210         EXPANDED,
 211         FOCUSABLE,
 212         FOCUSED,
 213         HORIZONTAL,
 214         ICONIFIED,
 215         MODAL,
 216         MULTI_LINE,
 217         MULTISELECTABLE,
 218         OPAQUE,
 219         PRESSED,
 220         RESIZABLE,
 221         SELECTABLE,
 222         SELECTED,
 223         SENSITIVE,
 224         SHOWING,
 225         SINGLE_LINE,
 226         STALE,
 227         TRANSIENT,
 228         VERTICAL,
 229         VISIBLE,
 230         MANAGES_DESCENDANTS,
 231         INDETERMINATE,
 232         TRUNCATED,
 233         REQUIRED,
 234         INVALID_ENTRY,
 235         SUPPORTS_AUTOCOMPLETION,
 236         SELECTABLE_TEXT,
 237         DEFAULT,
 238         ANIMATED,
 239         VISITED,
 240         LAST_DEFINED
 241 }
 242 /**
 243  * Text boundary types used for specifying boundaries for regions of text
 244  * ATK_TEXT_BOUNDARY_CHAR
 245  */
 246 public enum AtkTextBoundary
 247 {
 248         CHAR,
 249         WORD_START,
 250         WORD_END,
 251         SENTENCE_START,
 252         SENTENCE_END,
 253         LINE_START,
 254         LINE_END
 255 }
 256 /**
 257  * Describes the type of clipping required.
 258  * ATK_TEXT_CLIP_NONE
 259  */
 260 public enum AtkTextClipType
 261 {
 262         NONE,
 263         MIN,
 264         MAX,
 265         BOTH
 266 }
 267 /**
 268  * Describes the text attributes supported
 269  * ATK_TEXT_ATTR_INVALID
 270  */
 271 public enum AtkTextAttribute
 272 {
 273         INVALID = 0,
 274         LEFT_MARGIN,
 275         RIGHT_MARGIN,
 276         INDENT,
 277         INVISIBLE,
 278         EDITABLE,
 279         PIXELS_ABOVE_LINES,
 280         PIXELS_BELOW_LINES,
 281         PIXELS_INSIDE_WRAP,
 282         BG_FULL_HEIGHT,
 283         RISE,
 284         UNDERLINE,
 285         STRIKETHROUGH,
 286         SIZE,
 287         SCALE,
 288         WEIGHT,
 289         LANGUAGE,
 290         FAMILY_NAME,
 291         BG_COLOR,
 292         FG_COLOR,
 293         BG_STIPPLE,
 294         FG_STIPPLE,
 295         WRAP_MODE,
 296         DIRECTION,
 297         JUSTIFICATION,
 298         STRETCH,
 299         VARIANT,
 300         STYLE,
 301         LAST_DEFINED
 302 }
 303 /**
 304  * Specifies how xy coordinates are to be interpreted. Used by functions such
 305  * as atk_component_get_position() and atk_text_get_character_extents()
 306  * ATK_XY_SCREEN
 307  */
 308 public enum AtkCoordType
 309 {
 310         XY_SCREEN,
 311         XY_WINDOW
 312 }
 313 /**
 314  * Specifies the type of a keyboard evemt.
 315  * ATK_KEY_EVENT_PRESS
 316  */
 317 public enum AtkKeyEventType
 318 {
 319         PRESS,
 320         RELEASE,
 321         LAST_DEFINED
 322 }
 323
 324 /**
 325  * Main Gtk struct.
 326  * The AtkAction structure does not contain any fields.
 327  */
 328 public struct AtkAction{}
 329
 330
 331 /**
 332  * Main Gtk struct.
 333  * The AtkComponent structure does not contain any fields.
 334  */
 335 public struct AtkComponent{}
 336
 337
 338 /**
 339  * Main Gtk struct.
 340  * The AtkDocument structure does not contain any fields.
 341  */
 342 public struct AtkDocument{}
 343
 344
 345 /**
 346  * Main Gtk struct.
 347  * The AtkEditableText structure does not contain any fields.
 348  */
 349 public struct AtkEditableText{}
 350
 351
 352 /**
 353  * Main Gtk struct.
 354  * The AtkGObjectAccessible structure should not be accessed directly.
 355  */
 356 public struct AtkGObjectAccessible{}
 357
 358
 359 /**
 360  * Main Gtk struct.
 361  * The AtkHyperlink structure should not be accessed directly.
 362  */
 363 public struct AtkHyperlink{}
 364
 365
 366 /**
 367  * Main Gtk struct.
 368  * The AtkHypertext structure does not contain any fields.
 369  */
 370 public struct AtkHypertext{}
 371
 372
 373 /**
 374  * Main Gtk struct.
 375  * The AtkImage structure does not contain any fields.
 376  */
 377 public struct AtkImage{}
 378
 379
 380 /**
 381  * Main Gtk struct.
 382  * The AtkNoOpObject structure should not be accessed directly.
 383  */
 384 public struct AtkNoOpObject{}
 385
 386
 387 /**
 388  * Main Gtk struct.
 389  * The AtkNoOpObjectFactory structure should not be accessed directly.
 390  */
 391 public struct AtkNoOpObjectFactory{}
 392
 393
 394 /**
 395  * Main Gtk struct.
 396  * The AtkObject structure should not be accessed directly.
 397  */
 398 public struct AtkObject{}
 399
 400
 401 /**
 402  * The AtkImplementor structure does not contain any fields.
 403  */
 404 public struct AtkImplementor{}
 405
 406
 407 /**
 408  * note: For most properties the old_value field of AtkPropertyValues will
 409  * not contain a valid value.
 410  * Currently, the only property for which old_value is used is
 411  * accessible-state; for instance if there is a focus state the
 412  * property change handler will be called for the object which lost the focus
 413  * with the old_value containing an AtkState value corresponding to focused
 414  * and the property change handler will be called for the object which
 415  * received the focus with the new_value containing an AtkState value
 416  * corresponding to focused.
 417  * The Atk PropertyValue structure is used when notifying a change in property.
 418  * Currently, the only property for which old_value is used is
 419  * accessible-state; for instance if there is a focus change the
 420  * property change handler will be called for the object which lost the focus
 421  * with the old_value containing the AtkState value corresponding to focused
 422  * and the property change handler will be called for the object which
 423  * received the focus with the new_value containing the AtkState value
 424  * corresponding to focused.
 425  * constgchar*property_name;
 426  */
 427 public struct AtkPropertyValues{}
 428 // char *propertyName;
 429 // AtkObject.html
 430 // GValue oldValue;
 431 // AtkObject.html
 432 // GValue newValue;
 433 // AtkObject.html
 434
 435
 436 /**
 437  * Main Gtk struct.
 438  * The AtkObjectFactory structure should not be accessed directly.
 439  */
 440 public struct AtkObjectFactory{}
 441
 442
 443 /**
 444  * Main Gtk struct.
 445  * The AtkRegistry structure should not be accessed directly.
 446  */
 447 public struct AtkRegistry{}
 448
 449
 450 /**
 451  * Main Gtk struct.
 452  * The AtkRelation structure should not be accessed directly.
 453  */
 454 public struct AtkRelation{}
 455
 456
 457 /**
 458  * Main Gtk struct.
 459  * The AtkRelationSet structure should not be accessed directly.
 460  */
 461 public struct AtkRelationSet{}
 462
 463
 464 /**
 465  * Main Gtk struct.
 466  * The AtkAction structure does not contain any fields.
 467  */
 468 public struct AtkSelection{}
 469
 470
 471 /**
 472  * Main Gtk struct.
 473  * The AtkStreamableContent structure does not contain any fields.
 474  */
 475 public struct AtkStreamableContent{}
 476
 477
 478 /**
 479  * Main Gtk struct.
 480  * The AtkTable structure does not contain any fields.
 481  */
 482 public struct AtkTable{}
 483
 484
 485 /**
 486  * Main Gtk struct.
 487  * The AtkText structure does not contain any fields.
 488  */
 489 public struct AtkText{}
 490
 491
 492 /**
 493  * A structure used to describe a text range.
 494  * AtkTextRectanglebounds;
 495  */
 496 public struct AtkTextRange{}
 497 // AtkTextRectangle bounds;
 498 // AtkText.html
 499 // int startOffset;
 500 // AtkText.html
 501 // int endOffset;
 502 // AtkText.html
 503 // char* content;
 504 // AtkText.html
 505
 506
 507 /**
 508  * A structure used to store a rectangle used by AtkText.
 509  * gintx;
 510  */
 511 public struct AtkTextRectangle
 512 {
 513         int x;
 514         int y;
 515         int width;
 516         int height;
 517 }
 518
 519
 520 /**
 521  * A string name/value pair representing a text attribute.
 522  * gchar*name;
 523  */
 524 public struct AtkAttribute
 525 {
 526         char* name;
 527         char* value;
 528 }
 529
 530
 531 /**
 532  * The AtkUtil struct does not contain any fields.
 533  */
 534 public struct AtkUtil{}
 535
 536
 537 /**
 538  * Encapsulates information about a key event.
 539  * ginttype;
 540  */
 541 public struct AtkKeyEventStruct
 542 {
 543         int type;
 544         uint state;
 545         uint keyval;
 546         int length;
 547         char *string;
 548         ushort keycode;
 549         uint timestamp;
 550 }
 551
 552
 553 /**
 554  * Main Gtk struct.
 555  * The AtkValue structure does not contain any fields.
 556  */
 557 public struct AtkValue{}
 558
 559
 560 /*
 561  * An AtkFunction is a function definition used for padding which has been added
 562  * to class and interface structures to allow for expansion in the future.
 563  * data:
 564  * a gpointer to parameter data.
 565  * Returns:
 566  * Nothing useful, this is only a dummy prototype.
 567  */
 568 // gboolean (*AtkFunction) (gpointer data);
 569 public typedef extern(C) int  function (void*) AtkFunction;
 570
 571 /*
 572  * An AtkPropertyChangeHandler is a function which is executed when an AtkObject's property changes value. It is specified in a call to
 573  * atk_object_connect_property_change_handler().
 574  * Param1:
 575  *  an AtkObject
 576  * Param2:
 577  *  an AtkPropertyValues
 578  */
 579 // void (*AtkPropertyChangeHandler) (AtkObject *,  AtkPropertyValues *);
 580 public typedef extern(C) void  function (AtkObject*, AtkPropertyValues*) AtkPropertyChangeHandler;
 581
 582 /*
 583  * A function which is called when an object emits a matching event,
 584  * as used in atk_add_focus_tracker.
 585  * Currently the only events for which object-specific handlers are
 586  * supported are events of type "focus:". Most clients of ATK will prefer to
 587  * attach signal handlers for the various ATK signals instead.
 588  * see: atk_add_focus_tracker.
 589  * obj:
 590  *  An AtkObject instance for whom the callback will be called when
 591  * the specified event (e.g. 'focus:') takes place.
 592  */
 593 // void (*AtkEventListener) (AtkObject *obj);
 594 public typedef extern(C) void  function (AtkObject*) AtkEventListener;
 595
 596 /*
 597  * An AtkEventListenerInit function is a special function that is
 598  * called in order to initialize the per-object event registration system
 599  * used by AtkEventListener, if any preparation is required.
 600  * see: atk_focus_tracker_init.
 601  */
 602 // void (*AtkEventListenerInit) (void);
 603 public typedef extern(C) void  function () AtkEventListenerInit;
 604
 605 /*
 606  * An AtkKeySnoopFunc is a type of callback which is called whenever a key event occurs,
 607  * if registered via atk_add_key_event_listener. It allows for pre-emptive
 608  * interception of key events via the return code as described below.
 609  * event:
 610  *  an AtkKeyEventStruct containing information about the key event for which
 611  * notification is being given.
 612  * func_data:
 613  *  a block of data which will be passed to the event listener, on notification.
 614  * Returns:
 615  *  TRUE (nonzero) if the event emission should be stopped and the event
 616  * discarded without being passed to the normal GUI recipient; FALSE (zero) if the
 617  * event dispatch to the client application should proceed as normal.
 618  * see: atk_add_key_event_listener.
 619  */
 620 // gint (*AtkKeySnoopFunc) (AtkKeyEventStruct *event,  gpointer func_data);
 621 public typedef extern(C) int  function (AtkKeyEventStruct*, void*) AtkKeySnoopFunc;