Pileus Git - ~andy/gtk/blob - gdk/gdktypes.h

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #ifndef __GDK_TYPES_H__
  19 #define __GDK_TYPES_H__
  20
  21
  22 /* GDK uses "glib". (And so does GTK).
  23  */
  24 #include <glib.h>
  25
  26
  27 #define GDK_NONE             0L
  28 #define GDK_CURRENT_TIME     0L
  29 #define GDK_PARENT_RELATIVE  1L
  30
  31 /* special deviceid for core pointer events */
  32 #define GDK_CORE_POINTER 0xfedc
  33
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif /* __cplusplus */
  38
  39
  40 /* Type definitions for the basic structures.
  41  */
  42
  43 typedef gulong                    GdkAtom;
  44 typedef struct _GdkColor          GdkColor;
  45 typedef struct _GdkColormap       GdkColormap;
  46 typedef struct _GdkVisual         GdkVisual;
  47 typedef struct _GdkWindowAttr     GdkWindowAttr;
  48 typedef struct _GdkWindow         GdkWindow;
  49 typedef struct _GdkWindow         GdkPixmap;
  50 typedef struct _GdkWindow         GdkBitmap;
  51 typedef struct _GdkWindow         GdkDrawable;
  52 typedef struct _GdkImage          GdkImage;
  53 typedef struct _GdkGCValues       GdkGCValues;
  54 typedef struct _GdkGC             GdkGC;
  55 typedef struct _GdkPoint          GdkPoint;
  56 typedef struct _GdkRectangle      GdkRectangle;
  57 typedef struct _GdkSegment        GdkSegment;
  58 typedef struct _GdkFont           GdkFont;
  59 typedef struct _GdkCursor         GdkCursor;
  60
  61 typedef struct _GdkEventAny       GdkEventAny;
  62 typedef struct _GdkEventExpose    GdkEventExpose;
  63 typedef struct _GdkEventMotion    GdkEventMotion;
  64 typedef struct _GdkEventButton    GdkEventButton;
  65 typedef struct _GdkEventKey       GdkEventKey;
  66 typedef struct _GdkEventFocus     GdkEventFocus;
  67 typedef struct _GdkEventCrossing  GdkEventCrossing;
  68 typedef struct _GdkEventConfigure GdkEventConfigure;
  69 typedef struct _GdkEventProperty  GdkEventProperty;
  70 typedef struct _GdkEventSelection GdkEventSelection;
  71 typedef struct _GdkEventProximity GdkEventProximity;
  72 typedef struct _GdkEventOther     GdkEventOther;
  73 typedef struct _GdkEventDragBegin GdkEventDragBegin;
  74 typedef struct _GdkEventDragRequest GdkEventDragRequest;
  75 typedef struct _GdkEventDropEnter GdkEventDropEnter;
  76 typedef struct _GdkEventDropDataAvailable GdkEventDropDataAvailable;
  77 typedef struct _GdkEventDropLeave GdkEventDropLeave;
  78 typedef struct _GdkEventClient    GdkEventClient;
  79 typedef union  _GdkEvent          GdkEvent;
  80 typedef struct _GdkDeviceInfo     GdkDeviceInfo;
  81 typedef struct _GdkTimeCoord      GdkTimeCoord;
  82 typedef gint (*GdkEventFunc) (GdkEvent *event,
  83                               gpointer  data);
  84 #ifdef USE_XIM
  85 typedef void*                     GdkIC;
  86 typedef void*                     GdkIM;
  87 #endif
  88
  89
  90 /* Types of windows.
  91  *   Root: There is only 1 root window and it is initialized
  92  *         at startup. Creating a window of type GDK_WINDOW_ROOT
  93  *         is an error.
  94  *   Toplevel: Windows which interact with the window manager.
  95  *   Child: Windows which are children of some other type of window.
  96  *          (Any other type of window). Most windows are child windows.
  97  *   Dialog: A special kind of toplevel window which interacts with
  98  *           the window manager slightly differently than a regular
  99  *           toplevel window. Dialog windows should be used for any
 100  *           transient window.
 101  *   Pixmap: Pixmaps are really just another kind of window which
 102  *           doesn't actually appear on the screen. It can't have
 103  *           children, either and is really just a convenience so
 104  *           that the drawing functions can work on both windows
 105  *           and pixmaps transparently. (ie. You shouldn't pass a
 106  *           pixmap to any procedure which accepts a window with the
 107  *           exception of the drawing functions).
 108  */
 109 typedef enum
 110 {
 111   GDK_WINDOW_ROOT,
 112   GDK_WINDOW_TOPLEVEL,
 113   GDK_WINDOW_CHILD,
 114   GDK_WINDOW_DIALOG,
 115   GDK_WINDOW_TEMP,
 116   GDK_WINDOW_PIXMAP
 117 } GdkWindowType;
 118
 119 /* Classes of windows.
 120  *   InputOutput: Almost every window should be of this type. Such windows
 121  *                receive events and are also displayed on screen.
 122  *   InputOnly: Used only in special circumstances when events need to be
 123  *              stolen from another window or windows. Input only windows
 124  *              have no visible output, so they are handy for placing over
 125  *              top of a group of windows in order to grab the events (or
 126  *              filter the events) from those windows.
 127  */
 128 typedef enum
 129 {
 130   GDK_INPUT_OUTPUT,
 131   GDK_INPUT_ONLY
 132 } GdkWindowClass;
 133
 134 /* Types of images.
 135  *   Normal: Normal X image type. These are slow as they involve passing
 136  *           the entire image through the X connection each time a draw
 137  *           request is required.
 138  *   Shared: Shared memory X image type. These are fast as the X server
 139  *           and the program actually use the same piece of memory. They
 140  *           should be used with care though as there is the possibility
 141  *           for both the X server and the program to be reading/writing
 142  *           the image simultaneously and producing undesired results.
 143  */
 144 typedef enum
 145 {
 146   GDK_IMAGE_NORMAL,
 147   GDK_IMAGE_SHARED,
 148   GDK_IMAGE_FASTEST
 149 } GdkImageType;
 150
 151 /* Types of visuals.
 152  *   StaticGray:
 153  *   Grayscale:
 154  *   StaticColor:
 155  *   PseudoColor:
 156  *   TrueColor:
 157  *   DirectColor:
 158  */
 159 typedef enum
 160 {
 161   GDK_VISUAL_STATIC_GRAY,
 162   GDK_VISUAL_GRAYSCALE,
 163   GDK_VISUAL_STATIC_COLOR,
 164   GDK_VISUAL_PSEUDO_COLOR,
 165   GDK_VISUAL_TRUE_COLOR,
 166   GDK_VISUAL_DIRECT_COLOR
 167 } GdkVisualType;
 168
 169 /* Types of font.
 170  *   GDK_FONT_FONT: the font is an XFontStruct.
 171  *   GDK_FONT_FONTSET: the font is an XFontSet used for I18N.
 172  */
 173 typedef enum
 174 {
 175   GDK_FONT_FONT,
 176   GDK_FONT_FONTSET
 177 } GdkFontType;
 178
 179 /* Window attribute mask values.
 180  *   GDK_WA_TITLE: The "title" field is valid.
 181  *   GDK_WA_X: The "x" field is valid.
 182  *   GDK_WA_Y: The "y" field is valid.
 183  *   GDK_WA_CURSOR: The "cursor" field is valid.
 184  *   GDK_WA_COLORMAP: The "colormap" field is valid.
 185  *   GDK_WA_VISUAL: The "visual" field is valid.
 186  */
 187 typedef enum
 188 {
 189   GDK_WA_TITLE    = 1 << 1,
 190   GDK_WA_X        = 1 << 2,
 191   GDK_WA_Y        = 1 << 3,
 192   GDK_WA_CURSOR   = 1 << 4,
 193   GDK_WA_COLORMAP = 1 << 5,
 194   GDK_WA_VISUAL   = 1 << 6,
 195   GDK_WA_WMCLASS  = 1 << 7
 196 } GdkWindowAttributesType;
 197
 198 /* Size restriction enumeration.
 199  */
 200 typedef enum
 201 {
 202   GDK_HINT_POS       = 1 << 0,
 203   GDK_HINT_MIN_SIZE  = 1 << 1,
 204   GDK_HINT_MAX_SIZE  = 1 << 2
 205 } GdkWindowHints;
 206
 207 /* GC function types.
 208  *   Copy: Overwrites destination pixels with the source pixels.
 209  *   Invert: Inverts the destination pixels.
 210  *   Xor: Xor's the destination pixels with the source pixels.
 211  */
 212 typedef enum
 213 {
 214   GDK_COPY,
 215   GDK_INVERT,
 216   GDK_XOR
 217 } GdkFunction;
 218
 219 /* GC fill types.
 220  *  Solid:
 221  *  Tiled:
 222  *  Stippled:
 223  *  OpaqueStippled:
 224  */
 225 typedef enum
 226 {
 227   GDK_SOLID,
 228   GDK_TILED,
 229   GDK_STIPPLED,
 230   GDK_OPAQUE_STIPPLED
 231 } GdkFill;
 232
 233 /* GC line styles
 234  *  Solid:
 235  *  OnOffDash:
 236  *  DoubleDash:
 237  */
 238 typedef enum
 239 {
 240   GDK_LINE_SOLID,
 241   GDK_LINE_ON_OFF_DASH,
 242   GDK_LINE_DOUBLE_DASH
 243 } GdkLineStyle;
 244
 245 /* GC cap styles
 246  *  CapNotLast:
 247  *  CapButt:
 248  *  CapRound:
 249  *  CapProjecting:
 250  */
 251 typedef enum
 252 {
 253   GDK_CAP_NOT_LAST,
 254   GDK_CAP_BUTT,
 255   GDK_CAP_ROUND,
 256   GDK_CAP_PROJECTING
 257 } GdkCapStyle;
 258
 259 /* GC join styles
 260  *  JoinMiter:
 261  *  JoinRound:
 262  *  JoinBevel:
 263  */
 264 typedef enum
 265 {
 266   GDK_JOIN_MITER,
 267   GDK_JOIN_ROUND,
 268   GDK_JOIN_BEVEL
 269 } GdkJoinStyle;
 270
 271 /* Cursor types.
 272  */
 273 typedef enum
 274 {
 275 #include <gdk/gdkcursors.h>
 276   GDK_LAST_CURSOR
 277 } GdkCursorType;
 278
 279 /* Event types.
 280  *   Nothing: No event occurred.
 281  *   Delete: A window delete event was sent by the window manager.
 282  *           The specified window should be deleted.
 283  *   Destroy: A window has been destroyed.
 284  *   Expose: Part of a window has been uncovered.
 285  *   MotionNotify: The mouse has moved.
 286  *   ButtonPress: A mouse button was pressed.
 287  *   ButtonRelease: A mouse button was release.
 288  *   KeyPress: A key was pressed.
 289  *   KeyRelease: A key was released.
 290  *   EnterNotify: A window was entered.
 291  *   LeaveNotify: A window was exited.
 292  *   FocusChange: The focus window has changed. (The focus window gets
 293  *                keyboard events).
 294  *   Resize: A window has been resized.
 295  *   Map: A window has been mapped. (It is now visible on the screen).
 296  *   Unmap: A window has been unmapped. (It is no longer visible on
 297  *          the screen).
 298  */
 299 typedef enum
 300 {
 301   GDK_NOTHING           = -1,
 302   GDK_DELETE            = 0,
 303   GDK_DESTROY           = 1,
 304   GDK_EXPOSE            = 2,
 305   GDK_MOTION_NOTIFY     = 3,
 306   GDK_BUTTON_PRESS      = 4,
 307   GDK_2BUTTON_PRESS     = 5,
 308   GDK_3BUTTON_PRESS     = 6,
 309   GDK_BUTTON_RELEASE    = 7,
 310   GDK_KEY_PRESS         = 8,
 311   GDK_KEY_RELEASE       = 9,
 312   GDK_ENTER_NOTIFY      = 10,
 313   GDK_LEAVE_NOTIFY      = 11,
 314   GDK_FOCUS_CHANGE      = 12,
 315   GDK_CONFIGURE         = 13,
 316   GDK_MAP               = 14,
 317   GDK_UNMAP             = 15,
 318   GDK_PROPERTY_NOTIFY   = 16,
 319   GDK_SELECTION_CLEAR   = 17,
 320   GDK_SELECTION_REQUEST = 18,
 321   GDK_SELECTION_NOTIFY  = 19,
 322   GDK_PROXIMITY_IN      = 20,
 323   GDK_PROXIMITY_OUT     = 21,
 324   GDK_DRAG_BEGIN        = 22,
 325   GDK_DRAG_REQUEST      = 23,
 326   GDK_DROP_ENTER        = 24,
 327   GDK_DROP_LEAVE        = 25,
 328   GDK_DROP_DATA_AVAIL   = 26,
 329   GDK_CLIENT_EVENT      = 27,
 330   GDK_OTHER_EVENT       = 9999
 331 } GdkEventType;
 332
 333 /* Event masks. (Used to select what types of events a window
 334  *  will receive).
 335  */
 336 typedef enum
 337 {
 338   GDK_EXPOSURE_MASK             = 1 << 1,
 339   GDK_POINTER_MOTION_MASK       = 1 << 2,
 340   GDK_POINTER_MOTION_HINT_MASK  = 1 << 3,
 341   GDK_BUTTON_MOTION_MASK        = 1 << 4,
 342   GDK_BUTTON1_MOTION_MASK       = 1 << 5,
 343   GDK_BUTTON2_MOTION_MASK       = 1 << 6,
 344   GDK_BUTTON3_MOTION_MASK       = 1 << 7,
 345   GDK_BUTTON_PRESS_MASK         = 1 << 8,
 346   GDK_BUTTON_RELEASE_MASK       = 1 << 9,
 347   GDK_KEY_PRESS_MASK            = 1 << 10,
 348   GDK_KEY_RELEASE_MASK          = 1 << 11,
 349   GDK_ENTER_NOTIFY_MASK         = 1 << 12,
 350   GDK_LEAVE_NOTIFY_MASK         = 1 << 13,
 351   GDK_FOCUS_CHANGE_MASK         = 1 << 14,
 352   GDK_STRUCTURE_MASK            = 1 << 15,
 353   GDK_PROPERTY_CHANGE_MASK      = 1 << 16,
 354   GDK_PROXIMITY_IN_MASK         = 1 << 17,
 355   GDK_PROXIMITY_OUT_MASK        = 1 << 18,
 356   GDK_ALL_EVENTS_MASK           = 0x07FFFF
 357 } GdkEventMask;
 358
 359 /* Types of enter/leave notifications.
 360  *   Ancestor:
 361  *   Virtual:
 362  *   Inferior:
 363  *   Nonlinear:
 364  *   NonlinearVirtual:
 365  *   Unknown: An unknown type of enter/leave event occurred.
 366  */
 367 typedef enum
 368 {
 369   GDK_NOTIFY_ANCESTOR           = 0,
 370   GDK_NOTIFY_VIRTUAL            = 1,
 371   GDK_NOTIFY_INFERIOR           = 2,
 372   GDK_NOTIFY_NONLINEAR          = 3,
 373   GDK_NOTIFY_NONLINEAR_VIRTUAL  = 4,
 374   GDK_NOTIFY_UNKNOWN            = 5
 375 } GdkNotifyType;
 376
 377 /* Types of modifiers.
 378  */
 379 typedef enum
 380 {
 381   GDK_SHIFT_MASK    = 1 << 0,
 382   GDK_LOCK_MASK     = 1 << 1,
 383   GDK_CONTROL_MASK  = 1 << 2,
 384   GDK_MOD1_MASK     = 1 << 3,
 385   GDK_MOD2_MASK     = 1 << 4,
 386   GDK_MOD3_MASK     = 1 << 5,
 387   GDK_MOD4_MASK     = 1 << 6,
 388   GDK_MOD5_MASK     = 1 << 7,
 389   GDK_BUTTON1_MASK  = 1 << 8,
 390   GDK_BUTTON2_MASK  = 1 << 9,
 391   GDK_BUTTON3_MASK  = 1 << 10,
 392   GDK_BUTTON4_MASK  = 1 << 11,
 393   GDK_BUTTON5_MASK  = 1 << 12
 394 } GdkModifierType;
 395
 396 typedef enum
 397 {
 398   GDK_CLIP_BY_CHILDREN  = 0,
 399   GDK_INCLUDE_INFERIORS = 1
 400 } GdkSubwindowMode;
 401
 402 typedef enum
 403 {
 404   GDK_INPUT_READ       = 1 << 0,
 405   GDK_INPUT_WRITE      = 1 << 1,
 406   GDK_INPUT_EXCEPTION  = 1 << 2
 407 } GdkInputCondition;
 408
 409 typedef enum
 410 {
 411   GDK_OK          = 0,
 412   GDK_ERROR       = -1,
 413   GDK_ERROR_PARAM = -2,
 414   GDK_ERROR_FILE  = -3,
 415   GDK_ERROR_MEM   = -4
 416 } GdkStatus;
 417
 418 typedef enum
 419 {
 420   GDK_LSB_FIRST,
 421   GDK_MSB_FIRST
 422 } GdkByteOrder;
 423
 424 typedef enum
 425 {
 426   GDK_GC_FOREGROUND    = 1 << 0,
 427   GDK_GC_BACKGROUND    = 1 << 1,
 428   GDK_GC_FONT          = 1 << 2,
 429   GDK_GC_FUNCTION      = 1 << 3,
 430   GDK_GC_FILL          = 1 << 4,
 431   GDK_GC_TILE          = 1 << 5,
 432   GDK_GC_STIPPLE       = 1 << 6,
 433   GDK_GC_CLIP_MASK     = 1 << 7,
 434   GDK_GC_SUBWINDOW     = 1 << 8,
 435   GDK_GC_TS_X_ORIGIN   = 1 << 9,
 436   GDK_GC_TS_Y_ORIGIN   = 1 << 10,
 437   GDK_GC_CLIP_X_ORIGIN = 1 << 11,
 438   GDK_GC_CLIP_Y_ORIGIN = 1 << 12,
 439   GDK_GC_EXPOSURES     = 1 << 13,
 440   GDK_GC_LINE_WIDTH    = 1 << 14,
 441   GDK_GC_LINE_STYLE    = 1 << 15,
 442   GDK_GC_CAP_STYLE     = 1 << 16,
 443   GDK_GC_JOIN_STYLE    = 1 << 17
 444 } GdkGCValuesMask;
 445
 446 typedef enum
 447 {
 448   GDK_SELECTION_PRIMARY = 1,
 449   GDK_SELECTION_SECONDARY = 2
 450 } GdkSelection;
 451
 452 typedef enum
 453 {
 454   GDK_PROPERTY_NEW_VALUE,
 455   GDK_PROPERTY_DELETE
 456 } GdkPropertyState;
 457
 458 typedef enum
 459 {
 460   GDK_PROP_MODE_REPLACE,
 461   GDK_PROP_MODE_PREPEND,
 462   GDK_PROP_MODE_APPEND
 463 } GdkPropMode;
 464
 465 /* These definitions are for version 1 of the OffiX D&D protocol,
 466    taken from <OffiX/DragAndDropTypes.h> */
 467 typedef enum
 468 {
 469   GDK_DNDTYPE_NOTDND = -1,
 470   GDK_DNDTYPE_UNKNOWN = 0,
 471   GDK_DNDTYPE_RAWDATA = 1,
 472   GDK_DNDTYPE_FILE = 2,
 473   GDK_DNDTYPE_FILES = 3,
 474   GDK_DNDTYPE_TEXT = 4,
 475   GDK_DNDTYPE_DIR = 5,
 476   GDK_DNDTYPE_LINK = 6,
 477   GDK_DNDTYPE_EXE = 7,
 478   GDK_DNDTYPE_URL = 8,
 479   GDK_DNDTYPE_MIME = 9,
 480   GDK_DNDTYPE_END = 10
 481 } GdkDndType;
 482
 483 /* Enums for XInput support */
 484
 485 typedef enum
 486 {
 487   GDK_SOURCE_MOUSE,
 488   GDK_SOURCE_PEN,
 489   GDK_SOURCE_ERASER,
 490   GDK_SOURCE_CURSOR
 491 } GdkInputSource;
 492
 493 typedef enum
 494 {
 495   GDK_MODE_DISABLED,
 496   GDK_MODE_SCREEN,
 497   GDK_MODE_WINDOW
 498 } GdkInputMode;
 499
 500 typedef enum
 501 {
 502   GDK_AXIS_IGNORE,
 503   GDK_AXIS_X,
 504   GDK_AXIS_Y,
 505   GDK_AXIS_PRESSURE,
 506   GDK_AXIS_XTILT,
 507   GDK_AXIS_YTILT,
 508   GDK_AXIS_LAST
 509 } GdkAxisUse;
 510
 511 /* The next two types define enums for predefined atoms relating
 512    to selections. In general, one will need to use gdk_intern_atom */
 513
 514 typedef enum
 515 {
 516   GDK_TARGET_BITMAP = 5,
 517   GDK_TARGET_COLORMAP = 7,
 518   GDK_TARGET_DRAWABLE = 17,
 519   GDK_TARGET_PIXMAP = 20,
 520   GDK_TARGET_STRING = 31
 521 } GdkTarget;
 522
 523 typedef enum
 524 {
 525   GDK_SELECTION_TYPE_ATOM = 4,
 526   GDK_SELECTION_TYPE_BITMAP = 5,
 527   GDK_SELECTION_TYPE_COLORMAP = 7,
 528   GDK_SELECTION_TYPE_DRAWABLE = 17,
 529   GDK_SELECTION_TYPE_INTEGER = 19,
 530   GDK_SELECTION_TYPE_PIXMAP = 20,
 531   GDK_SELECTION_TYPE_WINDOW = 33,
 532   GDK_SELECTION_TYPE_STRING = 31
 533 } GdkSelectionType;
 534
 535 typedef enum
 536 {
 537   GDK_EXTENSION_EVENTS_NONE,
 538   GDK_EXTENSION_EVENTS_ALL,
 539   GDK_EXTENSION_EVENTS_CURSOR
 540 } GdkExtensionMode;
 541
 542 #ifdef USE_XIM
 543 /*
 544 */
 545
 546 typedef enum
 547 {
 548   GdkIMPreeditArea      = 0x0001L,
 549   GdkIMPreeditCallbacks = 0x0002L,
 550   GdkIMPreeditPosition  = 0x0004L,
 551   GdkIMPreeditNothing   = 0x0008L,
 552   GdkIMPreeditNone      = 0x0010L,
 553   GdkIMStatusArea       = 0x0100L,
 554   GdkIMStatusCallbacks  = 0x0200L,
 555   GdkIMStatusNothing    = 0x0400L,
 556   GdkIMStatusNone       = 0x0800L
 557 } GdkIMStyle;
 558
 559 #define GdkIMPreeditMask \
 560         ( GdkIMPreeditArea     | GdkIMPreeditCallbacks | \
 561           GdkIMPreeditPosition | GdkIMPreeditNothing | \
 562           GdkIMPreeditNone )
 563
 564 #define GdkIMStatusMask \
 565         ( GdkIMStatusArea | GdkIMStatusCallbacks | \
 566           GdkIMStatusNothing | GdkIMStatusNone )
 567
 568 #endif
 569
 570 typedef void (*GdkInputFunction) (gpointer          data,
 571                                   gint              source,
 572                                   GdkInputCondition condition);
 573
 574 /* The color type.
 575  *   A color consists of red, green and blue values in the
 576  *    range 0-65535 and a pixel value. The pixel value is highly
 577  *    dependent on the depth and colormap which this color will
 578  *    be used to draw into. Therefore, sharing colors between
 579  *    colormaps is a bad idea.
 580  */
 581 struct _GdkColor
 582 {
 583   gulong  pixel;
 584   gushort red;
 585   gushort green;
 586   gushort blue;
 587 };
 588
 589 /* The colormap type.
 590  *   Colormaps consist of 256 colors.
 591  */
 592 struct _GdkColormap
 593 {
 594   GdkColor colors[256];
 595 };
 596
 597 /* The visual type.
 598  *   "type" is the type of visual this is (PseudoColor, TrueColor, etc).
 599  *   "depth" is the bit depth of this visual.
 600  *   "colormap_size" is the size of a colormap for this visual.
 601  *   "bits_per_rgb" is the number of significant bits per red, green and blue.
 602  *  The red, green and blue masks, shifts and precisions refer
 603  *   to value needed to calculate pixel values in TrueColor and DirectColor
 604  *   visuals. The "mask" is the significant bits within the pixel. The
 605  *   "shift" is the number of bits left we must shift a primary for it
 606  *   to be in position (according to the "mask"). "prec" refers to how
 607  *   much precision the pixel value contains for a particular primary.
 608  */
 609 struct _GdkVisual
 610 {
 611   GdkVisualType type;
 612   gint depth;
 613   GdkByteOrder byte_order;
 614   gint colormap_size;
 615   gint bits_per_rgb;
 616
 617   guint32 red_mask;
 618   gint red_shift;
 619   gint red_prec;
 620
 621   guint32 green_mask;
 622   gint green_shift;
 623   gint green_prec;
 624
 625   guint32 blue_mask;
 626   gint blue_shift;
 627   gint blue_prec;
 628 };
 629
 630 struct _GdkWindowAttr
 631 {
 632   gchar *title;
 633   gint event_mask;
 634   gint16 x, y;
 635   gint16 width;
 636   gint16 height;
 637   GdkWindowClass wclass;
 638   GdkVisual *visual;
 639   GdkColormap *colormap;
 640   GdkWindowType window_type;
 641   GdkCursor *cursor;
 642   gchar *wmclass_name;
 643   gchar *wmclass_class;
 644 };
 645
 646 struct _GdkWindow
 647 {
 648   gpointer user_data;
 649 };
 650
 651 struct _GdkImage
 652 {
 653   GdkImageType  type;
 654   GdkVisual    *visual;     /* visual used to create the image */
 655   GdkByteOrder  byte_order;
 656   guint16       width;
 657   guint16       height;
 658   guint16       depth;
 659   guint16       bpp;        /* bytes per pixel */
 660   guint16       bpl;        /* bytes per line */
 661   gpointer      mem;
 662 };
 663
 664 struct _GdkGCValues
 665 {
 666   GdkColor          foreground;
 667   GdkColor          background;
 668   GdkFont          *font;
 669   GdkFunction       function;
 670   GdkFill           fill;
 671   GdkPixmap        *tile;
 672   GdkPixmap        *stipple;
 673   GdkPixmap        *clip_mask;
 674   GdkSubwindowMode  subwindow_mode;
 675   gint              ts_x_origin;
 676   gint              ts_y_origin;
 677   gint              clip_x_origin;
 678   gint              clip_y_origin;
 679   gint              graphics_exposures;
 680   gint              line_width;
 681   GdkLineStyle      line_style;
 682   GdkCapStyle       cap_style;
 683   GdkJoinStyle      join_style;
 684 };
 685
 686 struct _GdkGC
 687 {
 688   gint dummy_var;
 689 };
 690
 691 struct _GdkPoint
 692 {
 693   gint16 x;
 694   gint16 y;
 695 };
 696
 697 struct _GdkRectangle
 698 {
 699   gint16 x;
 700   gint16 y;
 701   guint16 width;
 702   guint16 height;
 703 };
 704
 705 struct _GdkSegment
 706 {
 707   gint16 x1;
 708   gint16 y1;
 709   gint16 x2;
 710   gint16 y2;
 711 };
 712
 713 struct _GdkFont
 714 {
 715   GdkFontType type;
 716   gint ascent;
 717   gint descent;
 718 };
 719
 720 struct _GdkCursor
 721 {
 722   GdkCursorType type;
 723 };
 724
 725 /* Types for XInput support */
 726
 727 struct _GdkDeviceInfo
 728 {
 729   guint32 deviceid;
 730   gchar *name;
 731   GdkInputSource source;
 732   GdkInputMode mode;
 733   gint has_cursor;      /* TRUE if the X pointer follows device motion */
 734   gint num_axes;
 735   GdkAxisUse *axes;    /* Specifies use for each axis */
 736 };
 737
 738 struct _GdkTimeCoord
 739 {
 740   guint32 time;
 741   gdouble x;
 742   gdouble y;
 743   gdouble pressure;
 744   gdouble xtilt;
 745   gdouble ytilt;
 746 };
 747
 748 struct _GdkEventAny
 749 {
 750   GdkEventType type;
 751   GdkWindow *window;
 752   gint8 send_event;
 753 };
 754
 755 struct _GdkEventExpose
 756 {
 757   GdkEventType type;
 758   GdkWindow *window;
 759   GdkRectangle area;
 760   gint count; /* If non-zero, how many more events follow. */
 761 };
 762
 763 struct _GdkEventMotion
 764 {
 765   GdkEventType type;
 766   GdkWindow *window;
 767   guint32 time;
 768   gdouble x;
 769   gdouble y;
 770   gdouble pressure;
 771   gdouble xtilt;
 772   gdouble ytilt;
 773   guint state;
 774   gint16 is_hint;
 775   GdkInputSource source;
 776   guint32 deviceid;
 777 };
 778
 779 struct _GdkEventButton
 780 {
 781   GdkEventType type;
 782   GdkWindow *window;
 783   guint32 time;
 784   gdouble x;
 785   gdouble y;
 786   gdouble pressure;
 787   gdouble xtilt;
 788   gdouble ytilt;
 789   guint state;
 790   guint button;
 791   GdkInputSource source;
 792   guint32 deviceid;
 793 };
 794
 795 struct _GdkEventKey
 796 {
 797   GdkEventType type;
 798   GdkWindow *window;
 799   guint32 time;
 800   guint state;
 801   guint keyval;
 802   gint length;
 803   gchar *string;
 804 };
 805
 806 struct _GdkEventCrossing
 807 {
 808   GdkEventType type;
 809   GdkWindow *window;
 810   GdkWindow *subwindow;
 811   GdkNotifyType detail;
 812 };
 813
 814 struct _GdkEventFocus
 815 {
 816   GdkEventType type;
 817   GdkWindow *window;
 818   gint16 in;
 819 };
 820
 821 struct _GdkEventConfigure
 822 {
 823   GdkEventType type;
 824   GdkWindow *window;
 825   gint16 x, y;
 826   gint16 width;
 827   gint16 height;
 828 };
 829
 830 struct _GdkEventProperty
 831 {
 832   GdkEventType type;
 833   GdkWindow *window;
 834   GdkAtom atom;
 835   guint32 time;
 836   guint state;
 837 };
 838
 839 struct _GdkEventSelection
 840 {
 841   GdkEventType type;
 842   GdkWindow *window;
 843   GdkAtom selection;
 844   GdkAtom target;
 845   GdkAtom property;
 846   guint32 requestor;
 847   guint32 time;
 848 };
 849
 850 /* This event type will be used pretty rarely. It only is important
 851    for XInput aware programs that are drawing their own cursor */
 852
 853 struct _GdkEventProximity
 854 {
 855   GdkEventType type;
 856   GdkWindow *window;
 857   guint32 time;
 858   GdkInputSource source;
 859   guint32 deviceid;
 860 };
 861
 862 struct _GdkEventDragRequest
 863 {
 864   GdkEventType type;
 865   GdkWindow *window;
 866   guint32 requestor;
 867   union {
 868     struct {
 869       guint protocol_version:4;
 870       guint sendreply:1;
 871       guint willaccept:1;
 872       guint delete_data:1; /* Do *not* delete if link is sent, only
 873                               if data is sent */
 874       guint senddata:1;
 875       guint reserved:22;
 876     } flags;
 877     glong allflags;
 878   } u;
 879   guint8 isdrop; /* This gdk event can be generated by a couple of
 880                     X events - this lets the app know whether the
 881                     drop really occurred or we just set the data */
 882
 883   GdkPoint drop_coords;
 884   gchar *data_type;
 885 };
 886
 887 struct _GdkEventDragBegin
 888 {
 889   GdkEventType type;
 890   GdkWindow *window;
 891   union {
 892     struct {
 893       guint protocol_version:4;
 894       guint reserved:28;
 895     } flags;
 896     glong allflags;
 897   } u;
 898 };
 899
 900 struct _GdkEventDropEnter
 901 {
 902   GdkEventType type;
 903   GdkWindow *window;
 904   guint32 requestor;
 905   union {
 906     struct {
 907       guint protocol_version:4;
 908       guint sendreply:1;
 909       guint extended_typelist:1;
 910       guint reserved:26;
 911     } flags;
 912     glong allflags;
 913   } u;
 914 };
 915
 916 struct _GdkEventDropLeave
 917 {
 918   GdkEventType type;
 919   GdkWindow *window;
 920   guint32 requestor;
 921   union {
 922     struct {
 923       guint protocol_version:4;
 924       guint reserved:28;
 925     } flags;
 926     glong allflags;
 927   } u;
 928 };
 929
 930 struct _GdkEventDropDataAvailable
 931 {
 932   GdkEventType type;
 933   GdkWindow *window;
 934   guint32 requestor;
 935   union {
 936     struct {
 937       guint protocol_version:4;
 938       guint isdrop:1;
 939       guint reserved:25;
 940     } flags;
 941     glong allflags;
 942   } u;
 943   gchar *data_type; /* MIME type */
 944   gulong data_numbytes;
 945   gpointer data;
 946 };
 947
 948 struct _GdkEventClient
 949 {
 950   GdkEventType type;
 951   GdkWindow *window;
 952   GdkAtom message_type;
 953   gushort data_format;
 954   union {
 955     char b[20];
 956     short s[10];
 957     long l[5];
 958   } data;
 959 };
 960
 961 typedef void GdkXEvent;   /* Can be cast to XEvent */
 962
 963 struct _GdkEventOther
 964 {
 965   GdkEventType type;
 966   GdkWindow *window;
 967   GdkXEvent *xevent;
 968 };
 969
 970 union _GdkEvent
 971 {
 972   GdkEventType      type;
 973   GdkEventAny       any;
 974   GdkEventExpose    expose;
 975   GdkEventMotion    motion;
 976   GdkEventButton    button;
 977   GdkEventKey       key;
 978   GdkEventCrossing  crossing;
 979   GdkEventFocus     focus_change;
 980   GdkEventConfigure configure;
 981   GdkEventProperty  property;
 982   GdkEventSelection selection;
 983   GdkEventProximity proximity;
 984   GdkEventDragBegin dragbegin;
 985   GdkEventDragRequest dragrequest;
 986   GdkEventDropEnter dropenter;
 987   GdkEventDropLeave dropleave;
 988   GdkEventDropDataAvailable dropdataavailable;
 989   GdkEventClient    client;
 990   GdkEventOther     other;
 991 };
 992
 993
 994 #ifdef __cplusplus
 995 }
 996 #endif /* __cplusplus */
 997
 998
 999 #endif /* __GDK_TYPES_H__ */