1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19  
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 module gtkc.gtktypes;
25 
26 public import gtkc.cairotypes;
27 public import gtkc.glibtypes;
28 public import gtkc.gobjecttypes;
29 public import gtkc.giotypes;
30 public import gtkc.pangotypes;
31 public import gtkc.atktypes;
32 public import gtkc.gdkpixbuftypes;
33 public import gtkc.gdktypes;
34 
35 version(LDC)
36 {
37 	version(D_Version2)
38 	{
39 		extern(C) Object _d_newclass(ClassInfo ci);
40 	}
41 	else
42 	{
43 		extern (C) void* _d_allocclass(ClassInfo ci);
44 	}
45 }
46 else
47 {
48 	extern(C) Object _d_newclass(ClassInfo ci);
49 }
50 
51 alias void GtkAccelGroupEntry;
52 alias void GtkContainerClass;
53 
54 
55 /**
56  * typedef GType GtkType;
57  * Warning
58  * GtkType is deprecated and should not be used in newly-written code.
59  * GtkType is unique integer identifying the type. The guts of the
60  * information about the type is held in a private struct named
61  * GtkTypeNode.
62  */
63 public alias GType GtkType;
64 
65 /**
66  * typedef GType GtkFundamentalType;
67  * Warning
68  * GtkFundamentalType is deprecated and should not be used in newly-written code.
69  * GtkFundamentalType is an enumerated type which lists all the possible
70  * fundamental types (e.g. char, uchar, int,
71  * long, float, etc).
72  */
73 public alias GType GtkFundamentalType;
74 
75 /**
76  * typedef GBaseInitFunc GtkClassInitFunc;
77  * Warning
78  * GtkClassInitFunc is deprecated and should not be used in newly-written code.
79  * Defines a function pointer.
80  */
81 public alias GBaseInitFunc GtkClassInitFunc;
82 
83 /**
84  * typedef GInstanceInitFunc GtkObjectInitFunc;
85  * Warning
86  * GtkObjectInitFunc is deprecated and should not be used in newly-written code.
87  * Defines a function pointer.
88  */
89 public alias GInstanceInitFunc GtkObjectInitFunc;
90 
91 /**
92  * typedef GSignalCMarshaller GtkSignalMarshaller;
93  * Warning
94  * GtkSignalMarshaller is deprecated and should not be used in newly-written code.
95  * Defines a function pointer.
96  */
97 public alias GSignalCMarshaller GtkSignalMarshaller;
98 
99 /**
100  * typedef GTypeInstance GtkTypeObject;
101  * Warning
102  * GtkTypeObject is deprecated and should not be used in newly-written code.
103  * A GtkTypeObject defines the minimum structure requirements
104  * for type instances. Type instances returned from gtk_type_new()
105  * and initialized through a GtkObjectInitFunc need to directly inherit
106  * from this structure or at least copy its fields one by one.
107  */
108 public alias GTypeInstance GtkTypeObject;
109 
110 /**
111  * typedef GTypeClass GtkTypeClass;
112  * Warning
113  * GtkTypeClass is deprecated and should not be used in newly-written code.
114  * The base structure for a GTK+ type. Every type inherits this as a base structure.
115  */
116 public alias GTypeClass GtkTypeClass;
117 
118 /**
119  * typedef GEnumValue GtkEnumValue;
120  * Warning
121  * GtkEnumValue is deprecated and should not be used in newly-written code.
122  * A structure which contains a single enum value, and its name, and its
123  * nickname.
124  */
125 public alias GEnumValue GtkEnumValue;
126 
127 /**
128  * typedef GFlagsValue GtkFlagValue;
129  * Warning
130  * GtkFlagValue is deprecated and should not be used in newly-written code.
131  */
132 public alias GFlagsValue GtkFlagValue;
133 /**
134  * The GtkDestDefaults enumeration specifies the various
135  * types of action that will be taken on behalf
136  * of the user for a drag destination site.
137  * GTK_DEST_DEFAULT_MOTION
138  *  If set for a widget, GTK+, during a drag over this
139  *  widget will check if the drag matches this widget's
140  *  list of possible targets and actions.
141  *  GTK+ will then call gdk_drag_status() as appropriate.
142  * GTK_DEST_DEFAULT_HIGHLIGHT
143  *  If set for a widget, GTK+ will draw a highlight on
144  *  this widget as long as a drag is over this widget
145  *  and the widget drag format and action are acceptable.
146  * GTK_DEST_DEFAULT_DROP
147  *  If set for a widget, when a drop occurs, GTK+ will
148  *  will check if the drag matches this widget's
149  *  list of possible targets and actions. If so,
150  *  GTK+ will call gtk_drag_get_data() on behalf
151  *  of the widget. Whether or not the drop is successful,
152  *  GTK+ will call gtk_drag_finish(). If the action
153  *  was a move, then if the drag was successful, then
154  *  TRUE will be passed for the delete parameter
155  *  to gtk_drag_finish().
156  * GTK_DEST_DEFAULT_ALL
157  *  If set, specifies that all default actions should
158  *  be taken.
159  */
160 public enum GtkDestDefaults
161 {
162 	MOTION = 1 << 0, /+* respond to "dragMotion" +/
163 	HIGHLIGHT = 1 << 1, /+* auto-highlight +/
164 	DROP = 1 << 2, /+* respond to "dragDrop" +/
165 	ALL = 0x07
166 }
167 alias GtkDestDefaults DestDefaults;
168 
169 /**
170  * The GtkTargetFlags enumeration is used to specify
171  * constraints on an entry in a GtkTargetTable.
172  * GTK_TARGET_SAME_APP
173  *  If this is set, the target will only be selected
174  *  for drags within a single application.
175  * GTK_TARGET_SAME_WIDGET
176  *  If this is set, the target will only be selected
177  *  for drags within a single widget.
178  * GTK_TARGET_OTHER_APP
179  *  If this is set, the target will not be selected
180  *  for drags within a single application. Since 2.12
181  * GTK_TARGET_OTHER_WIDGET
182  *  If this is set, the target will not be selected
183  *  for drags withing a single widget. Since 2.12
184  */
185 public enum GtkTargetFlags
186 {
187 	SAME_APP = 1 << 0, /+*< nick=same-app >+/
188 	SAME_WIDGET = 1 << 1, /+*< nick=same-widget >+/
189 	OTHER_APP = 1 << 2, /+*< nick=other-app >+/
190 	OTHER_WIDGET = 1 << 3 /+*< nick=other-widget >+/
191 }
192 alias GtkTargetFlags TargetFlags;
193 
194 /**
195  * Used to specify options for gtk_icon_theme_lookup_icon()
196  * GTK_ICON_LOOKUP_NO_SVG
197  * Never return SVG icons, even if gdk-pixbuf
198  *  supports them. Cannot be used together with GTK_ICON_LOOKUP_FORCE_SVG.
199  * GTK_ICON_LOOKUP_FORCE_SVG
200  * Return SVG icons, even if gdk-pixbuf
201  *  doesn't support them.
202  *  Cannot be used together with GTK_ICON_LOOKUP_NO_SVG.
203  * GTK_ICON_LOOKUP_USE_BUILTIN
204  * When passed to
205  *  gtk_icon_theme_lookup_icon() includes builtin icons
206  *  as well as files. For a builtin icon, gtk_icon_info_get_filename()
207  *  returns NULL and you need to call gtk_icon_info_get_builtin_pixbuf().
208  * GTK_ICON_LOOKUP_GENERIC_FALLBACK
209  * Try to shorten icon name at '-'
210  *  characters before looking at inherited themes. For more general
211  *  fallback, see gtk_icon_theme_choose_icon(). Since 2.12.
212  * GTK_ICON_LOOKUP_FORCE_SIZE
213  * Always return the icon scaled to the
214  *  requested size. Since 2.14.
215  */
216 public enum GtkIconLookupFlags
217 {
218 	NO_SVG = 1 << 0,
219 	FORCE_SVG = 1 << 1,
220 	USE_BUILTIN = 1 << 2,
221 	GENERIC_FALLBACK = 1 << 3,
222 	FORCE_SIZE = 1 << 4
223 }
224 alias GtkIconLookupFlags IconLookupFlags;
225 
226 /**
227  * Error codes for GtkIconTheme operations.
228  * GTK_ICON_THEME_NOT_FOUND
229  * The icon specified does not exist in the theme
230  * GTK_ICON_THEME_FAILED
231  * An unspecified error occurred.
232  */
233 public enum GtkIconThemeError
234 {
235 	NOT_FOUND,
236 	FAILED
237 }
238 alias GtkIconThemeError IconThemeError;
239 
240 public enum GtkIconSize
241 {
242 	INVALID,
243 	MENU,
244 	SMALL_TOOLBAR,
245 	LARGE_TOOLBAR,
246 	BUTTON,
247 	DND,
248 	DIALOG
249 }
250 alias GtkIconSize IconSize;
251 
252 /**
253  * The GtkRcFlags enumeration is used as a bitmask
254  * to specify which fields of a GtkRcStyle have been
255  * set for each state.
256  * GTK_RC_FG
257  * If present, the foreground color has been set for this state.
258  * GTK_RC_BG
259  * If present, the background color has been set for this state.
260  * GTK_RC_TEXT
261  * If present, the text color has been set for this state.
262  * GTK_RC_BASE
263  * If present, the base color has been set for this state.
264  */
265 public enum GtkRcFlags
266 {
267 	FG = 1 << 0,
268 	BG = 1 << 1,
269 	TEXT = 1 << 2,
270 	BASE = 1 << 3
271 }
272 alias GtkRcFlags RcFlags;
273 
274 /**
275  * The GtkRcTokenType enumeration represents the tokens
276  * in the RC file. It is exposed so that theme engines
277  * can reuse these tokens when parsing the theme-engine
278  * specific portions of a RC file.
279  */
280 public enum GtkRcTokenType
281 {
282 	INVALID = cast(int)TokenType.LAST,
283 	INCLUDE,
284 	NORMAL,
285 	ACTIVE,
286 	PRELIGHT,
287 	SELECTED,
288 	INSENSITIVE,
289 	FG,
290 	BG,
291 	TEXT,
292 	BASE,
293 	XTHICKNESS,
294 	YTHICKNESS,
295 	FONT,
296 	FONTSET,
297 	FONT_NAME,
298 	BG_PIXMAP,
299 	PIXMAP_PATH,
300 	STYLE,
301 	BINDING,
302 	BIND,
303 	WIDGET,
304 	WIDGET_CLASS,
305 	CLASS,
306 	LOWEST,
307 	GTK,
308 	APPLICATION,
309 	THEME,
310 	RC,
311 	HIGHEST,
312 	ENGINE,
313 	MODULE_PATH,
314 	IM_MODULE_PATH,
315 	IM_MODULE_FILE,
316 	STOCK,
317 	LTR,
318 	RTL,
319 	COLOR,
320 	UNBIND,
321 	LAST
322 }
323 alias GtkRcTokenType RcTokenType;
324 
325 public enum GtkAccelFlags
326 {
327 	VISIBLE = 1 << 0, /+* display inn GtkAccelLabel? +/
328 	LOCKED = 1 << 1, /+* is it removable? +/
329 	MASK = 0x07
330 }
331 alias GtkAccelFlags AccelFlags;
332 
333 public enum GtkAnchorType
334 {
335 	CENTER,
336 	NORTH,
337 	NORTH_WEST,
338 	NORTH_EAST,
339 	SOUTH,
340 	SOUTH_WEST,
341 	SOUTH_EAST,
342 	WEST,
343 	EAST,
344 	N = NORTH,
345 	NW = NORTH_WEST,
346 	NE = NORTH_EAST,
347 	S = SOUTH,
348 	SW = SOUTH_WEST,
349 	SE = SOUTH_EAST,
350 	W = WEST,
351 	E = EAST
352 }
353 alias GtkAnchorType AnchorType;
354 
355 /**
356  * Used to specify the placement of scroll arrows in scrolling menus.
357  * GTK_ARROWS_BOTH
358  * Place one arrow on each end of the menu.
359  * GTK_ARROWS_START
360  * Place both arrows at the top of the menu.
361  * GTK_ARROWS_END
362  * Place both arrows at the bottom of the menu.
363  */
364 public enum GtkArrowPlacement
365 {
366 	ARROWS_BOTH,
367 	ARROWS_START,
368 	ARROWS_END
369 }
370 alias GtkArrowPlacement ArrowPlacement;
371 
372 /**
373  * Used to indicate the direction in which a GtkArrow should point.
374  * GTK_ARROW_UP
375  * Represents an upward pointing arrow.
376  * GTK_ARROW_DOWN
377  * Represents a downward pointing arrow.
378  * GTK_ARROW_LEFT
379  * Represents a left pointing arrow.
380  * GTK_ARROW_RIGHT
381  * Represents a right pointing arrow.
382  * GTK_ARROW_NONE
383  * No arrow. Since 2.10.
384  */
385 public enum GtkArrowType
386 {
387 	UP,
388 	DOWN,
389 	LEFT,
390 	RIGHT,
391 	NONE
392 }
393 alias GtkArrowType ArrowType;
394 
395 /**
396  * Denotes the expansion properties that a widget will have when it (or its
397  * parent) is resized.
398  * GTK_EXPAND
399  * the widget should expand to take up any extra space in its
400  * container that has been allocated.
401  * GTK_SHRINK
402  * the widget should shrink as and when possible.
403  * GTK_FILL
404  * the widget should fill the space allocated to it.
405  */
406 public enum GtkAttachOptions
407 {
408 	EXPAND = 1 << 0,
409 	SHRINK = 1 << 1,
410 	FILL = 1 << 2
411 }
412 alias GtkAttachOptions AttachOptions;
413 
414 /**
415  * Used to dictate the style that a GtkButtonBox uses to layout the buttons it
416  * contains. (See also: GtkVButtonBox and GtkHButtonBox).
417  * GTK_BUTTONBOX_DEFAULT_STYLE
418  * Default packing.
419  * GTK_BUTTONBOX_SPREAD
420  * Buttons are evenly spread across the box.
421  * GTK_BUTTONBOX_EDGE
422  * Buttons are placed at the edges of the box.
423  * GTK_BUTTONBOX_START
424  * Buttons are grouped towards the start of the box,
425  *  (on the left for a HBox, or the top for a VBox).
426  * GTK_BUTTONBOX_END
427  * Buttons are grouped towards the end of the box,
428  *  (on the right for a HBox, or the bottom for a VBox).
429  * GTK_BUTTONBOX_CENTER
430  * Buttons are centered in the box. Since 2.12
431  */
432 public enum GtkButtonBoxStyle
433 {
434 	DEFAULT_STYLE,
435 	SPREAD,
436 	EDGE,
437 	START,
438 	END,
439 	CENTER
440 }
441 alias GtkButtonBoxStyle ButtonBoxStyle;
442 
443 /**
444  * Specifies which corner a child widget should be placed in when packed into
445  * a GtkScrolledWindow. This is effectively the opposite of where the scroll
446  * bars are placed.
447  * GTK_CORNER_TOP_LEFT
448  * Place the scrollbars on the right and bottom of the
449  * widget (default behaviour).
450  * GTK_CORNER_BOTTOM_LEFT
451  * Place the scrollbars on the top and right of the
452  * widget.
453  * GTK_CORNER_TOP_RIGHT
454  * Place the scrollbars on the left and bottom of the
455  * widget.
456  * GTK_CORNER_BOTTOM_RIGHT
457  * Place the scrollbars on the top and left of the
458  * widget.
459  */
460 public enum GtkCornerType
461 {
462 	TOP_LEFT,
463 	BOTTOM_LEFT,
464 	TOP_RIGHT,
465 	BOTTOM_RIGHT
466 }
467 alias GtkCornerType CornerType;
468 
469 /**
470  * Warning
471  * GtkCurveType is deprecated and should not be used in newly-written code.
472  */
473 public enum GtkCurveType
474 {
475 	TYPE_LINEAR, /+* linear interpolation +/
476 	TYPE_SPLINE, /+* spline interpolation +/
477 	TYPE_FREE /+* free form curve +/
478 }
479 alias GtkCurveType CurveType;
480 
481 public enum GtkDeleteType
482 {
483 	CHARS,
484 	WORD_ENDS, /+* delet only the portion of the word to the
485 	 * left/right of cursor if we're inn the middle
486 	 * of a word +/
487 	WORDS,
488 	DISPLAY_LINES,
489 	DISPLAY_LINE_ENDS,
490 	PARAGRAPH_ENDS, /+* like C-k inn Emacs (or its reverse) +/
491 	PARAGRAPHS, /+* C-k inn pico, kill whole line +/
492 	WHITESPACE /+* M-\ inn Emacs +/
493 }
494 alias GtkDeleteType DeleteType;
495 
496 public enum GtkDirectionType
497 {
498 	TAB_FORWARD,
499 	TAB_BACKWARD,
500 	UP,
501 	DOWN,
502 	LEFT,
503 	RIGHT
504 }
505 alias GtkDirectionType DirectionType;
506 
507 /**
508  * Used to specify the style of the expanders drawn by a GtkTreeView.
509  * GTK_EXPANDER_COLLAPSED
510  * The style used for a collapsed subtree.
511  * GTK_EXPANDER_SEMI_COLLAPSED
512  * Intermediate style used during animation.
513  * GTK_EXPANDER_SEMI_EXPANDED
514  * Intermediate style used during animation.
515  * GTK_EXPANDER_EXPANDED
516  * The style used for an expanded subtree.
517  */
518 public enum GtkExpanderStyle
519 {
520 	COLLAPSED,
521 	SEMI_COLLAPSED,
522 	SEMI_EXPANDED,
523 	EXPANDED
524 }
525 alias GtkExpanderStyle ExpanderStyle;
526 
527 public enum GtkIMPreeditStyle
528 {
529 	NOTHING,
530 	CALLBACK,
531 	NONE
532 }
533 alias GtkIMPreeditStyle IMPreeditStyle;
534 
535 public enum GtkIMStatusStyle
536 {
537 	NOTHING,
538 	CALLBACK,
539 	NONE
540 }
541 alias GtkIMStatusStyle IMStatusStyle;
542 
543 /**
544  * Used for justifying the text inside a GtkLabel widget. (See also
545  * GtkAlignment).
546  * GTK_JUSTIFY_LEFT
547  * The text is placed at the left edge of the label.
548  * GTK_JUSTIFY_RIGHT
549  * The text is placed at the right edge of the label.
550  * GTK_JUSTIFY_CENTER
551  * The text is placed in the center of the label.
552  * GTK_JUSTIFY_FILL
553  * The text is placed is distributed across the label.
554  */
555 public enum GtkJustification
556 {
557 	JUSTIFY_LEFT,
558 	JUSTIFY_RIGHT,
559 	JUSTIFY_CENTER,
560 	JUSTIFY_FILL
561 }
562 alias GtkJustification Justification;
563 
564 /**
565  * Warning
566  * GtkMatchType is deprecated and should not be used in newly-written code.
567  */
568 public enum GtkMatchType
569 {
570 	ALL, /+* "*A?A*" +/
571 	ALL_TAIL, /+* "*A?AA" +/
572 	HEAD, /+* "AAAA*" +/
573 	TAIL, /+* "*AAAA" +/
574 	EXACT, /+* "AAAAA" +/
575 	LAST
576 }
577 alias GtkMatchType MatchType;
578 
579 /**
580  * Used to indicate which metric is used by a GtkRuler.
581  * GTK_PIXELS
582  * Pixels.
583  * GTK_INCHES
584  * Inches.
585  * GTK_CENTIMETERS
586  * Centimeters.
587  */
588 public enum GtkMetricType
589 {
590 	PIXELS,
591 	INCHES,
592 	CENTIMETERS
593 }
594 alias GtkMetricType MetricType;
595 
596 public enum GtkMovementStep
597 {
598 	LOGICAL_POSITIONS, /+* move by forw/back graphemes +/
599 	VISUAL_POSITIONS, /+* move by left/right graphemes +/
600 	WORDS, /+* move by forward/back words +/
601 	DISPLAY_LINES, /+* move up/down lines (wrapped lines) +/
602 	DISPLAY_LINE_ENDS, /+* move to either end of a line +/
603 	PARAGRAPHS, /+* move up/down paragraphs (newline-ended lines) +/
604 	PARAGRAPH_ENDS, /+* move to either end of a paragraph +/
605 	PAGES, /+* move by pages +/
606 	BUFFER_ENDS, /+* move to ends of the buffer +/
607 	HORIZONTAL_PAGES /+* move horizontally by pages +/
608 }
609 alias GtkMovementStep MovementStep;
610 
611 /**
612  * Represents the orientation of widgets which can be switched between horizontal
613  * and vertical orientation on the fly, like GtkToolbar.
614  * GTK_ORIENTATION_HORIZONTAL
615  * The widget is in horizontal orientation.
616  * GTK_ORIENTATION_VERTICAL
617  * The widget is in vertical orientation.
618  */
619 public enum GtkOrientation
620 {
621 	HORIZONTAL,
622 	VERTICAL
623 }
624 alias GtkOrientation Orientation;
625 
626 /**
627  * Represents the packing location GtkBox children. (See: GtkVBox,
628  * GtkHBox, and GtkButtonBox).
629  * GTK_PACK_START
630  * The child is packed into the start of the box
631  * GTK_PACK_END
632  * The child is packed into the end of the box
633  */
634 public enum GtkPackType
635 {
636 	START,
637 	END
638 }
639 alias GtkPackType PackType;
640 
641 public enum GtkPathPriorityType
642 {
643 	LOWEST = 0,
644 	GTK = 4,
645 	APPLICATION = 8,
646 	THEME = 10,
647 	RC = 12,
648 	HIGHEST = 15
649 }
650 alias GtkPathPriorityType PathPriorityType;
651 
652 public enum GtkPathType
653 {
654 	WIDGET,
655 	WIDGET_CLASS,
656 	CLASS
657 }
658 alias GtkPathType PathType;
659 
660 /**
661  * Determines when a scroll bar will be visible.
662  * GTK_POLICY_ALWAYS
663  * The scrollbar is always visible.
664  * GTK_POLICY_AUTOMATIC
665  * The scrollbar will appear and disappear as necessary. For example,
666  * when all of a GtkCList can not be seen.
667  * GTK_POLICY_NEVER
668  * The scrollbar will never appear.
669  */
670 public enum GtkPolicyType
671 {
672 	ALWAYS,
673 	AUTOMATIC,
674 	NEVER
675 }
676 alias GtkPolicyType PolicyType;
677 
678 /**
679  * Describes which edge of a widget a certain feature is positioned at, e.g. the
680  * tabs of a GtkNotebook, the handle of a GtkHandleBox or the label of a
681  * GtkScale.
682  * GTK_POS_LEFT
683  * The feature is at the left edge.
684  * GTK_POS_RIGHT
685  * The feature is at the right edge.
686  * GTK_POS_TOP
687  * The feature is at the top edge.
688  * GTK_POS_BOTTOM
689  * The feature is at the bottom edge.
690  */
691 public enum GtkPositionType
692 {
693 	LEFT,
694 	RIGHT,
695 	TOP,
696 	BOTTOM
697 }
698 alias GtkPositionType PositionType;
699 
700 /**
701  * Warning
702  * GtkPreviewType is deprecated and should not be used in newly-written code.
703  * An enumeration which describes whether a preview
704  * contains grayscale or red-green-blue data.
705  * GTK_PREVIEW_COLOR
706  * the preview contains red-green-blue data.
707  * GTK_PREVIEW_GRAYSCALE
708  * The preview contains grayscale data.
709  */
710 public enum GtkPreviewType
711 {
712 	COLOR,
713 	GRAYSCALE
714 }
715 alias GtkPreviewType PreviewType;
716 
717 /**
718  * Indicated the relief to be drawn around a GtkButton.
719  * GTK_RELIEF_NORMAL
720  * Draw a normal relief.
721  * GTK_RELIEF_HALF
722  * A half relief.
723  * GTK_RELIEF_NONE
724  * No relief.
725  */
726 public enum GtkReliefStyle
727 {
728 	NORMAL,
729 	HALF,
730 	NONE
731 }
732 alias GtkReliefStyle ReliefStyle;
733 
734 /**
735  * GTK_RESIZE_PARENT
736  * GTK_RESIZE_QUEUE
737  * GTK_RESIZE_IMMEDIATE
738  * Deprecated.
739  */
740 public enum GtkResizeMode
741 {
742 	PARENT, /+* Pass resize request to the parent +/
743 	QUEUE, /+* Queue resizes on this widget +/
744 	IMMEDIATE /+* Perform the resizes now +/
745 }
746 alias GtkResizeMode ResizeMode;
747 
748 public enum GtkScrollStep
749 {
750 	STEPS,
751 	PAGES,
752 	ENDS,
753 	HORIZONTAL_STEPS,
754 	HORIZONTAL_PAGES,
755 	HORIZONTAL_ENDS
756 }
757 alias GtkScrollStep ScrollStep;
758 
759 public enum GtkScrollType
760 {
761 	NONE,
762 	JUMP,
763 	STEP_BACKWARD,
764 	STEP_FORWARD,
765 	PAGE_BACKWARD,
766 	PAGE_FORWARD,
767 	STEP_UP,
768 	STEP_DOWN,
769 	PAGE_UP,
770 	PAGE_DOWN,
771 	STEP_LEFT,
772 	STEP_RIGHT,
773 	PAGE_LEFT,
774 	PAGE_RIGHT,
775 	START,
776 	END
777 }
778 alias GtkScrollType ScrollType;
779 
780 /**
781  * Used to control what selections users are allowed to make.
782  * GTK_SELECTION_NONE
783  * No selection is possible.
784  * GTK_SELECTION_SINGLE
785  * Zero or one element may be selected.
786  * GTK_SELECTION_BROWSE
787  * Exactly one element is selected. In some circumstances,
788  *  such as initially or during a search operation, it's possible for no element
789  *  to be selected with GTK_SELECTION_BROWSE. What is really enforced is that
790  *  the user can't deselect a currently selected element except by selecting
791  *  another element.
792  * GTK_SELECTION_MULTIPLE
793  * Any number of elements may be selected.
794  *  Clicks toggle the state of an item. Any number of elements may be selected.
795  *  The Ctrl key may be used to enlarge the selection, and Shift key to select
796  *  between the focus and the child pointed to. Some widgets may also allow
797  *  Click-drag to select a range of elements.
798  * GTK_SELECTION_EXTENDED
799  * Deprecated, behaves identical to GTK_SELECTION_MULTIPLE.
800  */
801 public enum GtkSelectionMode
802 {
803 	NONE, /+* Nothing can be selected +/
804 	SINGLE,
805 	BROWSE,
806 	MULTIPLE,
807 	EXTENDED = MULTIPLE /+* Deprecated +/
808 }
809 alias GtkSelectionMode SelectionMode;
810 
811 /**
812  * Used to change the appearance of an outline typically provided by a GtkFrame.
813  * GTK_SHADOW_NONE
814  * No outline.
815  * GTK_SHADOW_IN
816  * The outline is bevelled inwards.
817  * GTK_SHADOW_OUT
818  * The outline is bevelled outwards like a button.
819  * GTK_SHADOW_ETCHED_IN
820  * The outline has a sunken 3d appearance.
821  * GTK_SHADOW_ETCHED_OUT
822  * The outline has a raised 3d appearance
823  */
824 public enum GtkShadowType
825 {
826 	NONE,
827 	IN,
828 	OUT,
829 	ETCHED_IN,
830 	ETCHED_OUT
831 }
832 alias GtkShadowType ShadowType;
833 
834 /**
835  * Warning
836  * GtkSideType is deprecated and should not be used in newly-written code.
837  */
838 public enum GtkSideType
839 {
840 	TOP,
841 	BOTTOM,
842 	LEFT,
843 	RIGHT
844 }
845 alias GtkSideType SideType;
846 
847 /**
848  * This type indicates the current state of a widget; the state determines how
849  * the widget is drawn. The GtkStateType enumeration is also used to
850  * identify different colors in a GtkStyle for drawing, so states can be
851  * used for subparts of a widget as well as entire widgets.
852  * GTK_STATE_NORMAL
853  * State during normal operation.
854  * GTK_STATE_ACTIVE
855  * State of a currently active widget, such as a depressed button.
856  * GTK_STATE_PRELIGHT
857  * State indicating that the mouse pointer is over
858  * the widget and the widget will respond to mouse clicks.
859  * GTK_STATE_SELECTED
860  * State of a selected item, such the selected row in a list.
861  * GTK_STATE_INSENSITIVE
862  * State indicating that the widget is
863  * unresponsive to user actions.
864  */
865 public enum GtkStateType
866 {
867 	NORMAL,
868 	ACTIVE,
869 	PRELIGHT,
870 	SELECTED,
871 	INSENSITIVE
872 }
873 alias GtkStateType StateType;
874 
875 /**
876  * Warning
877  * GtkSubmenuDirection is deprecated and should not be used in newly-written code.
878  * Indicates the direction a sub-menu will appear.
879  * GTK_DIRECTION_LEFT
880  * A sub-menu will appear to the left of the current menu.
881  * GTK_DIRECTION_RIGHT
882  * A sub-menu will appear to the right of the current menu.
883  */
884 public enum GtkSubmenuDirection
885 {
886 	DIRECTION_LEFT,
887 	DIRECTION_RIGHT
888 }
889 alias GtkSubmenuDirection SubmenuDirection;
890 
891 /**
892  * Warning
893  * GtkSubmenuPlacement is deprecated and should not be used in newly-written code.
894  */
895 public enum GtkSubmenuPlacement
896 {
897 	TOP_BOTTOM,
898 	LEFT_RIGHT
899 }
900 alias GtkSubmenuPlacement SubmenuPlacement;
901 
902 /**
903  * Used to customize the appearance of a GtkToolbar. Note that
904  * setting the toolbar style overrides the user's preferences
905  * for the default toolbar style. Note that if the button has only
906  * a label set and GTK_TOOLBAR_ICONS is used, the label will be
907  * visible, and vice versa.
908  * GTK_TOOLBAR_ICONS
909  * Buttons display only icons in the toolbar.
910  * GTK_TOOLBAR_TEXT
911  * Buttons display only text labels in the toolbar.
912  * GTK_TOOLBAR_BOTH
913  * Buttons display text and icons in the toolbar.
914  * GTK_TOOLBAR_BOTH_HORIZ
915  * Buttons display icons and text alongside each
916  * other, rather than vertically stacked
917  */
918 public enum GtkToolbarStyle
919 {
920 	ICONS,
921 	TEXT,
922 	BOTH,
923 	BOTH_HORIZ
924 }
925 alias GtkToolbarStyle ToolbarStyle;
926 
927 /**
928  * Used by GtkRange to control the policy for notifying value changes.
929  * GTK_UPDATE_CONTINUOUS
930  * Notify updates whenever the value changed
931  * GTK_UPDATE_DISCONTINUOUS
932  * Notify updates when the mouse button has been released
933  * GTK_UPDATE_DELAYED
934  * Space out updates with a small timeout
935  */
936 public enum GtkUpdateType
937 {
938 	CONTINUOUS,
939 	DISCONTINUOUS,
940 	DELAYED
941 }
942 alias GtkUpdateType UpdateType;
943 
944 /**
945  * Used by GtkCList and GtkCTree to indicate whether a row is visible.
946  * GTK_VISIBILITY_NONE
947  * The row is not visible.
948  * GTK_VISIBILITY_PARTIAL
949  * The row is partially visible.
950  * GTK_VISIBILITY_FULL
951  * The row is fully visible.
952  */
953 public enum GtkVisibility
954 {
955 	NONE,
956 	PARTIAL,
957 	FULL
958 }
959 alias GtkVisibility Visibility;
960 
961 /**
962  * Window placement can be influenced using this enumeration. Note that
963  * using GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea.
964  * It won't necessarily work well with all window managers or on all windowing systems.
965  * GTK_WIN_POS_NONE
966  * No influence is made on placement.
967  * GTK_WIN_POS_CENTER
968  * Windows should be placed in the center of the screen.
969  * GTK_WIN_POS_MOUSE
970  * Windows should be placed at the current mouse position.
971  * GTK_WIN_POS_CENTER_ALWAYS
972  * Keep window centered as it changes size, etc.
973  * GTK_WIN_POS_CENTER_ON_PARENT
974  * Center the window on its transient
975  * parent (see gtk_window_set_transient_for()).
976  */
977 public enum GtkWindowPosition
978 {
979 	POS_NONE,
980 	POS_CENTER,
981 	POS_MOUSE,
982 	POS_CENTER_ALWAYS,
983 	POS_CENTER_ON_PARENT
984 }
985 alias GtkWindowPosition WindowPosition;
986 
987 /**
988  * A GtkWindow can be one of these types. Most things you'd consider a
989  * "window" should have type GTK_WINDOW_TOPLEVEL; windows with this type
990  * are managed by the window manager and have a frame by default (call
991  * gtk_window_set_decorated() to toggle the frame). Windows with type
992  * GTK_WINDOW_POPUP are ignored by the window manager; window manager
993  * keybindings won't work on them, the window manager won't decorate the
994  * window with a frame, many GTK+ features that rely on the window
995  * manager will not work (e.g. resize grips and
996  * maximization/minimization). GTK_WINDOW_POPUP is used to implement
997  * widgets such as GtkMenu or tooltips that you normally don't think of
998  * as windows per se. Nearly all windows should be GTK_WINDOW_TOPLEVEL.
999  * In particular, do not use GTK_WINDOW_POPUP just to turn off
1000  * the window borders; use gtk_window_set_decorated() for that.
1001  * GTK_WINDOW_TOPLEVEL
1002  * A regular window, such as a dialog.
1003  * GTK_WINDOW_POPUP
1004  * A special window such as a tooltip.
1005  */
1006 public enum GtkWindowType
1007 {
1008 	TOPLEVEL,
1009 	POPUP
1010 }
1011 alias GtkWindowType WindowType;
1012 
1013 /**
1014  * Determines the direction of a sort.
1015  * GTK_SORT_ASCENDING
1016  * Sorting is in ascending order.
1017  * GTK_SORT_DESCENDING
1018  * Sorting is in descending order.
1019  */
1020 public enum GtkSortType
1021 {
1022 	ASCENDING,
1023 	DESCENDING
1024 }
1025 alias GtkSortType SortType;
1026 
1027 /**
1028  * Gives an indication why a drag operation failed.
1029  * The value can by obtained by connecting to the
1030  * "drag-failed" signal.
1031  * GTK_DRAG_RESULT_SUCCESS
1032  * The drag operation was successful
1033  * GTK_DRAG_RESULT_NO_TARGET
1034  * No suitable drag target
1035  * GTK_DRAG_RESULT_USER_CANCELLED
1036  * The user cancelled the drag operation
1037  * GTK_DRAG_RESULT_TIMEOUT_EXPIRED
1038  * The drag operation timed out
1039  * GTK_DRAG_RESULT_GRAB_BROKEN
1040  * The pointer or keyboard grab used
1041  *  for the drag operation was broken
1042  * GTK_DRAG_RESULT_ERROR
1043  * The drag operation failed due to some
1044  *  unspecified error
1045  */
1046 public enum GtkDragResult
1047 {
1048 	SUCCESS,
1049 	NO_TARGET,
1050 	USER_CANCELLED,
1051 	TIMEOUT_EXPIRED,
1052 	GRAB_BROKEN,
1053 	ERROR
1054 }
1055 alias GtkDragResult DragResult;
1056 
1057 /**
1058  * Warning
1059  * GtkSignalRunType is deprecated and should not be used in newly-written code.
1060  * These configure the signal's emission. They control
1061  * whether the signal can be emitted recursively on an object
1062  * and
1063  * whether to run the default method before or after the user-defined handlers.
1064  * GTK_RUN_FIRST
1065  * Run the default handler before the connected user-defined
1066  * handlers.
1067  * GTK_RUN_LAST
1068  * Run the default handler after the connected
1069  * user-defined handlers.
1070  * (Handlers registered as "after" always run after the default handler though)
1071  * GTK_RUN_BOTH
1072  * Run the default handler twice,
1073  * once before the user-defined handlers,
1074  * and
1075  * once after.
1076  * GTK_RUN_NO_RECURSE
1077  * Whether to prevent a handler or hook
1078  * from reemitting the signal from within itself.
1079  * Attempts to
1080  * emit the signal while it is running will result in the signal
1081  * emission being restarted once it is done with the current processing.
1082  * You must be
1083  * careful to avoid having two handlers endlessly reemitting signals,
1084  * gtk_signal_n_emissions() can be helpful.
1085  * GTK_RUN_ACTION
1086  * The signal is an action you can
1087  * invoke without any particular setup or cleanup.
1088  * The signal is treated no differently, but some
1089  * other code can determine if the signal is appropriate to
1090  * delegate to user control. For example, key binding sets
1091  * only allow bindings of ACTION signals to keystrokes.
1092  * GTK_RUN_NO_HOOKS
1093  * This prevents the connection of emission hooks
1094  * to the signal.
1095  */
1096 public enum GtkSignalRunType
1097 {
1098 	RUN_FIRST = SignalFlags.RUN_FIRST,
1099 	RUN_LAST = SignalFlags.RUN_LAST,
1100 	RUN_BOTH = (RUN_FIRST | RUN_LAST),
1101 	RUN_NO_RECURSE = SignalFlags.NO_RECURSE,
1102 	RUN_ACTION = SignalFlags.ACTION,
1103 	RUN_NO_HOOKS = SignalFlags.NO_HOOKS
1104 }
1105 alias GtkSignalRunType SignalRunType;
1106 
1107 /**
1108  * Flags used to influence dialog construction.
1109  * GTK_DIALOG_MODAL
1110  * Make the constructed dialog modal,
1111  *  see gtk_window_set_modal().
1112  * GTK_DIALOG_DESTROY_WITH_PARENT
1113  * Destroy the dialog when its
1114  *  parent is destroyed, see gtk_window_set_destroy_with_parent().
1115  * GTK_DIALOG_NO_SEPARATOR
1116  * Don't put a separator between the
1117  *  action area and the dialog content. This option has been deprecated in GTK+ 2.22. It will be removed in GTK+ 3
1118  */
1119 public enum GtkDialogFlags
1120 {
1121 	MODAL = 1 << 0, /+* call windowSetModal (win, TRUE) +/
1122 	DESTROY_WITH_PARENT = 1 << 1, /+* call windowSetDestroyWithParent () +/
1123 	NO_SEPARATOR = 1 << 2 /+* no separator bar above buttons +/
1124 }
1125 alias GtkDialogFlags DialogFlags;
1126 
1127 /**
1128  * Predefined values for use as response ids in gtk_dialog_add_button().
1129  * All predefined values are negative, GTK+ leaves positive values for
1130  * application-defined response ids.
1131  * GTK_RESPONSE_NONE
1132  * Returned if an action widget has no response id, or if
1133  *  the dialog gets programmatically hidden or destroyed.
1134  * GTK_RESPONSE_REJECT
1135  * Generic response id, not used by GTK+ dialogs.
1136  * GTK_RESPONSE_ACCEPT
1137  * Generic response id, not used by GTK+ dialogs.
1138  * GTK_RESPONSE_DELETE_EVENT
1139  * Returned if the dialog is deleted.
1140  * GTK_RESPONSE_OK
1141  * Returned by OK buttons in GTK+ dialogs.
1142  * GTK_RESPONSE_CANCEL
1143  * Returned by Cancel buttons in GTK+ dialogs.
1144  * GTK_RESPONSE_CLOSE
1145  * Returned by Close buttons in GTK+ dialogs.
1146  * GTK_RESPONSE_YES
1147  * Returned by Yes buttons in GTK+ dialogs.
1148  * GTK_RESPONSE_NO
1149  * Returned by No buttons in GTK+ dialogs.
1150  * GTK_RESPONSE_APPLY
1151  * Returned by Apply buttons in GTK+ dialogs.
1152  * GTK_RESPONSE_HELP
1153  * Returned by Help buttons in GTK+ dialogs.
1154  */
1155 public enum GtkResponseType
1156 {
1157 	/+* GTK returns this if a response widget has no responseId,
1158 	 * or if the dialog gets programmatically hidden or destroyed.
1159 	+/
1160 	NONE = -1,
1161 	/+* GTK won't return these unless you pass them inn
1162 	 * as the response for an action widget. They are
1163 	 * for your convenience.
1164 	+/
1165 	REJECT = -2,
1166 	ACCEPT = -3,
1167 	/+* If the dialog is deleted. +/
1168 	DELETE_EVENT = -4,
1169 	/+* These are returned from GTK dialogs, and you can also use them
1170 	 * yourself if you like.
1171 	+/
1172 	OK = -5,
1173 	CANCEL = -6,
1174 	CLOSE = -7,
1175 	YES = -8,
1176 	NO = -9,
1177 	APPLY = -10,
1178 	HELP = -11
1179 }
1180 alias GtkResponseType ResponseType;
1181 
1182 /**
1183  * The type of message being displayed in the dialog.
1184  * GTK_MESSAGE_INFO
1185  * Informational message
1186  * GTK_MESSAGE_WARNING
1187  * Nonfatal warning message
1188  * GTK_MESSAGE_QUESTION
1189  * Question requiring a choice
1190  * GTK_MESSAGE_ERROR
1191  * Fatal error message
1192  * GTK_MESSAGE_OTHER
1193  * None of the above, doesn't get an icon
1194  */
1195 public enum GtkMessageType
1196 {
1197 	INFO,
1198 	WARNING,
1199 	QUESTION,
1200 	ERROR,
1201 	OTHER
1202 }
1203 alias GtkMessageType MessageType;
1204 
1205 /**
1206  * Prebuilt sets of buttons for the dialog. If
1207  * none of these choices are appropriate, simply use GTK_BUTTONS_NONE
1208  * then call gtk_dialog_add_buttons().
1209  * Note
1210  *  Please note that GTK_BUTTONS_OK, GTK_BUTTONS_YES_NO
1211  *  and GTK_BUTTONS_OK_CANCEL are discouraged by the
1212  *  GNOME HIG.
1213  * GTK_BUTTONS_NONE
1214  * no buttons at all
1215  * GTK_BUTTONS_OK
1216  * an OK button
1217  * GTK_BUTTONS_CLOSE
1218  * a Close button
1219  * GTK_BUTTONS_CANCEL
1220  * a Cancel button
1221  * GTK_BUTTONS_YES_NO
1222  * Yes and No buttons
1223  * GTK_BUTTONS_OK_CANCEL
1224  * OK and Cancel buttons
1225  */
1226 public enum GtkButtonsType
1227 {
1228 	NONE,
1229 	OK,
1230 	CLOSE,
1231 	CANCEL,
1232 	YES_NO,
1233 	OK_CANCEL
1234 }
1235 alias GtkButtonsType ButtonsType;
1236 
1237 /**
1238  * An enum for determining the page role inside the GtkAssistant. It's
1239  * used to handle buttons sensitivity and visibility.
1240  * Note that an assistant needs to end its page flow with a page of type
1241  * GTK_ASSISTANT_PAGE_CONFIRM, GTK_ASSISTANT_PAGE_SUMMARY or
1242  * GTK_ASSISTANT_PAGE_PROGRESS to be correct.
1243  * GTK_ASSISTANT_PAGE_CONTENT
1244  * The page has regular contents.
1245  * GTK_ASSISTANT_PAGE_INTRO
1246  * The page contains an introduction to the
1247  *  assistant task.
1248  * GTK_ASSISTANT_PAGE_CONFIRM
1249  * The page lets the user confirm or deny the
1250  *  changes.
1251  * GTK_ASSISTANT_PAGE_SUMMARY
1252  * The page informs the user of the changes
1253  *  done.
1254  * GTK_ASSISTANT_PAGE_PROGRESS
1255  * Used for tasks that take a long time to
1256  *  complete, blocks the assistant until the page is marked as complete.
1257  */
1258 public enum GtkAssistantPageType
1259 {
1260 	CONTENT,
1261 	INTRO,
1262 	CONFIRM,
1263 	SUMMARY,
1264 	PROGRESS
1265 }
1266 alias GtkAssistantPageType AssistantPageType;
1267 
1268 /**
1269  * Describes the image data representation used by a GtkImage. If you
1270  * want to get the image from the widget, you can only get the
1271  * currently-stored representation. e.g. if the
1272  * gtk_image_get_storage_type() returns GTK_IMAGE_PIXBUF, then you can
1273  * call gtk_image_get_pixbuf() but not gtk_image_get_stock(). For empty
1274  * images, you can request any storage type (call any of the "get"
1275  * functions), but they will all return NULL values.
1276  * GTK_IMAGE_EMPTY
1277  * there is no image displayed by the widget
1278  * GTK_IMAGE_PIXMAP
1279  * the widget contains a GdkPixmap
1280  * GTK_IMAGE_IMAGE
1281  * the widget contains a GdkImage
1282  * GTK_IMAGE_PIXBUF
1283  * the widget contains a GdkPixbuf
1284  * GTK_IMAGE_STOCK
1285  * the widget contains a stock icon name (see Stock Items(3))
1286  * GTK_IMAGE_ICON_SET
1287  * the widget contains a GtkIconSet
1288  * GTK_IMAGE_ANIMATION
1289  * the widget contains a GdkPixbufAnimation
1290  * GTK_IMAGE_ICON_NAME
1291  * the widget contains a named icon.
1292  *  This image type was added in GTK+ 2.6
1293  * GTK_IMAGE_GICON
1294  * the widget contains a GIcon.
1295  *  This image type was added in GTK+ 2.14
1296  */
1297 public enum GtkImageType
1298 {
1299 	EMPTY,
1300 	PIXMAP,
1301 	IMAGE,
1302 	PIXBUF,
1303 	STOCK,
1304 	ICON_SET,
1305 	ANIMATION,
1306 	ICON_NAME,
1307 	GICON
1308 }
1309 alias GtkImageType ImageType;
1310 
1311 /**
1312  * An enumeration representing possible orientations and growth
1313  * directions for the visible progress bar.
1314  * GTK_PROGRESS_LEFT_TO_RIGHT
1315  * A horizontal progress bar growing from left to right.
1316  * GTK_PROGRESS_RIGHT_TO_LEFT
1317  * A horizontal progress bar growing from right to left.
1318  * GTK_PROGRESS_BOTTOM_TO_TOP
1319  * A vertical progress bar growing from bottom to top.
1320  * GTK_PROGRESS_TOP_TO_BOTTOM
1321  * A vertical progress bar growing from top to bottom.
1322  */
1323 public enum GtkProgressBarOrientation
1324 {
1325 	LEFT_TO_RIGHT,
1326 	RIGHT_TO_LEFT,
1327 	BOTTOM_TO_TOP,
1328 	TOP_TO_BOTTOM
1329 }
1330 alias GtkProgressBarOrientation ProgressBarOrientation;
1331 
1332 /**
1333  * An enumeration representing the styles for drawing the progress bar.
1334  * GTK_PROGRESS_CONTINUOUS
1335  * The progress bar grows in a smooth, continuous manner.
1336  * GTK_PROGRESS_DISCRETE
1337  * The progress bar grows in discrete, visible blocks.
1338  */
1339 public enum GtkProgressBarStyle
1340 {
1341 	CONTINUOUS,
1342 	DISCRETE
1343 }
1344 alias GtkProgressBarStyle ProgressBarStyle;
1345 
1346 /**
1347  * Specifies the side of the entry at which an icon is placed.
1348  * GTK_ENTRY_ICON_PRIMARY
1349  * At the beginning of the entry (depending on the text direction).
1350  * GTK_ENTRY_ICON_SECONDARY
1351  * At the end of the entry (depending on the text direction).
1352  * Since 2.16
1353  */
1354 public enum GtkEntryIconPosition
1355 {
1356 	PRIMARY,
1357 	SECONDARY
1358 }
1359 alias GtkEntryIconPosition EntryIconPosition;
1360 
1361 /**
1362  * GTK_UPDATE_ALWAYS
1363  * When refreshing your GtkSpinButton, the value is always displayed.
1364  * GTK_UPDATE_IF_VALID
1365  * When refreshing your GtkSpinButton, the value is only displayed if it is valid within the bounds of the spin button's GtkAdjustment.
1366  */
1367 public enum GtkSpinButtonUpdatePolicy
1368 {
1369 	UPDATE_ALWAYS,
1370 	UPDATE_IF_VALID
1371 }
1372 alias GtkSpinButtonUpdatePolicy SpinButtonUpdatePolicy;
1373 
1374 /**
1375  * GTK_SPIN_STEP_FORWARD,
1376  * GTK_SPIN_STEP_BACKWARD,
1377  * GTK_SPIN_PAGE_FORWARD,
1378  * GTK_SPIN_PAGE_BACKWARD
1379  * These values spin a GtkSpinButton by the relevant values of the spin button's GtkAdjustment.
1380  * GTK_SPIN_HOME,
1381  * GTK_SPIN_END
1382  * These set the spin button's value to the minimum or maxmimum possible values, (set by its GtkAdjustment), respectively.
1383  * GTK_SPIN_USER_DEFINED
1384  * The programmer must specify the exact amount to spin the GtkSpinButton.
1385  */
1386 public enum GtkSpinType
1387 {
1388 	STEP_FORWARD,
1389 	STEP_BACKWARD,
1390 	PAGE_FORWARD,
1391 	PAGE_BACKWARD,
1392 	HOME,
1393 	END,
1394 	USER_DEFINED
1395 }
1396 alias GtkSpinType SpinType;
1397 
1398 public enum GtkTextSearchFlags
1399 {
1400 	VISIBLE_ONLY = 1 << 0,
1401 	TEXT_ONLY = 1 << 1
1402 	/+* Possible future plans: SEARCH_CASE_INSENSITIVE, SEARCH_REGEXP +/
1403 }
1404 alias GtkTextSearchFlags TextSearchFlags;
1405 
1406 public enum GtkTextBufferTargetInfo
1407 {
1408 	BUFFER_CONTENTS = - 1,
1409 	RICH_TEXT = - 2,
1410 	TEXT = - 3
1411 }
1412 alias GtkTextBufferTargetInfo TextBufferTargetInfo;
1413 
1414 /**
1415  * Describes a type of line wrapping.
1416  * GTK_WRAP_NONE
1417  * do not wrap lines; just make the text area wider
1418  * GTK_WRAP_CHAR
1419  * wrap text, breaking lines anywhere the cursor can
1420  *  appear (between characters, usually - if you want to
1421  *  be technical, between graphemes, see
1422  *  pango_get_log_attrs())
1423  * GTK_WRAP_WORD
1424  * wrap text, breaking lines in between words
1425  * GTK_WRAP_WORD_CHAR
1426  * wrap text, breaking lines in between words, or if
1427  *  that is not enough, also between graphemes.
1428  */
1429 public enum GtkWrapMode
1430 {
1431 	NONE,
1432 	CHAR,
1433 	WORD,
1434 	WORD_CHAR
1435 }
1436 alias GtkWrapMode WrapMode;
1437 
1438 public enum GtkTextWindowType
1439 {
1440 	PRIVATE,
1441 	WIDGET,
1442 	TEXT,
1443 	LEFT,
1444 	RIGHT,
1445 	TOP,
1446 	BOTTOM
1447 }
1448 alias GtkTextWindowType TextWindowType;
1449 
1450 /**
1451  * These flags indicate various properties of a GtkTreeModel. They are
1452  * returned by gtk_tree_model_get_flags(), and must be static for the
1453  * lifetime of the object. A more complete description of
1454  * GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of this
1455  * section.
1456  * GTK_TREE_MODEL_ITERS_PERSIST
1457  * Iterators survive all signals emitted by the tree.
1458  * GTK_TREE_MODEL_LIST_ONLY
1459  * The model is a list only, and never has children
1460  */
1461 public enum GtkTreeModelFlags
1462 {
1463 	ITERS_PERSIST = 1 << 0,
1464 	LIST_ONLY = 1 << 1
1465 }
1466 alias GtkTreeModelFlags TreeModelFlags;
1467 
1468 /**
1469  * The sizing method the column uses to determine its width. Please note
1470  * that GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
1471  * can make columns appear choppy.
1472  * GTK_TREE_VIEW_COLUMN_GROW_ONLY
1473  * Columns only get bigger in reaction to changes in the model
1474  * GTK_TREE_VIEW_COLUMN_AUTOSIZE
1475  * Columns resize to be the optimal size everytime the model changes.
1476  * GTK_TREE_VIEW_COLUMN_FIXED
1477  * Columns are a fixed numbers of pixels wide.
1478  */
1479 public enum GtkTreeViewColumnSizing
1480 {
1481 	GROW_ONLY,
1482 	AUTOSIZE,
1483 	FIXED
1484 }
1485 alias GtkTreeViewColumnSizing TreeViewColumnSizing;
1486 
1487 /**
1488  * An enum for determining where a dropped row goes.
1489  * GTK_TREE_VIEW_DROP_BEFORE
1490  * dropped row is inserted before
1491  * GTK_TREE_VIEW_DROP_AFTER
1492  * dropped row is inserted after
1493  * GTK_TREE_VIEW_DROP_INTO_OR_BEFORE
1494  * dropped row becomes a child or is inserted before
1495  * GTK_TREE_VIEW_DROP_INTO_OR_AFTER
1496  * dropped row becomes a child or is inserted after
1497  */
1498 public enum GtkTreeViewDropPosition
1499 {
1500 	/+* drop before/after this row +/
1501 	BEFORE,
1502 	AFTER,
1503 	/+* drop as a child of this row (with fallback to before or after
1504 	 * if into is not possible)
1505 	+/
1506 	INTO_OR_BEFORE,
1507 	INTO_OR_AFTER
1508 }
1509 alias GtkTreeViewDropPosition TreeViewDropPosition;
1510 
1511 /**
1512  * Used to indicate which grid lines to draw in a tree view.
1513  * GTK_TREE_VIEW_GRID_LINES_NONE
1514  * No grid lines.
1515  * GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
1516  * Horizontal grid lines.
1517  * GTK_TREE_VIEW_GRID_LINES_VERTICAL
1518  * Vertical grid lines.
1519  * GTK_TREE_VIEW_GRID_LINES_BOTH
1520  * Horizontal and vertical grid lines.
1521  */
1522 public enum GtkTreeViewGridLines
1523 {
1524 	NONE,
1525 	HORIZONTAL,
1526 	VERTICAL,
1527 	BOTH
1528 }
1529 alias GtkTreeViewGridLines TreeViewGridLines;
1530 
1531 /**
1532  * An enum for determining where a dropped item goes.
1533  * GTK_ICON_VIEW_NO_DROP
1534  * no drop possible
1535  * GTK_ICON_VIEW_DROP_INTO
1536  * dropped item replaces the item
1537  * GTK_ICON_VIEW_DROP_LEFT
1538  * droppped item is inserted to the left
1539  * GTK_ICON_VIEW_DROP_RIGHT
1540  * dropped item is inserted to the right
1541  * GTK_ICON_VIEW_DROP_ABOVE
1542  * dropped item is inserted above
1543  * GTK_ICON_VIEW_DROP_BELOW
1544  * dropped item is inserted below
1545  */
1546 public enum GtkIconViewDropPosition
1547 {
1548 	NO_DROP,
1549 	DROP_INTO,
1550 	DROP_LEFT,
1551 	DROP_RIGHT,
1552 	DROP_ABOVE,
1553 	DROP_BELOW
1554 }
1555 alias GtkIconViewDropPosition IconViewDropPosition;
1556 
1557 /**
1558  * Tells how a cell is to be rendererd.
1559  * GTK_CELL_RENDERER_SELECTED
1560  * The cell is currently selected, and
1561  * probably has a selection colored background to render to.
1562  * GTK_CELL_RENDERER_PRELIT
1563  * The mouse is hovering over the cell.
1564  * GTK_CELL_RENDERER_INSENSITIVE
1565  * The cell is drawn in an insensitive manner
1566  * GTK_CELL_RENDERER_SORTED
1567  * The cell is in a sorted row
1568  * GTK_CELL_RENDERER_FOCUSED
1569  * The cell is in the focus row.
1570  */
1571 public enum GtkCellRendererState
1572 {
1573 	SELECTED = 1 << 0,
1574 	PRELIT = 1 << 1,
1575 	INSENSITIVE = 1 << 2,
1576 	/+* this flag means the cell is inn the sort column/row +/
1577 	SORTED = 1 << 3,
1578 	FOCUSED = 1 << 4
1579 }
1580 alias GtkCellRendererState CellRendererState;
1581 
1582 /**
1583  * Identifies how the user can interact with a particular cell.
1584  * GTK_CELL_RENDERER_MODE_INERT
1585  * The cell is just for display
1586  * and cannot be interacted with. Note that this doesn't mean that eg. the
1587  * row being drawn can't be selected -- just that a particular element of
1588  * it cannot be individually modified.
1589  * GTK_CELL_RENDERER_MODE_ACTIVATABLE
1590  * The cell can be clicked.
1591  * GTK_CELL_RENDERER_MODE_EDITABLE
1592  * The cell can be edited or otherwise modified.
1593  */
1594 public enum GtkCellRendererMode
1595 {
1596 	MODE_INERT,
1597 	MODE_ACTIVATABLE,
1598 	MODE_EDITABLE
1599 }
1600 alias GtkCellRendererMode CellRendererMode;
1601 
1602 public enum GtkCellRendererAccelMode
1603 {
1604 	MODE_GTK,
1605 	MODE_OTHER
1606 }
1607 alias GtkCellRendererAccelMode CellRendererAccelMode;
1608 
1609 /**
1610  * Determines how widgets should be packed insided menubars and
1611  * menuitems contained in menubars.
1612  * GTK_PACK_DIRECTION_LTR
1613  * Widgets are packed left-to-right.
1614  * GTK_PACK_DIRECTION_RTL
1615  * Widgets are packed right-to-left.
1616  * GTK_PACK_DIRECTION_TTB
1617  * Widgets are packed top-to-bottom.
1618  * GTK_PACK_DIRECTION_BTT
1619  * Widgets are packed bottom-to-top.
1620  */
1621 public enum GtkPackDirection
1622 {
1623 	LTR,
1624 	RTL,
1625 	TTB,
1626 	BTT
1627 }
1628 alias GtkPackDirection PackDirection;
1629 
1630 /**
1631  * Warning
1632  * GtkToolbarChildType is deprecated and should not be used in newly-written code.
1633  * GtkToolbarChildType is used to set the type of new elements that are added
1634  * to a GtkToolbar.
1635  * GTK_TOOLBAR_CHILD_SPACE
1636  * a space in the style of the toolbar's GtkToolbarSpaceStyle.
1637  * GTK_TOOLBAR_CHILD_BUTTON
1638  * a GtkButton.
1639  * GTK_TOOLBAR_CHILD_TOGGLEBUTTON
1640  * a GtkToggleButton.
1641  * GTK_TOOLBAR_CHILD_RADIOBUTTON
1642  * a GtkRadioButton.
1643  * GTK_TOOLBAR_CHILD_WIDGET
1644  * a standard GtkWidget.
1645  */
1646 public enum GtkToolbarChildType
1647 {
1648 	SPACE,
1649 	BUTTON,
1650 	TOGGLEBUTTON,
1651 	RADIOBUTTON,
1652 	WIDGET
1653 }
1654 alias GtkToolbarChildType ToolbarChildType;
1655 
1656 public enum GtkToolbarSpaceStyle
1657 {
1658 	EMPTY,
1659 	LINE
1660 }
1661 alias GtkToolbarSpaceStyle ToolbarSpaceStyle;
1662 
1663 /**
1664  * Flags used to specify the supported drag targets.
1665  * GTK_TOOL_PALETTE_DRAG_ITEMS
1666  * Support drag of items.
1667  * GTK_TOOL_PALETTE_DRAG_GROUPS
1668  * Support drag of groups.
1669  */
1670 public enum GtkToolPaletteDragTargets
1671 {
1672 	ITEMS = (1 << 0),
1673 	GROUPS = (1 << 1)
1674 }
1675 alias GtkToolPaletteDragTargets ToolPaletteDragTargets;
1676 
1677 /**
1678  * These enumeration values are used by gtk_ui_manager_add_ui() to determine
1679  * what UI element to create.
1680  * GTK_UI_MANAGER_AUTO
1681  * Pick the type of the UI element according to context.
1682  * GTK_UI_MANAGER_MENUBAR
1683  * Create a menubar.
1684  * GTK_UI_MANAGER_MENU
1685  * Create a menu.
1686  * GTK_UI_MANAGER_TOOLBAR
1687  * Create a toolbar.
1688  * GTK_UI_MANAGER_PLACEHOLDER
1689  * Insert a placeholder.
1690  * GTK_UI_MANAGER_POPUP
1691  * Create a popup menu.
1692  * GTK_UI_MANAGER_MENUITEM
1693  * Create a menuitem.
1694  * GTK_UI_MANAGER_TOOLITEM
1695  * Create a toolitem.
1696  * GTK_UI_MANAGER_SEPARATOR
1697  * Create a separator.
1698  * GTK_UI_MANAGER_ACCELERATOR
1699  * Install an accelerator.
1700  * GTK_UI_MANAGER_POPUP_WITH_ACCELS
1701  * Same as GTK_UI_MANAGER_POPUP, but the actions' accelerators are shown.
1702  */
1703 public enum GtkUIManagerItemType
1704 {
1705 	AUTO = 0,
1706 	MENUBAR = 1 << 0,
1707 	MENU = 1 << 1,
1708 	TOOLBAR = 1 << 2,
1709 	PLACEHOLDER = 1 << 3,
1710 	POPUP = 1 << 4,
1711 	MENUITEM = 1 << 5,
1712 	TOOLITEM = 1 << 6,
1713 	SEPARATOR = 1 << 7,
1714 	ACCELERATOR = 1 << 8,
1715 	POPUP_WITH_ACCELS = 1 << 9
1716 }
1717 alias GtkUIManagerItemType UIManagerItemType;
1718 
1719 /**
1720  * Describes whether a GtkFileChooser is being used to open existing files
1721  * or to save to a possibly new file.
1722  * GTK_FILE_CHOOSER_ACTION_OPEN
1723  * Indicates open mode. The file chooser
1724  *  will only let the user pick an existing file.
1725  * GTK_FILE_CHOOSER_ACTION_SAVE
1726  * Indicates save mode. The file chooser
1727  *  will let the user pick an existing file, or type in a new
1728  *  filename.
1729  * GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
1730  * Indicates an Open mode for
1731  *  selecting folders. The file chooser will let the user pick an
1732  *  existing folder.
1733  * GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
1734  * Indicates a mode for creating a
1735  *  new folder. The file chooser will let the user name an existing or
1736  *  new folder.
1737  */
1738 public enum GtkFileChooserAction
1739 {
1740 	OPEN,
1741 	SAVE,
1742 	SELECT_FOLDER,
1743 	CREATE_FOLDER
1744 }
1745 alias GtkFileChooserAction FileChooserAction;
1746 
1747 /**
1748  * Used as a return value of handlers for the
1749  * "confirm-overwrite" signal of a GtkFileChooser. This
1750  * value determines whether the file chooser will present the stock
1751  * confirmation dialog, accept the user's choice of a filename, or
1752  * let the user choose another filename.
1753  * GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM
1754  * The file chooser will present
1755  *  its stock dialog to confirm about overwriting an existing file.
1756  * GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME
1757  * The file chooser will
1758  *  terminate and accept the user's choice of a file name.
1759  * GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN
1760  * The file chooser will
1761  *  continue running, so as to let the user select another file name.
1762  * Since 2.8
1763  */
1764 public enum GtkFileChooserConfirmation
1765 {
1766 	CONFIRM,
1767 	ACCEPT_FILENAME,
1768 	SELECT_AGAIN
1769 }
1770 alias GtkFileChooserConfirmation FileChooserConfirmation;
1771 
1772 /**
1773  * These identify the various errors that can occur while calling
1774  * GtkFileChooser functions.
1775  * GTK_FILE_CHOOSER_ERROR_NONEXISTENT
1776  * Indicates that a file does not exist.
1777  * GTK_FILE_CHOOSER_ERROR_BAD_FILENAME
1778  * Indicates a malformed filename.
1779  * GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS
1780  * Indicates a duplicate path (e.g. when
1781  *  adding a bookmark).
1782  * GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME
1783  */
1784 public enum GtkFileChooserError
1785 {
1786 	NONEXISTENT,
1787 	BAD_FILENAME,
1788 	ALREADY_EXISTS,
1789 	INCOMPLETE_HOSTNAME
1790 }
1791 alias GtkFileChooserError FileChooserError;
1792 
1793 /**
1794  * These flags indicate what parts of a GtkFileFilterInfo struct
1795  * are filled or need to be filled.
1796  * GTK_FILE_FILTER_FILENAME
1797  * the filename of the file being tested
1798  * GTK_FILE_FILTER_URI
1799  * the URI for the file being tested
1800  * GTK_FILE_FILTER_DISPLAY_NAME
1801  * the string that will be used to
1802  *  display the file in the file chooser
1803  * GTK_FILE_FILTER_MIME_TYPE
1804  * the mime type of the file
1805  */
1806 public enum GtkFileFilterFlags
1807 {
1808 	FILENAME = 1 << 0,
1809 	URI = 1 << 1,
1810 	DISPLAY_NAME = 1 << 2,
1811 	MIME_TYPE = 1 << 3
1812 }
1813 alias GtkFileFilterFlags FileFilterFlags;
1814 
1815 /**
1816  * The status gives a rough indication of the completion
1817  * of a running print operation.
1818  * GTK_PRINT_STATUS_INITIAL
1819  * The printing has not started yet; this
1820  *  status is set initially, and while the print dialog is shown.
1821  * GTK_PRINT_STATUS_PREPARING
1822  * This status is set while the begin-print
1823  *  signal is emitted and during pagination.
1824  * GTK_PRINT_STATUS_GENERATING_DATA
1825  * This status is set while the
1826  *  pages are being rendered.
1827  * GTK_PRINT_STATUS_SENDING_DATA
1828  * The print job is being sent off to the
1829  *  printer.
1830  * GTK_PRINT_STATUS_PENDING
1831  * The print job has been sent to the printer,
1832  *  but is not printed for some reason, e.g. the printer may be stopped.
1833  * GTK_PRINT_STATUS_PENDING_ISSUE
1834  * Some problem has occurred during
1835  *  printing, e.g. a paper jam.
1836  * GTK_PRINT_STATUS_PRINTING
1837  * The printer is processing the print job.
1838  * GTK_PRINT_STATUS_FINISHED
1839  * The printing has been completed successfully.
1840  * GTK_PRINT_STATUS_FINISHED_ABORTED
1841  * The printing has been aborted.
1842  */
1843 public enum GtkPrintStatus
1844 {
1845 	INITIAL,
1846 	PREPARING,
1847 	GENERATING_DATA,
1848 	SENDING_DATA,
1849 	PENDING,
1850 	PENDING_ISSUE,
1851 	PRINTING,
1852 	FINISHED,
1853 	FINISHED_ABORTED
1854 }
1855 alias GtkPrintStatus PrintStatus;
1856 
1857 /**
1858  * The action parameter to gtk_print_operation_run()
1859  * determines what action the print operation should perform.
1860  * GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
1861  * Show the print dialog.
1862  * GTK_PRINT_OPERATION_ACTION_PRINT
1863  * Start to print without showing
1864  *  the print dialog, based on the current print settings.
1865  * GTK_PRINT_OPERATION_ACTION_PREVIEW
1866  * Show the print preview.
1867  * GTK_PRINT_OPERATION_ACTION_EXPORT
1868  * Export to a file. This requires
1869  *  the export-filename property to be set.
1870  */
1871 public enum GtkPrintOperationAction
1872 {
1873 	PRINT_DIALOG,
1874 	PRINT,
1875 	PREVIEW,
1876 	EXPORT
1877 }
1878 alias GtkPrintOperationAction PrintOperationAction;
1879 
1880 /**
1881  * A value of this type is returned by gtk_print_operation_run().
1882  * GTK_PRINT_OPERATION_RESULT_ERROR
1883  * An error has occured.
1884  * GTK_PRINT_OPERATION_RESULT_APPLY
1885  * The print settings should be stored.
1886  * GTK_PRINT_OPERATION_RESULT_CANCEL
1887  * The print operation has been canceled,
1888  *  the print settings should not be stored.
1889  * GTK_PRINT_OPERATION_RESULT_IN_PROGRESS
1890  * The print operation is not complete
1891  *  yet. This value will only be returned when running asynchronously.
1892  */
1893 public enum GtkPrintOperationResult
1894 {
1895 	ERROR,
1896 	APPLY,
1897 	CANCEL,
1898 	IN_PROGRESS
1899 }
1900 alias GtkPrintOperationResult PrintOperationResult;
1901 
1902 /**
1903  * Error codes that identify various errors that can occur while
1904  * using the GTK+ printing support.
1905  * GTK_PRINT_ERROR_GENERAL
1906  * An unspecified error occurred.
1907  * GTK_PRINT_ERROR_INTERNAL_ERROR
1908  * An internal error occurred.
1909  * GTK_PRINT_ERROR_NOMEM
1910  * A memory allocation failed.
1911  * GTK_PRINT_ERROR_INVALID_FILE
1912  * An error occurred while loading a page setup
1913  *  or paper size from a key file.
1914  */
1915 public enum GtkPrintError
1916 {
1917 	GENERAL,
1918 	INTERNAL_ERROR,
1919 	NOMEM,
1920 	INVALID_FILE
1921 }
1922 alias GtkPrintError PrintError;
1923 
1924 public enum GtkPageOrientation
1925 {
1926 	PORTRAIT,
1927 	LANDSCAPE,
1928 	REVERSE_PORTRAIT,
1929 	REVERSE_LANDSCAPE
1930 }
1931 alias GtkPageOrientation PageOrientation;
1932 
1933 public enum GtkPrintDuplex
1934 {
1935 	SIMPLEX,
1936 	HORIZONTAL,
1937 	VERTICAL
1938 }
1939 alias GtkPrintDuplex PrintDuplex;
1940 
1941 public enum GtkPrintQuality
1942 {
1943 	LOW,
1944 	NORMAL,
1945 	HIGH,
1946 	DRAFT
1947 }
1948 alias GtkPrintQuality PrintQuality;
1949 
1950 /**
1951  * Used to determine the layout of pages on a sheet when printing
1952  * multiple pages per sheet.
1953  * GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM
1954  * GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP
1955  * GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM
1956  * GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP
1957  * GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT
1958  * GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT
1959  * GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT
1960  * GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT
1961  */
1962 public enum GtkNumberUpLayout
1963 {
1964 	LEFT_TO_RIGHT_TOP_TO_BOTTOM, /+*< nick= lrtb >+/
1965 	LEFT_TO_RIGHT_BOTTOM_TO_TOP, /+*< nick= lrbt >+/
1966 	RIGHT_TO_LEFT_TOP_TO_BOTTOM, /+*< nick= rltb >+/
1967 	RIGHT_TO_LEFT_BOTTOM_TO_TOP, /+*< nick= rlbt >+/
1968 	TOP_TO_BOTTOM_LEFT_TO_RIGHT, /+*< nick= tblr >+/
1969 	TOP_TO_BOTTOM_RIGHT_TO_LEFT, /+*< nick= tbrl >+/
1970 	BOTTOM_TO_TOP_LEFT_TO_RIGHT, /+*< nick= btlr >+/
1971 	BOTTOM_TO_TOP_RIGHT_TO_LEFT /+*< nick= btrl >+/
1972 }
1973 alias GtkNumberUpLayout NumberUpLayout;
1974 
1975 public enum GtkPrintPages
1976 {
1977 	ALL,
1978 	CURRENT,
1979 	RANGES,
1980 	SELECTION
1981 }
1982 alias GtkPrintPages PrintPages;
1983 
1984 public enum GtkPageSet
1985 {
1986 	ALL,
1987 	EVEN,
1988 	ODD
1989 }
1990 alias GtkPageSet PageSet;
1991 
1992 public enum GtkUnit
1993 {
1994 	PIXEL,
1995 	POINTS,
1996 	INCH,
1997 	MM
1998 }
1999 alias GtkUnit Unit;
2000 
2001 /**
2002  * An enum for specifying which features the print dialog should offer.
2003  * If neither GTK_PRINT_CAPABILITY_GENERATE_PDF nor
2004  * GTK_PRINT_CAPABILITY_GENERATE_PS is specified, GTK+ assumes that all
2005  * formats are supported.
2006  * GTK_PRINT_CAPABILITY_PAGE_SET
2007  * Print dialog will offer printing even/odd pages.
2008  * GTK_PRINT_CAPABILITY_COPIES
2009  * Print dialog will allow to print multiple copies.
2010  * GTK_PRINT_CAPABILITY_COLLATE
2011  * Print dialog will allow to collate multiple copies.
2012  * GTK_PRINT_CAPABILITY_REVERSE
2013  * Print dialog will allow to print pages in reverse order.
2014  * GTK_PRINT_CAPABILITY_SCALE
2015  * Print dialog will allow to scale the output.
2016  * GTK_PRINT_CAPABILITY_GENERATE_PDF
2017  * The program will send the document to
2018  *  the printer in PDF format
2019  * GTK_PRINT_CAPABILITY_GENERATE_PS
2020  * The program will send the document to
2021  *  the printer in Postscript format
2022  * GTK_PRINT_CAPABILITY_PREVIEW
2023  * Print dialog will offer a preview
2024  * GTK_PRINT_CAPABILITY_NUMBER_UP
2025  * Print dialog will offer printing multiple
2026  *  pages per sheet. Since 2.12
2027  * GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT
2028  * Print dialog will allow to rearrange
2029  *  pages when printing multiple pages per sheet. Since 2.14
2030  */
2031 public enum GtkPrintCapabilities
2032 {
2033 	CAPABILITY_PAGE_SET = 1 << 0,
2034 	CAPABILITY_COPIES = 1 << 1,
2035 	CAPABILITY_COLLATE = 1 << 2,
2036 	CAPABILITY_REVERSE = 1 << 3,
2037 	CAPABILITY_SCALE = 1 << 4,
2038 	CAPABILITY_GENERATE_PDF = 1 << 5,
2039 	CAPABILITY_GENERATE_PS = 1 << 6,
2040 	CAPABILITY_PREVIEW = 1 << 7,
2041 	CAPABILITY_NUMBER_UP = 1 << 8,
2042 	CAPABILITY_NUMBER_UP_LAYOUT = 1 << 9
2043 }
2044 alias GtkPrintCapabilities PrintCapabilities;
2045 
2046 /**
2047  * These options can be used to influence the display and behaviour of a GtkCalendar.
2048  * GTK_CALENDAR_SHOW_HEADING
2049  * Specifies that the month and year should be displayed.
2050  * GTK_CALENDAR_SHOW_DAY_NAMES
2051  * Specifies that three letter day descriptions should be present.
2052  * GTK_CALENDAR_NO_MONTH_CHANGE
2053  * Prevents the user from switching months with the calendar.
2054  * GTK_CALENDAR_SHOW_WEEK_NUMBERS
2055  * Displays each week numbers of the current year, down the
2056  * left side of the calendar.
2057  * GTK_CALENDAR_WEEK_START_MONDAY
2058  * Since GTK+ 2.4, this option is deprecated and ignored by GTK+.
2059  * The information on which day the calendar week starts is derived from the locale.
2060  * GTK_CALENDAR_SHOW_DETAILS
2061  * Just show an indicator, not the full details
2062  * text when details are provided. See gtk_calendar_set_detail_func().
2063  */
2064 public enum GtkCalendarDisplayOptions
2065 {
2066 	SHOW_HEADING = 1 << 0,
2067 	SHOW_DAY_NAMES = 1 << 1,
2068 	NO_MONTH_CHANGE = 1 << 2,
2069 	SHOW_WEEK_NUMBERS = 1 << 3,
2070 	WEEK_START_MONDAY = 1 << 4,
2071 	SHOW_DETAILS = 1 << 5
2072 }
2073 alias GtkCalendarDisplayOptions CalendarDisplayOptions;
2074 
2075 /**
2076  * The mode of the size group determines the directions in which the size
2077  * group affects the requested sizes of its component widgets.
2078  * GTK_SIZE_GROUP_NONE
2079  * group has no effect
2080  * GTK_SIZE_GROUP_HORIZONTAL
2081  * group affects horizontal requisition
2082  * GTK_SIZE_GROUP_VERTICAL
2083  * group affects vertical requisition
2084  * GTK_SIZE_GROUP_BOTH
2085  * group affects both horizontal and vertical requisition
2086  */
2087 public enum GtkSizeGroupMode
2088 {
2089 	NONE,
2090 	HORIZONTAL,
2091 	VERTICAL,
2092 	BOTH
2093 }
2094 alias GtkSizeGroupMode SizeGroupMode;
2095 
2096 /**
2097  * An enumeration representing directional movements within a menu.
2098  * GTK_MENU_DIR_PARENT
2099  * To the parent menu shell.
2100  * GTK_MENU_DIR_CHILD
2101  * To the submenu, if any, associated with the item.
2102  * GTK_MENU_DIR_NEXT
2103  * To the next menu item.
2104  * GTK_MENU_DIR_PREV
2105  * To the previous menu item.
2106  * Property Details
2107  * The "take-focus" property
2108  *  "take-focus" gboolean : Read / Write
2109  * A boolean that determines whether the menu and its submenus grab the
2110  * keyboard focus. See gtk_menu_shell_set_take_focus() and
2111  * gtk_menu_shell_get_take_focus().
2112  * Default value: TRUE
2113  * Since 2.8
2114  * Signal Details
2115  * The "activate-current" signal
2116  * void user_function (GtkMenuShell *menushell,
2117  *  gboolean arg1,
2118  *  gpointer user_data) : Action
2119  * An action signal that activates the current menu item within the menu
2120  * shell.
2121  * menushell :
2122  * the object which received the signal.
2123  * force_hide :
2124  * if TRUE, hide the menu after activating the menu item.
2125  * user_data :
2126  * user data set when the signal handler was connected.
2127  */
2128 public enum GtkMenuDirectionType
2129 {
2130 	PARENT,
2131 	CHILD,
2132 	NEXT,
2133 	PREV
2134 }
2135 alias GtkMenuDirectionType MenuDirectionType;
2136 
2137 /**
2138  * Warning
2139  * GtkObjectFlags has been deprecated since version 2.22 and should not be used in newly-written code. Do not re-use GtkObject flags but use your own variable to
2140  *  store flags.
2141  * Tells about the state of the object.
2142  * GTK_IN_DESTRUCTION
2143  * the object is currently being destroyed. This is used
2144  *  internally by GTK+ to prevent reinvokations during destruction.
2145  * GTK_FLOATING
2146  * GTK_RESERVED_1
2147  * GTK_RESERVED_2
2148  * reserved for future use
2149  */
2150 public enum GtkObjectFlags
2151 {
2152 	IN_DESTRUCTION = 1 << 0, /+* Used internally during dispose +/
2153 	FLOATING = 1 << 1,
2154 	RESERVED_1 = 1 << 2,
2155 	RESERVED_2 = 1 << 3
2156 }
2157 alias GtkObjectFlags ObjectFlags;
2158 
2159 /**
2160  * Warning
2161  * GtkArgFlags is deprecated and should not be used in newly-written code. Use corresponding GParamSpec features instead
2162  * Possible flags indicating how an argument should be treated.
2163  * GTK_ARG_READABLE
2164  * the argument is readable. (i.e. can be queried)
2165  * GTK_ARG_WRITABLE
2166  * the argument is writable. (i.e. settable)
2167  * GTK_ARG_CONSTRUCT
2168  * the argument needs construction.
2169  * GTK_ARG_CONSTRUCT_ONLY
2170  * the argument needs construction (and will
2171  * be set once during object creation), but is otherwise cannot be
2172  * set. Hence this flag is not allowed with GTK_ARG_WRITABLE,
2173  * and is redundant with GTK_ARG_CONSTRUCT.
2174  * GTK_ARG_CHILD_ARG
2175  * an argument type that applies to (and may be different for)
2176  * each child. Used by GtkContainer.
2177  */
2178 public enum GtkArgFlags
2179 {
2180 	READABLE = cast(int)ParamFlags.READABLE,
2181 	WRITABLE = cast(int)ParamFlags.WRITABLE,
2182 	CONSTRUCT = cast(int)ParamFlags.CONSTRUCT,
2183 	CONSTRUCT_ONLY = cast(int)ParamFlags.CONSTRUCT_ONLY,
2184 	CHILD_ARG = 1 << 4
2185 }
2186 alias GtkArgFlags ArgFlags;
2187 
2188 /**
2189  * Determines how GTK+ handles the sensitivity of stepper arrows
2190  * at the end of range widgets.
2191  * GTK_SENSITIVITY_AUTO
2192  * The arrow is made insensitive if the
2193  *  thumb is at the end
2194  * GTK_SENSITIVITY_ON
2195  * The arrow is always sensitive
2196  * GTK_SENSITIVITY_OFF
2197  * The arrow is always insensitive
2198  */
2199 public enum GtkSensitivityType
2200 {
2201 	AUTO,
2202 	ON,
2203 	OFF
2204 }
2205 alias GtkSensitivityType SensitivityType;
2206 
2207 /**
2208  * Tells about certain properties of the widget.
2209  * GTK_TOPLEVEL
2210  * widgets without a real parent, as there are GtkWindows and
2211  *  GtkMenus have this flag set throughout their lifetime.
2212  *  Toplevel widgets always contain their own GdkWindow.
2213  * GTK_NO_WINDOW
2214  * Indicative for a widget that does not provide its own GdkWindow.
2215  *  Visible action (e.g. drawing) is performed on the parent's GdkWindow.
2216  * GTK_REALIZED
2217  * Set by gtk_widget_realize(), unset by gtk_widget_unrealize().
2218  *  A realized widget has an associated GdkWindow.
2219  * GTK_MAPPED
2220  * Set by gtk_widget_map(), unset by gtk_widget_unmap().
2221  *  Only realized widgets can be mapped. It means that gdk_window_show()
2222  *  has been called on the widgets window(s).
2223  * GTK_VISIBLE
2224  * Set by gtk_widget_show(), unset by gtk_widget_hide(). Implies that a
2225  *  widget will be mapped as soon as its parent is mapped.
2226  * GTK_SENSITIVE
2227  * Set and unset by gtk_widget_set_sensitive().
2228  *  The sensitivity of a widget determines whether it will receive
2229  *  certain events (e.g. button or key presses). One premise for
2230  *  the widget's sensitivity is to have this flag set.
2231  * GTK_PARENT_SENSITIVE
2232  * Set and unset by gtk_widget_set_sensitive() operations on the
2233  *  parents of the widget.
2234  *  This is the second premise for the widget's sensitivity. Once
2235  *  it has GTK_SENSITIVE and GTK_PARENT_SENSITIVE set, its state is
2236  *  effectively sensitive. This is expressed (and can be examined) by
2237  *  the GTK_WIDGET_IS_SENSITIVE macro.
2238  * GTK_CAN_FOCUS
2239  * Determines whether a widget is able to handle focus grabs.
2240  * GTK_HAS_FOCUS
2241  * Set by gtk_widget_grab_focus() for widgets that also
2242  *  have GTK_CAN_FOCUS set. The flag will be unset once another widget
2243  *  grabs the focus.
2244  * GTK_CAN_DEFAULT
2245  * The widget is allowed to receive the default action via
2246  *  gtk_widget_grab_default() and will reserve space to draw the default if possible
2247  * GTK_HAS_DEFAULT
2248  * The widget currently is receiving the default action and
2249  *  should be drawn appropriately if possible
2250  * GTK_HAS_GRAB
2251  * Set by gtk_grab_add(), unset by gtk_grab_remove(). It means that the
2252  *  widget is in the grab_widgets stack, and will be the preferred one for
2253  *  receiving events other than ones of cosmetic value.
2254  * GTK_RC_STYLE
2255  * Indicates that the widget's style has been looked up through the rc
2256  *  mechanism. It does not imply that the widget actually had a style
2257  *  defined through the rc mechanism.
2258  * GTK_COMPOSITE_CHILD
2259  * Indicates that the widget is a composite child of its parent; see
2260  *  gtk_widget_push_composite_child(), gtk_widget_pop_composite_child().
2261  * GTK_NO_REPARENT
2262  * Unused since before GTK+ 1.2, will be removed in a future version.
2263  * GTK_APP_PAINTABLE
2264  * Set and unset by gtk_widget_set_app_paintable().
2265  *  Must be set on widgets whose window the application directly draws on,
2266  *  in order to keep GTK+ from overwriting the drawn stuff. See
2267  *  the section called “App-paintable widgets” for a detailed
2268  *  description of this flag.
2269  * GTK_RECEIVES_DEFAULT
2270  * The widget when focused will receive the default action and have
2271  *  GTK_HAS_DEFAULT set even if there is a different widget set as default.
2272  * GTK_DOUBLE_BUFFERED
2273  * Set and unset by gtk_widget_set_double_buffered().
2274  *  Indicates that exposes done on the widget should be
2275  *  double-buffered. See the section called “Double buffering” for a
2276  *  detailed discussion of how double-buffering works in GTK+ and
2277  *  why you may want to disable it for special cases.
2278  * GTK_NO_SHOW_ALL
2279  */
2280 public enum GtkWidgetFlags
2281 {
2282 	TOPLEVEL = 1 << 4,
2283 	NO_WINDOW = 1 << 5,
2284 	REALIZED = 1 << 6,
2285 	MAPPED = 1 << 7,
2286 	VISIBLE = 1 << 8,
2287 	SENSITIVE = 1 << 9,
2288 	PARENT_SENSITIVE = 1 << 10,
2289 	CAN_FOCUS = 1 << 11,
2290 	HAS_FOCUS = 1 << 12,
2291 	CAN_DEFAULT = 1 << 13,
2292 	HAS_DEFAULT = 1 << 14,
2293 	HAS_GRAB = 1 << 15,
2294 	RC_STYLE = 1 << 16,
2295 	COMPOSITE_CHILD = 1 << 17,
2296 	NO_REPARENT = 1 << 18,
2297 	APP_PAINTABLE = 1 << 19,
2298 	RECEIVES_DEFAULT = 1 << 20,
2299 	DOUBLE_BUFFERED = 1 << 21,
2300 	NO_SHOW_ALL = 1 << 22
2301 }
2302 alias GtkWidgetFlags WidgetFlags;
2303 
2304 public enum GtkWidgetHelpType
2305 {
2306 	TOOLTIP,
2307 	WHATS_THIS
2308 }
2309 alias GtkWidgetHelpType WidgetHelpType;
2310 
2311 public enum GtkTextDirection
2312 {
2313 	NONE,
2314 	LTR,
2315 	RTL
2316 }
2317 alias GtkTextDirection TextDirection;
2318 
2319 /**
2320  * Error codes for GtkRecentManager operations
2321  * GTK_RECENT_MANAGER_ERROR_NOT_FOUND
2322  * the URI specified does not exists in
2323  *  the recently used resources list.
2324  * GTK_RECENT_MANAGER_ERROR_INVALID_URI
2325  * the URI specified is not valid.
2326  * GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING
2327  * the supplied string is not
2328  *  UTF-8 encoded.
2329  * GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED
2330  * no application has registered
2331  *  the specified item.
2332  * GTK_RECENT_MANAGER_ERROR_READ
2333  * failure while reading the recently used
2334  *  resources file.
2335  * GTK_RECENT_MANAGER_ERROR_WRITE
2336  * failure while writing the recently used
2337  *  resources file.
2338  * GTK_RECENT_MANAGER_ERROR_UNKNOWN
2339  * unspecified error.
2340  */
2341 public enum GtkRecentManagerError
2342 {
2343 	NOT_FOUND,
2344 	INVALID_URI,
2345 	INVALID_ENCODING,
2346 	NOT_REGISTERED,
2347 	READ,
2348 	WRITE,
2349 	UNKNOWN
2350 }
2351 alias GtkRecentManagerError RecentManagerError;
2352 
2353 /**
2354  * These identify the various errors that can occur while calling
2355  * GtkRecentChooser functions.
2356  * GTK_RECENT_CHOOSER_ERROR_NOT_FOUND
2357  * Indicates that a file does not exist
2358  * GTK_RECENT_CHOOSER_ERROR_INVALID_URI
2359  * Indicates a malformed URI
2360  */
2361 public enum GtkRecentChooserError
2362 {
2363 	NOT_FOUND,
2364 	INVALID_URI
2365 }
2366 alias GtkRecentChooserError RecentChooserError;
2367 
2368 /**
2369  * Used to specify the sorting method to be applyed to the recently
2370  * used resource list.
2371  * GTK_RECENT_SORT_NONE
2372  * Do not sort the returned list of recently used
2373  *  resources.
2374  * GTK_RECENT_SORT_MRU
2375  * Sort the returned list with the most recently used
2376  *  items first.
2377  * GTK_RECENT_SORT_LRU
2378  * Sort the returned list with the least recently used
2379  *  items first.
2380  * GTK_RECENT_SORT_CUSTOM
2381  * Sort the returned list using a custom sorting
2382  *  function passed using gtk_recent_manager_set_sort_func().
2383  */
2384 public enum GtkRecentSortType
2385 {
2386 	NONE = 0,
2387 	MRU,
2388 	LRU,
2389 	CUSTOM
2390 }
2391 alias GtkRecentSortType RecentSortType;
2392 
2393 /**
2394  * These flags indicate what parts of a GtkRecentFilterInfo struct
2395  * are filled or need to be filled.
2396  * GTK_RECENT_FILTER_URI
2397  * the URI of the file being tested
2398  * GTK_RECENT_FILTER_DISPLAY_NAME
2399  * the string that will be used to
2400  *  display the file in the recent chooser
2401  * GTK_RECENT_FILTER_MIME_TYPE
2402  * the mime type of the file
2403  * GTK_RECENT_FILTER_APPLICATION
2404  * the list of applications that have
2405  *  registered the file
2406  * GTK_RECENT_FILTER_GROUP
2407  * the groups to which the file belongs to
2408  * GTK_RECENT_FILTER_AGE
2409  * the number of days elapsed since the file
2410  *  has been registered
2411  */
2412 public enum GtkRecentFilterFlags
2413 {
2414 	URI = 1 << 0,
2415 	DISPLAY_NAME = 1 << 1,
2416 	MIME_TYPE = 1 << 2,
2417 	APPLICATION = 1 << 3,
2418 	GROUP = 1 << 4,
2419 	AGE = 1 << 5
2420 }
2421 alias GtkRecentFilterFlags RecentFilterFlags;
2422 
2423 /**
2424  * Error codes that identify various errors that can occur while
2425  * using GtkBuilder.
2426  * GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION
2427  * A type-func attribute didn't name
2428  *  a function that returns a GType.
2429  * GTK_BUILDER_ERROR_UNHANDLED_TAG
2430  * The input contained a tag that GtkBuilder
2431  *  can't handle.
2432  * GTK_BUILDER_ERROR_MISSING_ATTRIBUTE
2433  * An attribute that is required by
2434  *  GtkBuilder was missing.
2435  * GTK_BUILDER_ERROR_INVALID_ATTRIBUTE
2436  * GtkBuilder found an attribute that
2437  *  it doesn't understand.
2438  * GTK_BUILDER_ERROR_INVALID_TAG
2439  * GtkBuilder found a tag that
2440  *  it doesn't understand.
2441  * GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE
2442  * A required property value was
2443  *  missing.
2444  * GTK_BUILDER_ERROR_INVALID_VALUE
2445  * GtkBuilder couldn't parse
2446  *  some attribute value.
2447  * GTK_BUILDER_ERROR_VERSION_MISMATCH
2448  * The input file requires a newer version
2449  *  of GTK+.
2450  * GTK_BUILDER_ERROR_DUPLICATE_ID
2451  * An object id occurred twice.
2452  */
2453 public enum GtkBuilderError
2454 {
2455 	INVALID_TYPE_FUNCTION,
2456 	UNHANDLED_TAG,
2457 	MISSING_ATTRIBUTE,
2458 	INVALID_ATTRIBUTE,
2459 	INVALID_TAG,
2460 	MISSING_PROPERTY_VALUE,
2461 	INVALID_VALUE,
2462 	VERSION_MISMATCH,
2463 	DUPLICATE_ID
2464 }
2465 alias GtkBuilderError BuilderError;
2466 
2467 
2468 struct GtkObjectClass
2469 {
2470 	GObjectClass parentClass;
2471 	void function(GtkObject*, GtkArg*, uint) setArg;
2472 	void function(GtkObject*, GtkArg *, uint) getArg;
2473 	void function(GtkObject*) destroy;
2474 }
2475 
2476 public struct GtkWidgetClass
2477 {
2478 	/* The object class structure needs to be the first
2479 	 * element inn the widget class structure inn order for
2480 	 * the class mechanism to work correctly. This allows a
2481 	 * GtkWidgetClass pointer to be cast to a GtkObjectClass
2482 	 * pointer.
2483 	 */
2484 	GtkObjectClass parentClass;
2485 	/**/
2486 	uint activateSignal;
2487 	uint setScrollAdjustmentsSignal;
2488 	/**/
2489 	/* seldomly overidden */
2490 	extern(C) void  function(GtkWidget *widget,uint nPspecs,GParamSpec **pspecs) dispatchChildPropertiesChanged;
2491 	/* basics */
2492 	extern(C) void  function(GtkWidget *widget)  show;
2493 	extern(C) void  function(GtkWidget *widget)  showAll;
2494 	extern(C) void  function(GtkWidget *widget)  hide;
2495 	extern(C) void  function(GtkWidget *widget)  hideAll;
2496 	extern(C) void  function(GtkWidget *widget)  map;
2497 	extern(C) void  function(GtkWidget *widget)  unmap;
2498 	extern(C) void  function(GtkWidget *widget)  realize;
2499 	extern(C) void  function(GtkWidget *widget)  unrealize;
2500 	extern(C) void  function(GtkWidget *widget,GtkRequisition *requisition)  sizeRequest;
2501 	extern(C) void  function(GtkWidget *widget,GtkAllocation *allocation)  sizeAllocate;
2502 	extern(C) void  function(GtkWidget *widget,GtkStateType previousState)  stateChanged;
2503 	extern(C) void  function(GtkWidget *widget,GtkWidget *previousParent)  parentSet;
2504 	extern(C) void  function(GtkWidget *widget,GtkWidget *previousToplevel)  hierarchyChanged;
2505 	extern(C) void  function(GtkWidget *widget,GtkStyle *previousStyle)  styleSet;
2506 	extern(C) void  function(GtkWidget *widget,GtkTextDirection previousDirection)  directionChanged;
2507 	extern(C) void  function(GtkWidget *widget,int wasGrabbed)  grabNotify;
2508 	extern(C) void  function(GtkWidget *widget,GParamSpec *pspec)  childNotify;
2509 	/* Mnemonics */
2510 	extern(C) int  function(GtkWidget *widget,int groupCycling)  mnemonicActivate;
2511 	/* explicit focus */
2512 	extern(C) void  function(GtkWidget *widget)  grabFocus;
2513 	extern(C) int  function(GtkWidget *widget,GtkDirectionType direction)  focus;
2514 	/* events */
2515 	extern(C) int  function(GtkWidget *widget,GdkEvent *event)  event;
2516 	extern(C) int  function(GtkWidget *widget,GdkEventButton *event)  buttonPressEvent;
2517 	extern(C) int  function(GtkWidget *widget,GdkEventButton *event)  buttonReleaseEvent;
2518 	extern(C) int  function(GtkWidget *widget,GdkEventScroll *event)  scrollEvent;
2519 	extern(C) int  function(GtkWidget *widget,GdkEventMotion *event)  motionNotifyEvent;
2520 	extern(C) int  function(GtkWidget *widget,GdkEventAny *event)  deleteEvent;
2521 	extern(C) int  function(GtkWidget *widget,GdkEventAny *event)  destroyEvent;
2522 	extern(C) int  function(GtkWidget *widget,GdkEventExpose *event)  exposeEvent;
2523 	extern(C) int  function(GtkWidget *widget,GdkEventKey *event)  keyPressEvent;
2524 	extern(C) int  function(GtkWidget *widget,GdkEventKey *event)  keyReleaseEvent;
2525 	extern(C) int  function(GtkWidget *widget,GdkEventCrossing *event)  enterNotifyEvent;
2526 	extern(C) int  function(GtkWidget *widget,GdkEventCrossing *event)  leaveNotifyEvent;
2527 	extern(C) int  function(GtkWidget *widget,GdkEventConfigure *event)  configureEvent;
2528 	extern(C) int  function(GtkWidget *widget,GdkEventFocus *event)  focusInEvent;
2529 	extern(C) int  function(GtkWidget *widget,GdkEventFocus *event)  focusOutEvent;
2530 	extern(C) int  function(GtkWidget *widget,GdkEventAny *event)  mapEvent;
2531 	extern(C) int  function(GtkWidget *widget,GdkEventAny *event)  unmapEvent;
2532 	extern(C) int  function(GtkWidget *widget,GdkEventProperty *event)  propertyNotifyEvent;
2533 	extern(C) int  function(GtkWidget *widget,GdkEventSelection *event)  selectionClearEvent;
2534 	extern(C) int  function(GtkWidget *widget,GdkEventSelection *event)  selectionRequestEvent;
2535 	extern(C) int  function(GtkWidget *widget,GdkEventSelection *event)  selectionNotifyEvent;
2536 	extern(C) int  function(GtkWidget *widget,GdkEventProximity *event)  proximityInEvent;
2537 	extern(C) int  function(GtkWidget *widget,GdkEventProximity *event)  proximityOutEvent;
2538 	extern(C) int  function(GtkWidget *widget,GdkEventVisibility *event)  visibilityNotifyEvent;
2539 	extern(C) int  function(GtkWidget *widget,GdkEventClient *event)  clientEvent;
2540 	extern(C) int  function(GtkWidget *widget,GdkEventAny *event)  noExposeEvent;
2541 	extern(C) int  function(GtkWidget *widget,GdkEventWindowState *event)  windowStateEvent;
2542 	/* selection */
2543 	extern(C) void  function(GtkWidget *widget,GtkSelectionData *selectionData,uint info,uint time)  selectionGet;
2544 	extern(C) void  function(GtkWidget *widget,GtkSelectionData *selectionData,uint time)  selectionReceived;
2545 	/* Source side drag signals */
2546 	extern(C) void  function(GtkWidget *widget,GdkDragContext *context)  dragBegin;
2547 	extern(C) void  function(GtkWidget *widget,GdkDragContext *context)  dragEnd;
2548 	extern(C) void  function(GtkWidget *widget,GdkDragContext *context,GtkSelectionData *selectionData,uint info,uint time)  dragDataGet;
2549 	extern(C) void  function(GtkWidget *widget,GdkDragContext *context)  dragDataDelete;
2550 	/* Target side drag signals */
2551 	extern(C) void  function(GtkWidget *widget,GdkDragContext *context,uint time)  dragLeave;
2552 	extern(C) int  function(GtkWidget *widget,GdkDragContext *context,int x,int y,uint time)  dragMotion;
2553 	extern(C) int  function(GtkWidget *widget,GdkDragContext *context,int x,int y,uint time)  dragDrop;
2554 	extern(C) void  function(GtkWidget *widget,GdkDragContext *context,int x,int y,GtkSelectionData *selectionData,uint info,uint time)  dragDataReceived;
2555 	/* Signals used only for keybindings */
2556 	extern(C) int  function(GtkWidget *widget)  popupMenu;
2557 	/* If a widget has multiple tooltips/whatsthis, it should show the
2558 	 * one for the current focus location, or if that doesn't make
2559 	 * sense, should cycle through them showing each tip alongside
2560 	 * whatever piece of the widget it applies to.
2561 	 */
2562 	extern(C) int  function(GtkWidget *widget,GtkWidgetHelpType helpType)  showHelp;
2563 	/* accessibility support
2564 	 */
2565 	extern(C) AtkObject*  function(GtkWidget *widget) getAccessible;
2566 	extern(C) void  function(GtkWidget *widget,GdkScreen *previousScreen) screenChanged;
2567 	extern(C) int  function(GtkWidget *widget,uint signalId) canActivateAccel;
2568 	/* Sent when a grab is broken. */
2569 	extern(C) int  function(GtkWidget *widget,GdkEventGrabBroken *event) grabBrokenEvent;
2570 	extern(C) void  function(GtkWidget *widget)  compositedChanged;
2571 	extern(C) int  function(GtkWidget *widget,int x,int y,int keyboardTooltip,GtkTooltip *tooltip)  queryTooltip;
2572 	/* Padding for future expansion */
2573 	extern(C) void  function() _GtkReserved5;
2574 	extern(C) void  function() _GtkReserved6;
2575 	extern(C) void  function() _GtkReserved7;
2576 }
2577 
2578 struct GtkTextIter
2579 {
2580 	/* GtkTextIter is an opaque datatype; ignore all these fields.
2581 	 * Initialize the iter with gtk_text_buffer_get_iter_*
2582 	 * functions
2583 	 */
2584 	/*< private >*/
2585 	gpointer dummy1;
2586 	gpointer dummy2;
2587 	gint dummy3;
2588 	gint dummy4;
2589 	gint dummy5;
2590 	gint dummy6;
2591 	gint dummy7;
2592 	gint dummy8;
2593 	gpointer dummy9;
2594 	gpointer dummy10;
2595 	gint dummy11;
2596 	gint dummy12;
2597 	/* padding */
2598 	gint dummy13;
2599 	gpointer dummy14;
2600 }
2601 
2602 
2603 /**
2604  * Main Gtk struct.
2605  * An object representing and maintaining a group of accelerators.
2606  */
2607 public struct GtkAccelGroup{}
2608 
2609 
2610 public struct GtkAccelKey
2611 {
2612 	uint accelKey;
2613 	GdkModifierType accelMods;
2614 	uint bitfield0;
2615 	//uint accelFlags : 16;
2616 }
2617 
2618 
2619 /**
2620  * Main Gtk struct.
2621  */
2622 public struct GtkAccelMap{}
2623 
2624 
2625 /**
2626  * Main Gtk struct.
2627  */
2628 public struct GtkClipboard{}
2629 
2630 
2631 /**
2632  * Contains information found when looking up an icon in
2633  * an icon theme.
2634  */
2635 public struct GtkIconInfo{}
2636 
2637 
2638 /**
2639  * Main Gtk struct.
2640  * Acts as a database of information about an icon theme.
2641  * Normally, you retrieve the icon theme for a particular
2642  * screen using gtk_icon_theme_get_for_screen() and it
2643  * will contain information about current icon theme for
2644  * that screen, but you can also create a new GtkIconTheme
2645  * object and set the icon theme name explicitely using
2646  * gtk_icon_theme_set_custom_theme().
2647  */
2648 public struct GtkIconTheme{}
2649 
2650 
2651 /**
2652  * Main Gtk struct.
2653  */
2654 public struct GtkStockItem
2655 {
2656 	char *stockId;
2657 	char *label;
2658 	GdkModifierType modifier;
2659 	uint keyval;
2660 	char *translationDomain;
2661 }
2662 
2663 
2664 /**
2665  * Main Gtk struct.
2666  */
2667 public struct GtkIconSource{}
2668 
2669 
2670 public struct GtkIconFactory{}
2671 
2672 
2673 public struct GtkIconSet{}
2674 
2675 
2676 /**
2677  * Main Gtk struct.
2678  * The GtkRcStyle structure is used to represent a set
2679  * of information about the appearance of a widget.
2680  * This can later be composited together with other
2681  * GtkRcStyle structures to form a GtkStyle.
2682  */
2683 public struct GtkRcStyle
2684 {
2685 	char *name;
2686 	char*[5] bgPixmapName;
2687 	PangoFontDescription *fontDesc;
2688 	GtkRcFlags[5] colorFlags;
2689 	GdkColor[5] fg;
2690 	GdkColor[5] bg;
2691 	GdkColor[5] text;
2692 	GdkColor[5] base;
2693 	int xthickness;
2694 	int ythickness;
2695 }
2696 
2697 
2698 /**
2699  * Main Gtk struct.
2700  */
2701 public struct GtkSettings{}
2702 
2703 
2704 public struct GtkSettingsValue
2705 {
2706 	/+* origin should be something like "filename:linenumber" for rc files,
2707 	 * or e.g. "XProperty" for other sources
2708 	+/
2709 	char *origin;
2710 	/+* valid types are LONG, DOUBLE and STRING corresponding to the token parsed,
2711 	 * or a GSTRING holding an unparsed statement
2712 	+/
2713 	GValue value;
2714 }
2715 
2716 
2717 /**
2718  * Main Gtk struct.
2719  * A binding set maintains a list of activatable key bindings.
2720  * A single binding set can match multiple types of widgets.
2721  * Similar to styles, widgets can be mapped by widget name paths, widget
2722  * class paths or widget class types. When a binding within a set is
2723  * matched upon activation, an action signal is emitted on the target
2724  * widget to carry out the actual activation.
2725  * gchar *set_name;
2726  * unique binding set name
2727  * gint priority;
2728  * unused
2729  * GSList *widget_path_pspecs;
2730  * widgets matched by path that this binding set applies to
2731  * GSList *widget_class_pspecs;
2732  * widgets matched by class path that this binding set applies to
2733  * GSList *class_branch_pspecs;
2734  * widgets matched by class that this binding set applies to
2735  * GtkBindingEntry *entries;
2736  * the key binding entries in this binding set
2737  * GtkBindingEntry *current;
2738  * implementation detail
2739  * guint parsed : 1;
2740  * whether this binding set stems from an RC file and is reset upon theme changes
2741  */
2742 public struct GtkBindingSet
2743 {
2744 	char *setName;
2745 	int priority;
2746 	GSList *widgetPathPspecs;
2747 	GSList *widgetClassPspecs;
2748 	GSList *classBranchPspecs;
2749 	GtkBindingEntry *entries;
2750 	GtkBindingEntry *current;
2751 	uint bitfield0;
2752 	//uint parsed : 1; /+* From RC content +/
2753 }
2754 
2755 
2756 /**
2757  * Each key binding element of a binding sets binding list is represented by
2758  * a GtkBindingEntry.
2759  * guint keyval;
2760  * key value to match
2761  * GdkModifierType modifiers;
2762  * key modifier to match
2763  * GtkBindingSet *binding_set;
2764  * binding set this entry belongs to
2765  * guint destroyed : 1;
2766  * implementation detail
2767  * guint in_emission : 1;
2768  * implementation detail
2769  * guint marks_unbound : 1;
2770  * implementation detail
2771  * GtkBindingEntry *set_next;
2772  * linked list of entries maintained by binding set
2773  * GtkBindingEntry *hash_next;
2774  * implementation detail
2775  * GtkBindingSignal *signals;
2776  * action signals of this entry
2777  */
2778 public struct GtkBindingEntry
2779 {
2780 	/+* key portion
2781 	+/
2782 	uint keyval;
2783 	GdkModifierType modifiers;
2784 	GtkBindingSet *bindingSet;
2785 	uint bitfield0;
2786 	//uint destroyed : 1;
2787 	//uint inEmission : 1;
2788 	//uint marksUnbound : 1;
2789 	GtkBindingEntry *setNext;
2790 	GtkBindingEntry *hashNext;
2791 	GtkBindingSignal *signals;
2792 }
2793 
2794 
2795 /**
2796  * A GtkBindingSignal stores the necessary information to activate a widget
2797  * in response to a key press via a signal emission.
2798  * GtkBindingSignal *next;
2799  * implementation detail
2800  * gchar *signal_name;
2801  * the action signal to be emitted
2802  * guint n_args;
2803  * number of arguments specified for the signal
2804  * GtkBindingArg *args;
2805  * the arguments specified for the signal
2806  */
2807 public struct GtkBindingSignal
2808 {
2809 	GtkBindingSignal *next;
2810 	char *signalName;
2811 	uint nArgs;
2812 	GtkBindingArg *args;
2813 }
2814 
2815 
2816 /**
2817  * A GtkBindingArg holds the data associated with an argument for a
2818  * key binding signal emission as stored in GtkBindingSignal.
2819  * GType arg_type;
2820  * implementation detail
2821  */
2822 public struct GtkBindingArg
2823 {
2824 	GType argType;
2825 	union D
2826 	{
2827 		glong longData;
2828 		double doubleData;
2829 		char *stringData;
2830 	}
2831 	D d;
2832 }
2833 
2834 
2835 /**
2836  * Main Gtk struct.
2837  */
2838 public struct GtkStyle
2839 {
2840 	GdkColor[5] fg;
2841 	GdkColor[5] bg;
2842 	GdkColor[5] light;
2843 	GdkColor[5] dark;
2844 	GdkColor[5] mid;
2845 	GdkColor[5] text;
2846 	GdkColor[5] base;
2847 	GdkColor[5] textAa; /+* Halfway between text/base +/
2848 	GdkColor black;
2849 	GdkColor white;
2850 	PangoFontDescription *fontDesc;
2851 	int xthickness;
2852 	int ythickness;
2853 	GdkGC*[5] fgGc;
2854 	GdkGC*[5] bgGc;
2855 	GdkGC*[5] lightGc;
2856 	GdkGC*[5] darkGc;
2857 	GdkGC*[5] midGc;
2858 	GdkGC*[5] textGc;
2859 	GdkGC*[5] baseGc;
2860 	GdkGC*[5] textAaGc;
2861 	GdkGC *blackGc;
2862 	GdkGC *whiteGc;
2863 	GdkPixmap*[5] bgPixmap;
2864 }
2865 
2866 
2867 /**
2868  * A struct that specifies a border around a rectangular area that can
2869  * be of different width on each side.
2870  */
2871 public struct GtkBorder
2872 {
2873 	int left;
2874 	int right;
2875 	int top;
2876 	int bottom;
2877 }
2878 
2879 
2880 public struct GtkRcProperty
2881 {
2882 	/+* quark-ified property identifier like "GtkScrollbar::spacing" +/
2883 	GQuark typeName;
2884 	GQuark propertyName;
2885 	/+* fields similar to GtkSettingsValue +/
2886 	char *origin;
2887 	GValue value;
2888 }
2889 
2890 
2891 /**
2892  * A GtkTargetEntry structure represents a single type of
2893  * data than can be supplied for by a widget for a selection
2894  * or for supplied or received during drag-and-drop. It
2895  * contains a string representing the drag type, a flags
2896  * field (used only for drag and drop - see GtkTargetFlags),
2897  * and an application assigned integer ID. The integer
2898  * ID will later be passed as a signal parameter for signals
2899  * like "selection_get". It allows the application to identify
2900  * the target type without extensive string compares.
2901  */
2902 public struct GtkTargetEntry
2903 {
2904 	char *target;
2905 	uint flags;
2906 	uint info;
2907 }
2908 
2909 
2910 /**
2911  * Main Gtk struct.
2912  * A GtkTargetList structure is a reference counted list
2913  * of GtkTargetPair. It is used to represent the same
2914  * information as a table of GtkTargetEntry, but in
2915  * an efficient form. This structure should be treated as
2916  * opaque.
2917  */
2918 public struct GtkTargetList
2919 {
2920 	GList *list;
2921 	uint refCount;
2922 }
2923 
2924 
2925 /**
2926  * Internally used structure in the drag-and-drop and
2927  * selection handling code.
2928  */
2929 public struct GtkTargetPair
2930 {
2931 	GdkAtom target;
2932 	uint flags;
2933 	uint info;
2934 }
2935 
2936 
2937 /**
2938  * Warning
2939  * GtkArg is deprecated and should not be used in newly-written code.
2940  * This is a structure that we use to pass in typed values (and names).
2941  */
2942 public struct GtkArg
2943 {
2944 	GType type;
2945 	char *name;
2946 	/+* this unio only defines the required storage types for
2947 	 * the possibile values, thus there is no int enumData field,
2948 	 * because that would just be a mere alias for int intData.
2949 	 * use the GTK_VALUE_*() and GTK_RETLOC_*() macros to access
2950 	 * the discrete memebers.
2951 	+/
2952 	union D
2953 	{
2954 		/+* flat values +/
2955 		char charData;
2956 		char ucharData;
2957 		int boolData;
2958 		int intData;
2959 		uint uintData;
2960 		glong longData;
2961 		gulong ulongData;
2962 		float floatData;
2963 		double doubleData;
2964 		char *stringData;
2965 		GtkObject *objectData;
2966 		void* pointerData;
2967 		/+* structured values +/
2968 		struct SignalData
2969 		{
2970 			GCallback f;
2971 			void* d;
2972 		}
2973 		SignalData signalData;
2974 	}
2975 	D d;
2976 }
2977 
2978 
2979 /**
2980  * Warning
2981  * GtkTypeInfo is deprecated and should not be used in newly-written code.
2982  * Holds information about the type. gtk_type_name() returns the name.
2983  * object_size is somehow set to the number of bytes that an instance of
2984  * the object will occupy. class_init_func holds the type's
2985  * initialization function. object_init_func holds the initialization
2986  * function for an instance of the object. reserved_1 is used for
2987  * GtkEnumValue to hold the enumerated values.
2988  */
2989 public struct GtkTypeInfo
2990 {
2991 	char *typeName;
2992 	uint objectSize;
2993 	uint classSize;
2994 	GtkClassInitFunc classInitFunc;
2995 	GtkObjectInitFunc objectInitFunc;
2996 	void* reserved1;
2997 	void* reserved2;
2998 	GtkClassInitFunc baseClassInitFunc;
2999 }
3000 
3001 
3002 /**
3003  * Main Gtk struct.
3004  * This should not be accessed directly. Use the accessor functions below.
3005  */
3006 public struct GtkMountOperation{}
3007 
3008 
3009 /**
3010  * Main Gtk struct.
3011  * vbox is a GtkVBox - the main part of the
3012  * dialog box.
3013  * action_area is a GtkHButtonBox packed below the
3014  * dividing GtkHSeparator in the dialog. It is treated exactly the same
3015  * as any other GtkHButtonBox.
3016  */
3017 public struct GtkDialog
3018 {
3019 	GtkWidget *vbox;
3020 	GtkWidget *actionArea;
3021 }
3022 
3023 
3024 /**
3025  * Main Gtk struct.
3026  * The GtkInvisible struct contains no public fields.
3027  */
3028 public struct GtkInvisible{}
3029 
3030 
3031 /**
3032  * Main Gtk struct.
3033  */
3034 public struct GtkMessageDialog{}
3035 
3036 
3037 /**
3038  * Main Gtk struct.
3039  */
3040 public struct GtkWindow{}
3041 
3042 
3043 /**
3044  * Main Gtk struct.
3045  */
3046 public struct GtkWindowGroup{}
3047 
3048 
3049 /**
3050  * Main Gtk struct.
3051  * The GtkAboutDialog struct contains
3052  * only private fields and should not be directly accessed.
3053  */
3054 public struct GtkAboutDialog{}
3055 
3056 
3057 /**
3058  * Main Gtk struct.
3059  */
3060 public struct GtkAssistant{}
3061 
3062 
3063 /**
3064  * Main Gtk struct.
3065  */
3066 public struct GtkOffscreenWindow{}
3067 
3068 
3069 /**
3070  * Main Gtk struct.
3071  * The GtkAccelLabel struct contains private data only, and
3072  * should be accessed using the functions below.
3073  */
3074 public struct GtkAccelLabel{}
3075 
3076 
3077 /**
3078  * Main Gtk struct.
3079  * This struct contain private data only and should be accessed by the functions
3080  * below.
3081  */
3082 public struct GtkImage{}
3083 
3084 
3085 /**
3086  * Main Gtk struct.
3087  * This should not be accessed directly. Use the accessor functions as
3088  * described below.
3089  */
3090 public struct GtkLabel{}
3091 
3092 
3093 /**
3094  * Main Gtk struct.
3095  * The GtkProgressBar struct contains private data only,
3096  * and should be accessed using the functions below.
3097  */
3098 public struct GtkProgressBar{}
3099 
3100 
3101 /**
3102  * Main Gtk struct.
3103  * Contains private data that should be modified with the functions described
3104  * below.
3105  */
3106 public struct GtkStatusbar{}
3107 
3108 
3109 /**
3110  * Main Gtk struct.
3111  */
3112 public struct GtkInfoBar{}
3113 
3114 
3115 /**
3116  * Main Gtk struct.
3117  */
3118 public struct GtkStatusIcon{}
3119 
3120 
3121 /**
3122  * Main Gtk struct.
3123  */
3124 public struct GtkSpinner{}
3125 
3126 
3127 /**
3128  * Main Gtk struct.
3129  * This should not be accessed directly. Use the accessor functions below.
3130  */
3131 public struct GtkButton{}
3132 
3133 
3134 /**
3135  * Main Gtk struct.
3136  * toggle_button is a GtkToggleButton representing the actual toggle button that composes the check button.
3137  */
3138 public struct GtkCheckButton{}
3139 
3140 
3141 /**
3142  * Main Gtk struct.
3143  * Contains only private data that should be read and manipulated using the
3144  * functions below.
3145  */
3146 public struct GtkRadioButton{}
3147 
3148 
3149 /**
3150  * Main Gtk struct.
3151  * The GtkToggleButton struct contains private data only, and should be manipulated using the functions below.
3152  */
3153 public struct GtkToggleButton{}
3154 
3155 
3156 /**
3157  * Main Gtk struct.
3158  * The GtkLinkButton struct contains private data only, and should be
3159  * manipulated using the functions below.
3160  */
3161 public struct GtkLinkButton{}
3162 
3163 
3164 /**
3165  * Main Gtk struct.
3166  */
3167 public struct GtkScaleButton{}
3168 
3169 
3170 /**
3171  * Main Gtk struct.
3172  */
3173 public struct GtkVolumeButton{}
3174 
3175 
3176 /**
3177  * Main Gtk struct.
3178  * The GtkEntry struct contains only private data.
3179  */
3180 public struct GtkEntry{}
3181 
3182 
3183 /**
3184  * Main Gtk struct.
3185  */
3186 public struct GtkEntryBuffer{}
3187 
3188 
3189 /**
3190  * Main Gtk struct.
3191  * The GtkEntryCompletion struct contains only private data.
3192  */
3193 public struct GtkEntryCompletion{}
3194 
3195 
3196 /**
3197  * Main Gtk struct.
3198  * The GtkHScale struct contains private data only, and
3199  * should be accessed using the functions below.
3200  */
3201 public struct GtkHScale{}
3202 
3203 
3204 /**
3205  * Main Gtk struct.
3206  * The GtkVScale struct contains private data only, and
3207  * should be accessed using the functions below.
3208  */
3209 public struct GtkVScale{}
3210 
3211 
3212 /**
3213  * Main Gtk struct.
3214  * entry is the GtkEntry part of the GtkSpinButton
3215  * widget, and can be used accordingly. All other fields contain private data
3216  * and should only be modified using the functions below.
3217  */
3218 public struct GtkSpinButton{}
3219 
3220 
3221 /**
3222  * Main Gtk struct.
3223  * The GtkEditable structure is an opaque structure whose members
3224  * cannot be directly accessed.
3225  */
3226 public struct GtkEditable{}
3227 
3228 
3229 /**
3230  * Main Gtk struct.
3231  */
3232 public struct GtkTextMark{}
3233 
3234 
3235 /**
3236  * Main Gtk struct.
3237  */
3238 public struct GtkTextBuffer{}
3239 
3240 
3241 /**
3242  * Main Gtk struct.
3243  */
3244 public struct GtkTextTag{}
3245 
3246 
3247 /**
3248  * Using GtkTextAttributes directly should rarely be necessary. It's
3249  * primarily useful with gtk_text_iter_get_attributes(). As with most
3250  * GTK+ structs, the fields in this struct should only be read, never
3251  * modified directly.
3252  * GtkTextAppearance appearance;
3253  * pointer to sub-struct containing certain attributes
3254  * GtkJustification justification;
3255  * GtkTextDirection direction;
3256  * PangoFontDescription *font;
3257  * gdouble font_scale;
3258  * gint left_margin;
3259  * gint indent;
3260  * gint right_margin;
3261  * gint pixels_above_lines;
3262  * gint pixels_below_lines;
3263  * gint pixels_inside_wrap;
3264  * PangoTabArray *tabs;
3265  * GtkWrapMode wrap_mode;
3266  * PangoLanguage *language;
3267  * guint invisible : 1;
3268  * guint bg_full_height : 1;
3269  * guint editable : 1;
3270  * guint realized : 1;
3271  */
3272 public struct GtkTextAttributes
3273 {
3274 	GtkTextAppearance appearance;
3275 	GtkJustification justification;
3276 	GtkTextDirection direction;
3277 	/+* Individual chunks of this can be set/unset as a group +/
3278 	PangoFontDescription *font;
3279 	double fontScale;
3280 	int leftMargin;
3281 	int indent;
3282 	int rightMargin;
3283 	int pixelsAboveLines;
3284 	int pixelsBelowLines;
3285 	int pixelsInsideWrap;
3286 	PangoTabArray *tabs;
3287 	GtkWrapMode wrapMode; /+* How to handle wrap-around for this tag.
3288 	 * Must be GTK_WRAPMODE_CHAR,
3289 	 * GTK_WRAPMODE_NONE, GTK_WRAPMODE_WORD
3290 	+/
3291 	PangoLanguage *language;
3292 	/+* hide the text +/
3293 	uint bitfield0;
3294 	//uint invisible : 1;
3295 	/+* Background is fit to full line height rather than
3296 	 * baseline +\- ascent\descent (font height)
3297 	+/
3298 	//uint bgFullHeight : 1;
3299 	/+* can edit this text +/
3300 	//uint editable : 1;
3301 	/+* colors are allocated etc. +/
3302 	//uint realized : 1;
3303 }
3304 
3305 
3306 public struct GtkTextAppearance
3307 {
3308 	GdkColor bgColor;
3309 	GdkColor fgColor;
3310 	GdkBitmap *bgStipple;
3311 	GdkBitmap *fgStipple;
3312 	/+* super/subscript rise, can be negative +/
3313 	int rise;
3314 	uint bitfield0;
3315 	//uint underline : 4; /+* PangoUnderline +/
3316 	//uint strikethrough : 1;
3317 	/+* Whether to use background-related values; this is irrelevant for
3318 	 * the values struct when inn a tag, but is used for the composite
3319 	 * values struct; it's true if any of the tags being composited
3320 	 * had background stuff set.
3321 	+/
3322 	//uint drawBg : 1;
3323 	/+* These are only used when we are actually laying out and rendering
3324 	 * a paragraph; not when a GtkTextAppearance is part of a
3325 	 * GtkTextAttributes.
3326 	+/
3327 	//uint insideSelection : 1;
3328 	//uint isText : 1;
3329 }
3330 
3331 
3332 /**
3333  * Main Gtk struct.
3334  */
3335 public struct GtkTextTagTable{}
3336 
3337 
3338 /**
3339  * Main Gtk struct.
3340  */
3341 public struct GtkTextView{}
3342 
3343 
3344 /**
3345  * A GtkTextChildAnchor is a spot in the buffer
3346  * where child widgets can be "anchored" (inserted inline, as if they were
3347  * characters). The anchor can have multiple widgets anchored, to allow for
3348  * multiple views.
3349  */
3350 public struct GtkTextChildAnchor{}
3351 
3352 
3353 /**
3354  * Main Gtk struct.
3355  */
3356 public struct GtkTreeModel{}
3357 
3358 
3359 /**
3360  * The GtkTreeIter is the primary structure for
3361  * accessing a structure. Models are expected to put a unique integer in
3362  * the stamp member, and put model-specific
3363  * data in the three user_data members.
3364  */
3365 public struct GtkTreeIter
3366 {
3367 	int stamp;
3368 	void* userData;
3369 	void* userData2;
3370 	void* userData3;
3371 }
3372 
3373 
3374 public struct GtkTreePath{}
3375 
3376 
3377 public struct GtkTreeRowReference{}
3378 
3379 
3380 public struct GtkTreeModelIface
3381 {
3382 	GTypeInterface gIface;
3383 	/+* Signals +/
3384 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter)  rowChanged;
3385 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter)  rowInserted;
3386 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter)  rowHasChildToggled;
3387 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path)  rowDeleted;
3388 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter, int* newOrder)  rowsReordered;
3389 	/+* Virtual Table +/
3390 	extern(C) GtkTreeModelFlags function(GtkTreeModel* treeModel)  getFlags;
3391 	extern(C) int function(GtkTreeModel* treeModel)  getNColumns;
3392 	extern(C) GType function(GtkTreeModel* treeModel, int index)  getColumnType;
3393 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreePath* path)  getIter;
3394 	extern(C) GtkTreePath * function(GtkTreeModel* treeModel, GtkTreeIter* iter)  getPath;
3395 	extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter, int column, GValue* value)  getValue;
3396 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter)  iterNext;
3397 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* parent)  iterChildren;
3398 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter)  iterHasChild;
3399 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter)  iterNChildren;
3400 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* parent, int n)  iterNthChild;
3401 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* child)  iterParent;
3402 	extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter)  refNode;
3403 	extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter)  unrefNode;
3404 }
3405 
3406 
3407 /**
3408  * Main Gtk struct.
3409  */
3410 public struct GtkTreeSelection{}
3411 
3412 
3413 /**
3414  * Main Gtk struct.
3415  */
3416 public struct GtkTreeViewColumn{}
3417 
3418 
3419 /**
3420  * Main Gtk struct.
3421  */
3422 public struct GtkTreeView{}
3423 
3424 
3425 /**
3426  * A private struct for internal use only. The definition of this
3427  * structure is not publically available.
3428  */
3429 public struct GtkTreeViewPrivate{}
3430 
3431 
3432 /**
3433  * Main Gtk struct.
3434  */
3435 public struct GtkTreeDragSource{}
3436 
3437 
3438 public struct GtkTreeDragSourceIface
3439 {
3440 	GTypeInterface gIface;
3441 	/+* VTable - not signals +/
3442 	extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path)  rowDraggable;
3443 	extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path, GtkSelectionData* selectionData)  dragDataGet;
3444 	extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path)  dragDataDelete;
3445 }
3446 
3447 
3448 public struct GtkTreeDragDest{}
3449 
3450 
3451 public struct GtkTreeDragDestIface
3452 {
3453 	GTypeInterface gIface;
3454 	/+* VTable - not signals +/
3455 	extern(C) int function(GtkTreeDragDest* dragDest, GtkTreePath* dest, GtkSelectionData* selectionData)  dragDataReceived;
3456 	extern(C) int function(GtkTreeDragDest* dragDest, GtkTreePath* destPath, GtkSelectionData* selectionData)  rowDropPossible;
3457 }
3458 
3459 
3460 /**
3461  * Main Gtk struct.
3462  */
3463 public struct GtkCellView{}
3464 
3465 
3466 /**
3467  * Main Gtk struct.
3468  * The GtkIconView struct contains only
3469  * private fields and should not be directly accessed.
3470  */
3471 public struct GtkIconView{}
3472 
3473 
3474 /**
3475  * Main Gtk struct.
3476  */
3477 public struct GtkTreeSortable{}
3478 
3479 
3480 public struct GtkTreeSortableIface
3481 {
3482 	GTypeInterface gIface;
3483 	/+* signals +/
3484 	extern(C) void function(GtkTreeSortable* sortable)  sortColumnChanged;
3485 	/+* virtua table +/
3486 	extern(C) int function(GtkTreeSortable* sortable, int* sortColumnId, GtkSortType* order)  getSortColumnId;
3487 	extern(C) void function(GtkTreeSortable* sortable, int sortColumnId, GtkSortType order)  setSortColumnId;
3488 	extern(C) void function(GtkTreeSortable* sortable, int sortColumnId, GtkTreeIterCompareFunc func, void* data, GDestroyNotify destroy)  setSortFunc;
3489 	extern(C) void function(GtkTreeSortable* sortable, GtkTreeIterCompareFunc func, void* data, GDestroyNotify destroy)  setDefaultSortFunc;
3490 	extern(C) int function(GtkTreeSortable* sortable)  hasDefaultSortFunc;
3491 }
3492 
3493 
3494 /**
3495  * Main Gtk struct.
3496  * This should not be accessed directly. Use the accessor functions below.
3497  */
3498 public struct GtkTreeModelSort{}
3499 
3500 
3501 /**
3502  * Main Gtk struct.
3503  * The GtkTreeModelFilter struct contains only private fields.
3504  */
3505 public struct GtkTreeModelFilter{}
3506 
3507 
3508 /**
3509  * Main Gtk struct.
3510  */
3511 public struct GtkCellLayout{}
3512 
3513 
3514 public struct GtkCellLayoutIface
3515 {
3516 	GTypeInterface gIface;
3517 	/+* Virtual Table +/
3518 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int expand)  packStart;
3519 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int expand)  packEnd;
3520 	extern(C) void function(GtkCellLayout* cellLayout)  clear;
3521 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, char* attribute, int column)  addAttribute;
3522 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, GtkCellLayoutDataFunc func, void* funcData, GDestroyNotify destroy)  setCellDataFunc;
3523 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell)  clearAttributes;
3524 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int position)  reorder;
3525 	extern(C) GList* function(GtkCellLayout* cellLayout)  getCells;
3526 }
3527 
3528 
3529 /**
3530  * Main Gtk struct.
3531  */
3532 public struct GtkCellRenderer{}
3533 
3534 
3535 public struct GtkCellRendererClass
3536 {
3537 	GtkObjectClass parentClass;
3538 	/+* vtable - not signals +/
3539 	extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, GdkRectangle* cellArea, int* xOffset, int* yOffset, int* width, int* height)  getSize;
3540 	extern(C) void function(GtkCellRenderer* cell, GdkDrawable* window, GtkWidget* widget, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GdkRectangle* exposeArea, GtkCellRendererState flags)  render;
3541 	extern(C) int function(GtkCellRenderer* cell, GdkEvent* event, GtkWidget* widget, char* path, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags)  activate;
3542 	extern(C) GtkCellEditable * function(GtkCellRenderer* cell, GdkEvent* event, GtkWidget* widget, char* path, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags)  startEditing;
3543 	/+* Signals +/
3544 	extern(C) void function(GtkCellRenderer* cell)  editingCanceled;
3545 	extern(C) void function(GtkCellRenderer* cell, GtkCellEditable* editable, char* path)  editingStarted;
3546 	/+* Padding for future expansion +/
3547 	extern(C) void function() _GtkReserved1;
3548 	extern(C) void function() _GtkReserved2;
3549 }
3550 
3551 
3552 /**
3553  * Main Gtk struct.
3554  */
3555 public struct GtkCellEditable{}
3556 
3557 
3558 public struct GtkCellEditableIface
3559 {
3560 	GTypeInterface gIface;
3561 	/+* signals +/
3562 	extern(C) void function(GtkCellEditable* cellEditable)  editingDone;
3563 	extern(C) void function(GtkCellEditable* cellEditable)  removeWidget;
3564 	/+* virtua table +/
3565 	extern(C) void function(GtkCellEditable* cellEditable, GdkEvent* event)  startEditing;
3566 }
3567 
3568 
3569 /**
3570  * Main Gtk struct.
3571  */
3572 public struct GtkCellRendererAccel{}
3573 
3574 
3575 /**
3576  * Main Gtk struct.
3577  */
3578 public struct GtkCellRendererCombo{}
3579 
3580 
3581 /**
3582  * Main Gtk struct.
3583  */
3584 public struct GtkCellRendererPixbuf{}
3585 
3586 
3587 /**
3588  * Main Gtk struct.
3589  */
3590 public struct GtkCellRendererProgress{}
3591 
3592 
3593 /**
3594  * Main Gtk struct.
3595  */
3596 public struct GtkCellRendererSpin{}
3597 
3598 
3599 /**
3600  * Main Gtk struct.
3601  */
3602 public struct GtkCellRendererText{}
3603 
3604 
3605 /**
3606  * Main Gtk struct.
3607  */
3608 public struct GtkCellRendererToggle{}
3609 
3610 
3611 /**
3612  * Main Gtk struct.
3613  */
3614 public struct GtkCellRendererSpinner{}
3615 
3616 
3617 /**
3618  * Main Gtk struct.
3619  */
3620 public struct GtkListStore{}
3621 
3622 
3623 /**
3624  * Main Gtk struct.
3625  */
3626 public struct GtkTreeStore{}
3627 
3628 
3629 /**
3630  * Main Gtk struct.
3631  */
3632 public struct GtkComboBox{}
3633 
3634 
3635 /**
3636  * Main Gtk struct.
3637  * Warning
3638  * GtkComboBoxEntry is deprecated and should not be used in newly-written code.
3639  */
3640 public struct GtkComboBoxEntry{}
3641 
3642 
3643 /**
3644  * Main Gtk struct.
3645  * The GtkMenu struct contains private data only, and
3646  * should be accessed using the functions below.
3647  */
3648 public struct GtkMenu{}
3649 
3650 
3651 /**
3652  * Main Gtk struct.
3653  * The GtkMenuBar struct contains the following fields. (These fields should be considered read-only. They should never be set by an application.)
3654  */
3655 public struct GtkMenuBar{}
3656 
3657 
3658 /**
3659  * Main Gtk struct.
3660  */
3661 public struct GtkMenuItem{}
3662 
3663 
3664 /**
3665  * Main Gtk struct.
3666  */
3667 public struct GtkImageMenuItem{}
3668 
3669 
3670 /**
3671  * Main Gtk struct.
3672  * The structure contains only private data that must be accessed through
3673  * the interface functions.
3674  */
3675 public struct GtkRadioMenuItem{}
3676 
3677 
3678 /**
3679  * Main Gtk struct.
3680  * The GtkCheckMenuItem struct contains the following fields.
3681  * (These fields should be considered read-only. They should never be set by
3682  * an application.)
3683  * guint active;
3684  * TRUE if the check box is active.
3685  */
3686 public struct GtkCheckMenuItem{}
3687 
3688 
3689 /**
3690  * Main Gtk struct.
3691  * The GtkSeparatorMenuItem struct contains private data only, and
3692  * should be accessed using the functions below.
3693  */
3694 public struct GtkSeparatorMenuItem{}
3695 
3696 
3697 /**
3698  * Main Gtk struct.
3699  * The GtkTearoffMenuItem struct contains private data only, and
3700  * should be accessed using the functions below.
3701  */
3702 public struct GtkTearoffMenuItem{}
3703 
3704 
3705 /**
3706  * Main Gtk struct.
3707  * Dummy structure for accessing instances of GtkToolShellIface.
3708  */
3709 public struct GtkToolShell{}
3710 
3711 
3712 /**
3713  * Virtual function table for the GtkToolShell interface.
3714  * get_icon_size ()
3715  * mandatory implementation of gtk_tool_shell_get_icon_size().
3716  * get_orientation ()
3717  * mandatory implementation of gtk_tool_shell_get_orientation().
3718  * get_style ()
3719  * mandatory implementation of gtk_tool_shell_get_style().
3720  * get_relief_style ()
3721  * optional implementation of gtk_tool_shell_get_relief_style().
3722  * rebuild_menu ()
3723  * optional implementation of gtk_tool_shell_rebuild_menu().
3724  * get_text_orientation ()
3725  * optional implementation of gtk_tool_shell_get_text_orientation().
3726  * get_text_alignment ()
3727  * optional implementation of gtk_tool_shell_get_text_alignment().
3728  * get_ellipsize_mode ()
3729  * optional implementation of gtk_tool_shell_get_ellipsize_mode().
3730  * get_text_size_group ()
3731  * optional implementation of gtk_tool_shell_get_text_size_group().
3732  */
3733 public struct GtkToolShellIface
3734 {
3735 	extern(C) GtkIconSize function(GtkToolShell* shell) getIconSize;
3736 	extern(C) GtkOrientation function(GtkToolShell* shell) getOrientation;
3737 	extern(C) GtkToolbarStyle function(GtkToolShell* shell) getStyle;
3738 	extern(C) GtkReliefStyle function(GtkToolShell* shell) getReliefStyle;
3739 	extern(C) void function(GtkToolShell* shell) rebuildMenu;
3740 	extern(C) GtkOrientation function(GtkToolShell* shell) getTextOrientation;
3741 	extern(C) float function(GtkToolShell* shell) getTextAlignment;
3742 	extern(C) PangoEllipsizeMode function(GtkToolShell* shell) getEllipsizeMode;
3743 	extern(C) GtkSizeGroup * function(GtkToolShell* shell) getTextSizeGroup;
3744 }
3745 
3746 
3747 /**
3748  * Main Gtk struct.
3749  * The GtkToolbar struct only contains private data and should only be
3750  * accessed through the function described below.
3751  */
3752 public struct GtkToolbar
3753 {
3754 	int numChildren;
3755 	GList *children;
3756 	GtkOrientation orientation;
3757 	GtkToolbarStyle style;
3758 	GtkIconSize iconSize;
3759 	version(GTK_DISABLE_DEPRECATED)
3760 	{
3761 		GtkTooltips *tooltips;
3762 	}
3763 	else
3764 	{
3765 		void* _Tooltips;
3766 	}
3767 }
3768 
3769 
3770 /**
3771  * Warning
3772  * GtkToolbarChild is deprecated and should not be used in newly-written code.
3773  */
3774 public struct GtkToolbarChild
3775 {
3776 	GtkToolbarChildType type;
3777 	GtkWidget *widget;
3778 	GtkWidget *icon;
3779 	GtkWidget *label;
3780 }
3781 
3782 
3783 /**
3784  * Main Gtk struct.
3785  * The GtkToolItem struct contains only private data.
3786  * It should only be accessed through the functions described below.
3787  */
3788 public struct GtkToolItem{}
3789 
3790 
3791 /**
3792  * Main Gtk struct.
3793  * This should not be accessed directly. Use the accessor functions below.
3794  */
3795 public struct GtkToolPalette{}
3796 
3797 
3798 /**
3799  * Main Gtk struct.
3800  * This should not be accessed directly. Use the accessor functions below.
3801  */
3802 public struct GtkToolItemGroup{}
3803 
3804 
3805 /**
3806  * Main Gtk struct.
3807  * The GtkSeparatorToolItem struct contains only private data and
3808  * should only be accessed through the functions described below.
3809  */
3810 public struct GtkSeparatorToolItem{}
3811 
3812 
3813 /**
3814  * Main Gtk struct.
3815  * The GtkToolButton struct contains only private. It should only be
3816  * accessed with the function described below.
3817  */
3818 public struct GtkToolButton{}
3819 
3820 
3821 /**
3822  * Main Gtk struct.
3823  */
3824 public struct GtkMenuToolButton{}
3825 
3826 
3827 /**
3828  * Main Gtk struct.
3829  */
3830 public struct GtkToggleToolButton{}
3831 
3832 
3833 /**
3834  * Main Gtk struct.
3835  */
3836 public struct GtkRadioToolButton{}
3837 
3838 
3839 /**
3840  * Main Gtk struct.
3841  * The GtkUIManager struct contains only private
3842  * members and should not be accessed directly.
3843  */
3844 public struct GtkUIManager{}
3845 
3846 
3847 /**
3848  * Main Gtk struct.
3849  * The GtkActionGroup struct contains only private
3850  * members and should not be accessed directly.
3851  */
3852 public struct GtkActionGroup{}
3853 
3854 
3855 /**
3856  * GtkActionEntry structs are used with
3857  * gtk_action_group_add_actions() to construct actions.
3858  * const gchar *name;
3859  * The name of the action.
3860  * const gchar *stock_id;
3861  * The stock id for the action, or the name of an icon from the icon
3862  * theme.
3863  * const gchar *label;
3864  * The label for the action. This field should typically be marked for
3865  * translation, see gtk_action_group_set_translation_domain(). If label
3866  * is NULL, the label of the stock item with id stock_id is used.
3867  * const gchar *accelerator;
3868  * The accelerator for the action, in the format understood by
3869  * gtk_accelerator_parse().
3870  * const gchar *tooltip;
3871  * The tooltip for the action. This field should typically be marked
3872  * for translation, see gtk_action_group_set_translation_domain().
3873  * GCallback callback;
3874  * The function to call when the action is activated.
3875  */
3876 public struct GtkActionEntry
3877 {
3878 	char *name;
3879 	char *stockId;
3880 	char *label;
3881 	char *accelerator;
3882 	char *tooltip;
3883 	GCallback callback;
3884 }
3885 
3886 
3887 /**
3888  * GtkToggleActionEntry structs are used with
3889  * gtk_action_group_add_toggle_actions() to construct toggle actions.
3890  * const gchar *name;
3891  * The name of the action.
3892  * const gchar *stock_id;
3893  * The stock id for the action, or the name of an icon from the icon
3894  * theme.
3895  * const gchar *label;
3896  * The label for the action. This field should typically be marked for
3897  * translation, see gtk_action_group_set_translation_domain().
3898  * const gchar *accelerator;
3899  * The accelerator for the action, in the format understood by
3900  * gtk_accelerator_parse().
3901  * const gchar *tooltip;
3902  * The tooltip for the action. This field should typically be marked
3903  * for translation, see gtk_action_group_set_translation_domain().
3904  * GCallback callback;
3905  * The function to call when the action is activated.
3906  * gboolean is_active;
3907  * The initial state of the toggle action.
3908  */
3909 public struct GtkToggleActionEntry
3910 {
3911 	char *name;
3912 	char *stockId;
3913 	char *label;
3914 	char *accelerator;
3915 	char *tooltip;
3916 	GCallback callback;
3917 	int isActive;
3918 }
3919 
3920 
3921 /**
3922  * GtkRadioActionEntry structs are used with
3923  * gtk_action_group_add_radio_actions() to construct groups of radio actions.
3924  * const gchar *name;
3925  * The name of the action.
3926  * const gchar *stock_id;
3927  * The stock id for the action, or the name of an icon from the icon
3928  * theme.
3929  * const gchar *label;
3930  * The label for the action. This field should typically be marked for
3931  * translation, see gtk_action_group_set_translation_domain().
3932  * const gchar *accelerator;
3933  * The accelerator for the action, in the format understood by
3934  * gtk_accelerator_parse().
3935  * const gchar *tooltip;
3936  * The tooltip for the action. This field should typically be marked for
3937  * translation, see gtk_action_group_set_translation_domain().
3938  * gint value;
3939  * The value to set on the radio action. See gtk_radio_action_get_current_value().
3940  */
3941 public struct GtkRadioActionEntry
3942 {
3943 	char *name;
3944 	char *stockId;
3945 	char *label;
3946 	char *accelerator;
3947 	char *tooltip;
3948 	int value;
3949 }
3950 
3951 
3952 /**
3953  * Main Gtk struct.
3954  */
3955 public struct GtkAction{}
3956 
3957 
3958 /**
3959  * Main Gtk struct.
3960  * The GtkToggleAction struct contains only
3961  * private members and should not be accessed directly.
3962  */
3963 public struct GtkToggleAction{}
3964 
3965 
3966 /**
3967  * Main Gtk struct.
3968  * The GtkRadioAction struct contains
3969  * only private members and should not be accessed directly.
3970  */
3971 public struct GtkRadioAction{}
3972 
3973 
3974 /**
3975  * Main Gtk struct.
3976  */
3977 public struct GtkRecentAction{}
3978 
3979 
3980 /**
3981  * Main Gtk struct.
3982  */
3983 public struct GtkActivatable{}
3984 
3985 
3986 /**
3987  * GTypeInterface g_iface;
3988  * update ()
3989  * Called to update the activatable when its related action's properties change.
3990  * You must check the "use-action-appearance" property only apply action
3991  * properties that are meant to effect the appearance accordingly.
3992  * sync_action_properties ()
3993  * Called to update the activatable completely, this is called internally when
3994  * "related-action" property is set or unset and by the implementor when
3995  * "use-action-appearance" changes.
3996  * Note
3997  * This method can be called
3998  * with a NULL action at times
3999  * Since 2.16
4000  */
4001 public struct GtkActivatableIface
4002 {
4003 	GTypeInterface gIface;
4004 	/+* virtua table +/
4005 	extern(C) void function(GtkActivatable* activatable, GtkAction* action, char* propertyName)  update;
4006 	extern(C) void function(GtkActivatable* activatable, GtkAction* action)  syncActionProperties;
4007 }
4008 
4009 
4010 /**
4011  * Main Gtk struct.
4012  * The GtkColorButton struct has only private fields and
4013  * should not be used directly.
4014  */
4015 public struct GtkColorButton{}
4016 
4017 
4018 /**
4019  * Main Gtk struct.
4020  * The GtkColorSelection struct contains private data only,
4021  * and should be accessed using the functions below.
4022  */
4023 public struct GtkColorSelection{}
4024 
4025 
4026 /**
4027  * Main Gtk struct.
4028  * The GtkColorSelectionDialog struct contains the following fields.
4029  * (These fields should be considered read-only. They should never be set by
4030  * an application.)
4031  * GtkWidget *colorsel;
4032  * The GtkColorSelection widget contained within the
4033  * dialog. Use this widget and its gtk_color_selection_get_current_color()
4034  * function to gain access to the selected color. Connect a handler
4035  * for this widget's color_changed signal to be notified when the
4036  * color changes.
4037  * GtkWidget *ok_button;
4038  * The OK button widget contained within the dialog.
4039  * Connect a handler for the clicked event.
4040  * GtkWidget *cancel_button;
4041  * The cancel button widget contained within the dialog.
4042  * Connect a handler for the clicked event.
4043  * GtkWidget *help_button;
4044  * The help button widget contained within the dialog.
4045  * Connect a handler for the clicked event.
4046  */
4047 public struct GtkColorSelectionDialog{}
4048 
4049 
4050 /**
4051  * Main Gtk struct.
4052  */
4053 public struct GtkFileChooser{}
4054 
4055 
4056 /**
4057  * Main Gtk struct.
4058  * This should not be accessed directly. Use the accessor functions below.
4059  */
4060 public struct GtkFileChooserButton{}
4061 
4062 
4063 /**
4064  * Main Gtk struct.
4065  */
4066 public struct GtkFileChooserDialog{}
4067 
4068 
4069 /**
4070  * Main Gtk struct.
4071  */
4072 public struct GtkFileChooserWidget{}
4073 
4074 
4075 /**
4076  * Main Gtk struct.
4077  * The GtkFileFilter struct contains
4078  * only private fields and should not be directly accessed.
4079  */
4080 public struct GtkFileFilter{}
4081 
4082 
4083 /**
4084  * A GtkFileFilterInfo struct is used
4085  * to pass information about the tested file to
4086  * gtk_file_filter_filter().
4087  * GtkFileFilterFlags contains;
4088  * Flags indicating which of the following fields need
4089  * are filled
4090  * const gchar *filename;
4091  * the filename of the file being tested
4092  * const gchar *uri;
4093  * the URI for the file being tested
4094  * const gchar *display_name;
4095  * the string that will be used to display the file
4096  * in the file chooser
4097  * const gchar *mime_type;
4098  * the mime type of the file
4099  */
4100 public struct GtkFileFilterInfo
4101 {
4102 	GtkFileFilterFlags contains;
4103 	char *filename;
4104 	char *uri;
4105 	char *displayName;
4106 	char *mimeType;
4107 }
4108 
4109 
4110 /**
4111  * Main Gtk struct.
4112  * The GtkFontButton struct has only private members and should not be used
4113  * directly.
4114  */
4115 public struct GtkFontButton{}
4116 
4117 
4118 /**
4119  * Main Gtk struct.
4120  * The GtkFontSelection struct contains private data only, and should
4121  * only be accessed using the functions below.
4122  */
4123 public struct GtkFontSelection{}
4124 
4125 
4126 /**
4127  * Main Gtk struct.
4128  */
4129 public struct GtkFontSelectionDialog
4130 {
4131 	GtkWidget *okButton;
4132 	GtkWidget *applyButton;
4133 	GtkWidget *cancelButton;
4134 }
4135 
4136 
4137 /**
4138  * Main Gtk struct.
4139  * Warning
4140  * GtkInputDialog is deprecated and should not be used in newly-written code.
4141  */
4142 public struct GtkInputDialog{}
4143 
4144 
4145 /**
4146  * Main Gtk struct.
4147  */
4148 public struct GtkAlignment{}
4149 
4150 
4151 /**
4152  * Main Gtk struct.
4153  */
4154 public struct GtkAspectFrame{}
4155 
4156 
4157 /**
4158  * Main Gtk struct.
4159  */
4160 public struct GtkHBox{}
4161 
4162 
4163 /**
4164  * Main Gtk struct.
4165  */
4166 public struct GtkVBox{}
4167 
4168 
4169 /**
4170  * Main Gtk struct.
4171  * GtkHButtonBox does not contain any public fields.
4172  */
4173 public struct GtkHButtonBox{}
4174 
4175 
4176 /**
4177  * Main Gtk struct.
4178  */
4179 public struct GtkVButtonBox{}
4180 
4181 
4182 /**
4183  * Main Gtk struct.
4184  * The GtkFixed struct contains the following fields.
4185  * (These fields should be considered read-only. They should never be set by
4186  * an application.)
4187  * GList *children;
4188  * a list of GtkFixedChild elements, containing the child widgets and
4189  * their positions.
4190  */
4191 public struct GtkFixed{}
4192 
4193 
4194 /**
4195  * Main Gtk struct.
4196  */
4197 public struct GtkHPaned{}
4198 
4199 
4200 /**
4201  * Main Gtk struct.
4202  */
4203 public struct GtkVPaned{}
4204 
4205 
4206 /**
4207  * Main Gtk struct.
4208  */
4209 public struct GtkLayout
4210 {
4211 	GdkWindow *binWindow;
4212 }
4213 
4214 
4215 /**
4216  * Main Gtk struct.
4217  */
4218 public struct GtkNotebook{}
4219 
4220 
4221 /**
4222  * Warning
4223  * GtkNotebookPage is deprecated and should not be used in newly-written code.
4224  * The GtkNotebookPage is an opaque implementation detail of GtkNotebook.
4225  */
4226 public struct GtkNotebookPage{}
4227 
4228 
4229 /**
4230  * Main Gtk struct.
4231  * The GtkTable structure holds the data for the actual table itself.
4232  * 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.
4233  * nrows and ncols are 16bit integers storing the number of rows and columns the table has.
4234  */
4235 public struct GtkTable{}
4236 
4237 
4238 /**
4239  * Main Gtk struct.
4240  */
4241 public struct GtkExpander{}
4242 
4243 
4244 /**
4245  * Main Gtk struct.
4246  */
4247 public struct GtkOrientable{}
4248 
4249 
4250 /**
4251  * Main Gtk struct.
4252  */
4253 public struct GtkFrame{}
4254 
4255 
4256 /**
4257  * Main Gtk struct.
4258  * The GtkHSeparator struct contains private data only, and
4259  * should be accessed using the functions below.
4260  */
4261 public struct GtkHSeparator{}
4262 
4263 
4264 /**
4265  * Main Gtk struct.
4266  * The GtkVSeparator struct contains private data only, and
4267  * should be accessed using the functions below.
4268  */
4269 public struct GtkVSeparator{}
4270 
4271 
4272 /**
4273  * Main Gtk struct.
4274  * The GtkHScrollbar struct contains private data and should be accessed
4275  * using the functions below.
4276  */
4277 public struct GtkHScrollbar{}
4278 
4279 
4280 /**
4281  * Main Gtk struct.
4282  * The GtkVScrollbar struct contains private data and should be accessed
4283  * using the functions below.
4284  */
4285 public struct GtkVScrollbar{}
4286 
4287 
4288 /**
4289  * Main Gtk struct.
4290  * There are no public fields in the GtkScrolledWindow struct; it should
4291  * only be accessed using the functions below.
4292  */
4293 public struct GtkScrolledWindow
4294 {
4295 	GtkWidget *hscrollbar;
4296 	GtkWidget *vscrollbar;
4297 }
4298 
4299 
4300 /**
4301  * Main Gtk struct.
4302  */
4303 public struct GtkPrintOperation{}
4304 
4305 
4306 public struct GtkPrintOperationPreview{}
4307 
4308 
4309 /**
4310  * Main Gtk struct.
4311  */
4312 public struct GtkPrintContext{}
4313 
4314 
4315 /**
4316  * Main Gtk struct.
4317  */
4318 public struct GtkPrintSettings{}
4319 
4320 
4321 public struct GtkPageRange
4322 {
4323 	int start;
4324 	int end;
4325 }
4326 
4327 
4328 /**
4329  * Main Gtk struct.
4330  */
4331 public struct GtkPageSetup{}
4332 
4333 
4334 /**
4335  * Main Gtk struct.
4336  */
4337 public struct GtkPaperSize{}
4338 
4339 
4340 /**
4341  * Main Gtk struct.
4342  */
4343 public struct GtkPrinter{}
4344 
4345 
4346 public struct GtkPrintBackend{}
4347 
4348 
4349 /**
4350  * Main Gtk struct.
4351  * The GtkPrintJob struct contains only private members
4352  * and should not be directly accessed.
4353  */
4354 public struct GtkPrintJob{}
4355 
4356 
4357 /**
4358  * Main Gtk struct.
4359  */
4360 public struct GtkPrintUnixDialog{}
4361 
4362 
4363 /**
4364  * Main Gtk struct.
4365  */
4366 public struct GtkPageSetupUnixDialog{}
4367 
4368 
4369 /**
4370  * Main Gtk struct.
4371  * The GtkAdjustment struct contains the following fields.
4372  * gdouble lower;
4373  * the minimum value.
4374  * gdouble upper;
4375  * the maximum value.
4376  * gdouble value;
4377  * the current value.
4378  * gdouble step_increment;
4379  * the increment to use to make minor changes to the value.
4380  * In a GtkScrollbar this increment is used when the mouse is clicked on the
4381  * arrows at the top and bottom of the scrollbar, to scroll by a small amount.
4382  * gdouble page_increment;
4383  * the increment to use to make major changes to the value.
4384  * In a GtkScrollbar this increment is used when the mouse is clicked in the
4385  * trough, to scroll by a large amount.
4386  * gdouble page_size;
4387  * the page size.
4388  * In a GtkScrollbar this is the size of the area which is currently visible.
4389  */
4390 public struct GtkAdjustment{}
4391 
4392 
4393 /**
4394  * Main Gtk struct.
4395  */
4396 public struct GtkArrow{}
4397 
4398 
4399 /**
4400  * Main Gtk struct.
4401  * num_marked_dates is an integer containing the
4402  * number of days that have a mark over them.
4403  * marked_date is an array containing the day numbers
4404  * that currently have a mark over them.
4405  * month, year, and
4406  * selected_day contain the currently visible month,
4407  * year, and selected day respectively.
4408  * All of these fields should be considered read only, and everything in this
4409  * struct should only be modified using the functions provided below.
4410  * Note
4411  * Note that month is zero-based (i.e it allowed values
4412  * are 0-11) while selected_day is one-based
4413  * (i.e. allowed values are 1-31).
4414  */
4415 public struct GtkCalendar{}
4416 
4417 
4418 /**
4419  * Main Gtk struct.
4420  * The GtkDrawingArea struct contains private data only, and
4421  * should be accessed using the functions below.
4422  */
4423 public struct GtkDrawingArea{}
4424 
4425 
4426 /**
4427  * Main Gtk struct.
4428  * The GtkEventBox struct contains private data only, and
4429  * should be accessed using the functions below.
4430  */
4431 public struct GtkEventBox{}
4432 
4433 
4434 /**
4435  * Main Gtk struct.
4436  * The GtkHandleBox struct contains the following fields.
4437  * (These fields should be considered read-only. They should never be set by
4438  * an application.)
4439  * GtkShadowType shadow_type;
4440  * The shadow type for the entry. (See gtk_handle_box_set_shadow_type()).
4441  * GtkPositionType handle_position;
4442  * The position of the handlebox's handle with respect
4443  * to the child. (See gtk_handle_box_set_handle_position())
4444  * gint snap_edge;
4445  * A value of type GtkPosition type indicating snap edge for the widget.
4446  * (See gtk_handle_box_set_snap_edge). The value of -1 indicates
4447  * that this value has not been set.
4448  * gboolean child_detached;
4449  * A boolean value indicating whether the handlebox's
4450  * child is attached or detached.
4451  */
4452 public struct GtkHandleBox{}
4453 
4454 
4455 /**
4456  * Main Gtk struct.
4457  */
4458 public struct GtkIMContextSimple{}
4459 
4460 
4461 /**
4462  * Main Gtk struct.
4463  */
4464 public struct GtkIMMulticontext{}
4465 
4466 
4467 /**
4468  * Main Gtk struct.
4469  */
4470 public struct GtkSizeGroup{}
4471 
4472 
4473 /**
4474  * Main Gtk struct.
4475  */
4476 public struct GtkTooltip{}
4477 
4478 
4479 /**
4480  * Main Gtk struct.
4481  */
4482 public struct GtkViewport{}
4483 
4484 
4485 /**
4486  * Main Gtk struct.
4487  */
4488 public struct GtkAccessible{}
4489 
4490 
4491 /**
4492  * Main Gtk struct.
4493  */
4494 public struct GtkBin{}
4495 
4496 
4497 /**
4498  * Main Gtk struct.
4499  * The GtkBox describes an instance of GtkBox and contains the
4500  * following fields. (These fields should be considered read-only.
4501  * They should never be set by an application.)
4502  */
4503 public struct GtkBox
4504 {
4505 	GList *children;
4506 	short spacing;
4507 	uint bitfield0;
4508 	//uint homogeneous : 1;
4509 }
4510 
4511 
4512 /**
4513  * Warning
4514  * GtkBoxChild has been deprecated since version 2.22 and should not be used in newly-written code. Use gtk_container_get_children() instead.
4515  * The GtkBoxChild holds a child widget of GtkBox and describes how the child
4516  * is to be packed into the GtkBox. All fields of this GtkBoxChild should be
4517  * considered read-only and they should never be set directly by an application.
4518  * Use gtk_box_query_child_packing() and gtk_box_set_child_packing() to query
4519  * and set the GtkBoxChild.padding, GtkBoxChild.expand, GtkBoxChild.fill and
4520  * GtkBoxChild.pack fields.
4521  * The GtkBoxChild holds a child widget of GtkBox and describes
4522  * how the child is to be packed into the GtkBox. Use
4523  * gtk_box_query_child_packing() and gtk_box_set_child_packing() to query
4524  * and reset the padding,
4525  * expand, fill,
4526  * and pack fields.
4527  * GtkBoxChild contains the following fields. (These fields
4528  * should be considered read-only. They should never be directly set by an
4529  * application.)
4530  * GtkWidget *widget;
4531  * the child widget, packed into the GtkBox.
4532  * guint16 padding;
4533  * the number of extra pixels to put between this child and its
4534  * neighbors, set when packed, zero by default.
4535  * guint expand : 1;
4536  * flag indicates whether extra space should be given to this child.
4537  * Any extra space given to the parent GtkBox is divided up among all children
4538  * with this attribute set to TRUE; set when packed, TRUE by default.
4539  * guint fill : 1;
4540  * flag indicates whether any extra space given to this child due to its
4541  * expand attribute being set is actually allocated to the child, rather than
4542  * being used as padding around the widget; set when packed, TRUE by default.
4543  * guint pack : 1;
4544  * one of GtkPackType indicating whether the child is packed with
4545  * reference to the start (top/left) or end (bottom/right) of the GtkBox.
4546  * guint is_secondary : 1;
4547  * TRUE if the child is secondary
4548  */
4549 public struct GtkBoxChild
4550 {
4551 	GtkWidget *widget;
4552 	ushort padding;
4553 	uint bitfield0;
4554 	//uint expand : 1;
4555 	//uint fill : 1;
4556 	//uint pack : 1;
4557 	//uint isSecondary : 1;
4558 }
4559 
4560 
4561 /**
4562  * Main Gtk struct.
4563  * This is a read-only struct; no members should be modified directly.
4564  */
4565 public struct GtkButtonBox{}
4566 
4567 
4568 /**
4569  * Main Gtk struct.
4570  */
4571 public struct GtkContainer{}
4572 
4573 
4574 /**
4575  * Main Gtk struct.
4576  * The GtkItem struct contains private data only, and
4577  * should be accessed using the functions below.
4578  */
4579 public struct GtkItem{}
4580 
4581 
4582 /**
4583  * Main Gtk struct.
4584  * The GtkMenuShell struct contains the following fields.
4585  * (These fields should be considered read-only. They should never be set by
4586  * an application.)
4587  * GList *children;
4588  * The list of GtkMenuItem objects contained by this GtkMenuShell.
4589  */
4590 public struct GtkMenuShell{}
4591 
4592 
4593 /**
4594  * Main Gtk struct.
4595  * The GtkMisc struct contains the following fields.
4596  * (These fields should be considered read-only. They should never be set by
4597  * an application.)
4598  * gfloat xalign;
4599  * the horizontal alignment, from 0 (left) to 1 (right).
4600  * gfloat yalign;
4601  * the vertical alignment, from 0 (top) to 1 (bottom).
4602  * guint16 xpad;
4603  * the amount of space to add on the left and right of the widget,
4604  * in pixels.
4605  * guint16 ypad;
4606  * the amount of space to add on the top and bottom of the widget,
4607  * in pixels.
4608  */
4609 public struct GtkMisc{}
4610 
4611 
4612 /**
4613  * Main Gtk struct.
4614  * The object itself. You should never use these members directly -
4615  */
4616 public struct GtkObject{}
4617 
4618 
4619 /**
4620  * Main Gtk struct.
4621  */
4622 public struct GtkPaned{}
4623 
4624 
4625 /**
4626  * Main Gtk struct.
4627  */
4628 public struct GtkRange{}
4629 
4630 
4631 /**
4632  * Main Gtk struct.
4633  * The fields of the GtkScale struct should only be accessed via
4634  * the accessor functions.
4635  */
4636 public struct GtkScale{}
4637 
4638 
4639 /**
4640  * Main Gtk struct.
4641  * The GtkScrollbar struct does not contain any public data.
4642  * Style Property Details
4643  * The "fixed-slider-length" style property
4644  */
4645 public struct GtkScrollbar{}
4646 
4647 
4648 /**
4649  * Main Gtk struct.
4650  * The GtkSeparator struct contains private data only.
4651  */
4652 public struct GtkSeparator{}
4653 
4654 
4655 /**
4656  * Main Gtk struct.
4657  */
4658 public struct GtkWidget
4659 {
4660 	/+* The style for the widget. The style contains the
4661 	 * colors the widget should be drawn inn for each state
4662 	 * along with graphics contexts used to draw with and
4663 	 * the font to use for text.
4664 	+/
4665 	GtkStyle *style;
4666 	/+* The widget's desired size.
4667 	+/
4668 	GtkRequisition requisition;
4669 	/+* The widget's allocated size.
4670 	+/
4671 	GtkAllocation allocation;
4672 	/+* The widget's window or its parent window if it does
4673 	 * not have a window. (Which will be indicated by the
4674 	 * GTK_NO_WINDOW flag being set).
4675 	+/
4676 	GdkWindow *window;
4677 	/+* The widget's parent.
4678 	+/
4679 	GtkWidget *parent;
4680 }
4681 
4682 
4683 /**
4684  * A GtkRequisition represents the desired size of a widget. See
4685  * the section called “Size Requisition” for more information.
4686  * gint width;
4687  * the widget's desired width
4688  * gint height;
4689  * the widget's desired height
4690  */
4691 public struct GtkRequisition
4692 {
4693 	int width;
4694 	int height;
4695 }
4696 
4697 
4698 /**
4699  * A GtkAllocation of a widget represents region which has been allocated to the
4700  * widget by its parent. It is a subregion of its parents allocation. See
4701  * the section called “Size Allocation” for more information.
4702  * gint x;
4703  * the X position of the widget's area relative to its parents allocation.
4704  * gint y;
4705  * the Y position of the widget's area relative to its parents allocation.
4706  * gint width;
4707  * the width of the widget's allocated area.
4708  * gint height;
4709  * the height of the widget's allocated area.
4710  */
4711 public struct GtkAllocation
4712 {
4713 	int x;
4714 	int y;
4715 	int width;
4716 	int height;
4717 }
4718 
4719 
4720 public struct GtkSelectionData
4721 {
4722 	GdkAtom selection;
4723 	GdkAtom target;
4724 	GdkAtom type;
4725 	int format;
4726 	char *data;
4727 	int length;
4728 	GdkDisplay *display;
4729 }
4730 
4731 
4732 public struct GtkWidgetAuxInfo
4733 {
4734 	int x;
4735 	int y;
4736 	int width;
4737 	int height;
4738 	uint bitfield0;
4739 	//uint xSet : 1;
4740 	//uint ySet : 1;
4741 }
4742 
4743 
4744 public struct GtkWidgetShapeInfo
4745 {
4746 	short offsetX;
4747 	short offsetY;
4748 	GdkBitmap *shapeMask;
4749 }
4750 
4751 
4752 /**
4753  * Main Gtk struct.
4754  */
4755 public struct GtkIMContext{}
4756 
4757 
4758 /**
4759  * preedit_start ()
4760  * Default handler of the "preedit-start" signal.
4761  * preedit_end ()
4762  * Default handler of the "preedit-end" signal.
4763  * preedit_changed ()
4764  * Default handler of the "preedit-changed"
4765  * signal.
4766  * commit ()
4767  * Default handler of the "commit" signal.
4768  * retrieve_surrounding ()
4769  * Default handler of the
4770  * "retrieve-surrounding" signal.
4771  * delete_surrounding ()
4772  * Default handler of the
4773  * "delete-surrounding" signal.
4774  * set_client_window ()
4775  * Called via gtk_im_context_set_client_window() when the
4776  * input window where the entered text will appear changes. Override this to
4777  * keep track of the current input window, for instance for the purpose of
4778  * positioning a status display of your input method.
4779  * get_preedit_string ()
4780  * Called via gtk_im_context_get_preedit_string() to
4781  * retrieve the text currently being preedited for display at the cursor
4782  * position. Any input method which composes complex characters or any
4783  * other compositions from multiple sequential key presses should override
4784  * this method to provide feedback.
4785  * filter_keypress ()
4786  * Called via gtk_im_context_filter_keypress() on every
4787  * key press or release event. Every non-trivial input method needs to
4788  * override this in order to implement the mapping from key events to text.
4789  * A return value of TRUE indicates to the caller that the event was
4790  * consumed by the input method. In that case, the "commit"
4791  * signal should be emitted upon completion of a key sequence to pass the
4792  * resulting text back to the input widget. Alternatively, FALSE may be
4793  * returned to indicate that the event wasn't handled by the input method.
4794  * If a builtin mapping exists for the key, it is used to produce a
4795  * character.
4796  * focus_in ()
4797  * Called via gtk_im_context_focus_in() when the input widget
4798  * has gained focus. May be overridden to keep track of the current focus.
4799  * focus_out ()
4800  * Called via gtk_im_context_focus_in() when the input widget
4801  * has lost focus. May be overridden to keep track of the current focus.
4802  * reset ()
4803  * Called via gtk_im_context_reset() to signal a change such as a
4804  * change in cursor position. An input method that implements preediting
4805  * should override this method to clear the preedit state on reset.
4806  * set_cursor_location ()
4807  * Called via gtk_im_context_set_cursor_location()
4808  * to inform the input method of the current cursor location relative to
4809  * the client window. May be overridden to implement the display of popup
4810  * windows at the cursor position.
4811  * set_use_preedit ()
4812  * Called via gtk_im_context_set_use_preedit() to control
4813  * the use of the preedit string. Override this to display feedback by some
4814  * other means if turned off.
4815  * set_surrounding ()
4816  * Called via gtk_im_context_set_surrounding() in response
4817  * to signal "retrieve-surrounding" to update the input
4818  * method's idea of the context around the cursor. It is not necessary to
4819  * override this method even with input methods which implement
4820  * context-dependent behavior. The base implementation is sufficient for
4821  * gtk_im_context_get_surrounding() to work.
4822  * get_surrounding ()
4823  * Called via gtk_im_context_get_surrounding() to update
4824  * the context around the cursor location. It is not necessary to override
4825  * this method even with input methods which implement context-dependent
4826  * behavior. The base implementation emits
4827  * "retrieve-surrounding" and records the context received
4828  * by the subsequent invocation of get_surrounding.
4829  */
4830 public struct GtkIMContextClass
4831 {
4832 	/+* Signals +/
4833 	extern(C) void function(GtkIMContext* context) preeditStart;
4834 	extern(C) void function(GtkIMContext* context) preeditEnd;
4835 	extern(C) void function(GtkIMContext* context) preeditChanged;
4836 	extern(C) void function(GtkIMContext* context, char* str) commit;
4837 	extern(C) int function(GtkIMContext* context) retrieveSurrounding;
4838 	extern(C) int function(GtkIMContext* context, int offset, int nChars) deleteSurrounding;
4839 	/+* Virtual functions +/
4840 	extern(C) void function(GtkIMContext* context, GdkWindow* window) setClientWindow;
4841 	extern(C) void function(GtkIMContext* context, char** str, PangoAttrList** attrs, int* cursorPos) getPreeditString;
4842 	extern(C) int function(GtkIMContext* context, GdkEventKey* event) filterKeypress;
4843 	extern(C) void function(GtkIMContext* context) focusIn;
4844 	extern(C) void function(GtkIMContext* context) focusOut;
4845 	extern(C) void function(GtkIMContext* context) reset;
4846 	extern(C) void function(GtkIMContext* context, GdkRectangle* area) setCursorLocation;
4847 	extern(C) void function(GtkIMContext* context, int usePreedit) setUsePreedit;
4848 	extern(C) void function(GtkIMContext* context, char* text, int len, int cursorIndex) setSurrounding;
4849 	extern(C) int function(GtkIMContext* context, char** text, int* cursorIndex) getSurrounding;
4850 }
4851 
4852 
4853 /**
4854  * Bookkeeping information about a loadable input method.
4855  * const gchar *context_id;
4856  * The unique identification string of the input method.
4857  * const gchar *context_name;
4858  * The human-readable name of the input method.
4859  * const gchar *domain;
4860  * Translation domain to be used with dgettext()
4861  * const gchar *domain_dirname;
4862  * Name of locale directory for use with bindtextdomain()
4863  * const gchar *default_locales;
4864  * A colon-separated list of locales where this input method
4865  * should be the default. The asterisk "*" sets the default for all locales.
4866  */
4867 public struct GtkIMContextInfo
4868 {
4869 	char *contextId;
4870 	char *contextName;
4871 	char *domain;
4872 	char *domainDirname;
4873 	char *defaultLocales;
4874 }
4875 
4876 
4877 /**
4878  * Main Gtk struct.
4879  */
4880 public struct GtkPlug{}
4881 
4882 
4883 /**
4884  * Main Gtk struct.
4885  */
4886 public struct GtkSocket{}
4887 
4888 
4889 /**
4890  * Main Gtk struct.
4891  * Warning
4892  * GtkCurve is deprecated and should not be used in newly-written code.
4893  * The GtkCurve struct contains private data only, and
4894  * should be accessed using the functions below.
4895  */
4896 public struct GtkCurve{}
4897 
4898 
4899 /**
4900  * Main Gtk struct.
4901  * Warning
4902  * GtkGammaCurve is deprecated and should not be used in newly-written code.
4903  * The GtkGammaCurve struct contains private data only, and
4904  * should be accessed using the functions below.
4905  */
4906 public struct GtkGammaCurve{}
4907 
4908 
4909 /**
4910  * Main Gtk struct.
4911  * Warning
4912  * GtkRuler is deprecated and should not be used in newly-written code.
4913  * All distances are in 1/72nd's of an inch. (According to Adobe thats a point, but
4914  * points are really 1/72.27 in.)
4915  */
4916 public struct GtkRuler{}
4917 
4918 
4919 /**
4920  * Warning
4921  * GtkRulerMetric has been deprecated since version 2.24 and should not be used in newly-written code. GtkRuler has been removed from GTK 3 for being
4922  */
4923 public struct GtkRulerMetric
4924 {
4925 	char *metricName;
4926 	char *abbrev;
4927 	/+* This should be pointsPerUnit. This is the size of the unit
4928 	 * inn 1/72nd's of an inch and has nothing to do with screen pixels +/
4929 	double pixelsPerUnit;
4930 	double[10] rulerScale;
4931 	int[5] subdivide; /+* five possible modes of subdivision +/
4932 }
4933 
4934 
4935 /**
4936  * Main Gtk struct.
4937  * Warning
4938  * GtkHRuler is deprecated and should not be used in newly-written code.
4939  * The GtkHRuler struct contains private data and should be accessed
4940  * with the functions below.
4941  */
4942 public struct GtkHRuler{}
4943 
4944 
4945 /**
4946  * Main Gtk struct.
4947  * Warning
4948  * GtkVRuler is deprecated and should not be used in newly-written code.
4949  */
4950 public struct GtkVRuler{}
4951 
4952 
4953 /**
4954  * Main Gtk struct.
4955  * Acts as a database of information about the list of recently
4956  * used files. Normally, you retrieve the recent manager for a
4957  * particular screen using gtk_recent_manager_get_for_screen()
4958  * and it will contain information about current recent manager
4959  * for that screen.
4960  */
4961 public struct GtkRecentManager{}
4962 
4963 
4964 /**
4965  * Contains informations found when looking up an entry of the
4966  * recently used files list.
4967  */
4968 public struct GtkRecentInfo{}
4969 
4970 
4971 /**
4972  * Meta-data to be passed to gtk_recent_manager_add_full() when
4973  * registering a recently used resource.
4974  * gchar *display_name;
4975  * a UTF-8 encoded string, containing the name of the recently
4976  * used resource to be displayed, or NULL;
4977  * gchar *description;
4978  * a UTF-8 encoded string, containing a short description of
4979  * the resource, or NULL;
4980  * gchar *mime_type;
4981  * the MIME type of the resource;
4982  * gchar *app_name;
4983  * the name of the application that is registering this recently
4984  * used resource;
4985  * gchar *app_exec;
4986  * command line used to launch this resource; may contain the
4987  * "%f" and "%u" escape characters which will be expanded
4988  * to the resource file path and URI respectively when the command line
4989  * is retrieved;
4990  * gchar **groups;
4991  * a vector of strings containing groups names;
4992  * gboolean is_private;
4993  * whether this resource should be displayed only by the
4994  * applications that have registered it or not.
4995  */
4996 public struct GtkRecentData
4997 {
4998 	char *displayName;
4999 	char *description;
5000 	char *mimeType;
5001 	char *appName;
5002 	char *appExec;
5003 	char **groups;
5004 	int isPrivate;
5005 }
5006 
5007 
5008 /**
5009  * Main Gtk struct.
5010  */
5011 public struct GtkRecentChooser{}
5012 
5013 
5014 public struct GtkRecentChooserIface
5015 {
5016 	GTypeInterface baseIface;
5017 	/+*
5018 	 * Methods
5019 	+/
5020 	extern(C) int function(GtkRecentChooser* chooser, char* uri, GError** error)  setCurrentUri;
5021 	extern(C) char * function(GtkRecentChooser* chooser)  getCurrentUri;
5022 	extern(C) int function(GtkRecentChooser* chooser, char* uri, GError** error)  selectUri;
5023 	extern(C) void function(GtkRecentChooser* chooser, char* uri)  unselectUri;
5024 	extern(C) void function(GtkRecentChooser* chooser)  selectAll;
5025 	extern(C) void function(GtkRecentChooser* chooser)  unselectAll;
5026 	extern(C) GList * function(GtkRecentChooser* chooser)  getItems;
5027 	extern(C) GtkRecentManager * function(GtkRecentChooser* chooser)  getRecentManager;
5028 	extern(C) void function(GtkRecentChooser* chooser, GtkRecentFilter* filter)  addFilter;
5029 	extern(C) void function(GtkRecentChooser* chooser, GtkRecentFilter* filter)  removeFilter;
5030 	extern(C) GSList * function(GtkRecentChooser* chooser)  listFilters;
5031 	extern(C) void function(GtkRecentChooser* chooser, GtkRecentSortFunc sortFunc, void* data, GDestroyNotify destroy)  setSortFunc;
5032 	/+*
5033 	 * Signals
5034 	+/
5035 	extern(C) void function(GtkRecentChooser* chooser)  itemActivated;
5036 	extern(C) void function(GtkRecentChooser* chooser)  selectionChanged;
5037 }
5038 
5039 
5040 /**
5041  * Main Gtk struct.
5042  */
5043 public struct GtkRecentChooserDialog{}
5044 
5045 
5046 /**
5047  * Main Gtk struct.
5048  */
5049 public struct GtkRecentChooserMenu{}
5050 
5051 
5052 /**
5053  * Main Gtk struct.
5054  */
5055 public struct GtkRecentChooserWidget{}
5056 
5057 
5058 /**
5059  * Main Gtk struct.
5060  * The GtkRecentFilter struct contains
5061  * only private fields and should not be directly accessed.
5062  */
5063 public struct GtkRecentFilter{}
5064 
5065 
5066 /**
5067  * A GtkRecentFilterInfo struct is used
5068  * to pass information about the tested file to gtk_recent_filter_filter().
5069  * GtkRecentFilterFlags contains;
5070  * Flags indicating which of the following fields need
5071  * are filled
5072  * const gchar *uri;
5073  * the URI of the file being tested
5074  * const gchar *display_name;
5075  * the string that will be used to display the file
5076  * in the recent chooser
5077  * const gchar *mime_type;
5078  * the mime type of the file
5079  * const gchar **applications;
5080  * the list of applications that have registered the file
5081  * const gchar **groups;
5082  * the groups to which the file belongs to
5083  * gint age;
5084  * the number of days elapsed since the file has been registered
5085  */
5086 public struct GtkRecentFilterInfo
5087 {
5088 	GtkRecentFilterFlags contains;
5089 	char *uri;
5090 	char *displayName;
5091 	char *mimeType;
5092 	char **applications;
5093 	char **groups;
5094 	int age;
5095 }
5096 
5097 
5098 /**
5099  * Main Gtk struct.
5100  */
5101 public struct GtkBuildable{}
5102 
5103 
5104 /**
5105  * The GtkBuildableIface interface contains method that are
5106  * necessary to allow GtkBuilder to construct an object from
5107  * a GtkBuilder UI definition.
5108  * GTypeInterface g_iface;
5109  * the parent class
5110  * set_name ()
5111  * Stores the name attribute given in the GtkBuilder UI definition.
5112  * GtkWidget stores the name as object data. Implement this method if your
5113  * object has some notion of "name" and it makes sense to map the XML name
5114  * attribute to it.
5115  * get_name ()
5116  * The getter corresponding to set_name. Implement this
5117  * if you implement set_name.
5118  * add_child ()
5119  * Adds a child. The type parameter can be used to
5120  * differentiate the kind of child. GtkContainer implements this
5121  * to add add a child widget to the container, GtkNotebook uses
5122  * the type to distinguish between page labels (of type "page-label")
5123  * and normal children.
5124  * set_buildable_property ()
5125  * Sets a property of a buildable object.
5126  * It is normally not necessary to implement this, g_object_set_property()
5127  * is used by default. GtkWindow implements this to delay showing itself
5128  * (i.e. setting the "visible" property) until the whole interface
5129  * is created.
5130  * construct_child ()
5131  * Constructs a child of a buildable that has been
5132  * specified as "constructor" in the UI definition. GtkUIManager implements
5133  * this to reference to a widget created in a <ui> tag which is outside
5134  * of the normal GtkBuilder UI definition hierarchy. A reference to the
5135  * constructed object is returned and becomes owned by the caller.
5136  * custom_tag_start ()
5137  * Implement this if the buildable needs to parse
5138  * content below <child>. To handle an element, the implementation
5139  * must fill in the parser structure and user_data and return TRUE.
5140  * GtkWidget implements this to parse keyboard accelerators specified
5141  * in <accelerator> elements. GtkContainer implements it to map
5142  * properties defined via <packing> elements to child properties.
5143  * Note that user_data must be freed in custom_tag_end or custom_finished.
5144  * custom_tag_end ()
5145  * Called for the end tag of each custom element that is
5146  * handled by the buildable (see custom_tag_start).
5147  * custom_finished ()
5148  * Called for each custom tag handled by the buildable
5149  * when the builder finishes parsing (see custom_tag_start)
5150  * parser_finished ()
5151  * Called when a builder finishes the parsing
5152  * of a UI definition. It is normally not necessary to implement this,
5153  * unless you need to perform special cleanup actions. GtkWindow sets
5154  * the "visible" property here.
5155  * get_internal_child ()
5156  * Returns an internal child of a buildable.
5157  * GtkDialog implements this to give access to its vbox, making
5158  * it possible to add children to the vbox in a UI definition.
5159  * Implement this if the buildable has internal children that may
5160  * need to be accessed from a UI definition.
5161  */
5162 public struct GtkBuildableIface
5163 {
5164 	GTypeInterface gIface;
5165 	/+* virtua table +/
5166 	extern(C) void function(GtkBuildable* buildable, char* name)  setName;
5167 	extern(C) char * function(GtkBuildable* buildable)  getName;
5168 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, char* type)  addChild;
5169 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, char* name, GValue* value)  setBuildableProperty;
5170 	extern(C) GObject * function(GtkBuildable* buildable, GtkBuilder* builder, char* name)  constructChild;
5171 	extern(C) int function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, char* tagname, GMarkupParser* parser, void** data)  customTagStart;
5172 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, char* tagname, void** data)  customTagEnd;
5173 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, char* tagname, void* data)  customFinished;
5174 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder)  parserFinished;
5175 	extern(C) GObject * function(GtkBuildable* buildable, GtkBuilder* builder, char* childname)  getInternalChild;
5176 }
5177 
5178 
5179 /**
5180  * Main Gtk struct.
5181  */
5182 public struct GtkBuilder{}
5183 
5184 
5185 /**
5186  * Main Gtk struct.
5187  * Warning
5188  * GtkFileSelection is deprecated and should not be used in newly-written code.
5189  * The GtkFileSelection struct contains the following GtkWidget fields:
5190  * GtkWidget *dir_list;
5191  * GtkWidget *file_list;
5192  * GtkWidget *selection_entry;
5193  * GtkWidget *selection_text;
5194  * GtkWidget *main_vbox;
5195  * GtkWidget *ok_button;
5196  * GtkWidget *cancel_button;
5197  * the two main buttons that signals should be connected
5198  */
5199 public struct GtkFileSelection
5200 {
5201 	GtkWidget *dirList;
5202 	GtkWidget *fileList;
5203 	GtkWidget *selectionEntry;
5204 	GtkWidget *selectionText;
5205 	GtkWidget *mainVbox;
5206 	GtkWidget *okButton;
5207 	GtkWidget *cancelButton;
5208 	GtkWidget *helpButton;
5209 	GtkWidget *historyPulldown;
5210 	GtkWidget *historyMenu;
5211 	GList *historyList;
5212 	GtkWidget *fileopDialog;
5213 	GtkWidget *fileopEntry;
5214 	char *fileopFile;
5215 	void* cmplState;
5216 	GtkWidget *fileopCDir;
5217 	GtkWidget *fileopDelFile;
5218 	GtkWidget *fileopRenFile;
5219 	GtkWidget *buttonArea;
5220 	GtkWidget *actionArea;
5221 }
5222 
5223 
5224 /**
5225  * Main Gtk struct.
5226  * Warning
5227  * GtkItemFactory is deprecated and should not be used in newly-written code.
5228  */
5229 public struct GtkItemFactory{}
5230 
5231 
5232 /**
5233  * Warning
5234  * GtkItemFactoryEntry is deprecated and should not be used in newly-written code.
5235  */
5236 public struct GtkItemFactoryEntry
5237 {
5238 	char *path;
5239 	char *accelerator;
5240 	GtkItemFactoryCallback callback;
5241 	uint callbackAction;
5242 	/+* possible values:
5243 	 * NULL -> "<Item>"
5244 	 * "" -> "<Item>"
5245 	 * "<Title>" -> create a title item
5246 	 * "<Item>" -> create a simple item
5247 	 * "<ImageItem>" -> create an item holding an image
5248 	 * "<StockItem>" -> create an item holding a stock image
5249 	 * "<CheckItem>" -> create a check item
5250 	 * "<ToggleItem>" -> create a toggle item
5251 	 * "<RadioItem>" -> create a radio item
5252 	 * <path> -> path of a radio item to link against
5253 	 * "<Separator>" -> create a separator
5254 	 * "<Tearoff>" -> create a tearoff separator
5255 	 * "<Branch>" -> create an item to hold sub items
5256 	 * "<LastBranch>" -> create a right justified item to hold sub items
5257 	+/
5258 	char *itemType;
5259 	/+* Extra data for some item types:
5260 	 * ImageItem -> pointer to inlined pixbuf stream
5261 	 * StockItem -> name of stock item
5262 	+/
5263 	void* extraData;
5264 }
5265 
5266 
5267 /**
5268  * Warning
5269  * GtkItemFactoryItem is deprecated and should not be used in newly-written code.
5270  */
5271 public struct GtkItemFactoryItem
5272 {
5273 	char *path;
5274 	GSList *widgets;
5275 }
5276 
5277 
5278 /**
5279  * Main Gtk struct.
5280  * Warning
5281  * GtkTooltips is deprecated and should not be used in newly-written code.
5282  * Holds information about a group of tooltips. Fields should be changed using the functions provided, rather than directly accessing the struct's members.
5283  */
5284 public struct GtkTooltips{}
5285 
5286 
5287 /**
5288  * Warning
5289  * GtkTooltipsData has been deprecated since version 2.12 and should not be used in newly-written code.
5290  * 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.
5291  * 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?)
5292  */
5293 public struct GtkTooltipsData
5294 {
5295 	GtkTooltips *tooltips;
5296 	GtkWidget *widget;
5297 	char *tipText;
5298 	char *tipPrivate;
5299 }
5300 
5301 
5302 /**
5303  * Main Gtk struct.
5304  * The GtkProgress struct contains private data only.
5305  * and should be accessed using the functions below.
5306  */
5307 public struct GtkProgress{}
5308 
5309 
5310 /*
5311  * Returns whether the style is attached to a window.
5312  * style :
5313  * a GtkStyle.
5314  */
5315 // TODO
5316 // #define GTK_STYLE_ATTACHED(style) (GTK_STYLE (style)->attach_count > 0)
5317 
5318 /*
5319  * Warning
5320  * gtk_style_apply_default_pixmap is deprecated and should not be used in newly-written code. Use gtk_style_apply_default_background() instead.
5321  * Does the same as gtk_style_apply_default_background().
5322  */
5323 // TODO
5324 // #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)
5325 
5326 /*
5327  * Returns TRUE if the version of the GTK+ header files is the same
5328  * as or newer than the passed-in version.
5329  * major :
5330  * major version (e.g. 1 for version 1.2.5)
5331  * minor :
5332  * minor version (e.g. 2 for version 1.2.5)
5333  * micro :
5334  * micro version (e.g. 5 for version 1.2.5)
5335  */
5336 // TODO
5337 // #define GTK_CHECK_VERSION(major,minor,micro)
5338 
5339 /*
5340  * Warning
5341  * gtk_signal_lookup is deprecated and should not be used in newly-written code. Use g_signal_lookup() instead.
5342  * Given the name of the signal and the type of object it connects
5343  * to, get the signal's identifying integer. Emitting the signal
5344  * by number is somewhat faster than using the name each time.
5345  * It also tries the ancestors of the given type.
5346  * name :
5347  * the signal's name, e.g. clicked.
5348  * object_type :
5349  * the type that the signal operates on, e.g. GTK_TYPE_BUTTON.
5350  * Returns :
5351  * the signal's identifying number, or 0 if no signal was found.
5352  */
5353 // TODO
5354 // #define gtk_signal_lookup(name,object_type)
5355 
5356 /*
5357  * Warning
5358  * gtk_signal_name is deprecated and should not be used in newly-written code. Use g_signal_name() instead.
5359  * Given the signal's identifier, finds its name.
5360  * Two different signals may have the same name, if they have differing types.
5361  * signal_id :
5362  * the signal's identifying number.
5363  * Returns :
5364  * the signal name, or NULL if the signal number was invalid.
5365  */
5366 // TODO
5367 // #define gtk_signal_name(signal_id)
5368 
5369 /*
5370  * Warning
5371  * gtk_signal_emit_stop is deprecated and should not be used in newly-written code. Use g_signal_stop_emission() instead.
5372  * This function aborts a signal's current emission.
5373  * It will prevent the default method from running,
5374  * if the signal was GTK_RUN_LAST and you connected
5375  * normally (i.e. without the "after" flag).
5376  * It will print a warning if used on a signal which
5377  * isn't being emitted.
5378  * object :
5379  * the object whose signal handlers you wish to stop.
5380  * signal_id :
5381  * the signal identifier, as returned by g_signal_lookup().
5382  */
5383 // TODO
5384 // #define gtk_signal_emit_stop(object,signal_id)
5385 
5386 /*
5387  * Warning
5388  * gtk_signal_connect is deprecated and should not be used in newly-written code. Use g_signal_connect() instead.
5389  * Attaches a function pointer and user data to a signal for
5390  * a particular object.
5391  * The GtkSignalFunction takes a GtkObject as its first parameter.
5392  * It will be the same object as the one you're connecting
5393  * the hook to. The func_data will be passed as the last parameter
5394  * to the hook.
5395  * All else being equal, signal handlers are invoked in the order
5396  * connected (see gtk_signal_emit() for the other details of
5397  * which order things are called in).
5398  * Here is how one passes an integer as user data,
5399  * for when you just want to specify a constant int
5400  * as parameter to your function:
5401  * $(DDOC_COMMENT example)
5402  * object :
5403  * the object associated with the signal, e.g. if a button
5404  * is getting pressed, this is that button.
5405  * name :
5406  * name of the signal.
5407  * func :
5408  * function pointer to attach to the signal.
5409  * func_data :
5410  * value to pass as to your function (through the marshaller).
5411  * Returns :
5412  * the connection id.
5413  */
5414 // TODO
5415 // #define gtk_signal_connect(object,name,func,func_data)
5416 
5417 /*
5418  * Warning
5419  * gtk_signal_connect_after is deprecated and should not be used in newly-written code. Use g_signal_connect_after() instead.
5420  * Attaches a function pointer and user data to a signal
5421  * so that this handler will be called after the other handlers.
5422  * object :
5423  * the object associated with the signal.
5424  * name :
5425  * name of the signal.
5426  * func :
5427  * function pointer to attach to the signal.
5428  * func_data :
5429  * value to pass as to your function (through the marshaller).
5430  * Returns :
5431  * the unique identifier for this attachment: the connection id.
5432  */
5433 // TODO
5434 // #define gtk_signal_connect_after(object,name,func,func_data)
5435 
5436 /*
5437  * Warning
5438  * gtk_signal_connect_object is deprecated and should not be used in newly-written code. Use g_signal_connect_swapped() instead.
5439  * This function is for registering a callback that will
5440  * call another object's callback. That is,
5441  * instead of passing the object which is responsible
5442  * for the event as the first parameter of the callback,
5443  * it is switched with the user data (so the object which emits
5444  * the signal will be the last parameter, which is where the
5445  * user data usually is).
5446  * This is useful for passing a standard function in as a callback.
5447  * For example, if you wanted a button's press to gtk_widget_show()
5448  * some widget, you could write:
5449  * $(DDOC_COMMENT example)
5450  * object :
5451  * the object which emits the signal.
5452  * name :
5453  * the name of the signal.
5454  * func :
5455  * the function to callback.
5456  * slot_object :
5457  * the object to pass as the first parameter to func.
5458  * (Though it pretends to take an object, you can
5459  * really pass any gpointer as the slot_object .)
5460  * Returns :
5461  * the connection id.
5462  */
5463 // TODO
5464 // #define gtk_signal_connect_object(object,name,func,slot_object)
5465 
5466 /*
5467  * Warning
5468  * gtk_signal_connect_object_after is deprecated and should not be used in newly-written code. Use g_signal_connect_data() instead, passing
5469  * G_CONNECT_AFTER|G_CONNECT_SWAPPED as connect_flags.
5470  * Attaches a signal hook to a signal, passing in an alternate
5471  * object as the first parameter, and guaranteeing
5472  * that the default handler and all normal
5473  * handlers are called first.
5474  * object :
5475  * the object associated with the signal.
5476  * name :
5477  * name of the signal.
5478  * func :
5479  * function pointer to attach to the signal.
5480  * slot_object :
5481  * the object to pass as the first parameter to func.
5482  * Returns :
5483  * the connection id.
5484  */
5485 // TODO
5486 // #define gtk_signal_connect_object_after(object,name,func,slot_object)
5487 
5488 /*
5489  * Warning
5490  * gtk_signal_disconnect is deprecated and should not be used in newly-written code. Use g_signal_handler_disconnect() instead.
5491  * Destroys a user-defined handler connection.
5492  * object :
5493  * the object which the handler pertains to.
5494  * handler_id :
5495  * the connection id.
5496  */
5497 // TODO
5498 // #define gtk_signal_disconnect(object,handler_id)
5499 
5500 /*
5501  * Warning
5502  * gtk_signal_disconnect_by_func is deprecated and should not be used in newly-written code. Use g_signal_handlers_disconnect_by_func() instead.
5503  * Destroys all connections for a particular object, with
5504  * the given function-pointer and user-data.
5505  * object :
5506  * the object which emits the signal.
5507  * func :
5508  * the function pointer to search for.
5509  * data :
5510  * the user data to search for.
5511  */
5512 // TODO
5513 // #define gtk_signal_disconnect_by_func(object,func,data)
5514 
5515 /*
5516  * Warning
5517  * gtk_signal_disconnect_by_data is deprecated and should not be used in newly-written code. Use g_signal_handlers_disconnect_matched() instead.
5518  * Destroys all connections for a particular object, with
5519  * the given user-data.
5520  * object :
5521  * the object which emits the signal.
5522  * data :
5523  * the user data to search for.
5524  */
5525 // TODO
5526 // #define gtk_signal_disconnect_by_data(object,data)
5527 
5528 /*
5529  * Warning
5530  * gtk_signal_handler_block is deprecated and should not be used in newly-written code. Use g_signal_handler_block() instead.
5531  * Prevents a user-defined handler from being invoked. All other
5532  * signal processing will go on as normal, but this particular
5533  * handler will ignore it.
5534  * object :
5535  * the object which emits the signal to block.
5536  * handler_id :
5537  * the connection id.
5538  */
5539 // TODO
5540 // #define gtk_signal_handler_block(object,handler_id)
5541 
5542 /*
5543  * Warning
5544  * 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.
5545  * Prevents a user-defined handler from being invoked, by reference to
5546  * the user-defined handler's function pointer and user data. (It may result in
5547  * multiple hooks being blocked, if you've called connect multiple times.)
5548  * object :
5549  * the object which emits the signal to block.
5550  * func :
5551  * the function pointer of the handler to block.
5552  * data :
5553  * the user data of the handler to block.
5554  */
5555 // TODO
5556 // #define gtk_signal_handler_block_by_func(object,func,data)
5557 
5558 /*
5559  * Warning
5560  * gtk_signal_handler_block_by_data is deprecated and should not be used in newly-written code. Use g_signal_handlers_block_matched() instead.
5561  * Prevents all user-defined handlers with a certain user data from being invoked.
5562  * object :
5563  * the object which emits the signal we want to block.
5564  * data :
5565  * the user data of the handlers to block.
5566  */
5567 // TODO
5568 // #define gtk_signal_handler_block_by_data(object,data)
5569 
5570 /*
5571  * Warning
5572  * gtk_signal_handler_unblock is deprecated and should not be used in newly-written code. Use g_signal_handler_unblock() instead.
5573  * Undoes a block, by connection id. Note that undoing a block doesn't
5574  * necessarily make the hook callable, because if you block a
5575  * hook twice, you must unblock it twice.
5576  * object :
5577  * the object which emits the signal we want to unblock.
5578  * handler_id :
5579  * the emission handler identifier, as returned by
5580  * gtk_signal_connect(), etc.
5581  */
5582 // TODO
5583 // #define gtk_signal_handler_unblock(object,handler_id)
5584 
5585 /*
5586  * Warning
5587  * 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.
5588  * Undoes a block, by function pointer and data.
5589  * Note that undoing a block doesn't
5590  * necessarily make the hook callable, because if you block a
5591  * hook twice, you must unblock it twice.
5592  * object :
5593  * the object which emits the signal we want to unblock.
5594  * func :
5595  * the function pointer to search for.
5596  * data :
5597  * the user data to search for.
5598  */
5599 // TODO
5600 // #define gtk_signal_handler_unblock_by_func(object,func,data)
5601 
5602 /*
5603  * Warning
5604  * gtk_signal_handler_unblock_by_data is deprecated and should not be used in newly-written code. Use g_signal_handlers_unblock_matched() instead.
5605  * Undoes block(s), to all signals for a particular object
5606  * with a particular user-data pointer
5607  * object :
5608  * the object which emits the signal we want to unblock.
5609  * data :
5610  * the user data to search for.
5611  */
5612 // TODO
5613 // #define gtk_signal_handler_unblock_by_data(object,data)
5614 
5615 /*
5616  * Warning
5617  * gtk_signal_handler_pending is deprecated and should not be used in newly-written code. Use g_signal_has_handler_pending() instead.
5618  * Returns a connection id corresponding to a given signal id and object.
5619  * One example of when you might use this is when the arguments
5620  * to the signal are difficult to compute. A class implementor
5621  * may opt to not emit the signal if no one is attached anyway,
5622  * thus saving the cost of building the arguments.
5623  * object :
5624  * the object to search for the desired user-defined handler.
5625  * signal_id :
5626  * the number of the signal to search for.
5627  * may_be_blocked :
5628  * whether it is acceptable to return a blocked
5629  * handler.
5630  * Returns :
5631  * the connection id, if a connection was found. 0 otherwise.
5632  */
5633 // TODO
5634 // #define gtk_signal_handler_pending(object,signal_id,may_be_blocked)
5635 
5636 /*
5637  * Warning
5638  * gtk_signal_handler_pending_by_func is deprecated and should not be used in newly-written code.
5639  * Returns a connection id corresponding to a given signal id, object, function
5640  * pointer and user data.
5641  * object :
5642  * the object to search for the desired handler.
5643  * signal_id :
5644  * the number of the signal to search for.
5645  * may_be_blocked :
5646  * whether it is acceptable to return a blocked
5647  * handler.
5648  * func :
5649  * the function pointer to search for.
5650  * data :
5651  * the user data to search for.
5652  * Returns :
5653  * the connection id, if a handler was found. 0 otherwise.
5654  */
5655 // TODO
5656 // #define gtk_signal_handler_pending_by_func(object,signal_id,may_be_blocked,func,data)
5657 
5658 /*
5659  * Warning
5660  * GTK_CLASS_NAME is deprecated and should not be used in newly-written code. Use g_type_name() and G_TYPE_FROM_CLASS() instead.
5661  * Returns the type name of class.
5662  * class :
5663  * a GtkTypeClass.
5664  */
5665 // TODO
5666 // #define GTK_CLASS_NAME(class)		(g_type_name (G_TYPE_FROM_CLASS (class)))
5667 
5668 /*
5669  * Warning
5670  * GTK_CLASS_TYPE is deprecated and should not be used in newly-written code. Use G_TYPE_FROM_CLASS() instead.
5671  * Returns the type of class.
5672  * class :
5673  * a GtkTypeClass.
5674  */
5675 // TODO
5676 // #define GTK_CLASS_TYPE(class)		(G_TYPE_FROM_CLASS (class))
5677 
5678 /*
5679  * Warning
5680  * GTK_TYPE_IS_OBJECT is deprecated and should not be used in newly-written code. Use G_TYPE_IS_OBJECT() instead.
5681  * Returns TRUE if type is a GTK_TYPE_OBJECT.
5682  * type :
5683  * a GtkType.
5684  */
5685 // TODO
5686 // #define GTK_TYPE_IS_OBJECT(type) (g_type_is_a ((type), GTK_TYPE_OBJECT))
5687 
5688 /*
5689  * Warning
5690  * GTK_SIGNAL_FUNC is deprecated and should not be used in newly-written code.
5691  * Just a macroized cast into a GtkSignalFunc.
5692  */
5693 // TODO
5694 // #define GTK_SIGNAL_FUNC(f)	 G_CALLBACK(f)
5695 
5696 /*
5697  * Warning
5698  * GTK_VALUE_CHAR is deprecated and should not be used in newly-written code.
5699  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_CHAR.
5700  * a :
5701  * a GtkArg.
5702  */
5703 // TODO
5704 // #define GTK_VALUE_CHAR(a) ((a).d.char_data)
5705 
5706 /*
5707  * Warning
5708  * GTK_VALUE_UCHAR is deprecated and should not be used in newly-written code.
5709  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_UCHAR.
5710  * a :
5711  * a GtkArg.
5712  */
5713 // TODO
5714 // #define GTK_VALUE_UCHAR(a) ((a).d.uchar_data)
5715 
5716 /*
5717  * Warning
5718  * GTK_VALUE_BOOL is deprecated and should not be used in newly-written code.
5719  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_BOOL.
5720  * a :
5721  * a GtkArg.
5722  */
5723 // TODO
5724 // #define GTK_VALUE_BOOL(a) ((a).d.bool_data)
5725 
5726 /*
5727  * Warning
5728  * GTK_VALUE_INT is deprecated and should not be used in newly-written code.
5729  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_INT.
5730  * a :
5731  * a GtkArg.
5732  */
5733 // TODO
5734 // #define GTK_VALUE_INT(a) ((a).d.int_data)
5735 
5736 /*
5737  * Warning
5738  * GTK_VALUE_UINT is deprecated and should not be used in newly-written code.
5739  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_UINT.
5740  * a :
5741  * a GtkArg.
5742  */
5743 // TODO
5744 // #define GTK_VALUE_UINT(a) ((a).d.uint_data)
5745 
5746 /*
5747  * Warning
5748  * GTK_VALUE_LONG is deprecated and should not be used in newly-written code.
5749  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_LONG.
5750  * a :
5751  * a GtkArg.
5752  */
5753 // TODO
5754 // #define GTK_VALUE_LONG(a) ((a).d.long_data)
5755 
5756 /*
5757  * Warning
5758  * GTK_VALUE_ULONG is deprecated and should not be used in newly-written code.
5759  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_ULONG.
5760  * a :
5761  * a GtkArg.
5762  */
5763 // TODO
5764 // #define GTK_VALUE_ULONG(a) ((a).d.ulong_data)
5765 
5766 /*
5767  * Warning
5768  * GTK_VALUE_FLOAT is deprecated and should not be used in newly-written code.
5769  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_FLOAT.
5770  * a :
5771  * a GtkArg.
5772  */
5773 // TODO
5774 // #define GTK_VALUE_FLOAT(a) ((a).d.float_data)
5775 
5776 /*
5777  * Warning
5778  * GTK_VALUE_DOUBLE is deprecated and should not be used in newly-written code.
5779  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_DOUBLE.
5780  * a :
5781  * a GtkArg.
5782  */
5783 // TODO
5784 // #define GTK_VALUE_DOUBLE(a) ((a).d.double_data)
5785 
5786 /*
5787  * Warning
5788  * GTK_VALUE_STRING is deprecated and should not be used in newly-written code.
5789  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_STRING.
5790  * a :
5791  * a GtkArg.
5792  */
5793 // TODO
5794 // #define GTK_VALUE_STRING(a) ((a).d.string_data)
5795 
5796 /*
5797  * Warning
5798  * GTK_VALUE_ENUM is deprecated and should not be used in newly-written code.
5799  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_ENUM.
5800  * a :
5801  * a GtkArg.
5802  */
5803 // TODO
5804 // #define GTK_VALUE_ENUM(a) ((a).d.int_data)
5805 
5806 /*
5807  * Warning
5808  * GTK_VALUE_FLAGS is deprecated and should not be used in newly-written code.
5809  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_FLAGS.
5810  * a :
5811  * a GtkArg.
5812  */
5813 // TODO
5814 // #define GTK_VALUE_FLAGS(a) ((a).d.uint_data)
5815 
5816 /*
5817  * Warning
5818  * GTK_VALUE_BOXED is deprecated and should not be used in newly-written code.
5819  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_BOXED.
5820  * a :
5821  * a GtkArg.
5822  */
5823 // TODO
5824 // #define GTK_VALUE_BOXED(a) ((a).d.pointer_data)
5825 
5826 /*
5827  * Warning
5828  * GTK_VALUE_POINTER is deprecated and should not be used in newly-written code.
5829  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_POINTER.
5830  * a :
5831  * a GtkArg.
5832  */
5833 // TODO
5834 // #define GTK_VALUE_POINTER(a) ((a).d.pointer_data)
5835 
5836 /*
5837  * Warning
5838  * GTK_VALUE_OBJECT is deprecated and should not be used in newly-written code.
5839  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_OBJECT.
5840  * a :
5841  * a GtkArg.
5842  */
5843 // TODO
5844 // #define GTK_VALUE_OBJECT(a) ((a).d.object_data)
5845 
5846 /*
5847  * Warning
5848  * GTK_VALUE_SIGNAL is deprecated and should not be used in newly-written code.
5849  * Gets the value of a GtkArg whose GtkType is GTK_TYPE_SIGNAL.
5850  * a :
5851  * a GtkArg.
5852  */
5853 // TODO
5854 // #define GTK_VALUE_SIGNAL(a) ((a).d.signal_data)
5855 
5856 /*
5857  * Warning
5858  * GTK_RETLOC_CHAR is deprecated and should not be used in newly-written code.
5859  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_CHAR.
5860  * a :
5861  * a GtkArg.
5862  */
5863 // TODO
5864 // #define GTK_RETLOC_CHAR(a) ((gchar*) (a).d.pointer_data)
5865 
5866 /*
5867  * Warning
5868  * GTK_RETLOC_UCHAR is deprecated and should not be used in newly-written code.
5869  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_UCHAR.
5870  * a :
5871  * a GtkArg.
5872  */
5873 // TODO
5874 // #define GTK_RETLOC_UCHAR(a) ((guchar*) (a).d.pointer_data)
5875 
5876 /*
5877  * Warning
5878  * GTK_RETLOC_BOOL is deprecated and should not be used in newly-written code.
5879  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_BOOL.
5880  * a :
5881  * a GtkArg.
5882  */
5883 // TODO
5884 // #define GTK_RETLOC_BOOL(a) ((gboolean*) (a).d.pointer_data)
5885 
5886 /*
5887  * Warning
5888  * GTK_RETLOC_INT is deprecated and should not be used in newly-written code.
5889  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_INT.
5890  * a :
5891  * a GtkArg.
5892  */
5893 // TODO
5894 // #define GTK_RETLOC_INT(a) ((gint*) (a).d.pointer_data)
5895 
5896 /*
5897  * Warning
5898  * GTK_RETLOC_UINT is deprecated and should not be used in newly-written code.
5899  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_UINT.
5900  * a :
5901  * a GtkArg.
5902  */
5903 // TODO
5904 // #define GTK_RETLOC_UINT(a) ((guint*) (a).d.pointer_data)
5905 
5906 /*
5907  * Warning
5908  * GTK_RETLOC_LONG is deprecated and should not be used in newly-written code.
5909  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_LONG.
5910  * a :
5911  * a GtkArg.
5912  */
5913 // TODO
5914 // #define GTK_RETLOC_LONG(a) ((glong*) (a).d.pointer_data)
5915 
5916 /*
5917  * Warning
5918  * GTK_RETLOC_ULONG is deprecated and should not be used in newly-written code.
5919  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_ULONG.
5920  * a :
5921  * a GtkArg.
5922  */
5923 // TODO
5924 // #define GTK_RETLOC_ULONG(a) ((gulong*) (a).d.pointer_data)
5925 
5926 /*
5927  * Warning
5928  * GTK_RETLOC_FLOAT is deprecated and should not be used in newly-written code.
5929  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_FLOAT.
5930  * a :
5931  * a GtkArg.
5932  */
5933 // TODO
5934 // #define GTK_RETLOC_FLOAT(a) ((gfloat*) (a).d.pointer_data)
5935 
5936 /*
5937  * Warning
5938  * GTK_RETLOC_DOUBLE is deprecated and should not be used in newly-written code.
5939  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_DOUBLE.
5940  * a :
5941  * a GtkArg.
5942  */
5943 // TODO
5944 // #define GTK_RETLOC_DOUBLE(a) ((gdouble*) (a).d.pointer_data)
5945 
5946 /*
5947  * Warning
5948  * GTK_RETLOC_STRING is deprecated and should not be used in newly-written code.
5949  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_STRING.
5950  * a :
5951  * a GtkArg.
5952  */
5953 // TODO
5954 // #define GTK_RETLOC_STRING(a) ((gchar**) (a).d.pointer_data)
5955 
5956 /*
5957  * Warning
5958  * GTK_RETLOC_ENUM is deprecated and should not be used in newly-written code.
5959  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_ENUM.
5960  * a :
5961  * a GtkArg.
5962  */
5963 // TODO
5964 // #define GTK_RETLOC_ENUM(a) ((gint*) (a).d.pointer_data)
5965 
5966 /*
5967  * Warning
5968  * GTK_RETLOC_FLAGS is deprecated and should not be used in newly-written code.
5969  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_FLAGS.
5970  * a :
5971  * a GtkArg.
5972  */
5973 // TODO
5974 // #define GTK_RETLOC_FLAGS(a) ((guint*) (a).d.pointer_data)
5975 
5976 /*
5977  * Warning
5978  * GTK_RETLOC_BOXED is deprecated and should not be used in newly-written code.
5979  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_BOXED.
5980  * a :
5981  * a GtkArg.
5982  */
5983 // TODO
5984 // #define GTK_RETLOC_BOXED(a) ((gpointer*) (a).d.pointer_data)
5985 
5986 /*
5987  * Warning
5988  * GTK_RETLOC_POINTER is deprecated and should not be used in newly-written code.
5989  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_POINTER.
5990  * a :
5991  * a GtkArg.
5992  */
5993 // TODO
5994 // #define GTK_RETLOC_POINTER(a) ((gpointer*) (a).d.pointer_data)
5995 
5996 /*
5997  * Warning
5998  * GTK_RETLOC_OBJECT is deprecated and should not be used in newly-written code.
5999  * If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_OBJECT.
6000  * a :
6001  * a GtkArg.
6002  */
6003 // TODO
6004 // #define GTK_RETLOC_OBJECT(a) ((GtkObject**) (a).d.pointer_data)
6005 
6006 /*
6007  * Warning
6008  * gtk_type_name is deprecated and should not be used in newly-written code.
6009  * Returns a pointer to the name of a type, or NULL if it has none.
6010  * type :
6011  * a GtkType.
6012  * Returns :
6013  * a pointer to the name of a type, or NULL if it has none.
6014  */
6015 // TODO
6016 // #define gtk_type_name(type)		 g_type_name (type)
6017 
6018 /*
6019  * Warning
6020  * gtk_type_from_name is deprecated and should not be used in newly-written code.
6021  * Gets the internal representation of a type, given its name.
6022  * name :
6023  * the name of a GTK+ type
6024  * Returns :
6025  * a GtkType.
6026  */
6027 // TODO
6028 // #define gtk_type_from_name(name)	 g_type_from_name (name)
6029 
6030 /*
6031  * Warning
6032  * gtk_type_parent is deprecated and should not be used in newly-written code.
6033  * Returns the parent type of a GtkType.
6034  * type :
6035  * a GtkType.
6036  * Returns :
6037  * the GtkType of the parent.
6038  */
6039 // TODO
6040 // #define gtk_type_parent(type)		 g_type_parent (type)
6041 
6042 /*
6043  * Warning
6044  * gtk_type_is_a is deprecated and should not be used in newly-written code.
6045  * Looks in the type hierarchy to see if type has is_a_type among its
6046  * ancestors. Do so with a simple lookup, not a loop.
6047  * type :
6048  * a GtkType.
6049  * is_a_type :
6050  * another GtkType.
6051  * Returns :
6052  * TRUE if type is a is_a_type.
6053  */
6054 // TODO
6055 // #define gtk_type_is_a(type, is_a_type)	 g_type_is_a ((type), (is_a_type))
6056 
6057 /*
6058  * Warning
6059  * gtk_tree_model_get_iter_root is deprecated and should not be used in newly-written code.
6060  * A alternate name for gtk_tree_model_get_iter_first() provided for
6061  * compatibility reasons; this macro will be deprecated in future
6062  * versions of GTK+.
6063  * tree_model :
6064  * A GtkTreeModel.
6065  * iter :
6066  * uninitialized GtkTreeIter.
6067  * Returns :
6068  * TRUE, if iter was set.
6069  */
6070 // TODO
6071 // #define gtk_tree_model_get_iter_root(tree_model, iter) gtk_tree_model_get_iter_first(tree_model, iter)
6072 
6073 /*
6074  * Warning
6075  * gtk_tree_model_get_iter_root is deprecated and should not be used in newly-written code.
6076  * A alternate name for gtk_tree_model_get_iter_first() provided for
6077  * compatibility reasons; this macro will be deprecated in future
6078  * versions of GTK+.
6079  * tree_model :
6080  * A GtkTreeModel.
6081  * iter :
6082  * uninitialized GtkTreeIter.
6083  * Returns :
6084  * TRUE, if iter was set.
6085  */
6086 // TODO
6087 // #define gtk_tree_model_get_iter_root(tree_model, iter) gtk_tree_model_get_iter_first(tree_model, iter)
6088 
6089 /*
6090  * Warning
6091  * gtk_menu_append is deprecated and should not be used in newly-written code. Use gtk_menu_shell_append() instead.
6092  * Adds a new GtkMenuItem to the end of the menu's item list.
6093  * menu :
6094  * a GtkMenu.
6095  * child :
6096  * The GtkMenuItem to add.
6097  */
6098 // TODO
6099 // #define gtk_menu_append(menu,child) gtk_menu_shell_append ((GtkMenuShell *)(menu),(child))
6100 
6101 /*
6102  * Warning
6103  * gtk_menu_prepend is deprecated and should not be used in newly-written code. Use gtk_menu_shell_prepend() instead.
6104  * Adds a new GtkMenuItem to the beginning of the menu's item list.
6105  * menu :
6106  * a GtkMenu.
6107  * child :
6108  * The GtkMenuItem to add.
6109  */
6110 // TODO
6111 // #define gtk_menu_prepend(menu,child) gtk_menu_shell_prepend ((GtkMenuShell *)(menu),(child))
6112 
6113 /*
6114  * Warning
6115  * gtk_menu_insert is deprecated and should not be used in newly-written code. Use gtk_menu_shell_insert() instead.
6116  * Adds a new GtkMenuItem to the menu's item list at the position
6117  * indicated by position.
6118  * menu :
6119  * a GtkMenu.
6120  * child :
6121  * The GtkMenuItem to add.
6122  * pos :
6123  * The position in the item list where child is added.
6124  * Positions are numbered from 0 to n-1.
6125  */
6126 // TODO
6127 // #define gtk_menu_insert(menu,child,pos) gtk_menu_shell_insert ((GtkMenuShell *)(menu),(child),(pos))
6128 
6129 /*
6130  * Warning
6131  * gtk_menu_bar_append is deprecated and should not be used in newly-written code. Use gtk_menu_shell_append() instead.
6132  * Adds a new GtkMenuItem to the end of the GtkMenuBar
6133  * menu :
6134  * a GtkMenuBar
6135  * child :
6136  * the GtkMenuItem to add
6137  */
6138 // TODO
6139 // #define gtk_menu_bar_append(menu,child)	 gtk_menu_shell_append ((GtkMenuShell *)(menu),(child))
6140 
6141 /*
6142  * Warning
6143  * gtk_menu_bar_prepend is deprecated and should not be used in newly-written code. Use gtk_menu_shell_prepend() instead.
6144  * Adds a new GtkMenuItem to the beginning of the GtkMenuBar
6145  * menu :
6146  * a GtkMenuBar
6147  * child :
6148  * the GtkMenuItem to add
6149  */
6150 // TODO
6151 // #define gtk_menu_bar_prepend(menu,child) gtk_menu_shell_prepend ((GtkMenuShell *)(menu),(child))
6152 
6153 /*
6154  * Warning
6155  * gtk_menu_bar_insert is deprecated and should not be used in newly-written code. Use gtk_menu_shell_insert() instead.
6156  * Adds a new GtkMenuItem to the GtkMenuBar at the position defined by position
6157  * menu :
6158  * a GtkMenuBar
6159  * child :
6160  * the GtkMenuItem to add
6161  * pos :
6162  * the position in the item list where the child is added.
6163  */
6164 // TODO
6165 // #define gtk_menu_bar_insert(menu,child,pos) gtk_menu_shell_insert ((GtkMenuShell *)(menu),(child),(pos))
6166 
6167 /*
6168  * Warning
6169  * gtk_menu_item_right_justify is deprecated and should not be used in newly-written code.
6170  * Sets the menu item to be right-justified. Only useful for menu bars.
6171  * menu_item :
6172  * the menu item
6173  * Property Details
6174  * The "accel-path" property
6175  *  "accel-path" gchar* : Read / Write
6176  * Sets the accelerator path of the menu item, through which runtime
6177  * changes of the menu item's accelerator caused by the user can be
6178  * identified and saved to persistant storage.
6179  * Default value: NULL
6180  * Since 2.14
6181  */
6182 // TODO
6183 // #define gtk_menu_item_right_justify(menu_item) gtk_menu_item_set_right_justified ((menu_item), TRUE)
6184 
6185 /*
6186  * Warning
6187  * gtk_button_box_get_spacing is deprecated and should not be used in newly-written code. Use gtk_box_get_spacing() instead.
6188  * Retrieves how much space a button box is placing between each child button.
6189  * b :
6190  * a GtkButtonBox
6191  * Returns :
6192  * the current spacing applied to the buttons in widget
6193  */
6194 // TODO
6195 // #define gtk_button_box_get_spacing(b) gtk_box_get_spacing (GTK_BOX (b))
6196 
6197 /*
6198  * Warning
6199  * gtk_button_box_set_spacing is deprecated and should not be used in newly-written code. Use gtk_box_set_spacing() instead.
6200  * Sets the amount of spacing between buttons in a given button box.
6201  * b :
6202  * a GtkButtonBox
6203  * s :
6204  * the number of pixels of spacing
6205  */
6206 // TODO
6207 // #define gtk_button_box_set_spacing(b,s) gtk_box_set_spacing (GTK_BOX (b), s)
6208 
6209 /*
6210  */
6211 // TODO
6212 // #define GTK_IS_RESIZE_CONTAINER(widget) (GTK_IS_CONTAINER (widget)  ((GtkContainer*) (widget))->resize_mode != GTK_RESIZE_PARENT)
6213 
6214 /*
6215  * This macro should be used to emit a standard warning about unexpected
6216  * properties in set_child_property() and get_child_property() implementations.
6217  * object :
6218  * the GObject on which set_child_property() or get_child_property()
6219  * was called
6220  * property_id :
6221  * the numeric id of the property
6222  * pspec :
6223  * the GParamSpec of the property
6224  */
6225 // TODO
6226 // #define GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID(object, property_id, pspec)
6227 
6228 /*
6229  * Warning
6230  * GTK_OBJECT_FLAGS has been deprecated since version 2.22 and should not be used in newly-written code. Do not re-use GtkObject flags but use your own variable to
6231  *  store flags.
6232  * Gets the GtkObjectFlags for an object without directly
6233  * accessing its members.
6234  * obj :
6235  * the object whose flags are returned.
6236  */
6237 // TODO
6238 // #define GTK_OBJECT_FLAGS(obj)		 (GTK_OBJECT (obj)->flags)
6239 
6240 /*
6241  * Warning
6242  * GTK_OBJECT_FLOATING is deprecated and should not be used in newly-written code.
6243  * Evaluates to TRUE if the object still has its floating reference count.
6244  * See the overview documentation for GtkObject.
6245  * obj :
6246  * the object to examine.
6247  */
6248 // TODO
6249 // #define GTK_OBJECT_FLOATING(obj)	 (g_object_is_floating (obj))
6250 
6251 /*
6252  * Warning
6253  * gtk_paned_gutter_size is deprecated and should not be used in newly-written code.
6254  * Old name for gtk_paned_set_gutter_size().
6255  * p :
6256  * a paned widget
6257  * s :
6258  * the width of the gutter in pixels
6259  */
6260 // TODO
6261 // #define gtk_paned_gutter_size(p,s)		(void) 0
6262 
6263 /*
6264  * Warning
6265  * gtk_paned_set_gutter_size is deprecated and should not be used in newly-written code.
6266  * In older versions of GTK+, this function used to set the width of the
6267  * gutter (the area between the two panes). It does nothing now.
6268  * p :
6269  * a paned widget
6270  * s :
6271  * the width of the gutter in pixels
6272  */
6273 // TODO
6274 // #define gtk_paned_set_gutter_size(p,s)		(void) 0
6275 
6276 /*
6277  * Warning
6278  * GTK_WIDGET_TYPE has been deprecated since version 2.20 and should not be used in newly-written code. Use G_OBJECT_TYPE() instead.
6279  * Gets the type of a widget.
6280  * wid :
6281  * a GtkWidget.
6282  */
6283 // TODO
6284 // #define GTK_WIDGET_TYPE(wid)		 (GTK_OBJECT_TYPE (wid))
6285 
6286 /*
6287  * Warning
6288  * GTK_WIDGET_STATE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_state() instead.
6289  * wid :
6290  * a GtkWidget.
6291  * Returns :
6292  * the current state of the widget, as a GtkStateType.
6293  */
6294 // TODO
6295 // #define GTK_WIDGET_STATE(wid)		 (GTK_WIDGET (wid)->state)
6296 
6297 /*
6298  * Warning
6299  * GTK_WIDGET_SAVED_STATE has been deprecated since version 2.20 and should not be used in newly-written code. Do not used it.
6300  * wid :
6301  * a GtkWidget.
6302  * Returns :
6303  * the saved state of the widget, as a GtkStateType.
6304  * The saved state will be restored when a widget gets sensitive
6305  * again, after it has been made insensitive with gtk_widget_set_state()
6306  * or gtk_widget_set_sensitive().
6307  */
6308 // TODO
6309 // #define GTK_WIDGET_SAVED_STATE(wid)	 (GTK_WIDGET (wid)->saved_state)
6310 
6311 /*
6312  * Warning
6313  * GTK_WIDGET_FLAGS has been deprecated since version 2.20 and should not be used in newly-written code. Use the proper function to test individual states:
6314  * gtk_widget_get_app_paintable(), gtk_widget_get_can_default(),
6315  * gtk_widget_get_can_focus(), gtk_widget_get_double_buffered(),
6316  * gtk_widget_has_default(), gtk_widget_is_drawable(),
6317  * gtk_widget_has_focus(), gtk_widget_has_grab(), gtk_widget_get_mapped(),
6318  * gtk_widget_get_has_window(), gtk_widget_has_rc_style(),
6319  * gtk_widget_get_realized(), gtk_widget_get_receives_default(),
6320  * gtk_widget_get_sensitive(), gtk_widget_is_sensitive(),
6321  * gtk_widget_is_toplevel() or gtk_widget_get_visible().
6322  * wid :
6323  * a GtkWidget.
6324  * Returns :
6325  * the widget flags from wid.
6326  */
6327 // TODO
6328 // #define GTK_WIDGET_FLAGS(wid)		 (GTK_OBJECT_FLAGS (wid))
6329 
6330 /*
6331  * Warning
6332  * GTK_WIDGET_TOPLEVEL has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_is_toplevel() instead.
6333  * Evaluates to TRUE if the widget is a toplevel widget.
6334  * wid :
6335  * a GtkWidget.
6336  */
6337 // TODO
6338 // #define GTK_WIDGET_TOPLEVEL(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_TOPLEVEL) != 0)
6339 
6340 /*
6341  * Warning
6342  * GTK_WIDGET_NO_WINDOW has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_has_window() instead.
6343  * Evaluates to TRUE if the widget doesn't have an own GdkWindow.
6344  * wid :
6345  * a GtkWidget.
6346  */
6347 // TODO
6348 // #define GTK_WIDGET_NO_WINDOW(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_NO_WINDOW) != 0)
6349 
6350 /*
6351  * Warning
6352  * GTK_WIDGET_REALIZED has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_realized() instead.
6353  * Evaluates to TRUE if the widget is realized.
6354  * wid :
6355  * a GtkWidget.
6356  */
6357 // TODO
6358 // #define GTK_WIDGET_REALIZED(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_REALIZED) != 0)
6359 
6360 /*
6361  * Warning
6362  * GTK_WIDGET_MAPPED has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_mapped() instead.
6363  * Evaluates to TRUE if the widget is mapped.
6364  * wid :
6365  * a GtkWidget.
6366  */
6367 // TODO
6368 // #define GTK_WIDGET_MAPPED(wid)		 ((GTK_WIDGET_FLAGS (wid)  GTK_MAPPED) != 0)
6369 
6370 /*
6371  * Warning
6372  * GTK_WIDGET_VISIBLE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_visible() instead.
6373  * Evaluates to TRUE if the widget is visible.
6374  * wid :
6375  * a GtkWidget.
6376  */
6377 // TODO
6378 // #define GTK_WIDGET_VISIBLE(wid)		 ((GTK_WIDGET_FLAGS (wid)  GTK_VISIBLE) != 0)
6379 
6380 /*
6381  * Warning
6382  * GTK_WIDGET_DRAWABLE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_is_drawable() instead.
6383  * Evaluates to TRUE if the widget is mapped and visible.
6384  * wid :
6385  * a GtkWidget.
6386  */
6387 // TODO
6388 // #define GTK_WIDGET_DRAWABLE(wid)	 (GTK_WIDGET_VISIBLE (wid)  GTK_WIDGET_MAPPED (wid))
6389 
6390 /*
6391  * Warning
6392  * GTK_WIDGET_SENSITIVE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_sensitive() instead.
6393  * Evaluates to TRUE if the GTK_SENSITIVE flag has be set on the widget.
6394  * wid :
6395  * a GtkWidget.
6396  */
6397 // TODO
6398 // #define GTK_WIDGET_SENSITIVE(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_SENSITIVE) != 0)
6399 
6400 /*
6401  * Warning
6402  * GTK_WIDGET_PARENT_SENSITIVE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_sensitive() on the parent widget instead.
6403  * Evaluates to TRUE if the GTK_PARENT_SENSITIVE flag has be set on the widget.
6404  * wid :
6405  * a GtkWidget.
6406  */
6407 // TODO
6408 // #define GTK_WIDGET_PARENT_SENSITIVE(wid) ((GTK_WIDGET_FLAGS (wid)  GTK_PARENT_SENSITIVE) != 0)
6409 
6410 /*
6411  * Warning
6412  * GTK_WIDGET_IS_SENSITIVE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_is_sensitive() instead.
6413  * Evaluates to TRUE if the widget is effectively sensitive.
6414  * wid :
6415  * a GtkWidget.
6416  */
6417 // TODO
6418 // #define GTK_WIDGET_IS_SENSITIVE(wid)
6419 
6420 /*
6421  * Warning
6422  * GTK_WIDGET_CAN_FOCUS has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_can_focus() instead.
6423  * Evaluates to TRUE if the widget is able to handle focus grabs.
6424  * wid :
6425  * a GtkWidget.
6426  */
6427 // TODO
6428 // #define GTK_WIDGET_CAN_FOCUS(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_CAN_FOCUS) != 0)
6429 
6430 /*
6431  * Warning
6432  * GTK_WIDGET_HAS_FOCUS has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_has_focus() instead.
6433  * Evaluates to TRUE if the widget has grabbed the focus and no other
6434  * widget has done so more recently.
6435  * wid :
6436  * a GtkWidget.
6437  */
6438 // TODO
6439 // #define GTK_WIDGET_HAS_FOCUS(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_HAS_FOCUS) != 0)
6440 
6441 /*
6442  * Warning
6443  * GTK_WIDGET_CAN_DEFAULT has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_can_default() instead.
6444  * Evaluates to TRUE if the widget is allowed to receive the default action
6445  * via gtk_widget_grab_default().
6446  * wid :
6447  * a GtkWidget.
6448  */
6449 // TODO
6450 // #define GTK_WIDGET_CAN_DEFAULT(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_CAN_DEFAULT) != 0)
6451 
6452 /*
6453  * Warning
6454  * GTK_WIDGET_RECEIVES_DEFAULT has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_receives_default() instead.
6455  * Evaluates to TRUE if the widget when focused will receive the default action
6456  * even if there is a different widget set as default.
6457  * wid :
6458  * a GtkWidget.
6459  */
6460 // TODO
6461 // #define GTK_WIDGET_RECEIVES_DEFAULT(wid) ((GTK_WIDGET_FLAGS (wid)  GTK_RECEIVES_DEFAULT) != 0)
6462 
6463 /*
6464  * Warning
6465  * GTK_WIDGET_HAS_DEFAULT has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_has_default() instead.
6466  * Evaluates to TRUE if the widget currently is receiving the default action.
6467  * wid :
6468  * a GtkWidget.
6469  */
6470 // TODO
6471 // #define GTK_WIDGET_HAS_DEFAULT(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_HAS_DEFAULT) != 0)
6472 
6473 /*
6474  * Warning
6475  * GTK_WIDGET_HAS_GRAB has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_has_grab() instead.
6476  * Evaluates to TRUE if the widget is in the grab_widgets stack, and will be
6477  * the preferred one for receiving events other than ones of cosmetic value.
6478  * wid :
6479  * a GtkWidget.
6480  */
6481 // TODO
6482 // #define GTK_WIDGET_HAS_GRAB(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_HAS_GRAB) != 0)
6483 
6484 /*
6485  * Warning
6486  * GTK_WIDGET_RC_STYLE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_has_rc_style() instead.
6487  * Evaluates to TRUE if the widget's style has been looked up through the rc
6488  * mechanism.
6489  * wid :
6490  * a GtkWidget.
6491  */
6492 // TODO
6493 // #define GTK_WIDGET_RC_STYLE(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_RC_STYLE) != 0)
6494 
6495 /*
6496  * Warning
6497  * GTK_WIDGET_COMPOSITE_CHILD has been deprecated since version 2.20 and should not be used in newly-written code. Use the "composite-child" property instead.
6498  * Evaluates to TRUE if the widget is a composite child of its parent.
6499  * wid :
6500  * a GtkWidget.
6501  */
6502 // TODO
6503 // #define GTK_WIDGET_COMPOSITE_CHILD(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_COMPOSITE_CHILD) != 0)
6504 
6505 /*
6506  * Warning
6507  * GTK_WIDGET_APP_PAINTABLE has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_app_paintable() instead.
6508  * Evaluates to TRUE if the GTK_APP_PAINTABLE flag has been set on the widget.
6509  * wid :
6510  * a GtkWidget.
6511  */
6512 // TODO
6513 // #define GTK_WIDGET_APP_PAINTABLE(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_APP_PAINTABLE) != 0)
6514 
6515 /*
6516  * Warning
6517  * GTK_WIDGET_DOUBLE_BUFFERED has been deprecated since version 2.20 and should not be used in newly-written code. Use gtk_widget_get_double_buffered() instead.
6518  * Evaluates to TRUE if the GTK_DOUBLE_BUFFERED flag has been set on the widget.
6519  * wid :
6520  * a GtkWidget.
6521  */
6522 // TODO
6523 // #define GTK_WIDGET_DOUBLE_BUFFERED(wid)	 ((GTK_WIDGET_FLAGS (wid)  GTK_DOUBLE_BUFFERED) != 0)
6524 
6525 /*
6526  * Warning
6527  * GTK_WIDGET_SET_FLAGS has been deprecated since version 2.22 and should not be used in newly-written code. Use the proper function instead: gtk_widget_set_app_paintable(),
6528  *  gtk_widget_set_can_default(), gtk_widget_set_can_focus(),
6529  *  gtk_widget_set_double_buffered(), gtk_widget_set_has_window(),
6530  *  gtk_widget_set_mapped(), gtk_widget_set_no_show_all(),
6531  *  gtk_widget_set_realized(), gtk_widget_set_receives_default(),
6532  *  gtk_widget_set_sensitive() or gtk_widget_set_visible().
6533  * Turns on certain widget flags.
6534  * wid :
6535  * a GtkWidget.
6536  * flag :
6537  * the flags to set.
6538  */
6539 // TODO
6540 // #define GTK_WIDGET_SET_FLAGS(wid,flag)	 G_STMT_START{ (GTK_WIDGET_FLAGS (wid) |= (flag)); }G_STMT_END
6541 
6542 /*
6543  * Warning
6544  * GTK_WIDGET_UNSET_FLAGS has been deprecated since version 2.22 and should not be used in newly-written code. Use the proper function instead. See GTK_WIDGET_SET_FLAGS().
6545  * Turns off certain widget flags.
6546  * wid :
6547  * a GtkWidget.
6548  * flag :
6549  * the flags to unset.
6550  */
6551 // TODO
6552 // #define GTK_WIDGET_UNSET_FLAGS(wid,flag) G_STMT_START{ (GTK_WIDGET_FLAGS (wid) = ~(flag)); }G_STMT_END
6553 
6554 /*
6555  * Warning
6556  * gtk_widget_set_rc_style has been deprecated since version 2.0 and should not be used in newly-written code. Use gtk_widget_set_style() with a NULL style argument instead.
6557  * Equivalent to gtk_widget_set_style (widget, NULL).
6558  * widget :
6559  * a GtkWidget.
6560  */
6561 // TODO
6562 // #define gtk_widget_set_rc_style(widget) (gtk_widget_set_style (widget, NULL))
6563 
6564 /*
6565  * Warning
6566  * gtk_widget_restore_default_style has been deprecated since version 2.0 and should not be used in newly-written code. Use gtk_widget_set_style() with a NULL style argument instead.
6567  * Equivalent to gtk_widget_set_style (widget, NULL).
6568  * widget :
6569  * a GtkWidget.
6570  */
6571 // TODO
6572 // #define gtk_widget_restore_default_style(widget) (gtk_widget_set_style (widget, NULL))
6573 
6574 /*
6575  * Warning
6576  * gtk_widget_push_visual is deprecated and should not be used in newly-written code.
6577  * This function is deprecated; it does nothing.
6578  * visual :
6579  * a visual
6580  */
6581 // TODO
6582 // #define gtk_widget_push_visual(visual) ((void) 0)
6583 
6584 /*
6585  * Warning
6586  * gtk_widget_set_default_visual is deprecated and should not be used in newly-written code.
6587  * This function is deprecated; it does nothing.
6588  * visual :
6589  * a visual
6590  */
6591 // TODO
6592 // #define gtk_widget_set_default_visual(visual) ((void) 0)
6593 
6594 /*
6595  * Warning
6596  * gtk_widget_set_visual is deprecated and should not be used in newly-written code.
6597  * This function is deprecated; it does nothing.
6598  * widget :
6599  * a GtkWidget
6600  * visual :
6601  * a visual
6602  */
6603 // TODO
6604 // #define gtk_widget_set_visual(widget,visual) ((void) 0)
6605 
6606 /*
6607  * This macro should be used to emit a warning about and unexpected
6608  * type value in a GtkBuildable add_child implementation.
6609  * object :
6610  * the GtkBuildable on which the warning ocurred
6611  * type :
6612  * the unexpected type value
6613  */
6614 // TODO
6615 // #define GTK_BUILDER_WARN_INVALID_CHILD_TYPE(object, type)
6616 
6617 /*
6618  * Each GTK+ module must have a function gtk_module_init() with this prototype.
6619  * This function is called after loading the module with the argc and argv
6620  * cleaned from any arguments that GTK+ handles itself.
6621  * argc :
6622  * Pointer to the number of arguments remaining after gtk_init().
6623  * argv :
6624  * Points to the argument vector.
6625  */
6626 // void (*GtkModuleInitFunc) (gint *argc,  gchar ***argv);
6627 public alias extern(C) void function(gint* argc, gchar*** argv) GtkModuleInitFunc;
6628 
6629 /*
6630  * Since 2.2
6631  */
6632 // void (*GtkModuleDisplayInitFunc) (GdkDisplay *display);
6633 public alias extern(C) void function(GdkDisplay* display) GtkModuleDisplayInitFunc;
6634 
6635 /*
6636  * Key snooper functions are called before normal event delivery.
6637  * They can be used to implement custom key event handling.
6638  * grab_widget :
6639  * the widget to which the event will be delivered.
6640  * event :
6641  * the key event.
6642  * func_data :
6643  * the func_data supplied to gtk_key_snooper_install().
6644  * Returns :
6645  * TRUE to stop further processing of event, FALSE to continue.
6646  */
6647 // gint (*GtkKeySnoopFunc) (GtkWidget *grab_widget,  GdkEventKey *event,  gpointer func_data);
6648 public alias extern(C) int function(GtkWidget* grabWidget, GdkEventKey* event, void* funcData) GtkKeySnoopFunc;
6649 
6650 /*
6651  */
6652 // gboolean (*GtkAccelGroupActivate) (GtkAccelGroup *accel_group,  GObject *acceleratable,  guint keyval,  GdkModifierType modifier);
6653 public alias extern(C) int function(GtkAccelGroup* accelGroup, GObject* acceleratable, uint keyval, GdkModifierType modifier) GtkAccelGroupActivate;
6654 
6655 /*
6656  * Since 2.2
6657  */
6658 // gboolean (*GtkAccelGroupFindFunc) (GtkAccelKey *key,  GClosure *closure,  gpointer data);
6659 public alias extern(C) int function(GtkAccelKey* key, GClosure* closure, void* data) GtkAccelGroupFindFunc;
6660 
6661 /*
6662  * data :
6663  * accel_path :
6664  * accel_key :
6665  * accel_mods :
6666  * changed :
6667  */
6668 // void (*GtkAccelMapForeach) (gpointer data,  const gchar *accel_path,  guint accel_key,  GdkModifierType accel_mods,  gboolean changed);
6669 public alias extern(C) void function(void* data, char* accelPath, uint accelKey, GdkModifierType accelMods, int changed) GtkAccelMapForeach;
6670 
6671 /*
6672  *  A function to be called when the results of gtk_clipboard_request_contents()
6673  *  are received, or when the request fails.
6674  * clipboard :
6675  * the GtkClipboard
6676  * selection_data :
6677  * a GtkSelectionData containing the data was received.
6678  * If retrieving the data failed, then then length field
6679  * of selection_data will be negative.
6680  * data :
6681  * the user_data supplied to gtk_clipboard_request_contents().
6682  */
6683 // void (*GtkClipboardReceivedFunc) (GtkClipboard *clipboard,  GtkSelectionData *selection_data,  gpointer data);
6684 public alias extern(C) void function(GtkClipboard* clipboard, GtkSelectionData* selectionData, void* data) GtkClipboardReceivedFunc;
6685 
6686 /*
6687  *  A function to be called when the results of gtk_clipboard_request_text()
6688  *  are received, or when the request fails.
6689  * clipboard :
6690  * the GtkClipboard
6691  * text :
6692  * the text received, as a UTF-8 encoded string, or NULL
6693  * if retrieving the data failed.
6694  * data :
6695  * the user_data supplied to gtk_clipboard_request_text().
6696  */
6697 // void (*GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard,  const gchar *text,  gpointer data);
6698 public alias extern(C) void function(GtkClipboard* clipboard, char* text, void* data) GtkClipboardTextReceivedFunc;
6699 
6700 /*
6701  *  A function to be called when the results of gtk_clipboard_request_image()
6702  *  are received, or when the request fails.
6703  * clipboard :
6704  * the GtkClipboard
6705  * pixbuf :
6706  * the received image
6707  * data :
6708  * the user_data supplied to gtk_clipboard_request_image().
6709  * Since 2.6
6710  */
6711 // void (*GtkClipboardImageReceivedFunc) (GtkClipboard *clipboard,  GdkPixbuf *pixbuf,  gpointer data);
6712 public alias extern(C) void function(GtkClipboard* clipboard, GdkPixbuf* pixbuf, void* data) GtkClipboardImageReceivedFunc;
6713 
6714 /*
6715  *  A function to be called when the results of gtk_clipboard_request_targets()
6716  *  are received, or when the request fails.
6717  * clipboard :
6718  * the GtkClipboard
6719  * atoms :
6720  * the supported targets, as array of GdkAtom, or NULL
6721  * if retrieving the data failed.
6722  * n_atoms :
6723  * the length of the atoms array.
6724  * data :
6725  * the user_data supplied to gtk_clipboard_request_targets().
6726  * Since 2.4
6727  */
6728 // void (*GtkClipboardTargetsReceivedFunc) (GtkClipboard *clipboard,  GdkAtom *atoms,  gint n_atoms,  gpointer data);
6729 public alias extern(C) void function(GtkClipboard* clipboard, GdkAtom* atoms, int nAtoms, void* data) GtkClipboardTargetsReceivedFunc;
6730 
6731 /*
6732  */
6733 // void (*GtkClipboardRichTextReceivedFunc) (GtkClipboard *clipboard,  GdkAtom format,  const guint8 *text,  gsize length,  gpointer data);
6734 public alias extern(C) void function(GtkClipboard* clipboard, GdkAtom format, guint8* text, gsize length, void* data) GtkClipboardRichTextReceivedFunc;
6735 
6736 /*
6737  */
6738 // void (*GtkClipboardURIReceivedFunc) (GtkClipboard *clipboard,  gchar **uris,  gpointer data);
6739 public alias extern(C) void function(GtkClipboard* clipboard, gchar** uris, void* data) GtkClipboardURIReceivedFunc;
6740 
6741 /*
6742  * A function that will be called to provide the contents of the selection.
6743  * If multiple types of data were advertised, the requested type can
6744  * be determined from the info parameter or by checking the target field
6745  * of selection_data. If the data could successfully be converted into
6746  * then it should be stored into the selection_data object by
6747  * calling gtk_selection_data_set() (or related functions such
6748  * as gtk_selection_data_set_text()). If no data is set, the requestor
6749  * will be informed that the attempt to get the data failed.
6750  * clipboard :
6751  * the GtkClipboard
6752  * selection_data :
6753  * a GtkSelectionData argument in which the requested
6754  * data should be stored.
6755  * info :
6756  * the info field corresponding to the requested
6757  * target from the GtkTargetEntry array passed to
6758  * gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().
6759  * user_data_or_owner :
6760  * the user_data argument passed to gtk_clipboard_set_with_data(), or
6761  * the owner argument passed to gtk_clipboard_set_with_owner()
6762  */
6763 // void (*GtkClipboardGetFunc) (GtkClipboard *clipboard,  GtkSelectionData *selection_data,  guint info,  gpointer user_data_or_owner);
6764 public alias extern(C) void function(GtkClipboard* clipboard, GtkSelectionData* selectionData, uint info, void* userDataOrOwner) GtkClipboardGetFunc;
6765 
6766 /*
6767  * A function that will be called when the contents of the clipboard are changed
6768  * or cleared. Once this has called, the user_data_or_owner argument
6769  * will not be used again.
6770  * clipboard :
6771  * the GtkClipboard
6772  * user_data_or_owner :
6773  * the user_data argument passed to gtk_clipboard_set_with_data(), or
6774  * the owner argument passed to gtk_clipboard_set_with_owner()
6775  */
6776 // void (*GtkClipboardClearFunc) (GtkClipboard *clipboard,  gpointer user_data_or_owner);
6777 public alias extern(C) void function(GtkClipboard* clipboard, void* userDataOrOwner) GtkClipboardClearFunc;
6778 
6779 /*
6780  * Signal Details
6781  * The "realize" signal
6782  * void user_function (GtkStyle *style,
6783  *  gpointer user_data) : Run First
6784  * Emitted when the style has been initialized for a particular
6785  * colormap and depth. Connecting to this signal is probably seldom
6786  * useful since most of the time applications and widgets only
6787  * deal with styles that have been already realized.
6788  * style :
6789  * the object which received the signal
6790  * user_data :
6791  * user data set when the signal handler was connected.
6792  * Since 2.4
6793  */
6794 // gboolean (*GtkRcPropertyParser) (const GParamSpec *pspec,  const GString *rc_string,  GValue *property_value);
6795 public alias extern(C) int function(GParamSpec* pspec, GString* rcString, GValue* propertyValue) GtkRcPropertyParser;
6796 
6797 /*
6798  * Warning
6799  * GtkSignalFunc is deprecated and should not be used in newly-written code.
6800  * Defines a function pointer.
6801  */
6802 // void (*GtkSignalFunc) (void);
6803 public alias extern(C) void function() GtkSignalFunc;
6804 
6805 /*
6806  * Warning
6807  * GtkFunction has been deprecated since version 2.24 and should not be used in newly-written code. Use GSourceFunc() instead.
6808  * Defines a function pointer.
6809  * data :
6810  * gpointer
6811  * Returns :
6812  * gint
6813  */
6814 // gboolean (*GtkFunction) (gpointer data);
6815 public alias extern(C) int function(void* data) GtkFunction;
6816 
6817 /*
6818  * Warning
6819  * GtkDestroyNotify is deprecated and should not be used in newly-written code.
6820  * Defines a function pointer.
6821  * data :
6822  * gpointer
6823  */
6824 // void (*GtkDestroyNotify) (gpointer data);
6825 public alias extern(C) void function(void* data) GtkDestroyNotify;
6826 
6827 /*
6828  * Warning
6829  * GtkCallbackMarshal has been deprecated since version 2.24 and should not be used in newly-written code.
6830  * Defines a function pointer.
6831  * object :
6832  * GtkObject*
6833  * data :
6834  * gpointer
6835  * n_args :
6836  * guint
6837  * args :
6838  * GtkArg*
6839  */
6840 // void (*GtkCallbackMarshal) (GtkObject *object,  gpointer data,  guint n_args,  GtkArg *args);
6841 public alias extern(C) void function(GtkObject* object, void* data, uint nArgs, GtkArg* args) GtkCallbackMarshal;
6842 
6843 /*
6844  * The type of a function which is called when a URL or email
6845  * link is activated.
6846  * about :
6847  * the GtkAboutDialog in which the link was activated
6848  * link_ :
6849  * the URL or email address to which the activated link points
6850  * data :
6851  * user data that was passed when the function was registered
6852  * with gtk_about_dialog_set_email_hook() or
6853  * gtk_about_dialog_set_url_hook()
6854  */
6855 // void (*GtkAboutDialogActivateLinkFunc) (GtkAboutDialog *about,  const gchar *link_,  gpointer data);
6856 public alias extern(C) void function(GtkAboutDialog* about, char* link, void* data) GtkAboutDialogActivateLinkFunc;
6857 
6858 /*
6859  * A function used by gtk_assistant_set_forward_page_func() to know which
6860  * is the next page given a current one. It's called both for computing the
6861  * next page when the user presses the "forward" button and for handling
6862  * the behavior of the "last" button.
6863  * current_page :
6864  * The page number used to calculate the next page.
6865  * data :
6866  * user data.
6867  * Returns :
6868  * The next page number.
6869  */
6870 // gint (*GtkAssistantPageFunc) (gint current_page,  gpointer data);
6871 public alias extern(C) int function(int currentPage, void* data) GtkAssistantPageFunc;
6872 
6873 /*
6874  * The type of a function which is called when the GtkLinkButton is
6875  * clicked.
6876  * button :
6877  * the GtkLinkButton which was clicked
6878  * link_ :
6879  * the URI to which the clicked GtkLinkButton points
6880  * user_data :
6881  * user data that was passed when the function was registered
6882  * with gtk_link_button_set_uri_hook()
6883  */
6884 // void (*GtkLinkButtonUriFunc) (GtkLinkButton *button,  const gchar *link_,  gpointer user_data);
6885 public alias extern(C) void function(GtkLinkButton* button, char* link, void* userData) GtkLinkButtonUriFunc;
6886 
6887 /*
6888  * A function which decides whether the row indicated by iter matches a given
6889  * key, and should be displayed as a possible completion for key. Note that
6890  * key is normalized and case-folded (see g_utf8_normalize() and
6891  * g_utf8_casefold()). If this is not appropriate, match functions have access
6892  * to the unmodified key via gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ())).
6893  * completion :
6894  * the GtkEntryCompletion
6895  * key :
6896  * the string to match, normalized and case-folded
6897  * iter :
6898  * a GtkTreeIter indicating the row to match
6899  * user_data :
6900  * user data given to gtk_entry_completion_set_match_func()
6901  * Returns :
6902  * TRUE if iter should be displayed as a possible completion for key
6903  */
6904 // gboolean (*GtkEntryCompletionMatchFunc) (GtkEntryCompletion *completion,  const gchar *key,  GtkTreeIter *iter,  gpointer user_data);
6905 public alias extern(C) int function(GtkEntryCompletion* completion, char* key, GtkTreeIter* iter, void* userData) GtkEntryCompletionMatchFunc;
6906 
6907 /*
6908  */
6909 // gboolean (*GtkTextCharPredicate) (gunichar ch,  gpointer user_data);
6910 public alias extern(C) int function(gunichar ch, void* userData) GtkTextCharPredicate;
6911 
6912 /*
6913  * A function that is called to deserialize rich text that has been
6914  * serialized with gtk_text_buffer_serialize(), and insert it at iter.
6915  * register_buffer :
6916  * the GtkTextBuffer the format is registered with
6917  * content_buffer :
6918  * the GtkTextBuffer to deserialize into
6919  * iter :
6920  * insertion point for the deserialized text
6921  * data :
6922  * data to deserialize
6923  * length :
6924  * length of data
6925  * create_tags :
6926  * TRUE if deserializing may create tags
6927  * user_data :
6928  * user data that was specified when registering the format
6929  * error :
6930  * return location for a GError
6931  * Returns :
6932  * TRUE on success, FALSE otherwise
6933  */
6934 // gboolean (*GtkTextBufferDeserializeFunc) (GtkTextBuffer *register_buffer,  GtkTextBuffer *content_buffer,  GtkTextIter *iter,  const guint8 *data,  gsize length,  gboolean create_tags,  gpointer user_data,  GError **error);
6935 public alias extern(C) int function(GtkTextBuffer* registerBuffer, GtkTextBuffer* contentBuffer, GtkTextIter* iter, guint8* data, gsize length, int createTags, void* userData, GError** error) GtkTextBufferDeserializeFunc;
6936 
6937 /*
6938  * A function that is called to serialize the content of a text buffer.
6939  * It must return the serialized form of the content.
6940  * register_buffer :
6941  * the GtkTextBuffer for which the format is registered
6942  * content_buffer :
6943  * the GtkTextsBuffer to serialize
6944  * start :
6945  * start of the block of text to serialize
6946  * end :
6947  * end of the block of text to serialize
6948  * length :
6949  * Return location for the length of the serialized data
6950  * user_data :
6951  * user data that was specified when registering the format
6952  * Returns :
6953  * a newly-allocated array of guint8 which contains the serialized
6954  * data, or NULL if an error occurred
6955  */
6956 // guint8 * (*GtkTextBufferSerializeFunc) (GtkTextBuffer *register_buffer,  GtkTextBuffer *content_buffer,  const GtkTextIter *start,  const GtkTextIter *end,  gsize *length,  gpointer user_data);
6957 public alias extern(C) ubyte * function(GtkTextBuffer* registerBuffer, GtkTextBuffer* contentBuffer, GtkTextIter* start, GtkTextIter* end, gsize* length, void* userData) GtkTextBufferSerializeFunc;
6958 
6959 /*
6960  */
6961 // void (*GtkTextTagTableForeach) (GtkTextTag *tag,  gpointer data);
6962 public alias extern(C) void function(GtkTextTag* tag, void* data) GtkTextTagTableForeach;
6963 
6964 /*
6965  * model :
6966  * The GtkTreeModel currently being iterated
6967  * path :
6968  * The current GtkTreePath
6969  * iter :
6970  * The current GtkTreeIter
6971  * data :
6972  * The user data passed to gtk_tree_model_foreach()
6973  * Returns :
6974  * TRUE to stop iterating, FALSE to continue.
6975  */
6976 // gboolean (*GtkTreeModelForeachFunc) (GtkTreeModel *model,  GtkTreePath *path,  GtkTreeIter *iter,  gpointer data);
6977 public alias extern(C) int function(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, void* data) GtkTreeModelForeachFunc;
6978 
6979 /*
6980  * A function used by gtk_tree_selection_set_select_function() to filter
6981  * whether or not a row may be selected. It is called whenever a row's
6982  * state might change. A return value of TRUE indicates to selection
6983  * that it is okay to change the selection.
6984  * selection :
6985  * A GtkTreeSelection
6986  * model :
6987  * A GtkTreeModel being viewed
6988  * path :
6989  * The GtkTreePath of the row in question
6990  * path_currently_selected :
6991  * TRUE, if the path is currently selected
6992  * data :
6993  * user data
6994  * Returns :
6995  * TRUE, if the selection state of the row can be toggled
6996  */
6997 // gboolean (*GtkTreeSelectionFunc) (GtkTreeSelection *selection,  GtkTreeModel *model,  GtkTreePath *path,  gboolean path_currently_selected,  gpointer data);
6998 public alias extern(C) int function(GtkTreeSelection* selection, GtkTreeModel* model, GtkTreePath* path, int pathCurrentlySelected, void* data) GtkTreeSelectionFunc;
6999 
7000 /*
7001  * A function used by gtk_tree_selection_selected_foreach() to map all
7002  * selected rows. It will be called on every selected row in the view.
7003  * model :
7004  * The GtkTreeModel being viewed
7005  * path :
7006  * The GtkTreePath of a selected row
7007  * iter :
7008  * A GtkTreeIter pointing to a selected row
7009  * data :
7010  * user data
7011  */
7012 // void (*GtkTreeSelectionForeachFunc) (GtkTreeModel *model,  GtkTreePath *path,  GtkTreeIter *iter,  gpointer data);
7013 public alias extern(C) void function(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, void* data) GtkTreeSelectionForeachFunc;
7014 
7015 /*
7016  * A function to set the properties of a cell instead of just using the
7017  * straight mapping between the cell and the model. This is useful for
7018  * customizing the cell renderer. For example, a function might get an
7019  * integer from the tree_model, and render it to the "text" attribute of
7020  * "cell" by converting it to its written equivilent. This is set by
7021  * calling gtk_tree_view_column_set_cell_data_func()
7022  * tree_column :
7023  * A GtkTreeColumn
7024  * cell :
7025  * The GtkCellRenderer that is being rendered by tree_column
7026  * tree_model :
7027  * The GtkTreeModel being rendered
7028  * iter :
7029  * A GtkTreeIter of the current row rendered
7030  * data :
7031  * user data
7032  */
7033 // void (*GtkTreeCellDataFunc) (GtkTreeViewColumn *tree_column,  GtkCellRenderer *cell,  GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer data);
7034 public alias extern(C) void function(GtkTreeViewColumn* treeColumn, GtkCellRenderer* cell, GtkTreeModel* treeModel, GtkTreeIter* iter, void* data) GtkTreeCellDataFunc;
7035 
7036 /*
7037  * Function type for determining whether column can be dropped in a
7038  * particular spot (as determined by prev_column and next_column). In
7039  * left to right locales, prev_column is on the left of the potential drop
7040  * spot, and next_column is on the right. In right to left mode, this is
7041  * reversed. This function should return TRUE if the spot is a valid drop
7042  * spot. Please note that returning TRUE does not actually indicate that
7043  * the column drop was made, but is meant only to indicate a possible drop
7044  * spot to the user.
7045  * tree_view :
7046  * A GtkTreeView
7047  * column :
7048  * The GtkTreeViewColumn being dragged
7049  * prev_column :
7050  * A GtkTreeViewColumn on one side of column
7051  * next_column :
7052  * A GtkTreeViewColumn on the other side of column
7053  * data :
7054  * user data
7055  * Returns :
7056  * TRUE, if column can be dropped in this spot
7057  */
7058 // gboolean (*GtkTreeViewColumnDropFunc) (GtkTreeView *tree_view,  GtkTreeViewColumn *column,  GtkTreeViewColumn *prev_column,  GtkTreeViewColumn *next_column,  gpointer data);
7059 public alias extern(C) int function(GtkTreeView* treeView, GtkTreeViewColumn* column, GtkTreeViewColumn* prevColumn, GtkTreeViewColumn* nextColumn, void* data) GtkTreeViewColumnDropFunc;
7060 
7061 /*
7062  * Function used for gtk_tree_view_map_expanded_rows.
7063  * tree_view :
7064  * A GtkTreeView
7065  * path :
7066  * The path that's expanded
7067  * user_data :
7068  * user data
7069  */
7070 // void (*GtkTreeViewMappingFunc) (GtkTreeView *tree_view,  GtkTreePath *path,  gpointer user_data);
7071 public alias extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, void* userData) GtkTreeViewMappingFunc;
7072 
7073 /*
7074  * A function used for checking whether a row in model matches
7075  * a search key string entered by the user. Note the return value
7076  * is reversed from what you would normally expect, though it
7077  * has some similarity to strcmp() returning 0 for equal strings.
7078  * model :
7079  * the GtkTreeModel being searched
7080  * column :
7081  * the search column set by gtk_tree_view_set_search_column()
7082  * key :
7083  * the key string to compare with
7084  * iter :
7085  * a GtkTreeIter pointing the row of model that should be compared
7086  * with key.
7087  * search_data :
7088  * user data from gtk_tree_view_set_search_equal_func()
7089  * Returns :
7090  * FALSE if the row matches, TRUE otherwise.
7091  */
7092 // gboolean (*GtkTreeViewSearchEqualFunc) (GtkTreeModel *model,  gint column,  const gchar *key,  GtkTreeIter *iter,  gpointer search_data);
7093 public alias extern(C) int function(GtkTreeModel* model, int column, char* key, GtkTreeIter* iter, void* searchData) GtkTreeViewSearchEqualFunc;
7094 
7095 /*
7096  */
7097 // void (*GtkTreeViewSearchPositionFunc) (GtkTreeView *tree_view,  GtkWidget *search_dialog,  gpointer user_data);
7098 public alias extern(C) void function(GtkTreeView* treeView, GtkWidget* searchDialog, void* userData) GtkTreeViewSearchPositionFunc;
7099 
7100 /*
7101  */
7102 // void (*GtkTreeDestroyCountFunc) (GtkTreeView *tree_view,  GtkTreePath *path,  gint children,  gpointer user_data);
7103 public alias extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, int children, void* userData) GtkTreeDestroyCountFunc;
7104 
7105 /*
7106  * Function type for determining whether the row pointed to by iter should
7107  * be rendered as a separator. A common way to implement this is to have a
7108  * boolean column in the model, whose values the GtkTreeViewRowSeparatorFunc
7109  * returns.
7110  * model :
7111  * the GtkTreeModel
7112  * iter :
7113  * a GtkTreeIter pointing at a row in model
7114  * data :
7115  * user data
7116  * Returns :
7117  * TRUE if the row is a separator
7118  */
7119 // gboolean (*GtkTreeViewRowSeparatorFunc) (GtkTreeModel *model,  GtkTreeIter *iter,  gpointer data);
7120 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* iter, void* data) GtkTreeViewRowSeparatorFunc;
7121 
7122 /*
7123  * A function used by gtk_icon_view_selected_foreach() to map all
7124  * selected rows. It will be called on every selected row in the view.
7125  * icon_view :
7126  * a GtkIconView
7127  * path :
7128  * The GtkTreePath of a selected row
7129  * data :
7130  * user data
7131  */
7132 // void (*GtkIconViewForeachFunc) (GtkIconView *icon_view,  GtkTreePath *path,  gpointer data);
7133 public alias extern(C) void function(GtkIconView* iconView, GtkTreePath* path, void* data) GtkIconViewForeachFunc;
7134 
7135 /*
7136  * A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive
7137  * integer if a sorts before b, a sorts with b, or a sorts after b
7138  * respectively. If two iters compare as equal, their order in the sorted model
7139  * is undefined. In order to ensure that the GtkTreeSortable behaves as
7140  * expected, the GtkTreeIterCompareFunc must define a partial order on
7141  * the model, i.e. it must be reflexive, antisymmetric and transitive.
7142  * For example, if model is a product catalogue, then a compare function
7143  * for the "price" column could be one which returns
7144  * price_of(a) - price_of(b).
7145  * model :
7146  * The GtkTreeModel the comparison is within
7147  * a :
7148  * A GtkTreeIter in model
7149  * b :
7150  * Another GtkTreeIter in model
7151  * user_data :
7152  * Data passed when the compare func is assigned e.g. by
7153  * gtk_tree_sortable_set_sort_func()
7154  * Returns :
7155  * a negative integer, zero or a positive integer depending on whether
7156  * a sorts before, with or after b
7157  */
7158 // gint (*GtkTreeIterCompareFunc) (GtkTreeModel *model,  GtkTreeIter *a,  GtkTreeIter *b,  gpointer user_data);
7159 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* a, GtkTreeIter* b, void* userData) GtkTreeIterCompareFunc;
7160 
7161 /*
7162  * A function which decides whether the row indicated by iter is visible.
7163  * model :
7164  * the child model of the GtkTreeModelFilter
7165  * iter :
7166  * a GtkTreeIter pointing to the row in model whose visibility
7167  * is determined
7168  * data :
7169  * user data given to gtk_tree_model_filter_set_visible_func()
7170  * Returns :
7171  * Whether the row indicated by iter is visible.
7172  */
7173 // gboolean (*GtkTreeModelFilterVisibleFunc) (GtkTreeModel *model,  GtkTreeIter *iter,  gpointer data);
7174 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* iter, void* data) GtkTreeModelFilterVisibleFunc;
7175 
7176 /*
7177  * A function which calculates display values from raw values in the model.
7178  * It must fill value with the display value for the column column in the
7179  * row indicated by iter.
7180  * Since this function is called for each data access, it's not a
7181  * particularly efficient operation.
7182  * model :
7183  * the GtkTreeModelFilter
7184  * iter :
7185  * a GtkTreeIter pointing to the row whose display values are determined
7186  * value :
7187  * A GValue which is already initialized for with the correct type for
7188  * the column column.
7189  * column :
7190  * the column whose display value is determined
7191  * data :
7192  * user data given to gtk_tree_model_filter_set_modify_func()
7193  */
7194 // void (*GtkTreeModelFilterModifyFunc) (GtkTreeModel *model,  GtkTreeIter *iter,  GValue *value,  gint column,  gpointer data);
7195 public alias extern(C) void function(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, int column, void* data) GtkTreeModelFilterModifyFunc;
7196 
7197 /*
7198  * A function which should set the value of cell_layout's cell renderer(s)
7199  * as appropriate.
7200  * cell_layout :
7201  * a GtkCellLayout
7202  * cell :
7203  * the cell renderer whose value is to be set
7204  * tree_model :
7205  * the model
7206  * iter :
7207  * a GtkTreeIter indicating the row to set the value for
7208  * data :
7209  * user data passed to gtk_cell_layout_set_cell_data_func()
7210  */
7211 // void (*GtkCellLayoutDataFunc) (GtkCellLayout *cell_layout,  GtkCellRenderer *cell,  GtkTreeModel *tree_model,  GtkTreeIter *iter,  gpointer data);
7212 public alias extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, GtkTreeModel* treeModel, GtkTreeIter* iter, void* data) GtkCellLayoutDataFunc;
7213 
7214 /*
7215  * A user function supplied when calling gtk_menu_popup() which controls the
7216  * positioning of the menu when it is displayed. The function sets the x
7217  * and y parameters to the coordinates where the menu is to be drawn.
7218  * To make the menu appear on a different monitor than the mouse pointer,
7219  * gtk_menu_set_monitor() must be called.
7220  * menu :
7221  * a GtkMenu.
7222  * x :
7223  * address of the gint representing the horizontal position where the
7224  * menu shall be drawn. This is an output parameter.
7225  * y :
7226  * address of the gint representing the vertical position where the
7227  * menu shall be drawn. This is an output parameter.
7228  * push_in :
7229  * This parameter controls how menus placed outside the monitor are handled.
7230  * If this is set to TRUE and part of the menu is outside the monitor then
7231  * GTK+ pushes the window into the visible area, effectively modifying the
7232  * popup position.
7233  * Note that moving and possibly resizing the menu around will alter the
7234  * scroll position to keep the menu items "in place", i.e. at the same monitor
7235  * position they would have been without resizing.
7236  * In practice, this behavior is only useful for combobox popups or option
7237  * menus and cannot be used to simply confine a menu to monitor boundaries.
7238  * In that case, changing the scroll offset is not desirable.
7239  * user_data :
7240  * the data supplied by the user in the gtk_menu_popup() data
7241  * parameter.
7242  */
7243 // void (*GtkMenuPositionFunc) (GtkMenu *menu,  gint *x,  gint *y,  gboolean *push_in,  gpointer user_data);
7244 public alias extern(C) void function(GtkMenu* menu, gint* x, gint* y, gboolean* pushIn, void* userData) GtkMenuPositionFunc;
7245 
7246 /*
7247  * A user function supplied when calling gtk_menu_attach_to_widget() which
7248  * will be called when the menu is later detached from the widget.
7249  * attach_widget :
7250  * the GtkWidget that the menu is being detached from.
7251  * menu :
7252  * the GtkMenu being detached.
7253  * Property Details
7254  * The "accel-group" property
7255  *  "accel-group" GtkAccelGroup* : Read / Write
7256  * The accel group holding accelerators for the menu.
7257  * Since 2.14
7258  */
7259 // void (*GtkMenuDetachFunc) (GtkWidget *attach_widget,  GtkMenu *menu);
7260 public alias extern(C) void function(GtkWidget* attachWidget, GtkMenu* menu) GtkMenuDetachFunc;
7261 
7262 /*
7263  */
7264 // void (*GtkColorSelectionChangePaletteFunc)  (const GdkColor *colors,  gint n_colors);
7265 public alias extern(C) void function(GdkColor* colors, int nColors) GtkColorSelectionChangePaletteFunc;
7266 
7267 /*
7268  * Since 2.2
7269  */
7270 // void (*GtkColorSelectionChangePaletteWithScreenFunc)  (GdkScreen *screen,  const GdkColor *colors,  gint n_colors);
7271 public alias extern(C) void function(GdkScreen* screen, GdkColor* colors, int nColors) GtkColorSelectionChangePaletteWithScreenFunc;
7272 
7273 /*
7274  * The type of function that is used with custom filters,
7275  * see gtk_file_filter_add_custom().
7276  * filter_info :
7277  * a GtkFileFilterInfo that is filled according
7278  * to the needed flags passed to gtk_file_filter_add_custom()
7279  * data :
7280  * user data passed to gtk_file_filter_add_custom()
7281  * Returns :
7282  * TRUE if the file should be displayed
7283  */
7284 // gboolean (*GtkFileFilterFunc) (const GtkFileFilterInfo *filter_info,  gpointer data);
7285 public alias extern(C) int function(GtkFileFilterInfo* filterInfo, void* data) GtkFileFilterFunc;
7286 
7287 /*
7288  * A function used by GtkNotebook when a detachable tab is dropped
7289  * in the root window, it's used to create a window containing a notebook
7290  * where the tab will be attached. This function will also be responsible
7291  * of moving/resizing the window and adding the necessary properties to
7292  * the notebook (i.e.: group-id).
7293  * If the function returns NULL, the drag will be cancelled.
7294  * source :
7295  * The source GtkNotebook of the drag operation
7296  * page :
7297  * the child GtkWidget affected
7298  * x :
7299  * the X coordinate where the drop happens
7300  * y :
7301  * the Y coordinate where the drop happens
7302  * data :
7303  * user data
7304  * Returns :
7305  * The created GtkNotebook where the tab will be attached, or NULL to cancel the drag
7306  */
7307 // GtkNotebook * (*GtkNotebookWindowCreationFunc) (GtkNotebook *source,  GtkWidget *page,  gint x,  gint y,  gpointer data);
7308 public alias extern(C) GtkNotebook * function(GtkNotebook* source, GtkWidget* page, int x, int y, void* data) GtkNotebookWindowCreationFunc;
7309 
7310 /*
7311  * The type of function that is passed to gtk_print_run_page_setup_dialog_async().
7312  * This function will be called when the page setup dialog is dismissed, and
7313  * also serves as destroy notify for data.
7314  * page_setup :
7315  * the GtkPageSetup that has been
7316  * data :
7317  * user data that has been passed to
7318  * gtk_print_run_page_setup_dialog_async().
7319  */
7320 // void (*GtkPageSetupDoneFunc) (GtkPageSetup *page_setup,  gpointer data);
7321 public alias extern(C) void function(GtkPageSetup* pageSetup, void* data) GtkPageSetupDoneFunc;
7322 
7323 /*
7324  */
7325 // void (*GtkPrintSettingsFunc) (const gchar *key,  const gchar *value,  gpointer user_data);
7326 public alias extern(C) void function(char* key, char* value, void* userData) GtkPrintSettingsFunc;
7327 
7328 /*
7329  * The type of function passed to gtk_enumerate_printers().
7330  * Note that you need to ref printer, if you want to keep
7331  * a reference to it after the function has returned.
7332  * printer :
7333  * a GtkPrinter
7334  * data :
7335  * user data passed to gtk_enumerate_printers()
7336  * Returns :
7337  * TRUE to stop the enumeration, FALSE to continue
7338  */
7339 // gboolean (*GtkPrinterFunc) (GtkPrinter *printer,  gpointer data);
7340 public alias extern(C) int function(GtkPrinter* printer, void* data) GtkPrinterFunc;
7341 
7342 /*
7343  * The type of callback that is passed to gtk_print_job_send().
7344  * It is called when the print job has been completely sent.
7345  * print_job :
7346  * the GtkPrintJob
7347  * user_data :
7348  * user data that has been passed to gtk_print_job_send()
7349  * error :
7350  * a GError that contains error information if the sending
7351  * of the print job failed, otherwise NULL
7352  */
7353 // void (*GtkPrintJobCompleteFunc) (GtkPrintJob *print_job,  gpointer user_data,  GError *error);
7354 public alias extern(C) void function(GtkPrintJob* printJob, void* userData, GError* error) GtkPrintJobCompleteFunc;
7355 
7356 /*
7357  * This kind of functions provide Pango markup with detail information for the
7358  * specified day. Examples for such details are holidays or appointments. The
7359  * function returns NULL when no information is available.
7360  * calendar :
7361  * a GtkCalendar.
7362  * year :
7363  * the year for which details are needed.
7364  * month :
7365  * the month for which details are needed.
7366  * day :
7367  * the day of month for which details are needed.
7368  * user_data :
7369  * the data passed with gtk_calendar_set_detail_func().
7370  * Returns :
7371  * Newly allocated string with Pango markup with details
7372  * for the specified day, or NULL.
7373  * Since 2.14
7374  */
7375 // gchar * (*GtkCalendarDetailFunc) (GtkCalendar *calendar,  guint year,  guint month,  guint day,  gpointer user_data);
7376 public alias extern(C) char * function(GtkCalendar* calendar, uint year, uint month, uint day, void* userData) GtkCalendarDetailFunc;
7377 
7378 /*
7379  * The type of the callback functions used for e.g. iterating over
7380  * the children of a container, see gtk_container_foreach().
7381  * widget :
7382  * the widget to operate on
7383  * data :
7384  * user-supplied data
7385  */
7386 // void (*GtkCallback) (GtkWidget *widget,  gpointer data);
7387 public alias extern(C) void function(GtkWidget* widget, void* data) GtkCallback;
7388 
7389 /*
7390  */
7391 // gint (*GtkRecentSortFunc) (GtkRecentInfo *a,  GtkRecentInfo *b,  gpointer user_data);
7392 public alias extern(C) int function(GtkRecentInfo* a, GtkRecentInfo* b, void* userData) GtkRecentSortFunc;
7393 
7394 /*
7395  * The type of function that is used with custom filters,
7396  * see gtk_recent_filter_add_custom().
7397  * filter_info :
7398  * a GtkRecentFilterInfo that is filled according
7399  * to the needed flags passed to gtk_recent_filter_add_custom()
7400  * user_data :
7401  * user data passed to gtk_recent_filter_add_custom()
7402  * Returns :
7403  * TRUE if the file should be displayed
7404  */
7405 // gboolean (*GtkRecentFilterFunc) (const GtkRecentFilterInfo *filter_info,  gpointer user_data);
7406 public alias extern(C) int function(GtkRecentFilterInfo* filterInfo, void* userData) GtkRecentFilterFunc;
7407 
7408 /*
7409  * This is the signature of a function used to connect signals. It is used
7410  * by the gtk_builder_connect_signals() and gtk_builder_connect_signals_full()
7411  * methods. It is mainly intended for interpreted language bindings, but
7412  * could be useful where the programmer wants more control over the signal
7413  * connection process.
7414  * builder :
7415  * a GtkBuilder
7416  * object :
7417  * object to connect a signal to
7418  * signal_name :
7419  * name of the signal
7420  * handler_name :
7421  * name of the handler
7422  * connect_object :
7423  * a GObject, if non-NULL, use g_signal_connect_object()
7424  * flags :
7425  * GConnectFlags to use
7426  * user_data :
7427  * user data
7428  * Since 2.12
7429  */
7430 // void (*GtkBuilderConnectFunc) (GtkBuilder *builder,  GObject *object,  const gchar *signal_name,  const gchar *handler_name,  GObject *connect_object,  GConnectFlags flags,  gpointer user_data);
7431 public alias extern(C) void function(GtkBuilder* builder, GObject* object, char* signalName, char* handlerName, GObject* connectObject, GConnectFlags flags, void* userData) GtkBuilderConnectFunc;
7432 
7433 /*
7434  * Warning
7435  * GtkPrintFunc is deprecated and should not be used in newly-written code.
7436  */
7437 // void (*GtkPrintFunc) (gpointer func_data,  const gchar *str);
7438 public alias extern(C) void function(void* funcData, char* str) GtkPrintFunc;
7439 
7440 /*
7441  * The function used to translate messages in e.g. GtkIconFactory
7442  * and GtkActionGroup.
7443  * path :
7444  * The id of the message. In GtkItemFactory this will be a path
7445  * from a GtkItemFactoryEntry, in GtkActionGroup, it will be a label
7446  * or tooltip from a GtkActionEntry.
7447  * func_data :
7448  * user data passed in when registering the function
7449  * Returns :
7450  * the translated message
7451  */
7452 // gchar * (*GtkTranslateFunc) (const gchar *path,  gpointer func_data);
7453 public alias extern(C) char * function(char* path, void* funcData) GtkTranslateFunc;
7454 
7455 /*
7456  * Warning
7457  * GtkItemFactoryCallback is deprecated and should not be used in newly-written code.
7458  */
7459 // void (*GtkItemFactoryCallback) ();
7460 public alias extern(C) void function() GtkItemFactoryCallback;
7461 
7462 /*
7463  * Warning
7464  * GtkItemFactoryCallback1 is deprecated and should not be used in newly-written code.
7465  */
7466 // void (*GtkItemFactoryCallback1) (gpointer callback_data,  guint callback_action,  GtkWidget *widget);
7467 public alias extern(C) void function(void* callbackData, uint callbackAction, GtkWidget* widget) GtkItemFactoryCallback1;
7468 
7469 /*
7470  * Warning
7471  * GtkItemFactoryCallback2 is deprecated and should not be used in newly-written code.
7472  */
7473 // void (*GtkItemFactoryCallback2) (GtkWidget *widget,  gpointer callback_data,  guint callback_action);
7474 public alias extern(C) void function(GtkWidget* widget, void* callbackData, uint callbackAction) GtkItemFactoryCallback2;
7475 
7476 
7477 // StockIDs
7478 enum StockID
7479 {
7480 	
7481 	/**
7482 	 * The "About" item.
7483 	 * Since 2.6
7484 	 */
7485 	ABOUT,
7486 	
7487 	/**
7488 	 * The "Add" item.
7489 	 */
7490 	ADD,
7491 	
7492 	/**
7493 	 * The "Apply" item.
7494 	 */
7495 	APPLY,
7496 	
7497 	/**
7498 	 * The "Bold" item.
7499 	 */
7500 	BOLD,
7501 	
7502 	/**
7503 	 * The "Cancel" item.
7504 	 */
7505 	CANCEL,
7506 	
7507 	/**
7508 	 * The "Caps Lock Warning" icon.
7509 	 * Since 2.16
7510 	 */
7511 	CAPS_LOCK_WARNING,
7512 	
7513 	/**
7514 	 * The "CD-Rom" item.
7515 	 */
7516 	CDROM,
7517 	
7518 	/**
7519 	 * The "Clear" item.
7520 	 */
7521 	CLEAR,
7522 	
7523 	/**
7524 	 * The "Close" item.
7525 	 */
7526 	CLOSE,
7527 	
7528 	/**
7529 	 * The "Color Picker" item.
7530 	 * Since 2.2
7531 	 */
7532 	COLOR_PICKER,
7533 	
7534 	/**
7535 	 * The "Convert" item.
7536 	 */
7537 	CONVERT,
7538 	
7539 	/**
7540 	 * The "Connect" icon.
7541 	 * Since 2.6
7542 	 */
7543 	CONNECT,
7544 	
7545 	/**
7546 	 * The "Copy" item.
7547 	 */
7548 	COPY,
7549 	
7550 	/**
7551 	 * The "Cut" item.
7552 	 */
7553 	CUT,
7554 	
7555 	/**
7556 	 * The "Delete" item.
7557 	 */
7558 	DELETE,
7559 	
7560 	/**
7561 	 * The "Authentication" item.
7562 	 * Since 2.4
7563 	 */
7564 	DIALOG_AUTHENTICATION,
7565 	
7566 	/**
7567 	 * The "Error" item.
7568 	 */
7569 	DIALOG_ERROR,
7570 	
7571 	/**
7572 	 * The "Information" item.
7573 	 */
7574 	DIALOG_INFO,
7575 	
7576 	/**
7577 	 * The "Question" item.
7578 	 */
7579 	DIALOG_QUESTION,
7580 	
7581 	/**
7582 	 * The "Warning" item.
7583 	 */
7584 	DIALOG_WARNING,
7585 	
7586 	/**
7587 	 * The "Directory" icon.
7588 	 * Since 2.6
7589 	 */
7590 	DIRECTORY,
7591 	
7592 	/**
7593 	 * The "Discard" item.
7594 	 * Since 2.12
7595 	 */
7596 	DISCARD,
7597 	
7598 	/**
7599 	 * The "Disconnect" icon.
7600 	 * Since 2.6
7601 	 */
7602 	DISCONNECT,
7603 	
7604 	/**
7605 	 * The "Drag-And-Drop" icon.
7606 	 */
7607 	DND,
7608 	
7609 	/**
7610 	 * The "Drag-And-Drop multiple" icon.
7611 	 */
7612 	DND_MULTIPLE,
7613 	
7614 	/**
7615 	 * The "Edit" item.
7616 	 * Since 2.6
7617 	 */
7618 	EDIT,
7619 	
7620 	/**
7621 	 * The "Execute" item.
7622 	 */
7623 	EXECUTE,
7624 	
7625 	/**
7626 	 * The "File" icon.
7627 	 * Since 2.6
7628 	 */
7629 	FILE,
7630 	
7631 	/**
7632 	 * The "Find" item.
7633 	 */
7634 	FIND,
7635 	
7636 	/**
7637 	 * The "Find and Replace" item.
7638 	 */
7639 	FIND_AND_REPLACE,
7640 	
7641 	/**
7642 	 * The "Floppy" item.
7643 	 */
7644 	FLOPPY,
7645 	
7646 	/**
7647 	 * The "Fullscreen" item.
7648 	 * Since 2.8
7649 	 */
7650 	FULLSCREEN,
7651 	
7652 	/**
7653 	 * The "Bottom" item.
7654 	 */
7655 	GOTO_BOTTOM,
7656 	
7657 	/**
7658 	 * The "First" item.
7659 	 * RTL variant
7660 	 */
7661 	GOTO_FIRST,
7662 	
7663 	/**
7664 	 * The "Last" item.
7665 	 * RTL variant
7666 	 */
7667 	GOTO_LAST,
7668 	
7669 	/**
7670 	 * The "Top" item.
7671 	 */
7672 	GOTO_TOP,
7673 	
7674 	/**
7675 	 * The "Back" item.
7676 	 * RTL variant
7677 	 */
7678 	GO_BACK,
7679 	
7680 	/**
7681 	 * The "Down" item.
7682 	 */
7683 	GO_DOWN,
7684 	
7685 	/**
7686 	 * The "Forward" item.
7687 	 * RTL variant
7688 	 */
7689 	GO_FORWARD,
7690 	
7691 	/**
7692 	 * The "Up" item.
7693 	 */
7694 	GO_UP,
7695 	
7696 	/**
7697 	 * The "Harddisk" item.
7698 	 * Since 2.4
7699 	 */
7700 	HARDDISK,
7701 	
7702 	/**
7703 	 * The "Help" item.
7704 	 */
7705 	HELP,
7706 	
7707 	/**
7708 	 * The "Home" item.
7709 	 */
7710 	HOME,
7711 	
7712 	/**
7713 	 * The "Indent" item.
7714 	 * RTL variant
7715 	 * Since 2.4
7716 	 */
7717 	INDENT,
7718 	
7719 	/**
7720 	 * The "Index" item.
7721 	 */
7722 	INDEX,
7723 	
7724 	/**
7725 	 * The "Info" item.
7726 	 * Since 2.8
7727 	 */
7728 	INFO,
7729 	
7730 	/**
7731 	 * The "Italic" item.
7732 	 */
7733 	ITALIC,
7734 	
7735 	/**
7736 	 * The "Jump to" item.
7737 	 * RTL-variant
7738 	 */
7739 	JUMP_TO,
7740 	
7741 	/**
7742 	 * The "Center" item.
7743 	 */
7744 	JUSTIFY_CENTER,
7745 	
7746 	/**
7747 	 * The "Fill" item.
7748 	 */
7749 	JUSTIFY_FILL,
7750 	
7751 	/**
7752 	 * The "Left" item.
7753 	 */
7754 	JUSTIFY_LEFT,
7755 	
7756 	/**
7757 	 * The "Right" item.
7758 	 */
7759 	JUSTIFY_RIGHT,
7760 	
7761 	/**
7762 	 * The "Leave Fullscreen" item.
7763 	 * Since 2.8
7764 	 */
7765 	LEAVE_FULLSCREEN,
7766 	
7767 	/**
7768 	 * The "Media Forward" item.
7769 	 * RTL variant
7770 	 * Since 2.6
7771 	 */
7772 	MEDIA_FORWARD,
7773 	
7774 	/**
7775 	 * The "Media Next" item.
7776 	 * RTL variant
7777 	 * Since 2.6
7778 	 */
7779 	MEDIA_NEXT,
7780 	
7781 	/**
7782 	 * The "Media Pause" item.
7783 	 * Since 2.6
7784 	 */
7785 	MEDIA_PAUSE,
7786 	
7787 	/**
7788 	 * The "Media Play" item.
7789 	 * RTL variant
7790 	 * Since 2.6
7791 	 */
7792 	MEDIA_PLAY,
7793 	
7794 	/**
7795 	 * The "Media Previous" item.
7796 	 * RTL variant
7797 	 * Since 2.6
7798 	 */
7799 	MEDIA_PREVIOUS,
7800 	
7801 	/**
7802 	 * The "Media Record" item.
7803 	 * Since 2.6
7804 	 */
7805 	MEDIA_RECORD,
7806 	
7807 	/**
7808 	 * The "Media Rewind" item.
7809 	 * RTL variant
7810 	 * Since 2.6
7811 	 */
7812 	MEDIA_REWIND,
7813 	
7814 	/**
7815 	 * The "Media Stop" item.
7816 	 * Since 2.6
7817 	 */
7818 	MEDIA_STOP,
7819 	
7820 	/**
7821 	 * The "Missing image" icon.
7822 	 */
7823 	MISSING_IMAGE,
7824 	
7825 	/**
7826 	 * The "Network" item.
7827 	 * Since 2.4
7828 	 */
7829 	NETWORK,
7830 	
7831 	/**
7832 	 * The "New" item.
7833 	 */
7834 	NEW,
7835 	
7836 	/**
7837 	 * The "No" item.
7838 	 */
7839 	NO,
7840 	
7841 	/**
7842 	 * The "OK" item.
7843 	 */
7844 	OK,
7845 	
7846 	/**
7847 	 * The "Open" item.
7848 	 */
7849 	OPEN,
7850 	
7851 	/**
7852 	 * The "Landscape Orientation" item.
7853 	 * Since 2.10
7854 	 */
7855 	ORIENTATION_LANDSCAPE,
7856 	
7857 	/**
7858 	 * The "Portrait Orientation" item.
7859 	 * Since 2.10
7860 	 */
7861 	ORIENTATION_PORTRAIT,
7862 	
7863 	/**
7864 	 * The "Reverse Landscape Orientation" item.
7865 	 * Since 2.10
7866 	 */
7867 	ORIENTATION_REVERSE_LANDSCAPE,
7868 	
7869 	/**
7870 	 * The "Reverse Portrait Orientation" item.
7871 	 * Since 2.10
7872 	 */
7873 	ORIENTATION_REVERSE_PORTRAIT,
7874 	
7875 	/**
7876 	 * The "Page Setup" item.
7877 	 * Since 2.14
7878 	 */
7879 	PAGE_SETUP,
7880 	
7881 	/**
7882 	 * The "Paste" item.
7883 	 */
7884 	PASTE,
7885 	
7886 	/**
7887 	 * The "Preferences" item.
7888 	 */
7889 	PREFERENCES,
7890 	
7891 	/**
7892 	 * The "Print" item.
7893 	 */
7894 	PRINT,
7895 	
7896 	/**
7897 	 * The "Print Error" icon.
7898 	 * Since 2.14
7899 	 */
7900 	PRINT_ERROR,
7901 	
7902 	/**
7903 	 * The "Print Paused" icon.
7904 	 * Since 2.14
7905 	 */
7906 	PRINT_PAUSED,
7907 	
7908 	/**
7909 	 * The "Print Preview" item.
7910 	 */
7911 	PRINT_PREVIEW,
7912 	
7913 	/**
7914 	 * The "Print Report" icon.
7915 	 * Since 2.14
7916 	 */
7917 	PRINT_REPORT,
7918 	
7919 	/**
7920 	 * The "Print Warning" icon.
7921 	 * Since 2.14
7922 	 */
7923 	PRINT_WARNING,
7924 	
7925 	/**
7926 	 * The "Properties" item.
7927 	 */
7928 	PROPERTIES,
7929 	
7930 	/**
7931 	 * The "Quit" item.
7932 	 */
7933 	QUIT,
7934 	
7935 	/**
7936 	 * The "Redo" item.
7937 	 * RTL variant
7938 	 */
7939 	REDO,
7940 	
7941 	/**
7942 	 * The "Refresh" item.
7943 	 */
7944 	REFRESH,
7945 	
7946 	/**
7947 	 * The "Remove" item.
7948 	 */
7949 	REMOVE,
7950 	
7951 	/**
7952 	 * The "Revert" item.
7953 	 * RTL variant
7954 	 */
7955 	REVERT_TO_SAVED,
7956 	
7957 	/**
7958 	 * The "Save" item.
7959 	 */
7960 	SAVE,
7961 	
7962 	/**
7963 	 * The "Save As" item.
7964 	 */
7965 	SAVE_AS,
7966 	
7967 	/**
7968 	 * The "Select All" item.
7969 	 * Since 2.10
7970 	 */
7971 	SELECT_ALL,
7972 	
7973 	/**
7974 	 * The "Color" item.
7975 	 */
7976 	SELECT_COLOR,
7977 	
7978 	/**
7979 	 * The "Font" item.
7980 	 */
7981 	SELECT_FONT,
7982 	
7983 	/**
7984 	 * The "Ascending" item.
7985 	 */
7986 	SORT_ASCENDING,
7987 	
7988 	/**
7989 	 * The "Descending" item.
7990 	 */
7991 	SORT_DESCENDING,
7992 	
7993 	/**
7994 	 * The "Spell Check" item.
7995 	 */
7996 	SPELL_CHECK,
7997 	
7998 	/**
7999 	 * The "Stop" item.
8000 	 */
8001 	STOP,
8002 	
8003 	/**
8004 	 * The "Strikethrough" item.
8005 	 */
8006 	STRIKETHROUGH,
8007 	
8008 	/**
8009 	 * The "Undelete" item.
8010 	 * RTL variant
8011 	 */
8012 	UNDELETE,
8013 	
8014 	/**
8015 	 * The "Underline" item.
8016 	 */
8017 	UNDERLINE,
8018 	
8019 	/**
8020 	 * The "Undo" item.
8021 	 * RTL variant
8022 	 */
8023 	UNDO,
8024 	
8025 	/**
8026 	 * The "Unindent" item.
8027 	 * RTL variant
8028 	 * Since 2.4
8029 	 */
8030 	UNINDENT,
8031 	
8032 	/**
8033 	 * The "Yes" item.
8034 	 */
8035 	YES,
8036 	
8037 	/**
8038 	 * The "Zoom 100%" item.
8039 	 */
8040 	ZOOM_100,
8041 	
8042 	/**
8043 	 * The "Zoom to Fit" item.
8044 	 */
8045 	ZOOM_FIT,
8046 	
8047 	/**
8048 	 * The "Zoom In" item.
8049 	 */
8050 	ZOOM_IN,
8051 	
8052 	/**
8053 	 * The "Zoom Out" item.
8054 	 */
8055 	ZOOM_OUT,
8056 
8057 }
8058 
8059 // Stock strings
8060 string[] StockDesc = 
8061 [	"gtk-about",
8062 	"gtk-add",
8063 	"gtk-apply",
8064 	"gtk-bold",
8065 	"gtk-cancel",
8066 	"gtk-caps-lock-warning",
8067 	"gtk-cdrom",
8068 	"gtk-clear",
8069 	"gtk-close",
8070 	"gtk-color-picker",
8071 	"gtk-convert",
8072 	"gtk-connect",
8073 	"gtk-copy",
8074 	"gtk-cut",
8075 	"gtk-delete",
8076 	"gtk-dialog-authentication",
8077 	"gtk-dialog-error",
8078 	"gtk-dialog-info",
8079 	"gtk-dialog-question",
8080 	"gtk-dialog-warning",
8081 	"gtk-directory",
8082 	"gtk-discard",
8083 	"gtk-disconnect",
8084 	"gtk-dnd",
8085 	"gtk-dnd-multiple",
8086 	"gtk-edit",
8087 	"gtk-execute",
8088 	"gtk-file",
8089 	"gtk-find",
8090 	"gtk-find-and-replace",
8091 	"gtk-floppy",
8092 	"gtk-fullscreen",
8093 	"gtk-goto-bottom",
8094 	"gtk-goto-first",
8095 	"gtk-goto-last",
8096 	"gtk-goto-top",
8097 	"gtk-go-back",
8098 	"gtk-go-down",
8099 	"gtk-go-forward",
8100 	"gtk-go-up",
8101 	"gtk-harddisk",
8102 	"gtk-help",
8103 	"gtk-home",
8104 	"gtk-indent",
8105 	"gtk-index",
8106 	"gtk-info",
8107 	"gtk-italic",
8108 	"gtk-jump-to",
8109 	"gtk-justify-center",
8110 	"gtk-justify-fill",
8111 	"gtk-justify-left",
8112 	"gtk-justify-right",
8113 	"gtk-leave-fullscreen",
8114 	"gtk-media-forward",
8115 	"gtk-media-next",
8116 	"gtk-media-pause",
8117 	"gtk-media-play",
8118 	"gtk-media-previous",
8119 	"gtk-media-record",
8120 	"gtk-media-rewind",
8121 	"gtk-media-stop",
8122 	"gtk-missing-image",
8123 	"gtk-network",
8124 	"gtk-new",
8125 	"gtk-no",
8126 	"gtk-ok",
8127 	"gtk-open",
8128 	"gtk-orientation-landscape",
8129 	"gtk-orientation-portrait",
8130 	"gtk-orientation-reverse-landscape",
8131 	"gtk-orientation-reverse-portrait",
8132 	"gtk-page-setup",
8133 	"gtk-paste",
8134 	"gtk-preferences",
8135 	"gtk-print",
8136 	"gtk-print-error",
8137 	"gtk-print-paused",
8138 	"gtk-print-preview",
8139 	"gtk-print-report",
8140 	"gtk-print-warning",
8141 	"gtk-properties",
8142 	"gtk-quit",
8143 	"gtk-redo",
8144 	"gtk-refresh",
8145 	"gtk-remove",
8146 	"gtk-revert-to-saved",
8147 	"gtk-save",
8148 	"gtk-save-as",
8149 	"gtk-select-all",
8150 	"gtk-select-color",
8151 	"gtk-select-font",
8152 	"gtk-sort-ascending",
8153 	"gtk-sort-descending",
8154 	"gtk-spell-check",
8155 	"gtk-stop",
8156 	"gtk-strikethrough",
8157 	"gtk-undelete",
8158 	"gtk-underline",
8159 	"gtk-undo",
8160 	"gtk-unindent",
8161 	"gtk-yes",
8162 	"gtk-zoom-100",
8163 	"gtk-zoom-fit",
8164 	"gtk-zoom-in",
8165 	"gtk-zoom-out",
8166 
8167 ];