开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
togl.c
资源名称：scanalyze-1.0.3_source_code.rar　[点击查看]
上传用户：kellyonhid
上传日期：2013-10-12
资源大小：932k
文件大小：94k
源码类别：

3D图形编程

开发平台：

Visual C++

togl.c：源码内容
  2. /* $Id: togl.c,v 1.15 2002/09/26 16:56:04 kberg Exp $ */
  4. /*
  5.  * Togl - a Tk OpenGL widget
  6.  * Version 1.5
  7.  * Copyright (C) 1996-1997  Brian Paul and Ben Bederson
  8.  * See the LICENSE file for copyright details.
  9.  */
  12. /*
  13.  * $Log: togl.c,v $
  14.  * Revision 1.15  2002/09/26 16:56:04  kberg
  15.  * fixed a typo
  16.  *
  17.  * Revision 1.14  2002/09/21 02:00:42  kberg
  18.  * Added prgamas to turn off optimizations so windows version doesn't crash
  19.  * in optimized build
  20.  * ---------------------------------------------------------
  21.  *
  22.  * Revision 1.13  2001/10/09 22:26:13  smr
  23.  * Add #define for TK 8.3.3
  24.  *
  25.  * Revision 1.12  2001/07/24 22:12:22  kberg
  26.  * Update on the overlay plane work around. (kberg)
  27.  *
  28.  * Revision 1.11  2001/07/02 17:56:30  srm
  29.  * switched trunk over to branch non-lmeunier-rollfwd
  30.  *
  31.  * Revision 1.7.2.3  2001/06/14 15:06:45  srm
  32.  * roll fwd to 2000-12-16
  33.  *
  34.  * Revision 1.10  2000/11/22 08:55:40  srm
  35.  * Added yet another Tcl version to togl.
  36.  * Note 8.3.{1,2} point to the 8.3.2 header file
  37.  *
  38.  * Revision 1.9  2000/06/06 10:17:59  magi
  39.  * fix win32 compile
  40.  *
  41.  * Revision 1.8  2000/05/07 00:02:53  smr
  42.  * Linux portability fixes.
  43.  *
  44.  * Revision 1.7  1999/01/12 17:35:26  magi
  45.  * update win32 port
  46.  *
  47.  * Revision 1.6  1998/11/10 10:05:30  magi
  48.  * change order of operations in destroy handler, so client's destroy
  49.  * callback can still access widget fields like Togl->Ident
  50.  *
  51.  * Revision 1.5  1998/10/28 13:54:04  magi
  52.  * cache static images as bitmap for fast redraws -- only render when necessary
  53.  *
  54.  * Revision 1.4  1998/06/17 01:37:10  magi
  55.  * add per-togl support for timers
  56.  *
  57.  * Revision 1.3  1998/04/29 00:58:42  magi
  58.  * updated Togl code to version 1.5 beta 3 -- because 1.4 wasn't working
  59.  * under Tcl/Tk 8.0 -- note that I had to make one change to togl.c
  60.  * in ToglCmdDeletedProc, or it faults when trying to destroy the widget
  61.  * (only if there's an overlay buffer) because tkwin is NULL.
  62.  *
  63.  * Revision 1.43  1998/03/12 04:10:47  brianp
  64.  * added display list and OpenGL context sharing options
  65.  *
  66.  * Revision 1.42  1998/03/12 03:20:31  brianp
  67.  * fixed a few overlay update bugs (Yang Guo Liang)
  68.  *
  69.  * Revision 1.41  1998/01/20 01:05:10  brianp
  70.  * added more destroy/clean-up code
  71.  * added a few Tcl 7.4 / Tk 4.0 #if/#else/#endifs (David Laur)
  72.  *
  73.  * Revision 1.40  1997/12/13 02:27:46  brianp
  74.  * only call Tcl_DeleteCommandFromToken() is using Tcl/Tk 8.0 or later
  75.  *
  76.  * Revision 1.39  1997/12/13 02:26:02  brianp
  77.  * test for STEREO to enable SGI stereo code
  78.  * general code clean-up
  79.  *
  80.  * Revision 1.38  1997/12/11 02:21:18  brianp
  81.  * added support for Tcl/Tk 8.0p2
  82.  *
  83.  * Revision 1.37  1997/11/15 04:11:30  brianp
  84.  * added Adrian J. Chung's widget destroy code
  85.  *
  86.  * Revision 1.36  1997/11/15 03:33:13  brianp
  87.  * fixed multi-expose/redraw problem (Andy Colebourne)
  88.  *
  89.  * Revision 1.35  1997/11/15 03:28:42  brianp
  90.  * removed code in Togl_Configure(), added for stereo, that caused a new bug
  91.  *
  92.  * Revision 1.34  1997/11/15 02:58:48  brianp
  93.  * added Togl_TkWin() per Glenn Lewis
  94.  *
  95.  * Revision 1.33  1997/10/01 02:50:57  brianp
  96.  * added SGI stereo functions from Ben Evans
  97.  *
  98.  * Revision 1.32  1997/10/01 00:25:22  brianp
  99.  * made small change for HP compilation (Glenn Lewis)
  100.  *
  101.  * Revision 1.31  1997/09/17 02:41:07  brianp
  102.  * added Geza Groma's Windows NT/95 patches
  103.  *
  104.  * Revision 1.30  1997/09/12 01:21:05  brianp
  105.  * a few more tweaks for Windows compilation
  106.  */
  109. /*
  110.  * Currently support X11 and WIN32
  111.  */
  112. #ifndef WIN32
  113. #define X11
  114. #endif
  117. /*** Windows headers ***/
  118. #ifdef WIN32
  119. #define WIN32_LEAN_AND_MEAN
  120. #include <windows.h>
  121. #undef WIN32_LEAN_AND_MEAN
  122. #include <winnt.h>
  123. #endif /* WIN32 */
  125. /*** Standard C headers ***/
  126. #include <assert.h>
  127. #include <stdio.h>
  128. #include <stdlib.h>
  129. #include <string.h>
  131. /*** X Window System headers ***/
  132. #ifdef X11
  133. #include <X11/Xlib.h>
  134. #include <X11/Xutil.h>
  135. #include <X11/Xatom.h>  /* for XA_RGB_DEFAULT_MAP atom */
  136. #if defined(__vms)
  137. #include <X11/StdCmap.h>  /* for XmuLookupStandardColormap */
  138. #else
  139. #include <X11/Xmu/StdCmap.h>  /* for XmuLookupStandardColormap */
  140. #endif
  141. #include <GL/glx.h>
  142. #endif /*X11*/
  144. /*** Tcl/Tk headers ***/
  145. #ifdef X11
  146. #ifndef _TKPORT
  147. #define _TKPORT  /* This eliminates need to include a bunch of Tk baggage */
  148. #endif /* X11 */
  149. #endif
  150. #include <tcl.h>
  151. #include <tk.h>
  152. #if defined(X11)
  153. #if TK_MAJOR_VERSION==4 && TK_MINOR_VERSION==0
  154. #  include "tkInt4.0.h"
  155. #  define NO_TK_CURSOR
  156. #elif TK_MAJOR_VERSION==4 && TK_MINOR_VERSION==1
  157. #  include "tkInt4.1.h"
  158. #elif TK_MAJOR_VERSION==4 && TK_MINOR_VERSION==2
  159. #  include "tkInt4.2.h"
  160. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==0 && TK_RELEASE_SERIAL==0
  161. #  include "tkInt8.0.h"
  162. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==0 && TK_RELEASE_SERIAL==2
  163. #  include "tkInt8.0p2.h"
  164. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==0 && TK_RELEASE_SERIAL==2
  165. #  include "tkInt8.0p2.h"
  166. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==0 && TK_RELEASE_SERIAL==4
  167. #  include "tkInt8.0.4.h"
  168. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==0 && TK_RELEASE_SERIAL==5
  169. #  include "tkInt8.0.5.h"
  170. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==3 && TK_RELEASE_SERIAL==1
  171. #  include "tkInt8.3.2.h"
  172. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==3 && TK_RELEASE_SERIAL==2
  173. #  include "tkInt8.3.2.h"
  174. #elif TK_MAJOR_VERSION==8 && TK_MINOR_VERSION==3 && TK_RELEASE_SERIAL==3
  175. #  include "tkInt8.3.2.h"
  176. #else
  177. #error   Sorry, you will have to edit togl.c to include the right tkInt.h file
  178. #endif
  179. #elif defined(WIN32)
  180. #if TK_MAJOR_VERSION<8
  181.    Sorry Windows version requires Tcl/Tk ver 8.0 or higher.
  182. #endif
  183. #include "tkInt.h"
  184. #include "tkWinInt.h"
  185. #endif /* X11 */
  186. #include "togl.h"
  190. /* Defaults */
  191. #define DEFAULT_WIDTH "400"
  192. #define DEFAULT_HEIGHT "400"
  193. #define DEFAULT_IDENT ""
  194. #define DEFAULT_FONTNAME "fixed"
  195. #define DEFAULT_TIME "1"
  198. #ifdef WIN32
  199. /* maximum size of a logical palette corresponding to a colormap in color index mode */
  200. #define MAX_CI_COLORMAP_SIZE 4096
  201. #endif /* WIN32 */
  203. #define MAX(a,b) (((a)>(b))?(a):(b))
  205. #define TCL_ERR(interp, string) {Tcl_ResetResult(interp);
  206.          Tcl_AppendResult(interp, string, NULL);
  207.  return(TCL_ERROR);}
  209. #define ALL_EVENTS_MASK 
  210.     KeyPressMask|KeyReleaseMask|ButtonPressMask|ButtonReleaseMask|
  211.     EnterWindowMask|LeaveWindowMask|PointerMotionMask|ExposureMask|
  212.     VisibilityChangeMask|FocusChangeMask|PropertyChangeMask|ColormapChangeMask
  215. struct Togl
  216. {
  217.    struct Togl *Next;           /* next in linked list */
  219. #if defined(WIN32)
  220.    HDC tglGLHdc;                /* Device context of device that OpenGL calls will be drawn on */
  221.    HGLRC tglGLHglrc;            /* OpenGL rendering context to be made current */
  222.    int CiColormapSize;          /* (Maximum) size of colormap in color index mode */
  223. #elif defined(X11)
  224.    GLXContext GlCtx; /* Normal planes GLX context */
  225. #endif /* WIN32 */
  226.    Display *display; /* X's token for the window's display. */
  227.    Tk_Window  TkWin; /* Tk window structure */
  228.    Tcl_Interp *Interp; /* Tcl interpreter */
  229.    Tcl_Command widgetCmd;       /* Token for togl's widget command */
  230. #ifndef NO_TK_CURSOR
  231.    Tk_Cursor Cursor; /* The widget's cursor */
  232. #endif
  233.    int Width, Height; /* Dimensions of window */
  234.    int Time; /* Time value for timer */
  235. #if (TCL_MAJOR_VERSION * 100 + TCL_MINOR_VERSION) >= 705
  236.    Tcl_TimerToken timerHandler; /* Token for togl's timer handler */
  237. #else
  238.    Tk_TimerToken timerHandler;  /* Token for togl's timer handler */
  239. #endif
  240.    int RgbaFlag; /* configuration flags (ala GLX parameters) */
  241.    int RgbaRed;
  242.    int RgbaGreen;
  243.    int RgbaBlue;
  244.    int DoubleFlag;
  245.    int DepthFlag;
  246.    int DepthSize;
  247.    int AccumFlag;
  248.    int AccumRed;
  249.    int AccumGreen;
  250.    int AccumBlue;
  251.    int AccumAlpha;
  252.    int AlphaFlag;
  253.    int AlphaSize;
  254.    int StencilFlag;
  255.    int StencilSize;
  256.    int PrivateCmapFlag;
  257.    int OverlayFlag;
  258.    int StereoFlag;
  259.    int AuxNumber;
  260.    char *ShareList;             /* name (ident) of Togl to share dlists with */
  261.    char *ShareContext;          /* name (ident) to share OpenGL context with */
  263.    char *Ident; /* User's identification string */
  264.    ClientData Client_Data; /* Pointer to user data */
  266.    GLboolean UpdatePending; /* Should normal planes be redrawn? */
  268.    Togl_Callback *CreateProc; /* Callback when widget is created */
  269.    Togl_Callback *DisplayProc; /* Callback when widget is rendered */
  270.    Togl_Callback *ReshapeProc; /* Callback when window size changes */
  271.    Togl_Callback *DestroyProc; /* Callback when widget is destroyed */
  272.    Togl_Callback *TimerProc; /* Callback when widget is idle */
  274.    /* Overlay stuff */
  275. #if defined(X11)
  276.    GLXContext OverlayCtx; /* Overlay planes OpenGL context */
  277. #elif defined(WIN32)
  278.    HGLRC tglGLOverlayHglrc;
  279. #endif /* X11 */
  280.    Window OverlayWindow; /* The overlay window, or 0 */
  281.    Togl_Callback *OverlayDisplayProc; /* Overlay redraw proc */
  282.    GLboolean OverlayUpdatePending; /* Should overlay be redrawn? */
  283.    Colormap OverlayCmap; /* colormap for overlay is created */
  284.    int OverlayTransparentPixel; /* transparent pixel */
  285.    int OverlayIsMapped;
  287.    /* for DumpToEpsFile: Added by Miguel A. de Riera Pasenau 10.01.1997 */
  288.    XVisualInfo *VisInfo; /* Visual info of the current */
  289. /* context needed for DumpToEpsFile */
  290.    GLfloat *EpsRedMap; /* Index2RGB Maps for Color index modes */
  291.    GLfloat *EpsGreenMap;
  292.    GLfloat *EpsBlueMap;
  293.    GLint EpsMapSize;             /* = Number of indices in our Togl */
  294. };
  297. /* NTNTNT need to change to handle Windows Data Types */
  298. /*
  299.  * Prototypes for functions local to this file
  300.  */
  301. static int Togl_Cmd(ClientData clientData, Tcl_Interp *interp,
  302.                     int argc, char **argv);
  303. static void Togl_EventProc(ClientData clientData, XEvent *eventPtr);
  304. static int Togl_MakeWindowExist(struct Togl *togl);
  305. #ifdef MESA_COLOR_HACK
  306. static int get_free_color_cells( Display *display, int screen,
  307.                                  Colormap colormap);
  308. static void free_default_color_cells( Display *display, Colormap colormap);
  309. #endif
  310. static void ToglCmdDeletedProc( ClientData );
  314. #if defined(__sgi) && defined(STEREO)
  315. /* SGI-only stereo */
  316. static void stereoMakeCurrent( Display *dpy, Window win, GLXContext ctx );
  317. static void stereoInit( struct Togl *togl,int stereoEnabled );
  318. #endif
  322. /*
  323.  * Setup Togl widget configuration options:
  324.  */
  326. static Tk_ConfigSpec configSpecs[] = {
  327.     {TK_CONFIG_PIXELS, "-height", "height", "Height",
  328.      DEFAULT_HEIGHT, Tk_Offset(struct Togl, Height), 0, NULL},
  330.     {TK_CONFIG_PIXELS, "-width", "width", "Width",
  331.      DEFAULT_WIDTH, Tk_Offset(struct Togl, Width), 0, NULL},
  333.     {TK_CONFIG_BOOLEAN, "-rgba", "rgba", "Rgba",
  334.      "true", Tk_Offset(struct Togl, RgbaFlag), 0, NULL},
  336.     {TK_CONFIG_INT, "-redsize", "redsize", "RedSize",
  337.      "1", Tk_Offset(struct Togl, RgbaRed), 0, NULL},
  339.     {TK_CONFIG_INT, "-greensize", "greensize", "GreenSize",
  340.      "1", Tk_Offset(struct Togl, RgbaGreen), 0, NULL},
  342.     {TK_CONFIG_INT, "-bluesize", "bluesize", "BlueSize",
  343.      "1", Tk_Offset(struct Togl, RgbaBlue), 0, NULL},
  345.     {TK_CONFIG_BOOLEAN, "-double", "double", "Double",
  346.      "false", Tk_Offset(struct Togl, DoubleFlag), 0, NULL},
  348.     {TK_CONFIG_BOOLEAN, "-depth", "depth", "Depth",
  349.      "false", Tk_Offset(struct Togl, DepthFlag), 0, NULL},
  351.     {TK_CONFIG_INT, "-depthsize", "depthsize", "DepthSize",
  352.      "1", Tk_Offset(struct Togl, DepthSize), 0, NULL},
  354.     {TK_CONFIG_BOOLEAN, "-accum", "accum", "Accum",
  355.      "false", Tk_Offset(struct Togl, AccumFlag), 0, NULL},
  357.     {TK_CONFIG_INT, "-accumredsize", "accumredsize", "AccumRedSize",
  358.      "1", Tk_Offset(struct Togl, AccumRed), 0, NULL},
  360.     {TK_CONFIG_INT, "-accumgreensize", "accumgreensize", "AccumGreenSize",
  361.      "1", Tk_Offset(struct Togl, AccumGreen), 0, NULL},
  363.     {TK_CONFIG_INT, "-accumbluesize", "accumbluesize", "AccumBlueSize",
  364.      "1", Tk_Offset(struct Togl, AccumBlue), 0, NULL},
  366.     {TK_CONFIG_INT, "-accumalphasize", "accumalphasize", "AccumAlphaSize",
  367.      "1", Tk_Offset(struct Togl, AccumAlpha), 0, NULL},
  369.     {TK_CONFIG_BOOLEAN, "-alpha", "alpha", "Alpha",
  370.      "false", Tk_Offset(struct Togl, AlphaFlag), 0, NULL},
  372.     {TK_CONFIG_INT, "-alphasize", "alphasize", "AlphaSize",
  373.      "1", Tk_Offset(struct Togl, AlphaSize), 0, NULL},
  375.     {TK_CONFIG_BOOLEAN, "-stencil", "stencil", "Stencil",
  376.      "false", Tk_Offset(struct Togl, StencilFlag), 0, NULL},
  378.     {TK_CONFIG_INT, "-stencilsize", "stencilsize", "StencilSize",
  379.      "1", Tk_Offset(struct Togl, StencilSize), 0, NULL},
  381.     {TK_CONFIG_INT, "-auxbuffers", "auxbuffers", "AuxBuffers",
  382.      "0", Tk_Offset(struct Togl, AuxNumber), 0, NULL},
  384.     {TK_CONFIG_BOOLEAN, "-privatecmap", "privateCmap", "PrivateCmap",
  385.      "false", Tk_Offset(struct Togl, PrivateCmapFlag), 0, NULL},
  387.     {TK_CONFIG_BOOLEAN, "-overlay", "overlay", "Overlay",
  388.      "false", Tk_Offset(struct Togl, OverlayFlag), 0, NULL},
  390.     {TK_CONFIG_BOOLEAN, "-stereo", "stereo", "Stereo",
  391.      "false", Tk_Offset(struct Togl, StereoFlag), 0, NULL},
  393. #ifndef NO_TK_CURSOR
  394.     { TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
  395.      "", Tk_Offset(struct Togl, Cursor), TK_CONFIG_NULL_OK },
  396. #endif
  398.     {TK_CONFIG_INT, "-time", "time", "Time",
  399.      DEFAULT_TIME, Tk_Offset(struct Togl, Time), 0, NULL},
  401.     {TK_CONFIG_STRING, "-sharelist", "sharelist", "ShareList",
  402.      NULL, Tk_Offset(struct Togl, ShareList), 0, NULL},
  404.     {TK_CONFIG_STRING, "-sharecontext", "sharecontext", "ShareContext",
  405.      NULL, Tk_Offset(struct Togl, ShareContext), 0, NULL},
  407.     {TK_CONFIG_STRING, "-ident", "ident", "Ident",
  408.      DEFAULT_IDENT, Tk_Offset(struct Togl, Ident), 0, NULL},
  410.     {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
  411.      (char *) NULL, 0, 0, NULL}
  412. };
  415. static Togl_Callback *CreateProc = NULL;
  416. static Togl_Callback *DisplayProc = NULL;
  417. static Togl_Callback *ReshapeProc = NULL;
  418. static Togl_Callback *DestroyProc = NULL;
  419. static Togl_Callback *OverlayDisplayProc = NULL;
  420. static Togl_Callback *TimerProc = NULL;
  421. static ClientData DefaultClientData = NULL;
  422. static Tcl_HashTable CommandTable;
  424. static struct Togl *ToglHead = NULL;  /* head of linked list */
  427. /*
  428.  * Add given togl widget to linked list.
  429.  */
  430. static void AddToList(struct Togl *t)
  431. {
  432.    t->Next = ToglHead;
  433.    ToglHead = t;
  434. }
  436. /*
  437.  * Remove given togl widget from linked list.
  438.  */
  439. static void RemoveFromList(struct Togl *t)
  440. {
  441.    struct Togl *prev = NULL;
  442.    struct Togl *pos = ToglHead;
  443.    while (pos) {
  444.       if (pos == t) {
  445.          if (prev) {
  446.             prev->Next = pos->Next;
  447.          }
  448.          else {
  449.             ToglHead = pos->Next;
  450.          }
  451.          return;
  452.       }
  453.       prev = pos;
  454.       pos = pos->Next;
  455.    }
  456. }
  458. /*
  459.  * Return pointer to togl widget given a user identifier string.
  460.  */
  461. static struct Togl *FindTogl(const char *ident)
  462. {
  463.    struct Togl *t = ToglHead;
  464.    while (t) {
  465.       if (strcmp(t->Ident, ident) == 0)
  466.          return t;
  467.       t = t->Next;
  468.    }
  469.    return NULL;
  470. }
  475. #if defined(X11)
  476. /*
  477.  * Return an X colormap to use for OpenGL RGB-mode rendering.
  478.  * Input:  dpy - the X display
  479.  *         scrnum - the X screen number
  480.  *         visinfo - the XVisualInfo as returned by glXChooseVisual()
  481.  * Return:  an X Colormap or 0 if there's a _serious_ error.
  482.  */
  483. static Colormap
  484. get_rgb_colormap( Display *dpy, int scrnum, const XVisualInfo *visinfo )
  485. {
  486.    Atom hp_cr_maps;
  487.    Status status;
  488.    int numCmaps;
  489.    int i;
  490.    XStandardColormap *standardCmaps;
  491.    Window root = RootWindow(dpy,scrnum);
  492.    int using_mesa;
  494.    /*
  495.     * First check if visinfo's visual matches the default/root visual.
  496.     */
  497.    if (visinfo->visual==DefaultVisual(dpy,scrnum)) {
  498.       /* use the default/root colormap */
  499.       Colormap cmap;
  500.       cmap = DefaultColormap( dpy, scrnum );
  501. #ifdef MESA_COLOR_HACK
  502.       (void) get_free_color_cells( dpy, scrnum, cmap);
  503. #endif
  504.       return cmap;
  505.    }
  507.    /*
  508.     * Check if we're using Mesa.
  509.     */
  510.    if (strstr(glXQueryServerString( dpy, scrnum, GLX_VERSION ), "Mesa")) {
  511.       using_mesa = 1;
  512.    }
  513.    else {
  514.       using_mesa = 0;
  515.    }
  517.    /*
  518.     * Next, if we're using Mesa and displaying on an HP with the "Color
  519.     * Recovery" feature and the visual is 8-bit TrueColor, search for a
  520.     * special colormap initialized for dithering.  Mesa will know how to
  521.     * dither using this colormap.
  522.     */
  523.    if (using_mesa) {
  524.       hp_cr_maps = XInternAtom( dpy, "_HP_RGB_SMOOTH_MAP_LIST", True );
  525.       if (hp_cr_maps
  526. #ifdef __cplusplus
  527.   && visinfo->visual->c_class==TrueColor
  528. #else
  529.   && visinfo->visual->class==TrueColor
  530. #endif
  531.   && visinfo->depth==8) {
  532.  status = XGetRGBColormaps( dpy, root, &standardCmaps,
  533.     &numCmaps, hp_cr_maps );
  534.  if (status) {
  535.     for (i=0; i<numCmaps; i++) {
  536.        if (standardCmaps[i].visualid == visinfo->visual->visualid) {
  537.                   Colormap cmap = standardCmaps[i].colormap;
  538.                   XFree( standardCmaps );
  539.   return cmap;
  540.        }
  541.     }
  542.             XFree(standardCmaps);
  543.  }
  544.       }
  545.    }
  547.    /*
  548.     * Next, try to find a standard X colormap.
  549.     */
  550. #ifndef SOLARIS_BUG
  551.    status = XmuLookupStandardColormap( dpy, visinfo->screen,
  552.        visinfo->visualid, visinfo->depth,
  553.        XA_RGB_DEFAULT_MAP,
  554.        /* replace */ False, /* retain */ True);
  555.    if (status == 1) {
  556.       status = XGetRGBColormaps( dpy, root, &standardCmaps,
  557.  &numCmaps, XA_RGB_DEFAULT_MAP);
  558.       if (status == 1) {
  559.          for (i = 0; i < numCmaps; i++) {
  560.     if (standardCmaps[i].visualid == visinfo->visualid) {
  561.                Colormap cmap = standardCmaps[i].colormap;
  562.        XFree(standardCmaps);
  563.        return cmap;
  564.     }
  565.  }
  566.          XFree(standardCmaps);
  567.       }
  568.    }
  569. #endif
  571.    /*
  572.     * If we get here, give up and just allocate a new colormap.
  573.     */
  574.    return XCreateColormap( dpy, root, visinfo->visual, AllocNone );
  575. }
  576. #elif defined(WIN32)
  578. /* Code to create RGB palette is taken from the GENGL sample program
  579.    of Win32 SDK */
  581. static unsigned char threeto8[8] = {
  582.     0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377
  583. };
  585. static unsigned char twoto8[4] = {
  586.     0, 0x55, 0xaa, 0xff
  587. };
  589. static unsigned char oneto8[2] = {
  590.     0, 255
  591. };
  593. static int defaultOverride[13] = {
  594.     0, 3, 24, 27, 64, 67, 88, 173, 181, 236, 247, 164, 91
  595. };
  597. static PALETTEENTRY defaultPalEntry[20] = {
  598.     { 0,   0,   0,    0 },
  599.     { 0x80,0,   0,    0 },
  600.     { 0,   0x80,0,    0 },
  601.     { 0x80,0x80,0,    0 },
  602.     { 0,   0,   0x80, 0 },
  603.     { 0x80,0,   0x80, 0 },
  604.     { 0,   0x80,0x80, 0 },
  605.     { 0xC0,0xC0,0xC0, 0 },
  607.     { 192, 220, 192,  0 },
  608.     { 166, 202, 240,  0 },
  609.     { 255, 251, 240,  0 },
  610.     { 160, 160, 164,  0 },
  612.     { 0x80,0x80,0x80, 0 },
  613.     { 0xFF,0,   0,    0 },
  614.     { 0,   0xFF,0,    0 },
  615.     { 0xFF,0xFF,0,    0 },
  616.     { 0,   0,   0xFF, 0 },
  617.     { 0xFF,0,   0xFF, 0 },
  618.     { 0,   0xFF,0xFF, 0 },
  619.     { 0xFF,0xFF,0xFF, 0 }
  620. };
  622. static unsigned char
  623. ComponentFromIndex(int i, UINT nbits, UINT shift)
  624. {
  625.     unsigned char val;
  627.     val = (unsigned char) (i >> shift);
  628.     switch (nbits) {
  630.     case 1:
  631.         val &= 0x1;
  632.         return oneto8[val];
  634.     case 2:
  635.         val &= 0x3;
  636.         return twoto8[val];
  638.     case 3:
  639.         val &= 0x7;
  640.         return threeto8[val];
  642.     default:
  643.         return 0;
  644.     }
  645. }
  647. static Colormap Win32CreateRgbColormap(PIXELFORMATDESCRIPTOR pfd)
  648. {
  649.     TkWinColormap *cmap = (TkWinColormap *) ckalloc(sizeof(TkWinColormap));
  650.     LOGPALETTE *pPal;
  651.     int n, i;
  653.     n = 1 << pfd.cColorBits;
  654.     pPal = (PLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
  655.             n * sizeof(PALETTEENTRY));
  656.     pPal->palVersion = 0x300;
  657.     pPal->palNumEntries = n;
  658.     for (i=0; i<n; i++) {
  659.         pPal->palPalEntry[i].peRed =
  660.                 ComponentFromIndex(i, pfd.cRedBits, pfd.cRedShift);
  661.         pPal->palPalEntry[i].peGreen =
  662.                 ComponentFromIndex(i, pfd.cGreenBits, pfd.cGreenShift);
  663.         pPal->palPalEntry[i].peBlue =
  664.                 ComponentFromIndex(i, pfd.cBlueBits, pfd.cBlueShift);
  665.         pPal->palPalEntry[i].peFlags = 0;
  666.     }
  668.     /* fix up the palette to include the default GDI palette */
  669.     if ((pfd.cColorBits == 8)                           &&
  670.         (pfd.cRedBits   == 3) && (pfd.cRedShift   == 0) &&
  671.         (pfd.cGreenBits == 3) && (pfd.cGreenShift == 3) &&
  672.         (pfd.cBlueBits  == 2) && (pfd.cBlueShift  == 6)
  673.        ) {
  674.         for (i = 1 ; i <= 12 ; i++)
  675.             pPal->palPalEntry[defaultOverride[i]] = defaultPalEntry[i];
  676.     }
  678.     cmap->palette = CreatePalette(pPal);
  679.     LocalFree(pPal);
  680.     cmap->size = n;
  681.     cmap->stale = 0;
  683.     /* Since this is a private colormap of a fix size, we do not need
  684.        a valid hash table, but a dummy one */
  686.     Tcl_InitHashTable(&cmap->refCounts, TCL_ONE_WORD_KEYS);
  687.     return (Colormap)cmap;
  688. }
  690. static Colormap Win32CreateCiColormap(struct Togl *togl)
  691. {
  692.     /* Create a colormap with size of togl->CiColormapSize and set all
  693.        entries to black */
  695.     LOGPALETTE logPalette;
  696.     TkWinColormap *cmap = (TkWinColormap *) ckalloc(sizeof(TkWinColormap));
  698.     logPalette.palVersion = 0x300;
  699.     logPalette.palNumEntries = 1;
  700.     logPalette.palPalEntry[0].peRed = 0;
  701.     logPalette.palPalEntry[0].peGreen = 0;
  702.     logPalette.palPalEntry[0].peBlue = 0;
  703.     logPalette.palPalEntry[0].peFlags = 0;
  705.     cmap->palette = CreatePalette(&logPalette);
  706.     cmap->size = togl->CiColormapSize;
  707.     ResizePalette(cmap->palette, cmap->size);  /* sets new entries to black */
  708.     cmap->stale = 0;
  710.     /* Since this is a private colormap of a fix size, we do not need
  711.        a valid hash table, but a dummy one */
  713.     Tcl_InitHashTable(&cmap->refCounts, TCL_ONE_WORD_KEYS);
  714.     return (Colormap)cmap;
  715. }
  716. #endif /*X11*/
  720. /*
  721.  * Togl_Init
  722.  *
  723.  *   Called upon system startup to create Togl command.
  724.  */
  725. int Togl_Init(Tcl_Interp *interp)
  726. {
  727.    /* The Tcl_PkgProvide() function isn't available in Tcl 7.4 or earlier */
  728. #if (TCL_MAJOR_VERSION * 100 + TCL_MINOR_VERSION) > 704
  729.    /* The following allows Togl to be loaded dynamically into a running
  730.     * tclsh, if togl is made into a shared lib.  Contributed by Kerel
  731.     * Zuiderveld (karel.zuiderveld@cv.ruu.nl)
  732.     */
  733.    if (Tcl_PkgProvide(interp, "Togl", TOGL_VERSION) != TCL_OK) {
  734.       return TCL_ERROR;
  735.    }
  736. #endif
  738.    Tcl_CreateCommand(interp, "togl", Togl_Cmd,
  739.                      (ClientData) Tk_MainWindow(interp), NULL);
  740.    Tcl_InitHashTable(&CommandTable, TCL_STRING_KEYS);
  742.    return TCL_OK;
  743. }
  746. /*
  747.  * Register a C function to be called when an Togl widget is realized.
  748.  */
  749. void Togl_CreateFunc( Togl_Callback *proc )
  750. {
  751.    CreateProc = proc;
  752. }
  755. /*
  756.  * Register a C function to be called when an Togl widget must be redrawn.
  757.  */
  758. void Togl_DisplayFunc( Togl_Callback *proc )
  759. {
  760.    DisplayProc = proc;
  761. }
  764. /*
  765.  * Register a C function to be called when an Togl widget is resized.
  766.  */
  767. void Togl_ReshapeFunc( Togl_Callback *proc )
  768. {
  769.    ReshapeProc = proc;
  770. }
  773. /*
  774.  * Register a C function to be called when an Togl widget is destroyed.
  775.  */
  776. void Togl_DestroyFunc( Togl_Callback *proc )
  777. {
  778.    DestroyProc = proc;
  779. }
  782. /*
  783.  * Register a C function to be called from TimerEventHandler.
  784.  */
  785. void Togl_TimerFunc( Togl_Callback *proc )
  786. {
  787.    TimerProc = proc;
  788. }
  791. /*
  792.  * Reset default callback pointers to NULL.
  793.  */
  794. void Togl_ResetDefaultCallbacks( void )
  795. {
  796.    CreateProc = NULL;
  797.    DisplayProc = NULL;
  798.    ReshapeProc = NULL;
  799.    DestroyProc = NULL;
  800.    OverlayDisplayProc = NULL;
  801.    TimerProc = NULL;
  802.    DefaultClientData = NULL;
  803. }
  806. /*
  807.  * Change the create callback for a specific Togl widget.
  808.  */
  809. void Togl_SetCreateFunc( struct Togl *togl, Togl_Callback *proc )
  810. {
  811.    togl->CreateProc = proc;
  812. }
  815. Togl_Callback* Togl_GetCreateFunc( struct Togl *togl)
  816. {
  817.   return togl->CreateProc;
  818. }
  821. /*
  822.  * Change the display/redraw callback for a specific Togl widget.
  823.  */
  824. void Togl_SetDisplayFunc( struct Togl *togl, Togl_Callback *proc )
  825. {
  826.    togl->DisplayProc = proc;
  827. }
  830. Togl_Callback* Togl_GetDisplayFunc( struct Togl *togl)
  831. {
  832.   return togl->DisplayProc;
  833. }
  836. /*
  837.  * Change the reshape callback for a specific Togl widget.
  838.  */
  839. void Togl_SetReshapeFunc( struct Togl *togl, Togl_Callback *proc )
  840. {
  841.    togl->ReshapeProc = proc;
  842. }
  845. Togl_Callback* Togl_GetReshapeFunc( struct Togl *togl)
  846. {
  847.   return togl->ReshapeProc;
  848. }
  851. /*
  852.  * Change the timer callback for a specific Togl widget.
  853.  */
  854. static void Togl_Timer( ClientData clientData );
  855. void Togl_SetTimerFunc( struct Togl *togl, Togl_Callback *proc )
  856. {
  857.    togl->TimerProc = proc;
  858.    if (!TimerProc)    /* not already set */
  859.      Tk_CreateTimerHandler( togl->Time, Togl_Timer, (ClientData)togl );
  860. }
  863. Togl_Callback* Togl_GetTimerFunc( struct Togl *togl)
  864. {
  865.   return togl->TimerProc;
  866. }
  869. /*
  870.  * Change the destroy callback for a specific Togl widget.
  871.  */
  872. void Togl_SetDestroyFunc( struct Togl *togl, Togl_Callback *proc )
  873. {
  874.    togl->DestroyProc = proc;
  875. }
  878. Togl_Callback* Togl_GetDestroyFunc( struct Togl *togl)
  879. {
  880.   return togl->DestroyProc;
  881. }
  884. /*
  885.  * Togl_Timer
  886.  *
  887.  * Gets called from Tk_CreateTimerHandler.
  888.  */
  889. static void Togl_Timer( ClientData clientData )
  890. {
  891.    struct Togl *togl = (struct Togl *) clientData;
  892.    togl->TimerProc(togl);
  893. #if (TK_MAJOR_VERSION * 100 + TK_MINOR_VERSION) >= 401
  894.    togl->timerHandler =
  895.        Tcl_CreateTimerHandler( togl->Time, Togl_Timer, (ClientData)togl );
  896. #else
  897.    togl->timerHandler =
  898.        Tk_CreateTimerHandler( togl->Time, Togl_Timer, (ClientData)togl );
  899. #endif
  900. }
  903. /*
  904.  * Togl_CreateCommand
  905.  *
  906.  *   Declares a new C sub-command of Togl callable from Tcl.
  907.  *   Every time the sub-command is called from Tcl, the
  908.  *   C routine will be called with all the arguments from Tcl.
  909.  */
  910. void Togl_CreateCommand( char *cmd_name, Togl_CmdProc *cmd_proc)
  911. {
  912.    int new_item;
  913.    Tcl_HashEntry *entry;
  914.    entry = Tcl_CreateHashEntry(&CommandTable, cmd_name, &new_item);
  915.    Tcl_SetHashValue(entry, cmd_proc);
  916. }
  919. /*
  920.  * Togl_MakeCurrent
  921.  *
  922.  *   Bind the OpenGL rendering context to the specified
  923.  *   Togl widget.
  924.  */
  925. void Togl_MakeCurrent( const struct Togl *togl )
  926. {
  927. #if defined(WIN32)
  928.    int res = wglMakeCurrent(togl->tglGLHdc, togl->tglGLHglrc);
  929.    assert(res == TRUE);
  930. #elif defined(X11)
  931.    glXMakeCurrent( Tk_Display(togl->TkWin),
  932.                    Tk_WindowId(togl->TkWin),
  933.                    togl->GlCtx );
  934. #if defined(__sgi) && defined(STEREO)
  935.    stereoMakeCurrent( Tk_Display(togl->TkWin),
  936.                       Tk_WindowId(togl->TkWin),
  937.                       togl->GlCtx );
  938. #endif /*__sgi STEREO */
  939. #endif /* WIN32 */
  940. }
  943. /*
  944.  * Called when the widget's contents must be redrawn.  Basically, we
  945.  * just call the user's render callback function.
  946.  *
  947.  * Note that the parameter type is ClientData so this function can be
  948.  * passed to Tk_DoWhenIdle().
  949.  */
  950. static void Togl_Render( ClientData clientData )
  951. {
  952.    struct Togl *togl = (struct Togl *)clientData;
  954.    if (togl->DisplayProc) {
  955.       Togl_MakeCurrent(togl);
  956.       togl->DisplayProc(togl);
  957.    }
  958.    togl->UpdatePending = GL_FALSE;
  959. }
  962. static void RenderOverlay( ClientData clientData )
  963. {
  964.    struct Togl *togl = (struct Togl *)clientData;
  966.    if (togl->OverlayFlag && togl->OverlayDisplayProc) {
  967. #if defined(WIN32)
  968.       int res = wglMakeCurrent(togl->tglGLHdc, togl->tglGLHglrc);
  969.       assert(res == TRUE);
  970. #elif defined(X11)
  971.       glXMakeCurrent( Tk_Display(togl->TkWin),
  972.       togl->OverlayWindow,
  973.       togl->OverlayCtx );
  974. #if defined(__sgi) && defined(STEREO)
  975.       stereoMakeCurrent( Tk_Display(togl->TkWin),
  976.                          togl->OverlayWindow,
  977.                          togl->OverlayCtx );
  978. #endif /*__sgi STEREO */
  979. #endif /* WIN32 */
  980.       togl->OverlayDisplayProc(togl);
  981.    }
  982.    togl->OverlayUpdatePending = GL_FALSE;
  983. }
  986. /*
  987.  * It's possible to change with this function or in a script some
  988.  * options like RGBA - ColorIndex ; Z-buffer and so on
  989.  */
  990. int Togl_Configure(Tcl_Interp *interp, struct Togl *togl,
  991.                    int argc, char *argv[], int flags)
  992. {
  993.    int oldRgbaFlag    = togl->RgbaFlag;
  994.    int oldRgbaRed     = togl->RgbaRed;
  995.    int oldRgbaGreen   = togl->RgbaGreen;
  996.    int oldRgbaBlue    = togl->RgbaBlue;
  997.    int oldDoubleFlag  = togl->DoubleFlag;
  998.    int oldDepthFlag   = togl->DepthFlag;
  999.    int oldDepthSize   = togl->DepthSize;
  1000.    int oldAccumFlag   = togl->AccumFlag;
  1001.    int oldAccumRed    = togl->AccumRed;
  1002.    int oldAccumGreen  = togl->AccumGreen;
  1003.    int oldAccumBlue   = togl->AccumBlue;
  1004.    int oldAccumAlpha  = togl->AccumAlpha;
  1005.    int oldAlphaFlag   = togl->AlphaFlag;
  1006.    int oldAlphaSize   = togl->AlphaSize;
  1007.    int oldStencilFlag = togl->StencilFlag;
  1008.    int oldStencilSize = togl->StencilSize;
  1009.    int oldAuxNumber   = togl->AuxNumber;
  1011.    if (Tk_ConfigureWidget(interp, togl->TkWin, configSpecs,
  1012.                           argc, argv, (char *)togl, flags) == TCL_ERROR) {
  1013.       return(TCL_ERROR);
  1014.    }
  1016.    Tk_GeometryRequest(togl->TkWin, togl->Width, togl->Height);
  1018.    if (togl->RgbaFlag != oldRgbaFlag
  1019.        || togl->RgbaRed != oldRgbaRed
  1020.        || togl->RgbaGreen != oldRgbaGreen
  1021.        || togl->RgbaBlue != oldRgbaBlue
  1022.        || togl->DoubleFlag != oldDoubleFlag
  1023.        || togl->DepthFlag != oldDepthFlag
  1024.        || togl->DepthSize != oldDepthSize
  1025.        || togl->AccumFlag != oldAccumFlag
  1026.        || togl->AccumRed != oldAccumRed
  1027.        || togl->AccumGreen != oldAccumGreen
  1028.        || togl->AccumBlue != oldAccumBlue
  1029.        || togl->AccumAlpha != oldAccumAlpha
  1030.        || togl->AlphaFlag != oldAlphaFlag
  1031.        || togl->AlphaSize != oldAlphaSize
  1032.        || togl->StencilFlag != oldStencilFlag
  1033.        || togl->StencilSize != oldStencilSize
  1034.        || togl->AuxNumber != oldAuxNumber) {
  1035. #ifdef MESA_COLOR_HACK
  1036.       free_default_color_cells( Tk_Display(togl->TkWin),
  1037.                                 Tk_Colormap(togl->TkWin) );
  1038. #endif
  1039.       /* Have to recreate the window and GLX context */
  1040.       if (Togl_MakeWindowExist(togl)==TCL_ERROR) {
  1041.          return TCL_ERROR;
  1042.       }
  1043.    }
  1045. #if defined(__sgi) && defined(STEREO)
  1046.    stereoInit(togl,togl->StereoFlag);
  1047. #endif
  1049.    return TCL_OK;
  1050. }
  1053. int Togl_Widget(ClientData clientData, Tcl_Interp *interp,
  1054.        int argc, char *argv[])
  1055. {
  1056.    struct Togl *togl = (struct Togl *)clientData;
  1057.    int result = TCL_OK;
  1058.    Tcl_HashEntry *entry;
  1059.    Tcl_HashSearch search;
  1060.    Togl_CmdProc *cmd_proc;
  1062.    if (argc < 2) {
  1063.       Tcl_AppendResult(interp, "wrong # args: should be "",
  1064.                        argv[0], " ?options?"", NULL);
  1065.       return TCL_ERROR;
  1066.    }
  1068.    Tk_Preserve((ClientData)togl);
  1070.    if (!strncmp(argv[1], "configure", MAX(1, strlen(argv[1])))) {
  1071.       if (argc == 2) {
  1072.          /* Return list of all configuration parameters */
  1073.          result = Tk_ConfigureInfo(interp, togl->TkWin, configSpecs,
  1074.                                    (char *)togl, (char *)NULL, 0);
  1075.       }
  1076.       else if (argc == 3) {
  1077.          if (strcmp(argv[2],"-extensions")==0) {
  1078.             /* Return a list of OpenGL extensions available */
  1079.             char *extensions;
  1080.             extensions = (char *) glGetString(GL_EXTENSIONS);
  1081.             Tcl_SetResult( interp, extensions, TCL_STATIC );
  1082.             result = TCL_OK;
  1083.          }
  1084.          else {
  1085.             /* Return a specific configuration parameter */
  1086.             result = Tk_ConfigureInfo(interp, togl->TkWin, configSpecs,
  1087.                                       (char *)togl, argv[2], 0);
  1088.          }
  1089.       }
  1090.       else {
  1091.          /* Execute a configuration change */
  1092.          result = Togl_Configure(interp, togl, argc-2, argv+2,
  1093.                                 TK_CONFIG_ARGV_ONLY);
  1094.       }
  1095.    }
  1096.    else if (!strncmp(argv[1], "render", MAX(1, strlen(argv[1])))) {
  1097.       /* force the widget to be redrawn */
  1098.       Togl_Render((ClientData) togl);
  1099.    }
  1100.    else if (!strncmp(argv[1], "swapbuffers", MAX(1, strlen(argv[1])))) {
  1101.       /* force the widget to be redrawn */
  1102.       Togl_SwapBuffers(togl);
  1103.    }
  1104.    else if (!strncmp(argv[1], "makecurrent", MAX(1, strlen(argv[1])))) {
  1105.       /* force the widget to be redrawn */
  1106.       Togl_MakeCurrent(togl);
  1107.    }
  1108.    else {
  1109.       /* Probably a user-defined function */
  1110.       entry = Tcl_FindHashEntry(&CommandTable, argv[1]);
  1111.       if (entry != NULL) {
  1112.          cmd_proc = (Togl_CmdProc *)Tcl_GetHashValue(entry);
  1113.          result = cmd_proc(togl, argc, argv);
  1114.       }
  1115.       else {
  1116.          Tcl_AppendResult(interp, "Togl: Unknown option: ", argv[1], "n",
  1117.                           "Try: configure or rendern",
  1118.                           "or one of the user-defined commands:n",
  1119.                           NULL);
  1120.          entry = Tcl_FirstHashEntry(&CommandTable, &search);
  1121.          while (entry) {
  1122.             Tcl_AppendResult(interp, "  ",
  1123.                              Tcl_GetHashKey(&CommandTable, entry),
  1124.                              "n", NULL);
  1125.             entry = Tcl_NextHashEntry(&search);
  1126.          }
  1127.          result = TCL_ERROR;
  1128.       }
  1129.    }
  1131.    Tk_Release((ClientData)togl);
  1132.    return result;
  1133. }
  1137. /*
  1138.  * Togl_Cmd
  1139.  *
  1140.  *   Called when Togl is executed - creation of a Togl widget.
  1141.  *     * Creates a new window
  1142.  *     * Creates an 'Togl' data structure
  1143.  *     * Creates an event handler for this window
  1144.  *     * Creates a command that handles this object
  1145.  *     * Configures this Togl for the given arguments
  1146.  */
  1147. static int Togl_Cmd(ClientData clientData, Tcl_Interp *interp,
  1148.                     int argc, char **argv)
  1149. {
  1150.    char *name;
  1151.    Tk_Window main = (Tk_Window)clientData;
  1152.    Tk_Window tkwin;
  1153.    struct Togl *togl;
  1155.    if (argc <= 1) {
  1156.       TCL_ERR(interp, "wrong # args: should be "pathName read filename"");
  1157.    }
  1159.    /* Create the window. */
  1160.    name = argv[1];
  1161.    tkwin = Tk_CreateWindowFromPath(interp, main, name, (char *) NULL);
  1162.    if (tkwin == NULL) {
  1163.       return TCL_ERROR;
  1164.    }
  1166.    Tk_SetClass(tkwin, "Togl");
  1168.    /* Create Togl data structure */
  1169.    togl = (struct Togl *)malloc(sizeof(struct Togl));
  1170.    if (!togl) {
  1171.       return TCL_ERROR;
  1172.    }
  1174.    togl->Next = NULL;
  1175. #if defined(WIN32)
  1176.    togl->tglGLHdc = NULL;
  1177.    togl->tglGLHglrc = NULL;
  1178. #elif defined(X11)
  1179.    togl->GlCtx = NULL;
  1180.    togl->OverlayCtx = NULL;
  1181. #endif /* WIN32 */ 
  1182.    togl->display = Tk_Display( tkwin );
  1183.    togl->TkWin = tkwin;
  1184.    togl->Interp = interp;
  1185. #ifndef NO_TK_CURSOR
  1186.    togl->Cursor = None;
  1187. #endif
  1188.    togl->Width = 0;
  1189.    togl->Height = 0;
  1190.    togl->Time = 0;
  1191.    togl->RgbaFlag = 1;
  1192.    togl->RgbaRed = 1;
  1193.    togl->RgbaGreen = 1;
  1194.    togl->RgbaBlue = 1;
  1195.    togl->DoubleFlag = 0;
  1196.    togl->DepthFlag = 0;
  1197.    togl->DepthSize = 1;
  1198.    togl->AccumFlag = 0;
  1199.    togl->AccumRed = 1;
  1200.    togl->AccumGreen = 1;
  1201.    togl->AccumBlue = 1;
  1202.    togl->AccumAlpha = 1;
  1203.    togl->AlphaFlag = 0;
  1204.    togl->AlphaSize = 1;
  1205.    togl->StencilFlag = 0;
  1206.    togl->StencilSize = 1;
  1207.    togl->OverlayFlag = 0;
  1208.    togl->StereoFlag = 0;
  1209.    togl->AuxNumber = 0;
  1210.    togl->UpdatePending = GL_FALSE;
  1211.    togl->OverlayUpdatePending = GL_FALSE;
  1212.    togl->CreateProc = CreateProc;
  1213.    togl->DisplayProc = DisplayProc;
  1214.    togl->ReshapeProc = ReshapeProc;
  1215.    togl->DestroyProc = DestroyProc;
  1216.    togl->TimerProc = TimerProc;
  1217.    togl->OverlayDisplayProc = OverlayDisplayProc;
  1218.    togl->ShareList = NULL;
  1219.    togl->ShareContext = NULL;
  1220.    togl->Ident = NULL;
  1221.    togl->Client_Data = DefaultClientData;
  1223.    /* for EPS Output */ 
  1224.    togl->EpsRedMap = togl->EpsGreenMap = togl->EpsBlueMap = NULL;
  1225.    togl->EpsMapSize = 0;
  1227.    /* Create command event handler */ 
  1228.    togl->widgetCmd = Tcl_CreateCommand(interp, Tk_PathName(tkwin),
  1229.        Togl_Widget, (ClientData)togl,
  1230.        (Tcl_CmdDeleteProc*) ToglCmdDeletedProc);
  1231.    Tk_CreateEventHandler(tkwin,
  1232.                          ExposureMask | StructureNotifyMask,
  1233.                          Togl_EventProc,
  1234.                          (ClientData)togl);
  1236.    /* Configure Togl widget */
  1237.    if (Togl_Configure(interp, togl, argc-2, argv+2, 0) == TCL_ERROR) {
  1238.    Tk_DestroyWindow(tkwin);
  1239.    goto error;
  1240.    }
  1242.    /*
  1243.     * If OpenGL window wasn't already created by Togl_Configure() we
  1244.     * create it now.  We can tell by checking if the GLX context has
  1245.     * been initialized.
  1246.     */ 
  1247. #if defined(WIN32)
  1248.    if (!togl->tglGLHdc) {
  1249. #elif defined(X11)
  1250.    if (!togl->GlCtx) {
  1251. #endif /* WIN32 */ 
  1252.       if (Togl_MakeWindowExist(togl) == TCL_ERROR) {
  1253.          goto error;
  1254.       }
  1255.    }
  1257.    /* If defined, call create callback */ 
  1258.    if (togl->CreateProc) {
  1259.       togl->CreateProc(togl);
  1260.    }
  1262.    /* If defined, call reshape proc */ 
  1263.    if (togl->ReshapeProc) {
  1264.       togl->ReshapeProc(togl);
  1265.    }
  1267.    /* If defined, setup timer */ 
  1268.    if (togl->TimerProc){
  1269.       Tk_CreateTimerHandler( togl->Time, Togl_Timer, (ClientData)togl );
  1270.    }
  1272.    Tcl_AppendResult(interp, Tk_PathName(tkwin), NULL);
  1274.    /* Add to linked list */ 
  1275.    AddToList(togl);
  1277.    return TCL_OK;
  1278. error:
  1279.    Tcl_DeleteCommand(interp, "togl");
  1280.    /*free(togl);   Don't free it, if we do a crash occurs later...*/
  1281.    return TCL_ERROR;
  1282. }
  1286. /*
  1287.  * Do all the setup for overlay planes
  1288.  * Return:   TCL_OK or TCL_ERROR
  1289.  */
  1290. static int SetupOverlay( struct Togl *togl )
  1291. {
  1292. #if defined(X11)
  1294. #ifdef GLX_TRANSPARENT_TYPE_EXT
  1295.    static int ovAttributeList[] = {
  1296.       GLX_BUFFER_SIZE, 2,
  1297.       GLX_LEVEL, 1,
  1298.       GLX_TRANSPARENT_TYPE_EXT, GLX_TRANSPARENT_INDEX_EXT,
  1299.       None
  1300.    };
  1301. #else
  1302.    static int ovAttributeList[] = {
  1303.       GLX_BUFFER_SIZE, 2,
  1304.       GLX_LEVEL, 1,
  1305.       None
  1306.    };
  1307. #endif
  1309.    Display *dpy;
  1310.    XVisualInfo *visinfo;
  1311.    TkWindow *winPtr = (TkWindow *) togl->TkWin;
  1313.    XSetWindowAttributes swa;
  1314.    Tcl_HashEntry *hPtr;
  1315.    int new_flag;
  1317.    dpy = Tk_Display(togl->TkWin);
  1319.    visinfo = glXChooseVisual( dpy, DefaultScreen(dpy), ovAttributeList );
  1320.    if (!visinfo){
  1321.       Tcl_AppendResult(togl->Interp,Tk_PathName(winPtr),
  1322.                        ": No suitable overlay index visual available",
  1323.                        (char *) NULL);
  1324.       togl->OverlayCtx = 0;
  1325.       togl->OverlayWindow = 0;
  1326.       togl->OverlayCmap = 0;
  1327.       return TCL_ERROR;
  1328.    }
  1330. #ifdef GLX_TRANSPARENT_INDEX_EXT
  1331.    {
  1332.       int fail = glXGetConfig(dpy, visinfo,GLX_TRANSPARENT_INDEX_VALUE_EXT,
  1333.                               &togl->OverlayTransparentPixel);
  1334.       if (fail)
  1335.          togl->OverlayTransparentPixel=0; /* maybe, maybe ... */
  1336.    }
  1337. #else
  1338.    togl->OverlayTransparentPixel=0; /* maybe, maybe ... */
  1339. #endif
  1341.    /*
  1342.    togl->OverlayCtx = glXCreateContext( dpy, visinfo, None, GL_TRUE );
  1343.    */
  1344.    /* NEW in Togl 1.5 beta 3 */
  1345.    /* share display lists with normal layer context */
  1346.    togl->OverlayCtx = glXCreateContext( dpy, visinfo,
  1347.                                         togl->GlCtx, GL_TRUE );
  1349.    swa.colormap = XCreateColormap( dpy, RootWindow(dpy, visinfo->screen),
  1350.                                    visinfo->visual, AllocNone );
  1351.    togl->OverlayCmap = swa.colormap;
  1353.    swa.border_pixel = 0;
  1354.    swa.event_mask = ALL_EVENTS_MASK;
  1355.    togl->OverlayWindow = XCreateWindow( dpy, Tk_WindowId(togl->TkWin), 0, 0,
  1356.                                         togl->Width, togl->Height, 0,
  1357.                                         visinfo->depth, InputOutput,
  1358.                                         visinfo->visual,
  1359.                                         CWBorderPixel|CWColormap|CWEventMask,
  1360.                                         &swa );
  1362.    hPtr = Tcl_CreateHashEntry( &winPtr->dispPtr->winTable,
  1363.                                (char *) togl->OverlayWindow, &new_flag );
  1364.    Tcl_SetHashValue( hPtr, winPtr );
  1366. /*   XMapWindow( dpy, togl->OverlayWindow );*/
  1367.    togl->OverlayIsMapped = 0;
  1369.    /* Make sure window manager installs our colormap */
  1370.    XSetWMColormapWindows( dpy, togl->OverlayWindow, &togl->OverlayWindow, 1 );
  1372.    return TCL_OK;
  1374. #elif defined(WIN32)       /* not yet implemented on Windows*/
  1376.    return TCL_ERROR;
  1378. #endif /* X11 */
  1379. }
  1382. #ifdef WIN32
  1383. #define TOGL_CLASS_NAME "Togl Class"
  1384. static ToglClassInitialized = 0;
  1386. // turn off optimizations so release version doesn't crash
  1387. #pragma optimize("g", off)
  1388. static LRESULT CALLBACK Win32WinProc( HWND hwnd, UINT message,
  1389.                                     WPARAM wParam, LPARAM lParam)
  1390. {
  1391.     LONG result;
  1392.     struct Togl *togl = (struct Togl*) GetWindowLong(hwnd, 0);
  1393.     TkWinColormap *cmap;
  1394.     HPALETTE OldPal;
  1395.     UINT i;
  1397. switch( message ){
  1398.     case WM_WINDOWPOSCHANGED:
  1399.         /* Should be processed by DefWindowProc, otherwise a double buffered
  1400.         context is not properly resized when the corresponding window is resized.*/ 
  1401.         break;
  1402.     case WM_DESTROY:
  1403.         if (togl->tglGLHglrc) {
  1404.             wglDeleteContext(togl->tglGLHglrc);
  1405.         }
  1406.         if (togl->tglGLHdc) {
  1407.             ReleaseDC(hwnd, togl->tglGLHdc);
  1408.         }
  1409.         break;
  1410.     default: 
  1411. return TkWinChildProc(hwnd, message, wParam, lParam);
  1412.     }
  1414.     result = DefWindowProc(hwnd, message, wParam, lParam);
  1415.     Tcl_ServiceAll();
  1416.     return result;
  1417. }
  1418. #pragma optimize("g", on)
  1419. #endif /* WIN32 */
  1423. /*
  1424.  * Togl_MakeWindowExist
  1425.  *
  1426.  *   Modified version of Tk_MakeWindowExist.
  1427.  *   Creates an OpenGL window for the Togl widget.
  1428.  */
  1429. static int Togl_MakeWindowExist(struct Togl *togl)
  1430. {
  1431.    XVisualInfo *visinfo = NULL;
  1432.    Display *dpy;
  1433.    int dummy;
  1434.    int attrib_list[1000];
  1435.    int attrib_count;
  1436.    TkWindow *winPtr = (TkWindow *) togl->TkWin;
  1437.    TkWindow *winPtr2;
  1438.    Window parent;
  1439.    Colormap cmap;
  1440.    XSetWindowAttributes swa;
  1441.    Tcl_HashEntry *hPtr;
  1442.    int new_flag;
  1443.    int scrnum;
  1444.    int attempt;
  1446. #if defined(X11)
  1447. #define MAX_ATTEMPTS 12
  1448.    static int ci_depths[MAX_ATTEMPTS] = {
  1449.       8, 4, 2, 1, 12, 16, 8, 4, 2, 1, 12, 16
  1450.    };
  1451.    static int dbl_flags[MAX_ATTEMPTS] = {
  1452.       0, 0, 0, 0,  0,  0, 1, 1, 1, 1,  1,  1
  1453.    };
  1454. #elif defined(WIN32)
  1455.    HWND hwnd, parentWin;
  1456.    int style, pixelformat;
  1457.    HANDLE hInstance;
  1458.    WNDCLASS ToglClass;
  1459.    PIXELFORMATDESCRIPTOR pfd;
  1460.    XVisualInfo VisInf;
  1461. #endif /* X11 */
  1463.    dpy = Tk_Display(togl->TkWin);
  1465.    if (winPtr->window != None) {
  1466.       XDestroyWindow(dpy, winPtr->window);
  1467.       winPtr->window = 0;
  1468.    }
  1470. #if defined(X11)
  1471.    /* Make sure OpenGL's GLX extension supported */
  1472.    if (!glXQueryExtension(dpy, &dummy, &dummy)) {
  1473.       TCL_ERR(togl->Interp, "Togl: X server has no OpenGL GLX extension");
  1474.    }
  1476.    if (togl->ShareContext && FindTogl(togl->ShareContext)) {
  1477.       /* share OpenGL context with existing Togl widget */
  1478.       struct Togl *shareWith = FindTogl(togl->ShareContext);
  1479.       assert(shareWith);
  1480.       assert(shareWith->GlCtx);
  1481.       togl->GlCtx = shareWith->GlCtx;
  1482.       togl->VisInfo = shareWith->VisInfo;
  1483.       visinfo = togl->VisInfo;
  1484.       printf("SHARE CTXn");
  1485.    }
  1486.    else {
  1487.       /* It may take a few tries to get a visual */
  1488.       for (attempt=0; attempt<MAX_ATTEMPTS; attempt++) {
  1489.          attrib_count = 0;
  1490.          attrib_list[attrib_count++] = GLX_USE_GL;
  1491.          if (togl->RgbaFlag) {
  1492.             /* RGB[A] mode */
  1493.             attrib_list[attrib_count++] = GLX_RGBA;
  1494.             attrib_list[attrib_count++] = GLX_RED_SIZE;
  1495.             attrib_list[attrib_count++] = togl->RgbaRed;
  1496.             attrib_list[attrib_count++] = GLX_GREEN_SIZE;
  1497.             attrib_list[attrib_count++] = togl->RgbaGreen;
  1498.             attrib_list[attrib_count++] = GLX_BLUE_SIZE;
  1499.             attrib_list[attrib_count++] = togl->RgbaBlue;
  1500.             if (togl->AlphaFlag) {
  1501.                attrib_list[attrib_count++] = GLX_ALPHA_SIZE;
  1502.                attrib_list[attrib_count++] = togl->AlphaSize;
  1503.             }
  1505.             /* for EPS Output */
  1506.             if ( togl->EpsRedMap) free( ( char *)togl->EpsRedMap);
  1507.             if ( togl->EpsGreenMap) free( ( char *)togl->EpsGreenMap);
  1508.             if ( togl->EpsBlueMap) free( ( char *)togl->EpsBlueMap);
  1509.             togl->EpsRedMap = togl->EpsGreenMap = togl->EpsBlueMap = NULL;
  1510.             togl->EpsMapSize = 0;
  1511.          }
  1512.          else {
  1513.             /* Color index mode */
  1514.             int depth;
  1515.             attrib_list[attrib_count++] = GLX_BUFFER_SIZE;
  1516.             depth = ci_depths[attempt];
  1517.             attrib_list[attrib_count++] = depth;
  1518.          }
  1519.          if (togl->DepthFlag) {
  1520.             attrib_list[attrib_count++] = GLX_DEPTH_SIZE;
  1521.             attrib_list[attrib_count++] = togl->DepthSize;
  1522.          }
  1523.          if (togl->DoubleFlag || dbl_flags[attempt]) {
  1524.             attrib_list[attrib_count++] = GLX_DOUBLEBUFFER;
  1525.          }
  1526.          if (togl->StencilFlag) {
  1527.             attrib_list[attrib_count++] = GLX_STENCIL_SIZE;
  1528.             attrib_list[attrib_count++] = togl->StencilSize;
  1529.          }
  1530.          if (togl->AccumFlag) {
  1531.             attrib_list[attrib_count++] = GLX_ACCUM_RED_SIZE;
  1532.             attrib_list[attrib_count++] = togl->AccumRed;
  1533.             attrib_list[attrib_count++] = GLX_ACCUM_GREEN_SIZE;
  1534.             attrib_list[attrib_count++] = togl->AccumGreen;
  1535.             attrib_list[attrib_count++] = GLX_ACCUM_BLUE_SIZE;
  1536.             attrib_list[attrib_count++] = togl->AccumBlue;
  1537.             if (togl->AlphaFlag) {
  1538.                attrib_list[attrib_count++] = GLX_ACCUM_ALPHA_SIZE;
  1539.                attrib_list[attrib_count++] = togl->AccumAlpha;
  1540.             }
  1541.          }
  1542.          if (togl->AuxNumber != 0) {
  1543.             attrib_list[attrib_count++] = GLX_AUX_BUFFERS;
  1544.             attrib_list[attrib_count++] = togl->AuxNumber;
  1545.          }
  1547.          /* stereo hack */
  1548.          /*
  1549.            if (togl->StereoFlag) {
  1550.            attrib_list[attrib_count++] = GLX_STEREO;
  1551.            }
  1552.          */
  1553.          attrib_list[attrib_count++] = None;
  1555.          visinfo = glXChooseVisual( dpy, DefaultScreen(dpy), attrib_list );
  1556.          if (visinfo) {
  1557.             /* found a GLX visual! */
  1558.             break;
  1559.          }
  1560.       }
  1562.       togl->VisInfo = visinfo;
  1564.       if (visinfo==NULL) {
  1565.          TCL_ERR(togl->Interp, "Togl: couldn't get visual");
  1566.       }
  1568.       /*
  1569.        * Create a new OpenGL rendering context.
  1570.        */
  1571.       if (togl->ShareList) {
  1572.          /* share display lists with existing togl widget */
  1573.          struct Togl *shareWith = FindTogl(togl->ShareList);
  1574.          GLXContext shareCtx;
  1575.          if (shareWith)
  1576.             shareCtx = shareWith->GlCtx;
  1577.          else
  1578.             shareCtx = None;
  1579.          togl->GlCtx = glXCreateContext(dpy, visinfo, shareCtx, GL_TRUE);
  1580.       }
  1581.       else {
  1582.          /* don't share display lists */
  1583.          togl->GlCtx = glXCreateContext(dpy, visinfo, None, GL_TRUE);
  1584.       }
  1586.       if (togl->GlCtx == NULL) {
  1587.          TCL_ERR(togl->Interp, "could not create rendering context");
  1588.       }
  1590.    }
  1593. #endif /* X11 */
  1595.    /* Find parent of window */
  1596.    /* Necessary for creation */
  1597.    if ((winPtr->parentPtr == NULL) || (winPtr->flags & TK_TOP_LEVEL)) {
  1598.       parent = XRootWindow(winPtr->display, winPtr->screenNum);
  1599.    }
  1600.    else {
  1601.       if (winPtr->parentPtr->window == None) {
  1602.          Tk_MakeWindowExist((Tk_Window) winPtr->parentPtr);
  1603.       }
  1604.       parent = winPtr->parentPtr->window;
  1605.    }
  1607. #ifdef WIN32
  1608.    parentWin = Tk_GetHWND(parent);
  1609.    hInstance = Tk_GetHINSTANCE();
  1611.    if (ToglClassInitialized == 0) {
  1612.    ToglClassInitialized = 1;
  1613.        ToglClass.style = CS_HREDRAW | CS_VREDRAW;
  1614.        ToglClass.cbClsExtra = 0;
  1615.        ToglClass.cbWndExtra = 4;   /* to save struct Togl* */
  1616.        ToglClass.hInstance = hInstance;
  1617.        ToglClass.hbrBackground = NULL;
  1618.        ToglClass.lpszMenuName = NULL;
  1619.        ToglClass.lpszClassName = TOGL_CLASS_NAME;
  1620.        ToglClass.lpfnWndProc = Win32WinProc;
  1621.        ToglClass.hIcon = NULL;
  1622.        ToglClass.hCursor = NULL;
  1623.        if (!RegisterClass(&ToglClass)){
  1624.            TCL_ERR(togl->Interp, "unable register Togl window class");
  1625.        }
  1626.    }
  1628.    hwnd = CreateWindow(TOGL_CLASS_NAME, NULL, WS_CHILD | WS_CLIPCHILDREN
  1629.                        | WS_CLIPSIBLINGS, 0, 0, togl->Width, togl->Height,
  1630.                        parentWin, NULL, hInstance, NULL);
  1631.    
  1632.    SetWindowLong(hwnd, 0, (LONG) togl);
  1633.    SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
  1634.                SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
  1636.    togl->tglGLHdc = GetDC(hwnd);
  1638.    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
  1639.    pfd.nVersion = 1;
  1640.    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
  1641.    if (togl->DoubleFlag) {
  1642.         pfd.dwFlags |= PFD_DOUBLEBUFFER;
  1643.    }
  1644.    /* The stereo flag is not supported in the current generic OpenGL
  1645.     * implementation, but may be supported by specific hardware devices.
  1646.     */
  1647.    if (togl->StereoFlag) {
  1648.         pfd.dwFlags |= PFD_STEREO;
  1649.    }
  1651.    pfd.cColorBits = togl->RgbaRed + togl->RgbaGreen + togl->RgbaBlue;
  1652.    pfd.iPixelType = togl->RgbaFlag ? PFD_TYPE_RGBA : PFD_TYPE_COLORINDEX;
  1653.    /* Alpha bitplanes are not supported in the current generic OpenGL
  1654.     * implementation, but may be supported by specific hardware devices.
  1655.     */
  1656.    pfd.cAlphaBits = togl->AlphaFlag ? togl->AlphaSize : 0;
  1657.    pfd.cAccumBits = togl->AccumFlag ? (togl->AccumRed + togl->AccumGreen +
  1658.                                        togl->AccumBlue +togl->AccumAlpha) : 0;
  1659.    pfd.cDepthBits = togl->DepthFlag ? togl->DepthSize : 0;
  1660.    pfd.cStencilBits = togl->StencilFlag ? togl->StencilSize : 0;
  1661.    /* Auxiliary buffers are not supported in the current generic OpenGL
  1662.     * implementation, but may be supported by specific hardware devices.
  1663.     */
  1664.    pfd.cAuxBuffers = togl->AuxNumber;
  1665.    pfd.iLayerType = PFD_MAIN_PLANE;
  1667.    if ( (pixelformat = ChoosePixelFormat(togl->tglGLHdc, &pfd)) == 0 ) {
  1668.         TCL_ERR(togl->Interp, "Togl: couldn't choose pixel format");
  1669.    }
  1670.    if (SetPixelFormat(togl->tglGLHdc, pixelformat, &pfd) == FALSE) {
  1671.         TCL_ERR(togl->Interp, "Togl: couldn't choose pixel format");
  1672.    }
  1674.    /* Get the actual pixel format */
  1675.    DescribePixelFormat(togl->tglGLHdc, pixelformat, sizeof(pfd), &pfd);
  1677.    /* Create an OpenGL rendering context */
  1678.    togl->tglGLHglrc = wglCreateContext(togl->tglGLHdc);
  1679.    if (!togl->tglGLHglrc) {
  1680.         TCL_ERR(togl->Interp, "could not create rendering context");
  1681.    }
  1683.    /* Just for portability, define the simplest visinfo */
  1684.    visinfo = &VisInf;
  1685.    visinfo->visual = DefaultVisual(dpy, DefaultScreen(dpy));
  1686.    visinfo->depth = visinfo->visual->bits_per_rgb;
  1687. #endif /*WIN32 */
  1690.    /*
  1691.     * find a colormap
  1692.     */
  1693.    scrnum = DefaultScreen(dpy);
  1694.    if (togl->RgbaFlag) {
  1695.       /* Colormap for RGB mode */
  1696. #if defined(X11)
  1697.       cmap = get_rgb_colormap( dpy, scrnum, visinfo );
  1698. #elif defined(WIN32)
  1699.       if (pfd.dwFlags & PFD_NEED_PALETTE) {
  1700.          cmap = Win32CreateRgbColormap(pfd);
  1701.       }
  1702.       else {
  1703.          cmap = DefaultColormap(dpy,scrnum);
  1704.       }
  1706.       /* for EPS Output */
  1707.       if ( togl->EpsRedMap) free( ( char *)togl->EpsRedMap);
  1708.       if ( togl->EpsGreenMap) free( ( char *)togl->EpsGreenMap);
  1709.       if ( togl->EpsBlueMap) free( ( char *)togl->EpsBlueMap);
  1710.       togl->EpsRedMap = togl->EpsGreenMap = togl->EpsBlueMap = NULL;
  1711.       togl->EpsMapSize = 0;
  1712. #endif /* X11 */
  1713.    }
  1714.    else {
  1715.       /* Colormap for CI mode */
  1716. #ifdef WIN32
  1717.       togl->CiColormapSize = 1 << pfd.cColorBits;
  1718.       togl->CiColormapSize = togl->CiColormapSize < MAX_CI_COLORMAP_SIZE ?
  1719.                              togl->CiColormapSize : MAX_CI_COLORMAP_SIZE;
  1721. #endif /* WIN32 */
  1722.       if (togl->PrivateCmapFlag) {
  1723.          /* need read/write colormap so user can store own color entries */
  1724. #if defined(X11)
  1725.          cmap = XCreateColormap(dpy, RootWindow(dpy, visinfo->screen),
  1726.                                 visinfo->visual, AllocAll);
  1727. #elif defined(WIN32)
  1728.          cmap = Win32CreateCiColormap(togl);
  1729. #endif /* X11 */
  1730.       }
  1731.       else {
  1732.          if (visinfo->visual==DefaultVisual(dpy, scrnum)) {
  1733.             /* share default/root colormap */
  1734.             cmap = DefaultColormap(dpy,scrnum);
  1735.          }
  1736.          else {
  1737.             /* make a new read-only colormap */
  1738.             cmap = XCreateColormap(dpy, RootWindow(dpy, visinfo->screen),
  1739.                                    visinfo->visual, AllocNone);
  1740.          }
  1741.       }
  1742.    }
  1744.    /* Make sure Tk knows to switch to the new colormap when the cursor
  1745.     * is over this window when running in color index mode.
  1746.     */
  1747.    Tk_SetWindowVisual(togl->TkWin, visinfo->visual, visinfo->depth, cmap);
  1748. #ifdef WIN32
  1749.    /* Install the colormap */
  1750.    SelectPalette(togl->tglGLHdc, ((TkWinColormap *)cmap)->palette, TRUE);
  1751.    RealizePalette(togl->tglGLHdc);
  1752. #endif /* WIN32 */
  1754. #if defined(X11)
  1755.    swa.colormap = cmap;
  1756.    swa.border_pixel = 0;
  1757.    swa.event_mask = ALL_EVENTS_MASK;
  1758.    winPtr->window = XCreateWindow(dpy, parent,
  1759.                                   0, 0, togl->Width, togl->Height,
  1760.                                   0, visinfo->depth,
  1761.                                   InputOutput, visinfo->visual,
  1762.                                   CWBorderPixel | CWColormap | CWEventMask,
  1763.                                   &swa);
  1765.    /* Make sure window manager installs our colormap */
  1766.    XSetWMColormapWindows( dpy, winPtr->window, &winPtr->window, 1 );
  1767. #elif defined(WIN32)
  1768.    winPtr->window = Tk_AttachHWND((Tk_Window)winPtr, hwnd);
  1769. #endif /* X11 */
  1771.    hPtr = Tcl_CreateHashEntry(&winPtr->dispPtr->winTable,
  1772.                               (char *) winPtr->window, &new_flag);
  1773.    Tcl_SetHashValue(hPtr, winPtr);
  1775.    winPtr->dirtyAtts = 0;
  1776.    winPtr->dirtyChanges = 0;
  1777. #ifdef TK_USE_INPUT_METHODS
  1778.    winPtr->inputContext = NULL;
  1779. #endif /* TK_USE_INPUT_METHODS */
  1781.    if (!(winPtr->flags & TK_TOP_LEVEL)) {
  1782.       /*
  1783.        * If any siblings higher up in the stacking order have already
  1784.        * been created then move this window to its rightful position
  1785.        * in the stacking order.
  1786.        *
  1787.        * NOTE: this code ignores any changes anyone might have made
  1788.        * to the sibling and stack_mode field of the window's attributes,
  1789.        * so it really isn't safe for these to be manipulated except
  1790.        * by calling Tk_RestackWindow.
  1791.        */
  1793.       for (winPtr2 = winPtr->nextPtr; winPtr2 != NULL;
  1794.            winPtr2 = winPtr2->nextPtr) {
  1795.          if ((winPtr2->window != None) && !(winPtr2->flags & TK_TOP_LEVEL)) {
  1796.             XWindowChanges changes;
  1797.             changes.sibling = winPtr2->window;
  1798.             changes.stack_mode = Below;
  1799.             XConfigureWindow(winPtr->display, winPtr->window,
  1800.                              CWSibling|CWStackMode, &changes);
  1801.             break;
  1802.          }
  1803.       }
  1805.       /*
  1806.        * If this window has a different colormap than its parent, add
  1807.        * the window to the WM_COLORMAP_WINDOWS property for its top-level.
  1808.        */
  1810.       if ((winPtr->parentPtr != NULL) &&
  1811.           (winPtr->atts.colormap != winPtr->parentPtr->atts.colormap)) {
  1812.          TkWmAddToColormapWindows(winPtr);
  1813.       }
  1814.    }
  1816.    if (togl->OverlayFlag) {
  1817.       if (SetupOverlay( togl )==TCL_ERROR) {
  1818.          fprintf(stderr,"Warning: couldn't setup overlay.n");
  1819.          togl->OverlayFlag = 0;
  1820.       }
  1821.    }
  1823.    /*
  1824.     * Issue a ConfigureNotify event if there were deferred configuration
  1825.     * changes (but skip it if the window is being deleted;  the
  1826.     * ConfigureNotify event could cause problems if we're being called
  1827.     * from Tk_DestroyWindow under some conditions).
  1828.     */
  1829.    if ((winPtr->flags & TK_NEED_CONFIG_NOTIFY)
  1830.        && !(winPtr->flags & TK_ALREADY_DEAD)){
  1831.       XEvent event;
  1833.       winPtr->flags &= ~TK_NEED_CONFIG_NOTIFY;
  1835.       event.type = ConfigureNotify;
  1836.       event.xconfigure.serial = LastKnownRequestProcessed(winPtr->display);
  1837.       event.xconfigure.send_event = False;
  1838.       event.xconfigure.display = winPtr->display;
  1839.       event.xconfigure.event = winPtr->window;
  1840.       event.xconfigure.window = winPtr->window;
  1841.       event.xconfigure.x = winPtr->changes.x;
  1842.       event.xconfigure.y = winPtr->changes.y;
  1843.       event.xconfigure.width = winPtr->changes.width;
  1844.       event.xconfigure.height = winPtr->changes.height;
  1845.       event.xconfigure.border_width = winPtr->changes.border_width;
  1846.       if (winPtr->changes.stack_mode == Above) {
  1847.          event.xconfigure.above = winPtr->changes.sibling;
  1848.       }
  1849.       else {
  1850.          event.xconfigure.above = None;
  1851.       }
  1852.       event.xconfigure.override_redirect = winPtr->atts.override_redirect;
  1853.       Tk_HandleEvent(&event);
  1854.    }
  1856.    /* Request the X window to be displayed */
  1857.    XMapWindow(dpy, Tk_WindowId(togl->TkWin));
  1859.    /* Bind the context to the window and make it the current context. */
  1860.    Togl_MakeCurrent(togl);
  1862. #if defined(X11)
  1863.    /* Check for a single/double buffering snafu */
  1864.    {
  1865.       int dbl_flag;
  1866.       if (glXGetConfig( dpy, visinfo, GLX_DOUBLEBUFFER, &dbl_flag )) {
  1867.          if (togl->DoubleFlag==0 && dbl_flag) {
  1868.             /* We requested single buffering but had to accept a */
  1869.             /* double buffered visual.  Set the GL draw buffer to */
  1870.             /* be the front buffer to simulate single buffering. */
  1871.             glDrawBuffer( GL_FRONT );
  1872.          }
  1873.       }
  1874.    }
  1875. #endif /* X11 */
  1877.    /* for EPS Output */
  1878.    if ( !togl->RgbaFlag) {
  1879.       GLint index_bits;
  1880.       int index_size;
  1881. #if defined(X11)
  1882.       glGetIntegerv( GL_INDEX_BITS, &index_bits );
  1883.       index_size = 1 << index_bits;
  1884. #elif defined(WIN32)
  1885.       index_size = togl->CiColormapSize;
  1886. #endif /* X11 */
  1887.       if ( togl->EpsMapSize != index_size) {
  1888.          if ( togl->EpsRedMap) free( ( char *)togl->EpsRedMap);
  1889.          if ( togl->EpsGreenMap) free( ( char *)togl->EpsGreenMap);
  1890.          if ( togl->EpsBlueMap) free( ( char *)togl->EpsBlueMap);
  1891.          togl->EpsMapSize = index_size;
  1892.          togl->EpsRedMap = ( GLfloat *)calloc( index_size, sizeof( GLfloat));
  1893.          togl->EpsGreenMap = ( GLfloat *)calloc( index_size, sizeof( GLfloat));
  1894.          togl->EpsBlueMap = ( GLfloat *)calloc( index_size, sizeof( GLfloat));
  1895.       }
  1896.    }
  1898.    return TCL_OK;
  1899. }
  1901. /*
  1902.  * ToglCmdDeletedProc
  1903.  *
  1904.  *      This procedure is invoked when a widget command is deleted.  If
  1905.  *      the widget isn't already in the process of being destroyed,
  1906.  *      this command destroys it.
  1907.  *
  1908.  * Results:
  1909.  *      None.
  1910.  *
  1911.  * Side effects:
  1912.  *      The widget is destroyed.
  1913.  *
  1914.  *----------------------------------------------------------------------
  1915.  */ 
  1916. static void ToglCmdDeletedProc( ClientData clientData )
  1917. {
  1918.    struct Togl *togl = (struct Togl *)clientData;
  1919.    Tk_Window tkwin = togl->TkWin;
  1921.    /*
  1922.     * This procedure could be invoked either because the window was
  1923.     * destroyed and the command was then deleted (in which case tkwin
  1924.     * is NULL) or because the command was deleted, and then this procedure
  1925.     * destroys the widget.
  1926.     */
  1928.    /* NEW in togl 1.5 beta 3 */
  1929.    if (togl && tkwin) {
  1930.       Tk_DeleteEventHandler(tkwin,
  1931.                          ExposureMask | StructureNotifyMask,
  1932.                          Togl_EventProc,
  1933.                          (ClientData)togl);
  1934.    }
  1936.    /* NEW in togl 1.5 beta 3 */
  1937. #if defined(X11)
  1938.    if (togl->GlCtx) {
  1939.       /* XXX this might be bad if two or more Togl widgets share a context */
  1940.       glXDestroyContext( togl->display, togl->GlCtx );
  1941.       togl->GlCtx = NULL;
  1942.    }
  1943.    if (togl->OverlayCtx) {
  1944.       Tcl_HashEntry *entryPtr;
  1945.       TkWindow *winPtr = (TkWindow *) togl->TkWin;
  1946.       if (winPtr != NULL) {
  1947. entryPtr = Tcl_FindHashEntry(&winPtr->dispPtr->winTable,
  1948.      (char *) togl->OverlayWindow );
  1949. Tcl_DeleteHashEntry(entryPtr);
  1950.       }
  1951.       assert (togl->display && togl->OverlayCtx);
  1952.       glXDestroyContext( togl->display, togl->OverlayCtx );
  1953.       togl->OverlayCtx = NULL;
  1954.    }
  1955. #endif
  1957.    if (tkwin != NULL) {
  1958.       togl->TkWin = NULL;
  1959.       Tk_DestroyWindow(tkwin);
  1960.    }
  1961. }
  1964. /*
  1965.  * Togl_Destroy
  1966.  *
  1967.  * Gets called when an Togl widget is destroyed.
  1968.  */
  1969. #if (TK_MAJOR_VERSION * 100 + TK_MINOR_VERSION) >= 401
  1970. static void Togl_Destroy( char *clientData )
  1971. #else
  1972. static void Togl_Destroy( ClientData clientData )
  1973. #endif
  1974. {
  1975.    struct Togl *togl = (struct Togl *)clientData;
  1977.    if (togl->DestroyProc) {
  1978.       togl->DestroyProc(togl);
  1979.    }
  1981.    Tk_FreeOptions(configSpecs, (char *)togl, togl->display, 0);
  1983. #ifndef NO_TK_CURSOR
  1984.    if (togl->Cursor != None) {
  1985.       Tk_FreeCursor(togl->display, togl->Cursor);
  1986.    }
  1987. #endif
  1989.    /* remove from linked list */
  1990.    RemoveFromList(togl);
  1992.    free(togl);
  1993. }
  1997. /*
  1998.  * This gets called to handle Togl window configuration events
  1999.  */
  2000. static void Togl_EventProc(ClientData clientData, XEvent *eventPtr)
  2001. {
  2002.    struct Togl *togl = (struct Togl *)clientData;
  2004.    switch (eventPtr->type) {
  2005.       case Expose:
  2006.          if (eventPtr->xexpose.count == 0) {
  2007.             if (!togl->UpdatePending &&
  2008.                 eventPtr->xexpose.window==Tk_WindowId(togl->TkWin)) {
  2009.                Togl_PostRedisplay(togl);
  2010.             }
  2011. #if defined(X11)
  2012.             if (!togl->OverlayUpdatePending && togl->OverlayFlag
  2013.                 && togl->OverlayIsMapped
  2014.                 && eventPtr->xexpose.window==togl->OverlayWindow){
  2015.                Togl_PostOverlayRedisplay(togl);
  2016.             }
  2017. #endif /*X11*/
  2018.          }
  2019.          break;
  2020.       case ConfigureNotify:
  2021.          if (togl->Width != Tk_Width(togl->TkWin) ||
  2022.              togl->Height != Tk_Height(togl->TkWin)) {
  2023.             togl->Width = Tk_Width(togl->TkWin);
  2024.             togl->Height = Tk_Height(togl->TkWin);
  2025.             XResizeWindow(Tk_Display(togl->TkWin), Tk_WindowId(togl->TkWin),
  2026.                           togl->Width, togl->Height);
  2027. #if defined(X11)
  2028.             if (togl->OverlayFlag) {
  2029.                XResizeWindow( Tk_Display(togl->TkWin), togl->OverlayWindow,
  2030.                               togl->Width, togl->Height );
  2031.                XRaiseWindow( Tk_Display(togl->TkWin), togl->OverlayWindow );
  2032.             }
  2033. #endif /*X11*/
  2034.             Togl_MakeCurrent(togl);
  2035.             if (togl->ReshapeProc) {
  2036.                togl->ReshapeProc(togl);
  2037.             }
  2038.             else {
  2039.                glViewport(0, 0, togl->Width, togl->Height);
  2040. #if defined(X11)
  2041.                if (togl->OverlayFlag) {
  2042.                   Togl_UseLayer( togl,TOGL_OVERLAY );
  2043.                   glViewport( 0, 0, togl->Width, togl->Height );
  2044.                   Togl_UseLayer( togl, TOGL_NORMAL );
  2045.                }
  2046. #endif /*X11*/
  2047.             }
  2048. #ifndef WIN32 /* causes double redisplay on Win32 platform */
  2049.             Togl_PostRedisplay(togl);
  2050. #endif /* WIN32 */
  2051.          }
  2052.          break;
  2053.       case MapNotify:
  2054.          break;
  2055.       case DestroyNotify:
  2056.  if (togl->TkWin != NULL) {
  2057.     togl->TkWin = NULL;
  2058. #if (TCL_MAJOR_VERSION * 100 + TCL_MINOR_VERSION) >= 800
  2059.             /* This function new in Tcl/Tk 8.0 */
  2060.             Tcl_DeleteCommandFromToken( togl->Interp, togl->widgetCmd );
  2061. #endif
  2062.  }
  2063.  if (togl->TimerProc != NULL) {
  2064. #if (TK_MAJOR_VERSION * 100 + TK_MINOR_VERSION) >= 401
  2065.     Tcl_DeleteTimerHandler(togl->timerHandler);
  2066. #else
  2067.     Tk_DeleteTimerHandler(togl->timerHandler);
  2068. #endif
  2069.     
  2070.  }
  2071.  if (togl->UpdatePending) {
  2072. #if (TCL_MAJOR_VERSION * 100 + TCL_MINOR_VERSION) >= 705
  2073.             Tcl_CancelIdleCall(Togl_Render, (ClientData) togl);
  2074. #else
  2075.             Tk_CancelIdleCall(Togl_Render, (ClientData) togl);
  2076. #endif
  2077.  }
  2079. #if (TK_MAJOR_VERSION * 100 + TK_MINOR_VERSION) >= 401
  2080.          Tcl_EventuallyFree( (ClientData) togl, Togl_Destroy );
  2081. #else
  2082.          Tk_EventuallyFree((ClientData)togl, Togl_Destroy);
  2083. #endif
  2085.          break;
  2086.       default:
  2087.          /*nothing*/
  2088.          ;
  2089.    }
  2090. }
  2094. void Togl_PostRedisplay( struct Togl *togl )
  2095. {
  2096.    if (!togl->UpdatePending) {
  2097.       Tk_DoWhenIdle( Togl_Render, (ClientData) togl );
  2098.       togl->UpdatePending = GL_TRUE;
  2099.    }
  2100. }
  2104. void Togl_SwapBuffers( const struct Togl *togl )
  2105. {
  2106.    if (togl->DoubleFlag) {
  2107. #if defined(WIN32)
  2108.       int res = SwapBuffers(togl->tglGLHdc);
  2109.       assert(res == TRUE);
  2110. #elif defined(X11)
  2111.       glXSwapBuffers( Tk_Display(togl->TkWin), Tk_WindowId(togl->TkWin) );
  2112. #endif /* WIN32 */
  2113.    }
  2114.    else {
  2115.       glFlush();
  2116.    }
  2117. }
  2121. char *Togl_Ident( const struct Togl *togl )
  2122. {
  2123.    return togl->Ident;
  2124. }
  2127. int Togl_Width( const struct Togl *togl )
  2128. {
  2129.    return togl->Width;
  2130. }
  2133. int Togl_Height( const struct Togl *togl )
  2134. {
  2135.    return togl->Height;
  2136. }
  2139. Tcl_Interp *Togl_Interp( const struct Togl *togl )
  2140. {
  2141.    return togl->Interp;
  2142. }
  2145. Tk_Window Togl_TkWin( const struct Togl *togl )
  2146. {
  2147.    return togl->TkWin;
  2148. }
  2151. #if defined(X11)
  2152. /*
  2153.  * A replacement for XAllocColor.  This function should never
  2154.  * fail to allocate a color.  When XAllocColor fails, we return
  2155.  * the nearest matching color.  If we have to allocate many colors
  2156.  * this function isn't too efficient; the XQueryColors() could be
  2157.  * done just once.
  2158.  * Written by Michael Pichler, Brian Paul, Mark Kilgard
  2159.  * Input:  dpy - X display
  2160.  *         cmap - X colormap
  2161.  *         cmapSize - size of colormap
  2162.  * In/Out: color - the XColor struct
  2163.  * Output:  exact - 1=exact color match, 0=closest match
  2164.  */
  2165. static void
  2166. noFaultXAllocColor( Display *dpy, Colormap cmap, int cmapSize,
  2167.                     XColor *color, int *exact )
  2168. {
  2169.    XColor *ctable, subColor;
  2170.    int i, bestmatch;
  2171.    double mindist;       /* 3*2^16^2 exceeds long int precision.
  2172.                           */
  2174.    /* First try just using XAllocColor. */
  2175.    if (XAllocColor(dpy, cmap, color)) {
  2176.       *exact = 1;
  2177.       return;
  2178.    }
  2180.    /* Retrieve color table entries. */
  2181.    /* XXX alloca candidate. */
  2182.    ctable = (XColor *) malloc(cmapSize * sizeof(XColor));
  2183.    for (i = 0; i < cmapSize; i++) {
  2184.       ctable[i].pixel = i;
  2185.    }
  2186.    XQueryColors(dpy, cmap, ctable, cmapSize);
  2188.    /* Find best match. */
  2189.    bestmatch = -1;
  2190.    mindist = 0.0;
  2191.    for (i = 0; i < cmapSize; i++) {
  2192.       double dr = (double) color->red - (double) ctable[i].red;
  2193.       double dg = (double) color->green - (double) ctable[i].green;
  2194.       double db = (double) color->blue - (double) ctable[i].blue;
  2195.       double dist = dr * dr + dg * dg + db * db;
  2196.       if (bestmatch < 0 || dist < mindist) {
  2197.          bestmatch = i;
  2198.          mindist = dist;
  2199.       }
  2200.    }
  2202.    /* Return result. */
  2203.    subColor.red = ctable[bestmatch].red;
  2204.    subColor.green = ctable[bestmatch].green;
  2205.    subColor.blue = ctable[bestmatch].blue;
  2206.    free(ctable);
  2207.    /* Try to allocate the closest match color.  This should only
  2208.     * fail if the cell is read/write.  Otherwise, we're incrementing
  2209.     * the cell's reference count.
  2210.     */
  2211.    if (!XAllocColor(dpy, cmap, &subColor)) {
  2212.       /* do this to work around a problem reported by Frank Ortega */
  2213.       subColor.pixel = (unsigned long) bestmatch;
  2214.       subColor.red   = ctable[bestmatch].red;
  2215.       subColor.green = ctable[bestmatch].green;
  2216.       subColor.blue  = ctable[bestmatch].blue;
  2217.       subColor.flags = DoRed | DoGreen | DoBlue;
  2218.    }
  2219.    *color = subColor;
  2220. }
  2222. #elif defined(WIN32)
  2224. static UINT Win32AllocColor( const struct Togl *togl,
  2225.                              float red, float green, float blue )
  2226. {
  2227. /* Modified version of XAllocColor emulation of Tk.
  2228. *      - returns index, instead of color itself
  2229. *      - allocates logical palette entry even for non-palette devices
  2230. */
  2232.     TkWinColormap *cmap = (TkWinColormap *) Tk_Colormap(togl->TkWin);
  2233.     UINT index;
  2234.     COLORREF newColor, closeColor;
  2235.     PALETTEENTRY entry, closeEntry;
  2236.     int new, refCount;
  2237.     Tcl_HashEntry *entryPtr;
  2239.     entry.peRed =  red*255 + .5;
  2240.     entry.peGreen = green*255 + .5;
  2241.     entry.peBlue = blue*255 + .5;
  2242.     entry.peFlags = 0;
  2244. /*
  2245.  * Find the nearest existing palette entry.
  2246.  */
  2248.     newColor = RGB(entry.peRed, entry.peGreen, entry.peBlue);
  2249.     index = GetNearestPaletteIndex(cmap->palette, newColor);
  2250.     GetPaletteEntries(cmap->palette, index, 1, &closeEntry);
  2251.     closeColor = RGB(closeEntry.peRed, closeEntry.peGreen,  closeEntry.peBlue);
  2253.      /*
  2254.  * If this is not a duplicate and colormap is not full, allocate a new entry.
  2255.  */
  2257. if (newColor != closeColor) {
  2258.         if (cmap->size == togl->CiColormapSize) {
  2259.             entry = closeEntry;
  2260.         }
  2261.         else {
  2262.             cmap->size++;
  2263.     ResizePalette(cmap->palette, cmap->size);
  2264.     index = cmap->size -1;
  2265.     SetPaletteEntries(cmap->palette, index, 1, &entry);
  2266.     SelectPalette(togl->tglGLHdc, cmap->palette, TRUE);
  2267.     RealizePalette(togl->tglGLHdc);
  2268. }
  2269. }
  2270. newColor = PALETTERGB(entry.peRed, entry.peGreen, entry.peBlue);
  2271. entryPtr = Tcl_CreateHashEntry(&cmap->refCounts, (char *) newColor, &new);
  2272. if (new) {
  2273.     refCount = 1;
  2274. } else {
  2275.     refCount = ((int) Tcl_GetHashValue(entryPtr)) + 1;
  2276. }
  2277. Tcl_SetHashValue(entryPtr, (ClientData)refCount);
  2279.    /* for EPS output */
  2280.     togl->EpsRedMap[index] = entry.peRed / 255.0;
  2281.     togl->EpsGreenMap[index] = entry.peGreen / 255.0;
  2282.     togl->EpsBlueMap[index] = entry.peBlue / 255.0;
  2283.     return index;
  2284. }
  2286. static void Win32FreeColor( const struct Togl *togl, unsigned long index )
  2287. {
  2288.     TkWinColormap *cmap = (TkWinColormap *) Tk_Colormap(togl->TkWin);
  2289.     COLORREF cref;
  2290.     UINT count, refCount;
  2291.     PALETTEENTRY entry, *entries;
  2292.     Tcl_HashEntry *entryPtr;
  2294. if (index >= cmap->size ) {
  2295. panic("Tried to free a color that isn't allocated.");
  2296. }
  2297. GetPaletteEntries(cmap->palette, index, 1, &entry);
  2298. cref = PALETTERGB(entry.peRed, entry.peGreen, entry.peBlue);
  2299. entryPtr = Tcl_FindHashEntry(&cmap->refCounts, (char *) cref);
  2300. if (!entryPtr) {
  2301. panic("Tried to free a color that isn't allocated.");
  2302. }
  2303. refCount = (int) Tcl_GetHashValue(entryPtr) - 1;
  2304. if (refCount == 0) {
  2305. count = cmap->size - index;
  2306. entries = (PALETTEENTRY *) ckalloc(sizeof(PALETTEENTRY)* count);
  2307. GetPaletteEntries(cmap->palette, index+1, count, entries);
  2308. SetPaletteEntries(cmap->palette, index, count, entries);
  2309. SelectPalette(togl->tglGLHdc, cmap->palette, TRUE);
  2310. RealizePalette(togl->tglGLHdc);
  2311. ckfree((char *) entries);
  2312. cmap->size--;
  2313. Tcl_DeleteHashEntry(entryPtr);
  2314. } else {
  2315. Tcl_SetHashValue(entryPtr, (ClientData)refCount);
  2316. }
  2317. }
  2319. static void Win32SetColor( const struct Togl *togl,
  2320.                     unsigned long index, float red, float green, float blue )
  2321. {
  2322.     TkWinColormap *cmap = (TkWinColormap *) Tk_Colormap(togl->TkWin);
  2323.     PALETTEENTRY entry;
  2325.     entry.peRed =  red*255 + .5;
  2326.     entry.peGreen = green*255 + .5;
  2327.     entry.peBlue = blue*255 + .5;
  2328.     entry.peFlags = 0;
  2329.     SetPaletteEntries(cmap->palette, index, 1, &entry);
  2330. SelectPalette(togl->tglGLHdc, cmap->palette, TRUE);
  2331. RealizePalette(togl->tglGLHdc);
  2333. /* for EPS output */
  2334.     togl->EpsRedMap[index] = entry.peRed / 255.0;
  2335.     togl->EpsGreenMap[index] = entry.peGreen / 255.0;
  2336.     togl->EpsBlueMap[index] = entry.peBlue / 255.0;
  2337. }
  2338. #endif /* X11 */
  2342. unsigned long Togl_AllocColor( const struct Togl *togl,
  2343.                                float red, float green, float blue )
  2344. {
  2345.    XColor xcol;
  2346.    int exact;
  2348.    if (togl->RgbaFlag) {
  2349.       fprintf(stderr,"Error: Togl_AllocColor illegal in RGBA mode.n");
  2350.       return 0;
  2351.    }
  2352.    /* TODO: maybe not... */
  2353.    if (togl->PrivateCmapFlag) {
  2354.       fprintf(stderr,"Error: Togl_FreeColor illegal with private colormapn");
  2355.       return 0;
  2356.    }
  2358. #if defined(X11)
  2359.    xcol.red   = (short) (red   * 65535.0);
  2360.    xcol.green = (short) (green * 65535.0);
  2361.    xcol.blue  = (short) (blue  * 65535.0);
  2363.    noFaultXAllocColor( Tk_Display(togl->TkWin), Tk_Colormap(togl->TkWin),
  2364.                        Tk_Visual(togl->TkWin)->map_entries, &xcol, &exact );
  2367.    /* for EPS output */
  2368.    togl->EpsRedMap[ xcol.pixel] = xcol.red / 65535.0;
  2369.    togl->EpsGreenMap[ xcol.pixel] = xcol.green / 65535.0;
  2370.    togl->EpsBlueMap[ xcol.pixel] = xcol.blue / 65535.0;
  2372.    return xcol.pixel;
  2373. #elif defined(WIN32)
  2374.    return Win32AllocColor( togl, red, green, blue );
  2375. #endif /* X11 */
  2376. }
  2380. void Togl_FreeColor( const struct Togl *togl, unsigned long pixel )
  2381. {
  2382.    if (togl->RgbaFlag) {
  2383.       fprintf(stderr,"Error: Togl_AllocColor illegal in RGBA mode.n");
  2384.       return;
  2385.    }
  2386.    /* TODO: maybe not... */
  2387.    if (togl->PrivateCmapFlag) {
  2388.       fprintf(stderr,"Error: Togl_FreeColor illegal with private colormapn");
  2389.       return;
  2390.    }
  2392. #if defined(X11)
  2393.    XFreeColors( Tk_Display(togl->TkWin), Tk_Colormap(togl->TkWin),
  2394.                 &pixel, 1, 0 );
  2395. #elif defined(WIN32)
  2396.    Win32FreeColor(togl, pixel);
  2397. #endif /* X11 */
  2398. }
  2402. void Togl_SetColor( const struct Togl *togl,
  2403.                     unsigned long index, float red, float green, float blue )
  2404. {
  2405.    XColor xcol;
  2407.    if (togl->RgbaFlag) {
  2408.       fprintf(stderr,"Error: Togl_AllocColor illegal in RGBA mode.n");
  2409.       return;
  2410.    }
  2411.    if (!togl->PrivateCmapFlag) {
  2412.       fprintf(stderr,"Error: Togl_SetColor requires a private colormapn");
  2413.       return;
  2414.    }
  2416. #if defined(X11)
  2417.    xcol.pixel = index;
  2418.    xcol.red   = (short) (red   * 65535.0);
  2419.    xcol.green = (short) (green * 65535.0);
  2420.    xcol.blue  = (short) (blue  * 65535.0);
  2421.    xcol.flags = DoRed | DoGreen | DoBlue;
  2423.    XStoreColor( Tk_Display(togl->TkWin), Tk_Colormap(togl->TkWin), &xcol );
  2425.    /* for EPS output */
  2426.    togl->EpsRedMap[ xcol.pixel] = xcol.red / 65535.0;
  2427.    togl->EpsGreenMap[ xcol.pixel] = xcol.green / 65535.0;
  2428.    togl->EpsBlueMap[ xcol.pixel] = xcol.blue / 65535.0;
  2430. #elif defined(WIN32)
  2431.    Win32SetColor( togl, index, red, green, blue );
  2432. #endif /* X11 */
  2433. }
  2437. #if defined(WIN32)
  2438. #include "tkFont.h"
  2440. /*
  2441.  * The following structure represents Windows' implementation of a font.
  2442.  */
  2444. typedef struct WinFont {
  2445.     TkFont font; /* Stuff used by generic font package.  Must
  2446.  * be first in structure. */
  2447.     HFONT hFont; /* Windows information about font. */
  2448.     HWND hwnd; /* Toplevel window of application that owns
  2449.  * this font, used for getting HDC. */
  2450.     int widths[256]; /* Widths of first 256 chars in this font. */
  2451. } WinFont;
  2452. #endif /* WIN32 */
  2455. #define MAX_FONTS 1000
  2456. static GLuint ListBase[MAX_FONTS];
  2457. static GLuint ListCount[MAX_FONTS];
  2461. /*
  2462.  * Load the named bitmap font as a sequence of bitmaps in a display list.
  2463.  * fontname may be one of the predefined fonts like TOGL_BITMAP_8_BY_13
  2464.  * or an X font name, or a Windows font name, etc.
  2465.  */
  2466. GLuint Togl_LoadBitmapFont( const struct Togl *togl, const char *fontname )
  2467. {
  2468.    static int FirstTime = 1;
  2469. #if defined(X11)
  2470.    XFontStruct *fontinfo;
  2471. #elif defined(WIN32)
  2472.    WinFont *winfont;
  2473.    HFONT oldFont;
  2474.    TEXTMETRIC tm;
  2475. #endif /* X11 */
  2476.    int first, last, count;
  2477.    GLuint fontbase;
  2478.    const char *name;
  2480.    /* Initialize the ListBase and ListCount arrays */
  2481.    if (FirstTime) {
  2482.       int i;
  2483.       for (i=0;i<MAX_FONTS;i++) {
  2484.          ListBase[i] = ListCount[i] = 0;
  2485.       }
  2486.       FirstTime = 0;
  2487.    }
  2489.    /*
  2490.     * This method of selecting X fonts according to a TOGL_ font name
  2491.     * is a kludge.  To be fixed when I find time...
  2492.     */
  2493.    if (fontname==TOGL_BITMAP_8_BY_13) {
  2494.       name = "8x13";
  2495.    }
  2496.    else if (fontname==TOGL_BITMAP_9_BY_15) {
  2497.       name = "9x15";
  2498.    }
  2499.    else if (fontname==TOGL_BITMAP_TIMES_ROMAN_10) {
  2500.       name = "-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1";
  2501.    }
  2502.    else if (fontname==TOGL_BITMAP_TIMES_ROMAN_24) {
  2503.       name = "-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1";
  2504.    }
  2505.    else if (fontname==TOGL_BITMAP_HELVETICA_10) {
  2506.       name = "-adobe-helvetica-medium-r-normal--10-100-75-75-p-57-iso8859-1";
  2507.    }
  2508.    else if (fontname==TOGL_BITMAP_HELVETICA_12) {
  2509.       name = "-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1";
  2510.    }
  2511.    else if (fontname==TOGL_BITMAP_HELVETICA_18) {
  2512.       name = "-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1";
  2513.    }
  2514.    else if (!fontname) {
  2515.       name = DEFAULT_FONTNAME;
  2516.    }
  2517.    else {
  2518.       name = (const char *) fontname;
  2519.    }
  2521.    assert( name );
  2523. #if defined(X11)
  2524.    fontinfo = XLoadQueryFont( Tk_Display(togl->TkWin), name );
  2525.    if (!fontinfo) {
  2526.       return 0;
  2527.    }
  2529.    first = fontinfo->min_char_or_byte2;
  2530.    last = fontinfo->max_char_or_byte2;
  2531. #elif defined(WIN32)
  2532.    winfont = (WinFont*) Tk_GetFont(togl->Interp, togl->TkWin, name);
  2533.    if (!winfont) {
  2534.       return 0;
  2535.    }
  2536.    oldFont = SelectObject(togl->tglGLHdc, winfont->hFont);
  2537.    GetTextMetrics(togl->tglGLHdc, &tm);
  2538.    first = tm.tmFirstChar;
  2539.    last = tm.tmLastChar;
  2540. #endif /* X11 */
  2541.    count = last-first+1;
  2543.    fontbase = glGenLists( (GLuint) (last+1) );
  2544.    if (fontbase==0) {
  2545. #ifdef WIN32
  2546.       SelectObject(togl->tglGLHdc, oldFont);
  2547.       Tk_FreeFont((Tk_Font) winfont);
  2548. #endif /* WIN32 */
  2549.       return 0;
  2550.    }
  2551. #if defined(WIN32)
  2552.    wglUseFontBitmaps(togl->tglGLHdc, first, count, (int) fontbase+first );
  2553.    SelectObject(togl->tglGLHdc, oldFont);
  2554.    Tk_FreeFont((Tk_Font) winfont);
  2555. #elif defined(X11)
  2556.    glXUseXFont( fontinfo->fid, first, count, (int) fontbase+first );
  2557. #endif
  2559.    /* Record the list base and number of display lists
  2560.     * for Togl_UnloadBitmapFont().
  2561.     */
  2562.    {
  2563.       int i;
  2564.       for (i=0;i<MAX_FONTS;i++) {
  2565.          if (ListBase[i]==0) {
  2566.             ListBase[i] = fontbase;
  2567.             ListCount[i] = last+1;
  2568.             break;
  2569.          }
  2570.       }
  2571.    }
  2573.    return fontbase;
  2574. }
  2578. /*
  2579.  * Release the display lists which were generated by Togl_LoadBitmapFont().
  2580.  */
  2581. void Togl_UnloadBitmapFont( const struct Togl *togl, GLuint fontbase )
  2582. {
  2583.    int i;
  2584.    (void) togl;
  2585.    for (i=0;i<MAX_FONTS;i++) {
  2586.       if (ListBase[i]==fontbase) {
  2587.          glDeleteLists( ListBase[i], ListCount[i] );
  2588.          ListBase[i] = ListCount[i] = 0;
  2589.          return;
  2590.       }
  2591.    }
  2592. }
  2595. /*
  2596.  * Overlay functions
  2597.  */
  2600. void Togl_UseLayer( struct Togl *togl, int layer )
  2601. {
  2602.    if (togl->OverlayWindow) {
  2603.       if (layer==TOGL_OVERLAY) {
  2604. #if defined(WIN32)
  2605.          int res = wglMakeCurrent(togl->tglGLHdc, togl->tglGLOverlayHglrc);
  2606.          assert(res == TRUE);
  2607. #elif defined(X11)
  2608.  glXMakeCurrent( Tk_Display(togl->TkWin),
  2609.  togl->OverlayWindow,
  2610.  togl->OverlayCtx );
  2611. #if defined(__sgi) && defined(STEREO)
  2612. stereoMakeCurrent( Tk_Display(togl->TkWin),
  2613.    togl->OverlayWindow,
  2614.    togl->OverlayCtx );
  2615. #endif /* __sgi STEREO */
  2616. #endif /*WIN32 */
  2617.       }
  2618.       else if (layer==TOGL_NORMAL) {
  2619. #if defined(WIN32)
  2620. int res = wglMakeCurrent(togl->tglGLHdc, togl->tglGLHglrc);
  2621. assert(res == TRUE);
  2622. #elif defined(X11)
  2623. glXMakeCurrent( Tk_Display(togl->TkWin),
  2624. Tk_WindowId(togl->TkWin),
  2625. togl->GlCtx );
  2626. #if defined(__sgi) && defined(STEREO)
  2627. stereoMakeCurrent( Tk_Display(togl->TkWin),
  2628. Tk_WindowId(togl->TkWin),
  2629. togl->GlCtx );
  2630. #endif /* __sgi STEREO */
  2631. #endif /* WIN32 */
  2632.       }
  2633.       else {
  2634.          /* error */
  2635.       }
  2636.    }
  2637. }
  2641. void Togl_ShowOverlay( struct Togl *togl )
  2642. {
  2643. #if defined(X11)  /* not yet implemented on Windows*/
  2644.    if (togl->OverlayWindow) {
  2645.       XMapWindow( Tk_Display(togl->TkWin), togl->OverlayWindow );
  2646.       XInstallColormap(Tk_Display(togl->TkWin),togl->OverlayCmap);
  2647.       togl->OverlayIsMapped = 1;
  2648.    }
  2649. #endif /* X11 */
  2650. }
  2654. void Togl_HideOverlay( struct Togl *togl )
  2655. {
  2656.    if (togl->OverlayWindow && togl->OverlayIsMapped) {
  2657.       XUnmapWindow( Tk_Display(togl->TkWin), togl->OverlayWindow );
  2658.       togl->OverlayIsMapped=0;
  2659.    }
  2660. }
  2664. void Togl_PostOverlayRedisplay( struct Togl *togl )
  2665. {
  2666.    if (!togl->OverlayUpdatePending
  2667.        && togl->OverlayWindow && togl->OverlayDisplayProc) {
  2668.       Tk_DoWhenIdle( RenderOverlay, (ClientData) togl );
  2669.       togl->OverlayUpdatePending = 1;
  2670.    } 
  2671. }
  2674. void Togl_OverlayDisplayFunc( Togl_Callback *proc )
  2675. {
  2676.    OverlayDisplayProc = proc;
  2677. }
  2680. int Togl_ExistsOverlay( const struct Togl *togl )
  2681. {
  2682.    return togl->OverlayFlag;
  2683. }
  2686. int Togl_GetOverlayTransparentValue( const struct Togl *togl )
  2687. {
  2688.    return togl->OverlayTransparentPixel;
  2689. }
  2692. int Togl_IsMappedOverlay( const struct Togl *togl )
  2693. {
  2694.    return togl->OverlayFlag && togl->OverlayIsMapped;
  2695. }
  2698. unsigned long Togl_AllocColorOverlay( const struct Togl *togl,
  2699.                                       float red, float green, float blue )
  2700. {
  2701. #if defined(X11) /* not yet implemented on Windows*/
  2702.    if (togl->OverlayFlag && togl->OverlayCmap) {
  2703.       XColor xcol;
  2704.       xcol.red   = (short) (red* 65535.0);
  2705.       xcol.green = (short) (green* 65535.0);
  2706.       xcol.blue  = (short) (blue* 65535.0);
  2707.       if (!XAllocColor(Tk_Display(togl->TkWin),togl->OverlayCmap,&xcol))
  2708.          return (unsigned long) -1;
  2709.       return xcol.pixel;
  2710. #else /* X11 */
  2711.    if (0) {
  2712. #endif /* X11 */
  2713.    }
  2714.    else {
  2715.       return (unsigned long) -1;
  2716.    }
  2717. }
  2720. void Togl_FreeColorOverlay( const struct Togl *togl, unsigned long pixel )
  2721. {
  2722. #if defined(X11) /* not yet implemented on Windows*/
  2723.    if (togl->OverlayFlag && togl->OverlayCmap) {
  2724.       XFreeColors( Tk_Display(togl->TkWin), togl->OverlayCmap,
  2725.                    &pixel, 1, 0 );
  2726.    }
  2727. #endif /* X11 */
  2728. }
  2732. /*
  2733.  * User client data
  2734.  */
  2736. void Togl_ClientData( ClientData clientData )
  2737. {
  2738.    DefaultClientData = clientData;
  2739. }
  2742. ClientData Togl_GetClientData( const struct Togl *togl )
  2743. {
  2744.    return togl->Client_Data;
  2745. }
  2748. void Togl_SetClientData( struct Togl *togl, ClientData clientData )
  2749. {
  2750.    togl->Client_Data = clientData;
  2751. }
  2755. /*
  2756.  * X11-only functions
  2757.  * Contributed by Miguel A. De Riera Pasenau (miguel@DALILA.UPC.ES)
  2758.  */
  2760. Display* Togl_Display( const struct Togl *togl)
  2761. {
  2762.    return Tk_Display(togl->TkWin);
  2763. }
  2765. Screen* Togl_Screen( const struct Togl *togl)
  2766. {
  2767.    return Tk_Screen(togl->TkWin);
  2768. }
  2770. int Togl_ScreenNumber( const struct Togl *togl)
  2771. {
  2772.    return Tk_ScreenNumber(togl->TkWin);
  2773. }
  2775. Colormap Togl_Colormap( const struct Togl *togl)
  2776. {
  2777.    return Tk_Colormap(togl->TkWin);
  2778. }
  2782. #ifdef MESA_COLOR_HACK
  2783. /*
  2784.  * Let's know how many free colors do we have
  2785.  */
  2786. #if 0
  2787. static unsigned char rojo[] = { 4, 39, 74, 110, 145, 181, 216, 251},
  2788.                      verde[] = { 4, 39, 74, 110, 145, 181, 216, 251},
  2789.      azul[] = { 4, 39, 74, 110, 145, 181, 216, 251};
  2791. unsigned char rojo[] = { 4, 36, 72, 109, 145, 182, 218, 251},
  2792.               verde[] = { 4, 36, 72, 109, 145, 182, 218, 251},
  2793.               azul[] = { 4, 36, 72, 109, 145, 182, 218, 251};
  2794.               azul[] = { 0, 85, 170, 255};
  2795. #endif
  2797. #define RLEVELS     5
  2798. #define GLEVELS     9
  2799. #define BLEVELS     5
  2801. /* to free dithered_rgb_colormap pixels allocated by Mesa */
  2802. static unsigned long *ToglMesaUsedPixelCells = NULL;
  2803. static int ToglMesaUsedFreeCells = 0;
  2805. static int get_free_color_cells( Display *display, int screen,
  2806.                                  Colormap colormap)
  2807. {
  2808.    if ( !ToglMesaUsedPixelCells) {
  2809.       XColor xcol;
  2810.       int i;
  2811.       int colorsfailed, ncolors = XDisplayCells( display, screen);
  2813.       long r, g, b;
  2815.       ToglMesaUsedPixelCells = ( unsigned long *)calloc( ncolors, sizeof( unsigned long));
  2817.       /* Allocate X colors and initialize color_table[], red_table[], etc */
  2818.       /* de Mesa 2.1: xmesa1.c setup_dithered_(...) */
  2819.       i = colorsfailed = 0;
  2820.       for (r = 0; r < RLEVELS; r++)
  2821.          for (g = 0; g < GLEVELS; g++)
  2822.             for (b = 0; b < BLEVELS; b++) {
  2823.                int exact;
  2824.                xcol.red   = ( r*65535)/(RLEVELS-1);
  2825.                xcol.green = ( g*65535)/(GLEVELS-1);
  2826.                xcol.blue  = ( b*65535)/(BLEVELS-1);
  2827.                noFaultXAllocColor( display, colormap, ncolors,
  2828.                                    &xcol, &exact );
  2829.                ToglMesaUsedPixelCells[ i++] = xcol.pixel;
  2830.                if (!exact) {
  2831.                   colorsfailed++;
  2832.                }
  2833.             }
  2834.       ToglMesaUsedFreeCells = i;
  2836.       XFreeColors( display, colormap, ToglMesaUsedPixelCells,
  2837.                    ToglMesaUsedFreeCells, 0x00000000);
  2838.    }
  2839.    return ToglMesaUsedFreeCells;
  2840. }
  2843. static void free_default_color_cells( Display *display, Colormap colormap)
  2844. {
  2845.    if ( ToglMesaUsedPixelCells) {
  2846.       XFreeColors( display, colormap, ToglMesaUsedPixelCells,
  2847.                    ToglMesaUsedFreeCells, 0x00000000);
  2848.       free( ( char *)ToglMesaUsedPixelCells);
  2849.       ToglMesaUsedPixelCells = NULL;
  2850.       ToglMesaUsedFreeCells = 0;
  2851.    }
  2852. }
  2853. #endif
  2856. /*
  2857.  * Generate EPS file.
  2858.  * Contributed by Miguel A. De Riera Pasenau (miguel@DALILA.UPC.ES)
  2859.  */
  2861. /* Function that creates a EPS File from a created pixmap on the current
  2862.  * context.
  2863.  * Based on the code from Copyright (c) Mark J. Kilgard, 1996.
  2864.  * Parameters: name_file, b&w / Color flag, redraw function.
  2865.  * The redraw function is needed in order to draw things into the new
  2866.  * created pixmap.
  2867.  */
  2869. /* Copyright (c) Mark J. Kilgard, 1996. */
  2871. static GLvoid *grabPixels(int inColor, unsigned int width, unsigned int height)
  2872. {
  2873.    GLvoid *buffer;
  2874.    GLint swapbytes, lsbfirst, rowlength;
  2875.    GLint skiprows, skippixels, alignment;
  2876.    GLenum format;
  2877.    unsigned int size;
  2879.    if (inColor) {
  2880.       format = GL_RGB;
  2881.       size = width * height * 3;
  2882.    }
  2883.    else {
  2884.       format = GL_LUMINANCE;
  2885.       size = width * height * 1;
  2886.    }
  2888.    buffer = (GLvoid *) malloc(size);
  2889.    if (buffer == NULL)
  2890.       return NULL;
  2892.    /* Save current modes. */
  2893.    glGetIntegerv(GL_PACK_SWAP_BYTES, &swapbytes);
  2894.    glGetIntegerv(GL_PACK_LSB_FIRST, &lsbfirst);
  2895.    glGetIntegerv(GL_PACK_ROW_LENGTH, &rowlength);
  2896.    glGetIntegerv(GL_PACK_SKIP_ROWS, &skiprows);
  2897.    glGetIntegerv(GL_PACK_SKIP_PIXELS, &skippixels);
  2898.    glGetIntegerv(GL_PACK_ALIGNMENT, &alignment);
  2899.    /* Little endian machines (DEC Alpha for example) could
  2900.       benefit from setting GL_PACK_LSB_FIRST to GL_TRUE
  2901.       instead of GL_FALSE, but this would require changing the
  2902.       generated bitmaps too. */
  2903.    glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
  2904.    glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
  2905.    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
  2906.    glPixelStorei(GL_PACK_SKIP_ROWS, 0);
  2907.    glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
  2908.    glPixelStorei(GL_PACK_ALIGNMENT, 1);
  2910.    /* Actually read the pixels. */
  2911.    glReadPixels(0, 0, width, height, format,
  2912.                 GL_UNSIGNED_BYTE, (GLvoid *) buffer);
  2914.    /* Restore saved modes. */
  2915.    glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes);
  2916.    glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst);
  2917.    glPixelStorei(GL_PACK_ROW_LENGTH, rowlength);
  2918.    glPixelStorei(GL_PACK_SKIP_ROWS, skiprows);
  2919.    glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels);
  2920.    glPixelStorei(GL_PACK_ALIGNMENT, alignment);
  2921.    return buffer;
  2922. }
  2925. static int generateEPS(const char *filename, int inColor,
  2926.                        unsigned int width, unsigned int height)
  2927. {
  2928.    FILE *fp;
  2929.    GLvoid *pixels;
  2930.    unsigned char *curpix;
  2931.    unsigned int components, i;
  2932.    int pos;
  2933.    unsigned char bitpixel;
  2935.    pixels = grabPixels(inColor, width, height);
  2936.    if (pixels == NULL)
  2937.       return 1;
  2938.    if (inColor)
  2939.       components = 3;     /* Red, green, blue. */
  2940.    else
  2941.       components = 1;     /* Luminance. */
  2943.    fp = fopen(filename, "w");
  2944.    if (fp == NULL) {
  2945.       return 2;
  2946.    }
  2947.    fprintf(fp, "%%!PS-Adobe-2.0 EPSF-1.2n");
  2948.    fprintf(fp, "%%%%Creator: OpenGL pixmap render outputn");
  2949.    fprintf(fp, "%%%%BoundingBox: 0 0 %d %dn", width, height);
  2950.    fprintf(fp, "%%%%EndCommentsn");
  2952.    i = ((( width * height) + 7) / 8 ) / 40; /* # of lines, 40 bytes per line */
  2953.    fprintf(fp, "%%%%BeginPreview: %d %d %d %dn%%", width, height, 1, i);
  2954.    pos = 0;
  2955.    curpix = ( unsigned char *)pixels;
  2956.    for ( i = 0; i < width * height * components; ) {
  2957.       bitpixel = 0;
  2958.       if ( inColor) {
  2959.          double pix = 0.0;
  2960.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2961.          if ( pix > 127.0) bitpixel |= 0x80;
  2962.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2963.          if ( pix > 127.0) bitpixel |= 0x40;
  2964.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2965.          if ( pix > 127.0) bitpixel |= 0x20;
  2966.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2967.          if ( pix > 127.0) bitpixel |= 0x10;
  2968.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2969.          if ( pix > 127.0) bitpixel |= 0x08;
  2970.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2971.          if ( pix > 127.0) bitpixel |= 0x04;
  2972.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2973.          if ( pix > 127.0) bitpixel |= 0x02;
  2974.          pix = 0.30 * ( double)curpix[ i++] + 0.59 * ( double)curpix[ i++] + 0.11 * ( double)curpix[ i++];
  2975.          if ( pix > 127.0) bitpixel |= 0x01;
  2976.       }
  2977.       else {
  2978.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x80;
  2979.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x40;
  2980.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x20;
  2981.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x10;
  2982.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x08;
  2983.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x04;
  2984.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x02;
  2985.          if ( curpix[ i++] > 0x7f) bitpixel |= 0x01;
  2986.       }
  2987.       fprintf(fp, "%02hx", bitpixel);
  2988.       if (++pos >= 40) {
  2989.          fprintf(fp, "n%%");
  2990.          pos = 0;
  2991.       }
  2992.    }
  2993.    if (pos)
  2994.       fprintf(fp, "n%%%%EndPreviewn");
  2995.    else
  2996.       fprintf(fp, "%%EndPreviewn");
  2998.    fprintf(fp, "gsaven");
  2999.    fprintf(fp, "/bwproc {n");
  3000.    fprintf(fp, "    rgbprocn");
  3001.    fprintf(fp, "    dup length 3 idiv string 0 3 0n");
  3002.    fprintf(fp, "    5 -1 roll {n");
  3003.    fprintf(fp, "    add 2 1 roll 1 sub dup 0 eqn");
  3004.    fprintf(fp, "    { pop 3 idiv 3 -1 roll dup 4 -1 roll dupn");
  3005.    fprintf(fp, "        3 1 roll 5 -1 roll put 1 add 3 0 }n");
  3006.    fprintf(fp, "    { 2 1 roll } ifelsen");
  3007.    fprintf(fp, "    } foralln");
  3008.    fprintf(fp, "    pop pop popn");
  3009.    fprintf(fp, "} defn");
  3010.    fprintf(fp, "systemdict /colorimage known not {n");
  3011.    fprintf(fp, "    /colorimage {n");
  3012.    fprintf(fp, "        popn");
  3013.    fprintf(fp, "        popn");
  3014.    fprintf(fp, "        /rgbproc exch defn");
  3015.    fprintf(fp, "        { bwproc } imagen");
  3016.    fprintf(fp, "    } defn");
  3017.    fprintf(fp, "} ifn");
  3018.    fprintf(fp, "/picstr %d string defn", width * components);
  3019.    fprintf(fp, "%d %d scalen", width, height);
  3020.    fprintf(fp, "%d %d %dn", width, height, 8);
  3021.    fprintf(fp, "[%d 0 0 %d 0 0]n", width, height);
  3022.    fprintf(fp, "{currentfile picstr readhexstring pop}n");
  3023.    fprintf(fp, "false %dn", components);
  3024.    fprintf(fp, "colorimagen");
  3026.    curpix = (unsigned char *) pixels;
  3027.    pos = 0;
  3028.    for (i = width * height * components; i > 0; i--) {
  3029.       fprintf(fp, "%02hx", *curpix++);
  3030.       if (++pos >= 40) {
  3031.  fprintf(fp, "n");
  3032.  pos = 0;
  3033.       }
  3034.    }
  3035.    if (pos)
  3036.       fprintf(fp, "n");
  3038.    fprintf(fp, "grestoren");
  3039.    free(pixels);
  3040.    fclose(fp);
  3041.    return 0;
  3042. }
  3045. /* int Togl_DumpToEpsFile( const struct Togl *togl, const char *filename,
  3046.                         int inColor, void (*user_redraw)(void)) */
  3047. /* changed by GG */
  3048. int Togl_DumpToEpsFile( const struct Togl *togl, const char *filename,
  3049.                         int inColor, void (*user_redraw)( const struct Togl *))
  3050. {
  3051.    int using_mesa = 0;
  3052. #if 0
  3053.    Pixmap eps_pixmap;
  3054.    GLXPixmap eps_glxpixmap;
  3055.    XVisualInfo *vi = togl->VisInfo;
  3056.    Window win = Tk_WindowId( togl->TkWin);
  3057. #endif
  3058.    Display *dpy = Tk_Display( togl->TkWin);
  3059.    int retval;
  3060.    int scrnum = Tk_ScreenNumber(togl->TkWin);
  3061.    unsigned int width = togl->Width, height = togl->Height;
  3063. #if defined(X11)
  3064.    if (strstr(glXQueryServerString( dpy, scrnum, GLX_VERSION ), "Mesa"))
  3065.       using_mesa = 1;
  3066.    else
  3067. #endif /* X11 */
  3068.       using_mesa = 0;
  3069.    /* I don't use Pixmap do drawn into, because the code should link
  3070.     * with Mesa libraries and OpenGL libraries, and the which library
  3071.     * we use at run time should not matter, but the name of the calls
  3072.     * differs one from another:
  3073.     * MesaGl: glXCreateGLXPixmapMESA( dpy, vi, eps_pixmap, Tk_Colormap(togl->TkWin))
  3074.     * OpenGl: glXCreateGLXPixmap( dpy, vi, eps_pixmap);
  3075.     *
  3076.     * instead of this I read direct from back buffer of the screeen.
  3077.     */
  3078. #if 0
  3079.    eps_pixmap = XCreatePixmap( dpy, win, width, height, vi->depth);
  3080.    if ( using_mesa)
  3081.       eps_glxpixmap = glXCreateGLXPixmapMESA( dpy, vi, eps_pixmap, Tk_Colormap(togl->TkWin));
  3082.    else
  3083.       eps_glxpixmap = glXCreateGLXPixmap( dpy, vi, eps_pixmap);
  3085.    glXMakeCurrent( dpy, eps_glxpixmap, togl->GlCtx);
  3086.    user_redraw();
  3087. #endif
  3088.    if ( !togl->RgbaFlag) {
  3090. #if defined(WIN32)
  3091. /* Due to the lack of a unique inverse mapping from the frame buffer to
  3092.    the logical palette we need a translation map from the complete
  3093.    logical palette. */
  3094.        {
  3095.            int n, i;
  3096.            TkWinColormap *cmap = (TkWinColormap *)Tk_Colormap(togl->TkWin);
  3097.            LPPALETTEENTRY entry = malloc(togl->EpsMapSize * sizeof(PALETTEENTRY));
  3098.            n = GetPaletteEntries(cmap->palette, 0, togl->EpsMapSize, entry);
  3099.            for (i=0; i<n; i++) {
  3100.                togl->EpsRedMap[i] = entry[i].peRed / 255.0;
  3101.                togl->EpsGreenMap[i] = entry[i].peGreen / 255.0;
  3102.                togl->EpsBlueMap[i] = entry[i].peBlue / 255.0;
  3103.            }
  3104.            free(entry);
  3105.        }
  3106. #endif /* WIN32 */
  3108.       glPixelMapfv( GL_PIXEL_MAP_I_TO_R, togl->EpsMapSize, togl->EpsRedMap);
  3109.       glPixelMapfv( GL_PIXEL_MAP_I_TO_G, togl->EpsMapSize, togl->EpsGreenMap);
  3110.       glPixelMapfv( GL_PIXEL_MAP_I_TO_B, togl->EpsMapSize, togl->EpsBlueMap);
  3111.    }
  3112.    /*  user_redraw(); */
  3113.    user_redraw(togl);  /* changed by GG */
  3114.    /* glReadBuffer( GL_FRONT); */
  3115.    /* by default it read GL_BACK in double buffer mode*/
  3116.    glFlush();
  3117.    retval = generateEPS( filename, inColor, width, height);
  3118. #if 0
  3119.    glXMakeCurrent( dpy, win, togl->GlCtx );
  3120.    glXDestroyGLXPixmap( dpy, eps_glxpixmap);
  3121.    XFreePixmap( dpy, eps_pixmap);
  3122. #endif
  3123.    return retval;
  3124. }
  3126. /*
  3127.  * Full screen stereo for SGI graphics
  3128.  * Contributed by Ben Evans (Ben.Evans@anusf.anu.edu.au)
  3129.  * This code was based on SGI's /usr/share/src/OpenGL/teach/stereo
  3130.  */
  3132. #if defined(__sgi) && defined(STEREO)
  3134. static struct stereoStateRec {
  3135.     Bool        useSGIStereo;
  3136.     Display     *currentDisplay;
  3137.     Window      currentWindow;
  3138.     GLXContext  currentContext;
  3139.     GLenum      currentDrawBuffer;
  3140.     int         currentStereoBuffer;
  3141.     Bool        enabled;
  3142.     char        *stereoCommand;
  3143.     char        *restoreCommand;
  3144. } stereo;
  3146. /* call instead of glDrawBuffer */
  3147. void
  3148. Togl_StereoDrawBuffer(GLenum mode)
  3149. {
  3150.   if (stereo.useSGIStereo) {
  3151.     stereo.currentDrawBuffer = mode;
  3152.     switch (mode) {
  3153.     case GL_FRONT:
  3154.     case GL_BACK:
  3155.     case GL_FRONT_AND_BACK:
  3156.       /*
  3157.       ** Simultaneous drawing to both left and right buffers isn't
  3158.       ** really possible if we don't have a stereo capable visual.
  3159.       ** For now just fall through and use the left buffer.
  3160.       */
  3161.     case GL_LEFT:
  3162.     case GL_FRONT_LEFT:
  3163.     case GL_BACK_LEFT:
  3164.       stereo.currentStereoBuffer = STEREO_BUFFER_LEFT;
  3165.       break;
  3166.     case GL_RIGHT:
  3167.     case GL_FRONT_RIGHT: 
  3168.       stereo.currentStereoBuffer = STEREO_BUFFER_RIGHT;
  3169.       mode = GL_FRONT;
  3170.       break;
  3171.     case GL_BACK_RIGHT:
  3172.       stereo.currentStereoBuffer = STEREO_BUFFER_RIGHT;
  3173.       mode = GL_BACK;
  3174.       break;
  3175.     default:
  3176.       break;
  3177.     }
  3178.     if (stereo.currentDisplay && stereo.currentWindow) {
  3179.       glXWaitGL();  /* sync with GL command stream before calling X */
  3180.       XSGISetStereoBuffer(stereo.currentDisplay,
  3181.   stereo.currentWindow,
  3182.   stereo.currentStereoBuffer);
  3183.       glXWaitX();   /* sync with X command stream before calling GL */
  3184.     }
  3185.   }
  3186.   glDrawBuffer(mode);
  3187. }
  3189. /* call instead of glClear */
  3190. void
  3191. Togl_StereoClear(GLbitfield mask)
  3192. {
  3193.   GLenum drawBuffer;
  3194.   if (stereo.useSGIStereo) {
  3195.     drawBuffer = stereo.currentDrawBuffer;
  3196.     switch (drawBuffer) {
  3197.     case GL_FRONT:
  3198.       stereoDrawBuffer(GL_FRONT_RIGHT);
  3199.       glClear(mask);
  3200.       stereoDrawBuffer(drawBuffer);
  3201.       break;
  3202.     case GL_BACK:
  3203.       stereoDrawBuffer(GL_BACK_RIGHT);
  3204.       glClear(mask);
  3205.       stereoDrawBuffer(drawBuffer);
  3206.       break;
  3207.     case GL_FRONT_AND_BACK:
  3208.       stereoDrawBuffer(GL_RIGHT);
  3209.       glClear(mask);
  3210.       stereoDrawBuffer(drawBuffer);
  3211.       break;
  3212.     case GL_LEFT:
  3213.     case GL_FRONT_LEFT:
  3214.     case GL_BACK_LEFT:
  3215.     case GL_RIGHT:
  3216.     case GL_FRONT_RIGHT:
  3217.     case GL_BACK_RIGHT:
  3218.     default:
  3219.       break;
  3220.     }
  3221.   }
  3222.   glClear(mask);
  3223. }
  3225. static void
  3226. stereoMakeCurrent(Display *dpy, Window win, GLXContext ctx)
  3227. {
  3228.   
  3229.   if (stereo.useSGIStereo) {
  3230.     if (dpy && (dpy != stereo.currentDisplay)) {
  3231.       int event, error;
  3232.       /* Make sure new Display supports SGIStereo */
  3233.       if (XSGIStereoQueryExtension(dpy, &event, &error) == False) {
  3234. dpy = NULL;
  3235.       }
  3236.     }
  3237.     if (dpy && win && (win != stereo.currentWindow)) {
  3238.       /* Make sure new Window supports SGIStereo */
  3239.       if (XSGIQueryStereoMode(dpy, win) == X_STEREO_UNSUPPORTED) {
  3240. win = None;
  3241.       }
  3242.     }
  3243.     if (ctx && (ctx != stereo.currentContext)) {
  3244.       GLint drawBuffer;
  3245.       glGetIntegerv(GL_DRAW_BUFFER, &drawBuffer);
  3246.       stereoDrawBuffer((GLenum) drawBuffer);
  3247.     }
  3248.     stereo.currentDisplay = dpy;
  3249.     stereo.currentWindow = win;
  3250.     stereo.currentContext = ctx;
  3251.   }
  3252. }
  3255. /* call before using stereo */
  3256. static void
  3257. stereoInit(struct Togl *togl,int stereoEnabled)
  3258. {
  3259.   stereo.useSGIStereo = stereoEnabled;
  3260.   stereo.currentDisplay = NULL;
  3261.   stereo.currentWindow = None;
  3262.   stereo.currentContext = NULL;
  3263.   stereo.currentDrawBuffer = GL_NONE;
  3264.   stereo.currentStereoBuffer = STEREO_BUFFER_NONE;
  3265.   stereo.enabled = False;
  3266. }
  3269. void
  3270. Togl_StereoFrustum(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
  3271.                GLfloat near, GLfloat far, GLfloat eyeDist, GLfloat eyeOffset)
  3272. {
  3273.   GLfloat eyeShift = (eyeDist - near) * (eyeOffset / eyeDist);
  3274.   
  3275.   glFrustum(left+eyeShift, right+eyeShift, bottom, top, near, far);
  3276.   glTranslatef(-eyeShift, 0.0, 0.0);
  3277. }
  3279. #endif /* __sgi STEREO */