src/gtk/gtktypes.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit 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  * duit 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 duit; 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 gtk.gtktypes;
  24
  25 public import glib.glibtypes;
  26 public import gobject.gobjecttypes;
  27 public import pango.pangotypes;
  28 public import atk.atktypes;
  29 public import gdkpixbuf.gdkpixbuftypes;
  30 public import gdk.gdktypes;
  31 alias void GtkAccelGroupEntry;
  32 alias void GtkContainerClass;
  33
  34 //alias GTokenType.G_TOKEN_LAST G_TOKEN_LAST;";
  35 //alias GtkSignalRunType.G_SIGNAL_RUN_FIRST G_SIGNAL_RUN_FIRST;
  36 //alias GtkSignalRunType.G_SIGNAL_RUN_LAST G_SIGNAL_RUN_LAST;
  37 //alias GtkSignalRunType.G_SIGNAL_NO_RECURSE G_SIGNAL_NO_RECURSE;
  38 //alias GtkSignalRunType.G_SIGNAL_ACTION G_SIGNAL_ACTION;
  39 //alias GtkSignalRunType.G_SIGNAL_NO_HOOKS G_SIGNAL_NO_HOOKS;
  40
  41
  42 /**
  43  * typedef GType                        GtkType;
  44  * GtkType is unique integer identifying the type. The guts of the
  45  * information about the type is held in a private struct named
  46  * GtkTypeNode.
  47  */
  48 public alias GType GtkType;
  49
  50 /**
  51  * typedef GType GtkFundamentalType;
  52  * Warning
  53  * GtkFundamentalType is deprecated and should not be used in newly-written code.
  54  * GtkFundamentalType is an enumerated type which lists all the possible
  55  * fundamental types (e.g. char, uchar, int,
  56  * long, float, etc).
  57  */
  58 public alias GType GtkFundamentalType;
  59
  60 /**
  61  * typedef GBaseInitFunc                GtkClassInitFunc;
  62  * Warning
  63  * GtkClassInitFunc is deprecated and should not be used in newly-written code.
  64  * Defines a function pointer.
  65  */
  66 public alias GBaseInitFunc GtkClassInitFunc;
  67
  68 /**
  69  * typedef GInstanceInitFunc    GtkObjectInitFunc;
  70  * Warning
  71  * GtkObjectInitFunc is deprecated and should not be used in newly-written code.
  72  * Defines a function pointer.
  73  */
  74 public alias GInstanceInitFunc GtkObjectInitFunc;
  75
  76 /**
  77  * typedef GSignalCMarshaller GtkSignalMarshaller;
  78  * Warning
  79  * GtkSignalMarshaller is deprecated and should not be used in newly-written code.
  80  * Defines a function pointer.
  81  */
  82 public alias GSignalCMarshaller GtkSignalMarshaller;
  83
  84 /**
  85  * typedef GTypeInstance                GtkTypeObject;
  86  * Warning
  87  * GtkTypeObject is deprecated and should not be used in newly-written code.
  88  * A GtkTypeObject defines the minimum structure requirements
  89  * for type instances. Type instances returned from gtk_type_new()
  90  * and initialized through a GtkObjectInitFunc need to directly inherit
  91  * from this structure or at least copy its fields one by one.
  92  */
  93 public alias GTypeInstance GtkTypeObject;
  94
  95 /**
  96  * typedef GTypeClass           GtkTypeClass;
  97  * Warning
  98  * GtkTypeClass is deprecated and should not be used in newly-written code.
  99  * The base structure for a GTK+ type. Every type inherits this as a base structure.
 100  */
 101 public alias GTypeClass GtkTypeClass;
 102
 103 /**
 104  * typedef GEnumValue GtkEnumValue;
 105  * Warning
 106  * GtkEnumValue is deprecated and should not be used in newly-written code.
 107  * A structure which contains a single enum value, and its name, and its
 108  * nickname.
 109  */
 110 public alias GEnumValue GtkEnumValue;
 111
 112 /**
 113  * typedef GFlagsValue GtkFlagValue;
 114  * Warning
 115  * GtkFlagValue is deprecated and should not be used in newly-written code.
 116  */
 117 public alias GFlagsValue GtkFlagValue;
 118 /**
 119  * The GtkDestDefaults enumeration specifies the various
 120  * types of action that will be taken on behalf
 121  * of the user for a drag destination site.
 122  * GTK_DEST_DEFAULT_MOTION
 123  */
 124 public enum GtkDestDefaults
 125 {
 126         MOTION = 1 << 0, /+* respond to "dragMotion" +/
 127         HIGHLIGHT = 1 << 1, /+* auto-highlight +/
 128         DROP = 1 << 2, /+* respond to "dragDrop" +/
 129         ALL = 0x07
 130 }
 131 alias GtkDestDefaults DestDefaults;
 132
 133 /**
 134  * The GtkTargetFlags enumeration is used to specify
 135  * constraints on an entry in a GtkTargetTable.
 136  * GTK_TARGET_SAME_APP
 137  */
 138 public enum GtkTargetFlags
 139 {
 140         SAME_APP = 1 << 0, /+*< nick=same-app >+/
 141         SAME_WIDGET = 1 << 1 /+*< nick=same-widget >+/
 142 }
 143 alias GtkTargetFlags TargetFlags;
 144
 145 /**
 146  * Used to specify options for gtk_icon_theme_lookup_icon()
 147  * GTK_ICON_LOOKUP_NO_SVG
 148  */
 149 public enum GtkIconLookupFlags
 150 {
 151         NO_SVG = 1 << 0,
 152         FORCE_SVG = 1 << 1,
 153         USE_BUILTIN = 1 << 2
 154 }
 155 alias GtkIconLookupFlags IconLookupFlags;
 156
 157 /**
 158  * Error codes for GtkIconTheme operations.
 159  * GTK_ICON_THEME_NOT_FOUND
 160  */
 161 public enum GtkIconThemeError
 162 {
 163         NOT_FOUND,
 164         FAILED
 165 }
 166 alias GtkIconThemeError IconThemeError;
 167
 168 public enum GtkIconSize
 169 {
 170         INVALID,
 171         MENU,
 172         SMALL_TOOLBAR,
 173         LARGE_TOOLBAR,
 174         BUTTON,
 175         DND,
 176         DIALOG
 177 }
 178 alias GtkIconSize IconSize;
 179
 180 /**
 181  * The GtkRcFlags enumeration is used as a bitmask
 182  * to specify which fields of a GtkRcStyle have been
 183  * set for each state.
 184  * GTK_RC_FG
 185  * If present, the foreground color has been set for this state.
 186  * GTK_RC_BG
 187  * If present, the background color has been set for this state.
 188  * GTK_RC_TEXT
 189  * If present, the text color has been set for this state.
 190  * GTK_RC_BASE
 191  * If present, the base color has been set for this state.
 192  */
 193 public enum GtkRcFlags
 194 {
 195         FG = 1 << 0,
 196         BG = 1 << 1,
 197         TEXT = 1 << 2,
 198         BASE = 1 << 3
 199 }
 200 alias GtkRcFlags RcFlags;
 201
 202 /**
 203  * The GtkRcTokenType enumeration represents the tokens
 204  * in the RC file. It is exposed so that theme engines
 205  * can reuse these tokens when parsing the theme-engine
 206  * specific portions of a RC file.
 207  */
 208 public enum GtkRcTokenType
 209 {
 210         INVALID = TokenType.LAST,
 211         INCLUDE,
 212         NORMAL,
 213         ACTIVE,
 214         PRELIGHT,
 215         SELECTED,
 216         INSENSITIVE,
 217         FG,
 218         BG,
 219         TEXT,
 220         BASE,
 221         XTHICKNESS,
 222         YTHICKNESS,
 223         FONT,
 224         FONTSET,
 225         FONT_NAME,
 226         BG_PIXMAP,
 227         PIXMAP_PATH,
 228         STYLE,
 229         BINDING,
 230         BIND,
 231         WIDGET,
 232         WIDGET_CLASS,
 233         CLASS,
 234         LOWEST,
 235         GTK,
 236         APPLICATION,
 237         THEME,
 238         RC,
 239         HIGHEST,
 240         ENGINE,
 241         MODULE_PATH,
 242         IM_MODULE_PATH,
 243         IM_MODULE_FILE,
 244         STOCK,
 245         LTR,
 246         RTL,
 247         COLOR,
 248         UNBIND,
 249         LAST
 250 }
 251 alias GtkRcTokenType RcTokenType;
 252
 253 public enum GtkAccelFlags
 254 {
 255         VISIBLE = 1 << 0, /+* display inn GtkAccelLabel? +/
 256         LOCKED = 1 << 1, /+* is it removable? +/
 257         MASK = 0x07
 258 }
 259 alias GtkAccelFlags AccelFlags;
 260
 261 public enum GtkAnchorType
 262 {
 263         CENTER,
 264         NORTH,
 265         NORTH_WEST,
 266         NORTH_EAST,
 267         SOUTH,
 268         SOUTH_WEST,
 269         SOUTH_EAST,
 270         WEST,
 271         EAST,
 272         N = NORTH,
 273         NW = NORTH_WEST,
 274         NE = NORTH_EAST,
 275         S = SOUTH,
 276         SW = SOUTH_WEST,
 277         SE = SOUTH_EAST,
 278         W = WEST,
 279         E = EAST
 280 }
 281 alias GtkAnchorType AnchorType;
 282
 283 /**
 284  * Used to indicate the direction in which a GtkArrow should point.
 285  * GTK_ARROW_UP
 286  * Represents an upward pointing arrow.
 287  * GTK_ARROW_DOWN
 288  * Represents a downward pointing arrow.
 289  * GTK_ARROW_LEFT
 290  * Represents a left pointing arrow.
 291  * GTK_ARROW_RIGHT
 292  * Represents a right pointing arrow.
 293  * GTK_ARROW_NONE
 294  * No arrow. Since 2.10.
 295  */
 296 public enum GtkArrowType
 297 {
 298         UP,
 299         DOWN,
 300         LEFT,
 301         RIGHT,
 302         NONE
 303 }
 304 alias GtkArrowType ArrowType;
 305
 306 /**
 307  * Denotes the expansion properties that a widget will have when it (or its
 308  * parent) is resized.
 309  * GTK_EXPAND
 310  * the widget should expand to take up any extra space in its
 311  * container that has been allocated.
 312  * GTK_SHRINK
 313  * the widget should shrink as and when possible.
 314  * GTK_FILL
 315  * the widget should fill the space allocated to it.
 316  */
 317 public enum GtkAttachOptions
 318 {
 319         EXPAND = 1 << 0,
 320         SHRINK = 1 << 1,
 321         FILL = 1 << 2
 322 }
 323 alias GtkAttachOptions AttachOptions;
 324
 325 /**
 326  * Used to dictate the style that a GtkButtonBox uses to layout the buttons it
 327  * contains. (See also: GtkVButtonBox and GtkHButtonBox).
 328  * GTK_BUTTONBOX_DEFAULT_STYLE
 329  * Default packing.
 330  * GTK_BUTTONBOX_SPREAD
 331  * Buttons are evenly spread across the ButtonBox.
 332  * GTK_BUTTONBOX_EDGE
 333  * Buttons are placed at the edges of the ButtonBox.
 334  * GTK_BUTTONBOX_START
 335  * Buttons are grouped towards the start of box, (on the
 336  * left for a HBox, or the top for a VBox).
 337  * GTK_BUTTONBOX_END
 338  * Buttons are grouped towards the end of a box, (on the
 339  * right for a HBox, or the bottom for a VBox).
 340  */
 341 public enum GtkButtonBoxStyle
 342 {
 343         DEFAULT_STYLE,
 344         SPREAD,
 345         EDGE,
 346         START,
 347         END
 348 }
 349 alias GtkButtonBoxStyle ButtonBoxStyle;
 350
 351 /**
 352  * Specifies which corner a child widget should be placed in when packed into
 353  * a GtkScrolledWindow. This is effectively the opposite of where the scroll
 354  * bars are placed.
 355  * GTK_CORNER_TOP_LEFT
 356  * Place the scrollbars on the right and bottom of the
 357  * widget (default behaviour).
 358  * GTK_CORNER_BOTTOM_LEFT
 359  * Place the scrollbars on the top and right of the
 360  * widget.
 361  * GTK_CORNER_TOP_RIGHT
 362  * Place the scrollbars on the left and bottom of the
 363  * widget.
 364  * GTK_CORNER_BOTTOM_RIGHT
 365  * Place the scrollbars on the top and left of the
 366  * widget.
 367  */
 368 public enum GtkCornerType
 369 {
 370         TOP_LEFT,
 371         BOTTOM_LEFT,
 372         TOP_RIGHT,
 373         BOTTOM_RIGHT
 374 }
 375 alias GtkCornerType CornerType;
 376
 377 public enum GtkCurveType
 378 {
 379         TYPE_LINEAR, /+* linear interpolation +/
 380         TYPE_SPLINE, /+* spline interpolation +/
 381         TYPE_FREE /+* free form curve +/
 382 }
 383 alias GtkCurveType CurveType;
 384
 385 public enum GtkDeleteType
 386 {
 387         CHARS,
 388         WORD_ENDS, /+* delet only the portion of the word to the
 389          * left/right of cursor if we're inn the middle
 390          * of a word +/
 391         WORDS,
 392         DISPLAY_LINES,
 393         DISPLAY_LINE_ENDS,
 394         PARAGRAPH_ENDS, /+* like C-k inn Emacs (or its reverse) +/
 395         PARAGRAPHS, /+* C-k inn pico, kill whole line +/
 396         WHITESPACE /+* M-\ inn Emacs +/
 397 }
 398 alias GtkDeleteType DeleteType;
 399
 400 public enum GtkDirectionType
 401 {
 402         TAB_FORWARD,
 403         TAB_BACKWARD,
 404         UP,
 405         DOWN,
 406         LEFT,
 407         RIGHT
 408 }
 409 alias GtkDirectionType DirectionType;
 410
 411 /**
 412  * Used to specify the style of the expanders drawn by a GtkTreeView.
 413  * GTK_EXPANDER_COLLAPSED
 414  * The style used for a collapsed subtree.
 415  * GTK_EXPANDER_SEMI_COLLAPSED
 416  * Intermediate style used during animation.
 417  * GTK_EXPANDER_SEMI_EXPANDED
 418  * Intermediate style used during animation.
 419  * GTK_EXPANDER_EXPANDED
 420  * The style used for an expanded subtree.
 421  */
 422 public enum GtkExpanderStyle
 423 {
 424         COLLAPSED,
 425         SEMI_COLLAPSED,
 426         SEMI_EXPANDED,
 427         EXPANDED
 428 }
 429 alias GtkExpanderStyle ExpanderStyle;
 430
 431 public enum GtkIMPreeditStyle
 432 {
 433         NOTHING,
 434         CALLBACK,
 435         NONE
 436 }
 437 alias GtkIMPreeditStyle IMPreeditStyle;
 438
 439 public enum GtkIMStatusStyle
 440 {
 441         NOTHING,
 442         CALLBACK,
 443         NONE
 444 }
 445 alias GtkIMStatusStyle IMStatusStyle;
 446
 447 /**
 448  * Used for justifying the text inside a GtkLabel widget. (See also
 449  * GtkAlignment).
 450  * GTK_JUSTIFY_LEFT
 451  * The text is placed at the left edge of the label.
 452  * GTK_JUSTIFY_RIGHT
 453  * The text is placed at the right edge of the label.
 454  * GTK_JUSTIFY_CENTER
 455  * The text is placed in the center of the label.
 456  * GTK_JUSTIFY_FILL
 457  * The text is placed is distributed across the label.
 458  */
 459 public enum GtkJustification
 460 {
 461         JUSTIFY_LEFT,
 462         JUSTIFY_RIGHT,
 463         JUSTIFY_CENTER,
 464         JUSTIFY_FILL
 465 }
 466 alias GtkJustification Justification;
 467
 468 /**
 469  * Warning
 470  * GtkMatchType is deprecated and should not be used in newly-written code.
 471  */
 472 public enum GtkMatchType
 473 {
 474         ALL, /+* "*A?A*" +/
 475         ALL_TAIL, /+* "*A?AA" +/
 476         HEAD, /+* "AAAA*" +/
 477         TAIL, /+* "*AAAA" +/
 478         EXACT, /+* "AAAAA" +/
 479         LAST
 480 }
 481 alias GtkMatchType MatchType;
 482
 483 /**
 484  * Used to indicate which metric is used by a GtkRuler.
 485  * GTK_PIXELS
 486  * Pixels.
 487  * GTK_INCHES
 488  * Inches.
 489  * GTK_CENTIMETERS
 490  * Centimeters.
 491  */
 492 public enum GtkMetricType
 493 {
 494         PIXELS,
 495         INCHES,
 496         CENTIMETERS
 497 }
 498 alias GtkMetricType MetricType;
 499
 500 public enum GtkMovementStep
 501 {
 502         LOGICAL_POSITIONS, /+* move by forw/back graphemes +/
 503         VISUAL_POSITIONS, /+* move by left/right graphemes +/
 504         WORDS, /+* move by forward/back words +/
 505         DISPLAY_LINES, /+* move up/down lines (wrapped lines) +/
 506         DISPLAY_LINE_ENDS, /+* move up/down lines (wrapped lines) +/
 507         PARAGRAPHS, /+* move up/down paragraphs (newline-ended lines) +/
 508         PARAGRAPH_ENDS, /+* move to either end of a paragraph +/
 509         PAGES, /+* move by pages +/
 510         BUFFER_ENDS, /+* move to ends of the buffer +/
 511         HORIZONTAL_PAGES /+* move horizontally by pages +/
 512 }
 513 alias GtkMovementStep MovementStep;
 514
 515 /**
 516  * Represents the orientation of widgets which can be switched between horizontal
 517  * and vertical orientation on the fly, like GtkToolbar.
 518  * GTK_ORIENTATION_HORIZONTAL
 519  * The widget is in horizontal orientation.
 520  * GTK_ORIENTATION_VERTICAL
 521  * The widget is in vertical orientation.
 522  */
 523 public enum GtkOrientation
 524 {
 525         HORIZONTAL,
 526         VERTICAL
 527 }
 528 alias GtkOrientation Orientation;
 529
 530 /**
 531  * Represents the packing location GtkBox children. (See: GtkVBox,
 532  * GtkHBox, and GtkButtonBox).
 533  * GTK_PACK_START
 534  * The child is packed into the start of the box
 535  * GTK_PACK_END
 536  * The child is packed into the end of the box
 537  */
 538 public enum GtkPackType
 539 {
 540         START,
 541         END
 542 }
 543 alias GtkPackType PackType;
 544
 545 public enum GtkPathPriorityType
 546 {
 547         LOWEST = 0,
 548         GTK = 4,
 549         APPLICATION = 8,
 550         THEME = 10,
 551         RC = 12,
 552         HIGHEST = 15
 553 }
 554 alias GtkPathPriorityType PathPriorityType;
 555
 556 public enum GtkPathType
 557 {
 558         WIDGET,
 559         WIDGET_CLASS,
 560         CLASS
 561 }
 562 alias GtkPathType PathType;
 563
 564 /**
 565  * Determines when a scroll bar will be visible.
 566  * GTK_POLICY_ALWAYS
 567  * The scrollbar is always visible.
 568  * GTK_POLICY_AUTOMATIC
 569  * The scrollbar will appear and disappear as necessary. For example,
 570  * when all of a GtkCList can not be seen.
 571  * GTK_POLICY_NEVER
 572  * The scrollbar will never appear.
 573  */
 574 public enum GtkPolicyType
 575 {
 576         ALWAYS,
 577         AUTOMATIC,
 578         NEVER
 579 }
 580 alias GtkPolicyType PolicyType;
 581
 582 /**
 583  * Describes which edge of a widget a certain feature is positioned at, e.g. the
 584  * tabs of a GtkNotebook, the handle of a GtkHandleBox or the label of a
 585  * GtkScale.
 586  * GTK_POS_LEFT
 587  * The feature is at the left edge.
 588  * GTK_POS_RIGHT
 589  * The feature is at the right edge.
 590  * GTK_POS_TOP
 591  * The feature is at the top edge.
 592  * GTK_POS_BOTTOM
 593  * The feature is at the bottom edge.
 594  */
 595 public enum GtkPositionType
 596 {
 597         LEFT,
 598         RIGHT,
 599         TOP,
 600         BOTTOM
 601 }
 602 alias GtkPositionType PositionType;
 603
 604 /**
 605  * Warning
 606  * GtkPreviewType is deprecated and should not be used in newly-written code.
 607  * An enumeration which describes whether a preview
 608  * contains grayscale or red-green-blue data.
 609  * GTK_PREVIEW_COLOR
 610  * the preview contains red-green-blue data.
 611  * GTK_PREVIEW_GRAYSCALE
 612  * The preview contains grayscale data.
 613  */
 614 public enum GtkPreviewType
 615 {
 616         COLOR,
 617         GRAYSCALE
 618 }
 619 alias GtkPreviewType PreviewType;
 620
 621 /**
 622  * Indicated the relief to be drawn around a GtkButton.
 623  * GTK_RELIEF_NORMAL
 624  * Draw a normal relief.
 625  * GTK_RELIEF_HALF
 626  * A half relief.
 627  * GTK_RELIEF_NONE
 628  * No relief.
 629  */
 630 public enum GtkReliefStyle
 631 {
 632         NORMAL,
 633         HALF,
 634         NONE
 635 }
 636 alias GtkReliefStyle ReliefStyle;
 637
 638 /**
 639  * GTK_RESIZE_PARENT
 640  * GTK_RESIZE_QUEUE
 641  * GTK_RESIZE_IMMEDIATE
 642  * Deprecated.
 643  */
 644 public enum GtkResizeMode
 645 {
 646         PARENT, /+* Pass resize request to the parent +/
 647         QUEUE, /+* Queue resizes on this widget +/
 648         IMMEDIATE /+* Perform the resizes now +/
 649 }
 650 alias GtkResizeMode ResizeMode;
 651
 652 public enum GtkScrollStep
 653 {
 654         STEPS,
 655         PAGES,
 656         ENDS,
 657         HORIZONTAL_STEPS,
 658         HORIZONTAL_PAGES,
 659         HORIZONTAL_ENDS
 660 }
 661 alias GtkScrollStep ScrollStep;
 662
 663 public enum GtkScrollType
 664 {
 665         NONE,
 666         JUMP,
 667         STEP_BACKWARD,
 668         STEP_FORWARD,
 669         PAGE_BACKWARD,
 670         PAGE_FORWARD,
 671         STEP_UP,
 672         STEP_DOWN,
 673         PAGE_UP,
 674         PAGE_DOWN,
 675         STEP_LEFT,
 676         STEP_RIGHT,
 677         PAGE_LEFT,
 678         PAGE_RIGHT,
 679         START,
 680         END
 681 }
 682 alias GtkScrollType ScrollType;
 683
 684 /**
 685  * Used to control what selections users are allowed to make.
 686  * GTK_SELECTION_NONE
 687  * No selection is possible.
 688  * GTK_SELECTION_SINGLE
 689  * Zero or one element may be selected.
 690  * GTK_SELECTION_BROWSE
 691  * Exactly one element is selected. In some circumstances,
 692  */
 693 public enum GtkSelectionMode
 694 {
 695         NONE, /+* Nothing can be selected +/
 696         SINGLE,
 697         BROWSE,
 698         MULTIPLE,
 699         EXTENDED = MULTIPLE /+* Deprecated +/
 700 }
 701 alias GtkSelectionMode SelectionMode;
 702
 703 /**
 704  * Used to change the appearance of an outline typically provided by a GtkFrame.
 705  * GTK_SHADOW_NONE
 706  * No outline.
 707  * GTK_SHADOW_IN
 708  * The outline is bevelled inwards.
 709  * GTK_SHADOW_OUT
 710  * The outline is bevelled outwards like a button.
 711  * GTK_SHADOW_ETCHED_IN
 712  * The outline has a sunken 3d appearance.
 713  * GTK_SHADOW_ETCHED_OUT
 714  * The outline has a raised 3d appearance
 715  */
 716 public enum GtkShadowType
 717 {
 718         NONE,
 719         IN,
 720         OUT,
 721         ETCHED_IN,
 722         ETCHED_OUT
 723 }
 724 alias GtkShadowType ShadowType;
 725
 726 /**
 727  * Warning
 728  * GtkSideType is deprecated and should not be used in newly-written code.
 729  */
 730 public enum GtkSideType
 731 {
 732         TOP,
 733         BOTTOM,
 734         LEFT,
 735         RIGHT
 736 }
 737 alias GtkSideType SideType;
 738
 739 /**
 740  * This type indicates the current state of a widget; the state determines how
 741  * the widget is drawn. The GtkStateType enumeration is also used to
 742  * identify different colors in a GtkStyle for drawing, so states can be
 743  * used for subparts of a widget as well as entire widgets.
 744  * GTK_STATE_NORMAL
 745  * State during normal operation.
 746  * GTK_STATE_ACTIVE
 747  * State of a currently active widget, such as a depressed button.
 748  * GTK_STATE_PRELIGHT
 749  * State indicating that the mouse pointer is over
 750  * the widget and the widget will respond to mouse clicks.
 751  * GTK_STATE_SELECTED
 752  * State of a selected item, such the selected row in a list.
 753  * GTK_STATE_INSENSITIVE
 754  * State indicating that the widget is
 755  * unresponsive to user actions.
 756  */
 757 public enum GtkStateType
 758 {
 759         NORMAL,
 760         ACTIVE,
 761         PRELIGHT,
 762         SELECTED,
 763         INSENSITIVE
 764 }
 765 alias GtkStateType StateType;
 766
 767 /**
 768  * Warning
 769  * GtkSubmenuDirection is deprecated and should not be used in newly-written code.
 770  * Indicates the direction a sub-menu will appear.
 771  * GTK_DIRECTION_LEFT
 772  * A sub-menu will appear
 773  * GTK_DIRECTION_RIGHT
 774  */
 775 public enum GtkSubmenuDirection
 776 {
 777         DIRECTION_LEFT,
 778         DIRECTION_RIGHT
 779 }
 780 alias GtkSubmenuDirection SubmenuDirection;
 781
 782 /**
 783  * Warning
 784  * GtkSubmenuPlacement is deprecated and should not be used in newly-written code.
 785  */
 786 public enum GtkSubmenuPlacement
 787 {
 788         TOP_BOTTOM,
 789         LEFT_RIGHT
 790 }
 791 alias GtkSubmenuPlacement SubmenuPlacement;
 792
 793 /**
 794  * Used to customize the appearance of a GtkToolbar. Note that
 795  * setting the toolbar style overrides the user's preferences
 796  * for the default toolbar style. Note that if the button has only
 797  * a label set and GTK_TOOLBAR_ICONS is used, the label will be
 798  * visible, and vice versa.
 799  * GTK_TOOLBAR_ICONS
 800  * Buttons display only icons in the toolbar.
 801  * GTK_TOOLBAR_TEXT
 802  * Buttons display only text labels in the toolbar.
 803  * GTK_TOOLBAR_BOTH
 804  * Buttons display text and icons in the toolbar.
 805  * GTK_TOOLBAR_BOTH_HORIZ
 806  * Buttons display icons and text alongside each
 807  * other, rather than vertically stacked
 808  */
 809 public enum GtkToolbarStyle
 810 {
 811         ICONS,
 812         TEXT,
 813         BOTH,
 814         BOTH_HORIZ
 815 }
 816 alias GtkToolbarStyle ToolbarStyle;
 817
 818 public enum GtkUpdateType
 819 {
 820         CONTINUOUS,
 821         DISCONTINUOUS,
 822         DELAYED
 823 }
 824 alias GtkUpdateType UpdateType;
 825
 826 /**
 827  * Used by GtkCList and GtkCTree to indicate whether a row is visible.
 828  * GTK_VISIBILITY_NONE
 829  * The row is not visible.
 830  * GTK_VISIBILITY_PARTIAL
 831  * The row is partially visible.
 832  * GTK_VISIBILITY_FULL
 833  * The row is fully visible.
 834  */
 835 public enum GtkVisibility
 836 {
 837         NONE,
 838         PARTIAL,
 839         FULL
 840 }
 841 alias GtkVisibility Visibility;
 842
 843 /**
 844  * Window placement can be influenced using this enumeration.
 845  * GTK_WIN_POS_NONE
 846  * No influence is made on placement.
 847  * GTK_WIN_POS_CENTER
 848  * Windows should be placed in the center of the screen.
 849  * GTK_WIN_POS_MOUSE
 850  * Windows should be placed at the current mouse position.
 851  * GTK_WIN_POS_CENTER_ALWAYS
 852  * Keep window centered as it changes size, etc.
 853  * GTK_WIN_POS_CENTER_ON_PARENT
 854  * Center the window on its transient
 855  * parent (see gtk_window_set_transient_for()).
 856  */
 857 public enum GtkWindowPosition
 858 {
 859         POS_NONE,
 860         POS_CENTER,
 861         POS_MOUSE,
 862         POS_CENTER_ALWAYS,
 863         POS_CENTER_ON_PARENT
 864 }
 865 alias GtkWindowPosition WindowPosition;
 866
 867 /**
 868  * A GtkWindow can be one of these types. Most things you'd consider a
 869  * "window" should have type GTK_WINDOW_TOPLEVEL; windows with this type
 870  * are managed by the window manager and have a frame by default (call
 871  * gtk_window_set_decorated() to toggle the frame). Windows with type
 872  * GTK_WINDOW_POPUP are ignored by the window manager; window manager
 873  * keybindings won't work on them, the window manager won't decorate the
 874  * window with a frame, many GTK+ features that rely on the window
 875  * manager will not work (e.g. resize grips and
 876  * maximization/minimization). GTK_WINDOW_POPUP is used to implement
 877  * widgets such as GtkMenu or tooltips that you normally don't think of
 878  * as windows per se. Nearly all windows should be GTK_WINDOW_TOPLEVEL.
 879  * In particular, do not use GTK_WINDOW_POPUP just to turn off
 880  * the window borders; use gtk_window_set_decorated() for that.
 881  * GTK_WINDOW_TOPLEVEL
 882  * A regular window, such as a dialog.
 883  * GTK_WINDOW_POPUP
 884  * A special window such as a tooltip.
 885  */
 886 public enum GtkWindowType
 887 {
 888         TOPLEVEL,
 889         POPUP
 890 }
 891 alias GtkWindowType WindowType;
 892
 893 /**
 894  * Determines the direction of a sort.
 895  * GTK_SORT_ASCENDING
 896  * Sorting is in ascending order.
 897  * GTK_SORT_DESCENDING
 898  * Sorting is in descending order.
 899  */
 900 public enum GtkSortType
 901 {
 902         ASCENDING,
 903         DESCENDING
 904 }
 905 alias GtkSortType SortType;
 906
 907 /**
 908  * Warning
 909  * GtkSignalRunType is deprecated and should not be used in newly-written code.
 910  * These configure the signal's emission. They control
 911  * whether the signal can be emitted recursively on an object
 912  * and
 913  * whether to run the default method before or after the user-defined handlers.
 914  * GTK_RUN_FIRST
 915  * Run the default handler before the connected user-defined
 916  * handlers.
 917  * GTK_RUN_LAST
 918  * Run the default handler after the connected
 919  * user-defined handlers.
 920  * (Handlers registered as "after" always run after the default handler though)
 921  * GTK_RUN_BOTH
 922  * Run the default handler twice,
 923  * once before the user-defined handlers,
 924  * and
 925  * once after.
 926  * GTK_RUN_NO_RECURSE
 927  * Whether to prevent a handler or hook
 928  * from reemitting the signal from within itself.
 929  * Attempts to
 930  * emit the signal while it is running will result in the signal
 931  * emission being restarted once it is done with the current processing.
 932  * You must be
 933  * careful to avoid having two handlers endlessly reemitting signals,
 934  * gtk_signal_n_emissions() can be helpful.
 935  * GTK_RUN_ACTION
 936  * The signal is an action you can
 937  * invoke without any particular setup or cleanup.
 938  * The signal is treated no differently, but some
 939  * other code can determine if the signal is appropriate to
 940  * delegate to user control. For example, key binding sets
 941  * only allow bindings of ACTION signals to keystrokes.
 942  * GTK_RUN_NO_HOOKS
 943  * This prevents the connection of emission hooks
 944  * to the signal.
 945  */
 946 public enum GtkSignalRunType
 947 {
 948         RUN_FIRST = SignalFlags.RUN_FIRST,
 949         RUN_LAST = SignalFlags.RUN_LAST,
 950         RUN_BOTH = (RUN_FIRST | RUN_LAST),
 951         RUN_NO_RECURSE = SignalFlags.NO_RECURSE,
 952         RUN_ACTION = SignalFlags.ACTION,
 953         RUN_NO_HOOKS = SignalFlags.NO_HOOKS
 954 }
 955 alias GtkSignalRunType SignalRunType;
 956
 957 /**
 958  * Flags used to influence dialog construction.
 959  * GTK_DIALOG_MODAL
 960  * Make the constructed dialog modal,
 961  */
 962 public enum GtkDialogFlags
 963 {
 964         MODAL = 1 << 0, /+* call windowSetModal (win, TRUE) +/
 965         DESTROY_WITH_PARENT = 1 << 1, /+* call windowSetDestroyWithParent () +/
 966         NO_SEPARATOR = 1 << 2 /+* no separator bar above buttons +/
 967 }
 968 alias GtkDialogFlags DialogFlags;
 969
 970 /**
 971  * Predefined values for use as response ids in gtk_dialog_add_button().
 972  * All predefined values are negative, GTK+ leaves positive values for
 973  * application-defined response ids.
 974  * GTK_RESPONSE_NONE
 975  * Returned if an action widget has no response id, or if
 976  */
 977 public enum GtkResponseType
 978 {
 979         /+* GTK returns this if a response widget has no responseId,
 980          * or if the dialog gets programmatically hidden or destroyed.
 981         +/
 982         GTK_RESPONSE_NONE = -1,
 983         /+* GTK won't return these unless you pass them inn
 984          * as the response for an action widget. They are
 985          * for your convenience.
 986         +/
 987         GTK_RESPONSE_REJECT = -2,
 988         GTK_RESPONSE_ACCEPT = -3,
 989         /+* If the dialog is deleted. +/
 990         GTK_RESPONSE_DELETE_EVENT = -4,
 991         /+* These are returned from GTK dialogs, and you can also use them
 992          * yourself if you like.
 993         +/
 994         GTK_RESPONSE_OK = -5,
 995         GTK_RESPONSE_CANCEL = -6,
 996         GTK_RESPONSE_CLOSE = -7,
 997         GTK_RESPONSE_YES = -8,
 998         GTK_RESPONSE_NO = -9,
 999         GTK_RESPONSE_APPLY = -10,
1000         GTK_RESPONSE_HELP = -11
1001 }
1002 alias GtkResponseType ResponseType;
1003
1004 /**
1005  * The type of message being displayed in the dialog.
1006  * GTK_MESSAGE_INFO
1007  * Informational message
1008  * GTK_MESSAGE_WARNING
1009  * Nonfatal warning message
1010  * GTK_MESSAGE_QUESTION
1011  * Question requiring a choice
1012  * GTK_MESSAGE_ERROR
1013  * Fatal error message
1014  * GTK_MESSAGE_OTHER
1015  */
1016 public enum GtkMessageType
1017 {
1018         INFO,
1019         WARNING,
1020         QUESTION,
1021         ERROR,
1022         OTHER
1023 }
1024 alias GtkMessageType MessageType;
1025
1026 /**
1027  * Prebuilt sets of buttons for the dialog. If
1028  * none of these choices are appropriate, simply use GTK_BUTTONS_NONE
1029  * then call gtk_dialog_add_buttons().
1030  * GTK_BUTTONS_NONE
1031  * no buttons at all
1032  * GTK_BUTTONS_OK
1033  * an OK button
1034  * GTK_BUTTONS_CLOSE
1035  * a Close button
1036  * GTK_BUTTONS_CANCEL
1037  * a Cancel button
1038  * GTK_BUTTONS_YES_NO
1039  * Yes and No buttons
1040  * GTK_BUTTONS_OK_CANCEL
1041  * OK and Cancel buttons
1042  */
1043 public enum GtkButtonsType
1044 {
1045         NONE,
1046         OK,
1047         CLOSE,
1048         CANCEL,
1049         YES_NO,
1050         OK_CANCEL
1051 }
1052 alias GtkButtonsType ButtonsType;
1053
1054 /**
1055  * An enum for determining the page role inside the GtkAssistant. It's used to
1056  * handle buttons sensitivity and visibility.
1057  * Note that an assistant needs to end its page flow with a page of type GTK_ASSISTANT_PAGE_CONFIRM
1058  * or GTK_ASSISTANT_PAGE_SUMMARY to be correct.
1059  * GTK_ASSISTANT_PAGE_CONTENT
1060  * The page has regular contents.
1061  * GTK_ASSISTANT_PAGE_INTRO
1062  * The page contains an introduction to the assistant task.
1063  * GTK_ASSISTANT_PAGE_CONFIRM
1064  * The page lets the user confirm or deny the changes.
1065  * GTK_ASSISTANT_PAGE_SUMMARY
1066  * The page informs the user of the changes done.
1067  * GTK_ASSISTANT_PAGE_PROGRESS
1068  * Used for tasks that take a long time to complete, blocks the assistant until the page is marked as complete.
1069  */
1070 public enum GtkAssistantPageType
1071 {
1072         CONTENT,
1073         INTRO,
1074         CONFIRM,
1075         SUMMARY,
1076         PROGRESS
1077 }
1078 alias GtkAssistantPageType AssistantPageType;
1079
1080 /**
1081  * Describes the image data representation used by a GtkImage. If you
1082  * want to get the image from the widget, you can only get the
1083  * currently-stored representation. e.g. if the
1084  * gtk_image_get_storage_type() returns GTK_IMAGE_PIXBUF, then you can
1085  * call gtk_image_get_pixbuf() but not gtk_image_get_stock(). For empty
1086  * images, you can request any storage type (call any of the "get"
1087  * functions), but they will all return NULL values.
1088  * GTK_IMAGE_EMPTY
1089  * there is no image displayed by the widget
1090  * GTK_IMAGE_PIXMAP
1091  * the widget contains a GdkPixmap
1092  * GTK_IMAGE_IMAGE
1093  * the widget contains a GdkImage
1094  * GTK_IMAGE_PIXBUF
1095  * the widget contains a GdkPixbuf
1096  * GTK_IMAGE_STOCK
1097  * the widget contains a stock icon name (see Stock Items(3))
1098  * GTK_IMAGE_ICON_SET
1099  * the widget contains a GtkIconSet
1100  * GTK_IMAGE_ANIMATION
1101  * the widget contains a GdkPixbufAnimation
1102  * GTK_IMAGE_ICON_NAME
1103  * the widget contains a named icon.
1104  */
1105 public enum GtkImageType
1106 {
1107         EMPTY,
1108         PIXMAP,
1109         IMAGE,
1110         PIXBUF,
1111         STOCK,
1112         ICON_SET,
1113         ANIMATION,
1114         ICON_NAME
1115 }
1116 alias GtkImageType ImageType;
1117
1118 /**
1119  * An enumeration representing possible orientations and growth
1120  * directions for the visible progress bar.
1121  * GTK_PROGRESS_LEFT_TO_RIGHT
1122  * A horizontal progress bar growing from left to right.
1123  * GTK_PROGRESS_RIGHT_TO_LEFT
1124  * A horizontal progress bar growing from right to left.
1125  * GTK_PROGRESS_BOTTOM_TO_TOP
1126  * A vertical progress bar growing from bottom to top.
1127  * GTK_PROGRESS_TOP_TO_BOTTOM
1128  * A vertical progress bar growing from top to bottom.
1129  */
1130 public enum GtkProgressBarOrientation
1131 {
1132         LEFT_TO_RIGHT,
1133         RIGHT_TO_LEFT,
1134         BOTTOM_TO_TOP,
1135         TOP_TO_BOTTOM
1136 }
1137 alias GtkProgressBarOrientation ProgressBarOrientation;
1138
1139 /**
1140  * An enumeration representing the styles for drawing the progress bar.
1141  * GTK_PROGRESS_CONTINUOUS
1142  * The progress bar grows in a smooth, continuous manner.
1143  * GTK_PROGRESS_DISCRETE
1144  * The progress bar grows in discrete, visible blocks.
1145  */
1146 public enum GtkProgressBarStyle
1147 {
1148         CONTINUOUS,
1149         DISCRETE
1150 }
1151 alias GtkProgressBarStyle ProgressBarStyle;
1152
1153 /**
1154  * GTK_UPDATE_ALWAYS
1155  * When refreshing your GtkSpinButton, the value is always displayed.
1156  * GTK_UPDATE_IF_VALID
1157  * When refreshing your GtkSpinButton, the value is only displayed if it is valid within the bounds of the spin button's GtkAdjustment.
1158  */
1159 public enum GtkSpinButtonUpdatePolicy
1160 {
1161         UPDATE_ALWAYS,
1162         UPDATE_IF_VALID
1163 }
1164 alias GtkSpinButtonUpdatePolicy SpinButtonUpdatePolicy;
1165
1166 /**
1167  * GTK_SPIN_STEP_FORWARD,
1168  * GTK_SPIN_STEP_BACKWARD,
1169  * GTK_SPIN_PAGE_FORWARD,
1170  * GTK_SPIN_PAGE_BACKWARD
1171  * These values spin a GtkSpinButton by the relevant values of the spin button's GtkAdjustment.
1172  * GTK_SPIN_HOME,
1173  * GTK_SPIN_END
1174  * These set the spin button's value to the minimum or maxmimum possible values, (set by its GtkAdjustment), respectively.
1175  * GTK_SPIN_USER_DEFINED
1176  * The programmer must specify the exact amount to spin the GtkSpinButton.
1177  */
1178 public enum GtkSpinType
1179 {
1180         STEP_FORWARD,
1181         STEP_BACKWARD,
1182         PAGE_FORWARD,
1183         PAGE_BACKWARD,
1184         HOME,
1185         END,
1186         USER_DEFINED
1187 }
1188 alias GtkSpinType SpinType;
1189
1190 public enum GtkTextSearchFlags
1191 {
1192         VISIBLE_ONLY = 1 << 0,
1193         TEXT_ONLY = 1 << 1
1194         /+* Possible future plans: SEARCH_CASE_INSENSITIVE, SEARCH_REGEXP +/
1195 }
1196 alias GtkTextSearchFlags TextSearchFlags;
1197
1198 public enum GtkTextBufferTargetInfo
1199 {
1200         BUFFER_CONTENTS = G_MAXUINT - 0,
1201         RICH_TEXT = G_MAXUINT - 1,
1202         TEXT = G_MAXUINT - 2
1203 }
1204 alias GtkTextBufferTargetInfo TextBufferTargetInfo;
1205
1206 /**
1207  * Describes a type of line wrapping.
1208  * GTK_WRAP_NONE
1209  * do not wrap lines; just make the text area wider
1210  * GTK_WRAP_CHAR
1211  * wrap text, breaking lines anywhere the cursor can
1212  */
1213 public enum GtkWrapMode
1214 {
1215         NONE,
1216         CHAR,
1217         WORD,
1218         WORD_CHAR
1219 }
1220 alias GtkWrapMode WrapMode;
1221
1222 public enum GtkTextWindowType
1223 {
1224         PRIVATE,
1225         WIDGET,
1226         TEXT,
1227         LEFT,
1228         RIGHT,
1229         TOP,
1230         BOTTOM
1231 }
1232 alias GtkTextWindowType TextWindowType;
1233
1234 /**
1235  * These flags indicate various properties of a GtkTreeModel. They are
1236  * returned by gtk_tree_model_get_flags(), and must be static for the
1237  * lifetime of the object. A more complete description of
1238  * GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of this
1239  * section.
1240  * GTK_TREE_MODEL_ITERS_PERSIST
1241  * Iterators survive all signals emitted by the tree.
1242  * GTK_TREE_MODEL_LIST_ONLY
1243  * The model is a list only, and never has children
1244  */
1245 public enum GtkTreeModelFlags
1246 {
1247         ITERS_PERSIST = 1 << 0,
1248         LIST_ONLY = 1 << 1
1249 }
1250 alias GtkTreeModelFlags TreeModelFlags;
1251
1252 /**
1253  * The sizing method the column uses to determine its width. Please note
1254  * that GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
1255  * can make columns appear choppy.
1256  * GTK_TREE_VIEW_COLUMN_GROW_ONLY
1257  * Columns only get bigger in reaction to changes in the model
1258  * GTK_TREE_VIEW_COLUMN_AUTOSIZE
1259  * Columns resize to be the optimal size everytime the model changes.
1260  * GTK_TREE_VIEW_COLUMN_FIXED
1261  * Columns are a fixed numbers of pixels wide.
1262  */
1263 public enum GtkTreeViewColumnSizing
1264 {
1265         GROW_ONLY,
1266         AUTOSIZE,
1267         FIXED
1268 }
1269 alias GtkTreeViewColumnSizing TreeViewColumnSizing;
1270
1271 /**
1272  * An enum for determining where a dropped row goes.
1273  * GTK_TREE_VIEW_DROP_BEFORE
1274  * dropped row is inserted before
1275  * GTK_TREE_VIEW_DROP_AFTER
1276  * dropped row is inserted after
1277  * GTK_TREE_VIEW_DROP_INTO_OR_BEFORE
1278  * dropped row becomes a child or is inserted before
1279  * GTK_TREE_VIEW_DROP_INTO_OR_AFTER
1280  * dropped row becomes a child or is inserted after
1281  */
1282 public enum GtkTreeViewDropPosition
1283 {
1284         /+* drop before/after this row +/
1285         GTK_TREE_VIEW_DROP_BEFORE,
1286         GTK_TREE_VIEW_DROP_AFTER,
1287         /+* drop as a child of this row (with fallback to before or after
1288          * if into is not possible)
1289         +/
1290         GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
1291         GTK_TREE_VIEW_DROP_INTO_OR_AFTER
1292 }
1293 alias GtkTreeViewDropPosition TreeViewDropPosition;
1294
1295 public enum GtkTreeViewGridLines
1296 {
1297         NONE,
1298         HORIZONTAL,
1299         VERTICAL,
1300         BOTH
1301 }
1302 alias GtkTreeViewGridLines TreeViewGridLines;
1303
1304 /**
1305  * An enum for determining where a dropped item goes.
1306  * GTK_ICON_VIEW_NO_DROP
1307  * no drop possible
1308  * GTK_ICON_VIEW_DROP_INTO
1309  * dropped item replaces the item
1310  * GTK_ICON_VIEW_DROP_LEFT
1311  * droppped item is inserted to the left
1312  * GTK_ICON_VIEW_DROP_RIGHT
1313  * dropped item is inserted to the right
1314  * GTK_ICON_VIEW_DROP_ABOVE
1315  * dropped item is inserted above
1316  * GTK_ICON_VIEW_DROP_BELOW
1317  * dropped item is inserted below
1318  */
1319 public enum GtkIconViewDropPosition
1320 {
1321         NO_DROP,
1322         DROP_INTO,
1323         DROP_LEFT,
1324         DROP_RIGHT,
1325         DROP_ABOVE,
1326         DROP_BELOW
1327 }
1328 alias GtkIconViewDropPosition IconViewDropPosition;
1329
1330 /**
1331  * Tells how a cell is to be rendererd.
1332  * GTK_CELL_RENDERER_SELECTED
1333  * The cell is currently selected, and
1334  * probably has a selection colored background to render to.
1335  * GTK_CELL_RENDERER_PRELIT
1336  * The mouse is hovering over the cell.
1337  * GTK_CELL_RENDERER_INSENSITIVE
1338  * The cell is drawn in an insensitive manner
1339  * GTK_CELL_RENDERER_SORTED
1340  * The cell is in a sorted row
1341  * GTK_CELL_RENDERER_FOCUSED
1342  */
1343 public enum GtkCellRendererState
1344 {
1345         SELECTED = 1 << 0,
1346         PRELIT = 1 << 1,
1347         INSENSITIVE = 1 << 2,
1348         /+* this flag means the cell is inn the sort column/row +/
1349         SORTED = 1 << 3,
1350         FOCUSED = 1 << 4
1351 }
1352 alias GtkCellRendererState CellRendererState;
1353
1354 /**
1355  * Identifies how the user can interact with a particular cell.
1356  * GTK_CELL_RENDERER_MODE_INERT
1357  * The cell is just for display
1358  * and cannot be interacted with. Note that this doesn't mean that eg. the
1359  * row being drawn can't be selected -- just that a particular element of
1360  * it cannot be individually modified.
1361  * GTK_CELL_RENDERER_MODE_ACTIVATABLE
1362  * The cell can be clicked.
1363  * GTK_CELL_RENDERER_MODE_EDITABLE
1364  * The cell can be edited or otherwise modified.
1365  */
1366 public enum GtkCellRendererMode
1367 {
1368         MODE_INERT,
1369         MODE_ACTIVATABLE,
1370         MODE_EDITABLE
1371 }
1372 alias GtkCellRendererMode CellRendererMode;
1373
1374 public enum GtkPackDirection
1375 {
1376         LTR,
1377         RTL,
1378         TTB,
1379         BTT
1380 }
1381 alias GtkPackDirection PackDirection;
1382
1383 /**
1384  * An enumeration representing directional movements within a menu.
1385  * GTK_MENU_DIR_PARENT
1386  * To the parent menu shell.
1387  * GTK_MENU_DIR_CHILD
1388  * To the submenu, if any, associated with the item.
1389  * GTK_MENU_DIR_NEXT
1390  * To the next menu item.
1391  * GTK_MENU_DIR_PREV
1392  * To the previous menu item.
1393  * Property Details
1394  * The "take-focus" property
1395  */
1396 public enum GtkMenuDirectionType
1397 {
1398         PARENT,
1399         CHILD,
1400         NEXT,
1401         PREV
1402 }
1403 alias GtkMenuDirectionType MenuDirectionType;
1404
1405 /**
1406  * Warning
1407  * GtkToolbarChildType is deprecated and should not be used in newly-written code.
1408  * GtkToolbarChildType is used to set the type of new elements that are added
1409  * to a GtkToolbar.
1410  * GTK_TOOLBAR_CHILD_SPACE
1411  * a space in the style of the toolbar's GtkToolbarSpaceStyle.
1412  * GTK_TOOLBAR_CHILD_BUTTON
1413  * a GtkButton.
1414  * GTK_TOOLBAR_CHILD_TOGGLEBUTTON
1415  * a GtkToggleButton.
1416  * GTK_TOOLBAR_CHILD_RADIOBUTTON
1417  * a GtkRadioButton.
1418  * GTK_TOOLBAR_CHILD_WIDGET
1419  * a standard GtkWidget.
1420  */
1421 public enum GtkToolbarChildType
1422 {
1423         SPACE,
1424         BUTTON,
1425         TOGGLEBUTTON,
1426         RADIOBUTTON,
1427         WIDGET
1428 }
1429 alias GtkToolbarChildType ToolbarChildType;
1430
1431 public enum GtkToolbarSpaceStyle
1432 {
1433         EMPTY,
1434         LINE
1435 }
1436 alias GtkToolbarSpaceStyle ToolbarSpaceStyle;
1437
1438 /**
1439  * These enumeration values are used by gtk_ui_manager_add_ui() to determine
1440  * what UI element to create.
1441  * GTK_UI_MANAGER_AUTO
1442  * Pick the type of the UI element according to context.
1443  * GTK_UI_MANAGER_MENUBAR
1444  * Create a menubar.
1445  * GTK_UI_MANAGER_MENU
1446  * Create a menu.
1447  * GTK_UI_MANAGER_TOOLBAR
1448  * Create a toolbar.
1449  * GTK_UI_MANAGER_PLACEHOLDER
1450  * Insert a placeholder.
1451  * GTK_UI_MANAGER_POPUP
1452  * Create a popup menu.
1453  * GTK_UI_MANAGER_MENUITEM
1454  * Create a menuitem.
1455  * GTK_UI_MANAGER_TOOLITEM
1456  * Create a toolitem.
1457  * GTK_UI_MANAGER_SEPARATOR
1458  * Create a separator.
1459  * GTK_UI_MANAGER_ACCELERATOR
1460  * Install an accelerator.
1461  */
1462 public enum GtkUIManagerItemType
1463 {
1464         AUTO = 0,
1465         MENUBAR = 1 << 0,
1466         MENU = 1 << 1,
1467         TOOLBAR = 1 << 2,
1468         PLACEHOLDER = 1 << 3,
1469         POPUP = 1 << 4,
1470         MENUITEM = 1 << 5,
1471         TOOLITEM = 1 << 6,
1472         SEPARATOR = 1 << 7,
1473         ACCELERATOR = 1 << 8
1474 }
1475 alias GtkUIManagerItemType UIManagerItemType;
1476
1477 /**
1478  */
1479 public enum GtkFileChooserAction
1480 {
1481         OPEN,
1482         SAVE,
1483         SELECT_FOLDER,
1484         CREATE_FOLDER
1485 }
1486 alias GtkFileChooserAction FileChooserAction;
1487
1488 /**
1489  */
1490 public enum GtkFileChooserConfirmation
1491 {
1492         CONFIRM,
1493         ACCEPT_FILENAME,
1494         SELECT_AGAIN
1495 }
1496 alias GtkFileChooserConfirmation FileChooserConfirmation;
1497
1498 /**
1499  */
1500 public enum GtkFileChooserError
1501 {
1502         NONEXISTENT,
1503         BAD_FILENAME,
1504         ALREADY_EXISTS
1505 }
1506 alias GtkFileChooserError FileChooserError;
1507
1508 /**
1509  * These flags indicate what parts of a GtkFileFilterInfo struct
1510  * are filled or need to be filled.
1511  * GTK_FILE_FILTER_FILENAME
1512  * the filename of the file being tested
1513  * GTK_FILE_FILTER_URI
1514  * the URI for the file being tested
1515  * GTK_FILE_FILTER_DISPLAY_NAME
1516  * the string that will be used to
1517  */
1518 public enum GtkFileFilterFlags
1519 {
1520         FILENAME = 1 << 0,
1521         URI = 1 << 1,
1522         DISPLAY_NAME = 1 << 2,
1523         MIME_TYPE = 1 << 3
1524 }
1525 alias GtkFileFilterFlags FileFilterFlags;
1526
1527 /**
1528  * These options can be used to influence the display and behaviour of a GtkCalendar.
1529  * GTK_CALENDAR_SHOW_HEADING
1530  * Specifies that the month and year should be displayed.
1531  * GTK_CALENDAR_SHOW_DAY_NAMES
1532  * Specifies that three letter day descriptions should be present.
1533  * GTK_CALENDAR_NO_MONTH_CHANGE
1534  * Prevents the user from switching months with the calendar.
1535  * GTK_CALENDAR_SHOW_WEEK_NUMBERS
1536  * Displays each week numbers of the current year, down the left side
1537  */
1538 public enum GtkCalendarDisplayOptions
1539 {
1540         SHOW_HEADING = 1 << 0,
1541         SHOW_DAY_NAMES = 1 << 1,
1542         NO_MONTH_CHANGE = 1 << 2,
1543         SHOW_WEEK_NUMBERS = 1 << 3,
1544         WEEK_START_MONDAY = 1 << 4
1545 }
1546 alias GtkCalendarDisplayOptions CalendarDisplayOptions;
1547
1548 /**
1549  * The mode of the size group determines the directions in which the size
1550  * group affects the requested sizes of its component widgets.
1551  * GTK_SIZE_GROUP_NONE
1552  */
1553 public enum GtkSizeGroupMode
1554 {
1555         NONE,
1556         HORIZONTAL,
1557         VERTICAL,
1558         BOTH
1559 }
1560 alias GtkSizeGroupMode SizeGroupMode;
1561
1562 /**
1563  * Tells about the state of the object.
1564  * GTK_IN_DESTRUCTION
1565  * the object is currently being destroyed. This is used
1566  */
1567 public enum GtkObjectFlags
1568 {
1569         IN_DESTRUCTION = 1 << 0, /+* Used internally during dispose +/
1570         FLOATING = 1 << 1,
1571         RESERVED_1 = 1 << 2,
1572         RESERVED_2 = 1 << 3
1573 }
1574 alias GtkObjectFlags ObjectFlags;
1575
1576 /**
1577  * Warning
1578  * GtkArgFlags is deprecated and should not be used in newly-written code. Use corresponding GParamSpec features instead
1579  * Possible flags indicating how an argument should be treated.
1580  * GTK_ARG_READABLE
1581  * the argument is readable. (i.e. can be queried)
1582  * GTK_ARG_WRITABLE
1583  * the argument is writable. (i.e. settable)
1584  * GTK_ARG_CONSTRUCT
1585  * the argument needs construction.
1586  * GTK_ARG_CONSTRUCT_ONLY
1587  * the argument needs construction (and will
1588  * be set once during object creation), but is otherwise cannot be
1589  * set. Hence this flag is not allowed with GTK_ARG_WRITABLE,
1590  * and is redundant with GTK_ARG_CONSTRUCT.
1591  * GTK_ARG_CHILD_ARG
1592  * an argument type that applies to (and may be different for)
1593  * each child. Used by GtkContainer.
1594  */
1595 public enum GtkArgFlags
1596 {
1597         READABLE = ParamFlags.READABLE,
1598         WRITABLE = ParamFlags.WRITABLE,
1599         CONSTRUCT = ParamFlags.CONSTRUCT,
1600         CONSTRUCT_ONLY = ParamFlags.CONSTRUCT_ONLY,
1601         CHILD_ARG = 1 << 4
1602 }
1603 alias GtkArgFlags ArgFlags;
1604
1605 /**
1606  * Determines how GTK+ handles the sensitivity of stepper arrows
1607  * at the end of range widgets.
1608  * GTK_SENSITIVITY_AUTO
1609  * The arrow is made insensitive if the
1610  */
1611 public enum GtkSensitivityType
1612 {
1613         AUTO,
1614         ON,
1615         OFF
1616 }
1617 alias GtkSensitivityType SensitivityType;
1618
1619 /**
1620  * Tells about certain properties of the widget.
1621  * GTK_TOPLEVEL
1622  */
1623 public enum GtkWidgetFlags
1624 {
1625         TOPLEVEL = 1 << 4,
1626         NO_WINDOW = 1 << 5,
1627         REALIZED = 1 << 6,
1628         MAPPED = 1 << 7,
1629         VISIBLE = 1 << 8,
1630         SENSITIVE = 1 << 9,
1631         PARENT_SENSITIVE = 1 << 10,
1632         CAN_FOCUS = 1 << 11,
1633         HAS_FOCUS = 1 << 12,
1634         /+* widget is allowed to receive the defaulx via grabDefault
1635          * and will reserve space to draw the defaulx if possible
1636         +/
1637         CAN_DEFAULT = 1 << 13,
1638         /+* the widget currently is receiving the defaulx action and should be drawn
1639          * appropriately if possible
1640         +/
1641         HAS_DEFAULT = 1 << 14,
1642         HAS_GRAB = 1 << 15,
1643         RC_STYLE = 1 << 16,
1644         COMPOSITE_CHILD = 1 << 17,
1645         NO_REPARENT = 1 << 18,
1646         APP_PAINTABLE = 1 << 19,
1647         /+* the widget when focused will receive the defaulx action and have
1648          * HAS_DEFAULT set even if there is a different widget set as defaulx
1649         +/
1650         RECEIVES_DEFAULT = 1 << 20,
1651         DOUBLE_BUFFERED = 1 << 21,
1652         NO_SHOW_ALL = 1 << 22
1653 }
1654 alias GtkWidgetFlags WidgetFlags;
1655
1656 public enum GtkWidgetHelpType
1657 {
1658         TOOLTIP,
1659         WHATS_THIS
1660 }
1661 alias GtkWidgetHelpType WidgetHelpType;
1662
1663 public enum GtkTextDirection
1664 {
1665         NONE,
1666         LTR,
1667         RTL
1668 }
1669 alias GtkTextDirection TextDirection;
1670
1671
1672 struct GtkTextIter {
1673         /* GtkTextIter is an opaque datatype; ignore all these fields.
1674          * Initialize the iter with gtk_text_buffer_get_iter_*
1675          * functions
1676          */
1677         /*< private >*/
1678         gpointer dummy1;
1679         gpointer dummy2;
1680         gint dummy3;
1681         gint dummy4;
1682         gint dummy5;
1683         gint dummy6;
1684         gint dummy7;
1685         gint dummy8;
1686         gpointer dummy9;
1687         gpointer dummy10;
1688         gint dummy11;
1689         gint dummy12;
1690         /* padding */
1691         gint dummy13;
1692         gpointer dummy14;
1693 }
1694
1695
1696 /**
1697  * Main Gtk struct.
1698  * An object representing and maintaining a group of accelerators.
1699  */
1700 public struct GtkAccelGroup{}
1701
1702
1703 public struct GtkAccelKey{}
1704 // uint accelKey;
1705 // gtk-Keyboard-Accelerators.html
1706 // GdkModifierType accelMods;
1707 // gtk-Keyboard-Accelerators.html
1708 // uint accelFlags : 16;
1709 // gtk-Keyboard-Accelerators.html
1710
1711
1712 /**
1713  * Main Gtk struct.
1714  */
1715 public struct GtkAccelMap{}
1716
1717
1718 /**
1719  * Main Gtk struct.
1720  */
1721 public struct GtkClipboard{}
1722
1723
1724 /**
1725  * Contains information found when looking up an icon in
1726  * an icon theme.
1727  */
1728 public struct GtkIconInfo{}
1729
1730
1731 /**
1732  * Main Gtk struct.
1733  * Acts as a database of information about an icon theme.
1734  * Normally, you retrieve the icon theme for a particular
1735  * screen using gtk_icon_theme_get_for_screen() and it
1736  * will contain information about current icon theme for
1737  * that screen, but you can also create a new GtkIconTheme
1738  * object and set the icon theme name explicitely using
1739  * gtk_icon_theme_set_custom_theme().
1740  */
1741 public struct GtkIconTheme{}
1742
1743
1744 /**
1745  * Main Gtk struct.
1746  */
1747 public struct GtkStockItem{}
1748 // char *stockId;
1749 // gtk-Stock-Items.html
1750 // char *label;
1751 // gtk-Stock-Items.html
1752 // GdkModifierType modifier;
1753 // gtk-Stock-Items.html
1754 // uint keyval;
1755 // gtk-Stock-Items.html
1756 // char *translationDomain;
1757 // gtk-Stock-Items.html
1758
1759
1760 /**
1761  * Main Gtk struct.
1762  */
1763 public struct GtkIconSource{}
1764
1765
1766 public struct GtkIconFactory{}
1767
1768
1769 public struct GtkIconSet{}
1770
1771
1772 /**
1773  * Main Gtk struct.
1774  * The GtkRcStyle structure is used to represent a set
1775  * of information about the appearance of a widget.
1776  * This can later be composited together with other
1777  * GtkRcStyle structures to form a GtkStyle.
1778  */
1779 public struct GtkRcStyle{}
1780 // char *name;
1781 // gtk-Resource-Files.html
1782 // char *bgPixmapName[5];
1783 // gtk-Resource-Files.html
1784 // PangoFontDescription *fontDesc;
1785 // gtk-Resource-Files.html
1786 // GtkRcFlags colorFlags[5];
1787 // gtk-Resource-Files.html
1788 // GdkColor fg[5];
1789 // gtk-Resource-Files.html
1790 // GdkColor bg[5];
1791 // gtk-Resource-Files.html
1792 // GdkColor text[5];
1793 // gtk-Resource-Files.html
1794 // GdkColor base[5];
1795 // gtk-Resource-Files.html
1796 // int xthickness;
1797 // gtk-Resource-Files.html
1798 // int ythickness;
1799 // gtk-Resource-Files.html
1800
1801
1802 /**
1803  * Main Gtk struct.
1804  */
1805 public struct GtkSettings{}
1806
1807
1808 public struct GtkSettingsValue{}
1809 // /+* origin should be something like "filename:linenumber" for rc files,
1810 // GtkSettings.html
1811 // * or e.g. "XProperty" for other sources
1812 // GtkSettings.html
1813 // +/
1814 // GtkSettings.html
1815 // char *origin;
1816 // GtkSettings.html
1817 // /+* valid types are LONG, DOUBLE and STRING corresponding to the token parsed,
1818 // GtkSettings.html
1819 // * or a GSTRING holding an unparsed statement
1820 // GtkSettings.html
1821 // +/
1822 // GtkSettings.html
1823 // GValue value;
1824 // GtkSettings.html
1825
1826
1827 /**
1828  * Main Gtk struct.
1829  * A binding set maintains a list of activatable key bindings.
1830  * A single binding set can match multiple types of widgets.
1831  * Similar to styles, widgets can be mapped by widget name paths, widget class paths or widget class types.
1832  * When a binding within a set is matched upon activation, an action signal is emitted on
1833  * the target widget to carry out the actual activation.
1834  * gchar*set_name;
1835  */
1836 public struct GtkBindingSet{}
1837 // char *setName;
1838 // gtk-Bindings.html
1839 // int priority;
1840 // gtk-Bindings.html
1841 // GSList *widgetPathPspecs;
1842 // gtk-Bindings.html
1843 // GSList *widgetClassPspecs;
1844 // gtk-Bindings.html
1845 // GSList *classBranchPspecs;
1846 // gtk-Bindings.html
1847 // GtkBindingEntry *entries;
1848 // gtk-Bindings.html
1849 // GtkBindingEntry *current;
1850 // gtk-Bindings.html
1851 // uint parsed : 1; /+* From RC content +/
1852 // gtk-Bindings.html
1853
1854
1855 /**
1856  * Each key binding element of a binding sets binding list is represented by a GtkBindingEntry.
1857  * guintkeyval;
1858  */
1859 public struct GtkBindingEntry{}
1860 // /+* key portion
1861 // gtk-Bindings.html
1862 // +/
1863 // gtk-Bindings.html
1864 // uint keyval;
1865 // gtk-Bindings.html
1866 // GdkModifierType modifiers;
1867 // gtk-Bindings.html
1868 // GtkBindingSet *bindingSet;
1869 // gtk-Bindings.html
1870 // uint destroyed : 1;
1871 // gtk-Bindings.html
1872 // uint inEmission : 1;
1873 // gtk-Bindings.html
1874 // uint marksUnbound : 1;
1875 // gtk-Bindings.html
1876 // GtkBindingEntry *setNext;
1877 // gtk-Bindings.html
1878 // GtkBindingEntry *hashNext;
1879 // gtk-Bindings.html
1880 // GtkBindingSignal *signals;
1881 // gtk-Bindings.html
1882
1883
1884 /**
1885  * A GtkBindingSignal stores the necessary information to activate a widget
1886  * in response to a key press via a signal emission.
1887  * GtkBindingSignal*next;
1888  */
1889 public struct GtkBindingSignal{}
1890 // GtkBindingSignal *next;
1891 // gtk-Bindings.html
1892 // char *signalName;
1893 // gtk-Bindings.html
1894 // uint nArgs;
1895 // gtk-Bindings.html
1896 // GtkBindingArg *args;
1897 // gtk-Bindings.html
1898
1899
1900 /**
1901  * A GtkBindingArg holds the data associated with an argument for a
1902  * key binding signal emission as stored in GtkBindingSignal.
1903  * GTypearg_type;
1904  * implementation detail
1905  */
1906 public struct GtkBindingArg{}
1907 // GType argType;
1908 // gtk-Bindings.html
1909 // unio {
1910         // gtk-Bindings.html
1911         // int longData;
1912         // gtk-Bindings.html
1913         // double doubleData;
1914         // gtk-Bindings.html
1915         // char *stringData;
1916         // gtk-Bindings.html
1917 // } d;
1918 // gtk-Bindings.html
1919
1920
1921 /**
1922  * Main Gtk struct.
1923  */
1924 public struct GtkStyle{}
1925 // GdkColor fg[5];
1926 // GtkStyle.html
1927 // GdkColor bg[5];
1928 // GtkStyle.html
1929 // GdkColor light[5];
1930 // GtkStyle.html
1931 // GdkColor dark[5];
1932 // GtkStyle.html
1933 // GdkColor mid[5];
1934 // GtkStyle.html
1935 // GdkColor text[5];
1936 // GtkStyle.html
1937 // GdkColor base[5];
1938 // GtkStyle.html
1939 // GdkColor textAa[5]; /+* Halfway between text/base +/
1940 // GtkStyle.html
1941 // GdkColor black;
1942 // GtkStyle.html
1943 // GdkColor white;
1944 // GtkStyle.html
1945 // PangoFontDescription *fontDesc;
1946 // GtkStyle.html
1947 // int xthickness;
1948 // GtkStyle.html
1949 // int ythickness;
1950 // GtkStyle.html
1951 // GdkGC *fgGc[5];
1952 // GtkStyle.html
1953 // GdkGC *bgGc[5];
1954 // GtkStyle.html
1955 // GdkGC *lightGc[5];
1956 // GtkStyle.html
1957 // GdkGC *darkGc[5];
1958 // GtkStyle.html
1959 // GdkGC *midGc[5];
1960 // GtkStyle.html
1961 // GdkGC *textGc[5];
1962 // GtkStyle.html
1963 // GdkGC *baseGc[5];
1964 // GtkStyle.html
1965 // GdkGC *textAaGc[5];
1966 // GtkStyle.html
1967 // GdkGC *blackGc;
1968 // GtkStyle.html
1969 // GdkGC *whiteGc;
1970 // GtkStyle.html
1971 // GdkPixmap *bgPixmap[5];
1972 // GtkStyle.html
1973
1974
1975 public struct GtkBorder
1976 {
1977         int left;
1978         int right;
1979         int top;
1980         int bottom;
1981 }
1982
1983
1984 public struct GtkRcProperty{}
1985 // /+* quark-ified property identifier like "GtkScrollbar::spacing" +/
1986 // GtkStyle.html
1987 // GQuark typeName;
1988 // GtkStyle.html
1989 // GQuark propertyName;
1990 // GtkStyle.html
1991 // /+* fields similar to GtkSettingsValue +/
1992 // GtkStyle.html
1993 // char *origin;
1994 // GtkStyle.html
1995 // GValue value;
1996 // GtkStyle.html
1997
1998
1999 /**
2000  * A GtkTargetEntry structure represents a single type of
2001  * data than can be supplied for by a widget for a selection
2002  * or for supplied or received during drag-and-drop. It
2003  * contains a string representing the drag type, a flags
2004  * field (used only for drag and drop - see GtkTargetFlags),
2005  * and an application assigned integer ID. The integer
2006  * ID will later be passed as a signal parameter for signals
2007  * like "selection_get". It allows the application to identify
2008  * the target type without extensive string compares.
2009  */
2010 public struct GtkTargetEntry
2011 {
2012         char *target;
2013         uint flags;
2014         uint info;
2015 }
2016
2017
2018 /**
2019  * A GtkTargetList structure is a reference counted list
2020  * of GtkTargetPair. It is used to represent the same
2021  * information as a table of GtkTargetEntry, but in
2022  * an efficient form. This structure should be treated as
2023  * opaque.
2024  */
2025 public struct GtkTargetList{}
2026 // GList *list;
2027 // gtk-Selections.html
2028 // uint refCount;
2029 // gtk-Selections.html
2030
2031
2032 /**
2033  * Internally used structure in the drag-and-drop and
2034  * selection handling code.
2035  */
2036 public struct GtkTargetPair{}
2037 // GdkAtom target;
2038 // gtk-Selections.html
2039 // uint flags;
2040 // gtk-Selections.html
2041 // uint info;
2042 // gtk-Selections.html
2043
2044
2045 /**
2046  * Warning
2047  * GtkArg is deprecated and should not be used in newly-written code.
2048  * This is a structure that we use to pass in typed values (and names).
2049  */
2050 public struct GtkArg{}
2051 // GtkType type;
2052 // gtk-Types.html
2053 // char *name;
2054 // gtk-Types.html
2055 // /+* this unio only defines the required storage types for
2056 // gtk-Types.html
2057 // * the possibile values, thus there is no int enumData field,
2058 // gtk-Types.html
2059 // * because that would just be a mere alias for int intData.
2060 // gtk-Types.html
2061 // * use the GTK_VALUE_*() and GTK_RETLOC_*() macros to access
2062 // gtk-Types.html
2063 // * the discrete memebers.
2064 // gtk-Types.html
2065 // +/
2066 // gtk-Types.html
2067 // unio {
2068         // gtk-Types.html
2069         // /+* flat values +/
2070         // gtk-Types.html
2071         // char charData;
2072         // gtk-Types.html
2073         // char ucharData;
2074         // gtk-Types.html
2075         // int boolData;
2076         // gtk-Types.html
2077         // int intData;
2078         // gtk-Types.html
2079         // uint uintData;
2080         // gtk-Types.html
2081         // int longData;
2082         // gtk-Types.html
2083         // uint ulongData;
2084         // gtk-Types.html
2085         // float floatData;
2086         // gtk-Types.html
2087         // double doubleData;
2088         // gtk-Types.html
2089         // char *stringData;
2090         // gtk-Types.html
2091         // GtkObject *objectData;
2092         // gtk-Types.html
2093         // void* pointerData;
2094         // gtk-Types.html
2095         // /+* structured values +/
2096         // gtk-Types.html
2097         // struct {
2098                 // gtk-Types.html
2099                 // GtkSignalFunc f;
2100                 // gtk-Types.html
2101                 // void* d;
2102                 // gtk-Types.html
2103         // } signalData;
2104         // gtk-Types.html
2105 // } d;
2106 // gtk-Types.html
2107
2108
2109 /**
2110  * Warning
2111  * GtkTypeInfo is deprecated and should not be used in newly-written code.
2112  * Holds information about the type. gtk_type_name() returns the name.
2113  * object_size is somehow set to the number of bytes that an instance of
2114  * the object will occupy. class_init_func holds the type's
2115  * initialization function. object_init_func holds the initialization
2116  * function for an instance of the object. reserved_1 is used for
2117  * GtkEnumValue to hold the enumerated values.
2118  */
2119 public struct GtkTypeInfo{}
2120 // char *typeName;
2121 // gtk-Types.html
2122 // uint objectSize;
2123 // gtk-Types.html
2124 // uint classSize;
2125 // gtk-Types.html
2126 // GtkClassInitFunc classInitFunc;
2127 // gtk-Types.html
2128 // GtkObjectInitFunc objectInitFunc;
2129 // gtk-Types.html
2130 // void* reserved1;
2131 // gtk-Types.html
2132 // void* reserved2;
2133 // gtk-Types.html
2134 // GtkClassInitFunc baseClassInitFunc;
2135 // gtk-Types.html
2136
2137
2138 /**
2139  * Main Gtk struct.
2140  * vbox is a GtkVBox - the main part of the
2141  * dialog box.
2142  * action_area is a GtkHButtonBox packed below the
2143  * dividing GtkHSeparator in the dialog. It is treated exactly the same
2144  * as any other GtkHButtonBox.
2145  */
2146 public struct GtkDialog{}
2147 // GtkWidget *vbox;
2148 // GtkDialog.html
2149 // GtkWidget *actionArea;
2150 // GtkDialog.html
2151
2152
2153 /**
2154  * Main Gtk struct.
2155  * The GtkInvisible struct contains no public fields.
2156  */
2157 public struct GtkInvisible{}
2158
2159
2160 /**
2161  * Main Gtk struct.
2162  */
2163 public struct GtkMessageDialog{}
2164
2165
2166 /**
2167  * Main Gtk struct.
2168  */
2169 public struct GtkWindow{}
2170
2171
2172 /**
2173  * Main Gtk struct.
2174  */
2175 public struct GtkWindowGroup{}
2176
2177
2178 /**
2179  * Main Gtk struct.
2180  * The GtkAboutDialog struct contains
2181  * only private fields and should not be directly accessed.
2182  */
2183 public struct GtkAboutDialog{}
2184
2185
2186 /**
2187  * Main Gtk struct.
2188  */
2189 public struct GtkAssistant{}
2190
2191
2192 /**
2193  * Main Gtk struct.
2194  * The GtkAccelLabel struct contains private data only, and
2195  * should be accessed using the functions below.
2196  */
2197 public struct GtkAccelLabel{}
2198
2199
2200 /**
2201  * Main Gtk struct.
2202  * This struct contain private data only and should be accessed by the functions
2203  * below.
2204  */
2205 public struct GtkImage{}
2206
2207
2208 /**
2209  * Main Gtk struct.
2210  * This should not be accessed directly. Use the accessor functions as
2211  * described below.
2212  */
2213 public struct GtkLabel{}
2214
2215
2216 /**
2217  * Main Gtk struct.
2218  * The GtkProgressBar struct contains private data only,
2219  * and should be accessed using the functions below.
2220  */
2221 public struct GtkProgressBar{}
2222
2223
2224 /**
2225  * Main Gtk struct.
2226  * Contains private data that should be modified with the functions described below.
2227  */
2228 public struct GtkStatusbar{}
2229
2230
2231 /**
2232  * Main Gtk struct.
2233  * This should not be accessed directly. Use the accessor functions below.
2234  */
2235 public struct GtkButton{}
2236
2237
2238 /**
2239  * Main Gtk struct.
2240  * toggle_button is a GtkToggleButton representing the actual toggle button that composes the check button.
2241  */
2242 public struct GtkCheckButton{}
2243
2244
2245 /**
2246  * Main Gtk struct.
2247  * Contains only private data that should be read and manipulated using the
2248  * functions below.
2249  */
2250 public struct GtkRadioButton{}
2251
2252
2253 /**
2254  * Main Gtk struct.
2255  * The GtkToggleButton struct contains private data only, and should be manipulated using the functions below.
2256  */
2257 public struct GtkToggleButton{}
2258
2259
2260 /**
2261  * Main Gtk struct.
2262  * The GtkEntry struct contains only private data.
2263  */
2264 public struct GtkEntry{}
2265
2266
2267 /**
2268  * Main Gtk struct.
2269  * The GtkEntryCompletion struct contains only private data.
2270  */
2271 public struct GtkEntryCompletion{}
2272
2273
2274 /**
2275  * Main Gtk struct.
2276  * The GtkHScale struct contains private data only, and
2277  * should be accessed using the functions below.
2278  */
2279 public struct GtkHScale{}
2280
2281
2282 /**
2283  * Main Gtk struct.
2284  * The GtkVScale struct contains private data only, and
2285  * should be accessed using the functions below.
2286  */
2287 public struct GtkVScale{}
2288
2289
2290 /**
2291  * Main Gtk struct.
2292  * entry is the GtkEntry part of the GtkSpinButton
2293  * widget, and can be used accordingly. All other fields contain private data
2294  * and should only be modified using the functions below.
2295  */
2296 public struct GtkSpinButton{}
2297
2298
2299 /**
2300  * Main Gtk struct.
2301  * The GtkEditable structure contains the following fields.
2302  * (These fields should be considered read-only. They should
2303  * never be set by an application.)
2304  * guint selection_start;
2305  * the starting position of the selected characters
2306  */
2307 public struct GtkEditable{}
2308
2309
2310 /**
2311  * Main Gtk struct.
2312  */
2313 public struct GtkTextMark{}
2314
2315
2316 /**
2317  * Main Gtk struct.
2318  */
2319 public struct GtkTextBuffer{}
2320
2321
2322 /**
2323  * Main Gtk struct.
2324  */
2325 public struct GtkTextTag{}
2326
2327
2328 /**
2329  * Using GtkTextAttributes directly should rarely be necessary. It's
2330  * primarily useful with gtk_text_iter_get_attributes(). As with most
2331  * GTK+ structs, the fields in this struct should only be read, never
2332  * modified directly.
2333  * GtkTextAppearanceappearance;
2334  * pointer to sub-struct containing certain attributes
2335  * GtkJustificationjustification;
2336  * GtkTextDirectiondirection;
2337  * PangoFontDescription*font;
2338  * gdoublefont_scale;
2339  * gintleft_margin;
2340  * gintindent;
2341  * gintright_margin;
2342  * gintpixels_above_lines;
2343  * gintpixels_below_lines;
2344  * gintpixels_inside_wrap;
2345  * PangoTabArray*tabs;
2346  * GtkWrapModewrap_mode;
2347  * PangoLanguage*language;
2348  * guintinvisible:1;
2349  * guintbg_full_height:1;
2350  * guinteditable:1;
2351  * guintrealized:1;
2352  */
2353 public struct GtkTextAttributes{}
2354 // GtkTextAppearance appearance;
2355 // GtkTextTag.html
2356 // GtkJustification justification;
2357 // GtkTextTag.html
2358 // GtkTextDirection direction;
2359 // GtkTextTag.html
2360 // /+* Individual chunks of this can be set/unset as a group +/
2361 // GtkTextTag.html
2362 // PangoFontDescription *font;
2363 // GtkTextTag.html
2364 // double fontScale;
2365 // GtkTextTag.html
2366 // int leftMargin;
2367 // GtkTextTag.html
2368 // int indent;
2369 // GtkTextTag.html
2370 // int rightMargin;
2371 // GtkTextTag.html
2372 // int pixelsAboveLines;
2373 // GtkTextTag.html
2374 // int pixelsBelowLines;
2375 // GtkTextTag.html
2376 // int pixelsInsideWrap;
2377 // GtkTextTag.html
2378 // PangoTabArray *tabs;
2379 // GtkTextTag.html
2380 // GtkWrapMode wrapMode; /+* How to handle wrap-around for this tag.
2381 // GtkTextTag.html
2382 // * Must be GTK_WRAPMODE_CHAR,
2383 // GtkTextTag.html
2384 // * GTK_WRAPMODE_NONE, GTK_WRAPMODE_WORD
2385 // GtkTextTag.html
2386 // +/
2387 // GtkTextTag.html
2388 // PangoLanguage *language;
2389 // GtkTextTag.html
2390 // /+* hide the text +/
2391 // GtkTextTag.html
2392 // uint invisible : 1;
2393 // GtkTextTag.html
2394 // /+* Background is fit to full line height rather than
2395 // GtkTextTag.html
2396 // * baseline +/- ascent/descent (font height)
2397 // GtkTextTag.html
2398 // +/
2399 // GtkTextTag.html
2400 // uint bgFullHeight : 1;
2401 // GtkTextTag.html
2402 // /+* can edit this text +/
2403 // GtkTextTag.html
2404 // uint editable : 1;
2405 // GtkTextTag.html
2406 // /+* colors are allocated etc. +/
2407 // GtkTextTag.html
2408 // uint realized : 1;
2409 // GtkTextTag.html
2410
2411
2412 public struct GtkTextAppearance{}
2413 // GdkColor bgColor;
2414 // GtkTextTag.html
2415 // GdkColor fgColor;
2416 // GtkTextTag.html
2417 // GdkBitmap *bgStipple;
2418 // GtkTextTag.html
2419 // GdkBitmap *fgStipple;
2420 // GtkTextTag.html
2421 // /+* super/subscript rise, can be negative +/
2422 // GtkTextTag.html
2423 // int rise;
2424 // GtkTextTag.html
2425 // uint underline : 4; /+* PangoUnderline +/
2426 // GtkTextTag.html
2427 // uint strikethrough : 1;
2428 // GtkTextTag.html
2429 // /+* Whether to use background-related values; this is irrelevant for
2430 // GtkTextTag.html
2431 // * the values struct when inn a tag, but is used for the composite
2432 // GtkTextTag.html
2433 // * values struct; it's true if any of the tags being composited
2434 // GtkTextTag.html
2435 // * had background stuff set.
2436 // GtkTextTag.html
2437 // +/
2438 // GtkTextTag.html
2439 // uint drawBg : 1;
2440 // GtkTextTag.html
2441 // /+* These are only used when we are actually laying out and rendering
2442 // GtkTextTag.html
2443 // * a paragraph; not when a GtkTextAppearance is part of a
2444 // GtkTextTag.html
2445 // * GtkTextAttributes.
2446 // GtkTextTag.html
2447 // +/
2448 // GtkTextTag.html
2449 // uint insideSelection : 1;
2450 // GtkTextTag.html
2451 // uint isText : 1;
2452 // GtkTextTag.html
2453
2454
2455 /**
2456  * Main Gtk struct.
2457  */
2458 public struct GtkTextTagTable{}
2459
2460
2461 /**
2462  * Main Gtk struct.
2463  */
2464 public struct GtkTextView{}
2465
2466
2467 /**
2468  * A GtkTextChildAnchor is a spot in the buffer
2469  * where child widgets can be "anchored" (inserted inline, as if they were
2470  * characters). The anchor can have multiple widgets anchored, to allow for
2471  * multiple views.
2472  */
2473 public struct GtkTextChildAnchor{}
2474
2475
2476 /**
2477  * Main Gtk struct.
2478  */
2479 public struct GtkTreeModel{}
2480
2481
2482 /**
2483  * The GtkTreeIter is the primary structure for
2484  * accessing a structure. Models are expected to put a unique integer in
2485  * the stamp member, and put model-specific
2486  * data in the three user_data members.
2487  * gintstamp;
2488  * A unique stamp to catch invalid iterators
2489  * gpointeruser_data;
2490  * Model specific data
2491  * gpointeruser_data2;
2492  * Model specific data
2493  * gpointeruser_data3;
2494  * Model specific data
2495  */
2496 public struct GtkTreeIter
2497 {
2498         int stamp;
2499         void* userData;
2500         void* userData2;
2501         void* userData3;
2502 }
2503
2504
2505 public struct GtkTreePath{}
2506
2507
2508 public struct GtkTreeRowReference{}
2509
2510
2511 public struct GtkTreeModelIface{}
2512 // GTypeInterface gIface;
2513 // GtkTreeModel.html
2514 // /+* Signals +/
2515 // GtkTreeModel.html
2516 // void (* rowChanged) (GtkTreeModel *treeModel,
2517 // GtkTreeModel.html
2518 // GtkTreePath *path,
2519 // GtkTreeModel.html
2520 // GtkTreeIter *iter);
2521 // GtkTreeModel.html
2522 // void (* rowInserted) (GtkTreeModel *treeModel,
2523 // GtkTreeModel.html
2524 // GtkTreePath *path,
2525 // GtkTreeModel.html
2526 // GtkTreeIter *iter);
2527 // GtkTreeModel.html
2528 // void (* rowHasChildToggled) (GtkTreeModel *treeModel,
2529 // GtkTreeModel.html
2530 // GtkTreePath *path,
2531 // GtkTreeModel.html
2532 // GtkTreeIter *iter);
2533 // GtkTreeModel.html
2534 // void (* rowDeleted) (GtkTreeModel *treeModel,
2535 // GtkTreeModel.html
2536 // GtkTreePath *path);
2537 // GtkTreeModel.html
2538 // void (* rowsReordered) (GtkTreeModel *treeModel,
2539 // GtkTreeModel.html
2540 // GtkTreePath *path,
2541 // GtkTreeModel.html
2542 // GtkTreeIter *iter,
2543 // GtkTreeModel.html
2544 // int *newOrder);
2545 // GtkTreeModel.html
2546 // /+* Virtual Table +/
2547 // GtkTreeModel.html
2548 // GtkTreeModelFlags (* getFlags) (GtkTreeModel *treeModel);
2549 // GtkTreeModel.html
2550 // int (* getNColumns) (GtkTreeModel *treeModel);
2551 // GtkTreeModel.html
2552 // GType (* getColumnType) (GtkTreeModel *treeModel,
2553 // GtkTreeModel.html
2554 // int index);
2555 // GtkTreeModel.html
2556 // int (* getIter) (GtkTreeModel *treeModel,
2557 // GtkTreeModel.html
2558 // GtkTreeIter *iter,
2559 // GtkTreeModel.html
2560 // GtkTreePath *path);
2561 // GtkTreeModel.html
2562 // GtkTreePath *(* getPath) (GtkTreeModel *treeModel,
2563 // GtkTreeModel.html
2564 // GtkTreeIter *iter);
2565 // GtkTreeModel.html
2566 // void (* getValue) (GtkTreeModel *treeModel,
2567 // GtkTreeModel.html
2568 // GtkTreeIter *iter,
2569 // GtkTreeModel.html
2570 // int column,
2571 // GtkTreeModel.html
2572 // GValue *value);
2573 // GtkTreeModel.html
2574 // int (* iterNext) (GtkTreeModel *treeModel,
2575 // GtkTreeModel.html
2576 // GtkTreeIter *iter);
2577 // GtkTreeModel.html
2578 // int (* iterChildren) (GtkTreeModel *treeModel,
2579 // GtkTreeModel.html
2580 // GtkTreeIter *iter,
2581 // GtkTreeModel.html
2582 // GtkTreeIter *parent);
2583 // GtkTreeModel.html
2584 // int (* iterHasChild) (GtkTreeModel *treeModel,
2585 // GtkTreeModel.html
2586 // GtkTreeIter *iter);
2587 // GtkTreeModel.html
2588 // int (* iterNChildren) (GtkTreeModel *treeModel,
2589 // GtkTreeModel.html
2590 // GtkTreeIter *iter);
2591 // GtkTreeModel.html
2592 // int (* iterNthChild) (GtkTreeModel *treeModel,
2593 // GtkTreeModel.html
2594 // GtkTreeIter *iter,
2595 // GtkTreeModel.html
2596 // GtkTreeIter *parent,
2597 // GtkTreeModel.html
2598 // int n);
2599 // GtkTreeModel.html
2600 // int (* iterParent) (GtkTreeModel *treeModel,
2601 // GtkTreeModel.html
2602 // GtkTreeIter *iter,
2603 // GtkTreeModel.html
2604 // GtkTreeIter *child);
2605 // GtkTreeModel.html
2606 // void (* refNode) (GtkTreeModel *treeModel,
2607 // GtkTreeModel.html
2608 // GtkTreeIter *iter);
2609 // GtkTreeModel.html
2610 // void (* unrefNode) (GtkTreeModel *treeModel,
2611 // GtkTreeModel.html
2612 // GtkTreeIter *iter);
2613 // GtkTreeModel.html
2614
2615
2616 /**
2617  * Main Gtk struct.
2618  */
2619 public struct GtkTreeSelection{}
2620
2621
2622 /**
2623  * Main Gtk struct.
2624  */
2625 public struct GtkTreeViewColumn{}
2626
2627
2628 /**
2629  * Main Gtk struct.
2630  */
2631 public struct GtkTreeView{}
2632
2633
2634 /**
2635  * A private struct for internal use only. The definition of this
2636  * structure is not publically available.
2637  */
2638 public struct GtkTreeViewPrivate{}
2639
2640
2641 /**
2642  * Main Gtk struct.
2643  */
2644 public struct GtkTreeDragSource{}
2645
2646
2647 public struct GtkTreeDragSourceIface{}
2648 // GTypeInterface gIface;
2649 // gtk-GtkTreeView-drag-and-drop.html
2650 // /+* VTable - not signals +/
2651 // gtk-GtkTreeView-drag-and-drop.html
2652 // int (* rowDraggable) (GtkTreeDragSource *dragSource,
2653 // gtk-GtkTreeView-drag-and-drop.html
2654 // GtkTreePath *path);
2655 // gtk-GtkTreeView-drag-and-drop.html
2656 // int (* dragDataGet) (GtkTreeDragSource *dragSource,
2657 // gtk-GtkTreeView-drag-and-drop.html
2658 // GtkTreePath *path,
2659 // gtk-GtkTreeView-drag-and-drop.html
2660 // GtkSelectionData *selectionData);
2661 // gtk-GtkTreeView-drag-and-drop.html
2662 // int (* dragDataDelete) (GtkTreeDragSource *dragSource,
2663 // gtk-GtkTreeView-drag-and-drop.html
2664 // GtkTreePath *path);
2665 // gtk-GtkTreeView-drag-and-drop.html
2666
2667
2668 public struct GtkTreeDragDest{}
2669
2670
2671 public struct GtkTreeDragDestIface{}
2672 // GTypeInterface gIface;
2673 // gtk-GtkTreeView-drag-and-drop.html
2674 // /+* VTable - not signals +/
2675 // gtk-GtkTreeView-drag-and-drop.html
2676 // int (* dragDataReceived) (GtkTreeDragDest *dragDest,
2677 // gtk-GtkTreeView-drag-and-drop.html
2678 // GtkTreePath *dest,
2679 // gtk-GtkTreeView-drag-and-drop.html
2680 // GtkSelectionData *selectionData);
2681 // gtk-GtkTreeView-drag-and-drop.html
2682 // int (* rowDropPossible) (GtkTreeDragDest *dragDest,
2683 // gtk-GtkTreeView-drag-and-drop.html
2684 // GtkTreePath *destPath,
2685 // gtk-GtkTreeView-drag-and-drop.html
2686 // GtkSelectionData *selectionData);
2687 // gtk-GtkTreeView-drag-and-drop.html
2688
2689
2690 /**
2691  * Main Gtk struct.
2692  */
2693 public struct GtkCellView{}
2694
2695
2696 /**
2697  * Main Gtk struct.
2698  * The GtkIconView struct contains only
2699  * private fields and should not be directly accessed.
2700  */
2701 public struct GtkIconView{}
2702
2703
2704 /**
2705  * Main Gtk struct.
2706  */
2707 public struct GtkTreeSortable{}
2708
2709
2710 public struct GtkTreeSortableIface{}
2711 // GTypeInterface gIface;
2712 // GtkTreeSortable.html
2713 // /+* signals +/
2714 // GtkTreeSortable.html
2715 // void (* sortColumnChanged) (GtkTreeSortable *sortable);
2716 // GtkTreeSortable.html
2717 // /+* virtual table +/
2718 // GtkTreeSortable.html
2719 // int (* getSortColumnId) (GtkTreeSortable *sortable,
2720 // GtkTreeSortable.html
2721 // int *sortColumnId,
2722 // GtkTreeSortable.html
2723 // GtkSortType *order);
2724 // GtkTreeSortable.html
2725 // void (* setSortColumnId) (GtkTreeSortable *sortable,
2726 // GtkTreeSortable.html
2727 // int sortColumnId,
2728 // GtkTreeSortable.html
2729 // GtkSortType order);
2730 // GtkTreeSortable.html
2731 // void (* setSortFunc) (GtkTreeSortable *sortable,
2732 // GtkTreeSortable.html
2733 // int sortColumnId,
2734 // GtkTreeSortable.html
2735 // GtkTreeIterCompareFunc func,
2736 // GtkTreeSortable.html
2737 // void* data,
2738 // GtkTreeSortable.html
2739 // GtkDestroyNotify destroy);
2740 // GtkTreeSortable.html
2741 // void (* setDefaultSortFunc) (GtkTreeSortable *sortable,
2742 // GtkTreeSortable.html
2743 // GtkTreeIterCompareFunc func,
2744 // GtkTreeSortable.html
2745 // void* data,
2746 // GtkTreeSortable.html
2747 // GtkDestroyNotify destroy);
2748 // GtkTreeSortable.html
2749 // int (* hasDefaultSortFunc) (GtkTreeSortable *sortable);
2750 // GtkTreeSortable.html
2751
2752
2753 /**
2754  * Main Gtk struct.
2755  * This should not be accessed directly. Use the accessor functions below.
2756  */
2757 public struct GtkTreeModelSort{}
2758
2759
2760 /**
2761  * Main Gtk struct.
2762  * The GtkTreeModelFilter struct contains only private fields.
2763  */
2764 public struct GtkTreeModelFilter{}
2765
2766
2767 /**
2768  * Main Gtk struct.
2769  */
2770 public struct GtkCellLayout{}
2771
2772
2773 public struct GtkCellLayoutIface{}
2774 // GTypeInterface gIface;
2775 // GtkCellLayout.html
2776 // /+* Virtual Table +/
2777 // GtkCellLayout.html
2778 // void (* packStart) (GtkCellLayout *cellLayout,
2779 // GtkCellLayout.html
2780 // GtkCellRenderer *cell,
2781 // GtkCellLayout.html
2782 // int expand);
2783 // GtkCellLayout.html
2784 // void (* packEnd) (GtkCellLayout *cellLayout,
2785 // GtkCellLayout.html
2786 // GtkCellRenderer *cell,
2787 // GtkCellLayout.html
2788 // int expand);
2789 // GtkCellLayout.html
2790 // void (* clear) (GtkCellLayout *cellLayout);
2791 // GtkCellLayout.html
2792 // void (* addAttribute) (GtkCellLayout *cellLayout,
2793 // GtkCellLayout.html
2794 // GtkCellRenderer *cell,
2795 // GtkCellLayout.html
2796 // char *attribute,
2797 // GtkCellLayout.html
2798 // int column);
2799 // GtkCellLayout.html
2800 // void (* setCellDataFunc) (GtkCellLayout *cellLayout,
2801 // GtkCellLayout.html
2802 // GtkCellRenderer *cell,
2803 // GtkCellLayout.html
2804 // GtkCellLayoutDataFunc func,
2805 // GtkCellLayout.html
2806 // void* funcData,
2807 // GtkCellLayout.html
2808 // GDestroyNotify destroy);
2809 // GtkCellLayout.html
2810 // void (* clearAttributes) (GtkCellLayout *cellLayout,
2811 // GtkCellLayout.html
2812 // GtkCellRenderer *cell);
2813 // GtkCellLayout.html
2814 // void (* reorder) (GtkCellLayout *cellLayout,
2815 // GtkCellLayout.html
2816 // GtkCellRenderer *cell,
2817 // GtkCellLayout.html
2818 // int position);
2819 // GtkCellLayout.html
2820
2821
2822 /**
2823  * Main Gtk struct.
2824  */
2825 public struct GtkCellRenderer{}
2826
2827
2828 /**
2829  * Main Gtk struct.
2830  */
2831 public struct GtkCellEditable{}
2832
2833
2834 public struct GtkCellEditableIface{}
2835 // GTypeInterface gIface;
2836 // GtkCellEditable.html
2837 // /+* signals +/
2838 // GtkCellEditable.html
2839 // void (* editingDone) (GtkCellEditable *cellEditable);
2840 // GtkCellEditable.html
2841 // void (* removeWidget) (GtkCellEditable *cellEditable);
2842 // GtkCellEditable.html
2843 // /+* virtual table +/
2844 // GtkCellEditable.html
2845 // void (* startEditing) (GtkCellEditable *cellEditable,
2846 // GtkCellEditable.html
2847 // GdkEvent *event);
2848 // GtkCellEditable.html
2849
2850
2851 /**
2852  * Main Gtk struct.
2853  */
2854 public struct GtkCellRendererCombo{}
2855
2856
2857 /**
2858  * Main Gtk struct.
2859  */
2860 public struct GtkCellRendererPixbuf{}
2861
2862
2863 /**
2864  * Main Gtk struct.
2865  */
2866 public struct GtkCellRendererProgress{}
2867
2868
2869 /**
2870  * Main Gtk struct.
2871  */
2872 public struct GtkCellRendererText{}
2873
2874
2875 /**
2876  * Main Gtk struct.
2877  */
2878 public struct GtkCellRendererToggle{}
2879
2880
2881 /**
2882  * Main Gtk struct.
2883  */
2884 public struct GtkListStore{}
2885
2886
2887 /**
2888  * Main Gtk struct.
2889  */
2890 public struct GtkTreeStore{}
2891
2892
2893 /**
2894  * Main Gtk struct.
2895  */
2896 public struct GtkComboBox{}
2897
2898
2899 /**
2900  * Main Gtk struct.
2901  */
2902 public struct GtkComboBoxEntry{}
2903
2904
2905 /**
2906  * Main Gtk struct.
2907  * The GtkMenu struct contains private data only, and
2908  * should be accessed using the functions below.
2909  */
2910 public struct GtkMenu{}
2911
2912
2913 /**
2914  * Main Gtk struct.
2915  * The GtkMenuBar struct contains the following fields. (These fields should be considered read-only. They should never be set by an application.)
2916  */
2917 public struct GtkMenuBar{}
2918
2919
2920 /**
2921  * Main Gtk struct.
2922  */
2923 public struct GtkMenuItem{}
2924
2925
2926 /**
2927  * Main Gtk struct.
2928  * The GtkMenuShell struct contains the following fields.
2929  * (These fields should be considered read-only. They should never be set by
2930  * an application.)
2931  * GList *children;
2932  * The list of GtkMenuItem objects contained by this GtkMenuShell.
2933  */
2934 public struct GtkMenuShell{}
2935
2936
2937 /**
2938  * Main Gtk struct.
2939  */
2940 public struct GtkImageMenuItem{}
2941
2942
2943 /**
2944  * Main Gtk struct.
2945  * The structure contains only private data that must be accessed through
2946  * the interface functions.
2947  */
2948 public struct GtkRadioMenuItem{}
2949
2950
2951 /**
2952  * Main Gtk struct.
2953  * The GtkCheckMenuItem struct contains the following fields.
2954  * (These fields should be considered read-only. They should never be set by
2955  * an application.)
2956  * guint active;
2957  * TRUE if the check box is active.
2958  */
2959 public struct GtkCheckMenuItem{}
2960
2961
2962 /**
2963  * Main Gtk struct.
2964  * The GtkSeparatorMenuItem struct contains private data only, and
2965  * should be accessed using the functions below.
2966  */
2967 public struct GtkSeparatorMenuItem{}
2968
2969
2970 /**
2971  * Main Gtk struct.
2972  * The GtkTearoffMenuItem struct contains private data only, and
2973  * should be accessed using the functions below.
2974  */
2975 public struct GtkTearoffMenuItem{}
2976
2977
2978 /**
2979  * Main Gtk struct.
2980  * The GtkToolbar struct only contains private data and should only be
2981  * accessed through the function described below.
2982  */
2983 public struct GtkToolbar{}
2984 // int numChildren;
2985 // GtkToolbar.html
2986 // GList *children;
2987 // GtkToolbar.html
2988 // GtkOrientation orientation;
2989 // GtkToolbar.html
2990 // GtkToolbarStyle style;
2991 // GtkToolbar.html
2992 // GtkIconSize iconSize;
2993 // GtkToolbar.html
2994 // GtkTooltips *tooltips;
2995 // GtkToolbar.html
2996
2997
2998 /**
2999  * Warning
3000  * GtkToolbarChild is deprecated and should not be used in newly-written code.
3001  */
3002 public struct GtkToolbarChild{}
3003 // GtkToolbarChildType type;
3004 // GtkToolbar.html
3005 // GtkWidget *widget;
3006 // GtkToolbar.html
3007 // GtkWidget *icon;
3008 // GtkToolbar.html
3009 // GtkWidget *label;
3010 // GtkToolbar.html
3011
3012
3013 /**
3014  * Main Gtk struct.
3015  * The GtkToolItem struct contains only private data. It should only be
3016  * accessed through the functions described below.
3017  */
3018 public struct GtkToolItem{}
3019
3020
3021 /**
3022  * Main Gtk struct.
3023  * The GtkSeparatorToolItem struct contains only private data and
3024  * should only be accessed through the functions described below.
3025  */
3026 public struct GtkSeparatorToolItem{}
3027
3028
3029 /**
3030  * Main Gtk struct.
3031  * The GtkToolButton struct contains only private. It should only be
3032  * accessed with the function described below.
3033  */
3034 public struct GtkToolButton{}
3035
3036
3037 /**
3038  * Main Gtk struct.
3039  */
3040 public struct GtkMenuToolButton{}
3041
3042
3043 /**
3044  * Main Gtk struct.
3045  */
3046 public struct GtkToggleToolButton{}
3047
3048
3049 /**
3050  * Main Gtk struct.
3051  */
3052 public struct GtkRadioToolButton{}
3053
3054
3055 /**
3056  * Main Gtk struct.
3057  * The GtkUIManager struct contains only private
3058  * members and should not be accessed directly.
3059  */
3060 public struct GtkUIManager{}
3061
3062
3063 /**
3064  * Main Gtk struct.
3065  * The GtkActionGroup struct contains only private
3066  * members and should not be accessed directly.
3067  */
3068 public struct GtkActionGroup{}
3069
3070
3071 /**
3072  * GtkActionEntry structs are used with
3073  * gtk_action_group_add_actions() to construct actions.
3074  * constgchar*name;
3075  * The name of the action.
3076  * constgchar*stock_id;
3077  * The stock id for the action, or the name of an icon from the icon
3078  */
3079 public struct GtkActionEntry{}
3080 // char *name;
3081 // GtkActionGroup.html
3082 // char *stockId;
3083 // GtkActionGroup.html
3084 // char *label;
3085 // GtkActionGroup.html
3086 // char *accelerator;
3087 // GtkActionGroup.html
3088 // char *tooltip;
3089 // GtkActionGroup.html
3090 // GCallback callback;
3091 // GtkActionGroup.html
3092
3093
3094 /**
3095  * GtkToggleActionEntry structs are used with
3096  * gtk_action_group_add_toggle_actions() to construct toggle actions.
3097  * constgchar*name;
3098  * The name of the action.
3099  * constgchar*stock_id;
3100  * The stock id for the action, or the name of an icon from the icon
3101  */
3102 public struct GtkToggleActionEntry{}
3103 // char *name;
3104 // GtkActionGroup.html
3105 // char *stockId;
3106 // GtkActionGroup.html
3107 // char *label;
3108 // GtkActionGroup.html
3109 // char *accelerator;
3110 // GtkActionGroup.html
3111 // char *tooltip;
3112 // GtkActionGroup.html
3113 // GCallback callback;
3114 // GtkActionGroup.html
3115 // int isActive;
3116 // GtkActionGroup.html
3117
3118
3119 /**
3120  * GtkRadioActionEntry structs are used with
3121  * gtk_action_group_add_radio_actions() to construct groups of radio actions.
3122  * constgchar*name;
3123  * The name of the action.
3124  * constgchar*stock_id;
3125  * The stock id for the action, or the name of an icon from the icon
3126  */
3127 public struct GtkRadioActionEntry
3128 {
3129         char *name;
3130         char *stockId;
3131         char *label;
3132         char *accelerator;
3133         char *tooltip;
3134         int value;
3135 }
3136
3137
3138 /**
3139  * Main Gtk struct.
3140  * The GtkAction struct contains only private members
3141  * and should not be accessed directly.
3142  */
3143 public struct GtkAction{}
3144
3145
3146 /**
3147  * Main Gtk struct.
3148  * The GtkToggleAction struct contains only
3149  * private members and should not be accessed directly.
3150  */
3151 public struct GtkToggleAction{}
3152
3153
3154 /**
3155  * Main Gtk struct.
3156  * The GtkRadioAction struct contains
3157  * only private members and should not be accessed directly.
3158  */
3159 public struct GtkRadioAction{}
3160
3161
3162 /**
3163  * Main Gtk struct.
3164  * The GtkColorButton struct has only private fields and
3165  * should not be used directly.
3166  */
3167 public struct GtkColorButton{}
3168
3169
3170 /**
3171  * Main Gtk struct.
3172  * The GtkColorSelection struct contains private data only,
3173  * and should be accessed using the functions below.
3174  */
3175 public struct GtkColorSelection{}
3176
3177
3178 /**
3179  * Main Gtk struct.
3180  * The GtkColorSelectionDialog struct contains the following fields.
3181  * (These fields should be considered read-only. They should never be set by
3182  * an application.)
3183  * GtkWidget *colorsel;
3184  * The GtkColorSelection widget contained within the
3185  * dialog. Use this widget and its gtk_color_selection_get_current_color()
3186  * function to gain access to the selected color. Connect a handler
3187  * for this widget's color_changed signal to be notified when the
3188  * color changes.
3189  * GtkWidget *ok_button;
3190  * The OK button widget contained within the dialog.
3191  * Connect a handler for the clicked event.
3192  * GtkWidget *cancel_button;
3193  * The cancel button widget contained within the dialog.
3194  * Connect a handler for the clicked event.
3195  * GtkWidget *help_button;
3196  * The help button widget contained within the dialog.
3197  * Connect a handler for the clicked event.
3198  */
3199 public struct GtkColorSelectionDialog{}
3200
3201
3202 /**
3203  * Main Gtk struct.
3204  * The GtkFileSelection struct contains the following GtkWidget fields:
3205  * *fileop_dialog;
3206  * the dialog box used to display the GtkFileSelection. It can be customized by adding/removing widgets from it using the standard GtkDialog functions.
3207  * *ok_button, *cancel_button;
3208  * the two main buttons that signals should be connected to in order to perform an action when the user hits either OK or Cancel.
3209  * *history_pulldown;
3210  * the GtkOptionMenu used to create the drop-down directory history.
3211  * *fileop_c_dir, *fileop_del_file, *fileop_ren_file;
3212  * the buttons that appear at the top of the file selection dialog. These "operation buttons" can be hidden and redisplayed with gtk_file_selection_hide_fileop_buttons() and gtk_file_selection_show_fileop_buttons() respectively.
3213  */
3214 public struct GtkFileSelection{}
3215 // GtkWidget *dirList;
3216 // GtkFileSelection.html
3217 // GtkWidget *fileList;
3218 // GtkFileSelection.html
3219 // GtkWidget *selectionEntry;
3220 // GtkFileSelection.html
3221 // GtkWidget *selectionText;
3222 // GtkFileSelection.html
3223 // GtkWidget *mainVbox;
3224 // GtkFileSelection.html
3225 // GtkWidget *okButton;
3226 // GtkFileSelection.html
3227 // GtkWidget *cancelButton;
3228 // GtkFileSelection.html
3229 // GtkWidget *helpButton;
3230 // GtkFileSelection.html
3231 // GtkWidget *historyPulldown;
3232 // GtkFileSelection.html
3233 // GtkWidget *historyMenu;
3234 // GtkFileSelection.html
3235 // GList *historyList;
3236 // GtkFileSelection.html
3237 // GtkWidget *fileopDialog;
3238 // GtkFileSelection.html
3239 // GtkWidget *fileopEntry;
3240 // GtkFileSelection.html
3241 // char *fileopFile;
3242 // GtkFileSelection.html
3243 // void* cmplState;
3244 // GtkFileSelection.html
3245 // GtkWidget *fileopCDir;
3246 // GtkFileSelection.html
3247 // GtkWidget *fileopDelFile;
3248 // GtkFileSelection.html
3249 // GtkWidget *fileopRenFile;
3250 // GtkFileSelection.html
3251 // GtkWidget *buttonArea;
3252 // GtkFileSelection.html
3253 // GtkWidget *actionArea;
3254 // GtkFileSelection.html
3255
3256
3257 /**
3258  * Main Gtk struct.
3259  */
3260 public struct GtkFileChooser{}
3261
3262
3263 /**
3264  * Main Gtk struct.
3265  * This should not be accessed directly. Use the accessor functions below.
3266  */
3267 public struct GtkFileChooserButton{}
3268
3269
3270 /**
3271  * Main Gtk struct.
3272  */
3273 public struct GtkFileChooserDialog{}
3274
3275
3276 /**
3277  * Main Gtk struct.
3278  */
3279 public struct GtkFileChooserWidget{}
3280
3281
3282 /**
3283  * Main Gtk struct.
3284  * The GtkFileFilter struct contains
3285  * only private fields and should not be directly accessed.
3286  */
3287 public struct GtkFileFilter{}
3288
3289
3290 /**
3291  * A GtkFileFilterInfo struct is used
3292  * to pass information about the tested file to
3293  * gtk_file_filter_filter().
3294  * GtkFileFilterFlagscontains;
3295  * Flags indicating which of the following fields need
3296  */
3297 public struct GtkFileFilterInfo{}
3298 // GtkFileFilterFlags contains;
3299 // gtk-gtkfilefilter.html
3300 // char *filename;
3301 // gtk-gtkfilefilter.html
3302 // char *uri;
3303 // gtk-gtkfilefilter.html
3304 // char *displayName;
3305 // gtk-gtkfilefilter.html
3306 // char *mimeType;
3307 // gtk-gtkfilefilter.html
3308
3309
3310 /**
3311  * Main Gtk struct.
3312  * The GtkFontButton struct has only private members and should not be used
3313  * directly.
3314  */
3315 public struct GtkFontButton{}
3316
3317
3318 /**
3319  * Main Gtk struct.
3320  * The GtkFontSelection struct contains private data only, and should
3321  * only be accessed using the functions below.
3322  */
3323 public struct GtkFontSelection{}
3324
3325
3326 /**
3327  * Main Gtk struct.
3328  * GtkWidget*ok_button;
3329  * The OK button of the dialog
3330  * GtkWidget*apply_button;
3331  * The Apply button of the dialog. This button is hidden
3332  * by default but you can show/hide it
3333  * GtkWidget*cancel_button;
3334  * The Cancel button of the dialog
3335  */
3336 public struct GtkFontSelectionDialog{}
3337 // GtkWidget *okButton;
3338 // GtkFontSelectionDialog.html
3339 // GtkWidget *applyButton;
3340 // GtkFontSelectionDialog.html
3341 // GtkWidget *cancelButton;
3342 // GtkFontSelectionDialog.html
3343
3344
3345 /**
3346  * Main Gtk struct.
3347  */
3348 public struct GtkInputDialog{}
3349
3350
3351 /**
3352  * Main Gtk struct.
3353  * The GtkAlignment struct contains private data only, and should
3354  * be accessed using the functions below.
3355  */
3356 public struct GtkAlignment{}
3357
3358
3359 /**
3360  * Main Gtk struct.
3361  */
3362 public struct GtkAspectFrame{}
3363
3364
3365 /**
3366  * Main Gtk struct.
3367  */
3368 public struct GtkHBox{}
3369
3370
3371 /**
3372  * Main Gtk struct.
3373  */
3374 public struct GtkVBox{}
3375
3376
3377 /**
3378  * Main Gtk struct.
3379  * GtkHButtonBox does not contain any public fields.
3380  */
3381 public struct GtkHButtonBox{}
3382
3383
3384 /**
3385  * Main Gtk struct.
3386  * GtkVButtonBox does not contain any public fields.
3387  */
3388 public struct GtkVButtonBox{}
3389
3390
3391 /**
3392  * Main Gtk struct.
3393  * The GtkFixed struct contains the following fields.
3394  * (These fields should be considered read-only. They should never be set by
3395  * an application.)
3396  * GList *children;
3397  * a list of GtkFixedChild elements, containing the child widgets and
3398  * their positions.
3399  */
3400 public struct GtkFixed{}
3401
3402
3403 /**
3404  * The GtkFixedChild struct contains the following fields.
3405  * (These fields should be considered read-only. They should never be set by
3406  * an application.)
3407  * GtkWidget *widget;
3408  * the child GtkWidget.
3409  * gint x;
3410  * the horizontal position of the widget within the GtkFixed
3411  * container.
3412  * gint y;
3413  * the vertical position of the widget within the GtkFixed
3414  * container.
3415  */
3416 public struct GtkFixedChild{}
3417 // GtkWidget *widget;
3418 // GtkFixed.html
3419 // int x;
3420 // GtkFixed.html
3421 // int y;
3422 // GtkFixed.html
3423
3424
3425 /**
3426  * Main Gtk struct.
3427  */
3428 public struct GtkHPaned{}
3429
3430
3431 /**
3432  * Main Gtk struct.
3433  */
3434 public struct GtkVPaned{}
3435
3436
3437 /**
3438  * Main Gtk struct.
3439  */
3440 public struct GtkLayout{}
3441 // GdkWindow *binWindow;
3442 // GtkLayout.html
3443
3444
3445 /**
3446  * Main Gtk struct.
3447  */
3448 public struct GtkNotebook{}
3449
3450
3451 /**
3452  * The GtkNotebookPage is an opaque implementation detail of GtkNotebook.
3453  */
3454 public struct GtkNotebookPage{}
3455
3456
3457 /**
3458  * Main Gtk struct.
3459  * The GtkTable structure holds the data for the actual table itself.
3460  * children is a GList of all the widgets the table contains. rows and columns are pointers to GtkTableRowCol structures, which contain the default spacing and expansion details for the GtkTable's rows and columns, respectively.
3461  * nrows and ncols are 16bit integers storing the number of rows and columns the table has.
3462  */
3463 public struct GtkTable{}
3464
3465
3466 /**
3467  * The widget field is a pointer to the widget that
3468  * this GtkTableChild structure is keeping track of.
3469  * The left_attach,
3470  * right_attach,
3471  * top_attach, and
3472  * bottom_attach fields specify the row and column
3473  * numbers which make up the invisible rectangle that the child widget is packed into.
3474  * xpadding and ypadding
3475  * specify the space between this widget and the surrounding table cells.
3476  */
3477 public struct GtkTableChild{}
3478 // GtkWidget *widget;
3479 // GtkTable.html
3480 // ushort leftAttach;
3481 // GtkTable.html
3482 // ushort rightAttach;
3483 // GtkTable.html
3484 // ushort topAttach;
3485 // GtkTable.html
3486 // ushort bottomAttach;
3487 // GtkTable.html
3488 // ushort xpadding;
3489 // GtkTable.html
3490 // ushort ypadding;
3491 // GtkTable.html
3492 // uint xexpand : 1;
3493 // GtkTable.html
3494 // uint yexpand : 1;
3495 // GtkTable.html
3496 // uint xshrink : 1;
3497 // GtkTable.html
3498 // uint yshrink : 1;
3499 // GtkTable.html
3500 // uint xfill : 1;
3501 // GtkTable.html
3502 // uint yfill : 1;
3503 // GtkTable.html
3504
3505
3506 /**
3507  * These fields should be considered read-only and not be modified directly.
3508  */
3509 public struct GtkTableRowCol
3510 {
3511         ushort requisition;
3512         ushort allocation;
3513         ushort spacing;
3514         uint bitfield;
3515         //uint needExpand : 1;
3516 }
3517
3518
3519 /**
3520  * Main Gtk struct.
3521  */
3522 public struct GtkExpander{}
3523
3524
3525 /**
3526  * Main Gtk struct.
3527  */
3528 public struct GtkFrame{}
3529
3530
3531 /**
3532  * Main Gtk struct.
3533  * The GtkHSeparator struct contains private data only, and
3534  * should be accessed using the functions below.
3535  */
3536 public struct GtkHSeparator{}
3537
3538
3539 /**
3540  * Main Gtk struct.
3541  * The GtkVSeparator struct contains private data only, and
3542  * should be accessed using the functions below.
3543  */
3544 public struct GtkVSeparator{}
3545
3546
3547 /**
3548  * Main Gtk struct.
3549  * The GtkHScrollbar struct contains private data and should be accessed
3550  * using the functions below.
3551  */
3552 public struct GtkHScrollbar{}
3553
3554
3555 /**
3556  * Main Gtk struct.
3557  * The GtkVScrollbar struct contains private data and should be accessed
3558  * using the functions below.
3559  */
3560 public struct GtkVScrollbar{}
3561
3562
3563 /**
3564  * Main Gtk struct.
3565  * There are no public fields in the GtkScrolledWindow struct; it should
3566  * only be accessed using the functions below.
3567  */
3568 public struct GtkScrolledWindow{}
3569 // GtkWidget *hscrollbar;
3570 // GtkScrolledWindow.html
3571 // GtkWidget *vscrollbar;
3572 // GtkScrolledWindow.html
3573
3574
3575 /**
3576  * Main Gtk struct.
3577  * The GtkAdjustment struct contains the following fields.
3578  * gdouble lower;
3579  * the minimum value.
3580  * gdouble upper;
3581  * the maximum value.
3582  * gdouble value;
3583  * the current value.
3584  * gdouble step_increment;
3585  * the increment to use to make minor changes to the value.
3586  * In a GtkScrollbar this increment is used when the mouse is clicked on the
3587  * arrows at the top and bottom of the scrollbar, to scroll by a small amount.
3588  * gdouble page_increment;
3589  * the increment to use to make major changes to the value.
3590  * In a GtkScrollbar this increment is used when the mouse is clicked in the
3591  * trough, to scroll by a large amount.
3592  * gdouble page_size;
3593  * the page size.
3594  * In a GtkScrollbar this is the size of the area which is currently visible.
3595  */
3596 public struct GtkAdjustment{}
3597
3598
3599 /**
3600  * Main Gtk struct.
3601  * The GtkArrow struct containes the following fields.
3602  * (These fields should be considered read-only. They should never be set by
3603  * an application.)
3604  */
3605 public struct GtkArrow{}
3606
3607
3608 /**
3609  * Main Gtk struct.
3610  * num_marked_dates is an integer containing the
3611  * number of days that have a mark over them.
3612  * marked_date is an array containing the day numbers
3613  * that currently have a mark over them.
3614  * month, year, and
3615  * selected_day contain the currently visible month,
3616  * year, and selected day respectively.
3617  * All of these fields should be considered read only, and everything in this
3618  * struct should only be modified using the functions provided below.
3619  * Note
3620  * Note that month is zero-based (i.e it allowed values
3621  * are 0-11) while selected_day is one-based
3622  * (i.e. allowed values are 1-31).
3623  */
3624 public struct GtkCalendar{}
3625
3626
3627 /**
3628  * Main Gtk struct.
3629  * The GtkDrawingArea struct contains private data only, and
3630  * should be accessed using the functions below.
3631  */
3632 public struct GtkDrawingArea{}
3633
3634
3635 /**
3636  * Main Gtk struct.
3637  * The GtkEventBox struct contains private data only, and
3638  * should be accessed using the functions below.
3639  */
3640 public struct GtkEventBox{}
3641
3642
3643 /**
3644  * Main Gtk struct.
3645  * The GtkHandleBox struct contains the following fields.
3646  * (These fields should be considered read-only. They should never be set by
3647  * an application.)
3648  * GtkShadowType shadow_type;
3649  * The shadow type for the entry. (See gtk_handle_box_set_shadow_type()).
3650  * GtkPositionType handle_position;
3651  * The position of the handlebox's handle with respect
3652  * to the child. (See gtk_handle_box_set_handle_position())
3653  * gint snap_edge;
3654  * A value of type GtkPosition type indicating snap edge for the widget.
3655  * (See gtk_handle_box_set_snap_edge). The value of -1 indicates
3656  * that this value has not been set.
3657  * gboolean child_detached;
3658  * A boolean value indicating whether the handlebox's
3659  * child is attached or detached.
3660  */
3661 public struct GtkHandleBox{}
3662
3663
3664 /**
3665  * Main Gtk struct.
3666  */
3667 public struct GtkIMContextSimple{}
3668
3669
3670 /**
3671  * Main Gtk struct.
3672  */
3673 public struct GtkIMMulticontext{}
3674
3675
3676 /**
3677  * Main Gtk struct.
3678  */
3679 public struct GtkSizeGroup{}
3680
3681
3682 /**
3683  * Main Gtk struct.
3684  * Holds information about a group of tooltips. Fields should be changed using the functions provided, rather than directly accessing the struct's members.
3685  */
3686 public struct GtkTooltips{}
3687
3688
3689 /**
3690  * tooltips is the GtkTooltips group that this tooltip belongs to. widget is the GtkWidget that this tooltip data is associated with. tip_text is a string containing the tooltip message itself.
3691  * tip_private is a string that is not shown as the default tooltip. Instead, this message may be more informative and go towards forming a context-sensitive help system for your application. (FIXME: how to actually "switch on" private tips?)
3692  */
3693 public struct GtkTooltipsData{}
3694 // GtkTooltips *tooltips;
3695 // GtkTooltips.html
3696 // GtkWidget *widget;
3697 // GtkTooltips.html
3698 // char *tipText;
3699 // GtkTooltips.html
3700 // char *tipPrivate;
3701 // GtkTooltips.html
3702
3703
3704 /**
3705  * Main Gtk struct.
3706  */
3707 public struct GtkViewport{}
3708
3709
3710 /**
3711  * Main Gtk struct.
3712  */
3713 public struct GtkAccessible{}
3714
3715
3716 /**
3717  * Main Gtk struct.
3718  * The GtkBin struct contains the following fields.
3719  * (These fields should be considered read-only. They should never be set by
3720  * an application.)
3721  * GtkWidget *child;
3722  * the child widget.
3723  */
3724 public struct GtkBin{}
3725
3726
3727 /**
3728  * Main Gtk struct.
3729  * The GtkBox describes an instance of GtkBox and contains the following fields.
3730  * (These fields should be considered read-only. They should never be set by
3731  * an application.)
3732  * GList * children;
3733  * a list of children belonging the GtkBox. The data is a list of
3734  * structures of type GtkBoxChild.
3735  * gint16 spacing;
3736  * the number of pixels to put between children of the GtkBox, zero
3737  * by default. Use gtk_box_set_spacing() to set this field.
3738  * guint homogeneous;
3739  * a flag that if TRUE forces all children to get equal space in
3740  * the GtkBox; FALSE by default. Use gtk_box_set_homogeneous() to set this
3741  * field.
3742  */
3743 public struct GtkBox{}
3744 // GList *children;
3745 // GtkBox.html
3746 // short spacing;
3747 // GtkBox.html
3748 // uint homogeneous : 1;
3749 // GtkBox.html
3750
3751
3752 /**
3753  * The GtkBoxChild holds a child widget of GtkBox and describes
3754  * how the child is to be packed into the GtkBox. Use
3755  * gtk_box_query_child_packing() and gtk_box_set_child_packing() to query
3756  * and reset the padding,
3757  * expand, fill,
3758  * and pack fields.
3759  * GtkBoxChild contains the following fields. (These fields
3760  * should be considered read-only. They should never be directly set by an
3761  * application.)
3762  * GtkWidget * widget;
3763  * the child widget, packed into the GtkBox.
3764  * guint16 padding;
3765  * the number of extra pixels to put between this child and its
3766  * neighbors, set when packed, zero by default.
3767  * guint expand;
3768  * flag indicates whether extra space should be given to this
3769  * child. Any extra space given to the parent GtkBox is divided up among
3770  * all children with this attribute set to TRUE; set when packed, TRUE by
3771  * default.
3772  * guint fill;
3773  * flag indicates whether any extra space given to this child due to its
3774  * expand attribute being set is actually
3775  * allocated to the child, rather than being used as padding
3776  * around the widget; set when packed, TRUE by default.
3777  * guint pack;
3778  * one of
3779  * GtkPackType indicating whether the child is packed with reference to
3780  * the start (top/left) or end (bottom/right) of the GtkBox.
3781  */
3782 public struct GtkBoxChild{}
3783 // GtkWidget *widget;
3784 // GtkBox.html
3785 // ushort padding;
3786 // GtkBox.html
3787 // uint expand : 1;
3788 // GtkBox.html
3789 // uint fill : 1;
3790 // GtkBox.html
3791 // uint pack : 1;
3792 // GtkBox.html
3793 // uint isSecondary : 1;
3794 // GtkBox.html
3795
3796
3797 /**
3798  * Main Gtk struct.
3799  * This is a read-only struct; no members should be modified directly.
3800  */
3801 public struct GtkButtonBox{}
3802
3803
3804 /**
3805  * Main Gtk struct.
3806  */
3807 public struct GtkContainer{}
3808
3809
3810 /**
3811  * Main Gtk struct.
3812  * The GtkItem struct contains private data only, and
3813  * should be accessed using the functions below.
3814  */
3815 public struct GtkItem{}
3816
3817
3818 /**
3819  * Main Gtk struct.
3820  * The GtkMisc struct contains the following fields.
3821  * (These fields should be considered read-only. They should never be set by
3822  * an application.)
3823  * gfloat xalign;
3824  * the horizontal alignment, from 0 (left) to 1 (right).
3825  * gfloat yalign;
3826  * the vertical alignment, from 0 (top) to 1 (bottom).
3827  * guint16 xpad;
3828  * the amount of space to add on the left and right of the widget,
3829  * in pixels.
3830  * guint16 ypad;
3831  * the amount of space to add on the top and bottom of the widget,
3832  * in pixels.
3833  */
3834 public struct GtkMisc{}
3835
3836
3837 /**
3838  * Main Gtk struct.
3839  * The object itself. You should never use these members directly -
3840  */
3841 public struct GtkObject{}
3842
3843
3844 /**
3845  * Main Gtk struct.
3846  */
3847 public struct GtkPaned{}
3848
3849
3850 /**
3851  * Main Gtk struct.
3852  */
3853 public struct GtkRange{}
3854
3855
3856 /**
3857  * Main Gtk struct.
3858  * The GtkScale struct contains the following fields.
3859  * (These fields should be considered read-only. They should never be set by
3860  * an application.)
3861  * guint draw_value;
3862  * non-zero if the scale's current value is displayed next to the
3863  * slider.
3864  * guint value_pos;
3865  * the position in which the textual value is displayed, selected from
3866  * GtkPositionType.
3867  */
3868 public struct GtkScale{}
3869
3870
3871 /**
3872  * Main Gtk struct.
3873  * The GtkScrollbar struct does not contain any public data.
3874  * Style Property Details
3875  * The "fixed-slider-length" style property
3876  */
3877 public struct GtkScrollbar{}
3878
3879
3880 /**
3881  * Main Gtk struct.
3882  * The GtkSeparator struct contains private data only.
3883  */
3884 public struct GtkSeparator{}
3885
3886
3887 /**
3888  * Main Gtk struct.
3889  * GtkStyle*style;
3890  * The style for the widget. The style contains the colors the widget should be
3891  */
3892 public struct GtkWidget{}
3893 // /+* The style for the widget. The style contains the
3894 // GtkWidget.html
3895 // * colors the widget should be drawn inn for each state
3896 // GtkWidget.html
3897 // * along with graphics contexts used to draw with and
3898 // GtkWidget.html
3899 // * the font to use for text.
3900 // GtkWidget.html
3901 // +/
3902 // GtkWidget.html
3903 // GtkStyle *style;
3904 // GtkWidget.html
3905 // /+* The widget's desired size.
3906 // GtkWidget.html
3907 // +/
3908 // GtkWidget.html
3909 // GtkRequisition requisition;
3910 // GtkWidget.html
3911 // /+* The widget's allocated size.
3912 // GtkWidget.html
3913 // +/
3914 // GtkWidget.html
3915 // GtkAllocation allocation;
3916 // GtkWidget.html
3917 // /+* The widget's window or its parent window if it does
3918 // GtkWidget.html
3919 // * not have a window. (Which will be indicated by the
3920 // GtkWidget.html
3921 // * GTK_NO_WINDOW flag being set).
3922 // GtkWidget.html
3923 // +/
3924 // GtkWidget.html
3925 // GdkWindow *window;
3926 // GtkWidget.html
3927 // /+* The widget's parent.
3928 // GtkWidget.html
3929 // +/
3930 // GtkWidget.html
3931 // GtkWidget *parent;
3932 // GtkWidget.html
3933
3934
3935 /**
3936  * activate_signal
3937  * The signal to emit when a widget of this class is activated,
3938  * gtk_widget_activate() handles the emission. Implementation of this
3939  * signal is optional.
3940  * set_scroll_adjustment_signal
3941  * This signal is emitted when a widget of this class is added
3942  * to a scrolling aware parent, gtk_widget_set_scroll_adjustments()
3943  * handles the emission.
3944  * Implementation of this signal is optional.
3945  */
3946 public struct GtkWidgetClass{}
3947 // /+* The object class structure needs to be the first
3948 // GtkWidget.html
3949 // * element inn the widget class structure inn order for
3950 // GtkWidget.html
3951 // * the class mechanism to work correctly. This allows a
3952 // GtkWidget.html
3953 // * GtkWidgetClass pointer to be cast to a GtkObjectClass
3954 // GtkWidget.html
3955 // * pointer.
3956 // GtkWidget.html
3957 // +/
3958 // GtkWidget.html
3959 // GtkObjectClass parentClass;
3960 // GtkWidget.html
3961 // uint activateSignal;
3962 // GtkWidget.html
3963 // uint setScrollAdjustmentsSignal;
3964 // GtkWidget.html
3965
3966
3967 /**
3968  * A GtkRequisition represents the desired size of a widget. See
3969  * the section called Size Requisition for more information.
3970  * gintwidth;
3971  * the widget's desired width
3972  * gintheight;
3973  * the widget's desired height
3974  */
3975 public struct GtkRequisition
3976 {
3977         int width;
3978         int height;
3979 }
3980
3981
3982 /**
3983  * A GtkAllocation of a widget represents region which has been allocated to the
3984  * widget by its parent. It is a subregion of its parents allocation. See
3985  * the section called Size Allocation for more information.
3986  * gintx;
3987  * the X position of the widget's area relative to its parents allocation.
3988  * ginty;
3989  * the Y position of the widget's area relative to its parents allocation.
3990  * gintwidth;
3991  * the width of the widget's allocated area.
3992  * gintheight;
3993  * the height of the widget's allocated area.
3994  */
3995 public struct GtkAllocation
3996 {
3997         int x;
3998         int y;
3999         int width;
4000         int height;
4001 }
4002
4003
4004 public struct GtkSelectionData{}
4005 // GdkAtom selection;
4006 // GtkWidget.html
4007 // GdkAtom target;
4008 // GtkWidget.html
4009 // GdkAtom type;
4010 // GtkWidget.html
4011 // int format;
4012 // GtkWidget.html
4013 // char *data;
4014 // GtkWidget.html
4015 // int length;
4016 // GtkWidget.html
4017 // GdkDisplay *display;
4018 // GtkWidget.html
4019
4020
4021 public struct GtkWidgetAuxInfo
4022 {
4023         int x;
4024         int y;
4025         int width;
4026         int height;
4027         uint bitfield;
4028         //uint xSet : 1;
4029 }
4030
4031
4032 public struct GtkWidgetShapeInfo{}
4033 // short offsetX;
4034 // GtkWidget.html
4035 // short offsetY;
4036 // GtkWidget.html
4037 // GdkBitmap *shapeMask;
4038 // GtkWidget.html
4039
4040
4041 /**
4042  * Main Gtk struct.
4043  */
4044 public struct GtkIMContext{}
4045
4046
4047 /**
4048  * Main Gtk struct.
4049  */
4050 public struct GtkPlug{}
4051
4052
4053 /**
4054  * Main Gtk struct.
4055  * The GtkSocket structure contains the plug_window
4056  * field. (This field should be considered read-only. It should
4057  * never be set by an application.)
4058  */
4059 public struct GtkSocket{}
4060
4061
4062 /**
4063  * Main Gtk struct.
4064  * The GtkCurve struct contains private data only, and
4065  * should be accessed using the functions below.
4066  */
4067 public struct GtkCurve{}
4068
4069
4070 /**
4071  * Main Gtk struct.
4072  * The GtkGammaCurve struct contains private data only, and
4073  * should be accessed using the functions below.
4074  */
4075 public struct GtkGammaCurve{}
4076
4077
4078 /**
4079  * Main Gtk struct.
4080  * All distances are in 1/72nd's of an inch. (According to Adobe thats a point, but
4081  * points are really 1/72.27 in.)
4082  */
4083 public struct GtkRuler{}
4084
4085
4086 /**
4087  * This should be points_per_unit. This is the size of the unit in 1/72nd's of an inch and has nothing to do with screen pixels.
4088  */
4089 public struct GtkRulerMetric{}
4090 // char *metricName;
4091 // GtkRuler.html
4092 // char *abbrev;
4093 // GtkRuler.html
4094 // /+* This should be pointsPerUnit. This is the size of the unit
4095 // GtkRuler.html
4096 // * inn 1/72nd's of an inch and has nothing to do with screen pixels +/
4097 // GtkRuler.html
4098 // double pixelsPerUnit;
4099 // GtkRuler.html
4100 // double rulerScale[10];
4101 // GtkRuler.html
4102 // int subdivide[5]; /+* five possible modes of subdivision +/
4103 // GtkRuler.html
4104
4105
4106 /**
4107  * Main Gtk struct.
4108  * The GtkHRuler struct contains private data and should be accessed
4109  * with the functions below.
4110  */
4111 public struct GtkHRuler{}
4112
4113
4114 /**
4115  * Main Gtk struct.
4116  * The GtkVRuler struct contains private data and should be accessed
4117  * using the functions below.
4118  */
4119 public struct GtkVRuler{}
4120
4121
4122 /**
4123  * Main Gtk struct.
4124  * Warning
4125  * GtkItemFactory is deprecated and should not be used in newly-written code.
4126  */
4127 public struct GtkItemFactory{}
4128
4129
4130 /**
4131  * Warning
4132  * GtkItemFactoryEntry is deprecated and should not be used in newly-written code.
4133  */
4134 public struct GtkItemFactoryEntry{}
4135 // char *path;
4136 // GtkItemFactory.html
4137 // char *accelerator;
4138 // GtkItemFactory.html
4139 // GtkItemFactoryCallback callback;
4140 // GtkItemFactory.html
4141 // uint callbackAction;
4142 // GtkItemFactory.html
4143 // /+* possible values:
4144 // GtkItemFactory.html
4145 // * NULL -> "<Item>"
4146 // GtkItemFactory.html
4147 // * "" -> "<Item>"
4148 // GtkItemFactory.html
4149 // * "<Title>" -> create a title item
4150 // GtkItemFactory.html
4151 // * "<Item>" -> create a simple item
4152 // GtkItemFactory.html
4153 // * "<ImageItem>" -> create an item holding an image
4154 // GtkItemFactory.html
4155 // * "<StockItem>" -> create an item holding a stock image
4156 // GtkItemFactory.html
4157 // * "<CheckItem>" -> create a check item
4158 // GtkItemFactory.html
4159 // * "<ToggleItem>" -> create a toggle item
4160 // GtkItemFactory.html
4161 // * "<RadioItem>" -> create a radio item
4162 // GtkItemFactory.html
4163 // * <path> -> path of a radio item to link against
4164 // GtkItemFactory.html
4165 // * "<Separator>" -> create a separator
4166 // GtkItemFactory.html
4167 // * "<Tearoff>" -> create a tearoff separator
4168 // GtkItemFactory.html
4169 // * "<Branch>" -> create an item to hold sub items
4170 // GtkItemFactory.html
4171 // * "<LastBranch>" -> create a right justified item to hold sub items
4172 // GtkItemFactory.html
4173 // +/
4174 // GtkItemFactory.html
4175 // char *itemType;
4176 // GtkItemFactory.html
4177 // /+* Extra data for some item types:
4178 // GtkItemFactory.html
4179 // * ImageItem -> pointer to inlined pixbuf stream
4180 // GtkItemFactory.html
4181 // * StockItem -> name of stock item
4182 // GtkItemFactory.html
4183 // +/
4184 // GtkItemFactory.html
4185 // void* extraData;
4186 // GtkItemFactory.html
4187
4188
4189 /**
4190  * Warning
4191  * GtkItemFactoryItem is deprecated and should not be used in newly-written code.
4192  */
4193 public struct GtkItemFactoryItem{}
4194 // char *path;
4195 // GtkItemFactory.html
4196 // GSList *widgets;
4197 // GtkItemFactory.html
4198
4199
4200 /**
4201  * Main Gtk struct.
4202  * The GtkProgress struct contains private data only.
4203  * and should be accessed using the functions below.
4204  */
4205 public struct GtkProgress{}
4206
4207
4208 /*
4209  * Returns whether the style is attached to a window.
4210  * style:
4211  * a GtkStyle.
4212  */
4213 // TODO
4214 // #define GTK_STYLE_ATTACHED(style)    (GTK_STYLE (style)->attach_count > 0)
4215
4216 /*
4217  * Warning
4218  * gtk_style_apply_default_pixmap is deprecated and should not be used in newly-written code.
4219  * Deprecated alias for gtk_style_apply_default_background().
4220  * s:
4221  * gw:
4222  * st:
4223  * a:
4224  * x:
4225  * y:
4226  * w:
4227  * h:
4228  */
4229 // TODO
4230 // #define gtk_style_apply_default_pixmap(s,gw,st,a,x,y,w,h) gtk_style_apply_default_background (s,gw,1,st,a,x,y,w,h)
4231
4232 /*
4233  * Returns TRUE if the version of the GTK+ header files is the same
4234  * as or newer than the passed-in version.
4235  * major:
4236  * major version (e.g. 1 for version 1.2.5)
4237  * minor:
4238  * minor version (e.g. 2 for version 1.2.5)
4239  * micro:
4240  * micro version (e.g. 5 for version 1.2.5)
4241  */
4242 // TODO
4243 // #define GTK_CHECK_VERSION(major,minor,micro)
4244
4245 /*
4246  * Warning
4247  * gtk_signal_lookup is deprecated and should not be used in newly-written code. Use g_signal_lookup() instead.
4248  * Given the name of the signal and the type of object it connects
4249  * to, get the signal's identifying integer. Emitting the signal
4250  * by number is somewhat faster than using the name each time.
4251  * It also tries the ancestors of the given type.
4252  * name:
4253  * the signal's name, e.g. clicked.
4254  * object_type:
4255  * the type that the signal operates on, e.g. GTK_TYPE_BUTTON.
4256  * Returns:
4257  * the signal's identifying number, or 0 if no signal was found.
4258  */
4259 // TODO
4260 // #define gtk_signal_lookup(name,object_type)
4261
4262 /*
4263  * Warning
4264  * gtk_signal_name is deprecated and should not be used in newly-written code. Use g_signal_name() instead.
4265  * Given the signal's identifier, finds its name.
4266  * Two different signals may have the same name, if they have differing types.
4267  * signal_id:
4268  * the signal's identifying number.
4269  * Returns:
4270  * the signal name, or NULL if the signal number was invalid.
4271  */
4272 // TODO
4273 // #define gtk_signal_name(signal_id)
4274
4275 /*
4276  * Warning
4277  * gtk_signal_emit_stop is deprecated and should not be used in newly-written code. Use g_signal_stop_emission() instead.
4278  * This function aborts a signal's current emission.
4279  * It will prevent the default method from running,
4280  * if the signal was GTK_RUN_LAST and you connected
4281  * normally (i.e. without the "after" flag).
4282  * It will print a warning if used on a signal which
4283  * isn't being emitted.
4284  * object:
4285  * the object whose signal handlers you wish to stop.
4286  * signal_id:
4287  * the signal identifier, as returned by g_signal_lookup().
4288  */
4289 // TODO
4290 // #define gtk_signal_emit_stop(object,signal_id)
4291
4292 /*
4293  * Warning
4294  * gtk_signal_connect is deprecated and should not be used in newly-written code. Use g_signal_connect() instead.
4295  * Attaches a function pointer and user data to a signal for
4296  * a particular object.
4297  * The GtkSignalFunction takes a GtkObject as its first parameter.
4298  * It will be the same object as the one you're connecting
4299  * the hook to. The func_data will be passed as the last parameter
4300  * to the hook.
4301  * All else being equal, signal handlers are invoked in the order
4302  * connected (see gtk_signal_emit() for the other details of
4303  * which order things are called in).
4304  * Here is how one passes an integer as user data,
4305  * for when you just want to specify a constant int
4306  * as parameter to your function:
4307  * static void button_clicked_int (GtkButton* button, gpointer func_data)
4308  * {
4309          *      g_print ("button pressed: %d\n", GPOINTER_TO_INT (func_data));
4310  * }
4311  * /+* By calling this function, you will make the g_print above
4312  *  * execute, printing the number passed as `to_print'. +/
4313  * static void attach_print_signal (GtkButton* button, gint to_print)
4314  * {
4315          *      gtk_signal_connect (GTK_OBJECT (button), "clicked",
4316          *              GTK_SIGNAL_FUNC (button_clicked_int),
4317          *              GINT_TO_POINTER (to_print));
4318  * }
4319  * object:
4320  * the object associated with the signal, e.g. if a button
4321  * is getting pressed, this is that button.
4322  * name:
4323  * name of the signal.
4324  * func:
4325  * function pointer to attach to the signal.
4326  * func_data:
4327  * value to pass as to your function (through the marshaller).
4328  * Returns:
4329  * the connection id.
4330  */
4331 // TODO
4332 // #define gtk_signal_connect(object,name,func,func_data)
4333
4334 /*
4335  * Warning
4336  * gtk_signal_connect_after is deprecated and should not be used in newly-written code. Use g_signal_connect_after() instead.
4337  * Attaches a function pointer and user data to a signal
4338  * so that this handler will be called after the other handlers.
4339  * object:
4340  * the object associated with the signal.
4341  * name:
4342  * name of the signal.
4343  * func:
4344  * function pointer to attach to the signal.
4345  * func_data:
4346  * value to pass as to your function (through the marshaller).
4347  * Returns:
4348  * the unique identifier for this attachment: the connection id.
4349  */
4350 // TODO
4351 // #define gtk_signal_connect_after(object,name,func,func_data)
4352
4353 /*
4354  * Warning
4355  * gtk_signal_connect_object is deprecated and should not be used in newly-written code. Use g_signal_connect_swapped() instead.
4356  * This function is for registering a callback that will
4357  * call another object's callback. That is,
4358  * instead of passing the object which is responsible
4359  * for the event as the first parameter of the callback,
4360  * it is switched with the user data (so the object which emits
4361  * the signal will be the last parameter, which is where the
4362  * user data usually is).
4363  * This is useful for passing a standard function in as a callback.
4364  * For example, if you wanted a button's press to gtk_widget_show()
4365  * some widget, you could write:
4366  * gtk_signal_connect_object (button, "clicked", gtk_widget_show, window);
4367  * object:
4368  * the object which emits the signal.
4369  * name:
4370  * the name of the signal.
4371  * func:
4372  * the function to callback.
4373  * slot_object:
4374  * the object to pass as the first parameter to func.
4375  * (Though it pretends to take an object, you can
4376  * really pass any gpointer as the slot_object .)
4377  * Returns:
4378  * the connection id.
4379  */
4380 // TODO
4381 // #define gtk_signal_connect_object(object,name,func,slot_object)
4382
4383 /*
4384  * Warning
4385  * gtk_signal_connect_object_after is deprecated and should not be used in newly-written code. Use g_signal_connect_data() instead, passing
4386  * G_CONNECT_AFTER|G_CONNECT_SWAPPED as connect_flags.
4387  * Attaches a signal hook to a signal, passing in an alternate
4388  * object as the first parameter, and guaranteeing
4389  * that the default handler and all normal
4390  * handlers are called first.
4391  * object:
4392  * the object associated with the signal.
4393  * name:
4394  * name of the signal.
4395  * func:
4396  * function pointer to attach to the signal.
4397  * slot_object:
4398  * the object to pass as the first parameter to func.
4399  * Returns:
4400  * the connection id.
4401  */
4402 // TODO
4403 // #define gtk_signal_connect_object_after(object,name,func,slot_object)
4404
4405 /*
4406  * Warning
4407  * gtk_signal_disconnect is deprecated and should not be used in newly-written code. Use g_signal_handler_disconnect() instead.
4408  * Destroys a user-defined handler connection.
4409  * object:
4410  * the object which the handler pertains to.
4411  * handler_id:
4412  * the connection id.
4413  */
4414 // TODO
4415 // #define gtk_signal_disconnect(object,handler_id)
4416
4417 /*
4418  * Warning
4419  * gtk_signal_disconnect_by_func is deprecated and should not be used in newly-written code. Use g_signal_handlers_disconnect_by_func() instead.
4420  * Destroys all connections for a particular object, with
4421  * the given function-pointer and user-data.
4422  * object:
4423  * the object which emits the signal.
4424  * func:
4425  * the function pointer to search for.
4426  * data:
4427  * the user data to search for.
4428  */
4429 // TODO
4430 // #define gtk_signal_disconnect_by_func(object,func,data)
4431
4432 /*
4433  * Warning
4434  * gtk_signal_disconnect_by_data is deprecated and should not be used in newly-written code. Use g_signal_handlers_disconnect_matched() instead.
4435  * Destroys all connections for a particular object, with
4436  * the given user-data.
4437  * object:
4438  * the object which emits the signal.
4439  * data:
4440  * the user data to search for.
4441  */
4442 // TODO
4443 // #define gtk_signal_disconnect_by_data(object,data)
4444
4445 /*
4446  * Warning
4447  * gtk_signal_handler_block is deprecated and should not be used in newly-written code. Use g_signal_handler_block() instead.
4448  * Prevents a user-defined handler from being invoked. All other
4449  * signal processing will go on as normal, but this particular
4450  * handler will ignore it.
4451  * object:
4452  * the object which emits the signal to block.
4453  * handler_id:
4454  * the connection id.
4455  */
4456 // TODO
4457 // #define gtk_signal_handler_block(object,handler_id)
4458
4459 /*
4460  * Warning
4461  * gtk_signal_handler_block_by_func is deprecated and should not be used in newly-written code. Use g_signal_handlers_block_by_func() instead.
4462  * Prevents a user-defined handler from being invoked, by reference to
4463  * the user-defined handler's function pointer and user data. (It may result in
4464  * multiple hooks being blocked, if you've called connect multiple times.)
4465  * object:
4466  * the object which emits the signal to block.
4467  * func:
4468  * the function pointer of the handler to block.
4469  * data:
4470  * the user data of the handler to block.
4471  */
4472 // TODO
4473 // #define gtk_signal_handler_block_by_func(object,func,data)
4474
4475 /*
4476  * Warning
4477  * gtk_signal_handler_block_by_data is deprecated and should not be used in newly-written code. Use g_signal_handlers_block_matched() instead.
4478  * Prevents all user-defined handlers with a certain user data from being invoked.
4479  * object:
4480  * the object which emits the signal we want to block.
4481  * data:
4482  * the user data of the handlers to block.
4483  */
4484 // TODO
4485 // #define gtk_signal_handler_block_by_data(object,data)
4486
4487 /*
4488  * Warning
4489  * gtk_signal_handler_unblock is deprecated and should not be used in newly-written code. Use g_signal_handler_unblock() instead.
4490  * Undoes a block, by connection id. Note that undoing a block doesn't
4491  * necessarily make the hook callable, because if you block a
4492  * hook twice, you must unblock it twice.
4493  * object:
4494  * the object which emits the signal we want to unblock.
4495  * handler_id:
4496  * the emission handler identifier, as returned by
4497  * gtk_signal_connect(), etc.
4498  */
4499 // TODO
4500 // #define gtk_signal_handler_unblock(object,handler_id)
4501
4502 /*
4503  * Warning
4504  * gtk_signal_handler_unblock_by_func is deprecated and should not be used in newly-written code. Use g_signal_handlers_unblock_by_func() instead.
4505  * Undoes a block, by function pointer and data.
4506  * Note that undoing a block doesn't
4507  * necessarily make the hook callable, because if you block a
4508  * hook twice, you must unblock it twice.
4509  * object:
4510  * the object which emits the signal we want to unblock.
4511  * func:
4512  * the function pointer to search for.
4513  * data:
4514  * the user data to search for.
4515  */
4516 // TODO
4517 // #define gtk_signal_handler_unblock_by_func(object,func,data)
4518
4519 /*
4520  * Warning
4521  * gtk_signal_handler_unblock_by_data is deprecated and should not be used in newly-written code. Use g_signal_handlers_unblock_matched() instead.
4522  * Undoes block(s), to all signals for a particular object
4523  * with a particular user-data pointer
4524  * object:
4525  * the object which emits the signal we want to unblock.
4526  * data:
4527  * the user data to search for.
4528  */
4529 // TODO
4530 // #define gtk_signal_handler_unblock_by_data(object,data)
4531
4532 /*
4533  * Warning
4534  * gtk_signal_handler_pending is deprecated and should not be used in newly-written code. Use g_signal_has_handler_pending() instead.
4535  * Returns a connection id corresponding to a given signal id and object.
4536  * One example of when you might use this is when the arguments
4537  * to the signal are difficult to compute. A class implementor
4538  * may opt to not emit the signal if no one is attached anyway,
4539  * thus saving the cost of building the arguments.
4540  * object:
4541  * the object to search for the desired user-defined handler.
4542  * signal_id:
4543  * the number of the signal to search for.
4544  * may_be_blocked:
4545  * whether it is acceptable to return a blocked
4546  * handler.
4547  * Returns:
4548  * the connection id, if a connection was found. 0 otherwise.
4549  */
4550 // TODO
4551 // #define gtk_signal_handler_pending(object,signal_id,may_be_blocked)
4552
4553 /*
4554  * Warning
4555  * gtk_signal_handler_pending_by_func is deprecated and should not be used in newly-written code.
4556  * Returns a connection id corresponding to a given signal id, object, function
4557  * pointer and user data.
4558  * object:
4559  * the object to search for the desired handler.
4560  * signal_id:
4561  * the number of the signal to search for.
4562  * may_be_blocked:
4563  * whether it is acceptable to return a blocked
4564  * handler.
4565  * func:
4566  * the function pointer to search for.
4567  * data:
4568  * the user data to search for.
4569  * Returns:
4570  * the connection id, if a handler was found. 0 otherwise.
4571  */
4572 // TODO
4573 // #define gtk_signal_handler_pending_by_func(object,signal_id,may_be_blocked,func,data)
4574
4575 /*
4576  * Warning
4577  * GTK_CLASS_NAME is deprecated and should not be used in newly-written code. Use g_type_name() and G_TYPE_FROM_CLASS() instead.
4578  * Returns the type name of class.
4579  * class:
4580  * a GtkTypeClass.
4581  */
4582 // TODO
4583 // #define GTK_CLASS_NAME(class)                (g_type_name (G_TYPE_FROM_CLASS (class)))
4584
4585 /*
4586  * Warning
4587  * GTK_CLASS_TYPE is deprecated and should not be used in newly-written code. Use G_TYPE_FROM_CLASS() instead.
4588  * Returns the type of class.
4589  * class:
4590  * a GtkTypeClass.
4591  */
4592 // TODO
4593 // #define GTK_CLASS_TYPE(class)                (G_TYPE_FROM_CLASS (class))
4594
4595 /*
4596  * Warning
4597  * GTK_TYPE_IS_OBJECT is deprecated and should not be used in newly-written code. Use G_TYPE_IS_OBJECT() instead.
4598  * Returns TRUE if type is a GTK_TYPE_OBJECT.
4599  * type:
4600  * a GtkType.
4601  */
4602 // TODO
4603 // #define GTK_TYPE_IS_OBJECT(type)     (g_type_is_a ((type), GTK_TYPE_OBJECT))
4604
4605 /*
4606  * Just a macroized cast into a GtkSignalFunc.
4607  * f:
4608  */
4609 // TODO
4610 // #define GTK_SIGNAL_FUNC(f)    ((GtkSignalFunc) (f))
4611
4612 /*
4613  * Warning
4614  * GTK_VALUE_CHAR is deprecated and should not be used in newly-written code.
4615  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_CHAR.
4616  * a:
4617  * a GtkArg.
4618  */
4619 // TODO
4620 // #define GTK_VALUE_CHAR(a)    ((a).d.char_data)
4621
4622 /*
4623  * Warning
4624  * GTK_VALUE_UCHAR is deprecated and should not be used in newly-written code.
4625  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_UCHAR.
4626  * a:
4627  * a GtkArg.
4628  */
4629 // TODO
4630 // #define GTK_VALUE_UCHAR(a)   ((a).d.uchar_data)
4631
4632 /*
4633  * Warning
4634  * GTK_VALUE_BOOL is deprecated and should not be used in newly-written code.
4635  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_BOOL.
4636  * a:
4637  * a GtkArg.
4638  */
4639 // TODO
4640 // #define GTK_VALUE_BOOL(a)    ((a).d.bool_data)
4641
4642 /*
4643  * Warning
4644  * GTK_VALUE_INT is deprecated and should not be used in newly-written code.
4645  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_INT.
4646  * a:
4647  * a GtkArg.
4648  */
4649 // TODO
4650 // #define GTK_VALUE_INT(a)     ((a).d.int_data)
4651
4652 /*
4653  * Warning
4654  * GTK_VALUE_UINT is deprecated and should not be used in newly-written code.
4655  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_UINT.
4656  * a:
4657  * a GtkArg.
4658  */
4659 // TODO
4660 // #define GTK_VALUE_UINT(a)    ((a).d.uint_data)
4661
4662 /*
4663  * Warning
4664  * GTK_VALUE_LONG is deprecated and should not be used in newly-written code.
4665  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_LONG.
4666  * a:
4667  * a GtkArg.
4668  */
4669 // TODO
4670 // #define GTK_VALUE_LONG(a)    ((a).d.long_data)
4671
4672 /*
4673  * Warning
4674  * GTK_VALUE_ULONG is deprecated and should not be used in newly-written code.
4675  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_ULONG.
4676  * a:
4677  * a GtkArg.
4678  */
4679 // TODO
4680 // #define GTK_VALUE_ULONG(a)   ((a).d.ulong_data)
4681
4682 /*
4683  * Warning
4684  * GTK_VALUE_FLOAT is deprecated and should not be used in newly-written code.
4685  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_FLOAT.
4686  * a:
4687  * a GtkArg.
4688  */
4689 // TODO
4690 // #define GTK_VALUE_FLOAT(a)   ((a).d.float_data)
4691
4692 /*
4693  * Warning
4694  * GTK_VALUE_DOUBLE is deprecated and should not be used in newly-written code.
4695  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_DOUBLE.
4696  * a:
4697  * a GtkArg.
4698  */
4699 // TODO
4700 // #define GTK_VALUE_DOUBLE(a)  ((a).d.double_data)
4701
4702 /*
4703  * Warning
4704  * GTK_VALUE_STRING is deprecated and should not be used in newly-written code.
4705  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_STRING.
4706  * a:
4707  * a GtkArg.
4708  */
4709 // TODO
4710 // #define GTK_VALUE_STRING(a)  ((a).d.string_data)
4711
4712 /*
4713  * Warning
4714  * GTK_VALUE_ENUM is deprecated and should not be used in newly-written code.
4715  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_ENUM.
4716  * a:
4717  * a GtkArg.
4718  */
4719 // TODO
4720 // #define GTK_VALUE_ENUM(a)    ((a).d.int_data)
4721
4722 /*
4723  * Warning
4724  * GTK_VALUE_FLAGS is deprecated and should not be used in newly-written code.
4725  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_FLAGS.
4726  * a:
4727  * a GtkArg.
4728  */
4729 // TODO
4730 // #define GTK_VALUE_FLAGS(a)   ((a).d.uint_data)
4731
4732 /*
4733  * Warning
4734  * GTK_VALUE_BOXED is deprecated and should not be used in newly-written code.
4735  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_BOXED.
4736  * a:
4737  * a GtkArg.
4738  */
4739 // TODO
4740 // #define GTK_VALUE_BOXED(a)   ((a).d.pointer_data)
4741
4742 /*
4743  * Warning
4744  * GTK_VALUE_POINTER is deprecated and should not be used in newly-written code.
4745  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_POINTER.
4746  * a:
4747  * a GtkArg.
4748  */
4749 // TODO
4750 // #define GTK_VALUE_POINTER(a) ((a).d.pointer_data)
4751
4752 /*
4753  * Warning
4754  * GTK_VALUE_OBJECT is deprecated and should not be used in newly-written code.
4755  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_OBJECT.
4756  * a:
4757  * a GtkArg.
4758  */
4759 // TODO
4760 // #define GTK_VALUE_OBJECT(a)  ((a).d.object_data)
4761
4762 /*
4763  * Warning
4764  * GTK_VALUE_SIGNAL is deprecated and should not be used in newly-written code.
4765  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_SIGNAL.
4766  * a:
4767  * a GtkArg.
4768  */
4769 // TODO
4770 // #define GTK_VALUE_SIGNAL(a)  ((a).d.signal_data)
4771
4772 /*
4773  * Warning
4774  * GTK_RETLOC_CHAR is deprecated and should not be used in newly-written code.
4775  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_CHAR.
4776  * a:
4777  * a GtkArg.
4778  */
4779 // TODO
4780 // #define GTK_RETLOC_CHAR(a)   ((gchar*)       (a).d.pointer_data)
4781
4782 /*
4783  * Warning
4784  * GTK_RETLOC_UCHAR is deprecated and should not be used in newly-written code.
4785  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_UCHAR.
4786  * a:
4787  * a GtkArg.
4788  */
4789 // TODO
4790 // #define GTK_RETLOC_UCHAR(a)  ((guchar*)      (a).d.pointer_data)
4791
4792 /*
4793  * Warning
4794  * GTK_RETLOC_BOOL is deprecated and should not be used in newly-written code.
4795  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_BOOL.
4796  * a:
4797  * a GtkArg.
4798  */
4799 // TODO
4800 // #define GTK_RETLOC_BOOL(a)   ((gboolean*)    (a).d.pointer_data)
4801
4802 /*
4803  * Warning
4804  * GTK_RETLOC_INT is deprecated and should not be used in newly-written code.
4805  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_INT.
4806  * a:
4807  * a GtkArg.
4808  */
4809 // TODO
4810 // #define GTK_RETLOC_INT(a)    ((gint*)        (a).d.pointer_data)
4811
4812 /*
4813  * Warning
4814  * GTK_RETLOC_UINT is deprecated and should not be used in newly-written code.
4815  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_UINT.
4816  * a:
4817  * a GtkArg.
4818  */
4819 // TODO
4820 // #define GTK_RETLOC_UINT(a)   ((guint*)       (a).d.pointer_data)
4821
4822 /*
4823  * Warning
4824  * GTK_RETLOC_LONG is deprecated and should not be used in newly-written code.
4825  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_LONG.
4826  * a:
4827  * a GtkArg.
4828  */
4829 // TODO
4830 // #define GTK_RETLOC_LONG(a)   ((glong*)       (a).d.pointer_data)
4831
4832 /*
4833  * Warning
4834  * GTK_RETLOC_ULONG is deprecated and should not be used in newly-written code.
4835  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_ULONG.
4836  * a:
4837  * a GtkArg.
4838  */
4839 // TODO
4840 // #define GTK_RETLOC_ULONG(a)  ((gulong*)      (a).d.pointer_data)
4841
4842 /*
4843  * Warning
4844  * GTK_RETLOC_FLOAT is deprecated and should not be used in newly-written code.
4845  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_FLOAT.
4846  * a:
4847  * a GtkArg.
4848  */
4849 // TODO
4850 // #define GTK_RETLOC_FLOAT(a)  ((gfloat*)      (a).d.pointer_data)
4851
4852 /*
4853  * Warning
4854  * GTK_RETLOC_DOUBLE is deprecated and should not be used in newly-written code.
4855  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_DOUBLE.
4856  * a:
4857  * a GtkArg.
4858  */
4859 // TODO
4860 // #define GTK_RETLOC_DOUBLE(a) ((gdouble*)     (a).d.pointer_data)
4861
4862 /*
4863  * Warning
4864  * GTK_RETLOC_STRING is deprecated and should not be used in newly-written code.
4865  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_STRING.
4866  * a:
4867  * a GtkArg.
4868  */
4869 // TODO
4870 // #define GTK_RETLOC_STRING(a) ((gchar**)      (a).d.pointer_data)
4871
4872 /*
4873  * Warning
4874  * GTK_RETLOC_ENUM is deprecated and should not be used in newly-written code.
4875  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_ENUM.
4876  * a:
4877  * a GtkArg.
4878  */
4879 // TODO
4880 // #define GTK_RETLOC_ENUM(a)   ((gint*)        (a).d.pointer_data)
4881
4882 /*
4883  * Warning
4884  * GTK_RETLOC_FLAGS is deprecated and should not be used in newly-written code.
4885  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_FLAGS.
4886  * a:
4887  * a GtkArg.
4888  */
4889 // TODO
4890 // #define GTK_RETLOC_FLAGS(a)  ((guint*)       (a).d.pointer_data)
4891
4892 /*
4893  * Warning
4894  * GTK_RETLOC_BOXED is deprecated and should not be used in newly-written code.
4895  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_BOXED.
4896  * a:
4897  * a GtkArg.
4898  */
4899 // TODO
4900 // #define GTK_RETLOC_BOXED(a)  ((gpointer*)    (a).d.pointer_data)
4901
4902 /*
4903  * Warning
4904  * GTK_RETLOC_POINTER is deprecated and should not be used in newly-written code.
4905  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_POINTER.
4906  * a:
4907  * a GtkArg.
4908  */
4909 // TODO
4910 // #define GTK_RETLOC_POINTER(a)        ((gpointer*)    (a).d.pointer_data)
4911
4912 /*
4913  * Warning
4914  * GTK_RETLOC_OBJECT is deprecated and should not be used in newly-written code.
4915  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_OBJECT.
4916  * a:
4917  * a GtkArg.
4918  */
4919 // TODO
4920 // #define GTK_RETLOC_OBJECT(a) ((GtkObject**)  (a).d.pointer_data)
4921
4922 /*
4923  * Warning
4924  * gtk_type_name is deprecated and should not be used in newly-written code.
4925  * Returns a pointer to the name of a type, or NULL if it has none.
4926  * type:
4927  * a GtkType.
4928  * Returns:
4929  * a pointer to the name of a type, or NULL if it has none.
4930  */
4931 // TODO
4932 // #define      gtk_type_name(type)              g_type_name (type)
4933
4934 /*
4935  * Warning
4936  * gtk_type_from_name is deprecated and should not be used in newly-written code.
4937  * Gets the internal representation of a type, given its name.
4938  * name:
4939  * the name of a GTK+ type
4940  * Returns:
4941  * a GtkType.
4942  */
4943 // TODO
4944 // #define      gtk_type_from_name(name)         g_type_from_name (name)
4945
4946 /*
4947  * Warning
4948  * gtk_type_parent is deprecated and should not be used in newly-written code.
4949  * Returns the parent type of a GtkType.
4950  * type:
4951  * a GtkType.
4952  * Returns:
4953  * the GtkType of the parent.
4954  */
4955 // TODO
4956 // #define      gtk_type_parent(type)            g_type_parent (type)
4957
4958 /*
4959  * Warning
4960  * gtk_type_is_a is deprecated and should not be used in newly-written code.
4961  * Looks in the type hierarchy to see if type has is_a_type among its
4962  * ancestors. Do so with a simple lookup, not a loop.
4963  * type:
4964  * a GtkType.
4965  * is_a_type:
4966  * another GtkType.
4967  * Returns:
4968  * TRUE if type is a is_a_type.
4969  */
4970 // TODO
4971 // #define      gtk_type_is_a(type, is_a_type)   g_type_is_a ((type), (is_a_type))
4972
4973 /*
4974  * Warning
4975  * gtk_tree_model_get_iter_root is deprecated and should not be used in newly-written code.
4976  * A alternate name for gtk_tree_model_get_iter_first() provided for
4977  * compatibility reasons; this macro will be deprecated in future
4978  * versions of GTK+.
4979  * tree_model:
4980  *  A GtkTreeModel.
4981  * iter:
4982  * uninitialized GtkTreeIter.
4983  * Returns:
4984  *  TRUE, if iter was set.
4985  */
4986 // TODO
4987 // #define gtk_tree_model_get_iter_root(tree_model, iter) gtk_tree_model_get_iter_first(tree_model, iter)
4988
4989 /*
4990  * Warning
4991  * gtk_menu_append is deprecated and should not be used in newly-written code. Use gtk_menu_shell_append() instead.
4992  * Adds a new GtkMenuItem to the end of the menu's item list.
4993  * menu:
4994  * a GtkMenu.
4995  * child:
4996  * The GtkMenuItem to add.
4997  */
4998 // TODO
4999 // #define gtk_menu_append(menu,child)  gtk_menu_shell_append ((GtkMenuShell *)(menu),(child))
5000
5001 /*
5002  * Warning
5003  * gtk_menu_prepend is deprecated and should not be used in newly-written code. Use gtk_menu_shell_prepend() instead.
5004  * Adds a new GtkMenuItem to the beginning of the menu's item list.
5005  * menu:
5006  * a GtkMenu.
5007  * child:
5008  * The GtkMenuItem to add.
5009  */
5010 // TODO
5011 // #define gtk_menu_prepend(menu,child) gtk_menu_shell_prepend ((GtkMenuShell *)(menu),(child))
5012
5013 /*
5014  * Warning
5015  * gtk_menu_insert is deprecated and should not be used in newly-written code. Use gtk_menu_shell_insert() instead.
5016  * Adds a new GtkMenuItem to the menu's item list at the position
5017  * indicated by position.
5018  * menu:
5019  * a GtkMenu.
5020  * child:
5021  * The GtkMenuItem to add.
5022  * pos:
5023  * The position in the item list where child is added.
5024  *  Positions are numbered from 0 to n-1.
5025  */
5026 // TODO
5027 // #define gtk_menu_insert(menu,child,pos)      gtk_menu_shell_insert ((GtkMenuShell *)(menu),(child),(pos))
5028
5029 /*
5030  * Warning
5031  * gtk_menu_bar_append is deprecated and should not be used in newly-written code. Use gtk_menu_shell_append() instead.
5032  * Adds a new GtkMenuItem to the end of the GtkMenuBar
5033  * menu:
5034  * a GtkMenuBar
5035  * child:
5036  * the GtkMenuItem to add
5037  */
5038 // TODO
5039 // #define gtk_menu_bar_append(menu,child)       gtk_menu_shell_append ((GtkMenuShell *)(menu),(child))
5040
5041 /*
5042  * Warning
5043  * gtk_menu_bar_prepend is deprecated and should not be used in newly-written code. Use gtk_menu_shell_prepend() instead.
5044  * Adds a new GtkMenuItem to the beginning of the GtkMenuBar
5045  * menu:
5046  * a GtkMenuBar
5047  * child:
5048  * the GtkMenuItem to add
5049  */
5050 // TODO
5051 // #define gtk_menu_bar_prepend(menu,child) gtk_menu_shell_prepend ((GtkMenuShell *)(menu),(child))
5052
5053 /*
5054  * Warning
5055  * gtk_menu_bar_insert is deprecated and should not be used in newly-written code. Use gtk_menu_shell_insert() instead.
5056  * Adds a new GtkMenuItem to the GtkMenuBar at the position defined by position
5057  * menu:
5058  * a GtkMenuBar
5059  * child:
5060  * the GtkMenuItem to add
5061  * pos:
5062  * the position in the item list where the child is added.
5063  */
5064 // TODO
5065 // #define gtk_menu_bar_insert(menu,child,pos) gtk_menu_shell_insert ((GtkMenuShell *)(menu),(child),(pos))
5066
5067 /*
5068  * Warning
5069  * gtk_menu_item_right_justify is deprecated and should not be used in newly-written code.
5070  * Sets the menu item to be right-justified. Only useful for menu bars.
5071  * menu_item:
5072  * the menu item
5073  */
5074 // TODO
5075 // #define gtk_menu_item_right_justify(menu_item) gtk_menu_item_set_right_justified ((menu_item), TRUE)
5076
5077 /*
5078  * Warning
5079  * gtk_button_box_get_spacing is deprecated and should not be used in newly-written code.
5080  * Retrieves how much space a button box is placing between each child button.
5081  * b:
5082  * a GtkButtonBox
5083  * Returns:
5084  * the current spacing applied to the buttons in widget.
5085  */
5086 // TODO
5087 // #define gtk_button_box_get_spacing(b) gtk_box_get_spacing (GTK_BOX (b))
5088
5089 /*
5090  * Warning
5091  * gtk_button_box_set_spacing is deprecated and should not be used in newly-written code.
5092  * Sets the amount of spacing between buttons in a given button box.
5093  * b:
5094  * a GtkButtonBox.
5095  * s:
5096  * the number of pixels of spacing.
5097  */
5098 // TODO
5099 // #define gtk_button_box_set_spacing(b,s) gtk_box_set_spacing (GTK_BOX (b), s)
5100
5101 /*
5102  * widget:
5103  */
5104 // TODO
5105 // #define GTK_IS_RESIZE_CONTAINER(widget) (GTK_IS_CONTAINER (widget)  ((GtkContainer*) (widget))->resize_mode != GTK_RESIZE_PARENT)
5106
5107 /*
5108  * object:
5109  * property_id:
5110  * pspec:
5111  */
5112 // TODO
5113 // #define GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID(object, property_id, pspec)
5114
5115 /*
5116  * Gets the type of an object.
5117  * object:
5118  * a GtkObject.
5119  */
5120 // TODO
5121 // #define GTK_OBJECT_TYPE(object)               (G_TYPE_FROM_INSTANCE (object))
5122
5123 /*
5124  * Gets the name of an objects type.
5125  * object:
5126  * a GtkObject.
5127  */
5128 // TODO
5129 // #define GTK_OBJECT_TYPE_NAME(object)  (g_type_name (GTK_OBJECT_TYPE (object)))
5130
5131 /*
5132  * Gets the GtkObjectFlags for an object without directly
5133  * accessing its members.
5134  * obj:
5135  * the object whose flags are returned.
5136  */
5137 // TODO
5138 // #define GTK_OBJECT_FLAGS(obj)                 (GTK_OBJECT (obj)->flags)
5139
5140 /*
5141  * Warning
5142  * GTK_OBJECT_FLOATING is deprecated and should not be used in newly-written code.
5143  * Evaluates to TRUE if the object still has its floating reference count.
5144  * See the overview documentation for GtkObject.
5145  * obj:
5146  * the object to examine.
5147  */
5148 // TODO
5149 // #define GTK_OBJECT_FLOATING(obj)      (g_object_is_floating (obj))
5150
5151 /*
5152  * Warning
5153  * gtk_paned_gutter_size is deprecated and should not be used in newly-written code.
5154  * Old name for gtk_paned_set_gutter_size().
5155  * p:
5156  * a paned widget
5157  * s:
5158  * the width of the gutter in pixels
5159  */
5160 // TODO
5161 // #define      gtk_paned_gutter_size(p,s)              (void) 0
5162
5163 /*
5164  * Warning
5165  * gtk_paned_set_gutter_size is deprecated and should not be used in newly-written code.
5166  * In older versions of GTK+, this function used to set the width of the
5167  * gutter (the area between the two panes). It does nothing now.
5168  * p:
5169  * a paned widget
5170  * s:
5171  * the width of the gutter in pixels
5172  */
5173 // TODO
5174 // #define      gtk_paned_set_gutter_size(p,s)          (void) 0
5175
5176 /*
5177  * Gets the type of a widget.
5178  * wid:
5179  * a GtkWidget.
5180  */
5181 // TODO
5182 // #define GTK_WIDGET_TYPE(wid)          (GTK_OBJECT_TYPE (wid))
5183
5184 /*
5185  * Returns the current state of the widget, as a GtkStateType.
5186  * wid:
5187  * a GtkWidget.
5188  */
5189 // TODO
5190 // #define GTK_WIDGET_STATE(wid)                 (GTK_WIDGET (wid)->state)
5191
5192 /*
5193  * Returns the saved state of the widget, as a GtkStateType.
5194  * The saved state will be restored when a widget gets sensitive
5195  * again, after it has been made insensitive with gtk_widget_set_state()
5196  * or gtk_widget_set_sensitive().
5197  * wid:
5198  * a GtkWidget.
5199  */
5200 // TODO
5201 // #define GTK_WIDGET_SAVED_STATE(wid)   (GTK_WIDGET (wid)->saved_state)
5202
5203 /*
5204  * Returns the widget flags from wid.
5205  * wid:
5206  * a GtkWidget.
5207  */
5208 // TODO
5209 // #define GTK_WIDGET_FLAGS(wid)                 (GTK_OBJECT_FLAGS (wid))
5210
5211 /*
5212  * Evaluates to TRUE if the widget is a toplevel widget.
5213  * wid:
5214  * a GtkWidget.
5215  */
5216 // TODO
5217 // #define GTK_WIDGET_TOPLEVEL(wid)      ((GTK_WIDGET_FLAGS (wid)  GTK_TOPLEVEL) != 0)
5218
5219 /*
5220  * Evaluates to TRUE if the widget doesn't have an own GdkWindow.
5221  * wid:
5222  * a GtkWidget.
5223  */
5224 // TODO
5225 // #define GTK_WIDGET_NO_WINDOW(wid)     ((GTK_WIDGET_FLAGS (wid)  GTK_NO_WINDOW) != 0)
5226
5227 /*
5228  * Evaluates to TRUE if the widget is realized.
5229  * wid:
5230  * a GtkWidget.
5231  */
5232 // TODO
5233 // #define GTK_WIDGET_REALIZED(wid)      ((GTK_WIDGET_FLAGS (wid)  GTK_REALIZED) != 0)
5234
5235 /*
5236  * Evaluates to TRUE if the widget is mapped.
5237  * wid:
5238  * a GtkWidget.
5239  */
5240 // TODO
5241 // #define GTK_WIDGET_MAPPED(wid)                ((GTK_WIDGET_FLAGS (wid)  GTK_MAPPED) != 0)
5242
5243 /*
5244  * Evaluates to TRUE if the widget is visible.
5245  * wid:
5246  * a GtkWidget.
5247  */
5248 // TODO
5249 // #define GTK_WIDGET_VISIBLE(wid)               ((GTK_WIDGET_FLAGS (wid)  GTK_VISIBLE) != 0)
5250
5251 /*
5252  * Evaluates to TRUE if the widget is mapped and visible.
5253  * wid:
5254  * a GtkWidget.
5255  */
5256 // TODO
5257 // #define GTK_WIDGET_DRAWABLE(wid)      (GTK_WIDGET_VISIBLE (wid)  GTK_WIDGET_MAPPED (wid))
5258
5259 /*
5260  * Evaluates to TRUE if the GTK_SENSITIVE flag has be set on the widget.
5261  * wid:
5262  * a GtkWidget.
5263  */
5264 // TODO
5265 // #define GTK_WIDGET_SENSITIVE(wid)     ((GTK_WIDGET_FLAGS (wid)  GTK_SENSITIVE) != 0)
5266
5267 /*
5268  * Evaluates to TRUE if the GTK_PARENT_SENSITIVE flag has be set on the widget.
5269  * wid:
5270  * a GtkWidget.
5271  */
5272 // TODO
5273 // #define GTK_WIDGET_PARENT_SENSITIVE(wid) ((GTK_WIDGET_FLAGS (wid)  GTK_PARENT_SENSITIVE) != 0)
5274
5275 /*
5276  * Evaluates to TRUE if the widget is effectively sensitive.
5277  * wid:
5278  * a GtkWidget.
5279  */
5280 // TODO
5281 // #define GTK_WIDGET_IS_SENSITIVE(wid)
5282
5283 /*
5284  * Evaluates to TRUE if the widget is able to handle focus grabs.
5285  * wid:
5286  * a GtkWidget.
5287  */
5288 // TODO
5289 // #define GTK_WIDGET_CAN_FOCUS(wid)     ((GTK_WIDGET_FLAGS (wid)  GTK_CAN_FOCUS) != 0)
5290
5291 /*
5292  * Evaluates to TRUE if the widget has grabbed the focus and no other
5293  * widget has done so more recently.
5294  * wid:
5295  * a GtkWidget.
5296  */
5297 // TODO
5298 // #define GTK_WIDGET_HAS_FOCUS(wid)     ((GTK_WIDGET_FLAGS (wid)  GTK_HAS_FOCUS) != 0)
5299
5300 /*
5301  * Evaluates to TRUE if the widget is allowed to receive the default action
5302  * via gtk_widget_grab_default().
5303  * wid:
5304  * a GtkWidget.
5305  */
5306 // TODO
5307 // #define GTK_WIDGET_CAN_DEFAULT(wid)   ((GTK_WIDGET_FLAGS (wid)  GTK_CAN_DEFAULT) != 0)
5308
5309 /*
5310  * Evaluates to TRUE if the widget when focused will receive the default action
5311  * even if there is a different widget set as default.
5312  * wid:
5313  * a GtkWidget.
5314  */
5315 // TODO
5316 // #define GTK_WIDGET_RECEIVES_DEFAULT(wid) ((GTK_WIDGET_FLAGS (wid)  GTK_RECEIVES_DEFAULT) != 0)
5317
5318 /*
5319  * Evaluates to TRUE if the widget currently is receiving the default action.
5320  * wid:
5321  * a GtkWidget.
5322  */
5323 // TODO
5324 // #define GTK_WIDGET_HAS_DEFAULT(wid)   ((GTK_WIDGET_FLAGS (wid)  GTK_HAS_DEFAULT) != 0)
5325
5326 /*
5327  * Evaluates to TRUE if the widget is in the grab_widgets stack, and will be
5328  * the preferred one for receiving events other than ones of cosmetic value.
5329  * wid:
5330  * a GtkWidget.
5331  */
5332 // TODO
5333 // #define GTK_WIDGET_HAS_GRAB(wid)      ((GTK_WIDGET_FLAGS (wid)  GTK_HAS_GRAB) != 0)
5334
5335 /*
5336  * Evaluates to TRUE if the widget's style has been looked up through the rc
5337  * mechanism.
5338  * wid:
5339  * a GtkWidget.
5340  */
5341 // TODO
5342 // #define GTK_WIDGET_RC_STYLE(wid)      ((GTK_WIDGET_FLAGS (wid)  GTK_RC_STYLE) != 0)
5343
5344 /*
5345  * Evaluates to TRUE if the widget is a composite child of its parent.
5346  * wid:
5347  * a GtkWidget.
5348  */
5349 // TODO
5350 // #define GTK_WIDGET_COMPOSITE_CHILD(wid)       ((GTK_WIDGET_FLAGS (wid)  GTK_COMPOSITE_CHILD) != 0)
5351
5352 /*
5353  * Evaluates to TRUE if the GTK_APP_PAINTABLE flag has been set on the widget.
5354  * wid:
5355  * a GtkWidget.
5356  */
5357 // TODO
5358 // #define GTK_WIDGET_APP_PAINTABLE(wid)         ((GTK_WIDGET_FLAGS (wid)  GTK_APP_PAINTABLE) != 0)
5359
5360 /*
5361  * Evaluates to TRUE if the GTK_DOUBLE_BUFFERED flag has been set on the widget.
5362  * wid:
5363  * a GtkWidget.
5364  */
5365 // TODO
5366 // #define GTK_WIDGET_DOUBLE_BUFFERED(wid)       ((GTK_WIDGET_FLAGS (wid)  GTK_DOUBLE_BUFFERED) != 0)
5367
5368 /*
5369  * Turns on certain widget flags.
5370  * wid:
5371  * a GtkWidget.
5372  * flag:
5373  * the flags to set.
5374  */
5375 // TODO
5376 // #define GTK_WIDGET_SET_FLAGS(wid,flag)        G_STMT_START{ (GTK_WIDGET_FLAGS (wid) |= (flag)); }G_STMT_END
5377
5378 /*
5379  * Turns off certain widget flags.
5380  * wid:
5381  * a GtkWidget.
5382  * flag:
5383  * the flags to unset.
5384  */
5385 // TODO
5386 // #define GTK_WIDGET_UNSET_FLAGS(wid,flag) G_STMT_START{ (GTK_WIDGET_FLAGS (wid) = ~(flag)); }G_STMT_END
5387
5388 /*
5389  * Warning
5390  * gtk_widget_set_rc_style is deprecated and should not be used in newly-written code.
5391  * Equivalent to gtk_widget_set_style (widget, NULL).
5392  * widget:
5393  * a GtkWidget.
5394  */
5395 // TODO
5396 // #define gtk_widget_set_rc_style(widget) (gtk_widget_set_style (widget, NULL))
5397
5398 /*
5399  * Warning
5400  * gtk_widget_restore_default_style is deprecated and should not be used in newly-written code.
5401  * Equivalent to gtk_widget_set_style (widget, NULL).
5402  * widget:
5403  * a GtkWidget.
5404  */
5405 // TODO
5406 // #define gtk_widget_restore_default_style(widget) (gtk_widget_set_style (widget, NULL))
5407
5408 /*
5409  * Warning
5410  * gtk_widget_pop_visual is deprecated and should not be used in newly-written code.
5411  * This function is deprecated; it does nothing.
5412  */
5413 // TODO
5414 // #define gtk_widget_pop_visual() ((void) 0)
5415
5416 /*
5417  * Warning
5418  * gtk_widget_push_visual is deprecated and should not be used in newly-written code.
5419  * This function is deprecated; it does nothing.
5420  * visual:
5421  */
5422 // TODO
5423 // #define gtk_widget_push_visual(visual) ((void) 0)
5424
5425 /*
5426  * Warning
5427  * gtk_widget_set_default_visual is deprecated and should not be used in newly-written code.
5428  * This function is deprecated; it does nothing.
5429  * visual:
5430  */
5431 // TODO
5432 // #define gtk_widget_set_default_visual(visual) ((void) 0)
5433
5434 /*
5435  * Warning
5436  * gtk_widget_set_visual is deprecated and should not be used in newly-written code.
5437  * This function is deprecated; it does nothing.
5438  * widget:
5439  * visual:
5440  */
5441 // TODO
5442 // #define gtk_widget_set_visual(widget,visual) ((void) 0)
5443
5444 /*
5445  * Each GTK+ module must have a function gtk_module_init() with this prototype.
5446  * This function is called after loading the module with the argc and argv
5447  * cleaned from any arguments that GTK+ handles itself.
5448  * argc:
5449  * Pointer to the number of arguments remaining after gtk_init().
5450  * argv:
5451  * Points to the argument vector.
5452  */
5453 // void (*GtkModuleInitFunc) (gint *argc,  gchar ***argv);
5454 public typedef extern(C) void  function (gint*, gchar***) GtkModuleInitFunc;
5455
5456 /*
5457  * display:
5458  * Since 2.2
5459  */
5460 // void (*GtkModuleDisplayInitFunc) (GdkDisplay *display);
5461 public typedef extern(C) void  function (GdkDisplay*) GtkModuleDisplayInitFunc;
5462
5463 /*
5464  * Key snooper functions are called before normal event delivery.
5465  * They can be used to implement custom key event handling.
5466  * grab_widget:
5467  * the widget to which the event will be delivered.
5468  * event:
5469  * the key event.
5470  * func_data:
5471  * the func_data supplied to gtk_key_snooper_install().
5472  * Returns:
5473  * TRUE to stop further processing of event, FALSE to continue.
5474  */
5475 // gint (*GtkKeySnoopFunc) (GtkWidget *grab_widget,  GdkEventKey *event,  gpointer func_data);
5476 public typedef extern(C) int  function (GtkWidget*, GdkEventKey*, void*) GtkKeySnoopFunc;
5477
5478 /*
5479  * accel_group:
5480  * acceleratable:
5481  * keyval:
5482  * modifier:
5483  * Returns:
5484  */
5485 // gboolean (*GtkAccelGroupActivate) (GtkAccelGroup *accel_group,  GObject *acceleratable,  guint keyval,  GdkModifierType modifier);
5486 public typedef extern(C) int  function (GtkAccelGroup*, GObject*, uint, GdkModifierType) GtkAccelGroupActivate;
5487
5488 /*
5489  * key:
5490  * closure:
5491  * data:
5492  * Returns:
5493  * Since 2.2
5494  */
5495 // gboolean (*GtkAccelGroupFindFunc) (GtkAccelKey *key,  GClosure *closure,  gpointer data);
5496 public typedef extern(C) int  function (GtkAccelKey*, GClosure*, void*) GtkAccelGroupFindFunc;
5497
5498 /*
5499  * data:
5500  * accel_path:
5501  * accel_key:
5502  * accel_mods:
5503  * changed:
5504  */
5505 // void (*GtkAccelMapForeach) (gpointer data,  const gchar *accel_path,  guint accel_key,  GdkModifierType accel_mods,  gboolean changed);
5506 public typedef extern(C) void  function (void*, char[], uint, GdkModifierType, int) GtkAccelMapForeach;
5507
5508 /*
5509  *  A function to be called when the results of gtk_clipboard_request_contents()
5510  *  are received, or when the request fails.
5511  * clipboard:
5512  * the GtkClipboard
5513  * selection_data:
5514  * a GtkSelectionData containing the data was received.
5515  *  If retrieving the data failed, then then length field
5516  *  of selection_data will be negative.
5517  * data:
5518  * the user_data supplied to gtk_clipboard_request_contents().
5519  */
5520 // void (*GtkClipboardReceivedFunc) (GtkClipboard *clipboard,  GtkSelectionData *selection_data,  gpointer data);
5521 public typedef extern(C) void  function (GtkClipboard*, GtkSelectionData*, void*) GtkClipboardReceivedFunc;
5522
5523 /*
5524  *  A function to be called when the results of gtk_clipboard_request_text()
5525  *  are received, or when the request fails.
5526  * clipboard:
5527  * the GtkClipboard
5528  * text:
5529  * the text received, as a UTF-8 encoded string, or NULL
5530  *  if retrieving the data failed.
5531  * data:
5532  * the user_data supplied to gtk_clipboard_request_text().
5533  */
5534 // void (*GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard,  const gchar *text,  gpointer data);
5535 public typedef extern(C) void  function (GtkClipboard*, char[], void*) GtkClipboardTextReceivedFunc;
5536
5537 /*
5538  *  A function to be called when the results of gtk_clipboard_request_image()
5539  *  are received, or when the request fails.
5540  * clipboard:
5541  * the GtkClipboard
5542  * pixbuf:
5543  * the received image
5544  * data:
5545  * the user_data supplied to gtk_clipboard_request_image().
5546  * Since 2.6
5547  */
5548 // void (*GtkClipboardImageReceivedFunc)  (GtkClipboard *clipboard,  GdkPixbuf *pixbuf,  gpointer data);
5549 public typedef extern(C) void  function (GtkClipboard*, GdkPixbuf*, void*) GtkClipboardImageReceivedFunc;
5550
5551 /*
5552  *  A function to be called when the results of gtk_clipboard_request_targets()
5553  *  are received, or when the request fails.
5554  * clipboard:
5555  * the GtkClipboard
5556  * atoms:
5557  * the supported targets, as array of GdkAtom, or NULL
5558  *  if retrieving the data failed.
5559  * n_atoms:
5560  * the length of the atoms array.
5561  * data:
5562  * the user_data supplied to gtk_clipboard_request_targets().
5563  * Since 2.4
5564  */
5565 // void (*GtkClipboardTargetsReceivedFunc)  (GtkClipboard *clipboard,  GdkAtom *atoms,  gint n_atoms,  gpointer data);
5566 public typedef extern(C) void  function (GtkClipboard*, GdkAtom*, int, void*) GtkClipboardTargetsReceivedFunc;
5567
5568 /*
5569  * clipboard:
5570  * format:
5571  * text:
5572  * length:
5573  * data:
5574  */
5575 // void (*GtkClipboardRichTextReceivedFunc)  (GtkClipboard *clipboard,  GdkAtom format,  const guint8 *text,  gsize length,  gpointer data);
5576 public typedef extern(C) void  function (GtkClipboard*, GdkAtom, guint8*, uint, void*) GtkClipboardRichTextReceivedFunc;
5577
5578 /*
5579  * A function that will be called to provide the contents of the selection.
5580  * If multiple types of data were advertised, the requested type can
5581  * be determined from the info parameter or by checking the target field
5582  * of selection_data. If the data could successfully be converted into
5583  * then it should be stored into the selection_data object by
5584  * calling gtk_selection_data_set() (or related functions such
5585  * as gtk_selection_data_set_text()). If no data is set, the requestor
5586  * will be informed that the attempt to get the data failed.
5587  * clipboard:
5588  * the GtkClipboard
5589  * selection_data:
5590  * a GtkSelectionData argument in which the requested
5591  *  data should be stored.
5592  * info:
5593  * the info field corresponding to the requested
5594  *  target from the GtkTargetEntry array passed to
5595  *  gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().
5596  * user_data_or_owner:
5597  * the user_data argument passed to gtk_clipboard_set_with_data(), or
5598  *  the owner argument passed to gtk_clipboard_set_with_owner()
5599  */
5600 // void (*GtkClipboardGetFunc) (GtkClipboard *clipboard,  GtkSelectionData *selection_data,  guint info,  gpointer user_data_or_owner);
5601 public typedef extern(C) void  function (GtkClipboard*, GtkSelectionData*, uint, void*) GtkClipboardGetFunc;
5602
5603 /*
5604  * A function that will be called when the contents of the clipboard are changed
5605  * or cleared. Once this has called, the user_data_or_owner argument
5606  * will not be used again.
5607  * clipboard:
5608  * the GtkClipboard
5609  * user_data_or_owner:
5610  * the user_data argument passed to gtk_clipboard_set_with_data(), or
5611  *  the owner argument passed to gtk_clipboard_set_with_owner()
5612  */
5613 // void (*GtkClipboardClearFunc) (GtkClipboard *clipboard,  gpointer user_data_or_owner);
5614 public typedef extern(C) void  function (GtkClipboard*, void*) GtkClipboardClearFunc;
5615
5616 /*
5617  * pspec:
5618  * rc_string:
5619  * property_value:
5620  * Returns:
5621  * Signal Details
5622  * The "realize" signal
5623  * void user_function (GtkStyle *style,
5624  *  gpointer user_data) : Run first
5625  * Emitted when the style has been initialized for a particular
5626  * colormap and depth. Connecting to this signal is probably seldom
5627  * useful since most of the time applications and widgets only
5628  * deal with styles that have been already realized.
5629  * style:
5630  *  the object which received the signal
5631  * user_data:
5632  * user data set when the signal handler was connected.
5633  * Since 2.4
5634  */
5635 // gboolean (*GtkRcPropertyParser) (const GParamSpec *pspec,  const GString *rc_string,  GValue *property_value);
5636 public typedef extern(C) int  function (GParamSpec*, GString*, GValue*) GtkRcPropertyParser;
5637
5638 /*
5639  * Defines a function pointer.
5640  */
5641 // void (*GtkSignalFunc) (void);
5642 public typedef extern(C) void  function () GtkSignalFunc;
5643
5644 /*
5645  * Defines a function pointer.
5646  * data:
5647  * gpointer
5648  * Returns:
5649  * gint
5650  */
5651 // gboolean (*GtkFunction) (gpointer data);
5652 public typedef extern(C) int  function (void*) GtkFunction;
5653
5654 /*
5655  * Defines a function pointer.
5656  * data:
5657  * gpointer
5658  */
5659 // void (*GtkDestroyNotify) (gpointer data);
5660 public typedef extern(C) void  function (void*) GtkDestroyNotify;
5661
5662 /*
5663  * Defines a function pointer.
5664  * object:
5665  * GtkObject*
5666  * data:
5667  * gpointer
5668  * n_args:
5669  * guint
5670  * args:
5671  * GtkArg*
5672  */
5673 // void (*GtkCallbackMarshal) (GtkObject *object,  gpointer data,  guint n_args,  GtkArg *args);
5674 public typedef extern(C) void  function (GtkObject*, void*, uint, GtkArg*) GtkCallbackMarshal;
5675
5676 /*
5677  * The type of a function which is called when a URL or email
5678  * link is activated.
5679  * about:
5680  * the GtkAboutDialog in which the link was activated
5681  * link:
5682  * the URL or email address to whiche the activated link points
5683  * data:
5684  * user data that was passed when the function was registered
5685  *  with gtk_about_dialog_set_email_hook() or
5686  *  gtk_about_dialog_set_url_hook()
5687  */
5688 // void (*GtkAboutDialogActivateLinkFunc)  (GtkAboutDialog *about,  const gchar *link,  gpointer data);
5689 public typedef extern(C) void  function (GtkAboutDialog*, char[], void*) GtkAboutDialogActivateLinkFunc;
5690
5691 /*
5692  * A function used by gtk_assistant_set_forward_page_func() to know which
5693  * is the next page given a current one. It's called both for computing the
5694  * next page when the user presses the "forward" button and for handling
5695  * the behavior of the "last" button.
5696  * current_page:
5697  * The page number used to calculate the next page.
5698  * data:
5699  * user data.
5700  * Returns:
5701  * The next page number.
5702  */
5703 // gint (*GtkAssistantPageFunc) (gint current_page,  gpointer data);
5704 public typedef extern(C) int  function (int, void*) GtkAssistantPageFunc;
5705
5706 /*
5707  * A function which decides whether the row indicated by iter matches a given
5708  * key, and should be displayed as a possible completion for key. Note that
5709  * key is normalized and case-folded (see g_utf8_normalize() and
5710  * g_utf8_casefold()). If this is not appropriate, match functions have access
5711  * to the unmodified key via gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ())).
5712  * completion:
5713  * the GtkEntryCompletion
5714  * key:
5715  * the string to match, normalized and case-folded
5716  * iter:
5717  * a GtkTreeIter indicating the row to match
5718  * user_data:
5719  * user data given to gtk_entry_completion_set_match_func()
5720  * Returns:
5721  * TRUE if iter should be displayed as a possible completion for key
5722  */
5723 // gboolean (*GtkEntryCompletionMatchFunc) (GtkEntryCompletion *completion,  const gchar *key,  GtkTreeIter *iter,  gpointer user_data);
5724 public typedef extern(C) int  function (GtkEntryCompletion*, char[], GtkTreeIter*, void*) GtkEntryCompletionMatchFunc;
5725
5726 /*
5727  * ch:
5728  * user_data:
5729  * Returns:
5730  */
5731 // gboolean (*GtkTextCharPredicate) (gunichar ch,  gpointer user_data);
5732 public typedef extern(C) int  function (gunichar, void*) GtkTextCharPredicate;
5733
5734 /*
5735  * register_buffer:
5736  * content_buffer:
5737  * iter:
5738  * data:
5739  * length:
5740  * create_tags:
5741  * user_data:
5742  * error:
5743  * Returns:
5744  */
5745 // gboolean (*GtkTextBufferDeserializeFunc) (GtkTextBuffer *register_buffer,  GtkTextBuffer *content_buffer,  GtkTextIter *iter,  const guint8 *data,  gsize length,  gboolean create_tags,  gpointer user_data,  GError **error);
5746 public typedef extern(C) int  function (GtkTextBuffer*, GtkTextBuffer*, GtkTextIter*, guint8*, uint, int, void*, GError**) GtkTextBufferDeserializeFunc;
5747
5748 /*
5749  * register_buffer:
5750  * content_buffer:
5751  * start:
5752  * end:
5753  * length:
5754  * user_data:
5755  * Returns:
5756  */
5757 // guint8* (*GtkTextBufferSerializeFunc) (GtkTextBuffer *register_buffer,  GtkTextBuffer *content_buffer,  const GtkTextIter *start,  const GtkTextIter *end,  gsize *length,  gpointer user_data);
5758 public typedef extern(C) byte*  function (GtkTextBuffer*, GtkTextBuffer*, GtkTextIter*, GtkTextIter*, gsize*, void*) GtkTextBufferSerializeFunc;
5759
5760 /*
5761  * tag:
5762  * data:
5763  */
5764 // void (*GtkTextTagTableForeach) (GtkTextTag *tag,  gpointer data);
5765 public typedef extern(C) void  function (GtkTextTag*, void*) GtkTextTagTableForeach;
5766
5767 /*
5768  * model:
5769  * path:
5770  * iter:
5771  * data:
5772  * Returns:
5773  */
5774 // gboolean (*GtkTreeModelForeachFunc) (GtkTreeModel *model,  GtkTreePath *path,  GtkTreeIter *iter,  gpointer data);
5775 public typedef extern(C) int  function (GtkTreeModel*, GtkTreePath*, GtkTreeIter*, void*) GtkTreeModelForeachFunc;
5776
5777 /*
5778  * A function used by gtk_tree_selection_set_select_function() to filter
5779  * whether or not a row may be selected. It is called whenever a row's
5780  * state might change. A return value of TRUE indicates to selection
5781  * that it is okay to change the selection.
5782  * selection:
5783  * A GtkTreeSelection
5784  * model:
5785  * A GtkTreeModel being viewed
5786  * path:
5787  * The GtkTreePath of the row in question
5788  * path_currently_selected:
5789  * TRUE, if the path is currently selected
5790  * data:
5791  * user data
5792  * Returns:
5793  * TRUE, if the selection state of the row can be toggled
5794  */
5795 // gboolean (*GtkTreeSelectionFunc) (GtkTreeSelection *selection,  GtkTreeModel *model,  GtkTreePath *path,  gboolean path_currently_selected,  gpointer data);
5796 public typedef extern(C) int  function (GtkTreeSelection*, GtkTreeModel*, GtkTreePath*, int, void*) GtkTreeSelectionFunc;
5797
5798 /*
5799  * A function used by gtk_tree_selection_selected_foreach() to map all
5800  * selected rows. It will be called on every selected row in the view.
5801  * model:
5802  * The GtkTreeModel being viewed
5803  * path:
5804  * The GtkTreePath of a selected row
5805  * iter:
5806  * A GtkTreeIter pointing to a selected row
5807  * data:
5808  * user data
5809  */
5810 // void (*GtkTreeSelectionForeachFunc) (GtkTreeModel *model,  GtkTreePath *path,  GtkTreeIter *iter,  gpointer data);
5811 public typedef extern(C) void  function (GtkTreeModel*, GtkTreePath*, GtkTreeIter*, void*) GtkTreeSelectionForeachFunc;
5812
5813 /*
5814  * A function to set the properties of a cell instead of just using the
5815  * straight mapping between the cell and the model. This is useful for
5816  * customizing the cell renderer. For example, a function might get an
5817  * integer from the tree_model, and render it to the "text" attribute of
5818  * "cell" by converting it to its written equivilent. This is set by
5819  * calling gtk_tree_view_column_set_cell_data_func()
5820  * tree_column:
5821  * A GtkTreeColumn
5822  * cell:
5823  * The GtkCellRenderer that is being rendered by tree_column
5824  * tree_model:
5825  * The GtkTreeModel being rendered
5826  * iter:
5827  * A GtkTreeIter of the current row rendered
5828  * data:
5829  * user data
5830  */
5831 // void (*GtkTreeCellDataFunc) (GtkTreeViewColumn *tree_column,  GtkCellRenderer *cell,  GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer data);
5832 public typedef extern(C) void  function (GtkTreeViewColumn*, GtkCellRenderer*, GtkTreeModel*, GtkTreeIter*, void*) GtkTreeCellDataFunc;
5833
5834 /*
5835  * Function type for determining whether column can be dropped in a
5836  * particular spot (as determined by prev_column and next_column). In
5837  * left to right locales, prev_column is on the left of the potential drop
5838  * spot, and next_column is on the right. In right to left mode, this is
5839  * reversed. This function should return TRUE if the spot is a valid drop
5840  * spot. Please note that returning TRUE does not actually indicate that
5841  * the column drop was made, but is meant only to indicate a possible drop
5842  * spot to the user.
5843  * tree_view:
5844  * A GtkTreeView
5845  * column:
5846  * The GtkTreeViewColumn being dragged
5847  * prev_column:
5848  * A GtkTreeViewColumn on one side of column
5849  * next_column:
5850  * A GtkTreeViewColumn on the other side of column
5851  * data:
5852  * user data
5853  * Returns:
5854  * TRUE, if column can be dropped in this spot
5855  */
5856 // gboolean (*GtkTreeViewColumnDropFunc) (GtkTreeView *tree_view,  GtkTreeViewColumn *column,  GtkTreeViewColumn *prev_column,  GtkTreeViewColumn *next_column,  gpointer data);
5857 public typedef extern(C) int  function (GtkTreeView*, GtkTreeViewColumn*, GtkTreeViewColumn*, GtkTreeViewColumn*, void*) GtkTreeViewColumnDropFunc;
5858
5859 /*
5860  * Function used for gtk_tree_view_map_expanded_rows.
5861  * tree_view:
5862  * A GtkTreeView
5863  * path:
5864  * The path that's expanded
5865  * user_data:
5866  * user data
5867  */
5868 // void (*GtkTreeViewMappingFunc) (GtkTreeView *tree_view,  GtkTreePath *path,  gpointer user_data);
5869 public typedef extern(C) void  function (GtkTreeView*, GtkTreePath*, void*) GtkTreeViewMappingFunc;
5870
5871 /*
5872  * A function used for checking whether a row in model matches
5873  * a search key string entered by the user. Note the return value
5874  * is reversed from what you would normally expect, though it
5875  * has some similarity to strcmp() returning 0 for equal strings.
5876  * model:
5877  * the GtkTreeModel being searched
5878  * column:
5879  * the search column set by gtk_tree_view_set_search_column()
5880  * key:
5881  * the key string to compare with
5882  * iter:
5883  * a GtkTreeIter pointing the row of model that should be compared
5884  *  with key.
5885  * search_data:
5886  * user data from gtk_tree_view_set_search_equal_func()
5887  * Returns:
5888  * FALSE if the row matches, TRUE otherwise.
5889  */
5890 // gboolean (*GtkTreeViewSearchEqualFunc) (GtkTreeModel *model,  gint column,  const gchar *key,  GtkTreeIter *iter,  gpointer search_data);
5891 public typedef extern(C) int  function (GtkTreeModel*, int, char[], GtkTreeIter*, void*) GtkTreeViewSearchEqualFunc;
5892
5893 /*
5894  * tree_view:
5895  * search_dialog:
5896  * user_data:
5897  */
5898 // void (*GtkTreeViewSearchPositionFunc)  (GtkTreeView *tree_view,  GtkWidget *search_dialog,  gpointer user_data);
5899 public typedef extern(C) void  function (GtkTreeView*, GtkWidget*, void*) GtkTreeViewSearchPositionFunc;
5900
5901 /*
5902  * tree_view:
5903  * path:
5904  * children:
5905  * user_data:
5906  */
5907 // void (*GtkTreeDestroyCountFunc) (GtkTreeView *tree_view,  GtkTreePath *path,  gint children,  gpointer user_data);
5908 public typedef extern(C) void  function (GtkTreeView*, GtkTreePath*, int, void*) GtkTreeDestroyCountFunc;
5909
5910 /*
5911  * Function type for determining whether the row pointed to by iter should
5912  * be rendered as a separator. A common way to implement this is to have a
5913  * boolean column in the model, whose values the GtkTreeViewRowSeparatorFunc
5914  * returns.
5915  * model:
5916  * the GtkTreeModel
5917  * iter:
5918  * a GtkTreeIter pointing at a row in model
5919  * data:
5920  * user data
5921  * Returns:
5922  * TRUE if the row is a separator
5923  */
5924 // gboolean (*GtkTreeViewRowSeparatorFunc) (GtkTreeModel *model,  GtkTreeIter *iter,  gpointer data);
5925 public typedef extern(C) int  function (GtkTreeModel*, GtkTreeIter*, void*) GtkTreeViewRowSeparatorFunc;
5926
5927 /*
5928  * A function used by gtk_icon_view_selected_foreach() to map all
5929  * selected rows. It will be called on every selected row in the view.
5930  * icon_view:
5931  * a GtkIconView
5932  * path:
5933  * The GtkTreePath of a selected row
5934  * data:
5935  * user data
5936  */
5937 // void (*GtkIconViewForeachFunc) (GtkIconView *icon_view,  GtkTreePath *path,  gpointer data);
5938 public typedef extern(C) void  function (GtkIconView*, GtkTreePath*, void*) GtkIconViewForeachFunc;
5939
5940 /*
5941  * A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive
5942  * integer if a sorts before b, a sorts with b, or a sorts after b
5943  * respectively. If two iters compare as equal, their order in the sorted model
5944  * is undefined. In order to ensure that the GtkTreeSortable behaves as
5945  * expected, the GtkTreeIterCompareFunc must define a partial order on
5946  * the model, i.e. it must be reflexive, antisymmetric and transitive.
5947  * For example, if model is a product catalogue, then a compare function
5948  * for the "price" column could be one which returns
5949  * price_of(a) - price_of(b).
5950  * model:
5951  * The GtkTreeModel the comparison is within
5952  * a:
5953  * A GtkTreeIter in model
5954  * b:
5955  * Another GtkTreeIter in model
5956  * user_data:
5957  * Data passed when the compare func is assigned e.g. by
5958  * gtk_tree_sortable_set_sort_func()
5959  * Returns:
5960  */
5961 // gint (*GtkTreeIterCompareFunc) (GtkTreeModel *model,  GtkTreeIter *a,  GtkTreeIter *b,  gpointer user_data);
5962 public typedef extern(C) int  function (GtkTreeModel*, GtkTreeIter*, GtkTreeIter*, void*) GtkTreeIterCompareFunc;
5963
5964 /*
5965  * A function which decides whether the row indicated by iter is visible.
5966  * model:
5967  * the child model of the GtkTreeModelFilter
5968  * iter:
5969  * a GtkTreeIter pointing to the row in model whose visibility
5970  *  is determined
5971  * data:
5972  * user data given to gtk_tree_model_filter_set_visible_func()
5973  * Returns:
5974  * Whether the row indicated by iter is visible.
5975  */
5976 // gboolean (*GtkTreeModelFilterVisibleFunc)  (GtkTreeModel *model,  GtkTreeIter *iter,  gpointer data);
5977 public typedef extern(C) int  function (GtkTreeModel*, GtkTreeIter*, void*) GtkTreeModelFilterVisibleFunc;
5978
5979 /*
5980  * A function which calculates display values from raw values in the model.
5981  * It must fill value with the display value for the column column in the
5982  * row indicated by iter.
5983  * Since this function is called for each data access, it's not a
5984  * particularly efficient operation.
5985  * model:
5986  * the GtkTreeModelFilter
5987  * iter:
5988  * a GtkTreeIter pointing to the row whose display values are determined
5989  * value:
5990  * A GValue which is already initialized for with the correct type for
5991  *  the column column.
5992  * column:
5993  * the column whose display value is determined
5994  * data:
5995  * user data given to gtk_tree_model_filter_set_modify_func()
5996  */
5997 // void (*GtkTreeModelFilterModifyFunc) (GtkTreeModel *model,  GtkTreeIter *iter,  GValue *value,  gint column,  gpointer data);
5998 public typedef extern(C) void  function (GtkTreeModel*, GtkTreeIter*, GValue*, int, void*) GtkTreeModelFilterModifyFunc;
5999
6000 /*
6001  * A function which should set the value of cell_layout's cell renderer(s)
6002  * as appropriate.
6003  * cell_layout:
6004  * a GtkCellLayout
6005  * cell:
6006  * the cell renderer whose value is to be set
6007  * tree_model:
6008  * the model
6009  * iter:
6010  * a GtkTreeIter indicating the row to set the value for
6011  * data:
6012  * user data passed to gtk_cell_layout_set_cell_data_func()
6013  */
6014 // void (*GtkCellLayoutDataFunc) (GtkCellLayout *cell_layout,  GtkCellRenderer *cell,  GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer data);
6015 public typedef extern(C) void  function (GtkCellLayout*, GtkCellRenderer*, GtkTreeModel*, GtkTreeIter*, void*) GtkCellLayoutDataFunc;
6016
6017 /*
6018  * A user function supplied when calling gtk_menu_popup() which controls the
6019  * positioning of the menu when it is displayed. The function sets the x
6020  * and y parameters to the coordinates where the menu is to be drawn.
6021  * menu:
6022  * a GtkMenu.
6023  * x:
6024  * address of the gint representing the horizontal position where the
6025  * menu shall be drawn. This is an output parameter.
6026  * y:
6027  * address of the gint representing the vertical position where the
6028  * menu shall be drawn. This is an output parameter.
6029  * push_in:
6030  * whether the menu should be pushed in to be completely inside the
6031  *  screen instead of just clamped to the size to the screen.
6032  * user_data:
6033  * the data supplied by the user in the gtk_menu_popup() data
6034  * parameter.
6035  */
6036 // void (*GtkMenuPositionFunc) (GtkMenu *menu,  gint *x,  gint *y,  gboolean *push_in,  gpointer user_data);
6037 public typedef extern(C) void  function (GtkMenu*, gint*, gint*, gboolean*, void*) GtkMenuPositionFunc;
6038
6039 /*
6040  * A user function supplied when calling gtk_menu_attach_to_widget() which
6041  * will be called when the menu is later detached from the widget.
6042  * attach_widget:
6043  * the GtkWidget that the menu is being detached from.
6044  * menu:
6045  * the GtkMenu being detached.
6046  */
6047 // void (*GtkMenuDetachFunc) (GtkWidget *attach_widget,  GtkMenu *menu);
6048 public typedef extern(C) void  function (GtkWidget*, GtkMenu*) GtkMenuDetachFunc;
6049
6050 /*
6051  * colors:
6052  * n_colors:
6053  */
6054 // void (*GtkColorSelectionChangePaletteFunc)  (const GdkColor *colors,  gint n_colors);
6055 public typedef extern(C) void  function (GdkColor*, int) GtkColorSelectionChangePaletteFunc;
6056
6057 /*
6058  * screen:
6059  * colors:
6060  * n_colors:
6061  * Since 2.2
6062  */
6063 // void (*GtkColorSelectionChangePaletteWithScreenFunc)  (GdkScreen *screen,  const GdkColor *colors,  gint n_colors);
6064 public typedef extern(C) void  function (GdkScreen*, GdkColor*, int) GtkColorSelectionChangePaletteWithScreenFunc;
6065
6066 /*
6067  * The type of function that is used with custom filters,
6068  * see gtk_file_filter_add_custom().
6069  * filter_info:
6070  * a GtkFileFilterInfo that is filled according
6071  *  to the needed flags passed to gtk_file_filter_add_custom()
6072  * data:
6073  * user data passed to gtk_file_filter_add_custom()
6074  * Returns:
6075  * TRUE if the file should be displayed
6076  */
6077 // gboolean (*GtkFileFilterFunc) (const GtkFileFilterInfo *filter_info,  gpointer data);
6078 public typedef extern(C) int  function (GtkFileFilterInfo*, void*) GtkFileFilterFunc;
6079
6080 /*
6081  * A function used by GtkNotebook when a detachable tab is dropped
6082  * in the root window, it's used to create a window containing a notebook
6083  * where the tab will be attached. This function will also be responsible
6084  * of moving/resizing the window and adding the necessary properties to
6085  * the notebook (i.e.: group-id).
6086  * If the function returns NULL, the drag will be cancelled.
6087  * source:
6088  * The source GtkNotebook of the drag operation
6089  * page:
6090  * the child GtkWidget affected
6091  * x:
6092  * the X coordinate where the drop happens
6093  * y:
6094  * the Y coordinate where the drop happens
6095  * data:
6096  * user data
6097  * Returns:
6098  * The created GtkNotebook where the tab will be attached, or NULL to cancel the drag
6099  */
6100 // GtkNotebook* (*GtkNotebookWindowCreationFunc)  (GtkNotebook *source,  GtkWidget *page,  gint x,  gint y,  gpointer data);
6101 public typedef extern(C) GtkNotebook*  function (GtkNotebook*, GtkWidget*, int, int, void*) GtkNotebookWindowCreationFunc;
6102
6103 /*
6104  * The type of the callback functions used for e.g. iterating over
6105  * the children of a container, see gtk_container_foreach().
6106  * widget:
6107  * the widget to operate on
6108  * data:
6109  * user-supplied data
6110  */
6111 // void (*GtkCallback) (GtkWidget *widget,  gpointer data);
6112 public typedef extern(C) void  function (GtkWidget*, void*) GtkCallback;
6113
6114 /*
6115  * Warning
6116  * GtkPrintFunc is deprecated and should not be used in newly-written code.
6117  * func_data:
6118  * str:
6119  */
6120 // void (*GtkPrintFunc) (gpointer func_data,  const gchar *str);
6121 public typedef extern(C) void  function (void*, char[]) GtkPrintFunc;
6122
6123 /*
6124  * The function used to translate messages in e.g. GtkIconFactory
6125  * and GtkActionGroup.
6126  * path:
6127  * The id of the message. In GtkItemFactory this will be a path
6128  *  from a GtkItemFactoryEntry, in GtkActionGroup, it will be a label
6129  *  or tooltip from a GtkActionEntry.
6130  * func_data:
6131  * user data passed in when registering the function
6132  * Returns:
6133  * the translated message
6134  */
6135 // gchar* (*GtkTranslateFunc) (const gchar *path,  gpointer func_data);
6136 public typedef extern(C) char*  function (char[], void*) GtkTranslateFunc;
6137
6138 /*
6139  * Warning
6140  * GtkItemFactoryCallback is deprecated and should not be used in newly-written code.
6141  */
6142 // void (*GtkItemFactoryCallback) ();
6143 public typedef extern(C) void  function () GtkItemFactoryCallback;
6144
6145 /*
6146  * Warning
6147  * GtkItemFactoryCallback1 is deprecated and should not be used in newly-written code.
6148  * callback_data:
6149  * callback_action:
6150  * widget:
6151  */
6152 // void (*GtkItemFactoryCallback1) (gpointer callback_data,  guint callback_action,  GtkWidget *widget);
6153 public typedef extern(C) void  function (void*, uint, GtkWidget*) GtkItemFactoryCallback1;
6154
6155 /*
6156  * Warning
6157  * GtkItemFactoryCallback2 is deprecated and should not be used in newly-written code.
6158  * widget:
6159  * callback_data:
6160  * callback_action:
6161  */
6162 // void (*GtkItemFactoryCallback2) (GtkWidget *widget,  gpointer callback_data,  guint callback_action);
6163 public typedef extern(C) void  function (GtkWidget*, void*, uint) GtkItemFactoryCallback2;
6164
6165
6166 // StockIDs
6167 enum StockID
6168 {
6169
6170         /**
6171          * The "About" item.
6172          * Since 2.6
6173          */
6174         ABOUT,
6175
6176         /**
6177          * The "Add" item.
6178          */
6179         ADD,
6180
6181         /**
6182          * The "Apply" item.
6183          */
6184         APPLY,
6185
6186         /**
6187          * The "Bold" item.
6188          */
6189         BOLD,
6190
6191         /**
6192          * The "Cancel" item.
6193          */
6194         CANCEL,
6195
6196         /**
6197          * The "CD-Rom" item.
6198          */
6199         CDROM,
6200
6201         /**
6202          * The "Clear" item.
6203          */
6204         CLEAR,
6205
6206         /**
6207          * The "Close" item.
6208          */
6209         CLOSE,
6210
6211         /**
6212          * The "Color Picker" item.
6213          * Since 2.2
6214          */
6215         COLOR_PICKER,
6216
6217         /**
6218          * The "Convert" item.
6219          */
6220         CONVERT,
6221
6222         /**
6223          * The "Connect" icon.
6224          * Since 2.6
6225          */
6226         CONNECT,
6227
6228         /**
6229          * The "Copy" item.
6230          */
6231         COPY,
6232
6233         /**
6234          * The "Cut" item.
6235          */
6236         CUT,
6237
6238         /**
6239          * The "Delete" item.
6240          */
6241         DELETE,
6242
6243         /**
6244          * The "Error" item.
6245          */
6246         DIALOG_ERROR,
6247
6248         /**
6249          * The "Information" item.
6250          */
6251         DIALOG_INFO,
6252
6253         /**
6254          * The "Question" item.
6255          */
6256         DIALOG_QUESTION,
6257
6258         /**
6259          * The "Warning" item.
6260          */
6261         DIALOG_WARNING,
6262
6263         /**
6264          * The "Directory" icon.
6265          * Since 2.6
6266          */
6267         DIRECTORY,
6268
6269         /**
6270          * The "Disconnect" icon.
6271          * Since 2.6
6272          */
6273         DISCONNECT,
6274
6275         /**
6276          * The "Drag-And-Drop" icon.
6277          */
6278         DND,
6279
6280         /**
6281          * The "Drag-And-Drop multiple" icon.
6282          */
6283         DND_MULTIPLE,
6284
6285         /**
6286          * The "Edit" item.
6287          * Since 2.6
6288          */
6289         EDIT,
6290
6291         /**
6292          * The "Execute" item.
6293          */
6294         EXECUTE,
6295
6296         /**
6297          * The "File" icon.
6298          * Since 2.6
6299          */
6300         FILE,
6301
6302         /**
6303          * The "Find" item.
6304          */
6305         FIND,
6306
6307         /**
6308          * The "Find and Replace" item.
6309          */
6310         FIND_AND_REPLACE,
6311
6312         /**
6313          * The "Floppy" item.
6314          */
6315         FLOPPY,
6316
6317         /**
6318          * The "Fullscreen" item.
6319          * Since 2.8
6320          */
6321         FULLSCREEN,
6322
6323         /**
6324          * The "Bottom" item.
6325          */
6326         GOTO_BOTTOM,
6327
6328         /**
6329          * The "First" item.
6330          * RTL variant
6331          */
6332         GOTO_FIRST,
6333
6334         /**
6335          * The "Last" item.
6336          * RTL variant
6337          */
6338         GOTO_LAST,
6339
6340         /**
6341          * The "Top" item.
6342          */
6343         GOTO_TOP,
6344
6345         /**
6346          * The "Back" item.
6347          * RTL variant
6348          */
6349         GO_BACK,
6350
6351         /**
6352          * The "Down" item.
6353          */
6354         GO_DOWN,
6355
6356         /**
6357          * The "Forward" item.
6358          * RTL variant
6359          */
6360         GO_FORWARD,
6361
6362         /**
6363          * The "Up" item.
6364          */
6365         GO_UP,
6366
6367         /**
6368          * The "Harddisk" item.
6369          * Since 2.4
6370          */
6371         HARDDISK,
6372
6373         /**
6374          * The "Help" item.
6375          */
6376         HELP,
6377
6378         /**
6379          * The "Home" item.
6380          */
6381         HOME,
6382
6383         /**
6384          * The "Indent" item.
6385          * RTL variant
6386          * Since 2.4
6387          */
6388         INDENT,
6389
6390         /**
6391          * The "Index" item.
6392          */
6393         INDEX,
6394
6395         /**
6396          * The "Info" item.
6397          * Since 2.8
6398          */
6399         INFO,
6400
6401         /**
6402          * The "Italic" item.
6403          */
6404         ITALIC,
6405
6406         /**
6407          * The "Jump to" item.
6408          * RTL-variant
6409          */
6410         JUMP_TO,
6411
6412         /**
6413          * The "Center" item.
6414          */
6415         JUSTIFY_CENTER,
6416
6417         /**
6418          * The "Fill" item.
6419          */
6420         JUSTIFY_FILL,
6421
6422         /**
6423          * The "Left" item.
6424          */
6425         JUSTIFY_LEFT,
6426
6427         /**
6428          * The "Right" item.
6429          */
6430         JUSTIFY_RIGHT,
6431
6432         /**
6433          * The "Leave Fullscreen" item.
6434          * Since 2.8
6435          */
6436         LEAVE_FULLSCREEN,
6437
6438         /**
6439          * The "Media Forward" item.
6440          * RTL variant
6441          * Since 2.6
6442          */
6443         MEDIA_FORWARD,
6444
6445         /**
6446          * The "Media Next" item.
6447          * RTL variant
6448          * Since 2.6
6449          */
6450         MEDIA_NEXT,
6451
6452         /**
6453          * The "Media Pause" item.
6454          * Since 2.6
6455          */
6456         MEDIA_PAUSE,
6457
6458         /**
6459          * The "Media Play" item.
6460          * RTL variant
6461          * Since 2.6
6462          */
6463         MEDIA_PLAY,
6464
6465         /**
6466          * The "Media Previous" item.
6467          * RTL variant
6468          * Since 2.6
6469          */
6470         MEDIA_PREVIOUS,
6471
6472         /**
6473          * The "Media Record" item.
6474          * Since 2.6
6475          */
6476         MEDIA_RECORD,
6477
6478         /**
6479          * The "Media Rewind" item.
6480          * RTL variant
6481          * Since 2.6
6482          */
6483         MEDIA_REWIND,
6484
6485         /**
6486          * The "Media Stop" item.
6487          * Since 2.6
6488          */
6489         MEDIA_STOP,
6490
6491         /**
6492          * The "Missing image" icon.
6493          */
6494         MISSING_IMAGE,
6495
6496         /**
6497          * The "Network" item.
6498          * Since 2.4
6499          */
6500         NETWORK,
6501
6502         /**
6503          * The "New" item.
6504          */
6505         NEW,
6506
6507         /**
6508          * The "No" item.
6509          */
6510         NO,
6511
6512         /**
6513          * The "OK" item.
6514          */
6515         OK,
6516
6517         /**
6518          * The "Open" item.
6519          */
6520         OPEN,
6521
6522         /**
6523          * The "Landscape Orientation" item.
6524          * Since 2.10
6525          */
6526         ORIENTATION_LANDSCAPE,
6527
6528         /**
6529          * The "Portrait Orientation" item.
6530          * Since 2.10
6531          */
6532         ORIENTATION_PORTRAIT,
6533
6534         /**
6535          * The "Reverse Landscape Orientation" item.
6536          * Since 2.10
6537          */
6538         ORIENTATION_REVERSE_LANDSCAPE,
6539
6540         /**
6541          * The "Reverse Portrait Orientation" item.
6542          * Since 2.10
6543          */
6544         ORIENTATION_REVERSE_PORTRAIT,
6545
6546         /**
6547          * The "Paste" item.
6548          */
6549         PASTE,
6550
6551         /**
6552          * The "Preferences" item.
6553          */
6554         PREFERENCES,
6555
6556         /**
6557          * The "Print" item.
6558          */
6559         PRINT,
6560
6561         /**
6562          * The "Print Preview" item.
6563          */
6564         PRINT_PREVIEW,
6565
6566         /**
6567          * The "Properties" item.
6568          */
6569         PROPERTIES,
6570
6571         /**
6572          * The "Quit" item.
6573          */
6574         QUIT,
6575
6576         /**
6577          * The "Redo" item.
6578          * RTL variant
6579          */
6580         REDO,
6581
6582         /**
6583          * The "Refresh" item.
6584          */
6585         REFRESH,
6586
6587         /**
6588          * The "Remove" item.
6589          */
6590         REMOVE,
6591
6592         /**
6593          * The "Revert" item.
6594          * RTL variant
6595          */
6596         REVERT_TO_SAVED,
6597
6598         /**
6599          * The "Save" item.
6600          */
6601         SAVE,
6602
6603         /**
6604          * The "Save As" item.
6605          */
6606         SAVE_AS,
6607
6608         /**
6609          * The "Select All" item.
6610          * Since 2.10
6611          */
6612         SELECT_ALL,
6613
6614         /**
6615          * The "Color" item.
6616          */
6617         SELECT_COLOR,
6618
6619         /**
6620          * The "Font" item.
6621          */
6622         SELECT_FONT,
6623
6624         /**
6625          * The "Ascending" item.
6626          */
6627         SORT_ASCENDING,
6628
6629         /**
6630          * The "Descending" item.
6631          */
6632         SORT_DESCENDING,
6633
6634         /**
6635          * The "Spell Check" item.
6636          */
6637         SPELL_CHECK,
6638
6639         /**
6640          * The "Stop" item.
6641          */
6642         STOP,
6643
6644         /**
6645          * The "Strikethrough" item.
6646          */
6647         STRIKETHROUGH,
6648
6649         /**
6650          * The "Undelete" item.
6651          * RTL variant
6652          */
6653         UNDELETE,
6654
6655         /**
6656          * The "Underline" item.
6657          */
6658         UNDERLINE,
6659
6660         /**
6661          * The "Undo" item.
6662          * RTL variant
6663          */
6664         UNDO,
6665
6666         /**
6667          * The "Unindent" item.
6668          * RTL variant
6669          * Since 2.4
6670          */
6671         UNINDENT,
6672
6673         /**
6674          * The "Yes" item.
6675          */
6676         YES,
6677
6678         /**
6679          * The "Zoom 100%" item.
6680          */
6681         ZOOM_100,
6682
6683         /**
6684          * The "Zoom to Fit" item.
6685          */
6686         ZOOM_FIT,
6687
6688         /**
6689          * The "Zoom In" item.
6690          */
6691         ZOOM_IN,
6692
6693         /**
6694          * The "Zoom Out" item.
6695          */
6696         ZOOM_OUT,
6697
6698 }
6699
6700 // Stock strings
6701 char[][] StockDesc =
6702 [       "gtk-about",
6703         "gtk-add",
6704         "gtk-apply",
6705         "gtk-bold",
6706         "gtk-cancel",
6707         "gtk-cdrom",
6708         "gtk-clear",
6709         "gtk-close",
6710         "gtk-color-picker",
6711         "gtk-convert",
6712         "gtk-connect",
6713         "gtk-copy",
6714         "gtk-cut",
6715         "gtk-delete",
6716         "gtk-dialog-error",
6717         "gtk-dialog-info",
6718         "gtk-dialog-question",
6719         "gtk-dialog-warning",
6720         "gtk-directory",
6721         "gtk-disconnect",
6722         "gtk-dnd",
6723         "gtk-dnd-multiple",
6724         "gtk-edit",
6725         "gtk-execute",
6726         "gtk-file",
6727         "gtk-find",
6728         "gtk-find-and-replace",
6729         "gtk-floppy",
6730         "gtk-fullscreen",
6731         "gtk-goto-bottom",
6732         "gtk-goto-first",
6733         "gtk-goto-last",
6734         "gtk-goto-top",
6735         "gtk-go-back",
6736         "gtk-go-down",
6737         "gtk-go-forward",
6738         "gtk-go-up",
6739         "gtk-harddisk",
6740         "gtk-help",
6741         "gtk-home",
6742         "gtk-indent",
6743         "gtk-index",
6744         "gtk-info",
6745         "gtk-italic",
6746         "gtk-jump-to",
6747         "gtk-justify-center",
6748         "gtk-justify-fill",
6749         "gtk-justify-left",
6750         "gtk-justify-right",
6751         "gtk-leave-fullscreen",
6752         "gtk-media-forward",
6753         "gtk-media-next",
6754         "gtk-media-pause",
6755         "gtk-media-play",
6756         "gtk-media-previous",
6757         "gtk-media-record",
6758         "gtk-media-rewind",
6759         "gtk-media-stop",
6760         "gtk-missing-image",
6761         "gtk-network",
6762         "gtk-new",
6763         "gtk-no",
6764         "gtk-ok",
6765         "gtk-open",
6766         "gtk-orientation-landscape",
6767         "gtk-orientation-portrait",
6768         "gtk-orientation-reverse-landscape",
6769         "gtk-orientation-reverse-portrait",
6770         "gtk-paste",
6771         "gtk-preferences",
6772         "gtk-print",
6773         "gtk-print-preview",
6774         "gtk-properties",
6775         "gtk-quit",
6776         "gtk-redo",
6777         "gtk-refresh",
6778         "gtk-remove",
6779         "gtk-revert-to-saved",
6780         "gtk-save",
6781         "gtk-save-as",
6782         "gtk-select-all",
6783         "gtk-select-color",
6784         "gtk-select-font",
6785         "gtk-sort-ascending",
6786         "gtk-sort-descending",
6787         "gtk-spell-check",
6788         "gtk-stop",
6789         "gtk-strikethrough",
6790         "gtk-undelete",
6791         "gtk-underline",
6792         "gtk-undo",
6793         "gtk-unindent",
6794         "gtk-yes",
6795         "gtk-zoom-100",
6796         "gtk-zoom-fit",
6797         "gtk-zoom-in",
6798         "gtk-zoom-out",
6799
6800 ];