Squashed commit of the following:

commit 1856230d9fa61710cce3e152b8d88b1269611a73
Author: José Fonseca <[email protected]>
Date:   Tue Jul 12 23:41:27 2011 +0100

    make: Use better var names on packaging.

commit d1ae72d0bd14e820ecfe9f8f27b316f9566ceb0c
Author: José Fonseca <[email protected]>
Date:   Tue Jul 12 23:38:21 2011 +0100

    make: Apply several of Dan Nicholson's suggestions.

commit f27cf8743ac9cbf4c0ad66aff0cd3f97efde97e4
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 14:18:20 2011 +0100

    make: Put back the tar.bz2 creation rule.

    Removed by accident.

commit 34983337f9d7db984e9f0117808274106d262110
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 11:59:29 2011 +0100

    make: Determine tarballs contents via git ls-files.

    The wildcards were a mess:
    - lots of files for non Linux platforms missing
    - several files listed and archived twice

    Using git-ls-files ensures things are not loss when making the tarballs.

commit 34a28ccbf459ed5710aafba5e7149e8291cb808c
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 11:07:14 2011 +0100

    glut: Remove GLUT source.

    Most distros ship freeglut, and most people don't care one vs the other,
    and it hasn't been really maintained.

    So it is better to have Mesa GLUT be revisioned and built separately
    from Mesa.

commit 5c26a2c3c0c7e95ef853e19d12d75c4f80137e7d
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 10:31:02 2011 +0100

    Ignore the tarballs.

commit 26edecac589819f0d0efe2165ab748dbc4e53394
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 10:30:24 2011 +0100

    make: Create the Mesa-xxx-devel symlink automatically.

    Also actually remote the intermediate uncompressed tarballs.

1 files changed, 0 insertions, 1023 deletions

