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 gdk.c.types;
26 
27 public import cairo.c.types;
28 public import gdkpixbuf.c.types;
29 public import gio.c.types;
30 public import glib.c.types;
31 public import gobject.c.types;
32 public import pango.c.types;
33 
34 
35 /**
36  * Used to represent native events (XEvents for the X11
37  * backend, MSGs for Win32).
38  */
39 public alias void GdkXEvent;
40 
41 /**
42  * Positioning hints for aligning a window relative to a rectangle.
43  *
44  * These hints determine how the window should be positioned in the case that
45  * the window would fall off-screen if placed in its ideal position.
46  *
47  * For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
48  * %GDK_GRAVITY_NORTH_EAST and vice versa if the window extends beyond the left
49  * or right edges of the monitor.
50  *
51  * If %GDK_ANCHOR_SLIDE_X is set, the window can be shifted horizontally to fit
52  * on-screen. If %GDK_ANCHOR_RESIZE_X is set, the window can be shrunken
53  * horizontally to fit.
54  *
55  * In general, when multiple flags are set, flipping should take precedence over
56  * sliding, which should take precedence over resizing.
57  *
58  * Since: 3.22
59  */
60 public enum GdkAnchorHints
61 {
62 	/**
63 	 * allow flipping anchors horizontally
64 	 */
65 	FLIP_X = 1,
66 	/**
67 	 * allow flipping anchors vertically
68 	 */
69 	FLIP_Y = 2,
70 	/**
71 	 * allow sliding window horizontally
72 	 */
73 	SLIDE_X = 4,
74 	/**
75 	 * allow sliding window vertically
76 	 */
77 	SLIDE_Y = 8,
78 	/**
79 	 * allow resizing window horizontally
80 	 */
81 	RESIZE_X = 16,
82 	/**
83 	 * allow resizing window vertically
84 	 */
85 	RESIZE_Y = 32,
86 	/**
87 	 * allow flipping anchors on both axes
88 	 */
89 	FLIP = 3,
90 	/**
91 	 * allow sliding window on both axes
92 	 */
93 	SLIDE = 12,
94 	/**
95 	 * allow resizing window on both axes
96 	 */
97 	RESIZE = 48,
98 }
99 alias GdkAnchorHints AnchorHints;
100 
101 /**
102  * Flags describing the current capabilities of a device/tool.
103  *
104  * Since: 3.22
105  */
106 public enum GdkAxisFlags
107 {
108 	/**
109 	 * X axis is present
110 	 */
111 	X = 2,
112 	/**
113 	 * Y axis is present
114 	 */
115 	Y = 4,
116 	/**
117 	 * Pressure axis is present
118 	 */
119 	PRESSURE = 8,
120 	/**
121 	 * X tilt axis is present
122 	 */
123 	XTILT = 16,
124 	/**
125 	 * Y tilt axis is present
126 	 */
127 	YTILT = 32,
128 	/**
129 	 * Wheel axis is present
130 	 */
131 	WHEEL = 64,
132 	/**
133 	 * Distance axis is present
134 	 */
135 	DISTANCE = 128,
136 	/**
137 	 * Z-axis rotation is present
138 	 */
139 	ROTATION = 256,
140 	/**
141 	 * Slider axis is present
142 	 */
143 	SLIDER = 512,
144 }
145 alias GdkAxisFlags AxisFlags;
146 
147 /**
148  * An enumeration describing the way in which a device
149  * axis (valuator) maps onto the predefined valuator
150  * types that GTK+ understands.
151  *
152  * Note that the X and Y axes are not really needed; pointer devices
153  * report their location via the x/y members of events regardless. Whether
154  * X and Y are present as axes depends on the GDK backend.
155  */
156 public enum GdkAxisUse
157 {
158 	/**
159 	 * the axis is ignored.
160 	 */
161 	IGNORE = 0,
162 	/**
163 	 * the axis is used as the x axis.
164 	 */
165 	X = 1,
166 	/**
167 	 * the axis is used as the y axis.
168 	 */
169 	Y = 2,
170 	/**
171 	 * the axis is used for pressure information.
172 	 */
173 	PRESSURE = 3,
174 	/**
175 	 * the axis is used for x tilt information.
176 	 */
177 	XTILT = 4,
178 	/**
179 	 * the axis is used for y tilt information.
180 	 */
181 	YTILT = 5,
182 	/**
183 	 * the axis is used for wheel information.
184 	 */
185 	WHEEL = 6,
186 	/**
187 	 * the axis is used for pen/tablet distance information. (Since: 3.22)
188 	 */
189 	DISTANCE = 7,
190 	/**
191 	 * the axis is used for pen rotation information. (Since: 3.22)
192 	 */
193 	ROTATION = 8,
194 	/**
195 	 * the axis is used for pen slider information. (Since: 3.22)
196 	 */
197 	SLIDER = 9,
198 	/**
199 	 * a constant equal to the numerically highest axis value.
200 	 */
201 	LAST = 10,
202 }
203 alias GdkAxisUse AxisUse;
204 
205 /**
206  * A set of values describing the possible byte-orders
207  * for storing pixel values in memory.
208  */
209 public enum GdkByteOrder
210 {
211 	/**
212 	 * The values are stored with the least-significant byte
213 	 * first. For instance, the 32-bit value 0xffeecc would be stored
214 	 * in memory as 0xcc, 0xee, 0xff, 0x00.
215 	 */
216 	LSB_FIRST = 0,
217 	/**
218 	 * The values are stored with the most-significant byte
219 	 * first. For instance, the 32-bit value 0xffeecc would be stored
220 	 * in memory as 0x00, 0xff, 0xee, 0xcc.
221 	 */
222 	MSB_FIRST = 1,
223 }
224 alias GdkByteOrder ByteOrder;
225 
226 /**
227  * Specifies the crossing mode for #GdkEventCrossing.
228  */
229 public enum GdkCrossingMode
230 {
231 	/**
232 	 * crossing because of pointer motion.
233 	 */
234 	NORMAL = 0,
235 	/**
236 	 * crossing because a grab is activated.
237 	 */
238 	GRAB = 1,
239 	/**
240 	 * crossing because a grab is deactivated.
241 	 */
242 	UNGRAB = 2,
243 	/**
244 	 * crossing because a GTK+ grab is activated.
245 	 */
246 	GTK_GRAB = 3,
247 	/**
248 	 * crossing because a GTK+ grab is deactivated.
249 	 */
250 	GTK_UNGRAB = 4,
251 	/**
252 	 * crossing because a GTK+ widget changed
253 	 * state (e.g. sensitivity).
254 	 */
255 	STATE_CHANGED = 5,
256 	/**
257 	 * crossing because a touch sequence has begun,
258 	 * this event is synthetic as the pointer might have not left the window.
259 	 */
260 	TOUCH_BEGIN = 6,
261 	/**
262 	 * crossing because a touch sequence has ended,
263 	 * this event is synthetic as the pointer might have not left the window.
264 	 */
265 	TOUCH_END = 7,
266 	/**
267 	 * crossing because of a device switch (i.e.
268 	 * a mouse taking control of the pointer after a touch device), this event
269 	 * is synthetic as the pointer didn’t leave the window.
270 	 */
271 	DEVICE_SWITCH = 8,
272 }
273 alias GdkCrossingMode CrossingMode;
274 
275 /**
276  * Predefined cursors.
277  *
278  * Note that these IDs are directly taken from the X cursor font, and many
279  * of these cursors are either not useful, or are not available on other platforms.
280  *
281  * The recommended way to create cursors is to use gdk_cursor_new_from_name().
282  */
283 public enum GdkCursorType
284 {
285 	/**
286 	 * ![](X_cursor.png)
287 	 */
288 	X_CURSOR = 0,
289 	/**
290 	 * ![](arrow.png)
291 	 */
292 	ARROW = 2,
293 	/**
294 	 * ![](based_arrow_down.png)
295 	 */
296 	BASED_ARROW_DOWN = 4,
297 	/**
298 	 * ![](based_arrow_up.png)
299 	 */
300 	BASED_ARROW_UP = 6,
301 	/**
302 	 * ![](boat.png)
303 	 */
304 	BOAT = 8,
305 	/**
306 	 * ![](bogosity.png)
307 	 */
308 	BOGOSITY = 10,
309 	/**
310 	 * ![](bottom_left_corner.png)
311 	 */
312 	BOTTOM_LEFT_CORNER = 12,
313 	/**
314 	 * ![](bottom_right_corner.png)
315 	 */
316 	BOTTOM_RIGHT_CORNER = 14,
317 	/**
318 	 * ![](bottom_side.png)
319 	 */
320 	BOTTOM_SIDE = 16,
321 	/**
322 	 * ![](bottom_tee.png)
323 	 */
324 	BOTTOM_TEE = 18,
325 	/**
326 	 * ![](box_spiral.png)
327 	 */
328 	BOX_SPIRAL = 20,
329 	/**
330 	 * ![](center_ptr.png)
331 	 */
332 	CENTER_PTR = 22,
333 	/**
334 	 * ![](circle.png)
335 	 */
336 	CIRCLE = 24,
337 	/**
338 	 * ![](clock.png)
339 	 */
340 	CLOCK = 26,
341 	/**
342 	 * ![](coffee_mug.png)
343 	 */
344 	COFFEE_MUG = 28,
345 	/**
346 	 * ![](cross.png)
347 	 */
348 	CROSS = 30,
349 	/**
350 	 * ![](cross_reverse.png)
351 	 */
352 	CROSS_REVERSE = 32,
353 	/**
354 	 * ![](crosshair.png)
355 	 */
356 	CROSSHAIR = 34,
357 	/**
358 	 * ![](diamond_cross.png)
359 	 */
360 	DIAMOND_CROSS = 36,
361 	/**
362 	 * ![](dot.png)
363 	 */
364 	DOT = 38,
365 	/**
366 	 * ![](dotbox.png)
367 	 */
368 	DOTBOX = 40,
369 	/**
370 	 * ![](double_arrow.png)
371 	 */
372 	DOUBLE_ARROW = 42,
373 	/**
374 	 * ![](draft_large.png)
375 	 */
376 	DRAFT_LARGE = 44,
377 	/**
378 	 * ![](draft_small.png)
379 	 */
380 	DRAFT_SMALL = 46,
381 	/**
382 	 * ![](draped_box.png)
383 	 */
384 	DRAPED_BOX = 48,
385 	/**
386 	 * ![](exchange.png)
387 	 */
388 	EXCHANGE = 50,
389 	/**
390 	 * ![](fleur.png)
391 	 */
392 	FLEUR = 52,
393 	/**
394 	 * ![](gobbler.png)
395 	 */
396 	GOBBLER = 54,
397 	/**
398 	 * ![](gumby.png)
399 	 */
400 	GUMBY = 56,
401 	/**
402 	 * ![](hand1.png)
403 	 */
404 	HAND1 = 58,
405 	/**
406 	 * ![](hand2.png)
407 	 */
408 	HAND2 = 60,
409 	/**
410 	 * ![](heart.png)
411 	 */
412 	HEART = 62,
413 	/**
414 	 * ![](icon.png)
415 	 */
416 	ICON = 64,
417 	/**
418 	 * ![](iron_cross.png)
419 	 */
420 	IRON_CROSS = 66,
421 	/**
422 	 * ![](left_ptr.png)
423 	 */
424 	LEFT_PTR = 68,
425 	/**
426 	 * ![](left_side.png)
427 	 */
428 	LEFT_SIDE = 70,
429 	/**
430 	 * ![](left_tee.png)
431 	 */
432 	LEFT_TEE = 72,
433 	/**
434 	 * ![](leftbutton.png)
435 	 */
436 	LEFTBUTTON = 74,
437 	/**
438 	 * ![](ll_angle.png)
439 	 */
440 	LL_ANGLE = 76,
441 	/**
442 	 * ![](lr_angle.png)
443 	 */
444 	LR_ANGLE = 78,
445 	/**
446 	 * ![](man.png)
447 	 */
448 	MAN = 80,
449 	/**
450 	 * ![](middlebutton.png)
451 	 */
452 	MIDDLEBUTTON = 82,
453 	/**
454 	 * ![](mouse.png)
455 	 */
456 	MOUSE = 84,
457 	/**
458 	 * ![](pencil.png)
459 	 */
460 	PENCIL = 86,
461 	/**
462 	 * ![](pirate.png)
463 	 */
464 	PIRATE = 88,
465 	/**
466 	 * ![](plus.png)
467 	 */
468 	PLUS = 90,
469 	/**
470 	 * ![](question_arrow.png)
471 	 */
472 	QUESTION_ARROW = 92,
473 	/**
474 	 * ![](right_ptr.png)
475 	 */
476 	RIGHT_PTR = 94,
477 	/**
478 	 * ![](right_side.png)
479 	 */
480 	RIGHT_SIDE = 96,
481 	/**
482 	 * ![](right_tee.png)
483 	 */
484 	RIGHT_TEE = 98,
485 	/**
486 	 * ![](rightbutton.png)
487 	 */
488 	RIGHTBUTTON = 100,
489 	/**
490 	 * ![](rtl_logo.png)
491 	 */
492 	RTL_LOGO = 102,
493 	/**
494 	 * ![](sailboat.png)
495 	 */
496 	SAILBOAT = 104,
497 	/**
498 	 * ![](sb_down_arrow.png)
499 	 */
500 	SB_DOWN_ARROW = 106,
501 	/**
502 	 * ![](sb_h_double_arrow.png)
503 	 */
504 	SB_H_DOUBLE_ARROW = 108,
505 	/**
506 	 * ![](sb_left_arrow.png)
507 	 */
508 	SB_LEFT_ARROW = 110,
509 	/**
510 	 * ![](sb_right_arrow.png)
511 	 */
512 	SB_RIGHT_ARROW = 112,
513 	/**
514 	 * ![](sb_up_arrow.png)
515 	 */
516 	SB_UP_ARROW = 114,
517 	/**
518 	 * ![](sb_v_double_arrow.png)
519 	 */
520 	SB_V_DOUBLE_ARROW = 116,
521 	/**
522 	 * ![](shuttle.png)
523 	 */
524 	SHUTTLE = 118,
525 	/**
526 	 * ![](sizing.png)
527 	 */
528 	SIZING = 120,
529 	/**
530 	 * ![](spider.png)
531 	 */
532 	SPIDER = 122,
533 	/**
534 	 * ![](spraycan.png)
535 	 */
536 	SPRAYCAN = 124,
537 	/**
538 	 * ![](star.png)
539 	 */
540 	STAR = 126,
541 	/**
542 	 * ![](target.png)
543 	 */
544 	TARGET = 128,
545 	/**
546 	 * ![](tcross.png)
547 	 */
548 	TCROSS = 130,
549 	/**
550 	 * ![](top_left_arrow.png)
551 	 */
552 	TOP_LEFT_ARROW = 132,
553 	/**
554 	 * ![](top_left_corner.png)
555 	 */
556 	TOP_LEFT_CORNER = 134,
557 	/**
558 	 * ![](top_right_corner.png)
559 	 */
560 	TOP_RIGHT_CORNER = 136,
561 	/**
562 	 * ![](top_side.png)
563 	 */
564 	TOP_SIDE = 138,
565 	/**
566 	 * ![](top_tee.png)
567 	 */
568 	TOP_TEE = 140,
569 	/**
570 	 * ![](trek.png)
571 	 */
572 	TREK = 142,
573 	/**
574 	 * ![](ul_angle.png)
575 	 */
576 	UL_ANGLE = 144,
577 	/**
578 	 * ![](umbrella.png)
579 	 */
580 	UMBRELLA = 146,
581 	/**
582 	 * ![](ur_angle.png)
583 	 */
584 	UR_ANGLE = 148,
585 	/**
586 	 * ![](watch.png)
587 	 */
588 	WATCH = 150,
589 	/**
590 	 * ![](xterm.png)
591 	 */
592 	XTERM = 152,
593 	/**
594 	 * last cursor type
595 	 */
596 	LAST_CURSOR = 153,
597 	/**
598 	 * Blank cursor. Since 2.16
599 	 */
600 	BLANK_CURSOR = -2,
601 	/**
602 	 * type of cursors constructed with
603 	 * gdk_cursor_new_from_pixbuf()
604 	 */
605 	CURSOR_IS_PIXMAP = -1,
606 }
607 alias GdkCursorType CursorType;
608 
609 /**
610  * A pad feature.
611  */
612 public enum GdkDevicePadFeature
613 {
614 	/**
615 	 * a button
616 	 */
617 	BUTTON = 0,
618 	/**
619 	 * a ring-shaped interactive area
620 	 */
621 	RING = 1,
622 	/**
623 	 * a straight interactive area
624 	 */
625 	STRIP = 2,
626 }
627 alias GdkDevicePadFeature DevicePadFeature;
628 
629 /**
630  * Indicates the specific type of tool being used being a tablet. Such as an
631  * airbrush, pencil, etc.
632  *
633  * Since: 3.22
634  */
635 public enum GdkDeviceToolType
636 {
637 	/**
638 	 * Tool is of an unknown type.
639 	 */
640 	UNKNOWN = 0,
641 	/**
642 	 * Tool is a standard tablet stylus.
643 	 */
644 	PEN = 1,
645 	/**
646 	 * Tool is standard tablet eraser.
647 	 */
648 	ERASER = 2,
649 	/**
650 	 * Tool is a brush stylus.
651 	 */
652 	BRUSH = 3,
653 	/**
654 	 * Tool is a pencil stylus.
655 	 */
656 	PENCIL = 4,
657 	/**
658 	 * Tool is an airbrush stylus.
659 	 */
660 	AIRBRUSH = 5,
661 	/**
662 	 * Tool is a mouse.
663 	 */
664 	MOUSE = 6,
665 	/**
666 	 * Tool is a lens cursor.
667 	 */
668 	LENS = 7,
669 }
670 alias GdkDeviceToolType DeviceToolType;
671 
672 /**
673  * Indicates the device type. See [above][GdkDeviceManager.description]
674  * for more information about the meaning of these device types.
675  */
676 public enum GdkDeviceType
677 {
678 	/**
679 	 * Device is a master (or virtual) device. There will
680 	 * be an associated focus indicator on the screen.
681 	 */
682 	MASTER = 0,
683 	/**
684 	 * Device is a slave (or physical) device.
685 	 */
686 	SLAVE = 1,
687 	/**
688 	 * Device is a physical device, currently not attached to
689 	 * any virtual device.
690 	 */
691 	FLOATING = 2,
692 }
693 alias GdkDeviceType DeviceType;
694 
695 /**
696  * Used in #GdkDragContext to indicate what the destination
697  * should do with the dropped data.
698  */
699 public enum GdkDragAction
700 {
701 	/**
702 	 * Means nothing, and should not be used.
703 	 */
704 	DEFAULT = 1,
705 	/**
706 	 * Copy the data.
707 	 */
708 	COPY = 2,
709 	/**
710 	 * Move the data, i.e. first copy it, then delete
711 	 * it from the source using the DELETE target of the X selection protocol.
712 	 */
713 	MOVE = 4,
714 	/**
715 	 * Add a link to the data. Note that this is only
716 	 * useful if source and destination agree on what it means.
717 	 */
718 	LINK = 8,
719 	/**
720 	 * Special action which tells the source that the
721 	 * destination will do something that the source doesn’t understand.
722 	 */
723 	PRIVATE = 16,
724 	/**
725 	 * Ask the user what to do with the data.
726 	 */
727 	ASK = 32,
728 }
729 alias GdkDragAction DragAction;
730 
731 /**
732  * Used in #GdkDragContext to the reason of a cancelled DND operation.
733  *
734  * Since: 3.20
735  */
736 public enum GdkDragCancelReason
737 {
738 	/**
739 	 * There is no suitable drop target.
740 	 */
741 	NO_TARGET = 0,
742 	/**
743 	 * Drag cancelled by the user
744 	 */
745 	USER_CANCELLED = 1,
746 	/**
747 	 * Unspecified error.
748 	 */
749 	ERROR = 2,
750 }
751 alias GdkDragCancelReason DragCancelReason;
752 
753 /**
754  * Used in #GdkDragContext to indicate the protocol according to
755  * which DND is done.
756  */
757 public enum GdkDragProtocol
758 {
759 	/**
760 	 * no protocol.
761 	 */
762 	NONE = 0,
763 	/**
764 	 * The Motif DND protocol. No longer supported
765 	 */
766 	MOTIF = 1,
767 	/**
768 	 * The Xdnd protocol.
769 	 */
770 	XDND = 2,
771 	/**
772 	 * An extension to the Xdnd protocol for
773 	 * unclaimed root window drops.
774 	 */
775 	ROOTWIN = 3,
776 	/**
777 	 * The simple WM_DROPFILES protocol.
778 	 */
779 	WIN32_DROPFILES = 4,
780 	/**
781 	 * The complex OLE2 DND protocol (not implemented).
782 	 */
783 	OLE2 = 5,
784 	/**
785 	 * Intra-application DND.
786 	 */
787 	LOCAL = 6,
788 	/**
789 	 * Wayland DND protocol.
790 	 */
791 	WAYLAND = 7,
792 }
793 alias GdkDragProtocol DragProtocol;
794 
795 /**
796  * A set of bit-flags to indicate which events a window is to receive.
797  * Most of these masks map onto one or more of the #GdkEventType event types
798  * above.
799  *
800  * See the [input handling overview][chap-input-handling] for details of
801  * [event masks][event-masks] and [event propagation][event-propagation].
802  *
803  * %GDK_POINTER_MOTION_HINT_MASK is deprecated. It is a special mask
804  * to reduce the number of %GDK_MOTION_NOTIFY events received. When using
805  * %GDK_POINTER_MOTION_HINT_MASK, fewer %GDK_MOTION_NOTIFY events will
806  * be sent, some of which are marked as a hint (the is_hint member is
807  * %TRUE). To receive more motion events after a motion hint event,
808  * the application needs to asks for more, by calling
809  * gdk_event_request_motions().
810  *
811  * Since GTK 3.8, motion events are already compressed by default, independent
812  * of this mechanism. This compression can be disabled with
813  * gdk_window_set_event_compression(). See the documentation of that function
814  * for details.
815  *
816  * If %GDK_TOUCH_MASK is enabled, the window will receive touch events
817  * from touch-enabled devices. Those will come as sequences of #GdkEventTouch
818  * with type %GDK_TOUCH_UPDATE, enclosed by two events with
819  * type %GDK_TOUCH_BEGIN and %GDK_TOUCH_END (or %GDK_TOUCH_CANCEL).
820  * gdk_event_get_event_sequence() returns the event sequence for these
821  * events, so different sequences may be distinguished.
822  */
823 public enum GdkEventMask
824 {
825 	/**
826 	 * receive expose events
827 	 */
828 	EXPOSURE_MASK = 2,
829 	/**
830 	 * receive all pointer motion events
831 	 */
832 	POINTER_MOTION_MASK = 4,
833 	/**
834 	 * deprecated. see the explanation above
835 	 */
836 	POINTER_MOTION_HINT_MASK = 8,
837 	/**
838 	 * receive pointer motion events while any button is pressed
839 	 */
840 	BUTTON_MOTION_MASK = 16,
841 	/**
842 	 * receive pointer motion events while 1 button is pressed
843 	 */
844 	BUTTON1_MOTION_MASK = 32,
845 	/**
846 	 * receive pointer motion events while 2 button is pressed
847 	 */
848 	BUTTON2_MOTION_MASK = 64,
849 	/**
850 	 * receive pointer motion events while 3 button is pressed
851 	 */
852 	BUTTON3_MOTION_MASK = 128,
853 	/**
854 	 * receive button press events
855 	 */
856 	BUTTON_PRESS_MASK = 256,
857 	/**
858 	 * receive button release events
859 	 */
860 	BUTTON_RELEASE_MASK = 512,
861 	/**
862 	 * receive key press events
863 	 */
864 	KEY_PRESS_MASK = 1024,
865 	/**
866 	 * receive key release events
867 	 */
868 	KEY_RELEASE_MASK = 2048,
869 	/**
870 	 * receive window enter events
871 	 */
872 	ENTER_NOTIFY_MASK = 4096,
873 	/**
874 	 * receive window leave events
875 	 */
876 	LEAVE_NOTIFY_MASK = 8192,
877 	/**
878 	 * receive focus change events
879 	 */
880 	FOCUS_CHANGE_MASK = 16384,
881 	/**
882 	 * receive events about window configuration change
883 	 */
884 	STRUCTURE_MASK = 32768,
885 	/**
886 	 * receive property change events
887 	 */
888 	PROPERTY_CHANGE_MASK = 65536,
889 	/**
890 	 * receive visibility change events
891 	 */
892 	VISIBILITY_NOTIFY_MASK = 131072,
893 	/**
894 	 * receive proximity in events
895 	 */
896 	PROXIMITY_IN_MASK = 262144,
897 	/**
898 	 * receive proximity out events
899 	 */
900 	PROXIMITY_OUT_MASK = 524288,
901 	/**
902 	 * receive events about window configuration changes of
903 	 * child windows
904 	 */
905 	SUBSTRUCTURE_MASK = 1048576,
906 	/**
907 	 * receive scroll events
908 	 */
909 	SCROLL_MASK = 2097152,
910 	/**
911 	 * receive touch events. Since 3.4
912 	 */
913 	TOUCH_MASK = 4194304,
914 	/**
915 	 * receive smooth scrolling events. Since 3.4
916 	 */
917 	SMOOTH_SCROLL_MASK = 8388608,
918 	/**
919 	 * receive touchpad gesture events. Since 3.18
920 	 */
921 	TOUCHPAD_GESTURE_MASK = 16777216,
922 	/**
923 	 * receive tablet pad events. Since 3.22
924 	 */
925 	TABLET_PAD_MASK = 33554432,
926 	/**
927 	 * the combination of all the above event masks.
928 	 */
929 	ALL_EVENTS_MASK = 16777214,
930 }
931 alias GdkEventMask EventMask;
932 
933 /**
934  * Specifies the type of the event.
935  *
936  * Do not confuse these events with the signals that GTK+ widgets emit.
937  * Although many of these events result in corresponding signals being emitted,
938  * the events are often transformed or filtered along the way.
939  *
940  * In some language bindings, the values %GDK_2BUTTON_PRESS and
941  * %GDK_3BUTTON_PRESS would translate into something syntactically
942  * invalid (eg `Gdk.EventType.2ButtonPress`, where a
943  * symbol is not allowed to start with a number). In that case, the
944  * aliases %GDK_DOUBLE_BUTTON_PRESS and %GDK_TRIPLE_BUTTON_PRESS can
945  * be used instead.
946  */
947 public enum GdkEventType
948 {
949 	/**
950 	 * a special code to indicate a null event.
951 	 */
952 	NOTHING = -1,
953 	/**
954 	 * the window manager has requested that the toplevel window be
955 	 * hidden or destroyed, usually when the user clicks on a special icon in the
956 	 * title bar.
957 	 */
958 	DELETE = 0,
959 	/**
960 	 * the window has been destroyed.
961 	 */
962 	DESTROY = 1,
963 	/**
964 	 * all or part of the window has become visible and needs to be
965 	 * redrawn.
966 	 */
967 	EXPOSE = 2,
968 	/**
969 	 * the pointer (usually a mouse) has moved.
970 	 */
971 	MOTION_NOTIFY = 3,
972 	/**
973 	 * a mouse button has been pressed.
974 	 */
975 	BUTTON_PRESS = 4,
976 	/**
977 	 * alias for %GDK_2BUTTON_PRESS, added in 3.6.
978 	 */
979 	DOUBLE_BUTTON_PRESS = 5,
980 	/**
981 	 * alias for %GDK_3BUTTON_PRESS, added in 3.6.
982 	 */
983 	TRIPLE_BUTTON_PRESS = 6,
984 	/**
985 	 * a mouse button has been released.
986 	 */
987 	BUTTON_RELEASE = 7,
988 	/**
989 	 * a key has been pressed.
990 	 */
991 	KEY_PRESS = 8,
992 	/**
993 	 * a key has been released.
994 	 */
995 	KEY_RELEASE = 9,
996 	/**
997 	 * the pointer has entered the window.
998 	 */
999 	ENTER_NOTIFY = 10,
1000 	/**
1001 	 * the pointer has left the window.
1002 	 */
1003 	LEAVE_NOTIFY = 11,
1004 	/**
1005 	 * the keyboard focus has entered or left the window.
1006 	 */
1007 	FOCUS_CHANGE = 12,
1008 	/**
1009 	 * the size, position or stacking order of the window has changed.
1010 	 * Note that GTK+ discards these events for %GDK_WINDOW_CHILD windows.
1011 	 */
1012 	CONFIGURE = 13,
1013 	/**
1014 	 * the window has been mapped.
1015 	 */
1016 	MAP = 14,
1017 	/**
1018 	 * the window has been unmapped.
1019 	 */
1020 	UNMAP = 15,
1021 	/**
1022 	 * a property on the window has been changed or deleted.
1023 	 */
1024 	PROPERTY_NOTIFY = 16,
1025 	/**
1026 	 * the application has lost ownership of a selection.
1027 	 */
1028 	SELECTION_CLEAR = 17,
1029 	/**
1030 	 * another application has requested a selection.
1031 	 */
1032 	SELECTION_REQUEST = 18,
1033 	/**
1034 	 * a selection has been received.
1035 	 */
1036 	SELECTION_NOTIFY = 19,
1037 	/**
1038 	 * an input device has moved into contact with a sensing
1039 	 * surface (e.g. a touchscreen or graphics tablet).
1040 	 */
1041 	PROXIMITY_IN = 20,
1042 	/**
1043 	 * an input device has moved out of contact with a sensing
1044 	 * surface.
1045 	 */
1046 	PROXIMITY_OUT = 21,
1047 	/**
1048 	 * the mouse has entered the window while a drag is in progress.
1049 	 */
1050 	DRAG_ENTER = 22,
1051 	/**
1052 	 * the mouse has left the window while a drag is in progress.
1053 	 */
1054 	DRAG_LEAVE = 23,
1055 	/**
1056 	 * the mouse has moved in the window while a drag is in
1057 	 * progress.
1058 	 */
1059 	DRAG_MOTION = 24,
1060 	/**
1061 	 * the status of the drag operation initiated by the window
1062 	 * has changed.
1063 	 */
1064 	DRAG_STATUS = 25,
1065 	/**
1066 	 * a drop operation onto the window has started.
1067 	 */
1068 	DROP_START = 26,
1069 	/**
1070 	 * the drop operation initiated by the window has completed.
1071 	 */
1072 	DROP_FINISHED = 27,
1073 	/**
1074 	 * a message has been received from another application.
1075 	 */
1076 	CLIENT_EVENT = 28,
1077 	/**
1078 	 * the window visibility status has changed.
1079 	 */
1080 	VISIBILITY_NOTIFY = 29,
1081 	/**
1082 	 * the scroll wheel was turned
1083 	 */
1084 	SCROLL = 31,
1085 	/**
1086 	 * the state of a window has changed. See #GdkWindowState
1087 	 * for the possible window states
1088 	 */
1089 	WINDOW_STATE = 32,
1090 	/**
1091 	 * a setting has been modified.
1092 	 */
1093 	SETTING = 33,
1094 	/**
1095 	 * the owner of a selection has changed. This event type
1096 	 * was added in 2.6
1097 	 */
1098 	OWNER_CHANGE = 34,
1099 	/**
1100 	 * a pointer or keyboard grab was broken. This event type
1101 	 * was added in 2.8.
1102 	 */
1103 	GRAB_BROKEN = 35,
1104 	/**
1105 	 * the content of the window has been changed. This event type
1106 	 * was added in 2.14.
1107 	 */
1108 	DAMAGE = 36,
1109 	/**
1110 	 * A new touch event sequence has just started. This event
1111 	 * type was added in 3.4.
1112 	 */
1113 	TOUCH_BEGIN = 37,
1114 	/**
1115 	 * A touch event sequence has been updated. This event type
1116 	 * was added in 3.4.
1117 	 */
1118 	TOUCH_UPDATE = 38,
1119 	/**
1120 	 * A touch event sequence has finished. This event type
1121 	 * was added in 3.4.
1122 	 */
1123 	TOUCH_END = 39,
1124 	/**
1125 	 * A touch event sequence has been canceled. This event type
1126 	 * was added in 3.4.
1127 	 */
1128 	TOUCH_CANCEL = 40,
1129 	/**
1130 	 * A touchpad swipe gesture event, the current state
1131 	 * is determined by its phase field. This event type was added in 3.18.
1132 	 */
1133 	TOUCHPAD_SWIPE = 41,
1134 	/**
1135 	 * A touchpad pinch gesture event, the current state
1136 	 * is determined by its phase field. This event type was added in 3.18.
1137 	 */
1138 	TOUCHPAD_PINCH = 42,
1139 	/**
1140 	 * A tablet pad button press event. This event type
1141 	 * was added in 3.22.
1142 	 */
1143 	PAD_BUTTON_PRESS = 43,
1144 	/**
1145 	 * A tablet pad button release event. This event type
1146 	 * was added in 3.22.
1147 	 */
1148 	PAD_BUTTON_RELEASE = 44,
1149 	/**
1150 	 * A tablet pad axis event from a "ring". This event type was
1151 	 * added in 3.22.
1152 	 */
1153 	PAD_RING = 45,
1154 	/**
1155 	 * A tablet pad axis event from a "strip". This event type was
1156 	 * added in 3.22.
1157 	 */
1158 	PAD_STRIP = 46,
1159 	/**
1160 	 * A tablet pad group mode change. This event type was
1161 	 * added in 3.22.
1162 	 */
1163 	PAD_GROUP_MODE = 47,
1164 	/**
1165 	 * marks the end of the GdkEventType enumeration. Added in 2.18
1166 	 */
1167 	EVENT_LAST = 48,
1168 }
1169 alias GdkEventType EventType;
1170 
1171 /**
1172  * Specifies the result of applying a #GdkFilterFunc to a native event.
1173  */
1174 public enum GdkFilterReturn
1175 {
1176 	/**
1177 	 * event not handled, continue processing.
1178 	 */
1179 	CONTINUE = 0,
1180 	/**
1181 	 * native event translated into a GDK event and stored
1182 	 * in the `event` structure that was passed in.
1183 	 */
1184 	TRANSLATE = 1,
1185 	/**
1186 	 * event handled, terminate processing.
1187 	 */
1188 	REMOVE = 2,
1189 }
1190 alias GdkFilterReturn FilterReturn;
1191 
1192 /**
1193  * #GdkFrameClockPhase is used to represent the different paint clock
1194  * phases that can be requested. The elements of the enumeration
1195  * correspond to the signals of #GdkFrameClock.
1196  *
1197  * Since: 3.8
1198  */
1199 public enum GdkFrameClockPhase
1200 {
1201 	/**
1202 	 * no phase
1203 	 */
1204 	NONE = 0,
1205 	/**
1206 	 * corresponds to GdkFrameClock::flush-events. Should not be handled by applications.
1207 	 */
1208 	FLUSH_EVENTS = 1,
1209 	/**
1210 	 * corresponds to GdkFrameClock::before-paint. Should not be handled by applications.
1211 	 */
1212 	BEFORE_PAINT = 2,
1213 	/**
1214 	 * corresponds to GdkFrameClock::update.
1215 	 */
1216 	UPDATE = 4,
1217 	/**
1218 	 * corresponds to GdkFrameClock::layout.
1219 	 */
1220 	LAYOUT = 8,
1221 	/**
1222 	 * corresponds to GdkFrameClock::paint.
1223 	 */
1224 	PAINT = 16,
1225 	/**
1226 	 * corresponds to GdkFrameClock::resume-events. Should not be handled by applications.
1227 	 */
1228 	RESUME_EVENTS = 32,
1229 	/**
1230 	 * corresponds to GdkFrameClock::after-paint. Should not be handled by applications.
1231 	 */
1232 	AFTER_PAINT = 64,
1233 }
1234 alias GdkFrameClockPhase FrameClockPhase;
1235 
1236 /**
1237  * Indicates which monitor (in a multi-head setup) a window should span over
1238  * when in fullscreen mode.
1239  *
1240  * Since: 3.8
1241  */
1242 public enum GdkFullscreenMode
1243 {
1244 	/**
1245 	 * Fullscreen on current monitor only.
1246 	 */
1247 	CURRENT_MONITOR = 0,
1248 	/**
1249 	 * Span across all monitors when fullscreen.
1250 	 */
1251 	ALL_MONITORS = 1,
1252 }
1253 alias GdkFullscreenMode FullscreenMode;
1254 
1255 /**
1256  * Error enumeration for #GdkGLContext.
1257  *
1258  * Since: 3.16
1259  */
1260 public enum GdkGLError
1261 {
1262 	/**
1263 	 * OpenGL support is not available
1264 	 */
1265 	NOT_AVAILABLE = 0,
1266 	/**
1267 	 * The requested visual format is not supported
1268 	 */
1269 	UNSUPPORTED_FORMAT = 1,
1270 	/**
1271 	 * The requested profile is not supported
1272 	 */
1273 	UNSUPPORTED_PROFILE = 2,
1274 }
1275 alias GdkGLError GLError;
1276 
1277 /**
1278  * Defines how device grabs interact with other devices.
1279  */
1280 public enum GdkGrabOwnership
1281 {
1282 	/**
1283 	 * All other devices’ events are allowed.
1284 	 */
1285 	NONE = 0,
1286 	/**
1287 	 * Other devices’ events are blocked for the grab window.
1288 	 */
1289 	WINDOW = 1,
1290 	/**
1291 	 * Other devices’ events are blocked for the whole application.
1292 	 */
1293 	APPLICATION = 2,
1294 }
1295 alias GdkGrabOwnership GrabOwnership;
1296 
1297 /**
1298  * Returned by gdk_device_grab(), gdk_pointer_grab() and gdk_keyboard_grab() to
1299  * indicate success or the reason for the failure of the grab attempt.
1300  */
1301 public enum GdkGrabStatus
1302 {
1303 	/**
1304 	 * the resource was successfully grabbed.
1305 	 */
1306 	SUCCESS = 0,
1307 	/**
1308 	 * the resource is actively grabbed by another client.
1309 	 */
1310 	ALREADY_GRABBED = 1,
1311 	/**
1312 	 * the resource was grabbed more recently than the
1313 	 * specified time.
1314 	 */
1315 	INVALID_TIME = 2,
1316 	/**
1317 	 * the grab window or the @confine_to window are not
1318 	 * viewable.
1319 	 */
1320 	NOT_VIEWABLE = 3,
1321 	/**
1322 	 * the resource is frozen by an active grab of another client.
1323 	 */
1324 	FROZEN = 4,
1325 	/**
1326 	 * the grab failed for some other reason. Since 3.16
1327 	 */
1328 	FAILED = 5,
1329 }
1330 alias GdkGrabStatus GrabStatus;
1331 
1332 /**
1333  * Defines the reference point of a window and the meaning of coordinates
1334  * passed to gtk_window_move(). See gtk_window_move() and the "implementation
1335  * notes" section of the
1336  * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
1337  * specification for more details.
1338  */
1339 public enum GdkGravity
1340 {
1341 	/**
1342 	 * the reference point is at the top left corner.
1343 	 */
1344 	NORTH_WEST = 1,
1345 	/**
1346 	 * the reference point is in the middle of the top edge.
1347 	 */
1348 	NORTH = 2,
1349 	/**
1350 	 * the reference point is at the top right corner.
1351 	 */
1352 	NORTH_EAST = 3,
1353 	/**
1354 	 * the reference point is at the middle of the left edge.
1355 	 */
1356 	WEST = 4,
1357 	/**
1358 	 * the reference point is at the center of the window.
1359 	 */
1360 	CENTER = 5,
1361 	/**
1362 	 * the reference point is at the middle of the right edge.
1363 	 */
1364 	EAST = 6,
1365 	/**
1366 	 * the reference point is at the lower left corner.
1367 	 */
1368 	SOUTH_WEST = 7,
1369 	/**
1370 	 * the reference point is at the middle of the lower edge.
1371 	 */
1372 	SOUTH = 8,
1373 	/**
1374 	 * the reference point is at the lower right corner.
1375 	 */
1376 	SOUTH_EAST = 9,
1377 	/**
1378 	 * the reference point is at the top left corner of the
1379 	 * window itself, ignoring window manager decorations.
1380 	 */
1381 	STATIC = 10,
1382 }
1383 alias GdkGravity Gravity;
1384 
1385 /**
1386  * An enumeration that describes the mode of an input device.
1387  */
1388 public enum GdkInputMode
1389 {
1390 	/**
1391 	 * the device is disabled and will not report any events.
1392 	 */
1393 	DISABLED = 0,
1394 	/**
1395 	 * the device is enabled. The device’s coordinate space
1396 	 * maps to the entire screen.
1397 	 */
1398 	SCREEN = 1,
1399 	/**
1400 	 * the device is enabled. The device’s coordinate space
1401 	 * is mapped to a single window. The manner in which this window
1402 	 * is chosen is undefined, but it will typically be the same
1403 	 * way in which the focus window for key events is determined.
1404 	 */
1405 	WINDOW = 2,
1406 }
1407 alias GdkInputMode InputMode;
1408 
1409 /**
1410  * An enumeration describing the type of an input device in general terms.
1411  */
1412 public enum GdkInputSource
1413 {
1414 	/**
1415 	 * the device is a mouse. (This will be reported for the core
1416 	 * pointer, even if it is something else, such as a trackball.)
1417 	 */
1418 	MOUSE = 0,
1419 	/**
1420 	 * the device is a stylus of a graphics tablet or similar device.
1421 	 */
1422 	PEN = 1,
1423 	/**
1424 	 * the device is an eraser. Typically, this would be the other end
1425 	 * of a stylus on a graphics tablet.
1426 	 */
1427 	ERASER = 2,
1428 	/**
1429 	 * the device is a graphics tablet “puck” or similar device.
1430 	 */
1431 	CURSOR = 3,
1432 	/**
1433 	 * the device is a keyboard.
1434 	 */
1435 	KEYBOARD = 4,
1436 	/**
1437 	 * the device is a direct-input touch device, such
1438 	 * as a touchscreen or tablet. This device type has been added in 3.4.
1439 	 */
1440 	TOUCHSCREEN = 5,
1441 	/**
1442 	 * the device is an indirect touch device, such
1443 	 * as a touchpad. This device type has been added in 3.4.
1444 	 */
1445 	TOUCHPAD = 6,
1446 	/**
1447 	 * the device is a trackpoint. This device type has been
1448 	 * added in 3.22
1449 	 */
1450 	TRACKPOINT = 7,
1451 	/**
1452 	 * the device is a "pad", a collection of buttons,
1453 	 * rings and strips found in drawing tablets. This device type has been
1454 	 * added in 3.22.
1455 	 */
1456 	TABLET_PAD = 8,
1457 }
1458 alias GdkInputSource InputSource;
1459 
1460 /**
1461  * This enum is used with gdk_keymap_get_modifier_mask()
1462  * in order to determine what modifiers the
1463  * currently used windowing system backend uses for particular
1464  * purposes. For example, on X11/Windows, the Control key is used for
1465  * invoking menu shortcuts (accelerators), whereas on Apple computers
1466  * it’s the Command key (which correspond to %GDK_CONTROL_MASK and
1467  * %GDK_MOD2_MASK, respectively).
1468  *
1469  * Since: 3.4
1470  */
1471 public enum GdkModifierIntent
1472 {
1473 	/**
1474 	 * the primary modifier used to invoke
1475 	 * menu accelerators.
1476 	 */
1477 	PRIMARY_ACCELERATOR = 0,
1478 	/**
1479 	 * the modifier used to invoke context menus.
1480 	 * Note that mouse button 3 always triggers context menus. When this modifier
1481 	 * is not 0, it additionally triggers context menus when used with mouse button 1.
1482 	 */
1483 	CONTEXT_MENU = 1,
1484 	/**
1485 	 * the modifier used to extend selections
1486 	 * using `modifier`-click or `modifier`-cursor-key
1487 	 */
1488 	EXTEND_SELECTION = 2,
1489 	/**
1490 	 * the modifier used to modify selections,
1491 	 * which in most cases means toggling the clicked item into or out of the selection.
1492 	 */
1493 	MODIFY_SELECTION = 3,
1494 	/**
1495 	 * when any of these modifiers is pressed, the
1496 	 * key event cannot produce a symbol directly. This is meant to be used for
1497 	 * input methods, and for use cases like typeahead search.
1498 	 */
1499 	NO_TEXT_INPUT = 4,
1500 	/**
1501 	 * the modifier that switches between keyboard
1502 	 * groups (AltGr on X11/Windows and Option/Alt on OS X).
1503 	 */
1504 	SHIFT_GROUP = 5,
1505 	/**
1506 	 * The set of modifier masks accepted
1507 	 * as modifiers in accelerators. Needed because Command is mapped to MOD2 on
1508 	 * OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a
1509 	 * mod key is problematic at best.
1510 	 * Ref: https://bugzilla.gnome.org/show_bug.cgi?id=736125.
1511 	 */
1512 	DEFAULT_MOD_MASK = 6,
1513 }
1514 alias GdkModifierIntent ModifierIntent;
1515 
1516 /**
1517  * A set of bit-flags to indicate the state of modifier keys and mouse buttons
1518  * in various event types. Typical modifier keys are Shift, Control, Meta,
1519  * Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.
1520  *
1521  * Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.
1522  *
1523  * Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped
1524  * to Mod2 - Mod5, and indicates this by setting %GDK_SUPER_MASK,
1525  * %GDK_HYPER_MASK or %GDK_META_MASK in the state field of key events.
1526  *
1527  * Note that GDK may add internal values to events which include
1528  * reserved values such as %GDK_MODIFIER_RESERVED_13_MASK.  Your code
1529  * should preserve and ignore them.  You can use %GDK_MODIFIER_MASK to
1530  * remove all reserved values.
1531  *
1532  * Also note that the GDK X backend interprets button press events for button
1533  * 4-7 as scroll events, so %GDK_BUTTON4_MASK and %GDK_BUTTON5_MASK will never
1534  * be set.
1535  */
1536 public enum GdkModifierType
1537 {
1538 	/**
1539 	 * the Shift key.
1540 	 */
1541 	SHIFT_MASK = 1,
1542 	/**
1543 	 * a Lock key (depending on the modifier mapping of the
1544 	 * X server this may either be CapsLock or ShiftLock).
1545 	 */
1546 	LOCK_MASK = 2,
1547 	/**
1548 	 * the Control key.
1549 	 */
1550 	CONTROL_MASK = 4,
1551 	/**
1552 	 * the fourth modifier key (it depends on the modifier
1553 	 * mapping of the X server which key is interpreted as this modifier, but
1554 	 * normally it is the Alt key).
1555 	 */
1556 	MOD1_MASK = 8,
1557 	/**
1558 	 * the fifth modifier key (it depends on the modifier
1559 	 * mapping of the X server which key is interpreted as this modifier).
1560 	 */
1561 	MOD2_MASK = 16,
1562 	/**
1563 	 * the sixth modifier key (it depends on the modifier
1564 	 * mapping of the X server which key is interpreted as this modifier).
1565 	 */
1566 	MOD3_MASK = 32,
1567 	/**
1568 	 * the seventh modifier key (it depends on the modifier
1569 	 * mapping of the X server which key is interpreted as this modifier).
1570 	 */
1571 	MOD4_MASK = 64,
1572 	/**
1573 	 * the eighth modifier key (it depends on the modifier
1574 	 * mapping of the X server which key is interpreted as this modifier).
1575 	 */
1576 	MOD5_MASK = 128,
1577 	/**
1578 	 * the first mouse button.
1579 	 */
1580 	BUTTON1_MASK = 256,
1581 	/**
1582 	 * the second mouse button.
1583 	 */
1584 	BUTTON2_MASK = 512,
1585 	/**
1586 	 * the third mouse button.
1587 	 */
1588 	BUTTON3_MASK = 1024,
1589 	/**
1590 	 * the fourth mouse button.
1591 	 */
1592 	BUTTON4_MASK = 2048,
1593 	/**
1594 	 * the fifth mouse button.
1595 	 */
1596 	BUTTON5_MASK = 4096,
1597 	/**
1598 	 * A reserved bit flag; do not use in your own code
1599 	 */
1600 	MODIFIER_RESERVED_13_MASK = 8192,
1601 	/**
1602 	 * A reserved bit flag; do not use in your own code
1603 	 */
1604 	MODIFIER_RESERVED_14_MASK = 16384,
1605 	/**
1606 	 * A reserved bit flag; do not use in your own code
1607 	 */
1608 	MODIFIER_RESERVED_15_MASK = 32768,
1609 	/**
1610 	 * A reserved bit flag; do not use in your own code
1611 	 */
1612 	MODIFIER_RESERVED_16_MASK = 65536,
1613 	/**
1614 	 * A reserved bit flag; do not use in your own code
1615 	 */
1616 	MODIFIER_RESERVED_17_MASK = 131072,
1617 	/**
1618 	 * A reserved bit flag; do not use in your own code
1619 	 */
1620 	MODIFIER_RESERVED_18_MASK = 262144,
1621 	/**
1622 	 * A reserved bit flag; do not use in your own code
1623 	 */
1624 	MODIFIER_RESERVED_19_MASK = 524288,
1625 	/**
1626 	 * A reserved bit flag; do not use in your own code
1627 	 */
1628 	MODIFIER_RESERVED_20_MASK = 1048576,
1629 	/**
1630 	 * A reserved bit flag; do not use in your own code
1631 	 */
1632 	MODIFIER_RESERVED_21_MASK = 2097152,
1633 	/**
1634 	 * A reserved bit flag; do not use in your own code
1635 	 */
1636 	MODIFIER_RESERVED_22_MASK = 4194304,
1637 	/**
1638 	 * A reserved bit flag; do not use in your own code
1639 	 */
1640 	MODIFIER_RESERVED_23_MASK = 8388608,
1641 	/**
1642 	 * A reserved bit flag; do not use in your own code
1643 	 */
1644 	MODIFIER_RESERVED_24_MASK = 16777216,
1645 	/**
1646 	 * A reserved bit flag; do not use in your own code
1647 	 */
1648 	MODIFIER_RESERVED_25_MASK = 33554432,
1649 	/**
1650 	 * the Super modifier. Since 2.10
1651 	 */
1652 	SUPER_MASK = 67108864,
1653 	/**
1654 	 * the Hyper modifier. Since 2.10
1655 	 */
1656 	HYPER_MASK = 134217728,
1657 	/**
1658 	 * the Meta modifier. Since 2.10
1659 	 */
1660 	META_MASK = 268435456,
1661 	/**
1662 	 * A reserved bit flag; do not use in your own code
1663 	 */
1664 	MODIFIER_RESERVED_29_MASK = 536870912,
1665 	/**
1666 	 * not used in GDK itself. GTK+ uses it to differentiate
1667 	 * between (keyval, modifiers) pairs from key press and release events.
1668 	 */
1669 	RELEASE_MASK = 1073741824,
1670 	/**
1671 	 * a mask covering all modifier types.
1672 	 */
1673 	MODIFIER_MASK = 1543512063,
1674 }
1675 alias GdkModifierType ModifierType;
1676 
1677 /**
1678  * Specifies the kind of crossing for #GdkEventCrossing.
1679  *
1680  * See the X11 protocol specification of LeaveNotify for
1681  * full details of crossing event generation.
1682  */
1683 public enum GdkNotifyType
1684 {
1685 	/**
1686 	 * the window is entered from an ancestor or
1687 	 * left towards an ancestor.
1688 	 */
1689 	ANCESTOR = 0,
1690 	/**
1691 	 * the pointer moves between an ancestor and an
1692 	 * inferior of the window.
1693 	 */
1694 	VIRTUAL = 1,
1695 	/**
1696 	 * the window is entered from an inferior or
1697 	 * left towards an inferior.
1698 	 */
1699 	INFERIOR = 2,
1700 	/**
1701 	 * the window is entered from or left towards
1702 	 * a window which is neither an ancestor nor an inferior.
1703 	 */
1704 	NONLINEAR = 3,
1705 	/**
1706 	 * the pointer moves between two windows
1707 	 * which are not ancestors of each other and the window is part of
1708 	 * the ancestor chain between one of these windows and their least
1709 	 * common ancestor.
1710 	 */
1711 	NONLINEAR_VIRTUAL = 4,
1712 	/**
1713 	 * an unknown type of enter/leave event occurred.
1714 	 */
1715 	UNKNOWN = 5,
1716 }
1717 alias GdkNotifyType NotifyType;
1718 
1719 /**
1720  * Specifies why a selection ownership was changed.
1721  */
1722 public enum GdkOwnerChange
1723 {
1724 	/**
1725 	 * some other app claimed the ownership
1726 	 */
1727 	NEW_OWNER = 0,
1728 	/**
1729 	 * the window was destroyed
1730 	 */
1731 	DESTROY = 1,
1732 	/**
1733 	 * the client was closed
1734 	 */
1735 	CLOSE = 2,
1736 }
1737 alias GdkOwnerChange OwnerChange;
1738 
1739 /**
1740  * Describes how existing data is combined with new data when
1741  * using gdk_property_change().
1742  */
1743 public enum GdkPropMode
1744 {
1745 	/**
1746 	 * the new data replaces the existing data.
1747 	 */
1748 	REPLACE = 0,
1749 	/**
1750 	 * the new data is prepended to the existing data.
1751 	 */
1752 	PREPEND = 1,
1753 	/**
1754 	 * the new data is appended to the existing data.
1755 	 */
1756 	APPEND = 2,
1757 }
1758 alias GdkPropMode PropMode;
1759 
1760 /**
1761  * Specifies the type of a property change for a #GdkEventProperty.
1762  */
1763 public enum GdkPropertyState
1764 {
1765 	/**
1766 	 * the property value was changed.
1767 	 */
1768 	NEW_VALUE = 0,
1769 	/**
1770 	 * the property was deleted.
1771 	 */
1772 	DELETE = 1,
1773 }
1774 alias GdkPropertyState PropertyState;
1775 
1776 /**
1777  * Specifies the direction for #GdkEventScroll.
1778  */
1779 public enum GdkScrollDirection
1780 {
1781 	/**
1782 	 * the window is scrolled up.
1783 	 */
1784 	UP = 0,
1785 	/**
1786 	 * the window is scrolled down.
1787 	 */
1788 	DOWN = 1,
1789 	/**
1790 	 * the window is scrolled to the left.
1791 	 */
1792 	LEFT = 2,
1793 	/**
1794 	 * the window is scrolled to the right.
1795 	 */
1796 	RIGHT = 3,
1797 	/**
1798 	 * the scrolling is determined by the delta values
1799 	 * in #GdkEventScroll. See gdk_event_get_scroll_deltas(). Since: 3.4
1800 	 */
1801 	SMOOTH = 4,
1802 }
1803 alias GdkScrollDirection ScrollDirection;
1804 
1805 /**
1806  * Flags describing the seat capabilities.
1807  *
1808  * Since: 3.20
1809  */
1810 public enum GdkSeatCapabilities
1811 {
1812 	/**
1813 	 * No input capabilities
1814 	 */
1815 	NONE = 0,
1816 	/**
1817 	 * The seat has a pointer (e.g. mouse)
1818 	 */
1819 	POINTER = 1,
1820 	/**
1821 	 * The seat has touchscreen(s) attached
1822 	 */
1823 	TOUCH = 2,
1824 	/**
1825 	 * The seat has drawing tablet(s) attached
1826 	 */
1827 	TABLET_STYLUS = 4,
1828 	/**
1829 	 * The seat has keyboard(s) attached
1830 	 */
1831 	KEYBOARD = 8,
1832 	/**
1833 	 * The union of all pointing capabilities
1834 	 */
1835 	ALL_POINTING = 7,
1836 	/**
1837 	 * The union of all capabilities
1838 	 */
1839 	ALL = 15,
1840 }
1841 alias GdkSeatCapabilities SeatCapabilities;
1842 
1843 /**
1844  * Specifies the kind of modification applied to a setting in a
1845  * #GdkEventSetting.
1846  */
1847 public enum GdkSettingAction
1848 {
1849 	/**
1850 	 * a setting was added.
1851 	 */
1852 	NEW = 0,
1853 	/**
1854 	 * a setting was changed.
1855 	 */
1856 	CHANGED = 1,
1857 	/**
1858 	 * a setting was deleted.
1859 	 */
1860 	DELETED = 2,
1861 }
1862 alias GdkSettingAction SettingAction;
1863 
1864 public enum GdkStatus
1865 {
1866 	OK = 0,
1867 	ERROR = -1,
1868 	ERROR_PARAM = -2,
1869 	ERROR_FILE = -3,
1870 	ERROR_MEM = -4,
1871 }
1872 alias GdkStatus Status;
1873 
1874 /**
1875  * This enumeration describes how the red, green and blue components
1876  * of physical pixels on an output device are laid out.
1877  *
1878  * Since: 3.22
1879  */
1880 public enum GdkSubpixelLayout
1881 {
1882 	/**
1883 	 * The layout is not known
1884 	 */
1885 	UNKNOWN = 0,
1886 	/**
1887 	 * Not organized in this way
1888 	 */
1889 	NONE = 1,
1890 	/**
1891 	 * The layout is horizontal, the order is RGB
1892 	 */
1893 	HORIZONTAL_RGB = 2,
1894 	/**
1895 	 * The layout is horizontal, the order is BGR
1896 	 */
1897 	HORIZONTAL_BGR = 3,
1898 	/**
1899 	 * The layout is vertical, the order is RGB
1900 	 */
1901 	VERTICAL_RGB = 4,
1902 	/**
1903 	 * The layout is vertical, the order is BGR
1904 	 */
1905 	VERTICAL_BGR = 5,
1906 }
1907 alias GdkSubpixelLayout SubpixelLayout;
1908 
1909 /**
1910  * Specifies the current state of a touchpad gesture. All gestures are
1911  * guaranteed to begin with an event with phase %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
1912  * followed by 0 or several events with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
1913  *
1914  * A finished gesture may have 2 possible outcomes, an event with phase
1915  * %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
1916  * considered successful, this should be used as the hint to perform any
1917  * permanent changes.
1918  *
1919  * Cancelled gestures may be so for a variety of reasons, due to hardware
1920  * or the compositor, or due to the gesture recognition layers hinting the
1921  * gesture did not finish resolutely (eg. a 3rd finger being added during
1922  * a pinch gesture). In these cases, the last event will report the phase
1923  * %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
1924  * to undo any visible/permanent changes that were done throughout the
1925  * progress of the gesture.
1926  *
1927  * See also #GdkEventTouchpadSwipe and #GdkEventTouchpadPinch.
1928  */
1929 public enum GdkTouchpadGesturePhase
1930 {
1931 	/**
1932 	 * The gesture has begun.
1933 	 */
1934 	BEGIN = 0,
1935 	/**
1936 	 * The gesture has been updated.
1937 	 */
1938 	UPDATE = 1,
1939 	/**
1940 	 * The gesture was finished, changes
1941 	 * should be permanently applied.
1942 	 */
1943 	END = 2,
1944 	/**
1945 	 * The gesture was cancelled, all
1946 	 * changes should be undone.
1947 	 */
1948 	CANCEL = 3,
1949 }
1950 alias GdkTouchpadGesturePhase TouchpadGesturePhase;
1951 
1952 /**
1953  * Specifies the visiblity status of a window for a #GdkEventVisibility.
1954  */
1955 public enum GdkVisibilityState
1956 {
1957 	/**
1958 	 * the window is completely visible.
1959 	 */
1960 	UNOBSCURED = 0,
1961 	/**
1962 	 * the window is partially visible.
1963 	 */
1964 	PARTIAL = 1,
1965 	/**
1966 	 * the window is not visible at all.
1967 	 */
1968 	FULLY_OBSCURED = 2,
1969 }
1970 alias GdkVisibilityState VisibilityState;
1971 
1972 /**
1973  * A set of values that describe the manner in which the pixel values
1974  * for a visual are converted into RGB values for display.
1975  */
1976 public enum GdkVisualType
1977 {
1978 	/**
1979 	 * Each pixel value indexes a grayscale value
1980 	 * directly.
1981 	 */
1982 	STATIC_GRAY = 0,
1983 	/**
1984 	 * Each pixel is an index into a color map that
1985 	 * maps pixel values into grayscale values. The color map can be
1986 	 * changed by an application.
1987 	 */
1988 	GRAYSCALE = 1,
1989 	/**
1990 	 * Each pixel value is an index into a predefined,
1991 	 * unmodifiable color map that maps pixel values into RGB values.
1992 	 */
1993 	STATIC_COLOR = 2,
1994 	/**
1995 	 * Each pixel is an index into a color map that
1996 	 * maps pixel values into rgb values. The color map can be changed by
1997 	 * an application.
1998 	 */
1999 	PSEUDO_COLOR = 3,
2000 	/**
2001 	 * Each pixel value directly contains red, green,
2002 	 * and blue components. Use gdk_visual_get_red_pixel_details(), etc,
2003 	 * to obtain information about how the components are assembled into
2004 	 * a pixel value.
2005 	 */
2006 	TRUE_COLOR = 4,
2007 	/**
2008 	 * Each pixel value contains red, green, and blue
2009 	 * components as for %GDK_VISUAL_TRUE_COLOR, but the components are
2010 	 * mapped via a color table into the final output table instead of
2011 	 * being converted directly.
2012 	 */
2013 	DIRECT_COLOR = 5,
2014 }
2015 alias GdkVisualType VisualType;
2016 
2017 /**
2018  * These are hints originally defined by the Motif toolkit.
2019  * The window manager can use them when determining how to decorate
2020  * the window. The hint must be set before mapping the window.
2021  */
2022 public enum GdkWMDecoration
2023 {
2024 	/**
2025 	 * all decorations should be applied.
2026 	 */
2027 	ALL = 1,
2028 	/**
2029 	 * a frame should be drawn around the window.
2030 	 */
2031 	BORDER = 2,
2032 	/**
2033 	 * the frame should have resize handles.
2034 	 */
2035 	RESIZEH = 4,
2036 	/**
2037 	 * a titlebar should be placed above the window.
2038 	 */
2039 	TITLE = 8,
2040 	/**
2041 	 * a button for opening a menu should be included.
2042 	 */
2043 	MENU = 16,
2044 	/**
2045 	 * a minimize button should be included.
2046 	 */
2047 	MINIMIZE = 32,
2048 	/**
2049 	 * a maximize button should be included.
2050 	 */
2051 	MAXIMIZE = 64,
2052 }
2053 alias GdkWMDecoration WMDecoration;
2054 
2055 /**
2056  * These are hints originally defined by the Motif toolkit. The window manager
2057  * can use them when determining the functions to offer for the window. The
2058  * hint must be set before mapping the window.
2059  */
2060 public enum GdkWMFunction
2061 {
2062 	/**
2063 	 * all functions should be offered.
2064 	 */
2065 	ALL = 1,
2066 	/**
2067 	 * the window should be resizable.
2068 	 */
2069 	RESIZE = 2,
2070 	/**
2071 	 * the window should be movable.
2072 	 */
2073 	MOVE = 4,
2074 	/**
2075 	 * the window should be minimizable.
2076 	 */
2077 	MINIMIZE = 8,
2078 	/**
2079 	 * the window should be maximizable.
2080 	 */
2081 	MAXIMIZE = 16,
2082 	/**
2083 	 * the window should be closable.
2084 	 */
2085 	CLOSE = 32,
2086 }
2087 alias GdkWMFunction WMFunction;
2088 
2089 /**
2090  * Used to indicate which fields in the #GdkWindowAttr struct should be honored.
2091  * For example, if you filled in the “cursor” and “x” fields of #GdkWindowAttr,
2092  * pass “@GDK_WA_X | @GDK_WA_CURSOR” to gdk_window_new(). Fields in
2093  * #GdkWindowAttr not covered by a bit in this enum are required; for example,
2094  * the @width/@height, @wclass, and @window_type fields are required, they have
2095  * no corresponding flag in #GdkWindowAttributesType.
2096  */
2097 public enum GdkWindowAttributesType
2098 {
2099 	/**
2100 	 * Honor the title field
2101 	 */
2102 	TITLE = 2,
2103 	/**
2104 	 * Honor the X coordinate field
2105 	 */
2106 	X = 4,
2107 	/**
2108 	 * Honor the Y coordinate field
2109 	 */
2110 	Y = 8,
2111 	/**
2112 	 * Honor the cursor field
2113 	 */
2114 	CURSOR = 16,
2115 	/**
2116 	 * Honor the visual field
2117 	 */
2118 	VISUAL = 32,
2119 	/**
2120 	 * Honor the wmclass_class and wmclass_name fields
2121 	 */
2122 	WMCLASS = 64,
2123 	/**
2124 	 * Honor the override_redirect field
2125 	 */
2126 	NOREDIR = 128,
2127 	/**
2128 	 * Honor the type_hint field
2129 	 */
2130 	TYPE_HINT = 256,
2131 }
2132 alias GdkWindowAttributesType WindowAttributesType;
2133 
2134 /**
2135  * Determines a window edge or corner.
2136  */
2137 public enum GdkWindowEdge
2138 {
2139 	/**
2140 	 * the top left corner.
2141 	 */
2142 	NORTH_WEST = 0,
2143 	/**
2144 	 * the top edge.
2145 	 */
2146 	NORTH = 1,
2147 	/**
2148 	 * the top right corner.
2149 	 */
2150 	NORTH_EAST = 2,
2151 	/**
2152 	 * the left edge.
2153 	 */
2154 	WEST = 3,
2155 	/**
2156 	 * the right edge.
2157 	 */
2158 	EAST = 4,
2159 	/**
2160 	 * the lower left corner.
2161 	 */
2162 	SOUTH_WEST = 5,
2163 	/**
2164 	 * the lower edge.
2165 	 */
2166 	SOUTH = 6,
2167 	/**
2168 	 * the lower right corner.
2169 	 */
2170 	SOUTH_EAST = 7,
2171 }
2172 alias GdkWindowEdge WindowEdge;
2173 
2174 /**
2175  * Used to indicate which fields of a #GdkGeometry struct should be paid
2176  * attention to. Also, the presence/absence of @GDK_HINT_POS,
2177  * @GDK_HINT_USER_POS, and @GDK_HINT_USER_SIZE is significant, though they don't
2178  * directly refer to #GdkGeometry fields. @GDK_HINT_USER_POS will be set
2179  * automatically by #GtkWindow if you call gtk_window_move().
2180  * @GDK_HINT_USER_POS and @GDK_HINT_USER_SIZE should be set if the user
2181  * specified a size/position using a --geometry command-line argument;
2182  * gtk_window_parse_geometry() automatically sets these flags.
2183  */
2184 public enum GdkWindowHints
2185 {
2186 	/**
2187 	 * indicates that the program has positioned the window
2188 	 */
2189 	POS = 1,
2190 	/**
2191 	 * min size fields are set
2192 	 */
2193 	MIN_SIZE = 2,
2194 	/**
2195 	 * max size fields are set
2196 	 */
2197 	MAX_SIZE = 4,
2198 	/**
2199 	 * base size fields are set
2200 	 */
2201 	BASE_SIZE = 8,
2202 	/**
2203 	 * aspect ratio fields are set
2204 	 */
2205 	ASPECT = 16,
2206 	/**
2207 	 * resize increment fields are set
2208 	 */
2209 	RESIZE_INC = 32,
2210 	/**
2211 	 * window gravity field is set
2212 	 */
2213 	WIN_GRAVITY = 64,
2214 	/**
2215 	 * indicates that the window’s position was explicitly set
2216 	 * by the user
2217 	 */
2218 	USER_POS = 128,
2219 	/**
2220 	 * indicates that the window’s size was explicitly set by
2221 	 * the user
2222 	 */
2223 	USER_SIZE = 256,
2224 }
2225 alias GdkWindowHints WindowHints;
2226 
2227 /**
2228  * Specifies the state of a toplevel window.
2229  */
2230 public enum GdkWindowState
2231 {
2232 	/**
2233 	 * the window is not shown.
2234 	 */
2235 	WITHDRAWN = 1,
2236 	/**
2237 	 * the window is minimized.
2238 	 */
2239 	ICONIFIED = 2,
2240 	/**
2241 	 * the window is maximized.
2242 	 */
2243 	MAXIMIZED = 4,
2244 	/**
2245 	 * the window is sticky.
2246 	 */
2247 	STICKY = 8,
2248 	/**
2249 	 * the window is maximized without
2250 	 * decorations.
2251 	 */
2252 	FULLSCREEN = 16,
2253 	/**
2254 	 * the window is kept above other windows.
2255 	 */
2256 	ABOVE = 32,
2257 	/**
2258 	 * the window is kept below other windows.
2259 	 */
2260 	BELOW = 64,
2261 	/**
2262 	 * the window is presented as focused (with active decorations).
2263 	 */
2264 	FOCUSED = 128,
2265 	/**
2266 	 * the window is in a tiled state, Since 3.10. Since 3.22.23, this
2267 	 * is deprecated in favor of per-edge information.
2268 	 */
2269 	TILED = 256,
2270 	/**
2271 	 * whether the top edge is tiled, Since 3.22.23
2272 	 */
2273 	TOP_TILED = 512,
2274 	/**
2275 	 * whether the top edge is resizable, Since 3.22.23
2276 	 */
2277 	TOP_RESIZABLE = 1024,
2278 	/**
2279 	 * whether the right edge is tiled, Since 3.22.23
2280 	 */
2281 	RIGHT_TILED = 2048,
2282 	/**
2283 	 * whether the right edge is resizable, Since 3.22.23
2284 	 */
2285 	RIGHT_RESIZABLE = 4096,
2286 	/**
2287 	 * whether the bottom edge is tiled, Since 3.22.23
2288 	 */
2289 	BOTTOM_TILED = 8192,
2290 	/**
2291 	 * whether the bottom edge is resizable, Since 3.22.23
2292 	 */
2293 	BOTTOM_RESIZABLE = 16384,
2294 	/**
2295 	 * whether the left edge is tiled, Since 3.22.23
2296 	 */
2297 	LEFT_TILED = 32768,
2298 	/**
2299 	 * whether the left edge is resizable, Since 3.22.23
2300 	 */
2301 	LEFT_RESIZABLE = 65536,
2302 }
2303 alias GdkWindowState WindowState;
2304 
2305 /**
2306  * Describes the kind of window.
2307  */
2308 public enum GdkWindowType
2309 {
2310 	/**
2311 	 * root window; this window has no parent, covers the entire
2312 	 * screen, and is created by the window system
2313 	 */
2314 	ROOT = 0,
2315 	/**
2316 	 * toplevel window (used to implement #GtkWindow)
2317 	 */
2318 	TOPLEVEL = 1,
2319 	/**
2320 	 * child window (used to implement e.g. #GtkEntry)
2321 	 */
2322 	CHILD = 2,
2323 	/**
2324 	 * override redirect temporary window (used to implement
2325 	 * #GtkMenu)
2326 	 */
2327 	TEMP = 3,
2328 	/**
2329 	 * foreign window (see gdk_window_foreign_new())
2330 	 */
2331 	FOREIGN = 4,
2332 	/**
2333 	 * offscreen window (see
2334 	 * [Offscreen Windows][OFFSCREEN-WINDOWS]). Since 2.18
2335 	 */
2336 	OFFSCREEN = 5,
2337 	/**
2338 	 * subsurface-based window; This window is visually
2339 	 * tied to a toplevel, and is moved/stacked with it. Currently this window
2340 	 * type is only implemented in Wayland. Since 3.14
2341 	 */
2342 	SUBSURFACE = 6,
2343 }
2344 alias GdkWindowType WindowType;
2345 
2346 /**
2347  * These are hints for the window manager that indicate what type of function
2348  * the window has. The window manager can use this when determining decoration
2349  * and behaviour of the window. The hint must be set before mapping the window.
2350  *
2351  * See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
2352  * specification for more details about window types.
2353  */
2354 public enum GdkWindowTypeHint
2355 {
2356 	/**
2357 	 * Normal toplevel window.
2358 	 */
2359 	NORMAL = 0,
2360 	/**
2361 	 * Dialog window.
2362 	 */
2363 	DIALOG = 1,
2364 	/**
2365 	 * Window used to implement a menu; GTK+ uses
2366 	 * this hint only for torn-off menus, see #GtkTearoffMenuItem.
2367 	 */
2368 	MENU = 2,
2369 	/**
2370 	 * Window used to implement toolbars.
2371 	 */
2372 	TOOLBAR = 3,
2373 	/**
2374 	 * Window used to display a splash
2375 	 * screen during application startup.
2376 	 */
2377 	SPLASHSCREEN = 4,
2378 	/**
2379 	 * Utility windows which are not detached
2380 	 * toolbars or dialogs.
2381 	 */
2382 	UTILITY = 5,
2383 	/**
2384 	 * Used for creating dock or panel windows.
2385 	 */
2386 	DOCK = 6,
2387 	/**
2388 	 * Used for creating the desktop background
2389 	 * window.
2390 	 */
2391 	DESKTOP = 7,
2392 	/**
2393 	 * A menu that belongs to a menubar.
2394 	 */
2395 	DROPDOWN_MENU = 8,
2396 	/**
2397 	 * A menu that does not belong to a menubar,
2398 	 * e.g. a context menu.
2399 	 */
2400 	POPUP_MENU = 9,
2401 	/**
2402 	 * A tooltip.
2403 	 */
2404 	TOOLTIP = 10,
2405 	/**
2406 	 * A notification - typically a “bubble”
2407 	 * that belongs to a status icon.
2408 	 */
2409 	NOTIFICATION = 11,
2410 	/**
2411 	 * A popup from a combo box.
2412 	 */
2413 	COMBO = 12,
2414 	/**
2415 	 * A window that is used to implement a DND cursor.
2416 	 */
2417 	DND = 13,
2418 }
2419 alias GdkWindowTypeHint WindowTypeHint;
2420 
2421 /**
2422  * @GDK_INPUT_OUTPUT windows are the standard kind of window you might expect.
2423  * Such windows receive events and are also displayed on screen.
2424  * @GDK_INPUT_ONLY windows are invisible; they are usually placed above other
2425  * windows in order to trap or filter the events. You can’t draw on
2426  * @GDK_INPUT_ONLY windows.
2427  */
2428 public enum GdkWindowWindowClass
2429 {
2430 	/**
2431 	 * window for graphics and events
2432 	 */
2433 	INPUT_OUTPUT = 0,
2434 	/**
2435 	 * window for events only
2436 	 */
2437 	INPUT_ONLY = 1,
2438 }
2439 alias GdkWindowWindowClass WindowWindowClass;
2440 
2441 /**
2442  * An opaque type representing a string as an index into a table
2443  * of strings on the X server.
2444  */
2445 alias _GdkAtom* GdkAtom;
2446 public struct _GdkAtom;
2447 
2448 struct GdkAppLaunchContext;
2449 
2450 struct GdkColor
2451 {
2452 	/**
2453 	 * For allocated colors, the pixel value used to
2454 	 * draw this color on the screen. Not used anymore.
2455 	 */
2456 	uint pixel;
2457 	/**
2458 	 * The red component of the color. This is
2459 	 * a value between 0 and 65535, with 65535 indicating
2460 	 * full intensity
2461 	 */
2462 	ushort red;
2463 	/**
2464 	 * The green component of the color
2465 	 */
2466 	ushort green;
2467 	/**
2468 	 * The blue component of the color
2469 	 */
2470 	ushort blue;
2471 }
2472 
2473 struct GdkCursor;
2474 
2475 struct GdkDevice;
2476 
2477 struct GdkDeviceManager;
2478 
2479 struct GdkDevicePad;
2480 
2481 struct GdkDevicePadInterface;
2482 
2483 struct GdkDeviceTool;
2484 
2485 struct GdkDisplay;
2486 
2487 struct GdkDisplayManager;
2488 
2489 struct GdkDragContext;
2490 
2491 struct GdkDrawingContext;
2492 
2493 struct GdkDrawingContextClass;
2494 
2495 struct GdkEvent
2496 {
2497 	union
2498 	{
2499 		/**
2500 		 * the #GdkEventType
2501 		 */
2502 		GdkEventType type;
2503 		/**
2504 		 * a #GdkEventAny
2505 		 */
2506 		GdkEventAny any;
2507 		/**
2508 		 * a #GdkEventExpose
2509 		 */
2510 		GdkEventExpose expose;
2511 		/**
2512 		 * a #GdkEventVisibility
2513 		 */
2514 		GdkEventVisibility visibility;
2515 		/**
2516 		 * a #GdkEventMotion
2517 		 */
2518 		GdkEventMotion motion;
2519 		/**
2520 		 * a #GdkEventButton
2521 		 */
2522 		GdkEventButton button;
2523 		/**
2524 		 * a #GdkEventTouch
2525 		 */
2526 		GdkEventTouch touch;
2527 		/**
2528 		 * a #GdkEventScroll
2529 		 */
2530 		GdkEventScroll scroll;
2531 		/**
2532 		 * a #GdkEventKey
2533 		 */
2534 		GdkEventKey key;
2535 		/**
2536 		 * a #GdkEventCrossing
2537 		 */
2538 		GdkEventCrossing crossing;
2539 		/**
2540 		 * a #GdkEventFocus
2541 		 */
2542 		GdkEventFocus focusChange;
2543 		/**
2544 		 * a #GdkEventConfigure
2545 		 */
2546 		GdkEventConfigure configure;
2547 		/**
2548 		 * a #GdkEventProperty
2549 		 */
2550 		GdkEventProperty property;
2551 		/**
2552 		 * a #GdkEventSelection
2553 		 */
2554 		GdkEventSelection selection;
2555 		/**
2556 		 * a #GdkEventOwnerChange
2557 		 */
2558 		GdkEventOwnerChange ownerChange;
2559 		/**
2560 		 * a #GdkEventProximity
2561 		 */
2562 		GdkEventProximity proximity;
2563 		/**
2564 		 * a #GdkEventDND
2565 		 */
2566 		GdkEventDND dnd;
2567 		/**
2568 		 * a #GdkEventWindowState
2569 		 */
2570 		GdkEventWindowState windowState;
2571 		/**
2572 		 * a #GdkEventSetting
2573 		 */
2574 		GdkEventSetting setting;
2575 		/**
2576 		 * a #GdkEventGrabBroken
2577 		 */
2578 		GdkEventGrabBroken grabBroken;
2579 		/**
2580 		 * a #GdkEventTouchpadSwipe
2581 		 */
2582 		GdkEventTouchpadSwipe touchpadSwipe;
2583 		/**
2584 		 * a #GdkEventTouchpadPinch
2585 		 */
2586 		GdkEventTouchpadPinch touchpadPinch;
2587 		/**
2588 		 * a #GdkEventPadButton
2589 		 */
2590 		GdkEventPadButton padButton;
2591 		/**
2592 		 * a #GdkEventPadAxis
2593 		 */
2594 		GdkEventPadAxis padAxis;
2595 		/**
2596 		 * a #GdkEventPadGroupMode
2597 		 */
2598 		GdkEventPadGroupMode padGroupMode;
2599 	}
2600 }
2601 
2602 /**
2603  * Contains the fields which are common to all event structs.
2604  * Any event pointer can safely be cast to a pointer to a #GdkEventAny to
2605  * access these fields.
2606  */
2607 struct GdkEventAny
2608 {
2609 	/**
2610 	 * the type of the event.
2611 	 */
2612 	GdkEventType type;
2613 	/**
2614 	 * the window which received the event.
2615 	 */
2616 	GdkWindow* window;
2617 	/**
2618 	 * %TRUE if the event was sent explicitly.
2619 	 */
2620 	byte sendEvent;
2621 }
2622 
2623 /**
2624  * Used for button press and button release events. The
2625  * @type field will be one of %GDK_BUTTON_PRESS,
2626  * %GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE,
2627  *
2628  * Double and triple-clicks result in a sequence of events being received.
2629  * For double-clicks the order of events will be:
2630  *
2631  * - %GDK_BUTTON_PRESS
2632  * - %GDK_BUTTON_RELEASE
2633  * - %GDK_BUTTON_PRESS
2634  * - %GDK_2BUTTON_PRESS
2635  * - %GDK_BUTTON_RELEASE
2636  *
2637  * Note that the first click is received just like a normal
2638  * button press, while the second click results in a %GDK_2BUTTON_PRESS
2639  * being received just after the %GDK_BUTTON_PRESS.
2640  *
2641  * Triple-clicks are very similar to double-clicks, except that
2642  * %GDK_3BUTTON_PRESS is inserted after the third click. The order of the
2643  * events is:
2644  *
2645  * - %GDK_BUTTON_PRESS
2646  * - %GDK_BUTTON_RELEASE
2647  * - %GDK_BUTTON_PRESS
2648  * - %GDK_2BUTTON_PRESS
2649  * - %GDK_BUTTON_RELEASE
2650  * - %GDK_BUTTON_PRESS
2651  * - %GDK_3BUTTON_PRESS
2652  * - %GDK_BUTTON_RELEASE
2653  *
2654  * For a double click to occur, the second button press must occur within
2655  * 1/4 of a second of the first. For a triple click to occur, the third
2656  * button press must also occur within 1/2 second of the first button press.
2657  */
2658 struct GdkEventButton
2659 {
2660 	/**
2661 	 * the type of the event (%GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS,
2662 	 * %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE).
2663 	 */
2664 	GdkEventType type;
2665 	/**
2666 	 * the window which received the event.
2667 	 */
2668 	GdkWindow* window;
2669 	/**
2670 	 * %TRUE if the event was sent explicitly.
2671 	 */
2672 	byte sendEvent;
2673 	/**
2674 	 * the time of the event in milliseconds.
2675 	 */
2676 	uint time;
2677 	/**
2678 	 * the x coordinate of the pointer relative to the window.
2679 	 */
2680 	double x;
2681 	/**
2682 	 * the y coordinate of the pointer relative to the window.
2683 	 */
2684 	double y;
2685 	/**
2686 	 * @x, @y translated to the axes of @device, or %NULL if @device is
2687 	 * the mouse.
2688 	 */
2689 	double* axes;
2690 	/**
2691 	 * a bit-mask representing the state of
2692 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
2693 	 * buttons. See #GdkModifierType.
2694 	 */
2695 	ModifierType state;
2696 	/**
2697 	 * the button which was pressed or released, numbered from 1 to 5.
2698 	 * Normally button 1 is the left mouse button, 2 is the middle button,
2699 	 * and 3 is the right button. On 2-button mice, the middle button can
2700 	 * often be simulated by pressing both mouse buttons together.
2701 	 */
2702 	uint button;
2703 	/**
2704 	 * the master device that the event originated from. Use
2705 	 * gdk_event_get_source_device() to get the slave device.
2706 	 */
2707 	GdkDevice* device;
2708 	/**
2709 	 * the x coordinate of the pointer relative to the root of the
2710 	 * screen.
2711 	 */
2712 	double xRoot;
2713 	/**
2714 	 * the y coordinate of the pointer relative to the root of the
2715 	 * screen.
2716 	 */
2717 	double yRoot;
2718 }
2719 
2720 /**
2721  * Generated when a window size or position has changed.
2722  */
2723 struct GdkEventConfigure
2724 {
2725 	/**
2726 	 * the type of the event (%GDK_CONFIGURE).
2727 	 */
2728 	GdkEventType type;
2729 	/**
2730 	 * the window which received the event.
2731 	 */
2732 	GdkWindow* window;
2733 	/**
2734 	 * %TRUE if the event was sent explicitly.
2735 	 */
2736 	byte sendEvent;
2737 	/**
2738 	 * the new x coordinate of the window, relative to its parent.
2739 	 */
2740 	int x;
2741 	/**
2742 	 * the new y coordinate of the window, relative to its parent.
2743 	 */
2744 	int y;
2745 	/**
2746 	 * the new width of the window.
2747 	 */
2748 	int width;
2749 	/**
2750 	 * the new height of the window.
2751 	 */
2752 	int height;
2753 }
2754 
2755 /**
2756  * Generated when the pointer enters or leaves a window.
2757  */
2758 struct GdkEventCrossing
2759 {
2760 	/**
2761 	 * the type of the event (%GDK_ENTER_NOTIFY or %GDK_LEAVE_NOTIFY).
2762 	 */
2763 	GdkEventType type;
2764 	/**
2765 	 * the window which received the event.
2766 	 */
2767 	GdkWindow* window;
2768 	/**
2769 	 * %TRUE if the event was sent explicitly.
2770 	 */
2771 	byte sendEvent;
2772 	/**
2773 	 * the window that was entered or left.
2774 	 */
2775 	GdkWindow* subwindow;
2776 	/**
2777 	 * the time of the event in milliseconds.
2778 	 */
2779 	uint time;
2780 	/**
2781 	 * the x coordinate of the pointer relative to the window.
2782 	 */
2783 	double x;
2784 	/**
2785 	 * the y coordinate of the pointer relative to the window.
2786 	 */
2787 	double y;
2788 	/**
2789 	 * the x coordinate of the pointer relative to the root of the screen.
2790 	 */
2791 	double xRoot;
2792 	/**
2793 	 * the y coordinate of the pointer relative to the root of the screen.
2794 	 */
2795 	double yRoot;
2796 	/**
2797 	 * the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB,
2798 	 * %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or
2799 	 * %GDK_CROSSING_STATE_CHANGED).  %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB,
2800 	 * and %GDK_CROSSING_STATE_CHANGED were added in 2.14 and are always synthesized,
2801 	 * never native.
2802 	 */
2803 	GdkCrossingMode mode;
2804 	/**
2805 	 * the kind of crossing that happened (%GDK_NOTIFY_INFERIOR,
2806 	 * %GDK_NOTIFY_ANCESTOR, %GDK_NOTIFY_VIRTUAL, %GDK_NOTIFY_NONLINEAR or
2807 	 * %GDK_NOTIFY_NONLINEAR_VIRTUAL).
2808 	 */
2809 	GdkNotifyType detail;
2810 	/**
2811 	 * %TRUE if @window is the focus window or an inferior.
2812 	 */
2813 	bool focus;
2814 	/**
2815 	 * a bit-mask representing the state of
2816 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
2817 	 * buttons. See #GdkModifierType.
2818 	 */
2819 	ModifierType state;
2820 }
2821 
2822 /**
2823  * Generated during DND operations.
2824  */
2825 struct GdkEventDND
2826 {
2827 	/**
2828 	 * the type of the event (%GDK_DRAG_ENTER, %GDK_DRAG_LEAVE,
2829 	 * %GDK_DRAG_MOTION, %GDK_DRAG_STATUS, %GDK_DROP_START or
2830 	 * %GDK_DROP_FINISHED).
2831 	 */
2832 	GdkEventType type;
2833 	/**
2834 	 * the window which received the event.
2835 	 */
2836 	GdkWindow* window;
2837 	/**
2838 	 * %TRUE if the event was sent explicitly.
2839 	 */
2840 	byte sendEvent;
2841 	/**
2842 	 * the #GdkDragContext for the current DND operation.
2843 	 */
2844 	GdkDragContext* context;
2845 	/**
2846 	 * the time of the event in milliseconds.
2847 	 */
2848 	uint time;
2849 	/**
2850 	 * the x coordinate of the pointer relative to the root of the
2851 	 * screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.
2852 	 */
2853 	short xRoot;
2854 	/**
2855 	 * the y coordinate of the pointer relative to the root of the
2856 	 * screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.
2857 	 */
2858 	short yRoot;
2859 }
2860 
2861 /**
2862  * Generated when all or part of a window becomes visible and needs to be
2863  * redrawn.
2864  */
2865 struct GdkEventExpose
2866 {
2867 	/**
2868 	 * the type of the event (%GDK_EXPOSE or %GDK_DAMAGE).
2869 	 */
2870 	GdkEventType type;
2871 	/**
2872 	 * the window which received the event.
2873 	 */
2874 	GdkWindow* window;
2875 	/**
2876 	 * %TRUE if the event was sent explicitly.
2877 	 */
2878 	byte sendEvent;
2879 	/**
2880 	 * bounding box of @region.
2881 	 */
2882 	GdkRectangle area;
2883 	/**
2884 	 * the region that needs to be redrawn.
2885 	 */
2886 	cairo_region_t* region;
2887 	/**
2888 	 * the number of contiguous %GDK_EXPOSE events following this one.
2889 	 * The only use for this is “exposure compression”, i.e. handling all
2890 	 * contiguous %GDK_EXPOSE events in one go, though GDK performs some
2891 	 * exposure compression so this is not normally needed.
2892 	 */
2893 	int count;
2894 }
2895 
2896 /**
2897  * Describes a change of keyboard focus.
2898  */
2899 struct GdkEventFocus
2900 {
2901 	/**
2902 	 * the type of the event (%GDK_FOCUS_CHANGE).
2903 	 */
2904 	GdkEventType type;
2905 	/**
2906 	 * the window which received the event.
2907 	 */
2908 	GdkWindow* window;
2909 	/**
2910 	 * %TRUE if the event was sent explicitly.
2911 	 */
2912 	byte sendEvent;
2913 	/**
2914 	 * %TRUE if the window has gained the keyboard focus, %FALSE if
2915 	 * it has lost the focus.
2916 	 */
2917 	short inn;
2918 }
2919 
2920 /**
2921  * Generated when a pointer or keyboard grab is broken. On X11, this happens
2922  * when the grab window becomes unviewable (i.e. it or one of its ancestors
2923  * is unmapped), or if the same application grabs the pointer or keyboard
2924  * again. Note that implicit grabs (which are initiated by button presses)
2925  * can also cause #GdkEventGrabBroken events.
2926  *
2927  * Since: 2.8
2928  */
2929 struct GdkEventGrabBroken
2930 {
2931 	/**
2932 	 * the type of the event (%GDK_GRAB_BROKEN)
2933 	 */
2934 	GdkEventType type;
2935 	/**
2936 	 * the window which received the event, i.e. the window
2937 	 * that previously owned the grab
2938 	 */
2939 	GdkWindow* window;
2940 	/**
2941 	 * %TRUE if the event was sent explicitly.
2942 	 */
2943 	byte sendEvent;
2944 	/**
2945 	 * %TRUE if a keyboard grab was broken, %FALSE if a pointer
2946 	 * grab was broken
2947 	 */
2948 	bool keyboard;
2949 	/**
2950 	 * %TRUE if the broken grab was implicit
2951 	 */
2952 	bool implicit;
2953 	/**
2954 	 * If this event is caused by another grab in the same
2955 	 * application, @grab_window contains the new grab window. Otherwise
2956 	 * @grab_window is %NULL.
2957 	 */
2958 	GdkWindow* grabWindow;
2959 }
2960 
2961 /**
2962  * Describes a key press or key release event.
2963  */
2964 struct GdkEventKey
2965 {
2966 	/**
2967 	 * the type of the event (%GDK_KEY_PRESS or %GDK_KEY_RELEASE).
2968 	 */
2969 	GdkEventType type;
2970 	/**
2971 	 * the window which received the event.
2972 	 */
2973 	GdkWindow* window;
2974 	/**
2975 	 * %TRUE if the event was sent explicitly.
2976 	 */
2977 	byte sendEvent;
2978 	/**
2979 	 * the time of the event in milliseconds.
2980 	 */
2981 	uint time;
2982 	/**
2983 	 * a bit-mask representing the state of
2984 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
2985 	 * buttons. See #GdkModifierType.
2986 	 */
2987 	ModifierType state;
2988 	/**
2989 	 * the key that was pressed or released. See the
2990 	 * `gdk/gdkkeysyms.h` header file for a
2991 	 * complete list of GDK key codes.
2992 	 */
2993 	uint keyval;
2994 	/**
2995 	 * the length of @string.
2996 	 */
2997 	int length;
2998 	/**
2999 	 * a string containing an approximation of the text that
3000 	 * would result from this keypress. The only correct way to handle text
3001 	 * input of text is using input methods (see #GtkIMContext), so this
3002 	 * field is deprecated and should never be used.
3003 	 * (gdk_unicode_to_keyval() provides a non-deprecated way of getting
3004 	 * an approximate translation for a key.) The string is encoded in the
3005 	 * encoding of the current locale (Note: this for backwards compatibility:
3006 	 * strings in GTK+ and GDK are typically in UTF-8.) and NUL-terminated.
3007 	 * In some cases, the translation of the key code will be a single
3008 	 * NUL byte, in which case looking at @length is necessary to distinguish
3009 	 * it from the an empty translation.
3010 	 */
3011 	char* str;
3012 	/**
3013 	 * the raw code of the key that was pressed or released.
3014 	 */
3015 	ushort hardwareKeycode;
3016 	/**
3017 	 * the keyboard group.
3018 	 */
3019 	ubyte group;
3020 	import std.bitmanip: bitfields;
3021 	mixin(bitfields!(
3022 		uint, "isModifier", 1,
3023 		uint, "", 31
3024 	));
3025 }
3026 
3027 /**
3028  * Generated when the pointer moves.
3029  */
3030 struct GdkEventMotion
3031 {
3032 	/**
3033 	 * the type of the event.
3034 	 */
3035 	GdkEventType type;
3036 	/**
3037 	 * the window which received the event.
3038 	 */
3039 	GdkWindow* window;
3040 	/**
3041 	 * %TRUE if the event was sent explicitly.
3042 	 */
3043 	byte sendEvent;
3044 	/**
3045 	 * the time of the event in milliseconds.
3046 	 */
3047 	uint time;
3048 	/**
3049 	 * the x coordinate of the pointer relative to the window.
3050 	 */
3051 	double x;
3052 	/**
3053 	 * the y coordinate of the pointer relative to the window.
3054 	 */
3055 	double y;
3056 	/**
3057 	 * @x, @y translated to the axes of @device, or %NULL if @device is
3058 	 * the mouse.
3059 	 */
3060 	double* axes;
3061 	/**
3062 	 * a bit-mask representing the state of
3063 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
3064 	 * buttons. See #GdkModifierType.
3065 	 */
3066 	ModifierType state;
3067 	/**
3068 	 * set to 1 if this event is just a hint, see the
3069 	 * %GDK_POINTER_MOTION_HINT_MASK value of #GdkEventMask.
3070 	 */
3071 	short isHint;
3072 	/**
3073 	 * the master device that the event originated from. Use
3074 	 * gdk_event_get_source_device() to get the slave device.
3075 	 */
3076 	GdkDevice* device;
3077 	/**
3078 	 * the x coordinate of the pointer relative to the root of the
3079 	 * screen.
3080 	 */
3081 	double xRoot;
3082 	/**
3083 	 * the y coordinate of the pointer relative to the root of the
3084 	 * screen.
3085 	 */
3086 	double yRoot;
3087 }
3088 
3089 /**
3090  * Generated when the owner of a selection changes. On X11, this
3091  * information is only available if the X server supports the XFIXES
3092  * extension.
3093  *
3094  * Since: 2.6
3095  */
3096 struct GdkEventOwnerChange
3097 {
3098 	/**
3099 	 * the type of the event (%GDK_OWNER_CHANGE).
3100 	 */
3101 	GdkEventType type;
3102 	/**
3103 	 * the window which received the event
3104 	 */
3105 	GdkWindow* window;
3106 	/**
3107 	 * %TRUE if the event was sent explicitly.
3108 	 */
3109 	byte sendEvent;
3110 	/**
3111 	 * the new owner of the selection, or %NULL if there is none
3112 	 */
3113 	GdkWindow* owner;
3114 	/**
3115 	 * the reason for the ownership change as a #GdkOwnerChange value
3116 	 */
3117 	GdkOwnerChange reason;
3118 	/**
3119 	 * the atom identifying the selection
3120 	 */
3121 	GdkAtom selection;
3122 	/**
3123 	 * the timestamp of the event
3124 	 */
3125 	uint time;
3126 	/**
3127 	 * the time at which the selection ownership was taken
3128 	 * over
3129 	 */
3130 	uint selectionTime;
3131 }
3132 
3133 /**
3134  * Generated during %GDK_SOURCE_TABLET_PAD interaction with tactile sensors.
3135  *
3136  * Since: 3.22
3137  */
3138 struct GdkEventPadAxis
3139 {
3140 	/**
3141 	 * the type of the event (%GDK_PAD_RING or %GDK_PAD_STRIP).
3142 	 */
3143 	GdkEventType type;
3144 	/**
3145 	 * the window which received the event.
3146 	 */
3147 	GdkWindow* window;
3148 	/**
3149 	 * %TRUE if the event was sent explicitly.
3150 	 */
3151 	byte sendEvent;
3152 	/**
3153 	 * the time of the event in milliseconds.
3154 	 */
3155 	uint time;
3156 	/**
3157 	 * the pad group the ring/strip belongs to. A %GDK_SOURCE_TABLET_PAD
3158 	 * device may have one or more groups containing a set of buttons/rings/strips
3159 	 * each.
3160 	 */
3161 	uint group;
3162 	/**
3163 	 * number of strip/ring that was interacted. This number is 0-indexed.
3164 	 */
3165 	uint index;
3166 	/**
3167 	 * The current mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD
3168 	 * device may have different current modes.
3169 	 */
3170 	uint mode;
3171 	/**
3172 	 * The current value for the given axis.
3173 	 */
3174 	double value;
3175 }
3176 
3177 /**
3178  * Generated during %GDK_SOURCE_TABLET_PAD button presses and releases.
3179  *
3180  * Since: 3.22
3181  */
3182 struct GdkEventPadButton
3183 {
3184 	/**
3185 	 * the type of the event (%GDK_PAD_BUTTON_PRESS or %GDK_PAD_BUTTON_RELEASE).
3186 	 */
3187 	GdkEventType type;
3188 	/**
3189 	 * the window which received the event.
3190 	 */
3191 	GdkWindow* window;
3192 	/**
3193 	 * %TRUE if the event was sent explicitly.
3194 	 */
3195 	byte sendEvent;
3196 	/**
3197 	 * the time of the event in milliseconds.
3198 	 */
3199 	uint time;
3200 	/**
3201 	 * the pad group the button belongs to. A %GDK_SOURCE_TABLET_PAD device
3202 	 * may have one or more groups containing a set of buttons/rings/strips each.
3203 	 */
3204 	uint group;
3205 	/**
3206 	 * The pad button that was pressed.
3207 	 */
3208 	uint button;
3209 	/**
3210 	 * The current mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD
3211 	 * device may have different current modes.
3212 	 */
3213 	uint mode;
3214 }
3215 
3216 /**
3217  * Generated during %GDK_SOURCE_TABLET_PAD mode switches in a group.
3218  *
3219  * Since: 3.22
3220  */
3221 struct GdkEventPadGroupMode
3222 {
3223 	/**
3224 	 * the type of the event (%GDK_PAD_GROUP_MODE).
3225 	 */
3226 	GdkEventType type;
3227 	/**
3228 	 * the window which received the event.
3229 	 */
3230 	GdkWindow* window;
3231 	/**
3232 	 * %TRUE if the event was sent explicitly.
3233 	 */
3234 	byte sendEvent;
3235 	/**
3236 	 * the time of the event in milliseconds.
3237 	 */
3238 	uint time;
3239 	/**
3240 	 * the pad group that is switching mode. A %GDK_SOURCE_TABLET_PAD
3241 	 * device may have one or more groups containing a set of buttons/rings/strips
3242 	 * each.
3243 	 */
3244 	uint group;
3245 	/**
3246 	 * The new mode of @group. Different groups in a %GDK_SOURCE_TABLET_PAD
3247 	 * device may have different current modes.
3248 	 */
3249 	uint mode;
3250 }
3251 
3252 /**
3253  * Describes a property change on a window.
3254  */
3255 struct GdkEventProperty
3256 {
3257 	/**
3258 	 * the type of the event (%GDK_PROPERTY_NOTIFY).
3259 	 */
3260 	GdkEventType type;
3261 	/**
3262 	 * the window which received the event.
3263 	 */
3264 	GdkWindow* window;
3265 	/**
3266 	 * %TRUE if the event was sent explicitly.
3267 	 */
3268 	byte sendEvent;
3269 	/**
3270 	 * the property that was changed.
3271 	 */
3272 	GdkAtom atom;
3273 	/**
3274 	 * the time of the event in milliseconds.
3275 	 */
3276 	uint time;
3277 	/**
3278 	 * whether the property was changed
3279 	 * (%GDK_PROPERTY_NEW_VALUE) or deleted (%GDK_PROPERTY_DELETE).
3280 	 */
3281 	PropertyState state;
3282 }
3283 
3284 /**
3285  * Proximity events are generated when using GDK’s wrapper for the
3286  * XInput extension. The XInput extension is an add-on for standard X
3287  * that allows you to use nonstandard devices such as graphics tablets.
3288  * A proximity event indicates that the stylus has moved in or out of
3289  * contact with the tablet, or perhaps that the user’s finger has moved
3290  * in or out of contact with a touch screen.
3291  *
3292  * This event type will be used pretty rarely. It only is important for
3293  * XInput aware programs that are drawing their own cursor.
3294  */
3295 struct GdkEventProximity
3296 {
3297 	/**
3298 	 * the type of the event (%GDK_PROXIMITY_IN or %GDK_PROXIMITY_OUT).
3299 	 */
3300 	GdkEventType type;
3301 	/**
3302 	 * the window which received the event.
3303 	 */
3304 	GdkWindow* window;
3305 	/**
3306 	 * %TRUE if the event was sent explicitly.
3307 	 */
3308 	byte sendEvent;
3309 	/**
3310 	 * the time of the event in milliseconds.
3311 	 */
3312 	uint time;
3313 	/**
3314 	 * the master device that the event originated from. Use
3315 	 * gdk_event_get_source_device() to get the slave device.
3316 	 */
3317 	GdkDevice* device;
3318 }
3319 
3320 /**
3321  * Generated from button presses for the buttons 4 to 7. Wheel mice are
3322  * usually configured to generate button press events for buttons 4 and 5
3323  * when the wheel is turned.
3324  *
3325  * Some GDK backends can also generate “smooth” scroll events, which
3326  * can be recognized by the %GDK_SCROLL_SMOOTH scroll direction. For
3327  * these, the scroll deltas can be obtained with
3328  * gdk_event_get_scroll_deltas().
3329  */
3330 struct GdkEventScroll
3331 {
3332 	/**
3333 	 * the type of the event (%GDK_SCROLL).
3334 	 */
3335 	GdkEventType type;
3336 	/**
3337 	 * the window which received the event.
3338 	 */
3339 	GdkWindow* window;
3340 	/**
3341 	 * %TRUE if the event was sent explicitly.
3342 	 */
3343 	byte sendEvent;
3344 	/**
3345 	 * the time of the event in milliseconds.
3346 	 */
3347 	uint time;
3348 	/**
3349 	 * the x coordinate of the pointer relative to the window.
3350 	 */
3351 	double x;
3352 	/**
3353 	 * the y coordinate of the pointer relative to the window.
3354 	 */
3355 	double y;
3356 	/**
3357 	 * a bit-mask representing the state of
3358 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
3359 	 * buttons. See #GdkModifierType.
3360 	 */
3361 	ModifierType state;
3362 	/**
3363 	 * the direction to scroll to (one of %GDK_SCROLL_UP,
3364 	 * %GDK_SCROLL_DOWN, %GDK_SCROLL_LEFT, %GDK_SCROLL_RIGHT or
3365 	 * %GDK_SCROLL_SMOOTH).
3366 	 */
3367 	GdkScrollDirection direction;
3368 	/**
3369 	 * the master device that the event originated from. Use
3370 	 * gdk_event_get_source_device() to get the slave device.
3371 	 */
3372 	GdkDevice* device;
3373 	/**
3374 	 * the x coordinate of the pointer relative to the root of the
3375 	 * screen.
3376 	 */
3377 	double xRoot;
3378 	/**
3379 	 * the y coordinate of the pointer relative to the root of the
3380 	 * screen.
3381 	 */
3382 	double yRoot;
3383 	/**
3384 	 * the x coordinate of the scroll delta
3385 	 */
3386 	double deltaX;
3387 	/**
3388 	 * the y coordinate of the scroll delta
3389 	 */
3390 	double deltaY;
3391 	import std.bitmanip: bitfields;
3392 	mixin(bitfields!(
3393 		uint, "isStop", 1,
3394 		uint, "", 31
3395 	));
3396 }
3397 
3398 /**
3399  * Generated when a selection is requested or ownership of a selection
3400  * is taken over by another client application.
3401  */
3402 struct GdkEventSelection
3403 {
3404 	/**
3405 	 * the type of the event (%GDK_SELECTION_CLEAR,
3406 	 * %GDK_SELECTION_NOTIFY or %GDK_SELECTION_REQUEST).
3407 	 */
3408 	GdkEventType type;
3409 	/**
3410 	 * the window which received the event.
3411 	 */
3412 	GdkWindow* window;
3413 	/**
3414 	 * %TRUE if the event was sent explicitly.
3415 	 */
3416 	byte sendEvent;
3417 	/**
3418 	 * the selection.
3419 	 */
3420 	GdkAtom selection;
3421 	/**
3422 	 * the target to which the selection should be converted.
3423 	 */
3424 	GdkAtom target;
3425 	/**
3426 	 * the property in which to place the result of the conversion.
3427 	 */
3428 	GdkAtom property;
3429 	/**
3430 	 * the time of the event in milliseconds.
3431 	 */
3432 	uint time;
3433 	/**
3434 	 * the window on which to place @property or %NULL if none.
3435 	 */
3436 	GdkWindow* requestor;
3437 }
3438 
3439 struct GdkEventSequence;
3440 
3441 /**
3442  * Generated when a setting is modified.
3443  */
3444 struct GdkEventSetting
3445 {
3446 	/**
3447 	 * the type of the event (%GDK_SETTING).
3448 	 */
3449 	GdkEventType type;
3450 	/**
3451 	 * the window which received the event.
3452 	 */
3453 	GdkWindow* window;
3454 	/**
3455 	 * %TRUE if the event was sent explicitly.
3456 	 */
3457 	byte sendEvent;
3458 	/**
3459 	 * what happened to the setting (%GDK_SETTING_ACTION_NEW,
3460 	 * %GDK_SETTING_ACTION_CHANGED or %GDK_SETTING_ACTION_DELETED).
3461 	 */
3462 	GdkSettingAction action;
3463 	/**
3464 	 * the name of the setting.
3465 	 */
3466 	char* name;
3467 }
3468 
3469 /**
3470  * Used for touch events.
3471  * @type field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,
3472  * %GDK_TOUCH_END or %GDK_TOUCH_CANCEL.
3473  *
3474  * Touch events are grouped into sequences by means of the @sequence
3475  * field, which can also be obtained with gdk_event_get_event_sequence().
3476  * Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by
3477  * any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END
3478  * (or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be
3479  * several active sequences at the same time.
3480  */
3481 struct GdkEventTouch
3482 {
3483 	/**
3484 	 * the type of the event (%GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,
3485 	 * %GDK_TOUCH_END, %GDK_TOUCH_CANCEL)
3486 	 */
3487 	GdkEventType type;
3488 	/**
3489 	 * the window which received the event
3490 	 */
3491 	GdkWindow* window;
3492 	/**
3493 	 * %TRUE if the event was sent explicitly.
3494 	 */
3495 	byte sendEvent;
3496 	/**
3497 	 * the time of the event in milliseconds.
3498 	 */
3499 	uint time;
3500 	/**
3501 	 * the x coordinate of the pointer relative to the window
3502 	 */
3503 	double x;
3504 	/**
3505 	 * the y coordinate of the pointer relative to the window
3506 	 */
3507 	double y;
3508 	/**
3509 	 * @x, @y translated to the axes of @device, or %NULL if @device is
3510 	 * the mouse
3511 	 */
3512 	double* axes;
3513 	/**
3514 	 * a bit-mask representing the state of
3515 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
3516 	 * buttons. See #GdkModifierType
3517 	 */
3518 	ModifierType state;
3519 	/**
3520 	 * the event sequence that the event belongs to
3521 	 */
3522 	GdkEventSequence* sequence;
3523 	/**
3524 	 * whether the event should be used for emulating
3525 	 * pointer event
3526 	 */
3527 	bool emulatingPointer;
3528 	/**
3529 	 * the master device that the event originated from. Use
3530 	 * gdk_event_get_source_device() to get the slave device.
3531 	 */
3532 	GdkDevice* device;
3533 	/**
3534 	 * the x coordinate of the pointer relative to the root of the
3535 	 * screen
3536 	 */
3537 	double xRoot;
3538 	/**
3539 	 * the y coordinate of the pointer relative to the root of the
3540 	 * screen
3541 	 */
3542 	double yRoot;
3543 }
3544 
3545 /**
3546  * Generated during touchpad swipe gestures.
3547  */
3548 struct GdkEventTouchpadPinch
3549 {
3550 	/**
3551 	 * the type of the event (%GDK_TOUCHPAD_PINCH)
3552 	 */
3553 	GdkEventType type;
3554 	/**
3555 	 * the window which received the event
3556 	 */
3557 	GdkWindow* window;
3558 	/**
3559 	 * %TRUE if the event was sent explicitly
3560 	 */
3561 	byte sendEvent;
3562 	/**
3563 	 * the current phase of the gesture
3564 	 */
3565 	TouchpadGesturePhase phase;
3566 	/**
3567 	 * The number of fingers triggering the pinch
3568 	 */
3569 	byte nFingers;
3570 	/**
3571 	 * the time of the event in milliseconds
3572 	 */
3573 	uint time;
3574 	/**
3575 	 * The X coordinate of the pointer
3576 	 */
3577 	double x;
3578 	/**
3579 	 * The Y coordinate of the pointer
3580 	 */
3581 	double y;
3582 	/**
3583 	 * Movement delta in the X axis of the swipe focal point
3584 	 */
3585 	double dx;
3586 	/**
3587 	 * Movement delta in the Y axis of the swipe focal point
3588 	 */
3589 	double dy;
3590 	/**
3591 	 * The angle change in radians, negative angles
3592 	 * denote counter-clockwise movements
3593 	 */
3594 	double angleDelta;
3595 	/**
3596 	 * The current scale, relative to that at the time of
3597 	 * the corresponding %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN event
3598 	 */
3599 	double scale;
3600 	/**
3601 	 * The X coordinate of the pointer, relative to the
3602 	 * root of the screen.
3603 	 */
3604 	double xRoot;
3605 	/**
3606 	 * The Y coordinate of the pointer, relative to the
3607 	 * root of the screen.
3608 	 */
3609 	double yRoot;
3610 	/**
3611 	 * a bit-mask representing the state of
3612 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
3613 	 * buttons. See #GdkModifierType.
3614 	 */
3615 	ModifierType state;
3616 }
3617 
3618 /**
3619  * Generated during touchpad swipe gestures.
3620  */
3621 struct GdkEventTouchpadSwipe
3622 {
3623 	/**
3624 	 * the type of the event (%GDK_TOUCHPAD_SWIPE)
3625 	 */
3626 	GdkEventType type;
3627 	/**
3628 	 * the window which received the event
3629 	 */
3630 	GdkWindow* window;
3631 	/**
3632 	 * %TRUE if the event was sent explicitly
3633 	 */
3634 	byte sendEvent;
3635 	/**
3636 	 * the current phase of the gesture
3637 	 */
3638 	TouchpadGesturePhase phase;
3639 	/**
3640 	 * The number of fingers triggering the swipe
3641 	 */
3642 	byte nFingers;
3643 	/**
3644 	 * the time of the event in milliseconds
3645 	 */
3646 	uint time;
3647 	/**
3648 	 * The X coordinate of the pointer
3649 	 */
3650 	double x;
3651 	/**
3652 	 * The Y coordinate of the pointer
3653 	 */
3654 	double y;
3655 	/**
3656 	 * Movement delta in the X axis of the swipe focal point
3657 	 */
3658 	double dx;
3659 	/**
3660 	 * Movement delta in the Y axis of the swipe focal point
3661 	 */
3662 	double dy;
3663 	/**
3664 	 * The X coordinate of the pointer, relative to the
3665 	 * root of the screen.
3666 	 */
3667 	double xRoot;
3668 	/**
3669 	 * The Y coordinate of the pointer, relative to the
3670 	 * root of the screen.
3671 	 */
3672 	double yRoot;
3673 	/**
3674 	 * a bit-mask representing the state of
3675 	 * the modifier keys (e.g. Control, Shift and Alt) and the pointer
3676 	 * buttons. See #GdkModifierType.
3677 	 */
3678 	ModifierType state;
3679 }
3680 
3681 /**
3682  * Generated when the window visibility status has changed.
3683  *
3684  * Deprecated: Modern composited windowing systems with pervasive
3685  * transparency make it impossible to track the visibility of a window
3686  * reliably, so this event can not be guaranteed to provide useful
3687  * information.
3688  */
3689 struct GdkEventVisibility
3690 {
3691 	/**
3692 	 * the type of the event (%GDK_VISIBILITY_NOTIFY).
3693 	 */
3694 	GdkEventType type;
3695 	/**
3696 	 * the window which received the event.
3697 	 */
3698 	GdkWindow* window;
3699 	/**
3700 	 * %TRUE if the event was sent explicitly.
3701 	 */
3702 	byte sendEvent;
3703 	/**
3704 	 * the new visibility state (%GDK_VISIBILITY_FULLY_OBSCURED,
3705 	 * %GDK_VISIBILITY_PARTIAL or %GDK_VISIBILITY_UNOBSCURED).
3706 	 */
3707 	GdkVisibilityState state;
3708 }
3709 
3710 /**
3711  * Generated when the state of a toplevel window changes.
3712  */
3713 struct GdkEventWindowState
3714 {
3715 	/**
3716 	 * the type of the event (%GDK_WINDOW_STATE).
3717 	 */
3718 	GdkEventType type;
3719 	/**
3720 	 * the window which received the event.
3721 	 */
3722 	GdkWindow* window;
3723 	/**
3724 	 * %TRUE if the event was sent explicitly.
3725 	 */
3726 	byte sendEvent;
3727 	/**
3728 	 * mask specifying what flags have changed.
3729 	 */
3730 	GdkWindowState changedMask;
3731 	/**
3732 	 * the new window state, a combination of
3733 	 * #GdkWindowState bits.
3734 	 */
3735 	GdkWindowState newWindowState;
3736 }
3737 
3738 struct GdkFrameClock;
3739 
3740 struct GdkFrameClockClass;
3741 
3742 struct GdkFrameClockPrivate;
3743 
3744 struct GdkFrameTimings;
3745 
3746 struct GdkGLContext;
3747 
3748 /**
3749  * The #GdkGeometry struct gives the window manager information about
3750  * a window’s geometry constraints. Normally you would set these on
3751  * the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow
3752  * then sets the hints on the #GdkWindow it creates.
3753  *
3754  * gdk_window_set_geometry_hints() expects the hints to be fully valid already
3755  * and simply passes them to the window manager; in contrast,
3756  * gtk_window_set_geometry_hints() performs some interpretation. For example,
3757  * #GtkWindow will apply the hints to the geometry widget instead of the
3758  * toplevel window, if you set a geometry widget. Also, the
3759  * @min_width/@min_height/@max_width/@max_height fields may be set to -1, and
3760  * #GtkWindow will substitute the size request of the window or geometry widget.
3761  * If the minimum size hint is not provided, #GtkWindow will use its requisition
3762  * as the minimum size. If the minimum size is provided and a geometry widget is
3763  * set, #GtkWindow will take the minimum size as the minimum size of the
3764  * geometry widget rather than the entire window. The base size is treated
3765  * similarly.
3766  *
3767  * The canonical use-case for gtk_window_set_geometry_hints() is to get a
3768  * terminal widget to resize properly. Here, the terminal text area should be
3769  * the geometry widget; #GtkWindow will then automatically set the base size to
3770  * the size of other widgets in the terminal window, such as the menubar and
3771  * scrollbar. Then, the @width_inc and @height_inc fields should be set to the
3772  * size of one character in the terminal. Finally, the base size should be set
3773  * to the size of one character. The net effect is that the minimum size of the
3774  * terminal will have a 1x1 character terminal area, and only terminal sizes on
3775  * the “character grid” will be allowed.
3776  *
3777  * Here’s an example of how the terminal example would be implemented, assuming
3778  * a terminal area widget called “terminal” and a toplevel window “toplevel”:
3779  *
3780  * |[<!-- language="C" -->
3781  * GdkGeometry hints;
3782  *
3783  * hints.base_width = terminal->char_width;
3784  * hints.base_height = terminal->char_height;
3785  * hints.min_width = terminal->char_width;
3786  * hints.min_height = terminal->char_height;
3787  * hints.width_inc = terminal->char_width;
3788  * hints.height_inc = terminal->char_height;
3789  *
3790  * gtk_window_set_geometry_hints (GTK_WINDOW (toplevel),
3791  * GTK_WIDGET (terminal),
3792  * &hints,
3793  * GDK_HINT_RESIZE_INC |
3794  * GDK_HINT_MIN_SIZE |
3795  * GDK_HINT_BASE_SIZE);
3796  * ]|
3797  *
3798  * The other useful fields are the @min_aspect and @max_aspect fields; these
3799  * contain a width/height ratio as a floating point number. If a geometry widget
3800  * is set, the aspect applies to the geometry widget rather than the entire
3801  * window. The most common use of these hints is probably to set @min_aspect and
3802  * @max_aspect to the same value, thus forcing the window to keep a constant
3803  * aspect ratio.
3804  */
3805 struct GdkGeometry
3806 {
3807 	/**
3808 	 * minimum width of window (or -1 to use requisition, with
3809 	 * #GtkWindow only)
3810 	 */
3811 	int minWidth;
3812 	/**
3813 	 * minimum height of window (or -1 to use requisition, with
3814 	 * #GtkWindow only)
3815 	 */
3816 	int minHeight;
3817 	/**
3818 	 * maximum width of window (or -1 to use requisition, with
3819 	 * #GtkWindow only)
3820 	 */
3821 	int maxWidth;
3822 	/**
3823 	 * maximum height of window (or -1 to use requisition, with
3824 	 * #GtkWindow only)
3825 	 */
3826 	int maxHeight;
3827 	/**
3828 	 * allowed window widths are @base_width + @width_inc * N where N
3829 	 * is any integer (-1 allowed with #GtkWindow)
3830 	 */
3831 	int baseWidth;
3832 	/**
3833 	 * allowed window widths are @base_height + @height_inc * N where
3834 	 * N is any integer (-1 allowed with #GtkWindow)
3835 	 */
3836 	int baseHeight;
3837 	/**
3838 	 * width resize increment
3839 	 */
3840 	int widthInc;
3841 	/**
3842 	 * height resize increment
3843 	 */
3844 	int heightInc;
3845 	/**
3846 	 * minimum width/height ratio
3847 	 */
3848 	double minAspect;
3849 	/**
3850 	 * maximum width/height ratio
3851 	 */
3852 	double maxAspect;
3853 	/**
3854 	 * window gravity, see gtk_window_set_gravity()
3855 	 */
3856 	GdkGravity winGravity;
3857 }
3858 
3859 struct GdkKeymap;
3860 
3861 /**
3862  * A #GdkKeymapKey is a hardware key that can be mapped to a keyval.
3863  */
3864 struct GdkKeymapKey
3865 {
3866 	/**
3867 	 * the hardware keycode. This is an identifying number for a
3868 	 * physical key.
3869 	 */
3870 	uint keycode;
3871 	/**
3872 	 * indicates movement in a horizontal direction. Usually groups are used
3873 	 * for two different languages. In group 0, a key might have two English
3874 	 * characters, and in group 1 it might have two Hebrew characters. The Hebrew
3875 	 * characters will be printed on the key next to the English characters.
3876 	 */
3877 	int group;
3878 	/**
3879 	 * indicates which symbol on the key will be used, in a vertical direction.
3880 	 * So on a standard US keyboard, the key with the number “1” on it also has the
3881 	 * exclamation point ("!") character on it. The level indicates whether to use
3882 	 * the “1” or the “!” symbol. The letter keys are considered to have a lowercase
3883 	 * letter at level 0, and an uppercase letter at level 1, though only the
3884 	 * uppercase letter is printed.
3885 	 */
3886 	int level;
3887 }
3888 
3889 struct GdkMonitor;
3890 
3891 struct GdkMonitorClass;
3892 
3893 /**
3894  * Defines the x and y coordinates of a point.
3895  */
3896 struct GdkPoint
3897 {
3898 	/**
3899 	 * the x coordinate of the point.
3900 	 */
3901 	int x;
3902 	/**
3903 	 * the y coordinate of the point.
3904 	 */
3905 	int y;
3906 }
3907 
3908 struct GdkRGBA
3909 {
3910 	/**
3911 	 * The intensity of the red channel from 0.0 to 1.0 inclusive
3912 	 */
3913 	double red;
3914 	/**
3915 	 * The intensity of the green channel from 0.0 to 1.0 inclusive
3916 	 */
3917 	double green;
3918 	/**
3919 	 * The intensity of the blue channel from 0.0 to 1.0 inclusive
3920 	 */
3921 	double blue;
3922 	/**
3923 	 * The opacity of the color from 0.0 for completely translucent to
3924 	 * 1.0 for opaque
3925 	 */
3926 	double alpha;
3927 }
3928 
3929 /**
3930  * Defines the position and size of a rectangle. It is identical to
3931  * #cairo_rectangle_int_t.
3932  */
3933 struct GdkRectangle
3934 {
3935 	int x;
3936 	int y;
3937 	int width;
3938 	int height;
3939 }
3940 
3941 struct GdkScreen;
3942 
3943 struct GdkSeat
3944 {
3945 	GObject parentInstance;
3946 }
3947 
3948 /**
3949  * A #GdkTimeCoord stores a single event in a motion history.
3950  */
3951 struct GdkTimeCoord
3952 {
3953 	/**
3954 	 * The timestamp for this event.
3955 	 */
3956 	uint time;
3957 	/**
3958 	 * the values of the device’s axes.
3959 	 */
3960 	double[128] axes;
3961 }
3962 
3963 struct GdkVisual;
3964 
3965 struct GdkWindow;
3966 
3967 /**
3968  * Attributes to use for a newly-created window.
3969  */
3970 struct GdkWindowAttr
3971 {
3972 	/**
3973 	 * title of the window (for toplevel windows)
3974 	 */
3975 	char* title;
3976 	/**
3977 	 * event mask (see gdk_window_set_events())
3978 	 */
3979 	int eventMask;
3980 	/**
3981 	 * X coordinate relative to parent window (see gdk_window_move())
3982 	 */
3983 	int x;
3984 	/**
3985 	 * Y coordinate relative to parent window (see gdk_window_move())
3986 	 */
3987 	int y;
3988 	/**
3989 	 * width of window
3990 	 */
3991 	int width;
3992 	/**
3993 	 * height of window
3994 	 */
3995 	int height;
3996 	/**
3997 	 * #GDK_INPUT_OUTPUT (normal window) or #GDK_INPUT_ONLY (invisible
3998 	 * window that receives events)
3999 	 */
4000 	GdkWindowWindowClass wclass;
4001 	/**
4002 	 * #GdkVisual for window
4003 	 */
4004 	GdkVisual* visual;
4005 	/**
4006 	 * type of window
4007 	 */
4008 	GdkWindowType windowType;
4009 	/**
4010 	 * cursor for the window (see gdk_window_set_cursor())
4011 	 */
4012 	GdkCursor* cursor;
4013 	/**
4014 	 * don’t use (see gtk_window_set_wmclass())
4015 	 */
4016 	char* wmclassName;
4017 	/**
4018 	 * don’t use (see gtk_window_set_wmclass())
4019 	 */
4020 	char* wmclassClass;
4021 	/**
4022 	 * %TRUE to bypass the window manager
4023 	 */
4024 	bool overrideRedirect;
4025 	/**
4026 	 * a hint of the function of the window
4027 	 */
4028 	GdkWindowTypeHint typeHint;
4029 }
4030 
4031 struct GdkWindowClass
4032 {
4033 	GObjectClass parentClass;
4034 	/** */
4035 	extern(C) GdkWindow* function(GdkWindow* window, double x, double y) pickEmbeddedChild;
4036 	/** */
4037 	extern(C) void function(GdkWindow* window, double offscreenX, double offscreenY, double* embedderX, double* embedderY) toEmbedder;
4038 	/** */
4039 	extern(C) void function(GdkWindow* window, double embedderX, double embedderY, double* offscreenX, double* offscreenY) fromEmbedder;
4040 	/** */
4041 	extern(C) cairo_surface_t* function(GdkWindow* window, int width, int height) createSurface;
4042 	/** */
4043 	extern(C) void function() GdkReserved1;
4044 	/** */
4045 	extern(C) void function() GdkReserved2;
4046 	/** */
4047 	extern(C) void function() GdkReserved3;
4048 	/** */
4049 	extern(C) void function() GdkReserved4;
4050 	/** */
4051 	extern(C) void function() GdkReserved5;
4052 	/** */
4053 	extern(C) void function() GdkReserved6;
4054 	/** */
4055 	extern(C) void function() GdkReserved7;
4056 	/** */
4057 	extern(C) void function() GdkReserved8;
4058 }
4059 
4060 struct GdkWindowRedirect;
4061 
4062 struct GdkX11Window;
4063 
4064 struct GdkX11WindowClass;
4065 
4066 /**
4067  * Specifies the type of function passed to gdk_event_handler_set() to
4068  * handle all GDK events.
4069  *
4070  * Params:
4071  *     event = the #GdkEvent to process.
4072  *     data = user data set when the event handler was installed with
4073  *         gdk_event_handler_set().
4074  */
4075 public alias extern(C) void function(GdkEvent* event, void* data) GdkEventFunc;
4076 
4077 /**
4078  * Specifies the type of function used to filter native events before they are
4079  * converted to GDK events.
4080  *
4081  * When a filter is called, @event is unpopulated, except for
4082  * `event->window`. The filter may translate the native
4083  * event to a GDK event and store the result in @event, or handle it without
4084  * translation. If the filter translates the event and processing should
4085  * continue, it should return %GDK_FILTER_TRANSLATE.
4086  *
4087  * Params:
4088  *     xevent = the native event to filter.
4089  *     event = the GDK event to which the X event will be translated.
4090  *     data = user data set when the filter was installed.
4091  *
4092  * Returns: a #GdkFilterReturn value.
4093  */
4094 public alias extern(C) GdkFilterReturn function(GdkXEvent* xevent, GdkEvent* event, void* data) GdkFilterFunc;
4095 
4096 /**
4097  * Type of the callback used to set up @window so it can be
4098  * grabbed. A typical action would be ensuring the window is
4099  * visible, although there's room for other initialization
4100  * actions.
4101  *
4102  * Params:
4103  *     seat = the #GdkSeat being grabbed
4104  *     window = the #GdkWindow being grabbed
4105  *     userData = user data passed in gdk_seat_grab()
4106  *
4107  * Since: 3.20
4108  */
4109 public alias extern(C) void function(GdkSeat* seat, GdkWindow* window, void* userData) GdkSeatGrabPrepareFunc;
4110 
4111 /**
4112  * A function of this type is passed to gdk_window_invalidate_maybe_recurse().
4113  * It gets called for each child of the window to determine whether to
4114  * recursively invalidate it or now.
4115  *
4116  * Params:
4117  *     window = a #GdkWindow
4118  *     userData = user data
4119  *
4120  * Returns: %TRUE to invalidate @window recursively
4121  */
4122 public alias extern(C) int function(GdkWindow* window, void* userData) GdkWindowChildFunc;
4123 
4124 /**
4125  * Whenever some area of the window is invalidated (directly in the
4126  * window or in a child window) this gets called with @region in
4127  * the coordinate space of @window. You can use @region to just
4128  * keep track of the dirty region, or you can actually change
4129  * @region in case you are doing display tricks like showing
4130  * a child in multiple places.
4131  *
4132  * Params:
4133  *     window = a #GdkWindow
4134  *     region = a #cairo_region_t
4135  *
4136  * Since: 3.10
4137  */
4138 public alias extern(C) void function(GdkWindow* window, cairo_region_t* region) GdkWindowInvalidateHandlerFunc;
4139 
4140 /**
4141  * The middle button.
4142  */
4143 enum BUTTON_MIDDLE = 2;
4144 alias GDK_BUTTON_MIDDLE = BUTTON_MIDDLE;
4145 
4146 /**
4147  * The primary button. This is typically the left mouse button, or the
4148  * right button in a left-handed setup.
4149  */
4150 enum BUTTON_PRIMARY = 1;
4151 alias GDK_BUTTON_PRIMARY = BUTTON_PRIMARY;
4152 
4153 /**
4154  * The secondary button. This is typically the right mouse button, or the
4155  * left button in a left-handed setup.
4156  */
4157 enum BUTTON_SECONDARY = 3;
4158 alias GDK_BUTTON_SECONDARY = BUTTON_SECONDARY;
4159 
4160 /**
4161  * Represents the current time, and can be used anywhere a time is expected.
4162  */
4163 enum CURRENT_TIME = 0;
4164 alias GDK_CURRENT_TIME = CURRENT_TIME;
4165 
4166 /**
4167  * Use this macro as the return value for continuing the propagation of
4168  * an event handler.
4169  */
4170 enum EVENT_PROPAGATE = false;
4171 alias GDK_EVENT_PROPAGATE = EVENT_PROPAGATE;
4172 
4173 /**
4174  * Use this macro as the return value for stopping the propagation of
4175  * an event handler.
4176  */
4177 enum EVENT_STOP = true;
4178 alias GDK_EVENT_STOP = EVENT_STOP;
4179 
4180 enum MAX_TIMECOORD_AXES = 128;
4181 alias GDK_MAX_TIMECOORD_AXES = MAX_TIMECOORD_AXES;
4182 
4183 /**
4184  * A special value, indicating that the background
4185  * for a window should be inherited from the parent window.
4186  */
4187 enum PARENT_RELATIVE = 1;
4188 alias GDK_PARENT_RELATIVE = PARENT_RELATIVE;
4189 
4190 /**
4191  * This is the priority that the idle handler processing window updates
4192  * is given in the
4193  * [GLib Main Loop][glib-The-Main-Event-Loop].
4194  */
4195 enum PRIORITY_REDRAW = 20;
4196 alias GDK_PRIORITY_REDRAW = PRIORITY_REDRAW;