1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gtk.c.types;
26 
27 public import atk.c.types;
28 public import cairo.c.types;
29 public import gdk.c.types;
30 public import gdkpixbuf.c.types;
31 public import gio.c.types;
32 public import glib.c.types;
33 public import gobject.c.types;
34 public import pango.c.types;
35 
36 alias GtkAllocation* Allocation;
37 
38 /**
39  * A #GtkAllocation-struct of a widget represents region
40  * which has been allocated to the widget by its parent. It is a subregion
41  * of its parents allocation. See
42  * [GtkWidget’s geometry management section][geometry-management] for
43  * more information.
44  */
45 public alias GdkRectangle GtkAllocation;
46 
47 public alias char* GtkStock;
48 
49 /**
50  * Accelerator flags used with gtk_accel_group_connect().
51  */
52 public enum GtkAccelFlags
53 {
54 	/**
55 	 * Accelerator is visible
56 	 */
57 	VISIBLE = 1,
58 	/**
59 	 * Accelerator not removable
60 	 */
61 	LOCKED = 2,
62 	/**
63 	 * Mask
64 	 */
65 	MASK = 7,
66 }
67 alias GtkAccelFlags AccelFlags;
68 
69 /**
70  * Controls how a widget deals with extra space in a single (x or y)
71  * dimension.
72  *
73  * Alignment only matters if the widget receives a “too large” allocation,
74  * for example if you packed the widget with the #GtkWidget:expand
75  * flag inside a #GtkBox, then the widget might get extra space.  If
76  * you have for example a 16x16 icon inside a 32x32 space, the icon
77  * could be scaled and stretched, it could be centered, or it could be
78  * positioned to one side of the space.
79  *
80  * Note that in horizontal context @GTK_ALIGN_START and @GTK_ALIGN_END
81  * are interpreted relative to text direction.
82  *
83  * GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
84  * it is only supported for vertical alignment.  When its not supported by
85  * a child or a container it is treated as @GTK_ALIGN_FILL.
86  */
87 public enum GtkAlign
88 {
89 	/**
90 	 * stretch to fill all space if possible, center if
91 	 * no meaningful way to stretch
92 	 */
93 	FILL = 0,
94 	/**
95 	 * snap to left or top side, leaving space on right
96 	 * or bottom
97 	 */
98 	START = 1,
99 	/**
100 	 * snap to right or bottom side, leaving space on left
101 	 * or top
102 	 */
103 	END = 2,
104 	/**
105 	 * center natural width of widget inside the
106 	 * allocation
107 	 */
108 	CENTER = 3,
109 	/**
110 	 * align the widget according to the baseline. Since 3.10.
111 	 */
112 	BASELINE = 4,
113 }
114 alias GtkAlign Align;
115 
116 /**
117  * Types of user actions that may be blocked by gtk_application_inhibit().
118  *
119  * Since: 3.4
120  */
121 public enum GtkApplicationInhibitFlags
122 {
123 	/**
124 	 * Inhibit ending the user session
125 	 * by logging out or by shutting down the computer
126 	 */
127 	LOGOUT = 1,
128 	/**
129 	 * Inhibit user switching
130 	 */
131 	SWITCH = 2,
132 	/**
133 	 * Inhibit suspending the
134 	 * session or computer
135 	 */
136 	SUSPEND = 4,
137 	/**
138 	 * Inhibit the session being
139 	 * marked as idle (and possibly locked)
140 	 */
141 	IDLE = 8,
142 }
143 alias GtkApplicationInhibitFlags ApplicationInhibitFlags;
144 
145 /**
146  * Used to specify the placement of scroll arrows in scrolling menus.
147  */
148 public enum GtkArrowPlacement
149 {
150 	/**
151 	 * Place one arrow on each end of the menu.
152 	 */
153 	BOTH = 0,
154 	/**
155 	 * Place both arrows at the top of the menu.
156 	 */
157 	START = 1,
158 	/**
159 	 * Place both arrows at the bottom of the menu.
160 	 */
161 	END = 2,
162 }
163 alias GtkArrowPlacement ArrowPlacement;
164 
165 /**
166  * Used to indicate the direction in which an arrow should point.
167  */
168 public enum GtkArrowType
169 {
170 	/**
171 	 * Represents an upward pointing arrow.
172 	 */
173 	UP = 0,
174 	/**
175 	 * Represents a downward pointing arrow.
176 	 */
177 	DOWN = 1,
178 	/**
179 	 * Represents a left pointing arrow.
180 	 */
181 	LEFT = 2,
182 	/**
183 	 * Represents a right pointing arrow.
184 	 */
185 	RIGHT = 3,
186 	/**
187 	 * No arrow. Since 2.10.
188 	 */
189 	NONE = 4,
190 }
191 alias GtkArrowType ArrowType;
192 
193 /**
194  * An enum for determining the page role inside the #GtkAssistant. It's
195  * used to handle buttons sensitivity and visibility.
196  *
197  * Note that an assistant needs to end its page flow with a page of type
198  * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
199  * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
200  *
201  * The Cancel button will only be shown if the page isn’t “committed”.
202  * See gtk_assistant_commit() for details.
203  */
204 public enum GtkAssistantPageType
205 {
206 	/**
207 	 * The page has regular contents. Both the
208 	 * Back and forward buttons will be shown.
209 	 */
210 	CONTENT = 0,
211 	/**
212 	 * The page contains an introduction to the
213 	 * assistant task. Only the Forward button will be shown if there is a
214 	 * next page.
215 	 */
216 	INTRO = 1,
217 	/**
218 	 * The page lets the user confirm or deny the
219 	 * changes. The Back and Apply buttons will be shown.
220 	 */
221 	CONFIRM = 2,
222 	/**
223 	 * The page informs the user of the changes
224 	 * done. Only the Close button will be shown.
225 	 */
226 	SUMMARY = 3,
227 	/**
228 	 * Used for tasks that take a long time to
229 	 * complete, blocks the assistant until the page is marked as complete.
230 	 * Only the back button will be shown.
231 	 */
232 	PROGRESS = 4,
233 	/**
234 	 * Used for when other page types are not
235 	 * appropriate. No buttons will be shown, and the application must
236 	 * add its own buttons through gtk_assistant_add_action_widget().
237 	 */
238 	CUSTOM = 5,
239 }
240 alias GtkAssistantPageType AssistantPageType;
241 
242 /**
243  * Denotes the expansion properties that a widget will have when it (or its
244  * parent) is resized.
245  */
246 public enum GtkAttachOptions
247 {
248 	/**
249 	 * the widget should expand to take up any extra space in its
250 	 * container that has been allocated.
251 	 */
252 	EXPAND = 1,
253 	/**
254 	 * the widget should shrink as and when possible.
255 	 */
256 	SHRINK = 2,
257 	/**
258 	 * the widget should fill the space allocated to it.
259 	 */
260 	FILL = 4,
261 }
262 alias GtkAttachOptions AttachOptions;
263 
264 /**
265  * Whenever a container has some form of natural row it may align
266  * children in that row along a common typographical baseline. If
267  * the amount of verical space in the row is taller than the total
268  * requested height of the baseline-aligned children then it can use a
269  * #GtkBaselinePosition to select where to put the baseline inside the
270  * extra availible space.
271  *
272  * Since: 3.10
273  */
274 public enum GtkBaselinePosition
275 {
276 	/**
277 	 * Align the baseline at the top
278 	 */
279 	TOP = 0,
280 	/**
281 	 * Center the baseline
282 	 */
283 	CENTER = 1,
284 	/**
285 	 * Align the baseline at the bottom
286 	 */
287 	BOTTOM = 2,
288 }
289 alias GtkBaselinePosition BaselinePosition;
290 
291 /**
292  * Describes how the border of a UI element should be rendered.
293  */
294 public enum GtkBorderStyle
295 {
296 	/**
297 	 * No visible border
298 	 */
299 	NONE = 0,
300 	/**
301 	 * A single line segment
302 	 */
303 	SOLID = 1,
304 	/**
305 	 * Looks as if the content is sunken into the canvas
306 	 */
307 	INSET = 2,
308 	/**
309 	 * Looks as if the content is coming out of the canvas
310 	 */
311 	OUTSET = 3,
312 	/**
313 	 * Same as @GTK_BORDER_STYLE_NONE
314 	 */
315 	HIDDEN = 4,
316 	/**
317 	 * A series of round dots
318 	 */
319 	DOTTED = 5,
320 	/**
321 	 * A series of square-ended dashes
322 	 */
323 	DASHED = 6,
324 	/**
325 	 * Two parallel lines with some space between them
326 	 */
327 	DOUBLE = 7,
328 	/**
329 	 * Looks as if it were carved in the canvas
330 	 */
331 	GROOVE = 8,
332 	/**
333 	 * Looks as if it were coming out of the canvas
334 	 */
335 	RIDGE = 9,
336 }
337 alias GtkBorderStyle BorderStyle;
338 
339 /**
340  * Error codes that identify various errors that can occur while using
341  * #GtkBuilder.
342  */
343 public enum GtkBuilderError
344 {
345 	/**
346 	 * A type-func attribute didn’t name
347 	 * a function that returns a #GType.
348 	 */
349 	INVALID_TYPE_FUNCTION = 0,
350 	/**
351 	 * The input contained a tag that #GtkBuilder
352 	 * can’t handle.
353 	 */
354 	UNHANDLED_TAG = 1,
355 	/**
356 	 * An attribute that is required by
357 	 * #GtkBuilder was missing.
358 	 */
359 	MISSING_ATTRIBUTE = 2,
360 	/**
361 	 * #GtkBuilder found an attribute that
362 	 * it doesn’t understand.
363 	 */
364 	INVALID_ATTRIBUTE = 3,
365 	/**
366 	 * #GtkBuilder found a tag that
367 	 * it doesn’t understand.
368 	 */
369 	INVALID_TAG = 4,
370 	/**
371 	 * A required property value was
372 	 * missing.
373 	 */
374 	MISSING_PROPERTY_VALUE = 5,
375 	/**
376 	 * #GtkBuilder couldn’t parse
377 	 * some attribute value.
378 	 */
379 	INVALID_VALUE = 6,
380 	/**
381 	 * The input file requires a newer version
382 	 * of GTK+.
383 	 */
384 	VERSION_MISMATCH = 7,
385 	/**
386 	 * An object id occurred twice.
387 	 */
388 	DUPLICATE_ID = 8,
389 	/**
390 	 * A specified object type is of the same type or
391 	 * derived from the type of the composite class being extended with builder XML.
392 	 */
393 	OBJECT_TYPE_REFUSED = 9,
394 	/**
395 	 * The wrong type was specified in a composite class’s template XML
396 	 */
397 	TEMPLATE_MISMATCH = 10,
398 	/**
399 	 * The specified property is unknown for the object class.
400 	 */
401 	INVALID_PROPERTY = 11,
402 	/**
403 	 * The specified signal is unknown for the object class.
404 	 */
405 	INVALID_SIGNAL = 12,
406 	/**
407 	 * An object id is unknown
408 	 */
409 	INVALID_ID = 13,
410 }
411 alias GtkBuilderError BuilderError;
412 
413 /**
414  * Used to dictate the style that a #GtkButtonBox uses to layout the buttons it
415  * contains.
416  */
417 public enum GtkButtonBoxStyle
418 {
419 	/**
420 	 * Buttons are evenly spread across the box.
421 	 */
422 	SPREAD = 1,
423 	/**
424 	 * Buttons are placed at the edges of the box.
425 	 */
426 	EDGE = 2,
427 	/**
428 	 * Buttons are grouped towards the start of the box,
429 	 * (on the left for a HBox, or the top for a VBox).
430 	 */
431 	START = 3,
432 	/**
433 	 * Buttons are grouped towards the end of the box,
434 	 * (on the right for a HBox, or the bottom for a VBox).
435 	 */
436 	END = 4,
437 	/**
438 	 * Buttons are centered in the box. Since 2.12.
439 	 */
440 	CENTER = 5,
441 	/**
442 	 * Buttons expand to fill the box. This entails giving
443 	 * buttons a "linked" appearance, making button sizes homogeneous, and
444 	 * setting spacing to 0 (same as calling gtk_box_set_homogeneous() and
445 	 * gtk_box_set_spacing() manually). Since 3.12.
446 	 */
447 	EXPAND = 6,
448 }
449 alias GtkButtonBoxStyle ButtonBoxStyle;
450 
451 /**
452  * The role specifies the desired appearance of a #GtkModelButton.
453  */
454 public enum GtkButtonRole
455 {
456 	/**
457 	 * A plain button
458 	 */
459 	NORMAL = 0,
460 	/**
461 	 * A check button
462 	 */
463 	CHECK = 1,
464 	/**
465 	 * A radio button
466 	 */
467 	RADIO = 2,
468 }
469 alias GtkButtonRole ButtonRole;
470 
471 /**
472  * Prebuilt sets of buttons for the dialog. If
473  * none of these choices are appropriate, simply use %GTK_BUTTONS_NONE
474  * then call gtk_dialog_add_buttons().
475  *
476  * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
477  * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
478  * > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/).
479  */
480 public enum GtkButtonsType
481 {
482 	/**
483 	 * no buttons at all
484 	 */
485 	NONE = 0,
486 	/**
487 	 * an OK button
488 	 */
489 	OK = 1,
490 	/**
491 	 * a Close button
492 	 */
493 	CLOSE = 2,
494 	/**
495 	 * a Cancel button
496 	 */
497 	CANCEL = 3,
498 	/**
499 	 * Yes and No buttons
500 	 */
501 	YES_NO = 4,
502 	/**
503 	 * OK and Cancel buttons
504 	 */
505 	OK_CANCEL = 5,
506 }
507 alias GtkButtonsType ButtonsType;
508 
509 /**
510  * These options can be used to influence the display and behaviour of a #GtkCalendar.
511  */
512 public enum GtkCalendarDisplayOptions
513 {
514 	/**
515 	 * Specifies that the month and year should be displayed.
516 	 */
517 	SHOW_HEADING = 1,
518 	/**
519 	 * Specifies that three letter day descriptions should be present.
520 	 */
521 	SHOW_DAY_NAMES = 2,
522 	/**
523 	 * Prevents the user from switching months with the calendar.
524 	 */
525 	NO_MONTH_CHANGE = 4,
526 	/**
527 	 * Displays each week numbers of the current year, down the
528 	 * left side of the calendar.
529 	 */
530 	SHOW_WEEK_NUMBERS = 8,
531 	/**
532 	 * Just show an indicator, not the full details
533 	 * text when details are provided. See gtk_calendar_set_detail_func().
534 	 */
535 	SHOW_DETAILS = 32,
536 }
537 alias GtkCalendarDisplayOptions CalendarDisplayOptions;
538 
539 /**
540  * Determines if the edited accelerators are GTK+ accelerators. If
541  * they are, consumed modifiers are suppressed, only accelerators
542  * accepted by GTK+ are allowed, and the accelerators are rendered
543  * in the same way as they are in menus.
544  */
545 public enum GtkCellRendererAccelMode
546 {
547 	/**
548 	 * GTK+ accelerators mode
549 	 */
550 	GTK = 0,
551 	/**
552 	 * Other accelerator mode
553 	 */
554 	OTHER = 1,
555 }
556 alias GtkCellRendererAccelMode CellRendererAccelMode;
557 
558 /**
559  * Identifies how the user can interact with a particular cell.
560  */
561 public enum GtkCellRendererMode
562 {
563 	/**
564 	 * The cell is just for display
565 	 * and cannot be interacted with.  Note that this doesn’t mean that eg. the
566 	 * row being drawn can’t be selected -- just that a particular element of
567 	 * it cannot be individually modified.
568 	 */
569 	INERT = 0,
570 	/**
571 	 * The cell can be clicked.
572 	 */
573 	ACTIVATABLE = 1,
574 	/**
575 	 * The cell can be edited or otherwise modified.
576 	 */
577 	EDITABLE = 2,
578 }
579 alias GtkCellRendererMode CellRendererMode;
580 
581 /**
582  * Tells how a cell is to be rendered.
583  */
584 public enum GtkCellRendererState
585 {
586 	/**
587 	 * The cell is currently selected, and
588 	 * probably has a selection colored background to render to.
589 	 */
590 	SELECTED = 1,
591 	/**
592 	 * The mouse is hovering over the cell.
593 	 */
594 	PRELIT = 2,
595 	/**
596 	 * The cell is drawn in an insensitive manner
597 	 */
598 	INSENSITIVE = 4,
599 	/**
600 	 * The cell is in a sorted row
601 	 */
602 	SORTED = 8,
603 	/**
604 	 * The cell is in the focus row.
605 	 */
606 	FOCUSED = 16,
607 	/**
608 	 * The cell is in a row that can be expanded. Since 3.4
609 	 */
610 	EXPANDABLE = 32,
611 	/**
612 	 * The cell is in a row that is expanded. Since 3.4
613 	 */
614 	EXPANDED = 64,
615 }
616 alias GtkCellRendererState CellRendererState;
617 
618 /**
619  * Specifies which corner a child widget should be placed in when packed into
620  * a #GtkScrolledWindow. This is effectively the opposite of where the scroll
621  * bars are placed.
622  */
623 public enum GtkCornerType
624 {
625 	/**
626 	 * Place the scrollbars on the right and bottom of the
627 	 * widget (default behaviour).
628 	 */
629 	TOP_LEFT = 0,
630 	/**
631 	 * Place the scrollbars on the top and right of the
632 	 * widget.
633 	 */
634 	BOTTOM_LEFT = 1,
635 	/**
636 	 * Place the scrollbars on the left and bottom of the
637 	 * widget.
638 	 */
639 	TOP_RIGHT = 2,
640 	/**
641 	 * Place the scrollbars on the top and left of the
642 	 * widget.
643 	 */
644 	BOTTOM_RIGHT = 3,
645 }
646 alias GtkCornerType CornerType;
647 
648 /**
649  * Error codes for %GTK_CSS_PROVIDER_ERROR.
650  */
651 public enum GtkCssProviderError
652 {
653 	/**
654 	 * Failed.
655 	 */
656 	FAILED = 0,
657 	/**
658 	 * Syntax error.
659 	 */
660 	SYNTAX = 1,
661 	/**
662 	 * Import error.
663 	 */
664 	IMPORT = 2,
665 	/**
666 	 * Name error.
667 	 */
668 	NAME = 3,
669 	/**
670 	 * Deprecation error.
671 	 */
672 	DEPRECATED = 4,
673 	/**
674 	 * Unknown value.
675 	 */
676 	UNKNOWN_VALUE = 5,
677 }
678 alias GtkCssProviderError CssProviderError;
679 
680 /**
681  * The different types of sections indicate parts of a CSS document as
682  * parsed by GTK’s CSS parser. They are oriented towards the
683  * [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html),
684  * but may contain extensions.
685  *
686  * More types might be added in the future as the parser incorporates
687  * more features.
688  *
689  * Since: 3.2
690  */
691 public enum GtkCssSectionType
692 {
693 	/**
694 	 * The section describes a complete document.
695 	 * This section time is the only one where gtk_css_section_get_parent()
696 	 * might return %NULL.
697 	 */
698 	DOCUMENT = 0,
699 	/**
700 	 * The section defines an import rule.
701 	 */
702 	IMPORT = 1,
703 	/**
704 	 * The section defines a color. This
705 	 * is a GTK extension to CSS.
706 	 */
707 	COLOR_DEFINITION = 2,
708 	/**
709 	 * The section defines a binding set. This
710 	 * is a GTK extension to CSS.
711 	 */
712 	BINDING_SET = 3,
713 	/**
714 	 * The section defines a CSS ruleset.
715 	 */
716 	RULESET = 4,
717 	/**
718 	 * The section defines a CSS selector.
719 	 */
720 	SELECTOR = 5,
721 	/**
722 	 * The section defines the declaration of
723 	 * a CSS variable.
724 	 */
725 	DECLARATION = 6,
726 	/**
727 	 * The section defines the value of a CSS declaration.
728 	 */
729 	VALUE = 7,
730 	/**
731 	 * The section defines keyframes. See [CSS
732 	 * Animations](http://dev.w3.org/csswg/css3-animations/#keyframes) for details. Since 3.6
733 	 */
734 	KEYFRAMES = 8,
735 }
736 alias GtkCssSectionType CssSectionType;
737 
738 public enum GtkDebugFlag
739 {
740 	MISC = 1,
741 	PLUGSOCKET = 2,
742 	TEXT = 4,
743 	TREE = 8,
744 	UPDATES = 16,
745 	KEYBINDINGS = 32,
746 	MULTIHEAD = 64,
747 	MODULES = 128,
748 	GEOMETRY = 256,
749 	ICONTHEME = 512,
750 	PRINTING = 1024,
751 	BUILDER = 2048,
752 	SIZE_REQUEST = 4096,
753 	NO_CSS_CACHE = 8192,
754 	BASELINES = 16384,
755 	PIXEL_CACHE = 32768,
756 	NO_PIXEL_CACHE = 65536,
757 	INTERACTIVE = 131072,
758 	TOUCHSCREEN = 262144,
759 	ACTIONS = 524288,
760 	RESIZE = 1048576,
761 	LAYOUT = 2097152,
762 }
763 alias GtkDebugFlag DebugFlag;
764 
765 /**
766  * See also: #GtkEntry::delete-from-cursor.
767  */
768 public enum GtkDeleteType
769 {
770 	/**
771 	 * Delete characters.
772 	 */
773 	CHARS = 0,
774 	/**
775 	 * Delete only the portion of the word to the
776 	 * left/right of cursor if we’re in the middle of a word.
777 	 */
778 	WORD_ENDS = 1,
779 	/**
780 	 * Delete words.
781 	 */
782 	WORDS = 2,
783 	/**
784 	 * Delete display-lines. Display-lines
785 	 * refers to the visible lines, with respect to to the current line
786 	 * breaks. As opposed to paragraphs, which are defined by line
787 	 * breaks in the input.
788 	 */
789 	DISPLAY_LINES = 3,
790 	/**
791 	 * Delete only the portion of the
792 	 * display-line to the left/right of cursor.
793 	 */
794 	DISPLAY_LINE_ENDS = 4,
795 	/**
796 	 * Delete to the end of the
797 	 * paragraph. Like C-k in Emacs (or its reverse).
798 	 */
799 	PARAGRAPH_ENDS = 5,
800 	/**
801 	 * Delete entire line. Like C-k in pico.
802 	 */
803 	PARAGRAPHS = 6,
804 	/**
805 	 * Delete only whitespace. Like M-\ in Emacs.
806 	 */
807 	WHITESPACE = 7,
808 }
809 alias GtkDeleteType DeleteType;
810 
811 /**
812  * The #GtkDestDefaults enumeration specifies the various
813  * types of action that will be taken on behalf
814  * of the user for a drag destination site.
815  */
816 public enum GtkDestDefaults
817 {
818 	/**
819 	 * If set for a widget, GTK+, during a drag over this
820 	 * widget will check if the drag matches this widget’s list of possible targets
821 	 * and actions.
822 	 * GTK+ will then call gdk_drag_status() as appropriate.
823 	 */
824 	MOTION = 1,
825 	/**
826 	 * If set for a widget, GTK+ will draw a highlight on
827 	 * this widget as long as a drag is over this widget and the widget drag format
828 	 * and action are acceptable.
829 	 */
830 	HIGHLIGHT = 2,
831 	/**
832 	 * If set for a widget, when a drop occurs, GTK+ will
833 	 * will check if the drag matches this widget’s list of possible targets and
834 	 * actions. If so, GTK+ will call gtk_drag_get_data() on behalf of the widget.
835 	 * Whether or not the drop is successful, GTK+ will call gtk_drag_finish(). If
836 	 * the action was a move, then if the drag was successful, then %TRUE will be
837 	 * passed for the @delete parameter to gtk_drag_finish().
838 	 */
839 	DROP = 4,
840 	/**
841 	 * If set, specifies that all default actions should
842 	 * be taken.
843 	 */
844 	ALL = 7,
845 }
846 alias GtkDestDefaults DestDefaults;
847 
848 /**
849  * Flags used to influence dialog construction.
850  */
851 public enum GtkDialogFlags
852 {
853 	/**
854 	 * Make the constructed dialog modal,
855 	 * see gtk_window_set_modal()
856 	 */
857 	MODAL = 1,
858 	/**
859 	 * Destroy the dialog when its
860 	 * parent is destroyed, see gtk_window_set_destroy_with_parent()
861 	 */
862 	DESTROY_WITH_PARENT = 2,
863 	/**
864 	 * Create dialog with actions in header
865 	 * bar instead of action area. Since 3.12.
866 	 */
867 	USE_HEADER_BAR = 4,
868 }
869 alias GtkDialogFlags DialogFlags;
870 
871 /**
872  * Focus movement types.
873  */
874 public enum GtkDirectionType
875 {
876 	/**
877 	 * Move forward.
878 	 */
879 	TAB_FORWARD = 0,
880 	/**
881 	 * Move backward.
882 	 */
883 	TAB_BACKWARD = 1,
884 	/**
885 	 * Move up.
886 	 */
887 	UP = 2,
888 	/**
889 	 * Move down.
890 	 */
891 	DOWN = 3,
892 	/**
893 	 * Move left.
894 	 */
895 	LEFT = 4,
896 	/**
897 	 * Move right.
898 	 */
899 	RIGHT = 5,
900 }
901 alias GtkDirectionType DirectionType;
902 
903 /**
904  * Gives an indication why a drag operation failed.
905  * The value can by obtained by connecting to the
906  * #GtkWidget::drag-failed signal.
907  */
908 public enum GtkDragResult
909 {
910 	/**
911 	 * The drag operation was successful.
912 	 */
913 	SUCCESS = 0,
914 	/**
915 	 * No suitable drag target.
916 	 */
917 	NO_TARGET = 1,
918 	/**
919 	 * The user cancelled the drag operation.
920 	 */
921 	USER_CANCELLED = 2,
922 	/**
923 	 * The drag operation timed out.
924 	 */
925 	TIMEOUT_EXPIRED = 3,
926 	/**
927 	 * The pointer or keyboard grab used
928 	 * for the drag operation was broken.
929 	 */
930 	GRAB_BROKEN = 4,
931 	/**
932 	 * The drag operation failed due to some
933 	 * unspecified error.
934 	 */
935 	ERROR = 5,
936 }
937 alias GtkDragResult DragResult;
938 
939 /**
940  * Specifies the side of the entry at which an icon is placed.
941  *
942  * Since: 2.16
943  */
944 public enum GtkEntryIconPosition
945 {
946 	/**
947 	 * At the beginning of the entry (depending on the text direction).
948 	 */
949 	PRIMARY = 0,
950 	/**
951 	 * At the end of the entry (depending on the text direction).
952 	 */
953 	SECONDARY = 1,
954 }
955 alias GtkEntryIconPosition EntryIconPosition;
956 
957 /**
958  * Describes the state of a #GdkEventSequence in a #GtkGesture.
959  *
960  * Since: 3.14
961  */
962 public enum GtkEventSequenceState
963 {
964 	/**
965 	 * The sequence is handled, but not grabbed.
966 	 */
967 	NONE = 0,
968 	/**
969 	 * The sequence is handled and grabbed.
970 	 */
971 	CLAIMED = 1,
972 	/**
973 	 * The sequence is denied.
974 	 */
975 	DENIED = 2,
976 }
977 alias GtkEventSequenceState EventSequenceState;
978 
979 /**
980  * Used to specify the style of the expanders drawn by a #GtkTreeView.
981  */
982 public enum GtkExpanderStyle
983 {
984 	/**
985 	 * The style used for a collapsed subtree.
986 	 */
987 	COLLAPSED = 0,
988 	/**
989 	 * Intermediate style used during animation.
990 	 */
991 	SEMI_COLLAPSED = 1,
992 	/**
993 	 * Intermediate style used during animation.
994 	 */
995 	SEMI_EXPANDED = 2,
996 	/**
997 	 * The style used for an expanded subtree.
998 	 */
999 	EXPANDED = 3,
1000 }
1001 alias GtkExpanderStyle ExpanderStyle;
1002 
1003 /**
1004  * Describes whether a #GtkFileChooser is being used to open existing files
1005  * or to save to a possibly new file.
1006  */
1007 public enum GtkFileChooserAction
1008 {
1009 	/**
1010 	 * Indicates open mode.  The file chooser
1011 	 * will only let the user pick an existing file.
1012 	 */
1013 	OPEN = 0,
1014 	/**
1015 	 * Indicates save mode.  The file chooser
1016 	 * will let the user pick an existing file, or type in a new
1017 	 * filename.
1018 	 */
1019 	SAVE = 1,
1020 	/**
1021 	 * Indicates an Open mode for
1022 	 * selecting folders.  The file chooser will let the user pick an
1023 	 * existing folder.
1024 	 */
1025 	SELECT_FOLDER = 2,
1026 	/**
1027 	 * Indicates a mode for creating a
1028 	 * new folder.  The file chooser will let the user name an existing or
1029 	 * new folder.
1030 	 */
1031 	CREATE_FOLDER = 3,
1032 }
1033 alias GtkFileChooserAction FileChooserAction;
1034 
1035 /**
1036  * Used as a return value of handlers for the
1037  * #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This
1038  * value determines whether the file chooser will present the stock
1039  * confirmation dialog, accept the user’s choice of a filename, or
1040  * let the user choose another filename.
1041  *
1042  * Since: 2.8
1043  */
1044 public enum GtkFileChooserConfirmation
1045 {
1046 	/**
1047 	 * The file chooser will present
1048 	 * its stock dialog to confirm about overwriting an existing file.
1049 	 */
1050 	CONFIRM = 0,
1051 	/**
1052 	 * The file chooser will
1053 	 * terminate and accept the user’s choice of a file name.
1054 	 */
1055 	ACCEPT_FILENAME = 1,
1056 	/**
1057 	 * The file chooser will
1058 	 * continue running, so as to let the user select another file name.
1059 	 */
1060 	SELECT_AGAIN = 2,
1061 }
1062 alias GtkFileChooserConfirmation FileChooserConfirmation;
1063 
1064 /**
1065  * These identify the various errors that can occur while calling
1066  * #GtkFileChooser functions.
1067  */
1068 public enum GtkFileChooserError
1069 {
1070 	/**
1071 	 * Indicates that a file does not exist.
1072 	 */
1073 	NONEXISTENT = 0,
1074 	/**
1075 	 * Indicates a malformed filename.
1076 	 */
1077 	BAD_FILENAME = 1,
1078 	/**
1079 	 * Indicates a duplicate path (e.g. when
1080 	 * adding a bookmark).
1081 	 */
1082 	ALREADY_EXISTS = 2,
1083 	/**
1084 	 * Indicates an incomplete hostname (e.g. "http://foo" without a slash after that).
1085 	 */
1086 	INCOMPLETE_HOSTNAME = 3,
1087 }
1088 alias GtkFileChooserError FileChooserError;
1089 
1090 /**
1091  * These flags indicate what parts of a #GtkFileFilterInfo struct
1092  * are filled or need to be filled.
1093  */
1094 public enum GtkFileFilterFlags
1095 {
1096 	/**
1097 	 * the filename of the file being tested
1098 	 */
1099 	FILENAME = 1,
1100 	/**
1101 	 * the URI for the file being tested
1102 	 */
1103 	URI = 2,
1104 	/**
1105 	 * the string that will be used to
1106 	 * display the file in the file chooser
1107 	 */
1108 	DISPLAY_NAME = 4,
1109 	/**
1110 	 * the mime type of the file
1111 	 */
1112 	MIME_TYPE = 8,
1113 }
1114 alias GtkFileFilterFlags FileFilterFlags;
1115 
1116 /**
1117  * Style for input method preedit. See also
1118  * #GtkSettings:gtk-im-preedit-style
1119  */
1120 public enum GtkIMPreeditStyle
1121 {
1122 	/**
1123 	 * Deprecated
1124 	 */
1125 	NOTHING = 0,
1126 	/**
1127 	 * Deprecated
1128 	 */
1129 	CALLBACK = 1,
1130 	/**
1131 	 * Deprecated
1132 	 */
1133 	NONE = 2,
1134 }
1135 alias GtkIMPreeditStyle IMPreeditStyle;
1136 
1137 /**
1138  * Style for input method status. See also
1139  * #GtkSettings:gtk-im-status-style
1140  */
1141 public enum GtkIMStatusStyle
1142 {
1143 	/**
1144 	 * Deprecated
1145 	 */
1146 	NOTHING = 0,
1147 	/**
1148 	 * Deprecated
1149 	 */
1150 	CALLBACK = 1,
1151 	/**
1152 	 * Deprecated
1153 	 */
1154 	NONE = 2,
1155 }
1156 alias GtkIMStatusStyle IMStatusStyle;
1157 
1158 /**
1159  * Used to specify options for gtk_icon_theme_lookup_icon()
1160  */
1161 public enum GtkIconLookupFlags
1162 {
1163 	/**
1164 	 * Never get SVG icons, even if gdk-pixbuf
1165 	 * supports them. Cannot be used together with %GTK_ICON_LOOKUP_FORCE_SVG.
1166 	 */
1167 	NO_SVG = 1,
1168 	/**
1169 	 * Get SVG icons, even if gdk-pixbuf
1170 	 * doesn’t support them.
1171 	 * Cannot be used together with %GTK_ICON_LOOKUP_NO_SVG.
1172 	 */
1173 	FORCE_SVG = 2,
1174 	/**
1175 	 * When passed to
1176 	 * gtk_icon_theme_lookup_icon() includes builtin icons
1177 	 * as well as files. For a builtin icon, gtk_icon_info_get_filename()
1178 	 * is %NULL and you need to call gtk_icon_info_get_builtin_pixbuf().
1179 	 */
1180 	USE_BUILTIN = 4,
1181 	/**
1182 	 * Try to shorten icon name at '-'
1183 	 * characters before looking at inherited themes. This flag is only
1184 	 * supported in functions that take a single icon name. For more general
1185 	 * fallback, see gtk_icon_theme_choose_icon(). Since 2.12.
1186 	 */
1187 	GENERIC_FALLBACK = 8,
1188 	/**
1189 	 * Always get the icon scaled to the
1190 	 * requested size. Since 2.14.
1191 	 */
1192 	FORCE_SIZE = 16,
1193 	/**
1194 	 * Try to always load regular icons, even
1195 	 * when symbolic icon names are given. Since 3.14.
1196 	 */
1197 	FORCE_REGULAR = 32,
1198 	/**
1199 	 * Try to always load symbolic icons, even
1200 	 * when regular icon names are given. Since 3.14.
1201 	 */
1202 	FORCE_SYMBOLIC = 64,
1203 	/**
1204 	 * Try to load a variant of the icon for left-to-right
1205 	 * text direction. Since 3.14.
1206 	 */
1207 	DIR_LTR = 128,
1208 	/**
1209 	 * Try to load a variant of the icon for right-to-left
1210 	 * text direction. Since 3.14.
1211 	 */
1212 	DIR_RTL = 256,
1213 }
1214 alias GtkIconLookupFlags IconLookupFlags;
1215 
1216 /**
1217  * Built-in stock icon sizes.
1218  */
1219 public enum GtkIconSize
1220 {
1221 	/**
1222 	 * Invalid size.
1223 	 */
1224 	INVALID = 0,
1225 	/**
1226 	 * Size appropriate for menus (16px).
1227 	 */
1228 	MENU = 1,
1229 	/**
1230 	 * Size appropriate for small toolbars (16px).
1231 	 */
1232 	SMALL_TOOLBAR = 2,
1233 	/**
1234 	 * Size appropriate for large toolbars (24px)
1235 	 */
1236 	LARGE_TOOLBAR = 3,
1237 	/**
1238 	 * Size appropriate for buttons (16px)
1239 	 */
1240 	BUTTON = 4,
1241 	/**
1242 	 * Size appropriate for drag and drop (32px)
1243 	 */
1244 	DND = 5,
1245 	/**
1246 	 * Size appropriate for dialogs (48px)
1247 	 */
1248 	DIALOG = 6,
1249 }
1250 alias GtkIconSize IconSize;
1251 
1252 /**
1253  * Error codes for GtkIconTheme operations.
1254  */
1255 public enum GtkIconThemeError
1256 {
1257 	/**
1258 	 * The icon specified does not exist in the theme
1259 	 */
1260 	NOT_FOUND = 0,
1261 	/**
1262 	 * An unspecified error occurred.
1263 	 */
1264 	FAILED = 1,
1265 }
1266 alias GtkIconThemeError IconThemeError;
1267 
1268 /**
1269  * An enum for determining where a dropped item goes.
1270  */
1271 public enum GtkIconViewDropPosition
1272 {
1273 	/**
1274 	 * no drop possible
1275 	 */
1276 	NO_DROP = 0,
1277 	/**
1278 	 * dropped item replaces the item
1279 	 */
1280 	DROP_INTO = 1,
1281 	/**
1282 	 * droppped item is inserted to the left
1283 	 */
1284 	DROP_LEFT = 2,
1285 	/**
1286 	 * dropped item is inserted to the right
1287 	 */
1288 	DROP_RIGHT = 3,
1289 	/**
1290 	 * dropped item is inserted above
1291 	 */
1292 	DROP_ABOVE = 4,
1293 	/**
1294 	 * dropped item is inserted below
1295 	 */
1296 	DROP_BELOW = 5,
1297 }
1298 alias GtkIconViewDropPosition IconViewDropPosition;
1299 
1300 /**
1301  * Describes the image data representation used by a #GtkImage. If you
1302  * want to get the image from the widget, you can only get the
1303  * currently-stored representation. e.g.  if the
1304  * gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can
1305  * call gtk_image_get_pixbuf() but not gtk_image_get_stock().  For empty
1306  * images, you can request any storage type (call any of the "get"
1307  * functions), but they will all return %NULL values.
1308  */
1309 public enum GtkImageType
1310 {
1311 	/**
1312 	 * there is no image displayed by the widget
1313 	 */
1314 	EMPTY = 0,
1315 	/**
1316 	 * the widget contains a #GdkPixbuf
1317 	 */
1318 	PIXBUF = 1,
1319 	/**
1320 	 * the widget contains a [stock item name][gtkstock]
1321 	 */
1322 	STOCK = 2,
1323 	/**
1324 	 * the widget contains a #GtkIconSet
1325 	 */
1326 	ICON_SET = 3,
1327 	/**
1328 	 * the widget contains a #GdkPixbufAnimation
1329 	 */
1330 	ANIMATION = 4,
1331 	/**
1332 	 * the widget contains a named icon.
1333 	 * This image type was added in GTK+ 2.6
1334 	 */
1335 	ICON_NAME = 5,
1336 	/**
1337 	 * the widget contains a #GIcon.
1338 	 * This image type was added in GTK+ 2.14
1339 	 */
1340 	GICON = 6,
1341 	/**
1342 	 * the widget contains a #cairo_surface_t.
1343 	 * This image type was added in GTK+ 3.10
1344 	 */
1345 	SURFACE = 7,
1346 }
1347 alias GtkImageType ImageType;
1348 
1349 /**
1350  * Describes hints that might be taken into account by input methods
1351  * or applications. Note that input methods may already tailor their
1352  * behaviour according to the #GtkInputPurpose of the entry.
1353  *
1354  * Some common sense is expected when using these flags - mixing
1355  * @GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.
1356  *
1357  * This enumeration may be extended in the future; input methods should
1358  * ignore unknown values.
1359  *
1360  * Since: 3.6
1361  */
1362 public enum GtkInputHints
1363 {
1364 	/**
1365 	 * No special behaviour suggested
1366 	 */
1367 	NONE = 0,
1368 	/**
1369 	 * Suggest checking for typos
1370 	 */
1371 	SPELLCHECK = 1,
1372 	/**
1373 	 * Suggest not checking for typos
1374 	 */
1375 	NO_SPELLCHECK = 2,
1376 	/**
1377 	 * Suggest word completion
1378 	 */
1379 	WORD_COMPLETION = 4,
1380 	/**
1381 	 * Suggest to convert all text to lowercase
1382 	 */
1383 	LOWERCASE = 8,
1384 	/**
1385 	 * Suggest to capitalize all text
1386 	 */
1387 	UPPERCASE_CHARS = 16,
1388 	/**
1389 	 * Suggest to capitalize the first
1390 	 * character of each word
1391 	 */
1392 	UPPERCASE_WORDS = 32,
1393 	/**
1394 	 * Suggest to capitalize the
1395 	 * first word of each sentence
1396 	 */
1397 	UPPERCASE_SENTENCES = 64,
1398 	/**
1399 	 * Suggest to not show an onscreen keyboard
1400 	 * (e.g for a calculator that already has all the keys).
1401 	 */
1402 	INHIBIT_OSK = 128,
1403 	/**
1404 	 * The text is vertical. Since 3.18
1405 	 */
1406 	VERTICAL_WRITING = 256,
1407 	/**
1408 	 * Suggest offering Emoji support. Since 3.22.20
1409 	 */
1410 	EMOJI = 512,
1411 	/**
1412 	 * Suggest not offering Emoji support. Since 3.22.20
1413 	 */
1414 	NO_EMOJI = 1024,
1415 }
1416 alias GtkInputHints InputHints;
1417 
1418 /**
1419  * Describes primary purpose of the input widget. This information is
1420  * useful for on-screen keyboards and similar input methods to decide
1421  * which keys should be presented to the user.
1422  *
1423  * Note that the purpose is not meant to impose a totally strict rule
1424  * about allowed characters, and does not replace input validation.
1425  * It is fine for an on-screen keyboard to let the user override the
1426  * character set restriction that is expressed by the purpose. The
1427  * application is expected to validate the entry contents, even if
1428  * it specified a purpose.
1429  *
1430  * The difference between @GTK_INPUT_PURPOSE_DIGITS and
1431  * @GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits
1432  * while the latter also some punctuation (like commas or points, plus,
1433  * minus) and “e” or “E” as in 3.14E+000.
1434  *
1435  * This enumeration may be extended in the future; input methods should
1436  * interpret unknown values as “free form”.
1437  *
1438  * Since: 3.6
1439  */
1440 public enum GtkInputPurpose
1441 {
1442 	/**
1443 	 * Allow any character
1444 	 */
1445 	FREE_FORM = 0,
1446 	/**
1447 	 * Allow only alphabetic characters
1448 	 */
1449 	ALPHA = 1,
1450 	/**
1451 	 * Allow only digits
1452 	 */
1453 	DIGITS = 2,
1454 	/**
1455 	 * Edited field expects numbers
1456 	 */
1457 	NUMBER = 3,
1458 	/**
1459 	 * Edited field expects phone number
1460 	 */
1461 	PHONE = 4,
1462 	/**
1463 	 * Edited field expects URL
1464 	 */
1465 	URL = 5,
1466 	/**
1467 	 * Edited field expects email address
1468 	 */
1469 	EMAIL = 6,
1470 	/**
1471 	 * Edited field expects the name of a person
1472 	 */
1473 	NAME = 7,
1474 	/**
1475 	 * Like @GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden
1476 	 */
1477 	PASSWORD = 8,
1478 	/**
1479 	 * Like @GTK_INPUT_PURPOSE_DIGITS, but characters are hidden
1480 	 */
1481 	PIN = 9,
1482 }
1483 alias GtkInputPurpose InputPurpose;
1484 
1485 /**
1486  * Describes how a rendered element connects to adjacent elements.
1487  */
1488 public enum GtkJunctionSides
1489 {
1490 	/**
1491 	 * No junctions.
1492 	 */
1493 	NONE = 0,
1494 	/**
1495 	 * Element connects on the top-left corner.
1496 	 */
1497 	CORNER_TOPLEFT = 1,
1498 	/**
1499 	 * Element connects on the top-right corner.
1500 	 */
1501 	CORNER_TOPRIGHT = 2,
1502 	/**
1503 	 * Element connects on the bottom-left corner.
1504 	 */
1505 	CORNER_BOTTOMLEFT = 4,
1506 	/**
1507 	 * Element connects on the bottom-right corner.
1508 	 */
1509 	CORNER_BOTTOMRIGHT = 8,
1510 	/**
1511 	 * Element connects on the top side.
1512 	 */
1513 	TOP = 3,
1514 	/**
1515 	 * Element connects on the bottom side.
1516 	 */
1517 	BOTTOM = 12,
1518 	/**
1519 	 * Element connects on the left side.
1520 	 */
1521 	LEFT = 5,
1522 	/**
1523 	 * Element connects on the right side.
1524 	 */
1525 	RIGHT = 10,
1526 }
1527 alias GtkJunctionSides JunctionSides;
1528 
1529 /**
1530  * Used for justifying the text inside a #GtkLabel widget. (See also
1531  * #GtkAlignment).
1532  */
1533 public enum GtkJustification
1534 {
1535 	/**
1536 	 * The text is placed at the left edge of the label.
1537 	 */
1538 	LEFT = 0,
1539 	/**
1540 	 * The text is placed at the right edge of the label.
1541 	 */
1542 	RIGHT = 1,
1543 	/**
1544 	 * The text is placed in the center of the label.
1545 	 */
1546 	CENTER = 2,
1547 	/**
1548 	 * The text is placed is distributed across the label.
1549 	 */
1550 	FILL = 3,
1551 }
1552 alias GtkJustification Justification;
1553 
1554 /**
1555  * Describes how #GtkLevelBar contents should be rendered.
1556  * Note that this enumeration could be extended with additional modes
1557  * in the future.
1558  *
1559  * Since: 3.6
1560  */
1561 public enum GtkLevelBarMode
1562 {
1563 	/**
1564 	 * the bar has a continuous mode
1565 	 */
1566 	CONTINUOUS = 0,
1567 	/**
1568 	 * the bar has a discrete mode
1569 	 */
1570 	DISCRETE = 1,
1571 }
1572 alias GtkLevelBarMode LevelBarMode;
1573 
1574 /**
1575  * The type of license for an application.
1576  *
1577  * This enumeration can be expanded at later date.
1578  *
1579  * Since: 3.0
1580  */
1581 public enum GtkLicense
1582 {
1583 	/**
1584 	 * No license specified
1585 	 */
1586 	UNKNOWN = 0,
1587 	/**
1588 	 * A license text is going to be specified by the
1589 	 * developer
1590 	 */
1591 	CUSTOM = 1,
1592 	/**
1593 	 * The GNU General Public License, version 2.0 or later
1594 	 */
1595 	GPL_2_0 = 2,
1596 	/**
1597 	 * The GNU General Public License, version 3.0 or later
1598 	 */
1599 	GPL_3_0 = 3,
1600 	/**
1601 	 * The GNU Lesser General Public License, version 2.1 or later
1602 	 */
1603 	LGPL_2_1 = 4,
1604 	/**
1605 	 * The GNU Lesser General Public License, version 3.0 or later
1606 	 */
1607 	LGPL_3_0 = 5,
1608 	/**
1609 	 * The BSD standard license
1610 	 */
1611 	BSD = 6,
1612 	/**
1613 	 * The MIT/X11 standard license
1614 	 */
1615 	MIT_X11 = 7,
1616 	/**
1617 	 * The Artistic License, version 2.0
1618 	 */
1619 	ARTISTIC = 8,
1620 	/**
1621 	 * The GNU General Public License, version 2.0 only. Since 3.12.
1622 	 */
1623 	GPL_2_0_ONLY = 9,
1624 	/**
1625 	 * The GNU General Public License, version 3.0 only. Since 3.12.
1626 	 */
1627 	GPL_3_0_ONLY = 10,
1628 	/**
1629 	 * The GNU Lesser General Public License, version 2.1 only. Since 3.12.
1630 	 */
1631 	LGPL_2_1_ONLY = 11,
1632 	/**
1633 	 * The GNU Lesser General Public License, version 3.0 only. Since 3.12.
1634 	 */
1635 	LGPL_3_0_ONLY = 12,
1636 	/**
1637 	 * The GNU Affero General Public License, version 3.0 or later. Since: 3.22.
1638 	 */
1639 	AGPL_3_0 = 13,
1640 	/**
1641 	 * The GNU Affero General Public License, version 3.0 only. Since: 3.22.27.
1642 	 */
1643 	AGPL_3_0_ONLY = 14,
1644 }
1645 alias GtkLicense License;
1646 
1647 /**
1648  * An enumeration representing directional movements within a menu.
1649  */
1650 public enum GtkMenuDirectionType
1651 {
1652 	/**
1653 	 * To the parent menu shell
1654 	 */
1655 	PARENT = 0,
1656 	/**
1657 	 * To the submenu, if any, associated with the item
1658 	 */
1659 	CHILD = 1,
1660 	/**
1661 	 * To the next menu item
1662 	 */
1663 	NEXT = 2,
1664 	/**
1665 	 * To the previous menu item
1666 	 */
1667 	PREV = 3,
1668 }
1669 alias GtkMenuDirectionType MenuDirectionType;
1670 
1671 /**
1672  * The type of message being displayed in the dialog.
1673  */
1674 public enum GtkMessageType : uint
1675 {
1676 	/**
1677 	 * Informational message
1678 	 */
1679 	INFO = 0,
1680 	/**
1681 	 * Non-fatal warning message
1682 	 */
1683 	WARNING = 1,
1684 	/**
1685 	 * Question requiring a choice
1686 	 */
1687 	QUESTION = 2,
1688 	/**
1689 	 * Fatal error message
1690 	 */
1691 	ERROR = 3,
1692 	/**
1693 	 * None of the above
1694 	 */
1695 	OTHER = 4,
1696 }
1697 alias GtkMessageType MessageType;
1698 
1699 public enum GtkMovementStep
1700 {
1701 	/**
1702 	 * Move forward or back by graphemes
1703 	 */
1704 	LOGICAL_POSITIONS = 0,
1705 	/**
1706 	 * Move left or right by graphemes
1707 	 */
1708 	VISUAL_POSITIONS = 1,
1709 	/**
1710 	 * Move forward or back by words
1711 	 */
1712 	WORDS = 2,
1713 	/**
1714 	 * Move up or down lines (wrapped lines)
1715 	 */
1716 	DISPLAY_LINES = 3,
1717 	/**
1718 	 * Move to either end of a line
1719 	 */
1720 	DISPLAY_LINE_ENDS = 4,
1721 	/**
1722 	 * Move up or down paragraphs (newline-ended lines)
1723 	 */
1724 	PARAGRAPHS = 5,
1725 	/**
1726 	 * Move to either end of a paragraph
1727 	 */
1728 	PARAGRAPH_ENDS = 6,
1729 	/**
1730 	 * Move by pages
1731 	 */
1732 	PAGES = 7,
1733 	/**
1734 	 * Move to ends of the buffer
1735 	 */
1736 	BUFFER_ENDS = 8,
1737 	/**
1738 	 * Move horizontally by pages
1739 	 */
1740 	HORIZONTAL_PAGES = 9,
1741 }
1742 alias GtkMovementStep MovementStep;
1743 
1744 public enum GtkNotebookTab
1745 {
1746 	FIRST = 0,
1747 	LAST = 1,
1748 }
1749 alias GtkNotebookTab NotebookTab;
1750 
1751 /**
1752  * Used to determine the layout of pages on a sheet when printing
1753  * multiple pages per sheet.
1754  */
1755 public enum GtkNumberUpLayout
1756 {
1757 	/**
1758 	 * ![](layout-lrtb.png)
1759 	 */
1760 	LRTB = 0,
1761 	/**
1762 	 * ![](layout-lrbt.png)
1763 	 */
1764 	LRBT = 1,
1765 	/**
1766 	 * ![](layout-rltb.png)
1767 	 */
1768 	RLTB = 2,
1769 	/**
1770 	 * ![](layout-rlbt.png)
1771 	 */
1772 	RLBT = 3,
1773 	/**
1774 	 * ![](layout-tblr.png)
1775 	 */
1776 	TBLR = 4,
1777 	/**
1778 	 * ![](layout-tbrl.png)
1779 	 */
1780 	TBRL = 5,
1781 	/**
1782 	 * ![](layout-btlr.png)
1783 	 */
1784 	BTLR = 6,
1785 	/**
1786 	 * ![](layout-btrl.png)
1787 	 */
1788 	BTRL = 7,
1789 }
1790 alias GtkNumberUpLayout NumberUpLayout;
1791 
1792 /**
1793  * Represents the orientation of widgets and other objects which can be switched
1794  * between horizontal and vertical orientation on the fly, like #GtkToolbar or
1795  * #GtkGesturePan.
1796  */
1797 public enum GtkOrientation
1798 {
1799 	/**
1800 	 * The element is in horizontal orientation.
1801 	 */
1802 	HORIZONTAL = 0,
1803 	/**
1804 	 * The element is in vertical orientation.
1805 	 */
1806 	VERTICAL = 1,
1807 }
1808 alias GtkOrientation Orientation;
1809 
1810 /**
1811  * Determines how widgets should be packed inside menubars
1812  * and menuitems contained in menubars.
1813  */
1814 public enum GtkPackDirection
1815 {
1816 	/**
1817 	 * Widgets are packed left-to-right
1818 	 */
1819 	LTR = 0,
1820 	/**
1821 	 * Widgets are packed right-to-left
1822 	 */
1823 	RTL = 1,
1824 	/**
1825 	 * Widgets are packed top-to-bottom
1826 	 */
1827 	TTB = 2,
1828 	/**
1829 	 * Widgets are packed bottom-to-top
1830 	 */
1831 	BTT = 3,
1832 }
1833 alias GtkPackDirection PackDirection;
1834 
1835 /**
1836  * Represents the packing location #GtkBox children. (See: #GtkVBox,
1837  * #GtkHBox, and #GtkButtonBox).
1838  */
1839 public enum GtkPackType
1840 {
1841 	/**
1842 	 * The child is packed into the start of the box
1843 	 */
1844 	START = 0,
1845 	/**
1846 	 * The child is packed into the end of the box
1847 	 */
1848 	END = 1,
1849 }
1850 alias GtkPackType PackType;
1851 
1852 /**
1853  * The type of a pad action.
1854  */
1855 public enum GtkPadActionType
1856 {
1857 	/**
1858 	 * Action is triggered by a pad button
1859 	 */
1860 	BUTTON = 0,
1861 	/**
1862 	 * Action is triggered by a pad ring
1863 	 */
1864 	RING = 1,
1865 	/**
1866 	 * Action is triggered by a pad strip
1867 	 */
1868 	STRIP = 2,
1869 }
1870 alias GtkPadActionType PadActionType;
1871 
1872 /**
1873  * See also gtk_print_settings_set_orientation().
1874  */
1875 public enum GtkPageOrientation
1876 {
1877 	/**
1878 	 * Portrait mode.
1879 	 */
1880 	PORTRAIT = 0,
1881 	/**
1882 	 * Landscape mode.
1883 	 */
1884 	LANDSCAPE = 1,
1885 	/**
1886 	 * Reverse portrait mode.
1887 	 */
1888 	REVERSE_PORTRAIT = 2,
1889 	/**
1890 	 * Reverse landscape mode.
1891 	 */
1892 	REVERSE_LANDSCAPE = 3,
1893 }
1894 alias GtkPageOrientation PageOrientation;
1895 
1896 /**
1897  * See also gtk_print_job_set_page_set().
1898  */
1899 public enum GtkPageSet
1900 {
1901 	/**
1902 	 * All pages.
1903 	 */
1904 	ALL = 0,
1905 	/**
1906 	 * Even pages.
1907 	 */
1908 	EVEN = 1,
1909 	/**
1910 	 * Odd pages.
1911 	 */
1912 	ODD = 2,
1913 }
1914 alias GtkPageSet PageSet;
1915 
1916 /**
1917  * Describes the panning direction of a #GtkGesturePan
1918  *
1919  * Since: 3.14
1920  */
1921 public enum GtkPanDirection
1922 {
1923 	/**
1924 	 * panned towards the left
1925 	 */
1926 	LEFT = 0,
1927 	/**
1928 	 * panned towards the right
1929 	 */
1930 	RIGHT = 1,
1931 	/**
1932 	 * panned upwards
1933 	 */
1934 	UP = 2,
1935 	/**
1936 	 * panned downwards
1937 	 */
1938 	DOWN = 3,
1939 }
1940 alias GtkPanDirection PanDirection;
1941 
1942 /**
1943  * Priorities for path lookups.
1944  * See also gtk_binding_set_add_path().
1945  */
1946 public enum GtkPathPriorityType
1947 {
1948 	/**
1949 	 * Deprecated
1950 	 */
1951 	LOWEST = 0,
1952 	/**
1953 	 * Deprecated
1954 	 */
1955 	GTK = 4,
1956 	/**
1957 	 * Deprecated
1958 	 */
1959 	APPLICATION = 8,
1960 	/**
1961 	 * Deprecated
1962 	 */
1963 	THEME = 10,
1964 	/**
1965 	 * Deprecated
1966 	 */
1967 	RC = 12,
1968 	/**
1969 	 * Deprecated
1970 	 */
1971 	HIGHEST = 15,
1972 }
1973 alias GtkPathPriorityType PathPriorityType;
1974 
1975 /**
1976  * Widget path types.
1977  * See also gtk_binding_set_add_path().
1978  */
1979 public enum GtkPathType
1980 {
1981 	/**
1982 	 * Deprecated
1983 	 */
1984 	WIDGET = 0,
1985 	/**
1986 	 * Deprecated
1987 	 */
1988 	WIDGET_CLASS = 1,
1989 	/**
1990 	 * Deprecated
1991 	 */
1992 	CLASS = 2,
1993 }
1994 alias GtkPathType PathType;
1995 
1996 /**
1997  * These flags serve two purposes.  First, the application can call gtk_places_sidebar_set_open_flags()
1998  * using these flags as a bitmask.  This tells the sidebar that the application is able to open
1999  * folders selected from the sidebar in various ways, for example, in new tabs or in new windows in
2000  * addition to the normal mode.
2001  *
2002  * Second, when one of these values gets passed back to the application in the
2003  * #GtkPlacesSidebar::open-location signal, it means that the application should
2004  * open the selected location in the normal way, in a new tab, or in a new
2005  * window.  The sidebar takes care of determining the desired way to open the location,
2006  * based on the modifier keys that the user is pressing at the time the selection is made.
2007  *
2008  * If the application never calls gtk_places_sidebar_set_open_flags(), then the sidebar will only
2009  * use #GTK_PLACES_OPEN_NORMAL in the #GtkPlacesSidebar::open-location signal.  This is the
2010  * default mode of operation.
2011  */
2012 public enum GtkPlacesOpenFlags
2013 {
2014 	/**
2015 	 * This is the default mode that #GtkPlacesSidebar uses if no other flags
2016 	 * are specified.  It indicates that the calling application should open the selected location
2017 	 * in the normal way, for example, in the folder view beside the sidebar.
2018 	 */
2019 	NORMAL = 1,
2020 	/**
2021 	 * When passed to gtk_places_sidebar_set_open_flags(), this indicates
2022 	 * that the application can open folders selected from the sidebar in new tabs.  This value
2023 	 * will be passed to the #GtkPlacesSidebar::open-location signal when the user selects
2024 	 * that a location be opened in a new tab instead of in the standard fashion.
2025 	 */
2026 	NEW_TAB = 2,
2027 	/**
2028 	 * Similar to @GTK_PLACES_OPEN_NEW_TAB, but indicates that the application
2029 	 * can open folders in new windows.
2030 	 */
2031 	NEW_WINDOW = 4,
2032 }
2033 alias GtkPlacesOpenFlags PlacesOpenFlags;
2034 
2035 /**
2036  * Determines how the size should be computed to achieve the one of the
2037  * visibility mode for the scrollbars.
2038  */
2039 public enum GtkPolicyType
2040 {
2041 	/**
2042 	 * The scrollbar is always visible. The view size is
2043 	 * independent of the content.
2044 	 */
2045 	ALWAYS = 0,
2046 	/**
2047 	 * The scrollbar will appear and disappear as necessary.
2048 	 * For example, when all of a #GtkTreeView can not be seen.
2049 	 */
2050 	AUTOMATIC = 1,
2051 	/**
2052 	 * The scrollbar should never appear. In this mode the
2053 	 * content determines the size.
2054 	 */
2055 	NEVER = 2,
2056 	/**
2057 	 * Don't show a scrollbar, but don't force the
2058 	 * size to follow the content. This can be used e.g. to make multiple
2059 	 * scrolled windows share a scrollbar. Since: 3.16
2060 	 */
2061 	EXTERNAL = 3,
2062 }
2063 alias GtkPolicyType PolicyType;
2064 
2065 /**
2066  * Describes constraints to positioning of popovers. More values
2067  * may be added to this enumeration in the future.
2068  *
2069  * Since: 3.20
2070  */
2071 public enum GtkPopoverConstraint
2072 {
2073 	/**
2074 	 * Don't constrain the popover position
2075 	 * beyond what is imposed by the implementation
2076 	 */
2077 	NONE = 0,
2078 	/**
2079 	 * Constrain the popover to the boundaries
2080 	 * of the window that it is attached to
2081 	 */
2082 	WINDOW = 1,
2083 }
2084 alias GtkPopoverConstraint PopoverConstraint;
2085 
2086 /**
2087  * Describes which edge of a widget a certain feature is positioned at, e.g. the
2088  * tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a
2089  * #GtkScale.
2090  */
2091 public enum GtkPositionType
2092 {
2093 	/**
2094 	 * The feature is at the left edge.
2095 	 */
2096 	LEFT = 0,
2097 	/**
2098 	 * The feature is at the right edge.
2099 	 */
2100 	RIGHT = 1,
2101 	/**
2102 	 * The feature is at the top edge.
2103 	 */
2104 	TOP = 2,
2105 	/**
2106 	 * The feature is at the bottom edge.
2107 	 */
2108 	BOTTOM = 3,
2109 }
2110 alias GtkPositionType PositionType;
2111 
2112 /**
2113  * See also gtk_print_settings_set_duplex().
2114  */
2115 public enum GtkPrintDuplex
2116 {
2117 	/**
2118 	 * No duplex.
2119 	 */
2120 	SIMPLEX = 0,
2121 	/**
2122 	 * Horizontal duplex.
2123 	 */
2124 	HORIZONTAL = 1,
2125 	/**
2126 	 * Vertical duplex.
2127 	 */
2128 	VERTICAL = 2,
2129 }
2130 alias GtkPrintDuplex PrintDuplex;
2131 
2132 /**
2133  * Error codes that identify various errors that can occur while
2134  * using the GTK+ printing support.
2135  */
2136 public enum GtkPrintError
2137 {
2138 	/**
2139 	 * An unspecified error occurred.
2140 	 */
2141 	GENERAL = 0,
2142 	/**
2143 	 * An internal error occurred.
2144 	 */
2145 	INTERNAL_ERROR = 1,
2146 	/**
2147 	 * A memory allocation failed.
2148 	 */
2149 	NOMEM = 2,
2150 	/**
2151 	 * An error occurred while loading a page setup
2152 	 * or paper size from a key file.
2153 	 */
2154 	INVALID_FILE = 3,
2155 }
2156 alias GtkPrintError PrintError;
2157 
2158 /**
2159  * The @action parameter to gtk_print_operation_run()
2160  * determines what action the print operation should perform.
2161  */
2162 public enum GtkPrintOperationAction
2163 {
2164 	/**
2165 	 * Show the print dialog.
2166 	 */
2167 	PRINT_DIALOG = 0,
2168 	/**
2169 	 * Start to print without showing
2170 	 * the print dialog, based on the current print settings.
2171 	 */
2172 	PRINT = 1,
2173 	/**
2174 	 * Show the print preview.
2175 	 */
2176 	PREVIEW = 2,
2177 	/**
2178 	 * Export to a file. This requires
2179 	 * the export-filename property to be set.
2180 	 */
2181 	EXPORT = 3,
2182 }
2183 alias GtkPrintOperationAction PrintOperationAction;
2184 
2185 /**
2186  * A value of this type is returned by gtk_print_operation_run().
2187  */
2188 public enum GtkPrintOperationResult
2189 {
2190 	/**
2191 	 * An error has occurred.
2192 	 */
2193 	ERROR = 0,
2194 	/**
2195 	 * The print settings should be stored.
2196 	 */
2197 	APPLY = 1,
2198 	/**
2199 	 * The print operation has been canceled,
2200 	 * the print settings should not be stored.
2201 	 */
2202 	CANCEL = 2,
2203 	/**
2204 	 * The print operation is not complete
2205 	 * yet. This value will only be returned when running asynchronously.
2206 	 */
2207 	IN_PROGRESS = 3,
2208 }
2209 alias GtkPrintOperationResult PrintOperationResult;
2210 
2211 /**
2212  * See also gtk_print_job_set_pages()
2213  */
2214 public enum GtkPrintPages
2215 {
2216 	/**
2217 	 * All pages.
2218 	 */
2219 	ALL = 0,
2220 	/**
2221 	 * Current page.
2222 	 */
2223 	CURRENT = 1,
2224 	/**
2225 	 * Range of pages.
2226 	 */
2227 	RANGES = 2,
2228 	/**
2229 	 * Selected pages.
2230 	 */
2231 	SELECTION = 3,
2232 }
2233 alias GtkPrintPages PrintPages;
2234 
2235 /**
2236  * See also gtk_print_settings_set_quality().
2237  */
2238 public enum GtkPrintQuality
2239 {
2240 	/**
2241 	 * Low quality.
2242 	 */
2243 	LOW = 0,
2244 	/**
2245 	 * Normal quality.
2246 	 */
2247 	NORMAL = 1,
2248 	/**
2249 	 * High quality.
2250 	 */
2251 	HIGH = 2,
2252 	/**
2253 	 * Draft quality.
2254 	 */
2255 	DRAFT = 3,
2256 }
2257 alias GtkPrintQuality PrintQuality;
2258 
2259 /**
2260  * The status gives a rough indication of the completion of a running
2261  * print operation.
2262  */
2263 public enum GtkPrintStatus
2264 {
2265 	/**
2266 	 * The printing has not started yet; this
2267 	 * status is set initially, and while the print dialog is shown.
2268 	 */
2269 	INITIAL = 0,
2270 	/**
2271 	 * This status is set while the begin-print
2272 	 * signal is emitted and during pagination.
2273 	 */
2274 	PREPARING = 1,
2275 	/**
2276 	 * This status is set while the
2277 	 * pages are being rendered.
2278 	 */
2279 	GENERATING_DATA = 2,
2280 	/**
2281 	 * The print job is being sent off to the
2282 	 * printer.
2283 	 */
2284 	SENDING_DATA = 3,
2285 	/**
2286 	 * The print job has been sent to the printer,
2287 	 * but is not printed for some reason, e.g. the printer may be stopped.
2288 	 */
2289 	PENDING = 4,
2290 	/**
2291 	 * Some problem has occurred during
2292 	 * printing, e.g. a paper jam.
2293 	 */
2294 	PENDING_ISSUE = 5,
2295 	/**
2296 	 * The printer is processing the print job.
2297 	 */
2298 	PRINTING = 6,
2299 	/**
2300 	 * The printing has been completed successfully.
2301 	 */
2302 	FINISHED = 7,
2303 	/**
2304 	 * The printing has been aborted.
2305 	 */
2306 	FINISHED_ABORTED = 8,
2307 }
2308 alias GtkPrintStatus PrintStatus;
2309 
2310 /**
2311  * Describes the stage at which events are fed into a #GtkEventController.
2312  *
2313  * Since: 3.14
2314  */
2315 public enum GtkPropagationPhase
2316 {
2317 	/**
2318 	 * Events are not delivered automatically. Those can be
2319 	 * manually fed through gtk_event_controller_handle_event(). This should
2320 	 * only be used when full control about when, or whether the controller
2321 	 * handles the event is needed.
2322 	 */
2323 	NONE = 0,
2324 	/**
2325 	 * Events are delivered in the capture phase. The
2326 	 * capture phase happens before the bubble phase, runs from the toplevel down
2327 	 * to the event widget. This option should only be used on containers that
2328 	 * might possibly handle events before their children do.
2329 	 */
2330 	CAPTURE = 1,
2331 	/**
2332 	 * Events are delivered in the bubble phase. The bubble
2333 	 * phase happens after the capture phase, and before the default handlers
2334 	 * are run. This phase runs from the event widget, up to the toplevel.
2335 	 */
2336 	BUBBLE = 2,
2337 	/**
2338 	 * Events are delivered in the default widget event handlers,
2339 	 * note that widget implementations must chain up on button, motion, touch and
2340 	 * grab broken handlers for controllers in this phase to be run.
2341 	 */
2342 	TARGET = 3,
2343 }
2344 alias GtkPropagationPhase PropagationPhase;
2345 
2346 /**
2347  * Deprecated
2348  */
2349 public enum GtkRcFlags
2350 {
2351 	/**
2352 	 * Deprecated
2353 	 */
2354 	FG = 1,
2355 	/**
2356 	 * Deprecated
2357 	 */
2358 	BG = 2,
2359 	/**
2360 	 * Deprecated
2361 	 */
2362 	TEXT = 4,
2363 	/**
2364 	 * Deprecated
2365 	 */
2366 	BASE = 8,
2367 }
2368 alias GtkRcFlags RcFlags;
2369 
2370 /**
2371  * The #GtkRcTokenType enumeration represents the tokens
2372  * in the RC file. It is exposed so that theme engines
2373  * can reuse these tokens when parsing the theme-engine
2374  * specific portions of a RC file.
2375  *
2376  * Deprecated: Use #GtkCssProvider instead.
2377  */
2378 public enum GtkRcTokenType
2379 {
2380 	/**
2381 	 * Deprecated
2382 	 */
2383 	INVALID = 270,
2384 	/**
2385 	 * Deprecated
2386 	 */
2387 	INCLUDE = 271,
2388 	/**
2389 	 * Deprecated
2390 	 */
2391 	NORMAL = 272,
2392 	/**
2393 	 * Deprecated
2394 	 */
2395 	ACTIVE = 273,
2396 	/**
2397 	 * Deprecated
2398 	 */
2399 	PRELIGHT = 274,
2400 	/**
2401 	 * Deprecated
2402 	 */
2403 	SELECTED = 275,
2404 	/**
2405 	 * Deprecated
2406 	 */
2407 	INSENSITIVE = 276,
2408 	/**
2409 	 * Deprecated
2410 	 */
2411 	FG = 277,
2412 	/**
2413 	 * Deprecated
2414 	 */
2415 	BG = 278,
2416 	/**
2417 	 * Deprecated
2418 	 */
2419 	TEXT = 279,
2420 	/**
2421 	 * Deprecated
2422 	 */
2423 	BASE = 280,
2424 	/**
2425 	 * Deprecated
2426 	 */
2427 	XTHICKNESS = 281,
2428 	/**
2429 	 * Deprecated
2430 	 */
2431 	YTHICKNESS = 282,
2432 	/**
2433 	 * Deprecated
2434 	 */
2435 	FONT = 283,
2436 	/**
2437 	 * Deprecated
2438 	 */
2439 	FONTSET = 284,
2440 	/**
2441 	 * Deprecated
2442 	 */
2443 	FONT_NAME = 285,
2444 	/**
2445 	 * Deprecated
2446 	 */
2447 	BG_PIXMAP = 286,
2448 	/**
2449 	 * Deprecated
2450 	 */
2451 	PIXMAP_PATH = 287,
2452 	/**
2453 	 * Deprecated
2454 	 */
2455 	STYLE = 288,
2456 	/**
2457 	 * Deprecated
2458 	 */
2459 	BINDING = 289,
2460 	/**
2461 	 * Deprecated
2462 	 */
2463 	BIND = 290,
2464 	/**
2465 	 * Deprecated
2466 	 */
2467 	WIDGET = 291,
2468 	/**
2469 	 * Deprecated
2470 	 */
2471 	WIDGET_CLASS = 292,
2472 	/**
2473 	 * Deprecated
2474 	 */
2475 	CLASS = 293,
2476 	/**
2477 	 * Deprecated
2478 	 */
2479 	LOWEST = 294,
2480 	/**
2481 	 * Deprecated
2482 	 */
2483 	GTK = 295,
2484 	/**
2485 	 * Deprecated
2486 	 */
2487 	APPLICATION = 296,
2488 	/**
2489 	 * Deprecated
2490 	 */
2491 	THEME = 297,
2492 	/**
2493 	 * Deprecated
2494 	 */
2495 	RC = 298,
2496 	/**
2497 	 * Deprecated
2498 	 */
2499 	HIGHEST = 299,
2500 	/**
2501 	 * Deprecated
2502 	 */
2503 	ENGINE = 300,
2504 	/**
2505 	 * Deprecated
2506 	 */
2507 	MODULE_PATH = 301,
2508 	/**
2509 	 * Deprecated
2510 	 */
2511 	IM_MODULE_PATH = 302,
2512 	/**
2513 	 * Deprecated
2514 	 */
2515 	IM_MODULE_FILE = 303,
2516 	/**
2517 	 * Deprecated
2518 	 */
2519 	STOCK = 304,
2520 	/**
2521 	 * Deprecated
2522 	 */
2523 	LTR = 305,
2524 	/**
2525 	 * Deprecated
2526 	 */
2527 	RTL = 306,
2528 	/**
2529 	 * Deprecated
2530 	 */
2531 	COLOR = 307,
2532 	/**
2533 	 * Deprecated
2534 	 */
2535 	UNBIND = 308,
2536 	/**
2537 	 * Deprecated
2538 	 */
2539 	LAST = 309,
2540 }
2541 alias GtkRcTokenType RcTokenType;
2542 
2543 /**
2544  * These identify the various errors that can occur while calling
2545  * #GtkRecentChooser functions.
2546  *
2547  * Since: 2.10
2548  */
2549 public enum GtkRecentChooserError
2550 {
2551 	/**
2552 	 * Indicates that a file does not exist
2553 	 */
2554 	NOT_FOUND = 0,
2555 	/**
2556 	 * Indicates a malformed URI
2557 	 */
2558 	INVALID_URI = 1,
2559 }
2560 alias GtkRecentChooserError RecentChooserError;
2561 
2562 /**
2563  * These flags indicate what parts of a #GtkRecentFilterInfo struct
2564  * are filled or need to be filled.
2565  */
2566 public enum GtkRecentFilterFlags
2567 {
2568 	/**
2569 	 * the URI of the file being tested
2570 	 */
2571 	URI = 1,
2572 	/**
2573 	 * the string that will be used to
2574 	 * display the file in the recent chooser
2575 	 */
2576 	DISPLAY_NAME = 2,
2577 	/**
2578 	 * the mime type of the file
2579 	 */
2580 	MIME_TYPE = 4,
2581 	/**
2582 	 * the list of applications that have
2583 	 * registered the file
2584 	 */
2585 	APPLICATION = 8,
2586 	/**
2587 	 * the groups to which the file belongs to
2588 	 */
2589 	GROUP = 16,
2590 	/**
2591 	 * the number of days elapsed since the file
2592 	 * has been registered
2593 	 */
2594 	AGE = 32,
2595 }
2596 alias GtkRecentFilterFlags RecentFilterFlags;
2597 
2598 /**
2599  * Error codes for #GtkRecentManager operations
2600  *
2601  * Since: 2.10
2602  */
2603 public enum GtkRecentManagerError
2604 {
2605 	/**
2606 	 * the URI specified does not exists in
2607 	 * the recently used resources list.
2608 	 */
2609 	NOT_FOUND = 0,
2610 	/**
2611 	 * the URI specified is not valid.
2612 	 */
2613 	INVALID_URI = 1,
2614 	/**
2615 	 * the supplied string is not
2616 	 * UTF-8 encoded.
2617 	 */
2618 	INVALID_ENCODING = 2,
2619 	/**
2620 	 * no application has registered
2621 	 * the specified item.
2622 	 */
2623 	NOT_REGISTERED = 3,
2624 	/**
2625 	 * failure while reading the recently used
2626 	 * resources file.
2627 	 */
2628 	READ = 4,
2629 	/**
2630 	 * failure while writing the recently used
2631 	 * resources file.
2632 	 */
2633 	WRITE = 5,
2634 	/**
2635 	 * unspecified error.
2636 	 */
2637 	UNKNOWN = 6,
2638 }
2639 alias GtkRecentManagerError RecentManagerError;
2640 
2641 /**
2642  * Used to specify the sorting method to be applyed to the recently
2643  * used resource list.
2644  *
2645  * Since: 2.10
2646  */
2647 public enum GtkRecentSortType
2648 {
2649 	/**
2650 	 * Do not sort the returned list of recently used
2651 	 * resources.
2652 	 */
2653 	NONE = 0,
2654 	/**
2655 	 * Sort the returned list with the most recently used
2656 	 * items first.
2657 	 */
2658 	MRU = 1,
2659 	/**
2660 	 * Sort the returned list with the least recently used
2661 	 * items first.
2662 	 */
2663 	LRU = 2,
2664 	/**
2665 	 * Sort the returned list using a custom sorting
2666 	 * function passed using gtk_recent_chooser_set_sort_func().
2667 	 */
2668 	CUSTOM = 3,
2669 }
2670 alias GtkRecentSortType RecentSortType;
2671 
2672 /**
2673  * Describes a region within a widget.
2674  */
2675 public enum GtkRegionFlags
2676 {
2677 	/**
2678 	 * Region has an even number within a set.
2679 	 */
2680 	EVEN = 1,
2681 	/**
2682 	 * Region has an odd number within a set.
2683 	 */
2684 	ODD = 2,
2685 	/**
2686 	 * Region is the first one within a set.
2687 	 */
2688 	FIRST = 4,
2689 	/**
2690 	 * Region is the last one within a set.
2691 	 */
2692 	LAST = 8,
2693 	/**
2694 	 * Region is the only one within a set.
2695 	 */
2696 	ONLY = 16,
2697 	/**
2698 	 * Region is part of a sorted area.
2699 	 */
2700 	SORTED = 32,
2701 }
2702 alias GtkRegionFlags RegionFlags;
2703 
2704 /**
2705  * Indicated the relief to be drawn around a #GtkButton.
2706  */
2707 public enum GtkReliefStyle
2708 {
2709 	/**
2710 	 * Draw a normal relief.
2711 	 */
2712 	NORMAL = 0,
2713 	/**
2714 	 * A half relief. Deprecated in 3.14, does the same as @GTK_RELIEF_NORMAL
2715 	 */
2716 	HALF = 1,
2717 	/**
2718 	 * No relief.
2719 	 */
2720 	NONE = 2,
2721 }
2722 alias GtkReliefStyle ReliefStyle;
2723 
2724 public enum GtkResizeMode
2725 {
2726 	/**
2727 	 * Pass resize request to the parent
2728 	 */
2729 	PARENT = 0,
2730 	/**
2731 	 * Queue resizes on this widget
2732 	 */
2733 	QUEUE = 1,
2734 	/**
2735 	 * Resize immediately. Deprecated.
2736 	 */
2737 	IMMEDIATE = 2,
2738 }
2739 alias GtkResizeMode ResizeMode;
2740 
2741 /**
2742  * Predefined values for use as response ids in gtk_dialog_add_button().
2743  * All predefined values are negative; GTK+ leaves values of 0 or greater for
2744  * application-defined response ids.
2745  */
2746 public enum GtkResponseType
2747 {
2748 	/**
2749 	 * Returned if an action widget has no response id,
2750 	 * or if the dialog gets programmatically hidden or destroyed
2751 	 */
2752 	NONE = -1,
2753 	/**
2754 	 * Generic response id, not used by GTK+ dialogs
2755 	 */
2756 	REJECT = -2,
2757 	/**
2758 	 * Generic response id, not used by GTK+ dialogs
2759 	 */
2760 	ACCEPT = -3,
2761 	/**
2762 	 * Returned if the dialog is deleted
2763 	 */
2764 	DELETE_EVENT = -4,
2765 	/**
2766 	 * Returned by OK buttons in GTK+ dialogs
2767 	 */
2768 	OK = -5,
2769 	/**
2770 	 * Returned by Cancel buttons in GTK+ dialogs
2771 	 */
2772 	CANCEL = -6,
2773 	/**
2774 	 * Returned by Close buttons in GTK+ dialogs
2775 	 */
2776 	CLOSE = -7,
2777 	/**
2778 	 * Returned by Yes buttons in GTK+ dialogs
2779 	 */
2780 	YES = -8,
2781 	/**
2782 	 * Returned by No buttons in GTK+ dialogs
2783 	 */
2784 	NO = -9,
2785 	/**
2786 	 * Returned by Apply buttons in GTK+ dialogs
2787 	 */
2788 	APPLY = -10,
2789 	/**
2790 	 * Returned by Help buttons in GTK+ dialogs
2791 	 */
2792 	HELP = -11,
2793 }
2794 alias GtkResponseType ResponseType;
2795 
2796 /**
2797  * These enumeration values describe the possible transitions
2798  * when the child of a #GtkRevealer widget is shown or hidden.
2799  */
2800 public enum GtkRevealerTransitionType
2801 {
2802 	/**
2803 	 * No transition
2804 	 */
2805 	NONE = 0,
2806 	/**
2807 	 * Fade in
2808 	 */
2809 	CROSSFADE = 1,
2810 	/**
2811 	 * Slide in from the left
2812 	 */
2813 	SLIDE_RIGHT = 2,
2814 	/**
2815 	 * Slide in from the right
2816 	 */
2817 	SLIDE_LEFT = 3,
2818 	/**
2819 	 * Slide in from the bottom
2820 	 */
2821 	SLIDE_UP = 4,
2822 	/**
2823 	 * Slide in from the top
2824 	 */
2825 	SLIDE_DOWN = 5,
2826 }
2827 alias GtkRevealerTransitionType RevealerTransitionType;
2828 
2829 public enum GtkScrollStep
2830 {
2831 	/**
2832 	 * Scroll in steps.
2833 	 */
2834 	STEPS = 0,
2835 	/**
2836 	 * Scroll by pages.
2837 	 */
2838 	PAGES = 1,
2839 	/**
2840 	 * Scroll to ends.
2841 	 */
2842 	ENDS = 2,
2843 	/**
2844 	 * Scroll in horizontal steps.
2845 	 */
2846 	HORIZONTAL_STEPS = 3,
2847 	/**
2848 	 * Scroll by horizontal pages.
2849 	 */
2850 	HORIZONTAL_PAGES = 4,
2851 	/**
2852 	 * Scroll to the horizontal ends.
2853 	 */
2854 	HORIZONTAL_ENDS = 5,
2855 }
2856 alias GtkScrollStep ScrollStep;
2857 
2858 /**
2859  * Scrolling types.
2860  */
2861 public enum GtkScrollType
2862 {
2863 	/**
2864 	 * No scrolling.
2865 	 */
2866 	NONE = 0,
2867 	/**
2868 	 * Jump to new location.
2869 	 */
2870 	JUMP = 1,
2871 	/**
2872 	 * Step backward.
2873 	 */
2874 	STEP_BACKWARD = 2,
2875 	/**
2876 	 * Step forward.
2877 	 */
2878 	STEP_FORWARD = 3,
2879 	/**
2880 	 * Page backward.
2881 	 */
2882 	PAGE_BACKWARD = 4,
2883 	/**
2884 	 * Page forward.
2885 	 */
2886 	PAGE_FORWARD = 5,
2887 	/**
2888 	 * Step up.
2889 	 */
2890 	STEP_UP = 6,
2891 	/**
2892 	 * Step down.
2893 	 */
2894 	STEP_DOWN = 7,
2895 	/**
2896 	 * Page up.
2897 	 */
2898 	PAGE_UP = 8,
2899 	/**
2900 	 * Page down.
2901 	 */
2902 	PAGE_DOWN = 9,
2903 	/**
2904 	 * Step to the left.
2905 	 */
2906 	STEP_LEFT = 10,
2907 	/**
2908 	 * Step to the right.
2909 	 */
2910 	STEP_RIGHT = 11,
2911 	/**
2912 	 * Page to the left.
2913 	 */
2914 	PAGE_LEFT = 12,
2915 	/**
2916 	 * Page to the right.
2917 	 */
2918 	PAGE_RIGHT = 13,
2919 	/**
2920 	 * Scroll to start.
2921 	 */
2922 	START = 14,
2923 	/**
2924 	 * Scroll to end.
2925 	 */
2926 	END = 15,
2927 }
2928 alias GtkScrollType ScrollType;
2929 
2930 /**
2931  * Defines the policy to be used in a scrollable widget when updating
2932  * the scrolled window adjustments in a given orientation.
2933  */
2934 public enum GtkScrollablePolicy
2935 {
2936 	/**
2937 	 * Scrollable adjustments are based on the minimum size
2938 	 */
2939 	MINIMUM = 0,
2940 	/**
2941 	 * Scrollable adjustments are based on the natural size
2942 	 */
2943 	NATURAL = 1,
2944 }
2945 alias GtkScrollablePolicy ScrollablePolicy;
2946 
2947 /**
2948  * Used to control what selections users are allowed to make.
2949  */
2950 public enum GtkSelectionMode
2951 {
2952 	/**
2953 	 * No selection is possible.
2954 	 */
2955 	NONE = 0,
2956 	/**
2957 	 * Zero or one element may be selected.
2958 	 */
2959 	SINGLE = 1,
2960 	/**
2961 	 * Exactly one element is selected.
2962 	 * In some circumstances, such as initially or during a search
2963 	 * operation, it’s possible for no element to be selected with
2964 	 * %GTK_SELECTION_BROWSE. What is really enforced is that the user
2965 	 * can’t deselect a currently selected element except by selecting
2966 	 * another element.
2967 	 */
2968 	BROWSE = 2,
2969 	/**
2970 	 * Any number of elements may be selected.
2971 	 * The Ctrl key may be used to enlarge the selection, and Shift
2972 	 * key to select between the focus and the child pointed to.
2973 	 * Some widgets may also allow Click-drag to select a range of elements.
2974 	 */
2975 	MULTIPLE = 3,
2976 }
2977 alias GtkSelectionMode SelectionMode;
2978 
2979 /**
2980  * Determines how GTK+ handles the sensitivity of stepper arrows
2981  * at the end of range widgets.
2982  */
2983 public enum GtkSensitivityType
2984 {
2985 	/**
2986 	 * The arrow is made insensitive if the
2987 	 * thumb is at the end
2988 	 */
2989 	AUTO = 0,
2990 	/**
2991 	 * The arrow is always sensitive
2992 	 */
2993 	ON = 1,
2994 	/**
2995 	 * The arrow is always insensitive
2996 	 */
2997 	OFF = 2,
2998 }
2999 alias GtkSensitivityType SensitivityType;
3000 
3001 /**
3002  * Used to change the appearance of an outline typically provided by a #GtkFrame.
3003  *
3004  * Note that many themes do not differentiate the appearance of the
3005  * various shadow types: Either their is no visible shadow (@GTK_SHADOW_NONE),
3006  * or there is (any other value).
3007  */
3008 public enum GtkShadowType
3009 {
3010 	/**
3011 	 * No outline.
3012 	 */
3013 	NONE = 0,
3014 	/**
3015 	 * The outline is bevelled inwards.
3016 	 */
3017 	IN = 1,
3018 	/**
3019 	 * The outline is bevelled outwards like a button.
3020 	 */
3021 	OUT = 2,
3022 	/**
3023 	 * The outline has a sunken 3d appearance.
3024 	 */
3025 	ETCHED_IN = 3,
3026 	/**
3027 	 * The outline has a raised 3d appearance.
3028 	 */
3029 	ETCHED_OUT = 4,
3030 }
3031 alias GtkShadowType ShadowType;
3032 
3033 /**
3034  * GtkShortcutType specifies the kind of shortcut that is being described.
3035  * More values may be added to this enumeration over time.
3036  *
3037  * Since: 3.20
3038  */
3039 public enum GtkShortcutType
3040 {
3041 	/**
3042 	 * The shortcut is a keyboard accelerator. The #GtkShortcutsShortcut:accelerator
3043 	 * property will be used.
3044 	 */
3045 	ACCELERATOR = 0,
3046 	/**
3047 	 * The shortcut is a pinch gesture. GTK+ provides an icon and subtitle.
3048 	 */
3049 	GESTURE_PINCH = 1,
3050 	/**
3051 	 * The shortcut is a stretch gesture. GTK+ provides an icon and subtitle.
3052 	 */
3053 	GESTURE_STRETCH = 2,
3054 	/**
3055 	 * The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle.
3056 	 */
3057 	GESTURE_ROTATE_CLOCKWISE = 3,
3058 	/**
3059 	 * The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle.
3060 	 */
3061 	GESTURE_ROTATE_COUNTERCLOCKWISE = 4,
3062 	/**
3063 	 * The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
3064 	 */
3065 	GESTURE_TWO_FINGER_SWIPE_LEFT = 5,
3066 	/**
3067 	 * The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
3068 	 */
3069 	GESTURE_TWO_FINGER_SWIPE_RIGHT = 6,
3070 	/**
3071 	 * The shortcut is a gesture. The #GtkShortcutsShortcut:icon property will be
3072 	 * used.
3073 	 */
3074 	GESTURE = 7,
3075 }
3076 alias GtkShortcutType ShortcutType;
3077 
3078 /**
3079  * The mode of the size group determines the directions in which the size
3080  * group affects the requested sizes of its component widgets.
3081  */
3082 public enum GtkSizeGroupMode
3083 {
3084 	/**
3085 	 * group has no effect
3086 	 */
3087 	NONE = 0,
3088 	/**
3089 	 * group affects horizontal requisition
3090 	 */
3091 	HORIZONTAL = 1,
3092 	/**
3093 	 * group affects vertical requisition
3094 	 */
3095 	VERTICAL = 2,
3096 	/**
3097 	 * group affects both horizontal and vertical requisition
3098 	 */
3099 	BOTH = 3,
3100 }
3101 alias GtkSizeGroupMode SizeGroupMode;
3102 
3103 /**
3104  * Specifies a preference for height-for-width or
3105  * width-for-height geometry management.
3106  */
3107 public enum GtkSizeRequestMode
3108 {
3109 	/**
3110 	 * Prefer height-for-width geometry management
3111 	 */
3112 	HEIGHT_FOR_WIDTH = 0,
3113 	/**
3114 	 * Prefer width-for-height geometry management
3115 	 */
3116 	WIDTH_FOR_HEIGHT = 1,
3117 	/**
3118 	 * Don’t trade height-for-width or width-for-height
3119 	 */
3120 	CONSTANT_SIZE = 2,
3121 }
3122 alias GtkSizeRequestMode SizeRequestMode;
3123 
3124 /**
3125  * Determines the direction of a sort.
3126  */
3127 public enum GtkSortType
3128 {
3129 	/**
3130 	 * Sorting is in ascending order.
3131 	 */
3132 	ASCENDING = 0,
3133 	/**
3134 	 * Sorting is in descending order.
3135 	 */
3136 	DESCENDING = 1,
3137 }
3138 alias GtkSortType SortType;
3139 
3140 /**
3141  * The spin button update policy determines whether the spin button displays
3142  * values even if they are outside the bounds of its adjustment.
3143  * See gtk_spin_button_set_update_policy().
3144  */
3145 public enum GtkSpinButtonUpdatePolicy
3146 {
3147 	/**
3148 	 * When refreshing your #GtkSpinButton, the value is
3149 	 * always displayed
3150 	 */
3151 	ALWAYS = 0,
3152 	/**
3153 	 * When refreshing your #GtkSpinButton, the value is
3154 	 * only displayed if it is valid within the bounds of the spin button's
3155 	 * adjustment
3156 	 */
3157 	IF_VALID = 1,
3158 }
3159 alias GtkSpinButtonUpdatePolicy SpinButtonUpdatePolicy;
3160 
3161 /**
3162  * The values of the GtkSpinType enumeration are used to specify the
3163  * change to make in gtk_spin_button_spin().
3164  */
3165 public enum GtkSpinType
3166 {
3167 	/**
3168 	 * Increment by the adjustments step increment.
3169 	 */
3170 	STEP_FORWARD = 0,
3171 	/**
3172 	 * Decrement by the adjustments step increment.
3173 	 */
3174 	STEP_BACKWARD = 1,
3175 	/**
3176 	 * Increment by the adjustments page increment.
3177 	 */
3178 	PAGE_FORWARD = 2,
3179 	/**
3180 	 * Decrement by the adjustments page increment.
3181 	 */
3182 	PAGE_BACKWARD = 3,
3183 	/**
3184 	 * Go to the adjustments lower bound.
3185 	 */
3186 	HOME = 4,
3187 	/**
3188 	 * Go to the adjustments upper bound.
3189 	 */
3190 	END = 5,
3191 	/**
3192 	 * Change by a specified amount.
3193 	 */
3194 	USER_DEFINED = 6,
3195 }
3196 alias GtkSpinType SpinType;
3197 
3198 /**
3199  * These enumeration values describe the possible transitions
3200  * between pages in a #GtkStack widget.
3201  *
3202  * New values may be added to this enumeration over time.
3203  */
3204 public enum GtkStackTransitionType
3205 {
3206 	/**
3207 	 * No transition
3208 	 */
3209 	NONE = 0,
3210 	/**
3211 	 * A cross-fade
3212 	 */
3213 	CROSSFADE = 1,
3214 	/**
3215 	 * Slide from left to right
3216 	 */
3217 	SLIDE_RIGHT = 2,
3218 	/**
3219 	 * Slide from right to left
3220 	 */
3221 	SLIDE_LEFT = 3,
3222 	/**
3223 	 * Slide from bottom up
3224 	 */
3225 	SLIDE_UP = 4,
3226 	/**
3227 	 * Slide from top down
3228 	 */
3229 	SLIDE_DOWN = 5,
3230 	/**
3231 	 * Slide from left or right according to the children order
3232 	 */
3233 	SLIDE_LEFT_RIGHT = 6,
3234 	/**
3235 	 * Slide from top down or bottom up according to the order
3236 	 */
3237 	SLIDE_UP_DOWN = 7,
3238 	/**
3239 	 * Cover the old page by sliding up. Since 3.12
3240 	 */
3241 	OVER_UP = 8,
3242 	/**
3243 	 * Cover the old page by sliding down. Since: 3.12
3244 	 */
3245 	OVER_DOWN = 9,
3246 	/**
3247 	 * Cover the old page by sliding to the left. Since: 3.12
3248 	 */
3249 	OVER_LEFT = 10,
3250 	/**
3251 	 * Cover the old page by sliding to the right. Since: 3.12
3252 	 */
3253 	OVER_RIGHT = 11,
3254 	/**
3255 	 * Uncover the new page by sliding up. Since 3.12
3256 	 */
3257 	UNDER_UP = 12,
3258 	/**
3259 	 * Uncover the new page by sliding down. Since: 3.12
3260 	 */
3261 	UNDER_DOWN = 13,
3262 	/**
3263 	 * Uncover the new page by sliding to the left. Since: 3.12
3264 	 */
3265 	UNDER_LEFT = 14,
3266 	/**
3267 	 * Uncover the new page by sliding to the right. Since: 3.12
3268 	 */
3269 	UNDER_RIGHT = 15,
3270 	/**
3271 	 * Cover the old page sliding up or uncover the new page sliding down, according to order. Since: 3.12
3272 	 */
3273 	OVER_UP_DOWN = 16,
3274 	/**
3275 	 * Cover the old page sliding down or uncover the new page sliding up, according to order. Since: 3.14
3276 	 */
3277 	OVER_DOWN_UP = 17,
3278 	/**
3279 	 * Cover the old page sliding left or uncover the new page sliding right, according to order. Since: 3.14
3280 	 */
3281 	OVER_LEFT_RIGHT = 18,
3282 	/**
3283 	 * Cover the old page sliding right or uncover the new page sliding left, according to order. Since: 3.14
3284 	 */
3285 	OVER_RIGHT_LEFT = 19,
3286 }
3287 alias GtkStackTransitionType StackTransitionType;
3288 
3289 /**
3290  * Describes a widget state. Widget states are used to match the widget
3291  * against CSS pseudo-classes. Note that GTK extends the regular CSS
3292  * classes and sometimes uses different names.
3293  */
3294 public enum GtkStateFlags
3295 {
3296 	/**
3297 	 * State during normal operation.
3298 	 */
3299 	NORMAL = 0,
3300 	/**
3301 	 * Widget is active.
3302 	 */
3303 	ACTIVE = 1,
3304 	/**
3305 	 * Widget has a mouse pointer over it.
3306 	 */
3307 	PRELIGHT = 2,
3308 	/**
3309 	 * Widget is selected.
3310 	 */
3311 	SELECTED = 4,
3312 	/**
3313 	 * Widget is insensitive.
3314 	 */
3315 	INSENSITIVE = 8,
3316 	/**
3317 	 * Widget is inconsistent.
3318 	 */
3319 	INCONSISTENT = 16,
3320 	/**
3321 	 * Widget has the keyboard focus.
3322 	 */
3323 	FOCUSED = 32,
3324 	/**
3325 	 * Widget is in a background toplevel window.
3326 	 */
3327 	BACKDROP = 64,
3328 	/**
3329 	 * Widget is in left-to-right text direction. Since 3.8
3330 	 */
3331 	DIR_LTR = 128,
3332 	/**
3333 	 * Widget is in right-to-left text direction. Since 3.8
3334 	 */
3335 	DIR_RTL = 256,
3336 	/**
3337 	 * Widget is a link. Since 3.12
3338 	 */
3339 	LINK = 512,
3340 	/**
3341 	 * The location the widget points to has already been visited. Since 3.12
3342 	 */
3343 	VISITED = 1024,
3344 	/**
3345 	 * Widget is checked. Since 3.14
3346 	 */
3347 	CHECKED = 2048,
3348 	/**
3349 	 * Widget is highlighted as a drop target for DND. Since 3.20
3350 	 */
3351 	DROP_ACTIVE = 4096,
3352 }
3353 alias GtkStateFlags StateFlags;
3354 
3355 /**
3356  * This type indicates the current state of a widget; the state determines how
3357  * the widget is drawn. The #GtkStateType enumeration is also used to
3358  * identify different colors in a #GtkStyle for drawing, so states can be
3359  * used for subparts of a widget as well as entire widgets.
3360  *
3361  * Deprecated: All APIs that are using this enumeration have been deprecated
3362  * in favor of alternatives using #GtkStateFlags.
3363  */
3364 public enum GtkStateType
3365 {
3366 	/**
3367 	 * State during normal operation.
3368 	 */
3369 	NORMAL = 0,
3370 	/**
3371 	 * State of a currently active widget, such as a depressed button.
3372 	 */
3373 	ACTIVE = 1,
3374 	/**
3375 	 * State indicating that the mouse pointer is over
3376 	 * the widget and the widget will respond to mouse clicks.
3377 	 */
3378 	PRELIGHT = 2,
3379 	/**
3380 	 * State of a selected item, such the selected row in a list.
3381 	 */
3382 	SELECTED = 3,
3383 	/**
3384 	 * State indicating that the widget is
3385 	 * unresponsive to user actions.
3386 	 */
3387 	INSENSITIVE = 4,
3388 	/**
3389 	 * The widget is inconsistent, such as checkbuttons
3390 	 * or radiobuttons that aren’t either set to %TRUE nor %FALSE,
3391 	 * or buttons requiring the user attention.
3392 	 */
3393 	INCONSISTENT = 5,
3394 	/**
3395 	 * The widget has the keyboard focus.
3396 	 */
3397 	FOCUSED = 6,
3398 }
3399 alias GtkStateType StateType;
3400 
3401 /**
3402  * Flags that modify the behavior of gtk_style_context_to_string().
3403  * New values may be added to this enumeration.
3404  */
3405 public enum GtkStyleContextPrintFlags
3406 {
3407 	NONE = 0,
3408 	/**
3409 	 * Print the entire tree of
3410 	 * CSS nodes starting at the style context's node
3411 	 */
3412 	RECURSE = 1,
3413 	/**
3414 	 * Show the values of the
3415 	 * CSS properties for each node
3416 	 */
3417 	SHOW_STYLE = 2,
3418 }
3419 alias GtkStyleContextPrintFlags StyleContextPrintFlags;
3420 
3421 /**
3422  * The #GtkTargetFlags enumeration is used to specify
3423  * constraints on a #GtkTargetEntry.
3424  */
3425 public enum GtkTargetFlags
3426 {
3427 	/**
3428 	 * If this is set, the target will only be selected
3429 	 * for drags within a single application.
3430 	 */
3431 	SAME_APP = 1,
3432 	/**
3433 	 * If this is set, the target will only be selected
3434 	 * for drags within a single widget.
3435 	 */
3436 	SAME_WIDGET = 2,
3437 	/**
3438 	 * If this is set, the target will not be selected
3439 	 * for drags within a single application.
3440 	 */
3441 	OTHER_APP = 4,
3442 	/**
3443 	 * If this is set, the target will not be selected
3444 	 * for drags withing a single widget.
3445 	 */
3446 	OTHER_WIDGET = 8,
3447 }
3448 alias GtkTargetFlags TargetFlags;
3449 
3450 /**
3451  * These values are used as “info” for the targets contained in the
3452  * lists returned by gtk_text_buffer_get_copy_target_list() and
3453  * gtk_text_buffer_get_paste_target_list().
3454  *
3455  * The values counts down from `-1` to avoid clashes
3456  * with application added drag destinations which usually start at 0.
3457  */
3458 public enum GtkTextBufferTargetInfo
3459 {
3460 	/**
3461 	 * Buffer contents
3462 	 */
3463 	BUFFER_CONTENTS = -1,
3464 	/**
3465 	 * Rich text
3466 	 */
3467 	RICH_TEXT = -2,
3468 	/**
3469 	 * Text
3470 	 */
3471 	TEXT = -3,
3472 }
3473 alias GtkTextBufferTargetInfo TextBufferTargetInfo;
3474 
3475 /**
3476  * Reading directions for text.
3477  */
3478 public enum GtkTextDirection
3479 {
3480 	/**
3481 	 * No direction.
3482 	 */
3483 	NONE = 0,
3484 	/**
3485 	 * Left to right text direction.
3486 	 */
3487 	LTR = 1,
3488 	/**
3489 	 * Right to left text direction.
3490 	 */
3491 	RTL = 2,
3492 }
3493 alias GtkTextDirection TextDirection;
3494 
3495 /**
3496  * Granularity types that extend the text selection. Use the
3497  * #GtkTextView::extend-selection signal to customize the selection.
3498  *
3499  * Since: 3.16
3500  */
3501 public enum GtkTextExtendSelection
3502 {
3503 	/**
3504 	 * Selects the current word. It is triggered by
3505 	 * a double-click for example.
3506 	 */
3507 	WORD = 0,
3508 	/**
3509 	 * Selects the current line. It is triggered by
3510 	 * a triple-click for example.
3511 	 */
3512 	LINE = 1,
3513 }
3514 alias GtkTextExtendSelection TextExtendSelection;
3515 
3516 /**
3517  * Flags affecting how a search is done.
3518  *
3519  * If neither #GTK_TEXT_SEARCH_VISIBLE_ONLY nor #GTK_TEXT_SEARCH_TEXT_ONLY are
3520  * enabled, the match must be exact; the special 0xFFFC character will match
3521  * embedded pixbufs or child widgets.
3522  */
3523 public enum GtkTextSearchFlags
3524 {
3525 	/**
3526 	 * Search only visible data. A search match may
3527 	 * have invisible text interspersed.
3528 	 */
3529 	VISIBLE_ONLY = 1,
3530 	/**
3531 	 * Search only text. A match may have pixbufs or
3532 	 * child widgets mixed inside the matched range.
3533 	 */
3534 	TEXT_ONLY = 2,
3535 	/**
3536 	 * The text will be matched regardless of
3537 	 * what case it is in.
3538 	 */
3539 	CASE_INSENSITIVE = 4,
3540 }
3541 alias GtkTextSearchFlags TextSearchFlags;
3542 
3543 /**
3544  * Used to reference the layers of #GtkTextView for the purpose of customized
3545  * drawing with the ::draw_layer vfunc.
3546  */
3547 public enum GtkTextViewLayer
3548 {
3549 	/**
3550 	 * Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_BELOW_TEXT instead
3551 	 */
3552 	BELOW = 0,
3553 	/**
3554 	 * Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT instead
3555 	 */
3556 	ABOVE = 1,
3557 	/**
3558 	 * The layer rendered below the text (but above the background).  Since: 3.20
3559 	 */
3560 	BELOW_TEXT = 2,
3561 	/**
3562 	 * The layer rendered above the text.  Since: 3.20
3563 	 */
3564 	ABOVE_TEXT = 3,
3565 }
3566 alias GtkTextViewLayer TextViewLayer;
3567 
3568 /**
3569  * Used to reference the parts of #GtkTextView.
3570  */
3571 public enum GtkTextWindowType
3572 {
3573 	/**
3574 	 * Invalid value, used as a marker
3575 	 */
3576 	PRIVATE = 0,
3577 	/**
3578 	 * Window that floats over scrolling areas.
3579 	 */
3580 	WIDGET = 1,
3581 	/**
3582 	 * Scrollable text window.
3583 	 */
3584 	TEXT = 2,
3585 	/**
3586 	 * Left side border window.
3587 	 */
3588 	LEFT = 3,
3589 	/**
3590 	 * Right side border window.
3591 	 */
3592 	RIGHT = 4,
3593 	/**
3594 	 * Top border window.
3595 	 */
3596 	TOP = 5,
3597 	/**
3598 	 * Bottom border window.
3599 	 */
3600 	BOTTOM = 6,
3601 }
3602 alias GtkTextWindowType TextWindowType;
3603 
3604 /**
3605  * Flags used to specify the supported drag targets.
3606  */
3607 public enum GtkToolPaletteDragTargets
3608 {
3609 	/**
3610 	 * Support drag of items.
3611 	 */
3612 	ITEMS = 1,
3613 	/**
3614 	 * Support drag of groups.
3615 	 */
3616 	GROUPS = 2,
3617 }
3618 alias GtkToolPaletteDragTargets ToolPaletteDragTargets;
3619 
3620 /**
3621  * Whether spacers are vertical lines or just blank.
3622  */
3623 public enum GtkToolbarSpaceStyle
3624 {
3625 	/**
3626 	 * Use blank spacers.
3627 	 */
3628 	EMPTY = 0,
3629 	/**
3630 	 * Use vertical lines for spacers.
3631 	 */
3632 	LINE = 1,
3633 }
3634 alias GtkToolbarSpaceStyle ToolbarSpaceStyle;
3635 
3636 /**
3637  * Used to customize the appearance of a #GtkToolbar. Note that
3638  * setting the toolbar style overrides the user’s preferences
3639  * for the default toolbar style.  Note that if the button has only
3640  * a label set and GTK_TOOLBAR_ICONS is used, the label will be
3641  * visible, and vice versa.
3642  */
3643 public enum GtkToolbarStyle
3644 {
3645 	/**
3646 	 * Buttons display only icons in the toolbar.
3647 	 */
3648 	ICONS = 0,
3649 	/**
3650 	 * Buttons display only text labels in the toolbar.
3651 	 */
3652 	TEXT = 1,
3653 	/**
3654 	 * Buttons display text and icons in the toolbar.
3655 	 */
3656 	BOTH = 2,
3657 	/**
3658 	 * Buttons display icons and text alongside each
3659 	 * other, rather than vertically stacked
3660 	 */
3661 	BOTH_HORIZ = 3,
3662 }
3663 alias GtkToolbarStyle ToolbarStyle;
3664 
3665 /**
3666  * These flags indicate various properties of a #GtkTreeModel.
3667  *
3668  * They are returned by gtk_tree_model_get_flags(), and must be
3669  * static for the lifetime of the object. A more complete description
3670  * of #GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
3671  * this section.
3672  */
3673 public enum GtkTreeModelFlags
3674 {
3675 	/**
3676 	 * iterators survive all signals
3677 	 * emitted by the tree
3678 	 */
3679 	ITERS_PERSIST = 1,
3680 	/**
3681 	 * the model is a list only, and never
3682 	 * has children
3683 	 */
3684 	LIST_ONLY = 2,
3685 }
3686 alias GtkTreeModelFlags TreeModelFlags;
3687 
3688 /**
3689  * The sizing method the column uses to determine its width.  Please note
3690  * that @GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
3691  * can make columns appear choppy.
3692  */
3693 public enum GtkTreeViewColumnSizing
3694 {
3695 	/**
3696 	 * Columns only get bigger in reaction to changes in the model
3697 	 */
3698 	GROW_ONLY = 0,
3699 	/**
3700 	 * Columns resize to be the optimal size everytime the model changes.
3701 	 */
3702 	AUTOSIZE = 1,
3703 	/**
3704 	 * Columns are a fixed numbers of pixels wide.
3705 	 */
3706 	FIXED = 2,
3707 }
3708 alias GtkTreeViewColumnSizing TreeViewColumnSizing;
3709 
3710 /**
3711  * An enum for determining where a dropped row goes.
3712  */
3713 public enum GtkTreeViewDropPosition
3714 {
3715 	/**
3716 	 * dropped row is inserted before
3717 	 */
3718 	BEFORE = 0,
3719 	/**
3720 	 * dropped row is inserted after
3721 	 */
3722 	AFTER = 1,
3723 	/**
3724 	 * dropped row becomes a child or is inserted before
3725 	 */
3726 	INTO_OR_BEFORE = 2,
3727 	/**
3728 	 * dropped row becomes a child or is inserted after
3729 	 */
3730 	INTO_OR_AFTER = 3,
3731 }
3732 alias GtkTreeViewDropPosition TreeViewDropPosition;
3733 
3734 /**
3735  * Used to indicate which grid lines to draw in a tree view.
3736  */
3737 public enum GtkTreeViewGridLines
3738 {
3739 	/**
3740 	 * No grid lines.
3741 	 */
3742 	NONE = 0,
3743 	/**
3744 	 * Horizontal grid lines.
3745 	 */
3746 	HORIZONTAL = 1,
3747 	/**
3748 	 * Vertical grid lines.
3749 	 */
3750 	VERTICAL = 2,
3751 	/**
3752 	 * Horizontal and vertical grid lines.
3753 	 */
3754 	BOTH = 3,
3755 }
3756 alias GtkTreeViewGridLines TreeViewGridLines;
3757 
3758 /**
3759  * These enumeration values are used by gtk_ui_manager_add_ui() to determine
3760  * what UI element to create.
3761  */
3762 public enum GtkUIManagerItemType
3763 {
3764 	/**
3765 	 * Pick the type of the UI element according to context.
3766 	 */
3767 	AUTO = 0,
3768 	/**
3769 	 * Create a menubar.
3770 	 */
3771 	MENUBAR = 1,
3772 	/**
3773 	 * Create a menu.
3774 	 */
3775 	MENU = 2,
3776 	/**
3777 	 * Create a toolbar.
3778 	 */
3779 	TOOLBAR = 4,
3780 	/**
3781 	 * Insert a placeholder.
3782 	 */
3783 	PLACEHOLDER = 8,
3784 	/**
3785 	 * Create a popup menu.
3786 	 */
3787 	POPUP = 16,
3788 	/**
3789 	 * Create a menuitem.
3790 	 */
3791 	MENUITEM = 32,
3792 	/**
3793 	 * Create a toolitem.
3794 	 */
3795 	TOOLITEM = 64,
3796 	/**
3797 	 * Create a separator.
3798 	 */
3799 	SEPARATOR = 128,
3800 	/**
3801 	 * Install an accelerator.
3802 	 */
3803 	ACCELERATOR = 256,
3804 	/**
3805 	 * Same as %GTK_UI_MANAGER_POPUP, but the
3806 	 * actions’ accelerators are shown.
3807 	 */
3808 	POPUP_WITH_ACCELS = 512,
3809 }
3810 alias GtkUIManagerItemType UIManagerItemType;
3811 
3812 /**
3813  * See also gtk_print_settings_set_paper_width().
3814  */
3815 public enum GtkUnit
3816 {
3817 	/**
3818 	 * No units.
3819 	 */
3820 	NONE = 0,
3821 	/**
3822 	 * Dimensions in points.
3823 	 */
3824 	POINTS = 1,
3825 	/**
3826 	 * Dimensions in inches.
3827 	 */
3828 	INCH = 2,
3829 	/**
3830 	 * Dimensions in millimeters
3831 	 */
3832 	MM = 3,
3833 }
3834 alias GtkUnit Unit;
3835 
3836 /**
3837  * Kinds of widget-specific help. Used by the ::show-help signal.
3838  */
3839 public enum GtkWidgetHelpType
3840 {
3841 	/**
3842 	 * Tooltip.
3843 	 */
3844 	TOOLTIP = 0,
3845 	/**
3846 	 * What’s this.
3847 	 */
3848 	WHATS_THIS = 1,
3849 }
3850 alias GtkWidgetHelpType WidgetHelpType;
3851 
3852 /**
3853  * Window placement can be influenced using this enumeration. Note that
3854  * using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea.
3855  * It won’t necessarily work well with all window managers or on all windowing systems.
3856  */
3857 public enum GtkWindowPosition
3858 {
3859 	/**
3860 	 * No influence is made on placement.
3861 	 */
3862 	NONE = 0,
3863 	/**
3864 	 * Windows should be placed in the center of the screen.
3865 	 */
3866 	CENTER = 1,
3867 	/**
3868 	 * Windows should be placed at the current mouse position.
3869 	 */
3870 	MOUSE = 2,
3871 	/**
3872 	 * Keep window centered as it changes size, etc.
3873 	 */
3874 	CENTER_ALWAYS = 3,
3875 	/**
3876 	 * Center the window on its transient
3877 	 * parent (see gtk_window_set_transient_for()).
3878 	 */
3879 	CENTER_ON_PARENT = 4,
3880 }
3881 alias GtkWindowPosition WindowPosition;
3882 
3883 /**
3884  * A #GtkWindow can be one of these types. Most things you’d consider a
3885  * “window” should have type #GTK_WINDOW_TOPLEVEL; windows with this type
3886  * are managed by the window manager and have a frame by default (call
3887  * gtk_window_set_decorated() to toggle the frame).  Windows with type
3888  * #GTK_WINDOW_POPUP are ignored by the window manager; window manager
3889  * keybindings won’t work on them, the window manager won’t decorate the
3890  * window with a frame, many GTK+ features that rely on the window
3891  * manager will not work (e.g. resize grips and
3892  * maximization/minimization). #GTK_WINDOW_POPUP is used to implement
3893  * widgets such as #GtkMenu or tooltips that you normally don’t think of
3894  * as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL.
3895  * In particular, do not use #GTK_WINDOW_POPUP just to turn off
3896  * the window borders; use gtk_window_set_decorated() for that.
3897  */
3898 public enum GtkWindowType
3899 {
3900 	/**
3901 	 * A regular window, such as a dialog.
3902 	 */
3903 	TOPLEVEL = 0,
3904 	/**
3905 	 * A special window such as a tooltip.
3906 	 */
3907 	POPUP = 1,
3908 }
3909 alias GtkWindowType WindowType;
3910 
3911 /**
3912  * Describes a type of line wrapping.
3913  */
3914 public enum GtkWrapMode
3915 {
3916 	/**
3917 	 * do not wrap lines; just make the text area wider
3918 	 */
3919 	NONE = 0,
3920 	/**
3921 	 * wrap text, breaking lines anywhere the cursor can
3922 	 * appear (between characters, usually - if you want to be technical,
3923 	 * between graphemes, see pango_get_log_attrs())
3924 	 */
3925 	CHAR = 1,
3926 	/**
3927 	 * wrap text, breaking lines in between words
3928 	 */
3929 	WORD = 2,
3930 	/**
3931 	 * wrap text, breaking lines in between words, or if
3932 	 * that is not enough, also between graphemes
3933 	 */
3934 	WORD_CHAR = 3,
3935 }
3936 alias GtkWrapMode WrapMode;
3937 
3938 struct GtkAboutDialog
3939 {
3940 	GtkDialog parentInstance;
3941 	GtkAboutDialogPrivate* priv;
3942 }
3943 
3944 struct GtkAboutDialogClass
3945 {
3946 	GtkDialogClass parentClass;
3947 	/** */
3948 	extern(C) int function(GtkAboutDialog* dialog, const(char)* uri) activateLink;
3949 	/** */
3950 	extern(C) void function() GtkReserved1;
3951 	/** */
3952 	extern(C) void function() GtkReserved2;
3953 	/** */
3954 	extern(C) void function() GtkReserved3;
3955 	/** */
3956 	extern(C) void function() GtkReserved4;
3957 }
3958 
3959 struct GtkAboutDialogPrivate;
3960 
3961 struct GtkAccelGroup
3962 {
3963 	GObject parent;
3964 	GtkAccelGroupPrivate* priv;
3965 }
3966 
3967 struct GtkAccelGroupClass
3968 {
3969 	/**
3970 	 * The parent class.
3971 	 */
3972 	GObjectClass parentClass;
3973 	/** */
3974 	extern(C) void function(GtkAccelGroup* accelGroup, uint keyval, GdkModifierType modifier, GClosure* accelClosure) accelChanged;
3975 	/** */
3976 	extern(C) void function() GtkReserved1;
3977 	/** */
3978 	extern(C) void function() GtkReserved2;
3979 	/** */
3980 	extern(C) void function() GtkReserved3;
3981 	/** */
3982 	extern(C) void function() GtkReserved4;
3983 }
3984 
3985 struct GtkAccelGroupEntry
3986 {
3987 	GtkAccelKey key;
3988 	GClosure* closure;
3989 	GQuark accelPathQuark;
3990 }
3991 
3992 struct GtkAccelGroupPrivate;
3993 
3994 struct GtkAccelKey
3995 {
3996 	/**
3997 	 * The accelerator keyval
3998 	 */
3999 	uint accelKey;
4000 	/**
4001 	 * The accelerator modifiers
4002 	 */
4003 	GdkModifierType accelMods;
4004 	import std.bitmanip: bitfields;
4005 	mixin(bitfields!(
4006 		uint, "accelFlags", 16,
4007 		uint, "", 16
4008 	));
4009 }
4010 
4011 struct GtkAccelLabel
4012 {
4013 	GtkLabel label;
4014 	GtkAccelLabelPrivate* priv;
4015 }
4016 
4017 struct GtkAccelLabelClass
4018 {
4019 	GtkLabelClass parentClass;
4020 	char* signalQuote1;
4021 	char* signalQuote2;
4022 	char* modNameShift;
4023 	char* modNameControl;
4024 	char* modNameAlt;
4025 	char* modSeparator;
4026 	/** */
4027 	extern(C) void function() GtkReserved1;
4028 	/** */
4029 	extern(C) void function() GtkReserved2;
4030 	/** */
4031 	extern(C) void function() GtkReserved3;
4032 	/** */
4033 	extern(C) void function() GtkReserved4;
4034 }
4035 
4036 struct GtkAccelLabelPrivate;
4037 
4038 struct GtkAccelMap;
4039 
4040 struct GtkAccelMapClass;
4041 
4042 struct GtkAccessible
4043 {
4044 	AtkObject parent;
4045 	GtkAccessiblePrivate* priv;
4046 }
4047 
4048 struct GtkAccessibleClass
4049 {
4050 	AtkObjectClass parentClass;
4051 	/** */
4052 	extern(C) void function(GtkAccessible* accessible) connectWidgetDestroyed;
4053 	/** */
4054 	extern(C) void function(GtkAccessible* accessible) widgetSet;
4055 	/** */
4056 	extern(C) void function(GtkAccessible* accessible) widgetUnset;
4057 	/** */
4058 	extern(C) void function() GtkReserved3;
4059 	/** */
4060 	extern(C) void function() GtkReserved4;
4061 }
4062 
4063 struct GtkAccessiblePrivate;
4064 
4065 struct GtkAction
4066 {
4067 	GObject object;
4068 	GtkActionPrivate* privateData;
4069 }
4070 
4071 struct GtkActionBar
4072 {
4073 	GtkBin bin;
4074 }
4075 
4076 struct GtkActionBarClass
4077 {
4078 	GtkBinClass parentClass;
4079 	/** */
4080 	extern(C) void function() GtkReserved1;
4081 	/** */
4082 	extern(C) void function() GtkReserved2;
4083 	/** */
4084 	extern(C) void function() GtkReserved3;
4085 	/** */
4086 	extern(C) void function() GtkReserved4;
4087 }
4088 
4089 struct GtkActionBarPrivate;
4090 
4091 struct GtkActionClass
4092 {
4093 	/**
4094 	 * The parent class.
4095 	 */
4096 	GObjectClass parentClass;
4097 	/** */
4098 	extern(C) void function(GtkAction* action) activate;
4099 	GType menuItemType;
4100 	GType toolbarItemType;
4101 	/**
4102 	 *
4103 	 * Params:
4104 	 *     action = the action object
4105 	 * Returns: a menu item connected to the action.
4106 	 */
4107 	extern(C) GtkWidget* function(GtkAction* action) createMenuItem;
4108 	/**
4109 	 *
4110 	 * Params:
4111 	 *     action = the action object
4112 	 * Returns: a toolbar item connected to the action.
4113 	 */
4114 	extern(C) GtkWidget* function(GtkAction* action) createToolItem;
4115 	/** */
4116 	extern(C) void function(GtkAction* action, GtkWidget* proxy) connectProxy;
4117 	/** */
4118 	extern(C) void function(GtkAction* action, GtkWidget* proxy) disconnectProxy;
4119 	/**
4120 	 *
4121 	 * Params:
4122 	 *     action = a #GtkAction
4123 	 * Returns: the menu item provided by the
4124 	 *     action, or %NULL.
4125 	 */
4126 	extern(C) GtkWidget* function(GtkAction* action) createMenu;
4127 	/** */
4128 	extern(C) void function() GtkReserved1;
4129 	/** */
4130 	extern(C) void function() GtkReserved2;
4131 	/** */
4132 	extern(C) void function() GtkReserved3;
4133 	/** */
4134 	extern(C) void function() GtkReserved4;
4135 }
4136 
4137 /**
4138  * #GtkActionEntry structs are used with gtk_action_group_add_actions() to
4139  * construct actions.
4140  */
4141 struct GtkActionEntry
4142 {
4143 	/**
4144 	 * The name of the action.
4145 	 */
4146 	const(char)* name;
4147 	/**
4148 	 * The stock id for the action, or the name of an icon from the
4149 	 * icon theme.
4150 	 */
4151 	const(char)* stockId;
4152 	/**
4153 	 * The label for the action. This field should typically be marked
4154 	 * for translation, see gtk_action_group_set_translation_domain(). If
4155 	 * @label is %NULL, the label of the stock item with id @stock_id is used.
4156 	 */
4157 	const(char)* label;
4158 	/**
4159 	 * The accelerator for the action, in the format understood by
4160 	 * gtk_accelerator_parse().
4161 	 */
4162 	const(char)* accelerator;
4163 	/**
4164 	 * The tooltip for the action. This field should typically be
4165 	 * marked for translation, see gtk_action_group_set_translation_domain().
4166 	 */
4167 	const(char)* tooltip;
4168 	/**
4169 	 * The function to call when the action is activated.
4170 	 */
4171 	GCallback callback;
4172 }
4173 
4174 struct GtkActionGroup
4175 {
4176 	GObject parent;
4177 	GtkActionGroupPrivate* priv;
4178 }
4179 
4180 struct GtkActionGroupClass
4181 {
4182 	/**
4183 	 * The parent class.
4184 	 */
4185 	GObjectClass parentClass;
4186 	/**
4187 	 *
4188 	 * Params:
4189 	 *     actionGroup = the action group
4190 	 *     actionName = the name of the action
4191 	 * Returns: the action, or %NULL if no action by that name exists
4192 	 */
4193 	extern(C) GtkAction* function(GtkActionGroup* actionGroup, const(char)* actionName) getAction;
4194 	/** */
4195 	extern(C) void function() GtkReserved1;
4196 	/** */
4197 	extern(C) void function() GtkReserved2;
4198 	/** */
4199 	extern(C) void function() GtkReserved3;
4200 	/** */
4201 	extern(C) void function() GtkReserved4;
4202 }
4203 
4204 struct GtkActionGroupPrivate;
4205 
4206 struct GtkActionPrivate;
4207 
4208 struct GtkActionable;
4209 
4210 /**
4211  * The interface vtable for #GtkActionable.
4212  */
4213 struct GtkActionableInterface
4214 {
4215 	GTypeInterface gIface;
4216 	/**
4217 	 *
4218 	 * Params:
4219 	 *     actionable = a #GtkActionable widget
4220 	 * Returns: the action name, or %NULL if none is set
4221 	 */
4222 	extern(C) const(char)* function(GtkActionable* actionable) getActionName;
4223 	/** */
4224 	extern(C) void function(GtkActionable* actionable, const(char)* actionName) setActionName;
4225 	/**
4226 	 *
4227 	 * Params:
4228 	 *     actionable = a #GtkActionable widget
4229 	 * Returns: the current target value
4230 	 */
4231 	extern(C) GVariant* function(GtkActionable* actionable) getActionTargetValue;
4232 	/** */
4233 	extern(C) void function(GtkActionable* actionable, GVariant* targetValue) setActionTargetValue;
4234 }
4235 
4236 struct GtkActivatable;
4237 
4238 /**
4239  * > This method can be called with a %NULL action at times.
4240  *
4241  * Since: 2.16
4242  */
4243 struct GtkActivatableIface
4244 {
4245 	GTypeInterface gIface;
4246 	/** */
4247 	extern(C) void function(GtkActivatable* activatable, GtkAction* action, const(char)* propertyName) update;
4248 	/** */
4249 	extern(C) void function(GtkActivatable* activatable, GtkAction* action) syncActionProperties;
4250 }
4251 
4252 struct GtkAdjustment
4253 {
4254 	GObject parentInstance;
4255 	GtkAdjustmentPrivate* priv;
4256 }
4257 
4258 struct GtkAdjustmentClass
4259 {
4260 	GObjectClass parentClass;
4261 	/** */
4262 	extern(C) void function(GtkAdjustment* adjustment) changed;
4263 	/** */
4264 	extern(C) void function(GtkAdjustment* adjustment) valueChanged;
4265 	/** */
4266 	extern(C) void function() GtkReserved1;
4267 	/** */
4268 	extern(C) void function() GtkReserved2;
4269 	/** */
4270 	extern(C) void function() GtkReserved3;
4271 	/** */
4272 	extern(C) void function() GtkReserved4;
4273 }
4274 
4275 struct GtkAdjustmentPrivate;
4276 
4277 struct GtkAlignment
4278 {
4279 	GtkBin bin;
4280 	GtkAlignmentPrivate* priv;
4281 }
4282 
4283 struct GtkAlignmentClass
4284 {
4285 	/**
4286 	 * The parent class.
4287 	 */
4288 	GtkBinClass parentClass;
4289 	/** */
4290 	extern(C) void function() GtkReserved1;
4291 	/** */
4292 	extern(C) void function() GtkReserved2;
4293 	/** */
4294 	extern(C) void function() GtkReserved3;
4295 	/** */
4296 	extern(C) void function() GtkReserved4;
4297 }
4298 
4299 struct GtkAlignmentPrivate;
4300 
4301 struct GtkAppChooser;
4302 
4303 struct GtkAppChooserButton
4304 {
4305 	GtkComboBox parent;
4306 	GtkAppChooserButtonPrivate* priv;
4307 }
4308 
4309 struct GtkAppChooserButtonClass
4310 {
4311 	/**
4312 	 * The parent class.
4313 	 */
4314 	GtkComboBoxClass parentClass;
4315 	/** */
4316 	extern(C) void function(GtkAppChooserButton* self, const(char)* itemName) customItemActivated;
4317 	void*[16] padding;
4318 }
4319 
4320 struct GtkAppChooserButtonPrivate;
4321 
4322 struct GtkAppChooserDialog
4323 {
4324 	GtkDialog parent;
4325 	GtkAppChooserDialogPrivate* priv;
4326 }
4327 
4328 struct GtkAppChooserDialogClass
4329 {
4330 	/**
4331 	 * The parent class.
4332 	 */
4333 	GtkDialogClass parentClass;
4334 	void*[16] padding;
4335 }
4336 
4337 struct GtkAppChooserDialogPrivate;
4338 
4339 struct GtkAppChooserWidget
4340 {
4341 	GtkBox parent;
4342 	GtkAppChooserWidgetPrivate* priv;
4343 }
4344 
4345 struct GtkAppChooserWidgetClass
4346 {
4347 	/**
4348 	 * The parent class.
4349 	 */
4350 	GtkBoxClass parentClass;
4351 	/** */
4352 	extern(C) void function(GtkAppChooserWidget* self, GAppInfo* appInfo) applicationSelected;
4353 	/** */
4354 	extern(C) void function(GtkAppChooserWidget* self, GAppInfo* appInfo) applicationActivated;
4355 	/** */
4356 	extern(C) void function(GtkAppChooserWidget* self, GtkMenu* menu, GAppInfo* appInfo) populatePopup;
4357 	void*[16] padding;
4358 }
4359 
4360 struct GtkAppChooserWidgetPrivate;
4361 
4362 struct GtkApplication
4363 {
4364 	GApplication parent;
4365 	GtkApplicationPrivate* priv;
4366 }
4367 
4368 struct GtkApplicationClass
4369 {
4370 	/**
4371 	 * The parent class.
4372 	 */
4373 	GApplicationClass parentClass;
4374 	/** */
4375 	extern(C) void function(GtkApplication* application, GtkWindow* window) windowAdded;
4376 	/** */
4377 	extern(C) void function(GtkApplication* application, GtkWindow* window) windowRemoved;
4378 	void*[12] padding;
4379 }
4380 
4381 struct GtkApplicationPrivate;
4382 
4383 struct GtkApplicationWindow
4384 {
4385 	GtkWindow parentInstance;
4386 	GtkApplicationWindowPrivate* priv;
4387 }
4388 
4389 struct GtkApplicationWindowClass
4390 {
4391 	/**
4392 	 * The parent class.
4393 	 */
4394 	GtkWindowClass parentClass;
4395 	void*[14] padding;
4396 }
4397 
4398 struct GtkApplicationWindowPrivate;
4399 
4400 struct GtkArrow
4401 {
4402 	GtkMisc misc;
4403 	GtkArrowPrivate* priv;
4404 }
4405 
4406 struct GtkArrowAccessible
4407 {
4408 	GtkWidgetAccessible parent;
4409 	GtkArrowAccessiblePrivate* priv;
4410 }
4411 
4412 struct GtkArrowAccessibleClass
4413 {
4414 	GtkWidgetAccessibleClass parentClass;
4415 }
4416 
4417 struct GtkArrowAccessiblePrivate;
4418 
4419 struct GtkArrowClass
4420 {
4421 	GtkMiscClass parentClass;
4422 	/** */
4423 	extern(C) void function() GtkReserved1;
4424 	/** */
4425 	extern(C) void function() GtkReserved2;
4426 	/** */
4427 	extern(C) void function() GtkReserved3;
4428 	/** */
4429 	extern(C) void function() GtkReserved4;
4430 }
4431 
4432 struct GtkArrowPrivate;
4433 
4434 struct GtkAspectFrame
4435 {
4436 	GtkFrame frame;
4437 	GtkAspectFramePrivate* priv;
4438 }
4439 
4440 struct GtkAspectFrameClass
4441 {
4442 	/**
4443 	 * The parent class.
4444 	 */
4445 	GtkFrameClass parentClass;
4446 	/** */
4447 	extern(C) void function() GtkReserved1;
4448 	/** */
4449 	extern(C) void function() GtkReserved2;
4450 	/** */
4451 	extern(C) void function() GtkReserved3;
4452 	/** */
4453 	extern(C) void function() GtkReserved4;
4454 }
4455 
4456 struct GtkAspectFramePrivate;
4457 
4458 struct GtkAssistant
4459 {
4460 	GtkWindow parent;
4461 	GtkAssistantPrivate* priv;
4462 }
4463 
4464 struct GtkAssistantClass
4465 {
4466 	/**
4467 	 * The parent class.
4468 	 */
4469 	GtkWindowClass parentClass;
4470 	/** */
4471 	extern(C) void function(GtkAssistant* assistant, GtkWidget* page) prepare;
4472 	/** */
4473 	extern(C) void function(GtkAssistant* assistant) apply;
4474 	/** */
4475 	extern(C) void function(GtkAssistant* assistant) close;
4476 	/** */
4477 	extern(C) void function(GtkAssistant* assistant) cancel;
4478 	/** */
4479 	extern(C) void function() GtkReserved1;
4480 	/** */
4481 	extern(C) void function() GtkReserved2;
4482 	/** */
4483 	extern(C) void function() GtkReserved3;
4484 	/** */
4485 	extern(C) void function() GtkReserved4;
4486 	/** */
4487 	extern(C) void function() GtkReserved5;
4488 }
4489 
4490 struct GtkAssistantPrivate;
4491 
4492 struct GtkBin
4493 {
4494 	GtkContainer container;
4495 	GtkBinPrivate* priv;
4496 }
4497 
4498 struct GtkBinClass
4499 {
4500 	/**
4501 	 * The parent class.
4502 	 */
4503 	GtkContainerClass parentClass;
4504 	/** */
4505 	extern(C) void function() GtkReserved1;
4506 	/** */
4507 	extern(C) void function() GtkReserved2;
4508 	/** */
4509 	extern(C) void function() GtkReserved3;
4510 	/** */
4511 	extern(C) void function() GtkReserved4;
4512 }
4513 
4514 struct GtkBinPrivate;
4515 
4516 /**
4517  * A #GtkBindingArg holds the data associated with
4518  * an argument for a key binding signal emission as
4519  * stored in #GtkBindingSignal.
4520  */
4521 struct GtkBindingArg
4522 {
4523 	/**
4524 	 * implementation detail
4525 	 */
4526 	GType argType;
4527 	union D
4528 	{
4529 		glong longData;
4530 		double doubleData;
4531 		char* stringData;
4532 	}
4533 	D d;
4534 }
4535 
4536 /**
4537  * Each key binding element of a binding sets binding list is
4538  * represented by a GtkBindingEntry.
4539  */
4540 struct GtkBindingEntry
4541 {
4542 	/**
4543 	 * key value to match
4544 	 */
4545 	uint keyval;
4546 	/**
4547 	 * key modifiers to match
4548 	 */
4549 	GdkModifierType modifiers;
4550 	/**
4551 	 * binding set this entry belongs to
4552 	 */
4553 	GtkBindingSet* bindingSet;
4554 	import std.bitmanip: bitfields;
4555 	mixin(bitfields!(
4556 		uint, "destroyed", 1,
4557 		uint, "inEmission", 1,
4558 		uint, "marksUnbound", 1,
4559 		uint, "", 29
4560 	));
4561 	/**
4562 	 * linked list of entries maintained by binding set
4563 	 */
4564 	GtkBindingEntry* setNext;
4565 	/**
4566 	 * implementation detail
4567 	 */
4568 	GtkBindingEntry* hashNext;
4569 	/**
4570 	 * action signals of this entry
4571 	 */
4572 	GtkBindingSignal* signals;
4573 }
4574 
4575 struct GtkBindingSet
4576 {
4577 	/**
4578 	 * unique name of this binding set
4579 	 */
4580 	char* setName;
4581 	/**
4582 	 * unused
4583 	 */
4584 	int priority;
4585 	/**
4586 	 * unused
4587 	 */
4588 	GSList* widgetPathPspecs;
4589 	/**
4590 	 * unused
4591 	 */
4592 	GSList* widgetClassPspecs;
4593 	/**
4594 	 * unused
4595 	 */
4596 	GSList* classBranchPspecs;
4597 	/**
4598 	 * the key binding entries in this binding set
4599 	 */
4600 	GtkBindingEntry* entries;
4601 	/**
4602 	 * implementation detail
4603 	 */
4604 	GtkBindingEntry* current;
4605 	import std.bitmanip: bitfields;
4606 	mixin(bitfields!(
4607 		uint, "parsed", 1,
4608 		uint, "", 31
4609 	));
4610 }
4611 
4612 /**
4613  * A GtkBindingSignal stores the necessary information to
4614  * activate a widget in response to a key press via a signal
4615  * emission.
4616  */
4617 struct GtkBindingSignal
4618 {
4619 	/**
4620 	 * implementation detail
4621 	 */
4622 	GtkBindingSignal* next;
4623 	/**
4624 	 * the action signal to be emitted
4625 	 */
4626 	char* signalName;
4627 	/**
4628 	 * number of arguments specified for the signal
4629 	 */
4630 	uint nArgs;
4631 	/**
4632 	 * the arguments specified for the signal
4633 	 */
4634 	GtkBindingArg* args;
4635 }
4636 
4637 struct GtkBooleanCellAccessible
4638 {
4639 	GtkRendererCellAccessible parent;
4640 	GtkBooleanCellAccessiblePrivate* priv;
4641 }
4642 
4643 struct GtkBooleanCellAccessibleClass
4644 {
4645 	GtkRendererCellAccessibleClass parentClass;
4646 }
4647 
4648 struct GtkBooleanCellAccessiblePrivate;
4649 
4650 struct GtkBorder
4651 {
4652 	/**
4653 	 * The width of the left border
4654 	 */
4655 	short left;
4656 	/**
4657 	 * The width of the right border
4658 	 */
4659 	short right;
4660 	/**
4661 	 * The width of the top border
4662 	 */
4663 	short top;
4664 	/**
4665 	 * The width of the bottom border
4666 	 */
4667 	short bottom;
4668 }
4669 
4670 struct GtkBox
4671 {
4672 	GtkContainer container;
4673 	GtkBoxPrivate* priv;
4674 }
4675 
4676 struct GtkBoxClass
4677 {
4678 	/**
4679 	 * The parent class.
4680 	 */
4681 	GtkContainerClass parentClass;
4682 	/** */
4683 	extern(C) void function() GtkReserved1;
4684 	/** */
4685 	extern(C) void function() GtkReserved2;
4686 	/** */
4687 	extern(C) void function() GtkReserved3;
4688 	/** */
4689 	extern(C) void function() GtkReserved4;
4690 }
4691 
4692 struct GtkBoxPrivate;
4693 
4694 struct GtkBuildable;
4695 
4696 /**
4697  * The #GtkBuildableIface interface contains method that are
4698  * necessary to allow #GtkBuilder to construct an object from
4699  * a #GtkBuilder UI definition.
4700  */
4701 struct GtkBuildableIface
4702 {
4703 	/**
4704 	 * the parent class
4705 	 */
4706 	GTypeInterface gIface;
4707 	/** */
4708 	extern(C) void function(GtkBuildable* buildable, const(char)* name) setName;
4709 	/**
4710 	 *
4711 	 * Params:
4712 	 *     buildable = a #GtkBuildable
4713 	 * Returns: the name set with gtk_buildable_set_name()
4714 	 */
4715 	extern(C) const(char)* function(GtkBuildable* buildable) getName;
4716 	/** */
4717 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* type) addChild;
4718 	/** */
4719 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, const(char)* name, GValue* value) setBuildableProperty;
4720 	/**
4721 	 *
4722 	 * Params:
4723 	 *     buildable = A #GtkBuildable
4724 	 *     builder = #GtkBuilder used to construct this object
4725 	 *     name = name of child to construct
4726 	 * Returns: the constructed child
4727 	 */
4728 	extern(C) GObject* function(GtkBuildable* buildable, GtkBuilder* builder, const(char)* name) constructChild;
4729 	/**
4730 	 *
4731 	 * Params:
4732 	 *     buildable = a #GtkBuildable
4733 	 *     builder = a #GtkBuilder used to construct this object
4734 	 *     child = child object or %NULL for non-child tags
4735 	 *     tagname = name of tag
4736 	 *     parser = a #GMarkupParser to fill in
4737 	 *     data = return location for user data that will be passed in
4738 	 *         to parser functions
4739 	 * Returns: %TRUE if a object has a custom implementation, %FALSE
4740 	 *     if it doesn't.
4741 	 */
4742 	extern(C) int function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* tagname, GMarkupParser* parser, void** data) customTagStart;
4743 	/** */
4744 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* tagname, void** data) customTagEnd;
4745 	/** */
4746 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder, GObject* child, const(char)* tagname, void* data) customFinished;
4747 	/** */
4748 	extern(C) void function(GtkBuildable* buildable, GtkBuilder* builder) parserFinished;
4749 	/**
4750 	 *
4751 	 * Params:
4752 	 *     buildable = a #GtkBuildable
4753 	 *     builder = a #GtkBuilder
4754 	 *     childname = name of child
4755 	 * Returns: the internal child of the buildable object
4756 	 */
4757 	extern(C) GObject* function(GtkBuildable* buildable, GtkBuilder* builder, const(char)* childname) getInternalChild;
4758 }
4759 
4760 struct GtkBuilder
4761 {
4762 	GObject parentInstance;
4763 	GtkBuilderPrivate* priv;
4764 }
4765 
4766 struct GtkBuilderClass
4767 {
4768 	GObjectClass parentClass;
4769 	/**
4770 	 *
4771 	 * Params:
4772 	 *     builder = a #GtkBuilder
4773 	 *     typeName = type name to lookup
4774 	 * Returns: the #GType found for @type_name or #G_TYPE_INVALID
4775 	 *     if no type was found
4776 	 */
4777 	extern(C) GType function(GtkBuilder* builder, const(char)* typeName) getTypeFromName;
4778 	/** */
4779 	extern(C) void function() GtkReserved1;
4780 	/** */
4781 	extern(C) void function() GtkReserved2;
4782 	/** */
4783 	extern(C) void function() GtkReserved3;
4784 	/** */
4785 	extern(C) void function() GtkReserved4;
4786 	/** */
4787 	extern(C) void function() GtkReserved5;
4788 	/** */
4789 	extern(C) void function() GtkReserved6;
4790 	/** */
4791 	extern(C) void function() GtkReserved7;
4792 	/** */
4793 	extern(C) void function() GtkReserved8;
4794 }
4795 
4796 struct GtkBuilderPrivate;
4797 
4798 struct GtkButton
4799 {
4800 	GtkBin bin;
4801 	GtkButtonPrivate* priv;
4802 }
4803 
4804 struct GtkButtonAccessible
4805 {
4806 	GtkContainerAccessible parent;
4807 	GtkButtonAccessiblePrivate* priv;
4808 }
4809 
4810 struct GtkButtonAccessibleClass
4811 {
4812 	GtkContainerAccessibleClass parentClass;
4813 }
4814 
4815 struct GtkButtonAccessiblePrivate;
4816 
4817 struct GtkButtonBox
4818 {
4819 	GtkBox box;
4820 	GtkButtonBoxPrivate* priv;
4821 }
4822 
4823 struct GtkButtonBoxClass
4824 {
4825 	/**
4826 	 * The parent class.
4827 	 */
4828 	GtkBoxClass parentClass;
4829 	/** */
4830 	extern(C) void function() GtkReserved1;
4831 	/** */
4832 	extern(C) void function() GtkReserved2;
4833 	/** */
4834 	extern(C) void function() GtkReserved3;
4835 	/** */
4836 	extern(C) void function() GtkReserved4;
4837 }
4838 
4839 struct GtkButtonBoxPrivate;
4840 
4841 struct GtkButtonClass
4842 {
4843 	/**
4844 	 * The parent class.
4845 	 */
4846 	GtkBinClass parentClass;
4847 	/** */
4848 	extern(C) void function(GtkButton* button) pressed;
4849 	/** */
4850 	extern(C) void function(GtkButton* button) released;
4851 	/** */
4852 	extern(C) void function(GtkButton* button) clicked;
4853 	/** */
4854 	extern(C) void function(GtkButton* button) enter;
4855 	/** */
4856 	extern(C) void function(GtkButton* button) leave;
4857 	/** */
4858 	extern(C) void function(GtkButton* button) activate;
4859 	/** */
4860 	extern(C) void function() GtkReserved1;
4861 	/** */
4862 	extern(C) void function() GtkReserved2;
4863 	/** */
4864 	extern(C) void function() GtkReserved3;
4865 	/** */
4866 	extern(C) void function() GtkReserved4;
4867 }
4868 
4869 struct GtkButtonPrivate;
4870 
4871 struct GtkCalendar
4872 {
4873 	GtkWidget widget;
4874 	GtkCalendarPrivate* priv;
4875 }
4876 
4877 struct GtkCalendarClass
4878 {
4879 	GtkWidgetClass parentClass;
4880 	/** */
4881 	extern(C) void function(GtkCalendar* calendar) monthChanged;
4882 	/** */
4883 	extern(C) void function(GtkCalendar* calendar) daySelected;
4884 	/** */
4885 	extern(C) void function(GtkCalendar* calendar) daySelectedDoubleClick;
4886 	/** */
4887 	extern(C) void function(GtkCalendar* calendar) prevMonth;
4888 	/** */
4889 	extern(C) void function(GtkCalendar* calendar) nextMonth;
4890 	/** */
4891 	extern(C) void function(GtkCalendar* calendar) prevYear;
4892 	/** */
4893 	extern(C) void function(GtkCalendar* calendar) nextYear;
4894 	/** */
4895 	extern(C) void function() GtkReserved1;
4896 	/** */
4897 	extern(C) void function() GtkReserved2;
4898 	/** */
4899 	extern(C) void function() GtkReserved3;
4900 	/** */
4901 	extern(C) void function() GtkReserved4;
4902 }
4903 
4904 struct GtkCalendarPrivate;
4905 
4906 struct GtkCellAccessible
4907 {
4908 	GtkAccessible parent;
4909 	GtkCellAccessiblePrivate* priv;
4910 }
4911 
4912 struct GtkCellAccessibleClass
4913 {
4914 	GtkAccessibleClass parentClass;
4915 	/** */
4916 	extern(C) void function(GtkCellAccessible* cell, int emitSignal) updateCache;
4917 }
4918 
4919 struct GtkCellAccessibleParent;
4920 
4921 struct GtkCellAccessibleParentIface
4922 {
4923 	GTypeInterface parent;
4924 	/** */
4925 	extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell, int* x, int* y, int* width, int* height, AtkCoordType coordType) getCellExtents;
4926 	/** */
4927 	extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell, GdkRectangle* cellRect) getCellArea;
4928 	/** */
4929 	extern(C) int function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) grabFocus;
4930 	/** */
4931 	extern(C) int function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) getChildIndex;
4932 	/** */
4933 	extern(C) GtkCellRendererState function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) getRendererState;
4934 	/** */
4935 	extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) expandCollapse;
4936 	/** */
4937 	extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) activate;
4938 	/** */
4939 	extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell) edit;
4940 	/** */
4941 	extern(C) void function(GtkCellAccessibleParent* parent, GtkCellAccessible* cell, AtkRelationSet* relationset) updateRelationset;
4942 }
4943 
4944 struct GtkCellAccessiblePrivate;
4945 
4946 struct GtkCellArea
4947 {
4948 	GObject parentInstance;
4949 	GtkCellAreaPrivate* priv;
4950 }
4951 
4952 struct GtkCellAreaBox
4953 {
4954 	GtkCellArea parentInstance;
4955 	GtkCellAreaBoxPrivate* priv;
4956 }
4957 
4958 struct GtkCellAreaBoxClass
4959 {
4960 	GtkCellAreaClass parentClass;
4961 	/** */
4962 	extern(C) void function() GtkReserved1;
4963 	/** */
4964 	extern(C) void function() GtkReserved2;
4965 	/** */
4966 	extern(C) void function() GtkReserved3;
4967 	/** */
4968 	extern(C) void function() GtkReserved4;
4969 }
4970 
4971 struct GtkCellAreaBoxPrivate;
4972 
4973 struct GtkCellAreaClass
4974 {
4975 	GObjectClass parentClass;
4976 	/** */
4977 	extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer) add;
4978 	/** */
4979 	extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer) remove;
4980 	/** */
4981 	extern(C) void function(GtkCellArea* area, GtkCellCallback callback, void* callbackData) foreac;
4982 	/** */
4983 	extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, GdkRectangle* cellArea, GdkRectangle* backgroundArea, GtkCellAllocCallback callback, void* callbackData) foreachAlloc;
4984 	/**
4985 	 *
4986 	 * Params:
4987 	 *     area = a #GtkCellArea
4988 	 *     context = the #GtkCellAreaContext for this row of data.
4989 	 *     widget = the #GtkWidget that @area is rendering to
4990 	 *     event = the #GdkEvent to handle
4991 	 *     cellArea = the @widget relative coordinates for @area
4992 	 *     flags = the #GtkCellRendererState for @area in this row.
4993 	 * Returns: %TRUE if the event was handled by @area.
4994 	 */
4995 	extern(C) int function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, GdkEvent* event, GdkRectangle* cellArea, GtkCellRendererState flags) event;
4996 	/** */
4997 	extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, cairo_t* cr, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags, int paintFocus) render;
4998 	/** */
4999 	extern(C) void function(GtkCellArea* area, GtkTreeModel* treeModel, GtkTreeIter* iter, int isExpander, int isExpanded) applyAttributes;
5000 	/**
5001 	 *
5002 	 * Params:
5003 	 *     area = a #GtkCellArea
5004 	 * Returns: a newly created #GtkCellAreaContext which can be used with @area.
5005 	 */
5006 	extern(C) GtkCellAreaContext* function(GtkCellArea* area) createContext;
5007 	/**
5008 	 *
5009 	 * Params:
5010 	 *     area = a #GtkCellArea
5011 	 *     context = the #GtkCellAreaContext to copy
5012 	 * Returns: a newly created #GtkCellAreaContext copy of @context.
5013 	 */
5014 	extern(C) GtkCellAreaContext* function(GtkCellArea* area, GtkCellAreaContext* context) copyContext;
5015 	/**
5016 	 *
5017 	 * Params:
5018 	 *     area = a #GtkCellArea
5019 	 * Returns: The #GtkSizeRequestMode preferred by @area.
5020 	 */
5021 	extern(C) GtkSizeRequestMode function(GtkCellArea* area) getRequestMode;
5022 	/** */
5023 	extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int* minimumWidth, int* naturalWidth) getPreferredWidth;
5024 	/** */
5025 	extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth;
5026 	/** */
5027 	extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int* minimumHeight, int* naturalHeight) getPreferredHeight;
5028 	/** */
5029 	extern(C) void function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight;
5030 	/** */
5031 	extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer, uint propertyId, GValue* value, GParamSpec* pspec) setCellProperty;
5032 	/** */
5033 	extern(C) void function(GtkCellArea* area, GtkCellRenderer* renderer, uint propertyId, GValue* value, GParamSpec* pspec) getCellProperty;
5034 	/**
5035 	 *
5036 	 * Params:
5037 	 *     area = a #GtkCellArea
5038 	 *     direction = the #GtkDirectionType
5039 	 * Returns: %TRUE if focus remains inside @area as a result of this call.
5040 	 */
5041 	extern(C) int function(GtkCellArea* area, GtkDirectionType direction) focus;
5042 	/**
5043 	 *
5044 	 * Params:
5045 	 *     area = a #GtkCellArea
5046 	 * Returns: whether @area can do anything when activated.
5047 	 */
5048 	extern(C) int function(GtkCellArea* area) isActivatable;
5049 	/**
5050 	 *
5051 	 * Params:
5052 	 *     area = a #GtkCellArea
5053 	 *     context = the #GtkCellAreaContext in context with the current row data
5054 	 *     widget = the #GtkWidget that @area is rendering on
5055 	 *     cellArea = the size and location of @area relative to @widget’s allocation
5056 	 *     flags = the #GtkCellRendererState flags for @area for this row of data.
5057 	 *     editOnly = if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE
5058 	 *         will be activated.
5059 	 * Returns: Whether @area was successfully activated.
5060 	 */
5061 	extern(C) int function(GtkCellArea* area, GtkCellAreaContext* context, GtkWidget* widget, GdkRectangle* cellArea, GtkCellRendererState flags, int editOnly) activate;
5062 	/** */
5063 	extern(C) void function() GtkReserved1;
5064 	/** */
5065 	extern(C) void function() GtkReserved2;
5066 	/** */
5067 	extern(C) void function() GtkReserved3;
5068 	/** */
5069 	extern(C) void function() GtkReserved4;
5070 	/** */
5071 	extern(C) void function() GtkReserved5;
5072 	/** */
5073 	extern(C) void function() GtkReserved6;
5074 	/** */
5075 	extern(C) void function() GtkReserved7;
5076 	/** */
5077 	extern(C) void function() GtkReserved8;
5078 }
5079 
5080 struct GtkCellAreaContext
5081 {
5082 	GObject parentInstance;
5083 	GtkCellAreaContextPrivate* priv;
5084 }
5085 
5086 struct GtkCellAreaContextClass
5087 {
5088 	GObjectClass parentClass;
5089 	/** */
5090 	extern(C) void function(GtkCellAreaContext* context, int width, int height) allocate;
5091 	/** */
5092 	extern(C) void function(GtkCellAreaContext* context) reset;
5093 	/** */
5094 	extern(C) void function(GtkCellAreaContext* context, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth;
5095 	/** */
5096 	extern(C) void function(GtkCellAreaContext* context, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight;
5097 	/** */
5098 	extern(C) void function() GtkReserved1;
5099 	/** */
5100 	extern(C) void function() GtkReserved2;
5101 	/** */
5102 	extern(C) void function() GtkReserved3;
5103 	/** */
5104 	extern(C) void function() GtkReserved4;
5105 	/** */
5106 	extern(C) void function() GtkReserved5;
5107 	/** */
5108 	extern(C) void function() GtkReserved6;
5109 }
5110 
5111 struct GtkCellAreaContextPrivate;
5112 
5113 struct GtkCellAreaPrivate;
5114 
5115 struct GtkCellEditable;
5116 
5117 struct GtkCellEditableIface
5118 {
5119 	GTypeInterface gIface;
5120 	/** */
5121 	extern(C) void function(GtkCellEditable* cellEditable) editingDone;
5122 	/** */
5123 	extern(C) void function(GtkCellEditable* cellEditable) removeWidget;
5124 	/** */
5125 	extern(C) void function(GtkCellEditable* cellEditable, GdkEvent* event) startEditing;
5126 }
5127 
5128 struct GtkCellLayout;
5129 
5130 struct GtkCellLayoutIface
5131 {
5132 	GTypeInterface gIface;
5133 	/** */
5134 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int expand) packStart;
5135 	/** */
5136 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int expand) packEnd;
5137 	/** */
5138 	extern(C) void function(GtkCellLayout* cellLayout) clear;
5139 	/** */
5140 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, const(char)* attribute, int column) addAttribute;
5141 	/** */
5142 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, GtkCellLayoutDataFunc func, void* funcData, GDestroyNotify destroy) setCellDataFunc;
5143 	/** */
5144 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell) clearAttributes;
5145 	/** */
5146 	extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, int position) reorder;
5147 	/**
5148 	 *
5149 	 * Params:
5150 	 *     cellLayout = a #GtkCellLayout
5151 	 * Returns: a list of cell renderers. The list, but not the renderers has
5152 	 *     been newly allocated and should be freed with g_list_free()
5153 	 *     when no longer needed.
5154 	 */
5155 	extern(C) GList* function(GtkCellLayout* cellLayout) getCells;
5156 	/**
5157 	 *
5158 	 * Params:
5159 	 *     cellLayout = a #GtkCellLayout
5160 	 * Returns: the cell area used by @cell_layout,
5161 	 *     or %NULL in case no cell area is used.
5162 	 */
5163 	extern(C) GtkCellArea* function(GtkCellLayout* cellLayout) getArea;
5164 }
5165 
5166 struct GtkCellRenderer
5167 {
5168 	GObject parentInstance;
5169 	GtkCellRendererPrivate* priv;
5170 }
5171 
5172 struct GtkCellRendererAccel
5173 {
5174 	GtkCellRendererText parent;
5175 	GtkCellRendererAccelPrivate* priv;
5176 }
5177 
5178 struct GtkCellRendererAccelClass
5179 {
5180 	GtkCellRendererTextClass parentClass;
5181 	/** */
5182 	extern(C) void function(GtkCellRendererAccel* accel, const(char)* pathString, uint accelKey, GdkModifierType accelMods, uint hardwareKeycode) accelEdited;
5183 	/** */
5184 	extern(C) void function(GtkCellRendererAccel* accel, const(char)* pathString) accelCleared;
5185 	/** */
5186 	extern(C) void function() GtkReserved0;
5187 	/** */
5188 	extern(C) void function() GtkReserved1;
5189 	/** */
5190 	extern(C) void function() GtkReserved2;
5191 	/** */
5192 	extern(C) void function() GtkReserved3;
5193 	/** */
5194 	extern(C) void function() GtkReserved4;
5195 }
5196 
5197 struct GtkCellRendererAccelPrivate;
5198 
5199 struct GtkCellRendererClass
5200 {
5201 	GObjectClass parentClass;
5202 	/**
5203 	 *
5204 	 * Params:
5205 	 *     cell = a #GtkCellRenderer    instance
5206 	 * Returns: The #GtkSizeRequestMode preferred by this renderer.
5207 	 */
5208 	extern(C) GtkSizeRequestMode function(GtkCellRenderer* cell) getRequestMode;
5209 	/** */
5210 	extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int* minimumSize, int* naturalSize) getPreferredWidth;
5211 	/** */
5212 	extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth;
5213 	/** */
5214 	extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int* minimumSize, int* naturalSize) getPreferredHeight;
5215 	/** */
5216 	extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight;
5217 	/** */
5218 	extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, GtkCellRendererState flags, GdkRectangle* cellArea, GdkRectangle* alignedArea) getAlignedArea;
5219 	/** */
5220 	extern(C) void function(GtkCellRenderer* cell, GtkWidget* widget, GdkRectangle* cellArea, int* xOffset, int* yOffset, int* width, int* height) getSize;
5221 	/** */
5222 	extern(C) void function(GtkCellRenderer* cell, cairo_t* cr, GtkWidget* widget, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags) render;
5223 	/**
5224 	 *
5225 	 * Params:
5226 	 *     cell = a #GtkCellRenderer
5227 	 *     event = a #GdkEvent
5228 	 *     widget = widget that received the event
5229 	 *     path = widget-dependent string representation of the event location;
5230 	 *         e.g. for #GtkTreeView, a string representation of #GtkTreePath
5231 	 *     backgroundArea = background area as passed to gtk_cell_renderer_render()
5232 	 *     cellArea = cell area as passed to gtk_cell_renderer_render()
5233 	 *     flags = render flags
5234 	 * Returns: %TRUE if the event was consumed/handled
5235 	 */
5236 	extern(C) int function(GtkCellRenderer* cell, GdkEvent* event, GtkWidget* widget, const(char)* path, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags) activate;
5237 	/**
5238 	 *
5239 	 * Params:
5240 	 *     cell = a #GtkCellRenderer
5241 	 *     event = a #GdkEvent
5242 	 *     widget = widget that received the event
5243 	 *     path = widget-dependent string representation of the event location;
5244 	 *         e.g. for #GtkTreeView, a string representation of #GtkTreePath
5245 	 *     backgroundArea = background area as passed to gtk_cell_renderer_render()
5246 	 *     cellArea = cell area as passed to gtk_cell_renderer_render()
5247 	 *     flags = render flags
5248 	 * Returns: A new #GtkCellEditable, or %NULL
5249 	 */
5250 	extern(C) GtkCellEditable* function(GtkCellRenderer* cell, GdkEvent* event, GtkWidget* widget, const(char)* path, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags) startEditing;
5251 	/** */
5252 	extern(C) void function(GtkCellRenderer* cell) editingCanceled;
5253 	/** */
5254 	extern(C) void function(GtkCellRenderer* cell, GtkCellEditable* editable, const(char)* path) editingStarted;
5255 	GtkCellRendererClassPrivate* priv;
5256 	/** */
5257 	extern(C) void function() GtkReserved2;
5258 	/** */
5259 	extern(C) void function() GtkReserved3;
5260 	/** */
5261 	extern(C) void function() GtkReserved4;
5262 }
5263 
5264 struct GtkCellRendererClassPrivate;
5265 
5266 struct GtkCellRendererCombo
5267 {
5268 	GtkCellRendererText parent;
5269 	GtkCellRendererComboPrivate* priv;
5270 }
5271 
5272 struct GtkCellRendererComboClass
5273 {
5274 	GtkCellRendererTextClass parent;
5275 	/** */
5276 	extern(C) void function() GtkReserved1;
5277 	/** */
5278 	extern(C) void function() GtkReserved2;
5279 	/** */
5280 	extern(C) void function() GtkReserved3;
5281 	/** */
5282 	extern(C) void function() GtkReserved4;
5283 }
5284 
5285 struct GtkCellRendererComboPrivate;
5286 
5287 struct GtkCellRendererPixbuf
5288 {
5289 	GtkCellRenderer parent;
5290 	GtkCellRendererPixbufPrivate* priv;
5291 }
5292 
5293 struct GtkCellRendererPixbufClass
5294 {
5295 	GtkCellRendererClass parentClass;
5296 	/** */
5297 	extern(C) void function() GtkReserved1;
5298 	/** */
5299 	extern(C) void function() GtkReserved2;
5300 	/** */
5301 	extern(C) void function() GtkReserved3;
5302 	/** */
5303 	extern(C) void function() GtkReserved4;
5304 }
5305 
5306 struct GtkCellRendererPixbufPrivate;
5307 
5308 struct GtkCellRendererPrivate;
5309 
5310 struct GtkCellRendererProgress
5311 {
5312 	GtkCellRenderer parentInstance;
5313 	GtkCellRendererProgressPrivate* priv;
5314 }
5315 
5316 struct GtkCellRendererProgressClass
5317 {
5318 	GtkCellRendererClass parentClass;
5319 	/** */
5320 	extern(C) void function() GtkReserved1;
5321 	/** */
5322 	extern(C) void function() GtkReserved2;
5323 	/** */
5324 	extern(C) void function() GtkReserved3;
5325 	/** */
5326 	extern(C) void function() GtkReserved4;
5327 }
5328 
5329 struct GtkCellRendererProgressPrivate;
5330 
5331 struct GtkCellRendererSpin
5332 {
5333 	GtkCellRendererText parent;
5334 	GtkCellRendererSpinPrivate* priv;
5335 }
5336 
5337 struct GtkCellRendererSpinClass
5338 {
5339 	GtkCellRendererTextClass parent;
5340 	/** */
5341 	extern(C) void function() GtkReserved1;
5342 	/** */
5343 	extern(C) void function() GtkReserved2;
5344 	/** */
5345 	extern(C) void function() GtkReserved3;
5346 	/** */
5347 	extern(C) void function() GtkReserved4;
5348 }
5349 
5350 struct GtkCellRendererSpinPrivate;
5351 
5352 struct GtkCellRendererSpinner
5353 {
5354 	GtkCellRenderer parent;
5355 	GtkCellRendererSpinnerPrivate* priv;
5356 }
5357 
5358 struct GtkCellRendererSpinnerClass
5359 {
5360 	GtkCellRendererClass parentClass;
5361 	/** */
5362 	extern(C) void function() GtkReserved1;
5363 	/** */
5364 	extern(C) void function() GtkReserved2;
5365 	/** */
5366 	extern(C) void function() GtkReserved3;
5367 	/** */
5368 	extern(C) void function() GtkReserved4;
5369 }
5370 
5371 struct GtkCellRendererSpinnerPrivate;
5372 
5373 struct GtkCellRendererText
5374 {
5375 	GtkCellRenderer parent;
5376 	GtkCellRendererTextPrivate* priv;
5377 }
5378 
5379 struct GtkCellRendererTextClass
5380 {
5381 	GtkCellRendererClass parentClass;
5382 	/** */
5383 	extern(C) void function(GtkCellRendererText* cellRendererText, const(char)* path, const(char)* newText) edited;
5384 	/** */
5385 	extern(C) void function() GtkReserved1;
5386 	/** */
5387 	extern(C) void function() GtkReserved2;
5388 	/** */
5389 	extern(C) void function() GtkReserved3;
5390 	/** */
5391 	extern(C) void function() GtkReserved4;
5392 }
5393 
5394 struct GtkCellRendererTextPrivate;
5395 
5396 struct GtkCellRendererToggle
5397 {
5398 	GtkCellRenderer parent;
5399 	GtkCellRendererTogglePrivate* priv;
5400 }
5401 
5402 struct GtkCellRendererToggleClass
5403 {
5404 	GtkCellRendererClass parentClass;
5405 	/** */
5406 	extern(C) void function(GtkCellRendererToggle* cellRendererToggle, const(char)* path) toggled;
5407 	/** */
5408 	extern(C) void function() GtkReserved1;
5409 	/** */
5410 	extern(C) void function() GtkReserved2;
5411 	/** */
5412 	extern(C) void function() GtkReserved3;
5413 	/** */
5414 	extern(C) void function() GtkReserved4;
5415 }
5416 
5417 struct GtkCellRendererTogglePrivate;
5418 
5419 struct GtkCellView
5420 {
5421 	GtkWidget parentInstance;
5422 	GtkCellViewPrivate* priv;
5423 }
5424 
5425 struct GtkCellViewClass
5426 {
5427 	/**
5428 	 * The parent class.
5429 	 */
5430 	GtkWidgetClass parentClass;
5431 	/** */
5432 	extern(C) void function() GtkReserved1;
5433 	/** */
5434 	extern(C) void function() GtkReserved2;
5435 	/** */
5436 	extern(C) void function() GtkReserved3;
5437 	/** */
5438 	extern(C) void function() GtkReserved4;
5439 }
5440 
5441 struct GtkCellViewPrivate;
5442 
5443 struct GtkCheckButton
5444 {
5445 	GtkToggleButton toggleButton;
5446 }
5447 
5448 struct GtkCheckButtonClass
5449 {
5450 	GtkToggleButtonClass parentClass;
5451 	/** */
5452 	extern(C) void function(GtkCheckButton* checkButton, cairo_t* cr) drawIndicator;
5453 	/** */
5454 	extern(C) void function() GtkReserved1;
5455 	/** */
5456 	extern(C) void function() GtkReserved2;
5457 	/** */
5458 	extern(C) void function() GtkReserved3;
5459 	/** */
5460 	extern(C) void function() GtkReserved4;
5461 }
5462 
5463 struct GtkCheckMenuItem
5464 {
5465 	GtkMenuItem menuItem;
5466 	GtkCheckMenuItemPrivate* priv;
5467 }
5468 
5469 struct GtkCheckMenuItemAccessible
5470 {
5471 	GtkMenuItemAccessible parent;
5472 	GtkCheckMenuItemAccessiblePrivate* priv;
5473 }
5474 
5475 struct GtkCheckMenuItemAccessibleClass
5476 {
5477 	GtkMenuItemAccessibleClass parentClass;
5478 }
5479 
5480 struct GtkCheckMenuItemAccessiblePrivate;
5481 
5482 struct GtkCheckMenuItemClass
5483 {
5484 	/**
5485 	 * The parent class.
5486 	 */
5487 	GtkMenuItemClass parentClass;
5488 	/** */
5489 	extern(C) void function(GtkCheckMenuItem* checkMenuItem) toggled;
5490 	/** */
5491 	extern(C) void function(GtkCheckMenuItem* checkMenuItem, cairo_t* cr) drawIndicator;
5492 	/** */
5493 	extern(C) void function() GtkReserved1;
5494 	/** */
5495 	extern(C) void function() GtkReserved2;
5496 	/** */
5497 	extern(C) void function() GtkReserved3;
5498 	/** */
5499 	extern(C) void function() GtkReserved4;
5500 }
5501 
5502 struct GtkCheckMenuItemPrivate;
5503 
5504 struct GtkClipboard;
5505 
5506 struct GtkColorButton
5507 {
5508 	GtkButton button;
5509 	GtkColorButtonPrivate* priv;
5510 }
5511 
5512 struct GtkColorButtonClass
5513 {
5514 	GtkButtonClass parentClass;
5515 	/** */
5516 	extern(C) void function(GtkColorButton* cp) colorSet;
5517 	/** */
5518 	extern(C) void function() GtkReserved1;
5519 	/** */
5520 	extern(C) void function() GtkReserved2;
5521 	/** */
5522 	extern(C) void function() GtkReserved3;
5523 	/** */
5524 	extern(C) void function() GtkReserved4;
5525 }
5526 
5527 struct GtkColorButtonPrivate;
5528 
5529 struct GtkColorChooser;
5530 
5531 struct GtkColorChooserDialog
5532 {
5533 	GtkDialog parentInstance;
5534 	GtkColorChooserDialogPrivate* priv;
5535 }
5536 
5537 struct GtkColorChooserDialogClass
5538 {
5539 	GtkDialogClass parentClass;
5540 	/** */
5541 	extern(C) void function() GtkReserved1;
5542 	/** */
5543 	extern(C) void function() GtkReserved2;
5544 	/** */
5545 	extern(C) void function() GtkReserved3;
5546 	/** */
5547 	extern(C) void function() GtkReserved4;
5548 }
5549 
5550 struct GtkColorChooserDialogPrivate;
5551 
5552 struct GtkColorChooserInterface
5553 {
5554 	GTypeInterface baseInterface;
5555 	/** */
5556 	extern(C) void function(GtkColorChooser* chooser, GdkRGBA* color) getRgba;
5557 	/** */
5558 	extern(C) void function(GtkColorChooser* chooser, GdkRGBA* color) setRgba;
5559 	/** */
5560 	extern(C) void function(GtkColorChooser* chooser, GtkOrientation orientation, int colorsPerLine, int nColors, GdkRGBA* colors) addPalette;
5561 	/** */
5562 	extern(C) void function(GtkColorChooser* chooser, GdkRGBA* color) colorActivated;
5563 	void*[12] padding;
5564 }
5565 
5566 struct GtkColorChooserWidget
5567 {
5568 	GtkBox parentInstance;
5569 	GtkColorChooserWidgetPrivate* priv;
5570 }
5571 
5572 struct GtkColorChooserWidgetClass
5573 {
5574 	/**
5575 	 * The parent class.
5576 	 */
5577 	GtkBoxClass parentClass;
5578 	/** */
5579 	extern(C) void function() GtkReserved1;
5580 	/** */
5581 	extern(C) void function() GtkReserved2;
5582 	/** */
5583 	extern(C) void function() GtkReserved3;
5584 	/** */
5585 	extern(C) void function() GtkReserved4;
5586 	/** */
5587 	extern(C) void function() GtkReserved5;
5588 	/** */
5589 	extern(C) void function() GtkReserved6;
5590 	/** */
5591 	extern(C) void function() GtkReserved7;
5592 	/** */
5593 	extern(C) void function() GtkReserved8;
5594 }
5595 
5596 struct GtkColorChooserWidgetPrivate;
5597 
5598 struct GtkColorSelection
5599 {
5600 	GtkBox parentInstance;
5601 	GtkColorSelectionPrivate* privateData;
5602 }
5603 
5604 struct GtkColorSelectionClass
5605 {
5606 	/**
5607 	 * The parent class.
5608 	 */
5609 	GtkBoxClass parentClass;
5610 	/** */
5611 	extern(C) void function(GtkColorSelection* colorSelection) colorChanged;
5612 	/** */
5613 	extern(C) void function() GtkReserved1;
5614 	/** */
5615 	extern(C) void function() GtkReserved2;
5616 	/** */
5617 	extern(C) void function() GtkReserved3;
5618 	/** */
5619 	extern(C) void function() GtkReserved4;
5620 }
5621 
5622 struct GtkColorSelectionDialog
5623 {
5624 	GtkDialog parentInstance;
5625 	GtkColorSelectionDialogPrivate* priv;
5626 }
5627 
5628 struct GtkColorSelectionDialogClass
5629 {
5630 	GtkDialogClass parentClass;
5631 	/** */
5632 	extern(C) void function() GtkReserved1;
5633 	/** */
5634 	extern(C) void function() GtkReserved2;
5635 	/** */
5636 	extern(C) void function() GtkReserved3;
5637 	/** */
5638 	extern(C) void function() GtkReserved4;
5639 }
5640 
5641 struct GtkColorSelectionDialogPrivate;
5642 
5643 struct GtkColorSelectionPrivate;
5644 
5645 struct GtkComboBox
5646 {
5647 	GtkBin parentInstance;
5648 	GtkComboBoxPrivate* priv;
5649 }
5650 
5651 struct GtkComboBoxAccessible
5652 {
5653 	GtkContainerAccessible parent;
5654 	GtkComboBoxAccessiblePrivate* priv;
5655 }
5656 
5657 struct GtkComboBoxAccessibleClass
5658 {
5659 	GtkContainerAccessibleClass parentClass;
5660 }
5661 
5662 struct GtkComboBoxAccessiblePrivate;
5663 
5664 struct GtkComboBoxClass
5665 {
5666 	/**
5667 	 * The parent class.
5668 	 */
5669 	GtkBinClass parentClass;
5670 	/** */
5671 	extern(C) void function(GtkComboBox* comboBox) changed;
5672 	/** */
5673 	extern(C) char* function(GtkComboBox* comboBox, const(char)* path) formatEntryText;
5674 	/** */
5675 	extern(C) void function() GtkReserved1;
5676 	/** */
5677 	extern(C) void function() GtkReserved2;
5678 	/** */
5679 	extern(C) void function() GtkReserved3;
5680 }
5681 
5682 struct GtkComboBoxPrivate;
5683 
5684 struct GtkComboBoxText
5685 {
5686 	GtkComboBox parentInstance;
5687 	GtkComboBoxTextPrivate* priv;
5688 }
5689 
5690 struct GtkComboBoxTextClass
5691 {
5692 	GtkComboBoxClass parentClass;
5693 	/** */
5694 	extern(C) void function() GtkReserved1;
5695 	/** */
5696 	extern(C) void function() GtkReserved2;
5697 	/** */
5698 	extern(C) void function() GtkReserved3;
5699 	/** */
5700 	extern(C) void function() GtkReserved4;
5701 }
5702 
5703 struct GtkComboBoxTextPrivate;
5704 
5705 struct GtkContainer
5706 {
5707 	GtkWidget widget;
5708 	GtkContainerPrivate* priv;
5709 }
5710 
5711 struct GtkContainerAccessible
5712 {
5713 	GtkWidgetAccessible parent;
5714 	GtkContainerAccessiblePrivate* priv;
5715 }
5716 
5717 struct GtkContainerAccessibleClass
5718 {
5719 	GtkWidgetAccessibleClass parentClass;
5720 	/** */
5721 	extern(C) int function(GtkContainer* container, GtkWidget* widget, void* data) addGtk;
5722 	/** */
5723 	extern(C) int function(GtkContainer* container, GtkWidget* widget, void* data) removeGtk;
5724 }
5725 
5726 struct GtkContainerAccessiblePrivate;
5727 
5728 struct GtkContainerCellAccessible
5729 {
5730 	GtkCellAccessible parent;
5731 	GtkContainerCellAccessiblePrivate* priv;
5732 }
5733 
5734 struct GtkContainerCellAccessibleClass
5735 {
5736 	GtkCellAccessibleClass parentClass;
5737 }
5738 
5739 struct GtkContainerCellAccessiblePrivate;
5740 
5741 struct GtkContainerClass
5742 {
5743 	/**
5744 	 * The parent class.
5745 	 */
5746 	GtkWidgetClass parentClass;
5747 	/** */
5748 	extern(C) void function(GtkContainer* container, GtkWidget* widget) add;
5749 	/** */
5750 	extern(C) void function(GtkContainer* container, GtkWidget* widget) remove;
5751 	/** */
5752 	extern(C) void function(GtkContainer* container) checkResize;
5753 	/** */
5754 	extern(C) void function(GtkContainer* container, int includeInternals, GtkCallback callback, void* callbackData) forall;
5755 	/** */
5756 	extern(C) void function(GtkContainer* container, GtkWidget* child) setFocusChild;
5757 	/**
5758 	 *
5759 	 * Params:
5760 	 *     container = a #GtkContainer
5761 	 * Returns: a #GType.
5762 	 */
5763 	extern(C) GType function(GtkContainer* container) childType;
5764 	/** */
5765 	extern(C) char* function(GtkContainer* container, GtkWidget* child) compositeName;
5766 	/** */
5767 	extern(C) void function(GtkContainer* container, GtkWidget* child, uint propertyId, GValue* value, GParamSpec* pspec) setChildProperty;
5768 	/** */
5769 	extern(C) void function(GtkContainer* container, GtkWidget* child, uint propertyId, GValue* value, GParamSpec* pspec) getChildProperty;
5770 	/**
5771 	 *
5772 	 * Params:
5773 	 *     container = a #GtkContainer
5774 	 *     child = a child of @container
5775 	 * Returns: A newly created #GtkWidgetPath
5776 	 */
5777 	extern(C) GtkWidgetPath* function(GtkContainer* container, GtkWidget* child) getPathForChild;
5778 	import std.bitmanip: bitfields;
5779 	mixin(bitfields!(
5780 		uint, "HandleBorderWidth", 1,
5781 		uint, "", 31
5782 	));
5783 	/** */
5784 	extern(C) void function() GtkReserved1;
5785 	/** */
5786 	extern(C) void function() GtkReserved2;
5787 	/** */
5788 	extern(C) void function() GtkReserved3;
5789 	/** */
5790 	extern(C) void function() GtkReserved4;
5791 	/** */
5792 	extern(C) void function() GtkReserved5;
5793 	/** */
5794 	extern(C) void function() GtkReserved6;
5795 	/** */
5796 	extern(C) void function() GtkReserved7;
5797 	/** */
5798 	extern(C) void function() GtkReserved8;
5799 }
5800 
5801 struct GtkContainerPrivate;
5802 
5803 struct GtkCssProvider
5804 {
5805 	GObject parentInstance;
5806 	GtkCssProviderPrivate* priv;
5807 }
5808 
5809 struct GtkCssProviderClass
5810 {
5811 	GObjectClass parentClass;
5812 	/** */
5813 	extern(C) void function(GtkCssProvider* provider, GtkCssSection* section, GError* error) parsingError;
5814 	/** */
5815 	extern(C) void function() GtkReserved2;
5816 	/** */
5817 	extern(C) void function() GtkReserved3;
5818 	/** */
5819 	extern(C) void function() GtkReserved4;
5820 }
5821 
5822 struct GtkCssProviderPrivate;
5823 
5824 struct GtkCssSection;
5825 
5826 struct GtkDialog
5827 {
5828 	GtkWindow window;
5829 	GtkDialogPrivate* priv;
5830 }
5831 
5832 struct GtkDialogClass
5833 {
5834 	/**
5835 	 * The parent class.
5836 	 */
5837 	GtkWindowClass parentClass;
5838 	/** */
5839 	extern(C) void function(GtkDialog* dialog, int responseId) response;
5840 	/** */
5841 	extern(C) void function(GtkDialog* dialog) close;
5842 	/** */
5843 	extern(C) void function() GtkReserved1;
5844 	/** */
5845 	extern(C) void function() GtkReserved2;
5846 	/** */
5847 	extern(C) void function() GtkReserved3;
5848 	/** */
5849 	extern(C) void function() GtkReserved4;
5850 }
5851 
5852 struct GtkDialogPrivate;
5853 
5854 struct GtkDrawingArea
5855 {
5856 	GtkWidget widget;
5857 	void* dummy;
5858 }
5859 
5860 struct GtkDrawingAreaClass
5861 {
5862 	GtkWidgetClass parentClass;
5863 	/** */
5864 	extern(C) void function() GtkReserved1;
5865 	/** */
5866 	extern(C) void function() GtkReserved2;
5867 	/** */
5868 	extern(C) void function() GtkReserved3;
5869 	/** */
5870 	extern(C) void function() GtkReserved4;
5871 }
5872 
5873 struct GtkEditable;
5874 
5875 struct GtkEditableInterface
5876 {
5877 	GTypeInterface baseIface;
5878 	/** */
5879 	extern(C) void function(GtkEditable* editable, const(char)* newText, int newTextLength, int* position) insertText;
5880 	/** */
5881 	extern(C) void function(GtkEditable* editable, int startPos, int endPos) deleteText;
5882 	/** */
5883 	extern(C) void function(GtkEditable* editable) changed;
5884 	/** */
5885 	extern(C) void function(GtkEditable* editable, const(char)* newText, int newTextLength, int* position) doInsertText;
5886 	/** */
5887 	extern(C) void function(GtkEditable* editable, int startPos, int endPos) doDeleteText;
5888 	/**
5889 	 *
5890 	 * Params:
5891 	 *     editable = a #GtkEditable
5892 	 *     startPos = start of text
5893 	 *     endPos = end of text
5894 	 * Returns: a pointer to the contents of the widget as a
5895 	 *     string. This string is allocated by the #GtkEditable
5896 	 *     implementation and should be freed by the caller.
5897 	 */
5898 	extern(C) char* function(GtkEditable* editable, int startPos, int endPos) getChars;
5899 	/** */
5900 	extern(C) void function(GtkEditable* editable, int startPos, int endPos) setSelectionBounds;
5901 	/**
5902 	 *
5903 	 * Params:
5904 	 *     editable = a #GtkEditable
5905 	 *     startPos = location to store the starting position, or %NULL
5906 	 *     endPos = location to store the end position, or %NULL
5907 	 * Returns: %TRUE if an area is selected, %FALSE otherwise
5908 	 */
5909 	extern(C) int function(GtkEditable* editable, int* startPos, int* endPos) getSelectionBounds;
5910 	/** */
5911 	extern(C) void function(GtkEditable* editable, int position) setPosition;
5912 	/**
5913 	 *
5914 	 * Params:
5915 	 *     editable = a #GtkEditable
5916 	 * Returns: the cursor position
5917 	 */
5918 	extern(C) int function(GtkEditable* editable) getPosition;
5919 }
5920 
5921 struct GtkEntry
5922 {
5923 	GtkWidget parentInstance;
5924 	GtkEntryPrivate* priv;
5925 }
5926 
5927 struct GtkEntryAccessible
5928 {
5929 	GtkWidgetAccessible parent;
5930 	GtkEntryAccessiblePrivate* priv;
5931 }
5932 
5933 struct GtkEntryAccessibleClass
5934 {
5935 	GtkWidgetAccessibleClass parentClass;
5936 }
5937 
5938 struct GtkEntryAccessiblePrivate;
5939 
5940 struct GtkEntryBuffer
5941 {
5942 	GObject parentInstance;
5943 	GtkEntryBufferPrivate* priv;
5944 }
5945 
5946 struct GtkEntryBufferClass
5947 {
5948 	GObjectClass parentClass;
5949 	/** */
5950 	extern(C) void function(GtkEntryBuffer* buffer, uint position, const(char)* chars, uint nChars) insertedText;
5951 	/** */
5952 	extern(C) void function(GtkEntryBuffer* buffer, uint position, uint nChars) deletedText;
5953 	/** */
5954 	extern(C) const(char)* function(GtkEntryBuffer* buffer, size_t* nBytes) getText;
5955 	/**
5956 	 *
5957 	 * Params:
5958 	 *     buffer = a #GtkEntryBuffer
5959 	 * Returns: The number of characters in the buffer.
5960 	 */
5961 	extern(C) uint function(GtkEntryBuffer* buffer) getLength;
5962 	/**
5963 	 *
5964 	 * Params:
5965 	 *     buffer = a #GtkEntryBuffer
5966 	 *     position = the position at which to insert text.
5967 	 *     chars = the text to insert into the buffer.
5968 	 *     nChars = the length of the text in characters, or -1
5969 	 * Returns: The number of characters actually inserted.
5970 	 */
5971 	extern(C) uint function(GtkEntryBuffer* buffer, uint position, const(char)* chars, uint nChars) insertText;
5972 	/**
5973 	 *
5974 	 * Params:
5975 	 *     buffer = a #GtkEntryBuffer
5976 	 *     position = position at which to delete text
5977 	 *     nChars = number of characters to delete
5978 	 * Returns: The number of characters deleted.
5979 	 */
5980 	extern(C) uint function(GtkEntryBuffer* buffer, uint position, uint nChars) deleteText;
5981 	/** */
5982 	extern(C) void function() GtkReserved1;
5983 	/** */
5984 	extern(C) void function() GtkReserved2;
5985 	/** */
5986 	extern(C) void function() GtkReserved3;
5987 	/** */
5988 	extern(C) void function() GtkReserved4;
5989 	/** */
5990 	extern(C) void function() GtkReserved5;
5991 	/** */
5992 	extern(C) void function() GtkReserved6;
5993 	/** */
5994 	extern(C) void function() GtkReserved7;
5995 	/** */
5996 	extern(C) void function() GtkReserved8;
5997 }
5998 
5999 struct GtkEntryBufferPrivate;
6000 
6001 /**
6002  * Class structure for #GtkEntry. All virtual functions have a default
6003  * implementation. Derived classes may set the virtual function pointers for the
6004  * signal handlers to %NULL, but must keep @get_text_area_size and
6005  * @get_frame_size non-%NULL; either use the default implementation, or provide
6006  * a custom one.
6007  */
6008 struct GtkEntryClass
6009 {
6010 	/**
6011 	 * The parent class.
6012 	 */
6013 	GtkWidgetClass parentClass;
6014 	/** */
6015 	extern(C) void function(GtkEntry* entry, GtkWidget* popup) populatePopup;
6016 	/** */
6017 	extern(C) void function(GtkEntry* entry) activate;
6018 	/** */
6019 	extern(C) void function(GtkEntry* entry, GtkMovementStep step, int count, int extendSelection) moveCursor;
6020 	/** */
6021 	extern(C) void function(GtkEntry* entry, const(char)* str) insertAtCursor;
6022 	/** */
6023 	extern(C) void function(GtkEntry* entry, GtkDeleteType type, int count) deleteFromCursor;
6024 	/** */
6025 	extern(C) void function(GtkEntry* entry) backspace;
6026 	/** */
6027 	extern(C) void function(GtkEntry* entry) cutClipboard;
6028 	/** */
6029 	extern(C) void function(GtkEntry* entry) copyClipboard;
6030 	/** */
6031 	extern(C) void function(GtkEntry* entry) pasteClipboard;
6032 	/** */
6033 	extern(C) void function(GtkEntry* entry) toggleOverwrite;
6034 	/** */
6035 	extern(C) void function(GtkEntry* entry, int* x, int* y, int* width, int* height) getTextAreaSize;
6036 	/** */
6037 	extern(C) void function(GtkEntry* entry, int* x, int* y, int* width, int* height) getFrameSize;
6038 	/** */
6039 	extern(C) void function(GtkEntry* entry) insertEmoji;
6040 	/** */
6041 	extern(C) void function() GtkReserved1;
6042 	/** */
6043 	extern(C) void function() GtkReserved2;
6044 	/** */
6045 	extern(C) void function() GtkReserved3;
6046 	/** */
6047 	extern(C) void function() GtkReserved4;
6048 	/** */
6049 	extern(C) void function() GtkReserved5;
6050 	/** */
6051 	extern(C) void function() GtkReserved6;
6052 }
6053 
6054 struct GtkEntryCompletion
6055 {
6056 	GObject parentInstance;
6057 	GtkEntryCompletionPrivate* priv;
6058 }
6059 
6060 struct GtkEntryCompletionClass
6061 {
6062 	GObjectClass parentClass;
6063 	/** */
6064 	extern(C) int function(GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter) matchSelected;
6065 	/** */
6066 	extern(C) void function(GtkEntryCompletion* completion, int index) actionActivated;
6067 	/** */
6068 	extern(C) int function(GtkEntryCompletion* completion, const(char)* prefix) insertPrefix;
6069 	/** */
6070 	extern(C) int function(GtkEntryCompletion* completion, GtkTreeModel* model, GtkTreeIter* iter) cursorOnMatch;
6071 	/** */
6072 	extern(C) void function(GtkEntryCompletion* completion) noMatches;
6073 	/** */
6074 	extern(C) void function() GtkReserved0;
6075 	/** */
6076 	extern(C) void function() GtkReserved1;
6077 	/** */
6078 	extern(C) void function() GtkReserved2;
6079 }
6080 
6081 struct GtkEntryCompletionPrivate;
6082 
6083 struct GtkEntryIconAccessible;
6084 
6085 struct GtkEntryPrivate;
6086 
6087 struct GtkEventBox
6088 {
6089 	GtkBin bin;
6090 	GtkEventBoxPrivate* priv;
6091 }
6092 
6093 struct GtkEventBoxClass
6094 {
6095 	/**
6096 	 * The parent class.
6097 	 */
6098 	GtkBinClass parentClass;
6099 	/** */
6100 	extern(C) void function() GtkReserved1;
6101 	/** */
6102 	extern(C) void function() GtkReserved2;
6103 	/** */
6104 	extern(C) void function() GtkReserved3;
6105 	/** */
6106 	extern(C) void function() GtkReserved4;
6107 }
6108 
6109 struct GtkEventBoxPrivate;
6110 
6111 struct GtkEventController;
6112 
6113 struct GtkEventControllerClass;
6114 
6115 struct GtkExpander
6116 {
6117 	GtkBin bin;
6118 	GtkExpanderPrivate* priv;
6119 }
6120 
6121 struct GtkExpanderAccessible
6122 {
6123 	GtkContainerAccessible parent;
6124 	GtkExpanderAccessiblePrivate* priv;
6125 }
6126 
6127 struct GtkExpanderAccessibleClass
6128 {
6129 	GtkContainerAccessibleClass parentClass;
6130 }
6131 
6132 struct GtkExpanderAccessiblePrivate;
6133 
6134 struct GtkExpanderClass
6135 {
6136 	/**
6137 	 * The parent class.
6138 	 */
6139 	GtkBinClass parentClass;
6140 	/** */
6141 	extern(C) void function(GtkExpander* expander) activate;
6142 	/** */
6143 	extern(C) void function() GtkReserved1;
6144 	/** */
6145 	extern(C) void function() GtkReserved2;
6146 	/** */
6147 	extern(C) void function() GtkReserved3;
6148 	/** */
6149 	extern(C) void function() GtkReserved4;
6150 }
6151 
6152 struct GtkExpanderPrivate;
6153 
6154 struct GtkFileChooser;
6155 
6156 struct GtkFileChooserButton
6157 {
6158 	GtkBox parent;
6159 	GtkFileChooserButtonPrivate* priv;
6160 }
6161 
6162 struct GtkFileChooserButtonClass
6163 {
6164 	/**
6165 	 * The parent class.
6166 	 */
6167 	GtkBoxClass parentClass;
6168 	/** */
6169 	extern(C) void function(GtkFileChooserButton* fc) fileSet;
6170 	void* GtkReserved1;
6171 	void* GtkReserved2;
6172 	void* GtkReserved3;
6173 	void* GtkReserved4;
6174 }
6175 
6176 struct GtkFileChooserButtonPrivate;
6177 
6178 struct GtkFileChooserDialog
6179 {
6180 	GtkDialog parentInstance;
6181 	GtkFileChooserDialogPrivate* priv;
6182 }
6183 
6184 struct GtkFileChooserDialogClass
6185 {
6186 	GtkDialogClass parentClass;
6187 	/** */
6188 	extern(C) void function() GtkReserved1;
6189 	/** */
6190 	extern(C) void function() GtkReserved2;
6191 	/** */
6192 	extern(C) void function() GtkReserved3;
6193 	/** */
6194 	extern(C) void function() GtkReserved4;
6195 }
6196 
6197 struct GtkFileChooserDialogPrivate;
6198 
6199 struct GtkFileChooserNative;
6200 
6201 struct GtkFileChooserNativeClass
6202 {
6203 	GtkNativeDialogClass parentClass;
6204 }
6205 
6206 struct GtkFileChooserWidget
6207 {
6208 	GtkBox parentInstance;
6209 	GtkFileChooserWidgetPrivate* priv;
6210 }
6211 
6212 struct GtkFileChooserWidgetClass
6213 {
6214 	/**
6215 	 * The parent class.
6216 	 */
6217 	GtkBoxClass parentClass;
6218 	/** */
6219 	extern(C) void function() GtkReserved1;
6220 	/** */
6221 	extern(C) void function() GtkReserved2;
6222 	/** */
6223 	extern(C) void function() GtkReserved3;
6224 	/** */
6225 	extern(C) void function() GtkReserved4;
6226 }
6227 
6228 struct GtkFileChooserWidgetPrivate;
6229 
6230 struct GtkFileFilter;
6231 
6232 /**
6233  * A #GtkFileFilterInfo-struct is used to pass information about the
6234  * tested file to gtk_file_filter_filter().
6235  */
6236 struct GtkFileFilterInfo
6237 {
6238 	/**
6239 	 * Flags indicating which of the following fields need
6240 	 * are filled
6241 	 */
6242 	GtkFileFilterFlags contains;
6243 	/**
6244 	 * the filename of the file being tested
6245 	 */
6246 	const(char)* filename;
6247 	/**
6248 	 * the URI for the file being tested
6249 	 */
6250 	const(char)* uri;
6251 	/**
6252 	 * the string that will be used to display the file
6253 	 * in the file chooser
6254 	 */
6255 	const(char)* displayName;
6256 	/**
6257 	 * the mime type of the file
6258 	 */
6259 	const(char)* mimeType;
6260 }
6261 
6262 struct GtkFixed
6263 {
6264 	GtkContainer container;
6265 	GtkFixedPrivate* priv;
6266 }
6267 
6268 struct GtkFixedChild
6269 {
6270 	GtkWidget* widget;
6271 	int x;
6272 	int y;
6273 }
6274 
6275 struct GtkFixedClass
6276 {
6277 	GtkContainerClass parentClass;
6278 	/** */
6279 	extern(C) void function() GtkReserved1;
6280 	/** */
6281 	extern(C) void function() GtkReserved2;
6282 	/** */
6283 	extern(C) void function() GtkReserved3;
6284 	/** */
6285 	extern(C) void function() GtkReserved4;
6286 }
6287 
6288 struct GtkFixedPrivate;
6289 
6290 struct GtkFlowBox
6291 {
6292 	GtkContainer container;
6293 }
6294 
6295 struct GtkFlowBoxAccessible
6296 {
6297 	GtkContainerAccessible parent;
6298 	GtkFlowBoxAccessiblePrivate* priv;
6299 }
6300 
6301 struct GtkFlowBoxAccessibleClass
6302 {
6303 	GtkContainerAccessibleClass parentClass;
6304 }
6305 
6306 struct GtkFlowBoxAccessiblePrivate;
6307 
6308 struct GtkFlowBoxChild
6309 {
6310 	GtkBin parentInstance;
6311 }
6312 
6313 struct GtkFlowBoxChildAccessible
6314 {
6315 	GtkContainerAccessible parent;
6316 }
6317 
6318 struct GtkFlowBoxChildAccessibleClass
6319 {
6320 	GtkContainerAccessibleClass parentClass;
6321 }
6322 
6323 struct GtkFlowBoxChildClass
6324 {
6325 	GtkBinClass parentClass;
6326 	/** */
6327 	extern(C) void function(GtkFlowBoxChild* child) activate;
6328 	/** */
6329 	extern(C) void function() GtkReserved1;
6330 	/** */
6331 	extern(C) void function() GtkReserved2;
6332 }
6333 
6334 struct GtkFlowBoxClass
6335 {
6336 	GtkContainerClass parentClass;
6337 	/** */
6338 	extern(C) void function(GtkFlowBox* box, GtkFlowBoxChild* child) childActivated;
6339 	/** */
6340 	extern(C) void function(GtkFlowBox* box) selectedChildrenChanged;
6341 	/** */
6342 	extern(C) void function(GtkFlowBox* box) activateCursorChild;
6343 	/** */
6344 	extern(C) void function(GtkFlowBox* box) toggleCursorChild;
6345 	/** */
6346 	extern(C) int function(GtkFlowBox* box, GtkMovementStep step, int count) moveCursor;
6347 	/** */
6348 	extern(C) void function(GtkFlowBox* box) selectAll;
6349 	/** */
6350 	extern(C) void function(GtkFlowBox* box) unselectAll;
6351 	/** */
6352 	extern(C) void function() GtkReserved1;
6353 	/** */
6354 	extern(C) void function() GtkReserved2;
6355 	/** */
6356 	extern(C) void function() GtkReserved3;
6357 	/** */
6358 	extern(C) void function() GtkReserved4;
6359 	/** */
6360 	extern(C) void function() GtkReserved5;
6361 	/** */
6362 	extern(C) void function() GtkReserved6;
6363 }
6364 
6365 struct GtkFontButton
6366 {
6367 	GtkButton button;
6368 	GtkFontButtonPrivate* priv;
6369 }
6370 
6371 struct GtkFontButtonClass
6372 {
6373 	GtkButtonClass parentClass;
6374 	/** */
6375 	extern(C) void function(GtkFontButton* gfp) fontSet;
6376 	/** */
6377 	extern(C) void function() GtkReserved1;
6378 	/** */
6379 	extern(C) void function() GtkReserved2;
6380 	/** */
6381 	extern(C) void function() GtkReserved3;
6382 	/** */
6383 	extern(C) void function() GtkReserved4;
6384 }
6385 
6386 struct GtkFontButtonPrivate;
6387 
6388 struct GtkFontChooser;
6389 
6390 struct GtkFontChooserDialog
6391 {
6392 	GtkDialog parentInstance;
6393 	GtkFontChooserDialogPrivate* priv;
6394 }
6395 
6396 struct GtkFontChooserDialogClass
6397 {
6398 	/**
6399 	 * The parent class.
6400 	 */
6401 	GtkDialogClass parentClass;
6402 	/** */
6403 	extern(C) void function() GtkReserved1;
6404 	/** */
6405 	extern(C) void function() GtkReserved2;
6406 	/** */
6407 	extern(C) void function() GtkReserved3;
6408 	/** */
6409 	extern(C) void function() GtkReserved4;
6410 }
6411 
6412 struct GtkFontChooserDialogPrivate;
6413 
6414 struct GtkFontChooserIface
6415 {
6416 	GTypeInterface baseIface;
6417 	/**
6418 	 *
6419 	 * Params:
6420 	 *     fontchooser = a #GtkFontChooser
6421 	 * Returns: A #PangoFontFamily representing the
6422 	 *     selected font family, or %NULL. The returned object is owned by @fontchooser
6423 	 *     and must not be modified or freed.
6424 	 */
6425 	extern(C) PangoFontFamily* function(GtkFontChooser* fontchooser) getFontFamily;
6426 	/**
6427 	 *
6428 	 * Params:
6429 	 *     fontchooser = a #GtkFontChooser
6430 	 * Returns: A #PangoFontFace representing the
6431 	 *     selected font group details, or %NULL. The returned object is owned by
6432 	 *     @fontchooser and must not be modified or freed.
6433 	 */
6434 	extern(C) PangoFontFace* function(GtkFontChooser* fontchooser) getFontFace;
6435 	/**
6436 	 *
6437 	 * Params:
6438 	 *     fontchooser = a #GtkFontChooser
6439 	 * Returns: A n integer representing the selected font size,
6440 	 *     or -1 if no font size is selected.
6441 	 */
6442 	extern(C) int function(GtkFontChooser* fontchooser) getFontSize;
6443 	/** */
6444 	extern(C) void function(GtkFontChooser* fontchooser, GtkFontFilterFunc filter, void* userData, GDestroyNotify destroy) setFilterFunc;
6445 	/** */
6446 	extern(C) void function(GtkFontChooser* chooser, const(char)* fontname) fontActivated;
6447 	/** */
6448 	extern(C) void function(GtkFontChooser* fontchooser, PangoFontMap* fontmap) setFontMap;
6449 	/**
6450 	 *
6451 	 * Params:
6452 	 *     fontchooser = a #GtkFontChooser
6453 	 * Returns: a #PangoFontMap, or %NULL
6454 	 */
6455 	extern(C) PangoFontMap* function(GtkFontChooser* fontchooser) getFontMap;
6456 	void*[10] padding;
6457 }
6458 
6459 struct GtkFontChooserWidget
6460 {
6461 	GtkBox parentInstance;
6462 	GtkFontChooserWidgetPrivate* priv;
6463 }
6464 
6465 struct GtkFontChooserWidgetClass
6466 {
6467 	/**
6468 	 * The parent class.
6469 	 */
6470 	GtkBoxClass parentClass;
6471 	/** */
6472 	extern(C) void function() GtkReserved1;
6473 	/** */
6474 	extern(C) void function() GtkReserved2;
6475 	/** */
6476 	extern(C) void function() GtkReserved3;
6477 	/** */
6478 	extern(C) void function() GtkReserved4;
6479 	/** */
6480 	extern(C) void function() GtkReserved5;
6481 	/** */
6482 	extern(C) void function() GtkReserved6;
6483 	/** */
6484 	extern(C) void function() GtkReserved7;
6485 	/** */
6486 	extern(C) void function() GtkReserved8;
6487 }
6488 
6489 struct GtkFontChooserWidgetPrivate;
6490 
6491 struct GtkFontSelection
6492 {
6493 	GtkBox parentInstance;
6494 	GtkFontSelectionPrivate* priv;
6495 }
6496 
6497 struct GtkFontSelectionClass
6498 {
6499 	GtkBoxClass parentClass;
6500 	/** */
6501 	extern(C) void function() GtkReserved1;
6502 	/** */
6503 	extern(C) void function() GtkReserved2;
6504 	/** */
6505 	extern(C) void function() GtkReserved3;
6506 	/** */
6507 	extern(C) void function() GtkReserved4;
6508 }
6509 
6510 struct GtkFontSelectionDialog
6511 {
6512 	GtkDialog parentInstance;
6513 	GtkFontSelectionDialogPrivate* priv;
6514 }
6515 
6516 struct GtkFontSelectionDialogClass
6517 {
6518 	GtkDialogClass parentClass;
6519 	/** */
6520 	extern(C) void function() GtkReserved1;
6521 	/** */
6522 	extern(C) void function() GtkReserved2;
6523 	/** */
6524 	extern(C) void function() GtkReserved3;
6525 	/** */
6526 	extern(C) void function() GtkReserved4;
6527 }
6528 
6529 struct GtkFontSelectionDialogPrivate;
6530 
6531 struct GtkFontSelectionPrivate;
6532 
6533 struct GtkFrame
6534 {
6535 	GtkBin bin;
6536 	GtkFramePrivate* priv;
6537 }
6538 
6539 struct GtkFrameAccessible
6540 {
6541 	GtkContainerAccessible parent;
6542 	GtkFrameAccessiblePrivate* priv;
6543 }
6544 
6545 struct GtkFrameAccessibleClass
6546 {
6547 	GtkContainerAccessibleClass parentClass;
6548 }
6549 
6550 struct GtkFrameAccessiblePrivate;
6551 
6552 struct GtkFrameClass
6553 {
6554 	/**
6555 	 * The parent class.
6556 	 */
6557 	GtkBinClass parentClass;
6558 	/** */
6559 	extern(C) void function(GtkFrame* frame, GtkAllocation* allocation) computeChildAllocation;
6560 	/** */
6561 	extern(C) void function() GtkReserved1;
6562 	/** */
6563 	extern(C) void function() GtkReserved2;
6564 	/** */
6565 	extern(C) void function() GtkReserved3;
6566 	/** */
6567 	extern(C) void function() GtkReserved4;
6568 }
6569 
6570 struct GtkFramePrivate;
6571 
6572 struct GtkGLArea
6573 {
6574 	GtkWidget parentInstance;
6575 }
6576 
6577 /**
6578  * The `GtkGLAreaClass` structure contains only private data.
6579  *
6580  * Since: 3.16
6581  */
6582 struct GtkGLAreaClass
6583 {
6584 	GtkWidgetClass parentClass;
6585 	/** */
6586 	extern(C) int function(GtkGLArea* area, GdkGLContext* context) render;
6587 	/** */
6588 	extern(C) void function(GtkGLArea* area, int width, int height) resize;
6589 	/** */
6590 	extern(C) GdkGLContext* function(GtkGLArea* area) createContext;
6591 	void*[6] Padding;
6592 }
6593 
6594 struct GtkGesture;
6595 
6596 struct GtkGestureClass;
6597 
6598 struct GtkGestureDrag;
6599 
6600 struct GtkGestureDragClass;
6601 
6602 struct GtkGestureLongPress;
6603 
6604 struct GtkGestureLongPressClass;
6605 
6606 struct GtkGestureMultiPress;
6607 
6608 struct GtkGestureMultiPressClass;
6609 
6610 struct GtkGesturePan;
6611 
6612 struct GtkGesturePanClass;
6613 
6614 struct GtkGestureRotate;
6615 
6616 struct GtkGestureRotateClass;
6617 
6618 struct GtkGestureSingle;
6619 
6620 struct GtkGestureSingleClass;
6621 
6622 struct GtkGestureSwipe;
6623 
6624 struct GtkGestureSwipeClass;
6625 
6626 struct GtkGestureZoom;
6627 
6628 struct GtkGestureZoomClass;
6629 
6630 struct GtkGradient;
6631 
6632 struct GtkGrid
6633 {
6634 	GtkContainer container;
6635 	GtkGridPrivate* priv;
6636 }
6637 
6638 struct GtkGridClass
6639 {
6640 	/**
6641 	 * The parent class.
6642 	 */
6643 	GtkContainerClass parentClass;
6644 	/** */
6645 	extern(C) void function() GtkReserved1;
6646 	/** */
6647 	extern(C) void function() GtkReserved2;
6648 	/** */
6649 	extern(C) void function() GtkReserved3;
6650 	/** */
6651 	extern(C) void function() GtkReserved4;
6652 	/** */
6653 	extern(C) void function() GtkReserved5;
6654 	/** */
6655 	extern(C) void function() GtkReserved6;
6656 	/** */
6657 	extern(C) void function() GtkReserved7;
6658 	/** */
6659 	extern(C) void function() GtkReserved8;
6660 }
6661 
6662 struct GtkGridPrivate;
6663 
6664 struct GtkHBox
6665 {
6666 	GtkBox box;
6667 }
6668 
6669 struct GtkHBoxClass
6670 {
6671 	GtkBoxClass parentClass;
6672 }
6673 
6674 struct GtkHButtonBox
6675 {
6676 	GtkButtonBox buttonBox;
6677 }
6678 
6679 struct GtkHButtonBoxClass
6680 {
6681 	GtkButtonBoxClass parentClass;
6682 }
6683 
6684 struct GtkHPaned
6685 {
6686 	GtkPaned paned;
6687 }
6688 
6689 struct GtkHPanedClass
6690 {
6691 	GtkPanedClass parentClass;
6692 }
6693 
6694 struct GtkHSV
6695 {
6696 	GtkWidget parentInstance;
6697 	GtkHSVPrivate* priv;
6698 }
6699 
6700 struct GtkHSVClass
6701 {
6702 	GtkWidgetClass parentClass;
6703 	/** */
6704 	extern(C) void function(GtkHSV* hsv) changed;
6705 	/** */
6706 	extern(C) void function(GtkHSV* hsv, GtkDirectionType type) move;
6707 	/** */
6708 	extern(C) void function() GtkReserved1;
6709 	/** */
6710 	extern(C) void function() GtkReserved2;
6711 	/** */
6712 	extern(C) void function() GtkReserved3;
6713 	/** */
6714 	extern(C) void function() GtkReserved4;
6715 }
6716 
6717 struct GtkHSVPrivate;
6718 
6719 struct GtkHScale
6720 {
6721 	GtkScale scale;
6722 }
6723 
6724 struct GtkHScaleClass
6725 {
6726 	GtkScaleClass parentClass;
6727 }
6728 
6729 struct GtkHScrollbar
6730 {
6731 	GtkScrollbar scrollbar;
6732 }
6733 
6734 struct GtkHScrollbarClass
6735 {
6736 	GtkScrollbarClass parentClass;
6737 }
6738 
6739 struct GtkHSeparator
6740 {
6741 	GtkSeparator separator;
6742 }
6743 
6744 struct GtkHSeparatorClass
6745 {
6746 	GtkSeparatorClass parentClass;
6747 }
6748 
6749 struct GtkHandleBox
6750 {
6751 	GtkBin bin;
6752 	GtkHandleBoxPrivate* priv;
6753 }
6754 
6755 struct GtkHandleBoxClass
6756 {
6757 	/**
6758 	 * The parent class.
6759 	 */
6760 	GtkBinClass parentClass;
6761 	/** */
6762 	extern(C) void function(GtkHandleBox* handleBox, GtkWidget* child) childAttached;
6763 	/** */
6764 	extern(C) void function(GtkHandleBox* handleBox, GtkWidget* child) childDetached;
6765 	/** */
6766 	extern(C) void function() GtkReserved1;
6767 	/** */
6768 	extern(C) void function() GtkReserved2;
6769 	/** */
6770 	extern(C) void function() GtkReserved3;
6771 	/** */
6772 	extern(C) void function() GtkReserved4;
6773 }
6774 
6775 struct GtkHandleBoxPrivate;
6776 
6777 struct GtkHeaderBar
6778 {
6779 	GtkContainer container;
6780 }
6781 
6782 struct GtkHeaderBarClass
6783 {
6784 	GtkContainerClass parentClass;
6785 	/** */
6786 	extern(C) void function() GtkReserved1;
6787 	/** */
6788 	extern(C) void function() GtkReserved2;
6789 	/** */
6790 	extern(C) void function() GtkReserved3;
6791 	/** */
6792 	extern(C) void function() GtkReserved4;
6793 }
6794 
6795 struct GtkHeaderBarPrivate;
6796 
6797 struct GtkIMContext
6798 {
6799 	GObject parentInstance;
6800 }
6801 
6802 struct GtkIMContextClass
6803 {
6804 	GObjectClass parentClass;
6805 	/** */
6806 	extern(C) void function(GtkIMContext* context) preeditStart;
6807 	/** */
6808 	extern(C) void function(GtkIMContext* context) preeditEnd;
6809 	/** */
6810 	extern(C) void function(GtkIMContext* context) preeditChanged;
6811 	/** */
6812 	extern(C) void function(GtkIMContext* context, const(char)* str) commit;
6813 	/** */
6814 	extern(C) int function(GtkIMContext* context) retrieveSurrounding;
6815 	/**
6816 	 *
6817 	 * Params:
6818 	 *     context = a #GtkIMContext
6819 	 *     offset = offset from cursor position in chars;
6820 	 *         a negative value means start before the cursor.
6821 	 *     nChars = number of characters to delete.
6822 	 * Returns: %TRUE if the signal was handled.
6823 	 */
6824 	extern(C) int function(GtkIMContext* context, int offset, int nChars) deleteSurrounding;
6825 	/** */
6826 	extern(C) void function(GtkIMContext* context, GdkWindow* window) setClientWindow;
6827 	/** */
6828 	extern(C) void function(GtkIMContext* context, char** str, PangoAttrList** attrs, int* cursorPos) getPreeditString;
6829 	/**
6830 	 *
6831 	 * Params:
6832 	 *     context = a #GtkIMContext
6833 	 *     event = the key event
6834 	 * Returns: %TRUE if the input method handled the key event.
6835 	 */
6836 	extern(C) int function(GtkIMContext* context, GdkEventKey* event) filterKeypress;
6837 	/** */
6838 	extern(C) void function(GtkIMContext* context) focusIn;
6839 	/** */
6840 	extern(C) void function(GtkIMContext* context) focusOut;
6841 	/** */
6842 	extern(C) void function(GtkIMContext* context) reset;
6843 	/** */
6844 	extern(C) void function(GtkIMContext* context, GdkRectangle* area) setCursorLocation;
6845 	/** */
6846 	extern(C) void function(GtkIMContext* context, int usePreedit) setUsePreedit;
6847 	/** */
6848 	extern(C) void function(GtkIMContext* context, const(char)* text, int len, int cursorIndex) setSurrounding;
6849 	/**
6850 	 *
6851 	 * Params:
6852 	 *     context = a #GtkIMContext
6853 	 *     text = location to store a UTF-8 encoded
6854 	 *         string of text holding context around the insertion point.
6855 	 *         If the function returns %TRUE, then you must free the result
6856 	 *         stored in this location with g_free().
6857 	 *     cursorIndex = location to store byte index of the insertion
6858 	 *         cursor within @text.
6859 	 * Returns: %TRUE if surrounding text was provided; in this case
6860 	 *     you must free the result stored in *text.
6861 	 */
6862 	extern(C) int function(GtkIMContext* context, char** text, int* cursorIndex) getSurrounding;
6863 	/** */
6864 	extern(C) void function() GtkReserved1;
6865 	/** */
6866 	extern(C) void function() GtkReserved2;
6867 	/** */
6868 	extern(C) void function() GtkReserved3;
6869 	/** */
6870 	extern(C) void function() GtkReserved4;
6871 	/** */
6872 	extern(C) void function() GtkReserved5;
6873 	/** */
6874 	extern(C) void function() GtkReserved6;
6875 }
6876 
6877 /**
6878  * Bookkeeping information about a loadable input method.
6879  */
6880 struct GtkIMContextInfo
6881 {
6882 	/**
6883 	 * The unique identification string of the input method.
6884 	 */
6885 	const(char)* contextId;
6886 	/**
6887 	 * The human-readable name of the input method.
6888 	 */
6889 	const(char)* contextName;
6890 	/**
6891 	 * Translation domain to be used with dgettext()
6892 	 */
6893 	const(char)* domain;
6894 	/**
6895 	 * Name of locale directory for use with bindtextdomain()
6896 	 */
6897 	const(char)* domainDirname;
6898 	/**
6899 	 * A colon-separated list of locales where this input method
6900 	 * should be the default. The asterisk “*” sets the default for all locales.
6901 	 */
6902 	const(char)* defaultLocales;
6903 }
6904 
6905 struct GtkIMContextSimple
6906 {
6907 	GtkIMContext object;
6908 	GtkIMContextSimplePrivate* priv;
6909 }
6910 
6911 struct GtkIMContextSimpleClass
6912 {
6913 	GtkIMContextClass parentClass;
6914 }
6915 
6916 struct GtkIMContextSimplePrivate;
6917 
6918 struct GtkIMMulticontext
6919 {
6920 	GtkIMContext object;
6921 	GtkIMMulticontextPrivate* priv;
6922 }
6923 
6924 struct GtkIMMulticontextClass
6925 {
6926 	GtkIMContextClass parentClass;
6927 	/** */
6928 	extern(C) void function() GtkReserved1;
6929 	/** */
6930 	extern(C) void function() GtkReserved2;
6931 	/** */
6932 	extern(C) void function() GtkReserved3;
6933 	/** */
6934 	extern(C) void function() GtkReserved4;
6935 }
6936 
6937 struct GtkIMMulticontextPrivate;
6938 
6939 struct GtkIconFactory
6940 {
6941 	GObject parentInstance;
6942 	GtkIconFactoryPrivate* priv;
6943 }
6944 
6945 struct GtkIconFactoryClass
6946 {
6947 	/**
6948 	 * The parent class.
6949 	 */
6950 	GObjectClass parentClass;
6951 	/** */
6952 	extern(C) void function() GtkReserved1;
6953 	/** */
6954 	extern(C) void function() GtkReserved2;
6955 	/** */
6956 	extern(C) void function() GtkReserved3;
6957 	/** */
6958 	extern(C) void function() GtkReserved4;
6959 }
6960 
6961 struct GtkIconFactoryPrivate;
6962 
6963 struct GtkIconInfo;
6964 
6965 struct GtkIconInfoClass;
6966 
6967 struct GtkIconSet;
6968 
6969 struct GtkIconSource;
6970 
6971 struct GtkIconTheme
6972 {
6973 	GObject parentInstance;
6974 	GtkIconThemePrivate* priv;
6975 }
6976 
6977 struct GtkIconThemeClass
6978 {
6979 	/**
6980 	 * The parent class.
6981 	 */
6982 	GObjectClass parentClass;
6983 	/** */
6984 	extern(C) void function(GtkIconTheme* iconTheme) changed;
6985 	/** */
6986 	extern(C) void function() GtkReserved1;
6987 	/** */
6988 	extern(C) void function() GtkReserved2;
6989 	/** */
6990 	extern(C) void function() GtkReserved3;
6991 	/** */
6992 	extern(C) void function() GtkReserved4;
6993 }
6994 
6995 struct GtkIconThemePrivate;
6996 
6997 struct GtkIconView
6998 {
6999 	GtkContainer parent;
7000 	GtkIconViewPrivate* priv;
7001 }
7002 
7003 struct GtkIconViewAccessible
7004 {
7005 	GtkContainerAccessible parent;
7006 	GtkIconViewAccessiblePrivate* priv;
7007 }
7008 
7009 struct GtkIconViewAccessibleClass
7010 {
7011 	GtkContainerAccessibleClass parentClass;
7012 }
7013 
7014 struct GtkIconViewAccessiblePrivate;
7015 
7016 struct GtkIconViewClass
7017 {
7018 	GtkContainerClass parentClass;
7019 	/** */
7020 	extern(C) void function(GtkIconView* iconView, GtkTreePath* path) itemActivated;
7021 	/** */
7022 	extern(C) void function(GtkIconView* iconView) selectionChanged;
7023 	/** */
7024 	extern(C) void function(GtkIconView* iconView) selectAll;
7025 	/** */
7026 	extern(C) void function(GtkIconView* iconView) unselectAll;
7027 	/** */
7028 	extern(C) void function(GtkIconView* iconView) selectCursorItem;
7029 	/** */
7030 	extern(C) void function(GtkIconView* iconView) toggleCursorItem;
7031 	/** */
7032 	extern(C) int function(GtkIconView* iconView, GtkMovementStep step, int count) moveCursor;
7033 	/** */
7034 	extern(C) int function(GtkIconView* iconView) activateCursorItem;
7035 	/** */
7036 	extern(C) void function() GtkReserved1;
7037 	/** */
7038 	extern(C) void function() GtkReserved2;
7039 	/** */
7040 	extern(C) void function() GtkReserved3;
7041 	/** */
7042 	extern(C) void function() GtkReserved4;
7043 }
7044 
7045 struct GtkIconViewPrivate;
7046 
7047 struct GtkImage
7048 {
7049 	GtkMisc misc;
7050 	GtkImagePrivate* priv;
7051 }
7052 
7053 struct GtkImageAccessible
7054 {
7055 	GtkWidgetAccessible parent;
7056 	GtkImageAccessiblePrivate* priv;
7057 }
7058 
7059 struct GtkImageAccessibleClass
7060 {
7061 	GtkWidgetAccessibleClass parentClass;
7062 }
7063 
7064 struct GtkImageAccessiblePrivate;
7065 
7066 struct GtkImageCellAccessible
7067 {
7068 	GtkRendererCellAccessible parent;
7069 	GtkImageCellAccessiblePrivate* priv;
7070 }
7071 
7072 struct GtkImageCellAccessibleClass
7073 {
7074 	GtkRendererCellAccessibleClass parentClass;
7075 }
7076 
7077 struct GtkImageCellAccessiblePrivate;
7078 
7079 struct GtkImageClass
7080 {
7081 	GtkMiscClass parentClass;
7082 	/** */
7083 	extern(C) void function() GtkReserved1;
7084 	/** */
7085 	extern(C) void function() GtkReserved2;
7086 	/** */
7087 	extern(C) void function() GtkReserved3;
7088 	/** */
7089 	extern(C) void function() GtkReserved4;
7090 }
7091 
7092 struct GtkImageMenuItem
7093 {
7094 	GtkMenuItem menuItem;
7095 	GtkImageMenuItemPrivate* priv;
7096 }
7097 
7098 struct GtkImageMenuItemClass
7099 {
7100 	/**
7101 	 * The parent class.
7102 	 */
7103 	GtkMenuItemClass parentClass;
7104 	/** */
7105 	extern(C) void function() GtkReserved1;
7106 	/** */
7107 	extern(C) void function() GtkReserved2;
7108 	/** */
7109 	extern(C) void function() GtkReserved3;
7110 	/** */
7111 	extern(C) void function() GtkReserved4;
7112 }
7113 
7114 struct GtkImageMenuItemPrivate;
7115 
7116 struct GtkImagePrivate;
7117 
7118 struct GtkInfoBar
7119 {
7120 	GtkBox parent;
7121 	GtkInfoBarPrivate* priv;
7122 }
7123 
7124 struct GtkInfoBarClass
7125 {
7126 	GtkBoxClass parentClass;
7127 	/** */
7128 	extern(C) void function(GtkInfoBar* infoBar, int responseId) response;
7129 	/** */
7130 	extern(C) void function(GtkInfoBar* infoBar) close;
7131 	/** */
7132 	extern(C) void function() GtkReserved1;
7133 	/** */
7134 	extern(C) void function() GtkReserved2;
7135 	/** */
7136 	extern(C) void function() GtkReserved3;
7137 	/** */
7138 	extern(C) void function() GtkReserved4;
7139 }
7140 
7141 struct GtkInfoBarPrivate;
7142 
7143 struct GtkInvisible
7144 {
7145 	GtkWidget widget;
7146 	GtkInvisiblePrivate* priv;
7147 }
7148 
7149 struct GtkInvisibleClass
7150 {
7151 	GtkWidgetClass parentClass;
7152 	/** */
7153 	extern(C) void function() GtkReserved1;
7154 	/** */
7155 	extern(C) void function() GtkReserved2;
7156 	/** */
7157 	extern(C) void function() GtkReserved3;
7158 	/** */
7159 	extern(C) void function() GtkReserved4;
7160 }
7161 
7162 struct GtkInvisiblePrivate;
7163 
7164 struct GtkLabel
7165 {
7166 	GtkMisc misc;
7167 	GtkLabelPrivate* priv;
7168 }
7169 
7170 struct GtkLabelAccessible
7171 {
7172 	GtkWidgetAccessible parent;
7173 	GtkLabelAccessiblePrivate* priv;
7174 }
7175 
7176 struct GtkLabelAccessibleClass
7177 {
7178 	GtkWidgetAccessibleClass parentClass;
7179 }
7180 
7181 struct GtkLabelAccessiblePrivate;
7182 
7183 struct GtkLabelClass
7184 {
7185 	GtkMiscClass parentClass;
7186 	/** */
7187 	extern(C) void function(GtkLabel* label, GtkMovementStep step, int count, int extendSelection) moveCursor;
7188 	/** */
7189 	extern(C) void function(GtkLabel* label) copyClipboard;
7190 	/** */
7191 	extern(C) void function(GtkLabel* label, GtkMenu* menu) populatePopup;
7192 	/** */
7193 	extern(C) int function(GtkLabel* label, const(char)* uri) activateLink;
7194 	/** */
7195 	extern(C) void function() GtkReserved1;
7196 	/** */
7197 	extern(C) void function() GtkReserved2;
7198 	/** */
7199 	extern(C) void function() GtkReserved3;
7200 	/** */
7201 	extern(C) void function() GtkReserved4;
7202 	/** */
7203 	extern(C) void function() GtkReserved5;
7204 	/** */
7205 	extern(C) void function() GtkReserved6;
7206 	/** */
7207 	extern(C) void function() GtkReserved7;
7208 	/** */
7209 	extern(C) void function() GtkReserved8;
7210 }
7211 
7212 struct GtkLabelPrivate;
7213 
7214 struct GtkLabelSelectionInfo;
7215 
7216 struct GtkLayout
7217 {
7218 	GtkContainer container;
7219 	GtkLayoutPrivate* priv;
7220 }
7221 
7222 struct GtkLayoutClass
7223 {
7224 	GtkContainerClass parentClass;
7225 	/** */
7226 	extern(C) void function() GtkReserved1;
7227 	/** */
7228 	extern(C) void function() GtkReserved2;
7229 	/** */
7230 	extern(C) void function() GtkReserved3;
7231 	/** */
7232 	extern(C) void function() GtkReserved4;
7233 }
7234 
7235 struct GtkLayoutPrivate;
7236 
7237 struct GtkLevelBar
7238 {
7239 	GtkWidget parent;
7240 	GtkLevelBarPrivate* priv;
7241 }
7242 
7243 struct GtkLevelBarAccessible
7244 {
7245 	GtkWidgetAccessible parent;
7246 	GtkLevelBarAccessiblePrivate* priv;
7247 }
7248 
7249 struct GtkLevelBarAccessibleClass
7250 {
7251 	GtkWidgetAccessibleClass parentClass;
7252 }
7253 
7254 struct GtkLevelBarAccessiblePrivate;
7255 
7256 struct GtkLevelBarClass
7257 {
7258 	GtkWidgetClass parentClass;
7259 	/** */
7260 	extern(C) void function(GtkLevelBar* self, const(char)* name) offsetChanged;
7261 	void*[16] padding;
7262 }
7263 
7264 struct GtkLevelBarPrivate;
7265 
7266 struct GtkLinkButton
7267 {
7268 	GtkButton parentInstance;
7269 	GtkLinkButtonPrivate* priv;
7270 }
7271 
7272 struct GtkLinkButtonAccessible
7273 {
7274 	GtkButtonAccessible parent;
7275 	GtkLinkButtonAccessiblePrivate* priv;
7276 }
7277 
7278 struct GtkLinkButtonAccessibleClass
7279 {
7280 	GtkButtonAccessibleClass parentClass;
7281 }
7282 
7283 struct GtkLinkButtonAccessiblePrivate;
7284 
7285 /**
7286  * The #GtkLinkButtonClass contains only
7287  * private data.
7288  */
7289 struct GtkLinkButtonClass
7290 {
7291 	GtkButtonClass parentClass;
7292 	/** */
7293 	extern(C) int function(GtkLinkButton* button) activateLink;
7294 	/** */
7295 	extern(C) void function() GtkPadding1;
7296 	/** */
7297 	extern(C) void function() GtkPadding2;
7298 	/** */
7299 	extern(C) void function() GtkPadding3;
7300 	/** */
7301 	extern(C) void function() GtkPadding4;
7302 }
7303 
7304 struct GtkLinkButtonPrivate;
7305 
7306 struct GtkListBox
7307 {
7308 	GtkContainer parentInstance;
7309 }
7310 
7311 struct GtkListBoxAccessible
7312 {
7313 	GtkContainerAccessible parent;
7314 	GtkListBoxAccessiblePrivate* priv;
7315 }
7316 
7317 struct GtkListBoxAccessibleClass
7318 {
7319 	GtkContainerAccessibleClass parentClass;
7320 }
7321 
7322 struct GtkListBoxAccessiblePrivate;
7323 
7324 struct GtkListBoxClass
7325 {
7326 	/**
7327 	 * The parent class.
7328 	 */
7329 	GtkContainerClass parentClass;
7330 	/** */
7331 	extern(C) void function(GtkListBox* box, GtkListBoxRow* row) rowSelected;
7332 	/** */
7333 	extern(C) void function(GtkListBox* box, GtkListBoxRow* row) rowActivated;
7334 	/** */
7335 	extern(C) void function(GtkListBox* box) activateCursorRow;
7336 	/** */
7337 	extern(C) void function(GtkListBox* box) toggleCursorRow;
7338 	/** */
7339 	extern(C) void function(GtkListBox* box, GtkMovementStep step, int count) moveCursor;
7340 	/** */
7341 	extern(C) void function(GtkListBox* box) selectedRowsChanged;
7342 	/** */
7343 	extern(C) void function(GtkListBox* box) selectAll;
7344 	/** */
7345 	extern(C) void function(GtkListBox* box) unselectAll;
7346 	/** */
7347 	extern(C) void function() GtkReserved1;
7348 	/** */
7349 	extern(C) void function() GtkReserved2;
7350 	/** */
7351 	extern(C) void function() GtkReserved3;
7352 }
7353 
7354 struct GtkListBoxRow
7355 {
7356 	GtkBin parentInstance;
7357 }
7358 
7359 struct GtkListBoxRowAccessible
7360 {
7361 	GtkContainerAccessible parent;
7362 }
7363 
7364 struct GtkListBoxRowAccessibleClass
7365 {
7366 	GtkContainerAccessibleClass parentClass;
7367 }
7368 
7369 struct GtkListBoxRowClass
7370 {
7371 	/**
7372 	 * The parent class.
7373 	 */
7374 	GtkBinClass parentClass;
7375 	/** */
7376 	extern(C) void function(GtkListBoxRow* row) activate;
7377 	/** */
7378 	extern(C) void function() GtkReserved1;
7379 	/** */
7380 	extern(C) void function() GtkReserved2;
7381 }
7382 
7383 struct GtkListStore
7384 {
7385 	GObject parent;
7386 	GtkListStorePrivate* priv;
7387 }
7388 
7389 struct GtkListStoreClass
7390 {
7391 	GObjectClass parentClass;
7392 	/** */
7393 	extern(C) void function() GtkReserved1;
7394 	/** */
7395 	extern(C) void function() GtkReserved2;
7396 	/** */
7397 	extern(C) void function() GtkReserved3;
7398 	/** */
7399 	extern(C) void function() GtkReserved4;
7400 }
7401 
7402 struct GtkListStorePrivate;
7403 
7404 struct GtkLockButton
7405 {
7406 	GtkButton parent;
7407 	GtkLockButtonPrivate* priv;
7408 }
7409 
7410 struct GtkLockButtonAccessible
7411 {
7412 	GtkButtonAccessible parent;
7413 	GtkLockButtonAccessiblePrivate* priv;
7414 }
7415 
7416 struct GtkLockButtonAccessibleClass
7417 {
7418 	GtkButtonAccessibleClass parentClass;
7419 }
7420 
7421 struct GtkLockButtonAccessiblePrivate;
7422 
7423 struct GtkLockButtonClass
7424 {
7425 	/**
7426 	 * The parent class.
7427 	 */
7428 	GtkButtonClass parentClass;
7429 	/** */
7430 	extern(C) void function() reserved0;
7431 	/** */
7432 	extern(C) void function() reserved1;
7433 	/** */
7434 	extern(C) void function() reserved2;
7435 	/** */
7436 	extern(C) void function() reserved3;
7437 	/** */
7438 	extern(C) void function() reserved4;
7439 	/** */
7440 	extern(C) void function() reserved5;
7441 	/** */
7442 	extern(C) void function() reserved6;
7443 	/** */
7444 	extern(C) void function() reserved7;
7445 }
7446 
7447 struct GtkLockButtonPrivate;
7448 
7449 struct GtkMenu
7450 {
7451 	GtkMenuShell menuShell;
7452 	GtkMenuPrivate* priv;
7453 }
7454 
7455 struct GtkMenuAccessible
7456 {
7457 	GtkMenuShellAccessible parent;
7458 	GtkMenuAccessiblePrivate* priv;
7459 }
7460 
7461 struct GtkMenuAccessibleClass
7462 {
7463 	GtkMenuShellAccessibleClass parentClass;
7464 }
7465 
7466 struct GtkMenuAccessiblePrivate;
7467 
7468 struct GtkMenuBar
7469 {
7470 	GtkMenuShell menuShell;
7471 	GtkMenuBarPrivate* priv;
7472 }
7473 
7474 struct GtkMenuBarClass
7475 {
7476 	GtkMenuShellClass parentClass;
7477 	/** */
7478 	extern(C) void function() GtkReserved1;
7479 	/** */
7480 	extern(C) void function() GtkReserved2;
7481 	/** */
7482 	extern(C) void function() GtkReserved3;
7483 	/** */
7484 	extern(C) void function() GtkReserved4;
7485 }
7486 
7487 struct GtkMenuBarPrivate;
7488 
7489 struct GtkMenuButton
7490 {
7491 	GtkToggleButton parent;
7492 	GtkMenuButtonPrivate* priv;
7493 }
7494 
7495 struct GtkMenuButtonAccessible
7496 {
7497 	GtkToggleButtonAccessible parent;
7498 	GtkMenuButtonAccessiblePrivate* priv;
7499 }
7500 
7501 struct GtkMenuButtonAccessibleClass
7502 {
7503 	GtkToggleButtonAccessibleClass parentClass;
7504 }
7505 
7506 struct GtkMenuButtonAccessiblePrivate;
7507 
7508 struct GtkMenuButtonClass
7509 {
7510 	GtkToggleButtonClass parentClass;
7511 	/** */
7512 	extern(C) void function() GtkReserved1;
7513 	/** */
7514 	extern(C) void function() GtkReserved2;
7515 	/** */
7516 	extern(C) void function() GtkReserved3;
7517 	/** */
7518 	extern(C) void function() GtkReserved4;
7519 }
7520 
7521 struct GtkMenuButtonPrivate;
7522 
7523 struct GtkMenuClass
7524 {
7525 	GtkMenuShellClass parentClass;
7526 	/** */
7527 	extern(C) void function() GtkReserved1;
7528 	/** */
7529 	extern(C) void function() GtkReserved2;
7530 	/** */
7531 	extern(C) void function() GtkReserved3;
7532 	/** */
7533 	extern(C) void function() GtkReserved4;
7534 }
7535 
7536 struct GtkMenuItem
7537 {
7538 	GtkBin bin;
7539 	GtkMenuItemPrivate* priv;
7540 }
7541 
7542 struct GtkMenuItemAccessible
7543 {
7544 	GtkContainerAccessible parent;
7545 	GtkMenuItemAccessiblePrivate* priv;
7546 }
7547 
7548 struct GtkMenuItemAccessibleClass
7549 {
7550 	GtkContainerAccessibleClass parentClass;
7551 }
7552 
7553 struct GtkMenuItemAccessiblePrivate;
7554 
7555 struct GtkMenuItemClass
7556 {
7557 	/**
7558 	 * The parent class.
7559 	 */
7560 	GtkBinClass parentClass;
7561 	import std.bitmanip: bitfields;
7562 	mixin(bitfields!(
7563 		uint, "hideOnActivate", 1,
7564 		uint, "", 31
7565 	));
7566 	/** */
7567 	extern(C) void function(GtkMenuItem* menuItem) activate;
7568 	/** */
7569 	extern(C) void function(GtkMenuItem* menuItem) activateItem;
7570 	/** */
7571 	extern(C) void function(GtkMenuItem* menuItem, int* requisition) toggleSizeRequest;
7572 	/** */
7573 	extern(C) void function(GtkMenuItem* menuItem, int allocation) toggleSizeAllocate;
7574 	/** */
7575 	extern(C) void function(GtkMenuItem* menuItem, const(char)* label) setLabel;
7576 	/**
7577 	 *
7578 	 * Params:
7579 	 *     menuItem = a #GtkMenuItem
7580 	 * Returns: The text in the @menu_item label. This is the internal
7581 	 *     string used by the label, and must not be modified.
7582 	 */
7583 	extern(C) const(char)* function(GtkMenuItem* menuItem) getLabel;
7584 	/** */
7585 	extern(C) void function(GtkMenuItem* menuItem) select;
7586 	/** */
7587 	extern(C) void function(GtkMenuItem* menuItem) deselect;
7588 	/** */
7589 	extern(C) void function() GtkReserved1;
7590 	/** */
7591 	extern(C) void function() GtkReserved2;
7592 	/** */
7593 	extern(C) void function() GtkReserved3;
7594 	/** */
7595 	extern(C) void function() GtkReserved4;
7596 }
7597 
7598 struct GtkMenuItemPrivate;
7599 
7600 struct GtkMenuPrivate;
7601 
7602 struct GtkMenuShell
7603 {
7604 	GtkContainer container;
7605 	GtkMenuShellPrivate* priv;
7606 }
7607 
7608 struct GtkMenuShellAccessible
7609 {
7610 	GtkContainerAccessible parent;
7611 	GtkMenuShellAccessiblePrivate* priv;
7612 }
7613 
7614 struct GtkMenuShellAccessibleClass
7615 {
7616 	GtkContainerAccessibleClass parentClass;
7617 }
7618 
7619 struct GtkMenuShellAccessiblePrivate;
7620 
7621 struct GtkMenuShellClass
7622 {
7623 	GtkContainerClass parentClass;
7624 	import std.bitmanip: bitfields;
7625 	mixin(bitfields!(
7626 		uint, "submenuPlacement", 1,
7627 		uint, "", 31
7628 	));
7629 	/** */
7630 	extern(C) void function(GtkMenuShell* menuShell) deactivate;
7631 	/** */
7632 	extern(C) void function(GtkMenuShell* menuShell) selectionDone;
7633 	/** */
7634 	extern(C) void function(GtkMenuShell* menuShell, GtkMenuDirectionType direction) moveCurrent;
7635 	/** */
7636 	extern(C) void function(GtkMenuShell* menuShell, int forceHide) activateCurrent;
7637 	/** */
7638 	extern(C) void function(GtkMenuShell* menuShell) cancel;
7639 	/** */
7640 	extern(C) void function(GtkMenuShell* menuShell, GtkWidget* menuItem) selectItem;
7641 	/** */
7642 	extern(C) void function(GtkMenuShell* menuShell, GtkWidget* child, int position) insert;
7643 	/** */
7644 	extern(C) int function(GtkMenuShell* menuShell) getPopupDelay;
7645 	/** */
7646 	extern(C) int function(GtkMenuShell* menuShell, int distance) moveSelected;
7647 	/** */
7648 	extern(C) void function() GtkReserved1;
7649 	/** */
7650 	extern(C) void function() GtkReserved2;
7651 	/** */
7652 	extern(C) void function() GtkReserved3;
7653 	/** */
7654 	extern(C) void function() GtkReserved4;
7655 }
7656 
7657 struct GtkMenuShellPrivate;
7658 
7659 struct GtkMenuToolButton
7660 {
7661 	GtkToolButton parent;
7662 	GtkMenuToolButtonPrivate* priv;
7663 }
7664 
7665 struct GtkMenuToolButtonClass
7666 {
7667 	/**
7668 	 * The parent class.
7669 	 */
7670 	GtkToolButtonClass parentClass;
7671 	/** */
7672 	extern(C) void function(GtkMenuToolButton* button) showMenu;
7673 	/** */
7674 	extern(C) void function() GtkReserved1;
7675 	/** */
7676 	extern(C) void function() GtkReserved2;
7677 	/** */
7678 	extern(C) void function() GtkReserved3;
7679 	/** */
7680 	extern(C) void function() GtkReserved4;
7681 }
7682 
7683 struct GtkMenuToolButtonPrivate;
7684 
7685 struct GtkMessageDialog
7686 {
7687 	GtkDialog parentInstance;
7688 	GtkMessageDialogPrivate* priv;
7689 }
7690 
7691 struct GtkMessageDialogClass
7692 {
7693 	GtkDialogClass parentClass;
7694 	/** */
7695 	extern(C) void function() GtkReserved1;
7696 	/** */
7697 	extern(C) void function() GtkReserved2;
7698 	/** */
7699 	extern(C) void function() GtkReserved3;
7700 	/** */
7701 	extern(C) void function() GtkReserved4;
7702 }
7703 
7704 struct GtkMessageDialogPrivate;
7705 
7706 struct GtkMisc
7707 {
7708 	GtkWidget widget;
7709 	GtkMiscPrivate* priv;
7710 }
7711 
7712 struct GtkMiscClass
7713 {
7714 	GtkWidgetClass parentClass;
7715 	/** */
7716 	extern(C) void function() GtkReserved1;
7717 	/** */
7718 	extern(C) void function() GtkReserved2;
7719 	/** */
7720 	extern(C) void function() GtkReserved3;
7721 	/** */
7722 	extern(C) void function() GtkReserved4;
7723 }
7724 
7725 struct GtkMiscPrivate;
7726 
7727 struct GtkModelButton;
7728 
7729 struct GtkMountOperation
7730 {
7731 	GMountOperation parentInstance;
7732 	GtkMountOperationPrivate* priv;
7733 }
7734 
7735 struct GtkMountOperationClass
7736 {
7737 	/**
7738 	 * The parent class.
7739 	 */
7740 	GMountOperationClass parentClass;
7741 	/** */
7742 	extern(C) void function() GtkReserved1;
7743 	/** */
7744 	extern(C) void function() GtkReserved2;
7745 	/** */
7746 	extern(C) void function() GtkReserved3;
7747 	/** */
7748 	extern(C) void function() GtkReserved4;
7749 }
7750 
7751 struct GtkMountOperationPrivate;
7752 
7753 struct GtkNativeDialog
7754 {
7755 	GObject parentInstance;
7756 }
7757 
7758 struct GtkNativeDialogClass
7759 {
7760 	GObjectClass parentClass;
7761 	/** */
7762 	extern(C) void function(GtkNativeDialog* self, int responseId) response;
7763 	/** */
7764 	extern(C) void function(GtkNativeDialog* self) show;
7765 	/** */
7766 	extern(C) void function(GtkNativeDialog* self) hide;
7767 	/** */
7768 	extern(C) void function() GtkReserved1;
7769 	/** */
7770 	extern(C) void function() GtkReserved2;
7771 	/** */
7772 	extern(C) void function() GtkReserved3;
7773 	/** */
7774 	extern(C) void function() GtkReserved4;
7775 }
7776 
7777 struct GtkNotebook
7778 {
7779 	GtkContainer container;
7780 	GtkNotebookPrivate* priv;
7781 }
7782 
7783 struct GtkNotebookAccessible
7784 {
7785 	GtkContainerAccessible parent;
7786 	GtkNotebookAccessiblePrivate* priv;
7787 }
7788 
7789 struct GtkNotebookAccessibleClass
7790 {
7791 	GtkContainerAccessibleClass parentClass;
7792 }
7793 
7794 struct GtkNotebookAccessiblePrivate;
7795 
7796 struct GtkNotebookClass
7797 {
7798 	GtkContainerClass parentClass;
7799 	/** */
7800 	extern(C) void function(GtkNotebook* notebook, GtkWidget* page, uint pageNum) switchPage;
7801 	/** */
7802 	extern(C) int function(GtkNotebook* notebook, int moveFocus) selectPage;
7803 	/** */
7804 	extern(C) int function(GtkNotebook* notebook, GtkNotebookTab type) focusTab;
7805 	/** */
7806 	extern(C) int function(GtkNotebook* notebook, int offset) changeCurrentPage;
7807 	/** */
7808 	extern(C) void function(GtkNotebook* notebook, GtkDirectionType direction) moveFocusOut;
7809 	/** */
7810 	extern(C) int function(GtkNotebook* notebook, GtkDirectionType direction, int moveToLast) reorderTab;
7811 	/** */
7812 	extern(C) int function(GtkNotebook* notebook, GtkWidget* child, GtkWidget* tabLabel, GtkWidget* menuLabel, int position) insertPage;
7813 	/** */
7814 	extern(C) GtkNotebook* function(GtkNotebook* notebook, GtkWidget* page, int x, int y) createWindow;
7815 	/** */
7816 	extern(C) void function(GtkNotebook* notebook, GtkWidget* child, uint pageNum) pageReordered;
7817 	/** */
7818 	extern(C) void function(GtkNotebook* notebook, GtkWidget* child, uint pageNum) pageRemoved;
7819 	/** */
7820 	extern(C) void function(GtkNotebook* notebook, GtkWidget* child, uint pageNum) pageAdded;
7821 	/** */
7822 	extern(C) void function() GtkReserved1;
7823 	/** */
7824 	extern(C) void function() GtkReserved2;
7825 	/** */
7826 	extern(C) void function() GtkReserved3;
7827 	/** */
7828 	extern(C) void function() GtkReserved4;
7829 	/** */
7830 	extern(C) void function() GtkReserved5;
7831 	/** */
7832 	extern(C) void function() GtkReserved6;
7833 	/** */
7834 	extern(C) void function() GtkReserved7;
7835 	/** */
7836 	extern(C) void function() GtkReserved8;
7837 }
7838 
7839 struct GtkNotebookPageAccessible
7840 {
7841 	AtkObject parent;
7842 	GtkNotebookPageAccessiblePrivate* priv;
7843 }
7844 
7845 struct GtkNotebookPageAccessibleClass
7846 {
7847 	AtkObjectClass parentClass;
7848 }
7849 
7850 struct GtkNotebookPageAccessiblePrivate;
7851 
7852 struct GtkNotebookPrivate;
7853 
7854 struct GtkNumerableIcon
7855 {
7856 	GEmblemedIcon parent;
7857 	GtkNumerableIconPrivate* priv;
7858 }
7859 
7860 struct GtkNumerableIconClass
7861 {
7862 	GEmblemedIconClass parentClass;
7863 	void*[16] padding;
7864 }
7865 
7866 struct GtkNumerableIconPrivate;
7867 
7868 struct GtkOffscreenWindow
7869 {
7870 	GtkWindow parentObject;
7871 }
7872 
7873 struct GtkOffscreenWindowClass
7874 {
7875 	/**
7876 	 * The parent class.
7877 	 */
7878 	GtkWindowClass parentClass;
7879 	/** */
7880 	extern(C) void function() GtkReserved1;
7881 	/** */
7882 	extern(C) void function() GtkReserved2;
7883 	/** */
7884 	extern(C) void function() GtkReserved3;
7885 	/** */
7886 	extern(C) void function() GtkReserved4;
7887 }
7888 
7889 struct GtkOrientable;
7890 
7891 struct GtkOrientableIface
7892 {
7893 	GTypeInterface baseIface;
7894 }
7895 
7896 struct GtkOverlay
7897 {
7898 	GtkBin parent;
7899 	GtkOverlayPrivate* priv;
7900 }
7901 
7902 struct GtkOverlayClass
7903 {
7904 	/**
7905 	 * The parent class.
7906 	 */
7907 	GtkBinClass parentClass;
7908 	/** */
7909 	extern(C) int function(GtkOverlay* overlay, GtkWidget* widget, GtkAllocation* allocation) getChildPosition;
7910 	/** */
7911 	extern(C) void function() GtkReserved1;
7912 	/** */
7913 	extern(C) void function() GtkReserved2;
7914 	/** */
7915 	extern(C) void function() GtkReserved3;
7916 	/** */
7917 	extern(C) void function() GtkReserved4;
7918 	/** */
7919 	extern(C) void function() GtkReserved5;
7920 	/** */
7921 	extern(C) void function() GtkReserved6;
7922 	/** */
7923 	extern(C) void function() GtkReserved7;
7924 	/** */
7925 	extern(C) void function() GtkReserved8;
7926 }
7927 
7928 struct GtkOverlayPrivate;
7929 
7930 /**
7931  * Struct defining a pad action entry.
7932  */
7933 struct GtkPadActionEntry
7934 {
7935 	/**
7936 	 * the type of pad feature that will trigger this action entry.
7937 	 */
7938 	GtkPadActionType type;
7939 	/**
7940 	 * the 0-indexed button/ring/strip number that will trigger this action
7941 	 * entry.
7942 	 */
7943 	int index;
7944 	/**
7945 	 * the mode that will trigger this action entry, or -1 for all modes.
7946 	 */
7947 	int mode;
7948 	/**
7949 	 * Human readable description of this action entry, this string should
7950 	 * be deemed user-visible.
7951 	 */
7952 	char* label;
7953 	/**
7954 	 * action name that will be activated in the #GActionGroup.
7955 	 */
7956 	char* actionName;
7957 }
7958 
7959 struct GtkPadController;
7960 
7961 struct GtkPadControllerClass;
7962 
7963 /**
7964  * See also gtk_print_settings_set_page_ranges().
7965  */
7966 struct GtkPageRange
7967 {
7968 	/**
7969 	 * start of page range.
7970 	 */
7971 	int start;
7972 	/**
7973 	 * end of page range.
7974 	 */
7975 	int end;
7976 }
7977 
7978 struct GtkPageSetup;
7979 
7980 struct GtkPaned
7981 {
7982 	GtkContainer container;
7983 	GtkPanedPrivate* priv;
7984 }
7985 
7986 struct GtkPanedAccessible
7987 {
7988 	GtkContainerAccessible parent;
7989 	GtkPanedAccessiblePrivate* priv;
7990 }
7991 
7992 struct GtkPanedAccessibleClass
7993 {
7994 	GtkContainerAccessibleClass parentClass;
7995 }
7996 
7997 struct GtkPanedAccessiblePrivate;
7998 
7999 struct GtkPanedClass
8000 {
8001 	GtkContainerClass parentClass;
8002 	/** */
8003 	extern(C) int function(GtkPaned* paned, int reverse) cycleChildFocus;
8004 	/** */
8005 	extern(C) int function(GtkPaned* paned) toggleHandleFocus;
8006 	/** */
8007 	extern(C) int function(GtkPaned* paned, GtkScrollType scroll) moveHandle;
8008 	/** */
8009 	extern(C) int function(GtkPaned* paned, int reverse) cycleHandleFocus;
8010 	/** */
8011 	extern(C) int function(GtkPaned* paned) acceptPosition;
8012 	/** */
8013 	extern(C) int function(GtkPaned* paned) cancelPosition;
8014 	/** */
8015 	extern(C) void function() GtkReserved1;
8016 	/** */
8017 	extern(C) void function() GtkReserved2;
8018 	/** */
8019 	extern(C) void function() GtkReserved3;
8020 	/** */
8021 	extern(C) void function() GtkReserved4;
8022 }
8023 
8024 struct GtkPanedPrivate;
8025 
8026 struct GtkPaperSize;
8027 
8028 struct GtkPlacesSidebar;
8029 
8030 struct GtkPlacesSidebarClass;
8031 
8032 struct GtkPlug
8033 {
8034 	GtkWindow window;
8035 	GtkPlugPrivate* priv;
8036 }
8037 
8038 struct GtkPlugClass
8039 {
8040 	GtkWindowClass parentClass;
8041 	/** */
8042 	extern(C) void function(GtkPlug* plug) embedded;
8043 	/** */
8044 	extern(C) void function() GtkReserved1;
8045 	/** */
8046 	extern(C) void function() GtkReserved2;
8047 	/** */
8048 	extern(C) void function() GtkReserved3;
8049 	/** */
8050 	extern(C) void function() GtkReserved4;
8051 }
8052 
8053 struct GtkPlugPrivate;
8054 
8055 struct GtkPopover
8056 {
8057 	GtkBin parentInstance;
8058 	GtkPopoverPrivate* priv;
8059 }
8060 
8061 struct GtkPopoverAccessible
8062 {
8063 	GtkContainerAccessible parent;
8064 }
8065 
8066 struct GtkPopoverAccessibleClass
8067 {
8068 	GtkContainerAccessibleClass parentClass;
8069 }
8070 
8071 struct GtkPopoverClass
8072 {
8073 	GtkBinClass parentClass;
8074 	/** */
8075 	extern(C) void function(GtkPopover* popover) closed;
8076 	void*[10] reserved;
8077 }
8078 
8079 struct GtkPopoverMenu;
8080 
8081 struct GtkPopoverMenuClass
8082 {
8083 	GtkPopoverClass parentClass;
8084 	void*[10] reserved;
8085 }
8086 
8087 struct GtkPopoverPrivate;
8088 
8089 struct GtkPrintContext;
8090 
8091 struct GtkPrintOperation
8092 {
8093 	GObject parentInstance;
8094 	GtkPrintOperationPrivate* priv;
8095 }
8096 
8097 struct GtkPrintOperationClass
8098 {
8099 	/**
8100 	 * The parent class.
8101 	 */
8102 	GObjectClass parentClass;
8103 	/** */
8104 	extern(C) void function(GtkPrintOperation* operation, GtkPrintOperationResult result) done;
8105 	/** */
8106 	extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context) beginPrint;
8107 	/** */
8108 	extern(C) int function(GtkPrintOperation* operation, GtkPrintContext* context) paginate;
8109 	/** */
8110 	extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context, int pageNr, GtkPageSetup* setup) requestPageSetup;
8111 	/** */
8112 	extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context, int pageNr) drawPage;
8113 	/** */
8114 	extern(C) void function(GtkPrintOperation* operation, GtkPrintContext* context) endPrint;
8115 	/** */
8116 	extern(C) void function(GtkPrintOperation* operation) statusChanged;
8117 	/** */
8118 	extern(C) GtkWidget* function(GtkPrintOperation* operation) createCustomWidget;
8119 	/** */
8120 	extern(C) void function(GtkPrintOperation* operation, GtkWidget* widget) customWidgetApply;
8121 	/** */
8122 	extern(C) int function(GtkPrintOperation* operation, GtkPrintOperationPreview* preview, GtkPrintContext* context, GtkWindow* parent) preview;
8123 	/** */
8124 	extern(C) void function(GtkPrintOperation* operation, GtkWidget* widget, GtkPageSetup* setup, GtkPrintSettings* settings) updateCustomWidget;
8125 	/** */
8126 	extern(C) void function() GtkReserved1;
8127 	/** */
8128 	extern(C) void function() GtkReserved2;
8129 	/** */
8130 	extern(C) void function() GtkReserved3;
8131 	/** */
8132 	extern(C) void function() GtkReserved4;
8133 	/** */
8134 	extern(C) void function() GtkReserved5;
8135 	/** */
8136 	extern(C) void function() GtkReserved6;
8137 	/** */
8138 	extern(C) void function() GtkReserved7;
8139 	/** */
8140 	extern(C) void function() GtkReserved8;
8141 }
8142 
8143 struct GtkPrintOperationPreview;
8144 
8145 struct GtkPrintOperationPreviewIface
8146 {
8147 	GTypeInterface gIface;
8148 	/** */
8149 	extern(C) void function(GtkPrintOperationPreview* preview, GtkPrintContext* context) ready;
8150 	/** */
8151 	extern(C) void function(GtkPrintOperationPreview* preview, GtkPrintContext* context, GtkPageSetup* pageSetup) gotPageSize;
8152 	/** */
8153 	extern(C) void function(GtkPrintOperationPreview* preview, int pageNr) renderPage;
8154 	/**
8155 	 *
8156 	 * Params:
8157 	 *     preview = a #GtkPrintOperationPreview
8158 	 *     pageNr = a page number
8159 	 * Returns: %TRUE if the page has been selected for printing
8160 	 */
8161 	extern(C) int function(GtkPrintOperationPreview* preview, int pageNr) isSelected;
8162 	/** */
8163 	extern(C) void function(GtkPrintOperationPreview* preview) endPreview;
8164 	/** */
8165 	extern(C) void function() GtkReserved1;
8166 	/** */
8167 	extern(C) void function() GtkReserved2;
8168 	/** */
8169 	extern(C) void function() GtkReserved3;
8170 	/** */
8171 	extern(C) void function() GtkReserved4;
8172 	/** */
8173 	extern(C) void function() GtkReserved5;
8174 	/** */
8175 	extern(C) void function() GtkReserved6;
8176 	/** */
8177 	extern(C) void function() GtkReserved7;
8178 	/** */
8179 	extern(C) void function() GtkReserved8;
8180 }
8181 
8182 struct GtkPrintOperationPrivate;
8183 
8184 struct GtkPrintSettings;
8185 
8186 struct GtkProgressBar
8187 {
8188 	GtkWidget parent;
8189 	GtkProgressBarPrivate* priv;
8190 }
8191 
8192 struct GtkProgressBarAccessible
8193 {
8194 	GtkWidgetAccessible parent;
8195 	GtkProgressBarAccessiblePrivate* priv;
8196 }
8197 
8198 struct GtkProgressBarAccessibleClass
8199 {
8200 	GtkWidgetAccessibleClass parentClass;
8201 }
8202 
8203 struct GtkProgressBarAccessiblePrivate;
8204 
8205 struct GtkProgressBarClass
8206 {
8207 	GtkWidgetClass parentClass;
8208 	/** */
8209 	extern(C) void function() GtkReserved1;
8210 	/** */
8211 	extern(C) void function() GtkReserved2;
8212 	/** */
8213 	extern(C) void function() GtkReserved3;
8214 	/** */
8215 	extern(C) void function() GtkReserved4;
8216 }
8217 
8218 struct GtkProgressBarPrivate;
8219 
8220 struct GtkRadioAction
8221 {
8222 	GtkToggleAction parent;
8223 	GtkRadioActionPrivate* privateData;
8224 }
8225 
8226 struct GtkRadioActionClass
8227 {
8228 	GtkToggleActionClass parentClass;
8229 	/** */
8230 	extern(C) void function(GtkRadioAction* action, GtkRadioAction* current) changed;
8231 	/** */
8232 	extern(C) void function() GtkReserved1;
8233 	/** */
8234 	extern(C) void function() GtkReserved2;
8235 	/** */
8236 	extern(C) void function() GtkReserved3;
8237 	/** */
8238 	extern(C) void function() GtkReserved4;
8239 }
8240 
8241 /**
8242  * #GtkRadioActionEntry structs are used with
8243  * gtk_action_group_add_radio_actions() to construct groups of radio actions.
8244  */
8245 struct GtkRadioActionEntry
8246 {
8247 	/**
8248 	 * The name of the action.
8249 	 */
8250 	const(char)* name;
8251 	/**
8252 	 * The stock id for the action, or the name of an icon from the
8253 	 * icon theme.
8254 	 */
8255 	const(char)* stockId;
8256 	/**
8257 	 * The label for the action. This field should typically be marked
8258 	 * for translation, see gtk_action_group_set_translation_domain().
8259 	 */
8260 	const(char)* label;
8261 	/**
8262 	 * The accelerator for the action, in the format understood by
8263 	 * gtk_accelerator_parse().
8264 	 */
8265 	const(char)* accelerator;
8266 	/**
8267 	 * The tooltip for the action. This field should typically be
8268 	 * marked for translation, see gtk_action_group_set_translation_domain().
8269 	 */
8270 	const(char)* tooltip;
8271 	/**
8272 	 * The value to set on the radio action. See
8273 	 * gtk_radio_action_get_current_value().
8274 	 */
8275 	int value;
8276 }
8277 
8278 struct GtkRadioActionPrivate;
8279 
8280 struct GtkRadioButton
8281 {
8282 	GtkCheckButton checkButton;
8283 	GtkRadioButtonPrivate* priv;
8284 }
8285 
8286 struct GtkRadioButtonAccessible
8287 {
8288 	GtkToggleButtonAccessible parent;
8289 	GtkRadioButtonAccessiblePrivate* priv;
8290 }
8291 
8292 struct GtkRadioButtonAccessibleClass
8293 {
8294 	GtkToggleButtonAccessibleClass parentClass;
8295 }
8296 
8297 struct GtkRadioButtonAccessiblePrivate;
8298 
8299 struct GtkRadioButtonClass
8300 {
8301 	GtkCheckButtonClass parentClass;
8302 	/** */
8303 	extern(C) void function(GtkRadioButton* radioButton) groupChanged;
8304 	/** */
8305 	extern(C) void function() GtkReserved1;
8306 	/** */
8307 	extern(C) void function() GtkReserved2;
8308 	/** */
8309 	extern(C) void function() GtkReserved3;
8310 	/** */
8311 	extern(C) void function() GtkReserved4;
8312 }
8313 
8314 struct GtkRadioButtonPrivate;
8315 
8316 struct GtkRadioMenuItem
8317 {
8318 	GtkCheckMenuItem checkMenuItem;
8319 	GtkRadioMenuItemPrivate* priv;
8320 }
8321 
8322 struct GtkRadioMenuItemAccessible
8323 {
8324 	GtkCheckMenuItemAccessible parent;
8325 	GtkRadioMenuItemAccessiblePrivate* priv;
8326 }
8327 
8328 struct GtkRadioMenuItemAccessibleClass
8329 {
8330 	GtkCheckMenuItemAccessibleClass parentClass;
8331 }
8332 
8333 struct GtkRadioMenuItemAccessiblePrivate;
8334 
8335 struct GtkRadioMenuItemClass
8336 {
8337 	GtkCheckMenuItemClass parentClass;
8338 	/** */
8339 	extern(C) void function(GtkRadioMenuItem* radioMenuItem) groupChanged;
8340 	/** */
8341 	extern(C) void function() GtkReserved1;
8342 	/** */
8343 	extern(C) void function() GtkReserved2;
8344 	/** */
8345 	extern(C) void function() GtkReserved3;
8346 	/** */
8347 	extern(C) void function() GtkReserved4;
8348 }
8349 
8350 struct GtkRadioMenuItemPrivate;
8351 
8352 struct GtkRadioToolButton
8353 {
8354 	GtkToggleToolButton parent;
8355 }
8356 
8357 struct GtkRadioToolButtonClass
8358 {
8359 	GtkToggleToolButtonClass parentClass;
8360 	/** */
8361 	extern(C) void function() GtkReserved1;
8362 	/** */
8363 	extern(C) void function() GtkReserved2;
8364 	/** */
8365 	extern(C) void function() GtkReserved3;
8366 	/** */
8367 	extern(C) void function() GtkReserved4;
8368 }
8369 
8370 struct GtkRange
8371 {
8372 	GtkWidget widget;
8373 	GtkRangePrivate* priv;
8374 }
8375 
8376 struct GtkRangeAccessible
8377 {
8378 	GtkWidgetAccessible parent;
8379 	GtkRangeAccessiblePrivate* priv;
8380 }
8381 
8382 struct GtkRangeAccessibleClass
8383 {
8384 	GtkWidgetAccessibleClass parentClass;
8385 }
8386 
8387 struct GtkRangeAccessiblePrivate;
8388 
8389 struct GtkRangeClass
8390 {
8391 	GtkWidgetClass parentClass;
8392 	char* sliderDetail;
8393 	char* stepperDetail;
8394 	/** */
8395 	extern(C) void function(GtkRange* range) valueChanged;
8396 	/** */
8397 	extern(C) void function(GtkRange* range, double newValue) adjustBounds;
8398 	/** */
8399 	extern(C) void function(GtkRange* range, GtkScrollType scroll) moveSlider;
8400 	/** */
8401 	extern(C) void function(GtkRange* range, GtkBorder* border) getRangeBorder;
8402 	/** */
8403 	extern(C) int function(GtkRange* range, GtkScrollType scroll, double newValue) changeValue;
8404 	/** */
8405 	extern(C) void function(GtkRange* range, GtkOrientation orientation, int* minimum, int* natural) getRangeSizeRequest;
8406 	/** */
8407 	extern(C) void function() GtkReserved1;
8408 	/** */
8409 	extern(C) void function() GtkReserved2;
8410 	/** */
8411 	extern(C) void function() GtkReserved3;
8412 }
8413 
8414 struct GtkRangePrivate;
8415 
8416 struct GtkRcContext;
8417 
8418 /**
8419  * Deprecated
8420  */
8421 struct GtkRcProperty
8422 {
8423 	/**
8424 	 * quark-ified type identifier
8425 	 */
8426 	GQuark typeName;
8427 	/**
8428 	 * quark-ified property identifier like
8429 	 * “GtkScrollbar::spacing”
8430 	 */
8431 	GQuark propertyName;
8432 	/**
8433 	 * field similar to one found in #GtkSettingsValue
8434 	 */
8435 	char* origin;
8436 	/**
8437 	 * field similar to one found in #GtkSettingsValue
8438 	 */
8439 	GValue value;
8440 }
8441 
8442 struct GtkRcStyle
8443 {
8444 	GObject parentInstance;
8445 	/**
8446 	 * Name
8447 	 */
8448 	char* name;
8449 	/**
8450 	 * Pixmap name
8451 	 */
8452 	char*[5] bgPixmapName;
8453 	/**
8454 	 * A #PangoFontDescription
8455 	 */
8456 	PangoFontDescription* fontDesc;
8457 	/**
8458 	 * #GtkRcFlags
8459 	 */
8460 	GtkRcFlags[5] colorFlags;
8461 	/**
8462 	 * Foreground colors
8463 	 */
8464 	GdkColor[5] fg;
8465 	/**
8466 	 * Background colors
8467 	 */
8468 	GdkColor[5] bg;
8469 	/**
8470 	 * Text colors
8471 	 */
8472 	GdkColor[5] text;
8473 	/**
8474 	 * Base colors
8475 	 */
8476 	GdkColor[5] base;
8477 	/**
8478 	 * X thickness
8479 	 */
8480 	int xthickness;
8481 	/**
8482 	 * Y thickness
8483 	 */
8484 	int ythickness;
8485 	GArray* rcProperties;
8486 	GSList* rcStyleLists;
8487 	GSList* iconFactories;
8488 	import std.bitmanip: bitfields;
8489 	mixin(bitfields!(
8490 		uint, "engineSpecified", 1,
8491 		uint, "", 31
8492 	));
8493 }
8494 
8495 struct GtkRcStyleClass
8496 {
8497 	/**
8498 	 * The parent class.
8499 	 */
8500 	GObjectClass parentClass;
8501 	/** */
8502 	extern(C) GtkRcStyle* function(GtkRcStyle* rcStyle) createRcStyle;
8503 	/** */
8504 	extern(C) uint function(GtkRcStyle* rcStyle, GtkSettings* settings, GScanner* scanner) parse;
8505 	/** */
8506 	extern(C) void function(GtkRcStyle* dest, GtkRcStyle* src) merge;
8507 	/** */
8508 	extern(C) GtkStyle* function(GtkRcStyle* rcStyle) createStyle;
8509 	/** */
8510 	extern(C) void function() GtkReserved1;
8511 	/** */
8512 	extern(C) void function() GtkReserved2;
8513 	/** */
8514 	extern(C) void function() GtkReserved3;
8515 	/** */
8516 	extern(C) void function() GtkReserved4;
8517 }
8518 
8519 struct GtkRecentAction
8520 {
8521 	GtkAction parentInstance;
8522 	GtkRecentActionPrivate* priv;
8523 }
8524 
8525 struct GtkRecentActionClass
8526 {
8527 	GtkActionClass parentClass;
8528 	/** */
8529 	extern(C) void function() GtkReserved1;
8530 	/** */
8531 	extern(C) void function() GtkReserved2;
8532 	/** */
8533 	extern(C) void function() GtkReserved3;
8534 	/** */
8535 	extern(C) void function() GtkReserved4;
8536 }
8537 
8538 struct GtkRecentActionPrivate;
8539 
8540 struct GtkRecentChooser;
8541 
8542 struct GtkRecentChooserDialog
8543 {
8544 	GtkDialog parentInstance;
8545 	GtkRecentChooserDialogPrivate* priv;
8546 }
8547 
8548 struct GtkRecentChooserDialogClass
8549 {
8550 	GtkDialogClass parentClass;
8551 	/** */
8552 	extern(C) void function() GtkReserved1;
8553 	/** */
8554 	extern(C) void function() GtkReserved2;
8555 	/** */
8556 	extern(C) void function() GtkReserved3;
8557 	/** */
8558 	extern(C) void function() GtkReserved4;
8559 }
8560 
8561 struct GtkRecentChooserDialogPrivate;
8562 
8563 struct GtkRecentChooserIface
8564 {
8565 	GTypeInterface baseIface;
8566 	/**
8567 	 *
8568 	 * Params:
8569 	 *     chooser = a #GtkRecentChooser
8570 	 *     uri = a URI
8571 	 * Returns: %TRUE if the URI was found.
8572 	 *
8573 	 * Throws: GException on failure.
8574 	 */
8575 	extern(C) int function(GtkRecentChooser* chooser, const(char)* uri, GError** err) setCurrentUri;
8576 	/**
8577 	 *
8578 	 * Params:
8579 	 *     chooser = a #GtkRecentChooser
8580 	 * Returns: a newly allocated string holding a URI.
8581 	 */
8582 	extern(C) char* function(GtkRecentChooser* chooser) getCurrentUri;
8583 	/**
8584 	 *
8585 	 * Params:
8586 	 *     chooser = a #GtkRecentChooser
8587 	 *     uri = a URI
8588 	 * Returns: %TRUE if @uri was found.
8589 	 *
8590 	 * Throws: GException on failure.
8591 	 */
8592 	extern(C) int function(GtkRecentChooser* chooser, const(char)* uri, GError** err) selectUri;
8593 	/** */
8594 	extern(C) void function(GtkRecentChooser* chooser, const(char)* uri) unselectUri;
8595 	/** */
8596 	extern(C) void function(GtkRecentChooser* chooser) selectAll;
8597 	/** */
8598 	extern(C) void function(GtkRecentChooser* chooser) unselectAll;
8599 	/**
8600 	 *
8601 	 * Params:
8602 	 *     chooser = a #GtkRecentChooser
8603 	 * Returns: A newly allocated
8604 	 *     list of #GtkRecentInfo objects.  You should
8605 	 *     use gtk_recent_info_unref() on every item of the list, and then free
8606 	 *     the list itself using g_list_free().
8607 	 */
8608 	extern(C) GList* function(GtkRecentChooser* chooser) getItems;
8609 	/** */
8610 	extern(C) GtkRecentManager* function(GtkRecentChooser* chooser) getRecentManager;
8611 	/** */
8612 	extern(C) void function(GtkRecentChooser* chooser, GtkRecentFilter* filter) addFilter;
8613 	/** */
8614 	extern(C) void function(GtkRecentChooser* chooser, GtkRecentFilter* filter) removeFilter;
8615 	/**
8616 	 *
8617 	 * Params:
8618 	 *     chooser = a #GtkRecentChooser
8619 	 * Returns: A singly linked list
8620 	 *     of #GtkRecentFilter objects.  You
8621 	 *     should just free the returned list using g_slist_free().
8622 	 */
8623 	extern(C) GSList* function(GtkRecentChooser* chooser) listFilters;
8624 	/** */
8625 	extern(C) void function(GtkRecentChooser* chooser, GtkRecentSortFunc sortFunc, void* sortData, GDestroyNotify dataDestroy) setSortFunc;
8626 	/** */
8627 	extern(C) void function(GtkRecentChooser* chooser) itemActivated;
8628 	/** */
8629 	extern(C) void function(GtkRecentChooser* chooser) selectionChanged;
8630 }
8631 
8632 struct GtkRecentChooserMenu
8633 {
8634 	GtkMenu parentInstance;
8635 	GtkRecentChooserMenuPrivate* priv;
8636 }
8637 
8638 struct GtkRecentChooserMenuClass
8639 {
8640 	GtkMenuClass parentClass;
8641 	/** */
8642 	extern(C) void function() gtkRecent1;
8643 	/** */
8644 	extern(C) void function() gtkRecent2;
8645 	/** */
8646 	extern(C) void function() gtkRecent3;
8647 	/** */
8648 	extern(C) void function() gtkRecent4;
8649 }
8650 
8651 struct GtkRecentChooserMenuPrivate;
8652 
8653 struct GtkRecentChooserWidget
8654 {
8655 	GtkBox parentInstance;
8656 	GtkRecentChooserWidgetPrivate* priv;
8657 }
8658 
8659 struct GtkRecentChooserWidgetClass
8660 {
8661 	GtkBoxClass parentClass;
8662 	/** */
8663 	extern(C) void function() GtkReserved1;
8664 	/** */
8665 	extern(C) void function() GtkReserved2;
8666 	/** */
8667 	extern(C) void function() GtkReserved3;
8668 	/** */
8669 	extern(C) void function() GtkReserved4;
8670 }
8671 
8672 struct GtkRecentChooserWidgetPrivate;
8673 
8674 /**
8675  * Meta-data to be passed to gtk_recent_manager_add_full() when
8676  * registering a recently used resource.
8677  */
8678 struct GtkRecentData
8679 {
8680 	/**
8681 	 * a UTF-8 encoded string, containing the name of the recently
8682 	 * used resource to be displayed, or %NULL;
8683 	 */
8684 	char* displayName;
8685 	/**
8686 	 * a UTF-8 encoded string, containing a short description of
8687 	 * the resource, or %NULL;
8688 	 */
8689 	char* description;
8690 	/**
8691 	 * the MIME type of the resource;
8692 	 */
8693 	char* mimeType;
8694 	/**
8695 	 * the name of the application that is registering this recently
8696 	 * used resource;
8697 	 */
8698 	char* appName;
8699 	/**
8700 	 * command line used to launch this resource; may contain the
8701 	 * “\%f” and “\%u” escape characters which will be expanded
8702 	 * to the resource file path and URI respectively when the command line
8703 	 * is retrieved;
8704 	 */
8705 	char* appExec;
8706 	/**
8707 	 * a vector of strings containing
8708 	 * groups names;
8709 	 */
8710 	char** groups;
8711 	/**
8712 	 * whether this resource should be displayed only by the
8713 	 * applications that have registered it or not.
8714 	 */
8715 	bool isPrivate;
8716 }
8717 
8718 struct GtkRecentFilter;
8719 
8720 /**
8721  * A GtkRecentFilterInfo struct is used
8722  * to pass information about the tested file to gtk_recent_filter_filter().
8723  */
8724 struct GtkRecentFilterInfo
8725 {
8726 	/**
8727 	 * #GtkRecentFilterFlags to indicate which fields are set.
8728 	 */
8729 	GtkRecentFilterFlags contains;
8730 	/**
8731 	 * The URI of the file being tested.
8732 	 */
8733 	const(char)* uri;
8734 	/**
8735 	 * The string that will be used to display
8736 	 * the file in the recent chooser.
8737 	 */
8738 	const(char)* displayName;
8739 	/**
8740 	 * MIME type of the file.
8741 	 */
8742 	const(char)* mimeType;
8743 	/**
8744 	 * The list of
8745 	 * applications that have registered the file.
8746 	 */
8747 	char** applications;
8748 	/**
8749 	 * The groups to which
8750 	 * the file belongs to.
8751 	 */
8752 	char** groups;
8753 	/**
8754 	 * The number of days elapsed since the file has been
8755 	 * registered.
8756 	 */
8757 	int age;
8758 }
8759 
8760 struct GtkRecentInfo;
8761 
8762 struct GtkRecentManager
8763 {
8764 	GObject parentInstance;
8765 	GtkRecentManagerPrivate* priv;
8766 }
8767 
8768 /**
8769  * #GtkRecentManagerClass contains only private data.
8770  *
8771  * Since: 2.10
8772  */
8773 struct GtkRecentManagerClass
8774 {
8775 	GObjectClass parentClass;
8776 	/** */
8777 	extern(C) void function(GtkRecentManager* manager) changed;
8778 	/** */
8779 	extern(C) void function() GtkRecent1;
8780 	/** */
8781 	extern(C) void function() GtkRecent2;
8782 	/** */
8783 	extern(C) void function() GtkRecent3;
8784 	/** */
8785 	extern(C) void function() GtkRecent4;
8786 }
8787 
8788 struct GtkRecentManagerPrivate;
8789 
8790 struct GtkRendererCellAccessible
8791 {
8792 	GtkCellAccessible parent;
8793 	GtkRendererCellAccessiblePrivate* priv;
8794 }
8795 
8796 struct GtkRendererCellAccessibleClass
8797 {
8798 	GtkCellAccessibleClass parentClass;
8799 }
8800 
8801 struct GtkRendererCellAccessiblePrivate;
8802 
8803 /**
8804  * Represents a request of a screen object in a given orientation. These
8805  * are primarily used in container implementations when allocating a natural
8806  * size for children calling. See gtk_distribute_natural_allocation().
8807  */
8808 struct GtkRequestedSize
8809 {
8810 	/**
8811 	 * A client pointer
8812 	 */
8813 	void* data;
8814 	/**
8815 	 * The minimum size needed for allocation in a given orientation
8816 	 */
8817 	int minimumSize;
8818 	/**
8819 	 * The natural size for allocation in a given orientation
8820 	 */
8821 	int naturalSize;
8822 }
8823 
8824 struct GtkRequisition
8825 {
8826 	/**
8827 	 * the widget’s desired width
8828 	 */
8829 	int width;
8830 	/**
8831 	 * the widget’s desired height
8832 	 */
8833 	int height;
8834 }
8835 
8836 struct GtkRevealer
8837 {
8838 	GtkBin parentInstance;
8839 }
8840 
8841 struct GtkRevealerClass
8842 {
8843 	/**
8844 	 * The parent class.
8845 	 */
8846 	GtkBinClass parentClass;
8847 }
8848 
8849 struct GtkScale
8850 {
8851 	GtkRange range;
8852 	GtkScalePrivate* priv;
8853 }
8854 
8855 struct GtkScaleAccessible
8856 {
8857 	GtkRangeAccessible parent;
8858 	GtkScaleAccessiblePrivate* priv;
8859 }
8860 
8861 struct GtkScaleAccessibleClass
8862 {
8863 	GtkRangeAccessibleClass parentClass;
8864 }
8865 
8866 struct GtkScaleAccessiblePrivate;
8867 
8868 struct GtkScaleButton
8869 {
8870 	GtkButton parent;
8871 	GtkScaleButtonPrivate* priv;
8872 }
8873 
8874 struct GtkScaleButtonAccessible
8875 {
8876 	GtkButtonAccessible parent;
8877 	GtkScaleButtonAccessiblePrivate* priv;
8878 }
8879 
8880 struct GtkScaleButtonAccessibleClass
8881 {
8882 	GtkButtonAccessibleClass parentClass;
8883 }
8884 
8885 struct GtkScaleButtonAccessiblePrivate;
8886 
8887 struct GtkScaleButtonClass
8888 {
8889 	GtkButtonClass parentClass;
8890 	/** */
8891 	extern(C) void function(GtkScaleButton* button, double value) valueChanged;
8892 	/** */
8893 	extern(C) void function() GtkReserved1;
8894 	/** */
8895 	extern(C) void function() GtkReserved2;
8896 	/** */
8897 	extern(C) void function() GtkReserved3;
8898 	/** */
8899 	extern(C) void function() GtkReserved4;
8900 }
8901 
8902 struct GtkScaleButtonPrivate;
8903 
8904 struct GtkScaleClass
8905 {
8906 	GtkRangeClass parentClass;
8907 	/** */
8908 	extern(C) char* function(GtkScale* scale, double value) formatValue;
8909 	/** */
8910 	extern(C) void function(GtkScale* scale) drawValue;
8911 	/** */
8912 	extern(C) void function(GtkScale* scale, int* x, int* y) getLayoutOffsets;
8913 	/** */
8914 	extern(C) void function() GtkReserved1;
8915 	/** */
8916 	extern(C) void function() GtkReserved2;
8917 	/** */
8918 	extern(C) void function() GtkReserved3;
8919 	/** */
8920 	extern(C) void function() GtkReserved4;
8921 }
8922 
8923 struct GtkScalePrivate;
8924 
8925 struct GtkScrollable;
8926 
8927 struct GtkScrollableInterface
8928 {
8929 	GTypeInterface baseIface;
8930 	/**
8931 	 *
8932 	 * Params:
8933 	 *     scrollable = a #GtkScrollable
8934 	 *     border = return location for the results
8935 	 * Returns: %TRUE if @border has been set
8936 	 */
8937 	extern(C) int function(GtkScrollable* scrollable, GtkBorder* border) getBorder;
8938 }
8939 
8940 struct GtkScrollbar
8941 {
8942 	GtkRange range;
8943 }
8944 
8945 struct GtkScrollbarClass
8946 {
8947 	GtkRangeClass parentClass;
8948 	/** */
8949 	extern(C) void function() GtkReserved1;
8950 	/** */
8951 	extern(C) void function() GtkReserved2;
8952 	/** */
8953 	extern(C) void function() GtkReserved3;
8954 	/** */
8955 	extern(C) void function() GtkReserved4;
8956 }
8957 
8958 struct GtkScrolledWindow
8959 {
8960 	GtkBin container;
8961 	GtkScrolledWindowPrivate* priv;
8962 }
8963 
8964 struct GtkScrolledWindowAccessible
8965 {
8966 	GtkContainerAccessible parent;
8967 	GtkScrolledWindowAccessiblePrivate* priv;
8968 }
8969 
8970 struct GtkScrolledWindowAccessibleClass
8971 {
8972 	GtkContainerAccessibleClass parentClass;
8973 }
8974 
8975 struct GtkScrolledWindowAccessiblePrivate;
8976 
8977 struct GtkScrolledWindowClass
8978 {
8979 	/**
8980 	 * The parent class.
8981 	 */
8982 	GtkBinClass parentClass;
8983 	int scrollbarSpacing;
8984 	/** */
8985 	extern(C) int function(GtkScrolledWindow* scrolledWindow, GtkScrollType scroll, int horizontal) scrollChild;
8986 	/** */
8987 	extern(C) void function(GtkScrolledWindow* scrolledWindow, GtkDirectionType direction) moveFocusOut;
8988 	/** */
8989 	extern(C) void function() GtkReserved1;
8990 	/** */
8991 	extern(C) void function() GtkReserved2;
8992 	/** */
8993 	extern(C) void function() GtkReserved3;
8994 	/** */
8995 	extern(C) void function() GtkReserved4;
8996 }
8997 
8998 struct GtkScrolledWindowPrivate;
8999 
9000 struct GtkSearchBar
9001 {
9002 	GtkBin parent;
9003 }
9004 
9005 struct GtkSearchBarClass
9006 {
9007 	/**
9008 	 * The parent class.
9009 	 */
9010 	GtkBinClass parentClass;
9011 	/** */
9012 	extern(C) void function() GtkReserved1;
9013 	/** */
9014 	extern(C) void function() GtkReserved2;
9015 	/** */
9016 	extern(C) void function() GtkReserved3;
9017 	/** */
9018 	extern(C) void function() GtkReserved4;
9019 }
9020 
9021 struct GtkSearchEntry
9022 {
9023 	GtkEntry parent;
9024 }
9025 
9026 struct GtkSearchEntryClass
9027 {
9028 	GtkEntryClass parentClass;
9029 	/** */
9030 	extern(C) void function(GtkSearchEntry* entry) searchChanged;
9031 	/** */
9032 	extern(C) void function(GtkSearchEntry* entry) nextMatch;
9033 	/** */
9034 	extern(C) void function(GtkSearchEntry* entry) previousMatch;
9035 	/** */
9036 	extern(C) void function(GtkSearchEntry* entry) stopSearch;
9037 }
9038 
9039 struct GtkSelectionData;
9040 
9041 struct GtkSeparator
9042 {
9043 	GtkWidget widget;
9044 	GtkSeparatorPrivate* priv;
9045 }
9046 
9047 struct GtkSeparatorClass
9048 {
9049 	GtkWidgetClass parentClass;
9050 	/** */
9051 	extern(C) void function() GtkReserved1;
9052 	/** */
9053 	extern(C) void function() GtkReserved2;
9054 	/** */
9055 	extern(C) void function() GtkReserved3;
9056 	/** */
9057 	extern(C) void function() GtkReserved4;
9058 }
9059 
9060 struct GtkSeparatorMenuItem
9061 {
9062 	GtkMenuItem menuItem;
9063 }
9064 
9065 struct GtkSeparatorMenuItemClass
9066 {
9067 	/**
9068 	 * The parent class.
9069 	 */
9070 	GtkMenuItemClass parentClass;
9071 	/** */
9072 	extern(C) void function() GtkReserved1;
9073 	/** */
9074 	extern(C) void function() GtkReserved2;
9075 	/** */
9076 	extern(C) void function() GtkReserved3;
9077 	/** */
9078 	extern(C) void function() GtkReserved4;
9079 }
9080 
9081 struct GtkSeparatorPrivate;
9082 
9083 struct GtkSeparatorToolItem
9084 {
9085 	GtkToolItem parent;
9086 	GtkSeparatorToolItemPrivate* priv;
9087 }
9088 
9089 struct GtkSeparatorToolItemClass
9090 {
9091 	/**
9092 	 * The parent class.
9093 	 */
9094 	GtkToolItemClass parentClass;
9095 	/** */
9096 	extern(C) void function() GtkReserved1;
9097 	/** */
9098 	extern(C) void function() GtkReserved2;
9099 	/** */
9100 	extern(C) void function() GtkReserved3;
9101 	/** */
9102 	extern(C) void function() GtkReserved4;
9103 }
9104 
9105 struct GtkSeparatorToolItemPrivate;
9106 
9107 struct GtkSettings
9108 {
9109 	GObject parentInstance;
9110 	GtkSettingsPrivate* priv;
9111 }
9112 
9113 struct GtkSettingsClass
9114 {
9115 	GObjectClass parentClass;
9116 	/** */
9117 	extern(C) void function() GtkReserved1;
9118 	/** */
9119 	extern(C) void function() GtkReserved2;
9120 	/** */
9121 	extern(C) void function() GtkReserved3;
9122 	/** */
9123 	extern(C) void function() GtkReserved4;
9124 }
9125 
9126 struct GtkSettingsPrivate;
9127 
9128 struct GtkSettingsValue
9129 {
9130 	/**
9131 	 * Origin should be something like “filename:linenumber” for
9132 	 * rc files, or e.g. “XProperty” for other sources.
9133 	 */
9134 	char* origin;
9135 	/**
9136 	 * Valid types are LONG, DOUBLE and STRING corresponding to
9137 	 * the token parsed, or a GSTRING holding an unparsed statement
9138 	 */
9139 	GValue value;
9140 }
9141 
9142 struct GtkShortcutLabel;
9143 
9144 struct GtkShortcutLabelClass;
9145 
9146 struct GtkShortcutsGroup;
9147 
9148 struct GtkShortcutsGroupClass;
9149 
9150 struct GtkShortcutsSection;
9151 
9152 struct GtkShortcutsSectionClass;
9153 
9154 struct GtkShortcutsShortcut;
9155 
9156 struct GtkShortcutsShortcutClass;
9157 
9158 struct GtkShortcutsWindow
9159 {
9160 	GtkWindow window;
9161 }
9162 
9163 struct GtkShortcutsWindowClass
9164 {
9165 	GtkWindowClass parentClass;
9166 	/** */
9167 	extern(C) void function(GtkShortcutsWindow* self) close;
9168 	/** */
9169 	extern(C) void function(GtkShortcutsWindow* self) search;
9170 }
9171 
9172 struct GtkSizeGroup
9173 {
9174 	GObject parentInstance;
9175 	GtkSizeGroupPrivate* priv;
9176 }
9177 
9178 struct GtkSizeGroupClass
9179 {
9180 	GObjectClass parentClass;
9181 	/** */
9182 	extern(C) void function() GtkReserved1;
9183 	/** */
9184 	extern(C) void function() GtkReserved2;
9185 	/** */
9186 	extern(C) void function() GtkReserved3;
9187 	/** */
9188 	extern(C) void function() GtkReserved4;
9189 }
9190 
9191 struct GtkSizeGroupPrivate;
9192 
9193 struct GtkSocket
9194 {
9195 	GtkContainer container;
9196 	GtkSocketPrivate* priv;
9197 }
9198 
9199 struct GtkSocketClass
9200 {
9201 	GtkContainerClass parentClass;
9202 	/** */
9203 	extern(C) void function(GtkSocket* socket) plugAdded;
9204 	/** */
9205 	extern(C) int function(GtkSocket* socket) plugRemoved;
9206 	/** */
9207 	extern(C) void function() GtkReserved1;
9208 	/** */
9209 	extern(C) void function() GtkReserved2;
9210 	/** */
9211 	extern(C) void function() GtkReserved3;
9212 	/** */
9213 	extern(C) void function() GtkReserved4;
9214 }
9215 
9216 struct GtkSocketPrivate;
9217 
9218 struct GtkSpinButton
9219 {
9220 	GtkEntry entry;
9221 	GtkSpinButtonPrivate* priv;
9222 }
9223 
9224 struct GtkSpinButtonAccessible
9225 {
9226 	GtkEntryAccessible parent;
9227 	GtkSpinButtonAccessiblePrivate* priv;
9228 }
9229 
9230 struct GtkSpinButtonAccessibleClass
9231 {
9232 	GtkEntryAccessibleClass parentClass;
9233 }
9234 
9235 struct GtkSpinButtonAccessiblePrivate;
9236 
9237 struct GtkSpinButtonClass
9238 {
9239 	GtkEntryClass parentClass;
9240 	/** */
9241 	extern(C) int function(GtkSpinButton* spinButton, double* newValue) input;
9242 	/** */
9243 	extern(C) int function(GtkSpinButton* spinButton) output;
9244 	/** */
9245 	extern(C) void function(GtkSpinButton* spinButton) valueChanged;
9246 	/** */
9247 	extern(C) void function(GtkSpinButton* spinButton, GtkScrollType scroll) changeValue;
9248 	/** */
9249 	extern(C) void function(GtkSpinButton* spinButton) wrapped;
9250 	/** */
9251 	extern(C) void function() GtkReserved1;
9252 	/** */
9253 	extern(C) void function() GtkReserved2;
9254 	/** */
9255 	extern(C) void function() GtkReserved3;
9256 	/** */
9257 	extern(C) void function() GtkReserved4;
9258 }
9259 
9260 struct GtkSpinButtonPrivate;
9261 
9262 struct GtkSpinner
9263 {
9264 	GtkWidget parent;
9265 	GtkSpinnerPrivate* priv;
9266 }
9267 
9268 struct GtkSpinnerAccessible
9269 {
9270 	GtkWidgetAccessible parent;
9271 	GtkSpinnerAccessiblePrivate* priv;
9272 }
9273 
9274 struct GtkSpinnerAccessibleClass
9275 {
9276 	GtkWidgetAccessibleClass parentClass;
9277 }
9278 
9279 struct GtkSpinnerAccessiblePrivate;
9280 
9281 struct GtkSpinnerClass
9282 {
9283 	GtkWidgetClass parentClass;
9284 	/** */
9285 	extern(C) void function() GtkReserved1;
9286 	/** */
9287 	extern(C) void function() GtkReserved2;
9288 	/** */
9289 	extern(C) void function() GtkReserved3;
9290 	/** */
9291 	extern(C) void function() GtkReserved4;
9292 }
9293 
9294 struct GtkSpinnerPrivate;
9295 
9296 struct GtkStack
9297 {
9298 	GtkContainer parentInstance;
9299 }
9300 
9301 struct GtkStackAccessible
9302 {
9303 	GtkContainerAccessible parent;
9304 }
9305 
9306 struct GtkStackAccessibleClass
9307 {
9308 	GtkContainerAccessibleClass parentClass;
9309 }
9310 
9311 struct GtkStackClass
9312 {
9313 	GtkContainerClass parentClass;
9314 }
9315 
9316 struct GtkStackSidebar
9317 {
9318 	GtkBin parent;
9319 }
9320 
9321 struct GtkStackSidebarClass
9322 {
9323 	GtkBinClass parentClass;
9324 	/** */
9325 	extern(C) void function() GtkReserved1;
9326 	/** */
9327 	extern(C) void function() GtkReserved2;
9328 	/** */
9329 	extern(C) void function() GtkReserved3;
9330 	/** */
9331 	extern(C) void function() GtkReserved4;
9332 }
9333 
9334 struct GtkStackSidebarPrivate;
9335 
9336 struct GtkStackSwitcher
9337 {
9338 	GtkBox widget;
9339 }
9340 
9341 struct GtkStackSwitcherClass
9342 {
9343 	GtkBoxClass parentClass;
9344 	/** */
9345 	extern(C) void function() GtkReserved1;
9346 	/** */
9347 	extern(C) void function() GtkReserved2;
9348 	/** */
9349 	extern(C) void function() GtkReserved3;
9350 	/** */
9351 	extern(C) void function() GtkReserved4;
9352 }
9353 
9354 struct GtkStatusIcon
9355 {
9356 	GObject parentInstance;
9357 	GtkStatusIconPrivate* priv;
9358 }
9359 
9360 struct GtkStatusIconClass
9361 {
9362 	GObjectClass parentClass;
9363 	/** */
9364 	extern(C) void function(GtkStatusIcon* statusIcon) activate;
9365 	/** */
9366 	extern(C) void function(GtkStatusIcon* statusIcon, uint button, uint activateTime) popupMenu;
9367 	/** */
9368 	extern(C) int function(GtkStatusIcon* statusIcon, int size) sizeChanged;
9369 	/** */
9370 	extern(C) int function(GtkStatusIcon* statusIcon, GdkEventButton* event) buttonPressEvent;
9371 	/** */
9372 	extern(C) int function(GtkStatusIcon* statusIcon, GdkEventButton* event) buttonReleaseEvent;
9373 	/** */
9374 	extern(C) int function(GtkStatusIcon* statusIcon, GdkEventScroll* event) scrollEvent;
9375 	/** */
9376 	extern(C) int function(GtkStatusIcon* statusIcon, int x, int y, int keyboardMode, GtkTooltip* tooltip) queryTooltip;
9377 	void* GtkReserved1;
9378 	void* GtkReserved2;
9379 	void* GtkReserved3;
9380 	void* GtkReserved4;
9381 }
9382 
9383 struct GtkStatusIconPrivate;
9384 
9385 struct GtkStatusbar
9386 {
9387 	GtkBox parentWidget;
9388 	GtkStatusbarPrivate* priv;
9389 }
9390 
9391 struct GtkStatusbarAccessible
9392 {
9393 	GtkContainerAccessible parent;
9394 	GtkStatusbarAccessiblePrivate* priv;
9395 }
9396 
9397 struct GtkStatusbarAccessibleClass
9398 {
9399 	GtkContainerAccessibleClass parentClass;
9400 }
9401 
9402 struct GtkStatusbarAccessiblePrivate;
9403 
9404 struct GtkStatusbarClass
9405 {
9406 	GtkBoxClass parentClass;
9407 	void* reserved;
9408 	/** */
9409 	extern(C) void function(GtkStatusbar* statusbar, uint contextId, const(char)* text) textPushed;
9410 	/** */
9411 	extern(C) void function(GtkStatusbar* statusbar, uint contextId, const(char)* text) textPopped;
9412 	/** */
9413 	extern(C) void function() GtkReserved1;
9414 	/** */
9415 	extern(C) void function() GtkReserved2;
9416 	/** */
9417 	extern(C) void function() GtkReserved3;
9418 	/** */
9419 	extern(C) void function() GtkReserved4;
9420 }
9421 
9422 struct GtkStatusbarPrivate;
9423 
9424 struct GtkStockItem
9425 {
9426 	/**
9427 	 * Identifier.
9428 	 */
9429 	char* stockId;
9430 	/**
9431 	 * User visible label.
9432 	 */
9433 	char* label;
9434 	/**
9435 	 * Modifier type for keyboard accelerator
9436 	 */
9437 	GdkModifierType modifier;
9438 	/**
9439 	 * Keyboard accelerator
9440 	 */
9441 	uint keyval;
9442 	/**
9443 	 * Translation domain of the menu or toolbar item
9444 	 */
9445 	char* translationDomain;
9446 }
9447 
9448 struct GtkStyle
9449 {
9450 	GObject parentInstance;
9451 	/**
9452 	 * Set of foreground #GdkColor
9453 	 */
9454 	GdkColor[5] fg;
9455 	/**
9456 	 * Set of background #GdkColor
9457 	 */
9458 	GdkColor[5] bg;
9459 	/**
9460 	 * Set of light #GdkColor
9461 	 */
9462 	GdkColor[5] light;
9463 	/**
9464 	 * Set of dark #GdkColor
9465 	 */
9466 	GdkColor[5] dark;
9467 	/**
9468 	 * Set of mid #GdkColor
9469 	 */
9470 	GdkColor[5] mid;
9471 	/**
9472 	 * Set of text #GdkColor
9473 	 */
9474 	GdkColor[5] text;
9475 	/**
9476 	 * Set of base #GdkColor
9477 	 */
9478 	GdkColor[5] base;
9479 	/**
9480 	 * Color halfway between text/base
9481 	 */
9482 	GdkColor[5] textAa;
9483 	/**
9484 	 * #GdkColor to use for black
9485 	 */
9486 	GdkColor black;
9487 	/**
9488 	 * #GdkColor to use for white
9489 	 */
9490 	GdkColor white;
9491 	/**
9492 	 * #PangoFontDescription
9493 	 */
9494 	PangoFontDescription* fontDesc;
9495 	/**
9496 	 * Thickness in X direction
9497 	 */
9498 	int xthickness;
9499 	/**
9500 	 * Thickness in Y direction
9501 	 */
9502 	int ythickness;
9503 	/**
9504 	 * Set of background #cairo_pattern_t
9505 	 */
9506 	cairo_pattern_t*[5] background;
9507 	int attachCount;
9508 	GdkVisual* visual;
9509 	PangoFontDescription* privateFontDesc;
9510 	GtkRcStyle* rcStyle;
9511 	GSList* styles;
9512 	GArray* propertyCache;
9513 	GSList* iconFactories;
9514 }
9515 
9516 struct GtkStyleClass
9517 {
9518 	/**
9519 	 * The parent class.
9520 	 */
9521 	GObjectClass parentClass;
9522 	/** */
9523 	extern(C) void function(GtkStyle* style) realize;
9524 	/** */
9525 	extern(C) void function(GtkStyle* style) unrealize;
9526 	/** */
9527 	extern(C) void function(GtkStyle* style, GtkStyle* src) copy;
9528 	/** */
9529 	extern(C) GtkStyle* function(GtkStyle* style) clone;
9530 	/** */
9531 	extern(C) void function(GtkStyle* style, GtkRcStyle* rcStyle) initFromRc;
9532 	/** */
9533 	extern(C) void function(GtkStyle* style, GdkWindow* window, GtkStateType stateType) setBackground;
9534 	/**
9535 	 *
9536 	 * Params:
9537 	 *     style = a #GtkStyle
9538 	 *     source = the #GtkIconSource specifying the icon to render
9539 	 *     direction = a text direction
9540 	 *     state = a state
9541 	 *     size = the size to render the icon at (#GtkIconSize). A size of
9542 	 *         `(GtkIconSize)-1` means render at the size of the source and
9543 	 *         don’t scale.
9544 	 *     widget = the widget
9545 	 *     detail = a style detail
9546 	 * Returns: a newly-created #GdkPixbuf
9547 	 *     containing the rendered icon
9548 	 */
9549 	extern(C) GdkPixbuf* function(GtkStyle* style, GtkIconSource* source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget* widget, const(char)* detail) renderIcon;
9550 	/** */
9551 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int x1, int x2, int y) drawHline;
9552 	/** */
9553 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int y1, int y2, int x) drawVline;
9554 	/** */
9555 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawShadow;
9556 	/** */
9557 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, GtkArrowType arrowType, int fill, int x, int y, int width, int height) drawArrow;
9558 	/** */
9559 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawDiamond;
9560 	/** */
9561 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawBox;
9562 	/** */
9563 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawFlatBox;
9564 	/** */
9565 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawCheck;
9566 	/** */
9567 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawOption;
9568 	/** */
9569 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawTab;
9570 	/** */
9571 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth) drawShadowGap;
9572 	/** */
9573 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkPositionType gapSide, int gapX, int gapWidth) drawBoxGap;
9574 	/** */
9575 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkPositionType gapSide) drawExtension;
9576 	/** */
9577 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height) drawFocus;
9578 	/** */
9579 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkOrientation orientation) drawSlider;
9580 	/** */
9581 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkShadowType shadowType, GtkWidget* widget, const(char)* detail, int x, int y, int width, int height, GtkOrientation orientation) drawHandle;
9582 	/** */
9583 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, int x, int y, GtkExpanderStyle expanderStyle) drawExpander;
9584 	/** */
9585 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, int useText, GtkWidget* widget, const(char)* detail, int x, int y, PangoLayout* layout) drawLayout;
9586 	/** */
9587 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, GdkWindowEdge edge, int x, int y, int width, int height) drawResizeGrip;
9588 	/** */
9589 	extern(C) void function(GtkStyle* style, cairo_t* cr, GtkStateType stateType, GtkWidget* widget, const(char)* detail, uint step, int x, int y, int width, int height) drawSpinner;
9590 	/** */
9591 	extern(C) void function() GtkReserved1;
9592 	/** */
9593 	extern(C) void function() GtkReserved2;
9594 	/** */
9595 	extern(C) void function() GtkReserved3;
9596 	/** */
9597 	extern(C) void function() GtkReserved4;
9598 	/** */
9599 	extern(C) void function() GtkReserved5;
9600 	/** */
9601 	extern(C) void function() GtkReserved6;
9602 	/** */
9603 	extern(C) void function() GtkReserved7;
9604 	/** */
9605 	extern(C) void function() GtkReserved8;
9606 	/** */
9607 	extern(C) void function() GtkReserved9;
9608 	/** */
9609 	extern(C) void function() GtkReserved10;
9610 	/** */
9611 	extern(C) void function() GtkReserved11;
9612 }
9613 
9614 struct GtkStyleContext
9615 {
9616 	GObject parentObject;
9617 	GtkStyleContextPrivate* priv;
9618 }
9619 
9620 struct GtkStyleContextClass
9621 {
9622 	GObjectClass parentClass;
9623 	/** */
9624 	extern(C) void function(GtkStyleContext* context) changed;
9625 	/** */
9626 	extern(C) void function() GtkReserved1;
9627 	/** */
9628 	extern(C) void function() GtkReserved2;
9629 	/** */
9630 	extern(C) void function() GtkReserved3;
9631 	/** */
9632 	extern(C) void function() GtkReserved4;
9633 }
9634 
9635 struct GtkStyleContextPrivate;
9636 
9637 struct GtkStyleProperties
9638 {
9639 	GObject parentObject;
9640 	GtkStylePropertiesPrivate* priv;
9641 }
9642 
9643 struct GtkStylePropertiesClass
9644 {
9645 	GObjectClass parentClass;
9646 	/** */
9647 	extern(C) void function() GtkReserved1;
9648 	/** */
9649 	extern(C) void function() GtkReserved2;
9650 	/** */
9651 	extern(C) void function() GtkReserved3;
9652 	/** */
9653 	extern(C) void function() GtkReserved4;
9654 }
9655 
9656 struct GtkStylePropertiesPrivate;
9657 
9658 struct GtkStyleProvider;
9659 
9660 struct GtkStyleProviderIface
9661 {
9662 	GTypeInterface gIface;
9663 	/**
9664 	 *
9665 	 * Params:
9666 	 *     provider = a #GtkStyleProvider
9667 	 *     path = #GtkWidgetPath to query
9668 	 * Returns: a #GtkStyleProperties containing the
9669 	 *     style settings affecting @path
9670 	 */
9671 	extern(C) GtkStyleProperties* function(GtkStyleProvider* provider, GtkWidgetPath* path) getStyle;
9672 	/**
9673 	 *
9674 	 * Params:
9675 	 *     provider = a #GtkStyleProvider
9676 	 *     path = #GtkWidgetPath to query
9677 	 *     state = state to query the style property for
9678 	 *     pspec = The #GParamSpec to query
9679 	 *     value = return location for the property value
9680 	 * Returns: %TRUE if the property was found and has a value, %FALSE otherwise
9681 	 */
9682 	extern(C) int function(GtkStyleProvider* provider, GtkWidgetPath* path, GtkStateFlags state, GParamSpec* pspec, GValue* value) getStyleProperty;
9683 	/**
9684 	 *
9685 	 * Params:
9686 	 *     provider = a #GtkStyleProvider
9687 	 *     path = #GtkWidgetPath to query
9688 	 * Returns: The icon factory to use for @path, or %NULL
9689 	 */
9690 	extern(C) GtkIconFactory* function(GtkStyleProvider* provider, GtkWidgetPath* path) getIconFactory;
9691 }
9692 
9693 struct GtkSwitch
9694 {
9695 	GtkWidget parentInstance;
9696 	GtkSwitchPrivate* priv;
9697 }
9698 
9699 struct GtkSwitchAccessible
9700 {
9701 	GtkWidgetAccessible parent;
9702 	GtkSwitchAccessiblePrivate* priv;
9703 }
9704 
9705 struct GtkSwitchAccessibleClass
9706 {
9707 	GtkWidgetAccessibleClass parentClass;
9708 }
9709 
9710 struct GtkSwitchAccessiblePrivate;
9711 
9712 struct GtkSwitchClass
9713 {
9714 	/**
9715 	 * The parent class.
9716 	 */
9717 	GtkWidgetClass parentClass;
9718 	/** */
9719 	extern(C) void function(GtkSwitch* sw) activate;
9720 	/** */
9721 	extern(C) int function(GtkSwitch* sw, int state) stateSet;
9722 	/** */
9723 	extern(C) void function() SwitchPadding1;
9724 	/** */
9725 	extern(C) void function() SwitchPadding2;
9726 	/** */
9727 	extern(C) void function() SwitchPadding3;
9728 	/** */
9729 	extern(C) void function() SwitchPadding4;
9730 	/** */
9731 	extern(C) void function() SwitchPadding5;
9732 }
9733 
9734 struct GtkSwitchPrivate;
9735 
9736 struct GtkSymbolicColor;
9737 
9738 struct GtkTable
9739 {
9740 	GtkContainer container;
9741 	GtkTablePrivate* priv;
9742 }
9743 
9744 struct GtkTableChild
9745 {
9746 	GtkWidget* widget;
9747 	ushort leftAttach;
9748 	ushort rightAttach;
9749 	ushort topAttach;
9750 	ushort bottomAttach;
9751 	ushort xpadding;
9752 	ushort ypadding;
9753 	import std.bitmanip: bitfields;
9754 	mixin(bitfields!(
9755 		uint, "xexpand", 1,
9756 		uint, "yexpand", 1,
9757 		uint, "xshrink", 1,
9758 		uint, "yshrink", 1,
9759 		uint, "xfill", 1,
9760 		uint, "yfill", 1,
9761 		uint, "", 26
9762 	));
9763 }
9764 
9765 struct GtkTableClass
9766 {
9767 	GtkContainerClass parentClass;
9768 	/** */
9769 	extern(C) void function() GtkReserved1;
9770 	/** */
9771 	extern(C) void function() GtkReserved2;
9772 	/** */
9773 	extern(C) void function() GtkReserved3;
9774 	/** */
9775 	extern(C) void function() GtkReserved4;
9776 }
9777 
9778 struct GtkTablePrivate;
9779 
9780 struct GtkTableRowCol
9781 {
9782 	ushort requisition;
9783 	ushort allocation;
9784 	ushort spacing;
9785 	import std.bitmanip: bitfields;
9786 	mixin(bitfields!(
9787 		uint, "needExpand", 1,
9788 		uint, "needShrink", 1,
9789 		uint, "expand", 1,
9790 		uint, "shrink", 1,
9791 		uint, "empty", 1,
9792 		uint, "", 27
9793 	));
9794 }
9795 
9796 struct GtkTargetEntry
9797 {
9798 	/**
9799 	 * a string representation of the target type
9800 	 */
9801 	char* target;
9802 	/**
9803 	 * #GtkTargetFlags for DND
9804 	 */
9805 	uint flags;
9806 	/**
9807 	 * an application-assigned integer ID which will
9808 	 * get passed as a parameter to e.g the #GtkWidget::selection-get
9809 	 * signal. It allows the application to identify the target
9810 	 * type without extensive string compares.
9811 	 */
9812 	uint info;
9813 }
9814 
9815 struct GtkTargetList;
9816 
9817 /**
9818  * A #GtkTargetPair is used to represent the same
9819  * information as a table of #GtkTargetEntry, but in
9820  * an efficient form.
9821  */
9822 struct GtkTargetPair
9823 {
9824 	/**
9825 	 * #GdkAtom representation of the target type
9826 	 */
9827 	GdkAtom target;
9828 	/**
9829 	 * #GtkTargetFlags for DND
9830 	 */
9831 	uint flags;
9832 	/**
9833 	 * an application-assigned integer ID which will
9834 	 * get passed as a parameter to e.g the #GtkWidget::selection-get
9835 	 * signal. It allows the application to identify the target
9836 	 * type without extensive string compares.
9837 	 */
9838 	uint info;
9839 }
9840 
9841 struct GtkTearoffMenuItem
9842 {
9843 	GtkMenuItem menuItem;
9844 	GtkTearoffMenuItemPrivate* priv;
9845 }
9846 
9847 struct GtkTearoffMenuItemClass
9848 {
9849 	/**
9850 	 * The parent class.
9851 	 */
9852 	GtkMenuItemClass parentClass;
9853 	/** */
9854 	extern(C) void function() GtkReserved1;
9855 	/** */
9856 	extern(C) void function() GtkReserved2;
9857 	/** */
9858 	extern(C) void function() GtkReserved3;
9859 	/** */
9860 	extern(C) void function() GtkReserved4;
9861 }
9862 
9863 struct GtkTearoffMenuItemPrivate;
9864 
9865 struct GtkTextAppearance
9866 {
9867 	/**
9868 	 * Background #GdkColor.
9869 	 */
9870 	GdkColor bgColor;
9871 	/**
9872 	 * Foreground #GdkColor.
9873 	 */
9874 	GdkColor fgColor;
9875 	/**
9876 	 * Super/subscript rise, can be negative.
9877 	 */
9878 	int rise;
9879 	import std.bitmanip: bitfields;
9880 	mixin(bitfields!(
9881 		uint, "underline", 4,
9882 		uint, "strikethrough", 1,
9883 		uint, "drawBg", 1,
9884 		uint, "insideSelection", 1,
9885 		uint, "isText", 1,
9886 		uint, "", 24
9887 	));
9888 	union
9889 	{
9890 		GdkRGBA*[2] rgba;
9891 		uint[4] padding;
9892 	}
9893 }
9894 
9895 struct GtkTextAttributes
9896 {
9897 	uint refcount;
9898 	/**
9899 	 * #GtkTextAppearance for text.
9900 	 */
9901 	GtkTextAppearance appearance;
9902 	/**
9903 	 * #GtkJustification for text.
9904 	 */
9905 	GtkJustification justification;
9906 	/**
9907 	 * #GtkTextDirection for text.
9908 	 */
9909 	GtkTextDirection direction;
9910 	/**
9911 	 * #PangoFontDescription for text.
9912 	 */
9913 	PangoFontDescription* font;
9914 	/**
9915 	 * Font scale factor.
9916 	 */
9917 	double fontScale;
9918 	/**
9919 	 * Width of the left margin in pixels.
9920 	 */
9921 	int leftMargin;
9922 	/**
9923 	 * Width of the right margin in pixels.
9924 	 */
9925 	int rightMargin;
9926 	/**
9927 	 * Amount to indent the paragraph, in pixels.
9928 	 */
9929 	int indent;
9930 	/**
9931 	 * Pixels of blank space above paragraphs.
9932 	 */
9933 	int pixelsAboveLines;
9934 	/**
9935 	 * Pixels of blank space below paragraphs.
9936 	 */
9937 	int pixelsBelowLines;
9938 	/**
9939 	 * Pixels of blank space between wrapped lines in
9940 	 * a paragraph.
9941 	 */
9942 	int pixelsInsideWrap;
9943 	/**
9944 	 * Custom #PangoTabArray for this text.
9945 	 */
9946 	PangoTabArray* tabs;
9947 	/**
9948 	 * #GtkWrapMode for text.
9949 	 */
9950 	GtkWrapMode wrapMode;
9951 	/**
9952 	 * #PangoLanguage for text.
9953 	 */
9954 	PangoLanguage* language;
9955 	GdkColor* pgBgColor;
9956 	import std.bitmanip: bitfields;
9957 	mixin(bitfields!(
9958 		uint, "invisible", 1,
9959 		uint, "bgFullHeight", 1,
9960 		uint, "editable", 1,
9961 		uint, "noFallback", 1,
9962 		uint, "", 28
9963 	));
9964 	GdkRGBA* pgBgRgba;
9965 	/**
9966 	 * Extra space to insert between graphemes, in Pango units
9967 	 */
9968 	int letterSpacing;
9969 	union
9970 	{
9971 		char* fontFeatures;
9972 		uint[2] padding;
9973 	}
9974 }
9975 
9976 struct GtkTextBTree;
9977 
9978 struct GtkTextBuffer
9979 {
9980 	GObject parentInstance;
9981 	GtkTextBufferPrivate* priv;
9982 }
9983 
9984 struct GtkTextBufferClass
9985 {
9986 	/**
9987 	 * The object class structure needs to be the first.
9988 	 */
9989 	GObjectClass parentClass;
9990 	/** */
9991 	extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* pos, const(char)* newText, int newTextLength) insertText;
9992 	/** */
9993 	extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* iter, GdkPixbuf* pixbuf) insertPixbuf;
9994 	/** */
9995 	extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* iter, GtkTextChildAnchor* anchor) insertChildAnchor;
9996 	/** */
9997 	extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* start, GtkTextIter* end) deleteRange;
9998 	/** */
9999 	extern(C) void function(GtkTextBuffer* buffer) changed;
10000 	/** */
10001 	extern(C) void function(GtkTextBuffer* buffer) modifiedChanged;
10002 	/** */
10003 	extern(C) void function(GtkTextBuffer* buffer, GtkTextIter* location, GtkTextMark* mark) markSet;
10004 	/** */
10005 	extern(C) void function(GtkTextBuffer* buffer, GtkTextMark* mark) markDeleted;
10006 	/** */
10007 	extern(C) void function(GtkTextBuffer* buffer, GtkTextTag* tag, GtkTextIter* start, GtkTextIter* end) applyTag;
10008 	/** */
10009 	extern(C) void function(GtkTextBuffer* buffer, GtkTextTag* tag, GtkTextIter* start, GtkTextIter* end) removeTag;
10010 	/** */
10011 	extern(C) void function(GtkTextBuffer* buffer) beginUserAction;
10012 	/** */
10013 	extern(C) void function(GtkTextBuffer* buffer) endUserAction;
10014 	/** */
10015 	extern(C) void function(GtkTextBuffer* buffer, GtkClipboard* clipboard) pasteDone;
10016 	/** */
10017 	extern(C) void function() GtkReserved1;
10018 	/** */
10019 	extern(C) void function() GtkReserved2;
10020 	/** */
10021 	extern(C) void function() GtkReserved3;
10022 	/** */
10023 	extern(C) void function() GtkReserved4;
10024 }
10025 
10026 struct GtkTextBufferPrivate;
10027 
10028 struct GtkTextCellAccessible
10029 {
10030 	GtkRendererCellAccessible parent;
10031 	GtkTextCellAccessiblePrivate* priv;
10032 }
10033 
10034 struct GtkTextCellAccessibleClass
10035 {
10036 	GtkRendererCellAccessibleClass parentClass;
10037 }
10038 
10039 struct GtkTextCellAccessiblePrivate;
10040 
10041 struct GtkTextChildAnchor
10042 {
10043 	GObject parentInstance;
10044 	void* segment;
10045 }
10046 
10047 struct GtkTextChildAnchorClass
10048 {
10049 	GObjectClass parentClass;
10050 	/** */
10051 	extern(C) void function() GtkReserved1;
10052 	/** */
10053 	extern(C) void function() GtkReserved2;
10054 	/** */
10055 	extern(C) void function() GtkReserved3;
10056 	/** */
10057 	extern(C) void function() GtkReserved4;
10058 }
10059 
10060 struct GtkTextIter
10061 {
10062 	void* dummy1;
10063 	void* dummy2;
10064 	int dummy3;
10065 	int dummy4;
10066 	int dummy5;
10067 	int dummy6;
10068 	int dummy7;
10069 	int dummy8;
10070 	void* dummy9;
10071 	void* dummy10;
10072 	int dummy11;
10073 	int dummy12;
10074 	int dummy13;
10075 	void* dummy14;
10076 }
10077 
10078 struct GtkTextMark
10079 {
10080 	GObject parentInstance;
10081 	void* segment;
10082 }
10083 
10084 struct GtkTextMarkClass
10085 {
10086 	GObjectClass parentClass;
10087 	/** */
10088 	extern(C) void function() GtkReserved1;
10089 	/** */
10090 	extern(C) void function() GtkReserved2;
10091 	/** */
10092 	extern(C) void function() GtkReserved3;
10093 	/** */
10094 	extern(C) void function() GtkReserved4;
10095 }
10096 
10097 struct GtkTextTag
10098 {
10099 	GObject parentInstance;
10100 	GtkTextTagPrivate* priv;
10101 }
10102 
10103 struct GtkTextTagClass
10104 {
10105 	GObjectClass parentClass;
10106 	/**
10107 	 *
10108 	 * Params:
10109 	 *     tag = a #GtkTextTag
10110 	 *     eventObject = object that received the event, such as a widget
10111 	 *     event = the event
10112 	 *     iter = location where the event was received
10113 	 * Returns: result of signal emission (whether the event was handled)
10114 	 */
10115 	extern(C) int function(GtkTextTag* tag, GObject* eventObject, GdkEvent* event, GtkTextIter* iter) event;
10116 	/** */
10117 	extern(C) void function() GtkReserved1;
10118 	/** */
10119 	extern(C) void function() GtkReserved2;
10120 	/** */
10121 	extern(C) void function() GtkReserved3;
10122 	/** */
10123 	extern(C) void function() GtkReserved4;
10124 }
10125 
10126 struct GtkTextTagPrivate;
10127 
10128 struct GtkTextTagTable
10129 {
10130 	GObject parentInstance;
10131 	GtkTextTagTablePrivate* priv;
10132 }
10133 
10134 struct GtkTextTagTableClass
10135 {
10136 	GObjectClass parentClass;
10137 	/** */
10138 	extern(C) void function(GtkTextTagTable* table, GtkTextTag* tag, int sizeChanged) tagChanged;
10139 	/** */
10140 	extern(C) void function(GtkTextTagTable* table, GtkTextTag* tag) tagAdded;
10141 	/** */
10142 	extern(C) void function(GtkTextTagTable* table, GtkTextTag* tag) tagRemoved;
10143 	/** */
10144 	extern(C) void function() GtkReserved1;
10145 	/** */
10146 	extern(C) void function() GtkReserved2;
10147 	/** */
10148 	extern(C) void function() GtkReserved3;
10149 	/** */
10150 	extern(C) void function() GtkReserved4;
10151 }
10152 
10153 struct GtkTextTagTablePrivate;
10154 
10155 struct GtkTextView
10156 {
10157 	GtkContainer parentInstance;
10158 	GtkTextViewPrivate* priv;
10159 }
10160 
10161 struct GtkTextViewAccessible
10162 {
10163 	GtkContainerAccessible parent;
10164 	GtkTextViewAccessiblePrivate* priv;
10165 }
10166 
10167 struct GtkTextViewAccessibleClass
10168 {
10169 	GtkContainerAccessibleClass parentClass;
10170 }
10171 
10172 struct GtkTextViewAccessiblePrivate;
10173 
10174 struct GtkTextViewClass
10175 {
10176 	/**
10177 	 * The object class structure needs to be the first
10178 	 */
10179 	GtkContainerClass parentClass;
10180 	/** */
10181 	extern(C) void function(GtkTextView* textView, GtkWidget* popup) populatePopup;
10182 	/** */
10183 	extern(C) void function(GtkTextView* textView, GtkMovementStep step, int count, int extendSelection) moveCursor;
10184 	/** */
10185 	extern(C) void function(GtkTextView* textView) setAnchor;
10186 	/** */
10187 	extern(C) void function(GtkTextView* textView, const(char)* str) insertAtCursor;
10188 	/** */
10189 	extern(C) void function(GtkTextView* textView, GtkDeleteType type, int count) deleteFromCursor;
10190 	/** */
10191 	extern(C) void function(GtkTextView* textView) backspace;
10192 	/** */
10193 	extern(C) void function(GtkTextView* textView) cutClipboard;
10194 	/** */
10195 	extern(C) void function(GtkTextView* textView) copyClipboard;
10196 	/** */
10197 	extern(C) void function(GtkTextView* textView) pasteClipboard;
10198 	/** */
10199 	extern(C) void function(GtkTextView* textView) toggleOverwrite;
10200 	/** */
10201 	extern(C) GtkTextBuffer* function(GtkTextView* textView) createBuffer;
10202 	/** */
10203 	extern(C) void function(GtkTextView* textView, GtkTextViewLayer layer, cairo_t* cr) drawLayer;
10204 	/** */
10205 	extern(C) int function(GtkTextView* textView, GtkTextExtendSelection granularity, GtkTextIter* location, GtkTextIter* start, GtkTextIter* end) extendSelection;
10206 	/** */
10207 	extern(C) void function(GtkTextView* textView) insertEmoji;
10208 	/** */
10209 	extern(C) void function() GtkReserved1;
10210 	/** */
10211 	extern(C) void function() GtkReserved2;
10212 	/** */
10213 	extern(C) void function() GtkReserved3;
10214 	/** */
10215 	extern(C) void function() GtkReserved4;
10216 }
10217 
10218 struct GtkTextViewPrivate;
10219 
10220 struct GtkThemeEngine;
10221 
10222 struct GtkThemingEngine
10223 {
10224 	GObject parentObject;
10225 	GtkThemingEnginePrivate* priv;
10226 }
10227 
10228 /**
10229  * Base class for theming engines.
10230  */
10231 struct GtkThemingEngineClass
10232 {
10233 	/**
10234 	 * The parent class.
10235 	 */
10236 	GObjectClass parentClass;
10237 	/** */
10238 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x0, double y0, double x1, double y1) renderLine;
10239 	/** */
10240 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderBackground;
10241 	/** */
10242 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderFrame;
10243 	/** */
10244 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height, GtkPositionType gapSide, double xy0Gap, double xy1Gap) renderFrameGap;
10245 	/** */
10246 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height, GtkPositionType gapSide) renderExtension;
10247 	/** */
10248 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderCheck;
10249 	/** */
10250 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderOption;
10251 	/** */
10252 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double angle, double x, double y, double size) renderArrow;
10253 	/** */
10254 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderExpander;
10255 	/** */
10256 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderFocus;
10257 	/** */
10258 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, PangoLayout* layout) renderLayout;
10259 	/** */
10260 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height, GtkOrientation orientation) renderSlider;
10261 	/** */
10262 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderHandle;
10263 	/** */
10264 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, double x, double y, double width, double height) renderActivity;
10265 	/** */
10266 	extern(C) GdkPixbuf* function(GtkThemingEngine* engine, GtkIconSource* source, GtkIconSize size) renderIconPixbuf;
10267 	/** */
10268 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, GdkPixbuf* pixbuf, double x, double y) renderIcon;
10269 	/** */
10270 	extern(C) void function(GtkThemingEngine* engine, cairo_t* cr, cairo_surface_t* surface, double x, double y) renderIconSurface;
10271 	void*[14] padding;
10272 }
10273 
10274 struct GtkThemingEnginePrivate;
10275 
10276 struct GtkToggleAction
10277 {
10278 	GtkAction parent;
10279 	GtkToggleActionPrivate* privateData;
10280 }
10281 
10282 struct GtkToggleActionClass
10283 {
10284 	GtkActionClass parentClass;
10285 	/** */
10286 	extern(C) void function(GtkToggleAction* action) toggled;
10287 	/** */
10288 	extern(C) void function() GtkReserved1;
10289 	/** */
10290 	extern(C) void function() GtkReserved2;
10291 	/** */
10292 	extern(C) void function() GtkReserved3;
10293 	/** */
10294 	extern(C) void function() GtkReserved4;
10295 }
10296 
10297 /**
10298  * #GtkToggleActionEntry structs are used with
10299  * gtk_action_group_add_toggle_actions() to construct toggle actions.
10300  */
10301 struct GtkToggleActionEntry
10302 {
10303 	/**
10304 	 * The name of the action.
10305 	 */
10306 	const(char)* name;
10307 	/**
10308 	 * The stock id for the action, or the name of an icon from the
10309 	 * icon theme.
10310 	 */
10311 	const(char)* stockId;
10312 	/**
10313 	 * The label for the action. This field should typically be marked
10314 	 * for translation, see gtk_action_group_set_translation_domain().
10315 	 */
10316 	const(char)* label;
10317 	/**
10318 	 * The accelerator for the action, in the format understood by
10319 	 * gtk_accelerator_parse().
10320 	 */
10321 	const(char)* accelerator;
10322 	/**
10323 	 * The tooltip for the action. This field should typically be
10324 	 * marked for translation, see gtk_action_group_set_translation_domain().
10325 	 */
10326 	const(char)* tooltip;
10327 	/**
10328 	 * The function to call when the action is activated.
10329 	 */
10330 	GCallback callback;
10331 	/**
10332 	 * The initial state of the toggle action.
10333 	 */
10334 	bool isActive;
10335 }
10336 
10337 struct GtkToggleActionPrivate;
10338 
10339 struct GtkToggleButton
10340 {
10341 	GtkButton button;
10342 	GtkToggleButtonPrivate* priv;
10343 }
10344 
10345 struct GtkToggleButtonAccessible
10346 {
10347 	GtkButtonAccessible parent;
10348 	GtkToggleButtonAccessiblePrivate* priv;
10349 }
10350 
10351 struct GtkToggleButtonAccessibleClass
10352 {
10353 	GtkButtonAccessibleClass parentClass;
10354 }
10355 
10356 struct GtkToggleButtonAccessiblePrivate;
10357 
10358 struct GtkToggleButtonClass
10359 {
10360 	GtkButtonClass parentClass;
10361 	/** */
10362 	extern(C) void function(GtkToggleButton* toggleButton) toggled;
10363 	/** */
10364 	extern(C) void function() GtkReserved1;
10365 	/** */
10366 	extern(C) void function() GtkReserved2;
10367 	/** */
10368 	extern(C) void function() GtkReserved3;
10369 	/** */
10370 	extern(C) void function() GtkReserved4;
10371 }
10372 
10373 struct GtkToggleButtonPrivate;
10374 
10375 struct GtkToggleToolButton
10376 {
10377 	GtkToolButton parent;
10378 	GtkToggleToolButtonPrivate* priv;
10379 }
10380 
10381 struct GtkToggleToolButtonClass
10382 {
10383 	/**
10384 	 * The parent class.
10385 	 */
10386 	GtkToolButtonClass parentClass;
10387 	/** */
10388 	extern(C) void function(GtkToggleToolButton* button) toggled;
10389 	/** */
10390 	extern(C) void function() GtkReserved1;
10391 	/** */
10392 	extern(C) void function() GtkReserved2;
10393 	/** */
10394 	extern(C) void function() GtkReserved3;
10395 	/** */
10396 	extern(C) void function() GtkReserved4;
10397 }
10398 
10399 struct GtkToggleToolButtonPrivate;
10400 
10401 struct GtkToolButton
10402 {
10403 	GtkToolItem parent;
10404 	GtkToolButtonPrivate* priv;
10405 }
10406 
10407 struct GtkToolButtonClass
10408 {
10409 	/**
10410 	 * The parent class.
10411 	 */
10412 	GtkToolItemClass parentClass;
10413 	GType buttonType;
10414 	/** */
10415 	extern(C) void function(GtkToolButton* toolItem) clicked;
10416 	/** */
10417 	extern(C) void function() GtkReserved1;
10418 	/** */
10419 	extern(C) void function() GtkReserved2;
10420 	/** */
10421 	extern(C) void function() GtkReserved3;
10422 	/** */
10423 	extern(C) void function() GtkReserved4;
10424 }
10425 
10426 struct GtkToolButtonPrivate;
10427 
10428 struct GtkToolItem
10429 {
10430 	GtkBin parent;
10431 	GtkToolItemPrivate* priv;
10432 }
10433 
10434 struct GtkToolItemClass
10435 {
10436 	/**
10437 	 * The parent class.
10438 	 */
10439 	GtkBinClass parentClass;
10440 	/** */
10441 	extern(C) int function(GtkToolItem* toolItem) createMenuProxy;
10442 	/** */
10443 	extern(C) void function(GtkToolItem* toolItem) toolbarReconfigured;
10444 	/** */
10445 	extern(C) void function() GtkReserved1;
10446 	/** */
10447 	extern(C) void function() GtkReserved2;
10448 	/** */
10449 	extern(C) void function() GtkReserved3;
10450 	/** */
10451 	extern(C) void function() GtkReserved4;
10452 }
10453 
10454 struct GtkToolItemGroup
10455 {
10456 	GtkContainer parentInstance;
10457 	GtkToolItemGroupPrivate* priv;
10458 }
10459 
10460 struct GtkToolItemGroupClass
10461 {
10462 	/**
10463 	 * The parent class.
10464 	 */
10465 	GtkContainerClass parentClass;
10466 	/** */
10467 	extern(C) void function() GtkReserved1;
10468 	/** */
10469 	extern(C) void function() GtkReserved2;
10470 	/** */
10471 	extern(C) void function() GtkReserved3;
10472 	/** */
10473 	extern(C) void function() GtkReserved4;
10474 }
10475 
10476 struct GtkToolItemGroupPrivate;
10477 
10478 struct GtkToolItemPrivate;
10479 
10480 struct GtkToolPalette
10481 {
10482 	GtkContainer parentInstance;
10483 	GtkToolPalettePrivate* priv;
10484 }
10485 
10486 struct GtkToolPaletteClass
10487 {
10488 	/**
10489 	 * The parent class.
10490 	 */
10491 	GtkContainerClass parentClass;
10492 	/** */
10493 	extern(C) void function() GtkReserved1;
10494 	/** */
10495 	extern(C) void function() GtkReserved2;
10496 	/** */
10497 	extern(C) void function() GtkReserved3;
10498 	/** */
10499 	extern(C) void function() GtkReserved4;
10500 }
10501 
10502 struct GtkToolPalettePrivate;
10503 
10504 struct GtkToolShell;
10505 
10506 /**
10507  * Virtual function table for the #GtkToolShell interface.
10508  */
10509 struct GtkToolShellIface
10510 {
10511 	GTypeInterface gIface;
10512 	/** */
10513 	extern(C) GtkIconSize function(GtkToolShell* shell) getIconSize;
10514 	/**
10515 	 *
10516 	 * Params:
10517 	 *     shell = a #GtkToolShell
10518 	 * Returns: the current orientation of @shell
10519 	 */
10520 	extern(C) GtkOrientation function(GtkToolShell* shell) getOrientation;
10521 	/**
10522 	 *
10523 	 * Params:
10524 	 *     shell = a #GtkToolShell
10525 	 * Returns: the current style of @shell
10526 	 */
10527 	extern(C) GtkToolbarStyle function(GtkToolShell* shell) getStyle;
10528 	/**
10529 	 *
10530 	 * Params:
10531 	 *     shell = a #GtkToolShell
10532 	 * Returns: The relief style of buttons on @shell.
10533 	 */
10534 	extern(C) GtkReliefStyle function(GtkToolShell* shell) getReliefStyle;
10535 	/** */
10536 	extern(C) void function(GtkToolShell* shell) rebuildMenu;
10537 	/**
10538 	 *
10539 	 * Params:
10540 	 *     shell = a #GtkToolShell
10541 	 * Returns: the current text orientation of @shell
10542 	 */
10543 	extern(C) GtkOrientation function(GtkToolShell* shell) getTextOrientation;
10544 	/**
10545 	 *
10546 	 * Params:
10547 	 *     shell = a #GtkToolShell
10548 	 * Returns: the current text alignment of @shell
10549 	 */
10550 	extern(C) float function(GtkToolShell* shell) getTextAlignment;
10551 	/**
10552 	 *
10553 	 * Params:
10554 	 *     shell = a #GtkToolShell
10555 	 * Returns: the current ellipsize mode of @shell
10556 	 */
10557 	extern(C) PangoEllipsizeMode function(GtkToolShell* shell) getEllipsizeMode;
10558 	/**
10559 	 *
10560 	 * Params:
10561 	 *     shell = a #GtkToolShell
10562 	 * Returns: the current text size group of @shell
10563 	 */
10564 	extern(C) GtkSizeGroup* function(GtkToolShell* shell) getTextSizeGroup;
10565 }
10566 
10567 struct GtkToolbar
10568 {
10569 	GtkContainer container;
10570 	GtkToolbarPrivate* priv;
10571 }
10572 
10573 struct GtkToolbarClass
10574 {
10575 	GtkContainerClass parentClass;
10576 	/** */
10577 	extern(C) void function(GtkToolbar* toolbar, GtkOrientation orientation) orientationChanged;
10578 	/** */
10579 	extern(C) void function(GtkToolbar* toolbar, GtkToolbarStyle style) styleChanged;
10580 	/** */
10581 	extern(C) int function(GtkToolbar* toolbar, int x, int y, int buttonNumber) popupContextMenu;
10582 	/** */
10583 	extern(C) void function() GtkReserved1;
10584 	/** */
10585 	extern(C) void function() GtkReserved2;
10586 	/** */
10587 	extern(C) void function() GtkReserved3;
10588 	/** */
10589 	extern(C) void function() GtkReserved4;
10590 }
10591 
10592 struct GtkToolbarPrivate;
10593 
10594 struct GtkTooltip;
10595 
10596 struct GtkToplevelAccessible
10597 {
10598 	AtkObject parent;
10599 	GtkToplevelAccessiblePrivate* priv;
10600 }
10601 
10602 struct GtkToplevelAccessibleClass
10603 {
10604 	AtkObjectClass parentClass;
10605 }
10606 
10607 struct GtkToplevelAccessiblePrivate;
10608 
10609 struct GtkTreeDragDest;
10610 
10611 struct GtkTreeDragDestIface
10612 {
10613 	GTypeInterface gIface;
10614 	/**
10615 	 *
10616 	 * Params:
10617 	 *     dragDest = a #GtkTreeDragDest
10618 	 *     dest = row to drop in front of
10619 	 *     selectionData = data to drop
10620 	 * Returns: whether a new row was created before position @dest
10621 	 */
10622 	extern(C) int function(GtkTreeDragDest* dragDest, GtkTreePath* dest, GtkSelectionData* selectionData) dragDataReceived;
10623 	/**
10624 	 *
10625 	 * Params:
10626 	 *     dragDest = a #GtkTreeDragDest
10627 	 *     destPath = destination row
10628 	 *     selectionData = the data being dragged
10629 	 * Returns: %TRUE if a drop is possible before @dest_path
10630 	 */
10631 	extern(C) int function(GtkTreeDragDest* dragDest, GtkTreePath* destPath, GtkSelectionData* selectionData) rowDropPossible;
10632 }
10633 
10634 struct GtkTreeDragSource;
10635 
10636 struct GtkTreeDragSourceIface
10637 {
10638 	GTypeInterface gIface;
10639 	/**
10640 	 *
10641 	 * Params:
10642 	 *     dragSource = a #GtkTreeDragSource
10643 	 *     path = row on which user is initiating a drag
10644 	 * Returns: %TRUE if the row can be dragged
10645 	 */
10646 	extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path) rowDraggable;
10647 	/**
10648 	 *
10649 	 * Params:
10650 	 *     dragSource = a #GtkTreeDragSource
10651 	 *     path = row that was dragged
10652 	 *     selectionData = a #GtkSelectionData to fill with data
10653 	 *         from the dragged row
10654 	 * Returns: %TRUE if data of the required type was provided
10655 	 */
10656 	extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path, GtkSelectionData* selectionData) dragDataGet;
10657 	/**
10658 	 *
10659 	 * Params:
10660 	 *     dragSource = a #GtkTreeDragSource
10661 	 *     path = row that was being dragged
10662 	 * Returns: %TRUE if the row was successfully deleted
10663 	 */
10664 	extern(C) int function(GtkTreeDragSource* dragSource, GtkTreePath* path) dragDataDelete;
10665 }
10666 
10667 struct GtkTreeIter
10668 {
10669 	/**
10670 	 * a unique stamp to catch invalid iterators
10671 	 */
10672 	int stamp;
10673 	/**
10674 	 * model-specific data
10675 	 */
10676 	void* userData;
10677 	/**
10678 	 * model-specific data
10679 	 */
10680 	void* userData2;
10681 	/**
10682 	 * model-specific data
10683 	 */
10684 	void* userData3;
10685 }
10686 
10687 struct GtkTreeModel;
10688 
10689 struct GtkTreeModelFilter
10690 {
10691 	GObject parent;
10692 	GtkTreeModelFilterPrivate* priv;
10693 }
10694 
10695 struct GtkTreeModelFilterClass
10696 {
10697 	GObjectClass parentClass;
10698 	/** */
10699 	extern(C) int function(GtkTreeModelFilter* self, GtkTreeModel* childModel, GtkTreeIter* iter) visible;
10700 	/** */
10701 	extern(C) void function(GtkTreeModelFilter* self, GtkTreeModel* childModel, GtkTreeIter* iter, GValue* value, int column) modify;
10702 	/** */
10703 	extern(C) void function() GtkReserved1;
10704 	/** */
10705 	extern(C) void function() GtkReserved2;
10706 	/** */
10707 	extern(C) void function() GtkReserved3;
10708 	/** */
10709 	extern(C) void function() GtkReserved4;
10710 }
10711 
10712 struct GtkTreeModelFilterPrivate;
10713 
10714 struct GtkTreeModelIface
10715 {
10716 	GTypeInterface gIface;
10717 	/** */
10718 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter) rowChanged;
10719 	/** */
10720 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter) rowInserted;
10721 	/** */
10722 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter) rowHasChildToggled;
10723 	/** */
10724 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path) rowDeleted;
10725 	/** */
10726 	extern(C) void function(GtkTreeModel* treeModel, GtkTreePath* path, GtkTreeIter* iter, int* newOrder) rowsReordered;
10727 	/**
10728 	 *
10729 	 * Params:
10730 	 *     treeModel = a #GtkTreeModel
10731 	 * Returns: the flags supported by this interface
10732 	 */
10733 	extern(C) GtkTreeModelFlags function(GtkTreeModel* treeModel) getFlags;
10734 	/**
10735 	 *
10736 	 * Params:
10737 	 *     treeModel = a #GtkTreeModel
10738 	 * Returns: the number of columns
10739 	 */
10740 	extern(C) int function(GtkTreeModel* treeModel) getNColumns;
10741 	/**
10742 	 *
10743 	 * Params:
10744 	 *     treeModel = a #GtkTreeModel
10745 	 *     index = the column index
10746 	 * Returns: the type of the column
10747 	 */
10748 	extern(C) GType function(GtkTreeModel* treeModel, int index) getColumnType;
10749 	/**
10750 	 *
10751 	 * Params:
10752 	 *     treeModel = a #GtkTreeModel
10753 	 *     iter = the uninitialized #GtkTreeIter-struct
10754 	 *     path = the #GtkTreePath-struct
10755 	 * Returns: %TRUE, if @iter was set
10756 	 */
10757 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreePath* path) getIter;
10758 	/**
10759 	 *
10760 	 * Params:
10761 	 *     treeModel = a #GtkTreeModel
10762 	 *     iter = the #GtkTreeIter-struct
10763 	 * Returns: a newly-created #GtkTreePath-struct
10764 	 */
10765 	extern(C) GtkTreePath* function(GtkTreeModel* treeModel, GtkTreeIter* iter) getPath;
10766 	/** */
10767 	extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter, int column, GValue* value) getValue;
10768 	/**
10769 	 *
10770 	 * Params:
10771 	 *     treeModel = a #GtkTreeModel
10772 	 *     iter = the #GtkTreeIter-struct
10773 	 * Returns: %TRUE if @iter has been changed to the next node
10774 	 */
10775 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterNext;
10776 	/**
10777 	 *
10778 	 * Params:
10779 	 *     treeModel = a #GtkTreeModel
10780 	 *     iter = the #GtkTreeIter-struct
10781 	 * Returns: %TRUE if @iter has been changed to the previous node
10782 	 */
10783 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterPrevious;
10784 	/**
10785 	 *
10786 	 * Params:
10787 	 *     treeModel = a #GtkTreeModel
10788 	 *     iter = the new #GtkTreeIter-struct to be set to the child
10789 	 *     parent = the #GtkTreeIter-struct, or %NULL
10790 	 * Returns: %TRUE, if @iter has been set to the first child
10791 	 */
10792 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* parent) iterChildren;
10793 	/**
10794 	 *
10795 	 * Params:
10796 	 *     treeModel = a #GtkTreeModel
10797 	 *     iter = the #GtkTreeIter-struct to test for children
10798 	 * Returns: %TRUE if @iter has children
10799 	 */
10800 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterHasChild;
10801 	/**
10802 	 *
10803 	 * Params:
10804 	 *     treeModel = a #GtkTreeModel
10805 	 *     iter = the #GtkTreeIter-struct, or %NULL
10806 	 * Returns: the number of children of @iter
10807 	 */
10808 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter) iterNChildren;
10809 	/**
10810 	 *
10811 	 * Params:
10812 	 *     treeModel = a #GtkTreeModel
10813 	 *     iter = the #GtkTreeIter-struct to set to the nth child
10814 	 *     parent = the #GtkTreeIter-struct to get the child from, or %NULL.
10815 	 *     n = the index of the desired child
10816 	 * Returns: %TRUE, if @parent has an @n-th child
10817 	 */
10818 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* parent, int n) iterNthChild;
10819 	/**
10820 	 *
10821 	 * Params:
10822 	 *     treeModel = a #GtkTreeModel
10823 	 *     iter = the new #GtkTreeIter-struct to set to the parent
10824 	 *     child = the #GtkTreeIter-struct
10825 	 * Returns: %TRUE, if @iter is set to the parent of @child
10826 	 */
10827 	extern(C) int function(GtkTreeModel* treeModel, GtkTreeIter* iter, GtkTreeIter* child) iterParent;
10828 	/** */
10829 	extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter) refNode;
10830 	/** */
10831 	extern(C) void function(GtkTreeModel* treeModel, GtkTreeIter* iter) unrefNode;
10832 }
10833 
10834 struct GtkTreeModelSort
10835 {
10836 	GObject parent;
10837 	GtkTreeModelSortPrivate* priv;
10838 }
10839 
10840 struct GtkTreeModelSortClass
10841 {
10842 	GObjectClass parentClass;
10843 	/** */
10844 	extern(C) void function() GtkReserved1;
10845 	/** */
10846 	extern(C) void function() GtkReserved2;
10847 	/** */
10848 	extern(C) void function() GtkReserved3;
10849 	/** */
10850 	extern(C) void function() GtkReserved4;
10851 }
10852 
10853 struct GtkTreeModelSortPrivate;
10854 
10855 struct GtkTreePath;
10856 
10857 struct GtkTreeRowReference;
10858 
10859 struct GtkTreeSelection
10860 {
10861 	GObject parent;
10862 	GtkTreeSelectionPrivate* priv;
10863 }
10864 
10865 struct GtkTreeSelectionClass
10866 {
10867 	/**
10868 	 * The parent class.
10869 	 */
10870 	GObjectClass parentClass;
10871 	/** */
10872 	extern(C) void function(GtkTreeSelection* selection) changed;
10873 	/** */
10874 	extern(C) void function() GtkReserved1;
10875 	/** */
10876 	extern(C) void function() GtkReserved2;
10877 	/** */
10878 	extern(C) void function() GtkReserved3;
10879 	/** */
10880 	extern(C) void function() GtkReserved4;
10881 }
10882 
10883 struct GtkTreeSelectionPrivate;
10884 
10885 struct GtkTreeSortable;
10886 
10887 struct GtkTreeSortableIface
10888 {
10889 	GTypeInterface gIface;
10890 	/** */
10891 	extern(C) void function(GtkTreeSortable* sortable) sortColumnChanged;
10892 	/**
10893 	 *
10894 	 * Params:
10895 	 *     sortable = A #GtkTreeSortable
10896 	 *     sortColumnId = The sort column id to be filled in
10897 	 *     order = The #GtkSortType to be filled in
10898 	 * Returns: %TRUE if the sort column is not one of the special sort
10899 	 *     column ids.
10900 	 */
10901 	extern(C) int function(GtkTreeSortable* sortable, int* sortColumnId, GtkSortType* order) getSortColumnId;
10902 	/** */
10903 	extern(C) void function(GtkTreeSortable* sortable, int sortColumnId, GtkSortType order) setSortColumnId;
10904 	/** */
10905 	extern(C) void function(GtkTreeSortable* sortable, int sortColumnId, GtkTreeIterCompareFunc sortFunc, void* userData, GDestroyNotify destroy) setSortFunc;
10906 	/** */
10907 	extern(C) void function(GtkTreeSortable* sortable, GtkTreeIterCompareFunc sortFunc, void* userData, GDestroyNotify destroy) setDefaultSortFunc;
10908 	/**
10909 	 *
10910 	 * Params:
10911 	 *     sortable = A #GtkTreeSortable
10912 	 * Returns: %TRUE, if the model has a default sort function
10913 	 */
10914 	extern(C) int function(GtkTreeSortable* sortable) hasDefaultSortFunc;
10915 }
10916 
10917 struct GtkTreeStore
10918 {
10919 	GObject parent;
10920 	GtkTreeStorePrivate* priv;
10921 }
10922 
10923 struct GtkTreeStoreClass
10924 {
10925 	GObjectClass parentClass;
10926 	/** */
10927 	extern(C) void function() GtkReserved1;
10928 	/** */
10929 	extern(C) void function() GtkReserved2;
10930 	/** */
10931 	extern(C) void function() GtkReserved3;
10932 	/** */
10933 	extern(C) void function() GtkReserved4;
10934 }
10935 
10936 struct GtkTreeStorePrivate;
10937 
10938 struct GtkTreeView
10939 {
10940 	GtkContainer parent;
10941 	GtkTreeViewPrivate* priv;
10942 }
10943 
10944 struct GtkTreeViewAccessible
10945 {
10946 	GtkContainerAccessible parent;
10947 	GtkTreeViewAccessiblePrivate* priv;
10948 }
10949 
10950 struct GtkTreeViewAccessibleClass
10951 {
10952 	GtkContainerAccessibleClass parentClass;
10953 }
10954 
10955 struct GtkTreeViewAccessiblePrivate;
10956 
10957 struct GtkTreeViewClass
10958 {
10959 	GtkContainerClass parentClass;
10960 	/** */
10961 	extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, GtkTreeViewColumn* column) rowActivated;
10962 	/** */
10963 	extern(C) int function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) testExpandRow;
10964 	/** */
10965 	extern(C) int function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) testCollapseRow;
10966 	/** */
10967 	extern(C) void function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) rowExpanded;
10968 	/** */
10969 	extern(C) void function(GtkTreeView* treeView, GtkTreeIter* iter, GtkTreePath* path) rowCollapsed;
10970 	/** */
10971 	extern(C) void function(GtkTreeView* treeView) columnsChanged;
10972 	/** */
10973 	extern(C) void function(GtkTreeView* treeView) cursorChanged;
10974 	/** */
10975 	extern(C) int function(GtkTreeView* treeView, GtkMovementStep step, int count) moveCursor;
10976 	/** */
10977 	extern(C) int function(GtkTreeView* treeView) selectAll;
10978 	/** */
10979 	extern(C) int function(GtkTreeView* treeView) unselectAll;
10980 	/** */
10981 	extern(C) int function(GtkTreeView* treeView, int startEditing) selectCursorRow;
10982 	/** */
10983 	extern(C) int function(GtkTreeView* treeView) toggleCursorRow;
10984 	/** */
10985 	extern(C) int function(GtkTreeView* treeView, int logical, int expand, int openAll) expandCollapseCursorRow;
10986 	/** */
10987 	extern(C) int function(GtkTreeView* treeView) selectCursorParent;
10988 	/** */
10989 	extern(C) int function(GtkTreeView* treeView) startInteractiveSearch;
10990 	/** */
10991 	extern(C) void function() GtkReserved1;
10992 	/** */
10993 	extern(C) void function() GtkReserved2;
10994 	/** */
10995 	extern(C) void function() GtkReserved3;
10996 	/** */
10997 	extern(C) void function() GtkReserved4;
10998 	/** */
10999 	extern(C) void function() GtkReserved5;
11000 	/** */
11001 	extern(C) void function() GtkReserved6;
11002 	/** */
11003 	extern(C) void function() GtkReserved7;
11004 	/** */
11005 	extern(C) void function() GtkReserved8;
11006 }
11007 
11008 struct GtkTreeViewColumn
11009 {
11010 	GObject parentInstance;
11011 	GtkTreeViewColumnPrivate* priv;
11012 }
11013 
11014 struct GtkTreeViewColumnClass
11015 {
11016 	GObjectClass parentClass;
11017 	/** */
11018 	extern(C) void function(GtkTreeViewColumn* treeColumn) clicked;
11019 	/** */
11020 	extern(C) void function() GtkReserved1;
11021 	/** */
11022 	extern(C) void function() GtkReserved2;
11023 	/** */
11024 	extern(C) void function() GtkReserved3;
11025 	/** */
11026 	extern(C) void function() GtkReserved4;
11027 }
11028 
11029 struct GtkTreeViewColumnPrivate;
11030 
11031 struct GtkTreeViewPrivate;
11032 
11033 struct GtkUIManager
11034 {
11035 	GObject parent;
11036 	GtkUIManagerPrivate* privateData;
11037 }
11038 
11039 struct GtkUIManagerClass
11040 {
11041 	GObjectClass parentClass;
11042 	/** */
11043 	extern(C) void function(GtkUIManager* manager, GtkWidget* widget) addWidget;
11044 	/** */
11045 	extern(C) void function(GtkUIManager* manager) actionsChanged;
11046 	/** */
11047 	extern(C) void function(GtkUIManager* manager, GtkAction* action, GtkWidget* proxy) connectProxy;
11048 	/** */
11049 	extern(C) void function(GtkUIManager* manager, GtkAction* action, GtkWidget* proxy) disconnectProxy;
11050 	/** */
11051 	extern(C) void function(GtkUIManager* manager, GtkAction* action) preActivate;
11052 	/** */
11053 	extern(C) void function(GtkUIManager* manager, GtkAction* action) postActivate;
11054 	/**
11055 	 *
11056 	 * Params:
11057 	 *     manager = a #GtkUIManager
11058 	 *     path = a path
11059 	 * Returns: the widget found by following the path,
11060 	 *     or %NULL if no widget was found
11061 	 */
11062 	extern(C) GtkWidget* function(GtkUIManager* manager, const(char)* path) getWidget;
11063 	/**
11064 	 *
11065 	 * Params:
11066 	 *     manager = a #GtkUIManager
11067 	 *     path = a path
11068 	 * Returns: the action whose proxy widget is found by following the path,
11069 	 *     or %NULL if no widget was found.
11070 	 */
11071 	extern(C) GtkAction* function(GtkUIManager* manager, const(char)* path) getAction;
11072 	/** */
11073 	extern(C) void function() GtkReserved1;
11074 	/** */
11075 	extern(C) void function() GtkReserved2;
11076 	/** */
11077 	extern(C) void function() GtkReserved3;
11078 	/** */
11079 	extern(C) void function() GtkReserved4;
11080 }
11081 
11082 struct GtkUIManagerPrivate;
11083 
11084 struct GtkVBox
11085 {
11086 	GtkBox box;
11087 }
11088 
11089 struct GtkVBoxClass
11090 {
11091 	GtkBoxClass parentClass;
11092 }
11093 
11094 struct GtkVButtonBox
11095 {
11096 	GtkButtonBox buttonBox;
11097 }
11098 
11099 struct GtkVButtonBoxClass
11100 {
11101 	GtkButtonBoxClass parentClass;
11102 }
11103 
11104 struct GtkVPaned
11105 {
11106 	GtkPaned paned;
11107 }
11108 
11109 struct GtkVPanedClass
11110 {
11111 	GtkPanedClass parentClass;
11112 }
11113 
11114 struct GtkVScale
11115 {
11116 	GtkScale scale;
11117 }
11118 
11119 struct GtkVScaleClass
11120 {
11121 	GtkScaleClass parentClass;
11122 }
11123 
11124 struct GtkVScrollbar
11125 {
11126 	GtkScrollbar scrollbar;
11127 }
11128 
11129 struct GtkVScrollbarClass
11130 {
11131 	GtkScrollbarClass parentClass;
11132 }
11133 
11134 struct GtkVSeparator
11135 {
11136 	GtkSeparator separator;
11137 }
11138 
11139 struct GtkVSeparatorClass
11140 {
11141 	GtkSeparatorClass parentClass;
11142 }
11143 
11144 struct GtkViewport
11145 {
11146 	GtkBin bin;
11147 	GtkViewportPrivate* priv;
11148 }
11149 
11150 struct GtkViewportClass
11151 {
11152 	/**
11153 	 * The parent class.
11154 	 */
11155 	GtkBinClass parentClass;
11156 	/** */
11157 	extern(C) void function() GtkReserved1;
11158 	/** */
11159 	extern(C) void function() GtkReserved2;
11160 	/** */
11161 	extern(C) void function() GtkReserved3;
11162 	/** */
11163 	extern(C) void function() GtkReserved4;
11164 }
11165 
11166 struct GtkViewportPrivate;
11167 
11168 struct GtkVolumeButton
11169 {
11170 	GtkScaleButton parent;
11171 }
11172 
11173 struct GtkVolumeButtonClass
11174 {
11175 	GtkScaleButtonClass parentClass;
11176 	/** */
11177 	extern(C) void function() GtkReserved1;
11178 	/** */
11179 	extern(C) void function() GtkReserved2;
11180 	/** */
11181 	extern(C) void function() GtkReserved3;
11182 	/** */
11183 	extern(C) void function() GtkReserved4;
11184 }
11185 
11186 struct GtkWidget
11187 {
11188 	GObject parentInstance;
11189 	GtkWidgetPrivate* priv;
11190 }
11191 
11192 struct GtkWidgetAccessible
11193 {
11194 	GtkAccessible parent;
11195 	GtkWidgetAccessiblePrivate* priv;
11196 }
11197 
11198 struct GtkWidgetAccessibleClass
11199 {
11200 	GtkAccessibleClass parentClass;
11201 	/** */
11202 	extern(C) void function(GObject* object, GParamSpec* pspec) notifyGtk;
11203 }
11204 
11205 struct GtkWidgetAccessiblePrivate;
11206 
11207 struct GtkWidgetClass
11208 {
11209 	/**
11210 	 * The object class structure needs to be the first
11211 	 * element in the widget class structure in order for the class mechanism
11212 	 * to work correctly. This allows a GtkWidgetClass pointer to be cast to
11213 	 * a GObjectClass pointer.
11214 	 */
11215 	GObjectClass parentClass;
11216 	/**
11217 	 * The signal to emit when a widget of this class is
11218 	 * activated, gtk_widget_activate() handles the emission.
11219 	 * Implementation of this signal is optional.
11220 	 */
11221 	uint activateSignal;
11222 	/** */
11223 	extern(C) void function(GtkWidget* widget, uint nPspecs, GParamSpec** pspecs) dispatchChildPropertiesChanged;
11224 	/** */
11225 	extern(C) void function(GtkWidget* widget) destroy;
11226 	/** */
11227 	extern(C) void function(GtkWidget* widget) show;
11228 	/** */
11229 	extern(C) void function(GtkWidget* widget) showAll;
11230 	/** */
11231 	extern(C) void function(GtkWidget* widget) hide;
11232 	/** */
11233 	extern(C) void function(GtkWidget* widget) map;
11234 	/** */
11235 	extern(C) void function(GtkWidget* widget) unmap;
11236 	/** */
11237 	extern(C) void function(GtkWidget* widget) realize;
11238 	/** */
11239 	extern(C) void function(GtkWidget* widget) unrealize;
11240 	/** */
11241 	extern(C) void function(GtkWidget* widget, GtkAllocation* allocation) sizeAllocate;
11242 	/** */
11243 	extern(C) void function(GtkWidget* widget, GtkStateType previousState) stateChanged;
11244 	/** */
11245 	extern(C) void function(GtkWidget* widget, GtkStateFlags previousStateFlags) stateFlagsChanged;
11246 	/** */
11247 	extern(C) void function(GtkWidget* widget, GtkWidget* previousParent) parentSet;
11248 	/** */
11249 	extern(C) void function(GtkWidget* widget, GtkWidget* previousToplevel) hierarchyChanged;
11250 	/** */
11251 	extern(C) void function(GtkWidget* widget, GtkStyle* previousStyle) styleSet;
11252 	/** */
11253 	extern(C) void function(GtkWidget* widget, GtkTextDirection previousDirection) directionChanged;
11254 	/** */
11255 	extern(C) void function(GtkWidget* widget, int wasGrabbed) grabNotify;
11256 	/** */
11257 	extern(C) void function(GtkWidget* widget, GParamSpec* childProperty) childNotify;
11258 	/** */
11259 	extern(C) int function(GtkWidget* widget, cairo_t* cr) draw;
11260 	/**
11261 	 *
11262 	 * Params:
11263 	 *     widget = a #GtkWidget instance
11264 	 * Returns: The #GtkSizeRequestMode preferred by @widget.
11265 	 */
11266 	extern(C) GtkSizeRequestMode function(GtkWidget* widget) getRequestMode;
11267 	/** */
11268 	extern(C) void function(GtkWidget* widget, int* minimumHeight, int* naturalHeight) getPreferredHeight;
11269 	/** */
11270 	extern(C) void function(GtkWidget* widget, int height, int* minimumWidth, int* naturalWidth) getPreferredWidthForHeight;
11271 	/** */
11272 	extern(C) void function(GtkWidget* widget, int* minimumWidth, int* naturalWidth) getPreferredWidth;
11273 	/** */
11274 	extern(C) void function(GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight) getPreferredHeightForWidth;
11275 	/**
11276 	 *
11277 	 * Params:
11278 	 *     widget = a #GtkWidget
11279 	 *     groupCycling = %TRUE if there are other widgets with the same mnemonic
11280 	 * Returns: %TRUE if the signal has been handled
11281 	 */
11282 	extern(C) int function(GtkWidget* widget, int groupCycling) mnemonicActivate;
11283 	/** */
11284 	extern(C) void function(GtkWidget* widget) grabFocus;
11285 	/** */
11286 	extern(C) int function(GtkWidget* widget, GtkDirectionType direction) focus;
11287 	/** */
11288 	extern(C) void function(GtkWidget* widget, GtkDirectionType direction) moveFocus;
11289 	/**
11290 	 *
11291 	 * Params:
11292 	 *     widget = a #GtkWidget
11293 	 *     direction = direction of focus movement
11294 	 * Returns: %TRUE if stopping keyboard navigation is fine, %FALSE
11295 	 *     if the emitting widget should try to handle the keyboard
11296 	 *     navigation attempt in its parent container(s).
11297 	 */
11298 	extern(C) int function(GtkWidget* widget, GtkDirectionType direction) keynavFailed;
11299 	/**
11300 	 *
11301 	 * Params:
11302 	 *     widget = a #GtkWidget
11303 	 *     event = a #GdkEvent
11304 	 * Returns: return from the event signal emission (%TRUE if
11305 	 *     the event was handled)
11306 	 */
11307 	extern(C) int function(GtkWidget* widget, GdkEvent* event) event;
11308 	/** */
11309 	extern(C) int function(GtkWidget* widget, GdkEventButton* event) buttonPressEvent;
11310 	/** */
11311 	extern(C) int function(GtkWidget* widget, GdkEventButton* event) buttonReleaseEvent;
11312 	/** */
11313 	extern(C) int function(GtkWidget* widget, GdkEventScroll* event) scrollEvent;
11314 	/** */
11315 	extern(C) int function(GtkWidget* widget, GdkEventMotion* event) motionNotifyEvent;
11316 	/** */
11317 	extern(C) int function(GtkWidget* widget, GdkEventAny* event) deleteEvent;
11318 	/** */
11319 	extern(C) int function(GtkWidget* widget, GdkEventAny* event) destroyEvent;
11320 	/** */
11321 	extern(C) int function(GtkWidget* widget, GdkEventKey* event) keyPressEvent;
11322 	/** */
11323 	extern(C) int function(GtkWidget* widget, GdkEventKey* event) keyReleaseEvent;
11324 	/** */
11325 	extern(C) int function(GtkWidget* widget, GdkEventCrossing* event) enterNotifyEvent;
11326 	/** */
11327 	extern(C) int function(GtkWidget* widget, GdkEventCrossing* event) leaveNotifyEvent;
11328 	/** */
11329 	extern(C) int function(GtkWidget* widget, GdkEventConfigure* event) configureEvent;
11330 	/** */
11331 	extern(C) int function(GtkWidget* widget, GdkEventFocus* event) focusInEvent;
11332 	/** */
11333 	extern(C) int function(GtkWidget* widget, GdkEventFocus* event) focusOutEvent;
11334 	/** */
11335 	extern(C) int function(GtkWidget* widget, GdkEventAny* event) mapEvent;
11336 	/** */
11337 	extern(C) int function(GtkWidget* widget, GdkEventAny* event) unmapEvent;
11338 	/** */
11339 	extern(C) int function(GtkWidget* widget, GdkEventProperty* event) propertyNotifyEvent;
11340 	/** */
11341 	extern(C) int function(GtkWidget* widget, GdkEventSelection* event) selectionClearEvent;
11342 	/** */
11343 	extern(C) int function(GtkWidget* widget, GdkEventSelection* event) selectionRequestEvent;
11344 	/** */
11345 	extern(C) int function(GtkWidget* widget, GdkEventSelection* event) selectionNotifyEvent;
11346 	/** */
11347 	extern(C) int function(GtkWidget* widget, GdkEventProximity* event) proximityInEvent;
11348 	/** */
11349 	extern(C) int function(GtkWidget* widget, GdkEventProximity* event) proximityOutEvent;
11350 	/** */
11351 	extern(C) int function(GtkWidget* widget, GdkEventVisibility* event) visibilityNotifyEvent;
11352 	/** */
11353 	extern(C) int function(GtkWidget* widget, GdkEventWindowState* event) windowStateEvent;
11354 	/** */
11355 	extern(C) int function(GtkWidget* widget, GdkEventExpose* event) damageEvent;
11356 	/** */
11357 	extern(C) int function(GtkWidget* widget, GdkEventGrabBroken* event) grabBrokenEvent;
11358 	/** */
11359 	extern(C) void function(GtkWidget* widget, GtkSelectionData* selectionData, uint info, uint time) selectionGet;
11360 	/** */
11361 	extern(C) void function(GtkWidget* widget, GtkSelectionData* selectionData, uint time) selectionReceived;
11362 	/** */
11363 	extern(C) void function(GtkWidget* widget, GdkDragContext* context) dragBegin;
11364 	/** */
11365 	extern(C) void function(GtkWidget* widget, GdkDragContext* context) dragEnd;
11366 	/** */
11367 	extern(C) void function(GtkWidget* widget, GdkDragContext* context, GtkSelectionData* selectionData, uint info, uint time) dragDataGet;
11368 	/** */
11369 	extern(C) void function(GtkWidget* widget, GdkDragContext* context) dragDataDelete;
11370 	/** */
11371 	extern(C) void function(GtkWidget* widget, GdkDragContext* context, uint time) dragLeave;
11372 	/** */
11373 	extern(C) int function(GtkWidget* widget, GdkDragContext* context, int x, int y, uint time) dragMotion;
11374 	/** */
11375 	extern(C) int function(GtkWidget* widget, GdkDragContext* context, int x, int y, uint time) dragDrop;
11376 	/** */
11377 	extern(C) void function(GtkWidget* widget, GdkDragContext* context, int x, int y, GtkSelectionData* selectionData, uint info, uint time) dragDataReceived;
11378 	/** */
11379 	extern(C) int function(GtkWidget* widget, GdkDragContext* context, GtkDragResult result) dragFailed;
11380 	/** */
11381 	extern(C) int function(GtkWidget* widget) popupMenu;
11382 	/** */
11383 	extern(C) int function(GtkWidget* widget, GtkWidgetHelpType helpType) showHelp;
11384 	/**
11385 	 *
11386 	 * Params:
11387 	 *     widget = a #GtkWidget
11388 	 * Returns: the #AtkObject associated with @widget
11389 	 */
11390 	extern(C) AtkObject* function(GtkWidget* widget) getAccessible;
11391 	/** */
11392 	extern(C) void function(GtkWidget* widget, GdkScreen* previousScreen) screenChanged;
11393 	/**
11394 	 *
11395 	 * Params:
11396 	 *     widget = a #GtkWidget
11397 	 *     signalId = the ID of a signal installed on @widget
11398 	 * Returns: %TRUE if the accelerator can be activated.
11399 	 */
11400 	extern(C) int function(GtkWidget* widget, uint signalId) canActivateAccel;
11401 	/** */
11402 	extern(C) void function(GtkWidget* widget) compositedChanged;
11403 	/** */
11404 	extern(C) int function(GtkWidget* widget, int x, int y, int keyboardTooltip, GtkTooltip* tooltip) queryTooltip;
11405 	/** */
11406 	extern(C) void function(GtkWidget* widget, int* hexpandP, int* vexpandP) computeExpand;
11407 	/** */
11408 	extern(C) void function(GtkWidget* widget, GtkOrientation orientation, int* minimumSize, int* naturalSize) adjustSizeRequest;
11409 	/** */
11410 	extern(C) void function(GtkWidget* widget, GtkOrientation orientation, int* minimumSize, int* naturalSize, int* allocatedPos, int* allocatedSize) adjustSizeAllocation;
11411 	/** */
11412 	extern(C) void function(GtkWidget* widget) styleUpdated;
11413 	/** */
11414 	extern(C) int function(GtkWidget* widget, GdkEventTouch* event) touchEvent;
11415 	/** */
11416 	extern(C) void function(GtkWidget* widget, int width, int* minimumHeight, int* naturalHeight, int* minimumBaseline, int* naturalBaseline) getPreferredHeightAndBaselineForWidth;
11417 	/** */
11418 	extern(C) void function(GtkWidget* widget, int* minimumBaseline, int* naturalBaseline) adjustBaselineRequest;
11419 	/** */
11420 	extern(C) void function(GtkWidget* widget, int* baseline) adjustBaselineAllocation;
11421 	/** */
11422 	extern(C) void function(GtkWidget* widget, cairo_region_t* region) queueDrawRegion;
11423 	GtkWidgetClassPrivate* priv;
11424 	/** */
11425 	extern(C) void function() GtkReserved6;
11426 	/** */
11427 	extern(C) void function() GtkReserved7;
11428 }
11429 
11430 struct GtkWidgetClassPrivate;
11431 
11432 struct GtkWidgetPath;
11433 
11434 struct GtkWidgetPrivate;
11435 
11436 struct GtkWindow
11437 {
11438 	GtkBin bin;
11439 	GtkWindowPrivate* priv;
11440 }
11441 
11442 struct GtkWindowAccessible
11443 {
11444 	GtkContainerAccessible parent;
11445 	GtkWindowAccessiblePrivate* priv;
11446 }
11447 
11448 struct GtkWindowAccessibleClass
11449 {
11450 	GtkContainerAccessibleClass parentClass;
11451 }
11452 
11453 struct GtkWindowAccessiblePrivate;
11454 
11455 struct GtkWindowClass
11456 {
11457 	/**
11458 	 * The parent class.
11459 	 */
11460 	GtkBinClass parentClass;
11461 	/** */
11462 	extern(C) void function(GtkWindow* window, GtkWidget* focus) setFocus;
11463 	/** */
11464 	extern(C) void function(GtkWindow* window) activateFocus;
11465 	/** */
11466 	extern(C) void function(GtkWindow* window) activateDefault;
11467 	/** */
11468 	extern(C) void function(GtkWindow* window) keysChanged;
11469 	/** */
11470 	extern(C) int function(GtkWindow* window, int toggle) enableDebugging;
11471 	/** */
11472 	extern(C) void function() GtkReserved1;
11473 	/** */
11474 	extern(C) void function() GtkReserved2;
11475 	/** */
11476 	extern(C) void function() GtkReserved3;
11477 }
11478 
11479 struct GtkWindowGeometryInfo;
11480 
11481 struct GtkWindowGroup
11482 {
11483 	GObject parentInstance;
11484 	GtkWindowGroupPrivate* priv;
11485 }
11486 
11487 struct GtkWindowGroupClass
11488 {
11489 	GObjectClass parentClass;
11490 	/** */
11491 	extern(C) void function() GtkReserved1;
11492 	/** */
11493 	extern(C) void function() GtkReserved2;
11494 	/** */
11495 	extern(C) void function() GtkReserved3;
11496 	/** */
11497 	extern(C) void function() GtkReserved4;
11498 }
11499 
11500 struct GtkWindowGroupPrivate;
11501 
11502 struct GtkWindowPrivate;
11503 
11504 /** */
11505 public alias extern(C) int function(GtkAccelGroup* accelGroup, GObject* acceleratable, uint keyval, GdkModifierType modifier) GtkAccelGroupActivate;
11506 
11507 /** */
11508 public alias extern(C) int function(GtkAccelKey* key, GClosure* closure, void* data) GtkAccelGroupFindFunc;
11509 
11510 /** */
11511 public alias extern(C) void function(void* data, const(char)* accelPath, uint accelKey, GdkModifierType accelMods, int changed) GtkAccelMapForeach;
11512 
11513 /**
11514  * A function used by gtk_assistant_set_forward_page_func() to know which
11515  * is the next page given a current one. It’s called both for computing the
11516  * next page when the user presses the “forward” button and for handling
11517  * the behavior of the “last” button.
11518  *
11519  * Params:
11520  *     currentPage = The page number used to calculate the next page.
11521  *     data = user data.
11522  *
11523  * Returns: The next page number.
11524  */
11525 public alias extern(C) int function(int currentPage, void* data) GtkAssistantPageFunc;
11526 
11527 /**
11528  * This is the signature of a function used to connect signals.  It is used
11529  * by the gtk_builder_connect_signals() and gtk_builder_connect_signals_full()
11530  * methods.  It is mainly intended for interpreted language bindings, but
11531  * could be useful where the programmer wants more control over the signal
11532  * connection process. Note that this function can only be called once,
11533  * subsequent calls will do nothing.
11534  *
11535  * Params:
11536  *     builder = a #GtkBuilder
11537  *     object = object to connect a signal to
11538  *     signalName = name of the signal
11539  *     handlerName = name of the handler
11540  *     connectObject = a #GObject, if non-%NULL, use g_signal_connect_object()
11541  *     flags = #GConnectFlags to use
11542  *     userData = user data
11543  *
11544  * Since: 2.12
11545  */
11546 public alias extern(C) void function(GtkBuilder* builder, GObject* object, const(char)* signalName, const(char)* handlerName, GObject* connectObject, GConnectFlags flags, void* userData) GtkBuilderConnectFunc;
11547 
11548 /**
11549  * This kind of functions provide Pango markup with detail information for the
11550  * specified day. Examples for such details are holidays or appointments. The
11551  * function returns %NULL when no information is available.
11552  *
11553  * Params:
11554  *     calendar = a #GtkCalendar.
11555  *     year = the year for which details are needed.
11556  *     month = the month for which details are needed.
11557  *     day = the day of @month for which details are needed.
11558  *     userData = the data passed with gtk_calendar_set_detail_func().
11559  *
11560  * Returns: Newly allocated string with Pango markup
11561  *     with details for the specified day or %NULL.
11562  *
11563  * Since: 2.14
11564  */
11565 public alias extern(C) char* function(GtkCalendar* calendar, uint year, uint month, uint day, void* userData) GtkCalendarDetailFunc;
11566 
11567 /**
11568  * The type of the callback functions used for e.g. iterating over
11569  * the children of a container, see gtk_container_foreach().
11570  *
11571  * Params:
11572  *     widget = the widget to operate on
11573  *     data = user-supplied data
11574  */
11575 public alias extern(C) void function(GtkWidget* widget, void* data) GtkCallback;
11576 
11577 /**
11578  * The type of the callback functions used for iterating over the
11579  * cell renderers and their allocated areas inside a #GtkCellArea,
11580  * see gtk_cell_area_foreach_alloc().
11581  *
11582  * Params:
11583  *     renderer = the cell renderer to operate on
11584  *     cellArea = the area allocated to @renderer inside the rectangle
11585  *         provided to gtk_cell_area_foreach_alloc().
11586  *     cellBackground = the background area for @renderer inside the
11587  *         background area provided to gtk_cell_area_foreach_alloc().
11588  *     data = user-supplied data
11589  *
11590  * Returns: %TRUE to stop iterating over cells.
11591  */
11592 public alias extern(C) int function(GtkCellRenderer* renderer, GdkRectangle* cellArea, GdkRectangle* cellBackground, void* data) GtkCellAllocCallback;
11593 
11594 /**
11595  * The type of the callback functions used for iterating over
11596  * the cell renderers of a #GtkCellArea, see gtk_cell_area_foreach().
11597  *
11598  * Params:
11599  *     renderer = the cell renderer to operate on
11600  *     data = user-supplied data
11601  *
11602  * Returns: %TRUE to stop iterating over cells.
11603  */
11604 public alias extern(C) int function(GtkCellRenderer* renderer, void* data) GtkCellCallback;
11605 
11606 /**
11607  * A function which should set the value of @cell_layout’s cell renderer(s)
11608  * as appropriate.
11609  *
11610  * Params:
11611  *     cellLayout = a #GtkCellLayout
11612  *     cell = the cell renderer whose value is to be set
11613  *     treeModel = the model
11614  *     iter = a #GtkTreeIter indicating the row to set the value for
11615  *     data = user data passed to gtk_cell_layout_set_cell_data_func()
11616  */
11617 public alias extern(C) void function(GtkCellLayout* cellLayout, GtkCellRenderer* cell, GtkTreeModel* treeModel, GtkTreeIter* iter, void* data) GtkCellLayoutDataFunc;
11618 
11619 /**
11620  * A function that will be called when the contents of the clipboard are changed
11621  * or cleared. Once this has called, the @user_data_or_owner argument
11622  * will not be used again.
11623  *
11624  * Params:
11625  *     clipboard = the #GtkClipboard
11626  *     userDataOrOwner = the @user_data argument passed to gtk_clipboard_set_with_data(),
11627  *         or the @owner argument passed to gtk_clipboard_set_with_owner()
11628  */
11629 public alias extern(C) void function(GtkClipboard* clipboard, void* userDataOrOwner) GtkClipboardClearFunc;
11630 
11631 /**
11632  * A function that will be called to provide the contents of the selection.
11633  * If multiple types of data were advertised, the requested type can
11634  * be determined from the @info parameter or by checking the target field
11635  * of @selection_data. If the data could successfully be converted into
11636  * then it should be stored into the @selection_data object by
11637  * calling gtk_selection_data_set() (or related functions such
11638  * as gtk_selection_data_set_text()). If no data is set, the requestor
11639  * will be informed that the attempt to get the data failed.
11640  *
11641  * Params:
11642  *     clipboard = the #GtkClipboard
11643  *     selectionData = a #GtkSelectionData argument in which the requested
11644  *         data should be stored.
11645  *     info = the info field corresponding to the requested target from the
11646  *         #GtkTargetEntry array passed to gtk_clipboard_set_with_data() or
11647  *         gtk_clipboard_set_with_owner().
11648  *     userDataOrOwner = the @user_data argument passed to
11649  *         gtk_clipboard_set_with_data(), or the @owner argument passed to
11650  *         gtk_clipboard_set_with_owner()
11651  */
11652 public alias extern(C) void function(GtkClipboard* clipboard, GtkSelectionData* selectionData, uint info, void* userDataOrOwner) GtkClipboardGetFunc;
11653 
11654 /**
11655  * A function to be called when the results of gtk_clipboard_request_image()
11656  * are received, or when the request fails.
11657  *
11658  * Params:
11659  *     clipboard = the #GtkClipboard
11660  *     pixbuf = the received image
11661  *     data = the @user_data supplied to
11662  *         gtk_clipboard_request_image().
11663  *
11664  * Since: 2.6
11665  */
11666 public alias extern(C) void function(GtkClipboard* clipboard, GdkPixbuf* pixbuf, void* data) GtkClipboardImageReceivedFunc;
11667 
11668 /**
11669  * A function to be called when the results of gtk_clipboard_request_contents()
11670  * are received, or when the request fails.
11671  *
11672  * Params:
11673  *     clipboard = the #GtkClipboard
11674  *     selectionData = a #GtkSelectionData containing the data was received.
11675  *         If retrieving the data failed, then then length field
11676  *         of @selection_data will be negative.
11677  *     data = the @user_data supplied to
11678  *         gtk_clipboard_request_contents().
11679  */
11680 public alias extern(C) void function(GtkClipboard* clipboard, GtkSelectionData* selectionData, void* data) GtkClipboardReceivedFunc;
11681 
11682 /**
11683  * A function to be called when the results of
11684  * gtk_clipboard_request_rich_text() are received, or when the request
11685  * fails.
11686  *
11687  * Params:
11688  *     clipboard = the #GtkClipboard
11689  *     format = The format of the rich text
11690  *     text = the rich text received, as
11691  *         a UTF-8 encoded string, or %NULL if retrieving the data failed.
11692  *     length = Length of the text.
11693  *     data = the @user_data supplied to
11694  *         gtk_clipboard_request_rich_text().
11695  *
11696  * Since: 2.10
11697  */
11698 public alias extern(C) void function(GtkClipboard* clipboard, GdkAtom format, const(char)* text, size_t length, void* data) GtkClipboardRichTextReceivedFunc;
11699 
11700 /**
11701  * A function to be called when the results of gtk_clipboard_request_targets()
11702  * are received, or when the request fails.
11703  *
11704  * Params:
11705  *     clipboard = the #GtkClipboard
11706  *     atoms = the supported targets,
11707  *         as array of #GdkAtom, or %NULL if retrieving the data failed.
11708  *     nAtoms = the length of the @atoms array.
11709  *     data = the @user_data supplied to
11710  *         gtk_clipboard_request_targets().
11711  *
11712  * Since: 2.4
11713  */
11714 public alias extern(C) void function(GtkClipboard* clipboard, GdkAtom* atoms, int nAtoms, void* data) GtkClipboardTargetsReceivedFunc;
11715 
11716 /**
11717  * A function to be called when the results of gtk_clipboard_request_text()
11718  * are received, or when the request fails.
11719  *
11720  * Params:
11721  *     clipboard = the #GtkClipboard
11722  *     text = the text received, as a UTF-8 encoded string, or
11723  *         %NULL if retrieving the data failed.
11724  *     data = the @user_data supplied to
11725  *         gtk_clipboard_request_text().
11726  */
11727 public alias extern(C) void function(GtkClipboard* clipboard, const(char)* text, void* data) GtkClipboardTextReceivedFunc;
11728 
11729 /**
11730  * A function to be called when the results of
11731  * gtk_clipboard_request_uris() are received, or when the request
11732  * fails.
11733  *
11734  * Params:
11735  *     clipboard = the #GtkClipboard
11736  *     uris = the received URIs
11737  *     data = the @user_data supplied to
11738  *         gtk_clipboard_request_uris().
11739  *
11740  * Since: 2.14
11741  */
11742 public alias extern(C) void function(GtkClipboard* clipboard, char** uris, void* data) GtkClipboardURIReceivedFunc;
11743 
11744 /** */
11745 public alias extern(C) void function(GdkColor* colors, int nColors) GtkColorSelectionChangePaletteFunc;
11746 
11747 /** */
11748 public alias extern(C) void function(GdkScreen* screen, GdkColor* colors, int nColors) GtkColorSelectionChangePaletteWithScreenFunc;
11749 
11750 /**
11751  * A function which decides whether the row indicated by @iter matches
11752  * a given @key, and should be displayed as a possible completion for @key.
11753  * Note that @key is normalized and case-folded (see g_utf8_normalize()
11754  * and g_utf8_casefold()). If this is not appropriate, match functions
11755  * have access to the unmodified key via
11756  * `gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry ()))`.
11757  *
11758  * Params:
11759  *     completion = the #GtkEntryCompletion
11760  *     key = the string to match, normalized and case-folded
11761  *     iter = a #GtkTreeIter indicating the row to match
11762  *     userData = user data given to gtk_entry_completion_set_match_func()
11763  *
11764  * Returns: %TRUE if @iter should be displayed as a possible completion
11765  *     for @key
11766  */
11767 public alias extern(C) int function(GtkEntryCompletion* completion, const(char)* key, GtkTreeIter* iter, void* userData) GtkEntryCompletionMatchFunc;
11768 
11769 /**
11770  * The type of function that is used with custom filters, see
11771  * gtk_file_filter_add_custom().
11772  *
11773  * Params:
11774  *     filterInfo = a #GtkFileFilterInfo that is filled according
11775  *         to the @needed flags passed to gtk_file_filter_add_custom()
11776  *     data = user data passed to gtk_file_filter_add_custom()
11777  *
11778  * Returns: %TRUE if the file should be displayed
11779  */
11780 public alias extern(C) int function(GtkFileFilterInfo* filterInfo, void* data) GtkFileFilterFunc;
11781 
11782 /**
11783  * Called for flow boxes that are bound to a #GListModel with
11784  * gtk_flow_box_bind_model() for each item that gets added to the model.
11785  *
11786  * Params:
11787  *     item = the item from the model for which to create a widget for
11788  *     userData = user data from gtk_flow_box_bind_model()
11789  *
11790  * Returns: a #GtkWidget that represents @item
11791  *
11792  * Since: 3.18
11793  */
11794 public alias extern(C) GtkWidget* function(void* item, void* userData) GtkFlowBoxCreateWidgetFunc;
11795 
11796 /**
11797  * A function that will be called whenrever a child changes
11798  * or is added. It lets you control if the child should be
11799  * visible or not.
11800  *
11801  * Params:
11802  *     child = a #GtkFlowBoxChild that may be filtered
11803  *     userData = user data
11804  *
11805  * Returns: %TRUE if the row should be visible, %FALSE otherwise
11806  *
11807  * Since: 3.12
11808  */
11809 public alias extern(C) int function(GtkFlowBoxChild* child, void* userData) GtkFlowBoxFilterFunc;
11810 
11811 /**
11812  * A function used by gtk_flow_box_selected_foreach().
11813  * It will be called on every selected child of the @box.
11814  *
11815  * Params:
11816  *     box = a #GtkFlowBox
11817  *     child = a #GtkFlowBoxChild
11818  *     userData = user data
11819  *
11820  * Since: 3.12
11821  */
11822 public alias extern(C) void function(GtkFlowBox* box, GtkFlowBoxChild* child, void* userData) GtkFlowBoxForeachFunc;
11823 
11824 /**
11825  * A function to compare two children to determine which
11826  * should come first.
11827  *
11828  * Params:
11829  *     child1 = the first child
11830  *     child2 = the second child
11831  *     userData = user data
11832  *
11833  * Returns: < 0 if @child1 should be before @child2, 0 if
11834  *     the are equal, and > 0 otherwise
11835  *
11836  * Since: 3.12
11837  */
11838 public alias extern(C) int function(GtkFlowBoxChild* child1, GtkFlowBoxChild* child2, void* userData) GtkFlowBoxSortFunc;
11839 
11840 /**
11841  * The type of function that is used for deciding what fonts get
11842  * shown in a #GtkFontChooser. See gtk_font_chooser_set_filter_func().
11843  *
11844  * Params:
11845  *     family = a #PangoFontFamily
11846  *     face = a #PangoFontFace belonging to @family
11847  *     data = user data passed to gtk_font_chooser_set_filter_func()
11848  *
11849  * Returns: %TRUE if the font should be displayed
11850  */
11851 public alias extern(C) int function(PangoFontFamily* family, PangoFontFace* face, void* data) GtkFontFilterFunc;
11852 
11853 /**
11854  * A function used by gtk_icon_view_selected_foreach() to map all
11855  * selected rows.  It will be called on every selected row in the view.
11856  *
11857  * Params:
11858  *     iconView = a #GtkIconView
11859  *     path = The #GtkTreePath of a selected row
11860  *     data = user data
11861  */
11862 public alias extern(C) void function(GtkIconView* iconView, GtkTreePath* path, void* data) GtkIconViewForeachFunc;
11863 
11864 /**
11865  * Key snooper functions are called before normal event delivery.
11866  * They can be used to implement custom key event handling.
11867  *
11868  * Params:
11869  *     grabWidget = the widget to which the event will be delivered
11870  *     event = the key event
11871  *     funcData = data supplied to gtk_key_snooper_install()
11872  *
11873  * Returns: %TRUE to stop further processing of @event, %FALSE to continue.
11874  */
11875 public alias extern(C) int function(GtkWidget* grabWidget, GdkEventKey* event, void* funcData) GtkKeySnoopFunc;
11876 
11877 /**
11878  * Called for list boxes that are bound to a #GListModel with
11879  * gtk_list_box_bind_model() for each item that gets added to the model.
11880  *
11881  * Versions of GTK+ prior to 3.18 called gtk_widget_show_all() on the rows
11882  * created by the GtkListBoxCreateWidgetFunc, but this forced all widgets
11883  * inside the row to be shown, and is no longer the case. Applications should
11884  * be updated to show the desired row widgets.
11885  *
11886  * Params:
11887  *     item = the item from the model for which to create a widget for
11888  *     userData = user data
11889  *
11890  * Returns: a #GtkWidget that represents @item
11891  *
11892  * Since: 3.16
11893  */
11894 public alias extern(C) GtkWidget* function(void* item, void* userData) GtkListBoxCreateWidgetFunc;
11895 
11896 /**
11897  * Will be called whenever the row changes or is added and lets you control
11898  * if the row should be visible or not.
11899  *
11900  * Params:
11901  *     row = the row that may be filtered
11902  *     userData = user data
11903  *
11904  * Returns: %TRUE if the row should be visible, %FALSE otherwise
11905  *
11906  * Since: 3.10
11907  */
11908 public alias extern(C) int function(GtkListBoxRow* row, void* userData) GtkListBoxFilterFunc;
11909 
11910 /**
11911  * A function used by gtk_list_box_selected_foreach().
11912  * It will be called on every selected child of the @box.
11913  *
11914  * Params:
11915  *     box = a #GtkListBox
11916  *     row = a #GtkListBoxRow
11917  *     userData = user data
11918  *
11919  * Since: 3.14
11920  */
11921 public alias extern(C) void function(GtkListBox* box, GtkListBoxRow* row, void* userData) GtkListBoxForeachFunc;
11922 
11923 /**
11924  * Compare two rows to determine which should be first.
11925  *
11926  * Params:
11927  *     row1 = the first row
11928  *     row2 = the second row
11929  *     userData = user data
11930  *
11931  * Returns: < 0 if @row1 should be before @row2, 0 if they are
11932  *     equal and > 0 otherwise
11933  *
11934  * Since: 3.10
11935  */
11936 public alias extern(C) int function(GtkListBoxRow* row1, GtkListBoxRow* row2, void* userData) GtkListBoxSortFunc;
11937 
11938 /**
11939  * Whenever @row changes or which row is before @row changes this
11940  * is called, which lets you update the header on @row. You may
11941  * remove or set a new one via gtk_list_box_row_set_header() or
11942  * just change the state of the current header widget.
11943  *
11944  * Params:
11945  *     row = the row to update
11946  *     before = the row before @row, or %NULL if it is first
11947  *     userData = user data
11948  *
11949  * Since: 3.10
11950  */
11951 public alias extern(C) void function(GtkListBoxRow* row, GtkListBoxRow* before, void* userData) GtkListBoxUpdateHeaderFunc;
11952 
11953 /**
11954  * A user function supplied when calling gtk_menu_attach_to_widget() which
11955  * will be called when the menu is later detached from the widget.
11956  *
11957  * Params:
11958  *     attachWidget = the #GtkWidget that the menu is being detached from.
11959  *     menu = the #GtkMenu being detached.
11960  */
11961 public alias extern(C) void function(GtkWidget* attachWidget, GtkMenu* menu) GtkMenuDetachFunc;
11962 
11963 /**
11964  * A user function supplied when calling gtk_menu_popup() which
11965  * controls the positioning of the menu when it is displayed.  The
11966  * function sets the @x and @y parameters to the coordinates where the
11967  * menu is to be drawn.  To make the menu appear on a different
11968  * monitor than the mouse pointer, gtk_menu_set_monitor() must be
11969  * called.
11970  *
11971  * Params:
11972  *     menu = a #GtkMenu.
11973  *     x = address of the #gint representing the horizontal
11974  *         position where the menu shall be drawn.
11975  *     y = address of the #gint representing the vertical position
11976  *         where the menu shall be drawn.  This is an output parameter.
11977  *     pushIn = This parameter controls how menus placed outside
11978  *         the monitor are handled.  If this is set to %TRUE and part of
11979  *         the menu is outside the monitor then GTK+ pushes the window
11980  *         into the visible area, effectively modifying the popup
11981  *         position.  Note that moving and possibly resizing the menu
11982  *         around will alter the scroll position to keep the menu items
11983  *         “in place”, i.e. at the same monitor position they would have
11984  *         been without resizing.  In practice, this behavior is only
11985  *         useful for combobox popups or option menus and cannot be used
11986  *         to simply confine a menu to monitor boundaries.  In that case,
11987  *         changing the scroll offset is not desirable.
11988  *     userData = the data supplied by the user in the gtk_menu_popup()
11989  *         @data parameter.
11990  */
11991 public alias extern(C) void function(GtkMenu* menu, int* x, int* y, int* pushIn, void* userData) GtkMenuPositionFunc;
11992 
11993 /**
11994  * A multihead-aware GTK+ module may have a gtk_module_display_init() function
11995  * with this prototype. GTK+ calls this function for each opened display.
11996  *
11997  * Params:
11998  *     display = an open #GdkDisplay
11999  *
12000  * Since: 2.2
12001  */
12002 public alias extern(C) void function(GdkDisplay* display) GtkModuleDisplayInitFunc;
12003 
12004 /**
12005  * Each GTK+ module must have a function gtk_module_init() with this prototype.
12006  * This function is called after loading the module.
12007  *
12008  * Params:
12009  *     argc = GTK+ always passes %NULL for this argument
12010  *     argv = GTK+ always passes %NULL for this argument
12011  */
12012 public alias extern(C) void function(int* argc, char*** argv) GtkModuleInitFunc;
12013 
12014 /**
12015  * The type of function that is passed to
12016  * gtk_print_run_page_setup_dialog_async().
12017  *
12018  * This function will be called when the page setup dialog
12019  * is dismissed, and also serves as destroy notify for @data.
12020  *
12021  * Params:
12022  *     pageSetup = the #GtkPageSetup that has been
12023  *     data = user data that has been passed to
12024  *         gtk_print_run_page_setup_dialog_async()
12025  */
12026 public alias extern(C) void function(GtkPageSetup* pageSetup, void* data) GtkPageSetupDoneFunc;
12027 
12028 /** */
12029 public alias extern(C) void function(const(char)* key, const(char)* value, void* userData) GtkPrintSettingsFunc;
12030 
12031 /** */
12032 public alias extern(C) int function(GParamSpec* pspec, GString* rcString, GValue* propertyValue) GtkRcPropertyParser;
12033 
12034 /**
12035  * The type of function that is used with custom filters,
12036  * see gtk_recent_filter_add_custom().
12037  *
12038  * Params:
12039  *     filterInfo = a #GtkRecentFilterInfo that is filled according
12040  *         to the @needed flags passed to gtk_recent_filter_add_custom()
12041  *     userData = user data passed to gtk_recent_filter_add_custom()
12042  *
12043  * Returns: %TRUE if the file should be displayed
12044  */
12045 public alias extern(C) int function(GtkRecentFilterInfo* filterInfo, void* userData) GtkRecentFilterFunc;
12046 
12047 /** */
12048 public alias extern(C) int function(GtkRecentInfo* a, GtkRecentInfo* b, void* userData) GtkRecentSortFunc;
12049 
12050 /** */
12051 public alias extern(C) int function(const(char)* str, GValue* value, GError** err) GtkStylePropertyParser;
12052 
12053 /**
12054  * A function that is called to deserialize rich text that has been
12055  * serialized with gtk_text_buffer_serialize(), and insert it at @iter.
12056  *
12057  * Params:
12058  *     registerBuffer = the #GtkTextBuffer the format is registered with
12059  *     contentBuffer = the #GtkTextBuffer to deserialize into
12060  *     iter = insertion point for the deserialized text
12061  *     data = data to deserialize
12062  *     length = length of @data
12063  *     createTags = %TRUE if deserializing may create tags
12064  *     userData = user data that was specified when registering the format
12065  *
12066  * Returns: %TRUE on success, %FALSE otherwise
12067  *
12068  * Throws: GException on failure.
12069  */
12070 public alias extern(C) int function(GtkTextBuffer* registerBuffer, GtkTextBuffer* contentBuffer, GtkTextIter* iter, ubyte* data, size_t length, int createTags, void* userData, GError** err) GtkTextBufferDeserializeFunc;
12071 
12072 /**
12073  * A function that is called to serialize the content of a text buffer.
12074  * It must return the serialized form of the content.
12075  *
12076  * Params:
12077  *     registerBuffer = the #GtkTextBuffer for which the format is registered
12078  *     contentBuffer = the #GtkTextBuffer to serialize
12079  *     start = start of the block of text to serialize
12080  *     end = end of the block of text to serialize
12081  *     length = Return location for the length of the serialized data
12082  *     userData = user data that was specified when registering the format
12083  *
12084  * Returns: a newly-allocated array of guint8 which contains
12085  *     the serialized data, or %NULL if an error occurred
12086  */
12087 public alias extern(C) ubyte* function(GtkTextBuffer* registerBuffer, GtkTextBuffer* contentBuffer, GtkTextIter* start, GtkTextIter* end, size_t* length, void* userData) GtkTextBufferSerializeFunc;
12088 
12089 /** */
12090 public alias extern(C) int function(dchar ch, void* userData) GtkTextCharPredicate;
12091 
12092 /** */
12093 public alias extern(C) void function(GtkTextTag* tag, void* data) GtkTextTagTableForeach;
12094 
12095 /**
12096  * Callback type for adding a function to update animations. See gtk_widget_add_tick_callback().
12097  *
12098  * Params:
12099  *     widget = the widget
12100  *     frameClock = the frame clock for the widget (same as calling gtk_widget_get_frame_clock())
12101  *     userData = user data passed to gtk_widget_add_tick_callback().
12102  *
12103  * Returns: %G_SOURCE_CONTINUE if the tick callback should continue to be called,
12104  *     %G_SOURCE_REMOVE if the tick callback should be removed.
12105  *
12106  * Since: 3.8
12107  */
12108 public alias extern(C) int function(GtkWidget* widget, GdkFrameClock* frameClock, void* userData) GtkTickCallback;
12109 
12110 /**
12111  * The function used to translate messages in e.g. #GtkIconFactory
12112  * and #GtkActionGroup.
12113  *
12114  * Params:
12115  *     path = The id of the message. In #GtkActionGroup this will be a label
12116  *         or tooltip from a #GtkActionEntry.
12117  *     funcData = user data passed in when registering the
12118  *         function
12119  *
12120  * Returns: the translated message
12121  */
12122 public alias extern(C) char* function(const(char)* path, void* funcData) GtkTranslateFunc;
12123 
12124 /**
12125  * A function to set the properties of a cell instead of just using the
12126  * straight mapping between the cell and the model.  This is useful for
12127  * customizing the cell renderer.  For example, a function might get an
12128  * integer from the @tree_model, and render it to the “text” attribute of
12129  * “cell” by converting it to its written equivalent.  This is set by
12130  * calling gtk_tree_view_column_set_cell_data_func()
12131  *
12132  * Params:
12133  *     treeColumn = A #GtkTreeViewColumn
12134  *     cell = The #GtkCellRenderer that is being rendered by @tree_column
12135  *     treeModel = The #GtkTreeModel being rendered
12136  *     iter = A #GtkTreeIter of the current row rendered
12137  *     data = user data
12138  */
12139 public alias extern(C) void function(GtkTreeViewColumn* treeColumn, GtkCellRenderer* cell, GtkTreeModel* treeModel, GtkTreeIter* iter, void* data) GtkTreeCellDataFunc;
12140 
12141 /** */
12142 public alias extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, int children, void* userData) GtkTreeDestroyCountFunc;
12143 
12144 /**
12145  * A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive
12146  * integer if @a sorts before @b, @a sorts with @b, or @a sorts after @b
12147  * respectively. If two iters compare as equal, their order in the sorted model
12148  * is undefined. In order to ensure that the #GtkTreeSortable behaves as
12149  * expected, the GtkTreeIterCompareFunc must define a partial order on
12150  * the model, i.e. it must be reflexive, antisymmetric and transitive.
12151  *
12152  * For example, if @model is a product catalogue, then a compare function
12153  * for the “price” column could be one which returns
12154  * `price_of(@a) - price_of(@b)`.
12155  *
12156  * Params:
12157  *     model = The #GtkTreeModel the comparison is within
12158  *     a = A #GtkTreeIter in @model
12159  *     b = Another #GtkTreeIter in @model
12160  *     userData = Data passed when the compare func is assigned e.g. by
12161  *         gtk_tree_sortable_set_sort_func()
12162  *
12163  * Returns: a negative integer, zero or a positive integer depending on whether
12164  *     @a sorts before, with or after @b
12165  */
12166 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* a, GtkTreeIter* b, void* userData) GtkTreeIterCompareFunc;
12167 
12168 /**
12169  * A function which calculates display values from raw values in the model.
12170  * It must fill @value with the display value for the column @column in the
12171  * row indicated by @iter.
12172  *
12173  * Since this function is called for each data access, it’s not a
12174  * particularly efficient operation.
12175  *
12176  * Params:
12177  *     model = the #GtkTreeModelFilter
12178  *     iter = a #GtkTreeIter pointing to the row whose display values are determined
12179  *     value = A #GValue which is already initialized for
12180  *         with the correct type for the column @column.
12181  *     column = the column whose display value is determined
12182  *     data = user data given to gtk_tree_model_filter_set_modify_func()
12183  */
12184 public alias extern(C) void function(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, int column, void* data) GtkTreeModelFilterModifyFunc;
12185 
12186 /**
12187  * A function which decides whether the row indicated by @iter is visible.
12188  *
12189  * Params:
12190  *     model = the child model of the #GtkTreeModelFilter
12191  *     iter = a #GtkTreeIter pointing to the row in @model whose visibility
12192  *         is determined
12193  *     data = user data given to gtk_tree_model_filter_set_visible_func()
12194  *
12195  * Returns: Whether the row indicated by @iter is visible.
12196  */
12197 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* iter, void* data) GtkTreeModelFilterVisibleFunc;
12198 
12199 /**
12200  * Type of the callback passed to gtk_tree_model_foreach() to
12201  * iterate over the rows in a tree model.
12202  *
12203  * Params:
12204  *     model = the #GtkTreeModel being iterated
12205  *     path = the current #GtkTreePath
12206  *     iter = the current #GtkTreeIter
12207  *     data = The user data passed to gtk_tree_model_foreach()
12208  *
12209  * Returns: %TRUE to stop iterating, %FALSE to continue
12210  */
12211 public alias extern(C) int function(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, void* data) GtkTreeModelForeachFunc;
12212 
12213 /**
12214  * A function used by gtk_tree_selection_selected_foreach() to map all
12215  * selected rows.  It will be called on every selected row in the view.
12216  *
12217  * Params:
12218  *     model = The #GtkTreeModel being viewed
12219  *     path = The #GtkTreePath of a selected row
12220  *     iter = A #GtkTreeIter pointing to a selected row
12221  *     data = user data
12222  */
12223 public alias extern(C) void function(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, void* data) GtkTreeSelectionForeachFunc;
12224 
12225 /**
12226  * A function used by gtk_tree_selection_set_select_function() to filter
12227  * whether or not a row may be selected.  It is called whenever a row's
12228  * state might change.  A return value of %TRUE indicates to @selection
12229  * that it is okay to change the selection.
12230  *
12231  * Params:
12232  *     selection = A #GtkTreeSelection
12233  *     model = A #GtkTreeModel being viewed
12234  *     path = The #GtkTreePath of the row in question
12235  *     pathCurrentlySelected = %TRUE, if the path is currently selected
12236  *     data = user data
12237  *
12238  * Returns: %TRUE, if the selection state of the row can be toggled
12239  */
12240 public alias extern(C) int function(GtkTreeSelection* selection, GtkTreeModel* model, GtkTreePath* path, int pathCurrentlySelected, void* data) GtkTreeSelectionFunc;
12241 
12242 /**
12243  * Function type for determining whether @column can be dropped in a
12244  * particular spot (as determined by @prev_column and @next_column).  In
12245  * left to right locales, @prev_column is on the left of the potential drop
12246  * spot, and @next_column is on the right.  In right to left mode, this is
12247  * reversed.  This function should return %TRUE if the spot is a valid drop
12248  * spot.  Please note that returning %TRUE does not actually indicate that
12249  * the column drop was made, but is meant only to indicate a possible drop
12250  * spot to the user.
12251  *
12252  * Params:
12253  *     treeView = A #GtkTreeView
12254  *     column = The #GtkTreeViewColumn being dragged
12255  *     prevColumn = A #GtkTreeViewColumn on one side of @column
12256  *     nextColumn = A #GtkTreeViewColumn on the other side of @column
12257  *     data = user data
12258  *
12259  * Returns: %TRUE, if @column can be dropped in this spot
12260  */
12261 public alias extern(C) int function(GtkTreeView* treeView, GtkTreeViewColumn* column, GtkTreeViewColumn* prevColumn, GtkTreeViewColumn* nextColumn, void* data) GtkTreeViewColumnDropFunc;
12262 
12263 /**
12264  * Function used for gtk_tree_view_map_expanded_rows().
12265  *
12266  * Params:
12267  *     treeView = A #GtkTreeView
12268  *     path = The path that’s expanded
12269  *     userData = user data
12270  */
12271 public alias extern(C) void function(GtkTreeView* treeView, GtkTreePath* path, void* userData) GtkTreeViewMappingFunc;
12272 
12273 /**
12274  * Function type for determining whether the row pointed to by @iter should
12275  * be rendered as a separator. A common way to implement this is to have a
12276  * boolean column in the model, whose values the #GtkTreeViewRowSeparatorFunc
12277  * returns.
12278  *
12279  * Params:
12280  *     model = the #GtkTreeModel
12281  *     iter = a #GtkTreeIter pointing at a row in @model
12282  *     data = user data
12283  *
12284  * Returns: %TRUE if the row is a separator
12285  */
12286 public alias extern(C) int function(GtkTreeModel* model, GtkTreeIter* iter, void* data) GtkTreeViewRowSeparatorFunc;
12287 
12288 /**
12289  * A function used for checking whether a row in @model matches
12290  * a search key string entered by the user. Note the return value
12291  * is reversed from what you would normally expect, though it
12292  * has some similarity to strcmp() returning 0 for equal strings.
12293  *
12294  * Params:
12295  *     model = the #GtkTreeModel being searched
12296  *     column = the search column set by gtk_tree_view_set_search_column()
12297  *     key = the key string to compare with
12298  *     iter = a #GtkTreeIter pointing the row of @model that should be compared
12299  *         with @key.
12300  *     searchData = user data from gtk_tree_view_set_search_equal_func()
12301  *
12302  * Returns: %FALSE if the row matches, %TRUE otherwise.
12303  */
12304 public alias extern(C) int function(GtkTreeModel* model, int column, const(char)* key, GtkTreeIter* iter, void* searchData) GtkTreeViewSearchEqualFunc;
12305 
12306 /** */
12307 public alias extern(C) void function(GtkTreeView* treeView, GtkWidget* searchDialog, void* userData) GtkTreeViewSearchPositionFunc;
12308 
12309 /**
12310  * Like gtk_get_binary_age(), but from the headers used at
12311  * application compile time, rather than from the library linked
12312  * against at application run time.
12313  */
12314 enum BINARY_AGE = 2230;
12315 alias GTK_BINARY_AGE = BINARY_AGE;
12316 
12317 /**
12318  * Constant to return from a signal handler for the #GtkSpinButton::input
12319  * signal in case of conversion failure.
12320  */
12321 enum INPUT_ERROR = -1;
12322 alias GTK_INPUT_ERROR = INPUT_ERROR;
12323 
12324 /**
12325  * Like gtk_get_interface_age(), but from the headers used at
12326  * application compile time, rather than from the library linked
12327  * against at application run time.
12328  */
12329 enum INTERFACE_AGE = 30;
12330 alias GTK_INTERFACE_AGE = INTERFACE_AGE;
12331 
12332 /**
12333  * The name used for the stock full offset included by #GtkLevelBar.
12334  */
12335 enum LEVEL_BAR_OFFSET_FULL = "full";
12336 alias GTK_LEVEL_BAR_OFFSET_FULL = LEVEL_BAR_OFFSET_FULL;
12337 
12338 /**
12339  * The name used for the stock high offset included by #GtkLevelBar.
12340  */
12341 enum LEVEL_BAR_OFFSET_HIGH = "high";
12342 alias GTK_LEVEL_BAR_OFFSET_HIGH = LEVEL_BAR_OFFSET_HIGH;
12343 
12344 /**
12345  * The name used for the stock low offset included by #GtkLevelBar.
12346  */
12347 enum LEVEL_BAR_OFFSET_LOW = "low";
12348 alias GTK_LEVEL_BAR_OFFSET_LOW = LEVEL_BAR_OFFSET_LOW;
12349 
12350 /**
12351  * Like gtk_get_major_version(), but from the headers used at
12352  * application compile time, rather than from the library linked
12353  * against at application run time.
12354  */
12355 enum MAJOR_VERSION = 3;
12356 alias GTK_MAJOR_VERSION = MAJOR_VERSION;
12357 
12358 /**
12359  * The maximum length of sequences in compose tables.
12360  */
12361 enum MAX_COMPOSE_LEN = 7;
12362 alias GTK_MAX_COMPOSE_LEN = MAX_COMPOSE_LEN;
12363 
12364 /**
12365  * Like gtk_get_micro_version(), but from the headers used at
12366  * application compile time, rather than from the library linked
12367  * against at application run time.
12368  */
12369 enum MICRO_VERSION = 30;
12370 alias GTK_MICRO_VERSION = MICRO_VERSION;
12371 
12372 /**
12373  * Like gtk_get_minor_version(), but from the headers used at
12374  * application compile time, rather than from the library linked
12375  * against at application run time.
12376  */
12377 enum MINOR_VERSION = 22;
12378 alias GTK_MINOR_VERSION = MINOR_VERSION;
12379 
12380 /**
12381  * Name for the A3 paper size.
12382  */
12383 enum PAPER_NAME_A3 = "iso_a3";
12384 alias GTK_PAPER_NAME_A3 = PAPER_NAME_A3;
12385 
12386 /**
12387  * Name for the A4 paper size.
12388  */
12389 enum PAPER_NAME_A4 = "iso_a4";
12390 alias GTK_PAPER_NAME_A4 = PAPER_NAME_A4;
12391 
12392 /**
12393  * Name for the A5 paper size.
12394  */
12395 enum PAPER_NAME_A5 = "iso_a5";
12396 alias GTK_PAPER_NAME_A5 = PAPER_NAME_A5;
12397 
12398 /**
12399  * Name for the B5 paper size.
12400  */
12401 enum PAPER_NAME_B5 = "iso_b5";
12402 alias GTK_PAPER_NAME_B5 = PAPER_NAME_B5;
12403 
12404 /**
12405  * Name for the Executive paper size.
12406  */
12407 enum PAPER_NAME_EXECUTIVE = "na_executive";
12408 alias GTK_PAPER_NAME_EXECUTIVE = PAPER_NAME_EXECUTIVE;
12409 
12410 /**
12411  * Name for the Legal paper size.
12412  */
12413 enum PAPER_NAME_LEGAL = "na_legal";
12414 alias GTK_PAPER_NAME_LEGAL = PAPER_NAME_LEGAL;
12415 
12416 /**
12417  * Name for the Letter paper size.
12418  */
12419 enum PAPER_NAME_LETTER = "na_letter";
12420 alias GTK_PAPER_NAME_LETTER = PAPER_NAME_LETTER;
12421 
12422 enum PATH_PRIO_MASK = 15;
12423 alias GTK_PATH_PRIO_MASK = PATH_PRIO_MASK;
12424 
12425 enum PRINT_SETTINGS_COLLATE = "collate";
12426 alias GTK_PRINT_SETTINGS_COLLATE = PRINT_SETTINGS_COLLATE;
12427 
12428 enum PRINT_SETTINGS_DEFAULT_SOURCE = "default-source";
12429 alias GTK_PRINT_SETTINGS_DEFAULT_SOURCE = PRINT_SETTINGS_DEFAULT_SOURCE;
12430 
12431 enum PRINT_SETTINGS_DITHER = "dither";
12432 alias GTK_PRINT_SETTINGS_DITHER = PRINT_SETTINGS_DITHER;
12433 
12434 enum PRINT_SETTINGS_DUPLEX = "duplex";
12435 alias GTK_PRINT_SETTINGS_DUPLEX = PRINT_SETTINGS_DUPLEX;
12436 
12437 enum PRINT_SETTINGS_FINISHINGS = "finishings";
12438 alias GTK_PRINT_SETTINGS_FINISHINGS = PRINT_SETTINGS_FINISHINGS;
12439 
12440 enum PRINT_SETTINGS_MEDIA_TYPE = "media-type";
12441 alias GTK_PRINT_SETTINGS_MEDIA_TYPE = PRINT_SETTINGS_MEDIA_TYPE;
12442 
12443 enum PRINT_SETTINGS_NUMBER_UP = "number-up";
12444 alias GTK_PRINT_SETTINGS_NUMBER_UP = PRINT_SETTINGS_NUMBER_UP;
12445 
12446 enum PRINT_SETTINGS_NUMBER_UP_LAYOUT = "number-up-layout";
12447 alias GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT = PRINT_SETTINGS_NUMBER_UP_LAYOUT;
12448 
12449 enum PRINT_SETTINGS_N_COPIES = "n-copies";
12450 alias GTK_PRINT_SETTINGS_N_COPIES = PRINT_SETTINGS_N_COPIES;
12451 
12452 enum PRINT_SETTINGS_ORIENTATION = "orientation";
12453 alias GTK_PRINT_SETTINGS_ORIENTATION = PRINT_SETTINGS_ORIENTATION;
12454 
12455 /**
12456  * The key used by the “Print to file” printer to store the file
12457  * name of the output without the path to the directory and the
12458  * file extension.
12459  */
12460 enum PRINT_SETTINGS_OUTPUT_BASENAME = "output-basename";
12461 alias GTK_PRINT_SETTINGS_OUTPUT_BASENAME = PRINT_SETTINGS_OUTPUT_BASENAME;
12462 
12463 enum PRINT_SETTINGS_OUTPUT_BIN = "output-bin";
12464 alias GTK_PRINT_SETTINGS_OUTPUT_BIN = PRINT_SETTINGS_OUTPUT_BIN;
12465 
12466 /**
12467  * The key used by the “Print to file” printer to store the
12468  * directory to which the output should be written.
12469  */
12470 enum PRINT_SETTINGS_OUTPUT_DIR = "output-dir";
12471 alias GTK_PRINT_SETTINGS_OUTPUT_DIR = PRINT_SETTINGS_OUTPUT_DIR;
12472 
12473 /**
12474  * The key used by the “Print to file” printer to store the format
12475  * of the output. The supported values are “PS” and “PDF”.
12476  */
12477 enum PRINT_SETTINGS_OUTPUT_FILE_FORMAT = "output-file-format";
12478 alias GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT = PRINT_SETTINGS_OUTPUT_FILE_FORMAT;
12479 
12480 /**
12481  * The key used by the “Print to file” printer to store the URI
12482  * to which the output should be written. GTK+ itself supports
12483  * only “file://” URIs.
12484  */
12485 enum PRINT_SETTINGS_OUTPUT_URI = "output-uri";
12486 alias GTK_PRINT_SETTINGS_OUTPUT_URI = PRINT_SETTINGS_OUTPUT_URI;
12487 
12488 enum PRINT_SETTINGS_PAGE_RANGES = "page-ranges";
12489 alias GTK_PRINT_SETTINGS_PAGE_RANGES = PRINT_SETTINGS_PAGE_RANGES;
12490 
12491 enum PRINT_SETTINGS_PAGE_SET = "page-set";
12492 alias GTK_PRINT_SETTINGS_PAGE_SET = PRINT_SETTINGS_PAGE_SET;
12493 
12494 enum PRINT_SETTINGS_PAPER_FORMAT = "paper-format";
12495 alias GTK_PRINT_SETTINGS_PAPER_FORMAT = PRINT_SETTINGS_PAPER_FORMAT;
12496 
12497 enum PRINT_SETTINGS_PAPER_HEIGHT = "paper-height";
12498 alias GTK_PRINT_SETTINGS_PAPER_HEIGHT = PRINT_SETTINGS_PAPER_HEIGHT;
12499 
12500 enum PRINT_SETTINGS_PAPER_WIDTH = "paper-width";
12501 alias GTK_PRINT_SETTINGS_PAPER_WIDTH = PRINT_SETTINGS_PAPER_WIDTH;
12502 
12503 enum PRINT_SETTINGS_PRINTER = "printer";
12504 alias GTK_PRINT_SETTINGS_PRINTER = PRINT_SETTINGS_PRINTER;
12505 
12506 enum PRINT_SETTINGS_PRINTER_LPI = "printer-lpi";
12507 alias GTK_PRINT_SETTINGS_PRINTER_LPI = PRINT_SETTINGS_PRINTER_LPI;
12508 
12509 enum PRINT_SETTINGS_PRINT_PAGES = "print-pages";
12510 alias GTK_PRINT_SETTINGS_PRINT_PAGES = PRINT_SETTINGS_PRINT_PAGES;
12511 
12512 enum PRINT_SETTINGS_QUALITY = "quality";
12513 alias GTK_PRINT_SETTINGS_QUALITY = PRINT_SETTINGS_QUALITY;
12514 
12515 enum PRINT_SETTINGS_RESOLUTION = "resolution";
12516 alias GTK_PRINT_SETTINGS_RESOLUTION = PRINT_SETTINGS_RESOLUTION;
12517 
12518 enum PRINT_SETTINGS_RESOLUTION_X = "resolution-x";
12519 alias GTK_PRINT_SETTINGS_RESOLUTION_X = PRINT_SETTINGS_RESOLUTION_X;
12520 
12521 enum PRINT_SETTINGS_RESOLUTION_Y = "resolution-y";
12522 alias GTK_PRINT_SETTINGS_RESOLUTION_Y = PRINT_SETTINGS_RESOLUTION_Y;
12523 
12524 enum PRINT_SETTINGS_REVERSE = "reverse";
12525 alias GTK_PRINT_SETTINGS_REVERSE = PRINT_SETTINGS_REVERSE;
12526 
12527 enum PRINT_SETTINGS_SCALE = "scale";
12528 alias GTK_PRINT_SETTINGS_SCALE = PRINT_SETTINGS_SCALE;
12529 
12530 enum PRINT_SETTINGS_USE_COLOR = "use-color";
12531 alias GTK_PRINT_SETTINGS_USE_COLOR = PRINT_SETTINGS_USE_COLOR;
12532 
12533 enum PRINT_SETTINGS_WIN32_DRIVER_EXTRA = "win32-driver-extra";
12534 alias GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA = PRINT_SETTINGS_WIN32_DRIVER_EXTRA;
12535 
12536 enum PRINT_SETTINGS_WIN32_DRIVER_VERSION = "win32-driver-version";
12537 alias GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION = PRINT_SETTINGS_WIN32_DRIVER_VERSION;
12538 
12539 /**
12540  * Use this priority for functionality related to size allocation.
12541  *
12542  * It is used internally by GTK+ to compute the sizes of widgets.
12543  * This priority is higher than %GDK_PRIORITY_REDRAW to avoid
12544  * resizing a widget which was just redrawn.
12545  */
12546 enum PRIORITY_RESIZE = 10;
12547 alias GTK_PRIORITY_RESIZE = PRIORITY_RESIZE;
12548 
12549 /**
12550  * A CSS class to match an accelerator.
12551  *
12552  * Refer to individual widget documentation for used style classes.
12553  */
12554 enum STYLE_CLASS_ACCELERATOR = "accelerator";
12555 alias GTK_STYLE_CLASS_ACCELERATOR = STYLE_CLASS_ACCELERATOR;
12556 
12557 /**
12558  * A CSS class used when rendering an arrow element.
12559  *
12560  * Refer to individual widget documentation for used style classes.
12561  */
12562 enum STYLE_CLASS_ARROW = "arrow";
12563 alias GTK_STYLE_CLASS_ARROW = STYLE_CLASS_ARROW;
12564 
12565 /**
12566  * A CSS class to match the window background.
12567  *
12568  * Refer to individual widget documentation for used style classes.
12569  */
12570 enum STYLE_CLASS_BACKGROUND = "background";
12571 alias GTK_STYLE_CLASS_BACKGROUND = STYLE_CLASS_BACKGROUND;
12572 
12573 /**
12574  * A CSS class to indicate an area at the bottom of a widget.
12575  *
12576  * Refer to individual widget documentation for used style classes.
12577  */
12578 enum STYLE_CLASS_BOTTOM = "bottom";
12579 alias GTK_STYLE_CLASS_BOTTOM = STYLE_CLASS_BOTTOM;
12580 
12581 /**
12582  * A CSS class to match buttons.
12583  *
12584  * Refer to individual widget documentation for used style classes.
12585  */
12586 enum STYLE_CLASS_BUTTON = "button";
12587 alias GTK_STYLE_CLASS_BUTTON = STYLE_CLASS_BUTTON;
12588 
12589 /**
12590  * A CSS class to match calendars.
12591  *
12592  * Refer to individual widget documentation for used style classes.
12593  */
12594 enum STYLE_CLASS_CALENDAR = "calendar";
12595 alias GTK_STYLE_CLASS_CALENDAR = STYLE_CLASS_CALENDAR;
12596 
12597 /**
12598  * A CSS class to match content rendered in cell views.
12599  *
12600  * Refer to individual widget documentation for used style classes.
12601  */
12602 enum STYLE_CLASS_CELL = "cell";
12603 alias GTK_STYLE_CLASS_CELL = STYLE_CLASS_CELL;
12604 
12605 /**
12606  * A CSS class to match check boxes.
12607  *
12608  * Refer to individual widget documentation for used style classes.
12609  */
12610 enum STYLE_CLASS_CHECK = "check";
12611 alias GTK_STYLE_CLASS_CHECK = STYLE_CLASS_CHECK;
12612 
12613 /**
12614  * A CSS class to match combobox entries.
12615  *
12616  * Refer to individual widget documentation for used style classes.
12617  */
12618 enum STYLE_CLASS_COMBOBOX_ENTRY = "combobox-entry";
12619 alias GTK_STYLE_CLASS_COMBOBOX_ENTRY = STYLE_CLASS_COMBOBOX_ENTRY;
12620 
12621 /**
12622  * A CSS class to match context menus.
12623  *
12624  * Refer to individual widget documentation for used style classes.
12625  */
12626 enum STYLE_CLASS_CONTEXT_MENU = "context-menu";
12627 alias GTK_STYLE_CLASS_CONTEXT_MENU = STYLE_CLASS_CONTEXT_MENU;
12628 
12629 /**
12630  * A CSS class that gets added to windows which have client-side decorations.
12631  *
12632  * Refer to individual widget documentation for used style classes.
12633  */
12634 enum STYLE_CLASS_CSD = "csd";
12635 alias GTK_STYLE_CLASS_CSD = STYLE_CLASS_CSD;
12636 
12637 /**
12638  * A CSS class used when rendering a drag handle for
12639  * text selection.
12640  *
12641  * Refer to individual widget documentation for used style classes.
12642  */
12643 enum STYLE_CLASS_CURSOR_HANDLE = "cursor-handle";
12644 alias GTK_STYLE_CLASS_CURSOR_HANDLE = STYLE_CLASS_CURSOR_HANDLE;
12645 
12646 /**
12647  * A CSS class to match the default widget.
12648  *
12649  * Refer to individual widget documentation for used style classes.
12650  */
12651 enum STYLE_CLASS_DEFAULT = "default";
12652 alias GTK_STYLE_CLASS_DEFAULT = STYLE_CLASS_DEFAULT;
12653 
12654 /**
12655  * A CSS class used when an action (usually a button) is
12656  * one that is expected to remove or destroy something visible
12657  * to the user.
12658  *
12659  * Refer to individual widget documentation for used style classes.
12660  */
12661 enum STYLE_CLASS_DESTRUCTIVE_ACTION = "destructive-action";
12662 alias GTK_STYLE_CLASS_DESTRUCTIVE_ACTION = STYLE_CLASS_DESTRUCTIVE_ACTION;
12663 
12664 /**
12665  * A CSS class to match dimmed labels.
12666  *
12667  * Refer to individual widget documentation for used style classes.
12668  */
12669 enum STYLE_CLASS_DIM_LABEL = "dim-label";
12670 alias GTK_STYLE_CLASS_DIM_LABEL = STYLE_CLASS_DIM_LABEL;
12671 
12672 /**
12673  * A CSS class for a drag-and-drop indicator.
12674  *
12675  * Refer to individual widget documentation for used style classes.
12676  */
12677 enum STYLE_CLASS_DND = "dnd";
12678 alias GTK_STYLE_CLASS_DND = STYLE_CLASS_DND;
12679 
12680 /**
12681  * A CSS class defining a dock area.
12682  *
12683  * Refer to individual widget documentation for used style classes.
12684  */
12685 enum STYLE_CLASS_DOCK = "dock";
12686 alias GTK_STYLE_CLASS_DOCK = STYLE_CLASS_DOCK;
12687 
12688 /**
12689  * A CSS class to match text entries.
12690  *
12691  * Refer to individual widget documentation for used style classes.
12692  */
12693 enum STYLE_CLASS_ENTRY = "entry";
12694 alias GTK_STYLE_CLASS_ENTRY = STYLE_CLASS_ENTRY;
12695 
12696 /**
12697  * A CSS class for an area displaying an error message,
12698  * such as those in infobars.
12699  *
12700  * Refer to individual widget documentation for used style classes.
12701  */
12702 enum STYLE_CLASS_ERROR = "error";
12703 alias GTK_STYLE_CLASS_ERROR = STYLE_CLASS_ERROR;
12704 
12705 /**
12706  * A CSS class defining an expander, such as those in treeviews.
12707  *
12708  * Refer to individual widget documentation for used style classes.
12709  */
12710 enum STYLE_CLASS_EXPANDER = "expander";
12711 alias GTK_STYLE_CLASS_EXPANDER = STYLE_CLASS_EXPANDER;
12712 
12713 /**
12714  * A CSS class that is added when widgets that usually have
12715  * a frame or border (like buttons or entries) should appear
12716  * without it.
12717  *
12718  * Refer to individual widget documentation for used style classes.
12719  */
12720 enum STYLE_CLASS_FLAT = "flat";
12721 alias GTK_STYLE_CLASS_FLAT = STYLE_CLASS_FLAT;
12722 
12723 /**
12724  * A CSS class defining a frame delimiting content, such as
12725  * #GtkFrame or the scrolled window frame around the
12726  * scrollable area.
12727  *
12728  * Refer to individual widget documentation for used style classes.
12729  */
12730 enum STYLE_CLASS_FRAME = "frame";
12731 alias GTK_STYLE_CLASS_FRAME = STYLE_CLASS_FRAME;
12732 
12733 /**
12734  * A CSS class defining a resize grip.
12735  *
12736  * Refer to individual widget documentation for used style classes.
12737  */
12738 enum STYLE_CLASS_GRIP = "grip";
12739 alias GTK_STYLE_CLASS_GRIP = STYLE_CLASS_GRIP;
12740 
12741 /**
12742  * A CSS class to match a header element.
12743  *
12744  * Refer to individual widget documentation for used style classes.
12745  */
12746 enum STYLE_CLASS_HEADER = "header";
12747 alias GTK_STYLE_CLASS_HEADER = STYLE_CLASS_HEADER;
12748 
12749 /**
12750  * A CSS class defining a highlighted area, such as headings in
12751  * assistants and calendars.
12752  *
12753  * Refer to individual widget documentation for used style classes.
12754  */
12755 enum STYLE_CLASS_HIGHLIGHT = "highlight";
12756 alias GTK_STYLE_CLASS_HIGHLIGHT = STYLE_CLASS_HIGHLIGHT;
12757 
12758 /**
12759  * A CSS class for horizontally layered widgets.
12760  *
12761  * Refer to individual widget documentation for used style classes.
12762  */
12763 enum STYLE_CLASS_HORIZONTAL = "horizontal";
12764 alias GTK_STYLE_CLASS_HORIZONTAL = STYLE_CLASS_HORIZONTAL;
12765 
12766 /**
12767  * A CSS class defining an image, such as the icon in an entry.
12768  *
12769  * Refer to individual widget documentation for used style classes.
12770  */
12771 enum STYLE_CLASS_IMAGE = "image";
12772 alias GTK_STYLE_CLASS_IMAGE = STYLE_CLASS_IMAGE;
12773 
12774 /**
12775  * A CSS class for an area displaying an informational message,
12776  * such as those in infobars.
12777  *
12778  * Refer to individual widget documentation for used style classes.
12779  */
12780 enum STYLE_CLASS_INFO = "info";
12781 alias GTK_STYLE_CLASS_INFO = STYLE_CLASS_INFO;
12782 
12783 /**
12784  * A CSS class to match inline toolbars.
12785  *
12786  * Refer to individual widget documentation for used style classes.
12787  */
12788 enum STYLE_CLASS_INLINE_TOOLBAR = "inline-toolbar";
12789 alias GTK_STYLE_CLASS_INLINE_TOOLBAR = STYLE_CLASS_INLINE_TOOLBAR;
12790 
12791 /**
12792  * A CSS class used when rendering a drag handle for
12793  * the insertion cursor position.
12794  *
12795  * Refer to individual widget documentation for used style classes.
12796  */
12797 enum STYLE_CLASS_INSERTION_CURSOR = "insertion-cursor";
12798 alias GTK_STYLE_CLASS_INSERTION_CURSOR = STYLE_CLASS_INSERTION_CURSOR;
12799 
12800 /**
12801  * A CSS class to match labels.
12802  *
12803  * Refer to individual widget documentation for used style classes.
12804  */
12805 enum STYLE_CLASS_LABEL = "label";
12806 alias GTK_STYLE_CLASS_LABEL = STYLE_CLASS_LABEL;
12807 
12808 /**
12809  * A CSS class to indicate an area at the left of a widget.
12810  *
12811  * Refer to individual widget documentation for used style classes.
12812  */
12813 enum STYLE_CLASS_LEFT = "left";
12814 alias GTK_STYLE_CLASS_LEFT = STYLE_CLASS_LEFT;
12815 
12816 /**
12817  * A CSS class used when rendering a level indicator, such
12818  * as a battery charge level, or a password strength.
12819  *
12820  * Refer to individual widget documentation for used style classes.
12821  */
12822 enum STYLE_CLASS_LEVEL_BAR = "level-bar";
12823 alias GTK_STYLE_CLASS_LEVEL_BAR = STYLE_CLASS_LEVEL_BAR;
12824 
12825 /**
12826  * A CSS class to match a linked area, such as a box containing buttons
12827  * belonging to the same control.
12828  *
12829  * Refer to individual widget documentation for used style classes.
12830  */
12831 enum STYLE_CLASS_LINKED = "linked";
12832 alias GTK_STYLE_CLASS_LINKED = STYLE_CLASS_LINKED;
12833 
12834 /**
12835  * A CSS class to match lists.
12836  *
12837  * Refer to individual widget documentation for used style classes.
12838  */
12839 enum STYLE_CLASS_LIST = "list";
12840 alias GTK_STYLE_CLASS_LIST = STYLE_CLASS_LIST;
12841 
12842 /**
12843  * A CSS class to match list rows.
12844  *
12845  * Refer to individual widget documentation for used style classes.
12846  */
12847 enum STYLE_CLASS_LIST_ROW = "list-row";
12848 alias GTK_STYLE_CLASS_LIST_ROW = STYLE_CLASS_LIST_ROW;
12849 
12850 /**
12851  * A CSS class defining marks in a widget, such as in scales.
12852  *
12853  * Refer to individual widget documentation for used style classes.
12854  */
12855 enum STYLE_CLASS_MARK = "mark";
12856 alias GTK_STYLE_CLASS_MARK = STYLE_CLASS_MARK;
12857 
12858 /**
12859  * A CSS class to match menus.
12860  *
12861  * Refer to individual widget documentation for used style classes.
12862  */
12863 enum STYLE_CLASS_MENU = "menu";
12864 alias GTK_STYLE_CLASS_MENU = STYLE_CLASS_MENU;
12865 
12866 /**
12867  * A CSS class to menubars.
12868  *
12869  * Refer to individual widget documentation for used style classes.
12870  */
12871 enum STYLE_CLASS_MENUBAR = "menubar";
12872 alias GTK_STYLE_CLASS_MENUBAR = STYLE_CLASS_MENUBAR;
12873 
12874 /**
12875  * A CSS class to match menu items.
12876  *
12877  * Refer to individual widget documentation for used style classes.
12878  */
12879 enum STYLE_CLASS_MENUITEM = "menuitem";
12880 alias GTK_STYLE_CLASS_MENUITEM = STYLE_CLASS_MENUITEM;
12881 
12882 /**
12883  * A CSS class that is added to message dialogs.
12884  *
12885  * Refer to individual widget documentation for used style classes.
12886  */
12887 enum STYLE_CLASS_MESSAGE_DIALOG = "message-dialog";
12888 alias GTK_STYLE_CLASS_MESSAGE_DIALOG = STYLE_CLASS_MESSAGE_DIALOG;
12889 
12890 /**
12891  * A CSS class that is added to text view that should use
12892  * a monospace font.
12893  *
12894  * Refer to individual widget documentation for used style classes.
12895  */
12896 enum STYLE_CLASS_MONOSPACE = "monospace";
12897 alias GTK_STYLE_CLASS_MONOSPACE = STYLE_CLASS_MONOSPACE;
12898 
12899 /**
12900  * A CSS class used when an element needs the user attention,
12901  * for instance a button in a stack switcher corresponding to
12902  * a hidden page that changed state.
12903  *
12904  * Refer to individual widget documentation for used style classes.
12905  */
12906 enum STYLE_CLASS_NEEDS_ATTENTION = "needs-attention";
12907 alias GTK_STYLE_CLASS_NEEDS_ATTENTION = STYLE_CLASS_NEEDS_ATTENTION;
12908 
12909 /**
12910  * A CSS class defining a notebook.
12911  *
12912  * Refer to individual widget documentation for used style classes.
12913  */
12914 enum STYLE_CLASS_NOTEBOOK = "notebook";
12915 alias GTK_STYLE_CLASS_NOTEBOOK = STYLE_CLASS_NOTEBOOK;
12916 
12917 /**
12918  * A CSS class used when rendering an OSD (On Screen Display) element,
12919  * on top of another container.
12920  *
12921  * Refer to individual widget documentation for used style classes.
12922  */
12923 enum STYLE_CLASS_OSD = "osd";
12924 alias GTK_STYLE_CLASS_OSD = STYLE_CLASS_OSD;
12925 
12926 /**
12927  * A CSS class that is added on the visual hints that happen
12928  * when scrolling is attempted past the limits of a scrollable
12929  * area.
12930  *
12931  * Refer to individual widget documentation for used style classes.
12932  */
12933 enum STYLE_CLASS_OVERSHOOT = "overshoot";
12934 alias GTK_STYLE_CLASS_OVERSHOOT = STYLE_CLASS_OVERSHOOT;
12935 
12936 /**
12937  * A CSS class for a pane separator, such as those in #GtkPaned.
12938  *
12939  * Refer to individual widget documentation for used style classes.
12940  */
12941 enum STYLE_CLASS_PANE_SEPARATOR = "pane-separator";
12942 alias GTK_STYLE_CLASS_PANE_SEPARATOR = STYLE_CLASS_PANE_SEPARATOR;
12943 
12944 /**
12945  * A CSS class that is added to areas that should look like paper.
12946  *
12947  * This is used in print previews and themes are encouraged to
12948  * style it as black text on white background.
12949  *
12950  * Refer to individual widget documentation for used style classes.
12951  */
12952 enum STYLE_CLASS_PAPER = "paper";
12953 alias GTK_STYLE_CLASS_PAPER = STYLE_CLASS_PAPER;
12954 
12955 /**
12956  * A CSS class that matches popovers.
12957  *
12958  * Refer to individual widget documentation for used style classes.
12959  */
12960 enum STYLE_CLASS_POPOVER = "popover";
12961 alias GTK_STYLE_CLASS_POPOVER = STYLE_CLASS_POPOVER;
12962 
12963 /**
12964  * A CSS class that is added to the toplevel windows used for menus.
12965  *
12966  * Refer to individual widget documentation for used style classes.
12967  */
12968 enum STYLE_CLASS_POPUP = "popup";
12969 alias GTK_STYLE_CLASS_POPUP = STYLE_CLASS_POPUP;
12970 
12971 /**
12972  * A CSS class to match primary toolbars.
12973  *
12974  * Refer to individual widget documentation for used style classes.
12975  */
12976 enum STYLE_CLASS_PRIMARY_TOOLBAR = "primary-toolbar";
12977 alias GTK_STYLE_CLASS_PRIMARY_TOOLBAR = STYLE_CLASS_PRIMARY_TOOLBAR;
12978 
12979 /**
12980  * A CSS class to use when rendering activity as a progressbar.
12981  *
12982  * Refer to individual widget documentation for used style classes.
12983  */
12984 enum STYLE_CLASS_PROGRESSBAR = "progressbar";
12985 alias GTK_STYLE_CLASS_PROGRESSBAR = STYLE_CLASS_PROGRESSBAR;
12986 
12987 /**
12988  * A CSS class to use when rendering a pulse in an indeterminate progress bar.
12989  *
12990  * Refer to individual widget documentation for used style classes.
12991  */
12992 enum STYLE_CLASS_PULSE = "pulse";
12993 alias GTK_STYLE_CLASS_PULSE = STYLE_CLASS_PULSE;
12994 
12995 /**
12996  * A CSS class for an area displaying a question to the user,
12997  * such as those in infobars.
12998  *
12999  * Refer to individual widget documentation for used style classes.
13000  */
13001 enum STYLE_CLASS_QUESTION = "question";
13002 alias GTK_STYLE_CLASS_QUESTION = STYLE_CLASS_QUESTION;
13003 
13004 /**
13005  * A CSS class to match radio buttons.
13006  *
13007  * Refer to individual widget documentation for used style classes.
13008  */
13009 enum STYLE_CLASS_RADIO = "radio";
13010 alias GTK_STYLE_CLASS_RADIO = STYLE_CLASS_RADIO;
13011 
13012 /**
13013  * A CSS class to match a raised control, such as a raised
13014  * button on a toolbar.
13015  *
13016  * Refer to individual widget documentation for used style classes.
13017  */
13018 enum STYLE_CLASS_RAISED = "raised";
13019 alias GTK_STYLE_CLASS_RAISED = STYLE_CLASS_RAISED;
13020 
13021 /**
13022  * A CSS class used to indicate a read-only state.
13023  *
13024  * Refer to individual widget documentation for used style classes.
13025  */
13026 enum STYLE_CLASS_READ_ONLY = "read-only";
13027 alias GTK_STYLE_CLASS_READ_ONLY = STYLE_CLASS_READ_ONLY;
13028 
13029 /**
13030  * A CSS class to indicate an area at the right of a widget.
13031  *
13032  * Refer to individual widget documentation for used style classes.
13033  */
13034 enum STYLE_CLASS_RIGHT = "right";
13035 alias GTK_STYLE_CLASS_RIGHT = STYLE_CLASS_RIGHT;
13036 
13037 /**
13038  * A CSS class to match the rubberband selection rectangle.
13039  *
13040  * Refer to individual widget documentation for used style classes.
13041  */
13042 enum STYLE_CLASS_RUBBERBAND = "rubberband";
13043 alias GTK_STYLE_CLASS_RUBBERBAND = STYLE_CLASS_RUBBERBAND;
13044 
13045 /**
13046  * A CSS class to match scale widgets.
13047  *
13048  * Refer to individual widget documentation for used style classes.
13049  */
13050 enum STYLE_CLASS_SCALE = "scale";
13051 alias GTK_STYLE_CLASS_SCALE = STYLE_CLASS_SCALE;
13052 
13053 /**
13054  * A CSS class to match scale widgets with marks attached,
13055  * all the marks are above for horizontal #GtkScale.
13056  * left for vertical #GtkScale.
13057  *
13058  * Refer to individual widget documentation for used style classes.
13059  */
13060 enum STYLE_CLASS_SCALE_HAS_MARKS_ABOVE = "scale-has-marks-above";
13061 alias GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE = STYLE_CLASS_SCALE_HAS_MARKS_ABOVE;
13062 
13063 /**
13064  * A CSS class to match scale widgets with marks attached,
13065  * all the marks are below for horizontal #GtkScale,
13066  * right for vertical #GtkScale.
13067  *
13068  * Refer to individual widget documentation for used style classes.
13069  */
13070 enum STYLE_CLASS_SCALE_HAS_MARKS_BELOW = "scale-has-marks-below";
13071 alias GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW = STYLE_CLASS_SCALE_HAS_MARKS_BELOW;
13072 
13073 /**
13074  * A CSS class to match scrollbars.
13075  *
13076  * Refer to individual widget documentation for used style classes.
13077  */
13078 enum STYLE_CLASS_SCROLLBAR = "scrollbar";
13079 alias GTK_STYLE_CLASS_SCROLLBAR = STYLE_CLASS_SCROLLBAR;
13080 
13081 /**
13082  * A CSS class to match the junction area between an horizontal
13083  * and vertical scrollbar, when they’re both shown.
13084  *
13085  * Refer to individual widget documentation for used style classes.
13086  */
13087 enum STYLE_CLASS_SCROLLBARS_JUNCTION = "scrollbars-junction";
13088 alias GTK_STYLE_CLASS_SCROLLBARS_JUNCTION = STYLE_CLASS_SCROLLBARS_JUNCTION;
13089 
13090 /**
13091  * A CSS class for a separator.
13092  *
13093  * Refer to individual widget documentation for used style classes.
13094  */
13095 enum STYLE_CLASS_SEPARATOR = "separator";
13096 alias GTK_STYLE_CLASS_SEPARATOR = STYLE_CLASS_SEPARATOR;
13097 
13098 /**
13099  * A CSS class defining a sidebar, such as the left side in
13100  * a file chooser.
13101  *
13102  * Refer to individual widget documentation for used style classes.
13103  */
13104 enum STYLE_CLASS_SIDEBAR = "sidebar";
13105 alias GTK_STYLE_CLASS_SIDEBAR = STYLE_CLASS_SIDEBAR;
13106 
13107 /**
13108  * A CSS class to match sliders.
13109  *
13110  * Refer to individual widget documentation for used style classes.
13111  */
13112 enum STYLE_CLASS_SLIDER = "slider";
13113 alias GTK_STYLE_CLASS_SLIDER = STYLE_CLASS_SLIDER;
13114 
13115 /**
13116  * A CSS class defining an spinbutton.
13117  *
13118  * Refer to individual widget documentation for used style classes.
13119  */
13120 enum STYLE_CLASS_SPINBUTTON = "spinbutton";
13121 alias GTK_STYLE_CLASS_SPINBUTTON = STYLE_CLASS_SPINBUTTON;
13122 
13123 /**
13124  * A CSS class to use when rendering activity as a “spinner”.
13125  *
13126  * Refer to individual widget documentation for used style classes.
13127  */
13128 enum STYLE_CLASS_SPINNER = "spinner";
13129 alias GTK_STYLE_CLASS_SPINNER = STYLE_CLASS_SPINNER;
13130 
13131 /**
13132  * A CSS class to match statusbars.
13133  *
13134  * Refer to individual widget documentation for used style classes.
13135  */
13136 enum STYLE_CLASS_STATUSBAR = "statusbar";
13137 alias GTK_STYLE_CLASS_STATUSBAR = STYLE_CLASS_STATUSBAR;
13138 
13139 /**
13140  * A CSS class used for the subtitle label in a titlebar in
13141  * a toplevel window.
13142  *
13143  * Refer to individual widget documentation for used style classes.
13144  */
13145 enum STYLE_CLASS_SUBTITLE = "subtitle";
13146 alias GTK_STYLE_CLASS_SUBTITLE = STYLE_CLASS_SUBTITLE;
13147 
13148 /**
13149  * A CSS class used when an action (usually a button) is the
13150  * primary suggested action in a specific context.
13151  *
13152  * Refer to individual widget documentation for used style classes.
13153  */
13154 enum STYLE_CLASS_SUGGESTED_ACTION = "suggested-action";
13155 alias GTK_STYLE_CLASS_SUGGESTED_ACTION = STYLE_CLASS_SUGGESTED_ACTION;
13156 
13157 /**
13158  * A CSS class used for the title label in a titlebar in
13159  * a toplevel window.
13160  *
13161  * Refer to individual widget documentation for used style classes.
13162  */
13163 enum STYLE_CLASS_TITLE = "title";
13164 alias GTK_STYLE_CLASS_TITLE = STYLE_CLASS_TITLE;
13165 
13166 /**
13167  * A CSS class used when rendering a titlebar in a toplevel window.
13168  *
13169  * Refer to individual widget documentation for used style classes.
13170  */
13171 enum STYLE_CLASS_TITLEBAR = "titlebar";
13172 alias GTK_STYLE_CLASS_TITLEBAR = STYLE_CLASS_TITLEBAR;
13173 
13174 /**
13175  * A CSS class to match toolbars.
13176  *
13177  * Refer to individual widget documentation for used style classes.
13178  */
13179 enum STYLE_CLASS_TOOLBAR = "toolbar";
13180 alias GTK_STYLE_CLASS_TOOLBAR = STYLE_CLASS_TOOLBAR;
13181 
13182 /**
13183  * A CSS class to match tooltip windows.
13184  *
13185  * Refer to individual widget documentation for used style classes.
13186  */
13187 enum STYLE_CLASS_TOOLTIP = "tooltip";
13188 alias GTK_STYLE_CLASS_TOOLTIP = STYLE_CLASS_TOOLTIP;
13189 
13190 /**
13191  * A CSS class to indicate an area at the top of a widget.
13192  *
13193  * Refer to individual widget documentation for used style classes.
13194  */
13195 enum STYLE_CLASS_TOP = "top";
13196 alias GTK_STYLE_CLASS_TOP = STYLE_CLASS_TOP;
13197 
13198 /**
13199  * A CSS class for touch selection popups on entries
13200  * and text views.
13201  *
13202  * Refer to individual widget documentation for used style classes.
13203  */
13204 enum STYLE_CLASS_TOUCH_SELECTION = "touch-selection";
13205 alias GTK_STYLE_CLASS_TOUCH_SELECTION = STYLE_CLASS_TOUCH_SELECTION;
13206 
13207 /**
13208  * A CSS class to match troughs, as in scrollbars and progressbars.
13209  *
13210  * Refer to individual widget documentation for used style classes.
13211  */
13212 enum STYLE_CLASS_TROUGH = "trough";
13213 alias GTK_STYLE_CLASS_TROUGH = STYLE_CLASS_TROUGH;
13214 
13215 /**
13216  * A CSS class that is added on the visual hints that happen
13217  * where content is 'scrolled off' and can be made visible
13218  * by scrolling.
13219  *
13220  * Refer to individual widget documentation for used style classes.
13221  */
13222 enum STYLE_CLASS_UNDERSHOOT = "undershoot";
13223 alias GTK_STYLE_CLASS_UNDERSHOOT = STYLE_CLASS_UNDERSHOOT;
13224 
13225 /**
13226  * A CSS class for vertically layered widgets.
13227  *
13228  * Refer to individual widget documentation for used style classes.
13229  */
13230 enum STYLE_CLASS_VERTICAL = "vertical";
13231 alias GTK_STYLE_CLASS_VERTICAL = STYLE_CLASS_VERTICAL;
13232 
13233 /**
13234  * A CSS class defining a view, such as iconviews or treeviews.
13235  *
13236  * Refer to individual widget documentation for used style classes.
13237  */
13238 enum STYLE_CLASS_VIEW = "view";
13239 alias GTK_STYLE_CLASS_VIEW = STYLE_CLASS_VIEW;
13240 
13241 /**
13242  * A CSS class for an area displaying a warning message,
13243  * such as those in infobars.
13244  *
13245  * Refer to individual widget documentation for used style classes.
13246  */
13247 enum STYLE_CLASS_WARNING = "warning";
13248 alias GTK_STYLE_CLASS_WARNING = STYLE_CLASS_WARNING;
13249 
13250 /**
13251  * A CSS class to indicate that a UI element should be 'wide'.
13252  * Used by #GtkPaned.
13253  *
13254  * Refer to individual widget documentation for used style classes.
13255  */
13256 enum STYLE_CLASS_WIDE = "wide";
13257 alias GTK_STYLE_CLASS_WIDE = STYLE_CLASS_WIDE;
13258 
13259 /**
13260  * A property holding the background color of rendered elements as a #GdkRGBA.
13261  */
13262 enum STYLE_PROPERTY_BACKGROUND_COLOR = "background-color";
13263 alias GTK_STYLE_PROPERTY_BACKGROUND_COLOR = STYLE_PROPERTY_BACKGROUND_COLOR;
13264 
13265 /**
13266  * A property holding the element’s background as a #cairo_pattern_t.
13267  */
13268 enum STYLE_PROPERTY_BACKGROUND_IMAGE = "background-image";
13269 alias GTK_STYLE_PROPERTY_BACKGROUND_IMAGE = STYLE_PROPERTY_BACKGROUND_IMAGE;
13270 
13271 /**
13272  * A property holding the element’s border color as a #GdkRGBA.
13273  */
13274 enum STYLE_PROPERTY_BORDER_COLOR = "border-color";
13275 alias GTK_STYLE_PROPERTY_BORDER_COLOR = STYLE_PROPERTY_BORDER_COLOR;
13276 
13277 /**
13278  * A property holding the rendered element’s border radius in pixels as a #gint.
13279  */
13280 enum STYLE_PROPERTY_BORDER_RADIUS = "border-radius";
13281 alias GTK_STYLE_PROPERTY_BORDER_RADIUS = STYLE_PROPERTY_BORDER_RADIUS;
13282 
13283 /**
13284  * A property holding the element’s border style as a #GtkBorderStyle.
13285  */
13286 enum STYLE_PROPERTY_BORDER_STYLE = "border-style";
13287 alias GTK_STYLE_PROPERTY_BORDER_STYLE = STYLE_PROPERTY_BORDER_STYLE;
13288 
13289 /**
13290  * A property holding the rendered element’s border width in pixels as
13291  * a #GtkBorder. The border is the intermediary spacing property of the
13292  * padding/border/margin series.
13293  *
13294  * gtk_render_frame() uses this property to find out the frame line width,
13295  * so #GtkWidgets rendering frames may need to add up this padding when
13296  * requesting size
13297  */
13298 enum STYLE_PROPERTY_BORDER_WIDTH = "border-width";
13299 alias GTK_STYLE_PROPERTY_BORDER_WIDTH = STYLE_PROPERTY_BORDER_WIDTH;
13300 
13301 /**
13302  * A property holding the foreground color of rendered elements as a #GdkRGBA.
13303  */
13304 enum STYLE_PROPERTY_COLOR = "color";
13305 alias GTK_STYLE_PROPERTY_COLOR = STYLE_PROPERTY_COLOR;
13306 
13307 /**
13308  * A property holding the font properties used when rendering text
13309  * as a #PangoFontDescription.
13310  */
13311 enum STYLE_PROPERTY_FONT = "font";
13312 alias GTK_STYLE_PROPERTY_FONT = STYLE_PROPERTY_FONT;
13313 
13314 /**
13315  * A property holding the rendered element’s margin as a #GtkBorder. The
13316  * margin is defined as the spacing between the border of the element
13317  * and its surrounding elements. It is external to #GtkWidget's
13318  * size allocations, and the most external spacing property of the
13319  * padding/border/margin series.
13320  */
13321 enum STYLE_PROPERTY_MARGIN = "margin";
13322 alias GTK_STYLE_PROPERTY_MARGIN = STYLE_PROPERTY_MARGIN;
13323 
13324 /**
13325  * A property holding the rendered element’s padding as a #GtkBorder. The
13326  * padding is defined as the spacing between the inner part of the element border
13327  * and its child. It’s the innermost spacing property of the padding/border/margin
13328  * series.
13329  */
13330 enum STYLE_PROPERTY_PADDING = "padding";
13331 alias GTK_STYLE_PROPERTY_PADDING = STYLE_PROPERTY_PADDING;
13332 
13333 /**
13334  * A priority that can be used when adding a #GtkStyleProvider
13335  * for application-specific style information.
13336  */
13337 enum STYLE_PROVIDER_PRIORITY_APPLICATION = 600;
13338 alias GTK_STYLE_PROVIDER_PRIORITY_APPLICATION = STYLE_PROVIDER_PRIORITY_APPLICATION;
13339 
13340 /**
13341  * The priority used for default style information
13342  * that is used in the absence of themes.
13343  *
13344  * Note that this is not very useful for providing default
13345  * styling for custom style classes - themes are likely to
13346  * override styling provided at this priority with
13347  * catch-all `* {...}` rules.
13348  */
13349 enum STYLE_PROVIDER_PRIORITY_FALLBACK = 1;
13350 alias GTK_STYLE_PROVIDER_PRIORITY_FALLBACK = STYLE_PROVIDER_PRIORITY_FALLBACK;
13351 
13352 /**
13353  * The priority used for style information provided
13354  * via #GtkSettings.
13355  *
13356  * This priority is higher than #GTK_STYLE_PROVIDER_PRIORITY_THEME
13357  * to let settings override themes.
13358  */
13359 enum STYLE_PROVIDER_PRIORITY_SETTINGS = 400;
13360 alias GTK_STYLE_PROVIDER_PRIORITY_SETTINGS = STYLE_PROVIDER_PRIORITY_SETTINGS;
13361 
13362 /**
13363  * The priority used for style information provided
13364  * by themes.
13365  */
13366 enum STYLE_PROVIDER_PRIORITY_THEME = 200;
13367 alias GTK_STYLE_PROVIDER_PRIORITY_THEME = STYLE_PROVIDER_PRIORITY_THEME;
13368 
13369 /**
13370  * The priority used for the style information from
13371  * `~/.gtk-3.0.css`.
13372  *
13373  * You should not use priorities higher than this, to
13374  * give the user the last word.
13375  */
13376 enum STYLE_PROVIDER_PRIORITY_USER = 800;
13377 alias GTK_STYLE_PROVIDER_PRIORITY_USER = STYLE_PROVIDER_PRIORITY_USER;
13378 
13379 /**
13380  * A widget region name to define a treeview column.
13381  *
13382  * Deprecated: Don't use regions.
13383  */
13384 enum STYLE_REGION_COLUMN = "column";
13385 alias GTK_STYLE_REGION_COLUMN = STYLE_REGION_COLUMN;
13386 
13387 /**
13388  * A widget region name to define a treeview column header.
13389  *
13390  * Deprecated: Don't use regions.
13391  */
13392 enum STYLE_REGION_COLUMN_HEADER = "column-header";
13393 alias GTK_STYLE_REGION_COLUMN_HEADER = STYLE_REGION_COLUMN_HEADER;
13394 
13395 /**
13396  * A widget region name to define a treeview row.
13397  *
13398  * Deprecated: Don't use regions.
13399  */
13400 enum STYLE_REGION_ROW = "row";
13401 alias GTK_STYLE_REGION_ROW = STYLE_REGION_ROW;
13402 
13403 /**
13404  * A widget region name to define a notebook tab.
13405  *
13406  * Deprecated: Don't use regions.
13407  */
13408 enum STYLE_REGION_TAB = "tab";
13409 alias GTK_STYLE_REGION_TAB = STYLE_REGION_TAB;
13410 
13411 /**
13412  * The priority at which the text view validates onscreen lines
13413  * in an idle job in the background.
13414  */
13415 enum TEXT_VIEW_PRIORITY_VALIDATE = 5;
13416 alias GTK_TEXT_VIEW_PRIORITY_VALIDATE = TEXT_VIEW_PRIORITY_VALIDATE;
13417 
13418 /**
13419  * The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
13420  * #GtkTreeSortable use the default sort function.
13421  *
13422  * See also gtk_tree_sortable_set_sort_column_id()
13423  */
13424 enum TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = -1;
13425 alias GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID;
13426 
13427 /**
13428  * The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
13429  * #GtkTreeSortable use no sorting.
13430  *
13431  * See also gtk_tree_sortable_set_sort_column_id()
13432  */
13433 enum TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID = -2;
13434 alias GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID = TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID;
13435 
13436 /**
13437  * StockIds
13438  */
13439 public enum StockID
13440 {
13441 	/**
13442 	 * The “About” item.
13443 	 * ![](help-about.png)
13444 	 *
13445 	 * Deprecated: Use named icon &quot;help-about&quot; or the label &quot;_About&quot;.
13446 	 */
13447 	ABOUT = "gtk-about",
13448 	/**
13449 	 * The “Add” item and icon.
13450 	 *
13451 	 * Deprecated: Use named icon &quot;list-add&quot; or the label &quot;_Add&quot;.
13452 	 */
13453 	ADD = "gtk-add",
13454 	/**
13455 	 * The “Apply” item and icon.
13456 	 *
13457 	 * Deprecated: Do not use an icon. Use label &quot;_Apply&quot;.
13458 	 */
13459 	APPLY = "gtk-apply",
13460 	/**
13461 	 * The “Bold” item and icon.
13462 	 *
13463 	 * Deprecated: Use named icon &quot;format-text-bold&quot;.
13464 	 */
13465 	BOLD = "gtk-bold",
13466 	/**
13467 	 * The “Cancel” item and icon.
13468 	 *
13469 	 * Deprecated: Do not use an icon. Use label &quot;_Cancel&quot;.
13470 	 */
13471 	CANCEL = "gtk-cancel",
13472 	/**
13473 	 * The “Caps Lock Warning” icon.
13474 	 *
13475 	 * Deprecated: Use named icon &quot;dialog-warning-symbolic&quot;.
13476 	 */
13477 	CAPS_LOCK_WARNING = "gtk-caps-lock-warning",
13478 	/**
13479 	 * The “CD-Rom” item and icon.
13480 	 *
13481 	 * Deprecated: Use named icon &quot;media-optical&quot;.
13482 	 */
13483 	CDROM = "gtk-cdrom",
13484 	/**
13485 	 * The “Clear” item and icon.
13486 	 *
13487 	 * Deprecated: Use named icon &quot;edit-clear&quot;.
13488 	 */
13489 	CLEAR = "gtk-clear",
13490 	/**
13491 	 * The “Close” item and icon.
13492 	 *
13493 	 * Deprecated: Use named icon &quot;window-close&quot; or the label &quot;_Close&quot;.
13494 	 */
13495 	CLOSE = "gtk-close",
13496 	/**
13497 	 * The “Color Picker” item and icon.
13498 	 */
13499 	COLOR_PICKER = "gtk-color-picker",
13500 	/**
13501 	 * The “Connect” icon.
13502 	 */
13503 	CONNECT = "gtk-connect",
13504 	/**
13505 	 * The “Convert” item and icon.
13506 	 */
13507 	CONVERT = "gtk-convert",
13508 	/**
13509 	 * The “Copy” item and icon.
13510 	 *
13511 	 * Deprecated: Use the named icon &quot;edit-copy&quot; or the label &quot;_Copy&quot;.
13512 	 */
13513 	COPY = "gtk-copy",
13514 	/**
13515 	 * The “Cut” item and icon.
13516 	 *
13517 	 * Deprecated: Use the named icon &quot;edit-cut&quot; or the label &quot;Cu_t&quot;.
13518 	 */
13519 	CUT = "gtk-cut",
13520 	/**
13521 	 * The “Delete” item and icon.
13522 	 *
13523 	 * Deprecated: Use the named icon &quot;edit-delete&quot; or the label &quot;_Delete&quot;.
13524 	 */
13525 	DELETE = "gtk-delete",
13526 	/**
13527 	 * The “Authentication” item and icon.
13528 	 *
13529 	 * Deprecated: Use named icon &quot;dialog-password&quot;.
13530 	 */
13531 	DIALOG_AUTHENTICATION = "gtk-dialog-authentication",
13532 	/**
13533 	 * The “Error” item and icon.
13534 	 *
13535 	 * Deprecated: Use named icon &quot;dialog-error&quot;.
13536 	 */
13537 	DIALOG_ERROR = "gtk-dialog-error",
13538 	/**
13539 	 * The “Information” item and icon.
13540 	 *
13541 	 * Deprecated: Use named icon &quot;dialog-information&quot;.
13542 	 */
13543 	DIALOG_INFO = "gtk-dialog-info",
13544 	/**
13545 	 * The “Question” item and icon.
13546 	 *
13547 	 * Deprecated: Use named icon &quot;dialog-question&quot;.
13548 	 */
13549 	DIALOG_QUESTION = "gtk-dialog-question",
13550 	/**
13551 	 * The “Warning” item and icon.
13552 	 *
13553 	 * Deprecated: Use named icon &quot;dialog-warning&quot;.
13554 	 */
13555 	DIALOG_WARNING = "gtk-dialog-warning",
13556 	/**
13557 	 * The “Directory” icon.
13558 	 *
13559 	 * Deprecated: Use named icon &quot;folder&quot;.
13560 	 */
13561 	DIRECTORY = "gtk-directory",
13562 	/**
13563 	 * The “Discard” item.
13564 	 */
13565 	DISCARD = "gtk-discard",
13566 	/**
13567 	 * The “Disconnect” icon.
13568 	 */
13569 	DISCONNECT = "gtk-disconnect",
13570 	/**
13571 	 * The “Drag-And-Drop” icon.
13572 	 */
13573 	DND = "gtk-dnd",
13574 	/**
13575 	 * The “Drag-And-Drop multiple” icon.
13576 	 */
13577 	DND_MULTIPLE = "gtk-dnd-multiple",
13578 	/**
13579 	 * The “Edit” item and icon.
13580 	 */
13581 	EDIT = "gtk-edit",
13582 	/**
13583 	 * The “Execute” item and icon.
13584 	 *
13585 	 * Deprecated: Use named icon &quot;system-run&quot;.
13586 	 */
13587 	EXECUTE = "gtk-execute",
13588 	/**
13589 	 * The “File” item and icon.
13590 	 *
13591 	 * Since 3.0, this item has a label, before it only had an icon.
13592 	 *
13593 	 * Deprecated: Use named icon &quot;text-x-generic&quot;.
13594 	 */
13595 	FILE = "gtk-file",
13596 	/**
13597 	 * The “Find” item and icon.
13598 	 *
13599 	 * Deprecated: Use named icon &quot;edit-find&quot;.
13600 	 */
13601 	FIND = "gtk-find",
13602 	/**
13603 	 * The “Find and Replace” item and icon.
13604 	 *
13605 	 * Deprecated: Use named icon &quot;edit-find-replace&quot;.
13606 	 */
13607 	FIND_AND_REPLACE = "gtk-find-and-replace",
13608 	/**
13609 	 * The “Floppy” item and icon.
13610 	 */
13611 	FLOPPY = "gtk-floppy",
13612 	/**
13613 	 * The “Fullscreen” item and icon.
13614 	 *
13615 	 * Deprecated: Use named icon &quot;view-fullscreen&quot;.
13616 	 */
13617 	FULLSCREEN = "gtk-fullscreen",
13618 	/**
13619 	 * The “Bottom” item and icon.
13620 	 *
13621 	 * Deprecated: Use named icon &quot;go-bottom&quot;.
13622 	 */
13623 	GOTO_BOTTOM = "gtk-goto-bottom",
13624 	/**
13625 	 * The “First” item and icon. The icon has an RTL variant.
13626 	 *
13627 	 * Deprecated: Use named icon &quot;go-first&quot;.
13628 	 */
13629 	GOTO_FIRST = "gtk-goto-first",
13630 	/**
13631 	 * The “Last” item and icon. The icon has an RTL variant.
13632 	 *
13633 	 * Deprecated: Use named icon &quot;go-last&quot;.
13634 	 */
13635 	GOTO_LAST = "gtk-goto-last",
13636 	/**
13637 	 * The “Top” item and icon.
13638 	 *
13639 	 * Deprecated: Use named icon &quot;go-top&quot;.
13640 	 */
13641 	GOTO_TOP = "gtk-goto-top",
13642 	/**
13643 	 * The “Back” item and icon. The icon has an RTL variant.
13644 	 *
13645 	 * Deprecated: Use named icon &quot;go-previous&quot;.
13646 	 */
13647 	GO_BACK = "gtk-go-back",
13648 	/**
13649 	 * The “Down” item and icon.
13650 	 *
13651 	 * Deprecated: Use named icon &quot;go-down&quot;.
13652 	 */
13653 	GO_DOWN = "gtk-go-down",
13654 	/**
13655 	 * The “Forward” item and icon. The icon has an RTL variant.
13656 	 *
13657 	 * Deprecated: Use named icon &quot;go-next&quot;.
13658 	 */
13659 	GO_FORWARD = "gtk-go-forward",
13660 	/**
13661 	 * The “Up” item and icon.
13662 	 *
13663 	 * Deprecated: Use named icon &quot;go-up&quot;.
13664 	 */
13665 	GO_UP = "gtk-go-up",
13666 	/**
13667 	 * The “Harddisk” item and icon.
13668 	 *
13669 	 * Deprecated: Use named icon &quot;drive-harddisk&quot;.
13670 	 */
13671 	HARDDISK = "gtk-harddisk",
13672 	/**
13673 	 * The “Help” item and icon.
13674 	 *
13675 	 * Deprecated: Use named icon &quot;help-browser&quot;.
13676 	 */
13677 	HELP = "gtk-help",
13678 	/**
13679 	 * The “Home” item and icon.
13680 	 *
13681 	 * Deprecated: Use named icon &quot;go-home&quot;.
13682 	 */
13683 	HOME = "gtk-home",
13684 	/**
13685 	 * The “Indent” item and icon. The icon has an RTL variant.
13686 	 *
13687 	 * Deprecated: Use named icon &quot;format-indent-more&quot;.
13688 	 */
13689 	INDENT = "gtk-indent",
13690 	/**
13691 	 * The “Index” item and icon.
13692 	 */
13693 	INDEX = "gtk-index",
13694 	/**
13695 	 * The “Info” item and icon.
13696 	 *
13697 	 * Deprecated: Use named icon &quot;dialog-information&quot;.
13698 	 */
13699 	INFO = "gtk-info",
13700 	/**
13701 	 * The “Italic” item and icon.
13702 	 *
13703 	 * Deprecated: Use named icon &quot;format-text-italic&quot;.
13704 	 */
13705 	ITALIC = "gtk-italic",
13706 	/**
13707 	 * The “Jump to” item and icon. The icon has an RTL variant.
13708 	 *
13709 	 * Deprecated: Use named icon &quot;go-jump&quot;.
13710 	 */
13711 	JUMP_TO = "gtk-jump-to",
13712 	/**
13713 	 * The “Center” item and icon.
13714 	 *
13715 	 * Deprecated: Use named icon &quot;format-justify-center&quot;.
13716 	 */
13717 	JUSTIFY_CENTER = "gtk-justify-center",
13718 	/**
13719 	 * The “Fill” item and icon.
13720 	 *
13721 	 * Deprecated: Use named icon &quot;format-justify-fill&quot;.
13722 	 */
13723 	JUSTIFY_FILL = "gtk-justify-fill",
13724 	/**
13725 	 * The “Left” item and icon.
13726 	 *
13727 	 * Deprecated: Use named icon &quot;format-justify-left&quot;.
13728 	 */
13729 	JUSTIFY_LEFT = "gtk-justify-left",
13730 	/**
13731 	 * The “Right” item and icon.
13732 	 *
13733 	 * Deprecated: Use named icon &quot;format-justify-right&quot;.
13734 	 */
13735 	JUSTIFY_RIGHT = "gtk-justify-right",
13736 	/**
13737 	 * The “Leave Fullscreen” item and icon.
13738 	 *
13739 	 * Deprecated: Use named icon &quot;view-restore&quot;.
13740 	 */
13741 	LEAVE_FULLSCREEN = "gtk-leave-fullscreen",
13742 	/**
13743 	 * The “Media Forward” item and icon. The icon has an RTL variant.
13744 	 *
13745 	 * Deprecated: Use named icon &quot;media-seek-forward&quot; or the label &quot;_Forward&quot;.
13746 	 */
13747 	MEDIA_FORWARD = "gtk-media-forward",
13748 	/**
13749 	 * The “Media Next” item and icon. The icon has an RTL variant.
13750 	 *
13751 	 * Deprecated: Use named icon &quot;media-skip-forward&quot; or the label &quot;_Next&quot;.
13752 	 */
13753 	MEDIA_NEXT = "gtk-media-next",
13754 	/**
13755 	 * The “Media Pause” item and icon.
13756 	 *
13757 	 * Deprecated: Use named icon &quot;media-playback-pause&quot; or the label &quot;P_ause&quot;.
13758 	 */
13759 	MEDIA_PAUSE = "gtk-media-pause",
13760 	/**
13761 	 * The “Media Play” item and icon. The icon has an RTL variant.
13762 	 *
13763 	 * Deprecated: Use named icon &quot;media-playback-start&quot; or the label &quot;_Play&quot;.
13764 	 */
13765 	MEDIA_PLAY = "gtk-media-play",
13766 	/**
13767 	 * The “Media Previous” item and icon. The icon has an RTL variant.
13768 	 *
13769 	 * Deprecated: Use named icon &quot;media-skip-backward&quot; or the label &quot;Pre_vious&quot;.
13770 	 */
13771 	MEDIA_PREVIOUS = "gtk-media-previous",
13772 	/**
13773 	 * The “Media Record” item and icon.
13774 	 *
13775 	 * Deprecated: Use named icon &quot;media-record&quot; or the label &quot;_Record&quot;.
13776 	 */
13777 	MEDIA_RECORD = "gtk-media-record",
13778 	/**
13779 	 * The “Media Rewind” item and icon. The icon has an RTL variant.
13780 	 *
13781 	 * Deprecated: Use named icon &quot;media-seek-backward&quot; or the label &quot;R_ewind&quot;.
13782 	 */
13783 	MEDIA_REWIND = "gtk-media-rewind",
13784 	/**
13785 	 * The “Media Stop” item and icon.
13786 	 *
13787 	 * Deprecated: Use named icon &quot;media-playback-stop&quot; or the label &quot;_Stop&quot;.
13788 	 */
13789 	MEDIA_STOP = "gtk-media-stop",
13790 	/**
13791 	 * The “Missing image” icon.
13792 	 *
13793 	 * Deprecated: Use named icon &quot;image-missing&quot;.
13794 	 */
13795 	MISSING_IMAGE = "gtk-missing-image",
13796 	/**
13797 	 * The “Network” item and icon.
13798 	 *
13799 	 * Deprecated: Use named icon &quot;network-workgroup&quot;.
13800 	 */
13801 	NETWORK = "gtk-network",
13802 	/**
13803 	 * The “New” item and icon.
13804 	 *
13805 	 * Deprecated: Use named icon &quot;document-new&quot; or the label &quot;_New&quot;.
13806 	 */
13807 	NEW = "gtk-new",
13808 	/**
13809 	 * The “No” item and icon.
13810 	 */
13811 	NO = "gtk-no",
13812 	/**
13813 	 * The “OK” item and icon.
13814 	 *
13815 	 * Deprecated: Do not use an icon. Use label &quot;_OK&quot;.
13816 	 */
13817 	OK = "gtk-ok",
13818 	/**
13819 	 * The “Open” item and icon.
13820 	 *
13821 	 * Deprecated: Use named icon &quot;document-open&quot; or the label &quot;_Open&quot;.
13822 	 */
13823 	OPEN = "gtk-open",
13824 	/**
13825 	 * The “Landscape Orientation” item and icon.
13826 	 */
13827 	ORIENTATION_LANDSCAPE = "gtk-orientation-landscape",
13828 	/**
13829 	 * The “Portrait Orientation” item and icon.
13830 	 */
13831 	ORIENTATION_PORTRAIT = "gtk-orientation-portrait",
13832 	/**
13833 	 * The “Reverse Landscape Orientation” item and icon.
13834 	 */
13835 	ORIENTATION_REVERSE_LANDSCAPE = "gtk-orientation-reverse-landscape",
13836 	/**
13837 	 * The “Reverse Portrait Orientation” item and icon.
13838 	 */
13839 	ORIENTATION_REVERSE_PORTRAIT = "gtk-orientation-reverse-portrait",
13840 	/**
13841 	 * The “Page Setup” item and icon.
13842 	 *
13843 	 * Deprecated: Use named icon &quot;document-page-setup&quot; or the label &quot;Page Set_up&quot;.
13844 	 */
13845 	PAGE_SETUP = "gtk-page-setup",
13846 	/**
13847 	 * The “Paste” item and icon.
13848 	 *
13849 	 * Deprecated: Use named icon &quot;edit-paste&quot; or the label &quot;_Paste&quot;.
13850 	 */
13851 	PASTE = "gtk-paste",
13852 	/**
13853 	 * The “Preferences” item and icon.
13854 	 *
13855 	 * Deprecated: Use named icon &quot;preferences-system&quot; or the label &quot;_Preferences&quot;.
13856 	 */
13857 	PREFERENCES = "gtk-preferences",
13858 	/**
13859 	 * The “Print” item and icon.
13860 	 *
13861 	 * Deprecated: Use named icon &quot;document-print&quot; or the label &quot;_Print&quot;.
13862 	 */
13863 	PRINT = "gtk-print",
13864 	/**
13865 	 * The “Print Error” icon.
13866 	 *
13867 	 * Deprecated: Use named icon &quot;printer-error&quot;.
13868 	 */
13869 	PRINT_ERROR = "gtk-print-error",
13870 	/**
13871 	 * The “Print Paused” icon.
13872 	 */
13873 	PRINT_PAUSED = "gtk-print-paused",
13874 	/**
13875 	 * The “Print Preview” item and icon.
13876 	 *
13877 	 * Deprecated: Use label &quot;Pre_view&quot;.
13878 	 */
13879 	PRINT_PREVIEW = "gtk-print-preview",
13880 	/**
13881 	 * The “Print Report” icon.
13882 	 */
13883 	PRINT_REPORT = "gtk-print-report",
13884 	/**
13885 	 * The “Print Warning” icon.
13886 	 */
13887 	PRINT_WARNING = "gtk-print-warning",
13888 	/**
13889 	 * The “Properties” item and icon.
13890 	 *
13891 	 * Deprecated: Use named icon &quot;document-properties&quot; or the label &quot;_Properties&quot;.
13892 	 */
13893 	PROPERTIES = "gtk-properties",
13894 	/**
13895 	 * The “Quit” item and icon.
13896 	 *
13897 	 * Deprecated: Use named icon &quot;application-exit&quot; or the label &quot;_Quit&quot;.
13898 	 */
13899 	QUIT = "gtk-quit",
13900 	/**
13901 	 * The “Redo” item and icon. The icon has an RTL variant.
13902 	 *
13903 	 * Deprecated: Use named icon &quot;edit-redo&quot; or the label &quot;_Redo&quot;.
13904 	 */
13905 	REDO = "gtk-redo",
13906 	/**
13907 	 * The “Refresh” item and icon.
13908 	 *
13909 	 * Deprecated: Use named icon &quot;view-refresh&quot; or the label &quot;_Refresh&quot;.
13910 	 */
13911 	REFRESH = "gtk-refresh",
13912 	/**
13913 	 * The “Remove” item and icon.
13914 	 *
13915 	 * Deprecated: Use named icon &quot;list-remove&quot; or the label &quot;_Remove&quot;.
13916 	 */
13917 	REMOVE = "gtk-remove",
13918 	/**
13919 	 * The “Revert” item and icon. The icon has an RTL variant.
13920 	 *
13921 	 * Deprecated: Use named icon &quot;document-revert&quot; or the label &quot;_Revert&quot;.
13922 	 */
13923 	REVERT_TO_SAVED = "gtk-revert-to-saved",
13924 	/**
13925 	 * The “Save” item and icon.
13926 	 *
13927 	 * Deprecated: Use named icon &quot;document-save&quot; or the label &quot;_Save&quot;.
13928 	 */
13929 	SAVE = "gtk-save",
13930 	/**
13931 	 * The “Save As” item and icon.
13932 	 *
13933 	 * Deprecated: Use named icon &quot;document-save-as&quot; or the label &quot;Save _As&quot;.
13934 	 */
13935 	SAVE_AS = "gtk-save-as",
13936 	/**
13937 	 * The “Select All” item and icon.
13938 	 *
13939 	 * Deprecated: Use named icon &quot;edit-select-all&quot; or the label &quot;Select _All&quot;.
13940 	 */
13941 	SELECT_ALL = "gtk-select-all",
13942 	/**
13943 	 * The “Color” item and icon.
13944 	 */
13945 	SELECT_COLOR = "gtk-select-color",
13946 	/**
13947 	 * The “Font” item and icon.
13948 	 */
13949 	SELECT_FONT = "gtk-select-font",
13950 	/**
13951 	 * The “Ascending” item and icon.
13952 	 *
13953 	 * Deprecated: Use named icon &quot;view-sort-ascending&quot;.
13954 	 */
13955 	SORT_ASCENDING = "gtk-sort-ascending",
13956 	/**
13957 	 * The “Descending” item and icon.
13958 	 *
13959 	 * Deprecated: Use named icon &quot;view-sort-descending&quot;.
13960 	 */
13961 	SORT_DESCENDING = "gtk-sort-descending",
13962 	/**
13963 	 * The “Spell Check” item and icon.
13964 	 *
13965 	 * Deprecated: Use named icon &quot;tools-check-spelling&quot;.
13966 	 */
13967 	SPELL_CHECK = "gtk-spell-check",
13968 	/**
13969 	 * The “Stop” item and icon.
13970 	 *
13971 	 * Deprecated: Use named icon &quot;process-stop&quot; or the label &quot;_Stop&quot;.
13972 	 */
13973 	STOP = "gtk-stop",
13974 	/**
13975 	 * The “Strikethrough” item and icon.
13976 	 *
13977 	 * Deprecated: Use named icon &quot;format-text-strikethrough&quot; or the label &quot;_Strikethrough&quot;.
13978 	 */
13979 	STRIKETHROUGH = "gtk-strikethrough",
13980 	/**
13981 	 * The “Undelete” item and icon. The icon has an RTL variant.
13982 	 */
13983 	UNDELETE = "gtk-undelete",
13984 	/**
13985 	 * The “Underline” item and icon.
13986 	 *
13987 	 * Deprecated: Use named icon &quot;format-text-underline&quot; or the label &quot;_Underline&quot;.
13988 	 */
13989 	UNDERLINE = "gtk-underline",
13990 	/**
13991 	 * The “Undo” item and icon. The icon has an RTL variant.
13992 	 *
13993 	 * Deprecated: Use named icon &quot;edit-undo&quot; or the label &quot;_Undo&quot;.
13994 	 */
13995 	UNDO = "gtk-undo",
13996 	/**
13997 	 * The “Unindent” item and icon. The icon has an RTL variant.
13998 	 *
13999 	 * Deprecated: Use named icon &quot;format-indent-less&quot;.
14000 	 */
14001 	UNINDENT = "gtk-unindent",
14002 	/**
14003 	 * The “Yes” item and icon.
14004 	 */
14005 	YES = "gtk-yes",
14006 	/**
14007 	 * The “Zoom 100%” item and icon.
14008 	 *
14009 	 * Deprecated: Use named icon &quot;zoom-original&quot; or the label &quot;_Normal Size&quot;.
14010 	 */
14011 	ZOOM_100 = "gtk-zoom-100",
14012 	/**
14013 	 * The “Zoom to Fit” item and icon.
14014 	 *
14015 	 * Deprecated: Use named icon &quot;zoom-fit-best&quot; or the label &quot;Best _Fit&quot;.
14016 	 */
14017 	ZOOM_FIT = "gtk-zoom-fit",
14018 	/**
14019 	 * The “Zoom In” item and icon.
14020 	 *
14021 	 * Deprecated: Use named icon &quot;zoom-in&quot; or the label &quot;Zoom _In&quot;.
14022 	 */
14023 	ZOOM_IN = "gtk-zoom-in",
14024 	/**
14025 	 * The “Zoom Out” item and icon.
14026 	 *
14027 	 * Deprecated: Use named icon &quot;zoom-out&quot; or the label &quot;Zoom _Out&quot;.
14028 	 */
14029 	ZOOM_OUT = "gtk-zoom-out",
14030 }