diff --git a/src/glut/glx/glut_menu.c b/src/glut/glx/glut_menu.c
deleted file mode 100644
index d136823c54f..00000000000
--- a/src/glut/glx/glut_menu.c
+++ /dev/null
@@ -1,1023 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 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. */
-
-/* The Win32 GLUT file win32_menu.c completely re-implements all
-   the menuing functionality implemented.  This file is used only by
-   the X Window System version of GLUT. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-#include <assert.h>
-
-#include <unistd.h>
-#include <X11/Xlib.h>
-#include <X11/cursorfont.h>  /* for XC_arrow */
-
-#include "glutint.h"
-#include "layerutil.h"
-
-void (CDECL *__glutMenuStatusFunc) (int, int, int);
-GLUTmenuItem *__glutItemSelected;
-GLUTmenu **__glutMenuList = NULL;
-
-static int menuListSize = 0;
-static XFontStruct *menuFont = NULL;
-static Cursor menuCursor;
-static Colormap menuColormap;
-static Visual *menuVisual;
-static int menuDepth;
-static int fontHeight;
-static GC blackGC, grayGC, whiteGC;
-static unsigned long menuBlack, menuWhite, menuGray;
-static unsigned long useSaveUnders;
-
-/* A replacement for XAllocColor (originally by Brian Paul).
-   This  function should never fail to allocate a color.  When
-   XAllocColor fails, we return the nearest matching color.  If
-   we have to allocate many colors this function isn't a great
-   solution; the XQueryColors() could be done just once.  */
-static void
-noFaultXAllocColor(Display * dpy, Colormap cmap, int cmapSize,
-  XColor * color)
-{
-  XColor *ctable, subColor;
-  int i, bestmatch;
-  double mindist;       /* 3*2^16^2 exceeds 32-bit long int
-                           precision. */
-
-  for (;;) {
-    /* First try just using XAllocColor. */
-    if (XAllocColor(dpy, cmap, color)) {
-      return;
-    }
-
-    /* Retrieve color table entries. */
-    /* XXX alloca canidate. */
-    ctable = (XColor *) malloc(cmapSize * sizeof(XColor));
-    for (i = 0; i < cmapSize; i++)
-      ctable[i].pixel = i;
-    XQueryColors(dpy, cmap, ctable, cmapSize);
-
-    /* Find best match. */
-    bestmatch = -1;
-    mindist = 0.0;
-    for (i = 0; i < cmapSize; i++) {
-      double dr = (double) color->red - (double) ctable[i].red;
-      double dg = (double) color->green - (double) ctable[i].green;
-      double db = (double) color->blue - (double) ctable[i].blue;
-      double dist = dr * dr + dg * dg + db * db;
-      if (bestmatch < 0 || dist < mindist) {
-        bestmatch = i;
-        mindist = dist;
-      }
-    }
-
-    /* Return result. */
-    subColor.red = ctable[bestmatch].red;
-    subColor.green = ctable[bestmatch].green;
-    subColor.blue = ctable[bestmatch].blue;
-    free(ctable);
-    if (XAllocColor(dpy, cmap, &subColor)) {
-      *color = subColor;
-      return;
-    }
-    /* Extremely unlikely, but possibly color was deallocated
-       and reallocated by someone else before we could
-       XAllocColor the color cell we located.  If so, loop
-       again... */
-  }
-}
-
-static int
-ifSunCreator(void)
-{
-  char *xvendor, *glvendor, *renderer;
-  int isSunCreator = 0; /* Until proven that it is. */
-  int savedDisplayMode = 0;
-  char *savedDisplayString = 0;
-  GLUTwindow *window;
-
-#define VENDOR_SUN "Sun Microsystems"
-#define RENDERER_CREATOR "Creator"
-
-  /* Check the X vendor string first.  It is easier to check
-     than the OpenGL vendor and renderer strings since it
-     doesn't require a valid OpenGL rendering context.  Bail
-     early if not connected to a Sun. */
-  xvendor = ServerVendor(__glutDisplay);
-  if (!strncmp(xvendor, VENDOR_SUN, sizeof(VENDOR_SUN) - 1)) {
-
-    /* We need a valid current OpenGL rendering context to be
-       able to call glGetString successfully.  If there is not
-       a current window, set up a temporary one just to call
-       glGetString with (gag, expensive). */
-    if (__glutCurrentWindow) {
-      window = NULL;
-    } else {
-      savedDisplayMode = __glutDisplayMode;
-      savedDisplayString = __glutDisplayString;
-      __glutDisplayMode = GLUT_RGB | GLUT_SINGLE;
-      __glutDisplayString = NULL;
-      window = __glutCreateWindow(NULL, 0, 0, 1, 1, 0);
-    }
-
-    glvendor = (char *) glGetString(GL_VENDOR);
-    if (!strncmp(glvendor, VENDOR_SUN, sizeof(VENDOR_SUN) - 1)) {
-      renderer = (char *) glGetString(GL_RENDERER);
-      if (!strncmp(renderer, RENDERER_CREATOR, sizeof(RENDERER_CREATOR) - 1)) {
-        isSunCreator = 1;
-      }
-    }
-    /* Destroy the temporary window for glGetString if one
-       needed to be created. */
-    if (window) {
-      __glutDestroyWindow(window, window);
-      __glutDisplayMode = savedDisplayMode;
-      __glutDisplayString = savedDisplayString;
-    }
-  }
-  return isSunCreator;
-}
-
-static void
-menuVisualSetup(void)
-{
-  XLayerVisualInfo template, *visual, *overlayVisuals;
-  XColor color;
-  Status status;
-  Bool presumablyMesa;
-  int layer, nVisuals, i, dummy;
-  unsigned long *placeHolders = NULL;
-  int numPlaceHolders = 0;
-  Bool allocateHigh;
-
-  allocateHigh = ifSunCreator();
-
-  /* Start with the highest overlay layer and work down.  I
-     don't think any hardware has more than 3 overlay layers. */
-  for (layer = 3; layer > 0; layer--) {
-    template.layer = layer;
-    template.vinfo.screen = __glutScreen;
-    overlayVisuals = __glutXGetLayerVisualInfo(__glutDisplay,
-      VisualScreenMask | VisualLayerMask, &template, &nVisuals);
-    if (overlayVisuals) {
-      /* First, check if the default visual is in this layer.
-         If the default visual is in this layer, we try to use
-         it since it has pre-defined black and white pixels and 
-
-         using the default visual will probably minimize
-         colormap flashing problems. Suggested by Thomas Roell
-         ([email protected]). */
-      for (i = 0; i < nVisuals; i++) {
-        visual = &overlayVisuals[i];
-        if (visual->vinfo.colormap_size >= 3) {
-          /* Compare visual IDs just to be safe. */
-          if (visual->vinfo.visual->visualid == DefaultVisual(__glutDisplay, __glutScreen)->visualid) {
-            /* Settle for default visual. */
-            menuVisual = DefaultVisual(__glutDisplay, __glutScreen);
-            menuDepth = DefaultDepth(__glutDisplay, __glutScreen);
-            menuColormap = DefaultColormap(__glutDisplay, __glutScreen);
-            menuBlack = BlackPixel(__glutDisplay, __glutScreen);
-            menuWhite = WhitePixel(__glutDisplay, __glutScreen);
-            color.red = color.green = color.blue = 0xaa00;
-            noFaultXAllocColor(__glutDisplay, menuColormap,
-              menuVisual->map_entries, &color);
-            menuGray = color.pixel;
-            useSaveUnders = 0;
-            XFree(overlayVisuals);
-            return;
-          }
-        }
-      }
-      for (i = 0; i < nVisuals; i++) {
-        visual = &overlayVisuals[i];
-        if (visual->vinfo.colormap_size >= 3) {
-          if (allocateHigh) {
-            /* For Sun's Creator graphics, try to force the
-               read-only colors to the high end of the colormap
-               by first allocating read-write place-holder cells
-               for all but the last three cells.  This helps
-               avoid colormap flashing problems. */
-            numPlaceHolders = visual->vinfo.colormap_size - 3;
-            if (numPlaceHolders > 0) {
-              placeHolders = (unsigned long *)
-                malloc(numPlaceHolders * sizeof(unsigned long));
-              /* A malloc failure would be harmless. */
-            }
-          }
-          menuColormap = XCreateColormap(__glutDisplay, __glutRoot,
-            visual->vinfo.visual, AllocNone);
-          if (placeHolders) {
-            /* Again for Sun's Creator graphics, do the actual
-               read-write place-holder cell allocation. */
-            status = XAllocColorCells(__glutDisplay, menuColormap, False, 0, 0,
-              placeHolders, numPlaceHolders);
-            if (!status) {
-              XFreeColormap(__glutDisplay, menuColormap);
-              free(placeHolders);
-              placeHolders = NULL;
-              continue;
-            }
-          }
-          /* Allocate overlay colormap cells in defined order:
-             gray, black, white to match the IRIS GL allocation
-             scheme.  Increases likelihood of less overlay
-             colormap flashing. */
-          /* XXX Nice if these 3 AllocColor's could be done in
-             one protocol round-trip. */
-          color.red = color.green = color.blue = 0xaa00;
-          status = XAllocColor(__glutDisplay,
-            menuColormap, &color);
-          if (!status) {
-            XFreeColormap(__glutDisplay, menuColormap);
-            if (placeHolders) {
-              free(placeHolders);
-              placeHolders = NULL;
-            }
-            continue;
-          }
-          menuGray = color.pixel;
-          color.red = color.green = color.blue = 0x0000;
-          status = XAllocColor(__glutDisplay,
-            menuColormap, &color);
-          if (!status) {
-            XFreeColormap(__glutDisplay, menuColormap);
-            if (placeHolders) {
-              free(placeHolders);
-              placeHolders = NULL;
-            }
-            continue;
-          }
-          menuBlack = color.pixel;
-          color.red = color.green = color.blue = 0xffff;
-          status = XAllocColor(__glutDisplay,
-            menuColormap, &color);
-          if (!status) {
-            XFreeColormap(__glutDisplay, menuColormap);
-            if (placeHolders) {
-              free(placeHolders);
-              placeHolders = NULL;
-            }
-            continue;
-          }
-          if (placeHolders) {
-            /* Now free the placeholder cells. */
-            XFreeColors(__glutDisplay, menuColormap,
-              placeHolders, numPlaceHolders, 0);
-            free(placeHolders);
-            placeHolders = NULL;
-          }
-          menuWhite = color.pixel;
-          menuVisual = visual->vinfo.visual;
-          menuDepth = visual->vinfo.depth;
-          /* If using overlays, do not request "save unders". */
-          useSaveUnders = 0;
-          XFree(overlayVisuals);
-          return;
-        }
-      }
-      XFree(overlayVisuals);
-    }
-  }
-  /* Settle for default visual. */
-  menuVisual = DefaultVisual(__glutDisplay, __glutScreen);
-  menuDepth = DefaultDepth(__glutDisplay, __glutScreen);
-  menuColormap = DefaultColormap(__glutDisplay, __glutScreen);
-  menuBlack = BlackPixel(__glutDisplay, __glutScreen);
-  menuWhite = WhitePixel(__glutDisplay, __glutScreen);
-  color.red = color.green = color.blue = 0xaa00;
-  noFaultXAllocColor(__glutDisplay, menuColormap,
-    menuVisual->map_entries, &color);
-  menuGray = color.pixel;
-
-  /* When no overlays are supported, we would like to use X
-     "save unders" to avoid exposes to windows obscured by
-     pop-up menus.  However, OpenGL's direct rendering support
-     means OpenGL interacts poorly with X backing store and
-     save unders.  X servers do not (in implementation
-     practice) redirect OpenGL rendering destined to obscured
-     window regions into backing store.
-
-     Implementation solutions exist for this problem, but they
-     are expensive and high-end OpenGL implementations
-     typically provide fast rendering and/or overlays to
-     obviate the problem associated of user interfaces (pop-up
-     menus) forcing redraws of complex normal plane scenes.
-     (See support for overlays pop-up menus above.)
-
-     Mesa 3D, however, does not support direct rendering.
-     Overlays are often unavailable to Mesa, and Mesa is also
-     relatively slow.  For these reasons, Mesa-rendering GLUT
-     programs can and should use X save unders.
-
-     Look for the GLX extension.  If _not_ supported, we are
-     presumably using Mesa so enable save unders. */
-
-  presumablyMesa = !XQueryExtension(__glutDisplay, "GLX",
-    &dummy, &dummy, &dummy);
-
-  if (presumablyMesa) {
-    useSaveUnders = CWSaveUnder;
-  } else {
-    useSaveUnders = 0;
-  }
-}
-
-static void
-menuSetup(void)
-{
-  if (menuFont) {
-    /* MenuFont overload to indicate menu initalization. */
-    return;
-  }
-  menuFont = XLoadQueryFont(__glutDisplay,
-    "-*-helvetica-bold-o-normal--14-*-*-*-p-*-iso8859-1");
-  if (!menuFont) {
-    /* Try back up font. */
-    menuFont = XLoadQueryFont(__glutDisplay, "fixed");
-  }
-  if (!menuFont) {
-    __glutFatalError("could not load font.");
-  }
-  menuVisualSetup();
-  fontHeight = menuFont->ascent + menuFont->descent;
-  menuCursor = XCreateFontCursor(__glutDisplay, XC_arrow);
-}
-
-static void
-menuGraphicsContextSetup(Window win)
-{
-  XGCValues gcvals;
-
-  if (blackGC != None) {
-    return;
-  }
-  gcvals.font = menuFont->fid;
-  gcvals.foreground = menuBlack;
-  blackGC = XCreateGC(__glutDisplay, win,
-    GCFont | GCForeground, &gcvals);
-  gcvals.foreground = menuGray;
-  grayGC = XCreateGC(__glutDisplay, win, GCForeground, &gcvals);
-  gcvals.foreground = menuWhite;
-  whiteGC = XCreateGC(__glutDisplay, win, GCForeground, &gcvals);
-}
-
-void
-__glutSetMenu(GLUTmenu * menu)
-{
-  __glutCurrentMenu = menu;
-}
-
-static void
-unmapMenu(GLUTmenu * menu)
-{
-  if (menu->cascade) {
-    unmapMenu(menu->cascade);
-    menu->cascade = NULL;
-  }
-  menu->anchor = NULL;
-  menu->highlighted = NULL;
-  XUnmapWindow(__glutDisplay, menu->win);
-}
-
-static void
-finishMenu(Window win, int x, int y)
-{
-  Window dummy;
-  int rc;
-
-  unmapMenu(__glutMappedMenu);
-  XUngrabPointer(__glutDisplay, CurrentTime);
-
-  /* Popping up an overlay popup menu will install its own
-     colormap.  If the window associated with the menu has an
-     overlay, install that window's overlay colormap so the
-     overlay isn't left using the popup menu's colormap. */
-  if (__glutMenuWindow->overlay) {
-    XInstallColormap(__glutDisplay,
-      __glutMenuWindow->overlay->colormap->cmap);
-  }
-
-  /* This XFlush is needed to to make sure the pointer is
-     really ungrabbed when the application's menu callback is
-     called. Otherwise, a deadlock might happen because the
-     application may try to read from an terminal window, but
-     yet the ungrab hasn't really happened since it hasn't been
-     flushed out. */
-  XFlush(__glutDisplay);
-
-  if (__glutMenuStatusFunc) {
-    if (win != __glutMenuWindow->win) {
-      /* The button release may have occurred in a window other
-         than the window requesting the pop-up menu (for
-         example, one of the submenu windows).  In this case, we
-         need to translate the coordinates into the coordinate
-         system of the window associated with the window. */
-      rc = XTranslateCoordinates(__glutDisplay, win, __glutMenuWindow->win,
-        x, y, &x, &y, &dummy);
-      assert(rc != False);  /* Will always be on same screen. */
-    }
-    __glutSetWindow(__glutMenuWindow);
-    __glutSetMenu(__glutMappedMenu);
-
-    /* Setting __glutMappedMenu to NULL permits operations that
-       change menus or destroy the menu window again. */
-    __glutMappedMenu = NULL;
-
-    __glutMenuStatusFunc(GLUT_MENU_NOT_IN_USE, x, y);
-  }
-  /* Setting __glutMappedMenu to NULL permits operations that
-     change menus or destroy the menu window again. */
-  __glutMappedMenu = NULL;
-
-  /* If an item is selected and it is not a submenu trigger,
-     generate menu callback. */
-  if (__glutItemSelected && !__glutItemSelected->isTrigger) {
-    __glutSetWindow(__glutMenuWindow);
-    /* When menu callback is triggered, current menu should be
-       set to the callback menu. */
-    __glutSetMenu(__glutItemSelected->menu);
-    __glutItemSelected->menu->select(
-      __glutItemSelected->value);
-  }
-  __glutMenuWindow = NULL;
-}
-
-#define MENU_BORDER 1
-#define MENU_GAP 2
-#define MENU_ARROW_GAP 6
-#define MENU_ARROW_WIDTH 8
-
-static void
-mapMenu(GLUTmenu * menu, int x, int y)
-{
-  XWindowChanges changes;
-  unsigned int mask;
-  int subMenuExtension, num;
-
-  /* If there are submenus, we need to provide extra space for
-     the submenu pull arrow.  */
-  if (menu->submenus > 0) {
-    subMenuExtension = MENU_ARROW_GAP + MENU_ARROW_WIDTH;
-  } else {
-    subMenuExtension = 0;
-  }
-
-  changes.stack_mode = Above;
-  mask = CWStackMode | CWX | CWY;
-  /* If the menu isn't managed (ie, validated so all the
-     InputOnly subwindows are the right size), do so.  */
-  if (!menu->managed) {
-    GLUTmenuItem *item;
-
-    item = menu->list;
-    num = menu->num;
-    while (item) {
-      XWindowChanges itemupdate;
-
-      itemupdate.y = (num - 1) * fontHeight + MENU_GAP;
-      itemupdate.width = menu->pixwidth;
-      itemupdate.width += subMenuExtension;
-      XConfigureWindow(__glutDisplay, item->win,
-        CWWidth | CWY, &itemupdate);
-      item = item->next;
-      num--;
-    }
-    menu->pixheight = MENU_GAP +
-      fontHeight * menu->num + MENU_GAP;
-    changes.height = menu->pixheight;
-    changes.width = MENU_GAP +
-      menu->pixwidth + subMenuExtension + MENU_GAP;
-    mask |= CWWidth | CWHeight;
-    menu->managed = True;
-  }
-  /* Make sure menu appears fully on screen. */
-  if (y + menu->pixheight >= __glutScreenHeight) {
-    changes.y = __glutScreenHeight - menu->pixheight;
-  } else {
-    changes.y = y;
-  }
-  if (x + menu->pixwidth + subMenuExtension >=
-    __glutScreenWidth) {
-    changes.x = __glutScreenWidth -
-      menu->pixwidth + subMenuExtension;
-  } else {
-    changes.x = x;
-  }
-
-  /* Rember where the menu is placed so submenus can be
-     properly placed relative to it. */
-  menu->x = changes.x;
-  menu->y = changes.y;
-
-  XConfigureWindow(__glutDisplay, menu->win, mask, &changes);
-  XInstallColormap(__glutDisplay, menuColormap);
-  /* XXX The XRaiseWindow below should not be necessary because
-     the XConfigureWindow requests an Above stack mode (same as
-     XRaiseWindow), but some Sun users complained this was still
-     necessary.  Probably some window manager or X server bug on
-     these machines?? */
-  XRaiseWindow(__glutDisplay, menu->win);
-  XMapWindow(__glutDisplay, menu->win);
-}
-
-static void
-startMenu(GLUTmenu * menu, GLUTwindow * window,
-  int x, int y, int x_win, int y_win)
-{
-  int grab;
-
-  assert(__glutMappedMenu == NULL);
-  grab = XGrabPointer(__glutDisplay, __glutRoot, True,
-    ButtonPressMask | ButtonReleaseMask,
-    GrabModeAsync, GrabModeAsync,
-    __glutRoot, menuCursor, CurrentTime);
-  if (grab != GrabSuccess) {
-    /* Somebody else has pointer grabbed, ignore menu
-       activation. */
-    return;
-  }
-  __glutMappedMenu = menu;
-  __glutMenuWindow = window;
-  __glutItemSelected = NULL;
-  if (__glutMenuStatusFunc) {
-    __glutSetMenu(menu);
-    __glutSetWindow(window);
-    __glutMenuStatusFunc(GLUT_MENU_IN_USE, x_win, y_win);
-  }
-  mapMenu(menu, x, y);
-}
-
-static void
-paintSubMenuArrow(Window win, int x, int y)
-{
-  XPoint p[5];
-
-  p[0].x = p[4].x = x;
-  p[0].y = p[4].y = y - menuFont->ascent + 1;
-  p[1].x = p[0].x + MENU_ARROW_WIDTH - 1;
-  p[1].y = p[0].y + (menuFont->ascent / 2) - 1;
-  p[2].x = p[1].x;
-  p[2].y = p[1].y + 1;
-  p[3].x = p[0].x;
-  p[3].y = p[0].y + menuFont->ascent - 2;
-  XFillPolygon(__glutDisplay, win,
-    whiteGC, p, 4, Convex, CoordModeOrigin);
-  XDrawLines(__glutDisplay, win, blackGC, p, 5, CoordModeOrigin);
-}
-
-static void
-paintMenuItem(GLUTmenuItem * item, int num)
-{
-  Window win = item->menu->win;
-  GC gc;
-  int y;
-  int subMenuExtension;
-
-  if (item->menu->submenus > 0) {
-    subMenuExtension = MENU_ARROW_GAP + MENU_ARROW_WIDTH;
-  } else {
-    subMenuExtension = 0;
-  }
-  if (item->menu->highlighted == item) {
-    gc = whiteGC;
-  } else {
-    gc = grayGC;
-  }
-  y = MENU_GAP + fontHeight * num - menuFont->descent;
-  XFillRectangle(__glutDisplay, win, gc,
-    MENU_GAP, y - fontHeight + menuFont->descent,
-    item->menu->pixwidth + subMenuExtension, fontHeight);
-  XDrawString(__glutDisplay, win, blackGC,
-    MENU_GAP, y, item->label, item->len);
-  if (item->isTrigger) {
-    paintSubMenuArrow(win,
-      item->menu->pixwidth + MENU_ARROW_GAP + 1, y);
-  }
-}
-
-static void
-paintMenu(GLUTmenu * menu)
-{
-  GLUTmenuItem *item;
-  int i = menu->num;
-  int y = MENU_GAP + fontHeight * i - menuFont->descent;
-
-  item = menu->list;
-  while (item) {
-    if (item->menu->highlighted == item) {
-      paintMenuItem(item, i);
-    } else {
-      /* Quick render of the menu item; assume background
-         already cleared to gray. */
-      XDrawString(__glutDisplay, menu->win, blackGC,
-        2, y, item->label, item->len);
-      if (item->isTrigger) {
-        paintSubMenuArrow(menu->win,
-          menu->pixwidth + MENU_ARROW_GAP + 1, y);
-      }
-    }
-    i--;
-    y -= fontHeight;
-    item = item->next;
-  }
-}
-
-static GLUTmenuItem *
-getMenuItem(GLUTmenu * menu, Window win, int *which)
-{
-  GLUTmenuItem *item;
-  int i;
-
-  if (menu->searched) {
-    __glutFatalError("submenu infinite loop detected");
-  }
-  menu->searched = True;
-  i = menu->num;
-  item = menu->list;
-  while (item) {
-    if (item->win == win) {
-      *which = i;
-      menu->searched = False;
-      return item;
-    }
-    if (item->isTrigger) {
-      GLUTmenuItem *subitem;
-
-      subitem = __glutGetMenuItem(__glutMenuList[item->value],
-        win, which);
-      if (subitem) {
-        menu->searched = False;
-        return subitem;
-      }
-    }
-    i--;
-    item = item->next;
-  }
-  menu->searched = False;
-  return NULL;
-}
-
-static int
-getMenuItemIndex(GLUTmenuItem * item)
-{
-  int count = 0;
-
-  while (item) {
-    count++;
-    item = item->next;
-  }
-  return count;
-}
-
-static GLUTmenu *
-getMenu(Window win)
-{
-  GLUTmenu *menu;
-
-  menu = __glutMappedMenu;
-  while (menu) {
-    if (win == menu->win) {
-      return menu;
-    }
-    menu = menu->cascade;
-  }
-  return NULL;
-}
-
-static GLUTmenu *
-getMenuByNum(int menunum)
-{
-  if (menunum < 1 || menunum > menuListSize) {
-    return NULL;
-  }
-  return __glutMenuList[menunum - 1];
-}
-
-static int
-getUnusedMenuSlot(void)
-{
-  int i;
-
-  /* Look for allocated, unused slot. */
-  for (i = 0; i < menuListSize; i++) {
-    if (!__glutMenuList[i]) {
-      return i;
-    }
-  }
-  /* Allocate a new slot. */
-  menuListSize++;
-  if (__glutMenuList) {
-    __glutMenuList = (GLUTmenu **)
-      realloc(__glutMenuList, menuListSize * sizeof(GLUTmenu *));
-  } else {
-    /* XXX Some realloc's do not correctly perform a malloc
-       when asked to perform a realloc on a NULL pointer,
-       though the ANSI C library spec requires this. */
-    __glutMenuList = (GLUTmenu **) malloc(sizeof(GLUTmenu *));
-  }
-  if (!__glutMenuList) {
-    __glutFatalError("out of memory.");
-  }
-  __glutMenuList[menuListSize - 1] = NULL;
-  return menuListSize - 1;
-}
-
-void
-__glutMenuModificationError(void)
-{
-  /* XXX Remove the warning after GLUT 3.0. */
-  __glutWarning("The following is a new check for GLUT 3.0; update your code.");
-  __glutFatalError("menu manipulation not allowed while menus in use.");
-}
-
-
-static void
-menuItemEnterOrLeave(GLUTmenuItem * item,
-  int num, int type)
-{
-  int alreadyUp = 0;
-
-  if (type == EnterNotify) {
-    GLUTmenuItem *prevItem = item->menu->highlighted;
-
-    if (prevItem && prevItem != item) {
-      /* If there's an already higlighted item in this menu
-         that is different from this one (we could be
-         re-entering an item with an already cascaded
-         submenu!), unhighlight the previous item. */
-      item->menu->highlighted = NULL;
-      paintMenuItem(prevItem, getMenuItemIndex(prevItem));
-    }
-    item->menu->highlighted = item;
-    __glutItemSelected = item;
-    if (item->menu->cascade) {
-      if (!item->isTrigger) {
-        /* Entered a menu item that is not a submenu trigger,
-           so pop down the current submenu cascade of this
-           menu.  */
-        unmapMenu(item->menu->cascade);
-        item->menu->cascade = NULL;
-      } else {
-        GLUTmenu *submenu = __glutMenuList[item->value];
-
-        if (submenu->anchor == item) {
-          /* We entered the submenu trigger for the submenu
-             that is already up, so don't take down the
-             submenu.  */
-          alreadyUp = 1;
-        } else {
-          /* Submenu already popped up for some other submenu
-             item of this menu; need to pop down that other
-             submenu cascade.  */
-          unmapMenu(item->menu->cascade);
-          item->menu->cascade = NULL;
-        }
-      }
-    }
-    if (!alreadyUp) {
-      /* Make sure the menu item gets painted with
-         highlighting. */
-      paintMenuItem(item, num);
-    } else {
-      /* If already up, should already be highlighted.  */
-    }
-  } else {
-    /* LeaveNotify: Handle leaving a menu item...  */
-    if (item->menu->cascade &&
-      item->menu->cascade->anchor == item) {
-      /* If there is a submenu casacaded from this item, do not
-         change the highlighting on this item upon leaving. */
-    } else {
-      /* Unhighlight this menu item.  */
-      item->menu->highlighted = NULL;
-      paintMenuItem(item, num);
-    }
-    __glutItemSelected = NULL;
-  }
-  if (item->isTrigger) {
-    if (type == EnterNotify && !alreadyUp) {
-      GLUTmenu *submenu = __glutMenuList[item->value];
-
-      mapMenu(submenu,
-        item->menu->x + item->menu->pixwidth +
-        MENU_ARROW_GAP + MENU_ARROW_WIDTH +
-        MENU_GAP + MENU_BORDER,
-        item->menu->y + fontHeight * (num - 1) + MENU_GAP);
-      item->menu->cascade = submenu;
-      submenu->anchor = item;
-    }
-  }
-}
-
-/* Installs callback functions for use by glut_event.c  The point
-   of this is so that GLUT's menu code only gets linked into
-   GLUT binaries (assuming a static library) if the GLUT menu
-   API is used. */
-static void
-installMenuCallbacks(void)
-{
-  __glutMenuItemEnterOrLeave = menuItemEnterOrLeave;
-  __glutFinishMenu = finishMenu;
-  __glutPaintMenu = paintMenu;
-  __glutStartMenu = startMenu;
-  __glutGetMenuByNum = getMenuByNum;
-  __glutGetMenu = getMenu;
-  __glutGetMenuItem = getMenuItem;
-}
-
-int GLUTAPIENTRY 
-glutCreateMenu(GLUTselectCB selectFunc)
-{
-  XSetWindowAttributes wa;
-  GLUTmenu *menu;
-  int menuid;
-
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  if (!__glutDisplay) {
-    __glutOpenXConnection(NULL);
-  }
-
-  installMenuCallbacks();
-
-  menuid = getUnusedMenuSlot();
-  menu = (GLUTmenu *) malloc(sizeof(GLUTmenu));
-  if (!menu) {
-    __glutFatalError("out of memory.");
-  }
-  menu->id = menuid;
-  menu->num = 0;
-  menu->submenus = 0;
-  menu->managed = False;
-  menu->searched = False;
-  menu->pixwidth = 0;
-  menu->select = selectFunc;
-  menu->list = NULL;
-  menu->cascade = NULL;
-  menu->highlighted = NULL;
-  menu->anchor = NULL;
-  menuSetup();
-  wa.override_redirect = True;
-  wa.background_pixel = menuGray;
-  wa.border_pixel = menuBlack;
-  wa.colormap = menuColormap;
-  wa.event_mask = StructureNotifyMask | ExposureMask |
-    ButtonPressMask | ButtonReleaseMask |
-    EnterWindowMask | LeaveWindowMask;
-  /* Save unders really only enabled if useSaveUnders is set to
-     CWSaveUnder, ie. using Mesa 3D.  See earlier comments. */
-  wa.save_under = True;
-  menu->win = XCreateWindow(__glutDisplay, __glutRoot,
-  /* Real position determined when mapped. */
-    0, 0,
-  /* Real size will be determined when menu is manged. */
-    1, 1,
-    MENU_BORDER, menuDepth, InputOutput, menuVisual,
-    CWOverrideRedirect | CWBackPixel | CWBorderPixel |
-    CWEventMask | CWColormap | useSaveUnders,
-    &wa);
-  menuGraphicsContextSetup(menu->win);
-  __glutMenuList[menuid] = menu;
-  __glutSetMenu(menu);
-  return menuid + 1;
-}
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutGetMenu(void)
-{
-  if (__glutCurrentMenu) {
-    return __glutCurrentMenu->id + 1;
-  } else {
-    return 0;
-  }
-}
-
-void GLUTAPIENTRY 
-glutSetMenu(int menuid)
-{
-  GLUTmenu *menu;
-
-  if (menuid < 1 || menuid > menuListSize) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  menu = __glutMenuList[menuid - 1];
-  if (!menu) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  __glutSetMenu(menu);
-}
-/* ENDCENTRY */
-
-void
-__glutSetMenuItem(GLUTmenuItem * item, const char *label,
-  int value, Bool isTrigger)
-{
-  GLUTmenu *menu;
-
-  menu = item->menu;
-  item->label = __glutStrdup(label);
-  if (!item->label) {
-    __glutFatalError("out of memory.");
-  }
-  item->isTrigger = isTrigger;
-  item->len = (int) strlen(label);
-  item->value = value;
-  item->pixwidth = XTextWidth(menuFont, label, item->len) + 4;
-  if (item->pixwidth > menu->pixwidth) {
-    menu->pixwidth = item->pixwidth;
-  }
-  menu->managed = False;
-}
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutAddMenuEntry(const char *label, int value)
-{
-  XSetWindowAttributes wa;
-  GLUTmenuItem *entry;
-
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  entry = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
-  if (!entry) {
-    __glutFatalError("out of memory.");
-  }
-  entry->menu = __glutCurrentMenu;
-  __glutSetMenuItem(entry, label, value, False);
-  wa.event_mask = EnterWindowMask | LeaveWindowMask;
-  entry->win = XCreateWindow(__glutDisplay,
-    __glutCurrentMenu->win, MENU_GAP,
-    __glutCurrentMenu->num * fontHeight + MENU_GAP,  /* x & y */
-    entry->pixwidth, fontHeight,  /* width & height */
-    0, CopyFromParent, InputOnly, CopyFromParent,
-    CWEventMask, &wa);
-  XMapWindow(__glutDisplay, entry->win);
-  __glutCurrentMenu->num++;
-  entry->next = __glutCurrentMenu->list;
-  __glutCurrentMenu->list = entry;
-}
-
-void GLUTAPIENTRY 
-glutAddSubMenu(const char *label, int menu)
-{
-  XSetWindowAttributes wa;
-  GLUTmenuItem *submenu;
-
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  submenu = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
-  if (!submenu) {
-    __glutFatalError("out of memory.");
-  }
-  __glutCurrentMenu->submenus++;
-  submenu->menu = __glutCurrentMenu;
-  __glutSetMenuItem(submenu, label, /* base 0 */ menu - 1, True);
-  wa.event_mask = EnterWindowMask | LeaveWindowMask;
-  submenu->win = XCreateWindow(__glutDisplay,
-    __glutCurrentMenu->win, MENU_GAP,
-    __glutCurrentMenu->num * fontHeight + MENU_GAP,  /* x & y */
-    submenu->pixwidth, fontHeight,  /* width & height */
-    0, CopyFromParent, InputOnly, CopyFromParent,
-    CWEventMask, &wa);
-  XMapWindow(__glutDisplay, submenu->win);
-  __glutCurrentMenu->num++;
-  submenu->next = __glutCurrentMenu->list;
-  __glutCurrentMenu->list = submenu;
-}
-
-void GLUTAPIENTRY 
-glutAttachMenu(int button)
-{
-  /* if button >= GLUT_MAX_MENUS, we'll go out of array bounds below */
-  if (button >= GLUT_MAX_MENUS) {
-    return;
-  }
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  installMenuCallbacks();
-  if (__glutCurrentWindow->menu[button] < 1) {
-    __glutCurrentWindow->buttonUses++;
-  }
-  __glutChangeWindowEventMask(
-    ButtonPressMask | ButtonReleaseMask, True);
-  __glutCurrentWindow->menu[button] = __glutCurrentMenu->id + 1;
-}
-/* ENDCENTRY */