initial check-in (post crash)

1 files changed, 607 insertions, 0 deletions

diff --git a/src/glut/glx/glut_overlay.c b/src/glut/glx/glut_overlay.c
new file mode 100644
index 0000000000..13ece12a15
--- /dev/null
+++ b/src/glut/glx/glut_overlay.c
@@ -0,0 +1,607 @@
+
+/* Copyright (c) Mark J. Kilgard, 1996, 1997.  */
+
+/* This program is freely distributable without licensing fees
+   and is provided without guarantee or warrantee expressed or
+   implied. This program is -not- in the public domain. */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#if !defined(_WIN32)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>  /* for XA_RGB_DEFAULT_MAP atom */
+#if defined (__vms)
+#include <Xmu/StdCmap.h>  /* for XmuLookupStandardColormap */
+#else
+#include <X11/Xmu/StdCmap.h>  /* for XmuLookupStandardColormap */
+#endif
+#endif /* !_WIN32 */
+
+#include "glutint.h"
+#include "layerutil.h"
+
+static Criterion requiredOverlayCriteria[] =
+{
+  {LEVEL, EQ, 1},       /* This entry gets poked in
+                           determineOverlayVisual. */
+  {TRANSPARENT, EQ, 1},
+  {XPSEUDOCOLOR, EQ, 1},
+  {RGBA, EQ, 0},
+  {BUFFER_SIZE, GTE, 1}
+};
+static int numRequiredOverlayCriteria = sizeof(requiredOverlayCriteria) / sizeof(Criterion);
+static int requiredOverlayCriteriaMask =
+(1 << LEVEL) | (1 << TRANSPARENT) | (1 << XSTATICGRAY) | (1 << RGBA) | (1 << CI_MODE);
+
+#if !defined(_WIN32)
+static int
+checkOverlayAcceptability(XVisualInfo * vi, unsigned int mode)
+{
+  int value;
+
+  /* Must support OpenGL. */
+  glXGetConfig(__glutDisplay, vi, GLX_USE_GL, &value);
+  if (!value)
+    return 1;
+
+  /* Must be color index. */
+  glXGetConfig(__glutDisplay, vi, GLX_RGBA, &value);
+  if (value)
+    return 1;
+
+  /* Must match single/double buffering request. */
+  glXGetConfig(__glutDisplay, vi, GLX_DOUBLEBUFFER, &value);
+  if (GLUT_WIND_IS_DOUBLE(mode) != (value != 0))
+    return 1;
+
+  /* Must match mono/stereo request. */
+  glXGetConfig(__glutDisplay, vi, GLX_STEREO, &value);
+  if (GLUT_WIND_IS_STEREO(mode) != (value != 0))
+    return 1;
+
+  /* Alpha and accumulation buffers incompatible with color
+     index. */
+  if (GLUT_WIND_HAS_ALPHA(mode) || GLUT_WIND_HAS_ACCUM(mode))
+    return 1;
+
+  /* Look for depth buffer if requested. */
+  glXGetConfig(__glutDisplay, vi, GLX_DEPTH_SIZE, &value);
+  if (GLUT_WIND_HAS_DEPTH(mode) && (value <= 0))
+    return 1;
+
+  /* Look for stencil buffer if requested. */
+  glXGetConfig(__glutDisplay, vi, GLX_STENCIL_SIZE, &value);
+  if (GLUT_WIND_HAS_STENCIL(mode) && (value <= 0))
+    return 1;
+
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+  /* XXX Multisampled overlay color index??  Pretty unlikely. */
+  /* Look for multisampling if requested. */
+  if (__glutIsSupportedByGLX("GLX_SGIS_multisample"))
+    glXGetConfig(__glutDisplay, vi, GLX_SAMPLES_SGIS, &value);
+  else
+    value = 0;
+  if (GLUT_WIND_IS_MULTISAMPLE(mode) && (value <= 0))
+    return 1;
+#endif
+
+  return 0;
+}
+#endif
+
+static XVisualInfo *
+getOverlayVisualInfoCI(unsigned int mode)
+{
+#if !defined(_WIN32)
+  XLayerVisualInfo *vi;
+  XLayerVisualInfo template;
+  XVisualInfo *goodVisual, *returnVisual;
+  int nitems, i, j, bad;
+
+  /* The GLX 1.0 glXChooseVisual is does not permit queries
+     based on pixel transparency (and GLX_BUFFER_SIZE uses
+     "smallest that meets" its requirement instead of "largest
+     that meets" that GLUT wants. So, GLUT implements its own
+     visual selection routine for color index overlays. */
+
+  /* Try three overlay layers. */
+  for (i = 1; i <= 3; i++) {
+    template.vinfo.screen = __glutScreen;
+    template.vinfo.class = PseudoColor;
+    template.layer = i;
+    template.type = TransparentPixel;
+    vi = __glutXGetLayerVisualInfo(__glutDisplay,
+      VisualTransparentType | VisualScreenMask | VisualClassMask | VisualLayerMask,
+      &template, &nitems);
+    if (vi) {
+      /* Check list for acceptable visual meeting requirements
+         of requested display mode. */
+      for (j = 0; j < nitems; j++) {
+        bad = checkOverlayAcceptability(&vi[j].vinfo, mode);
+        if (bad) {
+          /* Set vi[j].vinfo.visual to mark it unacceptable. */
+          vi[j].vinfo.visual = NULL;
+        }
+      }
+
+      /* Look through list to find deepest acceptable visual. */
+      goodVisual = NULL;
+      for (j = 0; j < nitems; j++) {
+        if (vi[j].vinfo.visual) {
+          if (goodVisual == NULL) {
+            goodVisual = &vi[j].vinfo;
+          } else {
+            if (goodVisual->depth < vi[j].vinfo.depth) {
+              goodVisual = &vi[j].vinfo;
+            }
+          }
+        }
+      }
+
+      /* If a visual is found, clean up and return the visual. */
+      if (goodVisual) {
+        returnVisual = (XVisualInfo *) malloc(sizeof(XVisualInfo));
+        if (returnVisual) {
+          *returnVisual = *goodVisual;
+        }
+        XFree(vi);
+        return returnVisual;
+      }
+      XFree(vi);
+    }
+  }
+#endif /* !_WIN32 */
+  return NULL;
+}
+
+/* ARGSUSED */
+static XVisualInfo *
+getOverlayVisualInfoRGB(unsigned int mode)
+{
+
+  /* XXX For now, transparent RGBA overlays are not supported
+     by GLUT.  RGBA overlays raise difficult questions about
+     what the transparent pixel (really color) value should be.
+
+     Color index overlay transparency is "easy" because the
+     transparent pixel value does not affect displayable colors
+     (except for stealing one color cell) since colors are
+     determined by indirection through a colormap, and because
+     it is uncommon for arbitrary pixel values in color index to
+     be "calculated" (as can occur with a host of RGBA operations
+     like lighting, blending, etc) so it is easy to avoid the
+     transparent pixel value.
+
+     Since it is typically easy to avoid the transparent pixel
+     value in color index mode, if GLUT tells the programmer what
+     pixel is transparent, then most program can easily avoid
+     generating that pixel value except when they intend
+     transparency.  GLUT returns whatever transparent pixel value
+     is provided by the system through glutGet(
+     GLUT_TRANSPARENT_INDEX).
+
+     Theory versus practice for RGBA overlay transparency: In
+     theory, the reasonable thing is enabling overlay transparency
+     when an overlay pixel's destination alpha is 0 because this
+     allows overlay transparency to be controlled via alpha and all
+     visibile colors are permited, but no hardware I am aware of
+     supports this practice (and it requires destination alpha which
+     is typically optional and quite uncommon for overlay windows!). 
+
+     In practice, the choice of  transparent pixel value is typically
+     "hardwired" into most graphics hardware to a single pixel value.
+     SGI hardware uses true black (0,0,0) without regard for the
+     destination alpha.  This is far from ideal because true black (a
+     common color that is easy to accidently generate) can not be
+     generated in an RGBA overlay. I am not sure what other vendors
+     do.
+
+     Pragmatically, most of the typical things you want to do in the
+     overlays can be done in color index (rubber banding, pop-up
+     menus, etc.).  One solution for GLUT would be to simply
+     "advertise" what RGB triple (or possibly RGBA quadruple or simply 
+     A alone) generates transparency.  The problem with this approach
+     is that it forces programmers to avoid whatever arbitrary color
+     various systems decide is transparent.  This is a difficult
+     burden to place on programmers that want to portably make use of
+     overlays.
+
+     To actually support transparent RGBA overlays, there are really
+     two reaonsable options.  ONE: Simply mandate that true black is
+     the RGBA overlay transparent color (what IRIS GL did).  This is
+     nice for programmers since only one option, nice for existing SGI 
+     hardware, bad for anyone (including SGI) who wants to improve
+     upon "true black" RGB transparency. 
+
+     Or TWO: Provide a set of queriable "transparency types" (like
+     "true black" or "alpha == 0" or "true white" or even a queriable
+     transparent color).  This is harder for programmers, OK for
+     existing SGI hardware, and it leaves open the issue of what other 
+     modes are reasonable.
+
+     Option TWO seems the more general approach, but since hardware
+     designers will likely only implement a single mode (this is a
+     scan out issue where bandwidth is pressing issue), codifying
+     multiple speculative approaches nobody may ever implement seems
+     silly.  And option ONE fiats a suboptimal solution.
+
+     Therefore, I defer any decision of how GLUT should support RGBA
+     overlay transparency and leave support for it unimplemented.
+     Nobody has been pressing me for RGBA overlay transparency (though 
+     people have requested color index overlay transparency
+     repeatedly).  Geez, if you read this far you are either really
+     bored or maybe actually  interested in this topic.  Anyway, if
+     you have ideas (particularly if you plan on implementing a
+     hardware scheme for RGBA overlay transparency), I'd be
+     interested.
+
+     For the record, SGI's expiremental Framebufer Configuration
+     experimental GLX extension uses option TWO.  Transparency modes
+     for "none" and "RGB" are defined (others could be defined later). 
+     What RGB value is the transparent one must be queried. 
+
+     I was hoping GLUT could have something that required less work
+     from the programmer to use portably. -mjk */
+
+  __glutWarning("RGBA overlays are not supported by GLUT (for now).");
+  return NULL;
+}
+
+static XVisualInfo *
+getOverlayVisualInfo(unsigned int mode)
+{
+  /* XXX GLUT_LUMINANCE not implemented for GLUT 3.0. */
+  if (GLUT_WIND_IS_LUMINANCE(mode))
+    return NULL;
+
+  if (GLUT_WIND_IS_RGB(mode))
+    return getOverlayVisualInfoRGB(mode);
+  else
+    return getOverlayVisualInfoCI(mode);
+}
+
+#if !defined(_WIN32)
+
+/* The GLUT overlay can come and go, and the overlay window has
+   a distinct X window ID.  Logically though, GLUT treats the
+   normal and overlay windows as a unified window.  In
+   particular, X input events typically go to the overlay window 
+   since it is "on top of" the normal window.  When an overlay
+   window ID is destroyed (due to glutRemoveOverlay or a call to 
+   glutEstablishOverlay when an overlay already exists), we
+   still keep track of the overlay window ID until we get back a 
+   DestroyNotify event for the overlay window. Otherwise, we
+   could lose track of X input events sent to a destroyed
+   overlay.  To avoid this, we keep the destroyed overlay window 
+   ID on a "stale window" list.  This lets us properly route X
+   input events generated on destroyed overlay windows to the
+   proper GLUT window. */
+static void
+addStaleWindow(GLUTwindow * window, Window win)
+{
+  GLUTstale *entry;
+
+  entry = (GLUTstale *) malloc(sizeof(GLUTstale));
+  if (!entry)
+    __glutFatalError("out of memory");
+  entry->window = window;
+  entry->win = win;
+  entry->next = __glutStaleWindowList;
+  __glutStaleWindowList = entry;
+}
+
+#endif
+
+void
+__glutFreeOverlay(GLUToverlay * overlay)
+{
+  if (overlay->visAlloced)
+    XFree(overlay->vis);
+  XDestroyWindow(__glutDisplay, overlay->win);
+  glXDestroyContext(__glutDisplay, overlay->ctx);
+  if (overlay->colormap) {
+    /* Only color index overlays have colormap data structure. */
+    __glutFreeColormap(overlay->colormap);
+  }
+  free(overlay);
+}
+
+static XVisualInfo *
+determineOverlayVisual(int *treatAsSingle, Bool * visAlloced, void **fbc)
+{
+  if (__glutDisplayString) {
+    XVisualInfo *vi;
+    int i;
+
+    /* __glutDisplayString should be NULL except if
+       glutInitDisplayString has been called to register a
+       different display string.  Calling glutInitDisplayString
+       means using a string instead of an integer mask determine 
+
+       the visual to use. Using the function pointer variable
+       __glutDetermineVisualFromString below avoids linking in
+       the code for implementing glutInitDisplayString (ie,
+       glut_dstr.o) unless glutInitDisplayString gets called by
+       the application. */
+
+    assert(__glutDetermineVisualFromString);
+
+    /* Try three overlay layers. */
+    *visAlloced = False;
+    *fbc = NULL;
+    for (i = 1; i <= 3; i++) {
+      requiredOverlayCriteria[0].value = i;
+      vi = __glutDetermineVisualFromString(__glutDisplayString, treatAsSingle,
+        requiredOverlayCriteria, numRequiredOverlayCriteria,
+        requiredOverlayCriteriaMask, fbc);
+      if (vi) {
+        return vi;
+      }
+    }
+    return NULL;
+  } else {
+    *visAlloced = True;
+    *fbc = NULL;
+    return __glutDetermineVisual(__glutDisplayMode,
+      treatAsSingle, getOverlayVisualInfo);
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutEstablishOverlay(void)
+{
+  GLUToverlay *overlay;
+  GLUTwindow *window;
+  XSetWindowAttributes wa;
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+  GLXFBConfigSGIX fbc;
+#else
+  void *fbc;
+#endif
+
+  /* Register a routine to free an overlay with glut_win.c;
+     this keeps glut_win.c from pulling in all of
+     glut_overlay.c when no overlay functionality is used by
+     the application. */
+  __glutFreeOverlayFunc = __glutFreeOverlay;
+
+  window = __glutCurrentWindow;
+
+  /* Allow for an existant overlay to be re-established perhaps
+     if you wanted a different display mode. */
+  if (window->overlay) {
+#if !defined(_WIN32)
+    addStaleWindow(window, window->overlay->win);
+#endif
+    __glutFreeOverlay(window->overlay);
+  }
+  overlay = (GLUToverlay *) malloc(sizeof(GLUToverlay));
+  if (!overlay)
+    __glutFatalError("out of memory.");
+
+  overlay->vis = determineOverlayVisual(&overlay->treatAsSingle,
+    &overlay->visAlloced, (void **) &fbc);
+  if (!overlay->vis) {
+    __glutFatalError("lacks overlay support.");
+  }
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+  if (fbc) {
+    window->ctx = glXCreateContextWithConfigSGIX(__glutDisplay, fbc,
+      GLX_RGBA_TYPE_SGIX, None, __glutTryDirect);
+  } else
+#endif
+  {
+    overlay->ctx = glXCreateContext(__glutDisplay, overlay->vis,
+      None, __glutTryDirect);
+  }
+  if (!overlay->ctx) {
+    __glutFatalError(
+      "failed to create overlay OpenGL rendering context.");
+  }
+#if !defined(_WIN32)
+  overlay->isDirect = glXIsDirect(__glutDisplay, overlay->ctx);
+  if (__glutForceDirect) {
+    if (!overlay->isDirect) {
+      __glutFatalError("direct rendering not possible.");
+    }
+  }
+#endif
+  __glutSetupColormap(overlay->vis, &overlay->colormap, &overlay->cmap);
+  overlay->transparentPixel = __glutGetTransparentPixel(__glutDisplay,
+    overlay->vis);
+  wa.colormap = overlay->cmap;
+  wa.background_pixel = overlay->transparentPixel;
+  wa.event_mask = window->eventMask & GLUT_OVERLAY_EVENT_FILTER_MASK;
+  wa.border_pixel = 0;
+#if defined(_WIN32)
+  /* XXX Overlays not supported in Win32 yet. */
+#else
+  overlay->win = XCreateWindow(__glutDisplay,
+    window->win,
+    0, 0, window->width, window->height, 0,
+    overlay->vis->depth, InputOutput, overlay->vis->visual,
+    CWBackPixel | CWBorderPixel | CWEventMask | CWColormap,
+    &wa);
+#endif
+  if (window->children) {
+    /* Overlay window must be lowered below any GLUT
+       subwindows. */
+    XLowerWindow(__glutDisplay, overlay->win);
+  }
+  XMapWindow(__glutDisplay, overlay->win);
+  overlay->shownState = 1;
+
+  overlay->display = NULL;
+
+  /* Make sure a reshape gets delivered. */
+  window->forceReshape = True;
+
+#if !defined(_WIN32)
+  __glutPutOnWorkList(__glutToplevelOf(window), GLUT_COLORMAP_WORK);
+#endif
+
+  window->overlay = overlay;
+  glutUseLayer(GLUT_OVERLAY);
+
+  if (overlay->treatAsSingle) {
+    glDrawBuffer(GL_FRONT);
+    glReadBuffer(GL_FRONT);
+  }
+}
+
+void APIENTRY
+glutRemoveOverlay(void)
+{
+  GLUTwindow *window = __glutCurrentWindow;
+  GLUToverlay *overlay = __glutCurrentWindow->overlay;
+
+  if (!window->overlay)
+    return;
+
+  /* If using overlay, switch to the normal layer. */
+  if (window->renderWin == overlay->win) {
+    glutUseLayer(GLUT_NORMAL);
+  }
+#if !defined(_WIN32)
+  addStaleWindow(window, overlay->win);
+#endif
+  __glutFreeOverlay(overlay);
+  window->overlay = NULL;
+#if !defined(_WIN32)
+  __glutPutOnWorkList(__glutToplevelOf(window), GLUT_COLORMAP_WORK);
+#endif
+}
+
+void APIENTRY
+glutUseLayer(GLenum layer)
+{
+  GLUTwindow *window = __glutCurrentWindow;
+
+  switch (layer) {
+  case GLUT_NORMAL:
+#ifdef _WIN32
+    window->renderDc = window->hdc;
+#endif
+    window->renderWin = window->win;
+    window->renderCtx = window->ctx;
+    break;
+  case GLUT_OVERLAY:
+    /* Did you crash here?  Calling glutUseLayer(GLUT_OVERLAY)
+       without an overlay established is erroneous.  Fix your
+       code. */
+#ifdef _WIN32
+    window->renderDc = window->overlay->hdc;
+#endif
+    window->renderWin = window->overlay->win;
+    window->renderCtx = window->overlay->ctx;
+    break;
+  default:
+    __glutWarning("glutUseLayer: unknown layer, %d.", layer);
+    break;
+  }
+  __glutSetWindow(window);
+}
+
+void APIENTRY
+glutPostOverlayRedisplay(void)
+{
+  __glutPostRedisplay(__glutCurrentWindow, GLUT_OVERLAY_REDISPLAY_WORK);
+}
+
+/* The advantage of this routine is that it saves the cost of a
+   glutSetWindow call (entailing an expensive OpenGL context
+   switch), particularly useful when multiple windows need
+   redisplays posted at the same times. */
+void APIENTRY
+glutPostWindowOverlayRedisplay(int win)
+{
+  __glutPostRedisplay(__glutWindowList[win - 1], GLUT_OVERLAY_REDISPLAY_WORK);
+}
+
+void APIENTRY
+glutOverlayDisplayFunc(GLUTdisplayCB displayFunc)
+{
+  if (!__glutCurrentWindow->overlay) {
+    __glutWarning("glutOverlayDisplayFunc: window has no overlay established");
+    return;
+  }
+  __glutCurrentWindow->overlay->display = displayFunc;
+}
+
+void APIENTRY
+glutHideOverlay(void)
+{
+  if (!__glutCurrentWindow->overlay) {
+    __glutWarning("glutHideOverlay: window has no overlay established");
+    return;
+  }
+  XUnmapWindow(__glutDisplay, __glutCurrentWindow->overlay->win);
+  __glutCurrentWindow->overlay->shownState = 0;
+}
+
+void APIENTRY
+glutShowOverlay(void)
+{
+  if (!__glutCurrentWindow->overlay) {
+    __glutWarning("glutShowOverlay: window has no overlay established");
+    return;
+  }
+  XMapWindow(__glutDisplay, __glutCurrentWindow->overlay->win);
+  __glutCurrentWindow->overlay->shownState = 1;
+}
+
+int APIENTRY
+glutLayerGet(GLenum param)
+{
+  switch (param) {
+  case GLUT_OVERLAY_POSSIBLE:
+    {
+      XVisualInfo *vi;
+      Bool dummy, visAlloced;
+      void *fbc;
+
+      vi = determineOverlayVisual(&dummy, &visAlloced, &fbc);
+      if (vi) {
+        if (visAlloced)
+          XFree(vi);
+        return 1;
+      }
+      return 0;
+    }
+  case GLUT_LAYER_IN_USE:
+    return __glutCurrentWindow->renderWin != __glutCurrentWindow->win;
+  case GLUT_HAS_OVERLAY:
+    return __glutCurrentWindow->overlay != NULL;
+  case GLUT_TRANSPARENT_INDEX:
+    if (__glutCurrentWindow->overlay) {
+      return __glutCurrentWindow->overlay->transparentPixel;
+    } else {
+      return -1;
+    }
+  case GLUT_NORMAL_DAMAGED:
+    /* __glutWindowDamaged is used so the damage state within
+       the window (or overlay belwo) can be cleared before
+       calling a display callback so on return, the state does
+       not have to be cleared (since upon return from the
+       callback the window could be destroyed (or layer
+       removed). */
+    return (__glutCurrentWindow->workMask & GLUT_REPAIR_WORK)
+      || __glutWindowDamaged;
+  case GLUT_OVERLAY_DAMAGED:
+    if (__glutCurrentWindow->overlay) {
+      return (__glutCurrentWindow->workMask & GLUT_OVERLAY_REPAIR_WORK)
+        || __glutWindowDamaged;
+    } else {
+      return -1;
+    }
+  default:
+    __glutWarning("invalid glutLayerGet param: %d", param);
+    return -1;
+  }
+}
+/* ENDCENTRY */