1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19  
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 module gtkc.gdktypes;
25 
26 
27 public import gtkc.glibtypes;
28 public import gtkc.gobjecttypes;
29 public import gtkc.giotypes;
30 public import gtkc.pangotypes;
31 public import gtkc.gdkpixbuftypes;
32 
33 const int GDK_MAX_TIMECOORD_AXES = 128;
34 
35 
36 /**
37  * typedef guint32			 GdkWChar;
38  * Specifies a wide character type, used to represent character codes.
39  * This is needed since some native languages have character sets which have
40  * more than 256 characters (Japanese and Chinese, for example).
41  * Wide character values between 0 and 127 are always identical in meaning to
42  * the ASCII character codes. The wide character value 0 is often used to
43  * terminate strings of wide characters in a similar way to normal strings
44  * using the char type.
45  * An alternative to wide characters is multi-byte characters, which extend
46  * normal char strings to cope with larger character sets. As the name suggests,
47  * multi-byte characters use a different number of bytes to store different
48  * character codes. For example codes 0-127 (i.e. the ASCII codes) often
49  * use just one byte of memory, while other codes may use 2, 3 or even 4 bytes.
50  * Multi-byte characters have the advantage that they can often be used in an
51  * application with little change, since strings are still represented as arrays
52  * of char values. However multi-byte strings are much easier to manipulate since
53  * the character are all of the same size.
54  * Applications typically use wide characters to represent character codes
55  * internally, and multi-byte strings when saving the characters to a file.
56  * The gdk_wcstombs() and gdk_mbstowcs() functions can be used to convert from
57  * one representation to the other.
58  * See the 'Extended Characters' section of the GNU C Library Reference Manual
59  * for more detailed information on wide and multi-byte characters.
60  */
61 public alias uint GdkWChar;
62 
63 /**
64  * typedef void GdkXEvent;	 /+* Can be cast to window system specific
65  * Used to represent native events (XEvents for the X11
66  * backend, MSGs for Win32).
67  */
68 public alias void GdkXEvent;
69 
70 /**
71  * typedef gpointer GdkNativeWindow;
72  * Used to represent native windows (Windows for the X11 backend,
73  * HWNDs for Win32).
74  */
75 public alias void* GdkNativeWindow;
76 
77 /**
78  * typedef GdkAtom GdkSelection;
79  * Warning
80  * GdkSelection is deprecated and should not be used in newly-written code.
81  * The GdkSelection enumeration contains predefined
82  * atom values for several common selections.
83  */
84 public alias GdkAtom GdkSelection;
85 
86 /**
87  * typedef GdkAtom GdkSelectionType;
88  * Warning
89  * GdkSelectionType is deprecated and should not be used in newly-written code.
90  * The GdkSelectionType enumeration contains predefined
91  * atom values used to represent the types of data transferred
92  * in response to a request for a target. See the
93  * ICCCM for details about what data should be transferred
94  * for each of these types. Other atoms can be used,
95  * and the recommended practice for GTK+ is to to use mime
96  * types for this purpose. However, supporting these types
97  * may be useful for compatibility with older programs.
98  */
99 public alias GdkAtom GdkSelectionType;
100 
101 /**
102  * typedef GdkAtom GdkTarget;
103  * Warning
104  * GdkTarget is deprecated and should not be used in newly-written code.
105  * The GdkTarget enumeration contains predefined atom values which are
106  * used to describe possible targets for a selection. Other atoms can be
107  * used, and the recommended practice for GTK+ is to to use mime types
108  * for this purpose. However, supporting these types may be useful for
109  * compatibility with older programs.
110  */
111 public alias GdkAtom GdkTarget;
112 /**
113  * Returned by gdk_pointer_grab() and gdk_keyboard_grab() to indicate
114  * success or the reason for the failure of the grab attempt.
115  * GDK_GRAB_SUCCESS
116  * the resource was successfully grabbed.
117  * GDK_GRAB_ALREADY_GRABBED
118  * the resource is actively grabbed by another client.
119  * GDK_GRAB_INVALID_TIME
120  * the resource was grabbed more recently than the
121  *  specified time.
122  * GDK_GRAB_NOT_VIEWABLE
123  * the grab window or the confine_to window are not
124  *  viewable.
125  * GDK_GRAB_FROZEN
126  * the resource is frozen by an active grab of another client.
127  */
128 public enum GdkGrabStatus
129 {
130 	SUCCESS = 0,
131 	ALREADY_GRABBED = 1,
132 	INVALID_TIME = 2,
133 	NOT_VIEWABLE = 3,
134 	FROZEN = 4
135 }
136 alias GdkGrabStatus GrabStatus;
137 
138 /**
139  * Warning
140  * GdkFillRule is deprecated and should not be used in newly-written code.
141  * The method for determining which pixels are included in a region, when
142  * creating a GdkRegion from a polygon.
143  * The fill rule is only relevant for polygons which overlap themselves.
144  * GDK_EVEN_ODD_RULE
145  * areas which are overlapped an odd number of times are
146  * included in the region, while areas overlapped an even number of times are not.
147  * GDK_WINDING_RULE
148  * overlapping areas are always included.
149  */
150 public enum GdkFillRule
151 {
152 	EVEN_ODD_RULE,
153 	WINDING_RULE
154 }
155 alias GdkFillRule FillRule;
156 
157 /**
158  * Specifies the possible values returned by gdk_region_rect_in().
159  * GDK_OVERLAP_RECTANGLE_IN
160  * if the rectangle is inside the GdkRegion.
161  * GDK_OVERLAP_RECTANGLE_OUT
162  * if the rectangle is outside the GdkRegion.
163  * GDK_OVERLAP_RECTANGLE_PART
164  * if the rectangle is partly inside the GdkRegion.
165  */
166 public enum GdkOverlapType
167 {
168 	RECTANGLE_IN,
169 	RECTANGLE_OUT,
170 	RECTANGLE_PART
171 }
172 alias GdkOverlapType OverlapType;
173 
174 /**
175  * A set of bit flags used to indicate which fields
176  * GdkGCValues structure are set.
177  * GDK_GC_FOREGROUND
178  * the foreground is set.
179  * GDK_GC_BACKGROUND
180  * the background is set.
181  * GDK_GC_FONT
182  * the font is set.
183  * GDK_GC_FUNCTION
184  * the function is set.
185  * GDK_GC_FILL
186  * the fill is set.
187  * GDK_GC_TILE
188  * the tile is set.
189  * GDK_GC_STIPPLE
190  * the stipple is set.
191  * GDK_GC_CLIP_MASK
192  * the clip_mask is set.
193  * GDK_GC_SUBWINDOW
194  * the subwindow_mode is set.
195  * GDK_GC_TS_X_ORIGIN
196  * the ts_x_origin is set.
197  * GDK_GC_TS_Y_ORIGIN
198  * the ts_y_origin is set.
199  * GDK_GC_CLIP_X_ORIGIN
200  * the clip_x_origin is set.
201  * GDK_GC_CLIP_Y_ORIGIN
202  * the clip_y_origin is set.
203  * GDK_GC_EXPOSURES
204  * the graphics_exposures is set.
205  * GDK_GC_LINE_WIDTH
206  * the line_width is set.
207  * GDK_GC_LINE_STYLE
208  * the line_style is set.
209  * GDK_GC_CAP_STYLE
210  * the cap_style is set.
211  * GDK_GC_JOIN_STYLE
212  * the join_style is set.
213  */
214 public enum GdkGCValuesMask
215 {
216 	FOREGROUND = 1 << 0,
217 	BACKGROUND = 1 << 1,
218 	FONT = 1 << 2,
219 	FUNCTION = 1 << 3,
220 	FILL = 1 << 4,
221 	TILE = 1 << 5,
222 	STIPPLE = 1 << 6,
223 	CLIP_MASK = 1 << 7,
224 	SUBWINDOW = 1 << 8,
225 	TS_X_ORIGIN = 1 << 9,
226 	TS_Y_ORIGIN = 1 << 10,
227 	CLIP_X_ORIGIN = 1 << 11,
228 	CLIP_Y_ORIGIN = 1 << 12,
229 	EXPOSURES = 1 << 13,
230 	LINE_WIDTH = 1 << 14,
231 	LINE_STYLE = 1 << 15,
232 	CAP_STYLE = 1 << 16,
233 	JOIN_STYLE = 1 << 17
234 }
235 alias GdkGCValuesMask GCValuesMask;
236 
237 /**
238  * Determines how the bit values for the source pixels are combined with
239  * the bit values for destination pixels to produce the final result. The
240  * sixteen values here correspond to the 16 different possible 2x2 truth
241  * tables. Only a couple of these values are usually useful; for colored
242  * images, only GDK_COPY, GDK_XOR and GDK_INVERT are generally
243  * useful. For bitmaps, GDK_AND and GDK_OR are also useful.
244  * GDK_COPY
245  * dst = src
246  * GDK_INVERT
247  * dst = NOT dst
248  * GDK_XOR
249  * dst = src XOR dst
250  * GDK_CLEAR
251  * dst = 0
252  * GDK_AND
253  * dst = dst AND src
254  * GDK_AND_REVERSE
255  * dst = src AND (NOT dst)
256  * GDK_AND_INVERT
257  * dst = (NOT src) AND dst
258  * GDK_NOOP
259  * dst = dst
260  * GDK_OR
261  * dst = src OR dst
262  * GDK_EQUIV
263  * dst = (NOT src) XOR dst
264  * GDK_OR_REVERSE
265  * dst = src OR (NOT dst)
266  * GDK_COPY_INVERT
267  * dst = NOT src
268  * GDK_OR_INVERT
269  * dst = (NOT src) OR dst
270  * GDK_NAND
271  * dst = (NOT src) OR (NOT dst)
272  * GDK_NOR
273  * dst = (NOT src) AND (NOT dst)
274  * GDK_SET
275  * dst = 1
276  */
277 public enum GdkFunction
278 {
279 	COPY,
280 	INVERT,
281 	XOR,
282 	CLEAR,
283 	AND,
284 	AND_REVERSE,
285 	AND_INVERT,
286 	NOOP,
287 	OR,
288 	EQUIV,
289 	OR_REVERSE,
290 	COPY_INVERT,
291 	OR_INVERT,
292 	NAND,
293 	NOR,
294 	SET
295 }
296 alias GdkFunction Funct;
297 
298 /**
299  * Determines how primitives are drawn.
300  * GDK_SOLID
301  * draw with the foreground color.
302  * GDK_TILED
303  * draw with a tiled pixmap.
304  * GDK_STIPPLED
305  * draw using the stipple bitmap. Pixels corresponding
306  *  to bits in the stipple bitmap that are set will be drawn in the
307  *  foreground color; pixels corresponding to bits that are
308  *  not set will be left untouched.
309  * GDK_OPAQUE_STIPPLED
310  * draw using the stipple bitmap. Pixels corresponding
311  *  to bits in the stipple bitmap that are set will be drawn in the
312  *  foreground color; pixels corresponding to bits that are
313  *  not set will be drawn with the background color.
314  */
315 public enum GdkFill
316 {
317 	SOLID,
318 	TILED,
319 	STIPPLED,
320 	OPAQUE_STIPPLED
321 }
322 alias GdkFill Fill;
323 
324 /**
325  * Determines how drawing onto a window will affect child
326  * windows of that window.
327  * GDK_CLIP_BY_CHILDREN
328  * only draw onto the window itself.
329  * GDK_INCLUDE_INFERIORS
330  * draw onto the window and child windows.
331  */
332 public enum GdkSubwindowMode
333 {
334 	CLIP_BY_CHILDREN = 0,
335 	INCLUDE_INFERIORS = 1
336 }
337 alias GdkSubwindowMode SubwindowMode;
338 
339 /**
340  * Determines how lines are drawn.
341  * GDK_LINE_SOLID
342  * lines are drawn solid.
343  * GDK_LINE_ON_OFF_DASH
344  * even segments are drawn; odd segments are not drawn.
345  * GDK_LINE_DOUBLE_DASH
346  * even segments are normally. Odd segments are drawn
347  *  in the background color if the fill style is GDK_SOLID, or in the background
348  *  color masked by the stipple if the fill style is GDK_STIPPLED.
349  */
350 public enum GdkLineStyle
351 {
352 	SOLID,
353 	ON_OFF_DASH,
354 	DOUBLE_DASH
355 }
356 alias GdkLineStyle LineStyle;
357 
358 /**
359  * Determines how the end of lines are drawn.
360  * GDK_CAP_NOT_LAST
361  * the same as GDK_CAP_BUTT for lines of non-zero width.
362  *  for zero width lines, the final point on the line will not be drawn.
363  * GDK_CAP_BUTT
364  * the ends of the lines are drawn squared off and extending
365  *  to the coordinates of the end point.
366  * GDK_CAP_ROUND
367  * the ends of the lines are drawn as semicircles with the
368  *  diameter equal to the line width and centered at the end point.
369  * GDK_CAP_PROJECTING
370  * the ends of the lines are drawn squared off and extending
371  *  half the width of the line beyond the end point.
372  */
373 public enum GdkCapStyle
374 {
375 	NOT_LAST,
376 	BUTT,
377 	ROUND,
378 	PROJECTING
379 }
380 alias GdkCapStyle CapStyle;
381 
382 /**
383  * Determines how the joins between segments of a polygon are drawn.
384  * GDK_JOIN_MITER
385  * the sides of each line are extended to meet at an angle.
386  * GDK_JOIN_ROUND
387  * the sides of the two lines are joined by a circular arc.
388  * GDK_JOIN_BEVEL
389  * the sides of the two lines are joined by a straight line which
390  *  makes an equal angle with each line.
391  */
392 public enum GdkJoinStyle
393 {
394 	MITER,
395 	ROUND,
396 	BEVEL
397 }
398 alias GdkJoinStyle JoinStyle;
399 
400 /**
401  * Selects whether or not GdkRGB applies dithering
402  * to the image on display.
403  * Since GdkRGB currently only handles images with 8 bits per component,
404  * dithering on 24 bit per pixel displays is a moot point.
405  * GDK_RGB_DITHER_NONE
406  * Never use dithering.
407  * GDK_RGB_DITHER_NORMAL
408  * Use dithering in 8 bits per pixel (and below)
409  * only.
410  * GDK_RGB_DITHER_MAX
411  * Use dithering in 16 bits per pixel and below.
412  */
413 public enum GdkRgbDither
414 {
415 	NONE,
416 	NORMAL,
417 	MAX
418 }
419 alias GdkRgbDither RgbDither;
420 
421 /**
422  * Specifies the type of a GdkImage.
423  * GDK_IMAGE_NORMAL
424  * The original X image type, which is quite slow since the
425  * image has to be transferred from the client to the server to display it.
426  * GDK_IMAGE_SHARED
427  * A faster image type, which uses shared memory to transfer
428  * the image data between client and server. However this will only be available
429  * if client and server are on the same machine and the shared memory extension
430  * is supported by the server.
431  * GDK_IMAGE_FASTEST
432  * Specifies that GDK_IMAGE_SHARED should be tried first,
433  * and if that fails then GDK_IMAGE_NORMAL will be used.
434  */
435 public enum GdkImageType
436 {
437 	NORMAL,
438 	SHARED,
439 	FASTEST
440 }
441 alias GdkImageType ImageType;
442 
443 /**
444  * An error code in the GDK_PIXBUF_ERROR domain. Many gdk-pixbuf;
445  * operations can cause errors in this domain, or in the G_FILE_ERROR
446  * domain.
447  * GDK_PIXBUF_ERROR_CORRUPT_IMAGE
448  * An image file was broken somehow.
449  * GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY
450  * Not enough memory.
451  * GDK_PIXBUF_ERROR_BAD_OPTION
452  * A bad option was passed to a pixbuf save module.
453  * GDK_PIXBUF_ERROR_UNKNOWN_TYPE
454  * Unknown image type.
455  * GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION
456  * Don't know how to perform the
457  *  given operation on the type of image at hand.
458  * GDK_PIXBUF_ERROR_FAILED
459  * Generic failure code, something went wrong.
460  */
461 public enum GdkPixbufError
462 {
463 	/+* image data hosed +/
464 	CORRUPT_IMAGE,
465 	/+* no mem to load image +/
466 	INSUFFICIENT_MEMORY,
467 	/+* bad option passed to save routine +/
468 	BAD_OPTION,
469 	/+* unsupported image type (sort of an ENOSYS) +/
470 	UNKNOWN_TYPE,
471 	/+* unsupported operation (load, save) for image type +/
472 	UNSUPPORTED_OPERATION,
473 	FAILED
474 }
475 alias GdkPixbufError PixbufError;
476 
477 /**
478  * This enumeration defines the color spaces that are supported by
479  * the gdk-pixbuf; library. Currently only RGB is supported.
480  * GDK_COLORSPACE_RGB
481  * Indicates a red/green/blue additive color space.
482  */
483 public enum GdkColorspace
484 {
485 	RGB
486 }
487 alias GdkColorspace Colorspace;
488 
489 /**
490  * These values can be passed to
491  * gdk_pixbuf_render_to_drawable_alpha() to control how the alpha
492  * channel of an image should be handled. This function can create a
493  * bilevel clipping mask (black and white) and use it while painting
494  * the image. In the future, when the X Window System gets an alpha
495  * channel extension, it will be possible to do full alpha
496  * compositing onto arbitrary drawables. For now both cases fall
497  * back to a bilevel clipping mask.
498  * GDK_PIXBUF_ALPHA_BILEVEL
499  * A bilevel clipping mask (black and white)
500  *  will be created and used to draw the image. Pixels below 0.5 opacity
501  *  will be considered fully transparent, and all others will be
502  *  considered fully opaque.
503  * GDK_PIXBUF_ALPHA_FULL
504  * For now falls back to GDK_PIXBUF_ALPHA_BILEVEL.
505  *  In the future it will do full alpha compositing.
506  */
507 public enum GdkPixbufAlphaMode
508 {
509 	BILEVEL,
510 	FULL
511 }
512 alias GdkPixbufAlphaMode PixbufAlphaMode;
513 
514 /**
515  * This enumeration describes the different interpolation modes that
516  *  can be used with the scaling functions. GDK_INTERP_NEAREST is
517  *  the fastest scaling method, but has horrible quality when
518  *  scaling down. GDK_INTERP_BILINEAR is the best choice if you
519  *  aren't sure what to choose, it has a good speed/quality balance.
520  * Note
521  * 	Cubic filtering is missing from the list; hyperbolic
522  * 	interpolation is just as fast and results in higher quality.
523  * GDK_INTERP_NEAREST
524  * Nearest neighbor sampling; this is the fastest
525  *  and lowest quality mode. Quality is normally unacceptable when scaling
526  *  down, but may be OK when scaling up.
527  * GDK_INTERP_TILES
528  * This is an accurate simulation of the PostScript
529  *  image operator without any interpolation enabled. Each pixel is
530  *  rendered as a tiny parallelogram of solid color, the edges of which
531  *  are implemented with antialiasing. It resembles nearest neighbor for
532  *  enlargement, and bilinear for reduction.
533  * GDK_INTERP_BILINEAR
534  * Best quality/speed balance; use this mode by
535  *  default. Bilinear interpolation. For enlargement, it is
536  *  equivalent to point-sampling the ideal bilinear-interpolated image.
537  *  For reduction, it is equivalent to laying down small tiles and
538  *  integrating over the coverage area.
539  * GDK_INTERP_HYPER
540  * This is the slowest and highest quality
541  *  reconstruction function. It is derived from the hyperbolic filters in
542  *  Wolberg's "Digital Image Warping", and is formally defined as the
543  *  hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
544  *  image (the filter is designed to be idempotent for 1:1 pixel mapping).
545  */
546 public enum GdkInterpType
547 {
548 	NEAREST,
549 	TILES,
550 	BILINEAR,
551 	HYPER
552 }
553 alias GdkInterpType InterpType;
554 
555 /**
556  * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
557  * To make them easier to use, their numerical values are the actual degrees.
558  * GDK_PIXBUF_ROTATE_NONE
559  * No rotation.
560  * GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE
561  * Rotate by 90 degrees.
562  * GDK_PIXBUF_ROTATE_UPSIDEDOWN
563  * Rotate by 180 degrees.
564  * GDK_PIXBUF_ROTATE_CLOCKWISE
565  * Rotate by 270 degrees.
566  */
567 public enum GdkPixbufRotation
568 {
569 	ROTATE_NONE = 0,
570 	ROTATE_COUNTERCLOCKWISE = 90,
571 	ROTATE_UPSIDEDOWN = 180,
572 	ROTATE_CLOCKWISE = 270
573 }
574 alias GdkPixbufRotation PixbufRotation;
575 
576 /**
577  * A set of values that describe the manner in which the
578  * pixel values for a visual are converted into RGB
579  * values for display.
580  * GDK_VISUAL_STATIC_GRAY
581  * Each pixel value indexes a grayscale value directly.
582  * GDK_VISUAL_GRAYSCALE
583  * Each pixel is an index into a color map that maps pixel
584  *  values into grayscale values. The color map can be changed by an application.
585  * GDK_VISUAL_STATIC_COLOR
586  * Each pixel value is an index into a predefined,
587  *  unmodifiable color map that maps pixel values into RGB values.
588  * GDK_VISUAL_PSEUDO_COLOR
589  * Each pixel is an index into a color map that maps
590  *  pixel values into rgb values. The color map can be changed by an application.
591  * GDK_VISUAL_TRUE_COLOR
592  * Each pixel value directly contains red, green,
593  *  and blue components. The red_mask,
594  *  green_mask, and
595  *  blue_mask fields of the GdkVisual
596  *  structure describe how the components are assembled into a pixel value.
597  * GDK_VISUAL_DIRECT_COLOR
598  * Each pixel value contains red, green, and blue
599  *  components as for GDK_VISUAL_TRUE_COLOR, but the components are mapped via a
600  *  color table into the final output table instead of being converted directly.
601  */
602 public enum GdkVisualType
603 {
604 	STATIC_GRAY,
605 	GRAYSCALE,
606 	STATIC_COLOR,
607 	PSEUDO_COLOR,
608 	TRUE_COLOR,
609 	DIRECT_COLOR
610 }
611 alias GdkVisualType VisualType;
612 
613 /**
614  * A set of values describing the possible byte-orders
615  * for storing pixel values in memory.
616  * GDK_LSB_FIRST
617  * The values are stored with the least-significant byte
618  *  first. For instance, the 32-bit value 0xffeecc would be stored
619  *  in memory as 0xcc, 0xee, 0xff, 0x00.
620  * GDK_MSB_FIRST
621  * The values are stored with the most-significant byte
622  * first. For instance, the 32-bit value 0xffeecc would be stored
623  * in memory as 0x00, 0xcc, 0xee, 0xff.
624  */
625 public enum GdkByteOrder
626 {
627 	LSB_FIRST,
628 	MSB_FIRST
629 }
630 alias GdkByteOrder ByteOrder;
631 
632 /**
633  * Warning
634  * GdkFontType is deprecated and should not be used in newly-written code.
635  * Indicates the type of a font. The possible values
636  * are currently:
637  * GDK_FONT_FONT
638  * the font is a single font.
639  * GDK_FONT_FONTSET
640  * the font is a fontset.
641  */
642 public enum GdkFontType
643 {
644 	FONT,
645 	FONTSET
646 }
647 alias GdkFontType FontType;
648 
649 /**
650  * The standard cursors available.
651  * GDK_X_CURSOR
652  * GDK_ARROW
653  * GDK_BASED_ARROW_DOWN
654  * GDK_BASED_ARROW_UP
655  * GDK_BOAT
656  * GDK_BOGOSITY
657  * GDK_BOTTOM_LEFT_CORNER
658  * GDK_BOTTOM_RIGHT_CORNER
659  * GDK_BOTTOM_SIDE
660  * GDK_BOTTOM_TEE
661  * GDK_BOX_SPIRAL
662  * GDK_CENTER_PTR
663  * GDK_CIRCLE
664  * GDK_CLOCK
665  * GDK_COFFEE_MUG
666  * GDK_CROSS
667  * GDK_CROSS_REVERSE
668  * GDK_CROSSHAIR
669  * GDK_DIAMOND_CROSS
670  * GDK_DOT
671  * GDK_DOTBOX
672  * GDK_DOUBLE_ARROW
673  * GDK_DRAFT_LARGE
674  * GDK_DRAFT_SMALL
675  * GDK_DRAPED_BOX
676  * GDK_EXCHANGE
677  * GDK_FLEUR
678  * GDK_GOBBLER
679  * GDK_GUMBY
680  * GDK_HAND1
681  * GDK_HAND2
682  * GDK_HEART
683  * GDK_ICON
684  * GDK_IRON_CROSS
685  * GDK_LEFT_PTR
686  * GDK_LEFT_SIDE
687  * GDK_LEFT_TEE
688  * GDK_LEFTBUTTON
689  * GDK_LL_ANGLE
690  * GDK_LR_ANGLE
691  * GDK_MAN
692  * GDK_MIDDLEBUTTON
693  * GDK_MOUSE
694  * GDK_PENCIL
695  * GDK_PIRATE
696  * GDK_PLUS
697  * GDK_QUESTION_ARROW
698  * GDK_RIGHT_PTR
699  * GDK_RIGHT_SIDE
700  * GDK_RIGHT_TEE
701  * GDK_RIGHTBUTTON
702  * GDK_RTL_LOGO
703  * GDK_SAILBOAT
704  * GDK_SB_DOWN_ARROW
705  * GDK_SB_H_DOUBLE_ARROW
706  * GDK_SB_LEFT_ARROW
707  * GDK_SB_RIGHT_ARROW
708  * GDK_SB_UP_ARROW
709  * GDK_SB_V_DOUBLE_ARROW
710  * GDK_SHUTTLE
711  * GDK_SIZING
712  * GDK_SPIDER
713  * GDK_SPRAYCAN
714  * GDK_STAR
715  * GDK_TARGET
716  * GDK_TCROSS
717  * GDK_TOP_LEFT_ARROW
718  * GDK_TOP_LEFT_CORNER
719  * GDK_TOP_RIGHT_CORNER
720  * GDK_TOP_SIDE
721  * GDK_TOP_TEE
722  * GDK_TREK
723  * GDK_UL_ANGLE
724  * GDK_UMBRELLA
725  * GDK_UR_ANGLE
726  * GDK_WATCH
727  * GDK_XTERM
728  * GDK_LAST_CURSOR
729  * last cursor type
730  * GDK_BLANK_CURSOR
731  * Blank cursor. Since 2.16
732  * GDK_CURSOR_IS_PIXMAP
733  * type of cursors constructed with
734  *  gdk_cursor_new_from_pixmap() or gdk_cursor_new_from_pixbuf()
735  */
736 public enum GdkCursorType
737 {
738 	X_CURSOR = 0,
739 	ARROW = 2,
740 	BASED_ARROW_DOWN = 4,
741 	BASED_ARROW_UP = 6,
742 	BOAT = 8,
743 	BOGOSITY = 10,
744 	BOTTOM_LEFT_CORNER = 12,
745 	BOTTOM_RIGHT_CORNER = 14,
746 	BOTTOM_SIDE = 16,
747 	BOTTOM_TEE = 18,
748 	BOX_SPIRAL = 20,
749 	CENTER_PTR = 22,
750 	CIRCLE = 24,
751 	CLOCK = 26,
752 	COFFEE_MUG = 28,
753 	CROSS = 30,
754 	CROSS_REVERSE = 32,
755 	CROSSHAIR = 34,
756 	DIAMOND_CROSS = 36,
757 	DOT = 38,
758 	DOTBOX = 40,
759 	DOUBLE_ARROW = 42,
760 	DRAFT_LARGE = 44,
761 	DRAFT_SMALL = 46,
762 	DRAPED_BOX = 48,
763 	EXCHANGE = 50,
764 	FLEUR = 52,
765 	GOBBLER = 54,
766 	GUMBY = 56,
767 	HAND1 = 58,
768 	HAND2 = 60,
769 	HEART = 62,
770 	ICON = 64,
771 	IRON_CROSS = 66,
772 	LEFT_PTR = 68,
773 	LEFT_SIDE = 70,
774 	LEFT_TEE = 72,
775 	LEFTBUTTON = 74,
776 	LL_ANGLE = 76,
777 	LR_ANGLE = 78,
778 	MAN = 80,
779 	MIDDLEBUTTON = 82,
780 	MOUSE = 84,
781 	PENCIL = 86,
782 	PIRATE = 88,
783 	PLUS = 90,
784 	QUESTION_ARROW = 92,
785 	RIGHT_PTR = 94,
786 	RIGHT_SIDE = 96,
787 	RIGHT_TEE = 98,
788 	RIGHTBUTTON = 100,
789 	RTL_LOGO = 102,
790 	SAILBOAT = 104,
791 	SB_DOWN_ARROW = 106,
792 	SB_H_DOUBLE_ARROW = 108,
793 	SB_LEFT_ARROW = 110,
794 	SB_RIGHT_ARROW = 112,
795 	SB_UP_ARROW = 114,
796 	SB_V_DOUBLE_ARROW = 116,
797 	SHUTTLE = 118,
798 	SIZING = 120,
799 	SPIDER = 122,
800 	SPRAYCAN = 124,
801 	STAR = 126,
802 	TARGET = 128,
803 	TCROSS = 130,
804 	TOP_LEFT_ARROW = 132,
805 	TOP_LEFT_CORNER = 134,
806 	TOP_RIGHT_CORNER = 136,
807 	TOP_SIDE = 138,
808 	TOP_TEE = 140,
809 	TREK = 142,
810 	UL_ANGLE = 144,
811 	UMBRELLA = 146,
812 	UR_ANGLE = 148,
813 	WATCH = 150,
814 	XTERM = 152,
815 	LAST_CURSOR,
816 	BLANK_CURSOR = -2,
817 	CURSOR_IS_PIXMAP = -1
818 }
819 alias GdkCursorType CursorType;
820 
821 /**
822  * Describes the kind of window.
823  * GDK_WINDOW_ROOT
824  * root window; this window has no parent, covers the entire screen, and is created by the window system
825  * GDK_WINDOW_TOPLEVEL
826  * toplevel window (used to implement GtkWindow)
827  * GDK_WINDOW_CHILD
828  * child window (used to implement e.g. GtkEntry)
829  * GDK_WINDOW_DIALOG
830  * useless/deprecated compatibility type
831  * GDK_WINDOW_TEMP
832  * override redirect temporary window (used to implement GtkMenu)
833  * GDK_WINDOW_FOREIGN
834  * foreign window (see gdk_window_foreign_new())
835  * GDK_WINDOW_OFFSCREEN
836  * offscreen window (see the section called “Offscreen Windows”). Since 2.18
837  */
838 public enum GdkWindowType
839 {
840 	ROOT,
841 	TOPLEVEL,
842 	CHILD,
843 	DIALOG,
844 	TEMP,
845 	FOREIGN,
846 	OFFSCREEN
847 }
848 alias GdkWindowType WindowType;
849 
850 /**
851  * GDK_INPUT_OUTPUT windows are the standard kind of window you might expect.
852  * GDK_INPUT_ONLY windows are invisible; they are used to trap events, but
853  * you can't draw on them.
854  * GDK_INPUT_OUTPUT
855  * window for graphics and events
856  * GDK_INPUT_ONLY
857  * window for events only
858  */
859 public enum GdkWindowClass
860 {
861 	INPUT_OUTPUT,
862 	INPUT_ONLY
863 }
864 alias GdkWindowClass WindowClass;
865 
866 /**
867  * Used to indicate which fields of a GdkGeometry struct should be paid attention
868  * to. Also, the presence/absence of GDK_HINT_POS, GDK_HINT_USER_POS, and
869  * GDK_HINT_USER_SIZE is significant, though they don't directly refer to
870  * GdkGeometry fields. GDK_HINT_USER_POS will be set automatically by GtkWindow
871  * if you call gtk_window_move(). GDK_HINT_USER_POS and GDK_HINT_USER_SIZE
872  * should be set if the user specified a size/position using a --geometry
873  * command-line argument; gtk_window_parse_geometry() automatically sets these
874  * flags.
875  * GDK_HINT_POS
876  * indicates that the program has positioned the window
877  * GDK_HINT_MIN_SIZE
878  * min size fields are set
879  * GDK_HINT_MAX_SIZE
880  * max size fields are set
881  * GDK_HINT_BASE_SIZE
882  * base size fields are set
883  * GDK_HINT_ASPECT
884  * aspect ratio fields are set
885  * GDK_HINT_RESIZE_INC
886  * resize increment fields are set
887  * GDK_HINT_WIN_GRAVITY
888  * window gravity field is set
889  * GDK_HINT_USER_POS
890  * indicates that the window's position was explicitly set by the user
891  * GDK_HINT_USER_SIZE
892  * indicates that the window's size was explicitly set by the user
893  */
894 public enum GdkWindowHints
895 {
896 	HINT_POS = 1 << 0,
897 	HINT_MIN_SIZE = 1 << 1,
898 	HINT_MAX_SIZE = 1 << 2,
899 	HINT_BASE_SIZE = 1 << 3,
900 	HINT_ASPECT = 1 << 4,
901 	HINT_RESIZE_INC = 1 << 5,
902 	HINT_WIN_GRAVITY = 1 << 6,
903 	HINT_USER_POS = 1 << 7,
904 	HINT_USER_SIZE = 1 << 8
905 }
906 alias GdkWindowHints WindowHints;
907 
908 /**
909  * Defines the reference point of a window and the meaning of coordinates
910  * passed to gtk_window_move(). See gtk_window_move() and the "implementation
911  * notes" section of the
912  * Extended
913  * Window Manager Hints specification for more details.
914  * GDK_GRAVITY_NORTH_WEST
915  * the reference point is at the top left corner.
916  * GDK_GRAVITY_NORTH
917  * the reference point is in the middle of the top edge.
918  * GDK_GRAVITY_NORTH_EAST
919  * the reference point is at the top right corner.
920  * GDK_GRAVITY_WEST
921  * the reference point is at the middle of the left edge.
922  * GDK_GRAVITY_CENTER
923  * the reference point is at the center of the window.
924  * GDK_GRAVITY_EAST
925  * the reference point is at the middle of the right edge.
926  * GDK_GRAVITY_SOUTH_WEST
927  * the reference point is at the lower left corner.
928  * GDK_GRAVITY_SOUTH
929  * the reference point is at the middle of the lower edge.
930  * GDK_GRAVITY_SOUTH_EAST
931  * the reference point is at the lower right corner.
932  * GDK_GRAVITY_STATIC
933  * the reference point is at the top left corner of the
934  *  window itself, ignoring window manager decorations.
935  */
936 public enum GdkGravity
937 {
938 	NORTH_WEST = 1,
939 	NORTH,
940 	NORTH_EAST,
941 	WEST,
942 	CENTER,
943 	EAST,
944 	SOUTH_WEST,
945 	SOUTH,
946 	SOUTH_EAST,
947 	STATIC
948 }
949 alias GdkGravity Gravity;
950 
951 /**
952  * Determines a window edge or corner.
953  * GDK_WINDOW_EDGE_NORTH_WEST
954  * the top left corner.
955  * GDK_WINDOW_EDGE_NORTH
956  * the top edge.
957  * GDK_WINDOW_EDGE_NORTH_EAST
958  * the top right corner.
959  * GDK_WINDOW_EDGE_WEST
960  * the left edge.
961  * GDK_WINDOW_EDGE_EAST
962  * the right edge.
963  * GDK_WINDOW_EDGE_SOUTH_WEST
964  * the lower left corner.
965  * GDK_WINDOW_EDGE_SOUTH
966  * the lower edge.
967  * GDK_WINDOW_EDGE_SOUTH_EAST
968  * the lower right corner.
969  */
970 public enum GdkWindowEdge
971 {
972 	NORTH_WEST,
973 	NORTH,
974 	NORTH_EAST,
975 	WEST,
976 	EAST,
977 	SOUTH_WEST,
978 	SOUTH,
979 	SOUTH_EAST
980 }
981 alias GdkWindowEdge WindowEdge;
982 
983 /**
984  * These are hints for the window manager that indicate what type of function
985  * the window has. The window manager can use this when determining decoration
986  * and behaviour of the window. The hint must be set before mapping the window.
987  * See the
988  * Extended
989  * Window Manager Hints specification for more details about
990  * window types.
991  * GDK_WINDOW_TYPE_HINT_NORMAL
992  * Normal toplevel window.
993  * GDK_WINDOW_TYPE_HINT_DIALOG
994  * Dialog window.
995  * GDK_WINDOW_TYPE_HINT_MENU
996  * Window used to implement a menu; GTK+ uses
997  *  this hint only for torn-off menus, see GtkTearoffMenuItem.
998  * GDK_WINDOW_TYPE_HINT_TOOLBAR
999  * Window used to implement toolbars.
1000  * GDK_WINDOW_TYPE_HINT_SPLASHSCREEN
1001  * Window used to display a splash
1002  *  screen during application startup.
1003  * GDK_WINDOW_TYPE_HINT_UTILITY
1004  * Utility windows which are not detached
1005  *  toolbars or dialogs.
1006  * GDK_WINDOW_TYPE_HINT_DOCK
1007  * Used for creating dock or panel windows.
1008  * GDK_WINDOW_TYPE_HINT_DESKTOP
1009  * Used for creating the desktop background
1010  * window.
1011  * GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU
1012  * A menu that belongs to a menubar.
1013  * GDK_WINDOW_TYPE_HINT_POPUP_MENU
1014  * A menu that does not belong to a menubar,
1015  *  e.g. a context menu.
1016  * GDK_WINDOW_TYPE_HINT_TOOLTIP
1017  * A tooltip.
1018  * GDK_WINDOW_TYPE_HINT_NOTIFICATION
1019  * A notification - typically a "bubble"
1020  *  that belongs to a status icon.
1021  * GDK_WINDOW_TYPE_HINT_COMBO
1022  * A popup from a combo box.
1023  * GDK_WINDOW_TYPE_HINT_DND
1024  * A window that is used to implement a DND cursor.
1025  */
1026 public enum GdkWindowTypeHint
1027 {
1028 	NORMAL,
1029 	DIALOG,
1030 	MENU, /+* Torn off menu +/
1031 	TOOLBAR,
1032 	SPLASHSCREEN,
1033 	UTILITY,
1034 	DOCK,
1035 	DESKTOP,
1036 	DROPDOWN_MENU, /+* A drop down menu (from a menubar) +/
1037 	POPUP_MENU, /+* A popup menu (from right-click) +/
1038 	TOOLTIP,
1039 	NOTIFICATION,
1040 	COMBO,
1041 	DND
1042 }
1043 alias GdkWindowTypeHint WindowTypeHint;
1044 
1045 /**
1046  * Used to indicate which fields in the GdkWindowAttr struct should be
1047  * honored. For example, if you filled in the "cursor" and "x" fields of
1048  * GdkWindowAttr, pass "GDK_WA_X | GDK_WA_CURSOR" to gdk_window_new(). Fields
1049  * in GdkWindowAttr not covered by a bit in this enum are required; for example,
1050  * the width/height, wclass, and window_type fields are required, they have no
1051  * corresponding flag in GdkWindowAttributesType.
1052  * GDK_WA_TITLE
1053  * Honor the title field
1054  * GDK_WA_X
1055  * Honor the X coordinate field
1056  * GDK_WA_Y
1057  * Honor the Y coordinate field
1058  * GDK_WA_CURSOR
1059  * Honor the cursor field
1060  * GDK_WA_COLORMAP
1061  * Honor the colormap field
1062  * GDK_WA_VISUAL
1063  * Honor the visual field
1064  * GDK_WA_WMCLASS
1065  * Honor the wmclass_class and wmclass_name fields
1066  * GDK_WA_NOREDIR
1067  * Honor the override_redirect field
1068  * GDK_WA_TYPE_HINT
1069  * Honor the type_hint field
1070  */
1071 public enum GdkWindowAttributesType
1072 {
1073 	WA_TITLE = 1 << 1,
1074 	WA_X = 1 << 2,
1075 	WA_Y = 1 << 3,
1076 	WA_CURSOR = 1 << 4,
1077 	WA_COLORMAP = 1 << 5,
1078 	WA_VISUAL = 1 << 6,
1079 	WA_WMCLASS = 1 << 7,
1080 	WA_NOREDIR = 1 << 8,
1081 	WA_TYPE_HINT = 1 << 9
1082 }
1083 alias GdkWindowAttributesType WindowAttributesType;
1084 
1085 /**
1086  * Specifies the result of applying a GdkFilterFunc to a native event.
1087  * GDK_FILTER_CONTINUE
1088  * event not handled, continue processing.
1089  * GDK_FILTER_TRANSLATE
1090  * native event translated into a GDK event and stored
1091  *  in the event structure that was passed in.
1092  * GDK_FILTER_REMOVE
1093  * event handled, terminate processing.
1094  */
1095 public enum GdkFilterReturn
1096 {
1097 	CONTINUE, /+* Event not handled, continu processesing +/
1098 	TRANSLATE, /+* Native event translated into a GDK event and
1099 	stored inn the "event" structure that was
1100 	passed inn +/
1101 	REMOVE /+* Terminate processing, removing event +/
1102 }
1103 alias GdkFilterReturn FilterReturn;
1104 
1105 /**
1106  * A set of bit-flags to indicate the state of modifier keys and mouse buttons
1107  * in various event types. Typical modifier keys are Shift, Control, Meta, Super,
1108  * Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.
1109  * Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.
1110  * Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped
1111  * to Mod2 - Mod5, and indicates this by setting GDK_SUPER_MASK, GDK_HYPER_MASK
1112  * or GDK_META_MASK in the state field of key events.
1113  * GDK_SHIFT_MASK
1114  * the Shift key.
1115  * GDK_LOCK_MASK
1116  * a Lock key (depending on the modifier mapping of the
1117  *  X server this may either be CapsLock or ShiftLock).
1118  * GDK_CONTROL_MASK
1119  * the Control key.
1120  * GDK_MOD1_MASK
1121  * the fourth modifier key (it depends on the modifier
1122  *  mapping of the X server which key is interpreted as this modifier, but
1123  *  normally it is the Alt key).
1124  * GDK_MOD2_MASK
1125  * the fifth modifier key (it depends on the modifier
1126  *  mapping of the X server which key is interpreted as this modifier).
1127  * GDK_MOD3_MASK
1128  * the sixth modifier key (it depends on the modifier
1129  *  mapping of the X server which key is interpreted as this modifier).
1130  * GDK_MOD4_MASK
1131  * the seventh modifier key (it depends on the modifier
1132  *  mapping of the X server which key is interpreted as this modifier).
1133  * GDK_MOD5_MASK
1134  * the eighth modifier key (it depends on the modifier
1135  *  mapping of the X server which key is interpreted as this modifier).
1136  * GDK_BUTTON1_MASK
1137  * the first mouse button.
1138  * GDK_BUTTON2_MASK
1139  * the second mouse button.
1140  * GDK_BUTTON3_MASK
1141  * the third mouse button.
1142  * GDK_BUTTON4_MASK
1143  * the fourth mouse button.
1144  * GDK_BUTTON5_MASK
1145  * the fifth mouse button.
1146  * GDK_SUPER_MASK
1147  * the Super modifier. Since 2.10
1148  * GDK_HYPER_MASK
1149  * the Hyper modifier. Since 2.10
1150  * GDK_META_MASK
1151  * the Meta modifier. Since 2.10
1152  * GDK_RELEASE_MASK
1153  * not used in GDK itself. GTK+ uses it to differentiate
1154  *  between (keyval, modifiers) pairs from key press and release events.
1155  * GDK_MODIFIER_MASK
1156  * a mask covering all modifier types.
1157  */
1158 public enum GdkModifierType
1159 {
1160 	SHIFT_MASK = 1 << 0,
1161 	LOCK_MASK = 1 << 1,
1162 	CONTROL_MASK = 1 << 2,
1163 	MOD1_MASK = 1 << 3,
1164 	MOD2_MASK = 1 << 4,
1165 	MOD3_MASK = 1 << 5,
1166 	MOD4_MASK = 1 << 6,
1167 	MOD5_MASK = 1 << 7,
1168 	BUTTON1_MASK = 1 << 8,
1169 	BUTTON2_MASK = 1 << 9,
1170 	BUTTON3_MASK = 1 << 10,
1171 	BUTTON4_MASK = 1 << 11,
1172 	BUTTON5_MASK = 1 << 12,
1173 	/+* The next few modifiers are used by XKB, so we skip to the end.
1174 	 * Bits 15 - 25 are currently unused. Bit 29 is used internally.
1175 	+/
1176 	SUPER_MASK = 1 << 26,
1177 	HYPER_MASK = 1 << 27,
1178 	META_MASK = 1 << 28,
1179 	RELEASE_MASK = 1 << 30,
1180 	MODIFIER_MASK = 0x5c001fff
1181 }
1182 alias GdkModifierType ModifierType;
1183 
1184 /**
1185  * These are hints originally defined by the Motif toolkit.
1186  * The window manager can use them when determining how to decorate
1187  * the window. The hint must be set before mapping the window.
1188  * GDK_DECOR_ALL
1189  * all decorations should be applied.
1190  * GDK_DECOR_BORDER
1191  * a frame should be drawn around the window.
1192  * GDK_DECOR_RESIZEH
1193  * the frame should have resize handles.
1194  * GDK_DECOR_TITLE
1195  * a titlebar should be placed above the window.
1196  * GDK_DECOR_MENU
1197  * a button for opening a menu should be included.
1198  * GDK_DECOR_MINIMIZE
1199  * a minimize button should be included.
1200  * GDK_DECOR_MAXIMIZE
1201  * a maximize button should be included.
1202  */
1203 public enum GdkWMDecoration
1204 {
1205 	DECOR_ALL = 1 << 0,
1206 	DECOR_BORDER = 1 << 1,
1207 	DECOR_RESIZEH = 1 << 2,
1208 	DECOR_TITLE = 1 << 3,
1209 	DECOR_MENU = 1 << 4,
1210 	DECOR_MINIMIZE = 1 << 5,
1211 	DECOR_MAXIMIZE = 1 << 6
1212 }
1213 alias GdkWMDecoration WMDecoration;
1214 
1215 /**
1216  * These are hints originally defined by the Motif toolkit.
1217  * The window manager can use them when determining the functions
1218  * to offer for the window.
1219  * The hint must be set before mapping the window.
1220  * GDK_FUNC_ALL
1221  * all functions should be offered.
1222  * GDK_FUNC_RESIZE
1223  * the window should be resizable.
1224  * GDK_FUNC_MOVE
1225  * the window should be movable.
1226  * GDK_FUNC_MINIMIZE
1227  * the window should be minimizable.
1228  * GDK_FUNC_MAXIMIZE
1229  * the window should be maximizable.
1230  * GDK_FUNC_CLOSE
1231  * the window should be closable.
1232  */
1233 public enum GdkWMFunction
1234 {
1235 	FUNC_ALL = 1 << 0,
1236 	FUNC_RESIZE = 1 << 1,
1237 	FUNC_MOVE = 1 << 2,
1238 	FUNC_MINIMIZE = 1 << 3,
1239 	FUNC_MAXIMIZE = 1 << 4,
1240 	FUNC_CLOSE = 1 << 5
1241 }
1242 alias GdkWMFunction WMFunction;
1243 
1244 /**
1245  * Specifies the type of the event.
1246  * Do not confuse these events with the signals that GTK+ widgets emit.
1247  * Although many of these events result in corresponding signals being emitted,
1248  * the events are often transformed or filtered along the way.
1249  * GDK_NOTHING
1250  * a special code to indicate a null event.
1251  * GDK_DELETE
1252  * the window manager has requested that the toplevel window be
1253  * hidden or destroyed, usually when the user clicks on a special icon in the
1254  * title bar.
1255  * GDK_DESTROY
1256  * the window has been destroyed.
1257  * GDK_EXPOSE
1258  * all or part of the window has become visible and needs to be
1259  * redrawn.
1260  * GDK_MOTION_NOTIFY
1261  * the pointer (usually a mouse) has moved.
1262  * GDK_BUTTON_PRESS
1263  * a mouse button has been pressed.
1264  * GDK_2BUTTON_PRESS
1265  * a mouse button has been double-clicked (clicked twice
1266  * within a short period of time). Note that each click also generates a
1267  * GDK_BUTTON_PRESS event.
1268  * GDK_3BUTTON_PRESS
1269  * a mouse button has been clicked 3 times in a short period
1270  * of time. Note that each click also generates a GDK_BUTTON_PRESS event.
1271  * GDK_BUTTON_RELEASE
1272  * a mouse button has been released.
1273  * GDK_KEY_PRESS
1274  * a key has been pressed.
1275  * GDK_KEY_RELEASE
1276  * a key has been released.
1277  * GDK_ENTER_NOTIFY
1278  * the pointer has entered the window.
1279  * GDK_LEAVE_NOTIFY
1280  * the pointer has left the window.
1281  * GDK_FOCUS_CHANGE
1282  * the keyboard focus has entered or left the window.
1283  * GDK_CONFIGURE
1284  * the size, position or stacking order of the window has changed.
1285  * Note that GTK+ discards these events for GDK_WINDOW_CHILD windows.
1286  * GDK_MAP
1287  * the window has been mapped.
1288  * GDK_UNMAP
1289  * the window has been unmapped.
1290  * GDK_PROPERTY_NOTIFY
1291  * a property on the window has been changed or deleted.
1292  * GDK_SELECTION_CLEAR
1293  * the application has lost ownership of a selection.
1294  * GDK_SELECTION_REQUEST
1295  * another application has requested a selection.
1296  * GDK_SELECTION_NOTIFY
1297  * a selection has been received.
1298  * GDK_PROXIMITY_IN
1299  * an input device has moved into contact with a sensing
1300  * surface (e.g. a touchscreen or graphics tablet).
1301  * GDK_PROXIMITY_OUT
1302  * an input device has moved out of contact with a sensing
1303  * surface.
1304  * GDK_DRAG_ENTER
1305  * the mouse has entered the window while a drag is in progress.
1306  * GDK_DRAG_LEAVE
1307  * the mouse has left the window while a drag is in progress.
1308  * GDK_DRAG_MOTION
1309  * the mouse has moved in the window while a drag is in
1310  * progress.
1311  * GDK_DRAG_STATUS
1312  * the status of the drag operation initiated by the window
1313  * has changed.
1314  * GDK_DROP_START
1315  * a drop operation onto the window has started.
1316  * GDK_DROP_FINISHED
1317  * the drop operation initiated by the window has completed.
1318  * GDK_CLIENT_EVENT
1319  * a message has been received from another application.
1320  * GDK_VISIBILITY_NOTIFY
1321  * the window visibility status has changed.
1322  * GDK_NO_EXPOSE
1323  * indicates that the source region was completely available
1324  * when parts of a drawable were copied. This is not very useful.
1325  * GDK_SCROLL
1326  * the scroll wheel was turned
1327  * GDK_WINDOW_STATE
1328  * the state of a window has changed. See GdkWindowState
1329  * for the possible window states
1330  * GDK_SETTING
1331  * a setting has been modified.
1332  * GDK_OWNER_CHANGE
1333  * the owner of a selection has changed. This event type
1334  *  was added in 2.6
1335  * GDK_GRAB_BROKEN
1336  * a pointer or keyboard grab was broken. This event type
1337  *  was added in 2.8.
1338  * GDK_DAMAGE
1339  * the content of the window has been changed. This event type
1340  *  was added in 2.14.
1341  * GDK_EVENT_LAST
1342  * marks the end of the GdkEventType enumeration. Added in 2.18
1343  */
1344 public enum GdkEventType
1345 {
1346 	NOTHING = -1,
1347 	DELETE = 0,
1348 	DESTROY = 1,
1349 	EXPOSE = 2,
1350 	MOTION_NOTIFY = 3,
1351 	BUTTON_PRESS = 4,
1352 	DOUBLE_BUTTON_PRESS = 5,
1353 	TRIPLE_BUTTON_PRESS = 6,
1354 	BUTTON_RELEASE = 7,
1355 	KEY_PRESS = 8,
1356 	KEY_RELEASE = 9,
1357 	ENTER_NOTIFY = 10,
1358 	LEAVE_NOTIFY = 11,
1359 	FOCUS_CHANGE = 12,
1360 	CONFIGURE = 13,
1361 	MAP = 14,
1362 	UNMAP = 15,
1363 	PROPERTY_NOTIFY = 16,
1364 	SELECTION_CLEAR = 17,
1365 	SELECTION_REQUEST = 18,
1366 	SELECTION_NOTIFY = 19,
1367 	PROXIMITY_IN = 20,
1368 	PROXIMITY_OUT = 21,
1369 	DRAG_ENTER = 22,
1370 	DRAG_LEAVE = 23,
1371 	DRAG_MOTION = 24,
1372 	DRAG_STATUS = 25,
1373 	DROP_START = 26,
1374 	DROP_FINISHED = 27,
1375 	CLIENT_EVENT = 28,
1376 	VISIBILITY_NOTIFY = 29,
1377 	NO_EXPOSE = 30,
1378 	SCROLL = 31,
1379 	WINDOW_STATE = 32,
1380 	SETTING = 33,
1381 	OWNER_CHANGE = 34,
1382 	GRAB_BROKEN = 35,
1383 	DAMAGE = 36,
1384 	EVENT_LAST /+* helper variable for decls +/
1385 }
1386 alias GdkEventType EventType;
1387 
1388 /**
1389  * A set of bit-flags to indicate which events a window is to receive.
1390  * Most of these masks map onto one or more of the GdkEventType event types
1391  * above.
1392  * GDK_POINTER_MOTION_HINT_MASK is a special mask which is used to reduce the
1393  * number of GDK_MOTION_NOTIFY events received. Normally a GDK_MOTION_NOTIFY
1394  * event is received each time the mouse moves. However, if the application
1395  * spends a lot of time processing the event (updating the display, for example),
1396  * it can lag behind the position of the mouse. When using
1397  * GDK_POINTER_MOTION_HINT_MASK, fewer GDK_MOTION_NOTIFY events will be sent,
1398  * some of which are marked as a hint (the is_hint member is TRUE).
1399  * To receive more motion events after a motion hint event, the application
1400  * needs to asks for more, by calling gdk_event_request_motions().
1401  * GDK_EXPOSURE_MASK
1402  * receive expose events
1403  * GDK_POINTER_MOTION_MASK
1404  * receive all pointer motion events
1405  * GDK_POINTER_MOTION_HINT_MASK
1406  * see the explanation above
1407  * GDK_BUTTON_MOTION_MASK
1408  * receive pointer motion events while any button is pressed
1409  * GDK_BUTTON1_MOTION_MASK
1410  * receive pointer motion events while 1 button is pressed
1411  * GDK_BUTTON2_MOTION_MASK
1412  * receive pointer motion events while 2 button is pressed
1413  * GDK_BUTTON3_MOTION_MASK
1414  * receive pointer motion events while 3 button is pressed
1415  * GDK_BUTTON_PRESS_MASK
1416  * receive button press events
1417  * GDK_BUTTON_RELEASE_MASK
1418  * receive button release events
1419  * GDK_KEY_PRESS_MASK
1420  * receive key press events
1421  * GDK_KEY_RELEASE_MASK
1422  * receive key release events
1423  * GDK_ENTER_NOTIFY_MASK
1424  * receive window enter events
1425  * GDK_LEAVE_NOTIFY_MASK
1426  * receive window leave events
1427  * GDK_FOCUS_CHANGE_MASK
1428  * receive focus change events
1429  * GDK_STRUCTURE_MASK
1430  * receive events about window configuration change
1431  * GDK_PROPERTY_CHANGE_MASK
1432  * receive property change events
1433  * GDK_VISIBILITY_NOTIFY_MASK
1434  * receive visibility change events
1435  * GDK_PROXIMITY_IN_MASK
1436  * receive proximity in events
1437  * GDK_PROXIMITY_OUT_MASK
1438  * receive proximity out events
1439  * GDK_SUBSTRUCTURE_MASK
1440  * receive events about window configuration changes of
1441  *  child windows
1442  * GDK_SCROLL_MASK
1443  * receive scroll events
1444  * GDK_ALL_EVENTS_MASK
1445  * the combination of all the above event masks.
1446  */
1447 public enum GdkEventMask
1448 {
1449 	EXPOSURE_MASK = 1 << 1,
1450 	POINTER_MOTION_MASK = 1 << 2,
1451 	POINTER_MOTION_HINT_MASK = 1 << 3,
1452 	BUTTON_MOTION_MASK = 1 << 4,
1453 	BUTTON1_MOTION_MASK = 1 << 5,
1454 	BUTTON2_MOTION_MASK = 1 << 6,
1455 	BUTTON3_MOTION_MASK = 1 << 7,
1456 	BUTTON_PRESS_MASK = 1 << 8,
1457 	BUTTON_RELEASE_MASK = 1 << 9,
1458 	KEY_PRESS_MASK = 1 << 10,
1459 	KEY_RELEASE_MASK = 1 << 11,
1460 	ENTER_NOTIFY_MASK = 1 << 12,
1461 	LEAVE_NOTIFY_MASK = 1 << 13,
1462 	FOCUS_CHANGE_MASK = 1 << 14,
1463 	STRUCTURE_MASK = 1 << 15,
1464 	PROPERTY_CHANGE_MASK = 1 << 16,
1465 	VISIBILITY_NOTIFY_MASK = 1 << 17,
1466 	PROXIMITY_IN_MASK = 1 << 18,
1467 	PROXIMITY_OUT_MASK = 1 << 19,
1468 	SUBSTRUCTURE_MASK = 1 << 20,
1469 	SCROLL_MASK = 1 << 21,
1470 	ALL_EVENTS_MASK = 0x3FFFFE
1471 }
1472 alias GdkEventMask EventMask;
1473 
1474 /**
1475  * Specifies the direction for GdkEventScroll.
1476  * GDK_SCROLL_UP
1477  * the window is scrolled up.
1478  * GDK_SCROLL_DOWN
1479  * the window is scrolled down.
1480  * GDK_SCROLL_LEFT
1481  * the window is scrolled to the left.
1482  * GDK_SCROLL_RIGHT
1483  * the window is scrolled to the right.
1484  */
1485 public enum GdkScrollDirection
1486 {
1487 	UP,
1488 	DOWN,
1489 	LEFT,
1490 	RIGHT
1491 }
1492 alias GdkScrollDirection ScrollDirection;
1493 
1494 /**
1495  * Specifies the visiblity status of a window for a GdkEventVisibility.
1496  * GDK_VISIBILITY_UNOBSCURED
1497  * the window is completely visible.
1498  * GDK_VISIBILITY_PARTIAL
1499  * the window is partially visible.
1500  * GDK_VISIBILITY_FULLY_OBSCURED
1501  * the window is not visible at all.
1502  */
1503 public enum GdkVisibilityState
1504 {
1505 	UNOBSCURED,
1506 	PARTIAL,
1507 	FULLY_OBSCURED
1508 }
1509 alias GdkVisibilityState VisibilityState;
1510 
1511 /**
1512  * Specifies the crossing mode for GdkEventCrossing.
1513  * GDK_CROSSING_NORMAL
1514  * crossing because of pointer motion.
1515  * GDK_CROSSING_GRAB
1516  * crossing because a grab is activated.
1517  * GDK_CROSSING_UNGRAB
1518  * crossing because a grab is deactivated.
1519  * GDK_CROSSING_GTK_GRAB
1520  * crossing because a GTK+ grab is activated.
1521  * GDK_CROSSING_GTK_UNGRAB
1522  * crossing because a GTK+ grab is deactivated.
1523  * GDK_CROSSING_STATE_CHANGED
1524  * crossing because a GTK+ widget changed state (e.g.
1525  *  sensitivity).
1526  */
1527 public enum GdkCrossingMode
1528 {
1529 	NORMAL,
1530 	GRAB,
1531 	UNGRAB,
1532 	GTK_GRAB,
1533 	GTK_UNGRAB,
1534 	STATE_CHANGED
1535 }
1536 alias GdkCrossingMode CrossingMode;
1537 
1538 /**
1539  * Specifies the kind of crossing for GdkEventCrossing.
1540  * See the X11 protocol specification of LeaveNotify for
1541  * full details of crossing event generation.
1542  * GDK_NOTIFY_ANCESTOR
1543  * the window is entered from an ancestor or
1544  *  left towards an ancestor.
1545  * GDK_NOTIFY_VIRTUAL
1546  * the pointer moves between an ancestor and an
1547  *  inferior of the window.
1548  * GDK_NOTIFY_INFERIOR
1549  * the window is entered from an inferior or
1550  *  left towards an inferior.
1551  * GDK_NOTIFY_NONLINEAR
1552  *  the window is entered from or left towards
1553  *  a window which is neither an ancestor nor an inferior.
1554  * GDK_NOTIFY_NONLINEAR_VIRTUAL
1555  * the pointer moves between two windows
1556  *  which are not ancestors of each other and the window is part of
1557  *  the ancestor chain between one of these windows and their least
1558  *  common ancestor.
1559  * GDK_NOTIFY_UNKNOWN
1560  * an unknown type of enter/leave event occurred.
1561  */
1562 public enum GdkNotifyType
1563 {
1564 	ANCESTOR = 0,
1565 	VIRTUAL = 1,
1566 	INFERIOR = 2,
1567 	NONLINEAR = 3,
1568 	NONLINEAR_VIRTUAL = 4,
1569 	UNKNOWN = 5
1570 }
1571 alias GdkNotifyType NotifyType;
1572 
1573 /**
1574  * Specifies the type of a property change for a GdkEventProperty.
1575  * GDK_PROPERTY_NEW_VALUE
1576  * the property value was changed.
1577  * GDK_PROPERTY_DELETE
1578  * the property was deleted.
1579  */
1580 public enum GdkPropertyState
1581 {
1582 	NEW_VALUE,
1583 	DELETE
1584 }
1585 alias GdkPropertyState PropertyState;
1586 
1587 /**
1588  * Specifies the state of a toplevel window.
1589  * GDK_WINDOW_STATE_WITHDRAWN
1590  * the window is not shown.
1591  * GDK_WINDOW_STATE_ICONIFIED
1592  * the window is minimized.
1593  * GDK_WINDOW_STATE_MAXIMIZED
1594  * the window is maximized.
1595  * GDK_WINDOW_STATE_STICKY
1596  * the window is sticky.
1597  * GDK_WINDOW_STATE_FULLSCREEN
1598  * the window is maximized without decorations.
1599  * GDK_WINDOW_STATE_ABOVE
1600  * the window is kept above other windows.
1601  * GDK_WINDOW_STATE_BELOW
1602  * the window is kept below other windows.
1603  */
1604 public enum GdkWindowState
1605 {
1606 	WITHDRAWN = 1 << 0,
1607 	ICONIFIED = 1 << 1,
1608 	MAXIMIZED = 1 << 2,
1609 	STICKY = 1 << 3,
1610 	FULLSCREEN = 1 << 4,
1611 	ABOVE = 1 << 5,
1612 	BELOW = 1 << 6
1613 }
1614 alias GdkWindowState WindowState;
1615 
1616 /**
1617  * Specifies the kind of modification applied to a setting in a GdkEventSetting.
1618  * GDK_SETTING_ACTION_NEW
1619  * a setting was added.
1620  * GDK_SETTING_ACTION_CHANGED
1621  * a setting was changed.
1622  * GDK_SETTING_ACTION_DELETED
1623  * a setting was deleted.
1624  */
1625 public enum GdkSettingAction
1626 {
1627 	NEW,
1628 	CHANGED,
1629 	DELETED
1630 }
1631 alias GdkSettingAction SettingAction;
1632 
1633 /**
1634  * Specifies why a selection ownership was changed.
1635  * GDK_OWNER_CHANGE_NEW_OWNER
1636  * some other app claimed the ownership
1637  * GDK_OWNER_CHANGE_DESTROY
1638  * the window was destroyed
1639  * GDK_OWNER_CHANGE_CLOSE
1640  * the client was closed
1641  */
1642 public enum GdkOwnerChange
1643 {
1644 	NEW_OWNER,
1645 	DESTROY,
1646 	CLOSE
1647 }
1648 alias GdkOwnerChange OwnerChange;
1649 
1650 /**
1651  * Used in GdkDragContext to indicate the protocol according to
1652  * which DND is done.
1653  * GDK_DRAG_PROTO_MOTIF
1654  * The Motif DND protocol.
1655  * GDK_DRAG_PROTO_XDND
1656  * The Xdnd protocol.
1657  * GDK_DRAG_PROTO_ROOTWIN
1658  * An extension to the Xdnd protocol for
1659  *  unclaimed root window drops.
1660  * GDK_DRAG_PROTO_NONE
1661  * no protocol.
1662  * GDK_DRAG_PROTO_WIN32_DROPFILES
1663  * The simple WM_DROPFILES protocol.
1664  * GDK_DRAG_PROTO_OLE2
1665  * The complex OLE2 DND protocol (not implemented).
1666  * GDK_DRAG_PROTO_LOCAL
1667  * Intra-application DND.
1668  */
1669 public enum GdkDragProtocol
1670 {
1671 	MOTIF,
1672 	XDND,
1673 	ROOTWIN, /+* A root window with nobody claiming
1674 	 * drags +/
1675 	NONE, /+* Not a valid drag window +/
1676 	WIN32_DROPFILES, /+* The simple WM_DROPFILES dnd +/
1677 	OLE2, /+* The complex OLE2 dnd (not implemented) +/
1678 	LOCAL /+* Intra-app +/
1679 }
1680 alias GdkDragProtocol DragProtocol;
1681 
1682 /**
1683  * Used in GdkDragContext to indicate what the destination
1684  * should do with the dropped data.
1685  * GDK_ACTION_DEFAULT
1686  * Means nothing, and should not be used.
1687  * GDK_ACTION_COPY
1688  * Copy the data.
1689  * GDK_ACTION_MOVE
1690  * Move the data, i.e. first copy it, then delete
1691  *  it from the source using the DELETE target of the X selection protocol.
1692  * GDK_ACTION_LINK
1693  * Add a link to the data. Note that this is only
1694  *  useful if source and destination agree on what it means.
1695  * GDK_ACTION_PRIVATE
1696  * Special action which tells the source that the
1697  *  destination will do something that the source doesn't understand.
1698  * GDK_ACTION_ASK
1699  * Ask the user what to do with the data.
1700  */
1701 public enum GdkDragAction
1702 {
1703 	ACTION_DEFAULT = 1 << 0,
1704 	ACTION_COPY = 1 << 1,
1705 	ACTION_MOVE = 1 << 2,
1706 	ACTION_LINK = 1 << 3,
1707 	ACTION_PRIVATE = 1 << 4,
1708 	ACTION_ASK = 1 << 5
1709 }
1710 alias GdkDragAction DragAction;
1711 
1712 /**
1713  * Describes how existing data is combined with new data when
1714  * using gdk_property_change().
1715  * GDK_PROP_MODE_REPLACE
1716  * the new data replaces the existing data.
1717  * GDK_PROP_MODE_PREPEND
1718  * the new data is prepended to the existing data.
1719  * GDK_PROP_MODE_APPEND
1720  * the new data is appended to the existing data.
1721  */
1722 public enum GdkPropMode
1723 {
1724 	MODE_REPLACE,
1725 	MODE_PREPEND,
1726 	MODE_APPEND
1727 }
1728 alias GdkPropMode PropMode;
1729 
1730 /**
1731  * A set of bit flags used to specify conditions for which
1732  * an input callback will be triggered. The three members
1733  * of this enumeration correspond to the readfds,
1734  * writefds, and exceptfds arguments to the
1735  * select system call.
1736  * GDK_INPUT_READ
1737  * the file descriptor has become available for reading.
1738  * (Or, as is standard in Unix, a socket or pipe was closed
1739  * at the other end; this is the case if a subsequent read
1740  * on the file descriptor returns a count of zero.)
1741  * GDK_INPUT_WRITE
1742  * the file descriptor has become available for writing.
1743  * GDK_INPUT_EXCEPTION
1744  * an exception was raised on the file descriptor.
1745  */
1746 public enum GdkInputCondition
1747 {
1748 	READ = 1 << 0,
1749 	WRITE = 1 << 1,
1750 	EXCEPTION = 1 << 2
1751 }
1752 alias GdkInputCondition InputCondition;
1753 
1754 /**
1755  * An enumeration describing the type of an input device
1756  * in general terms.
1757  * GDK_SOURCE_MOUSE
1758  * the device is a mouse. (This will be reported for the core
1759  *  pointer, even if it is something else, such as a trackball.)
1760  * GDK_SOURCE_PEN
1761  * the device is a stylus of a graphics tablet or similar device.
1762  * GDK_SOURCE_ERASER
1763  * the device is an eraser. Typically, this would be the other end
1764  *  of a stylus on a graphics tablet.
1765  * GDK_SOURCE_CURSOR
1766  * the device is a graphics tablet "puck" or similar device.
1767  */
1768 public enum GdkInputSource
1769 {
1770 	SOURCE_MOUSE,
1771 	SOURCE_PEN,
1772 	SOURCE_ERASER,
1773 	SOURCE_CURSOR
1774 }
1775 alias GdkInputSource InputSource;
1776 
1777 /**
1778  * An enumeration that describes the mode of an input device.
1779  * GDK_MODE_DISABLED
1780  * the device is disabled and will not report any events.
1781  * GDK_MODE_SCREEN
1782  * the device is enabled. The device's coordinate space
1783  *  maps to the entire screen.
1784  * GDK_MODE_WINDOW
1785  * the device is enabled. The device's coordinate space
1786  *  is mapped to a single window. The manner in which this window
1787  *  is chosen is undefined, but it will typically be the same
1788  *  way in which the focus window for key events is determined.
1789  */
1790 public enum GdkInputMode
1791 {
1792 	MODE_DISABLED,
1793 	MODE_SCREEN,
1794 	MODE_WINDOW
1795 }
1796 alias GdkInputMode InputMode;
1797 
1798 /**
1799  * An enumeration describing the way in which a device
1800  * axis (valuator) maps onto the predefined valuator
1801  * types that GTK+ understands.
1802  * GDK_AXIS_IGNORE
1803  * the axis is ignored.
1804  * GDK_AXIS_X
1805  * the axis is used as the x axis.
1806  * GDK_AXIS_Y
1807  * the axis is used as the y axis.
1808  * GDK_AXIS_PRESSURE
1809  * the axis is used for pressure information.
1810  * GDK_AXIS_XTILT
1811  * the axis is used for x tilt information.
1812  * GDK_AXIS_YTILT
1813  * the axis is used for x tilt information.
1814  * GDK_AXIS_WHEEL
1815  * the axis is used for wheel information.
1816  * GDK_AXIS_LAST
1817  * a constant equal to the numerically highest axis value.
1818  */
1819 public enum GdkAxisUse
1820 {
1821 	IGNORE,
1822 	X,
1823 	Y,
1824 	PRESSURE,
1825 	XTILT,
1826 	YTILT,
1827 	WHEEL,
1828 	LAST
1829 }
1830 alias GdkAxisUse AxisUse;
1831 
1832 /**
1833  * An enumeration used to specify which extension events
1834  * are desired for a particular widget.
1835  * GDK_EXTENSION_EVENTS_NONE
1836  * no extension events are desired.
1837  * GDK_EXTENSION_EVENTS_ALL
1838  * all extension events are desired.
1839  * GDK_EXTENSION_EVENTS_CURSOR
1840  * extension events are desired only if a cursor
1841  *  will be displayed for the device.
1842  */
1843 public enum GdkExtensionMode
1844 {
1845 	EVENTS_NONE,
1846 	EVENTS_ALL,
1847 	EVENTS_CURSOR
1848 }
1849 alias GdkExtensionMode ExtensionMode;
1850 
1851 /**
1852  * An opaque type representing a string as an index into a table
1853  * of strings on the X server.
1854  */
1855 alias _GdkAtom* GdkAtom;
1856 public struct _GdkAtom;
1857 
1858 /**
1859  * Main Gtk struct.
1860  * The GdkDisplay struct is the GDK representation
1861  * of an X display. All its fields are private and should not be accessed directly.
1862  * Since 2.2
1863  */
1864 public struct GdkDisplay{}
1865 
1866 
1867 /**
1868  * A table of pointers to functions for getting quantities related to
1869  * the current pointer position. Each GdkDisplay has a table of this type,
1870  * which can be set using gdk_display_set_pointer_hooks().
1871  * This is only useful for such low-level tools as an event recorder.
1872  * Applications should never have any reason to use this facility
1873  * get_pointer ()
1874  * Obtains the current pointer position and modifier state.
1875  * The position is given in coordinates relative to the window containing
1876  * the pointer, which is returned in window.
1877  * window_get_pointer ()
1878  * Obtains the window underneath the mouse pointer.
1879  * Current pointer position and modifier state are returned in x, y and
1880  * mask. The position is given in coordinates relative to window.
1881  * window_at_pointer ()
1882  * Obtains the window underneath the mouse pointer,
1883  * returning the location of that window in win_x, win_y. Returns NULL
1884  * if the window under the mouse pointer is not known to GDK (for example,
1885  * belongs to another application).
1886  * Since 2.2
1887  */
1888 public struct GdkDisplayPointerHooks
1889 {
1890 	extern(C) void function(GdkDisplay* display, GdkScreen** screen, int* x, int* y, GdkModifierType* mask) getPointer;
1891 	extern(C) GdkWindow* function(GdkDisplay* display, GdkWindow* window, int* x, int* y, GdkModifierType* mask) windowGetPointer;
1892 	extern(C) GdkWindow* function(GdkDisplay* display, int* winX, int* winY) windowAtPointer;
1893 }
1894 
1895 
1896 /**
1897  * Main Gtk struct.
1898  * The GdkDisplayManager struct has no interesting
1899  * fields.
1900  * Since 2.2
1901  */
1902 public struct GdkDisplayManager{}
1903 
1904 
1905 /**
1906  * Main Gtk struct.
1907  * This is a currently just a placeholder typedef for the first argument of
1908  * the window_at_pointer function in GdkPointerHooks. It will be used
1909  * when GDK gets multihead support.
1910  * Since 2.2
1911  */
1912 public struct GdkScreen{}
1913 
1914 
1915 /**
1916  * Defines the x and y coordinates of a point.
1917  * gint x;
1918  * the x coordinate of the point.
1919  * gint y;
1920  * the y coordinate of the point.
1921  */
1922 public struct GdkPoint
1923 {
1924 	int x;
1925 	int y;
1926 }
1927 
1928 
1929 /**
1930  * Main Gtk struct.
1931  * Defines the position and size of a rectangle.
1932  * gint x;
1933  * the x coordinate of the left edge of the rectangle.
1934  * gint y;
1935  * the y coordinate of the top of the rectangle.
1936  * gint width;
1937  * the width of the rectangle.
1938  * gint height;
1939  * the height of the rectangle.
1940  */
1941 public struct GdkRectangle
1942 {
1943 	int x;
1944 	int y;
1945 	int width;
1946 	int height;
1947 }
1948 
1949 
1950 /**
1951  * A GdkRegion represents a set of pixels on the screen.
1952  * In GTK3, GdkRegion will be replaced by cairo_region_t. All the functions
1953  * listed in this section will go away and you will have to use the relevant
1954  * Cairo functions. The conversion can be done using simple serch and replace.
1955  */
1956 public struct GdkRegion{}
1957 
1958 
1959 /**
1960  * A GdkSpan represents a horizontal line of pixels starting
1961  * at the pixel with coordinates x, y and ending before x + width, y.
1962  * gint x;
1963  * x coordinate of the first pixel.
1964  * gint y;
1965  * y coordinate of the first pixel.
1966  * gint width;
1967  * number of pixels in the span.
1968  */
1969 public struct GdkSpan
1970 {
1971 	int x;
1972 	int y;
1973 	int width;
1974 }
1975 
1976 
1977 /**
1978  * Main Gtk struct.
1979  * The GdkGC structure represents a graphics context.
1980  * It is an opaque structure with no user-visible
1981  * elements.
1982  */
1983 public struct GdkGC{}
1984 
1985 
1986 /**
1987  * The GdkGCValues structure holds a set of values used
1988  * to create or modify a graphics context.
1989  * GdkColor foreground;
1990  * the foreground color. Note that gdk_gc_get_values()
1991  * only sets the pixel value.
1992  * GdkColor background;
1993  * the background color. Note that gdk_gc_get_values()
1994  * only sets the pixel value.
1995  * GdkFont *font;
1996  * the default font.
1997  * GdkFunction function;
1998  * the bitwise operation used when drawing.
1999  * GdkFill fill;
2000  * the fill style.
2001  * GdkPixmap *tile;
2002  * the tile pixmap.
2003  * GdkPixmap *stipple;
2004  * the stipple bitmap.
2005  * GdkPixmap *clip_mask;
2006  * the clip mask bitmap.
2007  * GdkSubwindowMode subwindow_mode;
2008  * the subwindow mode.
2009  * gint ts_x_origin;
2010  * the x origin of the tile or stipple.
2011  * gint ts_y_origin;
2012  * the y origin of the tile or stipple.
2013  * gint clip_x_origin;
2014  * the x origin of the clip mask.
2015  * gint clip_y_origin;
2016  * the y origin of the clip mask.
2017  * gint graphics_exposures;
2018  * whether graphics exposures are enabled.
2019  * gint line_width;
2020  * the line width.
2021  * GdkLineStyle line_style;
2022  * the way dashed lines are drawn.
2023  * GdkCapStyle cap_style;
2024  * the way the ends of lines are drawn.
2025  * GdkJoinStyle join_style;
2026  * the way joins between lines are drawn.
2027  */
2028 public struct GdkGCValues
2029 {
2030 	GdkColor foreground;
2031 	GdkColor background;
2032 	GdkFont *font;
2033 	GdkFunction funct;
2034 	GdkFill fill;
2035 	GdkPixmap *tile;
2036 	GdkPixmap *stipple;
2037 	GdkPixmap *clipMask;
2038 	GdkSubwindowMode subwindowMode;
2039 	int tsXOrigin;
2040 	int tsYOrigin;
2041 	int clipXOrigin;
2042 	int clipYOrigin;
2043 	int graphicsExposures;
2044 	int lineWidth;
2045 	GdkLineStyle lineStyle;
2046 	GdkCapStyle capStyle;
2047 	GdkJoinStyle joinStyle;
2048 }
2049 
2050 
2051 /**
2052  * Main Gtk struct.
2053  * An opaque structure representing an object that can be
2054  * drawn onto. This can be a GdkPixmap, a GdkBitmap,
2055  * or a GdkWindow.
2056  */
2057 public struct GdkDrawable{}
2058 
2059 
2060 /**
2061  * Specifies the start and end point of a line for use by the gdk_draw_segments()
2062  * function.
2063  * gint x1;
2064  * the x coordinate of the start point.
2065  * gint y1;
2066  * the y coordinate of the start point.
2067  * gint x2;
2068  * the x coordinate of the end point.
2069  * gint y2;
2070  * the y coordinate of the end point.
2071  */
2072 public struct GdkSegment
2073 {
2074 	int x1;
2075 	int y1;
2076 	int x2;
2077 	int y2;
2078 }
2079 
2080 
2081 /**
2082  * Specifies a trapezpoid for use by the gdk_draw_trapezoids().
2083  * The trapezoids used here have parallel, horizontal top and
2084  * bottom edges.
2085  * double y1;
2086  * the y coordinate of the start point.
2087  * double x11;
2088  * the x coordinate of the top left corner
2089  * double x21;
2090  * the x coordinate of the top right corner
2091  * double y2;
2092  * the y coordinate of the end point.
2093  * double x12;
2094  * the x coordinate of the bottom left corner
2095  * double x22;
2096  * the x coordinate of the bottom right corner
2097  */
2098 public struct GdkTrapezoid
2099 {
2100 	double y1, x11, x21, y2, x12, x22;
2101 }
2102 
2103 
2104 /**
2105  * Main Gtk struct.
2106  * An opaque structure representing an offscreen drawable.
2107  * Pointers to structures of type GdkPixmap, GdkBitmap,
2108  * and GdkWindow, can often be used interchangeably.
2109  * The type GdkDrawable refers generically to any of
2110  * these types.
2111  */
2112 public struct GdkPixmap{}
2113 
2114 
2115 /**
2116  * An opaque structure representing an offscreen drawable of depth
2117  * 1. Pointers to structures of type GdkPixmap, GdkBitmap, and
2118  * GdkWindow, can often be used interchangeably. The type GdkDrawable
2119  * refers generically to any of these types.
2120  */
2121 public struct GdkBitmap{}
2122 
2123 
2124 /**
2125  * Warning
2126  * GdkRgbCmap is deprecated and should not be used in newly-written code.
2127  * A private data structure which maps color indices to actual RGB
2128  * colors. This is used only for gdk_draw_indexed_image().
2129  * guint32 colors[256];
2130  * The colors, represented as 0xRRGGBB integer values.
2131  * gint n_colors;
2132  * The number of colors in the cmap.
2133  */
2134 public struct GdkRgbCmap
2135 {
2136 	uint[256] colors;
2137 	int nColors;
2138 }
2139 
2140 
2141 /**
2142  * Main Gtk struct.
2143  * The GdkImage struct contains information on the image and the pixel data.
2144  * GObject parent_instance;
2145  * the parent instance
2146  */
2147 public struct GdkImage
2148 {
2149 	GObject parentInstance;
2150 	GdkImageType type; /+* read only. +/
2151 	GdkVisual *visual; /+* read only. visual used to create the image +/
2152 	GdkByteOrder byteOrder; /+* read only. +/
2153 	int width; /+* read only. +/
2154 	int height; /+* read only. +/
2155 	ushort depth; /+* read only. +/
2156 	ushort bpp; /+* read only. bytes per pixel +/
2157 	ushort bpl; /+* read only. bytes per line +/
2158 	ushort bitsPerPixel; /+* read only. bits per pixel +/
2159 	void* mem;
2160 	GdkColormap *colormap; /+* read only. +/
2161 }
2162 
2163 
2164 /**
2165  * Main Gtk struct.
2166  * This is the main structure in the gdk-pixbuf; library. It is
2167  * used to represent images. It contains information about the
2168  * image's pixel data, its color space, bits per sample, width and
2169  * height, and the rowstride (the number of bytes between the start of
2170  * one row and the start of the next).
2171  */
2172 public struct GdkPixbuf{}
2173 
2174 
2175 /**
2176  * The GdkColor structure is used to describe an
2177  * allocated or unallocated color.
2178  * guint32 pixel;
2179  * For allocated colors, the value used to
2180  * draw this color on the screen.
2181  * guint16 red;
2182  * The red component of the color. This is
2183  * a value between 0 and 65535, with 65535 indicating
2184  * full intensitiy.
2185  * guint16 green;
2186  * The green component of the color.
2187  * guint16 blue;
2188  * The blue component of the color.
2189  */
2190 public struct GdkColor
2191 {
2192 	uint pixel;
2193 	ushort red;
2194 	ushort green;
2195 	ushort blue;
2196 }
2197 
2198 
2199 /**
2200  * Main Gtk struct.
2201  * The colormap structure contains the following public fields.
2202  */
2203 public struct GdkColormap
2204 {
2205 	int size;
2206 	GdkColor *colors;
2207 }
2208 
2209 
2210 /**
2211  * Main Gtk struct.
2212  * The GdkVisual structure contains information about
2213  * a particular visual.
2214  * $(DDOC_COMMENT example)
2215  * GObject parent_instance;
2216  * inherited portion from GObject
2217  */
2218 public struct GdkVisual
2219 {
2220 	GObject parentInstance;
2221 	GdkVisualType type;
2222 	int depth;
2223 	GdkByteOrder byteOrder;
2224 	int colormapSize;
2225 	int bitsPerRgb;
2226 	uint redMask;
2227 	int redShift;
2228 	int redPrec;
2229 	uint greenMask;
2230 	int greenShift;
2231 	int greenPrec;
2232 	uint blueMask;
2233 	int blueShift;
2234 	int bluePrec;
2235 }
2236 
2237 
2238 /**
2239  * Main Gtk struct.
2240  * Warning
2241  * GdkFont is deprecated and should not be used in newly-written code.
2242  * The GdkFont structure represents a font or fontset. It
2243  * contains the following public fields. A new GdkFont
2244  * structure is returned by gdk_font_load() or gdk_fontset_load(),
2245  * and is reference counted with gdk_font_ref() and gdk_font_unref()
2246  * GdkFontType type;
2247  * a value of type GdkFontType which indicates
2248  * whether this font is a single font or a fontset.
2249  * gint ascent;
2250  * the maximum distance that the font, when drawn,
2251  * ascends above the baseline.
2252  * gint descent;
2253  * the maximum distance that the font, when drawn,
2254  * descends below the baseline.
2255  */
2256 public struct GdkFont
2257 {
2258 	GdkFontType type;
2259 	int ascent;
2260 	int descent;
2261 }
2262 
2263 
2264 /**
2265  * Main Gtk struct.
2266  * A GdkCursor structure represents a cursor.
2267  */
2268 public struct GdkCursor
2269 {
2270 	GdkCursorType type;
2271 }
2272 
2273 
2274 /**
2275  * Main Gtk struct.
2276  * An opaque structure representing an onscreen drawable.
2277  * Pointers to structures of type GdkPixmap, GdkBitmap,
2278  * and GdkWindow, can often be used interchangeably.
2279  * The type GdkDrawable refers generically to any of
2280  * these types.
2281  */
2282 public struct GdkWindow{}
2283 
2284 
2285 /**
2286  * The GdkGeometry struct gives the window manager information about
2287  * a window's geometry constraints. Normally you would set these on
2288  * the GTK+ level using gtk_window_set_geometry_hints(). GtkWindow
2289  * then sets the hints on the GdkWindow it creates.
2290  * gdk_window_set_geometry_hints() expects the hints to be fully valid already and
2291  * simply passes them to the window manager; in contrast,
2292  * gtk_window_set_geometry_hints() performs some interpretation. For example,
2293  * GtkWindow will apply the hints to the geometry widget instead of the toplevel
2294  * window, if you set a geometry widget. Also, the
2295  * min_width/min_height/max_width/max_height fields may be set to -1, and
2296  * GtkWindow will substitute the size request of the window or geometry widget. If
2297  * the minimum size hint is not provided, GtkWindow will use its requisition as
2298  * the minimum size. If the minimum size is provided and a geometry widget is set,
2299  * GtkWindow will take the minimum size as the minimum size of the geometry widget
2300  * rather than the entire window. The base size is treated similarly.
2301  * The canonical use-case for gtk_window_set_geometry_hints() is to get a terminal
2302  * widget to resize properly. Here, the terminal text area should be the geometry
2303  * widget; GtkWindow will then automatically set the base size to the size of
2304  * other widgets in the terminal window, such as the menubar and scrollbar. Then,
2305  * the width_inc and height_inc fields should be set to the size of one character
2306  * in the terminal. Finally, the base size should be set to the size of one
2307  * character. The net effect is that the minimum size of the terminal
2308  * will have a 1x1 character terminal area, and only terminal sizes on
2309  * the "character grid" will be allowed.
2310  * Here's an example of how the terminal example would be implemented, assuming
2311  * a terminal area widget called "terminal" and a toplevel window "toplevel":
2312  * $(DDOC_COMMENT example)
2313  * The other useful fields are the min_aspect and max_aspect fields; these
2314  * contain a width/height ratio as a floating point number. If a geometry widget is
2315  * set, the aspect applies to the geometry widget rather than the entire window.
2316  * The most common use of these hints is probably to set min_aspect and
2317  * max_aspect to the same value, thus forcing the window to keep a constant aspect
2318  * ratio.
2319  * gint min_width;
2320  * minimum width of window (or -1 to use requisition, with GtkWindow only)
2321  * gint min_height;
2322  * minimum height of window (or -1 to use requisition, with GtkWindow only)
2323  * gint max_width;
2324  * maximum width of window (or -1 to use requisition, with GtkWindow only)
2325  * gint max_height;
2326  * maximum height of window (or -1 to use requisition, with GtkWindow only)
2327  * gint base_width;
2328  * allowed window widths are base_width + width_inc * N where N is any integer (-1 allowed with GtkWindow)
2329  * gint base_height;
2330  * allowed window widths are base_height + height_inc * N where N is any integer (-1 allowed with GtkWindow)
2331  * gint width_inc;
2332  * width resize increment
2333  * gint height_inc;
2334  * height resize increment
2335  * gdouble min_aspect;
2336  * minimum width/height ratio
2337  * gdouble max_aspect;
2338  * maximum width/height ratio
2339  * GdkGravity win_gravity;
2340  * window gravity, see gtk_window_set_gravity()
2341  */
2342 public struct GdkGeometry
2343 {
2344 	int minWidth;
2345 	int minHeight;
2346 	int maxWidth;
2347 	int maxHeight;
2348 	int baseWidth;
2349 	int baseHeight;
2350 	int widthInc;
2351 	int heightInc;
2352 	double minAspect;
2353 	double maxAspect;
2354 	GdkGravity winGravity;
2355 }
2356 
2357 
2358 /**
2359  * Attributes to use for a newly-created window.
2360  * gchar *title;
2361  * title of the window (for toplevel windows)
2362  * gint event_mask;
2363  * event mask (see gdk_window_set_events())
2364  * gint x;
2365  * X coordinate relative to parent window (see gdk_window_move())
2366  * gint y;
2367  * Y coordinate relative to parent window (see gdk_window_move())
2368  * gint width;
2369  * width of window
2370  * gint height;
2371  * height of window
2372  * GdkWindowClass wclass;
2373  * GDK_INPUT_OUTPUT (normal window) or GDK_INPUT_ONLY (invisible window that receives events)
2374  * GdkVisual *visual;
2375  * GdkVisual for window
2376  * GdkColormap *colormap;
2377  * GdkColormap for window
2378  * GdkWindowType window_type;
2379  * type of window
2380  * GdkCursor *cursor;
2381  * cursor for the window (see gdk_window_set_cursor())
2382  * gchar *wmclass_name;
2383  * don't use (see gtk_window_set_wmclass())
2384  * gchar *wmclass_class;
2385  * don't use (see gtk_window_set_wmclass())
2386  * gboolean override_redirect;
2387  * TRUE to bypass the window manager
2388  * GdkWindowTypeHint type_hint;
2389  * a hint of the function of the window
2390  */
2391 public struct GdkWindowAttr
2392 {
2393 	char *title;
2394 	int eventMask;
2395 	int x, y;
2396 	int width;
2397 	int height;
2398 	GdkWindowClass wclass;
2399 	GdkVisual *visual;
2400 	GdkColormap *colormap;
2401 	GdkWindowType windowType;
2402 	GdkCursor *cursor;
2403 	char *wmclassName;
2404 	char *wmclassClass;
2405 	int overrideRedirect;
2406 	GdkWindowTypeHint typeHint;
2407 }
2408 
2409 
2410 /**
2411  * A table of pointers to functions for getting quantities related to
2412  * the current pointer position. GDK has one global table of this type,
2413  * which can be set using gdk_set_pointer_hooks().
2414  * This is only useful for such low-level tools as an event recorder.
2415  * Applications should never have any reason to use this facility
2416  * get_pointer ()
2417  * Obtains the current pointer position and modifier state.
2418  * The position is given in coordinates relative to the window containing
2419  * the pointer, which is returned in window.
2420  * window_at_pointer ()
2421  * Obtains the window underneath the mouse pointer,
2422  * returning the location of that window in win_x, win_y. Returns NULL
2423  * if the window under the mouse pointer is not known to GDK (for example,
2424  * belongs to another application).
2425  */
2426 public struct GdkPointerHooks
2427 {
2428 	extern(C) GdkWindow* function(GdkWindow* window, int* x, int* y, GdkModifierType* mask) getPointer;
2429 	extern(C) GdkWindow* function(GdkScreen* screen, /+* unused +/int *winX, int* winY) windowAtPointer;
2430 }
2431 
2432 
2433 /**
2434  * Contains the fields which are common to all event structs.
2435  * Any event pointer can safely be cast to a pointer to a GdkEventAny to access
2436  * these fields.
2437  * GdkEventType type;
2438  * the type of the event.
2439  * GdkWindow *window;
2440  * the window which received the event.
2441  * gint8 send_event;
2442  * TRUE if the event was sent explicitly (e.g. using
2443  * XSendEvent).
2444  */
2445 public struct GdkEventAny
2446 {
2447 	GdkEventType type;
2448 	GdkWindow *window;
2449 	byte sendEvent;
2450 }
2451 
2452 
2453 /**
2454  * Describes a key press or key release event.
2455  * GdkEventType type;
2456  * the type of the event (GDK_KEY_PRESS or GDK_KEY_RELEASE).
2457  * GdkWindow *window;
2458  * the window which received the event.
2459  * gint8 send_event;
2460  * TRUE if the event was sent explicitly (e.g. using
2461  * XSendEvent).
2462  * guint32 time;
2463  * the time of the event in milliseconds.
2464  * guint state;
2465  * a bit-mask representing the state of the modifier keys (e.g. Control,
2466  * Shift and Alt) and the pointer buttons. See GdkModifierType.
2467  * guint keyval;
2468  * the key that was pressed or released. See the
2469  * <gdk/gdkkeysyms.h>
2470  * header file for a complete list of GDK key codes.
2471  * gint length;
2472  * the length of string.
2473  * gchar *string;
2474  * a string containing the an approximation of the text that
2475  * would result from this keypress. The only correct way to handle text
2476  * input of text is using input methods (see GtkIMContext), so this
2477  * field is deprecated and should never be used.
2478  * (gdk_unicode_to_keyval() provides a non-deprecated way of getting
2479  * an approximate translation for a key.) The string is encoded in the encoding
2480  * of the current locale (Note: this for backwards compatibility:
2481  * strings in GTK+ and GDK are typically in UTF-8.) and NUL-terminated.
2482  * In some cases, the translation of the key code will be a single
2483  * NUL byte, in which case looking at length is necessary to distinguish
2484  * it from the an empty translation.
2485  * guint16 hardware_keycode;
2486  * the raw code of the key that was pressed or released.
2487  * guint8 group;
2488  * the keyboard group.
2489  * guint is_modifier : 1;
2490  * a flag that indicates if hardware_keycode is mapped to a
2491  * modifier. Since 2.10
2492  */
2493 public struct GdkEventKey
2494 {
2495 	GdkEventType type;
2496 	GdkWindow *window;
2497 	byte sendEvent;
2498 	uint time;
2499 	uint state;
2500 	uint keyval;
2501 	int length;
2502 	char *string;
2503 	ushort hardwareKeycode;
2504 	ubyte group;
2505 	uint bitfield0;
2506 	//uint isModifier : 1;
2507 }
2508 
2509 
2510 /**
2511  * Used for button press and button release events. The
2512  * type field will be one of GDK_BUTTON_PRESS,
2513  * GDK_2BUTTON_PRESS, GDK_3BUTTON_PRESS, and GDK_BUTTON_RELEASE.
2514  * Double and triple-clicks result in a sequence of events being received.
2515  * For double-clicks the order of events will be:
2516  * GDK_BUTTON_PRESS
2517  * GDK_BUTTON_RELEASE
2518  * GDK_BUTTON_PRESS
2519  * GDK_2BUTTON_PRESS
2520  * GDK_BUTTON_RELEASE
2521  * Note that the first click is received just like a normal
2522  * button press, while the second click results in a GDK_2BUTTON_PRESS being
2523  * received just after the GDK_BUTTON_PRESS.
2524  * Triple-clicks are very similar to double-clicks, except that GDK_3BUTTON_PRESS
2525  * is inserted after the third click. The order of the events is:
2526  * GDK_BUTTON_PRESS
2527  * GDK_BUTTON_RELEASE
2528  * GDK_BUTTON_PRESS
2529  * GDK_2BUTTON_PRESS
2530  * GDK_BUTTON_RELEASE
2531  * GDK_BUTTON_PRESS
2532  * GDK_3BUTTON_PRESS
2533  * GDK_BUTTON_RELEASE
2534  * For a double click to occur, the second button press must occur within 1/4 of
2535  * a second of the first. For a triple click to occur, the third button press
2536  * must also occur within 1/2 second of the first button press.
2537  * GdkEventType type;
2538  * the type of the event (GDK_BUTTON_PRESS, GDK_2BUTTON_PRESS,
2539  * GDK_3BUTTON_PRESS or GDK_BUTTON_RELEASE).
2540  * GdkWindow *window;
2541  * the window which received the event.
2542  * gint8 send_event;
2543  * TRUE if the event was sent explicitly (e.g. using
2544  * XSendEvent).
2545  * guint32 time;
2546  * the time of the event in milliseconds.
2547  * gdouble x;
2548  * the x coordinate of the pointer relative to the window.
2549  * gdouble y;
2550  * the y coordinate of the pointer relative to the window.
2551  * gdouble *axes;
2552  * x, y translated to the axes of device, or NULL if device is
2553  * the mouse.
2554  * guint state;
2555  * a bit-mask representing the state of the modifier keys (e.g. Control,
2556  * Shift and Alt) and the pointer buttons. See GdkModifierType.
2557  * guint button;
2558  * the button which was pressed or released, numbered from 1 to 5.
2559  * Normally button 1 is the left mouse button, 2 is the middle button,
2560  * and 3 is the right button. On 2-button mice, the middle button can often
2561  * be simulated by pressing both mouse buttons together.
2562  * GdkDevice *device;
2563  * the device where the event originated.
2564  * gdouble x_root;
2565  * the x coordinate of the pointer relative to the root of the screen.
2566  * gdouble y_root;
2567  * the y coordinate of the pointer relative to the root of the screen.
2568  */
2569 public struct GdkEventButton
2570 {
2571 	GdkEventType type;
2572 	GdkWindow *window;
2573 	byte sendEvent;
2574 	uint time;
2575 	double x;
2576 	double y;
2577 	double *axes;
2578 	uint state;
2579 	uint button;
2580 	GdkDevice *device;
2581 	double xRoot, yRoot;
2582 }
2583 
2584 
2585 /**
2586  * Generated from button presses for the buttons 4 to 7. Wheel mice are
2587  * usually configured to generate button press events for buttons 4 and 5
2588  * when the wheel is turned.
2589  * GdkEventType type;
2590  * the type of the event (GDK_SCROLL).
2591  * GdkWindow *window;
2592  * the window which received the event.
2593  * gint8 send_event;
2594  * TRUE if the event was sent explicitly (e.g. using
2595  * XSendEvent).
2596  * guint32 time;
2597  * the time of the event in milliseconds.
2598  * gdouble x;
2599  * the x coordinate of the pointer relative to the window.
2600  * gdouble y;
2601  * the y coordinate of the pointer relative to the window.
2602  * guint state;
2603  * a bit-mask representing the state of the modifier keys (e.g. Control,
2604  * Shift and Alt) and the pointer buttons. See GdkModifierType.
2605  * GdkScrollDirection direction;
2606  * the direction to scroll to (one of GDK_SCROLL_UP,
2607  * GDK_SCROLL_DOWN, GDK_SCROLL_LEFT and GDK_SCROLL_RIGHT).
2608  * GdkDevice *device;
2609  * the device where the event originated.
2610  * gdouble x_root;
2611  * the x coordinate of the pointer relative to the root of the screen.
2612  * gdouble y_root;
2613  * the y coordinate of the pointer relative to the root of the screen.
2614  */
2615 public struct GdkEventScroll
2616 {
2617 	GdkEventType type;
2618 	GdkWindow *window;
2619 	byte sendEvent;
2620 	uint time;
2621 	double x;
2622 	double y;
2623 	uint state;
2624 	GdkScrollDirection direction;
2625 	GdkDevice *device;
2626 	double xRoot, yRoot;
2627 }
2628 
2629 
2630 /**
2631  * Generated when the pointer moves.
2632  * GdkEventType type;
2633  * the type of the event.
2634  * GdkWindow *window;
2635  * the window which received the event.
2636  * gint8 send_event;
2637  * TRUE if the event was sent explicitly (e.g. using
2638  * XSendEvent).
2639  * guint32 time;
2640  * the time of the event in milliseconds.
2641  * gdouble x;
2642  * the x coordinate of the pointer relative to the window.
2643  * gdouble y;
2644  * the y coordinate of the pointer relative to the window.
2645  * gdouble *axes;
2646  * x, y translated to the axes of device, or NULL if device is
2647  * the mouse.
2648  * guint state;
2649  * a bit-mask representing the state of the modifier keys (e.g. Control,
2650  * Shift and Alt) and the pointer buttons. See GdkModifierType.
2651  * gint16 is_hint;
2652  * set to 1 if this event is just a hint, see the GDK_POINTER_MOTION_HINT_MASK
2653  * value of GdkEventMask.
2654  * GdkDevice *device;
2655  * the device where the event originated.
2656  * gdouble x_root;
2657  * the x coordinate of the pointer relative to the root of the screen.
2658  * gdouble y_root;
2659  * the y coordinate of the pointer relative to the root of the screen.
2660  */
2661 public struct GdkEventMotion
2662 {
2663 	GdkEventType type;
2664 	GdkWindow *window;
2665 	byte sendEvent;
2666 	uint time;
2667 	double x;
2668 	double y;
2669 	double *axes;
2670 	uint state;
2671 	short isHint;
2672 	GdkDevice *device;
2673 	double xRoot, yRoot;
2674 }
2675 
2676 
2677 /**
2678  * Generated when all or part of a window becomes visible and needs to be
2679  * redrawn.
2680  * GdkEventType type;
2681  * the type of the event (GDK_EXPOSE or GDK_DAMAGE).
2682  * GdkWindow *window;
2683  * the window which received the event.
2684  * gint8 send_event;
2685  * TRUE if the event was sent explicitly (e.g. using
2686  * XSendEvent).
2687  * GdkRectangle area;
2688  * bounding box of region.
2689  * GdkRegion *region;
2690  * the region that needs to be redrawn.
2691  * gint count;
2692  * the number of contiguous GDK_EXPOSE events following this one.
2693  * The only use for this is "exposure compression", i.e. handling all contiguous
2694  * GDK_EXPOSE events in one go, though GDK performs some exposure compression
2695  * so this is not normally needed.
2696  */
2697 public struct GdkEventExpose
2698 {
2699 	GdkEventType type;
2700 	GdkWindow *window;
2701 	byte sendEvent;
2702 	GdkRectangle area;
2703 	GdkRegion *region;
2704 	int count; /+* If non-zero, how many more events follow. +/
2705 }
2706 
2707 
2708 /**
2709  * Generated when the window visibility status has changed.
2710  * GdkEventType type;
2711  * the type of the event (GDK_VISIBILITY_NOTIFY).
2712  * GdkWindow *window;
2713  * the window which received the event.
2714  * gint8 send_event;
2715  * TRUE if the event was sent explicitly (e.g. using
2716  * XSendEvent).
2717  * GdkVisibilityState state;
2718  * the new visibility state (GDK_VISIBILITY_FULLY_OBSCURED,
2719  * GDK_VISIBILITY_PARTIAL or GDK_VISIBILITY_UNOBSCURED).
2720  */
2721 public struct GdkEventVisibility
2722 {
2723 	GdkEventType type;
2724 	GdkWindow *window;
2725 	byte sendEvent;
2726 	GdkVisibilityState state;
2727 }
2728 
2729 
2730 /**
2731  * Generated when the pointer enters or leaves a window.
2732  * GdkEventType type;
2733  * the type of the event (GDK_ENTER_NOTIFY or GDK_LEAVE_NOTIFY).
2734  * GdkWindow *window;
2735  * the window which received the event.
2736  * gint8 send_event;
2737  * TRUE if the event was sent explicitly (e.g. using
2738  * XSendEvent).
2739  * GdkWindow *subwindow;
2740  * the window that was entered or left.
2741  * guint32 time;
2742  * the time of the event in milliseconds.
2743  * gdouble x;
2744  * the x coordinate of the pointer relative to the window.
2745  * gdouble y;
2746  * the y coordinate of the pointer relative to the window.
2747  * gdouble x_root;
2748  * the x coordinate of the pointer relative to the root of the screen.
2749  * gdouble y_root;
2750  * the y coordinate of the pointer relative to the root of the screen.
2751  * GdkCrossingMode mode;
2752  * the crossing mode (GDK_CROSSING_NORMAL, GDK_CROSSING_GRAB,
2753  * GDK_CROSSING_UNGRAB, GDK_CROSSING_GTK_GRAB, GDK_CROSSING_GTK_UNGRAB or
2754  * GDK_CROSSING_STATE_CHANGED). GDK_CROSSING_GTK_GRAB, GDK_CROSSING_GTK_UNGRAB,
2755  * and GDK_CROSSING_STATE_CHANGED were added in 2.14 and are always synthesized,
2756  * never native.
2757  * GdkNotifyType detail;
2758  * the kind of crossing that happened (GDK_NOTIFY_INFERIOR,
2759  * GDK_NOTIFY_ANCESTOR, GDK_NOTIFY_VIRTUAL, GDK_NOTIFY_NONLINEAR or
2760  * GDK_NOTIFY_NONLINEAR_VIRTUAL).
2761  * gboolean focus;
2762  * TRUE if window is the focus window or an inferior.
2763  * guint state;
2764  * a bit-mask representing the state of the modifier keys (e.g. Control,
2765  * Shift and Alt) and the pointer buttons. See GdkModifierType.
2766  */
2767 public struct GdkEventCrossing
2768 {
2769 	GdkEventType type;
2770 	GdkWindow *window;
2771 	byte sendEvent;
2772 	GdkWindow *subwindow;
2773 	uint time;
2774 	double x;
2775 	double y;
2776 	double xRoot;
2777 	double yRoot;
2778 	GdkCrossingMode mode;
2779 	GdkNotifyType detail;
2780 	int focus;
2781 	uint state;
2782 }
2783 
2784 
2785 /**
2786  * Describes a change of keyboard focus.
2787  * GdkEventType type;
2788  * the type of the event (GDK_FOCUS_CHANGE).
2789  * GdkWindow *window;
2790  * the window which received the event.
2791  * gint8 send_event;
2792  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2793  * gint16 in;
2794  * TRUE if the window has gained the keyboard focus, FALSE if it has lost
2795  * the focus.
2796  */
2797 public struct GdkEventFocus
2798 {
2799 	GdkEventType type;
2800 	GdkWindow *window;
2801 	byte sendEvent;
2802 	short inn;
2803 }
2804 
2805 
2806 /**
2807  * Generated when a window size or position has changed.
2808  * GdkEventType type;
2809  * the type of the event (GDK_CONFIGURE).
2810  * GdkWindow *window;
2811  * the window which received the event.
2812  * gint8 send_event;
2813  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2814  * gint x;
2815  * the new x coordinate of the window, relative to its parent.
2816  * gint y;
2817  * the new y coordinate of the window, relative to its parent.
2818  * gint width;
2819  * the new width of the window.
2820  * gint height;
2821  * the new height of the window.
2822  */
2823 public struct GdkEventConfigure
2824 {
2825 	GdkEventType type;
2826 	GdkWindow *window;
2827 	byte sendEvent;
2828 	int x, y;
2829 	int width;
2830 	int height;
2831 }
2832 
2833 
2834 /**
2835  * Describes a property change on a window.
2836  * GdkEventType type;
2837  * the type of the event (GDK_PROPERTY_NOTIFY).
2838  * GdkWindow *window;
2839  * the window which received the event.
2840  * gint8 send_event;
2841  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2842  * GdkAtom atom;
2843  * the property that was changed.
2844  * guint32 time;
2845  * the time of the event in milliseconds.
2846  * guint state;
2847  * whether the property was changed (GDK_PROPERTY_NEW_VALUE) or
2848  * deleted (GDK_PROPERTY_DELETE).
2849  */
2850 public struct GdkEventProperty
2851 {
2852 	GdkEventType type;
2853 	GdkWindow *window;
2854 	byte sendEvent;
2855 	GdkAtom atom;
2856 	uint time;
2857 	uint state;
2858 }
2859 
2860 
2861 /**
2862  * Generated when a selection is requested or ownership of a selection
2863  * is taken over by another client application.
2864  * GdkEventType type;
2865  * the type of the event (GDK_SELECTION_CLEAR, GDK_SELECTION_NOTIFY or
2866  * GDK_SELECTION_REQUEST).
2867  * GdkWindow *window;
2868  * the window which received the event.
2869  * gint8 send_event;
2870  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2871  * GdkAtom selection;
2872  * the selection.
2873  * GdkAtom target;
2874  * the target to which the selection should be converted.
2875  * GdkAtom property;
2876  * the property in which to place the result of the conversion.
2877  * guint32 time;
2878  * the time of the event in milliseconds.
2879  * GdkNativeWindow requestor;
2880  * the native window on which to place property.
2881  */
2882 public struct GdkEventSelection
2883 {
2884 	GdkEventType type;
2885 	GdkWindow *window;
2886 	byte sendEvent;
2887 	GdkAtom selection;
2888 	GdkAtom target;
2889 	GdkAtom property;
2890 	uint time;
2891 	GdkNativeWindow requestor;
2892 }
2893 
2894 
2895 /**
2896  * Generated during DND operations.
2897  * GdkEventType type;
2898  * the type of the event (GDK_DRAG_ENTER, GDK_DRAG_LEAVE,
2899  * GDK_DRAG_MOTION, GDK_DRAG_STATUS, GDK_DROP_START or GDK_DROP_FINISHED).
2900  * GdkWindow *window;
2901  * the window which received the event.
2902  * gint8 send_event;
2903  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2904  * GdkDragContext *context;
2905  * the GdkDragContext for the current DND operation.
2906  * guint32 time;
2907  * the time of the event in milliseconds.
2908  * gshort x_root;
2909  * the x coordinate of the pointer relative to the root of the screen,
2910  * only set for GDK_DRAG_MOTION and GDK_DROP_START.
2911  * gshort y_root;
2912  * the y coordinate of the pointer relative to the root of the screen,
2913  * only set for GDK_DRAG_MOTION and GDK_DROP_START.
2914  */
2915 public struct GdkEventDND
2916 {
2917 	GdkEventType type;
2918 	GdkWindow *window;
2919 	byte sendEvent;
2920 	GdkDragContext *context;
2921 	uint time;
2922 	short xRoot, yRoot;
2923 }
2924 
2925 
2926 /**
2927  * Proximity events are generated when using GDK's wrapper for the
2928  * XInput extension. The XInput extension is an add-on for standard X
2929  * that allows you to use nonstandard devices such as graphics tablets.
2930  * A proximity event indicates that the stylus has moved in or out of
2931  * contact with the tablet, or perhaps that the user's finger has moved
2932  * in or out of contact with a touch screen.
2933  * GdkEventType type;
2934  * the type of the event (GDK_PROXIMITY_IN or GDK_PROXIMITY_OUT).
2935  * GdkWindow *window;
2936  * the window which received the event.
2937  * gint8 send_event;
2938  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2939  * guint32 time;
2940  * the time of the event in milliseconds.
2941  * GdkDevice *device;
2942  * the device where the event originated.
2943  */
2944 public struct GdkEventProximity
2945 {
2946 	GdkEventType type;
2947 	GdkWindow *window;
2948 	byte sendEvent;
2949 	uint time;
2950 	GdkDevice *device;
2951 }
2952 
2953 
2954 /**
2955  * An event sent by another client application.
2956  * GdkEventType type;
2957  * the type of the event (GDK_CLIENT_EVENT).
2958  * GdkWindow *window;
2959  * the window which received the event.
2960  * gint8 send_event;
2961  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2962  * GdkAtom message_type;
2963  * the type of the message, which can be defined by the
2964  * application.
2965  * gushort data_format;
2966  * the format of the data, given as the number of bits in each
2967  * data element, i.e. 8, 16, or 32. 8-bit data uses the b array of the data
2968  * union, 16-bit data uses the s array, and 32-bit data uses the l array.
2969  */
2970 public struct GdkEventClient
2971 {
2972 	GdkEventType type;
2973 	GdkWindow *window;
2974 	byte sendEvent;
2975 	GdkAtom messageType;
2976 	ushort dataFormat;
2977 	union Data
2978 	{
2979 		char[20] b;
2980 		short[10] s;
2981 		long[5] l;
2982 	}
2983 	Data data;
2984 }
2985 
2986 
2987 /**
2988  * Generated when the area of a GdkDrawable being copied, with gdk_draw_drawable()
2989  * or gdk_window_copy_area(), was completely available.
2990  * FIXME: add more here.
2991  * GdkEventType type;
2992  * the type of the event (GDK_NO_EXPOSE).
2993  * GdkWindow *window;
2994  * the window which received the event.
2995  * gint8 send_event;
2996  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
2997  */
2998 public struct GdkEventNoExpose
2999 {
3000 	GdkEventType type;
3001 	GdkWindow *window;
3002 	byte sendEvent;
3003 }
3004 
3005 
3006 /**
3007  * Generated when the state of a toplevel window changes.
3008  * GdkEventType type;
3009  * the type of the event (GDK_WINDOW_STATE).
3010  * GdkWindow *window;
3011  * the window which received the event.
3012  * gint8 send_event;
3013  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
3014  * GdkWindowState changed_mask;
3015  * mask specifying what flags have changed.
3016  * GdkWindowState new_window_state;
3017  * the new window state, a combination of GdkWindowState bits.
3018  */
3019 public struct GdkEventWindowState
3020 {
3021 	GdkEventType type;
3022 	GdkWindow *window;
3023 	byte sendEvent;
3024 	GdkWindowState changedMask;
3025 	GdkWindowState newWindowState;
3026 }
3027 
3028 
3029 /**
3030  * Generated when a setting is modified.
3031  * GdkEventType type;
3032  * the type of the event (GDK_SETTING).
3033  * GdkWindow *window;
3034  * the window which received the event.
3035  * gint8 send_event;
3036  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
3037  * GdkSettingAction action;
3038  * what happened to the setting (GDK_SETTING_ACTION_NEW,
3039  * GDK_SETTING_ACTION_CHANGED or GDK_SETTING_ACTION_DELETED).
3040  * char *name;
3041  * the name of the setting.
3042  */
3043 public struct GdkEventSetting
3044 {
3045 	GdkEventType type;
3046 	GdkWindow *window;
3047 	byte sendEvent;
3048 	GdkSettingAction action;
3049 	char *name;
3050 }
3051 
3052 
3053 /**
3054  * Generated when the owner of a selection changes. On X11, this information is
3055  * only available if the X server supports the XFIXES extension.
3056  * GdkEventType type;
3057  * the type of the event (GDK_OWNER_CHANGE).
3058  * GdkWindow *window;
3059  * the window which received the event
3060  * gint8 send_event;
3061  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
3062  * GdkNativeWindow owner;
3063  * the new owner of the selection
3064  * GdkOwnerChange reason;
3065  * the reason for the ownership change as a GdkOwnerChange value
3066  * GdkAtom selection;
3067  * the atom identifying the selection
3068  * guint32 time;
3069  * the timestamp of the event
3070  * guint32 selection_time;
3071  * the time at which the selection ownership was taken over
3072  * Since 2.6
3073  */
3074 public struct GdkEventOwnerChange
3075 {
3076 	GdkEventType type;
3077 	GdkWindow *window;
3078 	byte sendEvent;
3079 	GdkNativeWindow owner;
3080 	GdkOwnerChange reason;
3081 	GdkAtom selection;
3082 	uint time;
3083 	uint selectionTime;
3084 }
3085 
3086 
3087 /**
3088  * Generated when a pointer or keyboard grab is broken. On X11, this happens
3089  * when the grab window becomes unviewable (i.e. it or one of its ancestors
3090  * is unmapped), or if the same application grabs the pointer or keyboard
3091  * again. Note that implicit grabs (which are initiated by button presses)
3092  * can also cause GdkEventGrabBroken events.
3093  * GdkEventType type;
3094  * the type of the event (GDK_GRAB_BROKEN)
3095  * GdkWindow *window;
3096  * the window which received the event, i.e. the window
3097  * that previously owned the grab
3098  * gint8 send_event;
3099  * TRUE if the event was sent explicitly (e.g. using XSendEvent).
3100  * gboolean keyboard;
3101  * TRUE if a keyboard grab was broken, FALSE if a pointer
3102  * grab was broken
3103  * gboolean implicit;
3104  * TRUE if the broken grab was implicit
3105  * GdkWindow *grab_window;
3106  * If this event is caused by another grab in the same
3107  * application, grab_window contains the new grab window. Otherwise
3108  * grab_window is NULL.
3109  * Since 2.8
3110  */
3111 public struct GdkEventGrabBroken
3112 {
3113 	GdkEventType type;
3114 	GdkWindow *window;
3115 	byte sendEvent;
3116 	int keyboard;
3117 	int implicit;
3118 	GdkWindow *grabWindow;
3119 }
3120 
3121 
3122 /**
3123  * Main Gtk struct.
3124  * A GdkKeymap defines the translation from keyboard state
3125  * (including a hardware key, a modifier mask, and active keyboard group)
3126  * to a keyval. This translation has two phases. The first phase is
3127  * to determine the effective keyboard group and level for the keyboard
3128  * state; the second phase is to look up the keycode/group/level triplet
3129  * in the keymap and see what keyval it corresponds to.
3130  */
3131 public struct GdkKeymap{}
3132 
3133 
3134 /**
3135  * A GdkKeymapKey is a hardware key that can
3136  * be mapped to a keyval.
3137  * guint keycode;
3138  * the hardware keycode. This is an identifying number for a
3139  * physical key.
3140  * gint group;
3141  * indicates movement in a horizontal direction. Usually groups are used
3142  * for two different languages. In group 0, a key might have two English
3143  * characters, and in group 1 it might have two Hebrew characters. The Hebrew
3144  * characters will be printed on the key next to the English characters.
3145  * gint level;
3146  * indicates which symbol on the key will be used, in a vertical direction. So on a standard US keyboard, the key with the number "1" on it also has the
3147  * exclamation point ("!") character on it. The level indicates whether to use
3148  * the "1" or the "!" symbol. The letter keys are considered to have a lowercase
3149  * letter at level 0, and an uppercase letter at level 1, though only the
3150  * uppercase letter is printed.
3151  */
3152 public struct GdkKeymapKey
3153 {
3154 	uint keycode;
3155 	int group;
3156 	int level;
3157 }
3158 
3159 
3160 /**
3161  * Main Gtk struct.
3162  * A GdkDragContext holds information about a
3163  * drag in progress. It is used on both source and destination sides.
3164  * GObject parent_instance;
3165  * the parent instance
3166  */
3167 public struct GdkDragContext
3168 {
3169 	GObject parentInstance;
3170 	GdkDragProtocol protocol;
3171 	int isSource;
3172 	GdkWindow *sourceWindow;
3173 	GdkWindow *destWindow;
3174 	GList *targets;
3175 	GdkDragAction actions;
3176 	GdkDragAction suggestedAction;
3177 	GdkDragAction action;
3178 	uint startTime;
3179 }
3180 
3181 
3182 /**
3183  * Main Gtk struct.
3184  * A GdkDevice structure contains
3185  * a detailed description of an extended input device. All
3186  * fields are read-only; but you can use gdk_device_set_source(),
3187  * gdk_device_set_mode(), gdk_device_set_key() and gdk_device_set_axis_use()
3188  * to configure various aspects of the device.
3189  * GObject parent_instance;
3190  * the parent instance
3191  */
3192 public struct GdkDevice
3193 {
3194 	GObject parentInstance;
3195 	/+* All fields are read-only +/
3196 	char *name;
3197 	GdkInputSource source;
3198 	GdkInputMode mode;
3199 	int hasCursor; /+* TRUE if the X pointer follows device motion +/
3200 	int numAxes;
3201 	GdkDeviceAxis *axes;
3202 	int numKeys;
3203 	GdkDeviceKey *keys;
3204 }
3205 
3206 
3207 /**
3208  * The GdkDeviceKey structure contains information
3209  * about the mapping of one device macro button onto a normal X key event.
3210  * It has the following fields:
3211  * guint keyval;
3212  * the keyval to generate when the macro button is pressed.
3213  * If this is 0, no keypress will be generated.
3214  * GdkModifierType modifiers;
3215  * the modifiers set for the generated key event.
3216  */
3217 public struct GdkDeviceKey
3218 {
3219 	uint keyval;
3220 	GdkModifierType modifiers;
3221 }
3222 
3223 
3224 /**
3225  * The GdkDeviceAxis structure contains information
3226  * about the range and mapping of a device axis.
3227  * GdkAxisUse use;
3228  * specifies how the axis is used.
3229  * gdouble min;
3230  * the minimal value that will be reported by this axis.
3231  * gdouble max;
3232  * the maximal value that will be reported by this axis.
3233  */
3234 public struct GdkDeviceAxis
3235 {
3236 	GdkAxisUse use;
3237 	double min;
3238 	double max;
3239 }
3240 
3241 
3242 /**
3243  * The GdkTimeCoord structure stores a single event in a
3244  * motion history. It contains the following fields:
3245  * guint32 time;
3246  * The timestamp for this event.
3247  * gdouble axes[GDK_MAX_TIMECOORD_AXES];
3248  * the values of the device's axes.
3249  */
3250 public struct GdkTimeCoord
3251 {
3252 	uint time;
3253 	double[GDK_MAX_TIMECOORD_AXES] axes;
3254 }
3255 
3256 
3257 /**
3258  * Main Gtk struct.
3259  * An opaque structure representing an application launch context.
3260  */
3261 public struct GdkAppLaunchContext{}
3262 
3263 
3264 /*
3265  * Warning
3266  * gdk_visual_ref is deprecated and should not be used in newly-written code.
3267  * Deprecated equivalent of g_object_ref().
3268  * v :
3269  * a GdkVisual
3270  * Returns :
3271  * the same visual
3272  */
3273 // TODO
3274 // #define gdk_visual_ref(v) g_object_ref(v)
3275 
3276 /*
3277  * Warning
3278  * gdk_visual_unref is deprecated and should not be used in newly-written code.
3279  * Deprecated equivalent of g_object_unref().
3280  * v :
3281  * a GdkVisual
3282  */
3283 // TODO
3284 // #define gdk_visual_unref(v) g_object_unref(v)
3285 
3286 /*
3287  * Warning
3288  * gdk_window_copy_area is deprecated and should not be used in newly-written code.
3289  * Deprecated equivalent to gdk_draw_drawable(), see that function for docs
3290  * drawable :
3291  * a GdkDrawable
3292  * gc :
3293  * a GdkGC sharing the drawable's visual and colormap
3294  * x :
3295  * X position in drawable where the rectangle should be drawn
3296  * y :
3297  * Y position in drawable where the rectangle should be drawn
3298  * source_drawable :
3299  * the source GdkDrawable, which may be the same as drawable
3300  * source_x :
3301  * X position in src of rectangle to draw
3302  * source_y :
3303  * Y position in src of rectangle to draw
3304  * width :
3305  * width of rectangle to draw, or -1 for entire src width
3306  * height :
3307  * height of rectangle to draw, or -1 for entire src height
3308  */
3309 // TODO
3310 // #define gdk_window_copy_area(drawable,gc,x,y,source_drawable,source_x,source_y,width,height)
3311 
3312 /*
3313  * Converts a GdkAtom into a pointer type.
3314  * atom :
3315  * a GdkAtom.
3316  */
3317 // TODO
3318 // #define GDK_ATOM_TO_POINTER(atom) (atom)
3319 
3320 /*
3321  * Extracts a GdkAtom from a pointer. The GdkAtom must have been
3322  * stored in the pointer with GDK_ATOM_TO_POINTER().
3323  * ptr :
3324  * a pointer containing a GdkAtom.
3325  */
3326 // TODO
3327 // #define GDK_POINTER_TO_ATOM(ptr) ((GdkAtom)(ptr))
3328 
3329 /*
3330  * Returns the display of a GdkWindow.
3331  * win :
3332  * a GdkWindow.
3333  * Returns :
3334  * an Xlib Display*.
3335  */
3336 // TODO
3337 // #define GDK_WINDOW_XDISPLAY(win) (GDK_SCREEN_X11 (GDK_WINDOW_SCREEN (win))->xdisplay)
3338 
3339 /*
3340  * Returns the X window belonging to a GdkWindow.
3341  * win :
3342  * a GdkWindow.
3343  * Returns :
3344  * the Xlib Window of win.
3345  */
3346 // TODO
3347 // #define GDK_WINDOW_XID(win) (GDK_DRAWABLE_IMPL_X11(((GdkWindowObject *)win)->impl)->xid)
3348 
3349 /*
3350  * Returns the display of a GdkPixmap.
3351  * pix :
3352  * a GdkPixmap.
3353  * Returns :
3354  * an Xlib Display*.
3355  */
3356 // TODO
3357 // #define GDK_PIXMAP_XDISPLAY(pix) (GDK_SCREEN_X11 (GDK_PIXMAP_SCREEN (pix))->xdisplay)
3358 
3359 /*
3360  * Returns the X pixmap belonging to a GdkPixmap.
3361  * pix :
3362  * a GdkPixmap.
3363  * Returns :
3364  * the Xlib XPixmap of win.
3365  */
3366 // TODO
3367 // #define GDK_PIXMAP_XID(pix) (GDK_DRAWABLE_IMPL_X11(((GdkPixmapObject *)pix)->impl)->xid)
3368 
3369 /*
3370  * Returns the display of a GdkDisplay.
3371  * display :
3372  * a GdkDisplay.
3373  */
3374 // TODO
3375 // #define GDK_DISPLAY_XDISPLAY(display) (GDK_DISPLAY_X11(display)->xdisplay)
3376 
3377 /*
3378  * Returns the display of a GdkDrawable.
3379  * win :
3380  * a GdkDrawable.
3381  * Returns :
3382  * an Xlib Display*.
3383  */
3384 // TODO
3385 // #define GDK_DRAWABLE_XDISPLAY(win) (GDK_IS_WINDOW (win) ? GDK_WINDOW_XDISPLAY (win) : GDK_PIXMAP_XDISPLAY (win))
3386 
3387 /*
3388  * Returns the X resource (window or pixmap) belonging to a GdkDrawable.
3389  * win :
3390  * a GdkDrawable.
3391  * Returns :
3392  * the ID of win's X resource.
3393  */
3394 // TODO
3395 // #define GDK_DRAWABLE_XID(win) (GDK_IS_WINDOW (win) ? GDK_WINDOW_XID (win) : GDK_PIXMAP_XID (win))
3396 
3397 /*
3398  * Returns the display of a GdkImage.
3399  * image :
3400  * a GdkImage.
3401  * Returns :
3402  * an Xlib Display*.
3403  */
3404 // TODO
3405 // #define GDK_IMAGE_XDISPLAY(image) (gdk_x11_image_get_xdisplay (image))
3406 
3407 /*
3408  * Returns the X image belonging to a GdkImage.
3409  * image :
3410  * a GdkImage.
3411  * Returns :
3412  * an XImage*.
3413  */
3414 // TODO
3415 // #define GDK_IMAGE_XIMAGE(image) (gdk_x11_image_get_ximage (image))
3416 
3417 /*
3418  * Returns the display of a GdkGC.
3419  * gc :
3420  * a GdkGC.
3421  * Returns :
3422  * an Xlib Display*.
3423  */
3424 // TODO
3425 // #define GDK_GC_XDISPLAY(gc) (GDK_SCREEN_XDISPLAY(GDK_GC_X11(gc)->screen))
3426 
3427 /*
3428  * Returns the display of a GdkColormap.
3429  * cmap :
3430  * a GdkColormap.
3431  * Returns :
3432  * an Xlib Display*.
3433  */
3434 // TODO
3435 // #define GDK_COLORMAP_XDISPLAY(cmap) (gdk_x11_colormap_get_xdisplay (cmap))
3436 
3437 /*
3438  * Returns the X colormap belonging to a GdkColormap.
3439  * cmap :
3440  * a GdkColormap.
3441  * Returns :
3442  * an Xlib Colormap.
3443  */
3444 // TODO
3445 // #define GDK_COLORMAP_XCOLORMAP(cmap) (gdk_x11_colormap_get_xcolormap (cmap))
3446 
3447 /*
3448  * Returns the display of a GdkScreen.
3449  * screen :
3450  * a GdkScreen.
3451  * Returns :
3452  * an Xlib Display*.
3453  */
3454 // TODO
3455 // #define GDK_SCREEN_XDISPLAY(screen) (GDK_SCREEN_X11 (screen)->xdisplay)
3456 
3457 /*
3458  * Returns the index of a GdkScreen.
3459  * screen :
3460  * a GdkScreen
3461  * Returns :
3462  * the position of screen among the screens of
3463  * its display.
3464  */
3465 // TODO
3466 // #define GDK_SCREEN_XNUMBER(screen) (GDK_SCREEN_X11 (screen)->screen_num)
3467 
3468 /*
3469  * Returns the screen of a GdkScreen.
3470  * screen :
3471  * a GdkScreen
3472  * Returns :
3473  * an Xlib Screen*.
3474  */
3475 // TODO
3476 // #define GDK_SCREEN_XSCREEN(screen) (GDK_SCREEN_X11 (screen)->xscreen)
3477 
3478 /*
3479  * Returns the X visual belonging to a GdkVisual.
3480  * vis :
3481  * a GdkVisual.
3482  * Returns :
3483  * an Xlib Visual*.
3484  */
3485 // TODO
3486 // #define GDK_VISUAL_XVISUAL(vis) (((GdkVisualPrivate *) vis)->xvisual)
3487 
3488 /*
3489  * Warning
3490  * GDK_FONT_XDISPLAY is deprecated and should not be used in newly-written code.
3491  * Returns the display of a GdkFont.
3492  * font :
3493  * a GdkFont.
3494  * Returns :
3495  * an Xlib Display*.
3496  */
3497 // TODO
3498 // #define GDK_FONT_XDISPLAY(font) (gdk_x11_font_get_xdisplay (font))
3499 
3500 /*
3501  * Warning
3502  * GDK_FONT_XFONT is deprecated and should not be used in newly-written code.
3503  * Returns the X font belonging to a GdkFont.
3504  * font :
3505  * a GdkFont.
3506  * Returns :
3507  * an Xlib XFontStruct* or an XFontSet.
3508  */
3509 // TODO
3510 // #define GDK_FONT_XFONT(font) (gdk_x11_font_get_xfont (font))
3511 
3512 /*
3513  * Returns the X cursor belonging to a GdkCursor.
3514  * cursor :
3515  * a GdkCursor.
3516  * Returns :
3517  * an Xlib Cursor.
3518  */
3519 // TODO
3520 // #define GDK_CURSOR_XCURSOR(cursor) (gdk_x11_cursor_get_xcursor (cursor))
3521 
3522 /*
3523  * Returns the display of a GdkCursor.
3524  * cursor :
3525  * a GdkCursor.
3526  * Returns :
3527  * an Xlib Display*.
3528  */
3529 // TODO
3530 // #define GDK_CURSOR_XDISPLAY(cursor) (gdk_x11_cursor_get_xdisplay (cursor))
3531 
3532 /*
3533  * Returns the X GC of a GdkGC.
3534  * gc :
3535  * a GdkGC.
3536  * Returns :
3537  * an Xlib GC.
3538  */
3539 // TODO
3540 // #define GDK_GC_XGC(gc)		 (GDK_GC_X11(gc)->xgc)
3541 
3542 /*
3543  * Returns the X GC of a GdkGC.
3544  * gc :
3545  * a GdkGC.
3546  * Returns :
3547  * an Xlib GC.
3548  */
3549 // TODO
3550 // #define GDK_GC_GET_XGC(gc)	 (GDK_GC_X11(gc)->dirty_mask ? _gdk_x11_gc_flush (gc) : ((GdkGCX11 *)(gc))->xgc)
3551 
3552 /*
3553  * Warning
3554  * gdk_font_lookup is deprecated and should not be used in newly-written code.
3555  * Obtains the GdkFont for the given Xlib font ID, or NULL if no GdkFont has
3556  * been created for xid.
3557  * xid :
3558  * an Xlib font ID
3559  */
3560 // TODO
3561 // #define gdk_font_lookup(xid)	 ((GdkFont*) gdk_xid_table_lookup (xid))
3562 
3563 /*
3564  * Warning
3565  * gdk_font_lookup_for_display is deprecated and should not be used in newly-written code.
3566  * Obtains the GdkFont for the given Xlib font ID on display, or NULL if no
3567  * GdkFont has been created for xid.
3568  * display :
3569  * a GdkDisplay
3570  * xid :
3571  * an Xlib font ID
3572  * Since: 2.2
3573  */
3574 // TODO
3575 // #define gdk_font_lookup_for_display(display, xid) ((GdkFont*) gdk_xid_table_lookup_for_display (display, ((xid)|XID_FONT_BIT)))
3576 
3577 /*
3578  * Warning
3579  * GdkSpanFunc is deprecated and should not be used in newly-written code.
3580  * This defines the type of the function passed to
3581  * gdk_region_spans_intersect_foreach().
3582  * span :
3583  * a GdkSpan.
3584  * data :
3585  * the user data passed to gdk_region_spans_intersect_foreach().
3586  */
3587 // void (*GdkSpanFunc) (GdkSpan *span,  gpointer data);
3588 public alias extern(C) void function(GdkSpan* span, void* data) GdkSpanFunc;
3589 
3590 /*
3591  * A function of this type is responsible for freeing the pixel array
3592  * of a pixbuf. The gdk_pixbuf_new_from_data() function lets you
3593  * pass in a pre-allocated pixel array so that a pixbuf can be
3594  * created from it; in this case you will need to pass in a function
3595  * of GdkPixbufDestroyNotify so that the pixel data can be freed
3596  * when the pixbuf is finalized.
3597  * pixels :
3598  * The pixel array of the pixbuf that is being finalized.
3599  * data :
3600  * User closure data.
3601  * See Also
3602  * GdkPixbuf, gdk_pixbuf_new_from_data().
3603  */
3604 // void (*GdkPixbufDestroyNotify) (guchar *pixels,  gpointer data);
3605 public alias extern(C) void function(guchar* pixels, void* data) GdkPixbufDestroyNotify;
3606 
3607 /*
3608  * Specifies the type of the function passed to
3609  * gdk_pixbuf_save_to_callback(). It is called once for each block of
3610  * bytes that is "written" by gdk_pixbuf_save_to_callback(). If
3611  * successful it should return TRUE. If an error occurs it should set
3612  * error and return FALSE, in which case gdk_pixbuf_save_to_callback()
3613  * will fail with the same error.
3614  * buf :
3615  * bytes to be written.
3616  * count :
3617  * number of bytes in buf.
3618  * error :
3619  * A location to return an error. [out]
3620  * data :
3621  * user data passed to gdk_pixbuf_save_to_callback(). [closure]
3622  * Returns :
3623  * TRUE if successful, FALSE (with error set) if failed.
3624  * Since 2.4
3625  */
3626 // gboolean (*GdkPixbufSaveFunc) (const gchar *buf,  gsize count,  GError **error,  gpointer data);
3627 public alias extern(C) int function(char* buf, gsize count, GError** error, void* data) GdkPixbufSaveFunc;
3628 
3629 /*
3630  * Specifies the type of function used to filter native events before they are
3631  * converted to GDK events.
3632  * When a filter is called, event is unpopulated, except for
3633  * event->window. The filter may translate the native
3634  * event to a GDK event and store the result in event, or handle it without
3635  * translation. If the filter translates the event and processing should
3636  * continue, it should return GDK_FILTER_TRANSLATE.
3637  * xevent :
3638  * the native event to filter.
3639  * event :
3640  * the GDK event to which the X event will be translated.
3641  * data :
3642  * user data set when the filter was installed.
3643  * Returns :
3644  * a GdkFilterReturn value.
3645  */
3646 // GdkFilterReturn (*GdkFilterFunc) (GdkXEvent *xevent,  GdkEvent *event,  gpointer data);
3647 public alias extern(C) GdkFilterReturn function(GdkXEvent* xevent, GdkEvent* event, void* data) GdkFilterFunc;
3648 
3649 /*
3650  * Specifies the type of function passed to gdk_event_handler_set() to handle
3651  * all GDK events.
3652  * event :
3653  * the GdkEvent to process.
3654  * data :
3655  * user data set when the event handler was installed with
3656  * gdk_event_handler_set().
3657  */
3658 // void (*GdkEventFunc) (GdkEvent *event,  gpointer data);
3659 public alias extern(C) void function(GdkEvent* event, void* data) GdkEventFunc;
3660 
3661 /*
3662  * A callback function that will be called when some condition
3663  * occurs.
3664  * data :
3665  * the user data passed to gdk_input_add() or gdk_input_add_full().
3666  * source :
3667  * the source where the condition occurred.
3668  * condition :
3669  * the triggering condition.
3670  */
3671 // void (*GdkInputFunction) (gpointer data,  gint source,  GdkInputCondition condition);
3672 public alias extern(C) void function(void* data, int source, GdkInputCondition condition) GdkInputFunction;
3673 
3674 /*
3675  * Warning
3676  * GdkDestroyNotify is deprecated and should not be used in newly-written code.
3677  * A callback function called when a piece of user data is
3678  * no longer being stored by GDK. Will typically free the
3679  * structure or object that data points to.
3680  * data :
3681  * the user data.
3682  */
3683 // void (*GdkDestroyNotify) (gpointer data);
3684 public alias extern(C) void function(void* data) GdkDestroyNotify;
3685 /**
3686  * The GdkEvent struct contains a union of all of the event structs,
3687  * and allows access to the data fields in a number of ways.
3688  * The event type is always the first field in all of the event structs, and
3689  * can always be accessed with the following code, no matter what type of event
3690  * it is:
3691  */
3692 public struct GdkEvent
3693 {
3694 	union
3695 	{
3696 		GdkEventType type;
3697 		GdkEventAny any;
3698 		GdkEventExpose expose;
3699 		GdkEventNoExpose noExpose;
3700 		GdkEventVisibility visibility;
3701 		GdkEventMotion motion;
3702 		GdkEventButton button;
3703 		GdkEventScroll scroll;
3704 		GdkEventKey key;
3705 		GdkEventCrossing crossing;
3706 		GdkEventFocus focusChange;
3707 		GdkEventConfigure configure;
3708 		GdkEventProperty property;
3709 		GdkEventSelection selection;
3710 		GdkEventOwnerChange ownerChange;
3711 		GdkEventProximity proximity;
3712 		GdkEventClient client;
3713 		GdkEventDND dnd;
3714 		GdkEventWindowState windowState;
3715 		GdkEventSetting setting;
3716 		GdkEventGrabBroken grabBroken;
3717 	}
3718 }