src/glut/glx/glutint.h

   1 #ifndef __glutint_h__
   2 #define __glutint_h__
   3
   4 /* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
   5
   6 /* This program is freely distributable without licensing fees
   7    and is provided without guarantee or warrantee expressed or
   8    implied. This program is -not- in the public domain. */
   9
  10 #ifdef __VMS
  11 #include <GL/vms_x_fix.h>
  12 #endif
  13
  14 #if defined(__CYGWIN32__)
  15 #include <sys/time.h>
  16 #endif
  17
  18 #define SUPPORT_FORTRAN  /* With GLUT 3.7, everyone supports Fortran. */
  19
  20 #if defined(_WIN32)
  21 #include "glutwin32.h"
  22 #else
  23 #include <X11/Xlib.h>
  24 #include <X11/Xutil.h>
  25 #define GLX_GLXEXT_PROTOTYPES
  26 #include <GL/glx.h>
  27 #endif
  28
  29 #ifndef GLUT_BUILDING_LIB
  30 #define GLUT_BUILDING_LIB  /* Building the GLUT library itself. */
  31 #endif
  32
  33 #include <GL/glut.h>
  34
  35 #ifndef _WIN32
  36 /* added by BrianP: */
  37 #ifndef APIENTRY
  38 #define APIENTRY GLAPIENTRY
  39 #endif
  40 #define __cdecl GLAPIENTRY
  41 #define CDECL GLAPIENTRY
  42 #endif
  43
  44 /* GLUT_BUILDING_LIB is used by <GL/glut.h> to 1) not #pragma link
  45    with the GLUT library, and 2) avoid the Win32 atexit hack. */
  46
  47 #ifdef SUPPORT_FORTRAN
  48 #include <GL/glutf90.h>
  49 #endif
  50
  51 #ifdef __vms
  52 #if ( __VMS_VER < 70000000 )
  53 #define OLD_VMS
  54 struct timeval6 {
  55   __int64 val;
  56 };
  57 extern int sys$gettim(struct timeval6 *);
  58 #else
  59 #include <time.h>
  60 #endif
  61 #else
  62 #include <sys/types.h>
  63 #if !defined(_WIN32) || defined(__CYGWIN32__)
  64 #include <sys/time.h>
  65 #else
  66 #include <winsock.h>
  67 #endif
  68 #endif
  69 #if defined(__vms) && ( __VMS_VER < 70000000 )
  70
  71 /* For VMS6.2 or lower :
  72    One TICK on VMS is 100 nanoseconds; 0.1 microseconds or
  73    0.0001 milliseconds. This means that there are 0.01
  74    ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000
  75    ticks/second. */
  76
  77 #define TICKS_PER_MILLISECOND 10000
  78 #define TICKS_PER_SECOND      10000000
  79
  80 #define GETTIMEOFDAY(_x) (void) sys$gettim (_x);
  81
  82 #define ADD_TIME(dest, src1, src2) { \
  83   (dest).val = (src1).val + (src2).val; \
  84 }
  85
  86 #define TIMEDELTA(dest, src1, src2) { \
  87   (dest).val = (src1).val - (src2).val; \
  88 }
  89
  90 #define IS_AFTER(t1, t2) ((t2).val > (t1).val)
  91
  92 #define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val)
  93
  94 #else
  95 #if defined(SVR4) && !defined(sun)  /* Sun claims SVR4, but
  96                                        wants 2 args. */
  97 #define GETTIMEOFDAY(_x) gettimeofday(_x)
  98 #else
  99 #define GETTIMEOFDAY(_x) gettimeofday(_x, NULL)
 100 #endif
 101 #define ADD_TIME(dest, src1, src2) { \
 102   if(((dest).tv_usec = \
 103     (src1).tv_usec + (src2).tv_usec) >= 1000000) { \
 104     (dest).tv_usec -= 1000000; \
 105     (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; \
 106   } else { \
 107     (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \
 108     if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
 109       (dest).tv_sec --;(dest).tv_usec += 1000000; \
 110     } \
 111   } \
 112 }
 113 #define TIMEDELTA(dest, src1, src2) { \
 114   if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { \
 115     (dest).tv_usec += 1000000; \
 116     (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; \
 117   } else { \
 118      (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \
 119   } \
 120 }
 121 #define IS_AFTER(t1, t2) \
 122   (((t2).tv_sec > (t1).tv_sec) || \
 123   (((t2).tv_sec == (t1).tv_sec) && \
 124   ((t2).tv_usec > (t1).tv_usec)))
 125 #define IS_AT_OR_AFTER(t1, t2) \
 126   (((t2).tv_sec > (t1).tv_sec) || \
 127   (((t2).tv_sec == (t1).tv_sec) && \
 128   ((t2).tv_usec >= (t1).tv_usec)))
 129 #endif
 130
 131 #define IGNORE_IN_GAME_MODE() \
 132   { if (__glutGameModeWindow) return; }
 133
 134 #define GLUT_WIND_IS_RGB(x)         (((x) & GLUT_INDEX) == 0)
 135 #define GLUT_WIND_IS_INDEX(x)       (((x) & GLUT_INDEX) != 0)
 136 #define GLUT_WIND_IS_SINGLE(x)      (((x) & GLUT_DOUBLE) == 0)
 137 #define GLUT_WIND_IS_DOUBLE(x)      (((x) & GLUT_DOUBLE) != 0)
 138 #define GLUT_WIND_HAS_ACCUM(x)      (((x) & GLUT_ACCUM) != 0)
 139 #define GLUT_WIND_HAS_ALPHA(x)      (((x) & GLUT_ALPHA) != 0)
 140 #define GLUT_WIND_HAS_DEPTH(x)      (((x) & GLUT_DEPTH) != 0)
 141 #define GLUT_WIND_HAS_STENCIL(x)    (((x) & GLUT_STENCIL) != 0)
 142 #define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0)
 143 #define GLUT_WIND_IS_STEREO(x)      (((x) & GLUT_STEREO) != 0)
 144 #define GLUT_WIND_IS_LUMINANCE(x)   (((x) & GLUT_LUMINANCE) != 0)
 145 #define GLUT_MAP_WORK               (1 << 0)
 146 #define GLUT_EVENT_MASK_WORK        (1 << 1)
 147 #define GLUT_REDISPLAY_WORK         (1 << 2)
 148 #define GLUT_CONFIGURE_WORK         (1 << 3)
 149 #define GLUT_COLORMAP_WORK          (1 << 4)
 150 #define GLUT_DEVICE_MASK_WORK       (1 << 5)
 151 #define GLUT_FINISH_WORK            (1 << 6)
 152 #define GLUT_DEBUG_WORK             (1 << 7)
 153 #define GLUT_DUMMY_WORK             (1 << 8)
 154 #define GLUT_FULL_SCREEN_WORK       (1 << 9)
 155 #define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10)
 156 #define GLUT_REPAIR_WORK            (1 << 11)
 157 #define GLUT_OVERLAY_REPAIR_WORK    (1 << 12)
 158
 159 /* Frame buffer capability macros and types. */
 160 #define RGBA                    0
 161 #define BUFFER_SIZE             1
 162 #define DOUBLEBUFFER            2
 163 #define STEREO                  3
 164 #define AUX_BUFFERS             4
 165 #define RED_SIZE                5  /* Used as mask bit for
 166                                       "color selected". */
 167 #define GREEN_SIZE              6
 168 #define BLUE_SIZE               7
 169 #define ALPHA_SIZE              8
 170 #define DEPTH_SIZE              9
 171 #define STENCIL_SIZE            10
 172 #define ACCUM_RED_SIZE          11  /* Used as mask bit for
 173                                        "acc selected". */
 174 #define ACCUM_GREEN_SIZE        12
 175 #define ACCUM_BLUE_SIZE         13
 176 #define ACCUM_ALPHA_SIZE        14
 177 #define LEVEL                   15
 178
 179 #define NUM_GLXCAPS             (LEVEL + 1)
 180
 181 #define XVISUAL                 (NUM_GLXCAPS + 0)
 182 #define TRANSPARENT             (NUM_GLXCAPS + 1)
 183 #define SAMPLES                 (NUM_GLXCAPS + 2)
 184 #define XSTATICGRAY             (NUM_GLXCAPS + 3)  /* Used as
 185                                                       mask bit
 186                                                       for "any
 187                                                       visual type
 188                                                       selected". */
 189 #define XGRAYSCALE              (NUM_GLXCAPS + 4)
 190 #define XSTATICCOLOR            (NUM_GLXCAPS + 5)
 191 #define XPSEUDOCOLOR            (NUM_GLXCAPS + 6)
 192 #define XTRUECOLOR              (NUM_GLXCAPS + 7)
 193 #define XDIRECTCOLOR            (NUM_GLXCAPS + 8)
 194 #define SLOW                    (NUM_GLXCAPS + 9)
 195 #define CONFORMANT              (NUM_GLXCAPS + 10)
 196
 197 #define NUM_CAPS                (NUM_GLXCAPS + 11)
 198
 199 /* Frame buffer capablities that don't have a corresponding
 200    FrameBufferMode entry.  These get used as mask bits. */
 201 #define NUM                     (NUM_CAPS + 0)
 202 #define RGBA_MODE               (NUM_CAPS + 1)
 203 #define CI_MODE                 (NUM_CAPS + 2)
 204 #define LUMINANCE_MODE          (NUM_CAPS + 3)
 205
 206 #define NONE                    0
 207 #define EQ                      1
 208 #define NEQ                     2
 209 #define LTE                     3
 210 #define GTE                     4
 211 #define GT                      5
 212 #define LT                      6
 213 #define MIN                     7
 214
 215 typedef struct _Criterion {
 216   int capability;
 217   int comparison;
 218   int value;
 219 } Criterion;
 220
 221 typedef struct _FrameBufferMode {
 222   XVisualInfo *vi;
 223 #if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
 224
 225   /* fbc is non-NULL when the XVisualInfo* is not OpenGL-capable
 226      (ie, GLX_USE_GL is false), but the SGIX_fbconfig extension shows
 227      the visual's fbconfig is OpenGL-capable.  The reason for this is typically
 228      an RGBA luminance fbconfig such as 16-bit StaticGray that could
 229      not be advertised as a GLX visual since StaticGray visuals are
 230      required (by the GLX specification) to be color index.  The
 231      SGIX_fbconfig allows StaticGray visuals to instead advertised as
 232      fbconfigs that can provide RGBA luminance support. */
 233
 234   GLXFBConfigSGIX fbc;
 235 #endif
 236   int valid;
 237   int cap[NUM_CAPS];
 238 } FrameBufferMode;
 239
 240 /* DisplayMode capability macros for game mode. */
 241 #define DM_WIDTH        0  /* "width" */
 242 #define DM_HEIGHT       1  /* "height" */
 243 #define DM_PIXEL_DEPTH  2  /* "bpp" (bits per pixel) */
 244 #define DM_HERTZ        3  /* "hertz" */
 245 #define DM_NUM          4  /* "num" */
 246
 247 #define NUM_DM_CAPS     (DM_NUM+1)
 248
 249 typedef struct _DisplayMode {
 250 #ifdef _WIN32
 251   DEVMODE devmode;
 252 #else
 253   /* XXX The X Window System does not have a standard
 254      mechanism for display setting changes.  On SGI
 255      systems, GLUT could use the XSGIvc (SGI X video
 256      control extension).  Perhaps this can be done in
 257      a future release of GLUT. */
 258 #endif
 259   int valid;
 260   int cap[NUM_DM_CAPS];
 261 } DisplayMode;
 262
 263 /* GLUT  function types */
 264 typedef void (GLUTCALLBACK *GLUTdisplayCB) (void);
 265 typedef void (GLUTCALLBACK *GLUTreshapeCB) (int, int);
 266 typedef void (GLUTCALLBACK *GLUTkeyboardCB) (unsigned char, int, int);
 267 typedef void (GLUTCALLBACK *GLUTmouseCB) (int, int, int, int);
 268 typedef void (GLUTCALLBACK *GLUTmotionCB) (int, int);
 269 typedef void (GLUTCALLBACK *GLUTpassiveCB) (int, int);
 270 typedef void (GLUTCALLBACK *GLUTentryCB) (int);
 271 typedef void (GLUTCALLBACK *GLUTvisibilityCB) (int);
 272 typedef void (GLUTCALLBACK *GLUTwindowStatusCB) (int);
 273 typedef void (GLUTCALLBACK *GLUTidleCB) (void);
 274 typedef void (GLUTCALLBACK *GLUTtimerCB) (int);
 275 typedef void (GLUTCALLBACK *GLUTmenuStateCB) (int);  /* DEPRICATED. */
 276 typedef void (GLUTCALLBACK *GLUTmenuStatusCB) (int, int, int);
 277 typedef void (GLUTCALLBACK *GLUTselectCB) (int);
 278 typedef void (GLUTCALLBACK *GLUTspecialCB) (int, int, int);
 279 typedef void (GLUTCALLBACK *GLUTspaceMotionCB) (int, int, int);
 280 typedef void (GLUTCALLBACK *GLUTspaceRotateCB) (int, int, int);
 281 typedef void (GLUTCALLBACK *GLUTspaceButtonCB) (int, int);
 282 typedef void (GLUTCALLBACK *GLUTdialsCB) (int, int);
 283 typedef void (GLUTCALLBACK *GLUTbuttonBoxCB) (int, int);
 284 typedef void (GLUTCALLBACK *GLUTtabletMotionCB) (int, int);
 285 typedef void (GLUTCALLBACK *GLUTtabletButtonCB) (int, int, int, int);
 286 typedef void (GLUTCALLBACK *GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z);
 287
 288 typedef struct _GLUTcolorcell GLUTcolorcell;
 289 struct _GLUTcolorcell {
 290   /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */
 291   GLfloat component[3];
 292 };
 293
 294 typedef struct _GLUTcolormap GLUTcolormap;
 295 struct _GLUTcolormap {
 296   Visual *visual;       /* visual of the colormap */
 297   Colormap cmap;        /* X colormap ID */
 298   int refcnt;           /* number of windows using colormap */
 299   int size;             /* number of cells in colormap */
 300   int transparent;      /* transparent pixel, or -1 if opaque */
 301   GLUTcolorcell *cells; /* array of cells */
 302   GLUTcolormap *next;   /* next colormap in list */
 303 };
 304
 305 typedef struct _GLUTwindow GLUTwindow;
 306 typedef struct _GLUToverlay GLUToverlay;
 307 struct _GLUTwindow {
 308   int num;              /* Small integer window id (0-based). */
 309
 310   /* Window system related state. */
 311 #if defined(_WIN32)
 312   int pf;               /* Pixel format. */
 313   HDC hdc;              /* Window's Win32 device context. */
 314 #endif
 315   Window win;           /* X window for GLUT window */
 316   GLXContext ctx;       /* OpenGL context GLUT glut window */
 317   XVisualInfo *vis;     /* visual for window */
 318   Bool visAlloced;      /* if vis needs deallocate on destroy */
 319   Colormap cmap;        /* RGB colormap for window; None if CI */
 320   GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
 321   GLUToverlay *overlay; /* overlay; NULL if no overlay */
 322 #if defined(_WIN32)
 323   HDC renderDc;         /* Win32's device context for rendering. */
 324 #endif
 325   Window renderWin;     /* X window for rendering (might be
 326                            overlay) */
 327   GLXContext renderCtx; /* OpenGL context for rendering (might
 328                            be overlay) */
 329   /* GLUT settable or visible window state. */
 330   int width;            /* window width in pixels */
 331   int height;           /* window height in pixels */
 332   int cursor;           /* cursor name */
 333   int visState;         /* visibility state (-1 is unknown) */
 334   int shownState;       /* if window mapped */
 335   int entryState;       /* entry state (-1 is unknown) */
 336 #define GLUT_MAX_MENUS              3
 337
 338   int menu[GLUT_MAX_MENUS];  /* attatched menu nums */
 339   /* Window relationship state. */
 340   GLUTwindow *parent;   /* parent window */
 341   GLUTwindow *children; /* list of children */
 342   GLUTwindow *siblings; /* list of siblings */
 343   /* Misc. non-API visible (hidden) state. */
 344   Bool treatAsSingle;   /* treat this window as single-buffered
 345                            (it might be "fake" though) */
 346   Bool forceReshape;    /* force reshape before display */
 347 #if !defined(_WIN32)
 348   Bool isDirect;        /* if direct context (X11 only) */
 349 #endif
 350   Bool usedSwapBuffers; /* if swap buffers used last display */
 351   long eventMask;       /* mask of X events selected for */
 352   int buttonUses;       /* number of button uses, ref cnt */
 353   int tabletPos[2];     /* tablet position (-1 is invalid) */
 354   /* Work list related state. */
 355   unsigned int workMask;  /* mask of window work to be done */
 356   GLUTwindow *prevWorkWin;  /* link list of windows to work on */
 357   Bool desiredMapState; /* how to mapped window if on map work
 358                            list */
 359   Bool ignoreKeyRepeat;  /* if window ignores autorepeat */
 360   int desiredConfMask;  /* mask of desired window configuration
 361                          */
 362   int desiredX;         /* desired X location */
 363   int desiredY;         /* desired Y location */
 364   int desiredWidth;     /* desired window width */
 365   int desiredHeight;    /* desired window height */
 366   int desiredStack;     /* desired window stack */
 367   /* Per-window callbacks. */
 368   GLUTdisplayCB display;  /* redraw */
 369   GLUTreshapeCB reshape;  /* resize (width,height) */
 370   GLUTmouseCB mouse;    /* mouse (button,state,x,y) */
 371   GLUTmotionCB motion;  /* motion (x,y) */
 372   GLUTpassiveCB passive;  /* passive motion (x,y) */
 373   GLUTentryCB entry;    /* window entry/exit (state) */
 374   GLUTkeyboardCB keyboard;  /* keyboard (ASCII,x,y) */
 375   GLUTkeyboardCB keyboardUp;  /* keyboard up (ASCII,x,y) */
 376   GLUTwindowStatusCB windowStatus;  /* window status */
 377   GLUTvisibilityCB visibility;  /* visibility */
 378   GLUTspecialCB special;  /* special key */
 379   GLUTspecialCB specialUp;  /* special up key */
 380   GLUTbuttonBoxCB buttonBox;  /* button box */
 381   GLUTdialsCB dials;    /* dials */
 382   GLUTspaceMotionCB spaceMotion;  /* Spaceball motion */
 383   GLUTspaceRotateCB spaceRotate;  /* Spaceball rotate */
 384   GLUTspaceButtonCB spaceButton;  /* Spaceball button */
 385   GLUTtabletMotionCB tabletMotion;  /* tablet motion */
 386   GLUTtabletButtonCB tabletButton;  /* tablet button */
 387 #ifdef _WIN32
 388   GLUTjoystickCB joystick;  /* joystick */
 389   int joyPollInterval; /* joystick polling interval */
 390 #endif
 391 #ifdef SUPPORT_FORTRAN
 392   GLUTdisplayFCB fdisplay;  /* Fortran display  */
 393   GLUTreshapeFCB freshape;  /* Fortran reshape  */
 394   GLUTmouseFCB fmouse;  /* Fortran mouse  */
 395   GLUTmotionFCB fmotion;  /* Fortran motion  */
 396   GLUTpassiveFCB fpassive;  /* Fortran passive  */
 397   GLUTentryFCB fentry;  /* Fortran entry  */
 398   GLUTkeyboardFCB fkeyboard;  /* Fortran keyboard  */
 399   GLUTkeyboardFCB fkeyboardUp;  /* Fortran keyboard up */
 400   GLUTwindowStatusFCB fwindowStatus;  /* Fortran window status */
 401   GLUTvisibilityFCB fvisibility;  /* Fortran visibility */
 402   GLUTspecialFCB fspecial;  /* special key */
 403   GLUTspecialFCB fspecialUp;  /* special key up */
 404   GLUTbuttonBoxFCB fbuttonBox;  /* button box */
 405   GLUTdialsFCB fdials;  /* dials */
 406   GLUTspaceMotionFCB fspaceMotion;  /* Spaceball motion */
 407   GLUTspaceRotateFCB fspaceRotate;  /* Spaceball rotate */
 408   GLUTspaceButtonFCB fspaceButton;  /* Spaceball button */
 409   GLUTtabletMotionFCB ftabletMotion;  /* tablet motion */
 410   GLUTtabletButtonFCB ftabletButton;  /* tablet button */
 411 #ifdef _WIN32
 412   GLUTjoystickFCB fjoystick;  /* joystick */
 413 #endif
 414 #endif
 415 };
 416
 417 struct _GLUToverlay {
 418 #if defined(_WIN32)
 419   int pf;
 420   HDC hdc;
 421 #endif
 422   Window win;
 423   GLXContext ctx;
 424   XVisualInfo *vis;     /* visual for window */
 425   Bool visAlloced;      /* if vis needs deallocate on destroy */
 426   Colormap cmap;        /* RGB colormap for window; None if CI */
 427   GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
 428   int shownState;       /* if overlay window mapped */
 429   Bool treatAsSingle;   /* treat as single-buffered */
 430 #if !defined(_WIN32)
 431   Bool isDirect;        /* if direct context */
 432 #endif
 433   int transparentPixel; /* transparent pixel value */
 434   GLUTdisplayCB display;  /* redraw  */
 435 #ifdef SUPPORT_FORTRAN
 436   GLUTdisplayFCB fdisplay;  /* redraw  */
 437 #endif
 438 };
 439
 440 typedef struct _GLUTstale GLUTstale;
 441 struct _GLUTstale {
 442   GLUTwindow *window;
 443   Window win;
 444   GLUTstale *next;
 445 };
 446
 447 extern GLUTstale *__glutStaleWindowList;
 448
 449 #define GLUT_OVERLAY_EVENT_FILTER_MASK \
 450   (ExposureMask | \
 451   StructureNotifyMask | \
 452   EnterWindowMask | \
 453   LeaveWindowMask)
 454 #define GLUT_DONT_PROPAGATE_FILTER_MASK \
 455   (ButtonReleaseMask | \
 456   ButtonPressMask | \
 457   KeyPressMask | \
 458   KeyReleaseMask | \
 459   PointerMotionMask | \
 460   Button1MotionMask | \
 461   Button2MotionMask | \
 462   Button3MotionMask)
 463 #define GLUT_HACK_STOP_PROPAGATE_MASK \
 464   (KeyPressMask | \
 465   KeyReleaseMask)
 466
 467 typedef struct _GLUTmenu GLUTmenu;
 468 typedef struct _GLUTmenuItem GLUTmenuItem;
 469 struct _GLUTmenu {
 470   int id;               /* small integer menu id (0-based) */
 471   Window win;           /* X window for the menu */
 472   GLUTselectCB select;  /*  function of menu */
 473   GLUTmenuItem *list;   /* list of menu entries */
 474   int num;              /* number of entries */
 475 #if !defined(_WIN32)
 476   Bool managed;         /* are the InputOnly windows size
 477                            validated? */
 478   Bool searched;        /* help detect menu loops */
 479   int pixheight;        /* height of menu in pixels */
 480   int pixwidth;         /* width of menu in pixels */
 481 #endif
 482   int submenus;         /* number of submenu entries */
 483   GLUTmenuItem *highlighted;  /* pointer to highlighted menu
 484                                  entry, NULL not highlighted */
 485   GLUTmenu *cascade;    /* currently cascading this menu  */
 486   GLUTmenuItem *anchor; /* currently anchored to this entry */
 487   int x;                /* current x origin relative to the
 488                            root window */
 489   int y;                /* current y origin relative to the
 490                            root window */
 491 #ifdef SUPPORT_FORTRAN
 492   GLUTselectFCB fselect;  /*  function of menu */
 493 #endif
 494 };
 495
 496 struct _GLUTmenuItem {
 497   Window win;           /* InputOnly X window for entry */
 498   GLUTmenu *menu;       /* menu entry belongs to */
 499   Bool isTrigger;       /* is a submenu trigger? */
 500   int value;            /* value to return for selecting this
 501                            entry; doubles as submenu id
 502                            (0-base) if submenu trigger */
 503 #if defined(_WIN32)
 504   UINT unique;          /* unique menu item id (Win32 only) */
 505 #endif
 506   char *label;          /* __glutStrdup'ed label string */
 507   int len;              /* length of label string */
 508   int pixwidth;         /* width of X window in pixels */
 509   GLUTmenuItem *next;   /* next menu entry on list for menu */
 510 };
 511
 512 typedef struct _GLUTtimer GLUTtimer;
 513 struct _GLUTtimer {
 514   GLUTtimer *next;      /* list of timers */
 515 #ifdef OLD_VMS
 516    struct timeval6 timeout;  /* time to be called */
 517 #else
 518    struct timeval timeout;  /* time to be called */
 519 #endif
 520    GLUTtimerCB func;     /* timer  (value) */
 521   int value;            /*  return value */
 522 #ifdef SUPPORT_FORTRAN
 523   GLUTtimerFCB ffunc;   /* Fortran timer  */
 524 #endif
 525 };
 526
 527 typedef struct _GLUTeventParser GLUTeventParser;
 528 struct _GLUTeventParser {
 529   int (*func) (XEvent *);
 530   GLUTeventParser *next;
 531 };
 532
 533 /* Declarations to implement glutFullScreen support with
 534    mwm/4Dwm. */
 535
 536 /* The following X property format is defined in Motif 1.1's
 537    Xm/MwmUtils.h, but GLUT should not depend on that header
 538    file. Note: Motif 1.2 expanded this structure with
 539    uninteresting fields (to GLUT) so just stick with the
 540    smaller Motif 1.1 structure. */
 541 typedef struct {
 542 #define MWM_HINTS_DECORATIONS   2
 543   long flags;
 544   long functions;
 545   long decorations;
 546   long input_mode;
 547 } MotifWmHints;
 548
 549 /* Make current and buffer swap macros. */
 550 #ifdef _WIN32
 551 #define MAKE_CURRENT_LAYER(window)                                    \
 552   {                                                                   \
 553     HGLRC currentContext = wglGetCurrentContext();                    \
 554     HDC currentDc = wglGetCurrentDC();                                \
 555                                                                       \
 556     if (currentContext != window->renderCtx                           \
 557       || currentDc != window->renderDc) {                             \
 558       wglMakeCurrent(window->renderDc, window->renderCtx);            \
 559     }                                                                 \
 560   }
 561 #define MAKE_CURRENT_WINDOW(window)                                   \
 562   {                                                                   \
 563     HGLRC currentContext = wglGetCurrentContext();                    \
 564     HDC currentDc = wglGetCurrentDC();                                \
 565                                                                       \
 566     if (currentContext != window->ctx || currentDc != window->hdc) {  \
 567       wglMakeCurrent(window->hdc, window->ctx);                       \
 568     }                                                                 \
 569   }
 570 #define MAKE_CURRENT_OVERLAY(overlay) \
 571   wglMakeCurrent(overlay->hdc, overlay->ctx)
 572 #define UNMAKE_CURRENT() \
 573   wglMakeCurrent(NULL, NULL)
 574 #define SWAP_BUFFERS_WINDOW(window) \
 575   SwapBuffers(window->hdc)
 576 #define SWAP_BUFFERS_LAYER(window) \
 577   SwapBuffers(window->renderDc)
 578 #else
 579 #define MAKE_CURRENT_LAYER(window) \
 580   glXMakeCurrent(__glutDisplay, window->renderWin, window->renderCtx)
 581 #define MAKE_CURRENT_WINDOW(window) \
 582   glXMakeCurrent(__glutDisplay, window->win, window->ctx)
 583 #define MAKE_CURRENT_OVERLAY(overlay) \
 584   glXMakeCurrent(__glutDisplay, overlay->win, overlay->ctx)
 585 #define UNMAKE_CURRENT() \
 586   glXMakeCurrent(__glutDisplay, None, NULL)
 587 #define SWAP_BUFFERS_WINDOW(window) \
 588   glXSwapBuffers(__glutDisplay, window->win)
 589 #define SWAP_BUFFERS_LAYER(window) \
 590   glXSwapBuffers(__glutDisplay, window->renderWin)
 591 #endif
 592
 593 /* private variables from glut_event.c */
 594 extern GLUTwindow *__glutWindowWorkList;
 595 extern int __glutWindowDamaged;
 596 #ifdef SUPPORT_FORTRAN
 597 extern GLUTtimer *__glutTimerList;
 598 extern GLUTtimer *__glutNewTimer;
 599 #endif
 600 extern GLUTmenu *__glutMappedMenu;
 601
 602 extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
 603 #if !defined(_WIN32)
 604 extern void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item,
 605   int num, int type);
 606 extern void (*__glutFinishMenu)(Window win, int x, int y);
 607 extern void (*__glutPaintMenu)(GLUTmenu * menu);
 608 extern void (*__glutStartMenu)(GLUTmenu * menu,
 609   GLUTwindow * window, int x, int y, int x_win, int y_win);
 610 extern GLUTmenu * (*__glutGetMenuByNum)(int menunum);
 611 extern GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu,
 612   Window win, int *which);
 613 extern GLUTmenu * (*__glutGetMenu)(Window win);
 614 #endif
 615
 616 /* private variables from glut_init.c */
 617 extern Atom __glutWMDeleteWindow;
 618 extern Display *__glutDisplay;
 619 extern unsigned int __glutDisplayMode;
 620 extern char *__glutDisplayString;
 621 extern XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
 622   Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc);
 623 extern GLboolean __glutDebug;
 624 extern GLboolean __glutForceDirect;
 625 extern GLboolean __glutIconic;
 626 extern GLboolean __glutTryDirect;
 627 extern Window __glutRoot;
 628 extern XSizeHints __glutSizeHints;
 629 extern char **__glutArgv;
 630 extern char *__glutProgramName;
 631 extern int __glutArgc;
 632 extern int __glutConnectionFD;
 633 extern int __glutInitHeight;
 634 extern int __glutInitWidth;
 635 extern int __glutInitX;
 636 extern int __glutInitY;
 637 extern int __glutScreen;
 638 extern int __glutScreenHeight;
 639 extern int __glutScreenWidth;
 640 extern Atom __glutMotifHints;
 641 extern unsigned int __glutModifierMask;
 642 #ifdef _WIN32
 643 extern void (__cdecl *__glutExitFunc)(int retval);
 644 #endif
 645 extern char *__glutPPMFile;
 646
 647 /* private variables from glut_menu.c */
 648 extern GLUTmenuItem *__glutItemSelected;
 649 extern GLUTmenu **__glutMenuList;
 650 extern void (GLUTCALLBACK *__glutMenuStatusFunc) (int, int, int);
 651 extern void __glutMenuModificationError(void);
 652 extern void __glutSetMenuItem(GLUTmenuItem * item,
 653   const char *label, int value, Bool isTrigger);
 654
 655 /* private variables from glut_win.c */
 656 extern GLUTwindow **__glutWindowList;
 657 extern GLUTwindow *__glutCurrentWindow;
 658 extern GLUTwindow *__glutMenuWindow;
 659 extern GLUTmenu *__glutCurrentMenu;
 660 extern int __glutWindowListSize;
 661 extern void (*__glutFreeOverlayFunc) (GLUToverlay *);
 662 extern void __glutFreeOverlay(GLUToverlay * overlay);
 663 extern XVisualInfo *__glutDetermineWindowVisual(Bool * treatAsSingle,
 664   Bool * visAlloced, void **fbc);
 665
 666 /* private variables from glut_ppm.c */
 667 extern void __glutWritePPMFile(void);
 668
 669 /* private variables from glut_mesa.c */
 670 extern int __glutMesaSwapHackSupport;
 671
 672 /* private variables from glut_gamemode.c */
 673 extern GLUTwindow *__glutGameModeWindow;
 674
 675 /* private routines from glut_cindex.c */
 676 extern GLUTcolormap * __glutAssociateNewColormap(XVisualInfo * vis);
 677 extern void __glutFreeColormap(GLUTcolormap *);
 678
 679 /* private routines from glut_cmap.c */
 680 extern void __glutSetupColormap(
 681   XVisualInfo * vi,
 682   GLUTcolormap ** colormap,
 683   Colormap * cmap);
 684 #if !defined(_WIN32)
 685 extern void __glutEstablishColormapsProperty(
 686   GLUTwindow * window);
 687 extern GLUTwindow *__glutToplevelOf(GLUTwindow * window);
 688 #endif
 689
 690 /* private routines from glut_cursor.c */
 691 extern void __glutSetCursor(GLUTwindow *window);
 692
 693 /* private routines from glut_event.c */
 694 extern void __glutPutOnWorkList(GLUTwindow * window,
 695   int work_mask);
 696 extern void __glutRegisterEventParser(GLUTeventParser * parser);
 697 extern void __glutPostRedisplay(GLUTwindow * window, int layerMask);
 698 extern void handleTimeouts(void);
 699
 700 /* private routines from glut_init.c */
 701 #if !defined(_WIN32)
 702 extern void __glutOpenXConnection(char *display);
 703 #else
 704 extern void __glutOpenWin32Connection(char *display);
 705 #endif
 706 #ifdef OLD_VMS
 707 extern void __glutInitTime(struct timeval6 *beginning);
 708 #else
 709 extern void __glutInitTime(struct timeval *beginning);
 710 #endif
 711
 712 /* private routines for glut_menu.c (or win32_menu.c) */
 713 #if defined(_WIN32)
 714 extern GLUTmenu *__glutGetMenu(Window win);
 715 extern GLUTmenu *__glutGetMenuByNum(int menunum);
 716 extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu,
 717   Window win, int *which);
 718 extern void __glutStartMenu(GLUTmenu * menu,
 719   GLUTwindow * window, int x, int y, int x_win, int y_win);
 720 extern void __glutFinishMenu(Window win, int x, int y);
 721 #endif
 722 extern void __glutSetMenu(GLUTmenu * menu);
 723
 724 /* private routines from glut_util.c */
 725 extern char * __glutStrdup(const char *string);
 726 extern void __glutWarning(char *format,...);
 727 extern void __glutFatalError(char *format,...);
 728 extern void __glutFatalUsage(char *format,...);
 729
 730 /* private routines from glut_win.c */
 731 extern GLUTwindow *__glutGetWindow(Window win);
 732 extern void __glutChangeWindowEventMask(long mask, Bool add);
 733 extern XVisualInfo *__glutDetermineVisual(
 734   unsigned int mode,
 735   Bool * fakeSingle,
 736   XVisualInfo * (getVisualInfo) (unsigned int));
 737 extern XVisualInfo *__glutGetVisualInfo(unsigned int mode);
 738 extern void __glutSetWindow(GLUTwindow * window);
 739 extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc,
 740   int callingConvention);
 741 extern void GLUTCALLBACK __glutDefaultReshape(int, int);
 742 extern GLUTwindow *__glutCreateWindow(
 743   GLUTwindow * parent,
 744   int x, int y, int width, int height, int gamemode);
 745 extern void __glutDestroyWindow(
 746   GLUTwindow * window,
 747   GLUTwindow * initialWindow);
 748
 749 #if !defined(_WIN32)
 750 /* private routines from glut_glxext.c */
 751 extern int __glutIsSupportedByGLX(char *);
 752 extern int __glut_glXBindChannelToWindowSGIX(Display *dpy, int screen,
 753                                              int channel, Window window);
 754 extern int __glut_glXChannelRectSGIX(Display *dpy, int screen, int channel,
 755                                      int x, int y, int w, int h);
 756 extern int __glut_glXQueryChannelRectSGIX(Display *dpy, int screen,
 757                                           int channel, int *x, int *y,
 758                                           int *w, int *h);
 759 extern int __glut_glXQueryChannelDeltasSGIX(Display *dpy, int screen,
 760                                             int channel, int *dx, int *dy,
 761                                             int *dw, int *dh);
 762 extern int __glut_glXChannelRectSyncSGIX(Display *dpy, int screen, int channel,
 763                                          GLenum synctype);
 764 extern GLXContext __glut_glXCreateContextWithConfigSGIX(Display *dpy,
 765                                                         GLXFBConfigSGIX config,
 766                                                         int render_type,
 767                                                         GLXContext share_list,
 768                                                         Bool direct);
 769 extern int __glut_glXGetFBConfigAttribSGIX(Display *dpy,
 770                                            GLXFBConfigSGIX config,
 771                                            int attribute,
 772                                            int *value);
 773 extern GLXFBConfigSGIX __glut_glXGetFBConfigFromVisualSGIX(Display *dpy,
 774                                                            XVisualInfo *vis);
 775 #endif
 776
 777 /* private routines from glut_input.c */
 778 extern void  __glutUpdateInputDeviceMask(GLUTwindow * window);
 779
 780 /* private routines from glut_mesa.c */
 781 extern void __glutDetermineMesaSwapHackSupport(void);
 782
 783 /* private routines from glut_gameglut.c */
 784 extern void __glutCloseDownGameMode(void);
 785
 786 /* private variables from glut_swap.c (BrianP) */
 787 extern GLint __glutFPS;
 788 extern GLint __glutSwapCount;
 789 extern GLint __glutSwapTime;
 790
 791 #if defined(_WIN32)
 792 /* private routines from win32_*.c */
 793 extern LONG WINAPI __glutWindowProc(HWND win, UINT msg, WPARAM w, LPARAM l);
 794 extern HDC XHDC;
 795 #endif
 796
 797
 798 #endif /* __glutint_h__ */