initial check-in (post crash)

68 files changed, 33991 insertions, 0 deletions

diff --git a/src/glut/glx/Makefile.X11 b/src/glut/glx/Makefile.X11
new file mode 100644
index 0000000000..04676e0489
--- /dev/null
+++ b/src/glut/glx/Makefile.X11
@@ -0,0 +1,121 @@
+# $Id: Makefile.X11,v 1.1 1999/08/19 14:00:01 brianp Exp $
+
+# Makefile for GLUT
+#
+# NOTICE:  The OpenGL Utility Toolkit (GLUT) distribution contains source
+# code published in a book titled "Programming OpenGL for the X Window
+# System" (ISBN: 0-201-48359-9) published by Addison-Wesley.  The
+# programs and associated files contained in the distribution were
+# developed by Mark J. Kilgard and are Copyright 1994, 1995, 1996 by Mark
+# J. Kilgard (unless otherwise noted).  The programs are not in the
+# public domain, but they are freely distributable without licensing
+# fees.  These programs are provided without guarantee or warrantee
+# expressed or implied.
+#
+# GLUT source included with Mesa with permission from Mark Kilgard.
+
+
+# $Log: Makefile.X11,v $
+# Revision 1.1  1999/08/19 14:00:01  brianp
+# initial check-in (post crash)
+#
+
+
+##### MACROS #####
+
+GLUT_MAJOR = 3
+GLUT_MINOR = 7
+
+VPATH = RCS
+
+INCDIR = ../include
+LIBDIR = ../lib
+
+SOURCES = \
+	glut_8x13.c \
+	glut_9x15.c \
+	glut_bitmap.c \
+	glut_bwidth.c \
+	glut_cindex.c \
+	glut_cmap.c \
+	glut_cursor.c \
+	glut_dials.c \
+	glut_dstr.c \
+	glut_event.c \
+	glut_ext.c \
+	glut_fbc.c \
+	glut_fullscrn.c \
+	glut_gamemode.c \
+	glut_get.c \
+	glut_glxext.c \
+	glut_hel10.c \
+	glut_hel12.c \
+	glut_hel18.c \
+	glut_init.c \
+	glut_input.c \
+	glut_joy.c \
+	glut_key.c \
+	glut_keyctrl.c \
+	glut_keyup.c \
+	glut_menu.c \
+	glut_menu2.c \
+	glut_mesa.c \
+	glut_modifier.c \
+	glut_mroman.c \
+	glut_overlay.c \
+	glut_roman.c \
+	glut_shapes.c \
+	glut_space.c \
+	glut_stroke.c \
+	glut_swap.c \
+	glut_swidth.c \
+	glut_tablet.c \
+	glut_teapot.c \
+	glut_tr10.c \
+	glut_tr24.c \
+	glut_util.c \
+	glut_vidresize.c \
+	glut_warp.c \
+	glut_win.c \
+	glut_winmisc.c \
+	layerutil.c
+
+
+OBJECTS = $(SOURCES:.c=.o)
+
+
+
+##### RULES #####
+
+.c.o:
+	$(CC) -c -I$(INCDIR) $(CFLAGS) $<
+
+
+
+##### TARGETS #####
+
+default:
+	@echo "Specify a target configuration"
+
+clean:
+	-rm *.o *~
+
+targets: $(LIBDIR)/$(GLUT_LIB)
+
+# Make the library
+$(LIBDIR)/$(GLUT_LIB): $(OBJECTS)
+	$(MAKELIB) $(GLUT_LIB) $(GLUT_MAJOR) $(GLUT_MINOR) $(OBJECTS)
+	mv $(GLUT_LIB)* $(LIBDIR)
+
+include ../Make-config
+
+include depend
+
+
+
+#
+# Run 'make dep' to update the dependencies if you change what's included
+# by any source file.
+# 
+dep: $(SOURCES)
+	makedepend -fdepend -Y -I../include $(SOURCES)
diff --git a/src/glut/glx/Makefile.cygnus b/src/glut/glx/Makefile.cygnus
new file mode 100644
index 0000000000..cf41987a55
--- /dev/null
+++ b/src/glut/glx/Makefile.cygnus
@@ -0,0 +1,109 @@
+# Makefile.cygnus for Cygnus-Win32 target
+# /Stephane Rehel, November 16 1997
+
+# Makefile for GLUT 3.6
+#
+# NOTICE:  The OpenGL Utility Toolkit (GLUT) distribution contains source
+# code published in a book titled "Programming OpenGL for the X Window
+# System" (ISBN: 0-201-48359-9) published by Addison-Wesley.  The
+# programs and associated files contained in the distribution were
+# developed by Mark J. Kilgard and are Copyright 1994, 1995, 1996 by Mark
+# J. Kilgard (unless otherwise noted).  The programs are not in the
+# public domain, but they are freely distributable without licensing
+# fees.  These programs are provided without guarantee or warrantee
+# expressed or implied.
+#
+# GLUT source included with Mesa with permission from Mark Kilgard.
+
+
+##### MACROS #####
+
+GLUT_MAJOR = 3
+GLUT_MINOR = 6
+
+VPATH = RCS
+
+INCDIR = ../include
+LIBDIR = ../lib
+
+SOURCES = \
+	glut_8x13.c \
+	glut_9x15.c \
+	glut_bitmap.c \
+	glut_bwidth.c \
+	glut_cindex.c \
+	glut_cmap.c \
+	glut_cursor.c \
+	glut_dials.c \
+	glut_dstr.c \
+	glut_event.c \
+	glut_ext.c \
+	glut_fullscrn.c \
+	glut_get.c \
+	glut_hel10.c \
+	glut_hel12.c \
+	glut_hel18.c \
+	glut_init.c \
+	glut_input.c \
+	glut_mesa.c \
+	glut_modifier.c \
+	glut_mroman.c \
+	glut_overlay.c \
+	glut_roman.c \
+	glut_shapes.c \
+	glut_space.c \
+	glut_stroke.c \
+	glut_swap.c \
+	glut_swidth.c \
+	glut_tablet.c \
+	glut_teapot.c \
+	glut_tr10.c \
+	glut_tr24.c \
+	glut_util.c \
+	glut_vidresize.c \
+	glut_warp.c \
+	glut_win.c \
+	glut_winmisc.c \
+	win32_x11.c \
+	win32_glx.c \
+	win32_menu.c \
+	win32_util.c 
+
+OBJECTS = $(SOURCES:.c=.o)
+
+
+
+##### RULES #####
+
+.c.o:
+	$(CC) -c -I$(INCDIR) $(CFLAGS) $<
+
+
+
+##### TARGETS #####
+
+default:
+	@echo "Specify a target configuration"
+
+clean:
+	-rm *.o *~
+
+targets: $(LIBDIR)/$(GLUT_LIB)
+
+# Make the library
+$(LIBDIR)/$(GLUT_LIB): $(OBJECTS)
+	$(MAKELIB) $(GLUT_LIB) $(GLUT_MAJOR) $(GLUT_MINOR) $(OBJECTS)
+	mv $(GLUT_LIB)* $(LIBDIR)
+
+include ../Make-config
+
+include depend
+
+
+
+#
+# Run 'make dep' to update the dependencies if you change what's included
+# by any source file.
+# 
+dep: $(SOURCES)
+	makedepend -fdepend -Y -I../include $(SOURCES)
diff --git a/src/glut/glx/Makefile.sgi b/src/glut/glx/Makefile.sgi
new file mode 100644
index 0000000000..9514c324d2
--- /dev/null
+++ b/src/glut/glx/Makefile.sgi
@@ -0,0 +1,189 @@
+#! smake
+#
+# Copyright (c) Mark J. Kilgard, 1995, 1998.
+#
+include $(ROOT)/usr/include/make/commondefs
+
+# NOTE:  In my GLUT development tree, many of the C source files for
+# GLUT are generated.  For this reason, "make full_clobber" will remove
+# these generated C files, while "make clobber" will not.
+
+TOP = ../..
+
+TARGETS = libglut.a
+
+LN = ln -s
+MV = mv
+RM = -rm -rf
+
+HDRS = glutint.h glutstroke.h layerutil.h glutbitmap.h
+
+SRCS = \
+	glut_bitmap.c \
+	glut_bwidth.c \
+	glut_cindex.c \
+	glut_cmap.c \
+	glut_cursor.c \
+	glut_dials.c \
+	glut_dstr.c \
+	glut_event.c \
+	glut_ext.c \
+	glut_fbc.c \
+	glut_fullscrn.c \
+	glut_gamemode.c \
+	glut_get.c \
+	glut_glxext.c \
+	glut_init.c \
+	glut_input.c \
+	glut_joy.c \
+	glut_key.c \
+	glut_keyctrl.c \
+	glut_keyup.c \
+	glut_menu.c \
+	glut_menu2.c \
+	glut_mesa.c \
+	glut_modifier.c \
+	glut_overlay.c \
+	glut_shapes.c \
+	glut_space.c \
+	glut_stroke.c \
+	glut_swap.c \
+	glut_swidth.c \
+	glut_tablet.c \
+	glut_teapot.c \
+	glut_util.c \
+	glut_vidresize.c \
+	glut_warp.c \
+	glut_win.c \
+	glut_winmisc.c \
+	layerutil.c
+
+SRCSSEMIGENS = \
+	glut_8x13.c \
+	glut_9x15.c \
+	glut_hel10.c \
+	glut_hel12.c \
+	glut_hel18.c \
+	glut_mroman.c \
+	glut_roman.c \
+	glut_tr10.c \
+	glut_tr24.c
+
+OBJS = $(SRCS:.c=.o) $(SRCSSEMIGENS:.c=.o)
+OTHERGENS = y.tab.c y.tab.h strokegen.c strokegen.h strokelex.c
+OTHERSRCS = strokegen.y strokelex.l stroke.h
+FONTS = Roman.stroke MonoRoman.stroke
+
+# Uncomment the LCDEFS line below if you want to build a version of
+# libglut.a that avoids using the SGI "fast atoms" optimization
+# introduced in IRIX 6.3.  This optimization eliminates serveral X server
+# round-trips.  If you are building libglut.a on an IRIX 6.3 or later
+# machine and want a chance (no guarantees) that GLUT executables built
+# against your libglut.a will work on IRIX 6.2 machines, uncomment out
+# the LCDEFS line below.  Otherwise, you'll get a run-time message about
+# "attempted access to unresolvable symbol in XXX: _XSGIFastInternAtom"
+#LCDEFS = -DNO_FAST_ATOMS
+
+LCOPTS = -I$(TOP)/include -fullwarn 
+LWOFF = ,813,852,827,826
+LDIRT = *~ $(OTHERGENS) strokegen *.bak hardcopy glutsrc.ps capturexfont *.pure dstr dstr.c *.gen
+
+default: $(TARGETS)
+
+sinclude ObjectType.mk
+
+$(OBJS) : $(HDRS)
+
+libglut.a : $(OBJS)
+	$(RM) $@
+	$(AR) crl $@ $(OBJS)
+
+.ORDER : strokegen.h strokegen.c
+
+strokegen.h strokegen.c : strokegen.y
+	$(YACC) -d strokegen.y
+	$(MV) y.tab.c strokegen.c
+	$(MV) y.tab.h strokegen.h
+
+# avoid warnings when compiling lex generated code
+strokegen.o : strokegen.c
+	$(CC) $(CFLAGS) -woff 726,825,635,818,819,820,824,831,835,822,821,1167,1498,1116,1136,1174,1196,803 -c -MDupdate Makedepend strokegen.c
+
+strokelex.c : strokelex.l
+	$(LEX) strokelex.l
+	$(MV) lex.yy.c strokelex.c
+
+# avoid warnings when compiling lex generated code
+strokelex.o : strokelex.c
+	$(CC) $(CFLAGS) -woff 831,825,817,835,702,819,635,824,822,1167,1498,1110,1196,1174,803 -c -MDupdate Makedepend strokelex.c
+
+strokegen : strokegen.o strokelex.o
+	$(CC) -o $@ $(LDFLAGS) strokegen.o strokelex.o -ll
+
+capturexfont : capturexfont.o
+	$(CC) -o $@ $(LDFLAGS) capturexfont.o -lX11
+
+# glut_roman.c and glut_mroman.c are now checked in, but here are rules to generate them
+glut_roman.c.gen : Roman.stroke strokegen
+	./strokegen -s glutStrokeRoman < Roman.stroke > $@
+glut_mroman.c.gen : MonoRoman.stroke strokegen
+	./strokegen -s glutStrokeMonoRoman < MonoRoman.stroke > $@
+
+glutsrc.ps : $(SRCS)
+	$(RM) hardcopy
+	mkdir -p hardcopy
+	for i in $(SRCS) ;\
+	do \
+	  grep -v CENTRY $$i | grep -v INDENT- > hardcopy/$$i; \
+	done
+	cd hardcopy ; enscript -p ../$@ -G -2r `echo $(SRCS) | fmt -1 | sort`
+	$(RM) hardcopy
+
+# The bitmap files can be generated using capturexfont, but because
+# they require a connection to an X server and potentially different
+# X servers have different fonts, these generated files are part
+# of the GLUT distribution.
+
+9_BY_15 = -misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1
+8_BY_13 = -misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1
+TR10 = -adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1
+TR24 = -adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1
+HEL10 = -adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1
+HEL12 = -adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1
+HEL18 = -adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1
+
+semigens : capturexfont
+	./capturexfont $(9_BY_15) glutBitmap9By15 > glut_9x15.c.gen
+	./capturexfont $(8_BY_13) glutBitmap8By13 > glut_8x13.c.gen
+	./capturexfont $(TR10) glutBitmapTimesRoman10 > glut_tr10.c.gen
+	./capturexfont $(TR24) glutBitmapTimesRoman24 > glut_tr24.c.gen
+	./capturexfont $(HEL10) glutBitmapHelvetica10 > glut_hel10.c.gen
+	./capturexfont $(HEL12) glutBitmapHelvetica12 > glut_hel12.c.gen
+	./capturexfont $(HEL18) glutBitmapHelvetica18 > glut_hel18.c.gen
+
+# unused test rule for test building 16-bit font
+JIS = -jis-fixed-medium-r-normal--24-230-75-75-c-240-jisx0208.1983-0
+glut_jis.c : 
+	./capturexfont $(JIS) glutBitmapJis > $@
+
+sources: $(SRCS)
+
+symcheck: libglut.a
+	-nm -Bo libglut.a | grep -v ' d ' | grep -v ' T glut' | grep -v ' D glut' | grep -v ' U ' | grep -v ' T __glut' | grep -v ' t ' | grep -v ' b ' | grep -v ' D __glut' | grep -v ' B __glut'
+
+dstr.c: glut_dstr.c
+	ln -s glut_dstr.c $@
+
+dstr: dstr.c glut_util.o glut_glxext.o
+	$(RM) $@
+	$(CC) -g -o $@ $(CFLAGS) -DTEST dstr.c glut_util.o glut_glxext.o -lGLU -lGL -lXext -lX11 -lm
+
+./glut.h : glut.h
+./glutint.h : glutint.h
+./glutstroke.h : glutstroke.h
+./strokegen.h : strokegen.h
+./stroke.h : stroke.h
+./layerutil.h : layerutil.h
+strokelex.o: strokelex.c strokegen.h
+
+include $(COMMONRULES)
diff --git a/src/glut/glx/Makefile.win b/src/glut/glx/Makefile.win
new file mode 100644
index 0000000000..4d809f1190
--- /dev/null
+++ b/src/glut/glx/Makefile.win
@@ -0,0 +1,95 @@
+# Makefile for Win32

+

+!include <win32.mak>

+

+TOP = ../..

+

+# NOTE: glut_menu.c and glut_glxext.c are NOT compiled into Win32 GLUT

+

+SRCS = glut_8x13.c glut_9x15.c glut_bitmap.c glut_bwidth.c glut_cindex.c glut_cmap.c glut_cursor.c glut_dials.c glut_dstr.c glut_event.c glut_ext.c glut_fbc.c glut_fullscrn.c glut_gamemode.c glut_get.c glut_hel10.c glut_hel12.c glut_hel18.c glut_init.c glut_input.c glut_joy.c glut_key.c glut_keyctrl.c glut_keyup.c glut_mesa.c glut_modifier.c glut_mroman.c glut_overlay.c glut_roman.c glut_shapes.c glut_space.c glut_stroke.c glut_swap.c glut_swidth.c glut_tablet.c glut_teapot.c glut_tr10.c glut_tr24.c glut_util.c glut_vidresize.c glut_warp.c glut_win.c glut_winmisc.c win32_glx.c win32_menu.c win32_util.c win32_winproc.c win32_x11.c

+

+all	: glutdll install

+

+!include "$(TOP)/glutwin32.mak"

+

+glutdll	: $(GLUTDLL)

+

+!IFDEF NODEBUG

+OPTIMIZE_CFLAGS = -DNDEBUG

+!ENDIF

+

+CFLAGS = $(cvarsdll) $(CFLAGS) $(OPTIMIZE_CFLAGS)

+LFLAGS = $(dlllflags) $(LFLAGS)

+

+OBJS   = $(SRCS:.c=.obj)

+MS_LIBS   = $(MS_OPENGL) $(MS_GLU) winmm.lib $(guilibsdll)

+SGI_LIBS   = $(SGI_OPENGL) $(SGI_GLU) winmm.lib $(guilibsdll)

+

+glut32.dll : $(OBJS) glut.def

+	$(link) $(LFLAGS) -out:glut32.dll -def:glut.def $(OBJS) $(MS_LIBS)

+

+glut.dll : $(OBJS) glut.def

+	$(link) $(LFLAGS) -out:glut.dll -def:glut.def $(OBJS) $(SGI_LIBS)

+

+install	: $(GLUTDLL)

+	@echo "copying GLUT dynamic link library to system directory..."

+	-copy $(GLUTDLL) $(DLLINSTALL)

+	@echo "copying GLUT header file to include directory..."

+	-copy ..\..\include\GL\glut.h $(INCLUDEINSTALL)

+	@echo "copying GLUT import library to library directory..."

+	-copy $(GLUTLIB) $(LIBINSTALL)

+

+.c.obj	:

+	$(cc)   $(CFLAGS) -I . $*.c

+

+# explicit object dependencies for all source files

+

+win32_glx.obj: win32_glx.c win32_glx.h

+win32_x11.obj: win32_x11.c win32_x11.h

+win32_menu.obj: win32_menu.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h

+win32_util.obj: win32_util.c glutint.h ..\..\include\GL\glutf90.h

+win32_winproc.obj: win32_winproc.c glutint.h ..\..\include\GL\glutf90.h

+

+glut_mroman.obj: glut_mroman.c glutstroke.h glutint.h ..\..\include\GL\glutf90.h

+glut_roman.obj: glut_roman.c glutstroke.h glutint.h ..\..\include\GL\glutf90.h

+glut_hel12.obj: glut_hel12.c glutbitmap.h glutint.h ..\..\include\GL\glutf90.h

+glut_8x13.obj: glut_8x13.c glutbitmap.h glutint.h ..\..\include\GL\glutf90.h

+glut_hel18.obj: glut_hel18.c glutbitmap.h glutint.h ..\..\include\GL\glutf90.h

+glut_9x15.obj: glut_9x15.c glutbitmap.h glutint.h ..\..\include\GL\glutf90.h

+glut_tr10.obj: glut_tr10.c glutbitmap.h glutint.h ..\..\include\GL\glutf90.h

+glut_hel10.obj: glut_hel10.c glutbitmap.h glutint.h ..\..\include\GL\glutf90.h

+glut_tr24.obj: glut_tr24.c glutbitmap.h glutint.h ..\..\include\GL\glutf90.h

+

+glut_bitmap.obj: glut_bitmap.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_bwidth.obj: glut_bwidth.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_cindex.obj: glut_cindex.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_cmap.obj: glut_cmap.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_cursor.obj: glut_cursor.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_dials.obj: glut_dials.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_dstr.obj: glut_dstr.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_event.obj: glut_event.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_ext.obj: glut_ext.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_fullscrn.obj: glut_fullscrn.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_gamemode.obj: glut_gamemode.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_get.obj: glut_get.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_init.obj: glut_init.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_input.obj: glut_input.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_joy.obj: glut_joy.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_key.obj: glut_key.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_keyctrl.obj: glut_keyctrl.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_keyup.obj: glut_keyup.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_mesa.obj: glut_mesa.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_modifier.obj: glut_modifier.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_overlay.obj: glut_overlay.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_shapes.obj: glut_shapes.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_space.obj: glut_space.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_swap.obj: glut_swap.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_swidth.obj: glut_swidth.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_tablet.obj: glut_tablet.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_teapot.obj: glut_teapot.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_util.obj: glut_util.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_vidresize.obj: glut_vidresize.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_warp.obj: glut_warp.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+glut_win.obj: glut_win.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h

+glut_winmisc.obj: glut_winmisc.c glutint.h ..\..\include\GL\glutf90.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h

+

diff --git a/src/glut/glx/capturexfont.c b/src/glut/glx/capturexfont.c
new file mode 100644
index 0000000000..3bed13c9be
--- /dev/null
+++ b/src/glut/glx/capturexfont.c
@@ -0,0 +1,352 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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. */
+
+/* capturexfont.c connects to an X server and downloads a
+   bitmap font from which a C source file is generated,
+   encoding  the font for GLUT's use. Example usage:
+   capturexfont.c 9x15 glutBitmap9By15 > glut_9x15.c */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <GL/gl.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#define MAX_GLYPHS_PER_GRAB 512  /* This is big enough for 2^9
+                                    glyph character sets */
+
+static void
+outputChar(int num, int width, int height,
+  int xoff, int yoff, int advance, int data)
+{
+  if (width == 0 || height == 0) {
+    printf("#ifdef _WIN32\n");
+    printf("/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with\n");
+    printf("   a height or width of zero does not advance the raster position\n");
+    printf("   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */\n");
+    printf("static const GLubyte ch%ddata[] = { 0x0 };\n", num);
+    printf("static const BitmapCharRec ch%d = {", num);
+    printf("%d,", 0);
+    printf("%d,", 0);
+    printf("%d,", xoff);
+    printf("%d,", yoff);
+    printf("%d,", advance);
+    printf("ch%ddata", num);
+    printf("};\n");
+    printf("#else\n");
+  }
+  printf("static const BitmapCharRec ch%d = {", num);
+  printf("%d,", width);
+  printf("%d,", height);
+  printf("%d,", xoff);
+  printf("%d,", yoff);
+  printf("%d,", advance);
+  if (data) {
+    printf("ch%ddata", num);
+  } else {
+    printf("0");
+  }
+  printf("};\n");
+  if (width == 0 || height == 0) {
+    printf("#endif\n");
+  }
+  printf("\n");
+}
+
+/* Can't just use isprint because it only works for the range
+   of ASCII characters (ie, TRUE for isascii) and capturexfont
+   might be run on 16-bit fonts. */
+#define PRINTABLE(ch)  (isascii(ch) ? isprint(ch) : 0)
+
+void
+captureXFont(Display * dpy, Font font, char *xfont, char *name)
+{
+  int first, last, count;
+  int cnt, len;
+  Pixmap offscreen;
+  Window drawable;
+  XFontStruct *fontinfo;
+  XImage *image;
+  GC xgc;
+  XGCValues values;
+  int width, height;
+  int i, j, k;
+  XCharStruct *charinfo;
+  XChar2b character;
+  GLubyte *bitmapData;
+  int x, y;
+  int spanLength;
+  int charWidth, charHeight, maxSpanLength, pixwidth;
+  int grabList[MAX_GLYPHS_PER_GRAB];
+  int glyphsPerGrab = MAX_GLYPHS_PER_GRAB;
+  int numToGrab;
+  int rows, pages, byte1, byte2, index;
+  int nullBitmap;
+
+  drawable = RootWindow(dpy, DefaultScreen(dpy));
+
+  fontinfo = XQueryFont(dpy, font);
+  pages = fontinfo->max_char_or_byte2 - fontinfo->min_char_or_byte2 + 1;
+  first = (fontinfo->min_byte1 << 8) + fontinfo->min_char_or_byte2;
+  last = (fontinfo->max_byte1 << 8) + fontinfo->max_char_or_byte2;
+  count = last - first + 1;
+
+  width = fontinfo->max_bounds.rbearing -
+    fontinfo->min_bounds.lbearing;
+  height = fontinfo->max_bounds.ascent +
+    fontinfo->max_bounds.descent;
+  /* 16-bit fonts have more than one row; indexing into
+     per_char is trickier. */
+  rows = fontinfo->max_byte1 - fontinfo->min_byte1 + 1;
+
+  maxSpanLength = (width + 7) / 8;
+  /* For portability reasons we don't use alloca for
+     bitmapData, but we could. */
+  bitmapData = malloc(height * maxSpanLength);
+  /* Be careful determining the width of the pixmap; the X
+     protocol allows pixmaps of width 2^16-1 (unsigned short
+     size) but drawing coordinates max out at 2^15-1 (signed
+     short size).  If the width is too large, we need to limit
+     the glyphs per grab. */
+  if ((glyphsPerGrab * 8 * maxSpanLength) >= (1 << 15)) {
+    glyphsPerGrab = (1 << 15) / (8 * maxSpanLength);
+  }
+  pixwidth = glyphsPerGrab * 8 * maxSpanLength;
+  offscreen = XCreatePixmap(dpy, drawable, pixwidth, height, 1);
+
+  values.font = font;
+  values.background = 0;
+  values.foreground = 0;
+  xgc = XCreateGC(dpy, offscreen,
+    GCFont | GCBackground | GCForeground, &values);
+  XFillRectangle(dpy, offscreen, xgc, 0, 0,
+    8 * maxSpanLength * glyphsPerGrab, height);
+  XSetForeground(dpy, xgc, 1);
+
+  numToGrab = 0;
+  if (fontinfo->per_char == NULL) {
+    charinfo = &(fontinfo->min_bounds);
+    charWidth = charinfo->rbearing - charinfo->lbearing;
+    charHeight = charinfo->ascent + charinfo->descent;
+    spanLength = (charWidth + 7) / 8;
+  }
+  printf("\n/* GENERATED FILE -- DO NOT MODIFY */\n\n");
+  printf("#include \"glutbitmap.h\"\n\n");
+  for (i = first; count; i++, count--) {
+    int undefined;
+    if (rows == 1) {
+      undefined = (fontinfo->min_char_or_byte2 > i ||
+        fontinfo->max_char_or_byte2 < i);
+    } else {
+      byte2 = i & 0xff;
+      byte1 = i >> 8;
+      undefined = (fontinfo->min_char_or_byte2 > byte2 ||
+        fontinfo->max_char_or_byte2 < byte2 ||
+        fontinfo->min_byte1 > byte1 ||
+        fontinfo->max_byte1 < byte1);
+
+    }
+    if (undefined) {
+      goto PossiblyDoGrab;
+    }
+    if (fontinfo->per_char != NULL) {
+      if (rows == 1) {
+        index = i - fontinfo->min_char_or_byte2;
+      } else {
+        byte2 = i & 0xff;
+        byte1 = i >> 8;
+        index =
+          (byte1 - fontinfo->min_byte1) * pages +
+          (byte2 - fontinfo->min_char_or_byte2);
+      }
+      charinfo = &(fontinfo->per_char[index]);
+      charWidth = charinfo->rbearing - charinfo->lbearing;
+      charHeight = charinfo->ascent + charinfo->descent;
+      if (charWidth == 0 || charHeight == 0) {
+        if (charinfo->width != 0) {
+          /* Still must move raster pos even if empty character 
+
+           */
+          outputChar(i, 0, 0, 0, 0, charinfo->width, 0);
+        }
+        goto PossiblyDoGrab;
+      }
+    }
+    grabList[numToGrab] = i;
+    character.byte2 = i & 255;
+    character.byte1 = i >> 8;
+
+    /* XXX We could use XDrawImageString16 which would also
+       paint the backing rectangle but X server bugs in some
+       scalable font rasterizers makes it more effective to do
+       XFillRectangles to clear the pixmap and then
+       XDrawImage16 for the text.  */
+    XDrawString16(dpy, offscreen, xgc,
+      -charinfo->lbearing + 8 * maxSpanLength * numToGrab,
+      charinfo->ascent, &character, 1);
+
+    numToGrab++;
+
+  PossiblyDoGrab:
+
+    if (numToGrab >= glyphsPerGrab || count == 1) {
+      image = XGetImage(dpy, offscreen,
+        0, 0, pixwidth, height, 1, XYPixmap);
+      for (j = numToGrab - 1; j >= 0; j--) {
+        if (fontinfo->per_char != NULL) {
+          byte2 = grabList[j] & 0xff;
+          byte1 = grabList[j] >> 8;
+          index =
+            (byte1 - fontinfo->min_byte1) * pages +
+            (byte2 - fontinfo->min_char_or_byte2);
+          charinfo = &(fontinfo->per_char[index]);
+          charWidth = charinfo->rbearing - charinfo->lbearing;
+          charHeight = charinfo->ascent + charinfo->descent;
+          spanLength = (charWidth + 7) / 8;
+        }
+        memset(bitmapData, 0, height * spanLength);
+        for (y = 0; y < charHeight; y++) {
+          for (x = 0; x < charWidth; x++) {
+            if (XGetPixel(image, j * maxSpanLength * 8 + x,
+                charHeight - 1 - y)) {
+              /* Little endian machines (such as DEC Alpha)
+                 could  benefit from reversing the bit order
+                 here and changing the GL_UNPACK_LSB_FIRST
+                 parameter in glutBitmapCharacter to GL_TRUE. */
+              bitmapData[y * spanLength + x / 8] |=
+                (1 << (7 - (x & 7)));
+            }
+          }
+        }
+        if (PRINTABLE(grabList[j])) {
+          printf("/* char: 0x%x '%c' */\n\n",
+            grabList[j], grabList[j]);
+        } else {
+          printf("/* char: 0x%x */\n\n", grabList[j]);
+        }
+
+        /* Determine if the bitmap is null. */
+        nullBitmap = 1;
+        len = (charinfo->ascent + charinfo->descent) *
+          ((charinfo->rbearing - charinfo->lbearing + 7) / 8);
+        cnt = 0;
+        while (cnt < len) {
+          for (k = 0; k < 16 && cnt < len; k++, cnt++) {
+            if (bitmapData[cnt] != 0) {
+              nullBitmap = 0;
+            }
+          }
+        }
+
+        if (!nullBitmap) {
+          printf("static const GLubyte ch%ddata[] = {\n", grabList[j]);
+          len = (charinfo->ascent + charinfo->descent) *
+            ((charinfo->rbearing - charinfo->lbearing + 7) / 8);
+          cnt = 0;
+          while (cnt < len) {
+            for (k = 0; k < 16 && cnt < len; k++, cnt++) {
+              printf("0x%x,", bitmapData[cnt]);
+            }
+            printf("\n");
+          }
+          printf("};\n\n");
+        } else {
+          charWidth = 0;
+          charHeight = 0;
+        }
+
+        outputChar(grabList[j], charWidth, charHeight,
+          -charinfo->lbearing, charinfo->descent,
+          charinfo->width, !nullBitmap);
+      }
+      XDestroyImage(image);
+      numToGrab = 0;
+      if (count > 0) {
+        XSetForeground(dpy, xgc, 0);
+        XFillRectangle(dpy, offscreen, xgc, 0, 0,
+          8 * maxSpanLength * glyphsPerGrab, height);
+        XSetForeground(dpy, xgc, 1);
+      }
+    }
+  }
+  XFreeGC(dpy, xgc);
+  XFreePixmap(dpy, offscreen);
+  /* For portability reasons we don't use alloca for
+     bitmapData, but we could. */
+  free(bitmapData);
+
+  printf("static const BitmapCharRec * const chars[] = {\n");
+  for (i = first; i <= last; i++) {
+    int undefined;
+    byte2 = i & 0xff;
+    byte1 = i >> 8;
+    undefined = (fontinfo->min_char_or_byte2 > byte2 ||
+      fontinfo->max_char_or_byte2 < byte2 ||
+      fontinfo->min_byte1 > byte1 ||
+      fontinfo->max_byte1 < byte1);
+    if (undefined) {
+      printf("0,\n");
+    } else {
+      if (fontinfo->per_char != NULL) {
+        if (rows == 1) {
+          index = i - fontinfo->min_char_or_byte2;
+        } else {
+          byte2 = i & 0xff;
+          byte1 = i >> 8;
+          index =
+            (byte1 - fontinfo->min_byte1) * pages +
+            (byte2 - fontinfo->min_char_or_byte2);
+        }
+        charinfo = &(fontinfo->per_char[index]);
+        charWidth = charinfo->rbearing - charinfo->lbearing;
+        charHeight = charinfo->ascent + charinfo->descent;
+        if (charWidth == 0 || charHeight == 0) {
+          if (charinfo->width == 0) {
+            printf("0,\n");
+            continue;
+          }
+        }
+      }
+      printf("&ch%d,\n", i);
+    }
+  }
+  printf("};\n\n");
+  printf("const BitmapFontRec %s = {\n", name);
+  printf("\"%s\",\n", xfont);
+  printf("%d,\n", last - first + 1);
+  printf("%d,\n", first);
+  printf("chars\n");
+  printf("};\n\n");
+  XFreeFont(dpy, fontinfo);
+}
+
+int
+main(int argc, char **argv)
+{
+  Display *dpy;
+  Font font;
+
+  if (argc != 3) {
+    fprintf(stderr, "usage: capturexfont XFONT NAME\n");
+    exit(1);
+  }
+  dpy = XOpenDisplay(NULL);
+  if (dpy == NULL) {
+    fprintf(stderr, "capturexfont: could not open X display\n");
+    exit(1);
+  }
+  font = XLoadFont(dpy, argv[1]);
+  if (font == None) {
+    fprintf(stderr, "capturexfont: bad font\n");
+    exit(1);
+  }
+  captureXFont(dpy, font, argv[1], argv[2]);
+  XCloseDisplay(dpy);
+  return 0;
+}
diff --git a/src/glut/glx/descrip.mms b/src/glut/glx/descrip.mms
new file mode 100644
index 0000000000..d47b245507
--- /dev/null
+++ b/src/glut/glx/descrip.mms
@@ -0,0 +1,127 @@
+# Makefile for GLUT for VMS
+# contributed by Jouk Jansen  joukj@crys.chem.uva.nl
+
+.first
+	define gl [-.include.gl]
+
+.include [-]mms-config.
+
+##### MACROS #####
+GLUT_MAJOR = 3
+GLUT_MINOR = 7
+
+VPATH = RCS
+
+INCDIR = [-.include]
+LIBDIR = [-.lib]
+CFLAGS = /nowarn/include=$(INCDIR)/prefix=all
+
+SOURCES = \
+glut_8x13.c \
+glut_9x15.c \
+glut_bitmap.c \
+glut_bwidth.c \
+glut_cindex.c \
+glut_cmap.c \
+glut_cursor.c \
+glut_dials.c \
+glut_dstr.c \
+glut_event.c \
+glut_ext.c \
+glut_fullscrn.c \
+glut_gamemode.c \
+glut_get.c \
+glut_glxext.c \
+glut_hel10.c \
+glut_hel12.c \
+glut_hel18.c \
+glut_init.c \
+glut_input.c \
+glut_joy.c \
+glut_key.c \
+glut_keyctrl.c \
+glut_keyup.c \
+glut_menu.c \
+glut_menu2.c \
+glut_mesa.c \
+glut_modifier.c \
+glut_mroman.c \
+glut_overlay.c \
+glut_roman.c \
+glut_shapes.c \
+glut_space.c \
+glut_stroke.c \
+glut_swap.c \
+glut_swidth.c \
+glut_tablet.c \
+glut_teapot.c \
+glut_tr10.c \
+glut_tr24.c \
+glut_util.c \
+glut_vidresize.c \
+glut_warp.c \
+glut_win.c \
+glut_winmisc.c \
+layerutil.c
+
+OBJECTS = \
+glut_8x13.obj,\
+glut_9x15.obj,\
+glut_bitmap.obj,\
+glut_bwidth.obj,\
+glut_cindex.obj,\
+glut_cmap.obj,\
+glut_cursor.obj,\
+glut_dials.obj,\
+glut_dstr.obj,\
+glut_event.obj,\
+glut_ext.obj,\
+glut_fullscrn.obj,\
+glut_gamemode.obj,\
+glut_get.obj,\
+glut_glxext.obj,\
+glut_hel10.obj,\
+glut_hel12.obj,\
+glut_hel18.obj,\
+glut_init.obj,\
+glut_input.obj,\
+glut_joy.obj,\
+glut_key.obj,\
+glut_keyctrl.obj,\
+glut_keyup.obj,\
+glut_menu.obj,\
+glut_menu2.obj,\
+glut_mesa.obj,\
+glut_modifier.obj,\
+glut_mroman.obj,\
+glut_overlay.obj,\
+glut_roman.obj,\
+glut_shapes.obj,\
+glut_space.obj,\
+glut_stroke.obj,\
+glut_swap.obj,\
+glut_swidth.obj,\
+glut_tablet.obj,\
+glut_teapot.obj,\
+glut_tr10.obj,\
+glut_tr24.obj,\
+glut_util.obj,\
+glut_vidresize.obj,\
+glut_warp.obj,\
+glut_win.obj,\
+glut_winmisc.obj,\
+layerutil.obj
+
+##### RULES #####
+
+##### TARGETS #####
+
+# Make the library:
+$(LIBDIR)$(GLUT_LIB) : $(OBJECTS)
+	$(MAKELIB) $(GLUT_LIB) $(OBJECTS)
+	rename $(GLUT_LIB)* $(LIBDIR)
+clean :
+	delete *.obj;*
+	purge
+
+include mms_depend.
diff --git a/src/glut/glx/fxglut.def b/src/glut/glx/fxglut.def
new file mode 100644
index 0000000000..ff6ffb1d39
--- /dev/null
+++ b/src/glut/glx/fxglut.def
@@ -0,0 +1,103 @@
+EXPORTS

+	glutInit

+	glutInitDisplayMode

+	glutInitDisplayString

+	glutInitWindowPosition

+	glutInitWindowSize

+	glutMainLoop

+	glutCreateWindow

+	glutCreateSubWindow

+	glutDestroyWindow

+	glutPostRedisplay

+	glutSwapBuffers

+	glutGetWindow

+	glutSetWindow

+	glutSetWindowTitle

+	glutSetIconTitle

+	glutPositionWindow

+	glutReshapeWindow

+	glutPopWindow

+	glutPushWindow

+	glutIconifyWindow

+	glutShowWindow

+	glutHideWindow

+	glutFullScreen

+	glutSetCursor

+	glutWarpPointer

+	glutEstablishOverlay

+	glutRemoveOverlay

+	glutUseLayer

+	glutPostOverlayRedisplay

+	glutShowOverlay

+	glutHideOverlay

+	glutCreateMenu

+	glutDestroyMenu

+	glutGetMenu

+	glutSetMenu

+	glutAddMenuEntry

+	glutAddSubMenu

+	glutChangeToMenuEntry

+	glutChangeToSubMenu

+	glutRemoveMenuItem

+	glutAttachMenu

+	glutDetachMenu

+	glutDisplayFunc

+	glutReshapeFunc

+	glutKeyboardFunc

+	glutMouseFunc

+	glutMotionFunc

+	glutPassiveMotionFunc

+	glutEntryFunc

+	glutVisibilityFunc

+	glutIdleFunc

+	glutTimerFunc

+	glutMenuStateFunc

+	glutSpecialFunc

+	glutSpaceballMotionFunc

+	glutSpaceballRotateFunc

+	glutSpaceballButtonFunc

+	glutButtonBoxFunc

+	glutDialsFunc

+	glutTabletMotionFunc

+	glutTabletButtonFunc

+	glutMenuStatusFunc

+	glutOverlayDisplayFunc

+	glutWindowStatusFunc

+	glutSetColor

+	glutGetColor

+	glutCopyColormap

+	glutGet

+	glutDeviceGet

+	glutExtensionSupported

+	glutGetModifiers

+	glutLayerGet

+	glutBitmapCharacter

+	glutBitmapWidth

+	glutStrokeCharacter

+	glutStrokeWidth

+	glutBitmapLength

+	glutStrokeLength

+	glutWireSphere

+	glutSolidSphere

+	glutWireCone

+	glutSolidCone

+	glutWireCube

+	glutSolidCube

+	glutWireTorus

+	glutSolidTorus

+	glutWireDodecahedron

+	glutSolidDodecahedron

+	glutWireTeapot

+	glutSolidTeapot

+	glutWireOctahedron

+	glutSolidOctahedron

+	glutWireTetrahedron

+	glutSolidTetrahedron

+	glutWireIcosahedron

+	glutSolidIcosahedron

+	glutVideoResizeGet

+	glutSetupVideoResizing

+	glutStopVideoResizing

+	glutVideoResize

+	glutVideoPan

+	glutReportErrors

diff --git a/src/glut/glx/glut_8x13.c b/src/glut/glx/glut_8x13.c
new file mode 100644
index 0000000000..843c63d35a
--- /dev/null
+++ b/src/glut/glx/glut_8x13.c
@@ -0,0 +1,2073 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#define glutBitmap8By13 XXX
+#include "glutbitmap.h"
+#undef glutBitmap8By13
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch0data[] = { 0x0 };
+static const BitmapCharRec ch0 = {1,1,0,0,8,ch0data};
+#else
+static const BitmapCharRec ch0 = {0,0,0,0,8,0};
+#endif
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch32data[] = { 0x0 };
+static const BitmapCharRec ch32 = {1,1,0,0,8,ch32data};
+#else
+static const BitmapCharRec ch32 = {0,0,0,0,8,0};
+#endif
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch127data[] = { 0x0 };
+static const BitmapCharRec ch127 = {1,1,0,0,8,ch127data};
+#else
+static const BitmapCharRec ch127 = {0,0,0,0,8,0};
+#endif
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch160data[] = { 0x0 };
+static const BitmapCharRec ch160 = {1,1,0,0,8,ch160data};
+#else
+static const BitmapCharRec ch160 = {0,0,0,0,8,0};
+#endif
+
+/* char: 0xff */
+
+static const GLubyte ch255data[] = {
+0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x0,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch255 = {6,12,-1,2,8,ch255data};
+
+/* char: 0xfe */
+
+static const GLubyte ch254data[] = {
+0x80,0x80,0xb8,0xc4,0x84,0x84,0xc4,0xb8,0x80,0x80,
+};
+
+static const BitmapCharRec ch254 = {6,10,-1,2,8,ch254data};
+
+/* char: 0xfd */
+
+static const GLubyte ch253data[] = {
+0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x0,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch253 = {6,12,-1,2,8,ch253data};
+
+/* char: 0xfc */
+
+static const GLubyte ch252data[] = {
+0x74,0x88,0x88,0x88,0x88,0x88,0x0,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch252 = {6,10,-1,0,8,ch252data};
+
+/* char: 0xfb */
+
+static const GLubyte ch251data[] = {
+0x74,0x88,0x88,0x88,0x88,0x88,0x0,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch251 = {6,10,-1,0,8,ch251data};
+
+/* char: 0xfa */
+
+static const GLubyte ch250data[] = {
+0x74,0x88,0x88,0x88,0x88,0x88,0x0,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch250 = {6,10,-1,0,8,ch250data};
+
+/* char: 0xf9 */
+
+static const GLubyte ch249data[] = {
+0x74,0x88,0x88,0x88,0x88,0x88,0x0,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch249 = {6,10,-1,0,8,ch249data};
+
+/* char: 0xf8 */
+
+static const GLubyte ch248data[] = {
+0x80,0x78,0xc4,0xa4,0x94,0x8c,0x78,0x4,
+};
+
+static const BitmapCharRec ch248 = {6,8,-1,1,8,ch248data};
+
+/* char: 0xf7 */
+
+static const GLubyte ch247data[] = {
+0x20,0x20,0x0,0xf8,0x0,0x20,0x20,
+};
+
+static const BitmapCharRec ch247 = {5,7,-1,-1,8,ch247data};
+
+/* char: 0xf6 */
+
+static const GLubyte ch246data[] = {
+0x78,0x84,0x84,0x84,0x84,0x78,0x0,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch246 = {6,10,-1,0,8,ch246data};
+
+/* char: 0xf5 */
+
+static const GLubyte ch245data[] = {
+0x78,0x84,0x84,0x84,0x84,0x78,0x0,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch245 = {6,10,-1,0,8,ch245data};
+
+/* char: 0xf4 */
+
+static const GLubyte ch244data[] = {
+0x78,0x84,0x84,0x84,0x84,0x78,0x0,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch244 = {6,10,-1,0,8,ch244data};
+
+/* char: 0xf3 */
+
+static const GLubyte ch243data[] = {
+0x78,0x84,0x84,0x84,0x84,0x78,0x0,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch243 = {6,10,-1,0,8,ch243data};
+
+/* char: 0xf2 */
+
+static const GLubyte ch242data[] = {
+0x78,0x84,0x84,0x84,0x84,0x78,0x0,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch242 = {6,10,-1,0,8,ch242data};
+
+/* char: 0xf1 */
+
+static const GLubyte ch241data[] = {
+0x84,0x84,0x84,0x84,0xc4,0xb8,0x0,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch241 = {6,10,-1,0,8,ch241data};
+
+/* char: 0xf0 */
+
+static const GLubyte ch240data[] = {
+0x78,0x84,0x84,0x84,0x84,0x78,0x8,0x50,0x30,0x48,
+};
+
+static const BitmapCharRec ch240 = {6,10,-1,0,8,ch240data};
+
+/* char: 0xef */
+
+static const GLubyte ch239data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x60,0x0,0x0,0x50,0x50,
+};
+
+static const BitmapCharRec ch239 = {5,10,-1,0,8,ch239data};
+
+/* char: 0xee */
+
+static const GLubyte ch238data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x60,0x0,0x0,0x90,0x60,
+};
+
+static const BitmapCharRec ch238 = {5,10,-1,0,8,ch238data};
+
+/* char: 0xed */
+
+static const GLubyte ch237data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x60,0x0,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch237 = {5,10,-1,0,8,ch237data};
+
+/* char: 0xec */
+
+static const GLubyte ch236data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x60,0x0,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch236 = {5,10,-1,0,8,ch236data};
+
+/* char: 0xeb */
+
+static const GLubyte ch235data[] = {
+0x78,0x84,0x80,0xfc,0x84,0x78,0x0,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch235 = {6,10,-1,0,8,ch235data};
+
+/* char: 0xea */
+
+static const GLubyte ch234data[] = {
+0x78,0x84,0x80,0xfc,0x84,0x78,0x0,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch234 = {6,10,-1,0,8,ch234data};
+
+/* char: 0xe9 */
+
+static const GLubyte ch233data[] = {
+0x78,0x84,0x80,0xfc,0x84,0x78,0x0,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch233 = {6,10,-1,0,8,ch233data};
+
+/* char: 0xe8 */
+
+static const GLubyte ch232data[] = {
+0x78,0x84,0x80,0xfc,0x84,0x78,0x0,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch232 = {6,10,-1,0,8,ch232data};
+
+/* char: 0xe7 */
+
+static const GLubyte ch231data[] = {
+0x20,0x10,0x78,0x84,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch231 = {6,8,-1,2,8,ch231data};
+
+/* char: 0xe6 */
+
+static const GLubyte ch230data[] = {
+0x6c,0x92,0x90,0x7c,0x12,0x6c,
+};
+
+static const BitmapCharRec ch230 = {7,6,0,0,8,ch230data};
+
+/* char: 0xe5 */
+
+static const GLubyte ch229data[] = {
+0x74,0x8c,0x84,0x7c,0x4,0x78,0x0,0x30,0x48,0x30,
+};
+
+static const BitmapCharRec ch229 = {6,10,-1,0,8,ch229data};
+
+/* char: 0xe4 */
+
+static const GLubyte ch228data[] = {
+0x74,0x8c,0x84,0x7c,0x4,0x78,0x0,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch228 = {6,10,-1,0,8,ch228data};
+
+/* char: 0xe3 */
+
+static const GLubyte ch227data[] = {
+0x74,0x8c,0x84,0x7c,0x4,0x78,0x0,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch227 = {6,10,-1,0,8,ch227data};
+
+/* char: 0xe2 */
+
+static const GLubyte ch226data[] = {
+0x74,0x8c,0x84,0x7c,0x4,0x78,0x0,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch226 = {6,10,-1,0,8,ch226data};
+
+/* char: 0xe1 */
+
+static const GLubyte ch225data[] = {
+0x74,0x8c,0x84,0x7c,0x4,0x78,0x0,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch225 = {6,10,-1,0,8,ch225data};
+
+/* char: 0xe0 */
+
+static const GLubyte ch224data[] = {
+0x74,0x8c,0x84,0x7c,0x4,0x78,0x0,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch224 = {6,10,-1,0,8,ch224data};
+
+/* char: 0xdf */
+
+static const GLubyte ch223data[] = {
+0x80,0xb8,0xc4,0x84,0x84,0xf8,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch223 = {6,9,-1,1,8,ch223data};
+
+/* char: 0xde */
+
+static const GLubyte ch222data[] = {
+0x80,0x80,0x80,0xf8,0x84,0x84,0x84,0xf8,0x80,
+};
+
+static const BitmapCharRec ch222 = {6,9,-1,0,8,ch222data};
+
+/* char: 0xdd */
+
+static const GLubyte ch221data[] = {
+0x20,0x20,0x20,0x20,0x50,0x88,0x88,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch221 = {5,10,-1,0,8,ch221data};
+
+/* char: 0xdc */
+
+static const GLubyte ch220data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch220 = {6,10,-1,0,8,ch220data};
+
+/* char: 0xdb */
+
+static const GLubyte ch219data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch219 = {6,10,-1,0,8,ch219data};
+
+/* char: 0xda */
+
+static const GLubyte ch218data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch218 = {6,10,-1,0,8,ch218data};
+
+/* char: 0xd9 */
+
+static const GLubyte ch217data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch217 = {6,10,-1,0,8,ch217data};
+
+/* char: 0xd8 */
+
+static const GLubyte ch216data[] = {
+0x80,0x78,0xc4,0xa4,0xa4,0xa4,0x94,0x94,0x8c,0x78,0x4,
+};
+
+static const BitmapCharRec ch216 = {6,11,-1,1,8,ch216data};
+
+/* char: 0xd7 */
+
+static const GLubyte ch215data[] = {
+0x84,0x48,0x30,0x30,0x48,0x84,
+};
+
+static const BitmapCharRec ch215 = {6,6,-1,-1,8,ch215data};
+
+/* char: 0xd6 */
+
+static const GLubyte ch214data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch214 = {7,10,0,0,8,ch214data};
+
+/* char: 0xd5 */
+
+static const GLubyte ch213data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x28,0x14,
+};
+
+static const BitmapCharRec ch213 = {7,10,0,0,8,ch213data};
+
+/* char: 0xd4 */
+
+static const GLubyte ch212data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x24,0x18,
+};
+
+static const BitmapCharRec ch212 = {7,10,0,0,8,ch212data};
+
+/* char: 0xd3 */
+
+static const GLubyte ch211data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch211 = {7,10,0,0,8,ch211data};
+
+/* char: 0xd2 */
+
+static const GLubyte ch210data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x8,0x10,
+};
+
+static const BitmapCharRec ch210 = {7,10,0,0,8,ch210data};
+
+/* char: 0xd1 */
+
+static const GLubyte ch209data[] = {
+0x82,0x86,0x8a,0x92,0xa2,0xc2,0x82,0x0,0x28,0x14,
+};
+
+static const BitmapCharRec ch209 = {7,10,0,0,8,ch209data};
+
+/* char: 0xd0 */
+
+static const GLubyte ch208data[] = {
+0xfc,0x42,0x42,0x42,0xe2,0x42,0x42,0x42,0xfc,
+};
+
+static const BitmapCharRec ch208 = {7,9,0,0,8,ch208data};
+
+/* char: 0xcf */
+
+static const GLubyte ch207data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x50,0x50,
+};
+
+static const BitmapCharRec ch207 = {5,10,-1,0,8,ch207data};
+
+/* char: 0xce */
+
+static const GLubyte ch206data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch206 = {5,10,-1,0,8,ch206data};
+
+/* char: 0xcd */
+
+static const GLubyte ch205data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch205 = {5,10,-1,0,8,ch205data};
+
+/* char: 0xcc */
+
+static const GLubyte ch204data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch204 = {5,10,-1,0,8,ch204data};
+
+/* char: 0xcb */
+
+static const GLubyte ch203data[] = {
+0xfc,0x80,0x80,0xf0,0x80,0x80,0xfc,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch203 = {6,10,-1,0,8,ch203data};
+
+/* char: 0xca */
+
+static const GLubyte ch202data[] = {
+0xfc,0x80,0x80,0xf0,0x80,0x80,0xfc,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch202 = {6,10,-1,0,8,ch202data};
+
+/* char: 0xc9 */
+
+static const GLubyte ch201data[] = {
+0xfc,0x80,0x80,0xf0,0x80,0x80,0xfc,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch201 = {6,10,-1,0,8,ch201data};
+
+/* char: 0xc8 */
+
+static const GLubyte ch200data[] = {
+0xfc,0x80,0x80,0xf0,0x80,0x80,0xfc,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch200 = {6,10,-1,0,8,ch200data};
+
+/* char: 0xc7 */
+
+static const GLubyte ch199data[] = {
+0x20,0x10,0x78,0x84,0x80,0x80,0x80,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch199 = {6,11,-1,2,8,ch199data};
+
+/* char: 0xc6 */
+
+static const GLubyte ch198data[] = {
+0x9e,0x90,0x90,0xf0,0x9c,0x90,0x90,0x90,0x6e,
+};
+
+static const BitmapCharRec ch198 = {7,9,0,0,8,ch198data};
+
+/* char: 0xc5 */
+
+static const GLubyte ch197data[] = {
+0x84,0x84,0xfc,0x84,0x84,0x48,0x30,0x30,0x48,0x30,
+};
+
+static const BitmapCharRec ch197 = {6,10,-1,0,8,ch197data};
+
+/* char: 0xc4 */
+
+static const GLubyte ch196data[] = {
+0x84,0x84,0xfc,0x84,0x84,0x48,0x30,0x0,0x48,0x48,
+};
+
+static const BitmapCharRec ch196 = {6,10,-1,0,8,ch196data};
+
+/* char: 0xc3 */
+
+static const GLubyte ch195data[] = {
+0x84,0x84,0xfc,0x84,0x84,0x48,0x30,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch195 = {6,10,-1,0,8,ch195data};
+
+/* char: 0xc2 */
+
+static const GLubyte ch194data[] = {
+0x84,0x84,0xfc,0x84,0x84,0x48,0x30,0x0,0x48,0x30,
+};
+
+static const BitmapCharRec ch194 = {6,10,-1,0,8,ch194data};
+
+/* char: 0xc1 */
+
+static const GLubyte ch193data[] = {
+0x84,0x84,0xfc,0x84,0x84,0x48,0x30,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch193 = {6,10,-1,0,8,ch193data};
+
+/* char: 0xc0 */
+
+static const GLubyte ch192data[] = {
+0x84,0x84,0xfc,0x84,0x84,0x48,0x30,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch192 = {6,10,-1,0,8,ch192data};
+
+/* char: 0xbf */
+
+static const GLubyte ch191data[] = {
+0x78,0x84,0x84,0x80,0x40,0x20,0x20,0x0,0x20,
+};
+
+static const BitmapCharRec ch191 = {6,9,-1,0,8,ch191data};
+
+/* char: 0xbe */
+
+static const GLubyte ch190data[] = {
+0x6,0x1a,0x12,0xa,0x66,0x92,0x10,0x20,0x90,0x60,
+};
+
+static const BitmapCharRec ch190 = {7,10,0,0,8,ch190data};
+
+/* char: 0xbd */
+
+static const GLubyte ch189data[] = {
+0x1e,0x10,0xc,0x2,0xf2,0x4c,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch189 = {7,10,0,0,8,ch189data};
+
+/* char: 0xbc */
+
+static const GLubyte ch188data[] = {
+0x6,0x1a,0x12,0xa,0xe6,0x42,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch188 = {7,10,0,0,8,ch188data};
+
+/* char: 0xbb */
+
+static const GLubyte ch187data[] = {
+0x90,0x48,0x24,0x12,0x24,0x48,0x90,
+};
+
+static const BitmapCharRec ch187 = {7,7,0,-1,8,ch187data};
+
+/* char: 0xba */
+
+static const GLubyte ch186data[] = {
+0xf0,0x0,0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch186 = {4,6,-1,-3,8,ch186data};
+
+/* char: 0xb9 */
+
+static const GLubyte ch185data[] = {
+0xe0,0x40,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch185 = {3,6,-1,-4,8,ch185data};
+
+/* char: 0xb8 */
+
+static const GLubyte ch184data[] = {
+0xc0,0x40,
+};
+
+static const BitmapCharRec ch184 = {2,2,-3,2,8,ch184data};
+
+/* char: 0xb7 */
+
+static const GLubyte ch183data[] = {
+0xc0,
+};
+
+static const BitmapCharRec ch183 = {2,1,-3,-4,8,ch183data};
+
+/* char: 0xb6 */
+
+static const GLubyte ch182data[] = {
+0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c,
+};
+
+static const BitmapCharRec ch182 = {6,9,-1,0,8,ch182data};
+
+/* char: 0xb5 */
+
+static const GLubyte ch181data[] = {
+0x80,0xb4,0xcc,0x84,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch181 = {6,7,-1,1,8,ch181data};
+
+/* char: 0xb4 */
+
+static const GLubyte ch180data[] = {
+0x80,0x40,
+};
+
+static const BitmapCharRec ch180 = {2,2,-3,-8,8,ch180data};
+
+/* char: 0xb3 */
+
+static const GLubyte ch179data[] = {
+0x60,0x90,0x10,0x20,0x90,0x60,
+};
+
+static const BitmapCharRec ch179 = {4,6,-1,-4,8,ch179data};
+
+/* char: 0xb2 */
+
+static const GLubyte ch178data[] = {
+0xf0,0x80,0x60,0x10,0x90,0x60,
+};
+
+static const BitmapCharRec ch178 = {4,6,-1,-4,8,ch178data};
+
+/* char: 0xb1 */
+
+static const GLubyte ch177data[] = {
+0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch177 = {5,7,-1,-1,8,ch177data};
+
+/* char: 0xb0 */
+
+static const GLubyte ch176data[] = {
+0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch176 = {4,4,-2,-5,8,ch176data};
+
+/* char: 0xaf */
+
+static const GLubyte ch175data[] = {
+0xfc,
+};
+
+static const BitmapCharRec ch175 = {6,1,-1,-8,8,ch175data};
+
+/* char: 0xae */
+
+static const GLubyte ch174data[] = {
+0x38,0x44,0xaa,0xb2,0xaa,0xaa,0x92,0x44,0x38,
+};
+
+static const BitmapCharRec ch174 = {7,9,0,-1,8,ch174data};
+
+/* char: 0xad */
+
+static const GLubyte ch173data[] = {
+0xfc,
+};
+
+static const BitmapCharRec ch173 = {6,1,-1,-4,8,ch173data};
+
+/* char: 0xac */
+
+static const GLubyte ch172data[] = {
+0x4,0x4,0x4,0xfc,
+};
+
+static const BitmapCharRec ch172 = {6,4,-1,-1,8,ch172data};
+
+/* char: 0xab */
+
+static const GLubyte ch171data[] = {
+0x12,0x24,0x48,0x90,0x48,0x24,0x12,
+};
+
+static const BitmapCharRec ch171 = {7,7,0,-1,8,ch171data};
+
+/* char: 0xaa */
+
+static const GLubyte ch170data[] = {
+0xf8,0x0,0x78,0x88,0x78,0x8,0x70,
+};
+
+static const BitmapCharRec ch170 = {5,7,-1,-2,8,ch170data};
+
+/* char: 0xa9 */
+
+static const GLubyte ch169data[] = {
+0x38,0x44,0x92,0xaa,0xa2,0xaa,0x92,0x44,0x38,
+};
+
+static const BitmapCharRec ch169 = {7,9,0,-1,8,ch169data};
+
+/* char: 0xa8 */
+
+static const GLubyte ch168data[] = {
+0xd8,
+};
+
+static const BitmapCharRec ch168 = {5,1,-1,-8,8,ch168data};
+
+/* char: 0xa7 */
+
+static const GLubyte ch167data[] = {
+0x60,0x90,0x10,0x60,0x90,0x90,0x60,0x80,0x90,0x60,
+};
+
+static const BitmapCharRec ch167 = {4,10,-2,0,8,ch167data};
+
+/* char: 0xa6 */
+
+static const GLubyte ch166data[] = {
+0x80,0x80,0x80,0x80,0x0,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch166 = {1,9,-3,0,8,ch166data};
+
+/* char: 0xa5 */
+
+static const GLubyte ch165data[] = {
+0x10,0x10,0x7c,0x10,0x7c,0x28,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch165 = {7,9,0,0,8,ch165data};
+
+/* char: 0xa4 */
+
+static const GLubyte ch164data[] = {
+0x84,0x78,0x48,0x48,0x78,0x84,
+};
+
+static const BitmapCharRec ch164 = {6,6,-1,-1,8,ch164data};
+
+/* char: 0xa3 */
+
+static const GLubyte ch163data[] = {
+0xdc,0x62,0x20,0x20,0x20,0x70,0x20,0x22,0x1c,
+};
+
+static const BitmapCharRec ch163 = {7,9,0,0,8,ch163data};
+
+/* char: 0xa2 */
+
+static const GLubyte ch162data[] = {
+0x20,0x70,0xa8,0xa0,0xa0,0xa8,0x70,0x20,
+};
+
+static const BitmapCharRec ch162 = {5,8,-1,-1,8,ch162data};
+
+/* char: 0xa1 */
+
+static const GLubyte ch161data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
+};
+
+static const BitmapCharRec ch161 = {1,9,-3,0,8,ch161data};
+
+/* char: 0x7e '~' */
+
+static const GLubyte ch126data[] = {
+0x90,0xa8,0x48,
+};
+
+static const BitmapCharRec ch126 = {5,3,-1,-6,8,ch126data};
+
+/* char: 0x7d '}' */
+
+static const GLubyte ch125data[] = {
+0xe0,0x10,0x10,0x20,0x18,0x20,0x10,0x10,0xe0,
+};
+
+static const BitmapCharRec ch125 = {5,9,-1,0,8,ch125data};
+
+/* char: 0x7c '|' */
+
+static const GLubyte ch124data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch124 = {1,9,-3,0,8,ch124data};
+
+/* char: 0x7b '{' */
+
+static const GLubyte ch123data[] = {
+0x38,0x40,0x40,0x20,0xc0,0x20,0x40,0x40,0x38,
+};
+
+static const BitmapCharRec ch123 = {5,9,-2,0,8,ch123data};
+
+/* char: 0x7a 'z' */
+
+static const GLubyte ch122data[] = {
+0xfc,0x40,0x20,0x10,0x8,0xfc,
+};
+
+static const BitmapCharRec ch122 = {6,6,-1,0,8,ch122data};
+
+/* char: 0x79 'y' */
+
+static const GLubyte ch121data[] = {
+0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch121 = {6,8,-1,2,8,ch121data};
+
+/* char: 0x78 'x' */
+
+static const GLubyte ch120data[] = {
+0x84,0x48,0x30,0x30,0x48,0x84,
+};
+
+static const BitmapCharRec ch120 = {6,6,-1,0,8,ch120data};
+
+/* char: 0x77 'w' */
+
+static const GLubyte ch119data[] = {
+0x44,0xaa,0x92,0x92,0x82,0x82,
+};
+
+static const BitmapCharRec ch119 = {7,6,0,0,8,ch119data};
+
+/* char: 0x76 'v' */
+
+static const GLubyte ch118data[] = {
+0x20,0x50,0x50,0x88,0x88,0x88,
+};
+
+static const BitmapCharRec ch118 = {5,6,-1,0,8,ch118data};
+
+/* char: 0x75 'u' */
+
+static const GLubyte ch117data[] = {
+0x74,0x88,0x88,0x88,0x88,0x88,
+};
+
+static const BitmapCharRec ch117 = {6,6,-1,0,8,ch117data};
+
+/* char: 0x74 't' */
+
+static const GLubyte ch116data[] = {
+0x38,0x44,0x40,0x40,0x40,0xf8,0x40,0x40,
+};
+
+static const BitmapCharRec ch116 = {6,8,-1,0,8,ch116data};
+
+/* char: 0x73 's' */
+
+static const GLubyte ch115data[] = {
+0x78,0x84,0x18,0x60,0x84,0x78,
+};
+
+static const BitmapCharRec ch115 = {6,6,-1,0,8,ch115data};
+
+/* char: 0x72 'r' */
+
+static const GLubyte ch114data[] = {
+0x40,0x40,0x40,0x40,0x44,0xb8,
+};
+
+static const BitmapCharRec ch114 = {6,6,-1,0,8,ch114data};
+
+/* char: 0x71 'q' */
+
+static const GLubyte ch113data[] = {
+0x4,0x4,0x4,0x74,0x8c,0x84,0x8c,0x74,
+};
+
+static const BitmapCharRec ch113 = {6,8,-1,2,8,ch113data};
+
+/* char: 0x70 'p' */
+
+static const GLubyte ch112data[] = {
+0x80,0x80,0x80,0xb8,0xc4,0x84,0xc4,0xb8,
+};
+
+static const BitmapCharRec ch112 = {6,8,-1,2,8,ch112data};
+
+/* char: 0x6f 'o' */
+
+static const GLubyte ch111data[] = {
+0x78,0x84,0x84,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch111 = {6,6,-1,0,8,ch111data};
+
+/* char: 0x6e 'n' */
+
+static const GLubyte ch110data[] = {
+0x84,0x84,0x84,0x84,0xc4,0xb8,
+};
+
+static const BitmapCharRec ch110 = {6,6,-1,0,8,ch110data};
+
+/* char: 0x6d 'm' */
+
+static const GLubyte ch109data[] = {
+0x82,0x92,0x92,0x92,0x92,0xec,
+};
+
+static const BitmapCharRec ch109 = {7,6,0,0,8,ch109data};
+
+/* char: 0x6c 'l' */
+
+static const GLubyte ch108data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x60,
+};
+
+static const BitmapCharRec ch108 = {5,9,-1,0,8,ch108data};
+
+/* char: 0x6b 'k' */
+
+static const GLubyte ch107data[] = {
+0x84,0x88,0x90,0xe0,0x90,0x88,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch107 = {6,9,-1,0,8,ch107data};
+
+/* char: 0x6a 'j' */
+
+static const GLubyte ch106data[] = {
+0x70,0x88,0x88,0x8,0x8,0x8,0x8,0x18,0x0,0x8,
+};
+
+static const BitmapCharRec ch106 = {5,10,-1,2,8,ch106data};
+
+/* char: 0x69 'i' */
+
+static const GLubyte ch105data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x60,0x0,0x20,
+};
+
+static const BitmapCharRec ch105 = {5,8,-1,0,8,ch105data};
+
+/* char: 0x68 'h' */
+
+static const GLubyte ch104data[] = {
+0x84,0x84,0x84,0x84,0xc4,0xb8,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch104 = {6,9,-1,0,8,ch104data};
+
+/* char: 0x67 'g' */
+
+static const GLubyte ch103data[] = {
+0x78,0x84,0x78,0x80,0x70,0x88,0x88,0x74,
+};
+
+static const BitmapCharRec ch103 = {6,8,-1,2,8,ch103data};
+
+/* char: 0x66 'f' */
+
+static const GLubyte ch102data[] = {
+0x40,0x40,0x40,0x40,0xf8,0x40,0x40,0x44,0x38,
+};
+
+static const BitmapCharRec ch102 = {6,9,-1,0,8,ch102data};
+
+/* char: 0x65 'e' */
+
+static const GLubyte ch101data[] = {
+0x78,0x84,0x80,0xfc,0x84,0x78,
+};
+
+static const BitmapCharRec ch101 = {6,6,-1,0,8,ch101data};
+
+/* char: 0x64 'd' */
+
+static const GLubyte ch100data[] = {
+0x74,0x8c,0x84,0x84,0x8c,0x74,0x4,0x4,0x4,
+};
+
+static const BitmapCharRec ch100 = {6,9,-1,0,8,ch100data};
+
+/* char: 0x63 'c' */
+
+static const GLubyte ch99data[] = {
+0x78,0x84,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch99 = {6,6,-1,0,8,ch99data};
+
+/* char: 0x62 'b' */
+
+static const GLubyte ch98data[] = {
+0xb8,0xc4,0x84,0x84,0xc4,0xb8,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch98 = {6,9,-1,0,8,ch98data};
+
+/* char: 0x61 'a' */
+
+static const GLubyte ch97data[] = {
+0x74,0x8c,0x84,0x7c,0x4,0x78,
+};
+
+static const BitmapCharRec ch97 = {6,6,-1,0,8,ch97data};
+
+/* char: 0x60 '`' */
+
+static const GLubyte ch96data[] = {
+0x10,0x60,0xe0,
+};
+
+static const BitmapCharRec ch96 = {4,3,-2,-6,8,ch96data};
+
+/* char: 0x5f '_' */
+
+static const GLubyte ch95data[] = {
+0xfe,
+};
+
+static const BitmapCharRec ch95 = {7,1,0,1,8,ch95data};
+
+/* char: 0x5e '^' */
+
+static const GLubyte ch94data[] = {
+0x88,0x50,0x20,
+};
+
+static const BitmapCharRec ch94 = {5,3,-1,-6,8,ch94data};
+
+/* char: 0x5d ']' */
+
+static const GLubyte ch93data[] = {
+0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xf0,
+};
+
+static const BitmapCharRec ch93 = {4,9,-1,0,8,ch93data};
+
+/* char: 0x5c '\' */
+
+static const GLubyte ch92data[] = {
+0x2,0x2,0x4,0x8,0x10,0x20,0x40,0x80,0x80,
+};
+
+static const BitmapCharRec ch92 = {7,9,0,0,8,ch92data};
+
+/* char: 0x5b '[' */
+
+static const GLubyte ch91data[] = {
+0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xf0,
+};
+
+static const BitmapCharRec ch91 = {4,9,-2,0,8,ch91data};
+
+/* char: 0x5a 'Z' */
+
+static const GLubyte ch90data[] = {
+0xfc,0x80,0x80,0x40,0x20,0x10,0x8,0x4,0xfc,
+};
+
+static const BitmapCharRec ch90 = {6,9,-1,0,8,ch90data};
+
+/* char: 0x59 'Y' */
+
+static const GLubyte ch89data[] = {
+0x10,0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch89 = {7,9,0,0,8,ch89data};
+
+/* char: 0x58 'X' */
+
+static const GLubyte ch88data[] = {
+0x82,0x82,0x44,0x28,0x10,0x28,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch88 = {7,9,0,0,8,ch88data};
+
+/* char: 0x57 'W' */
+
+static const GLubyte ch87data[] = {
+0x44,0xaa,0x92,0x92,0x92,0x82,0x82,0x82,0x82,
+};
+
+static const BitmapCharRec ch87 = {7,9,0,0,8,ch87data};
+
+/* char: 0x56 'V' */
+
+static const GLubyte ch86data[] = {
+0x10,0x28,0x28,0x28,0x44,0x44,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch86 = {7,9,0,0,8,ch86data};
+
+/* char: 0x55 'U' */
+
+static const GLubyte ch85data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch85 = {6,9,-1,0,8,ch85data};
+
+/* char: 0x54 'T' */
+
+static const GLubyte ch84data[] = {
+0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xfe,
+};
+
+static const BitmapCharRec ch84 = {7,9,0,0,8,ch84data};
+
+/* char: 0x53 'S' */
+
+static const GLubyte ch83data[] = {
+0x78,0x84,0x4,0x4,0x78,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch83 = {6,9,-1,0,8,ch83data};
+
+/* char: 0x52 'R' */
+
+static const GLubyte ch82data[] = {
+0x84,0x88,0x90,0xa0,0xf8,0x84,0x84,0x84,0xf8,
+};
+
+static const BitmapCharRec ch82 = {6,9,-1,0,8,ch82data};
+
+/* char: 0x51 'Q' */
+
+static const GLubyte ch81data[] = {
+0x4,0x78,0x94,0xa4,0x84,0x84,0x84,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch81 = {6,10,-1,1,8,ch81data};
+
+/* char: 0x50 'P' */
+
+static const GLubyte ch80data[] = {
+0x80,0x80,0x80,0x80,0xf8,0x84,0x84,0x84,0xf8,
+};
+
+static const BitmapCharRec ch80 = {6,9,-1,0,8,ch80data};
+
+/* char: 0x4f 'O' */
+
+static const GLubyte ch79data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch79 = {6,9,-1,0,8,ch79data};
+
+/* char: 0x4e 'N' */
+
+static const GLubyte ch78data[] = {
+0x84,0x84,0x84,0x8c,0x94,0xa4,0xc4,0x84,0x84,
+};
+
+static const BitmapCharRec ch78 = {6,9,-1,0,8,ch78data};
+
+/* char: 0x4d 'M' */
+
+static const GLubyte ch77data[] = {
+0x82,0x82,0x82,0x92,0x92,0xaa,0xc6,0x82,0x82,
+};
+
+static const BitmapCharRec ch77 = {7,9,0,0,8,ch77data};
+
+/* char: 0x4c 'L' */
+
+static const GLubyte ch76data[] = {
+0xfc,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch76 = {6,9,-1,0,8,ch76data};
+
+/* char: 0x4b 'K' */
+
+static const GLubyte ch75data[] = {
+0x84,0x88,0x90,0xa0,0xc0,0xa0,0x90,0x88,0x84,
+};
+
+static const BitmapCharRec ch75 = {6,9,-1,0,8,ch75data};
+
+/* char: 0x4a 'J' */
+
+static const GLubyte ch74data[] = {
+0x70,0x88,0x8,0x8,0x8,0x8,0x8,0x8,0x3c,
+};
+
+static const BitmapCharRec ch74 = {6,9,-1,0,8,ch74data};
+
+/* char: 0x49 'I' */
+
+static const GLubyte ch73data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,
+};
+
+static const BitmapCharRec ch73 = {5,9,-1,0,8,ch73data};
+
+/* char: 0x48 'H' */
+
+static const GLubyte ch72data[] = {
+0x84,0x84,0x84,0x84,0xfc,0x84,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch72 = {6,9,-1,0,8,ch72data};
+
+/* char: 0x47 'G' */
+
+static const GLubyte ch71data[] = {
+0x74,0x8c,0x84,0x9c,0x80,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch71 = {6,9,-1,0,8,ch71data};
+
+/* char: 0x46 'F' */
+
+static const GLubyte ch70data[] = {
+0x80,0x80,0x80,0x80,0xf0,0x80,0x80,0x80,0xfc,
+};
+
+static const BitmapCharRec ch70 = {6,9,-1,0,8,ch70data};
+
+/* char: 0x45 'E' */
+
+static const GLubyte ch69data[] = {
+0xfc,0x80,0x80,0x80,0xf0,0x80,0x80,0x80,0xfc,
+};
+
+static const BitmapCharRec ch69 = {6,9,-1,0,8,ch69data};
+
+/* char: 0x44 'D' */
+
+static const GLubyte ch68data[] = {
+0xfc,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0xfc,
+};
+
+static const BitmapCharRec ch68 = {7,9,0,0,8,ch68data};
+
+/* char: 0x43 'C' */
+
+static const GLubyte ch67data[] = {
+0x78,0x84,0x80,0x80,0x80,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch67 = {6,9,-1,0,8,ch67data};
+
+/* char: 0x42 'B' */
+
+static const GLubyte ch66data[] = {
+0xfc,0x42,0x42,0x42,0x7c,0x42,0x42,0x42,0xfc,
+};
+
+static const BitmapCharRec ch66 = {7,9,0,0,8,ch66data};
+
+/* char: 0x41 'A' */
+
+static const GLubyte ch65data[] = {
+0x84,0x84,0x84,0xfc,0x84,0x84,0x84,0x48,0x30,
+};
+
+static const BitmapCharRec ch65 = {6,9,-1,0,8,ch65data};
+
+/* char: 0x40 '@' */
+
+static const GLubyte ch64data[] = {
+0x78,0x80,0x94,0xac,0xa4,0x9c,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch64 = {6,9,-1,0,8,ch64data};
+
+/* char: 0x3f '?' */
+
+static const GLubyte ch63data[] = {
+0x10,0x0,0x10,0x10,0x8,0x4,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch63 = {6,9,-1,0,8,ch63data};
+
+/* char: 0x3e '>' */
+
+static const GLubyte ch62data[] = {
+0x80,0x40,0x20,0x10,0x8,0x10,0x20,0x40,0x80,
+};
+
+static const BitmapCharRec ch62 = {5,9,-1,0,8,ch62data};
+
+/* char: 0x3d '=' */
+
+static const GLubyte ch61data[] = {
+0xfc,0x0,0x0,0xfc,
+};
+
+static const BitmapCharRec ch61 = {6,4,-1,-2,8,ch61data};
+
+/* char: 0x3c '<' */
+
+static const GLubyte ch60data[] = {
+0x8,0x10,0x20,0x40,0x80,0x40,0x20,0x10,0x8,
+};
+
+static const BitmapCharRec ch60 = {5,9,-2,0,8,ch60data};
+
+/* char: 0x3b ';' */
+
+static const GLubyte ch59data[] = {
+0x80,0x60,0x70,0x0,0x0,0x20,0x70,0x20,
+};
+
+static const BitmapCharRec ch59 = {4,8,-1,1,8,ch59data};
+
+/* char: 0x3a ':' */
+
+static const GLubyte ch58data[] = {
+0x40,0xe0,0x40,0x0,0x0,0x40,0xe0,0x40,
+};
+
+static const BitmapCharRec ch58 = {3,8,-2,1,8,ch58data};
+
+/* char: 0x39 '9' */
+
+static const GLubyte ch57data[] = {
+0x70,0x8,0x4,0x4,0x74,0x8c,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch57 = {6,9,-1,0,8,ch57data};
+
+/* char: 0x38 '8' */
+
+static const GLubyte ch56data[] = {
+0x78,0x84,0x84,0x84,0x78,0x84,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch56 = {6,9,-1,0,8,ch56data};
+
+/* char: 0x37 '7' */
+
+static const GLubyte ch55data[] = {
+0x40,0x40,0x20,0x20,0x10,0x10,0x8,0x4,0xfc,
+};
+
+static const BitmapCharRec ch55 = {6,9,-1,0,8,ch55data};
+
+/* char: 0x36 '6' */
+
+static const GLubyte ch54data[] = {
+0x78,0x84,0x84,0xc4,0xb8,0x80,0x80,0x40,0x38,
+};
+
+static const BitmapCharRec ch54 = {6,9,-1,0,8,ch54data};
+
+/* char: 0x35 '5' */
+
+static const GLubyte ch53data[] = {
+0x78,0x84,0x4,0x4,0xc4,0xb8,0x80,0x80,0xfc,
+};
+
+static const BitmapCharRec ch53 = {6,9,-1,0,8,ch53data};
+
+/* char: 0x34 '4' */
+
+static const GLubyte ch52data[] = {
+0x8,0x8,0xfc,0x88,0x88,0x48,0x28,0x18,0x8,
+};
+
+static const BitmapCharRec ch52 = {6,9,-1,0,8,ch52data};
+
+/* char: 0x33 '3' */
+
+static const GLubyte ch51data[] = {
+0x78,0x84,0x4,0x4,0x38,0x10,0x8,0x4,0xfc,
+};
+
+static const BitmapCharRec ch51 = {6,9,-1,0,8,ch51data};
+
+/* char: 0x32 '2' */
+
+static const GLubyte ch50data[] = {
+0xfc,0x80,0x40,0x30,0x8,0x4,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch50 = {6,9,-1,0,8,ch50data};
+
+/* char: 0x31 '1' */
+
+static const GLubyte ch49data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xa0,0x60,0x20,
+};
+
+static const BitmapCharRec ch49 = {5,9,-1,0,8,ch49data};
+
+/* char: 0x30 '0' */
+
+static const GLubyte ch48data[] = {
+0x30,0x48,0x84,0x84,0x84,0x84,0x84,0x48,0x30,
+};
+
+static const BitmapCharRec ch48 = {6,9,-1,0,8,ch48data};
+
+/* char: 0x2f '/' */
+
+static const GLubyte ch47data[] = {
+0x80,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0x2,
+};
+
+static const BitmapCharRec ch47 = {7,9,0,0,8,ch47data};
+
+/* char: 0x2e '.' */
+
+static const GLubyte ch46data[] = {
+0x40,0xe0,0x40,
+};
+
+static const BitmapCharRec ch46 = {3,3,-2,1,8,ch46data};
+
+/* char: 0x2d '-' */
+
+static const GLubyte ch45data[] = {
+0xfc,
+};
+
+static const BitmapCharRec ch45 = {6,1,-1,-4,8,ch45data};
+
+/* char: 0x2c ',' */
+
+static const GLubyte ch44data[] = {
+0x80,0x60,0x70,
+};
+
+static const BitmapCharRec ch44 = {4,3,-1,1,8,ch44data};
+
+/* char: 0x2b '+' */
+
+static const GLubyte ch43data[] = {
+0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch43 = {5,5,-1,-2,8,ch43data};
+
+/* char: 0x2a '*' */
+
+static const GLubyte ch42data[] = {
+0x48,0x30,0xfc,0x30,0x48,
+};
+
+static const BitmapCharRec ch42 = {6,5,-1,-2,8,ch42data};
+
+/* char: 0x29 ')' */
+
+static const GLubyte ch41data[] = {
+0x80,0x40,0x40,0x20,0x20,0x20,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch41 = {3,9,-2,0,8,ch41data};
+
+/* char: 0x28 '(' */
+
+static const GLubyte ch40data[] = {
+0x20,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x20,
+};
+
+static const BitmapCharRec ch40 = {3,9,-3,0,8,ch40data};
+
+/* char: 0x27 ''' */
+
+static const GLubyte ch39data[] = {
+0x80,0x60,0x70,
+};
+
+static const BitmapCharRec ch39 = {4,3,-1,-6,8,ch39data};
+
+/* char: 0x26 '&' */
+
+static const GLubyte ch38data[] = {
+0x74,0x88,0x94,0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch38 = {6,7,-1,0,8,ch38data};
+
+/* char: 0x25 '%' */
+
+static const GLubyte ch37data[] = {
+0x88,0x54,0x48,0x20,0x10,0x10,0x48,0xa4,0x44,
+};
+
+static const BitmapCharRec ch37 = {6,9,-1,0,8,ch37data};
+
+/* char: 0x24 '$' */
+
+static const GLubyte ch36data[] = {
+0x20,0xf0,0x28,0x70,0xa0,0x78,0x20,
+};
+
+static const BitmapCharRec ch36 = {5,7,-1,-1,8,ch36data};
+
+/* char: 0x23 '#' */
+
+static const GLubyte ch35data[] = {
+0x48,0x48,0xfc,0x48,0xfc,0x48,0x48,
+};
+
+static const BitmapCharRec ch35 = {6,7,-1,-1,8,ch35data};
+
+/* char: 0x22 '"' */
+
+static const GLubyte ch34data[] = {
+0x90,0x90,0x90,
+};
+
+static const BitmapCharRec ch34 = {4,3,-2,-6,8,ch34data};
+
+/* char: 0x21 '!' */
+
+static const GLubyte ch33data[] = {
+0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch33 = {1,9,-3,0,8,ch33data};
+
+/* char: 0x1f */
+
+static const GLubyte ch31data[] = {
+0x80,
+};
+
+static const BitmapCharRec ch31 = {1,1,-3,-3,8,ch31data};
+
+/* char: 0x1e */
+
+static const GLubyte ch30data[] = {
+0xdc,0x62,0x20,0x20,0x20,0x70,0x20,0x22,0x1c,
+};
+
+static const BitmapCharRec ch30 = {7,9,0,0,8,ch30data};
+
+/* char: 0x1d */
+
+static const GLubyte ch29data[] = {
+0x80,0x40,0xfe,0x10,0xfe,0x4,0x2,
+};
+
+static const BitmapCharRec ch29 = {7,7,0,0,8,ch29data};
+
+/* char: 0x1c */
+
+static const GLubyte ch28data[] = {
+0x88,0x48,0x48,0x48,0x48,0xfc,
+};
+
+static const BitmapCharRec ch28 = {6,6,-1,0,8,ch28data};
+
+/* char: 0x1b */
+
+static const GLubyte ch27data[] = {
+0xfe,0x80,0x20,0x8,0x2,0x8,0x20,0x80,
+};
+
+static const BitmapCharRec ch27 = {7,8,0,0,8,ch27data};
+
+/* char: 0x1a */
+
+static const GLubyte ch26data[] = {
+0xfe,0x2,0x8,0x20,0x80,0x20,0x8,0x2,
+};
+
+static const BitmapCharRec ch26 = {7,8,0,0,8,ch26data};
+
+/* char: 0x19 */
+
+static const GLubyte ch25data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch25 = {1,13,-3,2,8,ch25data};
+
+/* char: 0x18 */
+
+static const GLubyte ch24data[] = {
+0x10,0x10,0x10,0x10,0x10,0xff,
+};
+
+static const BitmapCharRec ch24 = {8,6,0,2,8,ch24data};
+
+/* char: 0x17 */
+
+static const GLubyte ch23data[] = {
+0xff,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+};
+
+static const BitmapCharRec ch23 = {8,8,0,-3,8,ch23data};
+
+/* char: 0x16 */
+
+static const GLubyte ch22data[] = {
+0x10,0x10,0x10,0x10,0x10,0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+};
+
+static const BitmapCharRec ch22 = {4,13,0,2,8,ch22data};
+
+/* char: 0x15 */
+
+static const GLubyte ch21data[] = {
+0x80,0x80,0x80,0x80,0x80,0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch21 = {5,13,-3,2,8,ch21data};
+
+/* char: 0x14 */
+
+static const GLubyte ch20data[] = {
+0xff,
+};
+
+static const BitmapCharRec ch20 = {8,1,0,1,8,ch20data};
+
+/* char: 0x13 */
+
+static const GLubyte ch19data[] = {
+0xff,
+};
+
+static const BitmapCharRec ch19 = {8,1,0,-1,8,ch19data};
+
+/* char: 0x12 */
+
+static const GLubyte ch18data[] = {
+0xff,
+};
+
+static const BitmapCharRec ch18 = {8,1,0,-3,8,ch18data};
+
+/* char: 0x11 */
+
+static const GLubyte ch17data[] = {
+0xff,
+};
+
+static const BitmapCharRec ch17 = {8,1,0,-5,8,ch17data};
+
+/* char: 0x10 */
+
+static const GLubyte ch16data[] = {
+0xff,
+};
+
+static const BitmapCharRec ch16 = {8,1,0,-7,8,ch16data};
+
+/* char: 0xf */
+
+static const GLubyte ch15data[] = {
+0x10,0x10,0x10,0x10,0x10,0xff,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+};
+
+static const BitmapCharRec ch15 = {8,13,0,2,8,ch15data};
+
+/* char: 0xe */
+
+static const GLubyte ch14data[] = {
+0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch14 = {5,8,-3,-3,8,ch14data};
+
+/* char: 0xd */
+
+static const GLubyte ch13data[] = {
+0x80,0x80,0x80,0x80,0x80,0xf8,
+};
+
+static const BitmapCharRec ch13 = {5,6,-3,2,8,ch13data};
+
+/* char: 0xc */
+
+static const GLubyte ch12data[] = {
+0x10,0x10,0x10,0x10,0x10,0xf0,
+};
+
+static const BitmapCharRec ch12 = {4,6,0,2,8,ch12data};
+
+/* char: 0xb */
+
+static const GLubyte ch11data[] = {
+0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+};
+
+static const BitmapCharRec ch11 = {4,8,0,-3,8,ch11data};
+
+/* char: 0xa */
+
+static const GLubyte ch10data[] = {
+0x8,0x8,0x8,0x8,0x3e,0x20,0x50,0x88,0x88,
+};
+
+static const BitmapCharRec ch10 = {7,9,0,2,8,ch10data};
+
+/* char: 0x9 */
+
+static const GLubyte ch9data[] = {
+0x3e,0x20,0x20,0x20,0x88,0x98,0xa8,0xc8,0x88,
+};
+
+static const BitmapCharRec ch9 = {7,9,0,2,8,ch9data};
+
+/* char: 0x8 */
+
+static const GLubyte ch8data[] = {
+0xfe,0x10,0x10,0xfe,0x10,0x10,
+};
+
+static const BitmapCharRec ch8 = {7,6,0,0,8,ch8data};
+
+/* char: 0x7 */
+
+static const GLubyte ch7data[] = {
+0x70,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch7 = {5,4,-1,-5,8,ch7data};
+
+/* char: 0x6 */
+
+static const GLubyte ch6data[] = {
+0x20,0x20,0x3c,0x20,0x3e,0xf8,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch6 = {7,9,0,2,8,ch6data};
+
+/* char: 0x5 */
+
+static const GLubyte ch5data[] = {
+0x22,0x22,0x3c,0x22,0x3c,0x78,0x80,0x80,0x78,
+};
+
+static const BitmapCharRec ch5 = {7,9,0,2,8,ch5data};
+
+/* char: 0x4 */
+
+static const GLubyte ch4data[] = {
+0x10,0x10,0x1c,0x10,0x9e,0x80,0xe0,0x80,0xf0,
+};
+
+static const BitmapCharRec ch4 = {7,9,0,2,8,ch4data};
+
+/* char: 0x3 */
+
+static const GLubyte ch3data[] = {
+0x8,0x8,0x8,0x3e,0x88,0x88,0xf8,0x88,0x88,
+};
+
+static const BitmapCharRec ch3 = {7,9,0,2,8,ch3data};
+
+/* char: 0x2 */
+
+static const GLubyte ch2data[] = {
+0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,
+};
+
+static const BitmapCharRec ch2 = {8,12,0,2,8,ch2data};
+
+/* char: 0x1 */
+
+static const GLubyte ch1data[] = {
+0x10,0x38,0x7c,0xfe,0x7c,0x38,0x10,
+};
+
+static const BitmapCharRec ch1 = {7,7,0,-1,8,ch1data};
+
+static const BitmapCharRec * const chars[] = {
+&ch0,
+&ch1,
+&ch2,
+&ch3,
+&ch4,
+&ch5,
+&ch6,
+&ch7,
+&ch8,
+&ch9,
+&ch10,
+&ch11,
+&ch12,
+&ch13,
+&ch14,
+&ch15,
+&ch16,
+&ch17,
+&ch18,
+&ch19,
+&ch20,
+&ch21,
+&ch22,
+&ch23,
+&ch24,
+&ch25,
+&ch26,
+&ch27,
+&ch28,
+&ch29,
+&ch30,
+&ch31,
+&ch32,
+&ch33,
+&ch34,
+&ch35,
+&ch36,
+&ch37,
+&ch38,
+&ch39,
+&ch40,
+&ch41,
+&ch42,
+&ch43,
+&ch44,
+&ch45,
+&ch46,
+&ch47,
+&ch48,
+&ch49,
+&ch50,
+&ch51,
+&ch52,
+&ch53,
+&ch54,
+&ch55,
+&ch56,
+&ch57,
+&ch58,
+&ch59,
+&ch60,
+&ch61,
+&ch62,
+&ch63,
+&ch64,
+&ch65,
+&ch66,
+&ch67,
+&ch68,
+&ch69,
+&ch70,
+&ch71,
+&ch72,
+&ch73,
+&ch74,
+&ch75,
+&ch76,
+&ch77,
+&ch78,
+&ch79,
+&ch80,
+&ch81,
+&ch82,
+&ch83,
+&ch84,
+&ch85,
+&ch86,
+&ch87,
+&ch88,
+&ch89,
+&ch90,
+&ch91,
+&ch92,
+&ch93,
+&ch94,
+&ch95,
+&ch96,
+&ch97,
+&ch98,
+&ch99,
+&ch100,
+&ch101,
+&ch102,
+&ch103,
+&ch104,
+&ch105,
+&ch106,
+&ch107,
+&ch108,
+&ch109,
+&ch110,
+&ch111,
+&ch112,
+&ch113,
+&ch114,
+&ch115,
+&ch116,
+&ch117,
+&ch118,
+&ch119,
+&ch120,
+&ch121,
+&ch122,
+&ch123,
+&ch124,
+&ch125,
+&ch126,
+&ch127,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+&ch160,
+&ch161,
+&ch162,
+&ch163,
+&ch164,
+&ch165,
+&ch166,
+&ch167,
+&ch168,
+&ch169,
+&ch170,
+&ch171,
+&ch172,
+&ch173,
+&ch174,
+&ch175,
+&ch176,
+&ch177,
+&ch178,
+&ch179,
+&ch180,
+&ch181,
+&ch182,
+&ch183,
+&ch184,
+&ch185,
+&ch186,
+&ch187,
+&ch188,
+&ch189,
+&ch190,
+&ch191,
+&ch192,
+&ch193,
+&ch194,
+&ch195,
+&ch196,
+&ch197,
+&ch198,
+&ch199,
+&ch200,
+&ch201,
+&ch202,
+&ch203,
+&ch204,
+&ch205,
+&ch206,
+&ch207,
+&ch208,
+&ch209,
+&ch210,
+&ch211,
+&ch212,
+&ch213,
+&ch214,
+&ch215,
+&ch216,
+&ch217,
+&ch218,
+&ch219,
+&ch220,
+&ch221,
+&ch222,
+&ch223,
+&ch224,
+&ch225,
+&ch226,
+&ch227,
+&ch228,
+&ch229,
+&ch230,
+&ch231,
+&ch232,
+&ch233,
+&ch234,
+&ch235,
+&ch236,
+&ch237,
+&ch238,
+&ch239,
+&ch240,
+&ch241,
+&ch242,
+&ch243,
+&ch244,
+&ch245,
+&ch246,
+&ch247,
+&ch248,
+&ch249,
+&ch250,
+&ch251,
+&ch252,
+&ch253,
+&ch254,
+&ch255,
+};
+
+const BitmapFontRec glutBitmap8By13 = {
+"-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1",
+256,
+0,
+chars
+};
+
diff --git a/src/glut/glx/glut_9x15.c b/src/glut/glx/glut_9x15.c
new file mode 100644
index 0000000000..2d5c004e47
--- /dev/null
+++ b/src/glut/glx/glut_9x15.c
@@ -0,0 +1,2075 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#define glutBitmap9By15 XXX
+#include "glutbitmap.h"
+#undef glutBitmap9By15
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch0data[] = { 0x0 };
+static const BitmapCharRec ch0 = {1,1,0,0,9,ch0data};
+#else
+static const BitmapCharRec ch0 = {0,0,0,0,9,0};
+#endif
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch32data[] = { 0x0 };
+static const BitmapCharRec ch32 = {1,1,0,0,9,ch32data};
+#else
+static const BitmapCharRec ch32 = {0,0,0,0,9,0};
+#endif
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch127data[] = { 0x0 };
+static const BitmapCharRec ch127 = {1,1,0,0,9,ch127data};
+#else
+static const BitmapCharRec ch127 = {0,0,0,0,9,0};
+#endif
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch160data[] = { 0x0 };
+static const BitmapCharRec ch160 = {1,1,0,0,9,ch160data};
+#else
+static const BitmapCharRec ch160 = {0,0,0,0,9,0};
+#endif
+
+/* char: 0xff */
+
+static const GLubyte ch255data[] = {
+0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch255 = {6,14,-1,3,9,ch255data};
+
+/* char: 0xfe */
+
+static const GLubyte ch254data[] = {
+0x80,0x80,0x80,0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,
+};
+
+static const BitmapCharRec ch254 = {7,12,-1,3,9,ch254data};
+
+/* char: 0xfd */
+
+static const GLubyte ch253data[] = {
+0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch253 = {6,14,-1,3,9,ch253data};
+
+/* char: 0xfc */
+
+static const GLubyte ch252data[] = {
+0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch252 = {7,11,-1,0,9,ch252data};
+
+/* char: 0xfb */
+
+static const GLubyte ch251data[] = {
+0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch251 = {7,11,-1,0,9,ch251data};
+
+/* char: 0xfa */
+
+static const GLubyte ch250data[] = {
+0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch250 = {7,11,-1,0,9,ch250data};
+
+/* char: 0xf9 */
+
+static const GLubyte ch249data[] = {
+0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch249 = {7,11,-1,0,9,ch249data};
+
+/* char: 0xf8 */
+
+static const GLubyte ch248data[] = {
+0x80,0x7c,0xa2,0xa2,0x92,0x8a,0x8a,0x7c,0x2,
+};
+
+static const BitmapCharRec ch248 = {7,9,-1,1,9,ch248data};
+
+/* char: 0xf7 */
+
+static const GLubyte ch247data[] = {
+0x10,0x38,0x10,0x0,0xfe,0x0,0x10,0x38,0x10,
+};
+
+static const BitmapCharRec ch247 = {7,9,-1,0,9,ch247data};
+
+/* char: 0xf6 */
+
+static const GLubyte ch246data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch246 = {7,11,-1,0,9,ch246data};
+
+/* char: 0xf5 */
+
+static const GLubyte ch245data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch245 = {7,11,-1,0,9,ch245data};
+
+/* char: 0xf4 */
+
+static const GLubyte ch244data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch244 = {7,11,-1,0,9,ch244data};
+
+/* char: 0xf3 */
+
+static const GLubyte ch243data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch243 = {7,11,-1,0,9,ch243data};
+
+/* char: 0xf2 */
+
+static const GLubyte ch242data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch242 = {7,11,-1,0,9,ch242data};
+
+/* char: 0xf1 */
+
+static const GLubyte ch241data[] = {
+0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,0x0,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch241 = {7,11,-1,0,9,ch241data};
+
+/* char: 0xf0 */
+
+static const GLubyte ch240data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x8,0x50,0x30,0x48,
+};
+
+static const BitmapCharRec ch240 = {7,11,-1,0,9,ch240data};
+
+/* char: 0xef */
+
+static const GLubyte ch239data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x50,0x50,
+};
+
+static const BitmapCharRec ch239 = {5,11,-2,0,9,ch239data};
+
+/* char: 0xee */
+
+static const GLubyte ch238data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x90,0x60,
+};
+
+static const BitmapCharRec ch238 = {5,11,-2,0,9,ch238data};
+
+/* char: 0xed */
+
+static const GLubyte ch237data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x60,0x10,
+};
+
+static const BitmapCharRec ch237 = {5,11,-2,0,9,ch237data};
+
+/* char: 0xec */
+
+static const GLubyte ch236data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x30,0x40,
+};
+
+static const BitmapCharRec ch236 = {5,11,-2,0,9,ch236data};
+
+/* char: 0xeb */
+
+static const GLubyte ch235data[] = {
+0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch235 = {7,11,-1,0,9,ch235data};
+
+/* char: 0xea */
+
+static const GLubyte ch234data[] = {
+0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch234 = {7,11,-1,0,9,ch234data};
+
+/* char: 0xe9 */
+
+static const GLubyte ch233data[] = {
+0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch233 = {7,11,-1,0,9,ch233data};
+
+/* char: 0xe8 */
+
+static const GLubyte ch232data[] = {
+0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch232 = {7,11,-1,0,9,ch232data};
+
+/* char: 0xe7 */
+
+static const GLubyte ch231data[] = {
+0x30,0x48,0x18,0x7c,0x82,0x80,0x80,0x80,0x82,0x7c,
+};
+
+static const BitmapCharRec ch231 = {7,10,-1,3,9,ch231data};
+
+/* char: 0xe6 */
+
+static const GLubyte ch230data[] = {
+0x6e,0x92,0x90,0x7c,0x12,0x92,0x6c,
+};
+
+static const BitmapCharRec ch230 = {7,7,-1,0,9,ch230data};
+
+/* char: 0xe5 */
+
+static const GLubyte ch229data[] = {
+0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x18,0x24,0x18,
+};
+
+static const BitmapCharRec ch229 = {7,11,-1,0,9,ch229data};
+
+/* char: 0xe4 */
+
+static const GLubyte ch228data[] = {
+0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch228 = {7,11,-1,0,9,ch228data};
+
+/* char: 0xe3 */
+
+static const GLubyte ch227data[] = {
+0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch227 = {7,11,-1,0,9,ch227data};
+
+/* char: 0xe2 */
+
+static const GLubyte ch226data[] = {
+0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch226 = {7,11,-1,0,9,ch226data};
+
+/* char: 0xe1 */
+
+static const GLubyte ch225data[] = {
+0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch225 = {7,11,-1,0,9,ch225data};
+
+/* char: 0xe0 */
+
+static const GLubyte ch224data[] = {
+0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch224 = {7,11,-1,0,9,ch224data};
+
+/* char: 0xdf */
+
+static const GLubyte ch223data[] = {
+0x80,0xbc,0xc2,0x82,0x82,0xfc,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch223 = {7,9,-1,1,9,ch223data};
+
+/* char: 0xde */
+
+static const GLubyte ch222data[] = {
+0x80,0x80,0x80,0xfc,0x82,0x82,0x82,0xfc,0x80,0x80,
+};
+
+static const BitmapCharRec ch222 = {7,10,-1,0,9,ch222data};
+
+/* char: 0xdd */
+
+static const GLubyte ch221data[] = {
+0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch221 = {7,11,-1,0,9,ch221data};
+
+/* char: 0xdc */
+
+static const GLubyte ch220data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch220 = {7,11,-1,0,9,ch220data};
+
+/* char: 0xdb */
+
+static const GLubyte ch219data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch219 = {7,11,-1,0,9,ch219data};
+
+/* char: 0xda */
+
+static const GLubyte ch218data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch218 = {7,11,-1,0,9,ch218data};
+
+/* char: 0xd9 */
+
+static const GLubyte ch217data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch217 = {7,11,-1,0,9,ch217data};
+
+/* char: 0xd8 */
+
+static const GLubyte ch216data[] = {
+0x80,0x7c,0xc2,0xa2,0xa2,0x92,0x92,0x8a,0x8a,0x86,0x7c,0x2,
+};
+
+static const BitmapCharRec ch216 = {7,12,-1,1,9,ch216data};
+
+/* char: 0xd7 */
+
+static const GLubyte ch215data[] = {
+0x82,0x44,0x28,0x10,0x28,0x44,0x82,
+};
+
+static const BitmapCharRec ch215 = {7,7,-1,-1,9,ch215data};
+
+/* char: 0xd6 */
+
+static const GLubyte ch214data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch214 = {7,11,-1,0,9,ch214data};
+
+/* char: 0xd5 */
+
+static const GLubyte ch213data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch213 = {7,11,-1,0,9,ch213data};
+
+/* char: 0xd4 */
+
+static const GLubyte ch212data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch212 = {7,11,-1,0,9,ch212data};
+
+/* char: 0xd3 */
+
+static const GLubyte ch211data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch211 = {7,11,-1,0,9,ch211data};
+
+/* char: 0xd2 */
+
+static const GLubyte ch210data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch210 = {7,11,-1,0,9,ch210data};
+
+/* char: 0xd1 */
+
+static const GLubyte ch209data[] = {
+0x82,0x86,0x8a,0x92,0x92,0xa2,0xc2,0x82,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch209 = {7,11,-1,0,9,ch209data};
+
+/* char: 0xd0 */
+
+static const GLubyte ch208data[] = {
+0xfc,0x42,0x42,0x42,0x42,0xf2,0x42,0x42,0x42,0xfc,
+};
+
+static const BitmapCharRec ch208 = {7,10,-1,0,9,ch208data};
+
+/* char: 0xcf */
+
+static const GLubyte ch207data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x50,0x50,
+};
+
+static const BitmapCharRec ch207 = {5,11,-2,0,9,ch207data};
+
+/* char: 0xce */
+
+static const GLubyte ch206data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x88,0x70,
+};
+
+static const BitmapCharRec ch206 = {5,11,-2,0,9,ch206data};
+
+/* char: 0xcd */
+
+static const GLubyte ch205data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x60,0x10,
+};
+
+static const BitmapCharRec ch205 = {5,11,-2,0,9,ch205data};
+
+/* char: 0xcc */
+
+static const GLubyte ch204data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x30,0x40,
+};
+
+static const BitmapCharRec ch204 = {5,11,-2,0,9,ch204data};
+
+/* char: 0xcb */
+
+static const GLubyte ch203data[] = {
+0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch203 = {7,11,-1,0,9,ch203data};
+
+/* char: 0xca */
+
+static const GLubyte ch202data[] = {
+0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch202 = {7,11,-1,0,9,ch202data};
+
+/* char: 0xc9 */
+
+static const GLubyte ch201data[] = {
+0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch201 = {7,11,-1,0,9,ch201data};
+
+/* char: 0xc8 */
+
+static const GLubyte ch200data[] = {
+0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch200 = {7,11,-1,0,9,ch200data};
+
+/* char: 0xc7 */
+
+static const GLubyte ch199data[] = {
+0x30,0x48,0x18,0x7c,0x82,0x80,0x80,0x80,0x80,0x80,0x80,0x82,0x7c,
+};
+
+static const BitmapCharRec ch199 = {7,13,-1,3,9,ch199data};
+
+/* char: 0xc6 */
+
+static const GLubyte ch198data[] = {
+0x9e,0x90,0x90,0x90,0xfc,0x90,0x90,0x90,0x90,0x6e,
+};
+
+static const BitmapCharRec ch198 = {7,10,-1,0,9,ch198data};
+
+/* char: 0xc5 */
+
+static const GLubyte ch197data[] = {
+0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x10,0x28,0x10,
+};
+
+static const BitmapCharRec ch197 = {7,11,-1,0,9,ch197data};
+
+/* char: 0xc4 */
+
+static const GLubyte ch196data[] = {
+0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x28,0x28,
+};
+
+static const BitmapCharRec ch196 = {7,11,-1,0,9,ch196data};
+
+/* char: 0xc3 */
+
+static const GLubyte ch195data[] = {
+0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch195 = {7,11,-1,0,9,ch195data};
+
+/* char: 0xc2 */
+
+static const GLubyte ch194data[] = {
+0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x44,0x38,
+};
+
+static const BitmapCharRec ch194 = {7,11,-1,0,9,ch194data};
+
+/* char: 0xc1 */
+
+static const GLubyte ch193data[] = {
+0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x30,0x8,
+};
+
+static const BitmapCharRec ch193 = {7,11,-1,0,9,ch193data};
+
+/* char: 0xc0 */
+
+static const GLubyte ch192data[] = {
+0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x18,0x20,
+};
+
+static const BitmapCharRec ch192 = {7,11,-1,0,9,ch192data};
+
+/* char: 0xbf */
+
+static const GLubyte ch191data[] = {
+0x7c,0x82,0x82,0x80,0x40,0x20,0x10,0x10,0x0,0x10,
+};
+
+static const BitmapCharRec ch191 = {7,10,-1,0,9,ch191data};
+
+/* char: 0xbe */
+
+static const GLubyte ch190data[] = {
+0x6,0x1a,0x12,0xa,0x66,0x92,0x10,0x20,0x90,0x60,
+};
+
+static const BitmapCharRec ch190 = {7,10,-1,0,9,ch190data};
+
+/* char: 0xbd */
+
+static const GLubyte ch189data[] = {
+0x1e,0x10,0xc,0x2,0xf2,0x4c,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch189 = {7,10,-1,0,9,ch189data};
+
+/* char: 0xbc */
+
+static const GLubyte ch188data[] = {
+0x6,0x1a,0x12,0xa,0xe6,0x42,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch188 = {7,10,-1,0,9,ch188data};
+
+/* char: 0xbb */
+
+static const GLubyte ch187data[] = {
+0x90,0x48,0x24,0x12,0x12,0x24,0x48,0x90,
+};
+
+static const BitmapCharRec ch187 = {7,8,-1,-1,9,ch187data};
+
+/* char: 0xba */
+
+static const GLubyte ch186data[] = {
+0xf8,0x0,0x70,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch186 = {5,6,-1,-5,9,ch186data};
+
+/* char: 0xb9 */
+
+static const GLubyte ch185data[] = {
+0xe0,0x40,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch185 = {3,6,-1,-4,9,ch185data};
+
+/* char: 0xb8 */
+
+static const GLubyte ch184data[] = {
+0x60,0x90,0x30,
+};
+
+static const BitmapCharRec ch184 = {4,3,-2,3,9,ch184data};
+
+/* char: 0xb7 */
+
+static const GLubyte ch183data[] = {
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch183 = {2,2,-4,-4,9,ch183data};
+
+/* char: 0xb6 */
+
+static const GLubyte ch182data[] = {
+0xa,0xa,0xa,0xa,0xa,0x7a,0x8a,0x8a,0x8a,0x7e,
+};
+
+static const BitmapCharRec ch182 = {7,10,-1,0,9,ch182data};
+
+/* char: 0xb5 */
+
+static const GLubyte ch181data[] = {
+0x80,0x80,0xba,0xc6,0x82,0x82,0x82,0x82,0x82,
+};
+
+static const BitmapCharRec ch181 = {7,9,-1,2,9,ch181data};
+
+/* char: 0xb4 */
+
+static const GLubyte ch180data[] = {
+0xc0,0x20,
+};
+
+static const BitmapCharRec ch180 = {3,2,-3,-9,9,ch180data};
+
+/* char: 0xb3 */
+
+static const GLubyte ch179data[] = {
+0x60,0x90,0x10,0x20,0x90,0x60,
+};
+
+static const BitmapCharRec ch179 = {4,6,-1,-4,9,ch179data};
+
+/* char: 0xb2 */
+
+static const GLubyte ch178data[] = {
+0xf0,0x80,0x60,0x10,0x90,0x60,
+};
+
+static const BitmapCharRec ch178 = {4,6,-1,-4,9,ch178data};
+
+/* char: 0xb1 */
+
+static const GLubyte ch177data[] = {
+0xfe,0x0,0x10,0x10,0x10,0xfe,0x10,0x10,0x10,
+};
+
+static const BitmapCharRec ch177 = {7,9,-1,-1,9,ch177data};
+
+/* char: 0xb0 */
+
+static const GLubyte ch176data[] = {
+0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch176 = {4,4,-3,-6,9,ch176data};
+
+/* char: 0xaf */
+
+static const GLubyte ch175data[] = {
+0xfc,
+};
+
+static const BitmapCharRec ch175 = {6,1,-1,-9,9,ch175data};
+
+/* char: 0xae */
+
+static const GLubyte ch174data[] = {
+0x3c,0x42,0xa5,0xa9,0xbd,0xa5,0xb9,0x42,0x3c,
+};
+
+static const BitmapCharRec ch174 = {8,9,0,-1,9,ch174data};
+
+/* char: 0xad */
+
+static const GLubyte ch173data[] = {
+0xfc,
+};
+
+static const BitmapCharRec ch173 = {6,1,-1,-4,9,ch173data};
+
+/* char: 0xac */
+
+static const GLubyte ch172data[] = {
+0x4,0x4,0x4,0xfc,
+};
+
+static const BitmapCharRec ch172 = {6,4,-1,-2,9,ch172data};
+
+/* char: 0xab */
+
+static const GLubyte ch171data[] = {
+0x12,0x24,0x48,0x90,0x90,0x48,0x24,0x12,
+};
+
+static const BitmapCharRec ch171 = {7,8,-1,-1,9,ch171data};
+
+/* char: 0xaa */
+
+static const GLubyte ch170data[] = {
+0xf8,0x0,0x78,0x90,0x70,0x90,0x60,
+};
+
+static const BitmapCharRec ch170 = {5,7,-3,-3,9,ch170data};
+
+/* char: 0xa9 */
+
+static const GLubyte ch169data[] = {
+0x3c,0x42,0x99,0xa5,0xa1,0xa5,0x99,0x42,0x3c,
+};
+
+static const BitmapCharRec ch169 = {8,9,0,-1,9,ch169data};
+
+/* char: 0xa8 */
+
+static const GLubyte ch168data[] = {
+0xa0,0xa0,
+};
+
+static const BitmapCharRec ch168 = {3,2,-3,-9,9,ch168data};
+
+/* char: 0xa7 */
+
+static const GLubyte ch167data[] = {
+0x70,0x88,0x8,0x70,0x88,0x88,0x88,0x70,0x80,0x88,0x70,
+};
+
+static const BitmapCharRec ch167 = {5,11,-2,1,9,ch167data};
+
+/* char: 0xa6 */
+
+static const GLubyte ch166data[] = {
+0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch166 = {1,11,-4,1,9,ch166data};
+
+/* char: 0xa5 */
+
+static const GLubyte ch165data[] = {
+0x10,0x10,0x10,0x7c,0x10,0x7c,0x28,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch165 = {7,10,-1,0,9,ch165data};
+
+/* char: 0xa4 */
+
+static const GLubyte ch164data[] = {
+0x82,0x7c,0x44,0x44,0x7c,0x82,
+};
+
+static const BitmapCharRec ch164 = {7,6,-1,-3,9,ch164data};
+
+/* char: 0xa3 */
+
+static const GLubyte ch163data[] = {
+0x5c,0xa2,0x60,0x20,0x20,0xf8,0x20,0x20,0x22,0x1c,
+};
+
+static const BitmapCharRec ch163 = {7,10,-1,0,9,ch163data};
+
+/* char: 0xa2 */
+
+static const GLubyte ch162data[] = {
+0x40,0x78,0xa4,0xa0,0x90,0x94,0x78,0x8,
+};
+
+static const BitmapCharRec ch162 = {6,8,-1,0,9,ch162data};
+
+/* char: 0xa1 */
+
+static const GLubyte ch161data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x0,0x80,0x80,
+};
+
+static const BitmapCharRec ch161 = {1,11,-4,0,9,ch161data};
+
+/* char: 0x7e '~' */
+
+static const GLubyte ch126data[] = {
+0x8c,0x92,0x62,
+};
+
+static const BitmapCharRec ch126 = {7,3,-1,-7,9,ch126data};
+
+/* char: 0x7d '}' */
+
+static const GLubyte ch125data[] = {
+0xe0,0x10,0x10,0x10,0x20,0x18,0x18,0x20,0x10,0x10,0x10,0xe0,
+};
+
+static const BitmapCharRec ch125 = {5,12,-1,1,9,ch125data};
+
+/* char: 0x7c '|' */
+
+static const GLubyte ch124data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch124 = {1,12,-4,1,9,ch124data};
+
+/* char: 0x7b '{' */
+
+static const GLubyte ch123data[] = {
+0x38,0x40,0x40,0x40,0x20,0xc0,0xc0,0x20,0x40,0x40,0x40,0x38,
+};
+
+static const BitmapCharRec ch123 = {5,12,-3,1,9,ch123data};
+
+/* char: 0x7a 'z' */
+
+static const GLubyte ch122data[] = {
+0xfe,0x40,0x20,0x10,0x8,0x4,0xfe,
+};
+
+static const BitmapCharRec ch122 = {7,7,-1,0,9,ch122data};
+
+/* char: 0x79 'y' */
+
+static const GLubyte ch121data[] = {
+0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch121 = {6,10,-1,3,9,ch121data};
+
+/* char: 0x78 'x' */
+
+static const GLubyte ch120data[] = {
+0x82,0x44,0x28,0x10,0x28,0x44,0x82,
+};
+
+static const BitmapCharRec ch120 = {7,7,-1,0,9,ch120data};
+
+/* char: 0x77 'w' */
+
+static const GLubyte ch119data[] = {
+0x44,0xaa,0x92,0x92,0x92,0x82,0x82,
+};
+
+static const BitmapCharRec ch119 = {7,7,-1,0,9,ch119data};
+
+/* char: 0x76 'v' */
+
+static const GLubyte ch118data[] = {
+0x10,0x28,0x28,0x44,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch118 = {7,7,-1,0,9,ch118data};
+
+/* char: 0x75 'u' */
+
+static const GLubyte ch117data[] = {
+0x7a,0x84,0x84,0x84,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch117 = {7,7,-1,0,9,ch117data};
+
+/* char: 0x74 't' */
+
+static const GLubyte ch116data[] = {
+0x1c,0x22,0x20,0x20,0x20,0x20,0xfc,0x20,0x20,
+};
+
+static const BitmapCharRec ch116 = {7,9,-1,0,9,ch116data};
+
+/* char: 0x73 's' */
+
+static const GLubyte ch115data[] = {
+0x7c,0x82,0x2,0x7c,0x80,0x82,0x7c,
+};
+
+static const BitmapCharRec ch115 = {7,7,-1,0,9,ch115data};
+
+/* char: 0x72 'r' */
+
+static const GLubyte ch114data[] = {
+0x40,0x40,0x40,0x40,0x42,0x62,0x9c,
+};
+
+static const BitmapCharRec ch114 = {7,7,-1,0,9,ch114data};
+
+/* char: 0x71 'q' */
+
+static const GLubyte ch113data[] = {
+0x2,0x2,0x2,0x7a,0x86,0x82,0x82,0x82,0x86,0x7a,
+};
+
+static const BitmapCharRec ch113 = {7,10,-1,3,9,ch113data};
+
+/* char: 0x70 'p' */
+
+static const GLubyte ch112data[] = {
+0x80,0x80,0x80,0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,
+};
+
+static const BitmapCharRec ch112 = {7,10,-1,3,9,ch112data};
+
+/* char: 0x6f 'o' */
+
+static const GLubyte ch111data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch111 = {7,7,-1,0,9,ch111data};
+
+/* char: 0x6e 'n' */
+
+static const GLubyte ch110data[] = {
+0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,
+};
+
+static const BitmapCharRec ch110 = {7,7,-1,0,9,ch110data};
+
+/* char: 0x6d 'm' */
+
+static const GLubyte ch109data[] = {
+0x82,0x92,0x92,0x92,0x92,0x92,0xec,
+};
+
+static const BitmapCharRec ch109 = {7,7,-1,0,9,ch109data};
+
+/* char: 0x6c 'l' */
+
+static const GLubyte ch108data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xe0,
+};
+
+static const BitmapCharRec ch108 = {5,10,-2,0,9,ch108data};
+
+/* char: 0x6b 'k' */
+
+static const GLubyte ch107data[] = {
+0x82,0x8c,0xb0,0xc0,0xb0,0x8c,0x82,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch107 = {7,10,-1,0,9,ch107data};
+
+/* char: 0x6a 'j' */
+
+static const GLubyte ch106data[] = {
+0x78,0x84,0x84,0x84,0x4,0x4,0x4,0x4,0x4,0x1c,0x0,0x0,0xc,
+};
+
+static const BitmapCharRec ch106 = {6,13,-1,3,9,ch106data};
+
+/* char: 0x69 'i' */
+
+static const GLubyte ch105data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x60,
+};
+
+static const BitmapCharRec ch105 = {5,10,-2,0,9,ch105data};
+
+/* char: 0x68 'h' */
+
+static const GLubyte ch104data[] = {
+0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch104 = {7,10,-1,0,9,ch104data};
+
+/* char: 0x67 'g' */
+
+static const GLubyte ch103data[] = {
+0x7c,0x82,0x82,0x7c,0x80,0x78,0x84,0x84,0x84,0x7a,
+};
+
+static const BitmapCharRec ch103 = {7,10,-1,3,9,ch103data};
+
+/* char: 0x66 'f' */
+
+static const GLubyte ch102data[] = {
+0x20,0x20,0x20,0x20,0xf8,0x20,0x20,0x22,0x22,0x1c,
+};
+
+static const BitmapCharRec ch102 = {7,10,-1,0,9,ch102data};
+
+/* char: 0x65 'e' */
+
+static const GLubyte ch101data[] = {
+0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch101 = {7,7,-1,0,9,ch101data};
+
+/* char: 0x64 'd' */
+
+static const GLubyte ch100data[] = {
+0x7a,0x86,0x82,0x82,0x82,0x86,0x7a,0x2,0x2,0x2,
+};
+
+static const BitmapCharRec ch100 = {7,10,-1,0,9,ch100data};
+
+/* char: 0x63 'c' */
+
+static const GLubyte ch99data[] = {
+0x7c,0x82,0x80,0x80,0x80,0x82,0x7c,
+};
+
+static const BitmapCharRec ch99 = {7,7,-1,0,9,ch99data};
+
+/* char: 0x62 'b' */
+
+static const GLubyte ch98data[] = {
+0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch98 = {7,10,-1,0,9,ch98data};
+
+/* char: 0x61 'a' */
+
+static const GLubyte ch97data[] = {
+0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,
+};
+
+static const BitmapCharRec ch97 = {7,7,-1,0,9,ch97data};
+
+/* char: 0x60 '`' */
+
+static const GLubyte ch96data[] = {
+0x10,0x20,0x40,0xc0,
+};
+
+static const BitmapCharRec ch96 = {4,4,-3,-6,9,ch96data};
+
+/* char: 0x5f '_' */
+
+static const GLubyte ch95data[] = {
+0xff,
+};
+
+static const BitmapCharRec ch95 = {8,1,0,1,9,ch95data};
+
+/* char: 0x5e '^' */
+
+static const GLubyte ch94data[] = {
+0x82,0x44,0x28,0x10,
+};
+
+static const BitmapCharRec ch94 = {7,4,-1,-6,9,ch94data};
+
+/* char: 0x5d ']' */
+
+static const GLubyte ch93data[] = {
+0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xf0,
+};
+
+static const BitmapCharRec ch93 = {4,12,-2,1,9,ch93data};
+
+/* char: 0x5c '\' */
+
+static const GLubyte ch92data[] = {
+0x2,0x4,0x4,0x8,0x10,0x10,0x20,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch92 = {7,10,-1,0,9,ch92data};
+
+/* char: 0x5b '[' */
+
+static const GLubyte ch91data[] = {
+0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xf0,
+};
+
+static const BitmapCharRec ch91 = {4,12,-3,1,9,ch91data};
+
+/* char: 0x5a 'Z' */
+
+static const GLubyte ch90data[] = {
+0xfe,0x80,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0xfe,
+};
+
+static const BitmapCharRec ch90 = {7,10,-1,0,9,ch90data};
+
+/* char: 0x59 'Y' */
+
+static const GLubyte ch89data[] = {
+0x10,0x10,0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch89 = {7,10,-1,0,9,ch89data};
+
+/* char: 0x58 'X' */
+
+static const GLubyte ch88data[] = {
+0x82,0x82,0x44,0x28,0x10,0x10,0x28,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch88 = {7,10,-1,0,9,ch88data};
+
+/* char: 0x57 'W' */
+
+static const GLubyte ch87data[] = {
+0x44,0xaa,0x92,0x92,0x92,0x92,0x82,0x82,0x82,0x82,
+};
+
+static const BitmapCharRec ch87 = {7,10,-1,0,9,ch87data};
+
+/* char: 0x56 'V' */
+
+static const GLubyte ch86data[] = {
+0x10,0x28,0x28,0x28,0x44,0x44,0x44,0x82,0x82,0x82,
+};
+
+static const BitmapCharRec ch86 = {7,10,-1,0,9,ch86data};
+
+/* char: 0x55 'U' */
+
+static const GLubyte ch85data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
+};
+
+static const BitmapCharRec ch85 = {7,10,-1,0,9,ch85data};
+
+/* char: 0x54 'T' */
+
+static const GLubyte ch84data[] = {
+0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xfe,
+};
+
+static const BitmapCharRec ch84 = {7,10,-1,0,9,ch84data};
+
+/* char: 0x53 'S' */
+
+static const GLubyte ch83data[] = {
+0x7c,0x82,0x82,0x2,0xc,0x70,0x80,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch83 = {7,10,-1,0,9,ch83data};
+
+/* char: 0x52 'R' */
+
+static const GLubyte ch82data[] = {
+0x82,0x82,0x84,0x88,0x90,0xfc,0x82,0x82,0x82,0xfc,
+};
+
+static const BitmapCharRec ch82 = {7,10,-1,0,9,ch82data};
+
+/* char: 0x51 'Q' */
+
+static const GLubyte ch81data[] = {
+0x6,0x8,0x7c,0x92,0xa2,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch81 = {7,12,-1,2,9,ch81data};
+
+/* char: 0x50 'P' */
+
+static const GLubyte ch80data[] = {
+0x80,0x80,0x80,0x80,0x80,0xfc,0x82,0x82,0x82,0xfc,
+};
+
+static const BitmapCharRec ch80 = {7,10,-1,0,9,ch80data};
+
+/* char: 0x4f 'O' */
+
+static const GLubyte ch79data[] = {
+0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch79 = {7,10,-1,0,9,ch79data};
+
+/* char: 0x4e 'N' */
+
+static const GLubyte ch78data[] = {
+0x82,0x82,0x82,0x86,0x8a,0x92,0xa2,0xc2,0x82,0x82,
+};
+
+static const BitmapCharRec ch78 = {7,10,-1,0,9,ch78data};
+
+/* char: 0x4d 'M' */
+
+static const GLubyte ch77data[] = {
+0x82,0x82,0x82,0x92,0x92,0xaa,0xaa,0xc6,0x82,0x82,
+};
+
+static const BitmapCharRec ch77 = {7,10,-1,0,9,ch77data};
+
+/* char: 0x4c 'L' */
+
+static const GLubyte ch76data[] = {
+0xfe,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch76 = {7,10,-1,0,9,ch76data};
+
+/* char: 0x4b 'K' */
+
+static const GLubyte ch75data[] = {
+0x82,0x84,0x88,0x90,0xa0,0xe0,0x90,0x88,0x84,0x82,
+};
+
+static const BitmapCharRec ch75 = {7,10,-1,0,9,ch75data};
+
+/* char: 0x4a 'J' */
+
+static const GLubyte ch74data[] = {
+0x78,0x84,0x4,0x4,0x4,0x4,0x4,0x4,0x4,0x1e,
+};
+
+static const BitmapCharRec ch74 = {7,10,-1,0,9,ch74data};
+
+/* char: 0x49 'I' */
+
+static const GLubyte ch73data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,
+};
+
+static const BitmapCharRec ch73 = {5,10,-2,0,9,ch73data};
+
+/* char: 0x48 'H' */
+
+static const GLubyte ch72data[] = {
+0x82,0x82,0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x82,
+};
+
+static const BitmapCharRec ch72 = {7,10,-1,0,9,ch72data};
+
+/* char: 0x47 'G' */
+
+static const GLubyte ch71data[] = {
+0x7c,0x82,0x82,0x82,0x8e,0x80,0x80,0x80,0x82,0x7c,
+};
+
+static const BitmapCharRec ch71 = {7,10,-1,0,9,ch71data};
+
+/* char: 0x46 'F' */
+
+static const GLubyte ch70data[] = {
+0x40,0x40,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0xfe,
+};
+
+static const BitmapCharRec ch70 = {7,10,-1,0,9,ch70data};
+
+/* char: 0x45 'E' */
+
+static const GLubyte ch69data[] = {
+0xfe,0x40,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0xfe,
+};
+
+static const BitmapCharRec ch69 = {7,10,-1,0,9,ch69data};
+
+/* char: 0x44 'D' */
+
+static const GLubyte ch68data[] = {
+0xfc,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0xfc,
+};
+
+static const BitmapCharRec ch68 = {7,10,-1,0,9,ch68data};
+
+/* char: 0x43 'C' */
+
+static const GLubyte ch67data[] = {
+0x7c,0x82,0x80,0x80,0x80,0x80,0x80,0x80,0x82,0x7c,
+};
+
+static const BitmapCharRec ch67 = {7,10,-1,0,9,ch67data};
+
+/* char: 0x42 'B' */
+
+static const GLubyte ch66data[] = {
+0xfc,0x42,0x42,0x42,0x42,0x7c,0x42,0x42,0x42,0xfc,
+};
+
+static const BitmapCharRec ch66 = {7,10,-1,0,9,ch66data};
+
+/* char: 0x41 'A' */
+
+static const GLubyte ch65data[] = {
+0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x44,0x28,0x10,
+};
+
+static const BitmapCharRec ch65 = {7,10,-1,0,9,ch65data};
+
+/* char: 0x40 '@' */
+
+static const GLubyte ch64data[] = {
+0x7c,0x80,0x80,0x9a,0xa6,0xa2,0x9e,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch64 = {7,10,-1,0,9,ch64data};
+
+/* char: 0x3f '?' */
+
+static const GLubyte ch63data[] = {
+0x10,0x0,0x10,0x10,0x8,0x4,0x2,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch63 = {7,10,-1,0,9,ch63data};
+
+/* char: 0x3e '>' */
+
+static const GLubyte ch62data[] = {
+0x80,0x40,0x20,0x10,0x8,0x8,0x10,0x20,0x40,0x80,
+};
+
+static const BitmapCharRec ch62 = {5,10,-2,0,9,ch62data};
+
+/* char: 0x3d '=' */
+
+static const GLubyte ch61data[] = {
+0xfe,0x0,0x0,0xfe,
+};
+
+static const BitmapCharRec ch61 = {7,4,-1,-2,9,ch61data};
+
+/* char: 0x3c '<' */
+
+static const GLubyte ch60data[] = {
+0x8,0x10,0x20,0x40,0x80,0x80,0x40,0x20,0x10,0x8,
+};
+
+static const BitmapCharRec ch60 = {5,10,-2,0,9,ch60data};
+
+/* char: 0x3b ';' */
+
+static const GLubyte ch59data[] = {
+0x80,0x40,0x40,0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch59 = {2,10,-4,3,9,ch59data};
+
+/* char: 0x3a ':' */
+
+static const GLubyte ch58data[] = {
+0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch58 = {2,7,-4,0,9,ch58data};
+
+/* char: 0x39 '9' */
+
+static const GLubyte ch57data[] = {
+0x78,0x4,0x2,0x2,0x7a,0x86,0x82,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch57 = {7,10,-1,0,9,ch57data};
+
+/* char: 0x38 '8' */
+
+static const GLubyte ch56data[] = {
+0x38,0x44,0x82,0x82,0x44,0x38,0x44,0x82,0x44,0x38,
+};
+
+static const BitmapCharRec ch56 = {7,10,-1,0,9,ch56data};
+
+/* char: 0x37 '7' */
+
+static const GLubyte ch55data[] = {
+0x40,0x40,0x20,0x20,0x10,0x8,0x4,0x2,0x2,0xfe,
+};
+
+static const BitmapCharRec ch55 = {7,10,-1,0,9,ch55data};
+
+/* char: 0x36 '6' */
+
+static const GLubyte ch54data[] = {
+0x7c,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x40,0x3c,
+};
+
+static const BitmapCharRec ch54 = {7,10,-1,0,9,ch54data};
+
+/* char: 0x35 '5' */
+
+static const GLubyte ch53data[] = {
+0x7c,0x82,0x2,0x2,0x2,0xc2,0xbc,0x80,0x80,0xfe,
+};
+
+static const BitmapCharRec ch53 = {7,10,-1,0,9,ch53data};
+
+/* char: 0x34 '4' */
+
+static const GLubyte ch52data[] = {
+0x4,0x4,0x4,0xfe,0x84,0x44,0x24,0x14,0xc,0x4,
+};
+
+static const BitmapCharRec ch52 = {7,10,-1,0,9,ch52data};
+
+/* char: 0x33 '3' */
+
+static const GLubyte ch51data[] = {
+0x7c,0x82,0x2,0x2,0x2,0x1c,0x8,0x4,0x2,0xfe,
+};
+
+static const BitmapCharRec ch51 = {7,10,-1,0,9,ch51data};
+
+/* char: 0x32 '2' */
+
+static const GLubyte ch50data[] = {
+0xfe,0x80,0x40,0x30,0x8,0x4,0x2,0x82,0x82,0x7c,
+};
+
+static const BitmapCharRec ch50 = {7,10,-1,0,9,ch50data};
+
+/* char: 0x31 '1' */
+
+static const GLubyte ch49data[] = {
+0xfe,0x10,0x10,0x10,0x10,0x10,0x90,0x50,0x30,0x10,
+};
+
+static const BitmapCharRec ch49 = {7,10,-1,0,9,ch49data};
+
+/* char: 0x30 '0' */
+
+static const GLubyte ch48data[] = {
+0x38,0x44,0x82,0x82,0x82,0x82,0x82,0x82,0x44,0x38,
+};
+
+static const BitmapCharRec ch48 = {7,10,-1,0,9,ch48data};
+
+/* char: 0x2f '/' */
+
+static const GLubyte ch47data[] = {
+0x80,0x40,0x40,0x20,0x10,0x10,0x8,0x4,0x4,0x2,
+};
+
+static const BitmapCharRec ch47 = {7,10,-1,0,9,ch47data};
+
+/* char: 0x2e '.' */
+
+static const GLubyte ch46data[] = {
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch46 = {2,2,-4,0,9,ch46data};
+
+/* char: 0x2d '-' */
+
+static const GLubyte ch45data[] = {
+0xfe,
+};
+
+static const BitmapCharRec ch45 = {7,1,-1,-4,9,ch45data};
+
+/* char: 0x2c ',' */
+
+static const GLubyte ch44data[] = {
+0x80,0x40,0x40,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch44 = {2,5,-4,3,9,ch44data};
+
+/* char: 0x2b '+' */
+
+static const GLubyte ch43data[] = {
+0x10,0x10,0x10,0xfe,0x10,0x10,0x10,
+};
+
+static const BitmapCharRec ch43 = {7,7,-1,-1,9,ch43data};
+
+/* char: 0x2a '*' */
+
+static const GLubyte ch42data[] = {
+0x10,0x92,0x54,0x38,0x54,0x92,0x10,
+};
+
+static const BitmapCharRec ch42 = {7,7,-1,-1,9,ch42data};
+
+/* char: 0x29 ')' */
+
+static const GLubyte ch41data[] = {
+0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch41 = {3,12,-3,1,9,ch41data};
+
+/* char: 0x28 '(' */
+
+static const GLubyte ch40data[] = {
+0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
+};
+
+static const BitmapCharRec ch40 = {3,12,-3,1,9,ch40data};
+
+/* char: 0x27 ''' */
+
+static const GLubyte ch39data[] = {
+0x80,0x40,0x20,0x30,
+};
+
+static const BitmapCharRec ch39 = {4,4,-3,-6,9,ch39data};
+
+/* char: 0x26 '&' */
+
+static const GLubyte ch38data[] = {
+0x62,0x94,0x88,0x94,0x62,0x60,0x90,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch38 = {7,10,-1,0,9,ch38data};
+
+/* char: 0x25 '%' */
+
+static const GLubyte ch37data[] = {
+0x84,0x4a,0x4a,0x24,0x10,0x10,0x48,0xa4,0xa4,0x42,
+};
+
+static const BitmapCharRec ch37 = {7,10,-1,0,9,ch37data};
+
+/* char: 0x24 '$' */
+
+static const GLubyte ch36data[] = {
+0x10,0x7c,0x92,0x12,0x12,0x14,0x38,0x50,0x90,0x92,0x7c,0x10,
+};
+
+static const BitmapCharRec ch36 = {7,12,-1,1,9,ch36data};
+
+/* char: 0x23 '#' */
+
+static const GLubyte ch35data[] = {
+0x48,0x48,0xfc,0x48,0x48,0xfc,0x48,0x48,
+};
+
+static const BitmapCharRec ch35 = {6,8,-1,-1,9,ch35data};
+
+/* char: 0x22 '"' */
+
+static const GLubyte ch34data[] = {
+0x90,0x90,0x90,
+};
+
+static const BitmapCharRec ch34 = {4,3,-3,-7,9,ch34data};
+
+/* char: 0x21 '!' */
+
+static const GLubyte ch33data[] = {
+0x80,0x80,0x0,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch33 = {1,11,-4,0,9,ch33data};
+
+/* char: 0x1f */
+
+static const GLubyte ch31data[] = {
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch31 = {2,2,-4,-2,9,ch31data};
+
+/* char: 0x1e */
+
+static const GLubyte ch30data[] = {
+0x5c,0xa2,0x60,0x20,0x20,0xf8,0x20,0x20,0x22,0x1c,
+};
+
+static const BitmapCharRec ch30 = {7,10,-1,0,9,ch30data};
+
+/* char: 0x1d */
+
+static const GLubyte ch29data[] = {
+0x80,0x40,0xfe,0x10,0xfe,0x4,0x2,
+};
+
+static const BitmapCharRec ch29 = {7,7,-1,0,9,ch29data};
+
+/* char: 0x1c */
+
+static const GLubyte ch28data[] = {
+0x44,0x24,0x24,0x24,0x24,0x24,0xfe,
+};
+
+static const BitmapCharRec ch28 = {7,7,-1,0,9,ch28data};
+
+/* char: 0x1b */
+
+static const GLubyte ch27data[] = {
+0xfe,0x0,0x80,0x40,0x20,0x10,0x8,0x8,0x10,0x20,0x40,0x80,
+};
+
+static const BitmapCharRec ch27 = {7,12,-1,2,9,ch27data};
+
+/* char: 0x1a */
+
+static const GLubyte ch26data[] = {
+0xfc,0x0,0x4,0x8,0x10,0x20,0x40,0x40,0x20,0x10,0x8,0x4,
+};
+
+static const BitmapCharRec ch26 = {6,12,-2,2,9,ch26data};
+
+/* char: 0x19 */
+
+static const GLubyte ch25data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch25 = {1,15,-4,3,9,ch25data};
+
+/* char: 0x18 */
+
+static const GLubyte ch24data[] = {
+0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xff,0x80,
+};
+
+static const BitmapCharRec ch24 = {9,7,0,3,9,ch24data};
+
+/* char: 0x17 */
+
+static const GLubyte ch23data[] = {
+0xff,0x80,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,
+0x8,0x0,
+};
+
+static const BitmapCharRec ch23 = {9,9,0,-3,9,ch23data};
+
+/* char: 0x16 */
+
+static const GLubyte ch22data[] = {
+0x8,0x8,0x8,0x8,0x8,0x8,0xf8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,
+};
+
+static const BitmapCharRec ch22 = {5,15,0,3,9,ch22data};
+
+/* char: 0x15 */
+
+static const GLubyte ch21data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch21 = {5,15,-4,3,9,ch21data};
+
+/* char: 0x14 */
+
+static const GLubyte ch20data[] = {
+0xff,0x80,
+};
+
+static const BitmapCharRec ch20 = {9,1,0,1,9,ch20data};
+
+/* char: 0x13 */
+
+static const GLubyte ch19data[] = {
+0xff,0x80,
+};
+
+static const BitmapCharRec ch19 = {9,1,0,-1,9,ch19data};
+
+/* char: 0x12 */
+
+static const GLubyte ch18data[] = {
+0xff,0x80,
+};
+
+static const BitmapCharRec ch18 = {9,1,0,-3,9,ch18data};
+
+/* char: 0x11 */
+
+static const GLubyte ch17data[] = {
+0xff,0x80,
+};
+
+static const BitmapCharRec ch17 = {9,1,0,-5,9,ch17data};
+
+/* char: 0x10 */
+
+static const GLubyte ch16data[] = {
+0xff,0x80,
+};
+
+static const BitmapCharRec ch16 = {9,1,0,-7,9,ch16data};
+
+/* char: 0xf */
+
+static const GLubyte ch15data[] = {
+0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xff,0x80,0x8,0x0,
+0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,
+};
+
+static const BitmapCharRec ch15 = {9,15,0,3,9,ch15data};
+
+/* char: 0xe */
+
+static const GLubyte ch14data[] = {
+0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch14 = {5,9,-4,-3,9,ch14data};
+
+/* char: 0xd */
+
+static const GLubyte ch13data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0xf8,
+};
+
+static const BitmapCharRec ch13 = {5,7,-4,3,9,ch13data};
+
+/* char: 0xc */
+
+static const GLubyte ch12data[] = {
+0x8,0x8,0x8,0x8,0x8,0x8,0xf8,
+};
+
+static const BitmapCharRec ch12 = {5,7,0,3,9,ch12data};
+
+/* char: 0xb */
+
+static const GLubyte ch11data[] = {
+0xf8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,
+};
+
+static const BitmapCharRec ch11 = {5,9,0,-3,9,ch11data};
+
+/* char: 0xa */
+
+static const GLubyte ch10data[] = {
+0x8,0x8,0x8,0x8,0x3e,0x0,0x20,0x50,0x88,0x88,
+};
+
+static const BitmapCharRec ch10 = {7,10,-1,2,9,ch10data};
+
+/* char: 0x9 */
+
+static const GLubyte ch9data[] = {
+0x3e,0x20,0x20,0x20,0x20,0x88,0x98,0xa8,0xc8,0x88,
+};
+
+static const BitmapCharRec ch9 = {7,10,-1,2,9,ch9data};
+
+/* char: 0x8 */
+
+static const GLubyte ch8data[] = {
+0xfe,0x10,0x10,0xfe,0x10,0x10,
+};
+
+static const BitmapCharRec ch8 = {7,6,-1,0,9,ch8data};
+
+/* char: 0x7 */
+
+static const GLubyte ch7data[] = {
+0x70,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch7 = {5,4,-2,-6,9,ch7data};
+
+/* char: 0x6 */
+
+static const GLubyte ch6data[] = {
+0x20,0x20,0x3c,0x20,0x3e,0x0,0xf8,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch6 = {7,10,-1,2,9,ch6data};
+
+/* char: 0x5 */
+
+static const GLubyte ch5data[] = {
+0x22,0x22,0x3c,0x22,0x3c,0x0,0x78,0x80,0x80,0x78,
+};
+
+static const BitmapCharRec ch5 = {7,10,-1,2,9,ch5data};
+
+/* char: 0x4 */
+
+static const GLubyte ch4data[] = {
+0x10,0x10,0x1c,0x10,0x1e,0x80,0x80,0xe0,0x80,0xf0,
+};
+
+static const BitmapCharRec ch4 = {7,10,-1,2,9,ch4data};
+
+/* char: 0x3 */
+
+static const GLubyte ch3data[] = {
+0x8,0x8,0x8,0x3e,0x0,0x88,0x88,0xf8,0x88,0x88,
+};
+
+static const BitmapCharRec ch3 = {7,10,-1,2,9,ch3data};
+
+/* char: 0x2 */
+
+static const GLubyte ch2data[] = {
+0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,
+};
+
+static const BitmapCharRec ch2 = {8,14,0,3,9,ch2data};
+
+/* char: 0x1 */
+
+static const GLubyte ch1data[] = {
+0x10,0x38,0x7c,0xfe,0x7c,0x38,0x10,
+};
+
+static const BitmapCharRec ch1 = {7,7,-1,0,9,ch1data};
+
+static const BitmapCharRec * const chars[] = {
+&ch0,
+&ch1,
+&ch2,
+&ch3,
+&ch4,
+&ch5,
+&ch6,
+&ch7,
+&ch8,
+&ch9,
+&ch10,
+&ch11,
+&ch12,
+&ch13,
+&ch14,
+&ch15,
+&ch16,
+&ch17,
+&ch18,
+&ch19,
+&ch20,
+&ch21,
+&ch22,
+&ch23,
+&ch24,
+&ch25,
+&ch26,
+&ch27,
+&ch28,
+&ch29,
+&ch30,
+&ch31,
+&ch32,
+&ch33,
+&ch34,
+&ch35,
+&ch36,
+&ch37,
+&ch38,
+&ch39,
+&ch40,
+&ch41,
+&ch42,
+&ch43,
+&ch44,
+&ch45,
+&ch46,
+&ch47,
+&ch48,
+&ch49,
+&ch50,
+&ch51,
+&ch52,
+&ch53,
+&ch54,
+&ch55,
+&ch56,
+&ch57,
+&ch58,
+&ch59,
+&ch60,
+&ch61,
+&ch62,
+&ch63,
+&ch64,
+&ch65,
+&ch66,
+&ch67,
+&ch68,
+&ch69,
+&ch70,
+&ch71,
+&ch72,
+&ch73,
+&ch74,
+&ch75,
+&ch76,
+&ch77,
+&ch78,
+&ch79,
+&ch80,
+&ch81,
+&ch82,
+&ch83,
+&ch84,
+&ch85,
+&ch86,
+&ch87,
+&ch88,
+&ch89,
+&ch90,
+&ch91,
+&ch92,
+&ch93,
+&ch94,
+&ch95,
+&ch96,
+&ch97,
+&ch98,
+&ch99,
+&ch100,
+&ch101,
+&ch102,
+&ch103,
+&ch104,
+&ch105,
+&ch106,
+&ch107,
+&ch108,
+&ch109,
+&ch110,
+&ch111,
+&ch112,
+&ch113,
+&ch114,
+&ch115,
+&ch116,
+&ch117,
+&ch118,
+&ch119,
+&ch120,
+&ch121,
+&ch122,
+&ch123,
+&ch124,
+&ch125,
+&ch126,
+&ch127,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+&ch160,
+&ch161,
+&ch162,
+&ch163,
+&ch164,
+&ch165,
+&ch166,
+&ch167,
+&ch168,
+&ch169,
+&ch170,
+&ch171,
+&ch172,
+&ch173,
+&ch174,
+&ch175,
+&ch176,
+&ch177,
+&ch178,
+&ch179,
+&ch180,
+&ch181,
+&ch182,
+&ch183,
+&ch184,
+&ch185,
+&ch186,
+&ch187,
+&ch188,
+&ch189,
+&ch190,
+&ch191,
+&ch192,
+&ch193,
+&ch194,
+&ch195,
+&ch196,
+&ch197,
+&ch198,
+&ch199,
+&ch200,
+&ch201,
+&ch202,
+&ch203,
+&ch204,
+&ch205,
+&ch206,
+&ch207,
+&ch208,
+&ch209,
+&ch210,
+&ch211,
+&ch212,
+&ch213,
+&ch214,
+&ch215,
+&ch216,
+&ch217,
+&ch218,
+&ch219,
+&ch220,
+&ch221,
+&ch222,
+&ch223,
+&ch224,
+&ch225,
+&ch226,
+&ch227,
+&ch228,
+&ch229,
+&ch230,
+&ch231,
+&ch232,
+&ch233,
+&ch234,
+&ch235,
+&ch236,
+&ch237,
+&ch238,
+&ch239,
+&ch240,
+&ch241,
+&ch242,
+&ch243,
+&ch244,
+&ch245,
+&ch246,
+&ch247,
+&ch248,
+&ch249,
+&ch250,
+&ch251,
+&ch252,
+&ch253,
+&ch254,
+&ch255,
+};
+
+const BitmapFontRec glutBitmap9By15 = {
+"-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1",
+256,
+0,
+chars
+};
+
diff --git a/src/glut/glx/glut_bitmap.c b/src/glut/glx/glut_bitmap.c
new file mode 100644
index 0000000000..f1afdd7a04
--- /dev/null
+++ b/src/glut/glx/glut_bitmap.c
@@ -0,0 +1,57 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 "glutint.h"
+#include "glutbitmap.h"
+
+void APIENTRY 
+glutBitmapCharacter(GLUTbitmapFont font, int c)
+{
+  const BitmapCharRec *ch;
+  BitmapFontPtr fontinfo;
+  GLint swapbytes, lsbfirst, rowlength;
+  GLint skiprows, skippixels, alignment;
+
+#if defined(_WIN32)
+  fontinfo = (BitmapFontPtr) __glutFont(font);
+#else
+  fontinfo = (BitmapFontPtr) font;
+#endif
+
+  if (c < fontinfo->first ||
+    c >= fontinfo->first + fontinfo->num_chars)
+    return;
+  ch = fontinfo->ch[c - fontinfo->first];
+  if (ch) {
+    /* Save current modes. */
+    glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes);
+    glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst);
+    glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength);
+    glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows);
+    glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);
+    glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
+    /* Little endian machines (DEC Alpha for example) could
+       benefit from setting GL_UNPACK_LSB_FIRST to GL_TRUE
+       instead of GL_FALSE, but this would require changing the
+       generated bitmaps too. */
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glBitmap(ch->width, ch->height, ch->xorig, ch->yorig,
+      ch->advance, 0, ch->bitmap);
+    /* Restore saved modes. */
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
+  }
+}
diff --git a/src/glut/glx/glut_bwidth.c b/src/glut/glx/glut_bwidth.c
new file mode 100644
index 0000000000..bee5e8827e
--- /dev/null
+++ b/src/glut/glx/glut_bwidth.c
@@ -0,0 +1,58 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 "glutint.h"
+#include "glutbitmap.h"
+
+/* CENTRY */
+int APIENTRY 
+glutBitmapWidth(GLUTbitmapFont font, int c)
+{
+  BitmapFontPtr fontinfo;
+  const BitmapCharRec *ch;
+
+#ifdef _WIN32
+  fontinfo = (BitmapFontPtr) __glutFont(font);
+#else
+  fontinfo = (BitmapFontPtr) font;
+#endif
+
+  if (c < fontinfo->first || c >= fontinfo->first + fontinfo->num_chars)
+    return 0;
+  ch = fontinfo->ch[c - fontinfo->first];
+  if (ch)
+    return ch->advance;
+  else
+    return 0;
+}
+
+int APIENTRY 
+glutBitmapLength(GLUTbitmapFont font, const unsigned char *string)
+{
+  int c, length;
+  BitmapFontPtr fontinfo;
+  const BitmapCharRec *ch;
+
+#ifdef _WIN32
+  fontinfo = (BitmapFontPtr) __glutFont(font);
+#else
+  fontinfo = (BitmapFontPtr) font;
+#endif
+
+  length = 0;
+  for (; *string != '\0'; string++) {
+    c = *string;
+    if (c >= fontinfo->first && c < fontinfo->first + fontinfo->num_chars) {
+      ch = fontinfo->ch[c - fontinfo->first];
+      if (ch)
+        length += ch->advance;
+    }
+  }
+  return length;
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_cindex.c b/src/glut/glx/glut_cindex.c
new file mode 100644
index 0000000000..c47b21ea79
--- /dev/null
+++ b/src/glut/glx/glut_cindex.c
@@ -0,0 +1,252 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994, 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 "glutint.h"
+
+#define CLAMP(i) ((i) > 1.0 ? 1.0 : ((i) < 0.0 ? 0.0 : (i)))
+
+/* CENTRY */
+void APIENTRY
+glutSetColor(int ndx, GLfloat red, GLfloat green, GLfloat blue)
+{
+  GLUTcolormap *cmap, *newcmap;
+  XVisualInfo *vis;
+  XColor color;
+  int i;
+
+  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
+    cmap = __glutCurrentWindow->colormap;
+    vis = __glutCurrentWindow->vis;
+  } else {
+    cmap = __glutCurrentWindow->overlay->colormap;
+    vis = __glutCurrentWindow->overlay->vis;
+    if (ndx == __glutCurrentWindow->overlay->transparentPixel) {
+      __glutWarning(
+        "glutSetColor: cannot set color of overlay transparent index %d\n",
+        ndx);
+      return;
+    }
+  }
+
+  if (!cmap) {
+    __glutWarning("glutSetColor: current window is RGBA");
+    return;
+  }
+#if defined(_WIN32)
+  if (ndx >= 256 ||     /* always assume 256 colors on Win32 */
+#else
+  if (ndx >= vis->visual->map_entries ||
+#endif
+    ndx < 0) {
+    __glutWarning("glutSetColor: index %d out of range", ndx);
+    return;
+  }
+  if (cmap->refcnt > 1) {
+    newcmap = __glutAssociateNewColormap(vis);
+    cmap->refcnt--;
+    /* Wouldn't it be nice if XCopyColormapAndFree could be
+       told not to free the old colormap's entries! */
+    for (i = cmap->size - 1; i >= 0; i--) {
+      if (i == ndx) {
+        /* We are going to set this cell shortly! */
+        continue;
+      }
+      if (cmap->cells[i].component[GLUT_RED] >= 0.0) {
+        color.pixel = i;
+        newcmap->cells[i].component[GLUT_RED] =
+          cmap->cells[i].component[GLUT_RED];
+        color.red = (GLfloat) 0xffff *
+          cmap->cells[i].component[GLUT_RED];
+        newcmap->cells[i].component[GLUT_GREEN] =
+          cmap->cells[i].component[GLUT_GREEN];
+        color.green = (GLfloat) 0xffff *
+          cmap->cells[i].component[GLUT_GREEN];
+        newcmap->cells[i].component[GLUT_BLUE] =
+          cmap->cells[i].component[GLUT_BLUE];
+        color.blue = (GLfloat) 0xffff *
+          cmap->cells[i].component[GLUT_BLUE];
+        color.flags = DoRed | DoGreen | DoBlue;
+#if defined(_WIN32)
+        if (IsWindowVisible(__glutCurrentWindow->win)) {
+          XHDC = __glutCurrentWindow->hdc;
+        } else {
+          XHDC = 0;
+        }
+#endif
+        XStoreColor(__glutDisplay, newcmap->cmap, &color);
+      } else {
+        /* Leave unallocated entries unallocated. */
+      }
+    }
+    cmap = newcmap;
+    if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
+      __glutCurrentWindow->colormap = cmap;
+      __glutCurrentWindow->cmap = cmap->cmap;
+    } else {
+      __glutCurrentWindow->overlay->colormap = cmap;
+      __glutCurrentWindow->overlay->cmap = cmap->cmap;
+    }
+    XSetWindowColormap(__glutDisplay,
+      __glutCurrentWindow->renderWin, cmap->cmap);
+
+#if !defined(_WIN32)
+    {
+      GLUTwindow *toplevel;
+
+      toplevel = __glutToplevelOf(__glutCurrentWindow);
+      if (toplevel->cmap != cmap->cmap) {
+        __glutPutOnWorkList(toplevel, GLUT_COLORMAP_WORK);
+      }
+    }
+#endif
+  }
+  color.pixel = ndx;
+  red = CLAMP(red);
+  cmap->cells[ndx].component[GLUT_RED] = red;
+  color.red = (GLfloat) 0xffff *red;
+  green = CLAMP(green);
+  cmap->cells[ndx].component[GLUT_GREEN] = green;
+  color.green = (GLfloat) 0xffff *green;
+  blue = CLAMP(blue);
+  cmap->cells[ndx].component[GLUT_BLUE] = blue;
+  color.blue = (GLfloat) 0xffff *blue;
+  color.flags = DoRed | DoGreen | DoBlue;
+#if defined(_WIN32)
+  if (IsWindowVisible(__glutCurrentWindow->win)) {
+    XHDC = __glutCurrentWindow->hdc;
+  } else {
+    XHDC = 0;
+  }
+#endif
+  XStoreColor(__glutDisplay, cmap->cmap, &color);
+}
+
+GLfloat APIENTRY
+glutGetColor(int ndx, int comp)
+{
+  GLUTcolormap *colormap;
+  XVisualInfo *vis;
+
+  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
+    colormap = __glutCurrentWindow->colormap;
+    vis = __glutCurrentWindow->vis;
+  } else {
+    colormap = __glutCurrentWindow->overlay->colormap;
+    vis = __glutCurrentWindow->overlay->vis;
+    if (ndx == __glutCurrentWindow->overlay->transparentPixel) {
+      __glutWarning("glutGetColor: requesting overlay transparent index %d\n",
+        ndx);
+      return -1.0;
+    }
+  }
+
+  if (!colormap) {
+    __glutWarning("glutGetColor: current window is RGBA");
+    return -1.0;
+  }
+#if defined(_WIN32)
+#define OUT_OF_RANGE_NDX(ndx) (ndx >= 256 || ndx < 0)
+#else
+#define OUT_OF_RANGE_NDX(ndx) (ndx >= vis->visual->map_entries || ndx < 0)
+#endif
+  if (OUT_OF_RANGE_NDX(ndx)) {
+    __glutWarning("glutGetColor: index %d out of range", ndx);
+    return -1.0;
+  }
+  return colormap->cells[ndx].component[comp];
+}
+
+void APIENTRY
+glutCopyColormap(int winnum)
+{
+  GLUTwindow *window = __glutWindowList[winnum - 1];
+  GLUTcolormap *oldcmap, *newcmap;
+  XVisualInfo *dstvis;
+
+  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
+    oldcmap = __glutCurrentWindow->colormap;
+    dstvis = __glutCurrentWindow->vis;
+    newcmap = window->colormap;
+  } else {
+    oldcmap = __glutCurrentWindow->overlay->colormap;
+    dstvis = __glutCurrentWindow->overlay->vis;
+    if (!window->overlay) {
+      __glutWarning("glutCopyColormap: window %d has no overlay", winnum);
+      return;
+    }
+    newcmap = window->overlay->colormap;
+  }
+
+  if (!oldcmap) {
+    __glutWarning("glutCopyColormap: destination colormap must be color index");
+    return;
+  }
+  if (!newcmap) {
+    __glutWarning(
+      "glutCopyColormap: source colormap of window %d must be color index",
+      winnum);
+    return;
+  }
+  if (newcmap == oldcmap) {
+    /* Source and destination are the same; now copy needed. */
+    return;
+  }
+#if !defined(_WIN32)
+  /* Play safe: compare visual IDs, not Visual*'s. */
+  if (newcmap->visual->visualid == oldcmap->visual->visualid) {
+#endif
+    /* Visuals match!  "Copy" by reference...  */
+    __glutFreeColormap(oldcmap);
+    newcmap->refcnt++;
+    if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
+      __glutCurrentWindow->colormap = newcmap;
+      __glutCurrentWindow->cmap = newcmap->cmap;
+    } else {
+      __glutCurrentWindow->overlay->colormap = newcmap;
+      __glutCurrentWindow->overlay->cmap = newcmap->cmap;
+    }
+    XSetWindowColormap(__glutDisplay, __glutCurrentWindow->renderWin,
+      newcmap->cmap);
+#if !defined(_WIN32)
+    __glutPutOnWorkList(__glutToplevelOf(window), GLUT_COLORMAP_WORK);
+  } else {
+    GLUTcolormap *copycmap;
+    XColor color;
+    int i, last;
+
+    /* Visuals different - need a distinct X colormap! */
+    copycmap = __glutAssociateNewColormap(dstvis);
+    /* Wouldn't it be nice if XCopyColormapAndFree could be
+       told not to free the old colormap's entries! */
+    last = newcmap->size;
+    if (last > copycmap->size) {
+      last = copycmap->size;
+    }
+    for (i = last - 1; i >= 0; i--) {
+      if (newcmap->cells[i].component[GLUT_RED] >= 0.0) {
+        color.pixel = i;
+        copycmap->cells[i].component[GLUT_RED] =
+          newcmap->cells[i].component[GLUT_RED];
+        color.red = (GLfloat) 0xffff *
+          newcmap->cells[i].component[GLUT_RED];
+        copycmap->cells[i].component[GLUT_GREEN] =
+          newcmap->cells[i].component[GLUT_GREEN];
+        color.green = (GLfloat) 0xffff *
+          newcmap->cells[i].component[GLUT_GREEN];
+        copycmap->cells[i].component[GLUT_BLUE] =
+          newcmap->cells[i].component[GLUT_BLUE];
+        color.blue = (GLfloat) 0xffff *
+          newcmap->cells[i].component[GLUT_BLUE];
+        color.flags = DoRed | DoGreen | DoBlue;
+        XStoreColor(__glutDisplay, copycmap->cmap, &color);
+      }
+    }
+  }
+#endif
+}
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_cmap.c b/src/glut/glx/glut_cmap.c
new file mode 100644
index 0000000000..a9d004003f
--- /dev/null
+++ b/src/glut/glx/glut_cmap.c
@@ -0,0 +1,395 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994, 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 <string.h>
+#include <stdio.h>  /* SunOS multithreaded assert() needs <stdio.h>.  Lame. */
+#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
+
+/* SGI optimization introduced in IRIX 6.3 to avoid X server
+   round trips for interning common X atoms. */
+#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
+#include <X11/SGIFastAtom.h>
+#else
+#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
+#endif
+
+#include "glutint.h"
+#include "layerutil.h"
+
+GLUTcolormap *__glutColormapList = NULL;
+
+GLUTcolormap *
+__glutAssociateNewColormap(XVisualInfo * vis)
+{
+  GLUTcolormap *cmap;
+  int transparentPixel, i;
+  unsigned long pixels[255];
+
+  cmap = (GLUTcolormap *) malloc(sizeof(GLUTcolormap));
+  if (!cmap)
+    __glutFatalError("out of memory.");
+#if defined(_WIN32)
+  pixels[0] = 0;        /* avoid compilation warnings on win32 */
+  cmap->visual = 0;
+  cmap->size = 256;     /* always assume 256 on Win32 */
+#else
+  cmap->visual = vis->visual;
+  cmap->size = vis->visual->map_entries;
+#endif
+  cmap->refcnt = 1;
+  cmap->cells = (GLUTcolorcell *)
+    malloc(sizeof(GLUTcolorcell) * cmap->size);
+  if (!cmap->cells)
+    __glutFatalError("out of memory.");
+  /* make all color cell entries be invalid */
+  for (i = cmap->size - 1; i >= 0; i--) {
+    cmap->cells[i].component[GLUT_RED] = -1.0;
+    cmap->cells[i].component[GLUT_GREEN] = -1.0;
+    cmap->cells[i].component[GLUT_BLUE] = -1.0;
+  }
+  transparentPixel = __glutGetTransparentPixel(__glutDisplay, vis);
+  if (transparentPixel == -1 || transparentPixel >= cmap->size) {
+
+    /* If there is no transparent pixel or if the transparent
+       pixel is outside the range of valid colormap cells (HP
+       can implement their overlays this smart way since their
+       transparent pixel is 255), we can AllocAll the colormap.
+       See note below.  */
+
+    cmap->cmap = XCreateColormap(__glutDisplay,
+      __glutRoot, cmap->visual, AllocAll);
+  } else {
+
+    /* On machines where zero (or some other value in the range
+       of 0 through map_entries-1), BadAlloc may be generated
+       when an AllocAll overlay colormap is allocated since the
+       transparent pixel precludes all the cells in the colormap
+       being allocated (the transparent pixel is pre-allocated).
+       So in this case, use XAllocColorCells to allocate
+       map_entries-1 pixels (that is, all but the transparent
+       pixel.  */
+
+#if defined(_WIN32)
+    cmap->cmap = XCreateColormap(__glutDisplay,
+      __glutRoot, 0, AllocNone);
+#else
+    cmap->cmap = XCreateColormap(__glutDisplay,
+      __glutRoot, vis->visual, AllocNone);
+    XAllocColorCells(__glutDisplay, cmap->cmap, False, 0, 0,
+      pixels, cmap->size - 1);
+#endif
+  }
+  cmap->next = __glutColormapList;
+  __glutColormapList = cmap;
+  return cmap;
+}
+
+static GLUTcolormap *
+associateColormap(XVisualInfo * vis)
+{
+#if !defined(_WIN32)
+  GLUTcolormap *cmap = __glutColormapList;
+
+  while (cmap != NULL) {
+    /* Play safe: compare visual IDs, not Visual*'s. */
+    if (cmap->visual->visualid == vis->visual->visualid) {
+      /* Already have created colormap for the visual. */
+      cmap->refcnt++;
+      return cmap;
+    }
+    cmap = cmap->next;
+  }
+#endif
+  return __glutAssociateNewColormap(vis);
+}
+
+void
+__glutSetupColormap(XVisualInfo * vi, GLUTcolormap ** colormap, Colormap * cmap)
+{
+#if defined(_WIN32)
+  if (vi->dwFlags & PFD_NEED_PALETTE || vi->iPixelType == PFD_TYPE_COLORINDEX) {
+    *colormap = associateColormap(vi);
+    *cmap = (*colormap)->cmap;
+  } else {
+    *colormap = NULL;
+    *cmap = 0;
+  }
+#else
+  Status status;
+  XStandardColormap *standardCmaps;
+  int i, numCmaps;
+  static Atom hpColorRecoveryAtom = -1;
+  int isRGB, visualClass, rc;
+
+#if defined(__cplusplus) || defined(c_plusplus)
+  visualClass = vi->c_class;
+#else
+  visualClass = vi->class;
+#endif
+  switch (visualClass) {
+  case PseudoColor:
+    /* Mesa might return a PseudoColor visual for RGB mode. */
+    rc = glXGetConfig(__glutDisplay, vi, GLX_RGBA, &isRGB);
+    if (rc == 0 && isRGB) {
+      /* Must be Mesa. */
+      *colormap = NULL;
+      if (MaxCmapsOfScreen(DefaultScreenOfDisplay(__glutDisplay)) == 1
+        && vi->visual == DefaultVisual(__glutDisplay, __glutScreen)) {
+        char *privateCmap = getenv("MESA_PRIVATE_CMAP");
+
+        if (privateCmap) {
+          /* User doesn't want to share colormaps. */
+          *cmap = XCreateColormap(__glutDisplay, __glutRoot,
+            vi->visual, AllocNone);
+        } else {
+          /* Share the root colormap. */
+          *cmap = DefaultColormap(__glutDisplay, __glutScreen);
+        }
+      } else {
+        /* Get our own PseudoColor colormap. */
+        *cmap = XCreateColormap(__glutDisplay, __glutRoot,
+          vi->visual, AllocNone);
+      }
+    } else {
+      /* CI mode, real GLX never returns a PseudoColor visual
+         for RGB mode. */
+      *colormap = associateColormap(vi);
+      *cmap = (*colormap)->cmap;
+    }
+    break;
+  case TrueColor:
+  case DirectColor:
+    *colormap = NULL;   /* NULL if RGBA */
+
+    /* Hewlett-Packard supports a feature called "HP Color
+       Recovery". Mesa has code to use HP Color Recovery.  For
+       Mesa to use this feature, the atom
+       _HP_RGB_SMOOTH_MAP_LIST must be defined on the root
+       window AND the colormap obtainable by XGetRGBColormaps
+       for that atom must be set on the window.  If that
+       colormap is not set, the output will look stripy. */
+
+    if (hpColorRecoveryAtom == -1) {
+      char *xvendor;
+
+#define VENDOR_HP "Hewlett-Packard"
+
+      /* Only makes sense to make XInternAtom round-trip if we
+         know that we are connected to an HP X server. */
+      xvendor = ServerVendor(__glutDisplay);
+      if (!strncmp(xvendor, VENDOR_HP, sizeof(VENDOR_HP) - 1)) {
+        hpColorRecoveryAtom = XInternAtom(__glutDisplay, "_HP_RGB_SMOOTH_MAP_LIST", True);
+      } else {
+        hpColorRecoveryAtom = None;
+      }
+    }
+    if (hpColorRecoveryAtom != None) {
+      status = XGetRGBColormaps(__glutDisplay, __glutRoot,
+        &standardCmaps, &numCmaps, hpColorRecoveryAtom);
+      if (status == 1) {
+        for (i = 0; i < numCmaps; i++) {
+          if (standardCmaps[i].visualid == vi->visualid) {
+            *cmap = standardCmaps[i].colormap;
+            XFree(standardCmaps);
+            return;
+          }
+        }
+        XFree(standardCmaps);
+      }
+    }
+#ifndef SOLARIS_2_4_BUG
+    /* Solaris 2.4 and 2.5 have a bug in their
+       XmuLookupStandardColormap implementations.  Please
+       compile your Solaris 2.4 or 2.5 version of GLUT with
+       -DSOLARIS_2_4_BUG to work around this bug. The symptom
+       of the bug is that programs will get a BadMatch error
+       from X_CreateWindow when creating a GLUT window because
+       Solaris 2.4 and 2.5 create a  corrupted RGB_DEFAULT_MAP
+       property.  Note that this workaround prevents Colormap
+       sharing between applications, perhaps leading
+       unnecessary colormap installations or colormap flashing.
+       Sun fixed this bug in Solaris 2.6. */
+    status = XmuLookupStandardColormap(__glutDisplay,
+      vi->screen, vi->visualid, vi->depth, XA_RGB_DEFAULT_MAP,
+      /* replace */ False, /* retain */ True);
+    if (status == 1) {
+      status = XGetRGBColormaps(__glutDisplay, __glutRoot,
+        &standardCmaps, &numCmaps, XA_RGB_DEFAULT_MAP);
+      if (status == 1) {
+        for (i = 0; i < numCmaps; i++) {
+          if (standardCmaps[i].visualid == vi->visualid) {
+            *cmap = standardCmaps[i].colormap;
+            XFree(standardCmaps);
+            return;
+          }
+        }
+        XFree(standardCmaps);
+      }
+    }
+#endif
+    /* If no standard colormap but TrueColor, just make a
+       private one. */
+    /* XXX Should do a better job of internal sharing for
+       privately allocated TrueColor colormaps. */
+    /* XXX DirectColor probably needs ramps hand initialized! */
+    *cmap = XCreateColormap(__glutDisplay, __glutRoot,
+      vi->visual, AllocNone);
+    break;
+  case StaticColor:
+  case StaticGray:
+  case GrayScale:
+    /* Mesa supports these visuals */
+    *colormap = NULL;
+    *cmap = XCreateColormap(__glutDisplay, __glutRoot,
+      vi->visual, AllocNone);
+    break;
+  default:
+    __glutFatalError(
+      "could not allocate colormap for visual type: %d.",
+      visualClass);
+  }
+  return;
+#endif
+}
+
+#if !defined(_WIN32)
+static int
+findColormaps(GLUTwindow * window,
+  Window * winlist, Colormap * cmaplist, int num, int max)
+{
+  GLUTwindow *child;
+  int i;
+
+  /* Do not allow more entries that maximum number of
+     colormaps! */
+  if (num >= max)
+    return num;
+  /* Is cmap for this window already on the list? */
+  for (i = 0; i < num; i++) {
+    if (cmaplist[i] == window->cmap)
+      goto normalColormapAlreadyListed;
+  }
+  /* Not found on the list; add colormap and window. */
+  winlist[num] = window->win;
+  cmaplist[num] = window->cmap;
+  num++;
+
+normalColormapAlreadyListed:
+
+  /* Repeat above but for the overlay colormap if there one. */
+  if (window->overlay) {
+    if (num >= max)
+      return num;
+    for (i = 0; i < num; i++) {
+      if (cmaplist[i] == window->overlay->cmap)
+        goto overlayColormapAlreadyListed;
+    }
+    winlist[num] = window->overlay->win;
+    cmaplist[num] = window->overlay->cmap;
+    num++;
+  }
+overlayColormapAlreadyListed:
+
+  /* Recursively search children. */
+  child = window->children;
+  while (child) {
+    num = findColormaps(child, winlist, cmaplist, num, max);
+    child = child->siblings;
+  }
+  return num;
+}
+
+void
+__glutEstablishColormapsProperty(GLUTwindow * window)
+{
+  /* this routine is strictly X.  Win32 doesn't need to do
+     anything of this sort (but has to do other wacky stuff
+     later). */
+  static Atom wmColormapWindows = None;
+  Window *winlist;
+  Colormap *cmaplist;
+  Status status;
+  int maxcmaps, num;
+
+  assert(!window->parent);
+  maxcmaps = MaxCmapsOfScreen(ScreenOfDisplay(__glutDisplay,
+      __glutScreen));
+  /* For portability reasons we don't use alloca for winlist
+     and cmaplist, but we could. */
+  winlist = (Window *) malloc(maxcmaps * sizeof(Window));
+  cmaplist = (Colormap *) malloc(maxcmaps * sizeof(Colormap));
+  num = findColormaps(window, winlist, cmaplist, 0, maxcmaps);
+  if (num < 2) {
+    /* Property no longer needed; remove it. */
+    wmColormapWindows = XSGIFastInternAtom(__glutDisplay,
+      "WM_COLORMAP_WINDOWS", SGI_XA_WM_COLORMAP_WINDOWS, False);
+    if (wmColormapWindows == None) {
+      __glutWarning("Could not intern X atom for WM_COLORMAP_WINDOWS.");
+      return;
+    }
+    XDeleteProperty(__glutDisplay, window->win, wmColormapWindows);
+  } else {
+    status = XSetWMColormapWindows(__glutDisplay, window->win,
+      winlist, num);
+    /* XSetWMColormapWindows should always work unless the
+       WM_COLORMAP_WINDOWS property cannot be intern'ed.  We
+       check to be safe. */
+    if (status == False)
+      __glutFatalError("XSetWMColormapWindows returned False.");
+  }
+  /* For portability reasons we don't use alloca for winlist
+     and cmaplist, but we could. */
+  free(winlist);
+  free(cmaplist);
+}
+
+GLUTwindow *
+__glutToplevelOf(GLUTwindow * window)
+{
+  while (window->parent) {
+    window = window->parent;
+  }
+  return window;
+}
+#endif
+
+void
+__glutFreeColormap(GLUTcolormap * cmap)
+{
+  GLUTcolormap *cur, **prev;
+
+  cmap->refcnt--;
+  if (cmap->refcnt == 0) {
+    /* remove from colormap list */
+    cur = __glutColormapList;
+    prev = &__glutColormapList;
+    while (cur) {
+      if (cur == cmap) {
+        *prev = cmap->next;
+        break;
+      }
+      prev = &(cur->next);
+      cur = cur->next;
+    }
+    /* actually free colormap */
+    XFreeColormap(__glutDisplay, cmap->cmap);
+    free(cmap->cells);
+    free(cmap);
+  }
+}
+
diff --git a/src/glut/glx/glut_cursor.c b/src/glut/glx/glut_cursor.c
new file mode 100644
index 0000000000..74ecb9cd66
--- /dev/null
+++ b/src/glut/glx/glut_cursor.c
@@ -0,0 +1,201 @@
+
+/* Copyright (c) Mark J. Kilgard, 1995, 1998. */
+
+/* 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 "glutint.h"
+
+#if !defined(_WIN32)
+#include <X11/Xatom.h>  /* For XA_CURSOR */
+#include <X11/cursorfont.h>
+#endif
+
+typedef struct _CursorTable {
+#if defined(_WIN32)
+  char* glyph;
+#else
+  int glyph;
+#endif
+  Cursor cursor;
+} CursorTable;
+/* *INDENT-OFF* */
+
+static CursorTable cursorTable[] = {
+  {XC_arrow, None},		  /* GLUT_CURSOR_RIGHT_ARROW */
+  {XC_top_left_arrow, None},	  /* GLUT_CURSOR_LEFT_ARROW */
+  {XC_hand1, None},		  /* GLUT_CURSOR_INFO */
+  {XC_pirate, None},		  /* GLUT_CURSOR_DESTROY */
+  {XC_question_arrow, None},	  /* GLUT_CURSOR_HELP */
+  {XC_exchange, None},		  /* GLUT_CURSOR_CYCLE */
+  {XC_spraycan, None},		  /* GLUT_CURSOR_SPRAY */
+  {XC_watch, None},		  /* GLUT_CURSOR_WAIT */
+  {XC_xterm, None},		  /* GLUT_CURSOR_TEXT */
+  {XC_crosshair, None},		  /* GLUT_CURSOR_CROSSHAIR */
+  {XC_sb_v_double_arrow, None},	  /* GLUT_CURSOR_UP_DOWN */
+  {XC_sb_h_double_arrow, None},	  /* GLUT_CURSOR_LEFT_RIGHT */
+  {XC_top_side, None},		  /* GLUT_CURSOR_TOP_SIDE */
+  {XC_bottom_side, None},	  /* GLUT_CURSOR_BOTTOM_SIDE */
+  {XC_left_side, None},		  /* GLUT_CURSOR_LEFT_SIDE */
+  {XC_right_side, None},	  /* GLUT_CURSOR_RIGHT_SIDE */
+  {XC_top_left_corner, None},	  /* GLUT_CURSOR_TOP_LEFT_CORNER */
+  {XC_top_right_corner, None},	  /* GLUT_CURSOR_TOP_RIGHT_CORNER */
+  {XC_bottom_right_corner, None}, /* GLUT_CURSOR_BOTTOM_RIGHT_CORNER */
+  {XC_bottom_left_corner, None},  /* GLUT_CURSOR_BOTTOM_LEFT_CORNER */
+};
+/* *INDENT-ON* */
+
+#if !defined(_WIN32)
+static Cursor blankCursor = None;
+static Cursor fullCrosshairCusor = None;
+
+/* SGI X server's support a special property called the
+   _SGI_CROSSHAIR_CURSOR that when installed as a window's
+   cursor, becomes a full screen crosshair cursor.  SGI
+   has special cursor generation hardware for this case. */
+static Cursor
+getFullCrosshairCursor(void)
+{
+  Cursor cursor;
+  Atom crosshairAtom, actualType;
+  int rc, actualFormat;
+  unsigned long n, left;
+  unsigned long *value;
+
+  if (fullCrosshairCusor == None) {
+    crosshairAtom = XInternAtom(__glutDisplay,
+      "_SGI_CROSSHAIR_CURSOR", True);
+    if (crosshairAtom != None) {
+      value = 0;        /* Make compiler happy. */
+      rc = XGetWindowProperty(__glutDisplay, __glutRoot,
+        crosshairAtom, 0, 1, False, XA_CURSOR, &actualType,
+        &actualFormat, &n, &left, (unsigned char **) &value);
+      if (rc == Success && actualFormat == 32 && n >= 1) {
+        cursor = value[0];
+        XFree(value);
+        return cursor;
+      }
+    }
+  }
+  return XCreateFontCursor(__glutDisplay, XC_crosshair);
+}
+
+/* X11 forces you to create a blank cursor if you want
+   to disable the cursor. */
+static Cursor
+makeBlankCursor(void)
+{
+  static char data[1] =
+  {0};
+  Cursor cursor;
+  Pixmap blank;
+  XColor dummy;
+
+  blank = XCreateBitmapFromData(__glutDisplay, __glutRoot,
+    data, 1, 1);
+  if (blank == None)
+    __glutFatalError("out of memory.");
+  cursor = XCreatePixmapCursor(__glutDisplay, blank, blank,
+    &dummy, &dummy, 0, 0);
+  XFreePixmap(__glutDisplay, blank);
+
+  return cursor;
+}
+#endif /* !_WIN32 */
+
+/* Win32 and X11 use this same function to accomplish
+   fairly different tasks.  X11 lets you just define the
+   cursor for a window and the window system takes care
+   of making sure that the window's cursor is installed
+   when the mouse is in the window.  Win32 requires the
+   application to handle a WM_SETCURSOR message to install
+   the right cursor when windows are entered.  Think of
+   the Win32 __glutSetCursor (called from __glutWindowProc)
+   as "install cursor".  Think of the X11 __glutSetCursor
+   (called from glutSetCursor) as "define cursor". */
+void 
+__glutSetCursor(GLUTwindow *window)
+{
+  int cursor = window->cursor;
+  Cursor xcursor;
+
+  if (cursor >= 0 &&
+    cursor < sizeof(cursorTable) / sizeof(cursorTable[0])) {
+    if (cursorTable[cursor].cursor == None) {
+      cursorTable[cursor].cursor = XCreateFontCursor(__glutDisplay,
+        cursorTable[cursor].glyph);
+    }
+    xcursor = cursorTable[cursor].cursor;
+  } else {
+    /* Special cases. */
+    switch (cursor) {
+    case GLUT_CURSOR_INHERIT:
+#if defined(_WIN32)
+      while (window->parent) {
+        window = window->parent;
+        if (window->cursor != GLUT_CURSOR_INHERIT) {
+          __glutSetCursor(window);
+          return;
+        }
+      }
+      /* XXX Default to an arrow cursor.  Is this
+         right or should we be letting the default
+         window proc be installing some system cursor? */
+      xcursor = cursorTable[0].cursor;
+      if (xcursor == NULL) {
+        xcursor =
+          cursorTable[0].cursor =
+          LoadCursor(NULL, cursorTable[0].glyph);
+      }
+#else
+      xcursor = None;
+#endif
+      break;
+    case GLUT_CURSOR_NONE:
+#if defined(_WIN32)
+      xcursor = NULL;
+#else
+      if (blankCursor == None) {
+        blankCursor = makeBlankCursor();
+      }
+      xcursor = blankCursor;
+#endif
+      break;
+    case GLUT_CURSOR_FULL_CROSSHAIR:
+#if defined(_WIN32)
+      xcursor = IDC_CROSS;
+#else
+      if (fullCrosshairCusor == None) {
+        fullCrosshairCusor = getFullCrosshairCursor();
+      }
+      xcursor = fullCrosshairCusor;
+#endif
+      break;
+    }
+  }
+  XDefineCursor(__glutDisplay,
+    window->win, xcursor);
+  XFlush(__glutDisplay);
+}
+
+/* CENTRY */
+void APIENTRY 
+glutSetCursor(int cursor)
+{
+#ifdef _WIN32
+  POINT point;
+
+  __glutCurrentWindow->cursor = cursor;
+  /* Are we in the window right now?  If so,
+     install the cursor. */
+  GetCursorPos(&point);
+  if (__glutCurrentWindow->win == WindowFromPoint(point)) {
+    __glutSetCursor(__glutCurrentWindow);
+  }
+#else
+  __glutCurrentWindow->cursor = cursor;
+  __glutSetCursor(__glutCurrentWindow);
+#endif
+}
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_dials.c b/src/glut/glx/glut_dials.c
new file mode 100644
index 0000000000..3eea850c5b
--- /dev/null
+++ b/src/glut/glx/glut_dials.c
@@ -0,0 +1,26 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 "glutint.h"
+
+void APIENTRY 
+glutButtonBoxFunc(GLUTbuttonBoxCB buttonBoxFunc)
+{
+  __glutCurrentWindow->buttonBox = buttonBoxFunc;
+  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_DEVICE_MASK_WORK);
+}
+
+void APIENTRY 
+glutDialsFunc(GLUTdialsCB dialsFunc)
+{
+  __glutCurrentWindow->dials = dialsFunc;
+  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_DEVICE_MASK_WORK);
+}
diff --git a/src/glut/glx/glut_dstr.c b/src/glut/glx/glut_dstr.c
new file mode 100644
index 0000000000..74643b83be
--- /dev/null
+++ b/src/glut/glx/glut_dstr.c
@@ -0,0 +1,1627 @@
+
+/* Copyright (c) Mark J. Kilgard, 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 <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "glutint.h"
+
+/* glxcaps matches the criteria macros listed in glutint.h, but
+   only list the first set (those that correspond to GLX visual
+   attributes). */
+static int glxcap[NUM_GLXCAPS] =
+{
+  GLX_RGBA,
+  GLX_BUFFER_SIZE,
+  GLX_DOUBLEBUFFER,
+  GLX_STEREO,
+  GLX_AUX_BUFFERS,
+  GLX_RED_SIZE,
+  GLX_GREEN_SIZE,
+  GLX_BLUE_SIZE,
+  GLX_ALPHA_SIZE,
+  GLX_DEPTH_SIZE,
+  GLX_STENCIL_SIZE,
+  GLX_ACCUM_RED_SIZE,
+  GLX_ACCUM_GREEN_SIZE,
+  GLX_ACCUM_BLUE_SIZE,
+  GLX_ACCUM_ALPHA_SIZE,
+  GLX_LEVEL,
+};
+
+#ifdef TEST
+
+#if !defined(_WIN32)
+char *__glutProgramName = "dstr";
+Display *__glutDisplay;
+int __glutScreen;
+XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
+  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc) = NULL;
+char *__glutDisplayString = NULL;
+#endif
+static int verbose = 0;
+
+static char *compstr[] =
+{
+  "none", "=", "!=", "<=", ">=", ">", "<", "~"
+};
+static char *capstr[] =
+{
+  "rgba", "bufsize", "double", "stereo", "auxbufs", "red", "green", "blue", "alpha",
+  "depth", "stencil", "acred", "acgreen", "acblue", "acalpha", "level", "xvisual",
+  "transparent", "samples", "xstaticgray", "xgrayscale", "xstaticcolor", "xpseudocolor",
+  "xtruecolor", "xdirectcolor", "slow", "conformant", "num"
+};
+
+static void
+printCriteria(Criterion * criteria, int ncriteria)
+{
+  int i;
+  printf("Criteria: %d\n", ncriteria);
+  for (i = 0; i < ncriteria; i++) {
+    printf("  %s %s %d\n",
+      capstr[criteria[i].capability],
+      compstr[criteria[i].comparison],
+      criteria[i].value);
+  }
+}
+
+#endif /* TEST */
+
+static int isMesaGLX = -1;
+
+static int
+determineMesaGLX(void)
+{
+#ifdef GLX_VERSION_1_1
+  const char *vendor, *version, *ch;
+
+  vendor = glXGetClientString(__glutDisplay, GLX_VENDOR);
+  if (!strcmp(vendor, "Brian Paul")) {
+    version = glXGetClientString(__glutDisplay, GLX_VERSION);
+    for (ch = version; *ch != ' ' && *ch != '\0'; ch++);
+    for (; *ch == ' ' && *ch != '\0'; ch++);
+
+#define MESA_NAME "Mesa "  /* Trailing space is intentional. */
+
+    if (!strncmp(MESA_NAME, ch, sizeof(MESA_NAME) - 1)) {
+      return 1;
+    }
+  }
+#else
+  /* Recent versions for Mesa should support GLX 1.1 and
+     therefore glXGetClientString.  If we get into this case,
+     we would be compiling against a true OpenGL not supporting
+     GLX 1.1, and the resulting compiled library won't work well 
+     with Mesa then. */
+#endif
+  return 0;
+}
+
+static XVisualInfo **
+getMesaVisualList(int *n)
+{
+  XVisualInfo **vlist, *vinfo;
+  int attribs[23];
+  int i, x, cnt;
+
+  vlist = (XVisualInfo **) malloc((32 + 16) * sizeof(XVisualInfo *));
+  if (!vlist)
+    __glutFatalError("out of memory.");
+
+  cnt = 0;
+  for (i = 0; i < 32; i++) {
+    x = 0;
+    attribs[x] = GLX_RGBA;
+    x++;
+    attribs[x] = GLX_RED_SIZE;
+    x++;
+    attribs[x] = 1;
+    x++;
+    attribs[x] = GLX_GREEN_SIZE;
+    x++;
+    attribs[x] = 1;
+    x++;
+    attribs[x] = GLX_BLUE_SIZE;
+    x++;
+    attribs[x] = 1;
+    x++;
+    if (i & 1) {
+      attribs[x] = GLX_DEPTH_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+    }
+    if (i & 2) {
+      attribs[x] = GLX_STENCIL_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+    }
+    if (i & 4) {
+      attribs[x] = GLX_ACCUM_RED_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+      attribs[x] = GLX_ACCUM_GREEN_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+      attribs[x] = GLX_ACCUM_BLUE_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+    }
+    if (i & 8) {
+      attribs[x] = GLX_ALPHA_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+      if (i & 4) {
+        attribs[x] = GLX_ACCUM_ALPHA_SIZE;
+        x++;
+        attribs[x] = 1;
+        x++;
+      }
+    }
+    if (i & 16) {
+      attribs[x] = GLX_DOUBLEBUFFER;
+      x++;
+    }
+    attribs[x] = None;
+    x++;
+    assert(x <= sizeof(attribs) / sizeof(attribs[0]));
+    vinfo = glXChooseVisual(__glutDisplay, __glutScreen, attribs);
+    if (vinfo) {
+      vlist[cnt] = vinfo;
+      cnt++;
+    }
+  }
+  for (i = 0; i < 16; i++) {
+    x = 0;
+    if (i & 1) {
+      attribs[x] = GLX_DEPTH_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+    }
+    if (i & 2) {
+      attribs[x] = GLX_STENCIL_SIZE;
+      x++;
+      attribs[x] = 1;
+      x++;
+    }
+    if (i & 4) {
+      attribs[x] = GLX_DOUBLEBUFFER;
+      x++;
+    }
+    if (i & 8) {
+      attribs[x] = GLX_LEVEL;
+      x++;
+      attribs[x] = 1;
+      x++;
+#if defined(GLX_TRANSPARENT_TYPE_EXT) && defined(GLX_TRANSPARENT_INDEX_EXT)
+      attribs[x] = GLX_TRANSPARENT_TYPE_EXT;
+      x++;
+      attribs[x] = GLX_TRANSPARENT_INDEX_EXT;
+      x++;
+#endif
+    }
+    attribs[x] = None;
+    x++;
+    assert(x <= sizeof(attribs) / sizeof(attribs[0]));
+    vinfo = glXChooseVisual(__glutDisplay, __glutScreen, attribs);
+    if (vinfo) {
+      vlist[cnt] = vinfo;
+      cnt++;
+    }
+  }
+
+  *n = cnt;
+  return vlist;
+}
+
+static FrameBufferMode *
+loadVisuals(int *nitems_return)
+{
+  XVisualInfo *vinfo, **vlist, template;
+  FrameBufferMode *fbmodes, *mode;
+  int n, i, j, rc, glcapable;
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+  int multisample;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+  int visual_info;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
+  int visual_rating;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+  int fbconfig;
+#endif
+
+  isMesaGLX = determineMesaGLX();
+  if (isMesaGLX) {
+    vlist = getMesaVisualList(&n);
+  } else {
+#if !defined(_WIN32)
+    template.screen = __glutScreen;
+    vinfo = XGetVisualInfo(__glutDisplay, VisualScreenMask, &template, &n);
+#else
+    vinfo = XGetVisualInfo(__glutDisplay, 0, &template, &n);
+#endif
+    if (vinfo == NULL) {
+      *nitems_return = 0;
+      return NULL;
+    }
+    assert(n > 0);
+
+    /* Make an array of XVisualInfo* pointers to help the Mesa
+       case because each glXChooseVisual call returns a
+       distinct XVisualInfo*, not a handy array like
+       XGetVisualInfo.  (Mesa expects us to return the _exact_
+       pointer returned by glXChooseVisual so we could not just
+       copy the returned structure.) */
+    vlist = (XVisualInfo **) malloc(n * sizeof(XVisualInfo *));
+    if (!vlist)
+      __glutFatalError("out of memory.");
+    for (i = 0; i < n; i++) {
+      vlist[i] = &vinfo[i];
+    }
+  }
+
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+  multisample = __glutIsSupportedByGLX("GLX_SGIS_multisample");
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+  visual_info = __glutIsSupportedByGLX("GLX_EXT_visual_info");
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
+  visual_rating = __glutIsSupportedByGLX("GLX_EXT_visual_rating");
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+  fbconfig = __glutIsSupportedByGLX("GLX_SGIX_fbconfig");
+#endif
+
+  fbmodes = (FrameBufferMode *) malloc(n * sizeof(FrameBufferMode));
+  if (fbmodes == NULL) {
+    *nitems_return = -1;
+    return NULL;
+  }
+  for (i = 0; i < n; i++) {
+    mode = &fbmodes[i];
+    mode->vi = vlist[i];
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+    mode->fbc = NULL;
+#endif
+    rc = glXGetConfig(__glutDisplay, vlist[i], GLX_USE_GL, &glcapable);
+    if (rc == 0 && glcapable) {
+      mode->valid = 1;  /* Assume the best until proven
+                           otherwise. */
+      for (j = 0; j < NUM_GLXCAPS; j++) {
+        rc = glXGetConfig(__glutDisplay, vlist[i], glxcap[j], &mode->cap[j]);
+        if (rc != 0) {
+          mode->valid = 0;
+        }
+      }
+#if defined(_WIN32)
+      mode->cap[XVISUAL] = ChoosePixelFormat(XHDC, vlist[i]);
+#else
+      mode->cap[XVISUAL] = (int) vlist[i]->visualid;
+#endif
+      mode->cap[XSTATICGRAY] = 0;
+      mode->cap[XGRAYSCALE] = 0;
+      mode->cap[XSTATICCOLOR] = 0;
+      mode->cap[XPSEUDOCOLOR] = 0;
+      mode->cap[XTRUECOLOR] = 0;
+      mode->cap[XDIRECTCOLOR] = 0;
+#if !defined(_WIN32)
+#if defined(__cplusplus) || defined(c_plusplus)
+      switch (vlist[i]->c_class) {
+#else
+      switch (vlist[i]->class) {
+#endif
+      case StaticGray:
+        mode->cap[XSTATICGRAY] = 1;
+        break;
+      case GrayScale:
+        mode->cap[XGRAYSCALE] = 1;
+        break;
+      case StaticColor:
+        mode->cap[XSTATICCOLOR] = 1;
+        break;
+      case PseudoColor:
+        mode->cap[XPSEUDOCOLOR] = 1;
+        break;
+      case TrueColor:
+        mode->cap[XTRUECOLOR] = 1;
+        break;
+      case DirectColor:
+        mode->cap[XDIRECTCOLOR] = 1;
+        break;
+      }
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
+      if (visual_rating) {
+        int rating;
+
+/* babcock@cs.montana.edu reported that DEC UNIX (OSF1) V4.0
+   564 for Alpha did not properly define GLX_VISUAL_CAVEAT_EXT
+   in <GL/glx.h> despite claiming to support
+   GLX_EXT_visual_rating. */
+#ifndef GLX_VISUAL_CAVEAT_EXT
+#define GLX_VISUAL_CAVEAT_EXT 0x20
+#endif
+
+        rc = glXGetConfig(__glutDisplay,
+	  vlist[i], GLX_VISUAL_CAVEAT_EXT, &rating);
+        if (rc != 0) {
+          mode->cap[SLOW] = 0;
+          mode->cap[CONFORMANT] = 1;
+        } else {
+          switch (rating) {
+          case GLX_SLOW_VISUAL_EXT:
+            mode->cap[SLOW] = 1;
+            mode->cap[CONFORMANT] = 1;
+            break;
+
+/* IRIX 5.3 for the R10K Indigo2 may have shipped without this
+   properly defined in /usr/include/GL/glxtokens.h */
+#ifndef GLX_NON_CONFORMANT_VISUAL_EXT
+#define GLX_NON_CONFORMANT_VISUAL_EXT   0x800D
+#endif
+
+          case GLX_NON_CONFORMANT_VISUAL_EXT:
+            mode->cap[SLOW] = 0;
+            mode->cap[CONFORMANT] = 0;
+            break;
+          case GLX_NONE_EXT:
+          default:     /* XXX Hopefully this is a good default
+                           assumption. */
+            mode->cap[SLOW] = 0;
+            mode->cap[CONFORMANT] = 1;
+            break;
+          }
+        }
+      } else {
+        mode->cap[TRANSPARENT] = 0;
+      }
+#else
+      mode->cap[SLOW] = 0;
+      mode->cap[CONFORMANT] = 1;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+      if (visual_info) {
+        int transparent;
+
+/* babcock@cs.montana.edu reported that DEC UNIX (OSF1) V4.0
+   564 for Alpha did not properly define
+   GLX_TRANSPARENT_TYPE_EXT in <GL/glx.h> despite claiming to
+   support GLX_EXT_visual_info. */
+#ifndef GLX_TRANSPARENT_TYPE_EXT
+#define GLX_TRANSPARENT_TYPE_EXT 0x23
+#endif
+
+        rc = glXGetConfig(__glutDisplay,
+          vlist[i], GLX_TRANSPARENT_TYPE_EXT, &transparent);
+        if (rc != 0) {
+          mode->cap[TRANSPARENT] = 0;
+        } else {
+          mode->cap[TRANSPARENT] = (transparent != GLX_NONE_EXT);
+        }
+      } else {
+        mode->cap[TRANSPARENT] = 0;
+      }
+#else
+      mode->cap[TRANSPARENT] = 0;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+      if (multisample) {
+        rc = glXGetConfig(__glutDisplay,
+	  vlist[i], GLX_SAMPLES_SGIS, &mode->cap[SAMPLES]);
+        if (rc != 0) {
+          mode->cap[SAMPLES] = 0;
+        }
+      } else {
+        mode->cap[SAMPLES] = 0;
+      }
+#else
+      mode->cap[SAMPLES] = 0;
+#endif
+    } else {
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+      if (fbconfig) {
+        GLXFBConfigSGIX fbc;
+        int fbconfigID, drawType, renderType;
+
+        fbc = glXGetFBConfigFromVisualSGIX(__glutDisplay, vlist[i]);
+        if (fbc) {
+          rc = glXGetFBConfigAttribSGIX(__glutDisplay, fbc,
+	    GLX_FBCONFIG_ID_SGIX, &fbconfigID);
+          if ((rc == 0) && (fbconfigID != None)) {
+            rc = glXGetFBConfigAttribSGIX(__glutDisplay, fbc,
+	      GLX_DRAWABLE_TYPE_SGIX, &drawType);
+            if ((rc == 0) && (drawType & GLX_WINDOW_BIT_SGIX)) {
+              rc = glXGetFBConfigAttribSGIX(__glutDisplay, fbc,
+	        GLX_RENDER_TYPE_SGIX, &renderType);
+              if ((rc == 0) && (renderType & GLX_RGBA_BIT_SGIX)) {
+                mode->fbc = fbc;
+                mode->valid = 1;  /* Assume the best until
+                                     proven otherwise. */
+
+		assert(glxcap[0] == GLX_RGBA);
+                mode->cap[0] = 1;
+
+                /* Start with "j = 1" to skip the GLX_RGBA attribute. */
+                for (j = 1; j < NUM_GLXCAPS; j++) {
+                  rc = glXGetFBConfigAttribSGIX(__glutDisplay,
+		    fbc, glxcap[j], &mode->cap[j]);
+                  if (rc != 0) {
+                    mode->valid = 0;
+                  }
+                }
+
+                mode->cap[XVISUAL] = (int) vlist[i]->visualid;
+                mode->cap[XSTATICGRAY] = 0;
+                mode->cap[XGRAYSCALE] = 0;
+                mode->cap[XSTATICCOLOR] = 0;
+                mode->cap[XPSEUDOCOLOR] = 0;
+                mode->cap[XTRUECOLOR] = 0;
+                mode->cap[XDIRECTCOLOR] = 0;
+#if defined(__cplusplus) || defined(c_plusplus)
+                switch (vlist[i]->c_class) {
+#else
+                switch (vlist[i]->class) {
+#endif
+                case StaticGray:
+                  mode->cap[XSTATICGRAY] = 1;
+                  break;
+                case GrayScale:
+                  mode->cap[XGRAYSCALE] = 1;
+                  break;
+                case StaticColor:
+                  mode->cap[XSTATICCOLOR] = 1;
+                  break;
+                case PseudoColor:
+                  mode->cap[XPSEUDOCOLOR] = 1;
+                  break;
+                case TrueColor:
+                  mode->cap[XTRUECOLOR] = 1;
+                  break;
+                case DirectColor:
+                  mode->cap[XDIRECTCOLOR] = 1;
+                  break;
+                }
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
+                if (visual_rating) {
+                  int rating;
+
+/* babcock@cs.montana.edu reported that DEC UNIX (OSF1) V4.0
+   564 for Alpha did not properly define GLX_VISUAL_CAVEAT_EXT
+   in <GL/glx.h> despite claiming to support
+   GLX_EXT_visual_rating. */
+#ifndef GLX_VISUAL_CAVEAT_EXT
+#define GLX_VISUAL_CAVEAT_EXT 0x20
+#endif
+
+                  rc = glXGetFBConfigAttribSGIX(__glutDisplay,
+		    fbc, GLX_VISUAL_CAVEAT_EXT, &rating);
+                  if (rc != 0) {
+                    mode->cap[SLOW] = 0;
+                    mode->cap[CONFORMANT] = 1;
+                  } else {
+                    switch (rating) {
+                    case GLX_SLOW_VISUAL_EXT:
+                      mode->cap[SLOW] = 1;
+                      mode->cap[CONFORMANT] = 1;
+                      break;
+
+/* IRIX 5.3 for the R10K Indigo2 may have shipped without this
+   properly defined in /usr/include/GL/glxtokens.h */
+#ifndef GLX_NON_CONFORMANT_VISUAL_EXT
+#define GLX_NON_CONFORMANT_VISUAL_EXT   0x800D
+#endif
+
+                    case GLX_NON_CONFORMANT_VISUAL_EXT:
+                      mode->cap[SLOW] = 0;
+                      mode->cap[CONFORMANT] = 0;
+                      break;
+                    case GLX_NONE_EXT:
+                    default:  /* XXX Hopefully this is a good
+                                  default assumption. */
+                      mode->cap[SLOW] = 0;
+                      mode->cap[CONFORMANT] = 1;
+                      break;
+                    }
+                  }
+                } else {
+                  mode->cap[TRANSPARENT] = 0;
+                }
+#else
+                mode->cap[SLOW] = 0;
+                mode->cap[CONFORMANT] = 1;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+                if (visual_info) {
+                  int transparent;
+
+/* babcock@cs.montana.edu reported that DEC UNIX (OSF1) V4.0
+   564 for Alpha did not properly define
+   GLX_TRANSPARENT_TYPE_EXT in <GL/glx.h> despite claiming to
+   support GLX_EXT_visual_info. */
+#ifndef GLX_TRANSPARENT_TYPE_EXT
+#define GLX_TRANSPARENT_TYPE_EXT 0x23
+#endif
+
+                  rc = glXGetFBConfigAttribSGIX(__glutDisplay,
+		    fbc, GLX_TRANSPARENT_TYPE_EXT, &transparent);
+                  if (rc != 0) {
+                    mode->cap[TRANSPARENT] = 0;
+                  } else {
+                    mode->cap[TRANSPARENT] = (transparent != GLX_NONE_EXT);
+                  }
+                } else {
+                  mode->cap[TRANSPARENT] = 0;
+                }
+#else
+                mode->cap[TRANSPARENT] = 0;
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+                if (multisample) {
+                  rc = glXGetFBConfigAttribSGIX(__glutDisplay,
+		    fbc, GLX_SAMPLES_SGIS, &mode->cap[SAMPLES]);
+                  if (rc != 0) {
+                    mode->cap[SAMPLES] = 0;
+                  }
+                } else {
+                  mode->cap[SAMPLES] = 0;
+                }
+#else
+                mode->cap[SAMPLES] = 0;
+#endif
+
+              } else {
+                /* Fbconfig is not RGBA; GLUT only uses RGBA
+                   FBconfigs. */
+                /* XXX Code could be exteneded to handle color
+                   index FBconfigs, but seems a color index
+                   window-renderable FBconfig would also be
+                   advertised as an X visual. */
+                mode->valid = 0;
+              }
+            } else {
+              /* Fbconfig does not support window rendering;
+                 not a valid FBconfig for GLUT windows. */
+              mode->valid = 0;
+            }
+          } else {
+            /* FBconfig ID is None (zero); not a valid
+               FBconfig. */
+            mode->valid = 0;
+          }
+        } else {
+          /* FBconfig ID is None (zero); not a valid FBconfig. */
+          mode->valid = 0;
+        }
+      } else {
+        /* No SGIX_fbconfig GLX sever implementation support. */
+        mode->valid = 0;
+      }
+#else
+      /* No SGIX_fbconfig GLX extension API support. */
+      mode->valid = 0;
+#endif
+    }
+  }
+
+  free(vlist);
+  *nitems_return = n;
+  return fbmodes;
+}
+
+static XVisualInfo *
+findMatch(FrameBufferMode * fbmodes, int nfbmodes,
+  Criterion * criteria, int ncriteria, void **fbc)
+{
+  FrameBufferMode *found;
+  int *bestScore, *thisScore;
+  int i, j, numok, result, worse, better;
+
+  found = NULL;
+  numok = 1;            /* "num" capability is indexed from 1,
+                           not 0. */
+
+  /* XXX alloca canidate. */
+  bestScore = (int *) malloc(ncriteria * sizeof(int));
+  if (!bestScore)
+    __glutFatalError("out of memory.");
+  for (j = 0; j < ncriteria; j++) {
+    /* Very negative number. */
+    bestScore[j] = -32768;
+  }
+
+  /* XXX alloca canidate. */
+  thisScore = (int *) malloc(ncriteria * sizeof(int));
+  if (!thisScore)
+    __glutFatalError("out of memory.");
+
+  for (i = 0; i < nfbmodes; i++) {
+    if (fbmodes[i].valid) {
+#ifdef TEST
+#if !defined(_WIN32)
+      if (verbose)
+        printf("Visual 0x%x\n", fbmodes[i].vi->visualid);
+#endif
+#endif
+
+      worse = 0;
+      better = 0;
+
+      for (j = 0; j < ncriteria; j++) {
+        int cap, cvalue, fbvalue;
+
+        cap = criteria[j].capability;
+        cvalue = criteria[j].value;
+        if (cap == NUM) {
+          fbvalue = numok;
+        } else {
+          fbvalue = fbmodes[i].cap[cap];
+        }
+#ifdef TEST
+        if (verbose)
+          printf("  %s %s %d to %d\n",
+            capstr[cap], compstr[criteria[j].comparison], cvalue, fbvalue);
+#endif
+        switch (criteria[j].comparison) {
+        case EQ:
+          result = cvalue == fbvalue;
+          thisScore[j] = 1;
+          break;
+        case NEQ:
+          result = cvalue != fbvalue;
+          thisScore[j] = 1;
+          break;
+        case LT:
+          result = fbvalue < cvalue;
+          thisScore[j] = fbvalue - cvalue;
+          break;
+        case GT:
+          result = fbvalue > cvalue;
+          thisScore[j] = fbvalue - cvalue;
+          break;
+        case LTE:
+          result = fbvalue <= cvalue;
+          thisScore[j] = fbvalue - cvalue;
+          break;
+        case GTE:
+          result = (fbvalue >= cvalue);
+          thisScore[j] = fbvalue - cvalue;
+          break;
+        case MIN:
+          result = fbvalue >= cvalue;
+          thisScore[j] = cvalue - fbvalue;
+          break;
+        }
+
+#ifdef TEST
+        if (verbose)
+          printf("                result=%d   score=%d   bestScore=%d\n", result, thisScore[j], bestScore[j]);
+#endif
+
+        if (result) {
+          if (better || thisScore[j] > bestScore[j]) {
+            better = 1;
+          } else if (thisScore[j] == bestScore[j]) {
+            /* Keep looking. */
+          } else {
+            goto nextFBM;
+          }
+        } else {
+          if (cap == NUM) {
+            worse = 1;
+          } else {
+            goto nextFBM;
+          }
+        }
+
+      }
+
+      if (better && !worse) {
+        found = &fbmodes[i];
+        for (j = 0; j < ncriteria; j++) {
+          bestScore[j] = thisScore[j];
+        }
+      }
+      numok++;
+
+    nextFBM:;
+
+    }
+  }
+  free(bestScore);
+  free(thisScore);
+  if (found) {
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+    *fbc = found->fbc;
+#endif
+    return found->vi;
+  } else {
+    return NULL;
+  }
+}
+
+static int
+parseCriteria(char *word, Criterion * criterion, int *mask,
+  Bool * allowDoubleAsSingle)
+{
+  char *cstr, *vstr, *response;
+  int comparator, value;
+  int rgb, rgba, acc, acca, count, i;
+
+  cstr = strpbrk(word, "=><!~");
+  if (cstr) {
+    switch (cstr[0]) {
+    case '=':
+      comparator = EQ;
+      vstr = &cstr[1];
+      break;
+    case '~':
+      comparator = MIN;
+      vstr = &cstr[1];
+      break;
+    case '>':
+      if (cstr[1] == '=') {
+        comparator = GTE;
+        vstr = &cstr[2];
+      } else {
+        comparator = GT;
+        vstr = &cstr[1];
+      }
+      break;
+    case '<':
+      if (cstr[1] == '=') {
+        comparator = LTE;
+        vstr = &cstr[2];
+      } else {
+        comparator = LT;
+        vstr = &cstr[1];
+      }
+      break;
+    case '!':
+      if (cstr[1] == '=') {
+        comparator = NEQ;
+        vstr = &cstr[2];
+      } else {
+        return -1;
+      }
+      break;
+    default:
+      return -1;
+    }
+    value = (int) strtol(vstr, &response, 0);
+    if (response == vstr) {
+      /* Not a valid number. */
+      return -1;
+    }
+    *cstr = '\0';
+  } else {
+    comparator = NONE;
+  }
+  switch (word[0]) {
+  case 'a':
+    if (!strcmp(word, "alpha")) {
+      criterion[0].capability = ALPHA_SIZE;
+      if (comparator == NONE) {
+        criterion[0].comparison = GTE;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << RGBA);
+      *mask |= (1 << ALPHA_SIZE);
+      *mask |= (1 << RGBA_MODE);
+      return 1;
+    }
+    acca = !strcmp(word, "acca");
+    acc = !strcmp(word, "acc");
+    if (acc || acca) {
+      criterion[0].capability = ACCUM_RED_SIZE;
+      criterion[1].capability = ACCUM_GREEN_SIZE;
+      criterion[2].capability = ACCUM_BLUE_SIZE;
+      criterion[3].capability = ACCUM_ALPHA_SIZE;
+      if (acca) {
+        count = 4;
+      } else {
+        count = 3;
+        criterion[3].comparison = MIN;
+        criterion[3].value = 0;
+      }
+      if (comparator == NONE) {
+        comparator = GTE;
+        value = 8;
+      }
+      for (i = 0; i < count; i++) {
+        criterion[i].comparison = comparator;
+        criterion[i].value = value;
+      }
+      *mask |= (1 << ACCUM_RED_SIZE);
+      return 4;
+    }
+    if (!strcmp(word, "auxbufs")) {
+      criterion[0].capability = AUX_BUFFERS;
+      if (comparator == NONE) {
+        criterion[0].comparison = MIN;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << AUX_BUFFERS);
+      return 1;
+    }
+    return -1;
+  case 'b':
+    if (!strcmp(word, "blue")) {
+      criterion[0].capability = BLUE_SIZE;
+      if (comparator == NONE) {
+        criterion[0].comparison = GTE;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << RGBA);
+      *mask |= (1 << RGBA_MODE);
+      return 1;
+    }
+    if (!strcmp(word, "buffer")) {
+      criterion[0].capability = BUFFER_SIZE;
+      if (comparator == NONE) {
+        criterion[0].comparison = GTE;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      return 1;
+    }
+    return -1;
+  case 'c':
+    if (!strcmp(word, "conformant")) {
+      criterion[0].capability = CONFORMANT;
+      if (comparator == NONE) {
+        criterion[0].comparison = EQ;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << CONFORMANT);
+      return 1;
+    }
+    return -1;
+  case 'd':
+    if (!strcmp(word, "depth")) {
+      criterion[0].capability = DEPTH_SIZE;
+      if (comparator == NONE) {
+        criterion[0].comparison = GTE;
+        criterion[0].value = 12;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << DEPTH_SIZE);
+      return 1;
+    }
+    if (!strcmp(word, "double")) {
+      criterion[0].capability = DOUBLEBUFFER;
+      if (comparator == NONE) {
+        criterion[0].comparison = EQ;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << DOUBLEBUFFER);
+      return 1;
+    }
+    return -1;
+  case 'g':
+    if (!strcmp(word, "green")) {
+      criterion[0].capability = GREEN_SIZE;
+      if (comparator == NONE) {
+        criterion[0].comparison = GTE;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << RGBA);
+      *mask |= (1 << RGBA_MODE);
+      return 1;
+    }
+    return -1;
+  case 'i':
+    if (!strcmp(word, "index")) {
+      criterion[0].capability = RGBA;
+      criterion[0].comparison = EQ;
+      criterion[0].value = 0;
+      *mask |= (1 << RGBA);
+      *mask |= (1 << CI_MODE);
+      criterion[1].capability = BUFFER_SIZE;
+      if (comparator == NONE) {
+        criterion[1].comparison = GTE;
+        criterion[1].value = 1;
+      } else {
+        criterion[1].comparison = comparator;
+        criterion[1].value = value;
+      }
+      return 2;
+    }
+    return -1;
+  case 'l':
+    if (!strcmp(word, "luminance")) {
+      criterion[0].capability = RGBA;
+      criterion[0].comparison = EQ;
+      criterion[0].value = 1;
+
+      criterion[1].capability = RED_SIZE;
+      if (comparator == NONE) {
+        criterion[1].comparison = GTE;
+        criterion[1].value = 1;
+      } else {
+        criterion[1].comparison = comparator;
+        criterion[1].value = value;
+      }
+
+      criterion[2].capability = GREEN_SIZE;
+      criterion[2].comparison = EQ;
+      criterion[2].value = 0;
+
+      criterion[3].capability = BLUE_SIZE;
+      criterion[3].comparison = EQ;
+      criterion[3].value = 0;
+
+      *mask |= (1 << RGBA);
+      *mask |= (1 << RGBA_MODE);
+      *mask |= (1 << LUMINANCE_MODE);
+      return 4;
+    }
+    return -1;
+  case 'n':
+    if (!strcmp(word, "num")) {
+      criterion[0].capability = NUM;
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        return 1;
+      }
+    }
+    return -1;
+  case 'r':
+    if (!strcmp(word, "red")) {
+      criterion[0].capability = RED_SIZE;
+      if (comparator == NONE) {
+        criterion[0].comparison = GTE;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << RGBA);
+      *mask |= (1 << RGBA_MODE);
+      return 1;
+    }
+    rgba = !strcmp(word, "rgba");
+    rgb = !strcmp(word, "rgb");
+    if (rgb || rgba) {
+      criterion[0].capability = RGBA;
+      criterion[0].comparison = EQ;
+      criterion[0].value = 1;
+
+      criterion[1].capability = RED_SIZE;
+      criterion[2].capability = GREEN_SIZE;
+      criterion[3].capability = BLUE_SIZE;
+      criterion[4].capability = ALPHA_SIZE;
+      if (rgba) {
+        count = 5;
+      } else {
+        count = 4;
+        criterion[4].comparison = MIN;
+        criterion[4].value = 0;
+      }
+      if (comparator == NONE) {
+        comparator = GTE;
+        value = 1;
+      }
+      for (i = 1; i < count; i++) {
+        criterion[i].comparison = comparator;
+        criterion[i].value = value;
+      }
+      *mask |= (1 << RGBA);
+      *mask |= (1 << RGBA_MODE);
+      return 5;
+    }
+    return -1;
+  case 's':
+    if (!strcmp(word, "stencil")) {
+      criterion[0].capability = STENCIL_SIZE;
+      if (comparator == NONE) {
+        criterion[0].comparison = MIN;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << STENCIL_SIZE);
+      return 1;
+    }
+    if (!strcmp(word, "single")) {
+      criterion[0].capability = DOUBLEBUFFER;
+      if (comparator == NONE) {
+        criterion[0].comparison = EQ;
+        criterion[0].value = 0;
+        *allowDoubleAsSingle = True;
+        *mask |= (1 << DOUBLEBUFFER);
+        return 1;
+      } else {
+        return -1;
+      }
+    }
+    if (!strcmp(word, "stereo")) {
+      criterion[0].capability = STEREO;
+      if (comparator == NONE) {
+        criterion[0].comparison = EQ;
+        criterion[0].value = 1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << STEREO);
+      return 1;
+    }
+    if (!strcmp(word, "samples")) {
+      criterion[0].capability = SAMPLES;
+      if (comparator == NONE) {
+        criterion[0].comparison = LTE;
+        criterion[0].value = 4;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << SAMPLES);
+      return 1;
+    }
+    if (!strcmp(word, "slow")) {
+      criterion[0].capability = SLOW;
+      if (comparator == NONE) {
+        /* Just "slow" means permit fast visuals, but accept
+           slow ones in preference. Presumably the slow ones
+           must be higher quality or something else desirable. */
+        criterion[0].comparison = GTE;
+        criterion[0].value = 0;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+      }
+      *mask |= (1 << SLOW);
+      return 1;
+    }
+    return -1;
+#if defined(_WIN32)
+  case 'w':
+    if (!strcmp(word, "win32pfd")) {
+      criterion[0].capability = XVISUAL;
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        return 1;
+      }
+    }
+    return -1;
+#endif
+#if !defined(_WIN32)
+  case 'x':
+    if (!strcmp(word, "xvisual")) {
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].capability = XVISUAL;
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        /* Set everything in "mask" so that no default criteria
+           get used.  Assume the program really wants the
+           xvisual specified. */
+        *mask |= ~0;
+        return 1;
+      }
+    }
+    /* Be a little over-eager to fill in the comparison and
+       value so we won't have to replicate the code after each
+       string match. */
+    if (comparator == NONE) {
+      criterion[0].comparison = EQ;
+      criterion[0].value = 1;
+    } else {
+      criterion[0].comparison = comparator;
+      criterion[0].value = value;
+    }
+
+    if (!strcmp(word, "xstaticgray")) {
+      criterion[0].capability = XSTATICGRAY;
+      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
+                                       class selected. */
+      return 1;
+    }
+    if (!strcmp(word, "xgrayscale")) {
+      criterion[0].capability = XGRAYSCALE;
+      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
+                                       class selected. */
+      return 1;
+    }
+    if (!strcmp(word, "xstaticcolor")) {
+      criterion[0].capability = XSTATICCOLOR;
+      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
+                                       class selected. */
+      return 1;
+    }
+    if (!strcmp(word, "xpseudocolor")) {
+      criterion[0].capability = XPSEUDOCOLOR;
+      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
+                                       class selected. */
+      return 1;
+    }
+    if (!strcmp(word, "xtruecolor")) {
+      criterion[0].capability = XTRUECOLOR;
+      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
+                                       class selected. */
+      return 1;
+    }
+    if (!strcmp(word, "xdirectcolor")) {
+      criterion[0].capability = XDIRECTCOLOR;
+      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
+                                       class selected. */
+      return 1;
+    }
+    return -1;
+#endif
+  default:
+    return -1;
+  }
+}
+
+static Criterion *
+parseModeString(char *mode, int *ncriteria, Bool * allowDoubleAsSingle,
+  Criterion * requiredCriteria, int nRequired, int requiredMask)
+{
+  Criterion *criteria = NULL;
+  int n, mask, parsed, i;
+  char *copy, *word;
+
+  *allowDoubleAsSingle = False;
+  copy = __glutStrdup(mode);
+  /* Attempt to estimate how many criteria entries should be
+     needed. */
+  n = 0;
+  word = strtok(copy, " \t");
+  while (word) {
+    n++;
+    word = strtok(NULL, " \t");
+  }
+  /* Overestimate by 4 times ("rgba" might add four criteria
+     entries) plus add in possible defaults plus space for
+     required criteria. */
+  criteria = (Criterion *) malloc((4 * n + 30 + nRequired) * sizeof(Criterion));
+  if (!criteria) {
+    __glutFatalError("out of memory.");
+  }
+
+  /* Re-copy the copy of the mode string. */
+  strcpy(copy, mode);
+
+  /* First add the required criteria (these match at the
+     highest priority). Typically these will be used to force a
+     specific level (layer), transparency, and/or visual type. */
+  mask = requiredMask;
+  for (i = 0; i < nRequired; i++) {
+    criteria[i] = requiredCriteria[i];
+  }
+  n = nRequired;
+
+  word = strtok(copy, " \t");
+  while (word) {
+    parsed = parseCriteria(word, &criteria[n], &mask, allowDoubleAsSingle);
+    if (parsed >= 0) {
+      n += parsed;
+    } else {
+      __glutWarning("Unrecognized display string word: %s (ignoring)\n", word);
+    }
+    word = strtok(NULL, " \t");
+  }
+
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+  if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) {
+    if (!(mask & (1 << SAMPLES))) {
+      criteria[n].capability = SAMPLES;
+      criteria[n].comparison = EQ;
+      criteria[n].value = 0;
+      n++;
+    } else {
+      /* Multisample visuals are marked nonconformant.  If
+         multisampling was requeste and no conformant
+         preference was set, assume that we will settle for a
+         non-conformant visual to get multisampling. */
+      if (!(mask & (1 << CONFORMANT))) {
+        criteria[n].capability = CONFORMANT;
+        criteria[n].comparison = MIN;
+        criteria[n].value = 0;
+        n++;
+        mask |= (1 << CONFORMANT);
+      }
+    }
+  }
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
+  if (__glutIsSupportedByGLX("GLX_EXT_visual_info")) {
+    if (!(mask & (1 << TRANSPARENT))) {
+      criteria[n].capability = TRANSPARENT;
+      criteria[n].comparison = EQ;
+      criteria[n].value = 0;
+      n++;
+    }
+  }
+#endif
+#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
+  if (__glutIsSupportedByGLX("GLX_EXT_visual_rating")) {
+    if (!(mask & (1 << SLOW))) {
+      criteria[n].capability = SLOW;
+      criteria[n].comparison = EQ;
+      criteria[n].value = 0;
+      n++;
+    }
+    if (!(mask & (1 << CONFORMANT))) {
+      criteria[n].capability = CONFORMANT;
+      criteria[n].comparison = EQ;
+      criteria[n].value = 1;
+      n++;
+    }
+  }
+#endif
+  if (!(mask & (1 << ACCUM_RED_SIZE))) {
+    criteria[n].capability = ACCUM_RED_SIZE;
+    criteria[n].comparison = MIN;
+    criteria[n].value = 0;
+    criteria[n + 1].capability = ACCUM_GREEN_SIZE;
+    criteria[n + 1].comparison = MIN;
+    criteria[n + 1].value = 0;
+    criteria[n + 2].capability = ACCUM_BLUE_SIZE;
+    criteria[n + 2].comparison = MIN;
+    criteria[n + 2].value = 0;
+    criteria[n + 3].capability = ACCUM_ALPHA_SIZE;
+    criteria[n + 3].comparison = MIN;
+    criteria[n + 3].value = 0;
+    n += 4;
+  }
+  if (!(mask & (1 << AUX_BUFFERS))) {
+    criteria[n].capability = AUX_BUFFERS;
+    criteria[n].comparison = MIN;
+    criteria[n].value = 0;
+    n++;
+  }
+  if (!(mask & (1 << RGBA))) {
+    criteria[n].capability = RGBA;
+    criteria[n].comparison = EQ;
+    criteria[n].value = 1;
+    criteria[n + 1].capability = RED_SIZE;
+    criteria[n + 1].comparison = GTE;
+    criteria[n + 1].value = 1;
+    criteria[n + 2].capability = GREEN_SIZE;
+    criteria[n + 2].comparison = GTE;
+    criteria[n + 2].value = 1;
+    criteria[n + 3].capability = BLUE_SIZE;
+    criteria[n + 3].comparison = GTE;
+    criteria[n + 3].value = 1;
+    criteria[n + 4].capability = ALPHA_SIZE;
+    criteria[n + 4].comparison = MIN;
+    criteria[n + 4].value = 0;
+    n += 5;
+    mask |= (1 << RGBA_MODE);
+  }
+#if !defined(_WIN32)
+  if (!(mask & (1 << XSTATICGRAY))) {
+    assert(isMesaGLX != -1);
+    if ((mask & (1 << RGBA_MODE)) && !isMesaGLX) {
+      /* Normally, request an RGBA mode visual be TrueColor,
+         except in the case of Mesa where we trust Mesa (and
+         other code in GLUT) to handle any type of RGBA visual
+         reasonably. */
+      if (mask & (1 << LUMINANCE_MODE)) {
+	/* If RGBA luminance was requested, actually go for
+	   a StaticGray visual. */
+        criteria[n].capability = XSTATICGRAY;
+      } else {
+        criteria[n].capability = XTRUECOLOR;
+      }
+      criteria[n].value = 1;
+      criteria[n].comparison = EQ;
+
+      n++;
+    }
+    if (mask & (1 << CI_MODE)) {
+      criteria[n].capability = XPSEUDOCOLOR;
+      criteria[n].value = 1;
+      criteria[n].comparison = EQ;
+      n++;
+    }
+  }
+#endif
+  if (!(mask & (1 << STEREO))) {
+    criteria[n].capability = STEREO;
+    criteria[n].comparison = EQ;
+    criteria[n].value = 0;
+    n++;
+  }
+  if (!(mask & (1 << DOUBLEBUFFER))) {
+    criteria[n].capability = DOUBLEBUFFER;
+    criteria[n].comparison = EQ;
+    criteria[n].value = 0;
+    *allowDoubleAsSingle = True;
+    n++;
+  }
+  if (!(mask & (1 << DEPTH_SIZE))) {
+    criteria[n].capability = DEPTH_SIZE;
+    criteria[n].comparison = MIN;
+    criteria[n].value = 0;
+    n++;
+  }
+  if (!(mask & (1 << STENCIL_SIZE))) {
+    criteria[n].capability = STENCIL_SIZE;
+    criteria[n].comparison = MIN;
+    criteria[n].value = 0;
+    n++;
+  }
+  if (!(mask & (1 << LEVEL))) {
+    criteria[n].capability = LEVEL;
+    criteria[n].comparison = EQ;
+    criteria[n].value = 0;
+    n++;
+  }
+  if (n) {
+    /* Since over-estimated the size needed; squeeze it down to
+       reality. */
+    criteria = (Criterion *) realloc(criteria, n * sizeof(Criterion));
+    if (!criteria) {
+      /* Should never happen since should be shrinking down! */
+      __glutFatalError("out of memory.");
+    }
+  } else {
+    /* For portability, avoid "realloc(ptr,0)" call. */
+    free(criteria);
+    criteria = NULL;
+  }
+
+  free(copy);
+  *ncriteria = n;
+  return criteria;
+}
+
+static FrameBufferMode *fbmodes = NULL;
+static int nfbmodes = 0;
+
+static XVisualInfo *
+getVisualInfoFromString(char *string, Bool * treatAsSingle,
+  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc)
+{
+  Criterion *criteria;
+  XVisualInfo *visinfo;
+  Bool allowDoubleAsSingle;
+  int ncriteria, i;
+
+  if (!fbmodes) {
+    fbmodes = loadVisuals(&nfbmodes);
+  }
+  criteria = parseModeString(string, &ncriteria,
+    &allowDoubleAsSingle, requiredCriteria, nRequired, requiredMask);
+  if (criteria == NULL) {
+    __glutWarning("failed to parse mode string");
+    return NULL;
+  }
+#ifdef TEST
+  printCriteria(criteria, ncriteria);
+#endif
+  visinfo = findMatch(fbmodes, nfbmodes, criteria, ncriteria, fbc);
+  if (visinfo) {
+    *treatAsSingle = 0;
+  } else {
+    if (allowDoubleAsSingle) {
+      /* Rewrite criteria so that we now look for a double
+         buffered visual which will then get treated as a
+         single buffered visual. */
+      for (i = 0; i < ncriteria; i++) {
+        if (criteria[i].capability == DOUBLEBUFFER
+          && criteria[i].comparison == EQ
+          && criteria[i].value == 0) {
+          criteria[i].value = 1;
+        }
+      }
+      visinfo = findMatch(fbmodes, nfbmodes, criteria, ncriteria, fbc);
+      if (visinfo) {
+        *treatAsSingle = 1;
+      }
+    }
+  }
+  free(criteria);
+
+  if (visinfo) {
+#if defined(_WIN32)
+    /* We could have a valid pixel format for drawing to a
+       bitmap. However, we don't want to draw into a bitmap, we 
+       need one that can be used with a window, so make sure
+       that this is true. */
+    if (!(visinfo->dwFlags & PFD_DRAW_TO_WINDOW))
+      return NULL;
+#endif
+    return visinfo;
+  } else {
+    return NULL;
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutInitDisplayString(const char *string)
+{
+#ifdef _WIN32
+  XHDC = GetDC(GetDesktopWindow());
+#endif
+
+  __glutDetermineVisualFromString = getVisualInfoFromString;
+  if (__glutDisplayString) {
+    free(__glutDisplayString);
+  }
+  if (string) {
+    __glutDisplayString = __glutStrdup(string);
+    if (!__glutDisplayString)
+      __glutFatalError("out of memory.");
+  } else {
+    __glutDisplayString = NULL;
+  }
+}
+/* ENDCENTRY */
+
+#ifdef TEST
+
+Criterion requiredWindowCriteria[] =
+{
+  {LEVEL, EQ, 0},
+  {TRANSPARENT, EQ, 0}
+};
+int numRequiredWindowCriteria = sizeof(requiredWindowCriteria) / sizeof(Criterion);
+int requiredWindowCriteriaMask = (1 << LEVEL) | (1 << TRANSPARENT);
+
+Criterion requiredOverlayCriteria[] =
+{
+  {LEVEL, EQ, 1},
+  {TRANSPARENT, EQ, 1},
+  {XPSEUDOCOLOR, EQ, 1},
+  {RGBA, EQ, 0},
+  {BUFFER_SIZE, GTE, 1}
+};
+int numRequiredOverlayCriteria = sizeof(requiredOverlayCriteria) / sizeof(Criterion);
+int requiredOverlayCriteriaMask =
+(1 << LEVEL) | (1 << TRANSPARENT) | (1 << XSTATICGRAY) | (1 << RGBA) | (1 << CI_MODE);
+
+int
+main(int argc, char **argv)
+{
+  Display *dpy;
+  XVisualInfo *vinfo;
+  Bool treatAsSingle;
+  char *str, buffer[1024];
+  int tty = isatty(fileno(stdin));
+  int overlay = 0, showconfig = 0;
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+  GLXFBConfigSGIX fbc;
+#else
+  void *fbc;
+#endif
+
+#if !defined(_WIN32)
+  dpy = XOpenDisplay(NULL);
+  if (dpy == NULL) {
+    printf("Could not connect to X server\n");
+    exit(1);
+  }
+  __glutDisplay = dpy;
+  __glutScreen = DefaultScreen(__glutDisplay);
+#endif
+  while (!feof(stdin)) {
+    if (tty)
+      printf("dstr> ");
+    str = gets(buffer);
+    if (str) {
+      printf("\n");
+      if (!strcmp("v", str)) {
+        verbose = 1 - verbose;
+        printf("verbose = %d\n\n", verbose);
+      } else if (!strcmp("s", str)) {
+        showconfig = 1 - showconfig;
+        printf("showconfig = %d\n\n", showconfig);
+      } else if (!strcmp("o", str)) {
+        overlay = 1 - overlay;
+        printf("overlay = %d\n\n", overlay);
+      } else {
+        if (overlay) {
+          vinfo = getVisualInfoFromString(str, &treatAsSingle,
+            requiredOverlayCriteria, numRequiredOverlayCriteria, requiredOverlayCriteriaMask, (void**) &fbc);
+        } else {
+          vinfo = getVisualInfoFromString(str, &treatAsSingle,
+            requiredWindowCriteria, numRequiredWindowCriteria, requiredWindowCriteriaMask, (void**) &fbc);
+        }
+        if (vinfo) {
+          printf("\n");
+          if (!tty)
+            printf("Display string: %s", str);
+#ifdef _WIN32
+          printf("Visual = 0x%x\n", 0);
+#else
+          printf("Visual = 0x%x%s\n", vinfo->visualid, fbc ? " (needs FBC)" : "");
+#endif
+          if (treatAsSingle) {
+            printf("Treat as SINGLE.\n");
+          }
+          if (showconfig) {
+            int glxCapable, bufferSize, level, renderType, doubleBuffer,
+              stereo, auxBuffers, redSize, greenSize, blueSize,
+              alphaSize, depthSize, stencilSize, acRedSize, acGreenSize,
+              acBlueSize, acAlphaSize;
+
+            glXGetConfig(dpy, vinfo, GLX_BUFFER_SIZE, &bufferSize);
+            glXGetConfig(dpy, vinfo, GLX_LEVEL, &level);
+            glXGetConfig(dpy, vinfo, GLX_RGBA, &renderType);
+            glXGetConfig(dpy, vinfo, GLX_DOUBLEBUFFER, &doubleBuffer);
+            glXGetConfig(dpy, vinfo, GLX_STEREO, &stereo);
+            glXGetConfig(dpy, vinfo, GLX_AUX_BUFFERS, &auxBuffers);
+            glXGetConfig(dpy, vinfo, GLX_RED_SIZE, &redSize);
+            glXGetConfig(dpy, vinfo, GLX_GREEN_SIZE, &greenSize);
+            glXGetConfig(dpy, vinfo, GLX_BLUE_SIZE, &blueSize);
+            glXGetConfig(dpy, vinfo, GLX_ALPHA_SIZE, &alphaSize);
+            glXGetConfig(dpy, vinfo, GLX_DEPTH_SIZE, &depthSize);
+            glXGetConfig(dpy, vinfo, GLX_STENCIL_SIZE, &stencilSize);
+            glXGetConfig(dpy, vinfo, GLX_ACCUM_RED_SIZE, &acRedSize);
+            glXGetConfig(dpy, vinfo, GLX_ACCUM_GREEN_SIZE, &acGreenSize);
+            glXGetConfig(dpy, vinfo, GLX_ACCUM_BLUE_SIZE, &acBlueSize);
+            glXGetConfig(dpy, vinfo, GLX_ACCUM_ALPHA_SIZE, &acAlphaSize);
+            printf("RGBA = (%d, %d, %d, %d)\n", redSize, greenSize, blueSize, alphaSize);
+            printf("acc  = (%d, %d, %d, %d)\n", acRedSize, acGreenSize, acBlueSize, acAlphaSize);
+            printf("db   = %d\n", doubleBuffer);
+            printf("str  = %d\n", stereo);
+            printf("aux  = %d\n", auxBuffers);
+            printf("lvl  = %d\n", level);
+            printf("buf  = %d\n", bufferSize);
+            printf("rgba = %d\n", renderType);
+            printf("z    = %d\n", depthSize);
+            printf("s    = %d\n", stencilSize);
+          }
+        } else {
+          printf("\n");
+          printf("No match.\n");
+        }
+        printf("\n");
+      }
+    }
+  }
+  printf("\n");
+  return 0;
+}
+#endif
diff --git a/src/glut/glx/glut_event.c b/src/glut/glx/glut_event.c
new file mode 100644
index 0000000000..2c46203e59
--- /dev/null
+++ b/src/glut/glx/glut_event.c
@@ -0,0 +1,1353 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1997, 1998. */
+
+/* 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 <errno.h>
+#include <assert.h>
+#include <string.h>  /* Some FD_ZERO macros use memset without
+                        prototyping memset. */
+
+/* Much of the following #ifdef logic to include the proper
+   prototypes for the select system call is based on logic
+   from the X11R6.3 version of <X11/Xpoll.h>. */
+
+#if !defined(_WIN32)
+# ifdef __sgi
+#  include <bstring.h>    /* prototype for bzero used by FD_ZERO */
+# endif
+# if (defined(SVR4) || defined(CRAY) || defined(AIXV3)) && !defined(FD_SETSIZE)
+#  include <sys/select.h> /* select system call interface */
+#  ifdef luna
+#   include <sysent.h>
+#  endif
+# endif
+  /* AIX 4.2 fubar-ed <sys/select.h>, so go to heroic measures to get it */
+# if defined(AIXV4) && !defined(NFDBITS)
+#  include <sys/select.h>
+# endif
+#endif /* !_WIN32 */
+
+#include <sys/types.h>
+
+#if !defined(_WIN32)
+# if defined(__vms) && ( __VMS_VER < 70000000 )
+#  include <sys/time.h>
+# else
+#  ifndef __vms
+#   include <sys/time.h>
+#  endif
+# endif
+# include <unistd.h>
+# include <X11/Xlib.h>
+# include <X11/keysym.h>
+#else
+# ifdef __CYGWIN32__
+#  include <sys/time.h>
+# else
+#  include <sys/timeb.h>
+# endif
+# ifdef __hpux
+   /* XXX Bert Gijsbers <bert@mc.bio.uva.nl> reports that HP-UX
+      needs different keysyms for the End, Insert, and Delete keys
+      to work on an HP 715.  It would be better if HP generated
+      standard keysyms for standard keys. */
+#  include <X11/HPkeysym.h>
+# endif
+#endif /* !_WIN32 */
+
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+#include <ssdef.h>
+#include <psldef.h>
+extern int SYS$CLREF(int efn);
+extern int SYS$SETIMR(unsigned int efn, struct timeval *timeout, void *ast,
+  unsigned int request_id, unsigned int flags);
+extern int SYS$WFLOR(unsigned int efn, unsigned int mask);
+extern int SYS$CANTIM(unsigned int request_id, unsigned int mode);
+#endif /* __vms, VMs 6.2 or earlier */
+
+#include "glutint.h"
+
+static GLUTtimer *freeTimerList = NULL;
+
+GLUTidleCB __glutIdleFunc = NULL;
+GLUTtimer *__glutTimerList = NULL;
+#ifdef SUPPORT_FORTRAN
+GLUTtimer *__glutNewTimer;
+#endif
+GLUTwindow *__glutWindowWorkList = NULL;
+GLUTmenu *__glutMappedMenu;
+GLUTmenu *__glutCurrentMenu = NULL;
+
+void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
+#if !defined(_WIN32)
+void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item, int num, int type) = NULL;
+void (*__glutFinishMenu)(Window win, int x, int y);
+void (*__glutPaintMenu)(GLUTmenu * menu);
+void (*__glutStartMenu)(GLUTmenu * menu, GLUTwindow * window, int x, int y, int x_win, int y_win);
+GLUTmenu * (*__glutGetMenuByNum)(int menunum);
+GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu, Window win, int *which);
+GLUTmenu * (*__glutGetMenu)(Window win);
+#endif
+
+Atom __glutMotifHints = None;
+/* Modifier mask of ~0 implies not in core input callback. */
+unsigned int __glutModifierMask = (unsigned int) ~0;
+int __glutWindowDamaged = 0;
+
+void APIENTRY
+glutIdleFunc(GLUTidleCB idleFunc)
+{
+  __glutIdleFunc = idleFunc;
+}
+
+void APIENTRY
+glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value)
+{
+  GLUTtimer *timer, *other;
+  GLUTtimer **prevptr;
+  struct timeval now;
+
+  if (!timerFunc)
+    return;
+
+  if (freeTimerList) {
+    timer = freeTimerList;
+    freeTimerList = timer->next;
+  } else {
+    timer = (GLUTtimer *) malloc(sizeof(GLUTtimer));
+    if (!timer)
+      __glutFatalError("out of memory.");
+  }
+
+  timer->func = timerFunc;
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+  /* VMS time is expressed in units of 100 ns */
+  timer->timeout.val = interval * TICKS_PER_MILLISECOND;
+#else
+  timer->timeout.tv_sec = (int) interval / 1000;
+  timer->timeout.tv_usec = (int) (interval % 1000) * 1000;
+#endif
+  timer->value = value;
+  timer->next = NULL;
+  GETTIMEOFDAY(&now);
+  ADD_TIME(timer->timeout, timer->timeout, now);
+  prevptr = &__glutTimerList;
+  other = *prevptr;
+  while (other && IS_AFTER(other->timeout, timer->timeout)) {
+    prevptr = &other->next;
+    other = *prevptr;
+  }
+  timer->next = other;
+#ifdef SUPPORT_FORTRAN
+  __glutNewTimer = timer;  /* for Fortran binding! */
+#endif
+  *prevptr = timer;
+}
+
+void
+handleTimeouts(void)
+{
+  struct timeval now;
+  GLUTtimer *timer;
+
+  /* Assumption is that __glutTimerList is already determined
+     to be non-NULL. */
+  GETTIMEOFDAY(&now);
+  while (IS_AT_OR_AFTER(__glutTimerList->timeout, now)) {
+    timer = __glutTimerList;
+    timer->func(timer->value);
+    __glutTimerList = timer->next;
+    timer->next = freeTimerList;
+    freeTimerList = timer;
+    if (!__glutTimerList)
+      break;
+  }
+}
+
+void
+__glutPutOnWorkList(GLUTwindow * window, int workMask)
+{
+  if (window->workMask) {
+    /* Already on list; just OR in new workMask. */
+    window->workMask |= workMask;
+  } else {
+    /* Update work mask and add to window work list. */
+    window->workMask = workMask;
+    /* Assert that if the window does not have a
+       workMask already, the window should definitely
+       not be the head of the work list. */
+    assert(window != __glutWindowWorkList);
+    window->prevWorkWin = __glutWindowWorkList;
+    __glutWindowWorkList = window;
+  }
+}
+
+void
+__glutPostRedisplay(GLUTwindow * window, int layerMask)
+{
+  int shown = (layerMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) ?
+    window->shownState : window->overlay->shownState;
+
+  /* Post a redisplay if the window is visible (or the
+     visibility of the window is unknown, ie. window->visState
+     == -1) _and_ the layer is known to be shown. */
+  if (window->visState != GLUT_HIDDEN
+    && window->visState != GLUT_FULLY_COVERED && shown) {
+    __glutPutOnWorkList(window, layerMask);
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutPostRedisplay(void)
+{
+  __glutPostRedisplay(__glutCurrentWindow, GLUT_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.  See also glutPostWindowOverlayRedisplay. */
+void APIENTRY
+glutPostWindowRedisplay(int win)
+{
+  __glutPostRedisplay(__glutWindowList[win - 1], GLUT_REDISPLAY_WORK);
+}
+
+/* ENDCENTRY */
+static GLUTeventParser *eventParserList = NULL;
+
+/* __glutRegisterEventParser allows another module to register
+   to intercept X events types not otherwise acted on by the
+   GLUT processEventsAndTimeouts routine.  The X Input
+   extension support code uses an event parser for handling X
+   Input extension events.  */
+
+void
+__glutRegisterEventParser(GLUTeventParser * parser)
+{
+  parser->next = eventParserList;
+  eventParserList = parser;
+}
+
+static void
+markWindowHidden(GLUTwindow * window)
+{
+  if (GLUT_HIDDEN != window->visState) {
+    GLUTwindow *child;
+
+    if (window->windowStatus) {
+      window->visState = GLUT_HIDDEN;
+      __glutSetWindow(window);
+      window->windowStatus(GLUT_HIDDEN);
+    }
+    /* An unmap is only reported on a single window; its
+       descendents need to know they are no longer visible. */
+    child = window->children;
+    while (child) {
+      markWindowHidden(child);
+      child = child->siblings;
+    }
+  }
+}
+
+#if !defined(_WIN32)
+
+static void
+purgeStaleWindow(Window win)
+{
+  GLUTstale **pEntry = &__glutStaleWindowList;
+  GLUTstale *entry = __glutStaleWindowList;
+
+  /* Tranverse singly-linked stale window list look for the
+     window ID. */
+  while (entry) {
+    if (entry->win == win) {
+      /* Found it; delete it. */
+      *pEntry = entry->next;
+      free(entry);
+      return;
+    } else {
+      pEntry = &entry->next;
+      entry = *pEntry;
+    }
+  }
+}
+
+/* Unlike XNextEvent, if a signal arrives,
+   interruptibleXNextEvent will return (with a zero return
+   value).  This helps GLUT drop out of XNextEvent if a signal
+   is delivered.  The intent is so that a GLUT program can call 
+   glutIdleFunc in a signal handler to register an idle func
+   and then immediately get dropped into the idle func (after
+   returning from the signal handler).  The idea is to make
+   GLUT's main loop reliably interruptible by signals. */
+static int
+interruptibleXNextEvent(Display * dpy, XEvent * event)
+{
+  fd_set fds;
+  int rc;
+
+  /* Flush X protocol since XPending does not do this
+     implicitly. */
+  XFlush(__glutDisplay);
+  for (;;) {
+    if (XPending(__glutDisplay)) {
+      XNextEvent(dpy, event);
+      return 1;
+    }
+    FD_ZERO(&fds);
+    FD_SET(__glutConnectionFD, &fds);
+    rc = select(__glutConnectionFD + 1, &fds,
+      NULL, NULL, NULL);
+    if (rc < 0) {
+      if (errno == EINTR) {
+        return 0;
+      } else {
+        __glutFatalError("select error.");
+      }
+    }
+  }
+}
+
+#endif
+
+static void
+processEventsAndTimeouts(void)
+{
+  do {
+#if defined(_WIN32)
+    MSG event;
+
+    if(!GetMessage(&event, NULL, 0, 0))	/* bail if no more messages */
+      exit(0);
+    TranslateMessage(&event);		/* translate virtual-key messages */
+    DispatchMessage(&event);		/* call the window proc */
+    /* see win32_event.c for event (message) processing procedures */
+#else
+    static int mappedMenuButton;
+    GLUTeventParser *parser;
+    XEvent event, ahead;
+    GLUTwindow *window;
+    GLUTkeyboardCB keyboard;
+    GLUTspecialCB special;
+    int gotEvent, width, height;
+
+    gotEvent = interruptibleXNextEvent(__glutDisplay, &event);
+    if (gotEvent) {
+      switch (event.type) {
+      case MappingNotify:
+        XRefreshKeyboardMapping((XMappingEvent *) & event);
+        break;
+      case ConfigureNotify:
+        window = __glutGetWindow(event.xconfigure.window);
+        if (window) {
+          if (window->win != event.xconfigure.window) {
+            /* Ignore ConfigureNotify sent to the overlay
+               planes. GLUT could get here because overlays
+               select for StructureNotify events to receive
+               DestroyNotify. */
+            break;
+          }
+          width = event.xconfigure.width;
+          height = event.xconfigure.height;
+          if (width != window->width || height != window->height) {
+            if (window->overlay) {
+              XResizeWindow(__glutDisplay, window->overlay->win, width, height);
+            }
+            window->width = width;
+            window->height = height;
+            __glutSetWindow(window);
+            /* Do not execute OpenGL out of sequence with
+               respect to the XResizeWindow request! */
+            glXWaitX();
+            window->reshape(width, height);
+            window->forceReshape = False;
+            /* A reshape should be considered like posting a
+               repair; this is necessary for the "Mesa
+               glXSwapBuffers to repair damage" hack to operate
+               correctly.  Without it, there's not an initial
+               back buffer render from which to blit from when
+               damage happens to the window. */
+            __glutPostRedisplay(window, GLUT_REPAIR_WORK);
+          }
+        }
+        break;
+      case Expose:
+        /* compress expose events */
+        while (XEventsQueued(__glutDisplay, QueuedAfterReading)
+          > 0) {
+          XPeekEvent(__glutDisplay, &ahead);
+          if (ahead.type != Expose ||
+            ahead.xexpose.window != event.xexpose.window) {
+            break;
+          }
+          XNextEvent(__glutDisplay, &event);
+        }
+        if (event.xexpose.count == 0) {
+          GLUTmenu *menu;
+
+          if (__glutMappedMenu &&
+            (menu = __glutGetMenu(event.xexpose.window))) {
+            __glutPaintMenu(menu);
+          } else {
+            window = __glutGetWindow(event.xexpose.window);
+            if (window) {
+              if (window->win == event.xexpose.window) {
+                __glutPostRedisplay(window, GLUT_REPAIR_WORK);
+              } else if (window->overlay && window->overlay->win == event.xexpose.window) {
+                __glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
+              }
+            }
+          }
+        } else {
+          /* there are more exposes to read; wait to redisplay */
+        }
+        break;
+      case ButtonPress:
+      case ButtonRelease:
+        if (__glutMappedMenu && event.type == ButtonRelease
+          && mappedMenuButton == event.xbutton.button) {
+          /* Menu is currently popped up and its button is
+             released. */
+          __glutFinishMenu(event.xbutton.window, event.xbutton.x, event.xbutton.y);
+        } else {
+          window = __glutGetWindow(event.xbutton.window);
+          if (window) {
+            GLUTmenu *menu;
+	    int menuNum;
+
+            menuNum = window->menu[event.xbutton.button - 1];
+            /* Make sure that __glutGetMenuByNum is only called if there
+	       really is a menu present. */
+            if ((menuNum > 0) && (menu = __glutGetMenuByNum(menuNum))) {
+              if (event.type == ButtonPress && !__glutMappedMenu) {
+                __glutStartMenu(menu, window,
+                  event.xbutton.x_root, event.xbutton.y_root,
+                  event.xbutton.x, event.xbutton.y);
+                mappedMenuButton = event.xbutton.button;
+              } else {
+                /* Ignore a release of a button with a menu
+                   attatched to it when no menu is popped up,
+                   or ignore a press when another menu is
+                   already popped up. */
+              }
+            } else if (window->mouse) {
+              __glutSetWindow(window);
+              __glutModifierMask = event.xbutton.state;
+              window->mouse(event.xbutton.button - 1,
+                event.type == ButtonRelease ?
+                GLUT_UP : GLUT_DOWN,
+                event.xbutton.x, event.xbutton.y);
+              __glutModifierMask = ~0;
+            } else {
+              /* Stray mouse events.  Ignore. */
+            }
+          } else {
+            /* Window might have been destroyed and all the 
+               events for the window may not yet be received. */
+          }
+        }
+        break;
+      case MotionNotify:
+        if (!__glutMappedMenu) {
+          window = __glutGetWindow(event.xmotion.window);
+          if (window) {
+            /* If motion function registered _and_ buttons held 
+               * down, call motion function...  */
+            if (window->motion && event.xmotion.state &
+              (Button1Mask | Button2Mask | Button3Mask)) {
+              __glutSetWindow(window);
+              window->motion(event.xmotion.x, event.xmotion.y);
+            }
+            /* If passive motion function registered _and_
+               buttons not held down, call passive motion
+               function...  */
+            else if (window->passive &&
+                ((event.xmotion.state &
+                    (Button1Mask | Button2Mask | Button3Mask)) ==
+                0)) {
+              __glutSetWindow(window);
+              window->passive(event.xmotion.x,
+                event.xmotion.y);
+            }
+          }
+        } else {
+          /* Motion events are thrown away when a pop up menu
+             is active. */
+        }
+        break;
+      case KeyPress:
+      case KeyRelease:
+        window = __glutGetWindow(event.xkey.window);
+        if (!window) {
+          break;
+        }
+	if (event.type == KeyPress) {
+	  keyboard = window->keyboard;
+	} else {
+
+	  /* If we are ignoring auto repeated keys for this window,
+	     check if the next event in the X event queue is a KeyPress
+	     for the exact same key (and at the exact same time) as the
+	     key being released.  The X11 protocol will send auto
+	     repeated keys as such KeyRelease/KeyPress pairs. */
+
+	  if (window->ignoreKeyRepeat) {
+	    if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
+	      XPeekEvent(__glutDisplay, &ahead);
+	      if (ahead.type == KeyPress
+	        && ahead.xkey.window == event.xkey.window
+	        && ahead.xkey.keycode == event.xkey.keycode
+	        && ahead.xkey.time == event.xkey.time) {
+		/* Pop off the repeated KeyPress and ignore
+		   the auto repeated KeyRelease/KeyPress pair. */
+	        XNextEvent(__glutDisplay, &event);
+	        break;
+	      }
+	    }
+	  }
+	  keyboard = window->keyboardUp;
+	}
+        if (keyboard) {
+          char tmp[1];
+          int rc;
+
+          rc = XLookupString(&event.xkey, tmp, sizeof(tmp),
+            NULL, NULL);
+          if (rc) {
+            __glutSetWindow(window);
+            __glutModifierMask = event.xkey.state;
+            keyboard(tmp[0],
+              event.xkey.x, event.xkey.y);
+            __glutModifierMask = ~0;
+            break;
+          }
+        }
+	if (event.type == KeyPress) {
+	  special = window->special;
+        } else {
+	  special = window->specialUp;
+	}
+        if (special) {
+          KeySym ks;
+          int key;
+
+/* Introduced in X11R6:  (Partial list of) Keypad Functions.  Define
+   in place in case compiling against an older pre-X11R6
+   X11/keysymdef.h file. */
+#ifndef XK_KP_Home
+#define XK_KP_Home              0xFF95
+#endif
+#ifndef XK_KP_Left
+#define XK_KP_Left              0xFF96
+#endif
+#ifndef XK_KP_Up
+#define XK_KP_Up                0xFF97
+#endif
+#ifndef XK_KP_Right
+#define XK_KP_Right             0xFF98
+#endif
+#ifndef XK_KP_Down
+#define XK_KP_Down              0xFF99
+#endif
+#ifndef XK_KP_Prior
+#define XK_KP_Prior             0xFF9A
+#endif
+#ifndef XK_KP_Next
+#define XK_KP_Next              0xFF9B
+#endif
+#ifndef XK_KP_End
+#define XK_KP_End               0xFF9C
+#endif
+#ifndef XK_KP_Insert
+#define XK_KP_Insert            0xFF9E
+#endif
+#ifndef XK_KP_Delete
+#define XK_KP_Delete            0xFF9F
+#endif
+
+          ks = XLookupKeysym((XKeyEvent *) & event, 0);
+          /* XXX Verbose, but makes no assumptions about keysym
+             layout. */
+          switch (ks) {
+/* *INDENT-OFF* */
+          /* function keys */
+          case XK_F1:    key = GLUT_KEY_F1; break;
+          case XK_F2:    key = GLUT_KEY_F2; break;
+          case XK_F3:    key = GLUT_KEY_F3; break;
+          case XK_F4:    key = GLUT_KEY_F4; break;
+          case XK_F5:    key = GLUT_KEY_F5; break;
+          case XK_F6:    key = GLUT_KEY_F6; break;
+          case XK_F7:    key = GLUT_KEY_F7; break;
+          case XK_F8:    key = GLUT_KEY_F8; break;
+          case XK_F9:    key = GLUT_KEY_F9; break;
+          case XK_F10:   key = GLUT_KEY_F10; break;
+          case XK_F11:   key = GLUT_KEY_F11; break;
+          case XK_F12:   key = GLUT_KEY_F12; break;
+          /* directional keys */
+	  case XK_KP_Left:
+          case XK_Left:  key = GLUT_KEY_LEFT; break;
+	  case XK_KP_Up: /* Introduced in X11R6. */
+          case XK_Up:    key = GLUT_KEY_UP; break;
+	  case XK_KP_Right: /* Introduced in X11R6. */
+          case XK_Right: key = GLUT_KEY_RIGHT; break;
+	  case XK_KP_Down: /* Introduced in X11R6. */
+          case XK_Down:  key = GLUT_KEY_DOWN; break;
+/* *INDENT-ON* */
+
+	  case XK_KP_Prior: /* Introduced in X11R6. */
+          case XK_Prior:
+            /* XK_Prior same as X11R6's XK_Page_Up */
+            key = GLUT_KEY_PAGE_UP;
+            break;
+	  case XK_KP_Next: /* Introduced in X11R6. */
+          case XK_Next:
+            /* XK_Next same as X11R6's XK_Page_Down */
+            key = GLUT_KEY_PAGE_DOWN;
+            break;
+	  case XK_KP_Home: /* Introduced in X11R6. */
+          case XK_Home:
+            key = GLUT_KEY_HOME;
+            break;
+#ifdef __hpux
+          case XK_Select:
+#endif
+	  case XK_KP_End: /* Introduced in X11R6. */
+          case XK_End:
+            key = GLUT_KEY_END;
+            break;
+#ifdef __hpux
+          case XK_InsertChar:
+#endif
+	  case XK_KP_Insert: /* Introduced in X11R6. */
+          case XK_Insert:
+            key = GLUT_KEY_INSERT;
+            break;
+#ifdef __hpux
+          case XK_DeleteChar:
+#endif
+	  case XK_KP_Delete: /* Introduced in X11R6. */
+            /* The Delete character is really an ASCII key. */
+            __glutSetWindow(window);
+            keyboard(127,  /* ASCII Delete character. */
+              event.xkey.x, event.xkey.y);
+            goto skip;
+          default:
+            goto skip;
+          }
+          __glutSetWindow(window);
+          __glutModifierMask = event.xkey.state;
+          special(key, event.xkey.x, event.xkey.y);
+          __glutModifierMask = ~0;
+        skip:;
+        }
+        break;
+      case EnterNotify:
+      case LeaveNotify:
+        if (event.xcrossing.mode != NotifyNormal ||
+          event.xcrossing.detail == NotifyNonlinearVirtual ||
+          event.xcrossing.detail == NotifyVirtual) {
+
+          /* Careful to ignore Enter/LeaveNotify events that
+             come from the pop-up menu pointer grab and ungrab. 
+             Also, ignore "virtual" Enter/LeaveNotify events
+             since they represent the pointer passing through
+             the window hierarchy without actually entering or
+             leaving the actual real estate of a window.  */
+
+          break;
+        }
+        if (__glutMappedMenu) {
+          GLUTmenuItem *item;
+          int num;
+
+          item = __glutGetMenuItem(__glutMappedMenu,
+            event.xcrossing.window, &num);
+          if (item) {
+            __glutMenuItemEnterOrLeave(item, num, event.type);
+            break;
+          }
+        }
+        window = __glutGetWindow(event.xcrossing.window);
+        if (window) {
+          if (window->entry) {
+            if (event.type == EnterNotify) {
+
+              /* With overlays established, X can report two
+                 enter events for both the overlay and normal
+                 plane window. Do not generate a second enter
+                 callback if we reported one without an
+                 intervening leave. */
+
+              if (window->entryState != EnterNotify) {
+                int num = window->num;
+                Window xid = window->win;
+
+                window->entryState = EnterNotify;
+                __glutSetWindow(window);
+                window->entry(GLUT_ENTERED);
+
+                if (__glutMappedMenu) {
+
+                  /* Do not generate any passive motion events
+                     when menus are in use. */
+
+                } else {
+
+                  /* An EnterNotify event can result in a
+                     "compound" callback if a passive motion
+                     callback is also registered. In this case,
+                     be a little paranoid about the possibility
+                     the window could have been destroyed in the
+                     entry callback. */
+
+                  window = __glutWindowList[num];
+                  if (window && window->passive && window->win == xid) {
+                    __glutSetWindow(window);
+                    window->passive(event.xcrossing.x, event.xcrossing.y);
+                  }
+                }
+              }
+            } else {
+              if (window->entryState != LeaveNotify) {
+
+                /* When an overlay is established for a window
+                   already mapped and with the pointer in it,
+                   the X server will generate a leave/enter
+                   event pair as the pointer leaves (without
+                   moving) from the normal plane X window to
+                   the newly mapped overlay  X window (or vice
+                   versa). This enter/leave pair should not be
+                   reported to the GLUT program since the pair
+                   is a consequence of creating (or destroying) 
+                   the overlay, not an actual leave from the
+                   GLUT window. */
+
+                if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
+                  XPeekEvent(__glutDisplay, &ahead);
+                  if (ahead.type == EnterNotify &&
+                    __glutGetWindow(ahead.xcrossing.window) == window) {
+                    XNextEvent(__glutDisplay, &event);
+                    break;
+                  }
+                }
+                window->entryState = LeaveNotify;
+                __glutSetWindow(window);
+                window->entry(GLUT_LEFT);
+              }
+            }
+          } else if (window->passive) {
+            __glutSetWindow(window);
+            window->passive(event.xcrossing.x, event.xcrossing.y);
+          }
+        }
+        break;
+      case UnmapNotify:
+        /* MapNotify events are not needed to maintain
+           visibility state since VisibilityNotify events will
+           be delivered when a window becomes visible from
+           mapping.  However, VisibilityNotify events are not
+           delivered when a window is unmapped (for the window
+           or its children). */
+        window = __glutGetWindow(event.xunmap.window);
+        if (window) {
+          if (window->win != event.xconfigure.window) {
+            /* Ignore UnmapNotify sent to the overlay planes.
+               GLUT could get here because overlays select for
+               StructureNotify events to receive DestroyNotify. 
+             */
+            break;
+          }
+          markWindowHidden(window);
+        }
+        break;
+      case VisibilityNotify:
+        window = __glutGetWindow(event.xvisibility.window);
+        if (window) {
+          /* VisibilityUnobscured+1 = GLUT_FULLY_RETAINED,
+             VisibilityPartiallyObscured+1 =
+             GLUT_PARTIALLY_RETAINED, VisibilityFullyObscured+1 
+             =  GLUT_FULLY_COVERED. */
+          int visState = event.xvisibility.state + 1;
+
+          if (visState != window->visState) {
+            if (window->windowStatus) {
+              window->visState = visState;
+              __glutSetWindow(window);
+              window->windowStatus(visState);
+            }
+          }
+        }
+        break;
+      case ClientMessage:
+        if (event.xclient.data.l[0] == __glutWMDeleteWindow)
+          exit(0);
+        break;
+      case DestroyNotify:
+        purgeStaleWindow(event.xdestroywindow.window);
+        break;
+      case CirculateNotify:
+      case CreateNotify:
+      case GravityNotify:
+      case ReparentNotify:
+        /* Uninteresting to GLUT (but possible for GLUT to
+           receive). */
+        break;
+      default:
+        /* Pass events not directly handled by the GLUT main
+           event loop to any event parsers that have been
+           registered.  In this way, X Input extension events
+           are passed to the correct handler without forcing
+           all GLUT programs to support X Input event handling. 
+         */
+        parser = eventParserList;
+        while (parser) {
+          if (parser->func(&event))
+            break;
+          parser = parser->next;
+        }
+        break;
+      }
+    }
+#endif /* _WIN32 */
+    if (__glutTimerList) {
+      handleTimeouts();
+    }
+  }
+  while (XPending(__glutDisplay));
+}
+
+static void
+waitForSomething(void)
+{
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+  static struct timeval zerotime =
+  {0};
+  unsigned int timer_efn;
+#define timer_id 'glut' /* random :-) number */
+  unsigned int wait_mask;
+#else
+  static struct timeval zerotime =
+  {0, 0};
+#if !defined(_WIN32)
+  fd_set fds;
+#endif
+#endif
+  struct timeval now, timeout, waittime;
+#if !defined(_WIN32)
+  int rc;
+#endif
+
+  /* Flush X protocol since XPending does not do this
+     implicitly. */
+  XFlush(__glutDisplay);
+  if (XPending(__glutDisplay)) {
+    /* It is possible (but quite rare) that XFlush may have
+       needed to wait for a writable X connection file
+       descriptor, and in the process, may have had to read off
+       X protocol from the file descriptor. If XPending is true,
+       this case occured and we should avoid waiting in select
+       since X protocol buffered within Xlib is due to be
+       processed and potentially no more X protocol is on the
+       file descriptor, so we would risk waiting improperly in
+       select. */
+    goto immediatelyHandleXinput;
+  }
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+  timeout = __glutTimerList->timeout;
+  GETTIMEOFDAY(&now);
+  wait_mask = 1 << (__glutConnectionFD & 31);
+  if (IS_AFTER(now, timeout)) {
+    /* We need an event flag for the timer. */
+    /* XXX The `right' way to do this is to use LIB$GET_EF, but
+       since it needs to be in the same cluster as the EFN for
+       the display, we will have hack it. */
+    timer_efn = __glutConnectionFD - 1;
+    if ((timer_efn / 32) != (__glutConnectionFD / 32)) {
+      timer_efn = __glutConnectionFD + 1;
+    }
+    rc = SYS$CLREF(timer_efn);
+    rc = SYS$SETIMR(timer_efn, &timeout, NULL, timer_id, 0);
+    wait_mask |= 1 << (timer_efn & 31);
+  } else {
+    timer_efn = 0;
+  }
+  rc = SYS$WFLOR(__glutConnectionFD, wait_mask);
+  if (timer_efn != 0 && SYS$CLREF(timer_efn) == SS$_WASCLR) {
+    rc = SYS$CANTIM(timer_id, PSL$C_USER);
+  }
+  /* XXX There does not seem to be checking of "rc" in the code
+     above.  Can any of the SYS$ routines above fail? */
+#else /* not vms6.2 or lower */
+#if !defined(_WIN32)
+  FD_ZERO(&fds);
+  FD_SET(__glutConnectionFD, &fds);
+#endif
+  timeout = __glutTimerList->timeout;
+  GETTIMEOFDAY(&now);
+  if (IS_AFTER(now, timeout)) {
+    TIMEDELTA(waittime, timeout, now);
+  } else {
+    waittime = zerotime;
+  }
+#if !defined(_WIN32)
+  rc = select(__glutConnectionFD + 1, &fds,
+    NULL, NULL, &waittime);
+  if (rc < 0 && errno != EINTR)
+    __glutFatalError("select error.");
+#else
+
+  MsgWaitForMultipleObjects(0, NULL, FALSE,
+    waittime.tv_sec*1000 + waittime.tv_usec/1000, QS_ALLINPUT);
+
+#endif
+#endif /* not vms6.2 or lower */
+  /* Without considering the cause of select unblocking, check
+     for pending X events and handle any timeouts (by calling
+     processEventsAndTimeouts).  We always look for X events
+     even if select returned with 0 (indicating a timeout);
+     otherwise we risk starving X event processing by continous
+     timeouts. */
+  if (XPending(__glutDisplay)) {
+  immediatelyHandleXinput:
+    processEventsAndTimeouts();
+  } else {
+    if (__glutTimerList)
+      handleTimeouts();
+  }
+}
+
+static void
+idleWait(void)
+{
+  if (XPending(__glutDisplay)) {
+    processEventsAndTimeouts();
+  } else {
+    if (__glutTimerList) {
+      handleTimeouts();
+    }
+  }
+  /* Make sure idle func still exists! */
+  if (__glutIdleFunc) {
+    __glutIdleFunc();
+  }
+}
+
+static GLUTwindow **beforeEnd;
+
+static GLUTwindow *
+processWindowWorkList(GLUTwindow * window)
+{
+  int workMask;
+
+  if (window->prevWorkWin) {
+    window->prevWorkWin = processWindowWorkList(window->prevWorkWin);
+  } else {
+    beforeEnd = &window->prevWorkWin;
+  }
+
+  /* Capture work mask for work that needs to be done to this
+     window, then clear the window's work mask (excepting the
+     dummy work bit, see below).  Then, process the captured
+     work mask.  This allows callbacks in the processing the
+     captured work mask to set the window's work mask for
+     subsequent processing. */
+
+  workMask = window->workMask;
+  assert((workMask & GLUT_DUMMY_WORK) == 0);
+
+  /* Set the dummy work bit, clearing all other bits, to
+     indicate that the window is currently on the window work
+     list _and_ that the window's work mask is currently being
+     processed.  This convinces __glutPutOnWorkList that this
+     window is on the work list still. */
+  window->workMask = GLUT_DUMMY_WORK;
+
+  /* Optimization: most of the time, the work to do is a
+     redisplay and not these other types of work.  Check for
+     the following cases as a group to before checking each one
+     individually one by one. This saves about 25 MIPS
+     instructions in the common redisplay only case. */
+  if (workMask & (GLUT_EVENT_MASK_WORK | GLUT_DEVICE_MASK_WORK |
+      GLUT_CONFIGURE_WORK | GLUT_COLORMAP_WORK | GLUT_MAP_WORK)) {
+#if !defined(_WIN32)
+    /* Be sure to set event mask BEFORE map window is done. */
+    if (workMask & GLUT_EVENT_MASK_WORK) {
+      long eventMask;
+
+      /* Make sure children are not propogating events this
+         window is selecting for.  Be sure to do this before
+         enabling events on the children's parent. */
+      if (window->children) {
+        GLUTwindow *child = window->children;
+        unsigned long attribMask = CWDontPropagate;
+        XSetWindowAttributes wa;
+
+        wa.do_not_propagate_mask = window->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;
+        if (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK) {
+          wa.event_mask = child->eventMask | (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
+          attribMask |= CWEventMask;
+        }
+        do {
+          XChangeWindowAttributes(__glutDisplay, child->win,
+            attribMask, &wa);
+          child = child->siblings;
+        } while (child);
+      }
+      eventMask = window->eventMask;
+      if (window->parent && window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)
+        eventMask |= (window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
+      XSelectInput(__glutDisplay, window->win, eventMask);
+      if (window->overlay)
+        XSelectInput(__glutDisplay, window->overlay->win,
+          window->eventMask & GLUT_OVERLAY_EVENT_FILTER_MASK);
+    }
+#endif /* !_WIN32 */
+    /* Be sure to set device mask BEFORE map window is done. */
+    if (workMask & GLUT_DEVICE_MASK_WORK) {
+      __glutUpdateInputDeviceMaskFunc(window);
+    }
+    /* Be sure to configure window BEFORE map window is done. */
+    if (workMask & GLUT_CONFIGURE_WORK) {
+#if defined(_WIN32)
+      RECT changes;
+      POINT point;
+      UINT flags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER
+	| SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER;
+
+      GetClientRect(window->win, &changes);
+      
+      /* If this window is a toplevel window, translate the 0,0 client
+         coordinate into a screen coordinate for proper placement. */
+      if (!window->parent) {
+        point.x = 0;
+        point.y = 0;
+        ClientToScreen(window->win, &point);
+        changes.left = point.x;
+        changes.top = point.y;
+      }
+      if (window->desiredConfMask & (CWX | CWY)) {
+        changes.left = window->desiredX;
+        changes.top = window->desiredY;
+	flags &= ~SWP_NOMOVE;
+      }
+      if (window->desiredConfMask & (CWWidth | CWHeight)) {
+        changes.right = changes.left + window->desiredWidth;
+        changes.bottom = changes.top + window->desiredHeight;
+	flags &= ~SWP_NOSIZE;
+	/* XXX If overlay exists, resize the overlay here, ie.
+	   if (window->overlay) ... */
+      }
+      if (window->desiredConfMask & CWStackMode) {
+	flags &= ~SWP_NOZORDER;
+	/* XXX Overlay support might require something special here. */
+      }
+
+      /* Adjust the window rectangle because Win32 thinks that the x, y,
+         width & height are the WHOLE window (including decorations),
+         whereas GLUT treats the x, y, width & height as only the CLIENT
+         area of the window.  Only do this to top level windows
+         that are not in game mode (since game mode windows do
+         not have any decorations). */
+      if (!window->parent && window != __glutGameModeWindow) {
+        AdjustWindowRect(&changes,
+          WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+          FALSE);
+      }
+
+      /* Do the repositioning, moving, and push/pop. */
+      SetWindowPos(window->win,
+        window->desiredStack == Above ? HWND_TOP : HWND_NOTOPMOST,
+        changes.left, changes.top,
+        changes.right - changes.left, changes.bottom - changes.top,
+        flags);
+
+      /* Zero out the mask. */
+      window->desiredConfMask = 0;
+
+      /* This hack causes the window to go back to the right position
+         when it is taken out of fullscreen mode. */
+      if (workMask & GLUT_FULL_SCREEN_WORK) {
+        window->desiredConfMask |= CWX | CWY;
+        window->desiredX = point.x;
+        window->desiredY = point.y;
+      }
+#else /* !_WIN32 */
+      XWindowChanges changes;
+
+      changes.x = window->desiredX;
+      changes.y = window->desiredY;
+      if (window->desiredConfMask & (CWWidth | CWHeight)) {
+        changes.width = window->desiredWidth;
+        changes.height = window->desiredHeight;
+        if (window->overlay)
+          XResizeWindow(__glutDisplay, window->overlay->win,
+            window->desiredWidth, window->desiredHeight);
+        if (__glutMotifHints != None) {
+          if (workMask & GLUT_FULL_SCREEN_WORK) {
+            MotifWmHints hints;
+
+            hints.flags = MWM_HINTS_DECORATIONS;
+            hints.decorations = 0;  /* Absolutely no
+                                       decorations. */
+            XChangeProperty(__glutDisplay, window->win,
+              __glutMotifHints, __glutMotifHints, 32,
+              PropModeReplace, (unsigned char *) &hints, 4);
+            if (workMask & GLUT_MAP_WORK) {
+              /* Handle case where glutFullScreen is called
+                 before the first time that the window is
+                 mapped. Some window managers will randomly or
+                 interactively position the window the first
+                 time it is mapped if the window's
+                 WM_NORMAL_HINTS property does not request an
+                 explicit position. We don't want any such
+                 window manager interaction when going
+                 fullscreen.  Overwrite the WM_NORMAL_HINTS
+                 property installed by glutCreateWindow's
+                 XSetWMProperties property with one explicitly
+                 requesting a fullscreen window. */
+              XSizeHints hints;
+
+              hints.flags = USPosition | USSize;
+              hints.x = 0;
+              hints.y = 0;
+              hints.width = window->desiredWidth;
+              hints.height = window->desiredHeight;
+              XSetWMNormalHints(__glutDisplay, window->win, &hints);
+            }
+          } else {
+            XDeleteProperty(__glutDisplay, window->win, __glutMotifHints);
+          }
+        }
+      }
+      if (window->desiredConfMask & CWStackMode) {
+        changes.stack_mode = window->desiredStack;
+        /* Do not let glutPushWindow push window beneath the
+           underlay. */
+        if (window->parent && window->parent->overlay
+          && window->desiredStack == Below) {
+          changes.stack_mode = Above;
+          changes.sibling = window->parent->overlay->win;
+          window->desiredConfMask |= CWSibling;
+        }
+      }
+      XConfigureWindow(__glutDisplay, window->win,
+        window->desiredConfMask, &changes);
+      window->desiredConfMask = 0;
+#endif
+    }
+#if !defined(_WIN32)
+    /* Be sure to establish the colormaps BEFORE map window is
+       done. */
+    if (workMask & GLUT_COLORMAP_WORK) {
+      __glutEstablishColormapsProperty(window);
+    }
+#endif
+    if (workMask & GLUT_MAP_WORK) {
+      switch (window->desiredMapState) {
+      case WithdrawnState:
+        if (window->parent) {
+          XUnmapWindow(__glutDisplay, window->win);
+        } else {
+          XWithdrawWindow(__glutDisplay, window->win,
+            __glutScreen);
+        }
+        window->shownState = 0;
+        break;
+      case NormalState:
+        XMapWindow(__glutDisplay, window->win);
+        window->shownState = 1;
+        break;
+#ifdef _WIN32
+      case GameModeState:  /* Not an Xlib value. */
+        ShowWindow(window->win, SW_SHOW);
+        window->shownState = 1;
+        break;
+#endif
+      case IconicState:
+        XIconifyWindow(__glutDisplay, window->win, __glutScreen);
+        window->shownState = 0;
+        break;
+      }
+    }
+  }
+  if (workMask & (GLUT_REDISPLAY_WORK | GLUT_OVERLAY_REDISPLAY_WORK | GLUT_REPAIR_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
+    if (window->forceReshape) {
+      /* Guarantee that before a display callback is generated
+         for a window, a reshape callback must be generated. */
+      __glutSetWindow(window);
+      window->reshape(window->width, window->height);
+      window->forceReshape = False;
+
+      /* Setting the redisplay bit on the first reshape is
+         necessary to make the "Mesa glXSwapBuffers to repair
+         damage" hack operate correctly.  Without indicating a
+         redisplay is necessary, there's not an initial back
+         buffer render from which to blit from when damage
+         happens to the window. */
+      workMask |= GLUT_REDISPLAY_WORK;
+    }
+    /* The code below is more involved than otherwise necessary
+       because it is paranoid about the overlay or entire window
+       being removed or destroyed in the course of the callbacks.
+       Notice how the global __glutWindowDamaged is used to record
+       the layers' damage status.  See the code in glutLayerGet for
+       how __glutWindowDamaged is used. The  point is to not have to
+       update the "damaged" field after  the callback since the
+       window (or overlay) may be destroyed (or removed) when the
+       callback returns. */
+
+    if (window->overlay && window->overlay->display) {
+      int num = window->num;
+      Window xid = window->overlay ? window->overlay->win : None;
+
+      /* If an overlay display callback is registered, we
+         differentiate between a redisplay needed for the
+         overlay and/or normal plane.  If there is no overlay
+         display callback registered, we simply use the
+         standard display callback. */
+
+      if (workMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) {
+        if (__glutMesaSwapHackSupport) {
+          if (window->usedSwapBuffers) {
+            if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
+	      SWAP_BUFFERS_WINDOW(window);
+              goto skippedDisplayCallback1;
+            }
+          }
+        }
+        /* Render to normal plane. */
+#ifdef _WIN32
+        window->renderDc = window->hdc;
+#endif
+        window->renderWin = window->win;
+        window->renderCtx = window->ctx;
+        __glutWindowDamaged = (workMask & GLUT_REPAIR_WORK);
+        __glutSetWindow(window);
+        window->usedSwapBuffers = 0;
+        window->display();
+        __glutWindowDamaged = 0;
+
+      skippedDisplayCallback1:;
+      }
+      if (workMask & (GLUT_OVERLAY_REDISPLAY_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
+        window = __glutWindowList[num];
+        if (window && window->overlay &&
+          window->overlay->win == xid && window->overlay->display) {
+
+          /* Render to overlay. */
+#ifdef _WIN32
+          window->renderDc = window->overlay->hdc;
+#endif
+          window->renderWin = window->overlay->win;
+          window->renderCtx = window->overlay->ctx;
+          __glutWindowDamaged = (workMask & GLUT_OVERLAY_REPAIR_WORK);
+          __glutSetWindow(window);
+          window->overlay->display();
+          __glutWindowDamaged = 0;
+        } else {
+          /* Overlay may have since been destroyed or the
+             overlay callback may have been disabled during
+             normal display callback. */
+        }
+      }
+    } else {
+      if (__glutMesaSwapHackSupport) {
+        if (!window->overlay && window->usedSwapBuffers) {
+          if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
+	    SWAP_BUFFERS_WINDOW(window);
+            goto skippedDisplayCallback2;
+          }
+        }
+      }
+      /* Render to normal plane (and possibly overlay). */
+      __glutWindowDamaged = (workMask & (GLUT_OVERLAY_REPAIR_WORK | GLUT_REPAIR_WORK));
+      __glutSetWindow(window);
+      window->usedSwapBuffers = 0;
+      window->display();
+      __glutWindowDamaged = 0;
+
+    skippedDisplayCallback2:;
+    }
+  }
+  /* Combine workMask with window->workMask to determine what
+     finish and debug work there is. */
+  workMask |= window->workMask;
+
+  if (workMask & GLUT_FINISH_WORK) {
+    /* Finish work makes sure a glFinish gets done to indirect
+       rendering contexts.  Indirect contexts tend to have much 
+       longer latency because lots of OpenGL extension requests 
+       can queue up in the X protocol stream. __glutSetWindow
+       is where the finish works gets queued for indirect
+       contexts. */
+    __glutSetWindow(window);
+    glFinish();
+  }
+  if (workMask & GLUT_DEBUG_WORK) {
+    __glutSetWindow(window);
+    glutReportErrors();
+  }
+  /* Strip out dummy, finish, and debug work bits. */
+  window->workMask &= ~(GLUT_DUMMY_WORK | GLUT_FINISH_WORK | GLUT_DEBUG_WORK);
+  if (window->workMask) {
+    /* Leave on work list. */
+    return window;
+  } else {
+    /* Remove current window from work list. */
+    return window->prevWorkWin;
+  }
+}
+
+#ifndef _WIN32
+static  /* X11 implementations do not need this global. */
+#endif
+void
+__glutProcessWindowWorkLists(void)
+{
+  if (__glutWindowWorkList) {
+    GLUTwindow *remainder, *work;
+
+    work = __glutWindowWorkList;
+    __glutWindowWorkList = NULL;
+    if (work) {
+      remainder = processWindowWorkList(work);
+      if (remainder) {
+        *beforeEnd = __glutWindowWorkList;
+        __glutWindowWorkList = remainder;
+      }
+    }
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutMainLoop(void)
+{
+#if !defined(_WIN32)
+  if (!__glutDisplay)
+    __glutFatalUsage("main loop entered with out proper initialization.");
+#endif
+  if (!__glutWindowListSize)
+    __glutFatalUsage(
+      "main loop entered with no windows created.");
+  for (;;) {
+    __glutProcessWindowWorkLists();
+    if (__glutIdleFunc || __glutWindowWorkList) {
+      idleWait();
+    } else {
+      if (__glutTimerList) {
+        waitForSomething();
+      } else {
+        processEventsAndTimeouts();
+      }
+    }
+  }
+}
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_ext.c b/src/glut/glx/glut_ext.c
new file mode 100644
index 0000000000..abcb17a911
--- /dev/null
+++ b/src/glut/glx/glut_ext.c
@@ -0,0 +1,53 @@
+
+/* 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. */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "glutint.h"
+
+/* CENTRY */
+int APIENTRY 
+glutExtensionSupported(const char *extension)
+{
+  static const GLubyte *extensions = NULL;
+  const GLubyte *start;
+  GLubyte *where, *terminator;
+
+  /* Extension names should not have spaces. */
+  where = (GLubyte *) strchr(extension, ' ');
+  if (where || *extension == '\0')
+    return 0;
+
+  if (!extensions) {
+    extensions = glGetString(GL_EXTENSIONS);
+  }
+  /* It takes a bit of care to be fool-proof about parsing the
+     OpenGL extensions string.  Don't be fooled by sub-strings,
+     etc. */
+  start = extensions;
+  for (;;) {
+    /* If your application crashes in the strstr routine below,
+       you are probably calling glutExtensionSupported without
+       having a current window.  Calling glGetString without
+       a current OpenGL context has unpredictable results.
+       Please fix your program. */
+    where = (GLubyte *) strstr((const char *) start, extension);
+    if (!where)
+      break;
+    terminator = where + strlen(extension);
+    if (where == start || *(where - 1) == ' ') {
+      if (*terminator == ' ' || *terminator == '\0') {
+        return 1;
+      }
+    }
+    start = terminator;
+  }
+  return 0;
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_fbc.c b/src/glut/glx/glut_fbc.c
new file mode 100644
index 0000000000..e93188b862
--- /dev/null
+++ b/src/glut/glx/glut_fbc.c
@@ -0,0 +1,164 @@
+
+/* Copyright (c) Mark J. Kilgard, 1998.  */
+
+/* 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. */
+
+/* I appreciate the guidance from William Mitchell
+   (mitchell@cam.nist.gov) in developing this friend interface
+   for use by the f90gl package.  See ../../README.fortran */
+
+#include "glutint.h"
+
+/* FCB stands for Fortran CallBack. */
+
+/* There is only one idleFunc, menuStateFunc, and menuStatusFunc, so they
+   can be saved in the wrappers for Fortran rather than the C structures. */
+
+/* Set a Fortran callback function. */
+
+void APIENTRY
+__glutSetFCB(int which, void *func)
+{
+#ifdef SUPPORT_FORTRAN
+  switch (which) {
+  case GLUT_FCB_DISPLAY:
+    __glutCurrentWindow->fdisplay = (GLUTdisplayFCB) func;
+    break;
+  case GLUT_FCB_RESHAPE:
+    __glutCurrentWindow->freshape = (GLUTreshapeFCB) func;
+    break;
+  case GLUT_FCB_MOUSE:
+    __glutCurrentWindow->fmouse = (GLUTmouseFCB) func;
+    break;
+  case GLUT_FCB_MOTION:
+    __glutCurrentWindow->fmotion = (GLUTmotionFCB) func;
+    break;
+  case GLUT_FCB_PASSIVE:
+    __glutCurrentWindow->fpassive = (GLUTpassiveFCB) func;
+    break;
+  case GLUT_FCB_ENTRY:
+    __glutCurrentWindow->fentry = (GLUTentryFCB) func;
+    break;
+  case GLUT_FCB_KEYBOARD:
+    __glutCurrentWindow->fkeyboard = (GLUTkeyboardFCB) func;
+    break;
+  case GLUT_FCB_KEYBOARD_UP:
+    __glutCurrentWindow->fkeyboardUp = (GLUTkeyboardFCB) func;
+    break;
+  case GLUT_FCB_WINDOW_STATUS:
+    __glutCurrentWindow->fwindowStatus = (GLUTwindowStatusFCB) func;
+    break;
+  case GLUT_FCB_VISIBILITY:
+    __glutCurrentWindow->fvisibility = (GLUTvisibilityFCB) func;
+    break;
+  case GLUT_FCB_SPECIAL:
+    __glutCurrentWindow->fspecial = (GLUTspecialFCB) func;
+    break;
+  case GLUT_FCB_SPECIAL_UP:
+    __glutCurrentWindow->fspecialUp = (GLUTspecialFCB) func;
+    break;
+  case GLUT_FCB_BUTTON_BOX:
+    __glutCurrentWindow->fbuttonBox = (GLUTbuttonBoxFCB) func;
+    break;
+  case GLUT_FCB_DIALS:
+    __glutCurrentWindow->fdials = (GLUTdialsFCB) func;
+    break;
+  case GLUT_FCB_SPACE_MOTION:
+    __glutCurrentWindow->fspaceMotion = (GLUTspaceMotionFCB) func;
+    break;
+  case GLUT_FCB_SPACE_ROTATE:
+    __glutCurrentWindow->fspaceRotate = (GLUTspaceRotateFCB) func;
+    break;
+  case GLUT_FCB_SPACE_BUTTON:
+    __glutCurrentWindow->fspaceButton = (GLUTspaceButtonFCB) func;
+    break;
+  case GLUT_FCB_TABLET_MOTION:
+    __glutCurrentWindow->ftabletMotion = (GLUTtabletMotionFCB) func;
+    break;
+  case GLUT_FCB_TABLET_BUTTON:
+    __glutCurrentWindow->ftabletButton = (GLUTtabletButtonFCB) func;
+    break;
+#ifdef _WIN32
+  case GLUT_FCB_JOYSTICK:
+    __glutCurrentWindow->fjoystick = (GLUTjoystickFCB) func;
+    break;
+#endif
+  case GLUT_FCB_OVERLAY_DISPLAY:
+    __glutCurrentWindow->overlay->fdisplay = (GLUTdisplayFCB) func;
+    break;
+  case GLUT_FCB_SELECT:
+    __glutCurrentMenu->fselect = (GLUTselectFCB) func;
+    break;
+  case GLUT_FCB_TIMER:
+    __glutNewTimer->ffunc = (GLUTtimerFCB) func;
+    break;
+  }
+#endif
+}
+
+/* Get a Fortran callback function. */
+
+void* APIENTRY
+__glutGetFCB(int which)
+{
+#ifdef SUPPORT_FORTRAN
+  switch (which) {
+  case GLUT_FCB_DISPLAY:
+    return (void *) __glutCurrentWindow->fdisplay;
+  case GLUT_FCB_RESHAPE:
+    return (void *) __glutCurrentWindow->freshape;
+  case GLUT_FCB_MOUSE:
+    return (void *) __glutCurrentWindow->fmouse;
+  case GLUT_FCB_MOTION:
+    return (void *) __glutCurrentWindow->fmotion;
+  case GLUT_FCB_PASSIVE:
+    return (void *) __glutCurrentWindow->fpassive;
+  case GLUT_FCB_ENTRY:
+    return (void *) __glutCurrentWindow->fentry;
+  case GLUT_FCB_KEYBOARD:
+    return (void *) __glutCurrentWindow->fkeyboard;
+  case GLUT_FCB_KEYBOARD_UP:
+    return (void *) __glutCurrentWindow->fkeyboardUp;
+  case GLUT_FCB_WINDOW_STATUS:
+    return (void *) __glutCurrentWindow->fwindowStatus;
+  case GLUT_FCB_VISIBILITY:
+    return (void *) __glutCurrentWindow->fvisibility;
+  case GLUT_FCB_SPECIAL:
+    return (void *) __glutCurrentWindow->fspecial;
+  case GLUT_FCB_SPECIAL_UP:
+    return (void *) __glutCurrentWindow->fspecialUp;
+  case GLUT_FCB_BUTTON_BOX:
+    return (void *) __glutCurrentWindow->fbuttonBox;
+  case GLUT_FCB_DIALS:
+    return (void *) __glutCurrentWindow->fdials;
+  case GLUT_FCB_SPACE_MOTION:
+    return (void *) __glutCurrentWindow->fspaceMotion;
+  case GLUT_FCB_SPACE_ROTATE:
+    return (void *) __glutCurrentWindow->fspaceRotate;
+  case GLUT_FCB_SPACE_BUTTON:
+    return (void *) __glutCurrentWindow->fspaceButton;
+  case GLUT_FCB_TABLET_MOTION:
+    return (void *) __glutCurrentWindow->ftabletMotion;
+  case GLUT_FCB_TABLET_BUTTON:
+    return (void *) __glutCurrentWindow->ftabletButton;
+  case GLUT_FCB_JOYSTICK:
+#ifdef _WIN32
+    return (void *) __glutCurrentWindow->fjoystick;
+#else
+    return NULL;
+#endif
+  case GLUT_FCB_OVERLAY_DISPLAY:
+    return (void *) __glutCurrentWindow->overlay->fdisplay;
+  case GLUT_FCB_SELECT:
+    return (void *) __glutCurrentMenu->fselect;
+  case GLUT_FCB_TIMER:
+    return (void *) __glutTimerList->ffunc;
+  default:
+    return NULL;
+  }
+#else
+  return NULL;
+#endif
+}
diff --git a/src/glut/glx/glut_fullscrn.c b/src/glut/glx/glut_fullscrn.c
new file mode 100644
index 0000000000..8d58f1743c
--- /dev/null
+++ b/src/glut/glx/glut_fullscrn.c
@@ -0,0 +1,52 @@
+
+/* Copyright (c) Mark J. Kilgard, 1995, 1998. */
+
+/* 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 <stdio.h>  /* SunOS multithreaded assert() needs <stdio.h>.  Lame. */
+#include <assert.h>
+
+#if !defined(_WIN32)
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#endif
+
+/* SGI optimization introduced in IRIX 6.3 to avoid X server
+   round trips for interning common X atoms. */
+#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
+#include <X11/SGIFastAtom.h>
+#else
+#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
+#endif
+
+#include "glutint.h"
+
+/* CENTRY */
+void APIENTRY 
+glutFullScreen(void)
+{
+  assert(!__glutCurrentWindow->parent);
+  IGNORE_IN_GAME_MODE();
+#if !defined(_WIN32)
+  if (__glutMotifHints == None) {
+    __glutMotifHints = XSGIFastInternAtom(__glutDisplay, "_MOTIF_WM_HINTS",
+      SGI_XA__MOTIF_WM_HINTS, 0);
+    if (__glutMotifHints == None) {
+      __glutWarning("Could not intern X atom for _MOTIF_WM_HINTS.");
+    }
+  }
+#endif
+
+  __glutCurrentWindow->desiredX = 0;
+  __glutCurrentWindow->desiredY = 0;
+  __glutCurrentWindow->desiredWidth = __glutScreenWidth;
+  __glutCurrentWindow->desiredHeight = __glutScreenHeight;
+  __glutCurrentWindow->desiredConfMask |= CWX | CWY | CWWidth | CWHeight;
+
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_CONFIGURE_WORK | GLUT_FULL_SCREEN_WORK);
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_gamemode.c b/src/glut/glx/glut_gamemode.c
new file mode 100644
index 0000000000..b685ce33e2
--- /dev/null
+++ b/src/glut/glx/glut_gamemode.c
@@ -0,0 +1,674 @@
+
+/* Copyright (c) Mark J. Kilgard, 1998. */
+
+/* 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 <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "glutint.h"
+
+#ifndef _WIN32
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+/* SGI optimization introduced in IRIX 6.3 to avoid X server
+   round trips for interning common X atoms. */
+#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
+#include <X11/SGIFastAtom.h>
+#else
+#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
+#endif
+#endif  /* not _WIN32 */
+
+int __glutDisplaySettingsChanged = 0;
+static DisplayMode *dmodes, *currentDm = NULL;
+static int ndmodes = -1;
+GLUTwindow *__glutGameModeWindow = NULL;
+
+#ifdef TEST
+static char *compstr[] =
+{
+  "none", "=", "!=", "<=", ">=", ">", "<", "~"
+};
+static char *capstr[] =
+{
+  "width", "height", "bpp", "hertz", "num"
+};
+#endif
+
+void __cdecl
+__glutCloseDownGameMode(void)
+{
+  if (__glutDisplaySettingsChanged) {
+#ifdef _WIN32
+    /* Assumes that display settings have been changed, that
+       is __glutDisplaySettingsChanged is true. */
+    ChangeDisplaySettings(NULL, 0);
+#endif
+    __glutDisplaySettingsChanged = 0;
+  }
+  __glutGameModeWindow = NULL;
+}
+
+void APIENTRY
+glutLeaveGameMode(void)
+{
+  if (__glutGameModeWindow == NULL) {
+    __glutWarning("not in game mode so cannot leave game mode");
+    return;
+  }
+  __glutDestroyWindow(__glutGameModeWindow,
+    __glutGameModeWindow);
+  XFlush(__glutDisplay);
+  __glutGameModeWindow = NULL;
+}
+
+#ifdef _WIN32
+
+/* Same values as from MSDN's SetDisp.c example. */
+#define MIN_WIDTH 400
+#define MIN_FREQUENCY 60
+
+static void
+initGameModeSupport(void)
+{
+  DEVMODE dm;
+  DWORD mode;
+  int i;
+
+  if (ndmodes >= 0) {
+    /* ndmodes is initially -1 to indicate no
+       dmodes allocated yet. */
+    return;
+  }
+
+  /* Determine how many display modes there are. */
+  ndmodes = 0;
+  mode = 0;
+  while (EnumDisplaySettings(NULL, mode, &dm)) {
+    if (dm.dmPelsWidth >= MIN_WIDTH &&
+      (dm.dmDisplayFrequency == 0 ||
+      dm.dmDisplayFrequency >= MIN_FREQUENCY)) {
+      ndmodes++;
+    }
+    mode++;
+  }
+
+  /* Allocate memory for a list of all the display modes. */
+  dmodes = (DisplayMode*)
+    malloc(ndmodes * sizeof(DisplayMode));
+
+  /* Now that we know how many display modes to expect,
+     enumerate them again and save the information in
+     the list we allocated above. */
+  i = 0;
+  mode = 0;
+  while (EnumDisplaySettings(NULL, mode, &dm)) {
+    /* Try to reject any display settings that seem unplausible. */
+    if (dm.dmPelsWidth >= MIN_WIDTH &&
+      (dm.dmDisplayFrequency == 0 ||
+      dm.dmDisplayFrequency >= MIN_FREQUENCY)) {
+      dmodes[i].devmode = dm;
+      dmodes[i].valid = 1;  /* XXX Not used for now. */
+      dmodes[i].cap[DM_WIDTH] = dm.dmPelsWidth;
+      dmodes[i].cap[DM_HEIGHT] = dm.dmPelsHeight;
+      dmodes[i].cap[DM_PIXEL_DEPTH] = dm.dmBitsPerPel;
+      if (dm.dmDisplayFrequency == 0) {
+ 	/* Guess a reasonable guess. */
+	/* Lame Windows 95 version of EnumDisplaySettings. */
+        dmodes[i].cap[DM_HERTZ] = 60;
+      } else {
+	dmodes[i].cap[DM_HERTZ] = dm.dmDisplayFrequency;
+      }
+      i++;
+    }
+    mode++;
+  }
+
+  assert(i == ndmodes);
+}
+
+#else
+
+/* X Windows version of initGameModeSupport. */
+static void
+initGameModeSupport(void)
+{
+  if (ndmodes >= 0) {
+    /* ndmodes is initially -1 to indicate no
+       dmodes allocated yet. */
+    return;
+  }
+
+  /* Determine how many display modes there are. */
+  ndmodes = 0;
+}
+
+#endif
+
+/* This routine is based on similiar code in glut_dstr.c */
+static DisplayMode *
+findMatch(DisplayMode * dmodes, int ndmodes,
+  Criterion * criteria, int ncriteria)
+{
+  DisplayMode *found;
+  int *bestScore, *thisScore;
+  int i, j, numok, result, worse, better;
+
+  found = NULL;
+  numok = 1;            /* "num" capability is indexed from 1,
+                           not 0. */
+
+  /* XXX alloca canidate. */
+  bestScore = (int *) malloc(ncriteria * sizeof(int));
+  if (!bestScore) {
+    __glutFatalError("out of memory.");
+  }
+  for (j = 0; j < ncriteria; j++) {
+    /* Very negative number. */
+    bestScore[j] = -32768;
+  }
+
+  /* XXX alloca canidate. */
+  thisScore = (int *) malloc(ncriteria * sizeof(int));
+  if (!thisScore) {
+    __glutFatalError("out of memory.");
+  }
+
+  for (i = 0; i < ndmodes; i++) {
+    if (dmodes[i].valid) {
+      worse = 0;
+      better = 0;
+
+      for (j = 0; j < ncriteria; j++) {
+        int cap, cvalue, dvalue;
+
+        cap = criteria[j].capability;
+        cvalue = criteria[j].value;
+        if (cap == NUM) {
+          dvalue = numok;
+        } else {
+          dvalue = dmodes[i].cap[cap];
+        }
+#ifdef TEST
+        if (verbose)
+          printf("  %s %s %d to %d\n",
+            capstr[cap], compstr[criteria[j].comparison], cvalue, dvalue);
+#endif
+        switch (criteria[j].comparison) {
+        case EQ:
+          result = cvalue == dvalue;
+          thisScore[j] = 1;
+          break;
+        case NEQ:
+          result = cvalue != dvalue;
+          thisScore[j] = 1;
+          break;
+        case LT:
+          result = dvalue < cvalue;
+          thisScore[j] = dvalue - cvalue;
+          break;
+        case GT:
+          result = dvalue > cvalue;
+          thisScore[j] = dvalue - cvalue;
+          break;
+        case LTE:
+          result = dvalue <= cvalue;
+          thisScore[j] = dvalue - cvalue;
+          break;
+        case GTE:
+          result = (dvalue >= cvalue);
+          thisScore[j] = dvalue - cvalue;
+          break;
+        case MIN:
+          result = dvalue >= cvalue;
+          thisScore[j] = cvalue - dvalue;
+          break;
+        }
+
+#ifdef TEST
+        if (verbose)
+          printf("                result=%d   score=%d   bestScore=%d\n", result, thisScore[j], bestScore[j]);
+#endif
+
+        if (result) {
+          if (better || thisScore[j] > bestScore[j]) {
+            better = 1;
+          } else if (thisScore[j] == bestScore[j]) {
+            /* Keep looking. */
+          } else {
+            goto nextDM;
+          }
+        } else {
+          if (cap == NUM) {
+            worse = 1;
+          } else {
+            goto nextDM;
+          }
+        }
+
+      }
+
+      if (better && !worse) {
+        found = &dmodes[i];
+        for (j = 0; j < ncriteria; j++) {
+          bestScore[j] = thisScore[j];
+        }
+      }
+      numok++;
+
+    nextDM:;
+
+    }
+  }
+  free(bestScore);
+  free(thisScore);
+  return found;
+}
+
+/**
+ * Parses strings in the form of:
+ *  800x600
+ *  800x600:16
+ *  800x600@60
+ *  800x600:16@60
+ *  @60
+ *  :16
+ *  :16@60
+ * NOTE that @ before : is not parsed.
+ */
+static int
+specialCaseParse(char *word, Criterion * criterion, int mask)
+{
+  char *xstr, *response;
+  int got;
+  int width, height, bpp, hertz;
+
+  switch(word[0]) {
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+    /* The WWWxHHH case. */
+    if (mask & (1 << DM_WIDTH)) {
+      return -1;
+    }
+    xstr = strpbrk(&word[1], "x");
+    if (xstr) {
+      width = (int) strtol(word, &response, 0);
+      if (response == word || response[0] != 'x') {
+        /* Not a valid number OR needs to be followed by 'x'. */
+	return -1;
+      }
+      height = (int) strtol(&xstr[1], &response, 0);
+      if (response == &xstr[1]) {
+        /* Not a valid number. */
+	return -1;
+      }
+      criterion[0].capability = DM_WIDTH;
+      criterion[0].comparison = EQ;
+      criterion[0].value = width;
+      criterion[1].capability = DM_HEIGHT;
+      criterion[1].comparison = EQ;
+      criterion[1].value = height;
+      got = specialCaseParse(response,
+        &criterion[2], 1 << DM_WIDTH);
+      if (got >= 0) {
+        return got + 2;
+      } else {
+        return -1;
+      }
+    }
+    return -1;
+  case ':':
+    /* The :BPP case. */
+    if (mask & (1 << DM_PIXEL_DEPTH)) {
+      return -1;
+    }
+    bpp = (int) strtol(&word[1], &response, 0);
+    if (response == &word[1]) {
+      /* Not a valid number. */
+      return -1;
+    }
+    criterion[0].capability = DM_PIXEL_DEPTH;
+    criterion[0].comparison = EQ;
+    criterion[0].value = bpp;
+    got = specialCaseParse(response,
+      &criterion[1], 1 << DM_WIDTH | 1 << DM_PIXEL_DEPTH);
+    if (got >= 0) {
+      return got + 1;
+    } else {
+      return -1;
+    }
+  case '@':
+    /* The @HZ case. */
+    if (mask & (1 << DM_HERTZ)) {
+      return -1;
+    }
+    hertz = (int) strtol(&word[1], &response, 0);
+    if (response == &word[1]) {
+      /* Not a valid number. */
+      return -1;
+    }
+    criterion[0].capability = DM_HERTZ;
+    criterion[0].comparison = EQ;
+    criterion[0].value = hertz;
+    got = specialCaseParse(response,
+      &criterion[1], ~DM_HERTZ);
+    if (got >= 0) {
+      return got + 1;
+    } else {
+      return -1;
+    }
+  case '\0':
+    return 0;
+  }
+  return -1;
+}
+
+/* This routine is based on similiar code in glut_dstr.c */
+static int
+parseCriteria(char *word, Criterion * criterion)
+{
+  char *cstr, *vstr, *response;
+  int comparator, value;
+
+  cstr = strpbrk(word, "=><!~");
+  if (cstr) {
+    switch (cstr[0]) {
+    case '=':
+      comparator = EQ;
+      vstr = &cstr[1];
+      break;
+    case '~':
+      comparator = MIN;
+      vstr = &cstr[1];
+      break;
+    case '>':
+      if (cstr[1] == '=') {
+        comparator = GTE;
+        vstr = &cstr[2];
+      } else {
+        comparator = GT;
+        vstr = &cstr[1];
+      }
+      break;
+    case '<':
+      if (cstr[1] == '=') {
+        comparator = LTE;
+        vstr = &cstr[2];
+      } else {
+        comparator = LT;
+        vstr = &cstr[1];
+      }
+      break;
+    case '!':
+      if (cstr[1] == '=') {
+        comparator = NEQ;
+        vstr = &cstr[2];
+      } else {
+        return -1;
+      }
+      break;
+    default:
+      return -1;
+    }
+    value = (int) strtol(vstr, &response, 0);
+    if (response == vstr) {
+      /* Not a valid number. */
+      return -1;
+    }
+    *cstr = '\0';
+  } else {
+    comparator = NONE;
+  }
+  switch (word[0]) {
+  case 'b':
+    if (!strcmp(word, "bpp")) {
+      criterion[0].capability = DM_PIXEL_DEPTH;
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        return 1;
+      }
+    }
+    return -1;
+  case 'h':
+    if (!strcmp(word, "height")) {
+      criterion[0].capability = DM_HEIGHT;
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        return 1;
+      }
+    }
+    if (!strcmp(word, "hertz")) {
+      criterion[0].capability = DM_HERTZ;
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        return 1;
+      }
+    }
+    return -1;
+  case 'n':
+    if (!strcmp(word, "num")) {
+      criterion[0].capability = DM_NUM;
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        return 1;
+      }
+    }
+    return -1;
+  case 'w':
+    if (!strcmp(word, "width")) {
+      criterion[0].capability = DM_WIDTH;
+      if (comparator == NONE) {
+        return -1;
+      } else {
+        criterion[0].comparison = comparator;
+        criterion[0].value = value;
+        return 1;
+      }
+    }
+    return -1;
+  }
+  if (comparator == NONE) {
+    return specialCaseParse(word, criterion, 0);
+  }
+  return -1;
+}
+
+/* This routine is based on similiar code in glut_dstr.c */
+static Criterion *
+parseDisplayString(const char *display, int *ncriteria)
+{
+  Criterion *criteria = NULL;
+  int n, parsed;
+  char *copy, *word;
+
+  copy = __glutStrdup(display);
+  /* Attempt to estimate how many criteria entries should be
+     needed. */
+  n = 0;
+  word = strtok(copy, " \t");
+  while (word) {
+    n++;
+    word = strtok(NULL, " \t");
+  }
+  /* Allocate number of words of criteria.  A word
+     could contain as many as four criteria in the
+     worst case.  Example: 800x600:16@60 */
+  criteria = (Criterion *) malloc(4 * n * sizeof(Criterion));
+  if (!criteria) {
+    __glutFatalError("out of memory.");
+  }
+
+  /* Re-copy the copy of the display string. */
+  strcpy(copy, display);
+
+  n = 0;
+  word = strtok(copy, " \t");
+  while (word) {
+    parsed = parseCriteria(word, &criteria[n]);
+    if (parsed >= 0) {
+      n += parsed;
+    } else {
+      __glutWarning("Unrecognized game mode string word: %s (ignoring)\n", word);
+    }
+    word = strtok(NULL, " \t");
+  }
+
+  free(copy);
+  *ncriteria = n;
+  return criteria;
+}
+
+void APIENTRY
+glutGameModeString(const char *string)
+{
+  Criterion *criteria;
+  int ncriteria;
+
+  initGameModeSupport();
+  criteria = parseDisplayString(string, &ncriteria);
+  currentDm = findMatch(dmodes, ndmodes, criteria, ncriteria);
+  free(criteria);
+}
+
+int APIENTRY
+glutEnterGameMode(void)
+{
+  GLUTwindow *window;
+  int width, height;
+  Window win;
+
+  if (__glutMappedMenu) {
+    __glutFatalUsage("entering game mode not allowed while menus in use");
+  }
+  if (__glutGameModeWindow) {
+    /* Already in game mode, so blow away game mode
+       window so apps can change resolutions. */
+    window = __glutGameModeWindow;
+    /* Setting the game mode window to NULL tricks
+       the window destroy code into not undoing the
+       screen display change since we plan on immediately
+       doing another mode change. */
+    __glutGameModeWindow = NULL;
+    __glutDestroyWindow(window, window);
+  }
+
+  /* Assume default screen size until we find out if we
+     can actually change the display settings. */
+  width = __glutScreenWidth;
+  height = __glutScreenHeight;
+
+  if (currentDm) {
+#ifdef _WIN32
+    LONG status;
+    static int registered = 0;
+
+    status = ChangeDisplaySettings(&currentDm->devmode,
+      CDS_FULLSCREEN);
+    if (status == DISP_CHANGE_SUCCESSFUL) {
+      __glutDisplaySettingsChanged = 1;
+      width = currentDm->cap[DM_WIDTH];
+      height = currentDm->cap[DM_HEIGHT];
+      if (!registered) {
+        atexit(__glutCloseDownGameMode);
+        registered = 1;
+      }
+    } else {
+      /* Switch back to default resolution. */
+      ChangeDisplaySettings(NULL, 0);
+    }
+#endif
+  }
+
+  window = __glutCreateWindow(NULL, 0, 0,
+    width, height, /* game mode */ 1);
+  win = window->win;
+
+#if !defined(_WIN32)
+  if (__glutMotifHints == None) {
+    __glutMotifHints = XSGIFastInternAtom(__glutDisplay, "_MOTIF_WM_HINTS",
+      SGI_XA__MOTIF_WM_HINTS, 0);
+    if (__glutMotifHints == None) {
+      __glutWarning("Could not intern X atom for _MOTIF_WM_HINTS.");
+    }
+  }
+
+  /* Game mode window is a toplevel window. */
+  XSetWMProtocols(__glutDisplay, win, &__glutWMDeleteWindow, 1);
+#endif
+
+  /* Schedule the fullscreen property to be added and to
+     make sure the window is configured right.  Win32
+     doesn't need this. */
+  window->desiredX = 0;
+  window->desiredY = 0;
+  window->desiredWidth = width;
+  window->desiredHeight = height;
+  window->desiredConfMask |= CWX | CWY | CWWidth | CWHeight;
+#ifdef _WIN32
+  /* Win32 does not want to use GLUT_FULL_SCREEN_WORK
+     for game mode because we need to be maximizing
+     the window in game mode, not just sizing it to
+     take up the full screen.  The Win32-ness of game
+     mode happens when you pass 1 in the gameMode parameter
+     to __glutCreateWindow above.  A gameMode of creates
+     a WS_POPUP window, not a standard WS_OVERLAPPEDWINDOW
+     window.  WS_POPUP ensures the taskbar is hidden. */
+  __glutPutOnWorkList(window,
+    GLUT_CONFIGURE_WORK);
+#else
+  __glutPutOnWorkList(window,
+    GLUT_CONFIGURE_WORK | GLUT_FULL_SCREEN_WORK);
+#endif
+
+  __glutGameModeWindow = window;
+  return window->num + 1;
+}
+
+int APIENTRY
+glutGameModeGet(GLenum mode)
+{
+  switch (mode) {
+  case GLUT_GAME_MODE_ACTIVE:
+    return __glutGameModeWindow != NULL;
+  case GLUT_GAME_MODE_POSSIBLE:
+    return currentDm != NULL;
+  case GLUT_GAME_MODE_WIDTH:
+    return currentDm ? currentDm->cap[DM_WIDTH] : -1;
+  case GLUT_GAME_MODE_HEIGHT:
+    return currentDm ? currentDm->cap[DM_HEIGHT] : -1;
+  case GLUT_GAME_MODE_PIXEL_DEPTH:
+    return currentDm ? currentDm->cap[DM_PIXEL_DEPTH] : -1;
+  case GLUT_GAME_MODE_REFRESH_RATE:
+    return currentDm ? currentDm->cap[DM_HERTZ] : -1;
+  case GLUT_GAME_MODE_DISPLAY_CHANGED:
+    return __glutDisplaySettingsChanged;
+  default:
+    return -1;
+  }
+}
diff --git a/src/glut/glx/glut_get.c b/src/glut/glx/glut_get.c
new file mode 100644
index 0000000000..e4117bdc86
--- /dev/null
+++ b/src/glut/glx/glut_get.c
@@ -0,0 +1,216 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
+
+/* 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 <assert.h>
+#include <stdlib.h>  /* SunOS 4 needs NULL defined for GETTIMEOFDAY macro. */
+#include "glutint.h"
+
+/* CENTRY */
+int APIENTRY 
+glutGet(GLenum param)
+{
+  Window win, root;
+  int x, y, value;
+  unsigned int width, height, border, depth;
+
+  switch (param) {
+  case GLUT_INIT_WINDOW_X:
+    return __glutInitX;
+  case GLUT_INIT_WINDOW_Y:
+    return __glutInitY;
+  case GLUT_INIT_WINDOW_WIDTH:
+    return __glutInitWidth;
+  case GLUT_INIT_WINDOW_HEIGHT:
+    return __glutInitHeight;
+  case GLUT_INIT_DISPLAY_MODE:
+    return __glutDisplayMode;
+  case GLUT_WINDOW_X:
+    XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
+      __glutRoot, 0, 0, &x, &y, &win);
+    return x;
+  case GLUT_WINDOW_Y:
+    XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
+      __glutRoot, 0, 0, &x, &y, &win);
+    return y;
+  case GLUT_WINDOW_WIDTH:
+    if (!__glutCurrentWindow->reshape) {
+      XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
+        &root, &x, &y,
+        &width, &height, &border, &depth);
+      return width;
+    }
+    return __glutCurrentWindow->width;
+  case GLUT_WINDOW_HEIGHT:
+    if (!__glutCurrentWindow->reshape) {
+      XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
+        &root, &x, &y,
+        &width, &height, &border, &depth);
+      return height;
+    }
+    return __glutCurrentWindow->height;
+
+#define GET_CONFIG(attrib) { \
+  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \
+    glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \
+      attrib, &value); \
+  } else { \
+    glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \
+      attrib, &value); \
+  } \
+}
+
+  case GLUT_WINDOW_BUFFER_SIZE:
+    GET_CONFIG(GLX_BUFFER_SIZE);
+    return value;
+  case GLUT_WINDOW_STENCIL_SIZE:
+    GET_CONFIG(GLX_STENCIL_SIZE);
+    return value;
+  case GLUT_WINDOW_DEPTH_SIZE:
+    GET_CONFIG(GLX_DEPTH_SIZE);
+    return value;
+  case GLUT_WINDOW_RED_SIZE:
+    GET_CONFIG(GLX_RED_SIZE);
+    return value;
+  case GLUT_WINDOW_GREEN_SIZE:
+    GET_CONFIG(GLX_GREEN_SIZE);
+    return value;
+  case GLUT_WINDOW_BLUE_SIZE:
+    GET_CONFIG(GLX_BLUE_SIZE);
+    return value;
+  case GLUT_WINDOW_ALPHA_SIZE:
+    GET_CONFIG(GLX_ALPHA_SIZE);
+    return value;
+  case GLUT_WINDOW_ACCUM_RED_SIZE:
+    GET_CONFIG(GLX_ACCUM_RED_SIZE);
+    return value;
+  case GLUT_WINDOW_ACCUM_GREEN_SIZE:
+    GET_CONFIG(GLX_ACCUM_GREEN_SIZE);
+    return value;
+  case GLUT_WINDOW_ACCUM_BLUE_SIZE:
+    GET_CONFIG(GLX_ACCUM_BLUE_SIZE);
+    return value;
+  case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
+    GET_CONFIG(GLX_ACCUM_ALPHA_SIZE);
+    return value;
+  case GLUT_WINDOW_DOUBLEBUFFER:
+    GET_CONFIG(GLX_DOUBLEBUFFER);
+    return value;
+  case GLUT_WINDOW_RGBA:
+    GET_CONFIG(GLX_RGBA);
+    return value;
+  case GLUT_WINDOW_COLORMAP_SIZE:
+    GET_CONFIG(GLX_RGBA);
+    if (value) {
+      return 0;
+    } else {
+#if defined(_WIN32)
+      /* KLUDGE: we always assume 256 colors in CI mode on
+         Win32 */
+      return 256;
+#else
+      if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { 
+        return __glutCurrentWindow->vis->visual->map_entries;
+      } else {
+        return __glutCurrentWindow->overlay->vis->visual->map_entries;
+      }
+#endif /* _WIN32 */
+    }
+  case GLUT_WINDOW_PARENT:
+    return __glutCurrentWindow->parent ?
+      __glutCurrentWindow->parent->num + 1 : 0;
+  case GLUT_WINDOW_NUM_CHILDREN:
+    {
+      int num = 0;
+      GLUTwindow *children = __glutCurrentWindow->children;
+
+      while (children) {
+        num++;
+        children = children->siblings;
+      }
+      return num;
+    }
+  case GLUT_WINDOW_NUM_SAMPLES:
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+    if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) {
+      GET_CONFIG(GLX_SAMPLES_SGIS);
+      return value;
+    } else {
+      return 0;
+    }
+#else
+    /* Independent of GLX server support, multisampling not
+       supported by GLX client-side. */
+    return 0;
+#endif
+  case GLUT_WINDOW_STEREO:
+    GET_CONFIG(GLX_STEREO);
+    return value;
+  case GLUT_WINDOW_CURSOR:
+    return __glutCurrentWindow->cursor;
+  case GLUT_SCREEN_WIDTH:
+    return DisplayWidth(__glutDisplay, __glutScreen);
+  case GLUT_SCREEN_HEIGHT:
+    return DisplayHeight(__glutDisplay, __glutScreen);
+  case GLUT_SCREEN_WIDTH_MM:
+    return DisplayWidthMM(__glutDisplay, __glutScreen);
+  case GLUT_SCREEN_HEIGHT_MM:
+    return DisplayHeightMM(__glutDisplay, __glutScreen);
+  case GLUT_MENU_NUM_ITEMS:
+    return __glutCurrentMenu->num;
+  case GLUT_DISPLAY_MODE_POSSIBLE:
+    {
+      XVisualInfo *vi;
+      Bool dummy, visAlloced;
+      void *fbc;
+
+#if defined(_WIN32)      
+      /* Our fake glXChooseVisual (which is called by
+         __glutDetermineVisual) needs an HDC to work with, so grab one
+         from the "root" window. */
+      XHDC = GetDC(GetDesktopWindow());
+#endif
+      vi = __glutDetermineWindowVisual(&dummy, &visAlloced, &fbc);
+#if defined(_WIN32)      
+      ReleaseDC(GetDesktopWindow(), XHDC);
+#endif
+      if (vi) {
+        if (visAlloced)
+          XFree(vi);
+        return 1;
+      }
+      return 0;
+    }
+  case GLUT_ELAPSED_TIME:
+    {
+      struct timeval elapsed, beginning, now;
+
+      __glutInitTime(&beginning);
+      GETTIMEOFDAY(&now);
+      TIMEDELTA(elapsed, now, beginning);
+      /* Return elapsed milliseconds. */
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+      return (int) (elapsed.val / TICKS_PER_MILLISECOND);
+#else
+      return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000));
+#endif
+    }
+  case GLUT_WINDOW_FORMAT_ID:
+#if defined(_WIN32)
+    return GetPixelFormat(__glutCurrentWindow->hdc);
+#else
+    if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
+      return (int) __glutCurrentWindow->vis->visualid;
+    } else {
+      return (int) __glutCurrentWindow->overlay->vis->visualid;
+    }
+#endif
+  default:
+    __glutWarning("invalid glutGet parameter: %d", param);
+    return -1;
+  }
+}
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_glxext.c b/src/glut/glx/glut_glxext.c
new file mode 100644
index 0000000000..04862432fc
--- /dev/null
+++ b/src/glut/glx/glut_glxext.c
@@ -0,0 +1,48 @@
+
+/* Copyright (c) Mark J. Kilgard, 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 <string.h>
+#include "glutint.h"
+
+#if defined(GLX_VERSION_1_1)
+int
+__glutIsSupportedByGLX(char *extension)
+{
+  static const char *extensions = NULL;
+  const char *start;
+  char *where, *terminator;
+  int major, minor;
+
+  glXQueryVersion(__glutDisplay, &major, &minor);
+  /* Be careful not to call glXQueryExtensionsString if it
+     looks like the server doesn't support GLX 1.1.
+     Unfortunately, the original GLX 1.0 didn't have the notion
+     of GLX extensions. */
+  if ((major == 1 && minor >= 1) || (major > 1)) {
+    if (!extensions)
+      extensions = glXQueryExtensionsString(__glutDisplay, __glutScreen);
+    /* It takes a bit of care to be fool-proof about parsing
+       the GLX extensions string.  Don't be fooled by
+       sub-strings,  etc. */
+    start = extensions;
+    for (;;) {
+      where = strstr(start, extension);
+      if (!where)
+        return 0;
+      terminator = where + strlen(extension);
+      if (where == start || *(where - 1) == ' ') {
+        if (*terminator == ' ' || *terminator == '\0') {
+          return 1;
+        }
+      }
+      start = terminator;
+    }
+  }
+  return 0;
+}
+#endif
diff --git a/src/glut/glx/glut_hel10.c b/src/glut/glx/glut_hel10.c
new file mode 100644
index 0000000000..703cef38f2
--- /dev/null
+++ b/src/glut/glx/glut_hel10.c
@@ -0,0 +1,1778 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#define glutBitmapHelvetica10 XXX
+#include "glutbitmap.h"
+#undef glutBitmapHelvetica10
+
+/* char: 0xff */
+
+static const GLubyte ch255data[] = {
+0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x50,
+};
+
+static const BitmapCharRec ch255 = {4,10,0,2,5,ch255data};
+
+/* char: 0xfe */
+
+static const GLubyte ch254data[] = {
+0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80,
+};
+
+static const BitmapCharRec ch254 = {5,10,0,2,6,ch254data};
+
+/* char: 0xfd */
+
+static const GLubyte ch253data[] = {
+0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch253 = {4,11,0,2,5,ch253data};
+
+/* char: 0xfc */
+
+static const GLubyte ch252data[] = {
+0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50,
+};
+
+static const BitmapCharRec ch252 = {4,8,0,0,5,ch252data};
+
+/* char: 0xfb */
+
+static const GLubyte ch251data[] = {
+0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch251 = {4,9,0,0,5,ch251data};
+
+/* char: 0xfa */
+
+static const GLubyte ch250data[] = {
+0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch250 = {4,9,0,0,5,ch250data};
+
+/* char: 0xf9 */
+
+static const GLubyte ch249data[] = {
+0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch249 = {4,9,0,0,5,ch249data};
+
+/* char: 0xf8 */
+
+static const GLubyte ch248data[] = {
+0x70,0x88,0xc8,0xa8,0x98,0x74,
+};
+
+static const BitmapCharRec ch248 = {6,6,0,0,6,ch248data};
+
+/* char: 0xf7 */
+
+static const GLubyte ch247data[] = {
+0x20,0x0,0xf8,0x0,0x20,
+};
+
+static const BitmapCharRec ch247 = {5,5,0,-1,6,ch247data};
+
+/* char: 0xf6 */
+
+static const GLubyte ch246data[] = {
+0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,
+};
+
+static const BitmapCharRec ch246 = {5,8,0,0,6,ch246data};
+
+/* char: 0xf5 */
+
+static const GLubyte ch245data[] = {
+0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch245 = {5,9,0,0,6,ch245data};
+
+/* char: 0xf4 */
+
+static const GLubyte ch244data[] = {
+0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch244 = {5,9,0,0,6,ch244data};
+
+/* char: 0xf3 */
+
+static const GLubyte ch243data[] = {
+0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch243 = {5,9,0,0,6,ch243data};
+
+/* char: 0xf2 */
+
+static const GLubyte ch242data[] = {
+0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch242 = {5,9,0,0,6,ch242data};
+
+/* char: 0xf1 */
+
+static const GLubyte ch241data[] = {
+0x90,0x90,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50,
+};
+
+static const BitmapCharRec ch241 = {4,9,0,0,5,ch241data};
+
+/* char: 0xf0 */
+
+static const GLubyte ch240data[] = {
+0x70,0x88,0x88,0x88,0x88,0x78,0x90,0x60,0x50,
+};
+
+static const BitmapCharRec ch240 = {5,9,0,0,6,ch240data};
+
+/* char: 0xef */
+
+static const GLubyte ch239data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
+};
+
+static const BitmapCharRec ch239 = {3,8,0,0,2,ch239data};
+
+/* char: 0xee */
+
+static const GLubyte ch238data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch238 = {3,9,1,0,2,ch238data};
+
+/* char: 0xed */
+
+static const GLubyte ch237data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
+};
+
+static const BitmapCharRec ch237 = {2,9,0,0,2,ch237data};
+
+/* char: 0xec */
+
+static const GLubyte ch236data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch236 = {2,9,1,0,2,ch236data};
+
+/* char: 0xeb */
+
+static const GLubyte ch235data[] = {
+0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50,
+};
+
+static const BitmapCharRec ch235 = {4,8,0,0,5,ch235data};
+
+/* char: 0xea */
+
+static const GLubyte ch234data[] = {
+0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch234 = {4,9,0,0,5,ch234data};
+
+/* char: 0xe9 */
+
+static const GLubyte ch233data[] = {
+0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch233 = {4,9,0,0,5,ch233data};
+
+/* char: 0xe8 */
+
+static const GLubyte ch232data[] = {
+0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch232 = {4,9,0,0,5,ch232data};
+
+/* char: 0xe7 */
+
+static const GLubyte ch231data[] = {
+0x60,0x20,0x60,0x90,0x80,0x80,0x90,0x60,
+};
+
+static const BitmapCharRec ch231 = {4,8,0,2,5,ch231data};
+
+/* char: 0xe6 */
+
+static const GLubyte ch230data[] = {
+0x6c,0x92,0x90,0x7e,0x12,0xec,
+};
+
+static const BitmapCharRec ch230 = {7,6,0,0,8,ch230data};
+
+/* char: 0xe5 */
+
+static const GLubyte ch229data[] = {
+0x68,0x90,0x90,0x70,0x10,0xe0,0x20,0x50,0x20,
+};
+
+static const BitmapCharRec ch229 = {5,9,0,0,5,ch229data};
+
+/* char: 0xe4 */
+
+static const GLubyte ch228data[] = {
+0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50,
+};
+
+static const BitmapCharRec ch228 = {5,8,0,0,5,ch228data};
+
+/* char: 0xe3 */
+
+static const GLubyte ch227data[] = {
+0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0xa0,0x50,
+};
+
+static const BitmapCharRec ch227 = {5,9,0,0,5,ch227data};
+
+/* char: 0xe2 */
+
+static const GLubyte ch226data[] = {
+0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch226 = {5,9,0,0,5,ch226data};
+
+/* char: 0xe1 */
+
+static const GLubyte ch225data[] = {
+0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch225 = {5,9,0,0,5,ch225data};
+
+/* char: 0xe0 */
+
+static const GLubyte ch224data[] = {
+0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch224 = {5,9,0,0,5,ch224data};
+
+/* char: 0xdf */
+
+static const GLubyte ch223data[] = {
+0xa0,0x90,0x90,0x90,0xa0,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch223 = {4,8,0,0,5,ch223data};
+
+/* char: 0xde */
+
+static const GLubyte ch222data[] = {
+0x80,0x80,0xf0,0x88,0x88,0xf0,0x80,0x80,
+};
+
+static const BitmapCharRec ch222 = {5,8,-1,0,7,ch222data};
+
+/* char: 0xdd */
+
+static const GLubyte ch221data[] = {
+0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch221 = {7,11,0,0,7,ch221data};
+
+/* char: 0xdc */
+
+static const GLubyte ch220data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,
+};
+
+static const BitmapCharRec ch220 = {6,10,-1,0,8,ch220data};
+
+/* char: 0xdb */
+
+static const GLubyte ch219data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch219 = {6,11,-1,0,8,ch219data};
+
+/* char: 0xda */
+
+static const GLubyte ch218data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch218 = {6,11,-1,0,8,ch218data};
+
+/* char: 0xd9 */
+
+static const GLubyte ch217data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch217 = {6,11,-1,0,8,ch217data};
+
+/* char: 0xd8 */
+
+static const GLubyte ch216data[] = {
+0x80,0x78,0xc4,0xa4,0xa4,0x94,0x94,0x8c,0x78,0x4,
+};
+
+static const BitmapCharRec ch216 = {6,10,-1,1,8,ch216data};
+
+/* char: 0xd7 */
+
+static const GLubyte ch215data[] = {
+0x88,0x50,0x20,0x50,0x88,
+};
+
+static const BitmapCharRec ch215 = {5,5,0,-1,6,ch215data};
+
+/* char: 0xd6 */
+
+static const GLubyte ch214data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x48,
+};
+
+static const BitmapCharRec ch214 = {6,10,-1,0,8,ch214data};
+
+/* char: 0xd5 */
+
+static const GLubyte ch213data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch213 = {6,11,-1,0,8,ch213data};
+
+/* char: 0xd4 */
+
+static const GLubyte ch212data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch212 = {6,11,-1,0,8,ch212data};
+
+/* char: 0xd3 */
+
+static const GLubyte ch211data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch211 = {6,11,-1,0,8,ch211data};
+
+/* char: 0xd2 */
+
+static const GLubyte ch210data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch210 = {6,11,-1,0,8,ch210data};
+
+/* char: 0xd1 */
+
+static const GLubyte ch209data[] = {
+0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch209 = {6,11,-1,0,8,ch209data};
+
+/* char: 0xd0 */
+
+static const GLubyte ch208data[] = {
+0x78,0x44,0x42,0x42,0xf2,0x42,0x44,0x78,
+};
+
+static const BitmapCharRec ch208 = {7,8,0,0,8,ch208data};
+
+/* char: 0xcf */
+
+static const GLubyte ch207data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
+};
+
+static const BitmapCharRec ch207 = {3,10,0,0,3,ch207data};
+
+/* char: 0xce */
+
+static const GLubyte ch206data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch206 = {3,11,0,0,3,ch206data};
+
+/* char: 0xcd */
+
+static const GLubyte ch205data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
+};
+
+static const BitmapCharRec ch205 = {2,11,-1,0,3,ch205data};
+
+/* char: 0xcc */
+
+static const GLubyte ch204data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch204 = {2,11,0,0,3,ch204data};
+
+/* char: 0xcb */
+
+static const GLubyte ch203data[] = {
+0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x50,
+};
+
+static const BitmapCharRec ch203 = {5,10,-1,0,7,ch203data};
+
+/* char: 0xca */
+
+static const GLubyte ch202data[] = {
+0xf8,0x80,0x80,0xf8,0x80,0x80,0x80,0xf8,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch202 = {5,11,-1,0,7,ch202data};
+
+/* char: 0xc9 */
+
+static const GLubyte ch201data[] = {
+0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch201 = {5,11,-1,0,7,ch201data};
+
+/* char: 0xc8 */
+
+static const GLubyte ch200data[] = {
+0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch200 = {5,11,-1,0,7,ch200data};
+
+/* char: 0xc7 */
+
+static const GLubyte ch199data[] = {
+0x30,0x10,0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch199 = {6,10,-1,2,8,ch199data};
+
+/* char: 0xc6 */
+
+static const GLubyte ch198data[] = {
+0x8f,0x80,0x88,0x0,0x78,0x0,0x48,0x0,0x2f,0x80,0x28,0x0,0x18,0x0,0x1f,0x80,
+};
+
+static const BitmapCharRec ch198 = {9,8,0,0,10,ch198data};
+
+/* char: 0xc5 */
+
+static const GLubyte ch197data[] = {
+0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x10,0x28,0x10,
+};
+
+static const BitmapCharRec ch197 = {7,11,0,0,7,ch197data};
+
+/* char: 0xc4 */
+
+static const GLubyte ch196data[] = {
+0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,
+};
+
+static const BitmapCharRec ch196 = {7,10,0,0,7,ch196data};
+
+/* char: 0xc3 */
+
+static const GLubyte ch195data[] = {
+0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x14,
+};
+
+static const BitmapCharRec ch195 = {7,11,0,0,7,ch195data};
+
+/* char: 0xc2 */
+
+static const GLubyte ch194data[] = {
+0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch194 = {7,11,0,0,7,ch194data};
+
+/* char: 0xc1 */
+
+static const GLubyte ch193data[] = {
+0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch193 = {7,11,0,0,7,ch193data};
+
+/* char: 0xc0 */
+
+static const GLubyte ch192data[] = {
+0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch192 = {7,11,0,0,7,ch192data};
+
+/* char: 0xbf */
+
+static const GLubyte ch191data[] = {
+0x60,0x90,0x80,0x40,0x20,0x20,0x0,0x20,
+};
+
+static const BitmapCharRec ch191 = {4,8,-1,2,6,ch191data};
+
+/* char: 0xbe */
+
+static const GLubyte ch190data[] = {
+0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0xc8,0x0,0x24,0x0,0x44,0x0,0xe2,0x0,
+};
+
+static const BitmapCharRec ch190 = {9,8,0,0,9,ch190data};
+
+/* char: 0xbd */
+
+static const GLubyte ch189data[] = {
+0x27,0x12,0x15,0xb,0x48,0x44,0xc4,0x42,
+};
+
+static const BitmapCharRec ch189 = {8,8,0,0,9,ch189data};
+
+/* char: 0xbc */
+
+static const GLubyte ch188data[] = {
+0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0x48,0x0,0x44,0x0,0xc4,0x0,0x42,0x0,
+};
+
+static const BitmapCharRec ch188 = {9,8,0,0,9,ch188data};
+
+/* char: 0xbb */
+
+static const GLubyte ch187data[] = {
+0xa0,0x50,0x28,0x50,0xa0,
+};
+
+static const BitmapCharRec ch187 = {5,5,0,0,6,ch187data};
+
+/* char: 0xba */
+
+static const GLubyte ch186data[] = {
+0xe0,0x0,0xe0,0xa0,0xe0,
+};
+
+static const BitmapCharRec ch186 = {3,5,0,-3,4,ch186data};
+
+/* char: 0xb9 */
+
+static const GLubyte ch185data[] = {
+0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch185 = {2,4,0,-3,3,ch185data};
+
+/* char: 0xb8 */
+
+static const GLubyte ch184data[] = {
+0xc0,0x40,
+};
+
+static const BitmapCharRec ch184 = {2,2,0,2,3,ch184data};
+
+/* char: 0xb7 */
+
+static const GLubyte ch183data[] = {
+0xc0,
+};
+
+static const BitmapCharRec ch183 = {2,1,0,-3,3,ch183data};
+
+/* char: 0xb6 */
+
+static const GLubyte ch182data[] = {
+0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c,
+};
+
+static const BitmapCharRec ch182 = {6,10,0,2,6,ch182data};
+
+/* char: 0xb5 */
+
+static const GLubyte ch181data[] = {
+0x80,0x80,0xf0,0x90,0x90,0x90,0x90,0x90,
+};
+
+static const BitmapCharRec ch181 = {4,8,0,2,5,ch181data};
+
+/* char: 0xb4 */
+
+static const GLubyte ch180data[] = {
+0x80,0x40,
+};
+
+static const BitmapCharRec ch180 = {2,2,0,-6,3,ch180data};
+
+/* char: 0xb3 */
+
+static const GLubyte ch179data[] = {
+0xc0,0x20,0x40,0xe0,
+};
+
+static const BitmapCharRec ch179 = {3,4,0,-3,3,ch179data};
+
+/* char: 0xb2 */
+
+static const GLubyte ch178data[] = {
+0xe0,0x40,0xa0,0x60,
+};
+
+static const BitmapCharRec ch178 = {3,4,0,-3,3,ch178data};
+
+/* char: 0xb1 */
+
+static const GLubyte ch177data[] = {
+0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch177 = {5,7,0,0,6,ch177data};
+
+/* char: 0xb0 */
+
+static const GLubyte ch176data[] = {
+0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch176 = {4,4,0,-3,4,ch176data};
+
+/* char: 0xaf */
+
+static const GLubyte ch175data[] = {
+0xe0,
+};
+
+static const BitmapCharRec ch175 = {3,1,0,-7,3,ch175data};
+
+/* char: 0xae */
+
+static const GLubyte ch174data[] = {
+0x38,0x44,0xaa,0xb2,0xba,0x44,0x38,
+};
+
+static const BitmapCharRec ch174 = {7,7,-1,0,9,ch174data};
+
+/* char: 0xad */
+
+static const GLubyte ch173data[] = {
+0xe0,
+};
+
+static const BitmapCharRec ch173 = {3,1,0,-3,4,ch173data};
+
+/* char: 0xac */
+
+static const GLubyte ch172data[] = {
+0x8,0x8,0xf8,
+};
+
+static const BitmapCharRec ch172 = {5,3,-1,-2,7,ch172data};
+
+/* char: 0xab */
+
+static const GLubyte ch171data[] = {
+0x28,0x50,0xa0,0x50,0x28,
+};
+
+static const BitmapCharRec ch171 = {5,5,0,0,6,ch171data};
+
+/* char: 0xaa */
+
+static const GLubyte ch170data[] = {
+0xe0,0x0,0xa0,0x20,0xe0,
+};
+
+static const BitmapCharRec ch170 = {3,5,0,-3,4,ch170data};
+
+/* char: 0xa9 */
+
+static const GLubyte ch169data[] = {
+0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38,
+};
+
+static const BitmapCharRec ch169 = {7,7,-1,0,9,ch169data};
+
+/* char: 0xa8 */
+
+static const GLubyte ch168data[] = {
+0xa0,
+};
+
+static const BitmapCharRec ch168 = {3,1,0,-7,3,ch168data};
+
+/* char: 0xa7 */
+
+static const GLubyte ch167data[] = {
+0x70,0x88,0x18,0x70,0xc8,0x98,0x70,0xc0,0x88,0x70,
+};
+
+static const BitmapCharRec ch167 = {5,10,0,2,6,ch167data};
+
+/* char: 0xa6 */
+
+static const GLubyte ch166data[] = {
+0x80,0x80,0x80,0x80,0x0,0x0,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch166 = {1,10,-1,2,3,ch166data};
+
+/* char: 0xa5 */
+
+static const GLubyte ch165data[] = {
+0x20,0xf8,0x20,0xf8,0x50,0x50,0x88,0x88,
+};
+
+static const BitmapCharRec ch165 = {5,8,0,0,6,ch165data};
+
+/* char: 0xa4 */
+
+static const GLubyte ch164data[] = {
+0x90,0x60,0x90,0x90,0x60,0x90,
+};
+
+static const BitmapCharRec ch164 = {4,6,0,-1,5,ch164data};
+
+/* char: 0xa3 */
+
+static const GLubyte ch163data[] = {
+0xb0,0x48,0x40,0x40,0xe0,0x40,0x48,0x30,
+};
+
+static const BitmapCharRec ch163 = {5,8,0,0,6,ch163data};
+
+/* char: 0xa2 */
+
+static const GLubyte ch162data[] = {
+0x40,0x70,0xa8,0xa0,0xa0,0xa8,0x70,0x10,
+};
+
+static const BitmapCharRec ch162 = {5,8,0,1,6,ch162data};
+
+/* char: 0xa1 */
+
+static const GLubyte ch161data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
+};
+
+static const BitmapCharRec ch161 = {1,8,-1,2,3,ch161data};
+
+/* char: 0xa0 */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch160data[] = { 0x0 };
+static const BitmapCharRec ch160 = {1,1,0,0,3,ch160data};
+#else
+static const BitmapCharRec ch160 = {0,0,0,0,3,0};
+#endif
+
+/* char: 0x7e '~' */
+
+static const GLubyte ch126data[] = {
+0x98,0x64,
+};
+
+static const BitmapCharRec ch126 = {6,2,0,-3,7,ch126data};
+
+/* char: 0x7d '}' */
+
+static const GLubyte ch125data[] = {
+0x80,0x40,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch125 = {3,10,0,2,3,ch125data};
+
+/* char: 0x7c '|' */
+
+static const GLubyte ch124data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch124 = {1,10,-1,2,3,ch124data};
+
+/* char: 0x7b '{' */
+
+static const GLubyte ch123data[] = {
+0x20,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20,
+};
+
+static const BitmapCharRec ch123 = {3,10,0,2,3,ch123data};
+
+/* char: 0x7a 'z' */
+
+static const GLubyte ch122data[] = {
+0xf0,0x80,0x40,0x20,0x10,0xf0,
+};
+
+static const BitmapCharRec ch122 = {4,6,0,0,5,ch122data};
+
+/* char: 0x79 'y' */
+
+static const GLubyte ch121data[] = {
+0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,
+};
+
+static const BitmapCharRec ch121 = {4,8,0,2,5,ch121data};
+
+/* char: 0x78 'x' */
+
+static const GLubyte ch120data[] = {
+0x88,0x88,0x50,0x20,0x50,0x88,
+};
+
+static const BitmapCharRec ch120 = {5,6,0,0,6,ch120data};
+
+/* char: 0x77 'w' */
+
+static const GLubyte ch119data[] = {
+0x28,0x28,0x54,0x54,0x92,0x92,
+};
+
+static const BitmapCharRec ch119 = {7,6,0,0,8,ch119data};
+
+/* char: 0x76 'v' */
+
+static const GLubyte ch118data[] = {
+0x20,0x20,0x50,0x50,0x88,0x88,
+};
+
+static const BitmapCharRec ch118 = {5,6,0,0,6,ch118data};
+
+/* char: 0x75 'u' */
+
+static const GLubyte ch117data[] = {
+0x70,0x90,0x90,0x90,0x90,0x90,
+};
+
+static const BitmapCharRec ch117 = {4,6,0,0,5,ch117data};
+
+/* char: 0x74 't' */
+
+static const GLubyte ch116data[] = {
+0x60,0x40,0x40,0x40,0x40,0xe0,0x40,0x40,
+};
+
+static const BitmapCharRec ch116 = {3,8,0,0,4,ch116data};
+
+/* char: 0x73 's' */
+
+static const GLubyte ch115data[] = {
+0x60,0x90,0x10,0x60,0x90,0x60,
+};
+
+static const BitmapCharRec ch115 = {4,6,0,0,5,ch115data};
+
+/* char: 0x72 'r' */
+
+static const GLubyte ch114data[] = {
+0x80,0x80,0x80,0x80,0xc0,0xa0,
+};
+
+static const BitmapCharRec ch114 = {3,6,0,0,4,ch114data};
+
+/* char: 0x71 'q' */
+
+static const GLubyte ch113data[] = {
+0x8,0x8,0x68,0x98,0x88,0x88,0x98,0x68,
+};
+
+static const BitmapCharRec ch113 = {5,8,0,2,6,ch113data};
+
+/* char: 0x70 'p' */
+
+static const GLubyte ch112data[] = {
+0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0,
+};
+
+static const BitmapCharRec ch112 = {5,8,0,2,6,ch112data};
+
+/* char: 0x6f 'o' */
+
+static const GLubyte ch111data[] = {
+0x70,0x88,0x88,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch111 = {5,6,0,0,6,ch111data};
+
+/* char: 0x6e 'n' */
+
+static const GLubyte ch110data[] = {
+0x88,0x88,0x88,0x88,0xc8,0xb0,
+};
+
+static const BitmapCharRec ch110 = {5,6,0,0,6,ch110data};
+
+/* char: 0x6d 'm' */
+
+static const GLubyte ch109data[] = {
+0x92,0x92,0x92,0x92,0x92,0xec,
+};
+
+static const BitmapCharRec ch109 = {7,6,0,0,8,ch109data};
+
+/* char: 0x6c 'l' */
+
+static const GLubyte ch108data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch108 = {1,8,0,0,2,ch108data};
+
+/* char: 0x6b 'k' */
+
+static const GLubyte ch107data[] = {
+0x90,0x90,0xa0,0xc0,0xa0,0x90,0x80,0x80,
+};
+
+static const BitmapCharRec ch107 = {4,8,0,0,5,ch107data};
+
+/* char: 0x6a 'j' */
+
+static const GLubyte ch106data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
+};
+
+static const BitmapCharRec ch106 = {1,9,0,1,2,ch106data};
+
+/* char: 0x69 'i' */
+
+static const GLubyte ch105data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
+};
+
+static const BitmapCharRec ch105 = {1,8,0,0,2,ch105data};
+
+/* char: 0x68 'h' */
+
+static const GLubyte ch104data[] = {
+0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
+};
+
+static const BitmapCharRec ch104 = {5,8,0,0,6,ch104data};
+
+/* char: 0x67 'g' */
+
+static const GLubyte ch103data[] = {
+0x70,0x8,0x68,0x98,0x88,0x88,0x98,0x68,
+};
+
+static const BitmapCharRec ch103 = {5,8,0,2,6,ch103data};
+
+/* char: 0x66 'f' */
+
+static const GLubyte ch102data[] = {
+0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30,
+};
+
+static const BitmapCharRec ch102 = {4,8,0,0,4,ch102data};
+
+/* char: 0x65 'e' */
+
+static const GLubyte ch101data[] = {
+0x60,0x90,0x80,0xf0,0x90,0x60,
+};
+
+static const BitmapCharRec ch101 = {4,6,0,0,5,ch101data};
+
+/* char: 0x64 'd' */
+
+static const GLubyte ch100data[] = {
+0x68,0x98,0x88,0x88,0x98,0x68,0x8,0x8,
+};
+
+static const BitmapCharRec ch100 = {5,8,0,0,6,ch100data};
+
+/* char: 0x63 'c' */
+
+static const GLubyte ch99data[] = {
+0x60,0x90,0x80,0x80,0x90,0x60,
+};
+
+static const BitmapCharRec ch99 = {4,6,0,0,5,ch99data};
+
+/* char: 0x62 'b' */
+
+static const GLubyte ch98data[] = {
+0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80,
+};
+
+static const BitmapCharRec ch98 = {5,8,0,0,6,ch98data};
+
+/* char: 0x61 'a' */
+
+static const GLubyte ch97data[] = {
+0x68,0x90,0x90,0x70,0x10,0xe0,
+};
+
+static const BitmapCharRec ch97 = {5,6,0,0,5,ch97data};
+
+/* char: 0x60 '`' */
+
+static const GLubyte ch96data[] = {
+0x80,0x80,0x40,
+};
+
+static const BitmapCharRec ch96 = {2,3,0,-5,3,ch96data};
+
+/* char: 0x5f '_' */
+
+static const GLubyte ch95data[] = {
+0xfc,
+};
+
+static const BitmapCharRec ch95 = {6,1,0,2,6,ch95data};
+
+/* char: 0x5e '^' */
+
+static const GLubyte ch94data[] = {
+0x88,0x50,0x50,0x20,0x20,
+};
+
+static const BitmapCharRec ch94 = {5,5,0,-3,6,ch94data};
+
+/* char: 0x5d ']' */
+
+static const GLubyte ch93data[] = {
+0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
+};
+
+static const BitmapCharRec ch93 = {2,10,0,2,3,ch93data};
+
+/* char: 0x5c '\' */
+
+static const GLubyte ch92data[] = {
+0x20,0x20,0x40,0x40,0x40,0x40,0x80,0x80,
+};
+
+static const BitmapCharRec ch92 = {3,8,0,0,3,ch92data};
+
+/* char: 0x5b '[' */
+
+static const GLubyte ch91data[] = {
+0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
+};
+
+static const BitmapCharRec ch91 = {2,10,-1,2,3,ch91data};
+
+/* char: 0x5a 'Z' */
+
+static const GLubyte ch90data[] = {
+0xf8,0x80,0x40,0x20,0x20,0x10,0x8,0xf8,
+};
+
+static const BitmapCharRec ch90 = {5,8,-1,0,7,ch90data};
+
+/* char: 0x59 'Y' */
+
+static const GLubyte ch89data[] = {
+0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82,
+};
+
+static const BitmapCharRec ch89 = {7,8,0,0,7,ch89data};
+
+/* char: 0x58 'X' */
+
+static const GLubyte ch88data[] = {
+0x88,0x88,0x50,0x50,0x20,0x50,0x88,0x88,
+};
+
+static const BitmapCharRec ch88 = {5,8,-1,0,7,ch88data};
+
+/* char: 0x57 'W' */
+
+static const GLubyte ch87data[] = {
+0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
+};
+
+static const BitmapCharRec ch87 = {9,8,0,0,9,ch87data};
+
+/* char: 0x56 'V' */
+
+static const GLubyte ch86data[] = {
+0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch86 = {7,8,0,0,7,ch86data};
+
+/* char: 0x55 'U' */
+
+static const GLubyte ch85data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch85 = {6,8,-1,0,8,ch85data};
+
+/* char: 0x54 'T' */
+
+static const GLubyte ch84data[] = {
+0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,
+};
+
+static const BitmapCharRec ch84 = {5,8,0,0,5,ch84data};
+
+/* char: 0x53 'S' */
+
+static const GLubyte ch83data[] = {
+0x70,0x88,0x88,0x8,0x70,0x80,0x88,0x70,
+};
+
+static const BitmapCharRec ch83 = {5,8,-1,0,7,ch83data};
+
+/* char: 0x52 'R' */
+
+static const GLubyte ch82data[] = {
+0x88,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0,
+};
+
+static const BitmapCharRec ch82 = {5,8,-1,0,7,ch82data};
+
+/* char: 0x51 'Q' */
+
+static const GLubyte ch81data[] = {
+0x2,0x7c,0x8c,0x94,0x84,0x84,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch81 = {7,9,-1,1,8,ch81data};
+
+/* char: 0x50 'P' */
+
+static const GLubyte ch80data[] = {
+0x80,0x80,0x80,0x80,0xf0,0x88,0x88,0xf0,
+};
+
+static const BitmapCharRec ch80 = {5,8,-1,0,7,ch80data};
+
+/* char: 0x4f 'O' */
+
+static const GLubyte ch79data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,
+};
+
+static const BitmapCharRec ch79 = {6,8,-1,0,8,ch79data};
+
+/* char: 0x4e 'N' */
+
+static const GLubyte ch78data[] = {
+0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4,
+};
+
+static const BitmapCharRec ch78 = {6,8,-1,0,8,ch78data};
+
+/* char: 0x4d 'M' */
+
+static const GLubyte ch77data[] = {
+0x92,0x92,0x92,0xaa,0xaa,0xc6,0xc6,0x82,
+};
+
+static const BitmapCharRec ch77 = {7,8,-1,0,9,ch77data};
+
+/* char: 0x4c 'L' */
+
+static const GLubyte ch76data[] = {
+0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch76 = {4,8,-1,0,6,ch76data};
+
+/* char: 0x4b 'K' */
+
+static const GLubyte ch75data[] = {
+0x88,0x88,0x90,0x90,0xe0,0xa0,0x90,0x88,
+};
+
+static const BitmapCharRec ch75 = {5,8,-1,0,7,ch75data};
+
+/* char: 0x4a 'J' */
+
+static const GLubyte ch74data[] = {
+0x60,0x90,0x10,0x10,0x10,0x10,0x10,0x10,
+};
+
+static const BitmapCharRec ch74 = {4,8,0,0,5,ch74data};
+
+/* char: 0x49 'I' */
+
+static const GLubyte ch73data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch73 = {1,8,-1,0,3,ch73data};
+
+/* char: 0x48 'H' */
+
+static const GLubyte ch72data[] = {
+0x84,0x84,0x84,0x84,0xfc,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch72 = {6,8,-1,0,8,ch72data};
+
+/* char: 0x47 'G' */
+
+static const GLubyte ch71data[] = {
+0x74,0x8c,0x84,0x8c,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch71 = {6,8,-1,0,8,ch71data};
+
+/* char: 0x46 'F' */
+
+static const GLubyte ch70data[] = {
+0x80,0x80,0x80,0x80,0xf0,0x80,0x80,0xf8,
+};
+
+static const BitmapCharRec ch70 = {5,8,-1,0,6,ch70data};
+
+/* char: 0x45 'E' */
+
+static const GLubyte ch69data[] = {
+0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,
+};
+
+static const BitmapCharRec ch69 = {5,8,-1,0,7,ch69data};
+
+/* char: 0x44 'D' */
+
+static const GLubyte ch68data[] = {
+0xf0,0x88,0x84,0x84,0x84,0x84,0x88,0xf0,
+};
+
+static const BitmapCharRec ch68 = {6,8,-1,0,8,ch68data};
+
+/* char: 0x43 'C' */
+
+static const GLubyte ch67data[] = {
+0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch67 = {6,8,-1,0,8,ch67data};
+
+/* char: 0x42 'B' */
+
+static const GLubyte ch66data[] = {
+0xf0,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0,
+};
+
+static const BitmapCharRec ch66 = {5,8,-1,0,7,ch66data};
+
+/* char: 0x41 'A' */
+
+static const GLubyte ch65data[] = {
+0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,
+};
+
+static const BitmapCharRec ch65 = {7,8,0,0,7,ch65data};
+
+/* char: 0x40 '@' */
+
+static const GLubyte ch64data[] = {
+0x3e,0x0,0x40,0x0,0x9b,0x0,0xa4,0x80,0xa4,0x80,0xa2,0x40,0x92,0x40,0x4d,0x40,
+0x20,0x80,0x1f,0x0,
+};
+
+static const BitmapCharRec ch64 = {10,10,0,2,11,ch64data};
+
+/* char: 0x3f '?' */
+
+static const GLubyte ch63data[] = {
+0x40,0x0,0x40,0x40,0x20,0x10,0x90,0x60,
+};
+
+static const BitmapCharRec ch63 = {4,8,-1,0,6,ch63data};
+
+/* char: 0x3e '>' */
+
+static const GLubyte ch62data[] = {
+0x80,0x40,0x20,0x40,0x80,
+};
+
+static const BitmapCharRec ch62 = {3,5,-1,-1,6,ch62data};
+
+/* char: 0x3d '=' */
+
+static const GLubyte ch61data[] = {
+0xf0,0x0,0xf0,
+};
+
+static const BitmapCharRec ch61 = {4,3,0,-2,5,ch61data};
+
+/* char: 0x3c '<' */
+
+static const GLubyte ch60data[] = {
+0x20,0x40,0x80,0x40,0x20,
+};
+
+static const BitmapCharRec ch60 = {3,5,-1,-1,6,ch60data};
+
+/* char: 0x3b ';' */
+
+static const GLubyte ch59data[] = {
+0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40,
+};
+
+static const BitmapCharRec ch59 = {2,8,0,2,3,ch59data};
+
+/* char: 0x3a ':' */
+
+static const GLubyte ch58data[] = {
+0x80,0x0,0x0,0x0,0x0,0x80,
+};
+
+static const BitmapCharRec ch58 = {1,6,-1,0,3,ch58data};
+
+/* char: 0x39 '9' */
+
+static const GLubyte ch57data[] = {
+0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch57 = {5,8,0,0,6,ch57data};
+
+/* char: 0x38 '8' */
+
+static const GLubyte ch56data[] = {
+0x70,0x88,0x88,0x88,0x70,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch56 = {5,8,0,0,6,ch56data};
+
+/* char: 0x37 '7' */
+
+static const GLubyte ch55data[] = {
+0x40,0x40,0x20,0x20,0x10,0x10,0x8,0xf8,
+};
+
+static const BitmapCharRec ch55 = {5,8,0,0,6,ch55data};
+
+/* char: 0x36 '6' */
+
+static const GLubyte ch54data[] = {
+0x70,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70,
+};
+
+static const BitmapCharRec ch54 = {5,8,0,0,6,ch54data};
+
+/* char: 0x35 '5' */
+
+static const GLubyte ch53data[] = {
+0x70,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8,
+};
+
+static const BitmapCharRec ch53 = {5,8,0,0,6,ch53data};
+
+/* char: 0x34 '4' */
+
+static const GLubyte ch52data[] = {
+0x10,0x10,0xf8,0x90,0x50,0x50,0x30,0x10,
+};
+
+static const BitmapCharRec ch52 = {5,8,0,0,6,ch52data};
+
+/* char: 0x33 '3' */
+
+static const GLubyte ch51data[] = {
+0x70,0x88,0x8,0x8,0x30,0x8,0x88,0x70,
+};
+
+static const BitmapCharRec ch51 = {5,8,0,0,6,ch51data};
+
+/* char: 0x32 '2' */
+
+static const GLubyte ch50data[] = {
+0xf8,0x80,0x40,0x30,0x8,0x8,0x88,0x70,
+};
+
+static const BitmapCharRec ch50 = {5,8,0,0,6,ch50data};
+
+/* char: 0x31 '1' */
+
+static const GLubyte ch49data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch49 = {2,8,-1,0,6,ch49data};
+
+/* char: 0x30 '0' */
+
+static const GLubyte ch48data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch48 = {5,8,0,0,6,ch48data};
+
+/* char: 0x2f '/' */
+
+static const GLubyte ch47data[] = {
+0x80,0x80,0x40,0x40,0x40,0x40,0x20,0x20,
+};
+
+static const BitmapCharRec ch47 = {3,8,0,0,3,ch47data};
+
+/* char: 0x2e '.' */
+
+static const GLubyte ch46data[] = {
+0x80,
+};
+
+static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
+
+/* char: 0x2d '-' */
+
+static const GLubyte ch45data[] = {
+0xf8,
+};
+
+static const BitmapCharRec ch45 = {5,1,-1,-3,7,ch45data};
+
+/* char: 0x2c ',' */
+
+static const GLubyte ch44data[] = {
+0x80,0x40,0x40,
+};
+
+static const BitmapCharRec ch44 = {2,3,0,2,3,ch44data};
+
+/* char: 0x2b '+' */
+
+static const GLubyte ch43data[] = {
+0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch43 = {5,5,0,-1,6,ch43data};
+
+/* char: 0x2a '*' */
+
+static const GLubyte ch42data[] = {
+0xa0,0x40,0xa0,
+};
+
+static const BitmapCharRec ch42 = {3,3,0,-5,4,ch42data};
+
+/* char: 0x29 ')' */
+
+static const GLubyte ch41data[] = {
+0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch41 = {3,10,-1,2,4,ch41data};
+
+/* char: 0x28 '(' */
+
+static const GLubyte ch40data[] = {
+0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
+};
+
+static const BitmapCharRec ch40 = {3,10,0,2,4,ch40data};
+
+/* char: 0x27 ''' */
+
+static const GLubyte ch39data[] = {
+0x80,0x40,0x40,
+};
+
+static const BitmapCharRec ch39 = {2,3,-1,-5,3,ch39data};
+
+/* char: 0x26 '&' */
+
+static const GLubyte ch38data[] = {
+0x64,0x98,0x98,0xa4,0x60,0x50,0x50,0x20,
+};
+
+static const BitmapCharRec ch38 = {6,8,-1,0,8,ch38data};
+
+/* char: 0x25 '%' */
+
+static const GLubyte ch37data[] = {
+0x26,0x29,0x16,0x10,0x8,0x68,0x94,0x64,
+};
+
+static const BitmapCharRec ch37 = {8,8,0,0,9,ch37data};
+
+/* char: 0x24 '$' */
+
+static const GLubyte ch36data[] = {
+0x20,0x70,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20,
+};
+
+static const BitmapCharRec ch36 = {5,9,0,1,6,ch36data};
+
+/* char: 0x23 '#' */
+
+static const GLubyte ch35data[] = {
+0x50,0x50,0xf8,0x28,0x7c,0x28,0x28,
+};
+
+static const BitmapCharRec ch35 = {6,7,0,0,6,ch35data};
+
+/* char: 0x22 '"' */
+
+static const GLubyte ch34data[] = {
+0xa0,0xa0,
+};
+
+static const BitmapCharRec ch34 = {3,2,-1,-6,4,ch34data};
+
+/* char: 0x21 '!' */
+
+static const GLubyte ch33data[] = {
+0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch33 = {1,8,-1,0,3,ch33data};
+
+/* char: 0x20 ' ' */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch32data[] = { 0x0 };
+static const BitmapCharRec ch32 = {0,0,0,0,3,ch32data};
+#else
+static const BitmapCharRec ch32 = {0,0,0,0,3,0};
+#endif
+
+static const BitmapCharRec * const chars[] = {
+&ch32,
+&ch33,
+&ch34,
+&ch35,
+&ch36,
+&ch37,
+&ch38,
+&ch39,
+&ch40,
+&ch41,
+&ch42,
+&ch43,
+&ch44,
+&ch45,
+&ch46,
+&ch47,
+&ch48,
+&ch49,
+&ch50,
+&ch51,
+&ch52,
+&ch53,
+&ch54,
+&ch55,
+&ch56,
+&ch57,
+&ch58,
+&ch59,
+&ch60,
+&ch61,
+&ch62,
+&ch63,
+&ch64,
+&ch65,
+&ch66,
+&ch67,
+&ch68,
+&ch69,
+&ch70,
+&ch71,
+&ch72,
+&ch73,
+&ch74,
+&ch75,
+&ch76,
+&ch77,
+&ch78,
+&ch79,
+&ch80,
+&ch81,
+&ch82,
+&ch83,
+&ch84,
+&ch85,
+&ch86,
+&ch87,
+&ch88,
+&ch89,
+&ch90,
+&ch91,
+&ch92,
+&ch93,
+&ch94,
+&ch95,
+&ch96,
+&ch97,
+&ch98,
+&ch99,
+&ch100,
+&ch101,
+&ch102,
+&ch103,
+&ch104,
+&ch105,
+&ch106,
+&ch107,
+&ch108,
+&ch109,
+&ch110,
+&ch111,
+&ch112,
+&ch113,
+&ch114,
+&ch115,
+&ch116,
+&ch117,
+&ch118,
+&ch119,
+&ch120,
+&ch121,
+&ch122,
+&ch123,
+&ch124,
+&ch125,
+&ch126,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+&ch160,
+&ch161,
+&ch162,
+&ch163,
+&ch164,
+&ch165,
+&ch166,
+&ch167,
+&ch168,
+&ch169,
+&ch170,
+&ch171,
+&ch172,
+&ch173,
+&ch174,
+&ch175,
+&ch176,
+&ch177,
+&ch178,
+&ch179,
+&ch180,
+&ch181,
+&ch182,
+&ch183,
+&ch184,
+&ch185,
+&ch186,
+&ch187,
+&ch188,
+&ch189,
+&ch190,
+&ch191,
+&ch192,
+&ch193,
+&ch194,
+&ch195,
+&ch196,
+&ch197,
+&ch198,
+&ch199,
+&ch200,
+&ch201,
+&ch202,
+&ch203,
+&ch204,
+&ch205,
+&ch206,
+&ch207,
+&ch208,
+&ch209,
+&ch210,
+&ch211,
+&ch212,
+&ch213,
+&ch214,
+&ch215,
+&ch216,
+&ch217,
+&ch218,
+&ch219,
+&ch220,
+&ch221,
+&ch222,
+&ch223,
+&ch224,
+&ch225,
+&ch226,
+&ch227,
+&ch228,
+&ch229,
+&ch230,
+&ch231,
+&ch232,
+&ch233,
+&ch234,
+&ch235,
+&ch236,
+&ch237,
+&ch238,
+&ch239,
+&ch240,
+&ch241,
+&ch242,
+&ch243,
+&ch244,
+&ch245,
+&ch246,
+&ch247,
+&ch248,
+&ch249,
+&ch250,
+&ch251,
+&ch252,
+&ch253,
+&ch254,
+&ch255,
+};
+
+const BitmapFontRec glutBitmapHelvetica10 = {
+"-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1",
+224,
+32,
+chars
+};
+
diff --git a/src/glut/glx/glut_hel12.c b/src/glut/glx/glut_hel12.c
new file mode 100644
index 0000000000..68aed8a2bd
--- /dev/null
+++ b/src/glut/glx/glut_hel12.c
@@ -0,0 +1,1788 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#define glutBitmapHelvetica12 XXX
+#include "glutbitmap.h"
+#undef glutBitmapHelvetica12
+
+/* char: 0xff */
+
+static const GLubyte ch255data[] = {
+0xc0,0x20,0x20,0x20,0x30,0x50,0x50,0x48,0x88,0x88,0x0,0x50,
+};
+
+static const BitmapCharRec ch255 = {5,12,-1,3,7,ch255data};
+
+/* char: 0xfe */
+
+static const GLubyte ch254data[] = {
+0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
+};
+
+static const BitmapCharRec ch254 = {5,12,-1,3,7,ch254data};
+
+/* char: 0xfd */
+
+static const GLubyte ch253data[] = {
+0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch253 = {5,13,-1,3,7,ch253data};
+
+/* char: 0xfc */
+
+static const GLubyte ch252data[] = {
+0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50,
+};
+
+static const BitmapCharRec ch252 = {5,9,-1,0,7,ch252data};
+
+/* char: 0xfb */
+
+static const GLubyte ch251data[] = {
+0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch251 = {5,10,-1,0,7,ch251data};
+
+/* char: 0xfa */
+
+static const GLubyte ch250data[] = {
+0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch250 = {5,10,-1,0,7,ch250data};
+
+/* char: 0xf9 */
+
+static const GLubyte ch249data[] = {
+0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch249 = {5,10,-1,0,7,ch249data};
+
+/* char: 0xf8 */
+
+static const GLubyte ch248data[] = {
+0xb8,0x44,0x64,0x54,0x4c,0x44,0x3a,
+};
+
+static const BitmapCharRec ch248 = {7,7,0,0,7,ch248data};
+
+/* char: 0xf7 */
+
+static const GLubyte ch247data[] = {
+0x20,0x0,0xf8,0x0,0x20,
+};
+
+static const BitmapCharRec ch247 = {5,5,-1,-1,7,ch247data};
+
+/* char: 0xf6 */
+
+static const GLubyte ch246data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,
+};
+
+static const BitmapCharRec ch246 = {5,9,-1,0,7,ch246data};
+
+/* char: 0xf5 */
+
+static const GLubyte ch245data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch245 = {5,10,-1,0,7,ch245data};
+
+/* char: 0xf4 */
+
+static const GLubyte ch244data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch244 = {5,10,-1,0,7,ch244data};
+
+/* char: 0xf3 */
+
+static const GLubyte ch243data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch243 = {5,10,-1,0,7,ch243data};
+
+/* char: 0xf2 */
+
+static const GLubyte ch242data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch242 = {5,10,-1,0,7,ch242data};
+
+/* char: 0xf1 */
+
+static const GLubyte ch241data[] = {
+0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch241 = {5,10,-1,0,7,ch241data};
+
+/* char: 0xf0 */
+
+static const GLubyte ch240data[] = {
+0x70,0x88,0x88,0x88,0x88,0x78,0x8,0x50,0x30,0x68,
+};
+
+static const BitmapCharRec ch240 = {5,10,-1,0,7,ch240data};
+
+/* char: 0xef */
+
+static const GLubyte ch239data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
+};
+
+static const BitmapCharRec ch239 = {3,9,0,0,3,ch239data};
+
+/* char: 0xee */
+
+static const GLubyte ch238data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch238 = {3,10,0,0,3,ch238data};
+
+/* char: 0xed */
+
+static const GLubyte ch237data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
+};
+
+static const BitmapCharRec ch237 = {2,10,-1,0,3,ch237data};
+
+/* char: 0xec */
+
+static const GLubyte ch236data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch236 = {2,10,0,0,3,ch236data};
+
+/* char: 0xeb */
+
+static const GLubyte ch235data[] = {
+0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50,
+};
+
+static const BitmapCharRec ch235 = {5,9,-1,0,7,ch235data};
+
+/* char: 0xea */
+
+static const GLubyte ch234data[] = {
+0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch234 = {5,10,-1,0,7,ch234data};
+
+/* char: 0xe9 */
+
+static const GLubyte ch233data[] = {
+0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch233 = {5,10,-1,0,7,ch233data};
+
+/* char: 0xe8 */
+
+static const GLubyte ch232data[] = {
+0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch232 = {5,10,-1,0,7,ch232data};
+
+/* char: 0xe7 */
+
+static const GLubyte ch231data[] = {
+0x60,0x10,0x20,0x70,0x88,0x80,0x80,0x80,0x88,0x70,
+};
+
+static const BitmapCharRec ch231 = {5,10,-1,3,7,ch231data};
+
+/* char: 0xe6 */
+
+static const GLubyte ch230data[] = {
+0x77,0x0,0x88,0x80,0x88,0x0,0x7f,0x80,0x8,0x80,0x88,0x80,0x77,0x0,
+};
+
+static const BitmapCharRec ch230 = {9,7,-1,0,11,ch230data};
+
+/* char: 0xe5 */
+
+static const GLubyte ch229data[] = {
+0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x30,0x48,0x30,
+};
+
+static const BitmapCharRec ch229 = {6,10,-1,0,7,ch229data};
+
+/* char: 0xe4 */
+
+static const GLubyte ch228data[] = {
+0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,
+};
+
+static const BitmapCharRec ch228 = {6,9,-1,0,7,ch228data};
+
+/* char: 0xe3 */
+
+static const GLubyte ch227data[] = {
+0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch227 = {6,10,-1,0,7,ch227data};
+
+/* char: 0xe2 */
+
+static const GLubyte ch226data[] = {
+0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch226 = {6,10,-1,0,7,ch226data};
+
+/* char: 0xe1 */
+
+static const GLubyte ch225data[] = {
+0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch225 = {6,10,-1,0,7,ch225data};
+
+/* char: 0xe0 */
+
+static const GLubyte ch224data[] = {
+0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch224 = {6,10,-1,0,7,ch224data};
+
+/* char: 0xdf */
+
+static const GLubyte ch223data[] = {
+0xb0,0x88,0x88,0x88,0xb0,0x88,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch223 = {5,9,-1,0,7,ch223data};
+
+/* char: 0xde */
+
+static const GLubyte ch222data[] = {
+0x80,0x80,0xf8,0x84,0x84,0x84,0xf8,0x80,0x80,
+};
+
+static const BitmapCharRec ch222 = {6,9,-1,0,8,ch222data};
+
+/* char: 0xdd */
+
+static const GLubyte ch221data[] = {
+0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch221 = {7,12,-1,0,9,ch221data};
+
+/* char: 0xdc */
+
+static const GLubyte ch220data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,
+};
+
+static const BitmapCharRec ch220 = {6,11,-1,0,8,ch220data};
+
+/* char: 0xdb */
+
+static const GLubyte ch219data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch219 = {6,12,-1,0,8,ch219data};
+
+/* char: 0xda */
+
+static const GLubyte ch218data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch218 = {6,12,-1,0,8,ch218data};
+
+/* char: 0xd9 */
+
+static const GLubyte ch217data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch217 = {6,12,-1,0,8,ch217data};
+
+/* char: 0xd8 */
+
+static const GLubyte ch216data[] = {
+0x80,0x0,0x5e,0x0,0x21,0x0,0x50,0x80,0x48,0x80,0x44,0x80,0x44,0x80,0x42,0x80,
+0x21,0x0,0x1e,0x80,0x0,0x40,
+};
+
+static const BitmapCharRec ch216 = {10,11,0,1,10,ch216data};
+
+/* char: 0xd7 */
+
+static const GLubyte ch215data[] = {
+0x88,0x50,0x20,0x50,0x88,
+};
+
+static const BitmapCharRec ch215 = {5,5,-1,-1,7,ch215data};
+
+/* char: 0xd6 */
+
+static const GLubyte ch214data[] = {
+0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x24,
+};
+
+static const BitmapCharRec ch214 = {8,11,-1,0,10,ch214data};
+
+/* char: 0xd5 */
+
+static const GLubyte ch213data[] = {
+0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x28,0x14,
+};
+
+static const BitmapCharRec ch213 = {8,12,-1,0,10,ch213data};
+
+/* char: 0xd4 */
+
+static const GLubyte ch212data[] = {
+0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x14,0x8,
+};
+
+static const BitmapCharRec ch212 = {8,12,-1,0,10,ch212data};
+
+/* char: 0xd3 */
+
+static const GLubyte ch211data[] = {
+0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x4,
+};
+
+static const BitmapCharRec ch211 = {8,12,-1,0,10,ch211data};
+
+/* char: 0xd2 */
+
+static const GLubyte ch210data[] = {
+0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x10,
+};
+
+static const BitmapCharRec ch210 = {8,12,-1,0,10,ch210data};
+
+/* char: 0xd1 */
+
+static const GLubyte ch209data[] = {
+0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82,0x0,0x28,0x14,
+};
+
+static const BitmapCharRec ch209 = {7,12,-1,0,9,ch209data};
+
+/* char: 0xd0 */
+
+static const GLubyte ch208data[] = {
+0x7c,0x42,0x41,0x41,0xf1,0x41,0x41,0x42,0x7c,
+};
+
+static const BitmapCharRec ch208 = {8,9,0,0,9,ch208data};
+
+/* char: 0xcf */
+
+static const GLubyte ch207data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
+};
+
+static const BitmapCharRec ch207 = {3,11,0,0,3,ch207data};
+
+/* char: 0xce */
+
+static const GLubyte ch206data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch206 = {3,12,0,0,3,ch206data};
+
+/* char: 0xcd */
+
+static const GLubyte ch205data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
+};
+
+static const BitmapCharRec ch205 = {2,12,-1,0,3,ch205data};
+
+/* char: 0xcc */
+
+static const GLubyte ch204data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch204 = {2,12,0,0,3,ch204data};
+
+/* char: 0xcb */
+
+static const GLubyte ch203data[] = {
+0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28,
+};
+
+static const BitmapCharRec ch203 = {6,11,-1,0,8,ch203data};
+
+/* char: 0xca */
+
+static const GLubyte ch202data[] = {
+0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch202 = {6,12,-1,0,8,ch202data};
+
+/* char: 0xc9 */
+
+static const GLubyte ch201data[] = {
+0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch201 = {6,12,-1,0,8,ch201data};
+
+/* char: 0xc8 */
+
+static const GLubyte ch200data[] = {
+0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch200 = {6,12,-1,0,8,ch200data};
+
+/* char: 0xc7 */
+
+static const GLubyte ch199data[] = {
+0x30,0x8,0x8,0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c,
+};
+
+static const BitmapCharRec ch199 = {7,12,-1,3,9,ch199data};
+
+/* char: 0xc6 */
+
+static const GLubyte ch198data[] = {
+0x8f,0x80,0x88,0x0,0x88,0x0,0x78,0x0,0x4f,0x80,0x48,0x0,0x28,0x0,0x28,0x0,
+0x1f,0x80,
+};
+
+static const BitmapCharRec ch198 = {9,9,-1,0,11,ch198data};
+
+/* char: 0xc5 */
+
+static const GLubyte ch197data[] = {
+0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x10,0x28,0x10,
+};
+
+static const BitmapCharRec ch197 = {7,12,-1,0,9,ch197data};
+
+/* char: 0xc4 */
+
+static const GLubyte ch196data[] = {
+0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,
+};
+
+static const BitmapCharRec ch196 = {7,11,-1,0,9,ch196data};
+
+/* char: 0xc3 */
+
+static const GLubyte ch195data[] = {
+0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x14,
+};
+
+static const BitmapCharRec ch195 = {7,12,-1,0,9,ch195data};
+
+/* char: 0xc2 */
+
+static const GLubyte ch194data[] = {
+0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch194 = {7,12,-1,0,9,ch194data};
+
+/* char: 0xc1 */
+
+static const GLubyte ch193data[] = {
+0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch193 = {7,12,-1,0,9,ch193data};
+
+/* char: 0xc0 */
+
+static const GLubyte ch192data[] = {
+0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch192 = {7,12,-1,0,9,ch192data};
+
+/* char: 0xbf */
+
+static const GLubyte ch191data[] = {
+0x70,0x88,0x88,0x40,0x40,0x20,0x20,0x0,0x20,
+};
+
+static const BitmapCharRec ch191 = {5,9,-1,3,7,ch191data};
+
+/* char: 0xbe */
+
+static const GLubyte ch190data[] = {
+0x21,0x0,0x17,0x80,0x15,0x0,0xb,0x0,0xc9,0x0,0x24,0x0,0x44,0x0,0x22,0x0,
+0xe1,0x0,
+};
+
+static const BitmapCharRec ch190 = {9,9,0,0,10,ch190data};
+
+/* char: 0xbd */
+
+static const GLubyte ch189data[] = {
+0x47,0x80,0x22,0x0,0x11,0x0,0x14,0x80,0x4b,0x0,0x48,0x0,0x44,0x0,0xc2,0x0,
+0x41,0x0,
+};
+
+static const BitmapCharRec ch189 = {9,9,0,0,10,ch189data};
+
+/* char: 0xbc */
+
+static const GLubyte ch188data[] = {
+0x41,0x0,0x27,0x80,0x15,0x0,0x13,0x0,0x49,0x0,0x44,0x0,0x44,0x0,0xc2,0x0,
+0x41,0x0,
+};
+
+static const BitmapCharRec ch188 = {9,9,0,0,10,ch188data};
+
+/* char: 0xbb */
+
+static const GLubyte ch187data[] = {
+0xa0,0x50,0x28,0x50,0xa0,
+};
+
+static const BitmapCharRec ch187 = {5,5,-1,-1,7,ch187data};
+
+/* char: 0xba */
+
+static const GLubyte ch186data[] = {
+0xe0,0x0,0xe0,0xa0,0xe0,
+};
+
+static const BitmapCharRec ch186 = {3,5,-1,-4,5,ch186data};
+
+/* char: 0xb9 */
+
+static const GLubyte ch185data[] = {
+0x40,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch185 = {2,5,-1,-3,4,ch185data};
+
+/* char: 0xb8 */
+
+static const GLubyte ch184data[] = {
+0xc0,0x20,0x20,0x40,
+};
+
+static const BitmapCharRec ch184 = {3,4,0,3,3,ch184data};
+
+/* char: 0xb7 */
+
+static const GLubyte ch183data[] = {
+0x80,
+};
+
+static const BitmapCharRec ch183 = {1,1,-1,-3,3,ch183data};
+
+/* char: 0xb6 */
+
+static const GLubyte ch182data[] = {
+0x28,0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x68,0x3c,
+};
+
+static const BitmapCharRec ch182 = {6,12,0,3,7,ch182data};
+
+/* char: 0xb5 */
+
+static const GLubyte ch181data[] = {
+0x80,0x80,0x80,0xe8,0x98,0x88,0x88,0x88,0x88,0x88,
+};
+
+static const BitmapCharRec ch181 = {5,10,-1,3,7,ch181data};
+
+/* char: 0xb4 */
+
+static const GLubyte ch180data[] = {
+0x80,0x40,
+};
+
+static const BitmapCharRec ch180 = {2,2,0,-8,2,ch180data};
+
+/* char: 0xb3 */
+
+static const GLubyte ch179data[] = {
+0xc0,0x20,0x40,0x20,0xe0,
+};
+
+static const BitmapCharRec ch179 = {3,5,0,-3,4,ch179data};
+
+/* char: 0xb2 */
+
+static const GLubyte ch178data[] = {
+0xf0,0x40,0x20,0x90,0x60,
+};
+
+static const BitmapCharRec ch178 = {4,5,0,-3,4,ch178data};
+
+/* char: 0xb1 */
+
+static const GLubyte ch177data[] = {
+0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch177 = {5,7,-1,0,7,ch177data};
+
+/* char: 0xb0 */
+
+static const GLubyte ch176data[] = {
+0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch176 = {4,4,0,-4,5,ch176data};
+
+/* char: 0xaf */
+
+static const GLubyte ch175data[] = {
+0xf0,
+};
+
+static const BitmapCharRec ch175 = {4,1,0,-8,4,ch175data};
+
+/* char: 0xae */
+
+static const GLubyte ch174data[] = {
+0x3e,0x0,0x41,0x0,0x94,0x80,0x94,0x80,0x98,0x80,0x94,0x80,0x9c,0x80,0x41,0x0,
+0x3e,0x0,
+};
+
+static const BitmapCharRec ch174 = {9,9,-1,0,11,ch174data};
+
+/* char: 0xad */
+
+static const GLubyte ch173data[] = {
+0xf0,
+};
+
+static const BitmapCharRec ch173 = {4,1,0,-3,5,ch173data};
+
+/* char: 0xac */
+
+static const GLubyte ch172data[] = {
+0x4,0x4,0x4,0xfc,
+};
+
+static const BitmapCharRec ch172 = {6,4,-1,-2,8,ch172data};
+
+/* char: 0xab */
+
+static const GLubyte ch171data[] = {
+0x28,0x50,0xa0,0x50,0x28,
+};
+
+static const BitmapCharRec ch171 = {5,5,-1,-1,7,ch171data};
+
+/* char: 0xaa */
+
+static const GLubyte ch170data[] = {
+0xe0,0x0,0xa0,0x20,0xe0,
+};
+
+static const BitmapCharRec ch170 = {3,5,-1,-4,5,ch170data};
+
+/* char: 0xa9 */
+
+static const GLubyte ch169data[] = {
+0x3e,0x0,0x41,0x0,0x9c,0x80,0xa2,0x80,0xa0,0x80,0xa2,0x80,0x9c,0x80,0x41,0x0,
+0x3e,0x0,
+};
+
+static const BitmapCharRec ch169 = {9,9,-1,0,11,ch169data};
+
+/* char: 0xa8 */
+
+static const GLubyte ch168data[] = {
+0xa0,
+};
+
+static const BitmapCharRec ch168 = {3,1,0,-8,3,ch168data};
+
+/* char: 0xa7 */
+
+static const GLubyte ch167data[] = {
+0x70,0x88,0x8,0x30,0x48,0x88,0x88,0x90,0x60,0x80,0x88,0x70,
+};
+
+static const BitmapCharRec ch167 = {5,12,0,3,6,ch167data};
+
+/* char: 0xa6 */
+
+static const GLubyte ch166data[] = {
+0x80,0x80,0x80,0x80,0x0,0x0,0x0,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch166 = {1,11,-1,2,3,ch166data};
+
+/* char: 0xa5 */
+
+static const GLubyte ch165data[] = {
+0x20,0x20,0xf8,0x20,0xf8,0x20,0x50,0x88,0x88,
+};
+
+static const BitmapCharRec ch165 = {5,9,-1,0,7,ch165data};
+
+/* char: 0xa4 */
+
+static const GLubyte ch164data[] = {
+0x84,0x78,0x48,0x48,0x78,0x84,
+};
+
+static const BitmapCharRec ch164 = {6,6,0,-1,7,ch164data};
+
+/* char: 0xa3 */
+
+static const GLubyte ch163data[] = {
+0xb0,0x48,0x20,0x20,0xf0,0x40,0x40,0x48,0x30,
+};
+
+static const BitmapCharRec ch163 = {5,9,-1,0,7,ch163data};
+
+/* char: 0xa2 */
+
+static const GLubyte ch162data[] = {
+0x40,0x70,0xc8,0xa0,0xa0,0xa0,0xa8,0x70,0x10,
+};
+
+static const BitmapCharRec ch162 = {5,9,-1,1,7,ch162data};
+
+/* char: 0xa1 */
+
+static const GLubyte ch161data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
+};
+
+static const BitmapCharRec ch161 = {1,10,-1,3,3,ch161data};
+
+/* char: 0xa0 */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch160data[] = { 0x0 };
+static const BitmapCharRec ch160 = {1,1,0,0,4,ch160data};
+#else
+static const BitmapCharRec ch160 = {0,0,0,0,4,0};
+#endif
+
+/* char: 0x7e '~' */
+
+static const GLubyte ch126data[] = {
+0x98,0x64,
+};
+
+static const BitmapCharRec ch126 = {6,2,0,-3,7,ch126data};
+
+/* char: 0x7d '}' */
+
+static const GLubyte ch125data[] = {
+0xc0,0x20,0x20,0x20,0x20,0x20,0x10,0x20,0x20,0x20,0x20,0xc0,
+};
+
+static const BitmapCharRec ch125 = {4,12,0,3,4,ch125data};
+
+/* char: 0x7c '|' */
+
+static const GLubyte ch124data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch124 = {1,12,-1,3,3,ch124data};
+
+/* char: 0x7b '{' */
+
+static const GLubyte ch123data[] = {
+0x30,0x40,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x40,0x30,
+};
+
+static const BitmapCharRec ch123 = {4,12,0,3,4,ch123data};
+
+/* char: 0x7a 'z' */
+
+static const GLubyte ch122data[] = {
+0xf0,0x80,0x40,0x40,0x20,0x10,0xf0,
+};
+
+static const BitmapCharRec ch122 = {4,7,-1,0,6,ch122data};
+
+/* char: 0x79 'y' */
+
+static const GLubyte ch121data[] = {
+0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88,
+};
+
+static const BitmapCharRec ch121 = {5,10,-1,3,7,ch121data};
+
+/* char: 0x78 'x' */
+
+static const GLubyte ch120data[] = {
+0x84,0x84,0x48,0x30,0x30,0x48,0x84,
+};
+
+static const BitmapCharRec ch120 = {6,7,0,0,6,ch120data};
+
+/* char: 0x77 'w' */
+
+static const GLubyte ch119data[] = {
+0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
+};
+
+static const BitmapCharRec ch119 = {9,7,0,0,9,ch119data};
+
+/* char: 0x76 'v' */
+
+static const GLubyte ch118data[] = {
+0x20,0x20,0x50,0x50,0x88,0x88,0x88,
+};
+
+static const BitmapCharRec ch118 = {5,7,-1,0,7,ch118data};
+
+/* char: 0x75 'u' */
+
+static const GLubyte ch117data[] = {
+0x68,0x98,0x88,0x88,0x88,0x88,0x88,
+};
+
+static const BitmapCharRec ch117 = {5,7,-1,0,7,ch117data};
+
+/* char: 0x74 't' */
+
+static const GLubyte ch116data[] = {
+0x60,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x40,
+};
+
+static const BitmapCharRec ch116 = {3,9,0,0,3,ch116data};
+
+/* char: 0x73 's' */
+
+static const GLubyte ch115data[] = {
+0x60,0x90,0x10,0x60,0x80,0x90,0x60,
+};
+
+static const BitmapCharRec ch115 = {4,7,-1,0,6,ch115data};
+
+/* char: 0x72 'r' */
+
+static const GLubyte ch114data[] = {
+0x80,0x80,0x80,0x80,0x80,0xc0,0xa0,
+};
+
+static const BitmapCharRec ch114 = {3,7,-1,0,4,ch114data};
+
+/* char: 0x71 'q' */
+
+static const GLubyte ch113data[] = {
+0x8,0x8,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68,
+};
+
+static const BitmapCharRec ch113 = {5,10,-1,3,7,ch113data};
+
+/* char: 0x70 'p' */
+
+static const GLubyte ch112data[] = {
+0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,
+};
+
+static const BitmapCharRec ch112 = {5,10,-1,3,7,ch112data};
+
+/* char: 0x6f 'o' */
+
+static const GLubyte ch111data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch111 = {5,7,-1,0,7,ch111data};
+
+/* char: 0x6e 'n' */
+
+static const GLubyte ch110data[] = {
+0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,
+};
+
+static const BitmapCharRec ch110 = {5,7,-1,0,7,ch110data};
+
+/* char: 0x6d 'm' */
+
+static const GLubyte ch109data[] = {
+0x92,0x92,0x92,0x92,0x92,0xda,0xa4,
+};
+
+static const BitmapCharRec ch109 = {7,7,-1,0,9,ch109data};
+
+/* char: 0x6c 'l' */
+
+static const GLubyte ch108data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch108 = {1,9,-1,0,3,ch108data};
+
+/* char: 0x6b 'k' */
+
+static const GLubyte ch107data[] = {
+0x88,0x90,0xa0,0xc0,0xc0,0xa0,0x90,0x80,0x80,
+};
+
+static const BitmapCharRec ch107 = {5,9,-1,0,6,ch107data};
+
+/* char: 0x6a 'j' */
+
+static const GLubyte ch106data[] = {
+0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,
+};
+
+static const BitmapCharRec ch106 = {2,12,0,3,3,ch106data};
+
+/* char: 0x69 'i' */
+
+static const GLubyte ch105data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
+};
+
+static const BitmapCharRec ch105 = {1,9,-1,0,3,ch105data};
+
+/* char: 0x68 'h' */
+
+static const GLubyte ch104data[] = {
+0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
+};
+
+static const BitmapCharRec ch104 = {5,9,-1,0,7,ch104data};
+
+/* char: 0x67 'g' */
+
+static const GLubyte ch103data[] = {
+0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68,
+};
+
+static const BitmapCharRec ch103 = {5,10,-1,3,7,ch103data};
+
+/* char: 0x66 'f' */
+
+static const GLubyte ch102data[] = {
+0x40,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30,
+};
+
+static const BitmapCharRec ch102 = {4,9,0,0,3,ch102data};
+
+/* char: 0x65 'e' */
+
+static const GLubyte ch101data[] = {
+0x70,0x88,0x80,0xf8,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch101 = {5,7,-1,0,7,ch101data};
+
+/* char: 0x64 'd' */
+
+static const GLubyte ch100data[] = {
+0x68,0x98,0x88,0x88,0x88,0x98,0x68,0x8,0x8,
+};
+
+static const BitmapCharRec ch100 = {5,9,-1,0,7,ch100data};
+
+/* char: 0x63 'c' */
+
+static const GLubyte ch99data[] = {
+0x70,0x88,0x80,0x80,0x80,0x88,0x70,
+};
+
+static const BitmapCharRec ch99 = {5,7,-1,0,7,ch99data};
+
+/* char: 0x62 'b' */
+
+static const GLubyte ch98data[] = {
+0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
+};
+
+static const BitmapCharRec ch98 = {5,9,-1,0,7,ch98data};
+
+/* char: 0x61 'a' */
+
+static const GLubyte ch97data[] = {
+0x74,0x88,0x88,0x78,0x8,0x88,0x70,
+};
+
+static const BitmapCharRec ch97 = {6,7,-1,0,7,ch97data};
+
+/* char: 0x60 '`' */
+
+static const GLubyte ch96data[] = {
+0xc0,0x80,0x40,
+};
+
+static const BitmapCharRec ch96 = {2,3,0,-6,3,ch96data};
+
+/* char: 0x5f '_' */
+
+static const GLubyte ch95data[] = {
+0xfe,
+};
+
+static const BitmapCharRec ch95 = {7,1,0,2,7,ch95data};
+
+/* char: 0x5e '^' */
+
+static const GLubyte ch94data[] = {
+0x88,0x50,0x20,
+};
+
+static const BitmapCharRec ch94 = {5,3,0,-5,6,ch94data};
+
+/* char: 0x5d ']' */
+
+static const GLubyte ch93data[] = {
+0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
+};
+
+static const BitmapCharRec ch93 = {2,12,0,3,3,ch93data};
+
+/* char: 0x5c '\' */
+
+static const GLubyte ch92data[] = {
+0x10,0x10,0x20,0x20,0x20,0x40,0x40,0x80,0x80,
+};
+
+static const BitmapCharRec ch92 = {4,9,0,0,4,ch92data};
+
+/* char: 0x5b '[' */
+
+static const GLubyte ch91data[] = {
+0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
+};
+
+static const BitmapCharRec ch91 = {2,12,-1,3,3,ch91data};
+
+/* char: 0x5a 'Z' */
+
+static const GLubyte ch90data[] = {
+0xfe,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0xfe,
+};
+
+static const BitmapCharRec ch90 = {7,9,-1,0,9,ch90data};
+
+/* char: 0x59 'Y' */
+
+static const GLubyte ch89data[] = {
+0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch89 = {7,9,-1,0,9,ch89data};
+
+/* char: 0x58 'X' */
+
+static const GLubyte ch88data[] = {
+0x82,0x44,0x44,0x28,0x10,0x28,0x44,0x44,0x82,
+};
+
+static const BitmapCharRec ch88 = {7,9,-1,0,9,ch88data};
+
+/* char: 0x57 'W' */
+
+static const GLubyte ch87data[] = {
+0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
+0x88,0x80,
+};
+
+static const BitmapCharRec ch87 = {9,9,-1,0,11,ch87data};
+
+/* char: 0x56 'V' */
+
+static const GLubyte ch86data[] = {
+0x10,0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82,
+};
+
+static const BitmapCharRec ch86 = {7,9,-1,0,9,ch86data};
+
+/* char: 0x55 'U' */
+
+static const GLubyte ch85data[] = {
+0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,
+};
+
+static const BitmapCharRec ch85 = {6,9,-1,0,8,ch85data};
+
+/* char: 0x54 'T' */
+
+static const GLubyte ch84data[] = {
+0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xfe,
+};
+
+static const BitmapCharRec ch84 = {7,9,0,0,7,ch84data};
+
+/* char: 0x53 'S' */
+
+static const GLubyte ch83data[] = {
+0x78,0x84,0x84,0x4,0x18,0x60,0x80,0x84,0x78,
+};
+
+static const BitmapCharRec ch83 = {6,9,-1,0,8,ch83data};
+
+/* char: 0x52 'R' */
+
+static const GLubyte ch82data[] = {
+0x84,0x84,0x84,0x88,0xf8,0x84,0x84,0x84,0xf8,
+};
+
+static const BitmapCharRec ch82 = {6,9,-1,0,8,ch82data};
+
+/* char: 0x51 'Q' */
+
+static const GLubyte ch81data[] = {
+0x3d,0x42,0x85,0x89,0x81,0x81,0x81,0x42,0x3c,
+};
+
+static const BitmapCharRec ch81 = {8,9,-1,0,10,ch81data};
+
+/* char: 0x50 'P' */
+
+static const GLubyte ch80data[] = {
+0x80,0x80,0x80,0x80,0xf8,0x84,0x84,0x84,0xf8,
+};
+
+static const BitmapCharRec ch80 = {6,9,-1,0,8,ch80data};
+
+/* char: 0x4f 'O' */
+
+static const GLubyte ch79data[] = {
+0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,
+};
+
+static const BitmapCharRec ch79 = {8,9,-1,0,10,ch79data};
+
+/* char: 0x4e 'N' */
+
+static const GLubyte ch78data[] = {
+0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82,
+};
+
+static const BitmapCharRec ch78 = {7,9,-1,0,9,ch78data};
+
+/* char: 0x4d 'M' */
+
+static const GLubyte ch77data[] = {
+0x88,0x80,0x88,0x80,0x94,0x80,0x94,0x80,0xa2,0x80,0xa2,0x80,0xc1,0x80,0xc1,0x80,
+0x80,0x80,
+};
+
+static const BitmapCharRec ch77 = {9,9,-1,0,11,ch77data};
+
+/* char: 0x4c 'L' */
+
+static const GLubyte ch76data[] = {
+0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch76 = {5,9,-1,0,7,ch76data};
+
+/* char: 0x4b 'K' */
+
+static const GLubyte ch75data[] = {
+0x82,0x84,0x88,0x90,0xe0,0xa0,0x90,0x88,0x84,
+};
+
+static const BitmapCharRec ch75 = {7,9,-1,0,8,ch75data};
+
+/* char: 0x4a 'J' */
+
+static const GLubyte ch74data[] = {
+0x70,0x88,0x88,0x8,0x8,0x8,0x8,0x8,0x8,
+};
+
+static const BitmapCharRec ch74 = {5,9,-1,0,7,ch74data};
+
+/* char: 0x49 'I' */
+
+static const GLubyte ch73data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch73 = {1,9,-1,0,3,ch73data};
+
+/* char: 0x48 'H' */
+
+static const GLubyte ch72data[] = {
+0x82,0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x82,
+};
+
+static const BitmapCharRec ch72 = {7,9,-1,0,9,ch72data};
+
+/* char: 0x47 'G' */
+
+static const GLubyte ch71data[] = {
+0x3a,0x46,0x82,0x82,0x8e,0x80,0x80,0x42,0x3c,
+};
+
+static const BitmapCharRec ch71 = {7,9,-1,0,9,ch71data};
+
+/* char: 0x46 'F' */
+
+static const GLubyte ch70data[] = {
+0x80,0x80,0x80,0x80,0xf8,0x80,0x80,0x80,0xfc,
+};
+
+static const BitmapCharRec ch70 = {6,9,-1,0,8,ch70data};
+
+/* char: 0x45 'E' */
+
+static const GLubyte ch69data[] = {
+0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,
+};
+
+static const BitmapCharRec ch69 = {6,9,-1,0,8,ch69data};
+
+/* char: 0x44 'D' */
+
+static const GLubyte ch68data[] = {
+0xf8,0x84,0x82,0x82,0x82,0x82,0x82,0x84,0xf8,
+};
+
+static const BitmapCharRec ch68 = {7,9,-1,0,9,ch68data};
+
+/* char: 0x43 'C' */
+
+static const GLubyte ch67data[] = {
+0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c,
+};
+
+static const BitmapCharRec ch67 = {7,9,-1,0,9,ch67data};
+
+/* char: 0x42 'B' */
+
+static const GLubyte ch66data[] = {
+0xf8,0x84,0x84,0x84,0xf8,0x84,0x84,0x84,0xf8,
+};
+
+static const BitmapCharRec ch66 = {6,9,-1,0,8,ch66data};
+
+/* char: 0x41 'A' */
+
+static const GLubyte ch65data[] = {
+0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x28,0x10,
+};
+
+static const BitmapCharRec ch65 = {7,9,-1,0,9,ch65data};
+
+/* char: 0x40 '@' */
+
+static const GLubyte ch64data[] = {
+0x3e,0x0,0x40,0x0,0x9b,0x0,0xa6,0x80,0xa2,0x40,0xa2,0x40,0x92,0x40,0x4d,0x40,
+0x60,0x80,0x1f,0x0,
+};
+
+static const BitmapCharRec ch64 = {10,10,-1,1,12,ch64data};
+
+/* char: 0x3f '?' */
+
+static const GLubyte ch63data[] = {
+0x20,0x0,0x20,0x20,0x10,0x10,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch63 = {5,9,-1,0,7,ch63data};
+
+/* char: 0x3e '>' */
+
+static const GLubyte ch62data[] = {
+0xc0,0x30,0xc,0x30,0xc0,
+};
+
+static const BitmapCharRec ch62 = {6,5,-1,-1,7,ch62data};
+
+/* char: 0x3d '=' */
+
+static const GLubyte ch61data[] = {
+0xf8,0x0,0xf8,
+};
+
+static const BitmapCharRec ch61 = {5,3,-1,-2,7,ch61data};
+
+/* char: 0x3c '<' */
+
+static const GLubyte ch60data[] = {
+0xc,0x30,0xc0,0x30,0xc,
+};
+
+static const BitmapCharRec ch60 = {6,5,0,-1,7,ch60data};
+
+/* char: 0x3b ';' */
+
+static const GLubyte ch59data[] = {
+0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40,
+};
+
+static const BitmapCharRec ch59 = {2,8,0,2,3,ch59data};
+
+/* char: 0x3a ':' */
+
+static const GLubyte ch58data[] = {
+0x80,0x0,0x0,0x0,0x0,0x80,
+};
+
+static const BitmapCharRec ch58 = {1,6,-1,0,3,ch58data};
+
+/* char: 0x39 '9' */
+
+static const GLubyte ch57data[] = {
+0x70,0x88,0x8,0x8,0x78,0x88,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch57 = {5,9,-1,0,7,ch57data};
+
+/* char: 0x38 '8' */
+
+static const GLubyte ch56data[] = {
+0x70,0x88,0x88,0x88,0x88,0x70,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch56 = {5,9,-1,0,7,ch56data};
+
+/* char: 0x37 '7' */
+
+static const GLubyte ch55data[] = {
+0x40,0x40,0x20,0x20,0x20,0x10,0x10,0x8,0xf8,
+};
+
+static const BitmapCharRec ch55 = {5,9,-1,0,7,ch55data};
+
+/* char: 0x36 '6' */
+
+static const GLubyte ch54data[] = {
+0x70,0x88,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70,
+};
+
+static const BitmapCharRec ch54 = {5,9,-1,0,7,ch54data};
+
+/* char: 0x35 '5' */
+
+static const GLubyte ch53data[] = {
+0x70,0x88,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8,
+};
+
+static const BitmapCharRec ch53 = {5,9,-1,0,7,ch53data};
+
+/* char: 0x34 '4' */
+
+static const GLubyte ch52data[] = {
+0x8,0x8,0xfc,0x88,0x48,0x28,0x28,0x18,0x8,
+};
+
+static const BitmapCharRec ch52 = {6,9,0,0,7,ch52data};
+
+/* char: 0x33 '3' */
+
+static const GLubyte ch51data[] = {
+0x70,0x88,0x88,0x8,0x8,0x30,0x8,0x88,0x70,
+};
+
+static const BitmapCharRec ch51 = {5,9,-1,0,7,ch51data};
+
+/* char: 0x32 '2' */
+
+static const GLubyte ch50data[] = {
+0xf8,0x80,0x80,0x40,0x20,0x10,0x8,0x88,0x70,
+};
+
+static const BitmapCharRec ch50 = {5,9,-1,0,7,ch50data};
+
+/* char: 0x31 '1' */
+
+static const GLubyte ch49data[] = {
+0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xe0,0x20,
+};
+
+static const BitmapCharRec ch49 = {3,9,-1,0,7,ch49data};
+
+/* char: 0x30 '0' */
+
+static const GLubyte ch48data[] = {
+0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x70,
+};
+
+static const BitmapCharRec ch48 = {5,9,-1,0,7,ch48data};
+
+/* char: 0x2f '/' */
+
+static const GLubyte ch47data[] = {
+0x80,0x80,0x40,0x40,0x40,0x20,0x20,0x10,0x10,
+};
+
+static const BitmapCharRec ch47 = {4,9,0,0,4,ch47data};
+
+/* char: 0x2e '.' */
+
+static const GLubyte ch46data[] = {
+0x80,
+};
+
+static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
+
+/* char: 0x2d '-' */
+
+static const GLubyte ch45data[] = {
+0xf8,
+};
+
+static const BitmapCharRec ch45 = {5,1,-1,-3,8,ch45data};
+
+/* char: 0x2c ',' */
+
+static const GLubyte ch44data[] = {
+0x80,0x40,0x40,
+};
+
+static const BitmapCharRec ch44 = {2,3,-1,2,4,ch44data};
+
+/* char: 0x2b '+' */
+
+static const GLubyte ch43data[] = {
+0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch43 = {5,5,-1,-1,7,ch43data};
+
+/* char: 0x2a '*' */
+
+static const GLubyte ch42data[] = {
+0xa0,0x40,0xa0,
+};
+
+static const BitmapCharRec ch42 = {3,3,-1,-6,5,ch42data};
+
+/* char: 0x29 ')' */
+
+static const GLubyte ch41data[] = {
+0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch41 = {3,12,0,3,4,ch41data};
+
+/* char: 0x28 '(' */
+
+static const GLubyte ch40data[] = {
+0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
+};
+
+static const BitmapCharRec ch40 = {3,12,-1,3,4,ch40data};
+
+/* char: 0x27 ''' */
+
+static const GLubyte ch39data[] = {
+0x80,0x40,0xc0,
+};
+
+static const BitmapCharRec ch39 = {2,3,-1,-6,3,ch39data};
+
+/* char: 0x26 '&' */
+
+static const GLubyte ch38data[] = {
+0x72,0x8c,0x84,0x8a,0x50,0x30,0x48,0x48,0x30,
+};
+
+static const BitmapCharRec ch38 = {7,9,-1,0,9,ch38data};
+
+/* char: 0x25 '%' */
+
+static const GLubyte ch37data[] = {
+0x23,0x0,0x14,0x80,0x14,0x80,0x13,0x0,0x8,0x0,0x68,0x0,0x94,0x0,0x94,0x0,
+0x62,0x0,
+};
+
+static const BitmapCharRec ch37 = {9,9,-1,0,11,ch37data};
+
+/* char: 0x24 '$' */
+
+static const GLubyte ch36data[] = {
+0x20,0x70,0xa8,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20,
+};
+
+static const BitmapCharRec ch36 = {5,10,-1,1,7,ch36data};
+
+/* char: 0x23 '#' */
+
+static const GLubyte ch35data[] = {
+0x50,0x50,0x50,0xfc,0x28,0xfc,0x28,0x28,
+};
+
+static const BitmapCharRec ch35 = {6,8,0,0,7,ch35data};
+
+/* char: 0x22 '"' */
+
+static const GLubyte ch34data[] = {
+0xa0,0xa0,0xa0,
+};
+
+static const BitmapCharRec ch34 = {3,3,-1,-6,5,ch34data};
+
+/* char: 0x21 '!' */
+
+static const GLubyte ch33data[] = {
+0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch33 = {1,9,-1,0,3,ch33data};
+
+/* char: 0x20 ' ' */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch32data[] = { 0x0 };
+static const BitmapCharRec ch32 = {1,1,0,0,4,ch32data};
+#else
+static const BitmapCharRec ch32 = {0,0,0,0,4,0};
+#endif
+
+static const BitmapCharRec * const chars[] = {
+&ch32,
+&ch33,
+&ch34,
+&ch35,
+&ch36,
+&ch37,
+&ch38,
+&ch39,
+&ch40,
+&ch41,
+&ch42,
+&ch43,
+&ch44,
+&ch45,
+&ch46,
+&ch47,
+&ch48,
+&ch49,
+&ch50,
+&ch51,
+&ch52,
+&ch53,
+&ch54,
+&ch55,
+&ch56,
+&ch57,
+&ch58,
+&ch59,
+&ch60,
+&ch61,
+&ch62,
+&ch63,
+&ch64,
+&ch65,
+&ch66,
+&ch67,
+&ch68,
+&ch69,
+&ch70,
+&ch71,
+&ch72,
+&ch73,
+&ch74,
+&ch75,
+&ch76,
+&ch77,
+&ch78,
+&ch79,
+&ch80,
+&ch81,
+&ch82,
+&ch83,
+&ch84,
+&ch85,
+&ch86,
+&ch87,
+&ch88,
+&ch89,
+&ch90,
+&ch91,
+&ch92,
+&ch93,
+&ch94,
+&ch95,
+&ch96,
+&ch97,
+&ch98,
+&ch99,
+&ch100,
+&ch101,
+&ch102,
+&ch103,
+&ch104,
+&ch105,
+&ch106,
+&ch107,
+&ch108,
+&ch109,
+&ch110,
+&ch111,
+&ch112,
+&ch113,
+&ch114,
+&ch115,
+&ch116,
+&ch117,
+&ch118,
+&ch119,
+&ch120,
+&ch121,
+&ch122,
+&ch123,
+&ch124,
+&ch125,
+&ch126,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+&ch160,
+&ch161,
+&ch162,
+&ch163,
+&ch164,
+&ch165,
+&ch166,
+&ch167,
+&ch168,
+&ch169,
+&ch170,
+&ch171,
+&ch172,
+&ch173,
+&ch174,
+&ch175,
+&ch176,
+&ch177,
+&ch178,
+&ch179,
+&ch180,
+&ch181,
+&ch182,
+&ch183,
+&ch184,
+&ch185,
+&ch186,
+&ch187,
+&ch188,
+&ch189,
+&ch190,
+&ch191,
+&ch192,
+&ch193,
+&ch194,
+&ch195,
+&ch196,
+&ch197,
+&ch198,
+&ch199,
+&ch200,
+&ch201,
+&ch202,
+&ch203,
+&ch204,
+&ch205,
+&ch206,
+&ch207,
+&ch208,
+&ch209,
+&ch210,
+&ch211,
+&ch212,
+&ch213,
+&ch214,
+&ch215,
+&ch216,
+&ch217,
+&ch218,
+&ch219,
+&ch220,
+&ch221,
+&ch222,
+&ch223,
+&ch224,
+&ch225,
+&ch226,
+&ch227,
+&ch228,
+&ch229,
+&ch230,
+&ch231,
+&ch232,
+&ch233,
+&ch234,
+&ch235,
+&ch236,
+&ch237,
+&ch238,
+&ch239,
+&ch240,
+&ch241,
+&ch242,
+&ch243,
+&ch244,
+&ch245,
+&ch246,
+&ch247,
+&ch248,
+&ch249,
+&ch250,
+&ch251,
+&ch252,
+&ch253,
+&ch254,
+&ch255,
+};
+
+const BitmapFontRec glutBitmapHelvetica12 = {
+"-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1",
+224,
+32,
+chars
+};
+
diff --git a/src/glut/glx/glut_hel18.c b/src/glut/glx/glut_hel18.c
new file mode 100644
index 0000000000..f0800843e8
--- /dev/null
+++ b/src/glut/glx/glut_hel18.c
@@ -0,0 +1,1897 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#define glutBitmapHelvetica18 XXX
+#include "glutbitmap.h"
+#undef glutBitmapHelvetica18
+
+/* char: 0xff */
+
+static const GLubyte ch255data[] = {
+0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x66,
+0x66,
+};
+
+static const BitmapCharRec ch255 = {8,17,-1,4,10,ch255data};
+
+/* char: 0xfe */
+
+static const GLubyte ch254data[] = {
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,
+0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,0xff,0x0,0xde,0x0,0xc0,0x0,0xc0,0x0,
+0xc0,0x0,0xc0,0x0,
+};
+
+static const BitmapCharRec ch254 = {9,18,-1,4,11,ch254data};
+
+/* char: 0xfd */
+
+static const GLubyte ch253data[] = {
+0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x18,
+0xc,0x6,
+};
+
+static const BitmapCharRec ch253 = {8,18,-1,4,10,ch253data};
+
+/* char: 0xfc */
+
+static const GLubyte ch252data[] = {
+0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x66,
+};
+
+static const BitmapCharRec ch252 = {8,13,-1,0,10,ch252data};
+
+/* char: 0xfb */
+
+static const GLubyte ch251data[] = {
+0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x3c,0x18,
+};
+
+static const BitmapCharRec ch251 = {8,14,-1,0,10,ch251data};
+
+/* char: 0xfa */
+
+static const GLubyte ch250data[] = {
+0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x18,0xc,0x6,
+};
+
+static const BitmapCharRec ch250 = {8,14,-1,0,10,ch250data};
+
+/* char: 0xf9 */
+
+static const GLubyte ch249data[] = {
+0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0xc,0x18,0x30,
+};
+
+static const BitmapCharRec ch249 = {8,14,-1,0,10,ch249data};
+
+/* char: 0xf8 */
+
+static const GLubyte ch248data[] = {
+0xce,0x0,0x7f,0x80,0x31,0x80,0x78,0xc0,0x6c,0xc0,0x66,0xc0,0x63,0xc0,0x31,0x80,
+0x3f,0xc0,0xe,0x60,
+};
+
+static const BitmapCharRec ch248 = {11,10,0,0,11,ch248data};
+
+/* char: 0xf7 */
+
+static const GLubyte ch247data[] = {
+0x18,0x18,0x0,0xff,0xff,0x0,0x18,0x18,
+};
+
+static const BitmapCharRec ch247 = {8,8,-1,-1,10,ch247data};
+
+/* char: 0xf6 */
+
+static const GLubyte ch246data[] = {
+0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
+0x7f,0x0,0x3e,0x0,0x0,0x0,0x36,0x0,0x36,0x0,
+};
+
+static const BitmapCharRec ch246 = {9,13,-1,0,11,ch246data};
+
+/* char: 0xf5 */
+
+static const GLubyte ch245data[] = {
+0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
+0x7f,0x0,0x3e,0x0,0x0,0x0,0x26,0x0,0x2d,0x0,0x19,0x0,
+};
+
+static const BitmapCharRec ch245 = {9,14,-1,0,11,ch245data};
+
+/* char: 0xf4 */
+
+static const GLubyte ch244data[] = {
+0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
+0x7f,0x0,0x3e,0x0,0x0,0x0,0x33,0x0,0x1e,0x0,0xc,0x0,
+};
+
+static const BitmapCharRec ch244 = {9,14,-1,0,11,ch244data};
+
+/* char: 0xf3 */
+
+static const GLubyte ch243data[] = {
+0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
+0x7f,0x0,0x3e,0x0,0x0,0x0,0x18,0x0,0xc,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch243 = {9,14,-1,0,11,ch243data};
+
+/* char: 0xf2 */
+
+static const GLubyte ch242data[] = {
+0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
+0x7f,0x0,0x3e,0x0,0x0,0x0,0xc,0x0,0x18,0x0,0x30,0x0,
+};
+
+static const BitmapCharRec ch242 = {9,14,-1,0,11,ch242data};
+
+/* char: 0xf1 */
+
+static const GLubyte ch241data[] = {
+0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0x0,0x4c,0x5a,0x32,
+};
+
+static const BitmapCharRec ch241 = {8,14,-1,0,10,ch241data};
+
+/* char: 0xf0 */
+
+static const GLubyte ch240data[] = {
+0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
+0x7f,0x0,0x3e,0x0,0x4c,0x0,0x38,0x0,0x36,0x0,0x60,0x0,
+};
+
+static const BitmapCharRec ch240 = {9,14,-1,0,11,ch240data};
+
+/* char: 0xef */
+
+static const GLubyte ch239data[] = {
+0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xd8,0xd8,
+};
+
+static const BitmapCharRec ch239 = {5,13,0,0,4,ch239data};
+
+/* char: 0xee */
+
+static const GLubyte ch238data[] = {
+0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,0x78,0x30,
+};
+
+static const BitmapCharRec ch238 = {6,14,1,0,4,ch238data};
+
+/* char: 0xed */
+
+static const GLubyte ch237data[] = {
+0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xc0,0x60,0x30,
+};
+
+static const BitmapCharRec ch237 = {4,14,0,0,4,ch237data};
+
+/* char: 0xec */
+
+static const GLubyte ch236data[] = {
+0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0x30,0x60,0xc0,
+};
+
+static const BitmapCharRec ch236 = {4,14,0,0,4,ch236data};
+
+/* char: 0xeb */
+
+static const GLubyte ch235data[] = {
+0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x36,0x36,
+};
+
+static const BitmapCharRec ch235 = {8,13,-1,0,10,ch235data};
+
+/* char: 0xea */
+
+static const GLubyte ch234data[] = {
+0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x66,0x3c,0x18,
+};
+
+static const BitmapCharRec ch234 = {8,14,-1,0,10,ch234data};
+
+/* char: 0xe9 */
+
+static const GLubyte ch233data[] = {
+0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0xc,0x6,
+};
+
+static const BitmapCharRec ch233 = {8,14,-1,0,10,ch233data};
+
+/* char: 0xe8 */
+
+static const GLubyte ch232data[] = {
+0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0x30,0x60,
+};
+
+static const BitmapCharRec ch232 = {8,14,-1,0,10,ch232data};
+
+/* char: 0xe7 */
+
+static const GLubyte ch231data[] = {
+0x78,0x6c,0xc,0x38,0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e,
+};
+
+static const BitmapCharRec ch231 = {8,14,-1,4,10,ch231data};
+
+/* char: 0xe6 */
+
+static const GLubyte ch230data[] = {
+0x75,0xe0,0xef,0xf8,0xc7,0x18,0xc6,0x0,0xe6,0x0,0x7f,0xf8,0xe,0x18,0xc6,0x18,
+0xef,0xf0,0x7d,0xe0,
+};
+
+static const BitmapCharRec ch230 = {13,10,-1,0,15,ch230data};
+
+/* char: 0xe5 */
+
+static const GLubyte ch229data[] = {
+0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x38,0x6c,0x6c,0x38,
+};
+
+static const BitmapCharRec ch229 = {7,14,-1,0,9,ch229data};
+
+/* char: 0xe4 */
+
+static const GLubyte ch228data[] = {
+0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x6c,0x6c,
+};
+
+static const BitmapCharRec ch228 = {7,13,-1,0,9,ch228data};
+
+/* char: 0xe3 */
+
+static const GLubyte ch227data[] = {
+0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x4c,0x5a,0x32,
+};
+
+static const BitmapCharRec ch227 = {7,14,-1,0,9,ch227data};
+
+/* char: 0xe2 */
+
+static const GLubyte ch226data[] = {
+0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x66,0x3c,0x18,
+};
+
+static const BitmapCharRec ch226 = {7,14,-1,0,9,ch226data};
+
+/* char: 0xe1 */
+
+static const GLubyte ch225data[] = {
+0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x30,0x18,0xc,
+};
+
+static const BitmapCharRec ch225 = {7,14,-1,0,9,ch225data};
+
+/* char: 0xe0 */
+
+static const GLubyte ch224data[] = {
+0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x18,0x30,0x60,
+};
+
+static const BitmapCharRec ch224 = {7,14,-1,0,9,ch224data};
+
+/* char: 0xdf */
+
+static const GLubyte ch223data[] = {
+0xdc,0xde,0xc6,0xc6,0xc6,0xc6,0xdc,0xdc,0xc6,0xc6,0xc6,0xc6,0x7c,0x38,
+};
+
+static const BitmapCharRec ch223 = {7,14,-1,0,9,ch223data};
+
+/* char: 0xde */
+
+static const GLubyte ch222data[] = {
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x80,0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc1,0xc0,0xff,0x80,0xff,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
+};
+
+static const BitmapCharRec ch222 = {10,14,-1,0,12,ch222data};
+
+/* char: 0xdd */
+
+static const GLubyte ch221data[] = {
+0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
+0x30,0xc0,0x30,0xc0,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,0x0,0x0,0x6,0x0,
+0x3,0x0,0x1,0x80,
+};
+
+static const BitmapCharRec ch221 = {12,18,-1,0,14,ch221data};
+
+/* char: 0xdc */
+
+static const GLubyte ch220data[] = {
+0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x19,0x80,
+0x19,0x80,
+};
+
+static const BitmapCharRec ch220 = {11,17,-1,0,13,ch220data};
+
+/* char: 0xdb */
+
+static const GLubyte ch219data[] = {
+0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x19,0x80,
+0xf,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch219 = {11,18,-1,0,13,ch219data};
+
+/* char: 0xda */
+
+static const GLubyte ch218data[] = {
+0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0xc,0x0,
+0x6,0x0,0x3,0x0,
+};
+
+static const BitmapCharRec ch218 = {11,18,-1,0,13,ch218data};
+
+/* char: 0xd9 */
+
+static const GLubyte ch217data[] = {
+0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x6,0x0,
+0xc,0x0,0x18,0x0,
+};
+
+static const BitmapCharRec ch217 = {11,18,-1,0,13,ch217data};
+
+/* char: 0xd8 */
+
+static const GLubyte ch216data[] = {
+0xc7,0xc0,0xff,0xf0,0x78,0x38,0x38,0x18,0x6c,0x1c,0x6e,0xc,0x67,0xc,0x63,0x8c,
+0x61,0xcc,0x70,0xdc,0x30,0x78,0x38,0x38,0x1f,0xfc,0x7,0xcc,
+};
+
+static const BitmapCharRec ch216 = {14,14,0,0,15,ch216data};
+
+/* char: 0xd7 */
+
+static const GLubyte ch215data[] = {
+0xc0,0xc0,0x61,0x80,0x33,0x0,0x1e,0x0,0xc,0x0,0x1e,0x0,0x33,0x0,0x61,0x80,
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch215 = {10,9,0,0,10,ch215data};
+
+/* char: 0xd6 */
+
+static const GLubyte ch214data[] = {
+0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
+0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0xd,0x80,
+0xd,0x80,
+};
+
+static const BitmapCharRec ch214 = {13,17,-1,0,15,ch214data};
+
+/* char: 0xd5 */
+
+static const GLubyte ch213data[] = {
+0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
+0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x9,0x80,
+0xb,0x40,0x6,0x40,
+};
+
+static const BitmapCharRec ch213 = {13,18,-1,0,15,ch213data};
+
+/* char: 0xd4 */
+
+static const GLubyte ch212data[] = {
+0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
+0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0xc,0xc0,
+0x7,0x80,0x3,0x0,
+};
+
+static const BitmapCharRec ch212 = {13,18,-1,0,15,ch212data};
+
+/* char: 0xd3 */
+
+static const GLubyte ch211data[] = {
+0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
+0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x3,0x0,
+0x1,0x80,0x0,0xc0,
+};
+
+static const BitmapCharRec ch211 = {13,18,-1,0,15,ch211data};
+
+/* char: 0xd2 */
+
+static const GLubyte ch210data[] = {
+0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
+0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x3,0x0,
+0x6,0x0,0xc,0x0,
+};
+
+static const BitmapCharRec ch210 = {13,18,-1,0,15,ch210data};
+
+/* char: 0xd1 */
+
+static const GLubyte ch209data[] = {
+0xc0,0x60,0xc0,0xe0,0xc1,0xe0,0xc1,0xe0,0xc3,0x60,0xc6,0x60,0xc6,0x60,0xcc,0x60,
+0xcc,0x60,0xd8,0x60,0xd8,0x60,0xf0,0x60,0xe0,0x60,0xe0,0x60,0x0,0x0,0x13,0x0,
+0x16,0x80,0xc,0x80,
+};
+
+static const BitmapCharRec ch209 = {11,18,-1,0,13,ch209data};
+
+/* char: 0xd0 */
+
+static const GLubyte ch208data[] = {
+0x7f,0x80,0x7f,0xc0,0x60,0xe0,0x60,0x60,0x60,0x30,0x60,0x30,0xfc,0x30,0xfc,0x30,
+0x60,0x30,0x60,0x30,0x60,0x60,0x60,0xe0,0x7f,0xc0,0x7f,0x80,
+};
+
+static const BitmapCharRec ch208 = {12,14,0,0,13,ch208data};
+
+/* char: 0xcf */
+
+static const GLubyte ch207data[] = {
+0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,
+0xcc,
+};
+
+static const BitmapCharRec ch207 = {6,17,0,0,6,ch207data};
+
+/* char: 0xce */
+
+static const GLubyte ch206data[] = {
+0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,
+0x78,0x30,
+};
+
+static const BitmapCharRec ch206 = {6,18,0,0,6,ch206data};
+
+/* char: 0xcd */
+
+static const GLubyte ch205data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0xc0,
+0x60,0x30,
+};
+
+static const BitmapCharRec ch205 = {4,18,-2,0,6,ch205data};
+
+/* char: 0xcc */
+
+static const GLubyte ch204data[] = {
+0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x30,
+0x60,0xc0,
+};
+
+static const BitmapCharRec ch204 = {4,18,0,0,6,ch204data};
+
+/* char: 0xcb */
+
+static const GLubyte ch203data[] = {
+0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0x33,0x0,
+0x33,0x0,
+};
+
+static const BitmapCharRec ch203 = {9,17,-1,0,11,ch203data};
+
+/* char: 0xca */
+
+static const GLubyte ch202data[] = {
+0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0x33,0x0,
+0x1e,0x0,0xc,0x0,
+};
+
+static const BitmapCharRec ch202 = {9,18,-1,0,11,ch202data};
+
+/* char: 0xc9 */
+
+static const GLubyte ch201data[] = {
+0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0xc,0x0,
+0x6,0x0,0x3,0x0,
+};
+
+static const BitmapCharRec ch201 = {9,18,-1,0,11,ch201data};
+
+/* char: 0xc8 */
+
+static const GLubyte ch200data[] = {
+0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0xc,0x0,
+0x18,0x0,0x30,0x0,
+};
+
+static const BitmapCharRec ch200 = {9,18,-1,0,11,ch200data};
+
+/* char: 0xc7 */
+
+static const GLubyte ch199data[] = {
+0x1e,0x0,0x1b,0x0,0x3,0x0,0xe,0x0,0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,
+0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xe0,0x0,0x60,0x30,0x70,0x70,
+0x3f,0xe0,0xf,0x80,
+};
+
+static const BitmapCharRec ch199 = {12,18,-1,4,14,ch199data};
+
+/* char: 0xc6 */
+
+static const GLubyte ch198data[] = {
+0xc1,0xff,0xc1,0xff,0x61,0x80,0x61,0x80,0x7f,0x80,0x3f,0x80,0x31,0xfe,0x31,0xfe,
+0x19,0x80,0x19,0x80,0xd,0x80,0xd,0x80,0x7,0xff,0x7,0xff,
+};
+
+static const BitmapCharRec ch198 = {16,14,-1,0,18,ch198data};
+
+/* char: 0xc5 */
+
+static const GLubyte ch197data[] = {
+0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
+0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
+0x19,0x80,0xf,0x0,
+};
+
+static const BitmapCharRec ch197 = {12,18,0,0,12,ch197data};
+
+/* char: 0xc4 */
+
+static const GLubyte ch196data[] = {
+0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
+0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x19,0x80,
+0x19,0x80,
+};
+
+static const BitmapCharRec ch196 = {12,17,0,0,12,ch196data};
+
+/* char: 0xc3 */
+
+static const GLubyte ch195data[] = {
+0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
+0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x13,0x0,
+0x16,0x80,0xc,0x80,
+};
+
+static const BitmapCharRec ch195 = {12,18,0,0,12,ch195data};
+
+/* char: 0xc2 */
+
+static const GLubyte ch194data[] = {
+0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
+0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x19,0x80,
+0xf,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch194 = {12,18,0,0,12,ch194data};
+
+/* char: 0xc1 */
+
+static const GLubyte ch193data[] = {
+0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
+0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x6,0x0,
+0x3,0x0,0x1,0x80,
+};
+
+static const BitmapCharRec ch193 = {12,18,0,0,12,ch193data};
+
+/* char: 0xc0 */
+
+static const GLubyte ch192data[] = {
+0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
+0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x6,0x0,
+0xc,0x0,0x18,0x0,
+};
+
+static const BitmapCharRec ch192 = {12,18,0,0,12,ch192data};
+
+/* char: 0xbf */
+
+static const GLubyte ch191data[] = {
+0x7c,0xfe,0xc6,0xc6,0xe0,0x70,0x38,0x18,0x18,0x18,0x0,0x0,0x18,0x18,
+};
+
+static const BitmapCharRec ch191 = {7,14,-1,4,10,ch191data};
+
+/* char: 0xbe */
+
+static const GLubyte ch190data[] = {
+0x18,0x18,0x18,0x18,0xc,0xfc,0x6,0xd8,0x6,0x78,0x73,0x38,0xf9,0x18,0x99,0x88,
+0x30,0xc0,0x30,0xc0,0x98,0x60,0xf8,0x30,0x70,0x30,
+};
+
+static const BitmapCharRec ch190 = {14,13,0,0,15,ch190data};
+
+/* char: 0xbd */
+
+static const GLubyte ch189data[] = {
+0x30,0xf8,0x30,0xf8,0x18,0x60,0xc,0x30,0xc,0x18,0x66,0x98,0x62,0xf8,0x63,0x70,
+0x61,0x80,0x61,0x80,0xe0,0xc0,0xe0,0x60,0x60,0x60,
+};
+
+static const BitmapCharRec ch189 = {13,13,-1,0,15,ch189data};
+
+/* char: 0xbc */
+
+static const GLubyte ch188data[] = {
+0x30,0x30,0x30,0x30,0x19,0xf8,0xd,0xb0,0xc,0xf0,0x66,0x70,0x62,0x30,0x63,0x10,
+0x61,0x80,0x61,0x80,0xe0,0xc0,0xe0,0x60,0x60,0x60,
+};
+
+static const BitmapCharRec ch188 = {13,13,-1,0,15,ch188data};
+
+/* char: 0xbb */
+
+static const GLubyte ch187data[] = {
+0x90,0xd8,0x6c,0x36,0x36,0x6c,0xd8,0x90,
+};
+
+static const BitmapCharRec ch187 = {7,8,-1,-1,9,ch187data};
+
+/* char: 0xba */
+
+static const GLubyte ch186data[] = {
+0xf8,0x0,0x70,0xd8,0x88,0x88,0xd8,0x70,
+};
+
+static const BitmapCharRec ch186 = {5,8,-1,-6,7,ch186data};
+
+/* char: 0xb9 */
+
+static const GLubyte ch185data[] = {
+0x60,0x60,0x60,0x60,0x60,0xe0,0xe0,0x60,
+};
+
+static const BitmapCharRec ch185 = {3,8,-1,-5,6,ch185data};
+
+/* char: 0xb8 */
+
+static const GLubyte ch184data[] = {
+0xf0,0xd8,0x18,0x70,0x60,
+};
+
+static const BitmapCharRec ch184 = {5,5,0,4,5,ch184data};
+
+/* char: 0xb7 */
+
+static const GLubyte ch183data[] = {
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch183 = {2,2,-1,-4,4,ch183data};
+
+/* char: 0xb6 */
+
+static const GLubyte ch182data[] = {
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x32,0x72,0xf2,0xf2,0xf2,0xf2,
+0x72,0x3f,
+};
+
+static const BitmapCharRec ch182 = {8,18,-1,4,10,ch182data};
+
+/* char: 0xb5 */
+
+static const GLubyte ch181data[] = {
+0xc0,0xc0,0xc0,0xc0,0xdb,0xff,0xe7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,
+};
+
+static const BitmapCharRec ch181 = {8,14,-1,4,10,ch181data};
+
+/* char: 0xb4 */
+
+static const GLubyte ch180data[] = {
+0xc0,0x60,0x30,
+};
+
+static const BitmapCharRec ch180 = {4,3,0,-11,4,ch180data};
+
+/* char: 0xb3 */
+
+static const GLubyte ch179data[] = {
+0x70,0xf8,0x98,0x30,0x30,0x98,0xf8,0x70,
+};
+
+static const BitmapCharRec ch179 = {5,8,0,-5,6,ch179data};
+
+/* char: 0xb2 */
+
+static const GLubyte ch178data[] = {
+0xf8,0xf8,0x60,0x30,0x18,0x98,0xf8,0x70,
+};
+
+static const BitmapCharRec ch178 = {5,8,0,-5,6,ch178data};
+
+/* char: 0xb1 */
+
+static const GLubyte ch177data[] = {
+0xff,0xff,0x0,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18,
+};
+
+static const BitmapCharRec ch177 = {8,11,-1,0,10,ch177data};
+
+/* char: 0xb0 */
+
+static const GLubyte ch176data[] = {
+0x70,0xd8,0x88,0xd8,0x70,
+};
+
+static const BitmapCharRec ch176 = {5,5,-1,-8,7,ch176data};
+
+/* char: 0xaf */
+
+static const GLubyte ch175data[] = {
+0xf8,
+};
+
+static const BitmapCharRec ch175 = {5,1,0,-12,5,ch175data};
+
+/* char: 0xae */
+
+static const GLubyte ch174data[] = {
+0xf,0x80,0x30,0x60,0x40,0x10,0x48,0x50,0x88,0x88,0x89,0x8,0x8f,0x88,0x88,0x48,
+0x88,0x48,0x4f,0x90,0x40,0x10,0x30,0x60,0xf,0x80,
+};
+
+static const BitmapCharRec ch174 = {13,13,-1,0,14,ch174data};
+
+/* char: 0xad */
+
+static const GLubyte ch173data[] = {
+0xf8,0xf8,
+};
+
+static const BitmapCharRec ch173 = {5,2,-1,-4,7,ch173data};
+
+/* char: 0xac */
+
+static const GLubyte ch172data[] = {
+0x1,0x80,0x1,0x80,0x1,0x80,0xff,0x80,0xff,0x80,
+};
+
+static const BitmapCharRec ch172 = {9,5,-1,-3,11,ch172data};
+
+/* char: 0xab */
+
+static const GLubyte ch171data[] = {
+0x12,0x36,0x6c,0xd8,0xd8,0x6c,0x36,0x12,
+};
+
+static const BitmapCharRec ch171 = {7,8,-1,-1,9,ch171data};
+
+/* char: 0xaa */
+
+static const GLubyte ch170data[] = {
+0xf8,0x0,0x68,0xd8,0x48,0x38,0xc8,0x70,
+};
+
+static const BitmapCharRec ch170 = {5,8,-1,-6,7,ch170data};
+
+/* char: 0xa9 */
+
+static const GLubyte ch169data[] = {
+0xf,0x80,0x30,0x60,0x40,0x10,0x47,0x10,0x88,0x88,0x90,0x8,0x90,0x8,0x90,0x8,
+0x88,0x88,0x47,0x10,0x40,0x10,0x30,0x60,0xf,0x80,
+};
+
+static const BitmapCharRec ch169 = {13,13,-1,0,15,ch169data};
+
+/* char: 0xa8 */
+
+static const GLubyte ch168data[] = {
+0xd8,0xd8,
+};
+
+static const BitmapCharRec ch168 = {5,2,0,-11,6,ch168data};
+
+/* char: 0xa7 */
+
+static const GLubyte ch167data[] = {
+0x3c,0x7e,0xc3,0xc3,0x7,0xe,0x3e,0x73,0xe3,0xc3,0xc7,0x6e,0x7c,0xf0,0xc3,0xc3,
+0x7e,0x3c,
+};
+
+static const BitmapCharRec ch167 = {8,18,-1,4,10,ch167data};
+
+/* char: 0xa6 */
+
+static const GLubyte ch166data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,
+};
+
+static const BitmapCharRec ch166 = {2,17,-1,3,4,ch166data};
+
+/* char: 0xa5 */
+
+static const GLubyte ch165data[] = {
+0x18,0x18,0x18,0x18,0xff,0x18,0xff,0x3c,0x66,0x66,0x66,0xc3,0xc3,
+};
+
+static const BitmapCharRec ch165 = {8,13,-1,0,10,ch165data};
+
+/* char: 0xa4 */
+
+static const GLubyte ch164data[] = {
+0xc3,0xff,0x66,0x66,0x66,0xff,0xc3,
+};
+
+static const BitmapCharRec ch164 = {8,7,-1,-3,10,ch164data};
+
+/* char: 0xa3 */
+
+static const GLubyte ch163data[] = {
+0xdf,0x0,0xff,0x80,0x60,0x80,0x30,0x0,0x18,0x0,0x18,0x0,0x7e,0x0,0x30,0x0,
+0x60,0x0,0x61,0x80,0x61,0x80,0x3f,0x0,0x1e,0x0,
+};
+
+static const BitmapCharRec ch163 = {9,13,0,0,10,ch163data};
+
+/* char: 0xa2 */
+
+static const GLubyte ch162data[] = {
+0x10,0x10,0x3e,0x7f,0x6b,0xc8,0xc8,0xc8,0xc8,0x6b,0x7f,0x3e,0x4,0x4,
+};
+
+static const BitmapCharRec ch162 = {8,14,-1,2,10,ch162data};
+
+/* char: 0xa1 */
+
+static const GLubyte ch161data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x40,0x40,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch161 = {2,14,-2,4,6,ch161data};
+
+/* char: 0xa0 */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch160data[] = { 0x0 };
+static const BitmapCharRec ch160 = {1,1,0,0,5,ch160data};
+#else
+static const BitmapCharRec ch160 = {0,0,0,0,5,0};
+#endif
+
+/* char: 0x7e '~' */
+
+static const GLubyte ch126data[] = {
+0xcc,0x7e,0x33,
+};
+
+static const BitmapCharRec ch126 = {8,3,-1,-4,10,ch126data};
+
+/* char: 0x7d '}' */
+
+static const GLubyte ch125data[] = {
+0xc0,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x18,0xc,0x18,0x30,0x30,0x30,0x30,0x30,
+0x60,0xc0,
+};
+
+static const BitmapCharRec ch125 = {6,18,0,4,6,ch125data};
+
+/* char: 0x7c '|' */
+
+static const GLubyte ch124data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch124 = {2,18,-1,4,4,ch124data};
+
+/* char: 0x7b '{' */
+
+static const GLubyte ch123data[] = {
+0xc,0x18,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0xc0,0x60,0x30,0x30,0x30,0x30,0x30,
+0x18,0xc,
+};
+
+static const BitmapCharRec ch123 = {6,18,0,4,6,ch123data};
+
+/* char: 0x7a 'z' */
+
+static const GLubyte ch122data[] = {
+0xfe,0xfe,0xc0,0x60,0x30,0x18,0xc,0x6,0xfe,0xfe,
+};
+
+static const BitmapCharRec ch122 = {7,10,-1,0,9,ch122data};
+
+/* char: 0x79 'y' */
+
+static const GLubyte ch121data[] = {
+0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,
+};
+
+static const BitmapCharRec ch121 = {8,14,-1,4,10,ch121data};
+
+/* char: 0x78 'x' */
+
+static const GLubyte ch120data[] = {
+0xc3,0xe7,0x66,0x3c,0x18,0x18,0x3c,0x66,0xe7,0xc3,
+};
+
+static const BitmapCharRec ch120 = {8,10,-1,0,10,ch120data};
+
+/* char: 0x77 'w' */
+
+static const GLubyte ch119data[] = {
+0x19,0x80,0x19,0x80,0x39,0xc0,0x29,0x40,0x69,0x60,0x66,0x60,0x66,0x60,0xc6,0x30,
+0xc6,0x30,0xc6,0x30,
+};
+
+static const BitmapCharRec ch119 = {12,10,-1,0,14,ch119data};
+
+/* char: 0x76 'v' */
+
+static const GLubyte ch118data[] = {
+0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,
+};
+
+static const BitmapCharRec ch118 = {8,10,-1,0,10,ch118data};
+
+/* char: 0x75 'u' */
+
+static const GLubyte ch117data[] = {
+0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,
+};
+
+static const BitmapCharRec ch117 = {8,10,-1,0,10,ch117data};
+
+/* char: 0x74 't' */
+
+static const GLubyte ch116data[] = {
+0x18,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x30,
+};
+
+static const BitmapCharRec ch116 = {6,13,0,0,6,ch116data};
+
+/* char: 0x73 's' */
+
+static const GLubyte ch115data[] = {
+0x78,0xfc,0xc6,0x6,0x3e,0xfc,0xc0,0xc6,0x7e,0x3c,
+};
+
+static const BitmapCharRec ch115 = {7,10,-1,0,9,ch115data};
+
+/* char: 0x72 'r' */
+
+static const GLubyte ch114data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xe0,0xd8,0xd8,
+};
+
+static const BitmapCharRec ch114 = {5,10,-1,0,6,ch114data};
+
+/* char: 0x71 'q' */
+
+static const GLubyte ch113data[] = {
+0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,
+0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x80,0x7f,0x80,0x3d,0x80,
+};
+
+static const BitmapCharRec ch113 = {9,14,-1,4,11,ch113data};
+
+/* char: 0x70 'p' */
+
+static const GLubyte ch112data[] = {
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,
+0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,0xff,0x0,0xde,0x0,
+};
+
+static const BitmapCharRec ch112 = {9,14,-1,4,11,ch112data};
+
+/* char: 0x6f 'o' */
+
+static const GLubyte ch111data[] = {
+0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
+0x7f,0x0,0x3e,0x0,
+};
+
+static const BitmapCharRec ch111 = {9,10,-1,0,11,ch111data};
+
+/* char: 0x6e 'n' */
+
+static const GLubyte ch110data[] = {
+0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,
+};
+
+static const BitmapCharRec ch110 = {8,10,-1,0,10,ch110data};
+
+/* char: 0x6d 'm' */
+
+static const GLubyte ch109data[] = {
+0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xe7,0x30,
+0xde,0xf0,0xcc,0x60,
+};
+
+static const BitmapCharRec ch109 = {12,10,-1,0,14,ch109data};
+
+/* char: 0x6c 'l' */
+
+static const GLubyte ch108data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch108 = {2,14,-1,0,4,ch108data};
+
+/* char: 0x6b 'k' */
+
+static const GLubyte ch107data[] = {
+0xc7,0xc6,0xce,0xcc,0xd8,0xf8,0xf0,0xd8,0xcc,0xc6,0xc0,0xc0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch107 = {8,14,-1,0,9,ch107data};
+
+/* char: 0x6a 'j' */
+
+static const GLubyte ch106data[] = {
+0xe0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x0,
+0x30,0x30,
+};
+
+static const BitmapCharRec ch106 = {4,18,1,4,4,ch106data};
+
+/* char: 0x69 'i' */
+
+static const GLubyte ch105data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch105 = {2,14,-1,0,4,ch105data};
+
+/* char: 0x68 'h' */
+
+static const GLubyte ch104data[] = {
+0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0xc0,0xc0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch104 = {8,14,-1,0,10,ch104data};
+
+/* char: 0x67 'g' */
+
+static const GLubyte ch103data[] = {
+0x1c,0x0,0x7f,0x0,0x63,0x0,0x1,0x80,0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,
+0xc1,0x80,0xc1,0x80,0xc1,0x80,0x61,0x80,0x7f,0x80,0x3d,0x80,
+};
+
+static const BitmapCharRec ch103 = {9,14,-1,4,11,ch103data};
+
+/* char: 0x66 'f' */
+
+static const GLubyte ch102data[] = {
+0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x3c,0x1c,
+};
+
+static const BitmapCharRec ch102 = {6,14,0,0,6,ch102data};
+
+/* char: 0x65 'e' */
+
+static const GLubyte ch101data[] = {
+0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,
+};
+
+static const BitmapCharRec ch101 = {8,10,-1,0,10,ch101data};
+
+/* char: 0x64 'd' */
+
+static const GLubyte ch100data[] = {
+0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x80,
+0x7f,0x80,0x3d,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,
+};
+
+static const BitmapCharRec ch100 = {9,14,-1,0,11,ch100data};
+
+/* char: 0x63 'c' */
+
+static const GLubyte ch99data[] = {
+0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e,
+};
+
+static const BitmapCharRec ch99 = {8,10,-1,0,10,ch99data};
+
+/* char: 0x62 'b' */
+
+static const GLubyte ch98data[] = {
+0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,
+0xff,0x0,0xde,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
+};
+
+static const BitmapCharRec ch98 = {9,14,-1,0,11,ch98data};
+
+/* char: 0x61 'a' */
+
+static const GLubyte ch97data[] = {
+0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,
+};
+
+static const BitmapCharRec ch97 = {7,10,-1,0,9,ch97data};
+
+/* char: 0x60 '`' */
+
+static const GLubyte ch96data[] = {
+0xc0,0xc0,0x80,0x80,0x40,
+};
+
+static const BitmapCharRec ch96 = {2,5,-1,-9,4,ch96data};
+
+/* char: 0x5f '_' */
+
+static const GLubyte ch95data[] = {
+0xff,0xc0,0xff,0xc0,
+};
+
+static const BitmapCharRec ch95 = {10,2,0,4,10,ch95data};
+
+/* char: 0x5e '^' */
+
+static const GLubyte ch94data[] = {
+0x82,0xc6,0x6c,0x38,0x10,
+};
+
+static const BitmapCharRec ch94 = {7,5,-1,-8,9,ch94data};
+
+/* char: 0x5d ']' */
+
+static const GLubyte ch93data[] = {
+0xf0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+0xf0,0xf0,
+};
+
+static const BitmapCharRec ch93 = {4,18,0,4,5,ch93data};
+
+/* char: 0x5c '\' */
+
+static const GLubyte ch92data[] = {
+0x18,0x18,0x10,0x10,0x30,0x30,0x20,0x20,0x60,0x60,0x40,0x40,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch92 = {5,14,0,0,5,ch92data};
+
+/* char: 0x5b '[' */
+
+static const GLubyte ch91data[] = {
+0xf0,0xf0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xf0,0xf0,
+};
+
+static const BitmapCharRec ch91 = {4,18,-1,4,5,ch91data};
+
+/* char: 0x5a 'Z' */
+
+static const GLubyte ch90data[] = {
+0xff,0xc0,0xff,0xc0,0xc0,0x0,0x60,0x0,0x30,0x0,0x18,0x0,0x1c,0x0,0xc,0x0,
+0x6,0x0,0x3,0x0,0x1,0x80,0x0,0xc0,0xff,0xc0,0xff,0xc0,
+};
+
+static const BitmapCharRec ch90 = {10,14,-1,0,12,ch90data};
+
+/* char: 0x59 'Y' */
+
+static const GLubyte ch89data[] = {
+0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
+0x30,0xc0,0x30,0xc0,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,
+};
+
+static const BitmapCharRec ch89 = {12,14,-1,0,14,ch89data};
+
+/* char: 0x58 'X' */
+
+static const GLubyte ch88data[] = {
+0xc0,0x60,0xe0,0xe0,0x60,0xc0,0x71,0xc0,0x31,0x80,0x1b,0x0,0xe,0x0,0xe,0x0,
+0x1b,0x0,0x31,0x80,0x71,0xc0,0x60,0xc0,0xe0,0xe0,0xc0,0x60,
+};
+
+static const BitmapCharRec ch88 = {11,14,-1,0,13,ch88data};
+
+/* char: 0x57 'W' */
+
+static const GLubyte ch87data[] = {
+0x18,0x18,0x18,0x18,0x1c,0x38,0x34,0x2c,0x36,0x6c,0x36,0x6c,0x66,0x66,0x66,0x66,
+0x62,0x46,0x63,0xc6,0xc3,0xc3,0xc1,0x83,0xc1,0x83,0xc1,0x83,
+};
+
+static const BitmapCharRec ch87 = {16,14,-1,0,18,ch87data};
+
+/* char: 0x56 'V' */
+
+static const GLubyte ch86data[] = {
+0x6,0x0,0xf,0x0,0xf,0x0,0x19,0x80,0x19,0x80,0x19,0x80,0x30,0xc0,0x30,0xc0,
+0x30,0xc0,0x60,0x60,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,
+};
+
+static const BitmapCharRec ch86 = {12,14,-1,0,14,ch86data};
+
+/* char: 0x55 'U' */
+
+static const GLubyte ch85data[] = {
+0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+};
+
+static const BitmapCharRec ch85 = {11,14,-1,0,13,ch85data};
+
+/* char: 0x54 'T' */
+
+static const GLubyte ch84data[] = {
+0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,
+0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xff,0xc0,0xff,0xc0,
+};
+
+static const BitmapCharRec ch84 = {10,14,-1,0,12,ch84data};
+
+/* char: 0x53 'S' */
+
+static const GLubyte ch83data[] = {
+0x3f,0x0,0x7f,0xc0,0xe0,0xe0,0xc0,0x60,0x0,0x60,0x0,0xe0,0x3,0xc0,0x1f,0x0,
+0x7c,0x0,0xe0,0x0,0xc0,0x60,0xe0,0xe0,0x7f,0xc0,0x1f,0x0,
+};
+
+static const BitmapCharRec ch83 = {11,14,-1,0,13,ch83data};
+
+/* char: 0x52 'R' */
+
+static const GLubyte ch82data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0x80,0xc1,0x80,0xff,0x0,0xff,0x80,
+0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
+};
+
+static const BitmapCharRec ch82 = {10,14,-1,0,12,ch82data};
+
+/* char: 0x51 'Q' */
+
+static const GLubyte ch81data[] = {
+0x0,0x30,0xf,0xb0,0x3f,0xe0,0x70,0xf0,0x61,0xb0,0xe1,0xb8,0xc0,0x18,0xc0,0x18,
+0xc0,0x18,0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
+};
+
+static const BitmapCharRec ch81 = {13,15,-1,1,15,ch81data};
+
+/* char: 0x50 'P' */
+
+static const GLubyte ch80data[] = {
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x80,
+0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
+};
+
+static const BitmapCharRec ch80 = {10,14,-1,0,12,ch80data};
+
+/* char: 0x4f 'O' */
+
+static const GLubyte ch79data[] = {
+0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
+0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
+};
+
+static const BitmapCharRec ch79 = {13,14,-1,0,15,ch79data};
+
+/* char: 0x4e 'N' */
+
+static const GLubyte ch78data[] = {
+0xc0,0x60,0xc0,0xe0,0xc1,0xe0,0xc1,0xe0,0xc3,0x60,0xc6,0x60,0xc6,0x60,0xcc,0x60,
+0xcc,0x60,0xd8,0x60,0xf0,0x60,0xf0,0x60,0xe0,0x60,0xc0,0x60,
+};
+
+static const BitmapCharRec ch78 = {11,14,-1,0,13,ch78data};
+
+/* char: 0x4d 'M' */
+
+static const GLubyte ch77data[] = {
+0xc3,0xc,0xc3,0xc,0xc7,0x8c,0xc4,0x8c,0xcc,0xcc,0xcc,0xcc,0xd8,0x6c,0xd8,0x6c,
+0xf0,0x3c,0xf0,0x3c,0xe0,0x1c,0xe0,0x1c,0xc0,0xc,0xc0,0xc,
+};
+
+static const BitmapCharRec ch77 = {14,14,-1,0,16,ch77data};
+
+/* char: 0x4c 'L' */
+
+static const GLubyte ch76data[] = {
+0xff,0xff,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch76 = {8,14,-1,0,10,ch76data};
+
+/* char: 0x4b 'K' */
+
+static const GLubyte ch75data[] = {
+0xc0,0x70,0xc0,0xe0,0xc1,0xc0,0xc3,0x80,0xc7,0x0,0xce,0x0,0xfc,0x0,0xf8,0x0,
+0xdc,0x0,0xce,0x0,0xc7,0x0,0xc3,0x80,0xc1,0xc0,0xc0,0xe0,
+};
+
+static const BitmapCharRec ch75 = {12,14,-1,0,13,ch75data};
+
+/* char: 0x4a 'J' */
+
+static const GLubyte ch74data[] = {
+0x3c,0x7e,0xe7,0xc3,0xc3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,
+};
+
+static const BitmapCharRec ch74 = {8,14,-1,0,10,ch74data};
+
+/* char: 0x49 'I' */
+
+static const GLubyte ch73data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch73 = {2,14,-2,0,6,ch73data};
+
+/* char: 0x48 'H' */
+
+static const GLubyte ch72data[] = {
+0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xff,0xe0,0xff,0xe0,
+0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+};
+
+static const BitmapCharRec ch72 = {11,14,-1,0,13,ch72data};
+
+/* char: 0x47 'G' */
+
+static const GLubyte ch71data[] = {
+0xf,0xb0,0x3f,0xf0,0x70,0x70,0x60,0x30,0xe0,0x30,0xc1,0xf0,0xc1,0xf0,0xc0,0x0,
+0xc0,0x0,0xe0,0x30,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
+};
+
+static const BitmapCharRec ch71 = {12,14,-1,0,14,ch71data};
+
+/* char: 0x46 'F' */
+
+static const GLubyte ch70data[] = {
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,
+};
+
+static const BitmapCharRec ch70 = {9,14,-1,0,11,ch70data};
+
+/* char: 0x45 'E' */
+
+static const GLubyte ch69data[] = {
+0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,
+};
+
+static const BitmapCharRec ch69 = {9,14,-1,0,11,ch69data};
+
+/* char: 0x44 'D' */
+
+static const GLubyte ch68data[] = {
+0xff,0x0,0xff,0x80,0xc1,0xc0,0xc0,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
+0xc0,0x60,0xc0,0x60,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
+};
+
+static const BitmapCharRec ch68 = {11,14,-1,0,13,ch68data};
+
+/* char: 0x43 'C' */
+
+static const GLubyte ch67data[] = {
+0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
+0xc0,0x0,0xe0,0x0,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
+};
+
+static const BitmapCharRec ch67 = {12,14,-1,0,14,ch67data};
+
+/* char: 0x42 'B' */
+
+static const GLubyte ch66data[] = {
+0xff,0x80,0xff,0xc0,0xc0,0xe0,0xc0,0x60,0xc0,0x60,0xc0,0xe0,0xff,0xc0,0xff,0x80,
+0xc1,0x80,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
+};
+
+static const BitmapCharRec ch66 = {11,14,-1,0,13,ch66data};
+
+/* char: 0x41 'A' */
+
+static const GLubyte ch65data[] = {
+0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
+0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch65 = {12,14,0,0,12,ch65data};
+
+/* char: 0x40 '@' */
+
+static const GLubyte ch64data[] = {
+0x7,0xe0,0x1f,0xf0,0x38,0x0,0x70,0x0,0x67,0x70,0xcf,0xf8,0xcc,0xcc,0xcc,0x66,
+0xcc,0x66,0xcc,0x63,0xc6,0x33,0x67,0x73,0x63,0xb3,0x30,0x6,0x1c,0xe,0xf,0xfc,
+0x3,0xf0,
+};
+
+static const BitmapCharRec ch64 = {16,17,-1,3,18,ch64data};
+
+/* char: 0x3f '?' */
+
+static const GLubyte ch63data[] = {
+0x30,0x30,0x0,0x0,0x30,0x30,0x30,0x38,0x1c,0xe,0xc6,0xc6,0xfe,0x7c,
+};
+
+static const BitmapCharRec ch63 = {7,14,-1,0,10,ch63data};
+
+/* char: 0x3e '>' */
+
+static const GLubyte ch62data[] = {
+0xc0,0xf0,0x3c,0xe,0x3,0xe,0x3c,0xf0,0xc0,
+};
+
+static const BitmapCharRec ch62 = {8,9,-1,0,10,ch62data};
+
+/* char: 0x3d '=' */
+
+static const GLubyte ch61data[] = {
+0xfe,0xfe,0x0,0x0,0xfe,0xfe,
+};
+
+static const BitmapCharRec ch61 = {7,6,-2,-2,11,ch61data};
+
+/* char: 0x3c '<' */
+
+static const GLubyte ch60data[] = {
+0x3,0xf,0x3c,0x70,0xc0,0x70,0x3c,0xf,0x3,
+};
+
+static const BitmapCharRec ch60 = {8,9,-1,0,10,ch60data};
+
+/* char: 0x3b ';' */
+
+static const GLubyte ch59data[] = {
+0x80,0x40,0x40,0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch59 = {2,13,-1,3,5,ch59data};
+
+/* char: 0x3a ':' */
+
+static const GLubyte ch58data[] = {
+0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch58 = {2,10,-1,0,5,ch58data};
+
+/* char: 0x39 '9' */
+
+static const GLubyte ch57data[] = {
+0x7c,0xfe,0xc6,0x3,0x3,0x3b,0x7f,0xc3,0xc3,0xc3,0xc7,0x7e,0x3c,
+};
+
+static const BitmapCharRec ch57 = {8,13,-1,0,10,ch57data};
+
+/* char: 0x38 '8' */
+
+static const GLubyte ch56data[] = {
+0x3c,0x7e,0xe7,0xc3,0xc3,0x66,0x7e,0x66,0xc3,0xc3,0xe7,0x7e,0x3c,
+};
+
+static const BitmapCharRec ch56 = {8,13,-1,0,10,ch56data};
+
+/* char: 0x37 '7' */
+
+static const GLubyte ch55data[] = {
+0x60,0x60,0x30,0x30,0x30,0x18,0x18,0xc,0xc,0x6,0x3,0xff,0xff,
+};
+
+static const BitmapCharRec ch55 = {8,13,-1,0,10,ch55data};
+
+/* char: 0x36 '6' */
+
+static const GLubyte ch54data[] = {
+0x3c,0x7e,0xe3,0xc3,0xc3,0xc3,0xfe,0xdc,0xc0,0xc0,0x63,0x7f,0x3c,
+};
+
+static const BitmapCharRec ch54 = {8,13,-1,0,10,ch54data};
+
+/* char: 0x35 '5' */
+
+static const GLubyte ch53data[] = {
+0x7c,0xfe,0xc7,0xc3,0x3,0x3,0xc7,0xfe,0xfc,0xc0,0xc0,0xfe,0xfe,
+};
+
+static const BitmapCharRec ch53 = {8,13,-1,0,10,ch53data};
+
+/* char: 0x34 '4' */
+
+static const GLubyte ch52data[] = {
+0x3,0x0,0x3,0x0,0x3,0x0,0xff,0x80,0xff,0x80,0xc3,0x0,0x63,0x0,0x33,0x0,
+0x33,0x0,0x1b,0x0,0xf,0x0,0x7,0x0,0x3,0x0,
+};
+
+static const BitmapCharRec ch52 = {9,13,-1,0,10,ch52data};
+
+/* char: 0x33 '3' */
+
+static const GLubyte ch51data[] = {
+0x3c,0x7e,0xc7,0xc3,0x3,0x7,0x1e,0x1c,0x6,0xc3,0xc3,0x7e,0x3c,
+};
+
+static const BitmapCharRec ch51 = {8,13,-1,0,10,ch51data};
+
+/* char: 0x32 '2' */
+
+static const GLubyte ch50data[] = {
+0xff,0xff,0xc0,0xe0,0x70,0x38,0x1c,0xe,0x7,0x3,0xc3,0xfe,0x3c,
+};
+
+static const BitmapCharRec ch50 = {8,13,-1,0,10,ch50data};
+
+/* char: 0x31 '1' */
+
+static const GLubyte ch49data[] = {
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xf8,0xf8,0x18,
+};
+
+static const BitmapCharRec ch49 = {5,13,-2,0,10,ch49data};
+
+/* char: 0x30 '0' */
+
+static const GLubyte ch48data[] = {
+0x3c,0x7e,0x66,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x66,0x7e,0x3c,
+};
+
+static const BitmapCharRec ch48 = {8,13,-1,0,10,ch48data};
+
+/* char: 0x2f '/' */
+
+static const GLubyte ch47data[] = {
+0xc0,0xc0,0x40,0x40,0x60,0x60,0x20,0x20,0x30,0x30,0x10,0x10,0x18,0x18,
+};
+
+static const BitmapCharRec ch47 = {5,14,0,0,5,ch47data};
+
+/* char: 0x2e '.' */
+
+static const GLubyte ch46data[] = {
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch46 = {2,2,-1,0,5,ch46data};
+
+/* char: 0x2d '-' */
+
+static const GLubyte ch45data[] = {
+0xff,0xff,
+};
+
+static const BitmapCharRec ch45 = {8,2,-1,-4,11,ch45data};
+
+/* char: 0x2c ',' */
+
+static const GLubyte ch44data[] = {
+0x80,0x40,0x40,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch44 = {2,5,-1,3,5,ch44data};
+
+/* char: 0x2b '+' */
+
+static const GLubyte ch43data[] = {
+0x18,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18,0x18,
+};
+
+static const BitmapCharRec ch43 = {8,10,-1,0,10,ch43data};
+
+/* char: 0x2a '*' */
+
+static const GLubyte ch42data[] = {
+0x88,0x70,0x70,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch42 = {5,6,-1,-8,7,ch42data};
+
+/* char: 0x29 ')' */
+
+static const GLubyte ch41data[] = {
+0x80,0xc0,0x60,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0x60,
+0xc0,0x80,
+};
+
+static const BitmapCharRec ch41 = {4,18,-1,4,6,ch41data};
+
+/* char: 0x28 '(' */
+
+static const GLubyte ch40data[] = {
+0x10,0x30,0x60,0x60,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x60,0x60,
+0x30,0x10,
+};
+
+static const BitmapCharRec ch40 = {4,18,-1,4,6,ch40data};
+
+/* char: 0x27 ''' */
+
+static const GLubyte ch39data[] = {
+0x80,0x40,0x40,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch39 = {2,5,-1,-9,4,ch39data};
+
+/* char: 0x26 '&' */
+
+static const GLubyte ch38data[] = {
+0x3c,0x70,0x7e,0xe0,0xe7,0xc0,0xc3,0x80,0xc3,0xc0,0xc6,0xc0,0xee,0xc0,0x7c,0x0,
+0x3c,0x0,0x66,0x0,0x66,0x0,0x7e,0x0,0x3c,0x0,
+};
+
+static const BitmapCharRec ch38 = {12,13,-1,0,13,ch38data};
+
+/* char: 0x25 '%' */
+
+static const GLubyte ch37data[] = {
+0x18,0x78,0x18,0xfc,0xc,0xcc,0xc,0xcc,0x6,0xfc,0x6,0x78,0x3,0x0,0x7b,0x0,
+0xfd,0x80,0xcd,0x80,0xcc,0xc0,0xfc,0xc0,0x78,0x60,
+};
+
+static const BitmapCharRec ch37 = {14,13,-1,0,16,ch37data};
+
+/* char: 0x24 '$' */
+
+static const GLubyte ch36data[] = {
+0x8,0x0,0x8,0x0,0x3e,0x0,0x7f,0x0,0xeb,0x80,0xc9,0x80,0x9,0x80,0xf,0x0,
+0x3e,0x0,0x78,0x0,0xe8,0x0,0xc8,0x0,0xcb,0x0,0x7f,0x0,0x3e,0x0,0x8,0x0,
+};
+
+static const BitmapCharRec ch36 = {9,16,-1,2,10,ch36data};
+
+/* char: 0x23 '#' */
+
+static const GLubyte ch35data[] = {
+0x24,0x0,0x24,0x0,0x24,0x0,0xff,0x80,0xff,0x80,0x12,0x0,0x12,0x0,0x12,0x0,
+0x7f,0xc0,0x7f,0xc0,0x9,0x0,0x9,0x0,0x9,0x0,
+};
+
+static const BitmapCharRec ch35 = {10,13,0,0,10,ch35data};
+
+/* char: 0x22 '"' */
+
+static const GLubyte ch34data[] = {
+0x90,0x90,0xd8,0xd8,0xd8,
+};
+
+static const BitmapCharRec ch34 = {5,5,0,-9,5,ch34data};
+
+/* char: 0x21 '!' */
+
+static const GLubyte ch33data[] = {
+0xc0,0xc0,0x0,0x0,0x80,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch33 = {2,14,-2,0,6,ch33data};
+
+/* char: 0x20 ' ' */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch32data[] = { 0x0 };
+static const BitmapCharRec ch32 = {1,1,0,0,5,ch32data};
+#else
+static const BitmapCharRec ch32 = {0,0,0,0,5,0};
+#endif
+
+static const BitmapCharRec * const chars[] = {
+&ch32,
+&ch33,
+&ch34,
+&ch35,
+&ch36,
+&ch37,
+&ch38,
+&ch39,
+&ch40,
+&ch41,
+&ch42,
+&ch43,
+&ch44,
+&ch45,
+&ch46,
+&ch47,
+&ch48,
+&ch49,
+&ch50,
+&ch51,
+&ch52,
+&ch53,
+&ch54,
+&ch55,
+&ch56,
+&ch57,
+&ch58,
+&ch59,
+&ch60,
+&ch61,
+&ch62,
+&ch63,
+&ch64,
+&ch65,
+&ch66,
+&ch67,
+&ch68,
+&ch69,
+&ch70,
+&ch71,
+&ch72,
+&ch73,
+&ch74,
+&ch75,
+&ch76,
+&ch77,
+&ch78,
+&ch79,
+&ch80,
+&ch81,
+&ch82,
+&ch83,
+&ch84,
+&ch85,
+&ch86,
+&ch87,
+&ch88,
+&ch89,
+&ch90,
+&ch91,
+&ch92,
+&ch93,
+&ch94,
+&ch95,
+&ch96,
+&ch97,
+&ch98,
+&ch99,
+&ch100,
+&ch101,
+&ch102,
+&ch103,
+&ch104,
+&ch105,
+&ch106,
+&ch107,
+&ch108,
+&ch109,
+&ch110,
+&ch111,
+&ch112,
+&ch113,
+&ch114,
+&ch115,
+&ch116,
+&ch117,
+&ch118,
+&ch119,
+&ch120,
+&ch121,
+&ch122,
+&ch123,
+&ch124,
+&ch125,
+&ch126,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+&ch160,
+&ch161,
+&ch162,
+&ch163,
+&ch164,
+&ch165,
+&ch166,
+&ch167,
+&ch168,
+&ch169,
+&ch170,
+&ch171,
+&ch172,
+&ch173,
+&ch174,
+&ch175,
+&ch176,
+&ch177,
+&ch178,
+&ch179,
+&ch180,
+&ch181,
+&ch182,
+&ch183,
+&ch184,
+&ch185,
+&ch186,
+&ch187,
+&ch188,
+&ch189,
+&ch190,
+&ch191,
+&ch192,
+&ch193,
+&ch194,
+&ch195,
+&ch196,
+&ch197,
+&ch198,
+&ch199,
+&ch200,
+&ch201,
+&ch202,
+&ch203,
+&ch204,
+&ch205,
+&ch206,
+&ch207,
+&ch208,
+&ch209,
+&ch210,
+&ch211,
+&ch212,
+&ch213,
+&ch214,
+&ch215,
+&ch216,
+&ch217,
+&ch218,
+&ch219,
+&ch220,
+&ch221,
+&ch222,
+&ch223,
+&ch224,
+&ch225,
+&ch226,
+&ch227,
+&ch228,
+&ch229,
+&ch230,
+&ch231,
+&ch232,
+&ch233,
+&ch234,
+&ch235,
+&ch236,
+&ch237,
+&ch238,
+&ch239,
+&ch240,
+&ch241,
+&ch242,
+&ch243,
+&ch244,
+&ch245,
+&ch246,
+&ch247,
+&ch248,
+&ch249,
+&ch250,
+&ch251,
+&ch252,
+&ch253,
+&ch254,
+&ch255,
+};
+
+const BitmapFontRec glutBitmapHelvetica18 = {
+"-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1",
+224,
+32,
+chars
+};
+
diff --git a/src/glut/glx/glut_init.c b/src/glut/glx/glut_init.c
new file mode 100644
index 0000000000..b9d2fde3f3
--- /dev/null
+++ b/src/glut/glx/glut_init.c
@@ -0,0 +1,364 @@
+
+/* 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. */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#if !defined(_WIN32)
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#endif
+
+/* SGI optimization introduced in IRIX 6.3 to avoid X server
+   round trips for interning common X atoms. */
+#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
+#include <X11/SGIFastAtom.h>
+#else
+#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
+#endif
+
+#include "glutint.h"
+
+/* GLUT inter-file variables */
+/* *INDENT-OFF* */
+char *__glutProgramName = NULL;
+int __glutArgc = 0;
+char **__glutArgv = NULL;
+char *__glutGeometry = NULL;
+Display *__glutDisplay = NULL;
+int __glutScreen;
+Window __glutRoot;
+int __glutScreenHeight;
+int __glutScreenWidth;
+GLboolean __glutIconic = GL_FALSE;
+GLboolean __glutDebug = GL_FALSE;
+unsigned int __glutDisplayMode =
+  GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH;
+char *__glutDisplayString = NULL;
+int __glutConnectionFD;
+XSizeHints __glutSizeHints = {0};
+int __glutInitWidth = 300, __glutInitHeight = 300;
+int __glutInitX = -1, __glutInitY = -1;
+GLboolean __glutForceDirect = GL_FALSE,
+  __glutTryDirect = GL_TRUE;
+Atom __glutWMDeleteWindow;
+/* *INDENT-ON* */
+
+#ifdef _WIN32
+void (__cdecl *__glutExitFunc)(int retval) = NULL;
+#endif
+
+static Bool synchronize = False;
+
+#if defined(_WIN32)
+
+#ifdef __BORLANDC__
+#include <float.h>  /* For masking floating point exceptions. */
+#endif
+
+void
+__glutOpenWin32Connection(char* display)
+{
+  static char *classname;
+  WNDCLASS  wc;
+  HINSTANCE hInstance = GetModuleHandle(NULL);
+  
+  /* Make sure we register the window only once. */
+  if(classname)
+    return;
+
+#ifdef __BORLANDC__
+  /* Under certain conditions (e.g. while rendering solid surfaces with
+     lighting enabled) Microsoft OpenGL libraries cause some illegal
+     operations like floating point overflow or division by zero. The
+     default behaviour of Microsoft compilers is to mask (ignore)
+     floating point exceptions, while Borland compilers do not.  The
+     following function of Borland RTL allows to mask exceptions.
+     Advice from Pier Giorgio Esposito (mc2172@mclink.it). */
+  _control87(MCW_EM,MCW_EM);
+#endif
+
+  classname = "GLUT";
+
+  /* Clear (important!) and then fill in the window class structure. */
+  memset(&wc, 0, sizeof(WNDCLASS));
+  wc.style         = CS_OWNDC;
+  wc.lpfnWndProc   = (WNDPROC)__glutWindowProc;
+  wc.hInstance     = hInstance;
+  wc.hIcon         = LoadIcon(hInstance, "GLUT_ICON");
+  wc.hCursor       = LoadCursor(hInstance, IDC_ARROW);
+  wc.hbrBackground = NULL;
+  wc.lpszMenuName  = NULL;
+  wc.lpszClassName = classname;
+
+  /* Fill in a default icon if one isn't specified as a resource. */
+  if(!wc.hIcon)
+    wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
+  
+  if(!RegisterClass(&wc)) {
+    __glutFatalError("RegisterClass() failed:"
+		     "Cannot register GLUT window class.");
+  }
+ 
+  __glutScreenWidth     = GetSystemMetrics(SM_CXSCREEN);
+  __glutScreenHeight    = GetSystemMetrics(SM_CYSCREEN);
+
+  /* Set the root window to NULL because windows creates a top-level
+     window when the parent is NULL.  X creates a top-level window
+     when the parent is the root window. */
+  __glutRoot            = NULL;
+
+  /* Set the display to 1 -- we shouldn't be using this anywhere
+     (except as an argument to X calls). */
+  __glutDisplay         = (Display*)1;
+
+  /* There isn't any concept of multiple screens in Win32, therefore,
+     we don't need to keep track of the screen we're on... it's always
+     the same one. */
+  __glutScreen          = 0;
+}
+#else /* !_WIN32 */
+void
+__glutOpenXConnection(char *display)
+{
+  int errorBase, eventBase;
+
+  __glutDisplay = XOpenDisplay(display);
+  if (!__glutDisplay)
+    __glutFatalError("could not open display: %s",
+      XDisplayName(display));
+  if (synchronize)
+    XSynchronize(__glutDisplay, True);
+  if (!glXQueryExtension(__glutDisplay, &errorBase, &eventBase))
+    __glutFatalError(
+      "OpenGL GLX extension not supported by display: %s",
+      XDisplayName(display));
+  __glutScreen = DefaultScreen(__glutDisplay);
+  __glutRoot = RootWindow(__glutDisplay, __glutScreen);
+  __glutScreenWidth = DisplayWidth(__glutDisplay, __glutScreen);
+  __glutScreenHeight = DisplayHeight(__glutDisplay,
+    __glutScreen);
+  __glutConnectionFD = ConnectionNumber(__glutDisplay);
+  __glutWMDeleteWindow = XSGIFastInternAtom(__glutDisplay,
+    "WM_DELETE_WINDOW", SGI_XA_WM_DELETE_WINDOW, False);
+}
+#endif /* _WIN32 */
+
+void
+__glutInitTime(struct timeval *beginning)
+{
+  static int beenhere = 0;
+  static struct timeval genesis;
+
+  if (!beenhere) {
+    GETTIMEOFDAY(&genesis);
+    beenhere = 1;
+  }
+  *beginning = genesis;
+}
+
+static void
+removeArgs(int *argcp, char **argv, int numToRemove)
+{
+  int i, j;
+
+  for (i = 0, j = numToRemove; argv[j]; i++, j++) {
+    argv[i] = argv[j];
+  }
+  argv[i] = NULL;
+  *argcp -= numToRemove;
+}
+
+void APIENTRY 
+glutInit(int *argcp, char **argv)
+{
+  char *display = NULL;
+  char *str, *geometry = NULL;
+  struct timeval unused;
+  int i;
+
+  if (__glutDisplay) {
+    __glutWarning("glutInit being called a second time.");
+    return;
+  }
+  /* Determine temporary program name. */
+  str = strrchr(argv[0], '/');
+  if (str == NULL) {
+    __glutProgramName = argv[0];
+  } else {
+    __glutProgramName = str + 1;
+  }
+
+  /* Make private copy of command line arguments. */
+  __glutArgc = *argcp;
+  __glutArgv = (char **) malloc(__glutArgc * sizeof(char *));
+  if (!__glutArgv)
+    __glutFatalError("out of memory.");
+  for (i = 0; i < __glutArgc; i++) {
+    __glutArgv[i] = __glutStrdup(argv[i]);
+    if (!__glutArgv[i])
+      __glutFatalError("out of memory.");
+  }
+
+  /* determine permanent program name */
+  str = strrchr(__glutArgv[0], '/');
+  if (str == NULL) {
+    __glutProgramName = __glutArgv[0];
+  } else {
+    __glutProgramName = str + 1;
+  }
+
+  /* parse arguments for standard options */
+  for (i = 1; i < __glutArgc; i++) {
+    if (!strcmp(__glutArgv[i], "-display")) {
+#if defined(_WIN32)
+      __glutWarning("-display option not supported by Win32 GLUT.");
+#endif
+      if (++i >= __glutArgc) {
+        __glutFatalError(
+          "follow -display option with X display name.");
+      }
+      display = __glutArgv[i];
+      removeArgs(argcp, &argv[1], 2);
+    } else if (!strcmp(__glutArgv[i], "-geometry")) {
+      if (++i >= __glutArgc) {
+        __glutFatalError(
+          "follow -geometry option with geometry parameter.");
+      }
+      geometry = __glutArgv[i];
+      removeArgs(argcp, &argv[1], 2);
+    } else if (!strcmp(__glutArgv[i], "-direct")) {
+#if defined(_WIN32)
+      __glutWarning("-direct option not supported by Win32 GLUT.");
+#endif
+      if (!__glutTryDirect)
+        __glutFatalError(
+          "cannot force both direct and indirect rendering.");
+      __glutForceDirect = GL_TRUE;
+      removeArgs(argcp, &argv[1], 1);
+    } else if (!strcmp(__glutArgv[i], "-indirect")) {
+#if defined(_WIN32)
+      __glutWarning("-indirect option not supported by Win32 GLUT.");
+#endif
+      if (__glutForceDirect)
+        __glutFatalError(
+          "cannot force both direct and indirect rendering.");
+      __glutTryDirect = GL_FALSE;
+      removeArgs(argcp, &argv[1], 1);
+    } else if (!strcmp(__glutArgv[i], "-iconic")) {
+      __glutIconic = GL_TRUE;
+      removeArgs(argcp, &argv[1], 1);
+    } else if (!strcmp(__glutArgv[i], "-gldebug")) {
+      __glutDebug = GL_TRUE;
+      removeArgs(argcp, &argv[1], 1);
+    } else if (!strcmp(__glutArgv[i], "-sync")) {
+#if defined(_WIN32)
+      __glutWarning("-sync option not supported by Win32 GLUT.");
+#endif
+      synchronize = GL_TRUE;
+      removeArgs(argcp, &argv[1], 1);
+    } else {
+      /* Once unknown option encountered, stop command line
+         processing. */
+      break;
+    }
+  }
+#if defined(_WIN32)
+  __glutOpenWin32Connection(display);
+#else
+  __glutOpenXConnection(display);
+#endif
+  if (geometry) {
+    int flags, x, y, width, height;
+
+    /* Fix bogus "{width|height} may be used before set"
+       warning */
+    width = 0;
+    height = 0;
+
+    flags = XParseGeometry(geometry, &x, &y,
+      (unsigned int *) &width, (unsigned int *) &height);
+    if (WidthValue & flags) {
+      /* Careful because X does not allow zero or negative
+         width windows */
+      if (width > 0)
+        __glutInitWidth = width;
+    }
+    if (HeightValue & flags) {
+      /* Careful because X does not allow zero or negative
+         height windows */
+      if (height > 0)
+        __glutInitHeight = height;
+    }
+    glutInitWindowSize(__glutInitWidth, __glutInitHeight);
+    if (XValue & flags) {
+      if (XNegative & flags)
+        x = DisplayWidth(__glutDisplay, __glutScreen) +
+          x - __glutSizeHints.width;
+      /* Play safe: reject negative X locations */
+      if (x >= 0)
+        __glutInitX = x;
+    }
+    if (YValue & flags) {
+      if (YNegative & flags)
+        y = DisplayHeight(__glutDisplay, __glutScreen) +
+          y - __glutSizeHints.height;
+      /* Play safe: reject negative Y locations */
+      if (y >= 0)
+        __glutInitY = y;
+    }
+    glutInitWindowPosition(__glutInitX, __glutInitY);
+  }
+  __glutInitTime(&unused);
+}
+
+#ifdef _WIN32
+void APIENTRY 
+__glutInitWithExit(int *argcp, char **argv, void (__cdecl *exitfunc)(int))
+{
+  __glutExitFunc = exitfunc;
+  glutInit(argcp, argv);
+}
+#endif
+
+/* CENTRY */
+void APIENTRY 
+glutInitWindowPosition(int x, int y)
+{
+  __glutInitX = x;
+  __glutInitY = y;
+  if (x >= 0 && y >= 0) {
+    __glutSizeHints.x = x;
+    __glutSizeHints.y = y;
+    __glutSizeHints.flags |= USPosition;
+  } else {
+    __glutSizeHints.flags &= ~USPosition;
+  }
+}
+
+void APIENTRY 
+glutInitWindowSize(int width, int height)
+{
+  __glutInitWidth = width;
+  __glutInitHeight = height;
+  if (width > 0 && height > 0) {
+    __glutSizeHints.width = width;
+    __glutSizeHints.height = height;
+    __glutSizeHints.flags |= USSize;
+  } else {
+    __glutSizeHints.flags &= ~USSize;
+  }
+}
+
+void APIENTRY 
+glutInitDisplayMode(unsigned int mask)
+{
+  __glutDisplayMode = mask;
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_input.c b/src/glut/glx/glut_input.c
new file mode 100644
index 0000000000..a8d3c61cfe
--- /dev/null
+++ b/src/glut/glx/glut_input.c
@@ -0,0 +1,630 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
+
+/* 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 <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined(_WIN32)
+#include <X11/Xlib.h>
+#if defined(__vms)
+#include <X11/XInput.h>
+#else
+#include <X11/extensions/XInput.h>
+#endif
+#include <X11/Xutil.h>
+#else
+#include <windows.h>
+#include <mmsystem.h>  /* Win32 Multimedia API header. */
+#endif /* !_WIN32 */
+
+#include "glutint.h"
+
+int __glutNumDials = 0;
+int __glutNumSpaceballButtons = 0;
+int __glutNumButtonBoxButtons = 0;
+int __glutNumTabletButtons = 0;
+int __glutNumMouseButtons = 3;  /* Good guess. */
+XDevice *__glutTablet = NULL;
+XDevice *__glutDials = NULL;
+XDevice *__glutSpaceball = NULL;
+
+int __glutHasJoystick = 0;
+int __glutNumJoystickButtons = 0;
+int __glutNumJoystickAxes = 0;
+
+#if !defined(_WIN32)
+typedef struct _Range {
+  int min;
+  int range;
+} Range;
+
+#define NUM_SPACEBALL_AXIS	6
+#define NUM_TABLET_AXIS		2
+#define NUM_DIALS_AXIS		8
+
+Range __glutSpaceballRange[NUM_SPACEBALL_AXIS];
+Range __glutTabletRange[NUM_TABLET_AXIS];
+int *__glutDialsResolution;
+
+/* Safely assumes 0 is an illegal event type for X Input
+   extension events. */
+int __glutDeviceMotionNotify = 0;
+int __glutDeviceButtonPress = 0;
+int __glutDeviceButtonPressGrab = 0;
+int __glutDeviceButtonRelease = 0;
+int __glutDeviceStateNotify = 0;
+
+static int
+normalizeTabletPos(int axis, int rawValue)
+{
+  assert(rawValue >= __glutTabletRange[axis].min);
+  assert(rawValue <= __glutTabletRange[axis].min
+    + __glutTabletRange[axis].range);
+  /* Normalize rawValue to between 0 and 4000. */
+  return ((rawValue - __glutTabletRange[axis].min) * 4000) /
+    __glutTabletRange[axis].range;
+}
+
+static int
+normalizeDialAngle(int axis, int rawValue)
+{
+  /* XXX Assumption made that the resolution of the device is
+     number of clicks for one complete dial revolution.  This
+     is true for SGI's dial & button box. */
+  return (rawValue * 360.0) / __glutDialsResolution[axis];
+}
+
+static int
+normalizeSpaceballAngle(int axis, int rawValue)
+{
+  assert(rawValue >= __glutSpaceballRange[axis].min);
+  assert(rawValue <= __glutSpaceballRange[axis].min +
+    __glutSpaceballRange[axis].range);
+  /* Normalize rawValue to between -1800 and 1800. */
+  return ((rawValue - __glutSpaceballRange[axis].min) * 3600) /
+    __glutSpaceballRange[axis].range - 1800;
+}
+
+static int
+normalizeSpaceballDelta(int axis, int rawValue)
+{
+  assert(rawValue >= __glutSpaceballRange[axis].min);
+  assert(rawValue <= __glutSpaceballRange[axis].min +
+    __glutSpaceballRange[axis].range);
+  /* Normalize rawValue to between -1000 and 1000. */
+  return ((rawValue - __glutSpaceballRange[axis].min) * 2000) /
+    __glutSpaceballRange[axis].range - 1000;
+}
+
+static void
+queryTabletPos(GLUTwindow * window)
+{
+  XDeviceState *state;
+  XInputClass *any;
+  XValuatorState *v;
+  int i;
+
+  state = XQueryDeviceState(__glutDisplay, __glutTablet);
+  any = state->data;
+  for (i = 0; i < state->num_classes; i++) {
+#if defined(__cplusplus) || defined(c_plusplus)
+    switch (any->c_class) {
+#else
+    switch (any->class) {
+#endif
+    case ValuatorClass:
+      v = (XValuatorState *) any;
+      if (v->num_valuators < 2)
+        goto end;
+      if (window->tabletPos[0] == -1)
+        window->tabletPos[0] = normalizeTabletPos(0, v->valuators[0]);
+      if (window->tabletPos[1] == -1)
+        window->tabletPos[1] = normalizeTabletPos(1, v->valuators[1]);
+    }
+    any = (XInputClass *) ((char *) any + any->length);
+  }
+end:
+  XFreeDeviceState(state);
+}
+
+static void
+tabletPosChange(GLUTwindow * window, int first, int count, int *data)
+{
+  int i, value, genEvent = 0;
+
+  for (i = first; i < first + count; i++) {
+    switch (i) {
+    case 0:            /* X axis */
+    case 1:            /* Y axis */
+      value = normalizeTabletPos(i, data[i - first]);
+      if (value != window->tabletPos[i]) {
+        window->tabletPos[i] = value;
+        genEvent = 1;
+      }
+      break;
+    }
+  }
+  if (window->tabletPos[0] == -1 || window->tabletPos[1] == -1)
+    queryTabletPos(window);
+  if (genEvent)
+    window->tabletMotion(window->tabletPos[0], window->tabletPos[1]);
+}
+#endif /* !_WIN32 */
+
+int
+__glutProcessDeviceEvents(XEvent * event)
+{
+#if !defined(_WIN32)
+  GLUTwindow *window;
+
+  /* XXX Ugly code fan out. */
+
+  /* Can't use switch/case since X Input event types are
+     dynamic. */
+
+  if (__glutDeviceMotionNotify && event->type == __glutDeviceMotionNotify) {
+    XDeviceMotionEvent *devmot = (XDeviceMotionEvent *) event;
+
+    window = __glutGetWindow(devmot->window);
+    if (window) {
+      if (__glutTablet
+        && devmot->deviceid == __glutTablet->device_id
+        && window->tabletMotion) {
+        tabletPosChange(window, devmot->first_axis, devmot->axes_count,
+          devmot->axis_data);
+      } else if (__glutDials
+          && devmot->deviceid == __glutDials->device_id
+        && window->dials) {
+        int i, first = devmot->first_axis, count = devmot->axes_count;
+
+        for (i = first; i < first + count; i++)
+          window->dials(i + 1,
+            normalizeDialAngle(i, devmot->axis_data[i - first]));
+      } else if (__glutSpaceball
+        && devmot->deviceid == __glutSpaceball->device_id) {
+        /* XXX Assume that space ball motion events come in as
+           all the first 6 axes.  Assume first 3 axes are XYZ
+           translations; second 3 axes are XYZ rotations. */
+        if (devmot->first_axis == 0 && devmot->axes_count == 6) {
+          if (window->spaceMotion)
+            window->spaceMotion(
+              normalizeSpaceballDelta(0, devmot->axis_data[0]),
+              normalizeSpaceballDelta(1, devmot->axis_data[1]),
+              normalizeSpaceballDelta(2, devmot->axis_data[2]));
+          if (window->spaceRotate)
+            window->spaceRotate(
+              normalizeSpaceballAngle(3, devmot->axis_data[3]),
+              normalizeSpaceballAngle(4, devmot->axis_data[4]),
+              normalizeSpaceballAngle(5, devmot->axis_data[5]));
+        }
+      }
+      return 1;
+    }
+  } else if (__glutDeviceButtonPress
+    && event->type == __glutDeviceButtonPress) {
+    XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;
+
+    window = __glutGetWindow(devbtn->window);
+    if (window) {
+      if (__glutTablet
+        && devbtn->deviceid == __glutTablet->device_id
+        && window->tabletButton
+        && devbtn->first_axis == 0
+        && devbtn->axes_count == 2) {
+        tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
+          devbtn->axis_data);
+        window->tabletButton(devbtn->button, GLUT_DOWN,
+          window->tabletPos[0], window->tabletPos[1]);
+      } else if (__glutDials
+          && devbtn->deviceid == __glutDials->device_id
+        && window->buttonBox) {
+        window->buttonBox(devbtn->button, GLUT_DOWN);
+      } else if (__glutSpaceball
+          && devbtn->deviceid == __glutSpaceball->device_id
+        && window->spaceButton) {
+        window->spaceButton(devbtn->button, GLUT_DOWN);
+      }
+      return 1;
+    }
+  } else if (__glutDeviceButtonRelease
+    && event->type == __glutDeviceButtonRelease) {
+    XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;
+
+    window = __glutGetWindow(devbtn->window);
+    if (window) {
+      if (__glutTablet
+        && devbtn->deviceid == __glutTablet->device_id
+        && window->tabletButton
+        && devbtn->first_axis == 0
+        && devbtn->axes_count == 2) {
+        tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
+          devbtn->axis_data);
+        window->tabletButton(devbtn->button, GLUT_UP,
+          window->tabletPos[0], window->tabletPos[1]);
+      } else if (__glutDials
+          && devbtn->deviceid == __glutDials->device_id
+        && window->buttonBox) {
+        window->buttonBox(devbtn->button, GLUT_UP);
+      } else if (__glutSpaceball
+          && devbtn->deviceid == __glutSpaceball->device_id
+        && window->spaceButton) {
+        window->spaceButton(devbtn->button, GLUT_UP);
+      }
+      return 1;
+    }
+  }
+#else
+  {
+    JOYINFOEX info;
+    int njoyId = 0;
+    int nConnected = 0;
+    MMRESULT result;
+
+    /* Loop through all possible joystick IDs until we get the error
+       JOYERR_PARMS. Count the number of times we get JOYERR_NOERROR
+       indicating an installed joystick driver with a joystick currently
+       attached to the port. */
+    while ((result = joyGetPosEx(njoyId++,&info)) != JOYERR_PARMS) {
+      if (result == JOYERR_NOERROR) {
+        ++nConnected;  /* The count of connected joysticks. */
+      }
+    }
+  }
+#endif /* !_WIN32 */
+  return 0;
+}
+
+static GLUTeventParser eventParser =
+{__glutProcessDeviceEvents, NULL};
+
+static void
+addDeviceEventParser(void)
+{
+  static Bool been_here = False;
+
+  if (been_here)
+    return;
+  been_here = True;
+  __glutRegisterEventParser(&eventParser);
+}
+
+static int
+probeDevices(void)
+{
+  static Bool been_here = False;
+  static int support;
+#if !defined(_WIN32)
+  XExtensionVersion *version;
+  XDeviceInfoPtr device_info, device;
+  XAnyClassPtr any;
+  XButtonInfoPtr b;
+  XValuatorInfoPtr v;
+  XAxisInfoPtr a;
+  int num_dev, btns, dials;
+  int i, j, k;
+#endif /* !_WIN32 */
+
+  if (been_here) {
+    return support;
+  }
+  been_here = True;
+
+#if !defined(_WIN32)
+  version = XGetExtensionVersion(__glutDisplay, "XInputExtension");
+  /* Ugh.  XInput extension API forces annoying cast of a pointer
+     to a long so it can be compared with the NoSuchExtension
+     value (#defined to 1). */
+  if (version == NULL || ((long) version) == NoSuchExtension) {
+    support = 0;
+    return support;
+  }
+  XFree(version);
+  device_info = XListInputDevices(__glutDisplay, &num_dev);
+  if (device_info) {
+    for (i = 0; i < num_dev; i++) {
+      /* XXX These are SGI names for these devices;
+         unfortunately, no good standard exists for standard
+         types of X input extension devices. */
+
+      device = &device_info[i];
+      any = (XAnyClassPtr) device->inputclassinfo;
+
+      if (!__glutSpaceball && !strcmp(device->name, "spaceball")) {
+        v = NULL;
+        b = NULL;
+        for (j = 0; j < device->num_classes; j++) {
+#if defined(__cplusplus) || defined(c_plusplus)
+          switch (any->c_class) {
+#else
+          switch (any->class) {
+#endif
+          case ButtonClass:
+            b = (XButtonInfoPtr) any;
+            btns = b->num_buttons;
+            break;
+          case ValuatorClass:
+            v = (XValuatorInfoPtr) any;
+            /* Sanity check: at least 6 valuators? */
+            if (v->num_axes < NUM_SPACEBALL_AXIS)
+              goto skip_device;
+            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
+            for (k = 0; k < NUM_SPACEBALL_AXIS; k++, a++) {
+              __glutSpaceballRange[k].min = a->min_value;
+              __glutSpaceballRange[k].range = a->max_value - a->min_value;
+            }
+            break;
+          }
+          any = (XAnyClassPtr) ((char *) any + any->length);
+        }
+        if (v) {
+          __glutSpaceball = XOpenDevice(__glutDisplay, device->id);
+          if (__glutSpaceball) {
+            __glutNumSpaceballButtons = btns;
+            addDeviceEventParser();
+          }
+        }
+      } else if (!__glutDials && !strcmp(device->name, "dial+buttons")) {
+        v = NULL;
+        b = NULL;
+        for (j = 0; j < device->num_classes; j++) {
+#if defined(__cplusplus) || defined(c_plusplus)
+          switch (any->c_class) {
+#else
+          switch (any->class) {
+#endif
+          case ButtonClass:
+            b = (XButtonInfoPtr) any;
+            btns = b->num_buttons;
+            break;
+          case ValuatorClass:
+            v = (XValuatorInfoPtr) any;
+            /* Sanity check: at least 8 valuators? */
+            if (v->num_axes < NUM_DIALS_AXIS)
+              goto skip_device;
+            dials = v->num_axes;
+            __glutDialsResolution = (int *) malloc(sizeof(int) * dials);
+            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
+            for (k = 0; k < dials; k++, a++) {
+              __glutDialsResolution[k] = a->resolution;
+            }
+            break;
+          }
+          any = (XAnyClassPtr) ((char *) any + any->length);
+        }
+        if (v) {
+          __glutDials = XOpenDevice(__glutDisplay, device->id);
+          if (__glutDials) {
+            __glutNumButtonBoxButtons = btns;
+            __glutNumDials = dials;
+            addDeviceEventParser();
+          }
+        }
+      } else if (!__glutTablet && !strcmp(device->name, "tablet")) {
+        v = NULL;
+        b = NULL;
+        for (j = 0; j < device->num_classes; j++) {
+#if defined(__cplusplus) || defined(c_plusplus)
+          switch (any->c_class) {
+#else
+          switch (any->class) {
+#endif
+          case ButtonClass:
+            b = (XButtonInfoPtr) any;
+            btns = b->num_buttons;
+            break;
+          case ValuatorClass:
+            v = (XValuatorInfoPtr) any;
+            /* Sanity check: exactly 2 valuators? */
+            if (v->num_axes != NUM_TABLET_AXIS)
+              goto skip_device;
+            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
+            for (k = 0; k < NUM_TABLET_AXIS; k++, a++) {
+              __glutTabletRange[k].min = a->min_value;
+              __glutTabletRange[k].range = a->max_value - a->min_value;
+            }
+            break;
+          }
+          any = (XAnyClassPtr) ((char *) any + any->length);
+        }
+        if (v) {
+          __glutTablet = XOpenDevice(__glutDisplay, device->id);
+          if (__glutTablet) {
+            __glutNumTabletButtons = btns;
+            addDeviceEventParser();
+          }
+        }
+      } else if (!strcmp(device->name, "mouse")) {
+        for (j = 0; j < device->num_classes; j++) {
+#if defined(__cplusplus) || defined(c_plusplus)
+          if (any->c_class == ButtonClass) {
+#else
+          if (any->class == ButtonClass) {
+#endif
+            b = (XButtonInfoPtr) any;
+            __glutNumMouseButtons = b->num_buttons;
+          }
+          any = (XAnyClassPtr) ((char *) any + any->length);
+        }
+      }
+    skip_device:;
+    }
+    XFreeDeviceList(device_info);
+  }
+#else /* _WIN32 */
+  __glutNumMouseButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
+#endif /* !_WIN32 */
+  /* X Input extension might be supported, but only if there is
+     a tablet, dials, or spaceball do we claim devices are
+     supported. */
+  support = __glutTablet || __glutDials || __glutSpaceball;
+  return support;
+}
+
+void
+__glutUpdateInputDeviceMask(GLUTwindow * window)
+{
+#if !defined(_WIN32)
+  /* 5 (dial and buttons) + 5 (tablet locator and buttons) + 5
+     (Spaceball buttons and axis) = 15 */
+  XEventClass eventList[15];
+  int rc, numEvents;
+
+  rc = probeDevices();
+  if (rc) {
+    numEvents = 0;
+    if (__glutTablet) {
+      if (window->tabletMotion) {
+        DeviceMotionNotify(__glutTablet, __glutDeviceMotionNotify,
+          eventList[numEvents]);
+        numEvents++;
+      }
+      if (window->tabletButton) {
+        DeviceButtonPress(__glutTablet, __glutDeviceButtonPress,
+          eventList[numEvents]);
+        numEvents++;
+        DeviceButtonPressGrab(__glutTablet, __glutDeviceButtonPressGrab,
+          eventList[numEvents]);
+        numEvents++;
+        DeviceButtonRelease(__glutTablet, __glutDeviceButtonRelease,
+          eventList[numEvents]);
+        numEvents++;
+      }
+      if (window->tabletMotion || window->tabletButton) {
+        DeviceStateNotify(__glutTablet, __glutDeviceStateNotify,
+          eventList[numEvents]);
+        numEvents++;
+      }
+    }
+    if (__glutDials) {
+      if (window->dials) {
+        DeviceMotionNotify(__glutDials, __glutDeviceMotionNotify,
+          eventList[numEvents]);
+        numEvents++;
+      }
+      if (window->buttonBox) {
+        DeviceButtonPress(__glutDials, __glutDeviceButtonPress,
+          eventList[numEvents]);
+        numEvents++;
+        DeviceButtonPressGrab(__glutDials, __glutDeviceButtonPressGrab,
+          eventList[numEvents]);
+        numEvents++;
+        DeviceButtonRelease(__glutDials, __glutDeviceButtonRelease,
+          eventList[numEvents]);
+        numEvents++;
+      }
+      if (window->dials || window->buttonBox) {
+        DeviceStateNotify(__glutDials, __glutDeviceStateNotify,
+          eventList[numEvents]);
+        numEvents++;
+      }
+    }
+    if (__glutSpaceball) {
+      if (window->spaceMotion || window->spaceRotate) {
+        DeviceMotionNotify(__glutSpaceball, __glutDeviceMotionNotify,
+          eventList[numEvents]);
+        numEvents++;
+      }
+      if (window->spaceButton) {
+        DeviceButtonPress(__glutSpaceball, __glutDeviceButtonPress,
+          eventList[numEvents]);
+        numEvents++;
+        DeviceButtonPressGrab(__glutSpaceball, __glutDeviceButtonPressGrab,
+          eventList[numEvents]);
+        numEvents++;
+        DeviceButtonRelease(__glutSpaceball, __glutDeviceButtonRelease,
+          eventList[numEvents]);
+        numEvents++;
+      }
+      if (window->spaceMotion || window->spaceRotate || window->spaceButton) {
+        DeviceStateNotify(__glutSpaceball, __glutDeviceStateNotify,
+          eventList[numEvents]);
+        numEvents++;
+      }
+    }
+#if 0
+    if (window->children) {
+      GLUTwindow *child = window->children;
+
+      do {
+        XChangeDeviceDontPropagateList(__glutDisplay, child->win,
+          numEvents, eventList, AddToList);
+        child = child->siblings;
+      } while (child);
+    }
+#endif
+    XSelectExtensionEvent(__glutDisplay, window->win,
+      eventList, numEvents);
+    if (window->overlay) {
+      XSelectExtensionEvent(__glutDisplay, window->overlay->win,
+        eventList, numEvents);
+    }
+  } else {
+    /* X Input extension not supported; no chance for exotic
+       input devices. */
+  }
+#endif /* !_WIN32 */
+}
+
+/* CENTRY */
+int APIENTRY
+glutDeviceGet(GLenum param)
+{
+  probeDevices();
+  switch (param) {
+  case GLUT_HAS_KEYBOARD:
+  case GLUT_HAS_MOUSE:
+    /* Assume window system always has mouse and keyboard. */
+    return 1;
+  case GLUT_HAS_SPACEBALL:
+    return __glutSpaceball != NULL;
+  case GLUT_HAS_DIAL_AND_BUTTON_BOX:
+    return __glutDials != NULL;
+  case GLUT_HAS_TABLET:
+    return __glutTablet != NULL;
+  case GLUT_NUM_MOUSE_BUTTONS:
+    return __glutNumMouseButtons;
+  case GLUT_NUM_SPACEBALL_BUTTONS:
+    return __glutNumSpaceballButtons;
+  case GLUT_NUM_BUTTON_BOX_BUTTONS:
+    return __glutNumButtonBoxButtons;
+  case GLUT_NUM_DIALS:
+    return __glutNumDials;
+  case GLUT_NUM_TABLET_BUTTONS:
+    return __glutNumTabletButtons;
+  case GLUT_DEVICE_IGNORE_KEY_REPEAT:
+    return __glutCurrentWindow->ignoreKeyRepeat;
+#ifndef _WIN32
+  case GLUT_DEVICE_KEY_REPEAT:
+    {
+      XKeyboardState state;
+
+      XGetKeyboardControl(__glutDisplay, &state);
+      return state.global_auto_repeat;
+    }
+  case GLUT_JOYSTICK_POLL_RATE:
+    return 0;
+#else
+  case GLUT_DEVICE_KEY_REPEAT:
+    /* Win32 cannot globally disable key repeat. */
+    return GLUT_KEY_REPEAT_ON;
+  case GLUT_JOYSTICK_POLL_RATE:
+    return __glutCurrentWindow->joyPollInterval;
+#endif
+  case GLUT_HAS_JOYSTICK:
+    return __glutHasJoystick;
+  case GLUT_JOYSTICK_BUTTONS:
+    return __glutNumJoystickButtons;
+  case GLUT_JOYSTICK_AXES:
+    return __glutNumJoystickAxes;
+  default:
+    __glutWarning("invalid glutDeviceGet parameter: %d", param);
+    return -1;
+  }
+}
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_joy.c b/src/glut/glx/glut_joy.c
new file mode 100644
index 0000000000..a7db032f53
--- /dev/null
+++ b/src/glut/glx/glut_joy.c
@@ -0,0 +1,80 @@
+
+/* Copyright (c) Mark J. Kilgard, 1997, 1998. */
+
+/* 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. */
+
+#ifdef _WIN32
+#include <windows.h>
+#include <mmsystem.h>  /* Win32 Multimedia API header. */
+#endif
+
+#include "glutint.h"
+
+/* CENTRY */
+void APIENTRY
+glutJoystickFunc(GLUTjoystickCB joystickFunc, int pollInterval)
+{
+#ifdef _WIN32
+  if (joystickFunc && (pollInterval > 0)) {
+    if (__glutCurrentWindow->entryState == WM_SETFOCUS) {
+      MMRESULT result;
+
+      /* Capture joystick focus if current window has
+  	 focus now. */
+      result = joySetCapture(__glutCurrentWindow->win,
+        JOYSTICKID1, 0, TRUE);
+      if (result == JOYERR_NOERROR) {
+        (void) joySetThreshold(JOYSTICKID1, pollInterval);
+      }
+    }
+    __glutCurrentWindow->joyPollInterval = pollInterval;
+  } else {
+    /* Release joystick focus if current window has
+       focus now. */
+    if (__glutCurrentWindow->joystick
+      && (__glutCurrentWindow->joyPollInterval > 0)
+      && (__glutCurrentWindow->entryState == WM_SETFOCUS)) {
+      (void) joyReleaseCapture(JOYSTICKID1);
+    }
+    __glutCurrentWindow->joyPollInterval = 0;
+  }
+  __glutCurrentWindow->joystick = joystickFunc;
+#else
+  /* XXX No support currently for X11 joysticks. */
+#endif
+}
+
+void APIENTRY
+glutForceJoystickFunc(void)
+{
+#ifdef _WIN32
+  if (__glutCurrentWindow->joystick) {
+    JOYINFOEX jix;
+    MMRESULT res;
+    int x, y, z;
+
+    /* Poll the joystick. */
+    jix.dwSize = sizeof(jix);
+    jix.dwFlags = JOY_RETURNALL;
+    res = joyGetPosEx(JOYSTICKID1,&jix);
+    if (res == JOYERR_NOERROR) {
+
+      /* Convert to int for scaling. */
+      x = jix.dwXpos;
+      y = jix.dwYpos;
+      z = jix.dwZpos;
+
+#define SCALE(v)  ((int) ((v - 32767)/32.768))
+
+      __glutCurrentWindow->joystick(jix.dwButtons,
+        SCALE(x), SCALE(y), SCALE(z));
+    }
+  }
+#else
+  /* XXX No support currently for X11 joysticks. */
+#endif
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_key.c b/src/glut/glx/glut_key.c
new file mode 100644
index 0000000000..0927f66e56
--- /dev/null
+++ b/src/glut/glx/glut_key.c
@@ -0,0 +1,29 @@
+
+/* Copyright (c) Mark J. Kilgard, 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 "glutint.h"
+
+/* CENTRY */
+void APIENTRY
+glutKeyboardFunc(GLUTkeyboardCB keyboardFunc)
+{
+  __glutChangeWindowEventMask(KeyPressMask,
+    keyboardFunc != NULL || __glutCurrentWindow->special != NULL);
+  __glutCurrentWindow->keyboard = keyboardFunc;
+}
+
+void APIENTRY
+glutSpecialFunc(GLUTspecialCB specialFunc)
+{
+  __glutChangeWindowEventMask(KeyPressMask,
+    specialFunc != NULL || __glutCurrentWindow->keyboard != NULL);
+  __glutCurrentWindow->special = specialFunc;
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_keyctrl.c b/src/glut/glx/glut_keyctrl.c
new file mode 100644
index 0000000000..a4bc0210b7
--- /dev/null
+++ b/src/glut/glx/glut_keyctrl.c
@@ -0,0 +1,29 @@
+
+/* 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 "glutint.h"
+
+/* CENTRY */
+void APIENTRY
+glutIgnoreKeyRepeat(int ignore)
+{
+  __glutCurrentWindow->ignoreKeyRepeat = ignore;
+}
+
+void APIENTRY
+glutSetKeyRepeat(int repeatMode)
+{
+#if !defined(_WIN32)
+  XKeyboardControl values;
+
+  /* GLUT's repeatMode #define's match the Xlib API values. */
+  values.auto_repeat_mode = repeatMode;
+  XChangeKeyboardControl(__glutDisplay, KBAutoRepeatMode, &values);
+#endif
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_keyup.c b/src/glut/glx/glut_keyup.c
new file mode 100644
index 0000000000..1c6e78051d
--- /dev/null
+++ b/src/glut/glx/glut_keyup.c
@@ -0,0 +1,29 @@
+
+/* Copyright (c) Mark J. Kilgard, 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 "glutint.h"
+
+/* CENTRY */
+void APIENTRY
+glutKeyboardUpFunc(GLUTkeyboardCB keyboardUpFunc)
+{
+  __glutChangeWindowEventMask(KeyReleaseMask,
+    keyboardUpFunc != NULL || __glutCurrentWindow->specialUp != NULL);
+  __glutCurrentWindow->keyboardUp = keyboardUpFunc;
+}
+
+void APIENTRY
+glutSpecialUpFunc(GLUTspecialCB specialUpFunc)
+{
+  __glutChangeWindowEventMask(KeyReleaseMask,
+    specialUpFunc != NULL || __glutCurrentWindow->keyboardUp != NULL);
+  __glutCurrentWindow->specialUp = specialUpFunc;
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_menu.c b/src/glut/glx/glut_menu.c
new file mode 100644
index 0000000000..2af3482afc
--- /dev/null
+++ b/src/glut/glx/glut_menu.c
@@ -0,0 +1,1010 @@
+
+/* 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. */
+
+#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;
+  char *savedDisplayString;
+  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;
+  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
+         (thomas@xig.com). */
+      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);
+              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);
+            }
+            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);
+            }
+            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);
+            }
+            continue;
+          }
+          if (placeHolders) {
+            /* Now free the placeholder cells. */
+            XFreeColors(__glutDisplay, menuColormap,
+              placeHolders, numPlaceHolders, 0);
+            free(placeHolders);
+          }
+          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 APIENTRY 
+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 APIENTRY 
+glutGetMenu(void)
+{
+  if (__glutCurrentMenu) {
+    return __glutCurrentMenu->id + 1;
+  } else {
+    return 0;
+  }
+}
+
+void APIENTRY 
+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 APIENTRY 
+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 APIENTRY 
+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 APIENTRY 
+glutAttachMenu(int button)
+{
+  if (__glutMappedMenu) {
+    __glutMenuModificationError();
+  }
+  installMenuCallbacks();
+  if (__glutCurrentWindow->menu[button] < 1) {
+    __glutCurrentWindow->buttonUses++;
+  }
+  __glutChangeWindowEventMask(
+    ButtonPressMask | ButtonReleaseMask, True);
+  __glutCurrentWindow->menu[button] = __glutCurrentMenu->id + 1;
+}
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_menu2.c b/src/glut/glx/glut_menu2.c
new file mode 100644
index 0000000000..93119b540e
--- /dev/null
+++ b/src/glut/glx/glut_menu2.c
@@ -0,0 +1,185 @@
+
+/* 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. */
+
+/* glut_menu2.c implements the little used GLUT menu calls in
+   a distinct file from glut_menu.c for slim static linking. */
+
+/* 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. */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+
+#include <X11/Xlib.h>
+
+#include "glutint.h"
+#include "layerutil.h"
+
+/* CENTRY */
+/* DEPRICATED, use glutMenuStatusFunc instead. */
+void APIENTRY 
+glutMenuStateFunc(GLUTmenuStateCB menuStateFunc)
+{
+  __glutMenuStatusFunc = (GLUTmenuStatusCB) menuStateFunc;
+}
+
+void APIENTRY 
+glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc)
+{
+  __glutMenuStatusFunc = menuStatusFunc;
+}
+
+void APIENTRY 
+glutDestroyMenu(int menunum)
+{
+  GLUTmenu *menu = __glutGetMenuByNum(menunum);
+  GLUTmenuItem *item, *next;
+
+  if (__glutMappedMenu)
+    __glutMenuModificationError();
+  assert(menu->id == menunum - 1);
+  XDestroySubwindows(__glutDisplay, menu->win);
+  XDestroyWindow(__glutDisplay, menu->win);
+  __glutMenuList[menunum - 1] = NULL;
+  /* free all menu entries */
+  item = menu->list;
+  while (item) {
+    assert(item->menu == menu);
+    next = item->next;
+    free(item->label);
+    free(item);
+    item = next;
+  }
+  if (__glutCurrentMenu == menu) {
+    __glutCurrentMenu = NULL;
+  }
+  free(menu);
+}
+
+void APIENTRY 
+glutChangeToMenuEntry(int num, const char *label, int value)
+{
+  GLUTmenuItem *item;
+  int i;
+
+  if (__glutMappedMenu)
+    __glutMenuModificationError();
+  i = __glutCurrentMenu->num;
+  item = __glutCurrentMenu->list;
+  while (item) {
+    if (i == num) {
+      if (item->isTrigger) {
+        /* If changing a submenu trigger to a menu entry, we
+           need to account for submenus.  */
+        item->menu->submenus--;
+      }
+      free(item->label);
+      __glutSetMenuItem(item, label, value, False);
+      return;
+    }
+    i--;
+    item = item->next;
+  }
+  __glutWarning("Current menu has no %d item.", num);
+}
+
+void APIENTRY 
+glutChangeToSubMenu(int num, const char *label, int menu)
+{
+  GLUTmenuItem *item;
+  int i;
+
+  if (__glutMappedMenu)
+    __glutMenuModificationError();
+  i = __glutCurrentMenu->num;
+  item = __glutCurrentMenu->list;
+  while (item) {
+    if (i == num) {
+      if (!item->isTrigger) {
+        /* If changing a menu entry to as submenu trigger, we
+           need to account for submenus.  */
+        item->menu->submenus++;
+      }
+      free(item->label);
+      __glutSetMenuItem(item, label, /* base 0 */ menu - 1, True);
+      return;
+    }
+    i--;
+    item = item->next;
+  }
+  __glutWarning("Current menu has no %d item.", num);
+}
+
+void APIENTRY 
+glutRemoveMenuItem(int num)
+{
+  GLUTmenuItem *item, **prev, *remaining;
+  int pixwidth, i;
+
+  if (__glutMappedMenu)
+    __glutMenuModificationError();
+  i = __glutCurrentMenu->num;
+  prev = &__glutCurrentMenu->list;
+  item = __glutCurrentMenu->list;
+  /* If menu item is removed, the menu's pixwidth may need to
+     be recomputed. */
+  pixwidth = 1;
+  while (item) {
+    if (i == num) {
+      /* If this menu item's pixwidth is as wide as the menu's
+         pixwidth, removing this menu item will necessitate
+         shrinking the menu's pixwidth. */
+      if (item->pixwidth >= __glutCurrentMenu->pixwidth) {
+        /* Continue recalculating menu pixwidth, first skipping
+           the removed item. */
+        remaining = item->next;
+        while (remaining) {
+          if (remaining->pixwidth > pixwidth) {
+            pixwidth = remaining->pixwidth;
+          }
+          remaining = remaining->next;
+        }
+        __glutCurrentMenu->pixwidth = pixwidth;
+      }
+      __glutCurrentMenu->num--;
+      __glutCurrentMenu->managed = False;
+
+      /* Patch up menu's item list. */
+      *prev = item->next;
+
+      free(item->label);
+      free(item);
+      return;
+    }
+    if (item->pixwidth > pixwidth) {
+      pixwidth = item->pixwidth;
+    }
+    i--;
+    prev = &item->next;
+    item = item->next;
+  }
+  __glutWarning("Current menu has no %d item.", num);
+}
+
+void APIENTRY 
+glutDetachMenu(int button)
+{
+  if (__glutMappedMenu)
+    __glutMenuModificationError();
+  if (__glutCurrentWindow->menu[button] > 0) {
+    __glutCurrentWindow->buttonUses--;
+    __glutChangeWindowEventMask(ButtonPressMask | ButtonReleaseMask,
+      __glutCurrentWindow->buttonUses > 0);
+    __glutCurrentWindow->menu[button] = 0;
+  }
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_mesa.c b/src/glut/glx/glut_mesa.c
new file mode 100644
index 0000000000..7e202fa078
--- /dev/null
+++ b/src/glut/glx/glut_mesa.c
@@ -0,0 +1,57 @@
+
+/* Copyright (c) Mark J. Kilgard, 1996. */
+
+/* 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 <string.h>
+#include "glutint.h"
+
+int __glutMesaSwapHackSupport = 0;  /* Not supported until
+                                       proven otherwise. */
+
+/* Use the "Mesa swap hack" if reasonable if and only if
+   MESA_SWAP_HACK is set to something whose first character is
+   not "N" or "n" AND "Brian Paul" is the vendor string AND
+   "Mesa X11"* (or "Mesa" for backward compatibility)  is the
+   renderer string.
+
+   Anyone who modifies Mesa so that glXSwapBuffers does not
+   simply blit the previously rendered back buffer should
+   change either their vendor or renderer string to avoid
+   confusing GLUT. */
+
+void
+__glutDetermineMesaSwapHackSupport(void)
+{
+  static int doneAlready = 0;
+  char *env, *vendor, *renderer;
+
+  if (doneAlready)
+    return;
+  env = getenv("MESA_SWAP_HACK");
+  if (env) {
+    if ((env[0] != 'n') && (env[0] != 'N')) {
+      vendor = (char *) glGetString(GL_VENDOR);
+      renderer = (char *) glGetString(GL_RENDERER);
+
+      /* Old versions of X11 Mesa uses the renderer string
+         "Mesa"; Brian plans to start using "Mesa X11" to
+         distinguish the X version of Mesa from other flavor
+         such as Windows or 3Dfx. */
+
+#define MESA_X11 "Mesa X11"
+
+      /* XXX At some point in the future, eliminate the
+         backward compatibility for the old "Mesa" renderer
+         string. */
+
+      if (!strcmp(vendor, "Brian Paul") && (!strcmp(renderer, "Mesa") ||
+          !strncmp(renderer, MESA_X11, sizeof(MESA_X11) - 1)))
+        __glutMesaSwapHackSupport = 1;
+    }
+  }
+  doneAlready = 1;
+}
diff --git a/src/glut/glx/glut_modifier.c b/src/glut/glx/glut_modifier.c
new file mode 100644
index 0000000000..d2919fa89b
--- /dev/null
+++ b/src/glut/glx/glut_modifier.c
@@ -0,0 +1,31 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 "glutint.h"
+
+/* CENTRY */
+int APIENTRY
+glutGetModifiers(void)
+{
+  int modifiers;
+
+  if(__glutModifierMask == (unsigned int) ~0) {
+    __glutWarning(
+      "glutCurrentModifiers: do not call outside core input callback.");
+    return 0;
+  }
+  modifiers = 0;
+  if(__glutModifierMask & (ShiftMask|LockMask))
+    modifiers |= GLUT_ACTIVE_SHIFT;
+  if(__glutModifierMask & ControlMask)
+    modifiers |= GLUT_ACTIVE_CTRL;
+  if(__glutModifierMask & Mod1Mask)
+    modifiers |= GLUT_ACTIVE_ALT;
+  return modifiers;
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_mroman.c b/src/glut/glx/glut_mroman.c
new file mode 100644
index 0000000000..a29f043b4a
--- /dev/null
+++ b/src/glut/glx/glut_mroman.c
@@ -0,0 +1,2451 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#include "glutstroke.h"
+
+/* char: 33 '!' */
+
+static const CoordRec char33_stroke0[] = {
+    { 52.381, 100 },
+    { 52.381, 33.3333 },
+};
+
+static const CoordRec char33_stroke1[] = {
+    { 52.381, 9.5238 },
+    { 47.6191, 4.7619 },
+    { 52.381, 0 },
+    { 57.1429, 4.7619 },
+    { 52.381, 9.5238 },
+};
+
+static const StrokeRec char33[] = {
+   { 2, char33_stroke0 },
+   { 5, char33_stroke1 },
+};
+
+/* char: 34 '"' */
+
+static const CoordRec char34_stroke0[] = {
+    { 33.3334, 100 },
+    { 33.3334, 66.6667 },
+};
+
+static const CoordRec char34_stroke1[] = {
+    { 71.4286, 100 },
+    { 71.4286, 66.6667 },
+};
+
+static const StrokeRec char34[] = {
+   { 2, char34_stroke0 },
+   { 2, char34_stroke1 },
+};
+
+/* char: 35 '#' */
+
+static const CoordRec char35_stroke0[] = {
+    { 54.7619, 119.048 },
+    { 21.4286, -33.3333 },
+};
+
+static const CoordRec char35_stroke1[] = {
+    { 83.3334, 119.048 },
+    { 50, -33.3333 },
+};
+
+static const CoordRec char35_stroke2[] = {
+    { 21.4286, 57.1429 },
+    { 88.0952, 57.1429 },
+};
+
+static const CoordRec char35_stroke3[] = {
+    { 16.6667, 28.5714 },
+    { 83.3334, 28.5714 },
+};
+
+static const StrokeRec char35[] = {
+   { 2, char35_stroke0 },
+   { 2, char35_stroke1 },
+   { 2, char35_stroke2 },
+   { 2, char35_stroke3 },
+};
+
+/* char: 36 '$' */
+
+static const CoordRec char36_stroke0[] = {
+    { 42.8571, 119.048 },
+    { 42.8571, -19.0476 },
+};
+
+static const CoordRec char36_stroke1[] = {
+    { 61.9047, 119.048 },
+    { 61.9047, -19.0476 },
+};
+
+static const CoordRec char36_stroke2[] = {
+    { 85.7143, 85.7143 },
+    { 76.1905, 95.2381 },
+    { 61.9047, 100 },
+    { 42.8571, 100 },
+    { 28.5714, 95.2381 },
+    { 19.0476, 85.7143 },
+    { 19.0476, 76.1905 },
+    { 23.8095, 66.6667 },
+    { 28.5714, 61.9048 },
+    { 38.0952, 57.1429 },
+    { 66.6666, 47.619 },
+    { 76.1905, 42.8571 },
+    { 80.9524, 38.0952 },
+    { 85.7143, 28.5714 },
+    { 85.7143, 14.2857 },
+    { 76.1905, 4.7619 },
+    { 61.9047, 0 },
+    { 42.8571, 0 },
+    { 28.5714, 4.7619 },
+    { 19.0476, 14.2857 },
+};
+
+static const StrokeRec char36[] = {
+   { 2, char36_stroke0 },
+   { 2, char36_stroke1 },
+   { 20, char36_stroke2 },
+};
+
+/* char: 37 '%' */
+
+static const CoordRec char37_stroke0[] = {
+    { 95.2381, 100 },
+    { 9.5238, 0 },
+};
+
+static const CoordRec char37_stroke1[] = {
+    { 33.3333, 100 },
+    { 42.8571, 90.4762 },
+    { 42.8571, 80.9524 },
+    { 38.0952, 71.4286 },
+    { 28.5714, 66.6667 },
+    { 19.0476, 66.6667 },
+    { 9.5238, 76.1905 },
+    { 9.5238, 85.7143 },
+    { 14.2857, 95.2381 },
+    { 23.8095, 100 },
+    { 33.3333, 100 },
+    { 42.8571, 95.2381 },
+    { 57.1428, 90.4762 },
+    { 71.4286, 90.4762 },
+    { 85.7143, 95.2381 },
+    { 95.2381, 100 },
+};
+
+static const CoordRec char37_stroke2[] = {
+    { 76.1905, 33.3333 },
+    { 66.6667, 28.5714 },
+    { 61.9048, 19.0476 },
+    { 61.9048, 9.5238 },
+    { 71.4286, 0 },
+    { 80.9524, 0 },
+    { 90.4762, 4.7619 },
+    { 95.2381, 14.2857 },
+    { 95.2381, 23.8095 },
+    { 85.7143, 33.3333 },
+    { 76.1905, 33.3333 },
+};
+
+static const StrokeRec char37[] = {
+   { 2, char37_stroke0 },
+   { 16, char37_stroke1 },
+   { 11, char37_stroke2 },
+};
+
+/* char: 38 '&' */
+
+static const CoordRec char38_stroke0[] = {
+    { 100, 57.1429 },
+    { 100, 61.9048 },
+    { 95.2381, 66.6667 },
+    { 90.4762, 66.6667 },
+    { 85.7143, 61.9048 },
+    { 80.9524, 52.381 },
+    { 71.4286, 28.5714 },
+    { 61.9048, 14.2857 },
+    { 52.3809, 4.7619 },
+    { 42.8571, 0 },
+    { 23.8095, 0 },
+    { 14.2857, 4.7619 },
+    { 9.5238, 9.5238 },
+    { 4.7619, 19.0476 },
+    { 4.7619, 28.5714 },
+    { 9.5238, 38.0952 },
+    { 14.2857, 42.8571 },
+    { 47.619, 61.9048 },
+    { 52.3809, 66.6667 },
+    { 57.1429, 76.1905 },
+    { 57.1429, 85.7143 },
+    { 52.3809, 95.2381 },
+    { 42.8571, 100 },
+    { 33.3333, 95.2381 },
+    { 28.5714, 85.7143 },
+    { 28.5714, 76.1905 },
+    { 33.3333, 61.9048 },
+    { 42.8571, 47.619 },
+    { 66.6667, 14.2857 },
+    { 76.1905, 4.7619 },
+    { 85.7143, 0 },
+    { 95.2381, 0 },
+    { 100, 4.7619 },
+    { 100, 9.5238 },
+};
+
+static const StrokeRec char38[] = {
+   { 34, char38_stroke0 },
+};
+
+/* char: 39 ''' */
+
+static const CoordRec char39_stroke0[] = {
+    { 52.381, 100 },
+    { 52.381, 66.6667 },
+};
+
+static const StrokeRec char39[] = {
+   { 2, char39_stroke0 },
+};
+
+/* char: 40 '(' */
+
+static const CoordRec char40_stroke0[] = {
+    { 69.0476, 119.048 },
+    { 59.5238, 109.524 },
+    { 50, 95.2381 },
+    { 40.4762, 76.1905 },
+    { 35.7143, 52.381 },
+    { 35.7143, 33.3333 },
+    { 40.4762, 9.5238 },
+    { 50, -9.5238 },
+    { 59.5238, -23.8095 },
+    { 69.0476, -33.3333 },
+};
+
+static const StrokeRec char40[] = {
+   { 10, char40_stroke0 },
+};
+
+/* char: 41 ')' */
+
+static const CoordRec char41_stroke0[] = {
+    { 35.7143, 119.048 },
+    { 45.2381, 109.524 },
+    { 54.7619, 95.2381 },
+    { 64.2857, 76.1905 },
+    { 69.0476, 52.381 },
+    { 69.0476, 33.3333 },
+    { 64.2857, 9.5238 },
+    { 54.7619, -9.5238 },
+    { 45.2381, -23.8095 },
+    { 35.7143, -33.3333 },
+};
+
+static const StrokeRec char41[] = {
+   { 10, char41_stroke0 },
+};
+
+/* char: 42 '*' */
+
+static const CoordRec char42_stroke0[] = {
+    { 52.381, 71.4286 },
+    { 52.381, 14.2857 },
+};
+
+static const CoordRec char42_stroke1[] = {
+    { 28.5715, 57.1429 },
+    { 76.1905, 28.5714 },
+};
+
+static const CoordRec char42_stroke2[] = {
+    { 76.1905, 57.1429 },
+    { 28.5715, 28.5714 },
+};
+
+static const StrokeRec char42[] = {
+   { 2, char42_stroke0 },
+   { 2, char42_stroke1 },
+   { 2, char42_stroke2 },
+};
+
+/* char: 43 '+' */
+
+static const CoordRec char43_stroke0[] = {
+    { 52.3809, 85.7143 },
+    { 52.3809, 0 },
+};
+
+static const CoordRec char43_stroke1[] = {
+    { 9.5238, 42.8571 },
+    { 95.2381, 42.8571 },
+};
+
+static const StrokeRec char43[] = {
+   { 2, char43_stroke0 },
+   { 2, char43_stroke1 },
+};
+
+/* char: 44 ',' */
+
+static const CoordRec char44_stroke0[] = {
+    { 57.1429, 4.7619 },
+    { 52.381, 0 },
+    { 47.6191, 4.7619 },
+    { 52.381, 9.5238 },
+    { 57.1429, 4.7619 },
+    { 57.1429, -4.7619 },
+    { 52.381, -14.2857 },
+    { 47.6191, -19.0476 },
+};
+
+static const StrokeRec char44[] = {
+   { 8, char44_stroke0 },
+};
+
+/* char: 45 '-' */
+
+static const CoordRec char45_stroke0[] = {
+    { 9.5238, 42.8571 },
+    { 95.2381, 42.8571 },
+};
+
+static const StrokeRec char45[] = {
+   { 2, char45_stroke0 },
+};
+
+/* char: 46 '.' */
+
+static const CoordRec char46_stroke0[] = {
+    { 52.381, 9.5238 },
+    { 47.6191, 4.7619 },
+    { 52.381, 0 },
+    { 57.1429, 4.7619 },
+    { 52.381, 9.5238 },
+};
+
+static const StrokeRec char46[] = {
+   { 5, char46_stroke0 },
+};
+
+/* char: 47 '/' */
+
+static const CoordRec char47_stroke0[] = {
+    { 19.0476, -14.2857 },
+    { 85.7143, 100 },
+};
+
+static const StrokeRec char47[] = {
+   { 2, char47_stroke0 },
+};
+
+/* char: 48 '0' */
+
+static const CoordRec char48_stroke0[] = {
+    { 47.619, 100 },
+    { 33.3333, 95.2381 },
+    { 23.8095, 80.9524 },
+    { 19.0476, 57.1429 },
+    { 19.0476, 42.8571 },
+    { 23.8095, 19.0476 },
+    { 33.3333, 4.7619 },
+    { 47.619, 0 },
+    { 57.1428, 0 },
+    { 71.4286, 4.7619 },
+    { 80.9524, 19.0476 },
+    { 85.7143, 42.8571 },
+    { 85.7143, 57.1429 },
+    { 80.9524, 80.9524 },
+    { 71.4286, 95.2381 },
+    { 57.1428, 100 },
+    { 47.619, 100 },
+};
+
+static const StrokeRec char48[] = {
+   { 17, char48_stroke0 },
+};
+
+/* char: 49 '1' */
+
+static const CoordRec char49_stroke0[] = {
+    { 40.4762, 80.9524 },
+    { 50, 85.7143 },
+    { 64.2857, 100 },
+    { 64.2857, 0 },
+};
+
+static const StrokeRec char49[] = {
+   { 4, char49_stroke0 },
+};
+
+/* char: 50 '2' */
+
+static const CoordRec char50_stroke0[] = {
+    { 23.8095, 76.1905 },
+    { 23.8095, 80.9524 },
+    { 28.5714, 90.4762 },
+    { 33.3333, 95.2381 },
+    { 42.8571, 100 },
+    { 61.9047, 100 },
+    { 71.4286, 95.2381 },
+    { 76.1905, 90.4762 },
+    { 80.9524, 80.9524 },
+    { 80.9524, 71.4286 },
+    { 76.1905, 61.9048 },
+    { 66.6666, 47.619 },
+    { 19.0476, 0 },
+    { 85.7143, 0 },
+};
+
+static const StrokeRec char50[] = {
+   { 14, char50_stroke0 },
+};
+
+/* char: 51 '3' */
+
+static const CoordRec char51_stroke0[] = {
+    { 28.5714, 100 },
+    { 80.9524, 100 },
+    { 52.3809, 61.9048 },
+    { 66.6666, 61.9048 },
+    { 76.1905, 57.1429 },
+    { 80.9524, 52.381 },
+    { 85.7143, 38.0952 },
+    { 85.7143, 28.5714 },
+    { 80.9524, 14.2857 },
+    { 71.4286, 4.7619 },
+    { 57.1428, 0 },
+    { 42.8571, 0 },
+    { 28.5714, 4.7619 },
+    { 23.8095, 9.5238 },
+    { 19.0476, 19.0476 },
+};
+
+static const StrokeRec char51[] = {
+   { 15, char51_stroke0 },
+};
+
+/* char: 52 '4' */
+
+static const CoordRec char52_stroke0[] = {
+    { 64.2857, 100 },
+    { 16.6667, 33.3333 },
+    { 88.0952, 33.3333 },
+};
+
+static const CoordRec char52_stroke1[] = {
+    { 64.2857, 100 },
+    { 64.2857, 0 },
+};
+
+static const StrokeRec char52[] = {
+   { 3, char52_stroke0 },
+   { 2, char52_stroke1 },
+};
+
+/* char: 53 '5' */
+
+static const CoordRec char53_stroke0[] = {
+    { 76.1905, 100 },
+    { 28.5714, 100 },
+    { 23.8095, 57.1429 },
+    { 28.5714, 61.9048 },
+    { 42.8571, 66.6667 },
+    { 57.1428, 66.6667 },
+    { 71.4286, 61.9048 },
+    { 80.9524, 52.381 },
+    { 85.7143, 38.0952 },
+    { 85.7143, 28.5714 },
+    { 80.9524, 14.2857 },
+    { 71.4286, 4.7619 },
+    { 57.1428, 0 },
+    { 42.8571, 0 },
+    { 28.5714, 4.7619 },
+    { 23.8095, 9.5238 },
+    { 19.0476, 19.0476 },
+};
+
+static const StrokeRec char53[] = {
+   { 17, char53_stroke0 },
+};
+
+/* char: 54 '6' */
+
+static const CoordRec char54_stroke0[] = {
+    { 78.5714, 85.7143 },
+    { 73.8096, 95.2381 },
+    { 59.5238, 100 },
+    { 50, 100 },
+    { 35.7143, 95.2381 },
+    { 26.1905, 80.9524 },
+    { 21.4286, 57.1429 },
+    { 21.4286, 33.3333 },
+    { 26.1905, 14.2857 },
+    { 35.7143, 4.7619 },
+    { 50, 0 },
+    { 54.7619, 0 },
+    { 69.0476, 4.7619 },
+    { 78.5714, 14.2857 },
+    { 83.3334, 28.5714 },
+    { 83.3334, 33.3333 },
+    { 78.5714, 47.619 },
+    { 69.0476, 57.1429 },
+    { 54.7619, 61.9048 },
+    { 50, 61.9048 },
+    { 35.7143, 57.1429 },
+    { 26.1905, 47.619 },
+    { 21.4286, 33.3333 },
+};
+
+static const StrokeRec char54[] = {
+   { 23, char54_stroke0 },
+};
+
+/* char: 55 '7' */
+
+static const CoordRec char55_stroke0[] = {
+    { 85.7143, 100 },
+    { 38.0952, 0 },
+};
+
+static const CoordRec char55_stroke1[] = {
+    { 19.0476, 100 },
+    { 85.7143, 100 },
+};
+
+static const StrokeRec char55[] = {
+   { 2, char55_stroke0 },
+   { 2, char55_stroke1 },
+};
+
+/* char: 56 '8' */
+
+static const CoordRec char56_stroke0[] = {
+    { 42.8571, 100 },
+    { 28.5714, 95.2381 },
+    { 23.8095, 85.7143 },
+    { 23.8095, 76.1905 },
+    { 28.5714, 66.6667 },
+    { 38.0952, 61.9048 },
+    { 57.1428, 57.1429 },
+    { 71.4286, 52.381 },
+    { 80.9524, 42.8571 },
+    { 85.7143, 33.3333 },
+    { 85.7143, 19.0476 },
+    { 80.9524, 9.5238 },
+    { 76.1905, 4.7619 },
+    { 61.9047, 0 },
+    { 42.8571, 0 },
+    { 28.5714, 4.7619 },
+    { 23.8095, 9.5238 },
+    { 19.0476, 19.0476 },
+    { 19.0476, 33.3333 },
+    { 23.8095, 42.8571 },
+    { 33.3333, 52.381 },
+    { 47.619, 57.1429 },
+    { 66.6666, 61.9048 },
+    { 76.1905, 66.6667 },
+    { 80.9524, 76.1905 },
+    { 80.9524, 85.7143 },
+    { 76.1905, 95.2381 },
+    { 61.9047, 100 },
+    { 42.8571, 100 },
+};
+
+static const StrokeRec char56[] = {
+   { 29, char56_stroke0 },
+};
+
+/* char: 57 '9' */
+
+static const CoordRec char57_stroke0[] = {
+    { 83.3334, 66.6667 },
+    { 78.5714, 52.381 },
+    { 69.0476, 42.8571 },
+    { 54.7619, 38.0952 },
+    { 50, 38.0952 },
+    { 35.7143, 42.8571 },
+    { 26.1905, 52.381 },
+    { 21.4286, 66.6667 },
+    { 21.4286, 71.4286 },
+    { 26.1905, 85.7143 },
+    { 35.7143, 95.2381 },
+    { 50, 100 },
+    { 54.7619, 100 },
+    { 69.0476, 95.2381 },
+    { 78.5714, 85.7143 },
+    { 83.3334, 66.6667 },
+    { 83.3334, 42.8571 },
+    { 78.5714, 19.0476 },
+    { 69.0476, 4.7619 },
+    { 54.7619, 0 },
+    { 45.2381, 0 },
+    { 30.9524, 4.7619 },
+    { 26.1905, 14.2857 },
+};
+
+static const StrokeRec char57[] = {
+   { 23, char57_stroke0 },
+};
+
+/* char: 58 ':' */
+
+static const CoordRec char58_stroke0[] = {
+    { 52.381, 66.6667 },
+    { 47.6191, 61.9048 },
+    { 52.381, 57.1429 },
+    { 57.1429, 61.9048 },
+    { 52.381, 66.6667 },
+};
+
+static const CoordRec char58_stroke1[] = {
+    { 52.381, 9.5238 },
+    { 47.6191, 4.7619 },
+    { 52.381, 0 },
+    { 57.1429, 4.7619 },
+    { 52.381, 9.5238 },
+};
+
+static const StrokeRec char58[] = {
+   { 5, char58_stroke0 },
+   { 5, char58_stroke1 },
+};
+
+/* char: 59 ';' */
+
+static const CoordRec char59_stroke0[] = {
+    { 52.381, 66.6667 },
+    { 47.6191, 61.9048 },
+    { 52.381, 57.1429 },
+    { 57.1429, 61.9048 },
+    { 52.381, 66.6667 },
+};
+
+static const CoordRec char59_stroke1[] = {
+    { 57.1429, 4.7619 },
+    { 52.381, 0 },
+    { 47.6191, 4.7619 },
+    { 52.381, 9.5238 },
+    { 57.1429, 4.7619 },
+    { 57.1429, -4.7619 },
+    { 52.381, -14.2857 },
+    { 47.6191, -19.0476 },
+};
+
+static const StrokeRec char59[] = {
+   { 5, char59_stroke0 },
+   { 8, char59_stroke1 },
+};
+
+/* char: 60 '<' */
+
+static const CoordRec char60_stroke0[] = {
+    { 90.4762, 85.7143 },
+    { 14.2857, 42.8571 },
+    { 90.4762, 0 },
+};
+
+static const StrokeRec char60[] = {
+   { 3, char60_stroke0 },
+};
+
+/* char: 61 '=' */
+
+static const CoordRec char61_stroke0[] = {
+    { 9.5238, 57.1429 },
+    { 95.2381, 57.1429 },
+};
+
+static const CoordRec char61_stroke1[] = {
+    { 9.5238, 28.5714 },
+    { 95.2381, 28.5714 },
+};
+
+static const StrokeRec char61[] = {
+   { 2, char61_stroke0 },
+   { 2, char61_stroke1 },
+};
+
+/* char: 62 '>' */
+
+static const CoordRec char62_stroke0[] = {
+    { 14.2857, 85.7143 },
+    { 90.4762, 42.8571 },
+    { 14.2857, 0 },
+};
+
+static const StrokeRec char62[] = {
+   { 3, char62_stroke0 },
+};
+
+/* char: 63 '?' */
+
+static const CoordRec char63_stroke0[] = {
+    { 23.8095, 76.1905 },
+    { 23.8095, 80.9524 },
+    { 28.5714, 90.4762 },
+    { 33.3333, 95.2381 },
+    { 42.8571, 100 },
+    { 61.9047, 100 },
+    { 71.4285, 95.2381 },
+    { 76.1905, 90.4762 },
+    { 80.9524, 80.9524 },
+    { 80.9524, 71.4286 },
+    { 76.1905, 61.9048 },
+    { 71.4285, 57.1429 },
+    { 52.3809, 47.619 },
+    { 52.3809, 33.3333 },
+};
+
+static const CoordRec char63_stroke1[] = {
+    { 52.3809, 9.5238 },
+    { 47.619, 4.7619 },
+    { 52.3809, 0 },
+    { 57.1428, 4.7619 },
+    { 52.3809, 9.5238 },
+};
+
+static const StrokeRec char63[] = {
+   { 14, char63_stroke0 },
+   { 5, char63_stroke1 },
+};
+
+/* char: 64 '@' */
+
+static const CoordRec char64_stroke0[] = {
+    { 64.2857, 52.381 },
+    { 54.7619, 57.1429 },
+    { 45.2381, 57.1429 },
+    { 40.4762, 47.619 },
+    { 40.4762, 42.8571 },
+    { 45.2381, 33.3333 },
+    { 54.7619, 33.3333 },
+    { 64.2857, 38.0952 },
+};
+
+static const CoordRec char64_stroke1[] = {
+    { 64.2857, 57.1429 },
+    { 64.2857, 38.0952 },
+    { 69.0476, 33.3333 },
+    { 78.5714, 33.3333 },
+    { 83.3334, 42.8571 },
+    { 83.3334, 47.619 },
+    { 78.5714, 61.9048 },
+    { 69.0476, 71.4286 },
+    { 54.7619, 76.1905 },
+    { 50, 76.1905 },
+    { 35.7143, 71.4286 },
+    { 26.1905, 61.9048 },
+    { 21.4286, 47.619 },
+    { 21.4286, 42.8571 },
+    { 26.1905, 28.5714 },
+    { 35.7143, 19.0476 },
+    { 50, 14.2857 },
+    { 54.7619, 14.2857 },
+    { 69.0476, 19.0476 },
+};
+
+static const StrokeRec char64[] = {
+   { 8, char64_stroke0 },
+   { 19, char64_stroke1 },
+};
+
+/* char: 65 'A' */
+
+static const CoordRec char65_stroke0[] = {
+    { 52.3809, 100 },
+    { 14.2857, 0 },
+};
+
+static const CoordRec char65_stroke1[] = {
+    { 52.3809, 100 },
+    { 90.4762, 0 },
+};
+
+static const CoordRec char65_stroke2[] = {
+    { 28.5714, 33.3333 },
+    { 76.1905, 33.3333 },
+};
+
+static const StrokeRec char65[] = {
+   { 2, char65_stroke0 },
+   { 2, char65_stroke1 },
+   { 2, char65_stroke2 },
+};
+
+/* char: 66 'B' */
+
+static const CoordRec char66_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char66_stroke1[] = {
+    { 19.0476, 100 },
+    { 61.9047, 100 },
+    { 76.1905, 95.2381 },
+    { 80.9524, 90.4762 },
+    { 85.7143, 80.9524 },
+    { 85.7143, 71.4286 },
+    { 80.9524, 61.9048 },
+    { 76.1905, 57.1429 },
+    { 61.9047, 52.381 },
+};
+
+static const CoordRec char66_stroke2[] = {
+    { 19.0476, 52.381 },
+    { 61.9047, 52.381 },
+    { 76.1905, 47.619 },
+    { 80.9524, 42.8571 },
+    { 85.7143, 33.3333 },
+    { 85.7143, 19.0476 },
+    { 80.9524, 9.5238 },
+    { 76.1905, 4.7619 },
+    { 61.9047, 0 },
+    { 19.0476, 0 },
+};
+
+static const StrokeRec char66[] = {
+   { 2, char66_stroke0 },
+   { 9, char66_stroke1 },
+   { 10, char66_stroke2 },
+};
+
+/* char: 67 'C' */
+
+static const CoordRec char67_stroke0[] = {
+    { 88.0952, 76.1905 },
+    { 83.3334, 85.7143 },
+    { 73.8096, 95.2381 },
+    { 64.2857, 100 },
+    { 45.2381, 100 },
+    { 35.7143, 95.2381 },
+    { 26.1905, 85.7143 },
+    { 21.4286, 76.1905 },
+    { 16.6667, 61.9048 },
+    { 16.6667, 38.0952 },
+    { 21.4286, 23.8095 },
+    { 26.1905, 14.2857 },
+    { 35.7143, 4.7619 },
+    { 45.2381, 0 },
+    { 64.2857, 0 },
+    { 73.8096, 4.7619 },
+    { 83.3334, 14.2857 },
+    { 88.0952, 23.8095 },
+};
+
+static const StrokeRec char67[] = {
+   { 18, char67_stroke0 },
+};
+
+/* char: 68 'D' */
+
+static const CoordRec char68_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char68_stroke1[] = {
+    { 19.0476, 100 },
+    { 52.3809, 100 },
+    { 66.6666, 95.2381 },
+    { 76.1905, 85.7143 },
+    { 80.9524, 76.1905 },
+    { 85.7143, 61.9048 },
+    { 85.7143, 38.0952 },
+    { 80.9524, 23.8095 },
+    { 76.1905, 14.2857 },
+    { 66.6666, 4.7619 },
+    { 52.3809, 0 },
+    { 19.0476, 0 },
+};
+
+static const StrokeRec char68[] = {
+   { 2, char68_stroke0 },
+   { 12, char68_stroke1 },
+};
+
+/* char: 69 'E' */
+
+static const CoordRec char69_stroke0[] = {
+    { 21.4286, 100 },
+    { 21.4286, 0 },
+};
+
+static const CoordRec char69_stroke1[] = {
+    { 21.4286, 100 },
+    { 83.3334, 100 },
+};
+
+static const CoordRec char69_stroke2[] = {
+    { 21.4286, 52.381 },
+    { 59.5238, 52.381 },
+};
+
+static const CoordRec char69_stroke3[] = {
+    { 21.4286, 0 },
+    { 83.3334, 0 },
+};
+
+static const StrokeRec char69[] = {
+   { 2, char69_stroke0 },
+   { 2, char69_stroke1 },
+   { 2, char69_stroke2 },
+   { 2, char69_stroke3 },
+};
+
+/* char: 70 'F' */
+
+static const CoordRec char70_stroke0[] = {
+    { 21.4286, 100 },
+    { 21.4286, 0 },
+};
+
+static const CoordRec char70_stroke1[] = {
+    { 21.4286, 100 },
+    { 83.3334, 100 },
+};
+
+static const CoordRec char70_stroke2[] = {
+    { 21.4286, 52.381 },
+    { 59.5238, 52.381 },
+};
+
+static const StrokeRec char70[] = {
+   { 2, char70_stroke0 },
+   { 2, char70_stroke1 },
+   { 2, char70_stroke2 },
+};
+
+/* char: 71 'G' */
+
+static const CoordRec char71_stroke0[] = {
+    { 88.0952, 76.1905 },
+    { 83.3334, 85.7143 },
+    { 73.8096, 95.2381 },
+    { 64.2857, 100 },
+    { 45.2381, 100 },
+    { 35.7143, 95.2381 },
+    { 26.1905, 85.7143 },
+    { 21.4286, 76.1905 },
+    { 16.6667, 61.9048 },
+    { 16.6667, 38.0952 },
+    { 21.4286, 23.8095 },
+    { 26.1905, 14.2857 },
+    { 35.7143, 4.7619 },
+    { 45.2381, 0 },
+    { 64.2857, 0 },
+    { 73.8096, 4.7619 },
+    { 83.3334, 14.2857 },
+    { 88.0952, 23.8095 },
+    { 88.0952, 38.0952 },
+};
+
+static const CoordRec char71_stroke1[] = {
+    { 64.2857, 38.0952 },
+    { 88.0952, 38.0952 },
+};
+
+static const StrokeRec char71[] = {
+   { 19, char71_stroke0 },
+   { 2, char71_stroke1 },
+};
+
+/* char: 72 'H' */
+
+static const CoordRec char72_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char72_stroke1[] = {
+    { 85.7143, 100 },
+    { 85.7143, 0 },
+};
+
+static const CoordRec char72_stroke2[] = {
+    { 19.0476, 52.381 },
+    { 85.7143, 52.381 },
+};
+
+static const StrokeRec char72[] = {
+   { 2, char72_stroke0 },
+   { 2, char72_stroke1 },
+   { 2, char72_stroke2 },
+};
+
+/* char: 73 'I' */
+
+static const CoordRec char73_stroke0[] = {
+    { 52.381, 100 },
+    { 52.381, 0 },
+};
+
+static const StrokeRec char73[] = {
+   { 2, char73_stroke0 },
+};
+
+/* char: 74 'J' */
+
+static const CoordRec char74_stroke0[] = {
+    { 76.1905, 100 },
+    { 76.1905, 23.8095 },
+    { 71.4286, 9.5238 },
+    { 66.6667, 4.7619 },
+    { 57.1429, 0 },
+    { 47.6191, 0 },
+    { 38.0953, 4.7619 },
+    { 33.3334, 9.5238 },
+    { 28.5715, 23.8095 },
+    { 28.5715, 33.3333 },
+};
+
+static const StrokeRec char74[] = {
+   { 10, char74_stroke0 },
+};
+
+/* char: 75 'K' */
+
+static const CoordRec char75_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char75_stroke1[] = {
+    { 85.7143, 100 },
+    { 19.0476, 33.3333 },
+};
+
+static const CoordRec char75_stroke2[] = {
+    { 42.8571, 57.1429 },
+    { 85.7143, 0 },
+};
+
+static const StrokeRec char75[] = {
+   { 2, char75_stroke0 },
+   { 2, char75_stroke1 },
+   { 2, char75_stroke2 },
+};
+
+/* char: 76 'L' */
+
+static const CoordRec char76_stroke0[] = {
+    { 23.8095, 100 },
+    { 23.8095, 0 },
+};
+
+static const CoordRec char76_stroke1[] = {
+    { 23.8095, 0 },
+    { 80.9524, 0 },
+};
+
+static const StrokeRec char76[] = {
+   { 2, char76_stroke0 },
+   { 2, char76_stroke1 },
+};
+
+/* char: 77 'M' */
+
+static const CoordRec char77_stroke0[] = {
+    { 14.2857, 100 },
+    { 14.2857, 0 },
+};
+
+static const CoordRec char77_stroke1[] = {
+    { 14.2857, 100 },
+    { 52.3809, 0 },
+};
+
+static const CoordRec char77_stroke2[] = {
+    { 90.4762, 100 },
+    { 52.3809, 0 },
+};
+
+static const CoordRec char77_stroke3[] = {
+    { 90.4762, 100 },
+    { 90.4762, 0 },
+};
+
+static const StrokeRec char77[] = {
+   { 2, char77_stroke0 },
+   { 2, char77_stroke1 },
+   { 2, char77_stroke2 },
+   { 2, char77_stroke3 },
+};
+
+/* char: 78 'N' */
+
+static const CoordRec char78_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char78_stroke1[] = {
+    { 19.0476, 100 },
+    { 85.7143, 0 },
+};
+
+static const CoordRec char78_stroke2[] = {
+    { 85.7143, 100 },
+    { 85.7143, 0 },
+};
+
+static const StrokeRec char78[] = {
+   { 2, char78_stroke0 },
+   { 2, char78_stroke1 },
+   { 2, char78_stroke2 },
+};
+
+/* char: 79 'O' */
+
+static const CoordRec char79_stroke0[] = {
+    { 42.8571, 100 },
+    { 33.3333, 95.2381 },
+    { 23.8095, 85.7143 },
+    { 19.0476, 76.1905 },
+    { 14.2857, 61.9048 },
+    { 14.2857, 38.0952 },
+    { 19.0476, 23.8095 },
+    { 23.8095, 14.2857 },
+    { 33.3333, 4.7619 },
+    { 42.8571, 0 },
+    { 61.9047, 0 },
+    { 71.4286, 4.7619 },
+    { 80.9524, 14.2857 },
+    { 85.7143, 23.8095 },
+    { 90.4762, 38.0952 },
+    { 90.4762, 61.9048 },
+    { 85.7143, 76.1905 },
+    { 80.9524, 85.7143 },
+    { 71.4286, 95.2381 },
+    { 61.9047, 100 },
+    { 42.8571, 100 },
+};
+
+static const StrokeRec char79[] = {
+   { 21, char79_stroke0 },
+};
+
+/* char: 80 'P' */
+
+static const CoordRec char80_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char80_stroke1[] = {
+    { 19.0476, 100 },
+    { 61.9047, 100 },
+    { 76.1905, 95.2381 },
+    { 80.9524, 90.4762 },
+    { 85.7143, 80.9524 },
+    { 85.7143, 66.6667 },
+    { 80.9524, 57.1429 },
+    { 76.1905, 52.381 },
+    { 61.9047, 47.619 },
+    { 19.0476, 47.619 },
+};
+
+static const StrokeRec char80[] = {
+   { 2, char80_stroke0 },
+   { 10, char80_stroke1 },
+};
+
+/* char: 81 'Q' */
+
+static const CoordRec char81_stroke0[] = {
+    { 42.8571, 100 },
+    { 33.3333, 95.2381 },
+    { 23.8095, 85.7143 },
+    { 19.0476, 76.1905 },
+    { 14.2857, 61.9048 },
+    { 14.2857, 38.0952 },
+    { 19.0476, 23.8095 },
+    { 23.8095, 14.2857 },
+    { 33.3333, 4.7619 },
+    { 42.8571, 0 },
+    { 61.9047, 0 },
+    { 71.4286, 4.7619 },
+    { 80.9524, 14.2857 },
+    { 85.7143, 23.8095 },
+    { 90.4762, 38.0952 },
+    { 90.4762, 61.9048 },
+    { 85.7143, 76.1905 },
+    { 80.9524, 85.7143 },
+    { 71.4286, 95.2381 },
+    { 61.9047, 100 },
+    { 42.8571, 100 },
+};
+
+static const CoordRec char81_stroke1[] = {
+    { 57.1428, 19.0476 },
+    { 85.7143, -9.5238 },
+};
+
+static const StrokeRec char81[] = {
+   { 21, char81_stroke0 },
+   { 2, char81_stroke1 },
+};
+
+/* char: 82 'R' */
+
+static const CoordRec char82_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char82_stroke1[] = {
+    { 19.0476, 100 },
+    { 61.9047, 100 },
+    { 76.1905, 95.2381 },
+    { 80.9524, 90.4762 },
+    { 85.7143, 80.9524 },
+    { 85.7143, 71.4286 },
+    { 80.9524, 61.9048 },
+    { 76.1905, 57.1429 },
+    { 61.9047, 52.381 },
+    { 19.0476, 52.381 },
+};
+
+static const CoordRec char82_stroke2[] = {
+    { 52.3809, 52.381 },
+    { 85.7143, 0 },
+};
+
+static const StrokeRec char82[] = {
+   { 2, char82_stroke0 },
+   { 10, char82_stroke1 },
+   { 2, char82_stroke2 },
+};
+
+/* char: 83 'S' */
+
+static const CoordRec char83_stroke0[] = {
+    { 85.7143, 85.7143 },
+    { 76.1905, 95.2381 },
+    { 61.9047, 100 },
+    { 42.8571, 100 },
+    { 28.5714, 95.2381 },
+    { 19.0476, 85.7143 },
+    { 19.0476, 76.1905 },
+    { 23.8095, 66.6667 },
+    { 28.5714, 61.9048 },
+    { 38.0952, 57.1429 },
+    { 66.6666, 47.619 },
+    { 76.1905, 42.8571 },
+    { 80.9524, 38.0952 },
+    { 85.7143, 28.5714 },
+    { 85.7143, 14.2857 },
+    { 76.1905, 4.7619 },
+    { 61.9047, 0 },
+    { 42.8571, 0 },
+    { 28.5714, 4.7619 },
+    { 19.0476, 14.2857 },
+};
+
+static const StrokeRec char83[] = {
+   { 20, char83_stroke0 },
+};
+
+/* char: 84 'T' */
+
+static const CoordRec char84_stroke0[] = {
+    { 52.3809, 100 },
+    { 52.3809, 0 },
+};
+
+static const CoordRec char84_stroke1[] = {
+    { 19.0476, 100 },
+    { 85.7143, 100 },
+};
+
+static const StrokeRec char84[] = {
+   { 2, char84_stroke0 },
+   { 2, char84_stroke1 },
+};
+
+/* char: 85 'U' */
+
+static const CoordRec char85_stroke0[] = {
+    { 19.0476, 100 },
+    { 19.0476, 28.5714 },
+    { 23.8095, 14.2857 },
+    { 33.3333, 4.7619 },
+    { 47.619, 0 },
+    { 57.1428, 0 },
+    { 71.4286, 4.7619 },
+    { 80.9524, 14.2857 },
+    { 85.7143, 28.5714 },
+    { 85.7143, 100 },
+};
+
+static const StrokeRec char85[] = {
+   { 10, char85_stroke0 },
+};
+
+/* char: 86 'V' */
+
+static const CoordRec char86_stroke0[] = {
+    { 14.2857, 100 },
+    { 52.3809, 0 },
+};
+
+static const CoordRec char86_stroke1[] = {
+    { 90.4762, 100 },
+    { 52.3809, 0 },
+};
+
+static const StrokeRec char86[] = {
+   { 2, char86_stroke0 },
+   { 2, char86_stroke1 },
+};
+
+/* char: 87 'W' */
+
+static const CoordRec char87_stroke0[] = {
+    { 4.7619, 100 },
+    { 28.5714, 0 },
+};
+
+static const CoordRec char87_stroke1[] = {
+    { 52.3809, 100 },
+    { 28.5714, 0 },
+};
+
+static const CoordRec char87_stroke2[] = {
+    { 52.3809, 100 },
+    { 76.1905, 0 },
+};
+
+static const CoordRec char87_stroke3[] = {
+    { 100, 100 },
+    { 76.1905, 0 },
+};
+
+static const StrokeRec char87[] = {
+   { 2, char87_stroke0 },
+   { 2, char87_stroke1 },
+   { 2, char87_stroke2 },
+   { 2, char87_stroke3 },
+};
+
+/* char: 88 'X' */
+
+static const CoordRec char88_stroke0[] = {
+    { 19.0476, 100 },
+    { 85.7143, 0 },
+};
+
+static const CoordRec char88_stroke1[] = {
+    { 85.7143, 100 },
+    { 19.0476, 0 },
+};
+
+static const StrokeRec char88[] = {
+   { 2, char88_stroke0 },
+   { 2, char88_stroke1 },
+};
+
+/* char: 89 'Y' */
+
+static const CoordRec char89_stroke0[] = {
+    { 14.2857, 100 },
+    { 52.3809, 52.381 },
+    { 52.3809, 0 },
+};
+
+static const CoordRec char89_stroke1[] = {
+    { 90.4762, 100 },
+    { 52.3809, 52.381 },
+};
+
+static const StrokeRec char89[] = {
+   { 3, char89_stroke0 },
+   { 2, char89_stroke1 },
+};
+
+/* char: 90 'Z' */
+
+static const CoordRec char90_stroke0[] = {
+    { 85.7143, 100 },
+    { 19.0476, 0 },
+};
+
+static const CoordRec char90_stroke1[] = {
+    { 19.0476, 100 },
+    { 85.7143, 100 },
+};
+
+static const CoordRec char90_stroke2[] = {
+    { 19.0476, 0 },
+    { 85.7143, 0 },
+};
+
+static const StrokeRec char90[] = {
+   { 2, char90_stroke0 },
+   { 2, char90_stroke1 },
+   { 2, char90_stroke2 },
+};
+
+/* char: 91 '[' */
+
+static const CoordRec char91_stroke0[] = {
+    { 35.7143, 119.048 },
+    { 35.7143, -33.3333 },
+};
+
+static const CoordRec char91_stroke1[] = {
+    { 40.4762, 119.048 },
+    { 40.4762, -33.3333 },
+};
+
+static const CoordRec char91_stroke2[] = {
+    { 35.7143, 119.048 },
+    { 69.0476, 119.048 },
+};
+
+static const CoordRec char91_stroke3[] = {
+    { 35.7143, -33.3333 },
+    { 69.0476, -33.3333 },
+};
+
+static const StrokeRec char91[] = {
+   { 2, char91_stroke0 },
+   { 2, char91_stroke1 },
+   { 2, char91_stroke2 },
+   { 2, char91_stroke3 },
+};
+
+/* char: 92 '\' */
+
+static const CoordRec char92_stroke0[] = {
+    { 19.0476, 100 },
+    { 85.7143, -14.2857 },
+};
+
+static const StrokeRec char92[] = {
+   { 2, char92_stroke0 },
+};
+
+/* char: 93 ']' */
+
+static const CoordRec char93_stroke0[] = {
+    { 64.2857, 119.048 },
+    { 64.2857, -33.3333 },
+};
+
+static const CoordRec char93_stroke1[] = {
+    { 69.0476, 119.048 },
+    { 69.0476, -33.3333 },
+};
+
+static const CoordRec char93_stroke2[] = {
+    { 35.7143, 119.048 },
+    { 69.0476, 119.048 },
+};
+
+static const CoordRec char93_stroke3[] = {
+    { 35.7143, -33.3333 },
+    { 69.0476, -33.3333 },
+};
+
+static const StrokeRec char93[] = {
+   { 2, char93_stroke0 },
+   { 2, char93_stroke1 },
+   { 2, char93_stroke2 },
+   { 2, char93_stroke3 },
+};
+
+/* char: 94 '^' */
+
+static const CoordRec char94_stroke0[] = {
+    { 52.3809, 109.524 },
+    { 14.2857, 42.8571 },
+};
+
+static const CoordRec char94_stroke1[] = {
+    { 52.3809, 109.524 },
+    { 90.4762, 42.8571 },
+};
+
+static const StrokeRec char94[] = {
+   { 2, char94_stroke0 },
+   { 2, char94_stroke1 },
+};
+
+/* char: 95 '_' */
+
+static const CoordRec char95_stroke0[] = {
+    { 0, -33.3333 },
+    { 104.762, -33.3333 },
+    { 104.762, -28.5714 },
+    { 0, -28.5714 },
+    { 0, -33.3333 },
+};
+
+static const StrokeRec char95[] = {
+   { 5, char95_stroke0 },
+};
+
+/* char: 96 '`' */
+
+static const CoordRec char96_stroke0[] = {
+    { 42.8572, 100 },
+    { 66.6667, 71.4286 },
+};
+
+static const CoordRec char96_stroke1[] = {
+    { 42.8572, 100 },
+    { 38.0953, 95.2381 },
+    { 66.6667, 71.4286 },
+};
+
+static const StrokeRec char96[] = {
+   { 2, char96_stroke0 },
+   { 3, char96_stroke1 },
+};
+
+/* char: 97 'a' */
+
+static const CoordRec char97_stroke0[] = {
+    { 80.9524, 66.6667 },
+    { 80.9524, 0 },
+};
+
+static const CoordRec char97_stroke1[] = {
+    { 80.9524, 52.381 },
+    { 71.4285, 61.9048 },
+    { 61.9047, 66.6667 },
+    { 47.619, 66.6667 },
+    { 38.0952, 61.9048 },
+    { 28.5714, 52.381 },
+    { 23.8095, 38.0952 },
+    { 23.8095, 28.5714 },
+    { 28.5714, 14.2857 },
+    { 38.0952, 4.7619 },
+    { 47.619, 0 },
+    { 61.9047, 0 },
+    { 71.4285, 4.7619 },
+    { 80.9524, 14.2857 },
+};
+
+static const StrokeRec char97[] = {
+   { 2, char97_stroke0 },
+   { 14, char97_stroke1 },
+};
+
+/* char: 98 'b' */
+
+static const CoordRec char98_stroke0[] = {
+    { 23.8095, 100 },
+    { 23.8095, 0 },
+};
+
+static const CoordRec char98_stroke1[] = {
+    { 23.8095, 52.381 },
+    { 33.3333, 61.9048 },
+    { 42.8571, 66.6667 },
+    { 57.1428, 66.6667 },
+    { 66.6666, 61.9048 },
+    { 76.1905, 52.381 },
+    { 80.9524, 38.0952 },
+    { 80.9524, 28.5714 },
+    { 76.1905, 14.2857 },
+    { 66.6666, 4.7619 },
+    { 57.1428, 0 },
+    { 42.8571, 0 },
+    { 33.3333, 4.7619 },
+    { 23.8095, 14.2857 },
+};
+
+static const StrokeRec char98[] = {
+   { 2, char98_stroke0 },
+   { 14, char98_stroke1 },
+};
+
+/* char: 99 'c' */
+
+static const CoordRec char99_stroke0[] = {
+    { 80.9524, 52.381 },
+    { 71.4285, 61.9048 },
+    { 61.9047, 66.6667 },
+    { 47.619, 66.6667 },
+    { 38.0952, 61.9048 },
+    { 28.5714, 52.381 },
+    { 23.8095, 38.0952 },
+    { 23.8095, 28.5714 },
+    { 28.5714, 14.2857 },
+    { 38.0952, 4.7619 },
+    { 47.619, 0 },
+    { 61.9047, 0 },
+    { 71.4285, 4.7619 },
+    { 80.9524, 14.2857 },
+};
+
+static const StrokeRec char99[] = {
+   { 14, char99_stroke0 },
+};
+
+/* char: 100 'd' */
+
+static const CoordRec char100_stroke0[] = {
+    { 80.9524, 100 },
+    { 80.9524, 0 },
+};
+
+static const CoordRec char100_stroke1[] = {
+    { 80.9524, 52.381 },
+    { 71.4285, 61.9048 },
+    { 61.9047, 66.6667 },
+    { 47.619, 66.6667 },
+    { 38.0952, 61.9048 },
+    { 28.5714, 52.381 },
+    { 23.8095, 38.0952 },
+    { 23.8095, 28.5714 },
+    { 28.5714, 14.2857 },
+    { 38.0952, 4.7619 },
+    { 47.619, 0 },
+    { 61.9047, 0 },
+    { 71.4285, 4.7619 },
+    { 80.9524, 14.2857 },
+};
+
+static const StrokeRec char100[] = {
+   { 2, char100_stroke0 },
+   { 14, char100_stroke1 },
+};
+
+/* char: 101 'e' */
+
+static const CoordRec char101_stroke0[] = {
+    { 23.8095, 38.0952 },
+    { 80.9524, 38.0952 },
+    { 80.9524, 47.619 },
+    { 76.1905, 57.1429 },
+    { 71.4285, 61.9048 },
+    { 61.9047, 66.6667 },
+    { 47.619, 66.6667 },
+    { 38.0952, 61.9048 },
+    { 28.5714, 52.381 },
+    { 23.8095, 38.0952 },
+    { 23.8095, 28.5714 },
+    { 28.5714, 14.2857 },
+    { 38.0952, 4.7619 },
+    { 47.619, 0 },
+    { 61.9047, 0 },
+    { 71.4285, 4.7619 },
+    { 80.9524, 14.2857 },
+};
+
+static const StrokeRec char101[] = {
+   { 17, char101_stroke0 },
+};
+
+/* char: 102 'f' */
+
+static const CoordRec char102_stroke0[] = {
+    { 71.4286, 100 },
+    { 61.9048, 100 },
+    { 52.381, 95.2381 },
+    { 47.6191, 80.9524 },
+    { 47.6191, 0 },
+};
+
+static const CoordRec char102_stroke1[] = {
+    { 33.3334, 66.6667 },
+    { 66.6667, 66.6667 },
+};
+
+static const StrokeRec char102[] = {
+   { 5, char102_stroke0 },
+   { 2, char102_stroke1 },
+};
+
+/* char: 103 'g' */
+
+static const CoordRec char103_stroke0[] = {
+    { 80.9524, 66.6667 },
+    { 80.9524, -9.5238 },
+    { 76.1905, -23.8095 },
+    { 71.4285, -28.5714 },
+    { 61.9047, -33.3333 },
+    { 47.619, -33.3333 },
+    { 38.0952, -28.5714 },
+};
+
+static const CoordRec char103_stroke1[] = {
+    { 80.9524, 52.381 },
+    { 71.4285, 61.9048 },
+    { 61.9047, 66.6667 },
+    { 47.619, 66.6667 },
+    { 38.0952, 61.9048 },
+    { 28.5714, 52.381 },
+    { 23.8095, 38.0952 },
+    { 23.8095, 28.5714 },
+    { 28.5714, 14.2857 },
+    { 38.0952, 4.7619 },
+    { 47.619, 0 },
+    { 61.9047, 0 },
+    { 71.4285, 4.7619 },
+    { 80.9524, 14.2857 },
+};
+
+static const StrokeRec char103[] = {
+   { 7, char103_stroke0 },
+   { 14, char103_stroke1 },
+};
+
+/* char: 104 'h' */
+
+static const CoordRec char104_stroke0[] = {
+    { 26.1905, 100 },
+    { 26.1905, 0 },
+};
+
+static const CoordRec char104_stroke1[] = {
+    { 26.1905, 47.619 },
+    { 40.4762, 61.9048 },
+    { 50, 66.6667 },
+    { 64.2857, 66.6667 },
+    { 73.8095, 61.9048 },
+    { 78.5715, 47.619 },
+    { 78.5715, 0 },
+};
+
+static const StrokeRec char104[] = {
+   { 2, char104_stroke0 },
+   { 7, char104_stroke1 },
+};
+
+/* char: 105 'i' */
+
+static const CoordRec char105_stroke0[] = {
+    { 47.6191, 100 },
+    { 52.381, 95.2381 },
+    { 57.1429, 100 },
+    { 52.381, 104.762 },
+    { 47.6191, 100 },
+};
+
+static const CoordRec char105_stroke1[] = {
+    { 52.381, 66.6667 },
+    { 52.381, 0 },
+};
+
+static const StrokeRec char105[] = {
+   { 5, char105_stroke0 },
+   { 2, char105_stroke1 },
+};
+
+/* char: 106 'j' */
+
+static const CoordRec char106_stroke0[] = {
+    { 57.1429, 100 },
+    { 61.9048, 95.2381 },
+    { 66.6667, 100 },
+    { 61.9048, 104.762 },
+    { 57.1429, 100 },
+};
+
+static const CoordRec char106_stroke1[] = {
+    { 61.9048, 66.6667 },
+    { 61.9048, -14.2857 },
+    { 57.1429, -28.5714 },
+    { 47.6191, -33.3333 },
+    { 38.0953, -33.3333 },
+};
+
+static const StrokeRec char106[] = {
+   { 5, char106_stroke0 },
+   { 5, char106_stroke1 },
+};
+
+/* char: 107 'k' */
+
+static const CoordRec char107_stroke0[] = {
+    { 26.1905, 100 },
+    { 26.1905, 0 },
+};
+
+static const CoordRec char107_stroke1[] = {
+    { 73.8095, 66.6667 },
+    { 26.1905, 19.0476 },
+};
+
+static const CoordRec char107_stroke2[] = {
+    { 45.2381, 38.0952 },
+    { 78.5715, 0 },
+};
+
+static const StrokeRec char107[] = {
+   { 2, char107_stroke0 },
+   { 2, char107_stroke1 },
+   { 2, char107_stroke2 },
+};
+
+/* char: 108 'l' */
+
+static const CoordRec char108_stroke0[] = {
+    { 52.381, 100 },
+    { 52.381, 0 },
+};
+
+static const StrokeRec char108[] = {
+   { 2, char108_stroke0 },
+};
+
+/* char: 109 'm' */
+
+static const CoordRec char109_stroke0[] = {
+    { 0, 66.6667 },
+    { 0, 0 },
+};
+
+static const CoordRec char109_stroke1[] = {
+    { 0, 47.619 },
+    { 14.2857, 61.9048 },
+    { 23.8095, 66.6667 },
+    { 38.0952, 66.6667 },
+    { 47.619, 61.9048 },
+    { 52.381, 47.619 },
+    { 52.381, 0 },
+};
+
+static const CoordRec char109_stroke2[] = {
+    { 52.381, 47.619 },
+    { 66.6667, 61.9048 },
+    { 76.1905, 66.6667 },
+    { 90.4762, 66.6667 },
+    { 100, 61.9048 },
+    { 104.762, 47.619 },
+    { 104.762, 0 },
+};
+
+static const StrokeRec char109[] = {
+   { 2, char109_stroke0 },
+   { 7, char109_stroke1 },
+   { 7, char109_stroke2 },
+};
+
+/* char: 110 'n' */
+
+static const CoordRec char110_stroke0[] = {
+    { 26.1905, 66.6667 },
+    { 26.1905, 0 },
+};
+
+static const CoordRec char110_stroke1[] = {
+    { 26.1905, 47.619 },
+    { 40.4762, 61.9048 },
+    { 50, 66.6667 },
+    { 64.2857, 66.6667 },
+    { 73.8095, 61.9048 },
+    { 78.5715, 47.619 },
+    { 78.5715, 0 },
+};
+
+static const StrokeRec char110[] = {
+   { 2, char110_stroke0 },
+   { 7, char110_stroke1 },
+};
+
+/* char: 111 'o' */
+
+static const CoordRec char111_stroke0[] = {
+    { 45.2381, 66.6667 },
+    { 35.7143, 61.9048 },
+    { 26.1905, 52.381 },
+    { 21.4286, 38.0952 },
+    { 21.4286, 28.5714 },
+    { 26.1905, 14.2857 },
+    { 35.7143, 4.7619 },
+    { 45.2381, 0 },
+    { 59.5238, 0 },
+    { 69.0476, 4.7619 },
+    { 78.5714, 14.2857 },
+    { 83.3334, 28.5714 },
+    { 83.3334, 38.0952 },
+    { 78.5714, 52.381 },
+    { 69.0476, 61.9048 },
+    { 59.5238, 66.6667 },
+    { 45.2381, 66.6667 },
+};
+
+static const StrokeRec char111[] = {
+   { 17, char111_stroke0 },
+};
+
+/* char: 112 'p' */
+
+static const CoordRec char112_stroke0[] = {
+    { 23.8095, 66.6667 },
+    { 23.8095, -33.3333 },
+};
+
+static const CoordRec char112_stroke1[] = {
+    { 23.8095, 52.381 },
+    { 33.3333, 61.9048 },
+    { 42.8571, 66.6667 },
+    { 57.1428, 66.6667 },
+    { 66.6666, 61.9048 },
+    { 76.1905, 52.381 },
+    { 80.9524, 38.0952 },
+    { 80.9524, 28.5714 },
+    { 76.1905, 14.2857 },
+    { 66.6666, 4.7619 },
+    { 57.1428, 0 },
+    { 42.8571, 0 },
+    { 33.3333, 4.7619 },
+    { 23.8095, 14.2857 },
+};
+
+static const StrokeRec char112[] = {
+   { 2, char112_stroke0 },
+   { 14, char112_stroke1 },
+};
+
+/* char: 113 'q' */
+
+static const CoordRec char113_stroke0[] = {
+    { 80.9524, 66.6667 },
+    { 80.9524, -33.3333 },
+};
+
+static const CoordRec char113_stroke1[] = {
+    { 80.9524, 52.381 },
+    { 71.4285, 61.9048 },
+    { 61.9047, 66.6667 },
+    { 47.619, 66.6667 },
+    { 38.0952, 61.9048 },
+    { 28.5714, 52.381 },
+    { 23.8095, 38.0952 },
+    { 23.8095, 28.5714 },
+    { 28.5714, 14.2857 },
+    { 38.0952, 4.7619 },
+    { 47.619, 0 },
+    { 61.9047, 0 },
+    { 71.4285, 4.7619 },
+    { 80.9524, 14.2857 },
+};
+
+static const StrokeRec char113[] = {
+   { 2, char113_stroke0 },
+   { 14, char113_stroke1 },
+};
+
+/* char: 114 'r' */
+
+static const CoordRec char114_stroke0[] = {
+    { 33.3334, 66.6667 },
+    { 33.3334, 0 },
+};
+
+static const CoordRec char114_stroke1[] = {
+    { 33.3334, 38.0952 },
+    { 38.0953, 52.381 },
+    { 47.6191, 61.9048 },
+    { 57.1429, 66.6667 },
+    { 71.4286, 66.6667 },
+};
+
+static const StrokeRec char114[] = {
+   { 2, char114_stroke0 },
+   { 5, char114_stroke1 },
+};
+
+/* char: 115 's' */
+
+static const CoordRec char115_stroke0[] = {
+    { 78.5715, 52.381 },
+    { 73.8095, 61.9048 },
+    { 59.5238, 66.6667 },
+    { 45.2381, 66.6667 },
+    { 30.9524, 61.9048 },
+    { 26.1905, 52.381 },
+    { 30.9524, 42.8571 },
+    { 40.4762, 38.0952 },
+    { 64.2857, 33.3333 },
+    { 73.8095, 28.5714 },
+    { 78.5715, 19.0476 },
+    { 78.5715, 14.2857 },
+    { 73.8095, 4.7619 },
+    { 59.5238, 0 },
+    { 45.2381, 0 },
+    { 30.9524, 4.7619 },
+    { 26.1905, 14.2857 },
+};
+
+static const StrokeRec char115[] = {
+   { 17, char115_stroke0 },
+};
+
+/* char: 116 't' */
+
+static const CoordRec char116_stroke0[] = {
+    { 47.6191, 100 },
+    { 47.6191, 19.0476 },
+    { 52.381, 4.7619 },
+    { 61.9048, 0 },
+    { 71.4286, 0 },
+};
+
+static const CoordRec char116_stroke1[] = {
+    { 33.3334, 66.6667 },
+    { 66.6667, 66.6667 },
+};
+
+static const StrokeRec char116[] = {
+   { 5, char116_stroke0 },
+   { 2, char116_stroke1 },
+};
+
+/* char: 117 'u' */
+
+static const CoordRec char117_stroke0[] = {
+    { 26.1905, 66.6667 },
+    { 26.1905, 19.0476 },
+    { 30.9524, 4.7619 },
+    { 40.4762, 0 },
+    { 54.7619, 0 },
+    { 64.2857, 4.7619 },
+    { 78.5715, 19.0476 },
+};
+
+static const CoordRec char117_stroke1[] = {
+    { 78.5715, 66.6667 },
+    { 78.5715, 0 },
+};
+
+static const StrokeRec char117[] = {
+   { 7, char117_stroke0 },
+   { 2, char117_stroke1 },
+};
+
+/* char: 118 'v' */
+
+static const CoordRec char118_stroke0[] = {
+    { 23.8095, 66.6667 },
+    { 52.3809, 0 },
+};
+
+static const CoordRec char118_stroke1[] = {
+    { 80.9524, 66.6667 },
+    { 52.3809, 0 },
+};
+
+static const StrokeRec char118[] = {
+   { 2, char118_stroke0 },
+   { 2, char118_stroke1 },
+};
+
+/* char: 119 'w' */
+
+static const CoordRec char119_stroke0[] = {
+    { 14.2857, 66.6667 },
+    { 33.3333, 0 },
+};
+
+static const CoordRec char119_stroke1[] = {
+    { 52.3809, 66.6667 },
+    { 33.3333, 0 },
+};
+
+static const CoordRec char119_stroke2[] = {
+    { 52.3809, 66.6667 },
+    { 71.4286, 0 },
+};
+
+static const CoordRec char119_stroke3[] = {
+    { 90.4762, 66.6667 },
+    { 71.4286, 0 },
+};
+
+static const StrokeRec char119[] = {
+   { 2, char119_stroke0 },
+   { 2, char119_stroke1 },
+   { 2, char119_stroke2 },
+   { 2, char119_stroke3 },
+};
+
+/* char: 120 'x' */
+
+static const CoordRec char120_stroke0[] = {
+    { 26.1905, 66.6667 },
+    { 78.5715, 0 },
+};
+
+static const CoordRec char120_stroke1[] = {
+    { 78.5715, 66.6667 },
+    { 26.1905, 0 },
+};
+
+static const StrokeRec char120[] = {
+   { 2, char120_stroke0 },
+   { 2, char120_stroke1 },
+};
+
+/* char: 121 'y' */
+
+static const CoordRec char121_stroke0[] = {
+    { 26.1905, 66.6667 },
+    { 54.7619, 0 },
+};
+
+static const CoordRec char121_stroke1[] = {
+    { 83.3334, 66.6667 },
+    { 54.7619, 0 },
+    { 45.2381, -19.0476 },
+    { 35.7143, -28.5714 },
+    { 26.1905, -33.3333 },
+    { 21.4286, -33.3333 },
+};
+
+static const StrokeRec char121[] = {
+   { 2, char121_stroke0 },
+   { 6, char121_stroke1 },
+};
+
+/* char: 122 'z' */
+
+static const CoordRec char122_stroke0[] = {
+    { 78.5715, 66.6667 },
+    { 26.1905, 0 },
+};
+
+static const CoordRec char122_stroke1[] = {
+    { 26.1905, 66.6667 },
+    { 78.5715, 66.6667 },
+};
+
+static const CoordRec char122_stroke2[] = {
+    { 26.1905, 0 },
+    { 78.5715, 0 },
+};
+
+static const StrokeRec char122[] = {
+   { 2, char122_stroke0 },
+   { 2, char122_stroke1 },
+   { 2, char122_stroke2 },
+};
+
+/* char: 123 '{' */
+
+static const CoordRec char123_stroke0[] = {
+    { 64.2857, 119.048 },
+    { 54.7619, 114.286 },
+    { 50, 109.524 },
+    { 45.2381, 100 },
+    { 45.2381, 90.4762 },
+    { 50, 80.9524 },
+    { 54.7619, 76.1905 },
+    { 59.5238, 66.6667 },
+    { 59.5238, 57.1429 },
+    { 50, 47.619 },
+};
+
+static const CoordRec char123_stroke1[] = {
+    { 54.7619, 114.286 },
+    { 50, 104.762 },
+    { 50, 95.2381 },
+    { 54.7619, 85.7143 },
+    { 59.5238, 80.9524 },
+    { 64.2857, 71.4286 },
+    { 64.2857, 61.9048 },
+    { 59.5238, 52.381 },
+    { 40.4762, 42.8571 },
+    { 59.5238, 33.3333 },
+    { 64.2857, 23.8095 },
+    { 64.2857, 14.2857 },
+    { 59.5238, 4.7619 },
+    { 54.7619, 0 },
+    { 50, -9.5238 },
+    { 50, -19.0476 },
+    { 54.7619, -28.5714 },
+};
+
+static const CoordRec char123_stroke2[] = {
+    { 50, 38.0952 },
+    { 59.5238, 28.5714 },
+    { 59.5238, 19.0476 },
+    { 54.7619, 9.5238 },
+    { 50, 4.7619 },
+    { 45.2381, -4.7619 },
+    { 45.2381, -14.2857 },
+    { 50, -23.8095 },
+    { 54.7619, -28.5714 },
+    { 64.2857, -33.3333 },
+};
+
+static const StrokeRec char123[] = {
+   { 10, char123_stroke0 },
+   { 17, char123_stroke1 },
+   { 10, char123_stroke2 },
+};
+
+/* char: 124 '|' */
+
+static const CoordRec char124_stroke0[] = {
+    { 52.381, 119.048 },
+    { 52.381, -33.3333 },
+};
+
+static const StrokeRec char124[] = {
+   { 2, char124_stroke0 },
+};
+
+/* char: 125 '}' */
+
+static const CoordRec char125_stroke0[] = {
+    { 40.4762, 119.048 },
+    { 50, 114.286 },
+    { 54.7619, 109.524 },
+    { 59.5238, 100 },
+    { 59.5238, 90.4762 },
+    { 54.7619, 80.9524 },
+    { 50, 76.1905 },
+    { 45.2381, 66.6667 },
+    { 45.2381, 57.1429 },
+    { 54.7619, 47.619 },
+};
+
+static const CoordRec char125_stroke1[] = {
+    { 50, 114.286 },
+    { 54.7619, 104.762 },
+    { 54.7619, 95.2381 },
+    { 50, 85.7143 },
+    { 45.2381, 80.9524 },
+    { 40.4762, 71.4286 },
+    { 40.4762, 61.9048 },
+    { 45.2381, 52.381 },
+    { 64.2857, 42.8571 },
+    { 45.2381, 33.3333 },
+    { 40.4762, 23.8095 },
+    { 40.4762, 14.2857 },
+    { 45.2381, 4.7619 },
+    { 50, 0 },
+    { 54.7619, -9.5238 },
+    { 54.7619, -19.0476 },
+    { 50, -28.5714 },
+};
+
+static const CoordRec char125_stroke2[] = {
+    { 54.7619, 38.0952 },
+    { 45.2381, 28.5714 },
+    { 45.2381, 19.0476 },
+    { 50, 9.5238 },
+    { 54.7619, 4.7619 },
+    { 59.5238, -4.7619 },
+    { 59.5238, -14.2857 },
+    { 54.7619, -23.8095 },
+    { 50, -28.5714 },
+    { 40.4762, -33.3333 },
+};
+
+static const StrokeRec char125[] = {
+   { 10, char125_stroke0 },
+   { 17, char125_stroke1 },
+   { 10, char125_stroke2 },
+};
+
+/* char: 126 '~' */
+
+static const CoordRec char126_stroke0[] = {
+    { 9.5238, 28.5714 },
+    { 9.5238, 38.0952 },
+    { 14.2857, 52.381 },
+    { 23.8095, 57.1429 },
+    { 33.3333, 57.1429 },
+    { 42.8571, 52.381 },
+    { 61.9048, 38.0952 },
+    { 71.4286, 33.3333 },
+    { 80.9524, 33.3333 },
+    { 90.4762, 38.0952 },
+    { 95.2381, 47.619 },
+};
+
+static const CoordRec char126_stroke1[] = {
+    { 9.5238, 38.0952 },
+    { 14.2857, 47.619 },
+    { 23.8095, 52.381 },
+    { 33.3333, 52.381 },
+    { 42.8571, 47.619 },
+    { 61.9048, 33.3333 },
+    { 71.4286, 28.5714 },
+    { 80.9524, 28.5714 },
+    { 90.4762, 33.3333 },
+    { 95.2381, 47.619 },
+    { 95.2381, 57.1429 },
+};
+
+static const StrokeRec char126[] = {
+   { 11, char126_stroke0 },
+   { 11, char126_stroke1 },
+};
+
+/* char: 127 */
+
+static const CoordRec char127_stroke0[] = {
+    { 71.4286, 100 },
+    { 33.3333, -33.3333 },
+};
+
+static const CoordRec char127_stroke1[] = {
+    { 47.619, 66.6667 },
+    { 33.3333, 61.9048 },
+    { 23.8095, 52.381 },
+    { 19.0476, 38.0952 },
+    { 19.0476, 23.8095 },
+    { 23.8095, 14.2857 },
+    { 33.3333, 4.7619 },
+    { 47.619, 0 },
+    { 57.1428, 0 },
+    { 71.4286, 4.7619 },
+    { 80.9524, 14.2857 },
+    { 85.7143, 28.5714 },
+    { 85.7143, 42.8571 },
+    { 80.9524, 52.381 },
+    { 71.4286, 61.9048 },
+    { 57.1428, 66.6667 },
+    { 47.619, 66.6667 },
+};
+
+static const StrokeRec char127[] = {
+   { 2, char127_stroke0 },
+   { 17, char127_stroke1 },
+};
+
+static const StrokeCharRec chars[] = {
+    { 0, /* char0 */ 0, 0, 0 },
+    { 0, /* char1 */ 0, 0, 0 },
+    { 0, /* char2 */ 0, 0, 0 },
+    { 0, /* char3 */ 0, 0, 0 },
+    { 0, /* char4 */ 0, 0, 0 },
+    { 0, /* char5 */ 0, 0, 0 },
+    { 0, /* char6 */ 0, 0, 0 },
+    { 0, /* char7 */ 0, 0, 0 },
+    { 0, /* char8 */ 0, 0, 0 },
+    { 0, /* char9 */ 0, 0, 0 },
+    { 0, /* char10 */ 0, 0, 0 },
+    { 0, /* char11 */ 0, 0, 0 },
+    { 0, /* char12 */ 0, 0, 0 },
+    { 0, /* char13 */ 0, 0, 0 },
+    { 0, /* char14 */ 0, 0, 0 },
+    { 0, /* char15 */ 0, 0, 0 },
+    { 0, /* char16 */ 0, 0, 0 },
+    { 0, /* char17 */ 0, 0, 0 },
+    { 0, /* char18 */ 0, 0, 0 },
+    { 0, /* char19 */ 0, 0, 0 },
+    { 0, /* char20 */ 0, 0, 0 },
+    { 0, /* char21 */ 0, 0, 0 },
+    { 0, /* char22 */ 0, 0, 0 },
+    { 0, /* char23 */ 0, 0, 0 },
+    { 0, /* char24 */ 0, 0, 0 },
+    { 0, /* char25 */ 0, 0, 0 },
+    { 0, /* char26 */ 0, 0, 0 },
+    { 0, /* char27 */ 0, 0, 0 },
+    { 0, /* char28 */ 0, 0, 0 },
+    { 0, /* char29 */ 0, 0, 0 },
+    { 0, /* char30 */ 0, 0, 0 },
+    { 0, /* char31 */ 0, 0, 0 },
+    { 0, /* char32 */ 0, 52.381, 104.762 },
+    { 2, char33, 52.381, 104.762 },
+    { 2, char34, 52.381, 104.762 },
+    { 4, char35, 52.381, 104.762 },
+    { 3, char36, 52.381, 104.762 },
+    { 3, char37, 52.381, 104.762 },
+    { 1, char38, 52.381, 104.762 },
+    { 1, char39, 52.381, 104.762 },
+    { 1, char40, 52.381, 104.762 },
+    { 1, char41, 52.381, 104.762 },
+    { 3, char42, 52.381, 104.762 },
+    { 2, char43, 52.381, 104.762 },
+    { 1, char44, 52.381, 104.762 },
+    { 1, char45, 52.381, 104.762 },
+    { 1, char46, 52.381, 104.762 },
+    { 1, char47, 52.381, 104.762 },
+    { 1, char48, 52.381, 104.762 },
+    { 1, char49, 52.381, 104.762 },
+    { 1, char50, 52.381, 104.762 },
+    { 1, char51, 52.381, 104.762 },
+    { 2, char52, 52.381, 104.762 },
+    { 1, char53, 52.381, 104.762 },
+    { 1, char54, 52.381, 104.762 },
+    { 2, char55, 52.381, 104.762 },
+    { 1, char56, 52.381, 104.762 },
+    { 1, char57, 52.381, 104.762 },
+    { 2, char58, 52.381, 104.762 },
+    { 2, char59, 52.381, 104.762 },
+    { 1, char60, 52.381, 104.762 },
+    { 2, char61, 52.381, 104.762 },
+    { 1, char62, 52.381, 104.762 },
+    { 2, char63, 52.381, 104.762 },
+    { 2, char64, 52.381, 104.762 },
+    { 3, char65, 52.381, 104.762 },
+    { 3, char66, 52.381, 104.762 },
+    { 1, char67, 52.381, 104.762 },
+    { 2, char68, 52.381, 104.762 },
+    { 4, char69, 52.381, 104.762 },
+    { 3, char70, 52.381, 104.762 },
+    { 2, char71, 52.381, 104.762 },
+    { 3, char72, 52.381, 104.762 },
+    { 1, char73, 52.381, 104.762 },
+    { 1, char74, 52.381, 104.762 },
+    { 3, char75, 52.381, 104.762 },
+    { 2, char76, 52.381, 104.762 },
+    { 4, char77, 52.381, 104.762 },
+    { 3, char78, 52.381, 104.762 },
+    { 1, char79, 52.381, 104.762 },
+    { 2, char80, 52.381, 104.762 },
+    { 2, char81, 52.381, 104.762 },
+    { 3, char82, 52.381, 104.762 },
+    { 1, char83, 52.381, 104.762 },
+    { 2, char84, 52.381, 104.762 },
+    { 1, char85, 52.381, 104.762 },
+    { 2, char86, 52.381, 104.762 },
+    { 4, char87, 52.381, 104.762 },
+    { 2, char88, 52.381, 104.762 },
+    { 2, char89, 52.381, 104.762 },
+    { 3, char90, 52.381, 104.762 },
+    { 4, char91, 52.381, 104.762 },
+    { 1, char92, 52.381, 104.762 },
+    { 4, char93, 52.381, 104.762 },
+    { 2, char94, 52.381, 104.762 },
+    { 1, char95, 52.381, 104.762 },
+    { 2, char96, 52.381, 104.762 },
+    { 2, char97, 52.381, 104.762 },
+    { 2, char98, 52.381, 104.762 },
+    { 1, char99, 52.381, 104.762 },
+    { 2, char100, 52.381, 104.762 },
+    { 1, char101, 52.381, 104.762 },
+    { 2, char102, 52.381, 104.762 },
+    { 2, char103, 52.381, 104.762 },
+    { 2, char104, 52.381, 104.762 },
+    { 2, char105, 52.381, 104.762 },
+    { 2, char106, 52.381, 104.762 },
+    { 3, char107, 52.381, 104.762 },
+    { 1, char108, 52.381, 104.762 },
+    { 3, char109, 52.381, 104.762 },
+    { 2, char110, 52.381, 104.762 },
+    { 1, char111, 52.381, 104.762 },
+    { 2, char112, 52.381, 104.762 },
+    { 2, char113, 52.381, 104.762 },
+    { 2, char114, 52.381, 104.762 },
+    { 1, char115, 52.381, 104.762 },
+    { 2, char116, 52.381, 104.762 },
+    { 2, char117, 52.381, 104.762 },
+    { 2, char118, 52.381, 104.762 },
+    { 4, char119, 52.381, 104.762 },
+    { 2, char120, 52.381, 104.762 },
+    { 2, char121, 52.381, 104.762 },
+    { 3, char122, 52.381, 104.762 },
+    { 3, char123, 52.381, 104.762 },
+    { 1, char124, 52.381, 104.762 },
+    { 3, char125, 52.381, 104.762 },
+    { 2, char126, 52.381, 104.762 },
+    { 2, char127, 52.381, 104.762 },
+};
+
+StrokeFontRec glutStrokeMonoRoman = { "Roman", 128, chars, 119.048, -33.3333 };
+
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 */
diff --git a/src/glut/glx/glut_roman.c b/src/glut/glx/glut_roman.c
new file mode 100644
index 0000000000..af2b4ec956
--- /dev/null
+++ b/src/glut/glx/glut_roman.c
@@ -0,0 +1,2451 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#include "glutstroke.h"
+
+/* char: 33 '!' */
+
+static const CoordRec char33_stroke0[] = {
+    { 13.3819, 100 },
+    { 13.3819, 33.3333 },
+};
+
+static const CoordRec char33_stroke1[] = {
+    { 13.3819, 9.5238 },
+    { 8.62, 4.7619 },
+    { 13.3819, 0 },
+    { 18.1438, 4.7619 },
+    { 13.3819, 9.5238 },
+};
+
+static const StrokeRec char33[] = {
+   { 2, char33_stroke0 },
+   { 5, char33_stroke1 },
+};
+
+/* char: 34 '"' */
+
+static const CoordRec char34_stroke0[] = {
+    { 4.02, 100 },
+    { 4.02, 66.6667 },
+};
+
+static const CoordRec char34_stroke1[] = {
+    { 42.1152, 100 },
+    { 42.1152, 66.6667 },
+};
+
+static const StrokeRec char34[] = {
+   { 2, char34_stroke0 },
+   { 2, char34_stroke1 },
+};
+
+/* char: 35 '#' */
+
+static const CoordRec char35_stroke0[] = {
+    { 41.2952, 119.048 },
+    { 7.9619, -33.3333 },
+};
+
+static const CoordRec char35_stroke1[] = {
+    { 69.8667, 119.048 },
+    { 36.5333, -33.3333 },
+};
+
+static const CoordRec char35_stroke2[] = {
+    { 7.9619, 57.1429 },
+    { 74.6286, 57.1429 },
+};
+
+static const CoordRec char35_stroke3[] = {
+    { 3.2, 28.5714 },
+    { 69.8667, 28.5714 },
+};
+
+static const StrokeRec char35[] = {
+   { 2, char35_stroke0 },
+   { 2, char35_stroke1 },
+   { 2, char35_stroke2 },
+   { 2, char35_stroke3 },
+};
+
+/* char: 36 '$' */
+
+static const CoordRec char36_stroke0[] = {
+    { 28.6295, 119.048 },
+    { 28.6295, -19.0476 },
+};
+
+static const CoordRec char36_stroke1[] = {
+    { 47.6771, 119.048 },
+    { 47.6771, -19.0476 },
+};
+
+static const CoordRec char36_stroke2[] = {
+    { 71.4867, 85.7143 },
+    { 61.9629, 95.2381 },
+    { 47.6771, 100 },
+    { 28.6295, 100 },
+    { 14.3438, 95.2381 },
+    { 4.82, 85.7143 },
+    { 4.82, 76.1905 },
+    { 9.5819, 66.6667 },
+    { 14.3438, 61.9048 },
+    { 23.8676, 57.1429 },
+    { 52.439, 47.619 },
+    { 61.9629, 42.8571 },
+    { 66.7248, 38.0952 },
+    { 71.4867, 28.5714 },
+    { 71.4867, 14.2857 },
+    { 61.9629, 4.7619 },
+    { 47.6771, 0 },
+    { 28.6295, 0 },
+    { 14.3438, 4.7619 },
+    { 4.82, 14.2857 },
+};
+
+static const StrokeRec char36[] = {
+   { 2, char36_stroke0 },
+   { 2, char36_stroke1 },
+   { 20, char36_stroke2 },
+};
+
+/* char: 37 '%' */
+
+static const CoordRec char37_stroke0[] = {
+    { 92.0743, 100 },
+    { 6.36, 0 },
+};
+
+static const CoordRec char37_stroke1[] = {
+    { 30.1695, 100 },
+    { 39.6933, 90.4762 },
+    { 39.6933, 80.9524 },
+    { 34.9314, 71.4286 },
+    { 25.4076, 66.6667 },
+    { 15.8838, 66.6667 },
+    { 6.36, 76.1905 },
+    { 6.36, 85.7143 },
+    { 11.1219, 95.2381 },
+    { 20.6457, 100 },
+    { 30.1695, 100 },
+    { 39.6933, 95.2381 },
+    { 53.979, 90.4762 },
+    { 68.2648, 90.4762 },
+    { 82.5505, 95.2381 },
+    { 92.0743, 100 },
+};
+
+static const CoordRec char37_stroke2[] = {
+    { 73.0267, 33.3333 },
+    { 63.5029, 28.5714 },
+    { 58.741, 19.0476 },
+    { 58.741, 9.5238 },
+    { 68.2648, 0 },
+    { 77.7886, 0 },
+    { 87.3124, 4.7619 },
+    { 92.0743, 14.2857 },
+    { 92.0743, 23.8095 },
+    { 82.5505, 33.3333 },
+    { 73.0267, 33.3333 },
+};
+
+static const StrokeRec char37[] = {
+   { 2, char37_stroke0 },
+   { 16, char37_stroke1 },
+   { 11, char37_stroke2 },
+};
+
+/* char: 38 '&' */
+
+static const CoordRec char38_stroke0[] = {
+    { 101.218, 57.1429 },
+    { 101.218, 61.9048 },
+    { 96.4562, 66.6667 },
+    { 91.6943, 66.6667 },
+    { 86.9324, 61.9048 },
+    { 82.1705, 52.381 },
+    { 72.6467, 28.5714 },
+    { 63.1229, 14.2857 },
+    { 53.599, 4.7619 },
+    { 44.0752, 0 },
+    { 25.0276, 0 },
+    { 15.5038, 4.7619 },
+    { 10.7419, 9.5238 },
+    { 5.98, 19.0476 },
+    { 5.98, 28.5714 },
+    { 10.7419, 38.0952 },
+    { 15.5038, 42.8571 },
+    { 48.8371, 61.9048 },
+    { 53.599, 66.6667 },
+    { 58.361, 76.1905 },
+    { 58.361, 85.7143 },
+    { 53.599, 95.2381 },
+    { 44.0752, 100 },
+    { 34.5514, 95.2381 },
+    { 29.7895, 85.7143 },
+    { 29.7895, 76.1905 },
+    { 34.5514, 61.9048 },
+    { 44.0752, 47.619 },
+    { 67.8848, 14.2857 },
+    { 77.4086, 4.7619 },
+    { 86.9324, 0 },
+    { 96.4562, 0 },
+    { 101.218, 4.7619 },
+    { 101.218, 9.5238 },
+};
+
+static const StrokeRec char38[] = {
+   { 34, char38_stroke0 },
+};
+
+/* char: 39 ''' */
+
+static const CoordRec char39_stroke0[] = {
+    { 4.44, 100 },
+    { 4.44, 66.6667 },
+};
+
+static const StrokeRec char39[] = {
+   { 2, char39_stroke0 },
+};
+
+/* char: 40 '(' */
+
+static const CoordRec char40_stroke0[] = {
+    { 40.9133, 119.048 },
+    { 31.3895, 109.524 },
+    { 21.8657, 95.2381 },
+    { 12.3419, 76.1905 },
+    { 7.58, 52.381 },
+    { 7.58, 33.3333 },
+    { 12.3419, 9.5238 },
+    { 21.8657, -9.5238 },
+    { 31.3895, -23.8095 },
+    { 40.9133, -33.3333 },
+};
+
+static const StrokeRec char40[] = {
+   { 10, char40_stroke0 },
+};
+
+/* char: 41 ')' */
+
+static const CoordRec char41_stroke0[] = {
+    { 5.28, 119.048 },
+    { 14.8038, 109.524 },
+    { 24.3276, 95.2381 },
+    { 33.8514, 76.1905 },
+    { 38.6133, 52.381 },
+    { 38.6133, 33.3333 },
+    { 33.8514, 9.5238 },
+    { 24.3276, -9.5238 },
+    { 14.8038, -23.8095 },
+    { 5.28, -33.3333 },
+};
+
+static const StrokeRec char41[] = {
+   { 10, char41_stroke0 },
+};
+
+/* char: 42 '*' */
+
+static const CoordRec char42_stroke0[] = {
+    { 30.7695, 71.4286 },
+    { 30.7695, 14.2857 },
+};
+
+static const CoordRec char42_stroke1[] = {
+    { 6.96, 57.1429 },
+    { 54.579, 28.5714 },
+};
+
+static const CoordRec char42_stroke2[] = {
+    { 54.579, 57.1429 },
+    { 6.96, 28.5714 },
+};
+
+static const StrokeRec char42[] = {
+   { 2, char42_stroke0 },
+   { 2, char42_stroke1 },
+   { 2, char42_stroke2 },
+};
+
+/* char: 43 '+' */
+
+static const CoordRec char43_stroke0[] = {
+    { 48.8371, 85.7143 },
+    { 48.8371, 0 },
+};
+
+static const CoordRec char43_stroke1[] = {
+    { 5.98, 42.8571 },
+    { 91.6943, 42.8571 },
+};
+
+static const StrokeRec char43[] = {
+   { 2, char43_stroke0 },
+   { 2, char43_stroke1 },
+};
+
+/* char: 44 ',' */
+
+static const CoordRec char44_stroke0[] = {
+    { 18.2838, 4.7619 },
+    { 13.5219, 0 },
+    { 8.76, 4.7619 },
+    { 13.5219, 9.5238 },
+    { 18.2838, 4.7619 },
+    { 18.2838, -4.7619 },
+    { 13.5219, -14.2857 },
+    { 8.76, -19.0476 },
+};
+
+static const StrokeRec char44[] = {
+   { 8, char44_stroke0 },
+};
+
+/* char: 45 '-' */
+
+static const CoordRec char45_stroke0[] = {
+    { 7.38, 42.8571 },
+    { 93.0943, 42.8571 },
+};
+
+static const StrokeRec char45[] = {
+   { 2, char45_stroke0 },
+};
+
+/* char: 46 '.' */
+
+static const CoordRec char46_stroke0[] = {
+    { 13.1019, 9.5238 },
+    { 8.34, 4.7619 },
+    { 13.1019, 0 },
+    { 17.8638, 4.7619 },
+    { 13.1019, 9.5238 },
+};
+
+static const StrokeRec char46[] = {
+   { 5, char46_stroke0 },
+};
+
+/* char: 47 '/' */
+
+static const CoordRec char47_stroke0[] = {
+    { 7.24, -14.2857 },
+    { 73.9067, 100 },
+};
+
+static const StrokeRec char47[] = {
+   { 2, char47_stroke0 },
+};
+
+/* char: 48 '0' */
+
+static const CoordRec char48_stroke0[] = {
+    { 33.5514, 100 },
+    { 19.2657, 95.2381 },
+    { 9.7419, 80.9524 },
+    { 4.98, 57.1429 },
+    { 4.98, 42.8571 },
+    { 9.7419, 19.0476 },
+    { 19.2657, 4.7619 },
+    { 33.5514, 0 },
+    { 43.0752, 0 },
+    { 57.361, 4.7619 },
+    { 66.8848, 19.0476 },
+    { 71.6467, 42.8571 },
+    { 71.6467, 57.1429 },
+    { 66.8848, 80.9524 },
+    { 57.361, 95.2381 },
+    { 43.0752, 100 },
+    { 33.5514, 100 },
+};
+
+static const StrokeRec char48[] = {
+   { 17, char48_stroke0 },
+};
+
+/* char: 49 '1' */
+
+static const CoordRec char49_stroke0[] = {
+    { 11.82, 80.9524 },
+    { 21.3438, 85.7143 },
+    { 35.6295, 100 },
+    { 35.6295, 0 },
+};
+
+static const StrokeRec char49[] = {
+   { 4, char49_stroke0 },
+};
+
+/* char: 50 '2' */
+
+static const CoordRec char50_stroke0[] = {
+    { 10.1819, 76.1905 },
+    { 10.1819, 80.9524 },
+    { 14.9438, 90.4762 },
+    { 19.7057, 95.2381 },
+    { 29.2295, 100 },
+    { 48.2771, 100 },
+    { 57.801, 95.2381 },
+    { 62.5629, 90.4762 },
+    { 67.3248, 80.9524 },
+    { 67.3248, 71.4286 },
+    { 62.5629, 61.9048 },
+    { 53.039, 47.619 },
+    { 5.42, 0 },
+    { 72.0867, 0 },
+};
+
+static const StrokeRec char50[] = {
+   { 14, char50_stroke0 },
+};
+
+/* char: 51 '3' */
+
+static const CoordRec char51_stroke0[] = {
+    { 14.5238, 100 },
+    { 66.9048, 100 },
+    { 38.3333, 61.9048 },
+    { 52.619, 61.9048 },
+    { 62.1429, 57.1429 },
+    { 66.9048, 52.381 },
+    { 71.6667, 38.0952 },
+    { 71.6667, 28.5714 },
+    { 66.9048, 14.2857 },
+    { 57.381, 4.7619 },
+    { 43.0952, 0 },
+    { 28.8095, 0 },
+    { 14.5238, 4.7619 },
+    { 9.7619, 9.5238 },
+    { 5, 19.0476 },
+};
+
+static const StrokeRec char51[] = {
+   { 15, char51_stroke0 },
+};
+
+/* char: 52 '4' */
+
+static const CoordRec char52_stroke0[] = {
+    { 51.499, 100 },
+    { 3.88, 33.3333 },
+    { 75.3086, 33.3333 },
+};
+
+static const CoordRec char52_stroke1[] = {
+    { 51.499, 100 },
+    { 51.499, 0 },
+};
+
+static const StrokeRec char52[] = {
+   { 3, char52_stroke0 },
+   { 2, char52_stroke1 },
+};
+
+/* char: 53 '5' */
+
+static const CoordRec char53_stroke0[] = {
+    { 62.0029, 100 },
+    { 14.3838, 100 },
+    { 9.6219, 57.1429 },
+    { 14.3838, 61.9048 },
+    { 28.6695, 66.6667 },
+    { 42.9552, 66.6667 },
+    { 57.241, 61.9048 },
+    { 66.7648, 52.381 },
+    { 71.5267, 38.0952 },
+    { 71.5267, 28.5714 },
+    { 66.7648, 14.2857 },
+    { 57.241, 4.7619 },
+    { 42.9552, 0 },
+    { 28.6695, 0 },
+    { 14.3838, 4.7619 },
+    { 9.6219, 9.5238 },
+    { 4.86, 19.0476 },
+};
+
+static const StrokeRec char53[] = {
+   { 17, char53_stroke0 },
+};
+
+/* char: 54 '6' */
+
+static const CoordRec char54_stroke0[] = {
+    { 62.7229, 85.7143 },
+    { 57.961, 95.2381 },
+    { 43.6752, 100 },
+    { 34.1514, 100 },
+    { 19.8657, 95.2381 },
+    { 10.3419, 80.9524 },
+    { 5.58, 57.1429 },
+    { 5.58, 33.3333 },
+    { 10.3419, 14.2857 },
+    { 19.8657, 4.7619 },
+    { 34.1514, 0 },
+    { 38.9133, 0 },
+    { 53.199, 4.7619 },
+    { 62.7229, 14.2857 },
+    { 67.4848, 28.5714 },
+    { 67.4848, 33.3333 },
+    { 62.7229, 47.619 },
+    { 53.199, 57.1429 },
+    { 38.9133, 61.9048 },
+    { 34.1514, 61.9048 },
+    { 19.8657, 57.1429 },
+    { 10.3419, 47.619 },
+    { 5.58, 33.3333 },
+};
+
+static const StrokeRec char54[] = {
+   { 23, char54_stroke0 },
+};
+
+/* char: 55 '7' */
+
+static const CoordRec char55_stroke0[] = {
+    { 72.2267, 100 },
+    { 24.6076, 0 },
+};
+
+static const CoordRec char55_stroke1[] = {
+    { 5.56, 100 },
+    { 72.2267, 100 },
+};
+
+static const StrokeRec char55[] = {
+   { 2, char55_stroke0 },
+   { 2, char55_stroke1 },
+};
+
+/* char: 56 '8' */
+
+static const CoordRec char56_stroke0[] = {
+    { 29.4095, 100 },
+    { 15.1238, 95.2381 },
+    { 10.3619, 85.7143 },
+    { 10.3619, 76.1905 },
+    { 15.1238, 66.6667 },
+    { 24.6476, 61.9048 },
+    { 43.6952, 57.1429 },
+    { 57.981, 52.381 },
+    { 67.5048, 42.8571 },
+    { 72.2667, 33.3333 },
+    { 72.2667, 19.0476 },
+    { 67.5048, 9.5238 },
+    { 62.7429, 4.7619 },
+    { 48.4571, 0 },
+    { 29.4095, 0 },
+    { 15.1238, 4.7619 },
+    { 10.3619, 9.5238 },
+    { 5.6, 19.0476 },
+    { 5.6, 33.3333 },
+    { 10.3619, 42.8571 },
+    { 19.8857, 52.381 },
+    { 34.1714, 57.1429 },
+    { 53.219, 61.9048 },
+    { 62.7429, 66.6667 },
+    { 67.5048, 76.1905 },
+    { 67.5048, 85.7143 },
+    { 62.7429, 95.2381 },
+    { 48.4571, 100 },
+    { 29.4095, 100 },
+};
+
+static const StrokeRec char56[] = {
+   { 29, char56_stroke0 },
+};
+
+/* char: 57 '9' */
+
+static const CoordRec char57_stroke0[] = {
+    { 68.5048, 66.6667 },
+    { 63.7429, 52.381 },
+    { 54.219, 42.8571 },
+    { 39.9333, 38.0952 },
+    { 35.1714, 38.0952 },
+    { 20.8857, 42.8571 },
+    { 11.3619, 52.381 },
+    { 6.6, 66.6667 },
+    { 6.6, 71.4286 },
+    { 11.3619, 85.7143 },
+    { 20.8857, 95.2381 },
+    { 35.1714, 100 },
+    { 39.9333, 100 },
+    { 54.219, 95.2381 },
+    { 63.7429, 85.7143 },
+    { 68.5048, 66.6667 },
+    { 68.5048, 42.8571 },
+    { 63.7429, 19.0476 },
+    { 54.219, 4.7619 },
+    { 39.9333, 0 },
+    { 30.4095, 0 },
+    { 16.1238, 4.7619 },
+    { 11.3619, 14.2857 },
+};
+
+static const StrokeRec char57[] = {
+   { 23, char57_stroke0 },
+};
+
+/* char: 58 ':' */
+
+static const CoordRec char58_stroke0[] = {
+    { 14.0819, 66.6667 },
+    { 9.32, 61.9048 },
+    { 14.0819, 57.1429 },
+    { 18.8438, 61.9048 },
+    { 14.0819, 66.6667 },
+};
+
+static const CoordRec char58_stroke1[] = {
+    { 14.0819, 9.5238 },
+    { 9.32, 4.7619 },
+    { 14.0819, 0 },
+    { 18.8438, 4.7619 },
+    { 14.0819, 9.5238 },
+};
+
+static const StrokeRec char58[] = {
+   { 5, char58_stroke0 },
+   { 5, char58_stroke1 },
+};
+
+/* char: 59 ';' */
+
+static const CoordRec char59_stroke0[] = {
+    { 12.9619, 66.6667 },
+    { 8.2, 61.9048 },
+    { 12.9619, 57.1429 },
+    { 17.7238, 61.9048 },
+    { 12.9619, 66.6667 },
+};
+
+static const CoordRec char59_stroke1[] = {
+    { 17.7238, 4.7619 },
+    { 12.9619, 0 },
+    { 8.2, 4.7619 },
+    { 12.9619, 9.5238 },
+    { 17.7238, 4.7619 },
+    { 17.7238, -4.7619 },
+    { 12.9619, -14.2857 },
+    { 8.2, -19.0476 },
+};
+
+static const StrokeRec char59[] = {
+   { 5, char59_stroke0 },
+   { 8, char59_stroke1 },
+};
+
+/* char: 60 '<' */
+
+static const CoordRec char60_stroke0[] = {
+    { 79.2505, 85.7143 },
+    { 3.06, 42.8571 },
+    { 79.2505, 0 },
+};
+
+static const StrokeRec char60[] = {
+   { 3, char60_stroke0 },
+};
+
+/* char: 61 '=' */
+
+static const CoordRec char61_stroke0[] = {
+    { 5.7, 57.1429 },
+    { 91.4143, 57.1429 },
+};
+
+static const CoordRec char61_stroke1[] = {
+    { 5.7, 28.5714 },
+    { 91.4143, 28.5714 },
+};
+
+static const StrokeRec char61[] = {
+   { 2, char61_stroke0 },
+   { 2, char61_stroke1 },
+};
+
+/* char: 62 '>' */
+
+static const CoordRec char62_stroke0[] = {
+    { 2.78, 85.7143 },
+    { 78.9705, 42.8571 },
+    { 2.78, 0 },
+};
+
+static const StrokeRec char62[] = {
+   { 3, char62_stroke0 },
+};
+
+/* char: 63 '?' */
+
+static const CoordRec char63_stroke0[] = {
+    { 8.42, 76.1905 },
+    { 8.42, 80.9524 },
+    { 13.1819, 90.4762 },
+    { 17.9438, 95.2381 },
+    { 27.4676, 100 },
+    { 46.5152, 100 },
+    { 56.039, 95.2381 },
+    { 60.801, 90.4762 },
+    { 65.5629, 80.9524 },
+    { 65.5629, 71.4286 },
+    { 60.801, 61.9048 },
+    { 56.039, 57.1429 },
+    { 36.9914, 47.619 },
+    { 36.9914, 33.3333 },
+};
+
+static const CoordRec char63_stroke1[] = {
+    { 36.9914, 9.5238 },
+    { 32.2295, 4.7619 },
+    { 36.9914, 0 },
+    { 41.7533, 4.7619 },
+    { 36.9914, 9.5238 },
+};
+
+static const StrokeRec char63[] = {
+   { 14, char63_stroke0 },
+   { 5, char63_stroke1 },
+};
+
+/* char: 64 '@' */
+
+static const CoordRec char64_stroke0[] = {
+    { 49.2171, 52.381 },
+    { 39.6933, 57.1429 },
+    { 30.1695, 57.1429 },
+    { 25.4076, 47.619 },
+    { 25.4076, 42.8571 },
+    { 30.1695, 33.3333 },
+    { 39.6933, 33.3333 },
+    { 49.2171, 38.0952 },
+};
+
+static const CoordRec char64_stroke1[] = {
+    { 49.2171, 57.1429 },
+    { 49.2171, 38.0952 },
+    { 53.979, 33.3333 },
+    { 63.5029, 33.3333 },
+    { 68.2648, 42.8571 },
+    { 68.2648, 47.619 },
+    { 63.5029, 61.9048 },
+    { 53.979, 71.4286 },
+    { 39.6933, 76.1905 },
+    { 34.9314, 76.1905 },
+    { 20.6457, 71.4286 },
+    { 11.1219, 61.9048 },
+    { 6.36, 47.619 },
+    { 6.36, 42.8571 },
+    { 11.1219, 28.5714 },
+    { 20.6457, 19.0476 },
+    { 34.9314, 14.2857 },
+    { 39.6933, 14.2857 },
+    { 53.979, 19.0476 },
+};
+
+static const StrokeRec char64[] = {
+   { 8, char64_stroke0 },
+   { 19, char64_stroke1 },
+};
+
+/* char: 65 'A' */
+
+static const CoordRec char65_stroke0[] = {
+    { 40.5952, 100 },
+    { 2.5, 0 },
+};
+
+static const CoordRec char65_stroke1[] = {
+    { 40.5952, 100 },
+    { 78.6905, 0 },
+};
+
+static const CoordRec char65_stroke2[] = {
+    { 16.7857, 33.3333 },
+    { 64.4048, 33.3333 },
+};
+
+static const StrokeRec char65[] = {
+   { 2, char65_stroke0 },
+   { 2, char65_stroke1 },
+   { 2, char65_stroke2 },
+};
+
+/* char: 66 'B' */
+
+static const CoordRec char66_stroke0[] = {
+    { 11.42, 100 },
+    { 11.42, 0 },
+};
+
+static const CoordRec char66_stroke1[] = {
+    { 11.42, 100 },
+    { 54.2771, 100 },
+    { 68.5629, 95.2381 },
+    { 73.3248, 90.4762 },
+    { 78.0867, 80.9524 },
+    { 78.0867, 71.4286 },
+    { 73.3248, 61.9048 },
+    { 68.5629, 57.1429 },
+    { 54.2771, 52.381 },
+};
+
+static const CoordRec char66_stroke2[] = {
+    { 11.42, 52.381 },
+    { 54.2771, 52.381 },
+    { 68.5629, 47.619 },
+    { 73.3248, 42.8571 },
+    { 78.0867, 33.3333 },
+    { 78.0867, 19.0476 },
+    { 73.3248, 9.5238 },
+    { 68.5629, 4.7619 },
+    { 54.2771, 0 },
+    { 11.42, 0 },
+};
+
+static const StrokeRec char66[] = {
+   { 2, char66_stroke0 },
+   { 9, char66_stroke1 },
+   { 10, char66_stroke2 },
+};
+
+/* char: 67 'C' */
+
+static const CoordRec char67_stroke0[] = {
+    { 78.0886, 76.1905 },
+    { 73.3267, 85.7143 },
+    { 63.8029, 95.2381 },
+    { 54.279, 100 },
+    { 35.2314, 100 },
+    { 25.7076, 95.2381 },
+    { 16.1838, 85.7143 },
+    { 11.4219, 76.1905 },
+    { 6.66, 61.9048 },
+    { 6.66, 38.0952 },
+    { 11.4219, 23.8095 },
+    { 16.1838, 14.2857 },
+    { 25.7076, 4.7619 },
+    { 35.2314, 0 },
+    { 54.279, 0 },
+    { 63.8029, 4.7619 },
+    { 73.3267, 14.2857 },
+    { 78.0886, 23.8095 },
+};
+
+static const StrokeRec char67[] = {
+   { 18, char67_stroke0 },
+};
+
+/* char: 68 'D' */
+
+static const CoordRec char68_stroke0[] = {
+    { 11.96, 100 },
+    { 11.96, 0 },
+};
+
+static const CoordRec char68_stroke1[] = {
+    { 11.96, 100 },
+    { 45.2933, 100 },
+    { 59.579, 95.2381 },
+    { 69.1029, 85.7143 },
+    { 73.8648, 76.1905 },
+    { 78.6267, 61.9048 },
+    { 78.6267, 38.0952 },
+    { 73.8648, 23.8095 },
+    { 69.1029, 14.2857 },
+    { 59.579, 4.7619 },
+    { 45.2933, 0 },
+    { 11.96, 0 },
+};
+
+static const StrokeRec char68[] = {
+   { 2, char68_stroke0 },
+   { 12, char68_stroke1 },
+};
+
+/* char: 69 'E' */
+
+static const CoordRec char69_stroke0[] = {
+    { 11.42, 100 },
+    { 11.42, 0 },
+};
+
+static const CoordRec char69_stroke1[] = {
+    { 11.42, 100 },
+    { 73.3248, 100 },
+};
+
+static const CoordRec char69_stroke2[] = {
+    { 11.42, 52.381 },
+    { 49.5152, 52.381 },
+};
+
+static const CoordRec char69_stroke3[] = {
+    { 11.42, 0 },
+    { 73.3248, 0 },
+};
+
+static const StrokeRec char69[] = {
+   { 2, char69_stroke0 },
+   { 2, char69_stroke1 },
+   { 2, char69_stroke2 },
+   { 2, char69_stroke3 },
+};
+
+/* char: 70 'F' */
+
+static const CoordRec char70_stroke0[] = {
+    { 11.42, 100 },
+    { 11.42, 0 },
+};
+
+static const CoordRec char70_stroke1[] = {
+    { 11.42, 100 },
+    { 73.3248, 100 },
+};
+
+static const CoordRec char70_stroke2[] = {
+    { 11.42, 52.381 },
+    { 49.5152, 52.381 },
+};
+
+static const StrokeRec char70[] = {
+   { 2, char70_stroke0 },
+   { 2, char70_stroke1 },
+   { 2, char70_stroke2 },
+};
+
+/* char: 71 'G' */
+
+static const CoordRec char71_stroke0[] = {
+    { 78.4886, 76.1905 },
+    { 73.7267, 85.7143 },
+    { 64.2029, 95.2381 },
+    { 54.679, 100 },
+    { 35.6314, 100 },
+    { 26.1076, 95.2381 },
+    { 16.5838, 85.7143 },
+    { 11.8219, 76.1905 },
+    { 7.06, 61.9048 },
+    { 7.06, 38.0952 },
+    { 11.8219, 23.8095 },
+    { 16.5838, 14.2857 },
+    { 26.1076, 4.7619 },
+    { 35.6314, 0 },
+    { 54.679, 0 },
+    { 64.2029, 4.7619 },
+    { 73.7267, 14.2857 },
+    { 78.4886, 23.8095 },
+    { 78.4886, 38.0952 },
+};
+
+static const CoordRec char71_stroke1[] = {
+    { 54.679, 38.0952 },
+    { 78.4886, 38.0952 },
+};
+
+static const StrokeRec char71[] = {
+   { 19, char71_stroke0 },
+   { 2, char71_stroke1 },
+};
+
+/* char: 72 'H' */
+
+static const CoordRec char72_stroke0[] = {
+    { 11.42, 100 },
+    { 11.42, 0 },
+};
+
+static const CoordRec char72_stroke1[] = {
+    { 78.0867, 100 },
+    { 78.0867, 0 },
+};
+
+static const CoordRec char72_stroke2[] = {
+    { 11.42, 52.381 },
+    { 78.0867, 52.381 },
+};
+
+static const StrokeRec char72[] = {
+   { 2, char72_stroke0 },
+   { 2, char72_stroke1 },
+   { 2, char72_stroke2 },
+};
+
+/* char: 73 'I' */
+
+static const CoordRec char73_stroke0[] = {
+    { 10.86, 100 },
+    { 10.86, 0 },
+};
+
+static const StrokeRec char73[] = {
+   { 2, char73_stroke0 },
+};
+
+/* char: 74 'J' */
+
+static const CoordRec char74_stroke0[] = {
+    { 50.119, 100 },
+    { 50.119, 23.8095 },
+    { 45.3571, 9.5238 },
+    { 40.5952, 4.7619 },
+    { 31.0714, 0 },
+    { 21.5476, 0 },
+    { 12.0238, 4.7619 },
+    { 7.2619, 9.5238 },
+    { 2.5, 23.8095 },
+    { 2.5, 33.3333 },
+};
+
+static const StrokeRec char74[] = {
+   { 10, char74_stroke0 },
+};
+
+/* char: 75 'K' */
+
+static const CoordRec char75_stroke0[] = {
+    { 11.28, 100 },
+    { 11.28, 0 },
+};
+
+static const CoordRec char75_stroke1[] = {
+    { 77.9467, 100 },
+    { 11.28, 33.3333 },
+};
+
+static const CoordRec char75_stroke2[] = {
+    { 35.0895, 57.1429 },
+    { 77.9467, 0 },
+};
+
+static const StrokeRec char75[] = {
+   { 2, char75_stroke0 },
+   { 2, char75_stroke1 },
+   { 2, char75_stroke2 },
+};
+
+/* char: 76 'L' */
+
+static const CoordRec char76_stroke0[] = {
+    { 11.68, 100 },
+    { 11.68, 0 },
+};
+
+static const CoordRec char76_stroke1[] = {
+    { 11.68, 0 },
+    { 68.8229, 0 },
+};
+
+static const StrokeRec char76[] = {
+   { 2, char76_stroke0 },
+   { 2, char76_stroke1 },
+};
+
+/* char: 77 'M' */
+
+static const CoordRec char77_stroke0[] = {
+    { 10.86, 100 },
+    { 10.86, 0 },
+};
+
+static const CoordRec char77_stroke1[] = {
+    { 10.86, 100 },
+    { 48.9552, 0 },
+};
+
+static const CoordRec char77_stroke2[] = {
+    { 87.0505, 100 },
+    { 48.9552, 0 },
+};
+
+static const CoordRec char77_stroke3[] = {
+    { 87.0505, 100 },
+    { 87.0505, 0 },
+};
+
+static const StrokeRec char77[] = {
+   { 2, char77_stroke0 },
+   { 2, char77_stroke1 },
+   { 2, char77_stroke2 },
+   { 2, char77_stroke3 },
+};
+
+/* char: 78 'N' */
+
+static const CoordRec char78_stroke0[] = {
+    { 11.14, 100 },
+    { 11.14, 0 },
+};
+
+static const CoordRec char78_stroke1[] = {
+    { 11.14, 100 },
+    { 77.8067, 0 },
+};
+
+static const CoordRec char78_stroke2[] = {
+    { 77.8067, 100 },
+    { 77.8067, 0 },
+};
+
+static const StrokeRec char78[] = {
+   { 2, char78_stroke0 },
+   { 2, char78_stroke1 },
+   { 2, char78_stroke2 },
+};
+
+/* char: 79 'O' */
+
+static const CoordRec char79_stroke0[] = {
+    { 34.8114, 100 },
+    { 25.2876, 95.2381 },
+    { 15.7638, 85.7143 },
+    { 11.0019, 76.1905 },
+    { 6.24, 61.9048 },
+    { 6.24, 38.0952 },
+    { 11.0019, 23.8095 },
+    { 15.7638, 14.2857 },
+    { 25.2876, 4.7619 },
+    { 34.8114, 0 },
+    { 53.859, 0 },
+    { 63.3829, 4.7619 },
+    { 72.9067, 14.2857 },
+    { 77.6686, 23.8095 },
+    { 82.4305, 38.0952 },
+    { 82.4305, 61.9048 },
+    { 77.6686, 76.1905 },
+    { 72.9067, 85.7143 },
+    { 63.3829, 95.2381 },
+    { 53.859, 100 },
+    { 34.8114, 100 },
+};
+
+static const StrokeRec char79[] = {
+   { 21, char79_stroke0 },
+};
+
+/* char: 80 'P' */
+
+static const CoordRec char80_stroke0[] = {
+    { 12.1, 100 },
+    { 12.1, 0 },
+};
+
+static const CoordRec char80_stroke1[] = {
+    { 12.1, 100 },
+    { 54.9571, 100 },
+    { 69.2429, 95.2381 },
+    { 74.0048, 90.4762 },
+    { 78.7667, 80.9524 },
+    { 78.7667, 66.6667 },
+    { 74.0048, 57.1429 },
+    { 69.2429, 52.381 },
+    { 54.9571, 47.619 },
+    { 12.1, 47.619 },
+};
+
+static const StrokeRec char80[] = {
+   { 2, char80_stroke0 },
+   { 10, char80_stroke1 },
+};
+
+/* char: 81 'Q' */
+
+static const CoordRec char81_stroke0[] = {
+    { 33.8714, 100 },
+    { 24.3476, 95.2381 },
+    { 14.8238, 85.7143 },
+    { 10.0619, 76.1905 },
+    { 5.3, 61.9048 },
+    { 5.3, 38.0952 },
+    { 10.0619, 23.8095 },
+    { 14.8238, 14.2857 },
+    { 24.3476, 4.7619 },
+    { 33.8714, 0 },
+    { 52.919, 0 },
+    { 62.4429, 4.7619 },
+    { 71.9667, 14.2857 },
+    { 76.7286, 23.8095 },
+    { 81.4905, 38.0952 },
+    { 81.4905, 61.9048 },
+    { 76.7286, 76.1905 },
+    { 71.9667, 85.7143 },
+    { 62.4429, 95.2381 },
+    { 52.919, 100 },
+    { 33.8714, 100 },
+};
+
+static const CoordRec char81_stroke1[] = {
+    { 48.1571, 19.0476 },
+    { 76.7286, -9.5238 },
+};
+
+static const StrokeRec char81[] = {
+   { 21, char81_stroke0 },
+   { 2, char81_stroke1 },
+};
+
+/* char: 82 'R' */
+
+static const CoordRec char82_stroke0[] = {
+    { 11.68, 100 },
+    { 11.68, 0 },
+};
+
+static const CoordRec char82_stroke1[] = {
+    { 11.68, 100 },
+    { 54.5371, 100 },
+    { 68.8229, 95.2381 },
+    { 73.5848, 90.4762 },
+    { 78.3467, 80.9524 },
+    { 78.3467, 71.4286 },
+    { 73.5848, 61.9048 },
+    { 68.8229, 57.1429 },
+    { 54.5371, 52.381 },
+    { 11.68, 52.381 },
+};
+
+static const CoordRec char82_stroke2[] = {
+    { 45.0133, 52.381 },
+    { 78.3467, 0 },
+};
+
+static const StrokeRec char82[] = {
+   { 2, char82_stroke0 },
+   { 10, char82_stroke1 },
+   { 2, char82_stroke2 },
+};
+
+/* char: 83 'S' */
+
+static const CoordRec char83_stroke0[] = {
+    { 74.6667, 85.7143 },
+    { 65.1429, 95.2381 },
+    { 50.8571, 100 },
+    { 31.8095, 100 },
+    { 17.5238, 95.2381 },
+    { 8, 85.7143 },
+    { 8, 76.1905 },
+    { 12.7619, 66.6667 },
+    { 17.5238, 61.9048 },
+    { 27.0476, 57.1429 },
+    { 55.619, 47.619 },
+    { 65.1429, 42.8571 },
+    { 69.9048, 38.0952 },
+    { 74.6667, 28.5714 },
+    { 74.6667, 14.2857 },
+    { 65.1429, 4.7619 },
+    { 50.8571, 0 },
+    { 31.8095, 0 },
+    { 17.5238, 4.7619 },
+    { 8, 14.2857 },
+};
+
+static const StrokeRec char83[] = {
+   { 20, char83_stroke0 },
+};
+
+/* char: 84 'T' */
+
+static const CoordRec char84_stroke0[] = {
+    { 35.6933, 100 },
+    { 35.6933, 0 },
+};
+
+static const CoordRec char84_stroke1[] = {
+    { 2.36, 100 },
+    { 69.0267, 100 },
+};
+
+static const StrokeRec char84[] = {
+   { 2, char84_stroke0 },
+   { 2, char84_stroke1 },
+};
+
+/* char: 85 'U' */
+
+static const CoordRec char85_stroke0[] = {
+    { 11.54, 100 },
+    { 11.54, 28.5714 },
+    { 16.3019, 14.2857 },
+    { 25.8257, 4.7619 },
+    { 40.1114, 0 },
+    { 49.6352, 0 },
+    { 63.921, 4.7619 },
+    { 73.4448, 14.2857 },
+    { 78.2067, 28.5714 },
+    { 78.2067, 100 },
+};
+
+static const StrokeRec char85[] = {
+   { 10, char85_stroke0 },
+};
+
+/* char: 86 'V' */
+
+static const CoordRec char86_stroke0[] = {
+    { 2.36, 100 },
+    { 40.4552, 0 },
+};
+
+static const CoordRec char86_stroke1[] = {
+    { 78.5505, 100 },
+    { 40.4552, 0 },
+};
+
+static const StrokeRec char86[] = {
+   { 2, char86_stroke0 },
+   { 2, char86_stroke1 },
+};
+
+/* char: 87 'W' */
+
+static const CoordRec char87_stroke0[] = {
+    { 2.22, 100 },
+    { 26.0295, 0 },
+};
+
+static const CoordRec char87_stroke1[] = {
+    { 49.839, 100 },
+    { 26.0295, 0 },
+};
+
+static const CoordRec char87_stroke2[] = {
+    { 49.839, 100 },
+    { 73.6486, 0 },
+};
+
+static const CoordRec char87_stroke3[] = {
+    { 97.4581, 100 },
+    { 73.6486, 0 },
+};
+
+static const StrokeRec char87[] = {
+   { 2, char87_stroke0 },
+   { 2, char87_stroke1 },
+   { 2, char87_stroke2 },
+   { 2, char87_stroke3 },
+};
+
+/* char: 88 'X' */
+
+static const CoordRec char88_stroke0[] = {
+    { 2.5, 100 },
+    { 69.1667, 0 },
+};
+
+static const CoordRec char88_stroke1[] = {
+    { 69.1667, 100 },
+    { 2.5, 0 },
+};
+
+static const StrokeRec char88[] = {
+   { 2, char88_stroke0 },
+   { 2, char88_stroke1 },
+};
+
+/* char: 89 'Y' */
+
+static const CoordRec char89_stroke0[] = {
+    { 1.52, 100 },
+    { 39.6152, 52.381 },
+    { 39.6152, 0 },
+};
+
+static const CoordRec char89_stroke1[] = {
+    { 77.7105, 100 },
+    { 39.6152, 52.381 },
+};
+
+static const StrokeRec char89[] = {
+   { 3, char89_stroke0 },
+   { 2, char89_stroke1 },
+};
+
+/* char: 90 'Z' */
+
+static const CoordRec char90_stroke0[] = {
+    { 69.1667, 100 },
+    { 2.5, 0 },
+};
+
+static const CoordRec char90_stroke1[] = {
+    { 2.5, 100 },
+    { 69.1667, 100 },
+};
+
+static const CoordRec char90_stroke2[] = {
+    { 2.5, 0 },
+    { 69.1667, 0 },
+};
+
+static const StrokeRec char90[] = {
+   { 2, char90_stroke0 },
+   { 2, char90_stroke1 },
+   { 2, char90_stroke2 },
+};
+
+/* char: 91 '[' */
+
+static const CoordRec char91_stroke0[] = {
+    { 7.78, 119.048 },
+    { 7.78, -33.3333 },
+};
+
+static const CoordRec char91_stroke1[] = {
+    { 12.5419, 119.048 },
+    { 12.5419, -33.3333 },
+};
+
+static const CoordRec char91_stroke2[] = {
+    { 7.78, 119.048 },
+    { 41.1133, 119.048 },
+};
+
+static const CoordRec char91_stroke3[] = {
+    { 7.78, -33.3333 },
+    { 41.1133, -33.3333 },
+};
+
+static const StrokeRec char91[] = {
+   { 2, char91_stroke0 },
+   { 2, char91_stroke1 },
+   { 2, char91_stroke2 },
+   { 2, char91_stroke3 },
+};
+
+/* char: 92 '\' */
+
+static const CoordRec char92_stroke0[] = {
+    { 5.84, 100 },
+    { 72.5067, -14.2857 },
+};
+
+static const StrokeRec char92[] = {
+   { 2, char92_stroke0 },
+};
+
+/* char: 93 ']' */
+
+static const CoordRec char93_stroke0[] = {
+    { 33.0114, 119.048 },
+    { 33.0114, -33.3333 },
+};
+
+static const CoordRec char93_stroke1[] = {
+    { 37.7733, 119.048 },
+    { 37.7733, -33.3333 },
+};
+
+static const CoordRec char93_stroke2[] = {
+    { 4.44, 119.048 },
+    { 37.7733, 119.048 },
+};
+
+static const CoordRec char93_stroke3[] = {
+    { 4.44, -33.3333 },
+    { 37.7733, -33.3333 },
+};
+
+static const StrokeRec char93[] = {
+   { 2, char93_stroke0 },
+   { 2, char93_stroke1 },
+   { 2, char93_stroke2 },
+   { 2, char93_stroke3 },
+};
+
+/* char: 94 '^' */
+
+static const CoordRec char94_stroke0[] = {
+    { 44.0752, 109.524 },
+    { 5.98, 42.8571 },
+};
+
+static const CoordRec char94_stroke1[] = {
+    { 44.0752, 109.524 },
+    { 82.1705, 42.8571 },
+};
+
+static const StrokeRec char94[] = {
+   { 2, char94_stroke0 },
+   { 2, char94_stroke1 },
+};
+
+/* char: 95 '_' */
+
+static const CoordRec char95_stroke0[] = {
+    { -1.1, -33.3333 },
+    { 103.662, -33.3333 },
+    { 103.662, -28.5714 },
+    { -1.1, -28.5714 },
+    { -1.1, -33.3333 },
+};
+
+static const StrokeRec char95[] = {
+   { 5, char95_stroke0 },
+};
+
+/* char: 96 '`' */
+
+static const CoordRec char96_stroke0[] = {
+    { 33.0219, 100 },
+    { 56.8314, 71.4286 },
+};
+
+static const CoordRec char96_stroke1[] = {
+    { 33.0219, 100 },
+    { 28.26, 95.2381 },
+    { 56.8314, 71.4286 },
+};
+
+static const StrokeRec char96[] = {
+   { 2, char96_stroke0 },
+   { 3, char96_stroke1 },
+};
+
+/* char: 97 'a' */
+
+static const CoordRec char97_stroke0[] = {
+    { 63.8229, 66.6667 },
+    { 63.8229, 0 },
+};
+
+static const CoordRec char97_stroke1[] = {
+    { 63.8229, 52.381 },
+    { 54.299, 61.9048 },
+    { 44.7752, 66.6667 },
+    { 30.4895, 66.6667 },
+    { 20.9657, 61.9048 },
+    { 11.4419, 52.381 },
+    { 6.68, 38.0952 },
+    { 6.68, 28.5714 },
+    { 11.4419, 14.2857 },
+    { 20.9657, 4.7619 },
+    { 30.4895, 0 },
+    { 44.7752, 0 },
+    { 54.299, 4.7619 },
+    { 63.8229, 14.2857 },
+};
+
+static const StrokeRec char97[] = {
+   { 2, char97_stroke0 },
+   { 14, char97_stroke1 },
+};
+
+/* char: 98 'b' */
+
+static const CoordRec char98_stroke0[] = {
+    { 8.76, 100 },
+    { 8.76, 0 },
+};
+
+static const CoordRec char98_stroke1[] = {
+    { 8.76, 52.381 },
+    { 18.2838, 61.9048 },
+    { 27.8076, 66.6667 },
+    { 42.0933, 66.6667 },
+    { 51.6171, 61.9048 },
+    { 61.141, 52.381 },
+    { 65.9029, 38.0952 },
+    { 65.9029, 28.5714 },
+    { 61.141, 14.2857 },
+    { 51.6171, 4.7619 },
+    { 42.0933, 0 },
+    { 27.8076, 0 },
+    { 18.2838, 4.7619 },
+    { 8.76, 14.2857 },
+};
+
+static const StrokeRec char98[] = {
+   { 2, char98_stroke0 },
+   { 14, char98_stroke1 },
+};
+
+/* char: 99 'c' */
+
+static const CoordRec char99_stroke0[] = {
+    { 62.6629, 52.381 },
+    { 53.139, 61.9048 },
+    { 43.6152, 66.6667 },
+    { 29.3295, 66.6667 },
+    { 19.8057, 61.9048 },
+    { 10.2819, 52.381 },
+    { 5.52, 38.0952 },
+    { 5.52, 28.5714 },
+    { 10.2819, 14.2857 },
+    { 19.8057, 4.7619 },
+    { 29.3295, 0 },
+    { 43.6152, 0 },
+    { 53.139, 4.7619 },
+    { 62.6629, 14.2857 },
+};
+
+static const StrokeRec char99[] = {
+   { 14, char99_stroke0 },
+};
+
+/* char: 100 'd' */
+
+static const CoordRec char100_stroke0[] = {
+    { 61.7829, 100 },
+    { 61.7829, 0 },
+};
+
+static const CoordRec char100_stroke1[] = {
+    { 61.7829, 52.381 },
+    { 52.259, 61.9048 },
+    { 42.7352, 66.6667 },
+    { 28.4495, 66.6667 },
+    { 18.9257, 61.9048 },
+    { 9.4019, 52.381 },
+    { 4.64, 38.0952 },
+    { 4.64, 28.5714 },
+    { 9.4019, 14.2857 },
+    { 18.9257, 4.7619 },
+    { 28.4495, 0 },
+    { 42.7352, 0 },
+    { 52.259, 4.7619 },
+    { 61.7829, 14.2857 },
+};
+
+static const StrokeRec char100[] = {
+   { 2, char100_stroke0 },
+   { 14, char100_stroke1 },
+};
+
+/* char: 101 'e' */
+
+static const CoordRec char101_stroke0[] = {
+    { 5.72, 38.0952 },
+    { 62.8629, 38.0952 },
+    { 62.8629, 47.619 },
+    { 58.101, 57.1429 },
+    { 53.339, 61.9048 },
+    { 43.8152, 66.6667 },
+    { 29.5295, 66.6667 },
+    { 20.0057, 61.9048 },
+    { 10.4819, 52.381 },
+    { 5.72, 38.0952 },
+    { 5.72, 28.5714 },
+    { 10.4819, 14.2857 },
+    { 20.0057, 4.7619 },
+    { 29.5295, 0 },
+    { 43.8152, 0 },
+    { 53.339, 4.7619 },
+    { 62.8629, 14.2857 },
+};
+
+static const StrokeRec char101[] = {
+   { 17, char101_stroke0 },
+};
+
+/* char: 102 'f' */
+
+static const CoordRec char102_stroke0[] = {
+    { 38.7752, 100 },
+    { 29.2514, 100 },
+    { 19.7276, 95.2381 },
+    { 14.9657, 80.9524 },
+    { 14.9657, 0 },
+};
+
+static const CoordRec char102_stroke1[] = {
+    { 0.68, 66.6667 },
+    { 34.0133, 66.6667 },
+};
+
+static const StrokeRec char102[] = {
+   { 5, char102_stroke0 },
+   { 2, char102_stroke1 },
+};
+
+/* char: 103 'g' */
+
+static const CoordRec char103_stroke0[] = {
+    { 62.5029, 66.6667 },
+    { 62.5029, -9.5238 },
+    { 57.741, -23.8095 },
+    { 52.979, -28.5714 },
+    { 43.4552, -33.3333 },
+    { 29.1695, -33.3333 },
+    { 19.6457, -28.5714 },
+};
+
+static const CoordRec char103_stroke1[] = {
+    { 62.5029, 52.381 },
+    { 52.979, 61.9048 },
+    { 43.4552, 66.6667 },
+    { 29.1695, 66.6667 },
+    { 19.6457, 61.9048 },
+    { 10.1219, 52.381 },
+    { 5.36, 38.0952 },
+    { 5.36, 28.5714 },
+    { 10.1219, 14.2857 },
+    { 19.6457, 4.7619 },
+    { 29.1695, 0 },
+    { 43.4552, 0 },
+    { 52.979, 4.7619 },
+    { 62.5029, 14.2857 },
+};
+
+static const StrokeRec char103[] = {
+   { 7, char103_stroke0 },
+   { 14, char103_stroke1 },
+};
+
+/* char: 104 'h' */
+
+static const CoordRec char104_stroke0[] = {
+    { 9.6, 100 },
+    { 9.6, 0 },
+};
+
+static const CoordRec char104_stroke1[] = {
+    { 9.6, 47.619 },
+    { 23.8857, 61.9048 },
+    { 33.4095, 66.6667 },
+    { 47.6952, 66.6667 },
+    { 57.219, 61.9048 },
+    { 61.981, 47.619 },
+    { 61.981, 0 },
+};
+
+static const StrokeRec char104[] = {
+   { 2, char104_stroke0 },
+   { 7, char104_stroke1 },
+};
+
+/* char: 105 'i' */
+
+static const CoordRec char105_stroke0[] = {
+    { 10.02, 100 },
+    { 14.7819, 95.2381 },
+    { 19.5438, 100 },
+    { 14.7819, 104.762 },
+    { 10.02, 100 },
+};
+
+static const CoordRec char105_stroke1[] = {
+    { 14.7819, 66.6667 },
+    { 14.7819, 0 },
+};
+
+static const StrokeRec char105[] = {
+   { 5, char105_stroke0 },
+   { 2, char105_stroke1 },
+};
+
+/* char: 106 'j' */
+
+static const CoordRec char106_stroke0[] = {
+    { 17.3876, 100 },
+    { 22.1495, 95.2381 },
+    { 26.9114, 100 },
+    { 22.1495, 104.762 },
+    { 17.3876, 100 },
+};
+
+static const CoordRec char106_stroke1[] = {
+    { 22.1495, 66.6667 },
+    { 22.1495, -14.2857 },
+    { 17.3876, -28.5714 },
+    { 7.8638, -33.3333 },
+    { -1.66, -33.3333 },
+};
+
+static const StrokeRec char106[] = {
+   { 5, char106_stroke0 },
+   { 5, char106_stroke1 },
+};
+
+/* char: 107 'k' */
+
+static const CoordRec char107_stroke0[] = {
+    { 9.6, 100 },
+    { 9.6, 0 },
+};
+
+static const CoordRec char107_stroke1[] = {
+    { 57.219, 66.6667 },
+    { 9.6, 19.0476 },
+};
+
+static const CoordRec char107_stroke2[] = {
+    { 28.6476, 38.0952 },
+    { 61.981, 0 },
+};
+
+static const StrokeRec char107[] = {
+   { 2, char107_stroke0 },
+   { 2, char107_stroke1 },
+   { 2, char107_stroke2 },
+};
+
+/* char: 108 'l' */
+
+static const CoordRec char108_stroke0[] = {
+    { 10.02, 100 },
+    { 10.02, 0 },
+};
+
+static const StrokeRec char108[] = {
+   { 2, char108_stroke0 },
+};
+
+/* char: 109 'm' */
+
+static const CoordRec char109_stroke0[] = {
+    { 9.6, 66.6667 },
+    { 9.6, 0 },
+};
+
+static const CoordRec char109_stroke1[] = {
+    { 9.6, 47.619 },
+    { 23.8857, 61.9048 },
+    { 33.4095, 66.6667 },
+    { 47.6952, 66.6667 },
+    { 57.219, 61.9048 },
+    { 61.981, 47.619 },
+    { 61.981, 0 },
+};
+
+static const CoordRec char109_stroke2[] = {
+    { 61.981, 47.619 },
+    { 76.2667, 61.9048 },
+    { 85.7905, 66.6667 },
+    { 100.076, 66.6667 },
+    { 109.6, 61.9048 },
+    { 114.362, 47.619 },
+    { 114.362, 0 },
+};
+
+static const StrokeRec char109[] = {
+   { 2, char109_stroke0 },
+   { 7, char109_stroke1 },
+   { 7, char109_stroke2 },
+};
+
+/* char: 110 'n' */
+
+static const CoordRec char110_stroke0[] = {
+    { 9.18, 66.6667 },
+    { 9.18, 0 },
+};
+
+static const CoordRec char110_stroke1[] = {
+    { 9.18, 47.619 },
+    { 23.4657, 61.9048 },
+    { 32.9895, 66.6667 },
+    { 47.2752, 66.6667 },
+    { 56.799, 61.9048 },
+    { 61.561, 47.619 },
+    { 61.561, 0 },
+};
+
+static const StrokeRec char110[] = {
+   { 2, char110_stroke0 },
+   { 7, char110_stroke1 },
+};
+
+/* char: 111 'o' */
+
+static const CoordRec char111_stroke0[] = {
+    { 28.7895, 66.6667 },
+    { 19.2657, 61.9048 },
+    { 9.7419, 52.381 },
+    { 4.98, 38.0952 },
+    { 4.98, 28.5714 },
+    { 9.7419, 14.2857 },
+    { 19.2657, 4.7619 },
+    { 28.7895, 0 },
+    { 43.0752, 0 },
+    { 52.599, 4.7619 },
+    { 62.1229, 14.2857 },
+    { 66.8848, 28.5714 },
+    { 66.8848, 38.0952 },
+    { 62.1229, 52.381 },
+    { 52.599, 61.9048 },
+    { 43.0752, 66.6667 },
+    { 28.7895, 66.6667 },
+};
+
+static const StrokeRec char111[] = {
+   { 17, char111_stroke0 },
+};
+
+/* char: 112 'p' */
+
+static const CoordRec char112_stroke0[] = {
+    { 9.46, 66.6667 },
+    { 9.46, -33.3333 },
+};
+
+static const CoordRec char112_stroke1[] = {
+    { 9.46, 52.381 },
+    { 18.9838, 61.9048 },
+    { 28.5076, 66.6667 },
+    { 42.7933, 66.6667 },
+    { 52.3171, 61.9048 },
+    { 61.841, 52.381 },
+    { 66.6029, 38.0952 },
+    { 66.6029, 28.5714 },
+    { 61.841, 14.2857 },
+    { 52.3171, 4.7619 },
+    { 42.7933, 0 },
+    { 28.5076, 0 },
+    { 18.9838, 4.7619 },
+    { 9.46, 14.2857 },
+};
+
+static const StrokeRec char112[] = {
+   { 2, char112_stroke0 },
+   { 14, char112_stroke1 },
+};
+
+/* char: 113 'q' */
+
+static const CoordRec char113_stroke0[] = {
+    { 61.9829, 66.6667 },
+    { 61.9829, -33.3333 },
+};
+
+static const CoordRec char113_stroke1[] = {
+    { 61.9829, 52.381 },
+    { 52.459, 61.9048 },
+    { 42.9352, 66.6667 },
+    { 28.6495, 66.6667 },
+    { 19.1257, 61.9048 },
+    { 9.6019, 52.381 },
+    { 4.84, 38.0952 },
+    { 4.84, 28.5714 },
+    { 9.6019, 14.2857 },
+    { 19.1257, 4.7619 },
+    { 28.6495, 0 },
+    { 42.9352, 0 },
+    { 52.459, 4.7619 },
+    { 61.9829, 14.2857 },
+};
+
+static const StrokeRec char113[] = {
+   { 2, char113_stroke0 },
+   { 14, char113_stroke1 },
+};
+
+/* char: 114 'r' */
+
+static const CoordRec char114_stroke0[] = {
+    { 9.46, 66.6667 },
+    { 9.46, 0 },
+};
+
+static const CoordRec char114_stroke1[] = {
+    { 9.46, 38.0952 },
+    { 14.2219, 52.381 },
+    { 23.7457, 61.9048 },
+    { 33.2695, 66.6667 },
+    { 47.5552, 66.6667 },
+};
+
+static const StrokeRec char114[] = {
+   { 2, char114_stroke0 },
+   { 5, char114_stroke1 },
+};
+
+/* char: 115 's' */
+
+static const CoordRec char115_stroke0[] = {
+    { 57.081, 52.381 },
+    { 52.319, 61.9048 },
+    { 38.0333, 66.6667 },
+    { 23.7476, 66.6667 },
+    { 9.4619, 61.9048 },
+    { 4.7, 52.381 },
+    { 9.4619, 42.8571 },
+    { 18.9857, 38.0952 },
+    { 42.7952, 33.3333 },
+    { 52.319, 28.5714 },
+    { 57.081, 19.0476 },
+    { 57.081, 14.2857 },
+    { 52.319, 4.7619 },
+    { 38.0333, 0 },
+    { 23.7476, 0 },
+    { 9.4619, 4.7619 },
+    { 4.7, 14.2857 },
+};
+
+static const StrokeRec char115[] = {
+   { 17, char115_stroke0 },
+};
+
+/* char: 116 't' */
+
+static const CoordRec char116_stroke0[] = {
+    { 14.8257, 100 },
+    { 14.8257, 19.0476 },
+    { 19.5876, 4.7619 },
+    { 29.1114, 0 },
+    { 38.6352, 0 },
+};
+
+static const CoordRec char116_stroke1[] = {
+    { 0.54, 66.6667 },
+    { 33.8733, 66.6667 },
+};
+
+static const StrokeRec char116[] = {
+   { 5, char116_stroke0 },
+   { 2, char116_stroke1 },
+};
+
+/* char: 117 'u' */
+
+static const CoordRec char117_stroke0[] = {
+    { 9.46, 66.6667 },
+    { 9.46, 19.0476 },
+    { 14.2219, 4.7619 },
+    { 23.7457, 0 },
+    { 38.0314, 0 },
+    { 47.5552, 4.7619 },
+    { 61.841, 19.0476 },
+};
+
+static const CoordRec char117_stroke1[] = {
+    { 61.841, 66.6667 },
+    { 61.841, 0 },
+};
+
+static const StrokeRec char117[] = {
+   { 7, char117_stroke0 },
+   { 2, char117_stroke1 },
+};
+
+/* char: 118 'v' */
+
+static const CoordRec char118_stroke0[] = {
+    { 1.8, 66.6667 },
+    { 30.3714, 0 },
+};
+
+static const CoordRec char118_stroke1[] = {
+    { 58.9429, 66.6667 },
+    { 30.3714, 0 },
+};
+
+static const StrokeRec char118[] = {
+   { 2, char118_stroke0 },
+   { 2, char118_stroke1 },
+};
+
+/* char: 119 'w' */
+
+static const CoordRec char119_stroke0[] = {
+    { 2.5, 66.6667 },
+    { 21.5476, 0 },
+};
+
+static const CoordRec char119_stroke1[] = {
+    { 40.5952, 66.6667 },
+    { 21.5476, 0 },
+};
+
+static const CoordRec char119_stroke2[] = {
+    { 40.5952, 66.6667 },
+    { 59.6429, 0 },
+};
+
+static const CoordRec char119_stroke3[] = {
+    { 78.6905, 66.6667 },
+    { 59.6429, 0 },
+};
+
+static const StrokeRec char119[] = {
+   { 2, char119_stroke0 },
+   { 2, char119_stroke1 },
+   { 2, char119_stroke2 },
+   { 2, char119_stroke3 },
+};
+
+/* char: 120 'x' */
+
+static const CoordRec char120_stroke0[] = {
+    { 1.66, 66.6667 },
+    { 54.041, 0 },
+};
+
+static const CoordRec char120_stroke1[] = {
+    { 54.041, 66.6667 },
+    { 1.66, 0 },
+};
+
+static const StrokeRec char120[] = {
+   { 2, char120_stroke0 },
+   { 2, char120_stroke1 },
+};
+
+/* char: 121 'y' */
+
+static const CoordRec char121_stroke0[] = {
+    { 6.5619, 66.6667 },
+    { 35.1333, 0 },
+};
+
+static const CoordRec char121_stroke1[] = {
+    { 63.7048, 66.6667 },
+    { 35.1333, 0 },
+    { 25.6095, -19.0476 },
+    { 16.0857, -28.5714 },
+    { 6.5619, -33.3333 },
+    { 1.8, -33.3333 },
+};
+
+static const StrokeRec char121[] = {
+   { 2, char121_stroke0 },
+   { 6, char121_stroke1 },
+};
+
+/* char: 122 'z' */
+
+static const CoordRec char122_stroke0[] = {
+    { 56.821, 66.6667 },
+    { 4.44, 0 },
+};
+
+static const CoordRec char122_stroke1[] = {
+    { 4.44, 66.6667 },
+    { 56.821, 66.6667 },
+};
+
+static const CoordRec char122_stroke2[] = {
+    { 4.44, 0 },
+    { 56.821, 0 },
+};
+
+static const StrokeRec char122[] = {
+   { 2, char122_stroke0 },
+   { 2, char122_stroke1 },
+   { 2, char122_stroke2 },
+};
+
+/* char: 123 '{' */
+
+static const CoordRec char123_stroke0[] = {
+    { 31.1895, 119.048 },
+    { 21.6657, 114.286 },
+    { 16.9038, 109.524 },
+    { 12.1419, 100 },
+    { 12.1419, 90.4762 },
+    { 16.9038, 80.9524 },
+    { 21.6657, 76.1905 },
+    { 26.4276, 66.6667 },
+    { 26.4276, 57.1429 },
+    { 16.9038, 47.619 },
+};
+
+static const CoordRec char123_stroke1[] = {
+    { 21.6657, 114.286 },
+    { 16.9038, 104.762 },
+    { 16.9038, 95.2381 },
+    { 21.6657, 85.7143 },
+    { 26.4276, 80.9524 },
+    { 31.1895, 71.4286 },
+    { 31.1895, 61.9048 },
+    { 26.4276, 52.381 },
+    { 7.38, 42.8571 },
+    { 26.4276, 33.3333 },
+    { 31.1895, 23.8095 },
+    { 31.1895, 14.2857 },
+    { 26.4276, 4.7619 },
+    { 21.6657, 0 },
+    { 16.9038, -9.5238 },
+    { 16.9038, -19.0476 },
+    { 21.6657, -28.5714 },
+};
+
+static const CoordRec char123_stroke2[] = {
+    { 16.9038, 38.0952 },
+    { 26.4276, 28.5714 },
+    { 26.4276, 19.0476 },
+    { 21.6657, 9.5238 },
+    { 16.9038, 4.7619 },
+    { 12.1419, -4.7619 },
+    { 12.1419, -14.2857 },
+    { 16.9038, -23.8095 },
+    { 21.6657, -28.5714 },
+    { 31.1895, -33.3333 },
+};
+
+static const StrokeRec char123[] = {
+   { 10, char123_stroke0 },
+   { 17, char123_stroke1 },
+   { 10, char123_stroke2 },
+};
+
+/* char: 124 '|' */
+
+static const CoordRec char124_stroke0[] = {
+    { 11.54, 119.048 },
+    { 11.54, -33.3333 },
+};
+
+static const StrokeRec char124[] = {
+   { 2, char124_stroke0 },
+};
+
+/* char: 125 '}' */
+
+static const CoordRec char125_stroke0[] = {
+    { 9.18, 119.048 },
+    { 18.7038, 114.286 },
+    { 23.4657, 109.524 },
+    { 28.2276, 100 },
+    { 28.2276, 90.4762 },
+    { 23.4657, 80.9524 },
+    { 18.7038, 76.1905 },
+    { 13.9419, 66.6667 },
+    { 13.9419, 57.1429 },
+    { 23.4657, 47.619 },
+};
+
+static const CoordRec char125_stroke1[] = {
+    { 18.7038, 114.286 },
+    { 23.4657, 104.762 },
+    { 23.4657, 95.2381 },
+    { 18.7038, 85.7143 },
+    { 13.9419, 80.9524 },
+    { 9.18, 71.4286 },
+    { 9.18, 61.9048 },
+    { 13.9419, 52.381 },
+    { 32.9895, 42.8571 },
+    { 13.9419, 33.3333 },
+    { 9.18, 23.8095 },
+    { 9.18, 14.2857 },
+    { 13.9419, 4.7619 },
+    { 18.7038, 0 },
+    { 23.4657, -9.5238 },
+    { 23.4657, -19.0476 },
+    { 18.7038, -28.5714 },
+};
+
+static const CoordRec char125_stroke2[] = {
+    { 23.4657, 38.0952 },
+    { 13.9419, 28.5714 },
+    { 13.9419, 19.0476 },
+    { 18.7038, 9.5238 },
+    { 23.4657, 4.7619 },
+    { 28.2276, -4.7619 },
+    { 28.2276, -14.2857 },
+    { 23.4657, -23.8095 },
+    { 18.7038, -28.5714 },
+    { 9.18, -33.3333 },
+};
+
+static const StrokeRec char125[] = {
+   { 10, char125_stroke0 },
+   { 17, char125_stroke1 },
+   { 10, char125_stroke2 },
+};
+
+/* char: 126 '~' */
+
+static const CoordRec char126_stroke0[] = {
+    { 2.92, 28.5714 },
+    { 2.92, 38.0952 },
+    { 7.6819, 52.381 },
+    { 17.2057, 57.1429 },
+    { 26.7295, 57.1429 },
+    { 36.2533, 52.381 },
+    { 55.301, 38.0952 },
+    { 64.8248, 33.3333 },
+    { 74.3486, 33.3333 },
+    { 83.8724, 38.0952 },
+    { 88.6343, 47.619 },
+};
+
+static const CoordRec char126_stroke1[] = {
+    { 2.92, 38.0952 },
+    { 7.6819, 47.619 },
+    { 17.2057, 52.381 },
+    { 26.7295, 52.381 },
+    { 36.2533, 47.619 },
+    { 55.301, 33.3333 },
+    { 64.8248, 28.5714 },
+    { 74.3486, 28.5714 },
+    { 83.8724, 33.3333 },
+    { 88.6343, 47.619 },
+    { 88.6343, 57.1429 },
+};
+
+static const StrokeRec char126[] = {
+   { 11, char126_stroke0 },
+   { 11, char126_stroke1 },
+};
+
+/* char: 127 */
+
+static const CoordRec char127_stroke0[] = {
+    { 52.381, 100 },
+    { 14.2857, -33.3333 },
+};
+
+static const CoordRec char127_stroke1[] = {
+    { 28.5714, 66.6667 },
+    { 14.2857, 61.9048 },
+    { 4.7619, 52.381 },
+    { 0, 38.0952 },
+    { 0, 23.8095 },
+    { 4.7619, 14.2857 },
+    { 14.2857, 4.7619 },
+    { 28.5714, 0 },
+    { 38.0952, 0 },
+    { 52.381, 4.7619 },
+    { 61.9048, 14.2857 },
+    { 66.6667, 28.5714 },
+    { 66.6667, 42.8571 },
+    { 61.9048, 52.381 },
+    { 52.381, 61.9048 },
+    { 38.0952, 66.6667 },
+    { 28.5714, 66.6667 },
+};
+
+static const StrokeRec char127[] = {
+   { 2, char127_stroke0 },
+   { 17, char127_stroke1 },
+};
+
+static const StrokeCharRec chars[] = {
+    { 0, /* char0 */ 0, 0, 0 },
+    { 0, /* char1 */ 0, 0, 0 },
+    { 0, /* char2 */ 0, 0, 0 },
+    { 0, /* char3 */ 0, 0, 0 },
+    { 0, /* char4 */ 0, 0, 0 },
+    { 0, /* char5 */ 0, 0, 0 },
+    { 0, /* char6 */ 0, 0, 0 },
+    { 0, /* char7 */ 0, 0, 0 },
+    { 0, /* char8 */ 0, 0, 0 },
+    { 0, /* char9 */ 0, 0, 0 },
+    { 0, /* char10 */ 0, 0, 0 },
+    { 0, /* char11 */ 0, 0, 0 },
+    { 0, /* char12 */ 0, 0, 0 },
+    { 0, /* char13 */ 0, 0, 0 },
+    { 0, /* char14 */ 0, 0, 0 },
+    { 0, /* char15 */ 0, 0, 0 },
+    { 0, /* char16 */ 0, 0, 0 },
+    { 0, /* char17 */ 0, 0, 0 },
+    { 0, /* char18 */ 0, 0, 0 },
+    { 0, /* char19 */ 0, 0, 0 },
+    { 0, /* char20 */ 0, 0, 0 },
+    { 0, /* char21 */ 0, 0, 0 },
+    { 0, /* char22 */ 0, 0, 0 },
+    { 0, /* char23 */ 0, 0, 0 },
+    { 0, /* char24 */ 0, 0, 0 },
+    { 0, /* char25 */ 0, 0, 0 },
+    { 0, /* char26 */ 0, 0, 0 },
+    { 0, /* char27 */ 0, 0, 0 },
+    { 0, /* char28 */ 0, 0, 0 },
+    { 0, /* char29 */ 0, 0, 0 },
+    { 0, /* char30 */ 0, 0, 0 },
+    { 0, /* char31 */ 0, 0, 0 },
+    { 0, /* char32 */ 0, 52.381, 104.762 },
+    { 2, char33, 13.3819, 26.6238 },
+    { 2, char34, 23.0676, 51.4352 },
+    { 4, char35, 36.5333, 79.4886 },
+    { 3, char36, 38.1533, 76.2067 },
+    { 3, char37, 49.2171, 96.5743 },
+    { 1, char38, 53.599, 101.758 },
+    { 1, char39, 4.44, 13.62 },
+    { 1, char40, 21.8657, 47.1733 },
+    { 1, char41, 24.3276, 47.5333 },
+    { 3, char42, 30.7695, 59.439 },
+    { 2, char43, 48.8371, 97.2543 },
+    { 1, char44, 13.5219, 26.0638 },
+    { 1, char45, 50.2371, 100.754 },
+    { 1, char46, 13.1019, 26.4838 },
+    { 1, char47, 40.5733, 82.1067 },
+    { 1, char48, 38.3133, 77.0667 },
+    { 1, char49, 30.8676, 66.5295 },
+    { 1, char50, 38.7533, 77.6467 },
+    { 1, char51, 38.3333, 77.0467 },
+    { 2, char52, 37.2133, 80.1686 },
+    { 1, char53, 38.1933, 77.6867 },
+    { 1, char54, 34.1514, 73.8048 },
+    { 2, char55, 38.8933, 77.2267 },
+    { 1, char56, 38.9333, 77.6667 },
+    { 1, char57, 39.9333, 74.0648 },
+    { 2, char58, 14.0819, 26.2238 },
+    { 2, char59, 12.9619, 26.3038 },
+    { 1, char60, 41.1552, 81.6105 },
+    { 2, char61, 48.5571, 97.2543 },
+    { 1, char62, 40.8752, 81.6105 },
+    { 2, char63, 36.9914, 73.9029 },
+    { 2, char64, 34.9314, 74.3648 },
+    { 3, char65, 40.5952, 80.4905 },
+    { 3, char66, 44.7533, 83.6267 },
+    { 1, char67, 39.9933, 84.4886 },
+    { 2, char68, 45.2933, 85.2867 },
+    { 4, char69, 39.9914, 78.1848 },
+    { 3, char70, 39.9914, 78.7448 },
+    { 2, char71, 40.3933, 89.7686 },
+    { 3, char72, 44.7533, 89.0867 },
+    { 1, char73, 10.86, 21.3 },
+    { 1, char74, 31.0714, 59.999 },
+    { 3, char75, 44.6133, 79.3267 },
+    { 2, char76, 40.2514, 71.3229 },
+    { 4, char77, 48.9552, 97.2105 },
+    { 3, char78, 44.4733, 88.8067 },
+    { 1, char79, 44.3352, 88.8305 },
+    { 2, char80, 45.4333, 85.6667 },
+    { 2, char81, 43.3952, 88.0905 },
+    { 3, char82, 45.0133, 82.3667 },
+    { 1, char83, 41.3333, 80.8267 },
+    { 2, char84, 35.6933, 71.9467 },
+    { 1, char85, 44.8733, 89.4867 },
+    { 2, char86, 40.4552, 81.6105 },
+    { 4, char87, 49.839, 100.518 },
+    { 2, char88, 35.8333, 72.3667 },
+    { 2, char89, 39.6152, 79.6505 },
+    { 3, char90, 35.8333, 73.7467 },
+    { 4, char91, 22.0657, 46.1133 },
+    { 1, char92, 39.1733, 78.2067 },
+    { 4, char93, 23.4876, 46.3933 },
+    { 2, char94, 44.0752, 90.2305 },
+    { 1, char95, 51.281, 104.062 },
+    { 2, char96, 42.5457, 83.5714 },
+    { 2, char97, 35.2514, 66.6029 },
+    { 2, char98, 37.3314, 70.4629 },
+    { 1, char99, 34.0914, 68.9229 },
+    { 2, char100, 33.2114, 70.2629 },
+    { 1, char101, 34.2914, 68.5229 },
+    { 2, char102, 14.9657, 38.6552 },
+    { 2, char103, 33.9314, 70.9829 },
+    { 2, char104, 33.4095, 71.021 },
+    { 2, char105, 14.7819, 28.8638 },
+    { 2, char106, 17.3876, 36.2314 },
+    { 3, char107, 33.4095, 62.521 },
+    { 1, char108, 10.02, 19.34 },
+    { 3, char109, 61.981, 123.962 },
+    { 2, char110, 32.9895, 70.881 },
+    { 1, char111, 33.5514, 71.7448 },
+    { 2, char112, 38.0314, 70.8029 },
+    { 2, char113, 33.4114, 70.7429 },
+    { 2, char114, 23.7457, 49.4952 },
+    { 1, char115, 28.5095, 62.321 },
+    { 2, char116, 14.8257, 39.3152 },
+    { 2, char117, 33.2695, 71.161 },
+    { 2, char118, 30.3714, 60.6029 },
+    { 4, char119, 40.5952, 80.4905 },
+    { 2, char120, 25.4695, 56.401 },
+    { 2, char121, 35.1333, 66.0648 },
+    { 3, char122, 28.2495, 61.821 },
+    { 3, char123, 21.6657, 41.6295 },
+    { 1, char124, 11.54, 23.78 },
+    { 3, char125, 18.7038, 41.4695 },
+    { 2, char126, 45.7771, 91.2743 },
+    { 2, char127, 33.3333, 66.6667 },
+};
+
+StrokeFontRec glutStrokeRoman = { "Roman", 128, chars, 119.048, -33.3333 };
+
diff --git a/src/glut/glx/glut_shapes.c b/src/glut/glx/glut_shapes.c
new file mode 100644
index 0000000000..ce5bebb2be
--- /dev/null
+++ b/src/glut/glx/glut_shapes.c
@@ -0,0 +1,596 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
+
+/**
+(c) Copyright 1993, Silicon Graphics, Inc.
+
+ALL RIGHTS RESERVED
+
+Permission to use, copy, modify, and distribute this software
+for any purpose and without fee is hereby granted, provided
+that the above copyright notice appear in all copies and that
+both the copyright notice and this permission notice appear in
+supporting documentation, and that the name of Silicon
+Graphics, Inc. not be used in advertising or publicity
+pertaining to distribution of the software without specific,
+written prior permission.
+
+THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
+"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
+OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
+MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  IN NO
+EVENT SHALL SILICON GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE
+ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
+INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
+SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
+NOT SILICON GRAPHICS, INC.  HAS BEEN ADVISED OF THE POSSIBILITY
+OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+US Government Users Restricted Rights
+
+Use, duplication, or disclosure by the Government is subject to
+restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+(c)(1)(ii) of the Rights in Technical Data and Computer
+Software clause at DFARS 252.227-7013 and/or in similar or
+successor clauses in the FAR or the DOD or NASA FAR
+Supplement.  Unpublished-- rights reserved under the copyright
+laws of the United States.  Contractor/manufacturer is Silicon
+Graphics, Inc., 2011 N.  Shoreline Blvd., Mountain View, CA
+94039-7311.
+
+OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+*/
+
+#include <math.h>
+#include "glutint.h"
+
+/* Some <math.h> files do not define M_PI... */
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+static GLUquadricObj *quadObj;
+
+#define QUAD_OBJ_INIT() { if(!quadObj) initQuadObj(); }
+
+static void
+initQuadObj(void)
+{
+  quadObj = gluNewQuadric();
+  if (!quadObj)
+    __glutFatalError("out of memory.");
+}
+
+/* CENTRY */
+void APIENTRY
+glutWireSphere(GLdouble radius, GLint slices, GLint stacks)
+{
+  QUAD_OBJ_INIT();
+  gluQuadricDrawStyle(quadObj, GLU_LINE);
+  gluQuadricNormals(quadObj, GLU_SMOOTH);
+  /* If we ever changed/used the texture or orientation state
+     of quadObj, we'd need to change it to the defaults here
+     with gluQuadricTexture and/or gluQuadricOrientation. */
+  gluSphere(quadObj, radius, slices, stacks);
+}
+
+void APIENTRY
+glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)
+{
+  QUAD_OBJ_INIT();
+  gluQuadricDrawStyle(quadObj, GLU_FILL);
+  gluQuadricNormals(quadObj, GLU_SMOOTH);
+  /* If we ever changed/used the texture or orientation state
+     of quadObj, we'd need to change it to the defaults here
+     with gluQuadricTexture and/or gluQuadricOrientation. */
+  gluSphere(quadObj, radius, slices, stacks);
+}
+
+void APIENTRY
+glutWireCone(GLdouble base, GLdouble height,
+  GLint slices, GLint stacks)
+{
+  QUAD_OBJ_INIT();
+  gluQuadricDrawStyle(quadObj, GLU_LINE);
+  gluQuadricNormals(quadObj, GLU_SMOOTH);
+  /* If we ever changed/used the texture or orientation state
+     of quadObj, we'd need to change it to the defaults here
+     with gluQuadricTexture and/or gluQuadricOrientation. */
+  gluCylinder(quadObj, base, 0.0, height, slices, stacks);
+}
+
+void APIENTRY
+glutSolidCone(GLdouble base, GLdouble height,
+  GLint slices, GLint stacks)
+{
+  QUAD_OBJ_INIT();
+  gluQuadricDrawStyle(quadObj, GLU_FILL);
+  gluQuadricNormals(quadObj, GLU_SMOOTH);
+  /* If we ever changed/used the texture or orientation state
+     of quadObj, we'd need to change it to the defaults here
+     with gluQuadricTexture and/or gluQuadricOrientation. */
+  gluCylinder(quadObj, base, 0.0, height, slices, stacks);
+}
+
+/* ENDCENTRY */
+
+static void
+drawBox(GLfloat size, GLenum type)
+{
+  static GLfloat n[6][3] =
+  {
+    {-1.0, 0.0, 0.0},
+    {0.0, 1.0, 0.0},
+    {1.0, 0.0, 0.0},
+    {0.0, -1.0, 0.0},
+    {0.0, 0.0, 1.0},
+    {0.0, 0.0, -1.0}
+  };
+  static GLint faces[6][4] =
+  {
+    {0, 1, 2, 3},
+    {3, 2, 6, 7},
+    {7, 6, 5, 4},
+    {4, 5, 1, 0},
+    {5, 6, 2, 1},
+    {7, 4, 0, 3}
+  };
+  GLfloat v[8][3];
+  GLint i;
+
+  v[0][0] = v[1][0] = v[2][0] = v[3][0] = -size / 2;
+  v[4][0] = v[5][0] = v[6][0] = v[7][0] = size / 2;
+  v[0][1] = v[1][1] = v[4][1] = v[5][1] = -size / 2;
+  v[2][1] = v[3][1] = v[6][1] = v[7][1] = size / 2;
+  v[0][2] = v[3][2] = v[4][2] = v[7][2] = -size / 2;
+  v[1][2] = v[2][2] = v[5][2] = v[6][2] = size / 2;
+
+  for (i = 5; i >= 0; i--) {
+    glBegin(type);
+    glNormal3fv(&n[i][0]);
+    glVertex3fv(&v[faces[i][0]][0]);
+    glVertex3fv(&v[faces[i][1]][0]);
+    glVertex3fv(&v[faces[i][2]][0]);
+    glVertex3fv(&v[faces[i][3]][0]);
+    glEnd();
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutWireCube(GLdouble size)
+{
+  drawBox(size, GL_LINE_LOOP);
+}
+
+void APIENTRY
+glutSolidCube(GLdouble size)
+{
+  drawBox(size, GL_QUADS);
+}
+
+/* ENDCENTRY */
+
+static void
+doughnut(GLfloat r, GLfloat R, GLint nsides, GLint rings)
+{
+  int i, j;
+  GLfloat theta, phi, theta1;
+  GLfloat cosTheta, sinTheta;
+  GLfloat cosTheta1, sinTheta1;
+  GLfloat ringDelta, sideDelta;
+
+  ringDelta = 2.0 * M_PI / rings;
+  sideDelta = 2.0 * M_PI / nsides;
+
+  theta = 0.0;
+  cosTheta = 1.0;
+  sinTheta = 0.0;
+  for (i = rings - 1; i >= 0; i--) {
+    theta1 = theta + ringDelta;
+    cosTheta1 = cos(theta1);
+    sinTheta1 = sin(theta1);
+    glBegin(GL_QUAD_STRIP);
+    phi = 0.0;
+    for (j = nsides; j >= 0; j--) {
+      GLfloat cosPhi, sinPhi, dist;
+
+      phi += sideDelta;
+      cosPhi = cos(phi);
+      sinPhi = sin(phi);
+      dist = R + r * cosPhi;
+
+      glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
+      glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi);
+      glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi);
+      glVertex3f(cosTheta * dist, -sinTheta * dist,  r * sinPhi);
+    }
+    glEnd();
+    theta = theta1;
+    cosTheta = cosTheta1;
+    sinTheta = sinTheta1;
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutWireTorus(GLdouble innerRadius, GLdouble outerRadius,
+  GLint nsides, GLint rings)
+{
+  glPushAttrib(GL_POLYGON_BIT);
+  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+  doughnut(innerRadius, outerRadius, nsides, rings);
+  glPopAttrib();
+}
+
+void APIENTRY
+glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius,
+  GLint nsides, GLint rings)
+{
+  doughnut(innerRadius, outerRadius, nsides, rings);
+}
+
+/* ENDCENTRY */
+
+static GLfloat dodec[20][3];
+
+static void
+initDodecahedron(void)
+{
+  GLfloat alpha, beta;
+
+  alpha = sqrt(2.0 / (3.0 + sqrt(5.0)));
+  beta = 1.0 + sqrt(6.0 / (3.0 + sqrt(5.0)) -
+    2.0 + 2.0 * sqrt(2.0 / (3.0 + sqrt(5.0))));
+  /* *INDENT-OFF* */
+  dodec[0][0] = -alpha; dodec[0][1] = 0; dodec[0][2] = beta;
+  dodec[1][0] = alpha; dodec[1][1] = 0; dodec[1][2] = beta;
+  dodec[2][0] = -1; dodec[2][1] = -1; dodec[2][2] = -1;
+  dodec[3][0] = -1; dodec[3][1] = -1; dodec[3][2] = 1;
+  dodec[4][0] = -1; dodec[4][1] = 1; dodec[4][2] = -1;
+  dodec[5][0] = -1; dodec[5][1] = 1; dodec[5][2] = 1;
+  dodec[6][0] = 1; dodec[6][1] = -1; dodec[6][2] = -1;
+  dodec[7][0] = 1; dodec[7][1] = -1; dodec[7][2] = 1;
+  dodec[8][0] = 1; dodec[8][1] = 1; dodec[8][2] = -1;
+  dodec[9][0] = 1; dodec[9][1] = 1; dodec[9][2] = 1;
+  dodec[10][0] = beta; dodec[10][1] = alpha; dodec[10][2] = 0;
+  dodec[11][0] = beta; dodec[11][1] = -alpha; dodec[11][2] = 0;
+  dodec[12][0] = -beta; dodec[12][1] = alpha; dodec[12][2] = 0;
+  dodec[13][0] = -beta; dodec[13][1] = -alpha; dodec[13][2] = 0;
+  dodec[14][0] = -alpha; dodec[14][1] = 0; dodec[14][2] = -beta;
+  dodec[15][0] = alpha; dodec[15][1] = 0; dodec[15][2] = -beta;
+  dodec[16][0] = 0; dodec[16][1] = beta; dodec[16][2] = alpha;
+  dodec[17][0] = 0; dodec[17][1] = beta; dodec[17][2] = -alpha;
+  dodec[18][0] = 0; dodec[18][1] = -beta; dodec[18][2] = alpha;
+  dodec[19][0] = 0; dodec[19][1] = -beta; dodec[19][2] = -alpha;
+  /* *INDENT-ON* */
+
+}
+
+#define DIFF3(_a,_b,_c) { \
+    (_c)[0] = (_a)[0] - (_b)[0]; \
+    (_c)[1] = (_a)[1] - (_b)[1]; \
+    (_c)[2] = (_a)[2] - (_b)[2]; \
+}
+
+static void
+crossprod(GLfloat v1[3], GLfloat v2[3], GLfloat prod[3])
+{
+  GLfloat p[3];         /* in case prod == v1 or v2 */
+
+  p[0] = v1[1] * v2[2] - v2[1] * v1[2];
+  p[1] = v1[2] * v2[0] - v2[2] * v1[0];
+  p[2] = v1[0] * v2[1] - v2[0] * v1[1];
+  prod[0] = p[0];
+  prod[1] = p[1];
+  prod[2] = p[2];
+}
+
+static void
+normalize(GLfloat v[3])
+{
+  GLfloat d;
+
+  d = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (d == 0.0) {
+    __glutWarning("normalize: zero length vector");
+    v[0] = d = 1.0;
+  }
+  d = 1 / d;
+  v[0] *= d;
+  v[1] *= d;
+  v[2] *= d;
+}
+
+static void
+pentagon(int a, int b, int c, int d, int e, GLenum shadeType)
+{
+  GLfloat n0[3], d1[3], d2[3];
+
+  DIFF3(dodec[a], dodec[b], d1);
+  DIFF3(dodec[b], dodec[c], d2);
+  crossprod(d1, d2, n0);
+  normalize(n0);
+
+  glBegin(shadeType);
+  glNormal3fv(n0);
+  glVertex3fv(&dodec[a][0]);
+  glVertex3fv(&dodec[b][0]);
+  glVertex3fv(&dodec[c][0]);
+  glVertex3fv(&dodec[d][0]);
+  glVertex3fv(&dodec[e][0]);
+  glEnd();
+}
+
+static void
+dodecahedron(GLenum type)
+{
+  static int inited = 0;
+
+  if (inited == 0) {
+    inited = 1;
+    initDodecahedron();
+  }
+  pentagon(0, 1, 9, 16, 5, type);
+  pentagon(1, 0, 3, 18, 7, type);
+  pentagon(1, 7, 11, 10, 9, type);
+  pentagon(11, 7, 18, 19, 6, type);
+  pentagon(8, 17, 16, 9, 10, type);
+  pentagon(2, 14, 15, 6, 19, type);
+  pentagon(2, 13, 12, 4, 14, type);
+  pentagon(2, 19, 18, 3, 13, type);
+  pentagon(3, 0, 5, 12, 13, type);
+  pentagon(6, 15, 8, 10, 11, type);
+  pentagon(4, 17, 8, 15, 14, type);
+  pentagon(4, 12, 5, 16, 17, type);
+}
+
+/* CENTRY */
+void APIENTRY
+glutWireDodecahedron(void)
+{
+  dodecahedron(GL_LINE_LOOP);
+}
+
+void APIENTRY
+glutSolidDodecahedron(void)
+{
+  dodecahedron(GL_TRIANGLE_FAN);
+}
+
+/* ENDCENTRY */
+
+static void
+recorditem(GLfloat * n1, GLfloat * n2, GLfloat * n3,
+  GLenum shadeType)
+{
+  GLfloat q0[3], q1[3];
+
+  DIFF3(n1, n2, q0);
+  DIFF3(n2, n3, q1);
+  crossprod(q0, q1, q1);
+  normalize(q1);
+
+  glBegin(shadeType);
+  glNormal3fv(q1);
+  glVertex3fv(n1);
+  glVertex3fv(n2);
+  glVertex3fv(n3);
+  glEnd();
+}
+
+static void
+subdivide(GLfloat * v0, GLfloat * v1, GLfloat * v2,
+  GLenum shadeType)
+{
+  int depth;
+  GLfloat w0[3], w1[3], w2[3];
+  GLfloat l;
+  int i, j, k, n;
+
+  depth = 1;
+  for (i = 0; i < depth; i++) {
+    for (j = 0; i + j < depth; j++) {
+      k = depth - i - j;
+      for (n = 0; n < 3; n++) {
+        w0[n] = (i * v0[n] + j * v1[n] + k * v2[n]) / depth;
+        w1[n] = ((i + 1) * v0[n] + j * v1[n] + (k - 1) * v2[n])
+          / depth;
+        w2[n] = (i * v0[n] + (j + 1) * v1[n] + (k - 1) * v2[n])
+          / depth;
+      }
+      l = sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]);
+      w0[0] /= l;
+      w0[1] /= l;
+      w0[2] /= l;
+      l = sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]);
+      w1[0] /= l;
+      w1[1] /= l;
+      w1[2] /= l;
+      l = sqrt(w2[0] * w2[0] + w2[1] * w2[1] + w2[2] * w2[2]);
+      w2[0] /= l;
+      w2[1] /= l;
+      w2[2] /= l;
+      recorditem(w1, w0, w2, shadeType);
+    }
+  }
+}
+
+static void
+drawtriangle(int i, GLfloat data[][3], int ndx[][3],
+  GLenum shadeType)
+{
+  GLfloat *x0, *x1, *x2;
+
+  x0 = data[ndx[i][0]];
+  x1 = data[ndx[i][1]];
+  x2 = data[ndx[i][2]];
+  subdivide(x0, x1, x2, shadeType);
+}
+
+/* octahedron data: The octahedron produced is centered at the
+   origin and has radius 1.0 */
+static GLfloat odata[6][3] =
+{
+  {1.0, 0.0, 0.0},
+  {-1.0, 0.0, 0.0},
+  {0.0, 1.0, 0.0},
+  {0.0, -1.0, 0.0},
+  {0.0, 0.0, 1.0},
+  {0.0, 0.0, -1.0}
+};
+
+static int ondex[8][3] =
+{
+  {0, 4, 2},
+  {1, 2, 4},
+  {0, 3, 4},
+  {1, 4, 3},
+  {0, 2, 5},
+  {1, 5, 2},
+  {0, 5, 3},
+  {1, 3, 5}
+};
+
+static void
+octahedron(GLenum shadeType)
+{
+  int i;
+
+  for (i = 7; i >= 0; i--) {
+    drawtriangle(i, odata, ondex, shadeType);
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutWireOctahedron(void)
+{
+  octahedron(GL_LINE_LOOP);
+}
+
+void APIENTRY
+glutSolidOctahedron(void)
+{
+  octahedron(GL_TRIANGLES);
+}
+
+/* ENDCENTRY */
+
+/* icosahedron data: These numbers are rigged to make an
+   icosahedron of radius 1.0 */
+
+#define X .525731112119133606
+#define Z .850650808352039932
+
+static GLfloat idata[12][3] =
+{
+  {-X, 0, Z},
+  {X, 0, Z},
+  {-X, 0, -Z},
+  {X, 0, -Z},
+  {0, Z, X},
+  {0, Z, -X},
+  {0, -Z, X},
+  {0, -Z, -X},
+  {Z, X, 0},
+  {-Z, X, 0},
+  {Z, -X, 0},
+  {-Z, -X, 0}
+};
+
+static int index[20][3] =
+{
+  {0, 4, 1},
+  {0, 9, 4},
+  {9, 5, 4},
+  {4, 5, 8},
+  {4, 8, 1},
+  {8, 10, 1},
+  {8, 3, 10},
+  {5, 3, 8},
+  {5, 2, 3},
+  {2, 7, 3},
+  {7, 10, 3},
+  {7, 6, 10},
+  {7, 11, 6},
+  {11, 0, 6},
+  {0, 1, 6},
+  {6, 1, 10},
+  {9, 0, 11},
+  {9, 11, 2},
+  {9, 2, 5},
+  {7, 2, 11},
+};
+
+static void
+icosahedron(GLenum shadeType)
+{
+  int i;
+
+  for (i = 19; i >= 0; i--) {
+    drawtriangle(i, idata, index, shadeType);
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutWireIcosahedron(void)
+{
+  icosahedron(GL_LINE_LOOP);
+}
+
+void APIENTRY
+glutSolidIcosahedron(void)
+{
+  icosahedron(GL_TRIANGLES);
+}
+
+/* ENDCENTRY */
+
+/* tetrahedron data: */
+
+#define T       1.73205080756887729
+
+static GLfloat tdata[4][3] =
+{
+  {T, T, T},
+  {T, -T, -T},
+  {-T, T, -T},
+  {-T, -T, T}
+};
+
+static int tndex[4][3] =
+{
+  {0, 1, 3},
+  {2, 1, 0},
+  {3, 2, 0},
+  {1, 2, 3}
+};
+
+static void
+tetrahedron(GLenum shadeType)
+{
+  int i;
+
+  for (i = 3; i >= 0; i--)
+    drawtriangle(i, tdata, tndex, shadeType);
+}
+
+/* CENTRY */
+void APIENTRY
+glutWireTetrahedron(void)
+{
+  tetrahedron(GL_LINE_LOOP);
+}
+
+void APIENTRY
+glutSolidTetrahedron(void)
+{
+  tetrahedron(GL_TRIANGLES);
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_space.c b/src/glut/glx/glut_space.c
new file mode 100644
index 0000000000..aeb00b767e
--- /dev/null
+++ b/src/glut/glx/glut_space.c
@@ -0,0 +1,35 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 "glutint.h"
+
+void APIENTRY 
+glutSpaceballMotionFunc(GLUTspaceMotionCB spaceMotionFunc)
+{
+  __glutCurrentWindow->spaceMotion = spaceMotionFunc;
+  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_DEVICE_MASK_WORK);
+}
+
+void APIENTRY 
+glutSpaceballRotateFunc(GLUTspaceRotateCB spaceRotateFunc)
+{
+  __glutCurrentWindow->spaceRotate = spaceRotateFunc;
+  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_DEVICE_MASK_WORK);
+}
+
+void APIENTRY 
+glutSpaceballButtonFunc(GLUTspaceButtonCB spaceButtonFunc)
+{
+  __glutCurrentWindow->spaceButton = spaceButtonFunc;
+  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_DEVICE_MASK_WORK);
+}
diff --git a/src/glut/glx/glut_stroke.c b/src/glut/glx/glut_stroke.c
new file mode 100644
index 0000000000..2fe408be1a
--- /dev/null
+++ b/src/glut/glx/glut_stroke.c
@@ -0,0 +1,42 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 "glutint.h"
+#include "glutstroke.h"
+
+void APIENTRY 
+glutStrokeCharacter(GLUTstrokeFont font, int c)
+{
+  const StrokeCharRec *ch;
+  const StrokeRec *stroke;
+  const CoordRec *coord;
+  StrokeFontPtr fontinfo;
+  int i, j;
+
+
+#if defined(_WIN32)
+  fontinfo = (StrokeFontPtr) __glutFont(font);
+#else
+  fontinfo = (StrokeFontPtr) font;
+#endif
+
+  if (c < 0 || c >= fontinfo->num_chars)
+    return;
+  ch = &(fontinfo->ch[c]);
+  if (ch) {
+    for (i = ch->num_strokes, stroke = ch->stroke;
+      i > 0; i--, stroke++) {
+      glBegin(GL_LINE_STRIP);
+      for (j = stroke->num_coords, coord = stroke->coord;
+        j > 0; j--, coord++) {
+        glVertex2f(coord->x, coord->y);
+      }
+      glEnd();
+    }
+    glTranslatef(ch->right, 0.0, 0.0);
+  }
+}
diff --git a/src/glut/glx/glut_swap.c b/src/glut/glx/glut_swap.c
new file mode 100644
index 0000000000..0864e58d42
--- /dev/null
+++ b/src/glut/glx/glut_swap.c
@@ -0,0 +1,47 @@
+
+/* 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. */
+
+#include "glutint.h"
+
+/* CENTRY */
+void APIENTRY
+glutSwapBuffers(void)
+{
+  GLUTwindow *window = __glutCurrentWindow;
+
+  if (window->renderWin == window->win) {
+    if (__glutCurrentWindow->treatAsSingle) {
+      /* Pretend the double buffered window is single buffered,
+         so treat glutSwapBuffers as a no-op. */
+      return;
+    }
+  } else {
+    if (__glutCurrentWindow->overlay->treatAsSingle) {
+      /* Pretend the double buffered overlay is single
+         buffered, so treat glutSwapBuffers as a no-op. */
+      return;
+    }
+  }
+
+  /* For the MESA_SWAP_HACK. */
+  window->usedSwapBuffers = 1;
+
+  SWAP_BUFFERS_LAYER(__glutCurrentWindow);
+
+  /* I considered putting the window being swapped on the
+     GLUT_FINISH_WORK work list because you could call
+     glutSwapBuffers from an idle callback which doesn't call
+     __glutSetWindow which normally adds indirect rendering
+     windows to the GLUT_FINISH_WORK work list.  Not being put
+     on the list could lead to the buffering up of multiple
+     redisplays and buffer swaps and hamper interactivity.  I
+     consider this an application bug due to not using
+     glutPostRedisplay to trigger redraws.  If
+     glutPostRedisplay were used, __glutSetWindow would be
+     called and a glFinish to throttle buffering would occur. */
+}
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_swidth.c b/src/glut/glx/glut_swidth.c
new file mode 100644
index 0000000000..e1b7374575
--- /dev/null
+++ b/src/glut/glx/glut_swidth.c
@@ -0,0 +1,58 @@
+
+/* Copyright (c) Mark J. Kilgard, 1995. */
+
+/* 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 "glutint.h"
+#include "glutstroke.h"
+
+/* CENTRY */
+int APIENTRY 
+glutStrokeWidth(GLUTstrokeFont font, int c)
+{
+  StrokeFontPtr fontinfo;
+  const StrokeCharRec *ch;
+
+#if defined(_WIN32)
+  fontinfo = (StrokeFontPtr) __glutFont(font);
+#else
+  fontinfo = (StrokeFontPtr) font;
+#endif
+
+  if (c < 0 || c >= fontinfo->num_chars)
+    return 0;
+  ch = &(fontinfo->ch[c]);
+  if (ch)
+    return ch->right;
+  else
+    return 0;
+}
+
+int APIENTRY 
+glutStrokeLength(GLUTstrokeFont font, const unsigned char *string)
+{
+  int c, length;
+  StrokeFontPtr fontinfo;
+  const StrokeCharRec *ch;
+
+#if defined(_WIN32)
+  fontinfo = (StrokeFontPtr) __glutFont(font);
+#else
+  fontinfo = (StrokeFontPtr) font;
+#endif
+
+  length = 0;
+  for (; *string != '\0'; string++) {
+    c = *string;
+    if (c >= 0 && c < fontinfo->num_chars) {
+      ch = &(fontinfo->ch[c]);
+      if (ch)
+        length += ch->right;
+    }
+  }
+  return length;
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_tablet.c b/src/glut/glx/glut_tablet.c
new file mode 100644
index 0000000000..92567f9a8e
--- /dev/null
+++ b/src/glut/glx/glut_tablet.c
@@ -0,0 +1,33 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 "glutint.h"
+
+void APIENTRY 
+glutTabletMotionFunc(GLUTtabletMotionCB tabletMotionFunc)
+{
+  __glutCurrentWindow->tabletMotion = tabletMotionFunc;
+  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_DEVICE_MASK_WORK);
+  /* If deinstalling callback, invalidate tablet position. */
+  if (tabletMotionFunc == NULL) {
+    __glutCurrentWindow->tabletPos[0] = -1;
+    __glutCurrentWindow->tabletPos[1] = -1;
+  }
+}
+
+void APIENTRY 
+glutTabletButtonFunc(GLUTtabletButtonCB tabletButtonFunc)
+{
+  __glutCurrentWindow->tabletButton = tabletButtonFunc;
+  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
+  __glutPutOnWorkList(__glutCurrentWindow,
+    GLUT_DEVICE_MASK_WORK);
+}
diff --git a/src/glut/glx/glut_teapot.c b/src/glut/glx/glut_teapot.c
new file mode 100644
index 0000000000..fe096e774d
--- /dev/null
+++ b/src/glut/glx/glut_teapot.c
@@ -0,0 +1,210 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/**
+(c) Copyright 1993, Silicon Graphics, Inc.
+
+ALL RIGHTS RESERVED
+
+Permission to use, copy, modify, and distribute this software
+for any purpose and without fee is hereby granted, provided
+that the above copyright notice appear in all copies and that
+both the copyright notice and this permission notice appear in
+supporting documentation, and that the name of Silicon
+Graphics, Inc. not be used in advertising or publicity
+pertaining to distribution of the software without specific,
+written prior permission.
+
+THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
+"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
+OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
+MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  IN NO
+EVENT SHALL SILICON GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE
+ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
+INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
+SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
+NOT SILICON GRAPHICS, INC.  HAS BEEN ADVISED OF THE POSSIBILITY
+OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+US Government Users Restricted Rights
+
+Use, duplication, or disclosure by the Government is subject to
+restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+(c)(1)(ii) of the Rights in Technical Data and Computer
+Software clause at DFARS 252.227-7013 and/or in similar or
+successor clauses in the FAR or the DOD or NASA FAR
+Supplement.  Unpublished-- rights reserved under the copyright
+laws of the United States.  Contractor/manufacturer is Silicon
+Graphics, Inc., 2011 N.  Shoreline Blvd., Mountain View, CA
+94039-7311.
+
+OpenGL(TM) is a trademark of Silicon Graphics, Inc.
+*/
+
+#include "glutint.h"
+
+/* Rim, body, lid, and bottom data must be reflected in x and
+   y; handle and spout data across the y axis only.  */
+
+static int patchdata[][16] =
+{
+    /* rim */
+  {102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11,
+    12, 13, 14, 15},
+    /* body */
+  {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+    24, 25, 26, 27},
+  {24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36,
+    37, 38, 39, 40},
+    /* lid */
+  {96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101,
+    101, 0, 1, 2, 3,},
+  {0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112,
+    113, 114, 115, 116, 117},
+    /* bottom */
+  {118, 118, 118, 118, 124, 122, 119, 121, 123, 126,
+    125, 120, 40, 39, 38, 37},
+    /* handle */
+  {41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
+    53, 54, 55, 56},
+  {53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+    28, 65, 66, 67},
+    /* spout */
+  {68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+    80, 81, 82, 83},
+  {80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+    92, 93, 94, 95}
+};
+/* *INDENT-OFF* */
+
+static float cpdata[][3] =
+{
+    {0.2, 0, 2.7}, {0.2, -0.112, 2.7}, {0.112, -0.2, 2.7}, {0,
+    -0.2, 2.7}, {1.3375, 0, 2.53125}, {1.3375, -0.749, 2.53125},
+    {0.749, -1.3375, 2.53125}, {0, -1.3375, 2.53125}, {1.4375,
+    0, 2.53125}, {1.4375, -0.805, 2.53125}, {0.805, -1.4375,
+    2.53125}, {0, -1.4375, 2.53125}, {1.5, 0, 2.4}, {1.5, -0.84,
+    2.4}, {0.84, -1.5, 2.4}, {0, -1.5, 2.4}, {1.75, 0, 1.875},
+    {1.75, -0.98, 1.875}, {0.98, -1.75, 1.875}, {0, -1.75,
+    1.875}, {2, 0, 1.35}, {2, -1.12, 1.35}, {1.12, -2, 1.35},
+    {0, -2, 1.35}, {2, 0, 0.9}, {2, -1.12, 0.9}, {1.12, -2,
+    0.9}, {0, -2, 0.9}, {-2, 0, 0.9}, {2, 0, 0.45}, {2, -1.12,
+    0.45}, {1.12, -2, 0.45}, {0, -2, 0.45}, {1.5, 0, 0.225},
+    {1.5, -0.84, 0.225}, {0.84, -1.5, 0.225}, {0, -1.5, 0.225},
+    {1.5, 0, 0.15}, {1.5, -0.84, 0.15}, {0.84, -1.5, 0.15}, {0,
+    -1.5, 0.15}, {-1.6, 0, 2.025}, {-1.6, -0.3, 2.025}, {-1.5,
+    -0.3, 2.25}, {-1.5, 0, 2.25}, {-2.3, 0, 2.025}, {-2.3, -0.3,
+    2.025}, {-2.5, -0.3, 2.25}, {-2.5, 0, 2.25}, {-2.7, 0,
+    2.025}, {-2.7, -0.3, 2.025}, {-3, -0.3, 2.25}, {-3, 0,
+    2.25}, {-2.7, 0, 1.8}, {-2.7, -0.3, 1.8}, {-3, -0.3, 1.8},
+    {-3, 0, 1.8}, {-2.7, 0, 1.575}, {-2.7, -0.3, 1.575}, {-3,
+    -0.3, 1.35}, {-3, 0, 1.35}, {-2.5, 0, 1.125}, {-2.5, -0.3,
+    1.125}, {-2.65, -0.3, 0.9375}, {-2.65, 0, 0.9375}, {-2,
+    -0.3, 0.9}, {-1.9, -0.3, 0.6}, {-1.9, 0, 0.6}, {1.7, 0,
+    1.425}, {1.7, -0.66, 1.425}, {1.7, -0.66, 0.6}, {1.7, 0,
+    0.6}, {2.6, 0, 1.425}, {2.6, -0.66, 1.425}, {3.1, -0.66,
+    0.825}, {3.1, 0, 0.825}, {2.3, 0, 2.1}, {2.3, -0.25, 2.1},
+    {2.4, -0.25, 2.025}, {2.4, 0, 2.025}, {2.7, 0, 2.4}, {2.7,
+    -0.25, 2.4}, {3.3, -0.25, 2.4}, {3.3, 0, 2.4}, {2.8, 0,
+    2.475}, {2.8, -0.25, 2.475}, {3.525, -0.25, 2.49375},
+    {3.525, 0, 2.49375}, {2.9, 0, 2.475}, {2.9, -0.15, 2.475},
+    {3.45, -0.15, 2.5125}, {3.45, 0, 2.5125}, {2.8, 0, 2.4},
+    {2.8, -0.15, 2.4}, {3.2, -0.15, 2.4}, {3.2, 0, 2.4}, {0, 0,
+    3.15}, {0.8, 0, 3.15}, {0.8, -0.45, 3.15}, {0.45, -0.8,
+    3.15}, {0, -0.8, 3.15}, {0, 0, 2.85}, {1.4, 0, 2.4}, {1.4,
+    -0.784, 2.4}, {0.784, -1.4, 2.4}, {0, -1.4, 2.4}, {0.4, 0,
+    2.55}, {0.4, -0.224, 2.55}, {0.224, -0.4, 2.55}, {0, -0.4,
+    2.55}, {1.3, 0, 2.55}, {1.3, -0.728, 2.55}, {0.728, -1.3,
+    2.55}, {0, -1.3, 2.55}, {1.3, 0, 2.4}, {1.3, -0.728, 2.4},
+    {0.728, -1.3, 2.4}, {0, -1.3, 2.4}, {0, 0, 0}, {1.425,
+    -0.798, 0}, {1.5, 0, 0.075}, {1.425, 0, 0}, {0.798, -1.425,
+    0}, {0, -1.5, 0.075}, {0, -1.425, 0}, {1.5, -0.84, 0.075},
+    {0.84, -1.5, 0.075}
+};
+
+static float tex[2][2][2] =
+{
+  { {0, 0},
+    {1, 0}},
+  { {0, 1},
+    {1, 1}}
+};
+
+/* *INDENT-ON* */
+
+static void
+teapot(GLint grid, GLdouble scale, GLenum type)
+{
+  float p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
+  long i, j, k, l;
+
+  glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT);
+  glEnable(GL_AUTO_NORMAL);
+  glEnable(GL_NORMALIZE);
+  glEnable(GL_MAP2_VERTEX_3);
+  glEnable(GL_MAP2_TEXTURE_COORD_2);
+  glPushMatrix();
+  glRotatef(270.0, 1.0, 0.0, 0.0);
+  glScalef(0.5 * scale, 0.5 * scale, 0.5 * scale);
+  glTranslatef(0.0, 0.0, -1.5);
+  for (i = 0; i < 10; i++) {
+    for (j = 0; j < 4; j++) {
+      for (k = 0; k < 4; k++) {
+        for (l = 0; l < 3; l++) {
+          p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
+          q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
+          if (l == 1)
+            q[j][k][l] *= -1.0;
+          if (i < 6) {
+            r[j][k][l] =
+              cpdata[patchdata[i][j * 4 + (3 - k)]][l];
+            if (l == 0)
+              r[j][k][l] *= -1.0;
+            s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
+            if (l == 0)
+              s[j][k][l] *= -1.0;
+            if (l == 1)
+              s[j][k][l] *= -1.0;
+          }
+        }
+      }
+    }
+    glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2,
+      &tex[0][0][0]);
+    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
+      &p[0][0][0]);
+    glMapGrid2f(grid, 0.0, 1.0, grid, 0.0, 1.0);
+    glEvalMesh2(type, 0, grid, 0, grid);
+    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
+      &q[0][0][0]);
+    glEvalMesh2(type, 0, grid, 0, grid);
+    if (i < 6) {
+      glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
+        &r[0][0][0]);
+      glEvalMesh2(type, 0, grid, 0, grid);
+      glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
+        &s[0][0][0]);
+      glEvalMesh2(type, 0, grid, 0, grid);
+    }
+  }
+  glPopMatrix();
+  glPopAttrib();
+}
+
+/* CENTRY */
+void APIENTRY 
+glutSolidTeapot(GLdouble scale)
+{
+  teapot(7, scale, GL_FILL);
+}
+
+void APIENTRY 
+glutWireTeapot(GLdouble scale)
+{
+  teapot(10, scale, GL_LINE);
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_tr10.c b/src/glut/glx/glut_tr10.c
new file mode 100644
index 0000000000..0fac8070ca
--- /dev/null
+++ b/src/glut/glx/glut_tr10.c
@@ -0,0 +1,1777 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#define glutBitmapTimesRoman10 XXX
+#include "glutbitmap.h"
+#undef glutBitmapTimesRoman10
+
+/* char: 0xff */
+
+static const GLubyte ch255data[] = {
+0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0xa0,
+};
+
+static const BitmapCharRec ch255 = {5,9,0,2,5,ch255data};
+
+/* char: 0xfe */
+
+static const GLubyte ch254data[] = {
+0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0,0x80,0x80,
+};
+
+static const BitmapCharRec ch254 = {4,9,0,2,5,ch254data};
+
+/* char: 0xfd */
+
+static const GLubyte ch253data[] = {
+0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch253 = {5,10,0,2,5,ch253data};
+
+/* char: 0xfc */
+
+static const GLubyte ch252data[] = {
+0x68,0x90,0x90,0x90,0x90,0x0,0x50,
+};
+
+static const BitmapCharRec ch252 = {5,7,0,0,5,ch252data};
+
+/* char: 0xfb */
+
+static const GLubyte ch251data[] = {
+0x68,0x90,0x90,0x90,0x90,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch251 = {5,8,0,0,5,ch251data};
+
+/* char: 0xfa */
+
+static const GLubyte ch250data[] = {
+0x68,0x90,0x90,0x90,0x90,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch250 = {5,8,0,0,5,ch250data};
+
+/* char: 0xf9 */
+
+static const GLubyte ch249data[] = {
+0x68,0x90,0x90,0x90,0x90,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch249 = {5,8,0,0,5,ch249data};
+
+/* char: 0xf8 */
+
+static const GLubyte ch248data[] = {
+0x80,0x70,0x48,0x48,0x48,0x38,0x4,
+};
+
+static const BitmapCharRec ch248 = {6,7,1,1,5,ch248data};
+
+/* char: 0xf7 */
+
+static const GLubyte ch247data[] = {
+0x20,0x0,0xf8,0x0,0x20,
+};
+
+static const BitmapCharRec ch247 = {5,5,0,0,6,ch247data};
+
+/* char: 0xf6 */
+
+static const GLubyte ch246data[] = {
+0x60,0x90,0x90,0x90,0x60,0x0,0xa0,
+};
+
+static const BitmapCharRec ch246 = {4,7,0,0,5,ch246data};
+
+/* char: 0xf5 */
+
+static const GLubyte ch245data[] = {
+0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x50,
+};
+
+static const BitmapCharRec ch245 = {4,8,0,0,5,ch245data};
+
+/* char: 0xf4 */
+
+static const GLubyte ch244data[] = {
+0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch244 = {4,8,0,0,5,ch244data};
+
+/* char: 0xf3 */
+
+static const GLubyte ch243data[] = {
+0x60,0x90,0x90,0x90,0x60,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch243 = {4,8,0,0,5,ch243data};
+
+/* char: 0xf2 */
+
+static const GLubyte ch242data[] = {
+0x60,0x90,0x90,0x90,0x60,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch242 = {4,8,0,0,5,ch242data};
+
+/* char: 0xf1 */
+
+static const GLubyte ch241data[] = {
+0xd8,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50,
+};
+
+static const BitmapCharRec ch241 = {5,8,0,0,5,ch241data};
+
+/* char: 0xf0 */
+
+static const GLubyte ch240data[] = {
+0x60,0x90,0x90,0x90,0x70,0xa0,0x70,0x40,
+};
+
+static const BitmapCharRec ch240 = {4,8,0,0,5,ch240data};
+
+/* char: 0xef */
+
+static const GLubyte ch239data[] = {
+0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0,
+};
+
+static const BitmapCharRec ch239 = {3,7,0,0,4,ch239data};
+
+/* char: 0xee */
+
+static const GLubyte ch238data[] = {
+0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch238 = {3,8,0,0,4,ch238data};
+
+/* char: 0xed */
+
+static const GLubyte ch237data[] = {
+0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch237 = {3,8,0,0,4,ch237data};
+
+/* char: 0xec */
+
+static const GLubyte ch236data[] = {
+0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch236 = {3,8,0,0,4,ch236data};
+
+/* char: 0xeb */
+
+static const GLubyte ch235data[] = {
+0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0,
+};
+
+static const BitmapCharRec ch235 = {3,7,0,0,4,ch235data};
+
+/* char: 0xea */
+
+static const GLubyte ch234data[] = {
+0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch234 = {3,8,0,0,4,ch234data};
+
+/* char: 0xe9 */
+
+static const GLubyte ch233data[] = {
+0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch233 = {3,8,0,0,4,ch233data};
+
+/* char: 0xe8 */
+
+static const GLubyte ch232data[] = {
+0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch232 = {3,8,0,0,4,ch232data};
+
+/* char: 0xe7 */
+
+static const GLubyte ch231data[] = {
+0xc0,0x20,0x40,0x60,0x80,0x80,0x80,0x60,
+};
+
+static const BitmapCharRec ch231 = {3,8,0,3,4,ch231data};
+
+/* char: 0xe6 */
+
+static const GLubyte ch230data[] = {
+0xd8,0xa0,0x70,0x28,0xd8,
+};
+
+static const BitmapCharRec ch230 = {5,5,0,0,6,ch230data};
+
+/* char: 0xe5 */
+
+static const GLubyte ch229data[] = {
+0xe0,0xa0,0x60,0x20,0xc0,0x40,0xa0,0x40,
+};
+
+static const BitmapCharRec ch229 = {3,8,0,0,4,ch229data};
+
+/* char: 0xe4 */
+
+static const GLubyte ch228data[] = {
+0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,
+};
+
+static const BitmapCharRec ch228 = {3,7,0,0,4,ch228data};
+
+/* char: 0xe3 */
+
+static const GLubyte ch227data[] = {
+0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x50,
+};
+
+static const BitmapCharRec ch227 = {4,8,0,0,4,ch227data};
+
+/* char: 0xe2 */
+
+static const GLubyte ch226data[] = {
+0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch226 = {3,8,0,0,4,ch226data};
+
+/* char: 0xe1 */
+
+static const GLubyte ch225data[] = {
+0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch225 = {3,8,0,0,4,ch225data};
+
+/* char: 0xe0 */
+
+static const GLubyte ch224data[] = {
+0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch224 = {3,8,0,0,4,ch224data};
+
+/* char: 0xdf */
+
+static const GLubyte ch223data[] = {
+0xe0,0x50,0x50,0x60,0x50,0x50,0x20,
+};
+
+static const BitmapCharRec ch223 = {4,7,0,0,5,ch223data};
+
+/* char: 0xde */
+
+static const GLubyte ch222data[] = {
+0xe0,0x40,0x70,0x48,0x70,0x40,0xe0,
+};
+
+static const BitmapCharRec ch222 = {5,7,0,0,6,ch222data};
+
+/* char: 0xdd */
+
+static const GLubyte ch221data[] = {
+0x38,0x10,0x10,0x28,0x28,0x44,0xee,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch221 = {7,10,0,0,8,ch221data};
+
+/* char: 0xdc */
+
+static const GLubyte ch220data[] = {
+0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28,
+};
+
+static const BitmapCharRec ch220 = {7,9,0,0,8,ch220data};
+
+/* char: 0xdb */
+
+static const GLubyte ch219data[] = {
+0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch219 = {7,10,0,0,8,ch219data};
+
+/* char: 0xda */
+
+static const GLubyte ch218data[] = {
+0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch218 = {7,10,0,0,8,ch218data};
+
+/* char: 0xd9 */
+
+static const GLubyte ch217data[] = {
+0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch217 = {7,10,0,0,8,ch217data};
+
+/* char: 0xd8 */
+
+static const GLubyte ch216data[] = {
+0x80,0x7c,0x66,0x52,0x52,0x4a,0x66,0x3e,0x1,
+};
+
+static const BitmapCharRec ch216 = {8,9,0,1,8,ch216data};
+
+/* char: 0xd7 */
+
+static const GLubyte ch215data[] = {
+0x88,0x50,0x20,0x50,0x88,
+};
+
+static const BitmapCharRec ch215 = {5,5,0,0,6,ch215data};
+
+/* char: 0xd6 */
+
+static const GLubyte ch214data[] = {
+0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,
+};
+
+static const BitmapCharRec ch214 = {6,9,0,0,7,ch214data};
+
+/* char: 0xd5 */
+
+static const GLubyte ch213data[] = {
+0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch213 = {6,10,0,0,7,ch213data};
+
+/* char: 0xd4 */
+
+static const GLubyte ch212data[] = {
+0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch212 = {6,10,0,0,7,ch212data};
+
+/* char: 0xd3 */
+
+static const GLubyte ch211data[] = {
+0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch211 = {6,10,0,0,7,ch211data};
+
+/* char: 0xd2 */
+
+static const GLubyte ch210data[] = {
+0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch210 = {6,10,0,0,7,ch210data};
+
+/* char: 0xd1 */
+
+static const GLubyte ch209data[] = {
+0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee,0x0,0x50,0x28,
+};
+
+static const BitmapCharRec ch209 = {7,10,0,0,8,ch209data};
+
+/* char: 0xd0 */
+
+static const GLubyte ch208data[] = {
+0xf8,0x4c,0x44,0xe4,0x44,0x4c,0xf8,
+};
+
+static const BitmapCharRec ch208 = {6,7,0,0,7,ch208data};
+
+/* char: 0xcf */
+
+static const GLubyte ch207data[] = {
+0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0,
+};
+
+static const BitmapCharRec ch207 = {3,9,0,0,4,ch207data};
+
+/* char: 0xce */
+
+static const GLubyte ch206data[] = {
+0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch206 = {3,10,0,0,4,ch206data};
+
+/* char: 0xcd */
+
+static const GLubyte ch205data[] = {
+0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x20,
+};
+
+static const BitmapCharRec ch205 = {3,10,0,0,4,ch205data};
+
+/* char: 0xcc */
+
+static const GLubyte ch204data[] = {
+0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x80,
+};
+
+static const BitmapCharRec ch204 = {3,10,0,0,4,ch204data};
+
+/* char: 0xcb */
+
+static const GLubyte ch203data[] = {
+0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50,
+};
+
+static const BitmapCharRec ch203 = {5,9,0,0,6,ch203data};
+
+/* char: 0xca */
+
+static const GLubyte ch202data[] = {
+0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50,0x20,
+};
+
+static const BitmapCharRec ch202 = {5,10,0,0,6,ch202data};
+
+/* char: 0xc9 */
+
+static const GLubyte ch201data[] = {
+0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x10,
+};
+
+static const BitmapCharRec ch201 = {5,10,0,0,6,ch201data};
+
+/* char: 0xc8 */
+
+static const GLubyte ch200data[] = {
+0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x40,
+};
+
+static const BitmapCharRec ch200 = {5,10,0,0,6,ch200data};
+
+/* char: 0xc7 */
+
+static const GLubyte ch199data[] = {
+0x60,0x10,0x20,0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c,
+};
+
+static const BitmapCharRec ch199 = {6,10,0,3,7,ch199data};
+
+/* char: 0xc6 */
+
+static const GLubyte ch198data[] = {
+0xef,0x49,0x78,0x2e,0x28,0x39,0x1f,
+};
+
+static const BitmapCharRec ch198 = {8,7,0,0,9,ch198data};
+
+/* char: 0xc5 */
+
+static const GLubyte ch197data[] = {
+0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x10,0x28,0x10,
+};
+
+static const BitmapCharRec ch197 = {7,10,0,0,8,ch197data};
+
+/* char: 0xc4 */
+
+static const GLubyte ch196data[] = {
+0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,
+};
+
+static const BitmapCharRec ch196 = {7,9,0,0,8,ch196data};
+
+/* char: 0xc3 */
+
+static const GLubyte ch195data[] = {
+0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x14,
+};
+
+static const BitmapCharRec ch195 = {7,10,0,0,8,ch195data};
+
+/* char: 0xc2 */
+
+static const GLubyte ch194data[] = {
+0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x10,
+};
+
+static const BitmapCharRec ch194 = {7,10,0,0,8,ch194data};
+
+/* char: 0xc1 */
+
+static const GLubyte ch193data[] = {
+0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x8,
+};
+
+static const BitmapCharRec ch193 = {7,10,0,0,8,ch193data};
+
+/* char: 0xc0 */
+
+static const GLubyte ch192data[] = {
+0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x20,
+};
+
+static const BitmapCharRec ch192 = {7,10,0,0,8,ch192data};
+
+/* char: 0xbf */
+
+static const GLubyte ch191data[] = {
+0xe0,0xa0,0x80,0x40,0x40,0x0,0x40,
+};
+
+static const BitmapCharRec ch191 = {3,7,0,2,4,ch191data};
+
+/* char: 0xbe */
+
+static const GLubyte ch190data[] = {
+0x44,0x3e,0x2c,0xd4,0x28,0x48,0xe4,
+};
+
+static const BitmapCharRec ch190 = {7,7,0,0,8,ch190data};
+
+/* char: 0xbd */
+
+static const GLubyte ch189data[] = {
+0x4e,0x24,0x2a,0xf6,0x48,0xc8,0x44,
+};
+
+static const BitmapCharRec ch189 = {7,7,0,0,8,ch189data};
+
+/* char: 0xbc */
+
+static const GLubyte ch188data[] = {
+0x44,0x3e,0x2c,0xf4,0x48,0xc8,0x44,
+};
+
+static const BitmapCharRec ch188 = {7,7,0,0,8,ch188data};
+
+/* char: 0xbb */
+
+static const GLubyte ch187data[] = {
+0xa0,0x50,0x50,0xa0,
+};
+
+static const BitmapCharRec ch187 = {4,4,0,-1,5,ch187data};
+
+/* char: 0xba */
+
+static const GLubyte ch186data[] = {
+0xe0,0x0,0x40,0xa0,0x40,
+};
+
+static const BitmapCharRec ch186 = {3,5,0,-2,4,ch186data};
+
+/* char: 0xb9 */
+
+static const GLubyte ch185data[] = {
+0xe0,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch185 = {3,4,0,-3,3,ch185data};
+
+/* char: 0xb8 */
+
+static const GLubyte ch184data[] = {
+0xc0,0x20,0x40,
+};
+
+static const BitmapCharRec ch184 = {3,3,0,3,4,ch184data};
+
+/* char: 0xb7 */
+
+static const GLubyte ch183data[] = {
+0x80,
+};
+
+static const BitmapCharRec ch183 = {1,1,0,-2,2,ch183data};
+
+/* char: 0xb6 */
+
+static const GLubyte ch182data[] = {
+0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c,
+};
+
+static const BitmapCharRec ch182 = {6,9,0,2,6,ch182data};
+
+/* char: 0xb5 */
+
+static const GLubyte ch181data[] = {
+0x80,0x80,0xe8,0x90,0x90,0x90,0x90,
+};
+
+static const BitmapCharRec ch181 = {5,7,0,2,5,ch181data};
+
+/* char: 0xb4 */
+
+static const GLubyte ch180data[] = {
+0x80,0x40,
+};
+
+static const BitmapCharRec ch180 = {2,2,0,-5,3,ch180data};
+
+/* char: 0xb3 */
+
+static const GLubyte ch179data[] = {
+0xc0,0x20,0x40,0xe0,
+};
+
+static const BitmapCharRec ch179 = {3,4,0,-3,3,ch179data};
+
+/* char: 0xb2 */
+
+static const GLubyte ch178data[] = {
+0xe0,0x40,0xa0,0x60,
+};
+
+static const BitmapCharRec ch178 = {3,4,0,-3,3,ch178data};
+
+/* char: 0xb1 */
+
+static const GLubyte ch177data[] = {
+0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch177 = {5,7,0,0,6,ch177data};
+
+/* char: 0xb0 */
+
+static const GLubyte ch176data[] = {
+0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch176 = {4,4,0,-3,4,ch176data};
+
+/* char: 0xaf */
+
+static const GLubyte ch175data[] = {
+0xe0,
+};
+
+static const BitmapCharRec ch175 = {3,1,0,-6,4,ch175data};
+
+/* char: 0xae */
+
+static const GLubyte ch174data[] = {
+0x38,0x44,0xaa,0xb2,0xba,0x44,0x38,
+};
+
+static const BitmapCharRec ch174 = {7,7,-1,0,9,ch174data};
+
+/* char: 0xad */
+
+static const GLubyte ch173data[] = {
+0xe0,
+};
+
+static const BitmapCharRec ch173 = {3,1,0,-2,4,ch173data};
+
+/* char: 0xac */
+
+static const GLubyte ch172data[] = {
+0x8,0x8,0xf8,
+};
+
+static const BitmapCharRec ch172 = {5,3,-1,-1,7,ch172data};
+
+/* char: 0xab */
+
+static const GLubyte ch171data[] = {
+0x50,0xa0,0xa0,0x50,
+};
+
+static const BitmapCharRec ch171 = {4,4,0,-1,5,ch171data};
+
+/* char: 0xaa */
+
+static const GLubyte ch170data[] = {
+0xe0,0x0,0xa0,0x20,0xc0,
+};
+
+static const BitmapCharRec ch170 = {3,5,0,-2,4,ch170data};
+
+/* char: 0xa9 */
+
+static const GLubyte ch169data[] = {
+0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38,
+};
+
+static const BitmapCharRec ch169 = {7,7,-1,0,9,ch169data};
+
+/* char: 0xa8 */
+
+static const GLubyte ch168data[] = {
+0xa0,
+};
+
+static const BitmapCharRec ch168 = {3,1,-1,-6,5,ch168data};
+
+/* char: 0xa7 */
+
+static const GLubyte ch167data[] = {
+0xe0,0x90,0x20,0x50,0x90,0xa0,0x40,0x90,0x70,
+};
+
+static const BitmapCharRec ch167 = {4,9,0,1,5,ch167data};
+
+/* char: 0xa6 */
+
+static const GLubyte ch166data[] = {
+0x80,0x80,0x80,0x0,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch166 = {1,7,0,0,2,ch166data};
+
+/* char: 0xa5 */
+
+static const GLubyte ch165data[] = {
+0x70,0x20,0xf8,0x20,0xd8,0x50,0x88,
+};
+
+static const BitmapCharRec ch165 = {5,7,0,0,5,ch165data};
+
+/* char: 0xa4 */
+
+static const GLubyte ch164data[] = {
+0x88,0x70,0x50,0x50,0x70,0x88,
+};
+
+static const BitmapCharRec ch164 = {5,6,0,-1,5,ch164data};
+
+/* char: 0xa3 */
+
+static const GLubyte ch163data[] = {
+0xf0,0xc8,0x40,0xe0,0x40,0x50,0x30,
+};
+
+static const BitmapCharRec ch163 = {5,7,0,0,5,ch163data};
+
+/* char: 0xa2 */
+
+static const GLubyte ch162data[] = {
+0x80,0xe0,0x90,0x80,0x90,0x70,0x10,
+};
+
+static const BitmapCharRec ch162 = {4,7,0,1,5,ch162data};
+
+/* char: 0xa1 */
+
+static const GLubyte ch161data[] = {
+0x80,0x80,0x80,0x80,0x80,0x0,0x80,
+};
+
+static const BitmapCharRec ch161 = {1,7,-1,2,3,ch161data};
+
+/* char: 0xa0 */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch160data[] = { 0x0 };
+static const BitmapCharRec ch160 = {1,1,0,0,2,ch160data};
+#else
+static const BitmapCharRec ch160 = {0,0,0,0,2,0};
+#endif
+
+/* char: 0x7e '~' */
+
+static const GLubyte ch126data[] = {
+0x98,0x64,
+};
+
+static const BitmapCharRec ch126 = {6,2,0,-2,7,ch126data};
+
+/* char: 0x7d '}' */
+
+static const GLubyte ch125data[] = {
+0x80,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch125 = {3,9,0,2,4,ch125data};
+
+/* char: 0x7c '|' */
+
+static const GLubyte ch124data[] = {
+0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch124 = {1,9,0,2,2,ch124data};
+
+/* char: 0x7b '{' */
+
+static const GLubyte ch123data[] = {
+0x20,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20,
+};
+
+static const BitmapCharRec ch123 = {3,9,0,2,4,ch123data};
+
+/* char: 0x7a 'z' */
+
+static const GLubyte ch122data[] = {
+0xf0,0x90,0x40,0x20,0xf0,
+};
+
+static const BitmapCharRec ch122 = {4,5,0,0,5,ch122data};
+
+/* char: 0x79 'y' */
+
+static const GLubyte ch121data[] = {
+0x40,0x40,0x20,0x30,0x50,0x48,0xdc,
+};
+
+static const BitmapCharRec ch121 = {6,7,1,2,5,ch121data};
+
+/* char: 0x78 'x' */
+
+static const GLubyte ch120data[] = {
+0xd8,0x50,0x20,0x50,0xd8,
+};
+
+static const BitmapCharRec ch120 = {5,5,0,0,6,ch120data};
+
+/* char: 0x77 'w' */
+
+static const GLubyte ch119data[] = {
+0x28,0x6c,0x54,0x92,0xdb,
+};
+
+static const BitmapCharRec ch119 = {8,5,0,0,8,ch119data};
+
+/* char: 0x76 'v' */
+
+static const GLubyte ch118data[] = {
+0x20,0x60,0x50,0x90,0xd8,
+};
+
+static const BitmapCharRec ch118 = {5,5,0,0,5,ch118data};
+
+/* char: 0x75 'u' */
+
+static const GLubyte ch117data[] = {
+0x68,0x90,0x90,0x90,0x90,
+};
+
+static const BitmapCharRec ch117 = {5,5,0,0,5,ch117data};
+
+/* char: 0x74 't' */
+
+static const GLubyte ch116data[] = {
+0x30,0x40,0x40,0x40,0xe0,0x40,
+};
+
+static const BitmapCharRec ch116 = {4,6,0,0,4,ch116data};
+
+/* char: 0x73 's' */
+
+static const GLubyte ch115data[] = {
+0xe0,0x20,0x60,0x80,0xe0,
+};
+
+static const BitmapCharRec ch115 = {3,5,0,0,4,ch115data};
+
+/* char: 0x72 'r' */
+
+static const GLubyte ch114data[] = {
+0xe0,0x40,0x40,0x60,0xa0,
+};
+
+static const BitmapCharRec ch114 = {3,5,0,0,4,ch114data};
+
+/* char: 0x71 'q' */
+
+static const GLubyte ch113data[] = {
+0x38,0x10,0x70,0x90,0x90,0x90,0x70,
+};
+
+static const BitmapCharRec ch113 = {5,7,0,2,5,ch113data};
+
+/* char: 0x70 'p' */
+
+static const GLubyte ch112data[] = {
+0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0,
+};
+
+static const BitmapCharRec ch112 = {4,7,0,2,5,ch112data};
+
+/* char: 0x6f 'o' */
+
+static const GLubyte ch111data[] = {
+0x60,0x90,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch111 = {4,5,0,0,5,ch111data};
+
+/* char: 0x6e 'n' */
+
+static const GLubyte ch110data[] = {
+0xd8,0x90,0x90,0x90,0xe0,
+};
+
+static const BitmapCharRec ch110 = {5,5,0,0,5,ch110data};
+
+/* char: 0x6d 'm' */
+
+static const GLubyte ch109data[] = {
+0xdb,0x92,0x92,0x92,0xec,
+};
+
+static const BitmapCharRec ch109 = {8,5,0,0,8,ch109data};
+
+/* char: 0x6c 'l' */
+
+static const GLubyte ch108data[] = {
+0xe0,0x40,0x40,0x40,0x40,0x40,0xc0,
+};
+
+static const BitmapCharRec ch108 = {3,7,0,0,4,ch108data};
+
+/* char: 0x6b 'k' */
+
+static const GLubyte ch107data[] = {
+0x98,0x90,0xe0,0xa0,0x90,0x80,0x80,
+};
+
+static const BitmapCharRec ch107 = {5,7,0,0,5,ch107data};
+
+/* char: 0x6a 'j' */
+
+static const GLubyte ch106data[] = {
+0x80,0x40,0x40,0x40,0x40,0x40,0xc0,0x0,0x40,
+};
+
+static const BitmapCharRec ch106 = {2,9,0,2,3,ch106data};
+
+/* char: 0x69 'i' */
+
+static const GLubyte ch105data[] = {
+0x40,0x40,0x40,0x40,0xc0,0x0,0x40,
+};
+
+static const BitmapCharRec ch105 = {2,7,0,0,3,ch105data};
+
+/* char: 0x68 'h' */
+
+static const GLubyte ch104data[] = {
+0xd8,0x90,0x90,0x90,0xe0,0x80,0x80,
+};
+
+static const BitmapCharRec ch104 = {5,7,0,0,5,ch104data};
+
+/* char: 0x67 'g' */
+
+static const GLubyte ch103data[] = {
+0xe0,0x90,0x60,0x40,0xa0,0xa0,0x70,
+};
+
+static const BitmapCharRec ch103 = {4,7,0,2,5,ch103data};
+
+/* char: 0x66 'f' */
+
+static const GLubyte ch102data[] = {
+0xe0,0x40,0x40,0x40,0xe0,0x40,0x30,
+};
+
+static const BitmapCharRec ch102 = {4,7,0,0,4,ch102data};
+
+/* char: 0x65 'e' */
+
+static const GLubyte ch101data[] = {
+0x60,0x80,0xc0,0xa0,0x60,
+};
+
+static const BitmapCharRec ch101 = {3,5,0,0,4,ch101data};
+
+/* char: 0x64 'd' */
+
+static const GLubyte ch100data[] = {
+0x68,0x90,0x90,0x90,0x70,0x10,0x30,
+};
+
+static const BitmapCharRec ch100 = {5,7,0,0,5,ch100data};
+
+/* char: 0x63 'c' */
+
+static const GLubyte ch99data[] = {
+0x60,0x80,0x80,0x80,0x60,
+};
+
+static const BitmapCharRec ch99 = {3,5,0,0,4,ch99data};
+
+/* char: 0x62 'b' */
+
+static const GLubyte ch98data[] = {
+0xe0,0x90,0x90,0x90,0xe0,0x80,0x80,
+};
+
+static const BitmapCharRec ch98 = {4,7,0,0,5,ch98data};
+
+/* char: 0x61 'a' */
+
+static const GLubyte ch97data[] = {
+0xe0,0xa0,0x60,0x20,0xc0,
+};
+
+static const BitmapCharRec ch97 = {3,5,0,0,4,ch97data};
+
+/* char: 0x60 '`' */
+
+static const GLubyte ch96data[] = {
+0xc0,0x80,
+};
+
+static const BitmapCharRec ch96 = {2,2,0,-5,3,ch96data};
+
+/* char: 0x5f '_' */
+
+static const GLubyte ch95data[] = {
+0xf8,
+};
+
+static const BitmapCharRec ch95 = {5,1,0,3,5,ch95data};
+
+/* char: 0x5e '^' */
+
+static const GLubyte ch94data[] = {
+0xa0,0xa0,0x40,
+};
+
+static const BitmapCharRec ch94 = {3,3,-1,-4,5,ch94data};
+
+/* char: 0x5d ']' */
+
+static const GLubyte ch93data[] = {
+0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
+};
+
+static const BitmapCharRec ch93 = {2,9,0,2,3,ch93data};
+
+/* char: 0x5c '\' */
+
+static const GLubyte ch92data[] = {
+0x20,0x20,0x40,0x40,0x40,0x80,0x80,
+};
+
+static const BitmapCharRec ch92 = {3,7,0,0,3,ch92data};
+
+/* char: 0x5b '[' */
+
+static const GLubyte ch91data[] = {
+0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
+};
+
+static const BitmapCharRec ch91 = {2,9,0,2,3,ch91data};
+
+/* char: 0x5a 'Z' */
+
+static const GLubyte ch90data[] = {
+0xf8,0x88,0x40,0x20,0x10,0x88,0xf8,
+};
+
+static const BitmapCharRec ch90 = {5,7,0,0,6,ch90data};
+
+/* char: 0x59 'Y' */
+
+static const GLubyte ch89data[] = {
+0x38,0x10,0x10,0x28,0x28,0x44,0xee,
+};
+
+static const BitmapCharRec ch89 = {7,7,0,0,8,ch89data};
+
+/* char: 0x58 'X' */
+
+static const GLubyte ch88data[] = {
+0xee,0x44,0x28,0x10,0x28,0x44,0xee,
+};
+
+static const BitmapCharRec ch88 = {7,7,0,0,8,ch88data};
+
+/* char: 0x57 'W' */
+
+static const GLubyte ch87data[] = {
+0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0xc9,0x80,0x88,0x80,0xdd,0xc0,
+};
+
+static const BitmapCharRec ch87 = {10,7,0,0,10,ch87data};
+
+/* char: 0x56 'V' */
+
+static const GLubyte ch86data[] = {
+0x10,0x10,0x28,0x28,0x6c,0x44,0xee,
+};
+
+static const BitmapCharRec ch86 = {7,7,0,0,8,ch86data};
+
+/* char: 0x55 'U' */
+
+static const GLubyte ch85data[] = {
+0x38,0x6c,0x44,0x44,0x44,0x44,0xee,
+};
+
+static const BitmapCharRec ch85 = {7,7,0,0,8,ch85data};
+
+/* char: 0x54 'T' */
+
+static const GLubyte ch84data[] = {
+0x70,0x20,0x20,0x20,0x20,0xa8,0xf8,
+};
+
+static const BitmapCharRec ch84 = {5,7,0,0,6,ch84data};
+
+/* char: 0x53 'S' */
+
+static const GLubyte ch83data[] = {
+0xe0,0x90,0x10,0x60,0xc0,0x90,0x70,
+};
+
+static const BitmapCharRec ch83 = {4,7,0,0,5,ch83data};
+
+/* char: 0x52 'R' */
+
+static const GLubyte ch82data[] = {
+0xec,0x48,0x50,0x70,0x48,0x48,0xf0,
+};
+
+static const BitmapCharRec ch82 = {6,7,0,0,7,ch82data};
+
+/* char: 0x51 'Q' */
+
+static const GLubyte ch81data[] = {
+0xc,0x18,0x70,0xcc,0x84,0x84,0x84,0xcc,0x78,
+};
+
+static const BitmapCharRec ch81 = {6,9,0,2,7,ch81data};
+
+/* char: 0x50 'P' */
+
+static const GLubyte ch80data[] = {
+0xe0,0x40,0x40,0x70,0x48,0x48,0xf0,
+};
+
+static const BitmapCharRec ch80 = {5,7,0,0,6,ch80data};
+
+/* char: 0x4f 'O' */
+
+static const GLubyte ch79data[] = {
+0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,
+};
+
+static const BitmapCharRec ch79 = {6,7,0,0,7,ch79data};
+
+/* char: 0x4e 'N' */
+
+static const GLubyte ch78data[] = {
+0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee,
+};
+
+static const BitmapCharRec ch78 = {7,7,0,0,8,ch78data};
+
+/* char: 0x4d 'M' */
+
+static const GLubyte ch77data[] = {
+0xeb,0x80,0x49,0x0,0x55,0x0,0x55,0x0,0x63,0x0,0x63,0x0,0xe3,0x80,
+};
+
+static const BitmapCharRec ch77 = {9,7,0,0,10,ch77data};
+
+/* char: 0x4c 'L' */
+
+static const GLubyte ch76data[] = {
+0xf8,0x48,0x40,0x40,0x40,0x40,0xe0,
+};
+
+static const BitmapCharRec ch76 = {5,7,0,0,6,ch76data};
+
+/* char: 0x4b 'K' */
+
+static const GLubyte ch75data[] = {
+0xec,0x48,0x50,0x60,0x50,0x48,0xec,
+};
+
+static const BitmapCharRec ch75 = {6,7,0,0,7,ch75data};
+
+/* char: 0x4a 'J' */
+
+static const GLubyte ch74data[] = {
+0xc0,0xa0,0x20,0x20,0x20,0x20,0x70,
+};
+
+static const BitmapCharRec ch74 = {4,7,0,0,4,ch74data};
+
+/* char: 0x49 'I' */
+
+static const GLubyte ch73data[] = {
+0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,
+};
+
+static const BitmapCharRec ch73 = {3,7,0,0,4,ch73data};
+
+/* char: 0x48 'H' */
+
+static const GLubyte ch72data[] = {
+0xee,0x44,0x44,0x7c,0x44,0x44,0xee,
+};
+
+static const BitmapCharRec ch72 = {7,7,0,0,8,ch72data};
+
+/* char: 0x47 'G' */
+
+static const GLubyte ch71data[] = {
+0x78,0xc4,0x84,0x9c,0x80,0xc4,0x7c,
+};
+
+static const BitmapCharRec ch71 = {6,7,0,0,7,ch71data};
+
+/* char: 0x46 'F' */
+
+static const GLubyte ch70data[] = {
+0xe0,0x40,0x40,0x70,0x40,0x48,0xf8,
+};
+
+static const BitmapCharRec ch70 = {5,7,0,0,6,ch70data};
+
+/* char: 0x45 'E' */
+
+static const GLubyte ch69data[] = {
+0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,
+};
+
+static const BitmapCharRec ch69 = {5,7,0,0,6,ch69data};
+
+/* char: 0x44 'D' */
+
+static const GLubyte ch68data[] = {
+0xf8,0x4c,0x44,0x44,0x44,0x4c,0xf8,
+};
+
+static const BitmapCharRec ch68 = {6,7,0,0,7,ch68data};
+
+/* char: 0x43 'C' */
+
+static const GLubyte ch67data[] = {
+0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c,
+};
+
+static const BitmapCharRec ch67 = {6,7,0,0,7,ch67data};
+
+/* char: 0x42 'B' */
+
+static const GLubyte ch66data[] = {
+0xf0,0x48,0x48,0x70,0x48,0x48,0xf0,
+};
+
+static const BitmapCharRec ch66 = {5,7,0,0,6,ch66data};
+
+/* char: 0x41 'A' */
+
+static const GLubyte ch65data[] = {
+0xee,0x44,0x7c,0x28,0x28,0x38,0x10,
+};
+
+static const BitmapCharRec ch65 = {7,7,0,0,8,ch65data};
+
+/* char: 0x40 '@' */
+
+static const GLubyte ch64data[] = {
+0x3e,0x40,0x92,0xad,0xa5,0xa5,0x9d,0x42,0x3c,
+};
+
+static const BitmapCharRec ch64 = {8,9,0,2,9,ch64data};
+
+/* char: 0x3f '?' */
+
+static const GLubyte ch63data[] = {
+0x40,0x0,0x40,0x40,0x20,0xa0,0xe0,
+};
+
+static const BitmapCharRec ch63 = {3,7,0,0,4,ch63data};
+
+/* char: 0x3e '>' */
+
+static const GLubyte ch62data[] = {
+0x80,0x40,0x20,0x40,0x80,
+};
+
+static const BitmapCharRec ch62 = {3,5,0,0,5,ch62data};
+
+/* char: 0x3d '=' */
+
+static const GLubyte ch61data[] = {
+0xf8,0x0,0xf8,
+};
+
+static const BitmapCharRec ch61 = {5,3,0,-1,6,ch61data};
+
+/* char: 0x3c '<' */
+
+static const GLubyte ch60data[] = {
+0x20,0x40,0x80,0x40,0x20,
+};
+
+static const BitmapCharRec ch60 = {3,5,-1,0,5,ch60data};
+
+/* char: 0x3b ';' */
+
+static const GLubyte ch59data[] = {
+0x80,0x80,0x80,0x0,0x0,0x0,0x80,
+};
+
+static const BitmapCharRec ch59 = {1,7,-1,2,3,ch59data};
+
+/* char: 0x3a ':' */
+
+static const GLubyte ch58data[] = {
+0x80,0x0,0x0,0x0,0x80,
+};
+
+static const BitmapCharRec ch58 = {1,5,-1,0,3,ch58data};
+
+/* char: 0x39 '9' */
+
+static const GLubyte ch57data[] = {
+0xc0,0x20,0x70,0x90,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch57 = {4,7,0,0,5,ch57data};
+
+/* char: 0x38 '8' */
+
+static const GLubyte ch56data[] = {
+0x60,0x90,0x90,0x60,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch56 = {4,7,0,0,5,ch56data};
+
+/* char: 0x37 '7' */
+
+static const GLubyte ch55data[] = {
+0x40,0x40,0x40,0x20,0x20,0x90,0xf0,
+};
+
+static const BitmapCharRec ch55 = {4,7,0,0,5,ch55data};
+
+/* char: 0x36 '6' */
+
+static const GLubyte ch54data[] = {
+0x60,0x90,0x90,0x90,0xe0,0x40,0x30,
+};
+
+static const BitmapCharRec ch54 = {4,7,0,0,5,ch54data};
+
+/* char: 0x35 '5' */
+
+static const GLubyte ch53data[] = {
+0xe0,0x90,0x10,0x10,0xe0,0x40,0x70,
+};
+
+static const BitmapCharRec ch53 = {4,7,0,0,5,ch53data};
+
+/* char: 0x34 '4' */
+
+static const GLubyte ch52data[] = {
+0x10,0x10,0xf8,0x90,0x50,0x30,0x10,
+};
+
+static const BitmapCharRec ch52 = {5,7,0,0,5,ch52data};
+
+/* char: 0x33 '3' */
+
+static const GLubyte ch51data[] = {
+0xe0,0x10,0x10,0x60,0x10,0x90,0x60,
+};
+
+static const BitmapCharRec ch51 = {4,7,0,0,5,ch51data};
+
+/* char: 0x32 '2' */
+
+static const GLubyte ch50data[] = {
+0xf0,0x40,0x20,0x20,0x10,0x90,0x60,
+};
+
+static const BitmapCharRec ch50 = {4,7,0,0,5,ch50data};
+
+/* char: 0x31 '1' */
+
+static const GLubyte ch49data[] = {
+0xe0,0x40,0x40,0x40,0x40,0xc0,0x40,
+};
+
+static const BitmapCharRec ch49 = {3,7,-1,0,5,ch49data};
+
+/* char: 0x30 '0' */
+
+static const GLubyte ch48data[] = {
+0x60,0x90,0x90,0x90,0x90,0x90,0x60,
+};
+
+static const BitmapCharRec ch48 = {4,7,0,0,5,ch48data};
+
+/* char: 0x2f '/' */
+
+static const GLubyte ch47data[] = {
+0x80,0x80,0x40,0x40,0x40,0x20,0x20,
+};
+
+static const BitmapCharRec ch47 = {3,7,0,0,3,ch47data};
+
+/* char: 0x2e '.' */
+
+static const GLubyte ch46data[] = {
+0x80,
+};
+
+static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
+
+/* char: 0x2d '-' */
+
+static const GLubyte ch45data[] = {
+0xf0,
+};
+
+static const BitmapCharRec ch45 = {4,1,-1,-2,7,ch45data};
+
+/* char: 0x2c ',' */
+
+static const GLubyte ch44data[] = {
+0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch44 = {1,3,-1,2,3,ch44data};
+
+/* char: 0x2b '+' */
+
+static const GLubyte ch43data[] = {
+0x20,0x20,0xf8,0x20,0x20,
+};
+
+static const BitmapCharRec ch43 = {5,5,0,0,6,ch43data};
+
+/* char: 0x2a '*' */
+
+static const GLubyte ch42data[] = {
+0xa0,0x40,0xa0,
+};
+
+static const BitmapCharRec ch42 = {3,3,0,-4,5,ch42data};
+
+/* char: 0x29 ')' */
+
+static const GLubyte ch41data[] = {
+0x80,0x40,0x40,0x20,0x20,0x20,0x40,0x40,0x80,
+};
+
+static const BitmapCharRec ch41 = {3,9,0,2,4,ch41data};
+
+/* char: 0x28 '(' */
+
+static const GLubyte ch40data[] = {
+0x20,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x20,
+};
+
+static const BitmapCharRec ch40 = {3,9,0,2,4,ch40data};
+
+/* char: 0x27 ''' */
+
+static const GLubyte ch39data[] = {
+0x40,0xc0,
+};
+
+static const BitmapCharRec ch39 = {2,2,0,-5,3,ch39data};
+
+/* char: 0x26 '&' */
+
+static const GLubyte ch38data[] = {
+0x76,0x8d,0x98,0x74,0x6e,0x50,0x30,
+};
+
+static const BitmapCharRec ch38 = {8,7,0,0,8,ch38data};
+
+/* char: 0x25 '%' */
+
+static const GLubyte ch37data[] = {
+0x44,0x2a,0x2a,0x56,0xa8,0xa4,0x7e,
+};
+
+static const BitmapCharRec ch37 = {7,7,0,0,8,ch37data};
+
+/* char: 0x24 '$' */
+
+static const GLubyte ch36data[] = {
+0x20,0xe0,0x90,0x10,0x60,0x80,0x90,0x70,0x20,
+};
+
+static const BitmapCharRec ch36 = {4,9,0,1,5,ch36data};
+
+/* char: 0x23 '#' */
+
+static const GLubyte ch35data[] = {
+0x50,0x50,0xf8,0x50,0xf8,0x50,0x50,
+};
+
+static const BitmapCharRec ch35 = {5,7,0,0,5,ch35data};
+
+/* char: 0x22 '"' */
+
+static const GLubyte ch34data[] = {
+0xa0,0xa0,
+};
+
+static const BitmapCharRec ch34 = {3,2,0,-5,4,ch34data};
+
+/* char: 0x21 '!' */
+
+static const GLubyte ch33data[] = {
+0x80,0x0,0x80,0x80,0x80,0x80,0x80,
+};
+
+static const BitmapCharRec ch33 = {1,7,-1,0,3,ch33data};
+
+/* char: 0x20 ' ' */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch32data[] = { 0x0 };
+static const BitmapCharRec ch32 = {1,1,0,0,2,ch32data};
+#else
+static const BitmapCharRec ch32 = {0,0,0,0,2,0};
+#endif
+
+static const BitmapCharRec * const chars[] = {
+&ch32,
+&ch33,
+&ch34,
+&ch35,
+&ch36,
+&ch37,
+&ch38,
+&ch39,
+&ch40,
+&ch41,
+&ch42,
+&ch43,
+&ch44,
+&ch45,
+&ch46,
+&ch47,
+&ch48,
+&ch49,
+&ch50,
+&ch51,
+&ch52,
+&ch53,
+&ch54,
+&ch55,
+&ch56,
+&ch57,
+&ch58,
+&ch59,
+&ch60,
+&ch61,
+&ch62,
+&ch63,
+&ch64,
+&ch65,
+&ch66,
+&ch67,
+&ch68,
+&ch69,
+&ch70,
+&ch71,
+&ch72,
+&ch73,
+&ch74,
+&ch75,
+&ch76,
+&ch77,
+&ch78,
+&ch79,
+&ch80,
+&ch81,
+&ch82,
+&ch83,
+&ch84,
+&ch85,
+&ch86,
+&ch87,
+&ch88,
+&ch89,
+&ch90,
+&ch91,
+&ch92,
+&ch93,
+&ch94,
+&ch95,
+&ch96,
+&ch97,
+&ch98,
+&ch99,
+&ch100,
+&ch101,
+&ch102,
+&ch103,
+&ch104,
+&ch105,
+&ch106,
+&ch107,
+&ch108,
+&ch109,
+&ch110,
+&ch111,
+&ch112,
+&ch113,
+&ch114,
+&ch115,
+&ch116,
+&ch117,
+&ch118,
+&ch119,
+&ch120,
+&ch121,
+&ch122,
+&ch123,
+&ch124,
+&ch125,
+&ch126,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+&ch160,
+&ch161,
+&ch162,
+&ch163,
+&ch164,
+&ch165,
+&ch166,
+&ch167,
+&ch168,
+&ch169,
+&ch170,
+&ch171,
+&ch172,
+&ch173,
+&ch174,
+&ch175,
+&ch176,
+&ch177,
+&ch178,
+&ch179,
+&ch180,
+&ch181,
+&ch182,
+&ch183,
+&ch184,
+&ch185,
+&ch186,
+&ch187,
+&ch188,
+&ch189,
+&ch190,
+&ch191,
+&ch192,
+&ch193,
+&ch194,
+&ch195,
+&ch196,
+&ch197,
+&ch198,
+&ch199,
+&ch200,
+&ch201,
+&ch202,
+&ch203,
+&ch204,
+&ch205,
+&ch206,
+&ch207,
+&ch208,
+&ch209,
+&ch210,
+&ch211,
+&ch212,
+&ch213,
+&ch214,
+&ch215,
+&ch216,
+&ch217,
+&ch218,
+&ch219,
+&ch220,
+&ch221,
+&ch222,
+&ch223,
+&ch224,
+&ch225,
+&ch226,
+&ch227,
+&ch228,
+&ch229,
+&ch230,
+&ch231,
+&ch232,
+&ch233,
+&ch234,
+&ch235,
+&ch236,
+&ch237,
+&ch238,
+&ch239,
+&ch240,
+&ch241,
+&ch242,
+&ch243,
+&ch244,
+&ch245,
+&ch246,
+&ch247,
+&ch248,
+&ch249,
+&ch250,
+&ch251,
+&ch252,
+&ch253,
+&ch254,
+&ch255,
+};
+
+const BitmapFontRec glutBitmapTimesRoman10 = {
+"-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1",
+224,
+32,
+chars
+};
+
diff --git a/src/glut/glx/glut_tr24.c b/src/glut/glx/glut_tr24.c
new file mode 100644
index 0000000000..22b0e51603
--- /dev/null
+++ b/src/glut/glx/glut_tr24.c
@@ -0,0 +1,2060 @@
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+#define glutBitmapTimesRoman24 XXX
+#include "glutbitmap.h"
+#undef glutBitmapTimesRoman24
+
+/* char: 0xff */
+
+static const GLubyte ch255data[] = {
+0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
+0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
+0xf1,0xe0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
+};
+
+static const BitmapCharRec ch255 = {11,21,0,5,11,ch255data};
+
+/* char: 0xfe */
+
+static const GLubyte ch254data[] = {
+0xf0,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x6e,0x0,0x73,0x80,0x61,0x80,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x61,0x80,0x73,0x80,
+0x6e,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0xe0,0x0,
+};
+
+static const BitmapCharRec ch254 = {10,22,-1,5,12,ch254data};
+
+/* char: 0xfd */
+
+static const GLubyte ch253data[] = {
+0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
+0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
+0xf1,0xe0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,0x1,0x80,
+};
+
+static const BitmapCharRec ch253 = {11,22,0,5,11,ch253data};
+
+/* char: 0xfc */
+
+static const GLubyte ch252data[] = {
+0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
+};
+
+static const BitmapCharRec ch252 = {11,16,-1,0,13,ch252data};
+
+/* char: 0xfb */
+
+static const GLubyte ch251data[] = {
+0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
+0xc,0x0,
+};
+
+static const BitmapCharRec ch251 = {11,17,-1,0,13,ch251data};
+
+/* char: 0xfa */
+
+static const GLubyte ch250data[] = {
+0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,
+0x1,0x80,
+};
+
+static const BitmapCharRec ch250 = {11,17,-1,0,13,ch250data};
+
+/* char: 0xf9 */
+
+static const GLubyte ch249data[] = {
+0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x2,0x0,0xc,0x0,0x38,0x0,
+0x30,0x0,
+};
+
+static const BitmapCharRec ch249 = {11,17,-1,0,13,ch249data};
+
+/* char: 0xf8 */
+
+static const GLubyte ch248data[] = {
+0xc0,0x0,0xde,0x0,0x73,0x80,0x71,0x80,0xd0,0xc0,0xd8,0xc0,0xc8,0xc0,0xcc,0xc0,
+0xc4,0xc0,0xc6,0xc0,0x63,0x80,0x73,0x80,0x1e,0xc0,0x0,0xc0,
+};
+
+static const BitmapCharRec ch248 = {10,14,-1,1,12,ch248data};
+
+/* char: 0xf7 */
+
+static const GLubyte ch247data[] = {
+0x6,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0,
+0x6,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch247 = {12,10,-1,-2,14,ch247data};
+
+/* char: 0xf6 */
+
+static const GLubyte ch246data[] = {
+0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
+};
+
+static const BitmapCharRec ch246 = {10,16,-1,0,12,ch246data};
+
+/* char: 0xf5 */
+
+static const GLubyte ch245data[] = {
+0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x0,0x0,0x27,0x0,0x1c,0x80,
+};
+
+static const BitmapCharRec ch245 = {10,16,-1,0,12,ch245data};
+
+/* char: 0xf4 */
+
+static const GLubyte ch244data[] = {
+0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
+0xc,0x0,
+};
+
+static const BitmapCharRec ch244 = {10,17,-1,0,12,ch244data};
+
+/* char: 0xf3 */
+
+static const GLubyte ch243data[] = {
+0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,
+0x1,0x80,
+};
+
+static const BitmapCharRec ch243 = {10,17,-1,0,12,ch243data};
+
+/* char: 0xf2 */
+
+static const GLubyte ch242data[] = {
+0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x2,0x0,0xc,0x0,0x38,0x0,
+0x30,0x0,
+};
+
+static const BitmapCharRec ch242 = {10,17,-1,0,12,ch242data};
+
+/* char: 0xf1 */
+
+static const GLubyte ch241data[] = {
+0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x71,0xc0,0x6f,0x80,0xe7,0x0,0x0,0x0,0x0,0x0,0x27,0x0,0x1c,0x80,
+};
+
+static const BitmapCharRec ch241 = {11,16,-1,0,13,ch241data};
+
+/* char: 0xf0 */
+
+static const GLubyte ch240data[] = {
+0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0x61,0x80,0x73,0x80,0x1f,0x0,0xc6,0x0,0x3c,0x0,0x1e,0x0,0x71,0x80,
+0xc0,0x0,
+};
+
+static const BitmapCharRec ch240 = {10,17,-1,0,12,ch240data};
+
+/* char: 0xef */
+
+static const GLubyte ch239data[] = {
+0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x0,0xcc,0xcc,
+};
+
+static const BitmapCharRec ch239 = {6,16,0,0,6,ch239data};
+
+/* char: 0xee */
+
+static const GLubyte ch238data[] = {
+0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x84,0x48,0x78,
+0x30,
+};
+
+static const BitmapCharRec ch238 = {6,17,0,0,6,ch238data};
+
+/* char: 0xed */
+
+static const GLubyte ch237data[] = {
+0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x80,0x60,0x38,
+0x18,
+};
+
+static const BitmapCharRec ch237 = {5,17,-1,0,6,ch237data};
+
+/* char: 0xec */
+
+static const GLubyte ch236data[] = {
+0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x8,0x30,0xe0,
+0xc0,
+};
+
+static const BitmapCharRec ch236 = {5,17,0,0,6,ch236data};
+
+/* char: 0xeb */
+
+static const GLubyte ch235data[] = {
+0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
+0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
+};
+
+static const BitmapCharRec ch235 = {9,16,-1,0,11,ch235data};
+
+/* char: 0xea */
+
+static const GLubyte ch234data[] = {
+0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
+0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
+0xc,0x0,
+};
+
+static const BitmapCharRec ch234 = {9,17,-1,0,11,ch234data};
+
+/* char: 0xe9 */
+
+static const GLubyte ch233data[] = {
+0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
+0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x10,0x0,0xc,0x0,0x7,0x0,
+0x3,0x0,
+};
+
+static const BitmapCharRec ch233 = {9,17,-1,0,11,ch233data};
+
+/* char: 0xe8 */
+
+static const GLubyte ch232data[] = {
+0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
+0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x4,0x0,0x18,0x0,0x70,0x0,
+0x60,0x0,
+};
+
+static const BitmapCharRec ch232 = {9,17,-1,0,11,ch232data};
+
+/* char: 0xe7 */
+
+static const GLubyte ch231data[] = {
+0x3c,0x0,0x66,0x0,0x6,0x0,0x1e,0x0,0x18,0x0,0x8,0x0,0x1e,0x0,0x7f,0x0,
+0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x41,0x80,
+0x63,0x80,0x1f,0x0,
+};
+
+static const BitmapCharRec ch231 = {9,18,-1,6,11,ch231data};
+
+/* char: 0xe6 */
+
+static const GLubyte ch230data[] = {
+0x70,0xf0,0xfb,0xf8,0xc7,0x84,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0xfc,
+0x3,0xc,0x63,0xc,0x67,0x98,0x3c,0xf0,
+};
+
+static const BitmapCharRec ch230 = {14,12,-1,0,16,ch230data};
+
+/* char: 0xe5 */
+
+static const GLubyte ch229data[] = {
+0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
+0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x1c,0x0,0x22,0x0,0x22,0x0,
+0x1c,0x0,
+};
+
+static const BitmapCharRec ch229 = {9,17,-1,0,11,ch229data};
+
+/* char: 0xe4 */
+
+static const GLubyte ch228data[] = {
+0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
+0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x66,0x0,
+};
+
+static const BitmapCharRec ch228 = {9,16,-1,0,11,ch228data};
+
+/* char: 0xe3 */
+
+static const GLubyte ch227data[] = {
+0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
+0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x5c,0x0,0x3a,0x0,
+};
+
+static const BitmapCharRec ch227 = {9,16,-1,0,11,ch227data};
+
+/* char: 0xe2 */
+
+static const GLubyte ch226data[] = {
+0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
+0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x42,0x0,0x24,0x0,0x3c,0x0,
+0x18,0x0,
+};
+
+static const BitmapCharRec ch226 = {9,17,-1,0,11,ch226data};
+
+/* char: 0xe1 */
+
+static const GLubyte ch225data[] = {
+0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
+0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x10,0x0,0xc,0x0,0x7,0x0,
+0x3,0x0,
+};
+
+static const BitmapCharRec ch225 = {9,17,-1,0,11,ch225data};
+
+/* char: 0xe0 */
+
+static const GLubyte ch224data[] = {
+0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
+0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x4,0x0,0x18,0x0,0x70,0x0,
+0x60,0x0,
+};
+
+static const BitmapCharRec ch224 = {9,17,-1,0,11,ch224data};
+
+/* char: 0xdf */
+
+static const GLubyte ch223data[] = {
+0xe7,0x0,0x6c,0x80,0x6c,0xc0,0x60,0xc0,0x60,0xc0,0x61,0xc0,0x61,0x80,0x63,0x80,
+0x67,0x0,0x6c,0x0,0x63,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
+0x1e,0x0,
+};
+
+static const BitmapCharRec ch223 = {10,17,-1,0,12,ch223data};
+
+/* char: 0xde */
+
+static const GLubyte ch222data[] = {
+0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x18,
+0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,0x3f,0xc0,0x30,0x0,0x30,0x0,0x30,0x0,
+0xfc,0x0,
+};
+
+static const BitmapCharRec ch222 = {13,17,-1,0,15,ch222data};
+
+/* char: 0xdd */
+
+static const GLubyte ch221data[] = {
+0x7,0xe0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0xc0,
+0x3,0x40,0x6,0x60,0x6,0x20,0xc,0x30,0x1c,0x10,0x18,0x18,0x38,0x8,0x30,0xc,
+0xfc,0x3f,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
+};
+
+static const BitmapCharRec ch221 = {16,22,0,0,16,ch221data};
+
+/* char: 0xdc */
+
+static const GLubyte ch220data[] = {
+0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0xfc,0x1f,0x0,0x0,0x0,0x0,0x6,0x30,0x6,0x30,
+};
+
+static const BitmapCharRec ch220 = {16,21,-1,0,18,ch220data};
+
+/* char: 0xdb */
+
+static const GLubyte ch219data[] = {
+0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0xfc,0x1f,0x0,0x0,0x8,0x10,0x6,0x60,0x3,0xc0,0x1,0x80,
+};
+
+static const BitmapCharRec ch219 = {16,22,-1,0,18,ch219data};
+
+/* char: 0xda */
+
+static const GLubyte ch218data[] = {
+0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0xfc,0x1f,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
+};
+
+static const BitmapCharRec ch218 = {16,22,-1,0,18,ch218data};
+
+/* char: 0xd9 */
+
+static const GLubyte ch217data[] = {
+0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0xfc,0x1f,0x0,0x0,0x0,0x40,0x1,0x80,0x7,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch217 = {16,22,-1,0,18,ch217data};
+
+/* char: 0xd8 */
+
+static const GLubyte ch216data[] = {
+0x20,0x0,0x27,0xe0,0x1c,0x38,0x38,0x1c,0x68,0x6,0x64,0x6,0xc2,0x3,0xc2,0x3,
+0xc1,0x3,0xc1,0x3,0xc0,0x83,0xc0,0x83,0xc0,0x43,0x60,0x46,0x60,0x26,0x38,0x1c,
+0x1c,0x38,0x7,0xe4,0x0,0x4,
+};
+
+static const BitmapCharRec ch216 = {16,19,-1,1,18,ch216data};
+
+/* char: 0xd7 */
+
+static const GLubyte ch215data[] = {
+0x80,0x40,0xc0,0xc0,0x61,0x80,0x33,0x0,0x1e,0x0,0xc,0x0,0x1e,0x0,0x33,0x0,
+0x61,0x80,0xc0,0xc0,0x80,0x40,
+};
+
+static const BitmapCharRec ch215 = {10,11,-2,-1,14,ch215data};
+
+/* char: 0xd6 */
+
+static const GLubyte ch214data[] = {
+0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
+0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
+0x7,0xe0,0x0,0x0,0x0,0x0,0x6,0x60,0x6,0x60,
+};
+
+static const BitmapCharRec ch214 = {16,21,-1,0,18,ch214data};
+
+/* char: 0xd5 */
+
+static const GLubyte ch213data[] = {
+0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
+0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
+0x7,0xe0,0x0,0x0,0x0,0x0,0x4,0xe0,0x3,0x90,
+};
+
+static const BitmapCharRec ch213 = {16,21,-1,0,18,ch213data};
+
+/* char: 0xd4 */
+
+static const GLubyte ch212data[] = {
+0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
+0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
+0x7,0xe0,0x0,0x0,0x8,0x10,0x6,0x60,0x3,0xc0,0x1,0x80,
+};
+
+static const BitmapCharRec ch212 = {16,22,-1,0,18,ch212data};
+
+/* char: 0xd3 */
+
+static const GLubyte ch211data[] = {
+0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
+0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
+0x7,0xe0,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
+};
+
+static const BitmapCharRec ch211 = {16,22,-1,0,18,ch211data};
+
+/* char: 0xd2 */
+
+static const GLubyte ch210data[] = {
+0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
+0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
+0x7,0xe0,0x0,0x0,0x0,0x40,0x1,0x80,0x7,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch210 = {16,22,-1,0,18,ch210data};
+
+/* char: 0xd1 */
+
+static const GLubyte ch209data[] = {
+0xf8,0xc,0x20,0x1c,0x20,0x1c,0x20,0x34,0x20,0x64,0x20,0x64,0x20,0xc4,0x21,0x84,
+0x21,0x84,0x23,0x4,0x26,0x4,0x26,0x4,0x2c,0x4,0x38,0x4,0x38,0x4,0x30,0x4,
+0xf0,0x1f,0x0,0x0,0x0,0x0,0x4,0xe0,0x3,0x90,
+};
+
+static const BitmapCharRec ch209 = {16,21,-1,0,18,ch209data};
+
+/* char: 0xd0 */
+
+static const GLubyte ch208data[] = {
+0x7f,0xe0,0x18,0x38,0x18,0x1c,0x18,0x6,0x18,0x6,0x18,0x3,0x18,0x3,0x18,0x3,
+0xff,0x3,0x18,0x3,0x18,0x3,0x18,0x3,0x18,0x6,0x18,0x6,0x18,0x1c,0x18,0x38,
+0x7f,0xe0,
+};
+
+static const BitmapCharRec ch208 = {16,17,0,0,17,ch208data};
+
+/* char: 0xcf */
+
+static const GLubyte ch207data[] = {
+0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+0xfc,0x0,0x0,0xcc,0xcc,
+};
+
+static const BitmapCharRec ch207 = {6,21,-1,0,8,ch207data};
+
+/* char: 0xce */
+
+static const GLubyte ch206data[] = {
+0x7e,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x7e,0x0,0x81,0x66,0x3c,0x18,
+};
+
+static const BitmapCharRec ch206 = {8,22,-1,0,8,ch206data};
+
+/* char: 0xcd */
+
+static const GLubyte ch205data[] = {
+0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+0xfc,0x0,0x40,0x30,0x1c,0xc,
+};
+
+static const BitmapCharRec ch205 = {6,22,-1,0,8,ch205data};
+
+/* char: 0xcc */
+
+static const GLubyte ch204data[] = {
+0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+0xfc,0x0,0x8,0x30,0xe0,0xc0,
+};
+
+static const BitmapCharRec ch204 = {6,22,-1,0,8,ch204data};
+
+/* char: 0xcb */
+
+static const GLubyte ch203data[] = {
+0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
+0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
+0xff,0xf0,0x0,0x0,0x0,0x0,0x19,0x80,0x19,0x80,
+};
+
+static const BitmapCharRec ch203 = {13,21,-1,0,15,ch203data};
+
+/* char: 0xca */
+
+static const GLubyte ch202data[] = {
+0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
+0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
+0xff,0xf0,0x0,0x0,0x10,0x20,0xc,0xc0,0x7,0x80,0x3,0x0,
+};
+
+static const BitmapCharRec ch202 = {13,22,-1,0,15,ch202data};
+
+/* char: 0xc9 */
+
+static const GLubyte ch201data[] = {
+0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
+0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
+0xff,0xf0,0x0,0x0,0x4,0x0,0x3,0x0,0x1,0xc0,0x0,0xc0,
+};
+
+static const BitmapCharRec ch201 = {13,22,-1,0,15,ch201data};
+
+/* char: 0xc8 */
+
+static const GLubyte ch200data[] = {
+0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
+0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
+0xff,0xf0,0x0,0x0,0x1,0x0,0x6,0x0,0x1c,0x0,0x18,0x0,
+};
+
+static const BitmapCharRec ch200 = {13,22,-1,0,15,ch200data};
+
+/* char: 0xc7 */
+
+static const GLubyte ch199data[] = {
+0x7,0x80,0xc,0xc0,0x0,0xc0,0x3,0xc0,0x3,0x0,0x1,0x0,0x7,0xe0,0x1e,0x38,
+0x38,0x8,0x60,0x4,0x60,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
+0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,0x7,0xe4,
+};
+
+static const BitmapCharRec ch199 = {14,23,-1,6,16,ch199data};
+
+/* char: 0xc6 */
+
+static const GLubyte ch198data[] = {
+0xf9,0xff,0xf0,0x30,0x60,0x30,0x10,0x60,0x10,0x10,0x60,0x10,0x18,0x60,0x0,0x8,
+0x60,0x0,0xf,0xe0,0x80,0xc,0x60,0x80,0x4,0x7f,0x80,0x4,0x60,0x80,0x6,0x60,
+0x80,0x2,0x60,0x0,0x2,0x60,0x0,0x1,0x60,0x20,0x1,0x60,0x20,0x1,0xe0,0x60,
+0x3,0xff,0xe0,
+};
+
+static const BitmapCharRec ch198 = {20,17,0,0,21,ch198data};
+
+/* char: 0xc5 */
+
+static const GLubyte ch197data[] = {
+0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
+0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
+0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
+0x0,0x80,0x0,0x1,0xc0,0x0,0x2,0x20,0x0,0x2,0x20,0x0,0x1,0xc0,0x0,
+};
+
+static const BitmapCharRec ch197 = {17,21,0,0,17,ch197data};
+
+/* char: 0xc4 */
+
+static const GLubyte ch196data[] = {
+0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
+0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
+0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
+0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x30,0x0,0x6,0x30,0x0,
+};
+
+static const BitmapCharRec ch196 = {17,21,0,0,17,ch196data};
+
+/* char: 0xc3 */
+
+static const GLubyte ch195data[] = {
+0xfc,0x1f,0x80,0x30,0x7,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
+0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
+0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
+0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0xe0,0x0,0x3,0x90,0x0,
+};
+
+static const BitmapCharRec ch195 = {17,21,0,0,17,ch195data};
+
+/* char: 0xc2 */
+
+static const GLubyte ch194data[] = {
+0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
+0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
+0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
+0x0,0x80,0x0,0x0,0x0,0x0,0x8,0x10,0x0,0x6,0x60,0x0,0x3,0xc0,0x0,0x1,
+0x80,0x0,
+};
+
+static const BitmapCharRec ch194 = {17,22,0,0,17,ch194data};
+
+/* char: 0xc1 */
+
+static const GLubyte ch193data[] = {
+0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
+0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
+0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
+0x0,0x80,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xc0,0x0,0x0,0x70,0x0,0x0,
+0x30,0x0,
+};
+
+static const BitmapCharRec ch193 = {17,22,0,0,17,ch193data};
+
+/* char: 0xc0 */
+
+static const GLubyte ch192data[] = {
+0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
+0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
+0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
+0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0xc0,0x0,0x3,0x80,0x0,0x3,
+0x0,0x0,
+};
+
+static const BitmapCharRec ch192 = {17,22,0,0,17,ch192data};
+
+/* char: 0xbf */
+
+static const GLubyte ch191data[] = {
+0x3e,0x63,0xc1,0xc3,0xc3,0xe0,0x70,0x30,0x38,0x18,0x18,0x8,0x8,0x0,0x0,0xc,
+0xc,
+};
+
+static const BitmapCharRec ch191 = {8,17,-1,5,11,ch191data};
+
+/* char: 0xbe */
+
+static const GLubyte ch190data[] = {
+0x18,0x2,0x0,0x8,0x2,0x0,0xc,0x7f,0x80,0x4,0x22,0x0,0x6,0x32,0x0,0x3,
+0x12,0x0,0x1,0xa,0x0,0x71,0x8e,0x0,0x88,0x86,0x0,0x8c,0xc2,0x0,0xc,0x60,
+0x0,0x8,0x20,0x0,0x30,0x30,0x0,0x8,0x10,0x0,0x8c,0x18,0x0,0x4c,0xc,0x0,
+0x38,0x4,0x0,
+};
+
+static const BitmapCharRec ch190 = {17,17,0,0,18,ch190data};
+
+/* char: 0xbd */
+
+static const GLubyte ch189data[] = {
+0x30,0x7e,0x10,0x22,0x18,0x10,0x8,0x18,0xc,0x8,0x6,0x4,0x2,0x6,0xfb,0x46,
+0x21,0x26,0x21,0x9c,0x20,0xc0,0x20,0x40,0x20,0x60,0x20,0x20,0xa0,0x30,0x60,0x18,
+0x20,0x8,
+};
+
+static const BitmapCharRec ch189 = {15,17,-1,0,18,ch189data};
+
+/* char: 0xbc */
+
+static const GLubyte ch188data[] = {
+0x30,0x4,0x10,0x4,0x18,0xff,0x8,0x44,0xc,0x64,0x6,0x24,0x2,0x14,0xfb,0x1c,
+0x21,0xc,0x21,0x84,0x20,0xc0,0x20,0x40,0x20,0x60,0x20,0x20,0xa0,0x30,0x60,0x18,
+0x20,0x8,
+};
+
+static const BitmapCharRec ch188 = {16,17,-1,0,18,ch188data};
+
+/* char: 0xbb */
+
+static const GLubyte ch187data[] = {
+0x88,0x0,0xcc,0x0,0x66,0x0,0x33,0x0,0x19,0x80,0x19,0x80,0x33,0x0,0x66,0x0,
+0xcc,0x0,0x88,0x0,
+};
+
+static const BitmapCharRec ch187 = {9,10,-2,-1,12,ch187data};
+
+/* char: 0xba */
+
+static const GLubyte ch186data[] = {
+0xfc,0x0,0x78,0xcc,0xcc,0xcc,0xcc,0xcc,0x78,
+};
+
+static const BitmapCharRec ch186 = {6,9,-1,-8,8,ch186data};
+
+/* char: 0xb9 */
+
+static const GLubyte ch185data[] = {
+0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xa0,0x60,0x20,
+};
+
+static const BitmapCharRec ch185 = {5,10,-1,-7,7,ch185data};
+
+/* char: 0xb8 */
+
+static const GLubyte ch184data[] = {
+0x78,0xcc,0xc,0x3c,0x30,0x10,
+};
+
+static const BitmapCharRec ch184 = {6,6,-1,6,8,ch184data};
+
+/* char: 0xb7 */
+
+static const GLubyte ch183data[] = {
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch183 = {2,2,-2,-6,6,ch183data};
+
+/* char: 0xb6 */
+
+static const GLubyte ch182data[] = {
+0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,
+0x9,0x0,0x9,0x0,0x9,0x0,0x19,0x0,0x39,0x0,0x79,0x0,0x79,0x0,0xf9,0x0,
+0xf9,0x0,0xf9,0x0,0x79,0x0,0x79,0x0,0x39,0x0,0x1f,0x80,
+};
+
+static const BitmapCharRec ch182 = {9,22,-1,5,11,ch182data};
+
+/* char: 0xb5 */
+
+static const GLubyte ch181data[] = {
+0x40,0x0,0xe0,0x0,0xc0,0x0,0x40,0x0,0x40,0x0,0x5c,0xe0,0x7e,0xc0,0x71,0xc0,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0xe1,0xc0,
+};
+
+static const BitmapCharRec ch181 = {11,17,-1,5,13,ch181data};
+
+/* char: 0xb4 */
+
+static const GLubyte ch180data[] = {
+0x80,0x60,0x38,0x18,
+};
+
+static const BitmapCharRec ch180 = {5,4,-2,-13,8,ch180data};
+
+/* char: 0xb3 */
+
+static const GLubyte ch179data[] = {
+0x70,0x88,0x8c,0xc,0x8,0x30,0x8,0x8c,0x4c,0x38,
+};
+
+static const BitmapCharRec ch179 = {6,10,0,-7,7,ch179data};
+
+/* char: 0xb2 */
+
+static const GLubyte ch178data[] = {
+0xfc,0x44,0x20,0x30,0x10,0x8,0xc,0x8c,0x4c,0x38,
+};
+
+static const BitmapCharRec ch178 = {6,10,0,-7,7,ch178data};
+
+/* char: 0xb1 */
+
+static const GLubyte ch177data[] = {
+0xff,0xf0,0xff,0xf0,0x0,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
+0xff,0xf0,0xff,0xf0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch177 = {12,15,-1,0,14,ch177data};
+
+/* char: 0xb0 */
+
+static const GLubyte ch176data[] = {
+0x38,0x44,0x82,0x82,0x82,0x44,0x38,
+};
+
+static const BitmapCharRec ch176 = {7,7,-1,-10,9,ch176data};
+
+/* char: 0xaf */
+
+static const GLubyte ch175data[] = {
+0xfc,0xfc,
+};
+
+static const BitmapCharRec ch175 = {6,2,-1,-14,8,ch175data};
+
+/* char: 0xae */
+
+static const GLubyte ch174data[] = {
+0x7,0xf0,0x0,0x1c,0x1c,0x0,0x30,0x6,0x0,0x60,0x3,0x0,0x47,0x19,0x0,0xc2,
+0x31,0x80,0x82,0x20,0x80,0x82,0x40,0x80,0x83,0xe0,0x80,0x82,0x30,0x80,0x82,0x10,
+0x80,0xc2,0x11,0x80,0x42,0x31,0x0,0x67,0xe3,0x0,0x30,0x6,0x0,0x1c,0x1c,0x0,
+0x7,0xf0,0x0,
+};
+
+static const BitmapCharRec ch174 = {17,17,-1,0,19,ch174data};
+
+/* char: 0xad */
+
+static const GLubyte ch173data[] = {
+0xfe,0xfe,
+};
+
+static const BitmapCharRec ch173 = {7,2,-1,-5,9,ch173data};
+
+/* char: 0xac */
+
+static const GLubyte ch172data[] = {
+0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0xff,0xf0,0xff,0xf0,
+};
+
+static const BitmapCharRec ch172 = {12,7,-1,-3,14,ch172data};
+
+/* char: 0xab */
+
+static const GLubyte ch171data[] = {
+0x8,0x80,0x19,0x80,0x33,0x0,0x66,0x0,0xcc,0x0,0xcc,0x0,0x66,0x0,0x33,0x0,
+0x19,0x80,0x8,0x80,
+};
+
+static const BitmapCharRec ch171 = {9,10,-2,-1,13,ch171data};
+
+/* char: 0xaa */
+
+static const GLubyte ch170data[] = {
+0x7e,0x0,0x76,0xcc,0xcc,0x7c,0xc,0xcc,0x78,
+};
+
+static const BitmapCharRec ch170 = {7,9,0,-8,8,ch170data};
+
+/* char: 0xa9 */
+
+static const GLubyte ch169data[] = {
+0x7,0xf0,0x0,0x1c,0x1c,0x0,0x30,0x6,0x0,0x61,0xc3,0x0,0x47,0x71,0x0,0xc4,
+0x19,0x80,0x8c,0x0,0x80,0x88,0x0,0x80,0x88,0x0,0x80,0x88,0x0,0x80,0x8c,0x0,
+0x80,0xc4,0x19,0x80,0x47,0x31,0x0,0x61,0xe3,0x0,0x30,0x6,0x0,0x1c,0x1c,0x0,
+0x7,0xf0,0x0,
+};
+
+static const BitmapCharRec ch169 = {17,17,-1,0,19,ch169data};
+
+/* char: 0xa8 */
+
+static const GLubyte ch168data[] = {
+0xcc,0xcc,
+};
+
+static const BitmapCharRec ch168 = {6,2,-1,-14,8,ch168data};
+
+/* char: 0xa7 */
+
+static const GLubyte ch167data[] = {
+0x38,0x64,0x62,0x6,0xe,0x1c,0x38,0x74,0xe2,0xc3,0x83,0x87,0x4e,0x3c,0x38,0x70,
+0x60,0x46,0x26,0x1c,
+};
+
+static const BitmapCharRec ch167 = {8,20,-2,2,12,ch167data};
+
+/* char: 0xa6 */
+
+static const GLubyte ch166data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,
+};
+
+static const BitmapCharRec ch166 = {2,17,-2,0,6,ch166data};
+
+/* char: 0xa5 */
+
+static const GLubyte ch165data[] = {
+0xf,0xc0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x1f,0xe0,0x3,0x0,0x1f,0xe0,
+0x3,0x0,0x7,0x80,0xc,0x80,0xc,0xc0,0x18,0x40,0x18,0x60,0x30,0x20,0x70,0x30,
+0xf8,0x7c,
+};
+
+static const BitmapCharRec ch165 = {14,17,0,0,14,ch165data};
+
+/* char: 0xa4 */
+
+static const GLubyte ch164data[] = {
+0xc0,0x60,0xee,0xe0,0x7f,0xc0,0x31,0x80,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x31,0x80,0x7f,0xc0,0xee,0xe0,0xc0,0x60,
+};
+
+static const BitmapCharRec ch164 = {11,12,-1,-3,13,ch164data};
+
+/* char: 0xa3 */
+
+static const GLubyte ch163data[] = {
+0xe7,0x80,0xbe,0xc0,0x78,0x40,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
+0x30,0x0,0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x31,0x80,0x19,0x80,
+0xf,0x0,
+};
+
+static const BitmapCharRec ch163 = {10,17,-1,0,12,ch163data};
+
+/* char: 0xa2 */
+
+static const GLubyte ch162data[] = {
+0x40,0x0,0x40,0x0,0x3e,0x0,0x7f,0x0,0x70,0x80,0xd0,0x0,0xc8,0x0,0xc8,0x0,
+0xc8,0x0,0xc4,0x0,0xc4,0x0,0x43,0x80,0x63,0x80,0x1f,0x0,0x1,0x0,0x1,0x0,
+};
+
+static const BitmapCharRec ch162 = {9,16,-1,2,12,ch162data};
+
+/* char: 0xa1 */
+
+static const GLubyte ch161data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0,
+0xc0,
+};
+
+static const BitmapCharRec ch161 = {2,17,-4,5,8,ch161data};
+
+/* char: 0xa0 */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch160data[] = { 0x0 };
+static const BitmapCharRec ch160 = {1,1,0,0,6,ch160data};
+#else
+static const BitmapCharRec ch160 = {0,0,0,0,6,0};
+#endif
+
+/* char: 0x7e '~' */
+
+static const GLubyte ch126data[] = {
+0x83,0x80,0xc7,0xc0,0x7c,0x60,0x38,0x20,
+};
+
+static const BitmapCharRec ch126 = {11,4,-1,-5,13,ch126data};
+
+/* char: 0x7d '}' */
+
+static const GLubyte ch125data[] = {
+0xe0,0x30,0x18,0x18,0x18,0x18,0x18,0x18,0x8,0xc,0x4,0x3,0x4,0xc,0x8,0x18,
+0x18,0x18,0x18,0x18,0x30,0xe0,
+};
+
+static const BitmapCharRec ch125 = {8,22,-1,5,10,ch125data};
+
+/* char: 0x7c '|' */
+
+static const GLubyte ch124data[] = {
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,
+};
+
+static const BitmapCharRec ch124 = {2,17,-2,0,6,ch124data};
+
+/* char: 0x7b '{' */
+
+static const GLubyte ch123data[] = {
+0x7,0xc,0x18,0x18,0x18,0x18,0x18,0x18,0x10,0x30,0x20,0xc0,0x20,0x30,0x10,0x18,
+0x18,0x18,0x18,0x18,0xc,0x7,
+};
+
+static const BitmapCharRec ch123 = {8,22,-1,5,10,ch123data};
+
+/* char: 0x7a 'z' */
+
+static const GLubyte ch122data[] = {
+0xff,0xc3,0x61,0x70,0x30,0x38,0x18,0x1c,0xe,0x86,0xc3,0xff,
+};
+
+static const BitmapCharRec ch122 = {8,12,-1,0,10,ch122data};
+
+/* char: 0x79 'y' */
+
+static const GLubyte ch121data[] = {
+0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
+0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
+0xf1,0xe0,
+};
+
+static const BitmapCharRec ch121 = {11,17,0,5,11,ch121data};
+
+/* char: 0x78 'x' */
+
+static const GLubyte ch120data[] = {
+0xf1,0xe0,0x60,0xc0,0x21,0x80,0x33,0x80,0x1b,0x0,0xe,0x0,0xc,0x0,0x1a,0x0,
+0x39,0x0,0x31,0x80,0x60,0xc0,0xf1,0xe0,
+};
+
+static const BitmapCharRec ch120 = {11,12,-1,0,13,ch120data};
+
+/* char: 0x77 'w' */
+
+static const GLubyte ch119data[] = {
+0x4,0x10,0x0,0xe,0x38,0x0,0xe,0x38,0x0,0x1a,0x28,0x0,0x1a,0x64,0x0,0x19,
+0x64,0x0,0x31,0x64,0x0,0x30,0xc2,0x0,0x30,0xc2,0x0,0x60,0xc2,0x0,0x60,0xc3,
+0x0,0xf1,0xe7,0x80,
+};
+
+static const BitmapCharRec ch119 = {17,12,0,0,17,ch119data};
+
+/* char: 0x76 'v' */
+
+static const GLubyte ch118data[] = {
+0x4,0x0,0xe,0x0,0xe,0x0,0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,
+0x30,0x80,0x60,0x80,0x60,0xc0,0xf1,0xe0,
+};
+
+static const BitmapCharRec ch118 = {11,12,0,0,11,ch118data};
+
+/* char: 0x75 'u' */
+
+static const GLubyte ch117data[] = {
+0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,
+};
+
+static const BitmapCharRec ch117 = {11,12,-1,0,13,ch117data};
+
+/* char: 0x74 't' */
+
+static const GLubyte ch116data[] = {
+0x1c,0x32,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x70,0x30,0x10,
+};
+
+static const BitmapCharRec ch116 = {7,15,0,0,7,ch116data};
+
+/* char: 0x73 's' */
+
+static const GLubyte ch115data[] = {
+0xf8,0xc6,0x83,0x3,0x7,0x1e,0x7c,0x70,0xe0,0xc2,0x66,0x3e,
+};
+
+static const BitmapCharRec ch115 = {8,12,-1,0,10,ch115data};
+
+/* char: 0x72 'r' */
+
+static const GLubyte ch114data[] = {
+0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x76,0x6e,0xe6,
+};
+
+static const BitmapCharRec ch114 = {7,12,-1,0,8,ch114data};
+
+/* char: 0x71 'q' */
+
+static const GLubyte ch113data[] = {
+0x3,0xc0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1d,0x80,0x73,0x80,0x61,0x80,
+0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x61,0x80,0x73,0x80,
+0x1d,0x80,
+};
+
+static const BitmapCharRec ch113 = {10,17,-1,5,12,ch113data};
+
+/* char: 0x70 'p' */
+
+static const GLubyte ch112data[] = {
+0xf0,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x6e,0x0,0x73,0x80,0x61,0x80,
+0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x61,0x80,0x73,0x80,
+0xee,0x0,
+};
+
+static const BitmapCharRec ch112 = {10,17,-1,5,12,ch112data};
+
+/* char: 0x6f 'o' */
+
+static const GLubyte ch111data[] = {
+0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,
+};
+
+static const BitmapCharRec ch111 = {10,12,-1,0,12,ch111data};
+
+/* char: 0x6e 'n' */
+
+static const GLubyte ch110data[] = {
+0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x71,0xc0,0x6f,0x80,0xe7,0x0,
+};
+
+static const BitmapCharRec ch110 = {11,12,-1,0,13,ch110data};
+
+/* char: 0x6d 'm' */
+
+static const GLubyte ch109data[] = {
+0xf1,0xe3,0xc0,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,
+0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x71,0xe3,0x80,0x6f,0x9f,
+0x0,0xe7,0xe,0x0,
+};
+
+static const BitmapCharRec ch109 = {18,12,-1,0,20,ch109data};
+
+/* char: 0x6c 'l' */
+
+static const GLubyte ch108data[] = {
+0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,
+0xe0,
+};
+
+static const BitmapCharRec ch108 = {4,17,-1,0,6,ch108data};
+
+/* char: 0x6b 'k' */
+
+static const GLubyte ch107data[] = {
+0xf3,0xe0,0x61,0xc0,0x63,0x80,0x67,0x0,0x6e,0x0,0x6c,0x0,0x78,0x0,0x68,0x0,
+0x64,0x0,0x66,0x0,0x63,0x0,0x67,0xc0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
+0xe0,0x0,
+};
+
+static const BitmapCharRec ch107 = {11,17,-1,0,12,ch107data};
+
+/* char: 0x6a 'j' */
+
+static const GLubyte ch106data[] = {
+0xc0,0xe0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+0x70,0x0,0x0,0x0,0x30,0x30,
+};
+
+static const BitmapCharRec ch106 = {4,22,0,5,6,ch106data};
+
+/* char: 0x69 'i' */
+
+static const GLubyte ch105data[] = {
+0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x0,0x0,0x60,
+0x60,
+};
+
+static const BitmapCharRec ch105 = {4,17,-1,0,6,ch105data};
+
+/* char: 0x68 'h' */
+
+static const GLubyte ch104data[] = {
+0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x71,0xc0,0x6f,0x80,0x67,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
+0xe0,0x0,
+};
+
+static const BitmapCharRec ch104 = {11,17,-1,0,13,ch104data};
+
+/* char: 0x67 'g' */
+
+static const GLubyte ch103data[] = {
+0x3f,0x0,0xf1,0xc0,0xc0,0x60,0xc0,0x20,0x60,0x60,0x3f,0xc0,0x7f,0x0,0x60,0x0,
+0x30,0x0,0x3e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
+0x1f,0xc0,
+};
+
+static const BitmapCharRec ch103 = {11,17,-1,5,12,ch103data};
+
+/* char: 0x66 'f' */
+
+static const GLubyte ch102data[] = {
+0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x30,0x30,0x30,0x16,
+0xe,
+};
+
+static const BitmapCharRec ch102 = {7,17,0,0,7,ch102data};
+
+/* char: 0x65 'e' */
+
+static const GLubyte ch101data[] = {
+0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
+0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,
+};
+
+static const BitmapCharRec ch101 = {9,12,-1,0,11,ch101data};
+
+/* char: 0x64 'd' */
+
+static const GLubyte ch100data[] = {
+0x1e,0xc0,0x73,0x80,0x61,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,
+0xc1,0x80,0x61,0x80,0x73,0x80,0x1d,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,
+0x3,0x80,
+};
+
+static const BitmapCharRec ch100 = {10,17,-1,0,12,ch100data};
+
+/* char: 0x63 'c' */
+
+static const GLubyte ch99data[] = {
+0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
+0xc0,0x0,0x41,0x80,0x63,0x80,0x1f,0x0,
+};
+
+static const BitmapCharRec ch99 = {9,12,-1,0,11,ch99data};
+
+/* char: 0x62 'b' */
+
+static const GLubyte ch98data[] = {
+0x5e,0x0,0x73,0x80,0x61,0x80,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
+0x60,0xc0,0x61,0x80,0x73,0x80,0x6e,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
+0xe0,0x0,
+};
+
+static const BitmapCharRec ch98 = {10,17,-1,0,12,ch98data};
+
+/* char: 0x61 'a' */
+
+static const GLubyte ch97data[] = {
+0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
+0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,
+};
+
+static const BitmapCharRec ch97 = {9,12,-1,0,11,ch97data};
+
+/* char: 0x60 '`' */
+
+static const GLubyte ch96data[] = {
+0x60,0xe0,0x80,0xc0,0x60,
+};
+
+static const BitmapCharRec ch96 = {3,5,-2,-12,7,ch96data};
+
+/* char: 0x5f '_' */
+
+static const GLubyte ch95data[] = {
+0xff,0xf8,0xff,0xf8,
+};
+
+static const BitmapCharRec ch95 = {13,2,0,5,13,ch95data};
+
+/* char: 0x5e '^' */
+
+static const GLubyte ch94data[] = {
+0x80,0x80,0xc1,0x80,0x41,0x0,0x63,0x0,0x22,0x0,0x36,0x0,0x14,0x0,0x1c,0x0,
+0x8,0x0,
+};
+
+static const BitmapCharRec ch94 = {9,9,-1,-8,11,ch94data};
+
+/* char: 0x5d ']' */
+
+static const GLubyte ch93data[] = {
+0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x18,0x18,0x18,0xf8,
+};
+
+static const BitmapCharRec ch93 = {5,21,-1,4,8,ch93data};
+
+/* char: 0x5c '\' */
+
+static const GLubyte ch92data[] = {
+0x6,0x6,0x4,0xc,0xc,0x8,0x18,0x18,0x10,0x30,0x30,0x20,0x60,0x60,0x40,0xc0,
+0xc0,
+};
+
+static const BitmapCharRec ch92 = {7,17,0,0,7,ch92data};
+
+/* char: 0x5b '[' */
+
+static const GLubyte ch91data[] = {
+0xf8,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0xc0,0xc0,0xf8,
+};
+
+static const BitmapCharRec ch91 = {5,21,-2,4,8,ch91data};
+
+/* char: 0x5a 'Z' */
+
+static const GLubyte ch90data[] = {
+0xff,0xf8,0xe0,0x18,0x70,0x8,0x30,0x8,0x38,0x0,0x18,0x0,0x1c,0x0,0xe,0x0,
+0x6,0x0,0x7,0x0,0x3,0x0,0x3,0x80,0x1,0xc0,0x80,0xc0,0x80,0xe0,0xc0,0x70,
+0xff,0xf0,
+};
+
+static const BitmapCharRec ch90 = {13,17,-1,0,15,ch90data};
+
+/* char: 0x59 'Y' */
+
+static const GLubyte ch89data[] = {
+0x7,0xe0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0xc0,
+0x3,0x40,0x6,0x60,0x6,0x20,0xc,0x30,0x1c,0x10,0x18,0x18,0x38,0x8,0x30,0xc,
+0xfc,0x3f,
+};
+
+static const BitmapCharRec ch89 = {16,17,0,0,16,ch89data};
+
+/* char: 0x58 'X' */
+
+static const GLubyte ch88data[] = {
+0xfc,0xf,0xc0,0x30,0x3,0x80,0x18,0x7,0x0,0x8,0xe,0x0,0x4,0xc,0x0,0x6,
+0x18,0x0,0x2,0x38,0x0,0x1,0x70,0x0,0x0,0xe0,0x0,0x0,0xc0,0x0,0x1,0xc0,
+0x0,0x3,0xa0,0x0,0x3,0x10,0x0,0x6,0x8,0x0,0xe,0xc,0x0,0x1c,0x6,0x0,
+0x7e,0xf,0x80,
+};
+
+static const BitmapCharRec ch88 = {18,17,0,0,18,ch88data};
+
+/* char: 0x57 'W' */
+
+static const GLubyte ch87data[] = {
+0x1,0x83,0x0,0x1,0x83,0x0,0x1,0x83,0x80,0x3,0x87,0x80,0x3,0x46,0x80,0x3,
+0x46,0xc0,0x6,0x46,0x40,0x6,0x4c,0x40,0x6,0x4c,0x60,0xc,0x2c,0x60,0xc,0x2c,
+0x20,0x18,0x2c,0x20,0x18,0x18,0x30,0x18,0x18,0x10,0x30,0x18,0x10,0x30,0x18,0x18,
+0xfc,0x7e,0x7e,
+};
+
+static const BitmapCharRec ch87 = {23,17,0,0,23,ch87data};
+
+/* char: 0x56 'V' */
+
+static const GLubyte ch86data[] = {
+0x1,0x80,0x0,0x1,0x80,0x0,0x1,0x80,0x0,0x3,0xc0,0x0,0x3,0x40,0x0,0x3,
+0x60,0x0,0x6,0x20,0x0,0x6,0x20,0x0,0x6,0x30,0x0,0xc,0x10,0x0,0xc,0x18,
+0x0,0x18,0x8,0x0,0x18,0x8,0x0,0x18,0xc,0x0,0x30,0x4,0x0,0x30,0x6,0x0,
+0xfc,0x1f,0x80,
+};
+
+static const BitmapCharRec ch86 = {17,17,0,0,17,ch86data};
+
+/* char: 0x55 'U' */
+
+static const GLubyte ch85data[] = {
+0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
+0xfc,0x1f,
+};
+
+static const BitmapCharRec ch85 = {16,17,-1,0,18,ch85data};
+
+/* char: 0x54 'T' */
+
+static const GLubyte ch84data[] = {
+0xf,0xc0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,
+0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x83,0x4,0x83,0x4,0xc3,0xc,
+0xff,0xfc,
+};
+
+static const BitmapCharRec ch84 = {14,17,-1,0,16,ch84data};
+
+/* char: 0x53 'S' */
+
+static const GLubyte ch83data[] = {
+0x9e,0x0,0xf1,0x80,0xc0,0xc0,0x80,0x60,0x80,0x60,0x0,0x60,0x0,0xe0,0x3,0xc0,
+0xf,0x80,0x1e,0x0,0x78,0x0,0xe0,0x0,0xc0,0x40,0xc0,0x40,0xc0,0xc0,0x63,0xc0,
+0x1e,0x40,
+};
+
+static const BitmapCharRec ch83 = {11,17,-1,0,13,ch83data};
+
+/* char: 0x52 'R' */
+
+static const GLubyte ch82data[] = {
+0xfc,0x1e,0x30,0x1c,0x30,0x38,0x30,0x70,0x30,0x60,0x30,0xc0,0x31,0xc0,0x33,0x80,
+0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x38,0x30,0x18,0x30,0x38,0x30,0x30,0x30,0x70,
+0xff,0xc0,
+};
+
+static const BitmapCharRec ch82 = {15,17,-1,0,16,ch82data};
+
+/* char: 0x51 'Q' */
+
+static const GLubyte ch81data[] = {
+0x0,0xf,0x0,0x38,0x0,0x70,0x0,0xe0,0x1,0xc0,0x7,0xe0,0x1c,0x38,0x38,0x1c,
+0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,
+0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,0x7,0xe0,
+};
+
+static const BitmapCharRec ch81 = {16,22,-1,5,18,ch81data};
+
+/* char: 0x50 'P' */
+
+static const GLubyte ch80data[] = {
+0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
+0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x18,0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,
+0xff,0xc0,
+};
+
+static const BitmapCharRec ch80 = {13,17,-1,0,15,ch80data};
+
+/* char: 0x4f 'O' */
+
+static const GLubyte ch79data[] = {
+0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
+0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
+0x7,0xe0,
+};
+
+static const BitmapCharRec ch79 = {16,17,-1,0,18,ch79data};
+
+/* char: 0x4e 'N' */
+
+static const GLubyte ch78data[] = {
+0xf8,0xc,0x20,0x1c,0x20,0x1c,0x20,0x34,0x20,0x64,0x20,0x64,0x20,0xc4,0x21,0x84,
+0x21,0x84,0x23,0x4,0x26,0x4,0x26,0x4,0x2c,0x4,0x38,0x4,0x38,0x4,0x30,0x4,
+0xf0,0x1f,
+};
+
+static const BitmapCharRec ch78 = {16,17,-1,0,18,ch78data};
+
+/* char: 0x4d 'M' */
+
+static const GLubyte ch77data[] = {
+0xf8,0x21,0xf8,0x20,0x60,0x60,0x20,0x60,0x60,0x20,0xd0,0x60,0x20,0xd0,0x60,0x21,
+0x88,0x60,0x21,0x88,0x60,0x23,0x8,0x60,0x23,0x4,0x60,0x26,0x4,0x60,0x26,0x2,
+0x60,0x2c,0x2,0x60,0x2c,0x2,0x60,0x38,0x1,0x60,0x38,0x1,0x60,0x30,0x0,0xe0,
+0xf0,0x0,0xf8,
+};
+
+static const BitmapCharRec ch77 = {21,17,-1,0,22,ch77data};
+
+/* char: 0x4c 'L' */
+
+static const GLubyte ch76data[] = {
+0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
+0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
+0xfc,0x0,
+};
+
+static const BitmapCharRec ch76 = {13,17,-1,0,14,ch76data};
+
+/* char: 0x4b 'K' */
+
+static const GLubyte ch75data[] = {
+0xfc,0x1f,0x30,0xe,0x30,0x1c,0x30,0x38,0x30,0x70,0x30,0xe0,0x31,0xc0,0x33,0x80,
+0x3f,0x0,0x3e,0x0,0x33,0x0,0x31,0x80,0x30,0xc0,0x30,0x60,0x30,0x30,0x30,0x18,
+0xfc,0x7e,
+};
+
+static const BitmapCharRec ch75 = {16,17,-1,0,17,ch75data};
+
+/* char: 0x4a 'J' */
+
+static const GLubyte ch74data[] = {
+0x78,0x0,0xcc,0x0,0xc6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
+0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
+0x1f,0x80,
+};
+
+static const BitmapCharRec ch74 = {9,17,-1,0,11,ch74data};
+
+/* char: 0x49 'I' */
+
+static const GLubyte ch73data[] = {
+0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+0xfc,
+};
+
+static const BitmapCharRec ch73 = {6,17,-1,0,8,ch73data};
+
+/* char: 0x48 'H' */
+
+static const GLubyte ch72data[] = {
+0xfc,0x1f,0x80,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,
+0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x3f,0xfe,0x0,0x30,0x6,0x0,0x30,0x6,
+0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,
+0xfc,0x1f,0x80,
+};
+
+static const BitmapCharRec ch72 = {17,17,-1,0,19,ch72data};
+
+/* char: 0x47 'G' */
+
+static const GLubyte ch71data[] = {
+0x7,0xe0,0x1e,0x38,0x38,0x1c,0x60,0xc,0x60,0xc,0xc0,0xc,0xc0,0xc,0xc0,0x3f,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,
+0x7,0xe4,
+};
+
+static const BitmapCharRec ch71 = {16,17,-1,0,18,ch71data};
+
+/* char: 0x46 'F' */
+
+static const GLubyte ch70data[] = {
+0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x20,0x30,0x20,
+0x3f,0xe0,0x30,0x20,0x30,0x20,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
+0xff,0xf0,
+};
+
+static const BitmapCharRec ch70 = {12,17,-1,0,14,ch70data};
+
+/* char: 0x45 'E' */
+
+static const GLubyte ch69data[] = {
+0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
+0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
+0xff,0xf0,
+};
+
+static const BitmapCharRec ch69 = {13,17,-1,0,15,ch69data};
+
+/* char: 0x44 'D' */
+
+static const GLubyte ch68data[] = {
+0xff,0xc0,0x30,0x70,0x30,0x38,0x30,0xc,0x30,0xc,0x30,0x6,0x30,0x6,0x30,0x6,
+0x30,0x6,0x30,0x6,0x30,0x6,0x30,0x6,0x30,0xc,0x30,0xc,0x30,0x38,0x30,0x70,
+0xff,0xc0,
+};
+
+static const BitmapCharRec ch68 = {15,17,-1,0,17,ch68data};
+
+/* char: 0x43 'C' */
+
+static const GLubyte ch67data[] = {
+0x7,0xe0,0x1e,0x38,0x38,0x8,0x60,0x4,0x60,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
+0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,
+0x7,0xe4,
+};
+
+static const BitmapCharRec ch67 = {14,17,-1,0,16,ch67data};
+
+/* char: 0x42 'B' */
+
+static const GLubyte ch66data[] = {
+0xff,0xe0,0x30,0x78,0x30,0x18,0x30,0xc,0x30,0xc,0x30,0xc,0x30,0x18,0x30,0x38,
+0x3f,0xe0,0x30,0x40,0x30,0x30,0x30,0x18,0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,
+0xff,0xc0,
+};
+
+static const BitmapCharRec ch66 = {14,17,-1,0,16,ch66data};
+
+/* char: 0x41 'A' */
+
+static const GLubyte ch65data[] = {
+0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
+0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
+0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
+0x0,0x80,0x0,
+};
+
+static const BitmapCharRec ch65 = {17,17,0,0,17,ch65data};
+
+/* char: 0x40 '@' */
+
+static const GLubyte ch64data[] = {
+0x3,0xf0,0x0,0xe,0xc,0x0,0x18,0x0,0x0,0x30,0x0,0x0,0x61,0xde,0x0,0x63,
+0x7b,0x0,0xc6,0x39,0x80,0xc6,0x18,0x80,0xc6,0x18,0xc0,0xc6,0x18,0x40,0xc6,0xc,
+0x40,0xc3,0xc,0x40,0xc3,0x8c,0x40,0xe1,0xfc,0x40,0x60,0xec,0xc0,0x70,0x0,0x80,
+0x38,0x1,0x80,0x1c,0x3,0x0,0xf,0xe,0x0,0x3,0xf8,0x0,
+};
+
+static const BitmapCharRec ch64 = {18,20,-2,3,22,ch64data};
+
+/* char: 0x3f '?' */
+
+static const GLubyte ch63data[] = {
+0x30,0x30,0x0,0x0,0x10,0x10,0x10,0x18,0x18,0xc,0xe,0x7,0xc3,0xc3,0x83,0xc6,
+0x7c,
+};
+
+static const BitmapCharRec ch63 = {8,17,-2,0,11,ch63data};
+
+/* char: 0x3e '>' */
+
+static const GLubyte ch62data[] = {
+0xc0,0x0,0x70,0x0,0x1c,0x0,0x7,0x0,0x1,0xc0,0x0,0x60,0x1,0xc0,0x7,0x0,
+0x1c,0x0,0x70,0x0,0xc0,0x0,
+};
+
+static const BitmapCharRec ch62 = {11,11,-1,-1,13,ch62data};
+
+/* char: 0x3d '=' */
+
+static const GLubyte ch61data[] = {
+0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0,
+};
+
+static const BitmapCharRec ch61 = {12,6,-1,-4,14,ch61data};
+
+/* char: 0x3c '<' */
+
+static const GLubyte ch60data[] = {
+0x0,0x60,0x1,0xc0,0x7,0x0,0x1c,0x0,0x70,0x0,0xc0,0x0,0x70,0x0,0x1c,0x0,
+0x7,0x0,0x1,0xc0,0x0,0x60,
+};
+
+static const BitmapCharRec ch60 = {11,11,-1,-1,13,ch60data};
+
+/* char: 0x3b ';' */
+
+static const GLubyte ch59data[] = {
+0xc0,0x60,0x20,0xe0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch59 = {3,14,-2,3,7,ch59data};
+
+/* char: 0x3a ':' */
+
+static const GLubyte ch58data[] = {
+0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
+};
+
+static const BitmapCharRec ch58 = {2,11,-2,0,6,ch58data};
+
+/* char: 0x39 '9' */
+
+static const GLubyte ch57data[] = {
+0xf0,0x0,0x1c,0x0,0x6,0x0,0x3,0x0,0x3,0x80,0x1,0x80,0x1d,0x80,0x73,0xc0,
+0x61,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0x61,0x80,0x77,0x80,
+0x1e,0x0,
+};
+
+static const BitmapCharRec ch57 = {10,17,-1,0,12,ch57data};
+
+/* char: 0x38 '8' */
+
+static const GLubyte ch56data[] = {
+0x1e,0x0,0x73,0x80,0xe1,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x41,0xc0,0x61,0x80,
+0x37,0x0,0x1e,0x0,0x1e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
+0x1e,0x0,
+};
+
+static const BitmapCharRec ch56 = {10,17,-1,0,12,ch56data};
+
+/* char: 0x37 '7' */
+
+static const GLubyte ch55data[] = {
+0x18,0x0,0x18,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0x4,0x0,0x6,0x0,0x6,0x0,
+0x2,0x0,0x3,0x0,0x3,0x0,0x1,0x0,0x1,0x80,0x81,0x80,0xc0,0xc0,0xff,0xc0,
+0x7f,0xc0,
+};
+
+static const BitmapCharRec ch55 = {10,17,-1,0,12,ch55data};
+
+/* char: 0x36 '6' */
+
+static const GLubyte ch54data[] = {
+0x1e,0x0,0x7b,0x80,0x61,0x80,0xe0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc1,0x80,0xf3,0x80,0xee,0x0,0x60,0x0,0x70,0x0,0x30,0x0,0x18,0x0,0xe,0x0,
+0x3,0xc0,
+};
+
+static const BitmapCharRec ch54 = {10,17,-1,0,12,ch54data};
+
+/* char: 0x35 '5' */
+
+static const GLubyte ch53data[] = {
+0x7e,0x0,0xe3,0x80,0xc1,0x80,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x1,0xc0,
+0x3,0x80,0xf,0x80,0x7e,0x0,0x78,0x0,0x60,0x0,0x20,0x0,0x20,0x0,0x1f,0x80,
+0x1f,0xc0,
+};
+
+static const BitmapCharRec ch53 = {10,17,-1,0,12,ch53data};
+
+/* char: 0x34 '4' */
+
+static const GLubyte ch52data[] = {
+0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0xff,0xc0,0xff,0xc0,0xc3,0x0,0x43,0x0,
+0x63,0x0,0x23,0x0,0x33,0x0,0x13,0x0,0x1b,0x0,0xb,0x0,0x7,0x0,0x7,0x0,
+0x3,0x0,
+};
+
+static const BitmapCharRec ch52 = {10,17,-1,0,12,ch52data};
+
+/* char: 0x33 '3' */
+
+static const GLubyte ch51data[] = {
+0x78,0x0,0xe6,0x0,0xc3,0x0,0x1,0x0,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0x80,
+0x7,0x0,0x1e,0x0,0xc,0x0,0x6,0x0,0x83,0x0,0x83,0x0,0x47,0x0,0x7e,0x0,
+0x1c,0x0,
+};
+
+static const BitmapCharRec ch51 = {9,17,-1,0,12,ch51data};
+
+/* char: 0x32 '2' */
+
+static const GLubyte ch50data[] = {
+0xff,0x80,0xff,0xc0,0x60,0x40,0x30,0x0,0x18,0x0,0xc,0x0,0x4,0x0,0x6,0x0,
+0x3,0x0,0x3,0x0,0x1,0x80,0x1,0x80,0x81,0x80,0x81,0x80,0x43,0x80,0x7f,0x0,
+0x1c,0x0,
+};
+
+static const BitmapCharRec ch50 = {10,17,-1,0,12,ch50data};
+
+/* char: 0x31 '1' */
+
+static const GLubyte ch49data[] = {
+0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x78,0x18,
+0x8,
+};
+
+static const BitmapCharRec ch49 = {8,17,-2,0,12,ch49data};
+
+/* char: 0x30 '0' */
+
+static const GLubyte ch48data[] = {
+0x1e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0xe1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x61,0x80,0x61,0x80,0x33,0x0,
+0x1e,0x0,
+};
+
+static const BitmapCharRec ch48 = {10,17,-1,0,12,ch48data};
+
+/* char: 0x2f '/' */
+
+static const GLubyte ch47data[] = {
+0xc0,0xc0,0xc0,0x60,0x60,0x20,0x30,0x30,0x10,0x18,0x18,0x8,0xc,0xc,0x4,0x6,
+0x6,0x3,0x3,0x3,
+};
+
+static const BitmapCharRec ch47 = {8,20,1,3,7,ch47data};
+
+/* char: 0x2e '.' */
+
+static const GLubyte ch46data[] = {
+0xc0,0xc0,
+};
+
+static const BitmapCharRec ch46 = {2,2,-2,0,6,ch46data};
+
+/* char: 0x2d '-' */
+
+static const GLubyte ch45data[] = {
+0xff,0xf0,0xff,0xf0,
+};
+
+static const BitmapCharRec ch45 = {12,2,-1,-6,14,ch45data};
+
+/* char: 0x2c ',' */
+
+static const GLubyte ch44data[] = {
+0xc0,0x60,0x20,0xe0,0xc0,
+};
+
+static const BitmapCharRec ch44 = {3,5,-2,3,7,ch44data};
+
+/* char: 0x2b '+' */
+
+static const GLubyte ch43data[] = {
+0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xff,0xf0,0xff,0xf0,0x6,0x0,
+0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
+};
+
+static const BitmapCharRec ch43 = {12,12,-1,-1,14,ch43data};
+
+/* char: 0x2a '*' */
+
+static const GLubyte ch42data[] = {
+0x8,0x0,0x1c,0x0,0xc9,0x80,0xeb,0x80,0x1c,0x0,0xeb,0x80,0xc9,0x80,0x1c,0x0,
+0x8,0x0,
+};
+
+static const BitmapCharRec ch42 = {9,9,-2,-8,12,ch42data};
+
+/* char: 0x29 ')' */
+
+static const GLubyte ch41data[] = {
+0x80,0x40,0x20,0x30,0x10,0x18,0x18,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0x18,
+0x18,0x10,0x30,0x20,0x40,0x80,
+};
+
+static const BitmapCharRec ch41 = {6,22,-1,5,8,ch41data};
+
+/* char: 0x28 '(' */
+
+static const GLubyte ch40data[] = {
+0x4,0x8,0x10,0x30,0x20,0x60,0x60,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x60,
+0x60,0x20,0x30,0x10,0x8,0x4,
+};
+
+static const BitmapCharRec ch40 = {6,22,-1,5,8,ch40data};
+
+/* char: 0x27 ''' */
+
+static const GLubyte ch39data[] = {
+0xc0,0x60,0x20,0xe0,0xc0,
+};
+
+static const BitmapCharRec ch39 = {3,5,-3,-12,8,ch39data};
+
+/* char: 0x26 '&' */
+
+static const GLubyte ch38data[] = {
+0x3c,0x3c,0x7f,0x7e,0xe1,0xe1,0xc0,0xc0,0xc1,0xc0,0xc1,0xa0,0x63,0x20,0x37,0x10,
+0x1e,0x18,0xe,0x3e,0xf,0x0,0x1d,0x80,0x18,0xc0,0x18,0x40,0x18,0x40,0xc,0xc0,
+0x7,0x80,
+};
+
+static const BitmapCharRec ch38 = {16,17,-1,0,18,ch38data};
+
+/* char: 0x25 '%' */
+
+static const GLubyte ch37data[] = {
+0x30,0x3c,0x0,0x18,0x72,0x0,0xc,0x61,0x0,0x4,0x60,0x80,0x6,0x60,0x80,0x3,
+0x30,0x80,0x1,0x19,0x80,0x1,0x8f,0x0,0x78,0xc0,0x0,0xe4,0x40,0x0,0xc2,0x60,
+0x0,0xc1,0x30,0x0,0xc1,0x10,0x0,0x61,0x18,0x0,0x33,0xfc,0x0,0x1e,0xc,0x0,
+};
+
+static const BitmapCharRec ch37 = {17,16,-1,0,19,ch37data};
+
+/* char: 0x24 '$' */
+
+static const GLubyte ch36data[] = {
+0x4,0x0,0x4,0x0,0x3f,0x0,0xe5,0xc0,0xc4,0xc0,0x84,0x60,0x84,0x60,0x4,0x60,
+0x4,0xe0,0x7,0xc0,0x7,0x80,0x1e,0x0,0x3c,0x0,0x74,0x0,0x64,0x0,0x64,0x20,
+0x64,0x60,0x34,0xe0,0x1f,0x80,0x4,0x0,0x4,0x0,
+};
+
+static const BitmapCharRec ch36 = {11,21,0,2,12,ch36data};
+
+/* char: 0x23 '#' */
+
+static const GLubyte ch35data[] = {
+0x22,0x0,0x22,0x0,0x22,0x0,0x22,0x0,0x22,0x0,0xff,0xc0,0xff,0xc0,0x11,0x0,
+0x11,0x0,0x11,0x0,0x7f,0xe0,0x7f,0xe0,0x8,0x80,0x8,0x80,0x8,0x80,0x8,0x80,
+0x8,0x80,
+};
+
+static const BitmapCharRec ch35 = {11,17,-1,0,13,ch35data};
+
+/* char: 0x22 '"' */
+
+static const GLubyte ch34data[] = {
+0x88,0xcc,0xcc,0xcc,0xcc,
+};
+
+static const BitmapCharRec ch34 = {6,5,-1,-12,10,ch34data};
+
+/* char: 0x21 '!' */
+
+static const GLubyte ch33data[] = {
+0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
+0xc0,
+};
+
+static const BitmapCharRec ch33 = {2,17,-3,0,8,ch33data};
+
+/* char: 0x20 ' ' */
+
+#ifdef _WIN32
+/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
+   a height or width of zero does not advance the raster position
+   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
+static const GLubyte ch32data[] = { 0x0 };
+static const BitmapCharRec ch32 = {1,1,0,0,6,ch32data};
+#else
+static const BitmapCharRec ch32 = {0,0,0,0,6,0};
+#endif
+
+static const BitmapCharRec * const chars[] = {
+&ch32,
+&ch33,
+&ch34,
+&ch35,
+&ch36,
+&ch37,
+&ch38,
+&ch39,
+&ch40,
+&ch41,
+&ch42,
+&ch43,
+&ch44,
+&ch45,
+&ch46,
+&ch47,
+&ch48,
+&ch49,
+&ch50,
+&ch51,
+&ch52,
+&ch53,
+&ch54,
+&ch55,
+&ch56,
+&ch57,
+&ch58,
+&ch59,
+&ch60,
+&ch61,
+&ch62,
+&ch63,
+&ch64,
+&ch65,
+&ch66,
+&ch67,
+&ch68,
+&ch69,
+&ch70,
+&ch71,
+&ch72,
+&ch73,
+&ch74,
+&ch75,
+&ch76,
+&ch77,
+&ch78,
+&ch79,
+&ch80,
+&ch81,
+&ch82,
+&ch83,
+&ch84,
+&ch85,
+&ch86,
+&ch87,
+&ch88,
+&ch89,
+&ch90,
+&ch91,
+&ch92,
+&ch93,
+&ch94,
+&ch95,
+&ch96,
+&ch97,
+&ch98,
+&ch99,
+&ch100,
+&ch101,
+&ch102,
+&ch103,
+&ch104,
+&ch105,
+&ch106,
+&ch107,
+&ch108,
+&ch109,
+&ch110,
+&ch111,
+&ch112,
+&ch113,
+&ch114,
+&ch115,
+&ch116,
+&ch117,
+&ch118,
+&ch119,
+&ch120,
+&ch121,
+&ch122,
+&ch123,
+&ch124,
+&ch125,
+&ch126,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+0,
+&ch160,
+&ch161,
+&ch162,
+&ch163,
+&ch164,
+&ch165,
+&ch166,
+&ch167,
+&ch168,
+&ch169,
+&ch170,
+&ch171,
+&ch172,
+&ch173,
+&ch174,
+&ch175,
+&ch176,
+&ch177,
+&ch178,
+&ch179,
+&ch180,
+&ch181,
+&ch182,
+&ch183,
+&ch184,
+&ch185,
+&ch186,
+&ch187,
+&ch188,
+&ch189,
+&ch190,
+&ch191,
+&ch192,
+&ch193,
+&ch194,
+&ch195,
+&ch196,
+&ch197,
+&ch198,
+&ch199,
+&ch200,
+&ch201,
+&ch202,
+&ch203,
+&ch204,
+&ch205,
+&ch206,
+&ch207,
+&ch208,
+&ch209,
+&ch210,
+&ch211,
+&ch212,
+&ch213,
+&ch214,
+&ch215,
+&ch216,
+&ch217,
+&ch218,
+&ch219,
+&ch220,
+&ch221,
+&ch222,
+&ch223,
+&ch224,
+&ch225,
+&ch226,
+&ch227,
+&ch228,
+&ch229,
+&ch230,
+&ch231,
+&ch232,
+&ch233,
+&ch234,
+&ch235,
+&ch236,
+&ch237,
+&ch238,
+&ch239,
+&ch240,
+&ch241,
+&ch242,
+&ch243,
+&ch244,
+&ch245,
+&ch246,
+&ch247,
+&ch248,
+&ch249,
+&ch250,
+&ch251,
+&ch252,
+&ch253,
+&ch254,
+&ch255,
+};
+
+const BitmapFontRec glutBitmapTimesRoman24 = {
+"-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1",
+224,
+32,
+chars
+};
+
diff --git a/src/glut/glx/glut_util.c b/src/glut/glx/glut_util.c
new file mode 100644
index 0000000000..e18a47fb83
--- /dev/null
+++ b/src/glut/glx/glut_util.c
@@ -0,0 +1,86 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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 <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "glutint.h"
+
+/* strdup is actually not a standard ANSI C or POSIX routine
+   so implement a private one for GLUT.  OpenVMS does not have a
+   strdup; Linux's standard libc doesn't declare strdup by default
+   (unless BSD or SVID interfaces are requested). */
+char *
+__glutStrdup(const char *string)
+{
+  char *copy;
+
+  copy = (char*) malloc(strlen(string) + 1);
+  if (copy == NULL)
+    return NULL;
+  strcpy(copy, string);
+  return copy;
+}
+
+void
+__glutWarning(char *format,...)
+{
+  va_list args;
+
+  va_start(args, format);
+  fprintf(stderr, "GLUT: Warning in %s: ",
+    __glutProgramName ? __glutProgramName : "(unamed)");
+  vfprintf(stderr, format, args);
+  va_end(args);
+  putc('\n', stderr);
+}
+
+/* CENTRY */
+void APIENTRY 
+glutReportErrors(void)
+{
+  GLenum error;
+
+  while ((error = glGetError()) != GL_NO_ERROR)
+    __glutWarning("GL error: %s", gluErrorString(error));
+}
+/* ENDCENTRY */
+
+void
+__glutFatalError(char *format,...)
+{
+  va_list args;
+
+  va_start(args, format);
+  fprintf(stderr, "GLUT: Fatal Error in %s: ",
+    __glutProgramName ? __glutProgramName : "(unamed)");
+  vfprintf(stderr, format, args);
+  va_end(args);
+  putc('\n', stderr);
+#ifdef _WIN32
+  if (__glutExitFunc) {
+    __glutExitFunc(1);
+  }
+#endif
+  exit(1);
+}
+
+void
+__glutFatalUsage(char *format,...)
+{
+  va_list args;
+
+  va_start(args, format);
+  fprintf(stderr, "GLUT: Fatal API Usage in %s: ",
+    __glutProgramName ? __glutProgramName : "(unamed)");
+  vfprintf(stderr, format, args);
+  va_end(args);
+  putc('\n', stderr);
+  abort();
+}
diff --git a/src/glut/glx/glut_vidresize.c b/src/glut/glx/glut_vidresize.c
new file mode 100644
index 0000000000..5b82573478
--- /dev/null
+++ b/src/glut/glx/glut_vidresize.c
@@ -0,0 +1,230 @@
+
+/* Copyright (c) Mark J. Kilgard, 1996. */
+
+/* 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>
+
+#if !defined(_WIN32)
+#include <GL/glx.h>
+#endif
+
+#ifdef __sgi
+#include <dlfcn.h>
+#endif
+
+#include "glutint.h"
+
+/* Grumble.  The IRIX 6.3 and early IRIX 6.4 OpenGL headers
+   support the video resize extension, but failed to define
+   GLX_SGIX_video_resize. */
+#ifdef GLX_SYNC_FRAME_SGIX
+#define GLX_SGIX_video_resize 1
+#endif
+
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+static int canVideoResize = -1;
+static int videoResizeChannel;
+#else
+static int canVideoResize = 0;
+#endif
+static int videoResizeInUse = 0;
+static int dx = -1, dy = -1, dw = -1, dh = -1;
+
+/* XXX Note that IRIX 6.2, 6.3, and some 6.4 versions have a
+   bug where programs seg-fault when they attempt video
+   resizing from an indirect OpenGL context (either local or
+   over a network). */
+
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+
+static volatile int errorCaught;
+
+/* ARGSUSED */
+static
+catchXSGIvcErrors(Display * dpy, XErrorEvent * event)
+{
+  errorCaught = 1;
+  return 0;
+}
+#endif
+
+/* CENTRY */
+int APIENTRY 
+glutVideoResizeGet(GLenum param)
+{
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+  if (canVideoResize < 0) {
+    canVideoResize = __glutIsSupportedByGLX("GLX_SGIX_video_resize");
+    if (canVideoResize) {
+#if __sgi
+      /* This is a hack because IRIX 6.2, 6.3, and some 6.4
+         versions were released with GLX_SGIX_video_resize
+         being advertised by the X server though the video
+         resize extension is not actually supported.  We try to
+         determine if the libGL.so we are using actually has a
+         video resize entrypoint before we try to use the
+         feature. */
+      void (*func) (void);
+      void *glxDso = dlopen("libGL.so", RTLD_LAZY);
+
+      func = (void (*)(void)) dlsym(glxDso, "glXQueryChannelDeltasSGIX");
+      if (!func) {
+        canVideoResize = 0;
+      } else
+#endif
+      {
+        char *channelString;
+        int (*handler) (Display *, XErrorEvent *);
+
+        channelString = getenv("GLUT_VIDEO_RESIZE_CHANNEL");
+        videoResizeChannel = channelString ? atoi(channelString) : 0;
+
+        /* Work around another annoying problem with SGI's
+           GLX_SGIX_video_resize implementation.  Early IRIX
+           6.4 OpenGL's advertise the extension and have the
+           video resize API, but an XSGIvc X protocol errors
+           result trying to use the API.  Set up an error
+           handler to intercept what would otherwise be a fatal
+           error.  If an error was recieved, do not report that
+           video resize is possible. */
+        handler = XSetErrorHandler(catchXSGIvcErrors);
+
+        errorCaught = 0;
+
+        glXQueryChannelDeltasSGIX(__glutDisplay, __glutScreen,
+          videoResizeChannel, &dx, &dy, &dw, &dh);
+
+        /* glXQueryChannelDeltasSGIX is an inherent X server
+           round-trip so we know we will have gotten either the
+           correct reply or and error by this time. */
+        XSetErrorHandler(handler);
+
+        /* Still yet another work around.  In IRIX 6.4 betas,
+           glXQueryChannelDeltasSGIX will return as if it
+           succeeded, but the values are filled with junk.
+           Watch to make sure the delta variables really make
+           sense. */
+        if (errorCaught ||
+          dx < 0 || dy < 0 || dw < 0 || dh < 0 ||
+          dx > 2048 || dy > 2048 || dw > 2048 || dh > 2048) {
+          canVideoResize = 0;
+        }
+      }
+    }
+  }
+#endif /* GLX_SGIX_video_resize */
+
+  switch (param) {
+  case GLUT_VIDEO_RESIZE_POSSIBLE:
+    return canVideoResize;
+  case GLUT_VIDEO_RESIZE_IN_USE:
+    return videoResizeInUse;
+  case GLUT_VIDEO_RESIZE_X_DELTA:
+    return dx;
+  case GLUT_VIDEO_RESIZE_Y_DELTA:
+    return dy;
+  case GLUT_VIDEO_RESIZE_WIDTH_DELTA:
+    return dw;
+  case GLUT_VIDEO_RESIZE_HEIGHT_DELTA:
+    return dh;
+  case GLUT_VIDEO_RESIZE_X:
+  case GLUT_VIDEO_RESIZE_Y:
+  case GLUT_VIDEO_RESIZE_WIDTH:
+  case GLUT_VIDEO_RESIZE_HEIGHT:
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+    if (videoResizeInUse) {
+      int x, y, width, height;
+
+      glXQueryChannelRectSGIX(__glutDisplay, __glutScreen,
+        videoResizeChannel, &x, &y, &width, &height);
+      switch (param) {
+      case GLUT_VIDEO_RESIZE_X:
+        return x;
+      case GLUT_VIDEO_RESIZE_Y:
+        return y;
+      case GLUT_VIDEO_RESIZE_WIDTH:
+        return width;
+      case GLUT_VIDEO_RESIZE_HEIGHT:
+        return height;
+      }
+    }
+#endif
+    return -1;
+  default:
+    __glutWarning("invalid glutVideoResizeGet parameter: %d", param);
+    return -1;
+  }
+}
+
+void APIENTRY 
+glutSetupVideoResizing(void)
+{
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
+    glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
+      videoResizeChannel, __glutCurrentWindow->win);
+    videoResizeInUse = 1;
+  } else
+#endif
+    __glutFatalError("glutEstablishVideoResizing: video resizing not possible.\n");
+}
+
+void APIENTRY 
+glutStopVideoResizing(void)
+{
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
+    if (videoResizeInUse) {
+      glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
+        videoResizeChannel, None);
+      videoResizeInUse = 0;
+    }
+  }
+#endif
+}
+
+/* ARGSUSED */
+void APIENTRY 
+glutVideoResize(int x, int y, int width, int height)
+{
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+  if (videoResizeInUse) {
+#ifdef GLX_SYNC_SWAP_SGIX
+    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
+       6.2; the original unpatched IRIX 6.2 behavior is always
+       GLX_SYNC_SWAP_SGIX. */
+    glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
+      videoResizeChannel, GLX_SYNC_SWAP_SGIX);
+#endif
+    glXChannelRectSGIX(__glutDisplay, __glutScreen,
+      videoResizeChannel, x, y, width, height);
+  }
+#endif
+}
+
+/* ARGSUSED */
+void APIENTRY 
+glutVideoPan(int x, int y, int width, int height)
+{
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
+  if (videoResizeInUse) {
+#ifdef GLX_SYNC_FRAME_SGIX
+    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
+       6.2; the original unpatched IRIX 6.2 behavior is always
+       GLX_SYNC_SWAP_SGIX.  We just ignore that we cannot
+       accomplish GLX_SYNC_FRAME_SGIX on IRIX unpatched 6.2;
+       this means you'd need a glutSwapBuffers to actually
+       realize the video resize. */
+    glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
+      videoResizeChannel, GLX_SYNC_FRAME_SGIX);
+#endif
+    glXChannelRectSGIX(__glutDisplay, __glutScreen,
+      videoResizeChannel, x, y, width, height);
+  }
+#endif
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_warp.c b/src/glut/glx/glut_warp.c
new file mode 100644
index 0000000000..fa55f75914
--- /dev/null
+++ b/src/glut/glx/glut_warp.c
@@ -0,0 +1,23 @@
+
+/* 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 <stdarg.h>
+#include <stdio.h>
+
+#include "glutint.h"
+
+/* CENTRY */
+void APIENTRY
+glutWarpPointer(int x, int y)
+{
+  XWarpPointer(__glutDisplay, None, __glutCurrentWindow->win,
+    0, 0, 0, 0, x, y);
+  XFlush(__glutDisplay);
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glut_win.c b/src/glut/glx/glut_win.c
new file mode 100644
index 0000000000..883bacb087
--- /dev/null
+++ b/src/glut/glx/glut_win.c
@@ -0,0 +1,1007 @@
+
+/* 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. */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#if !defined(_WIN32)
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#endif
+
+#include "glutint.h"
+
+GLUTwindow *__glutCurrentWindow = NULL;
+GLUTwindow **__glutWindowList = NULL;
+int __glutWindowListSize = 0;
+#if !defined(_WIN32)
+GLUTstale *__glutStaleWindowList = NULL;
+#endif
+GLUTwindow *__glutMenuWindow = NULL;
+
+void (*__glutFreeOverlayFunc) (GLUToverlay *);
+XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
+  Criterion * requiredCriteria, int nRequired, int requiredMask, void** fbc) = NULL;
+
+static Criterion requiredWindowCriteria[] =
+{
+  {LEVEL, EQ, 0},
+  {TRANSPARENT, EQ, 0}
+};
+static int numRequiredWindowCriteria = sizeof(requiredWindowCriteria) / sizeof(Criterion);
+static int requiredWindowCriteriaMask = (1 << LEVEL) | (1 << TRANSPARENT);
+
+static void
+cleanWindowWorkList(GLUTwindow * window)
+{
+  GLUTwindow **pEntry = &__glutWindowWorkList;
+  GLUTwindow *entry = __glutWindowWorkList;
+
+  /* Tranverse singly-linked window work list look for the
+     window. */
+  while (entry) {
+    if (entry == window) {
+      /* Found it; delete it. */
+      *pEntry = entry->prevWorkWin;
+      return;
+    } else {
+      pEntry = &entry->prevWorkWin;
+      entry = *pEntry;
+    }
+  }
+}
+
+#if !defined(_WIN32)
+
+static void
+cleanStaleWindowList(GLUTwindow * window)
+{
+  GLUTstale **pEntry = &__glutStaleWindowList;
+  GLUTstale *entry = __glutStaleWindowList;
+
+  /* Tranverse singly-linked stale window list look for the
+     window ID. */
+  while (entry) {
+    if (entry->window == window) {
+      /* Found it; delete it. */
+      *pEntry = entry->next;
+      free(entry);
+      return;
+    } else {
+      pEntry = &entry->next;
+      entry = *pEntry;
+    }
+  }
+}
+
+#endif
+
+static GLUTwindow *__glutWindowCache = NULL;
+
+GLUTwindow *
+__glutGetWindow(Window win)
+{
+  int i;
+
+  /* Does win belong to the last window ID looked up? */
+  if (__glutWindowCache && (win == __glutWindowCache->win ||
+      (__glutWindowCache->overlay && win ==
+        __glutWindowCache->overlay->win))) {
+    return
+      __glutWindowCache;
+  }
+  /* Otherwise scan the window list looking for the window ID. */
+  for (i = 0; i < __glutWindowListSize; i++) {
+    if (__glutWindowList[i]) {
+      if (win == __glutWindowList[i]->win) {
+        __glutWindowCache = __glutWindowList[i];
+        return __glutWindowCache;
+      }
+      if (__glutWindowList[i]->overlay) {
+        if (win == __glutWindowList[i]->overlay->win) {
+          __glutWindowCache = __glutWindowList[i];
+          return __glutWindowCache;
+        }
+      }
+    }
+  }
+#if !defined(_WIN32)
+  {
+    GLUTstale *entry;
+
+    /* Scan through destroyed overlay window IDs for which no
+       DestroyNotify has yet been received. */
+    for (entry = __glutStaleWindowList; entry; entry = entry->next) {
+      if (entry->win == win)
+        return entry->window;
+    }
+  }
+#endif
+  return NULL;
+}
+
+/* CENTRY */
+int APIENTRY
+glutGetWindow(void)
+{
+  if (__glutCurrentWindow) {
+    return __glutCurrentWindow->num + 1;
+  } else {
+    return 0;
+  }
+}
+/* ENDCENTRY */
+
+void
+__glutSetWindow(GLUTwindow * window)
+{
+  /* It is tempting to try to short-circuit the call to
+     glXMakeCurrent if we "know" we are going to make current
+     to a window we are already current to.  In fact, this
+     assumption breaks when GLUT is expected to integrated with
+     other OpenGL windowing APIs that also make current to
+     OpenGL contexts.  Since glXMakeCurrent short-circuits the
+     "already bound" case, GLUT avoids the temptation to do so
+     too. */
+  __glutCurrentWindow = window;
+
+  MAKE_CURRENT_LAYER(__glutCurrentWindow);
+
+#if !defined(_WIN32)
+  /* We should be careful to force a finish between each
+     iteration through the GLUT main loop if indirect OpenGL 
+     contexts are in use; indirect contexts tend to have  much
+     longer latency because lots of OpenGL extension requests
+     can queue up in the X protocol stream.  We accomplish this
+     by posting GLUT_FINISH_WORK to be done. */
+  if (!__glutCurrentWindow->isDirect)
+    __glutPutOnWorkList(__glutCurrentWindow, GLUT_FINISH_WORK);
+#endif
+
+  /* If debugging is enabled, we'll want to check this window
+     for any OpenGL errors every iteration through the GLUT
+     main loop.  To accomplish this, we post the
+     GLUT_DEBUG_WORK to be done on this window. */
+  if (__glutDebug) {
+    __glutPutOnWorkList(__glutCurrentWindow, GLUT_DEBUG_WORK);
+  }
+}
+
+/* CENTRY */
+void APIENTRY
+glutSetWindow(int win)
+{
+  GLUTwindow *window;
+
+  if (win < 1 || win > __glutWindowListSize) {
+    __glutWarning("glutSetWindow attempted on bogus window.");
+    return;
+  }
+  window = __glutWindowList[win - 1];
+  if (!window) {
+    __glutWarning("glutSetWindow attempted on bogus window.");
+    return;
+  }
+  __glutSetWindow(window);
+}
+/* ENDCENTRY */
+
+static int
+getUnusedWindowSlot(void)
+{
+  int i;
+
+  /* Look for allocated, unused slot. */
+  for (i = 0; i < __glutWindowListSize; i++) {
+    if (!__glutWindowList[i]) {
+      return i;
+    }
+  }
+  /* Allocate a new slot. */
+  __glutWindowListSize++;
+  if (__glutWindowList) {
+    __glutWindowList = (GLUTwindow **)
+      realloc(__glutWindowList,
+      __glutWindowListSize * sizeof(GLUTwindow *));
+  } 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. */
+    __glutWindowList = (GLUTwindow **)
+      malloc(sizeof(GLUTwindow *));
+  }
+  if (!__glutWindowList)
+    __glutFatalError("out of memory.");
+  __glutWindowList[__glutWindowListSize - 1] = NULL;
+  return __glutWindowListSize - 1;
+}
+
+static XVisualInfo *
+getVisualInfoCI(unsigned int mode)
+{
+  static int bufSizeList[] =
+  {16, 12, 8, 4, 2, 1, 0};
+  XVisualInfo *vi;
+  int list[32];
+  int i, n = 0;
+
+  /* Should not be looking at display mode mask if
+     __glutDisplayString is non-NULL. */
+  assert(!__glutDisplayString);
+
+  list[n++] = GLX_BUFFER_SIZE;
+  list[n++] = 1;
+  if (GLUT_WIND_IS_DOUBLE(mode)) {
+    list[n++] = GLX_DOUBLEBUFFER;
+  }
+  if (GLUT_WIND_IS_STEREO(mode)) {
+    list[n++] = GLX_STEREO;
+  }
+  if (GLUT_WIND_HAS_DEPTH(mode)) {
+    list[n++] = GLX_DEPTH_SIZE;
+    list[n++] = 1;
+  }
+  if (GLUT_WIND_HAS_STENCIL(mode)) {
+    list[n++] = GLX_STENCIL_SIZE;
+    list[n++] = 1;
+  }
+  list[n] = (int) None; /* terminate list */
+
+  /* glXChooseVisual specify GLX_BUFFER_SIZE prefers the
+     "smallest index buffer of at least the specified size".
+     This would be reasonable if GLUT allowed the user to
+     specify the required buffe size, but GLUT's display mode
+     is too simplistic (easy to use?). GLUT should try to find
+     the "largest".  So start with a large buffer size and
+     shrink until we find a matching one that exists. */
+
+  for (i = 0; bufSizeList[i]; i++) {
+    /* XXX Assumes list[1] is where GLX_BUFFER_SIZE parameter
+       is. */
+    list[1] = bufSizeList[i];
+    vi = glXChooseVisual(__glutDisplay,
+      __glutScreen, list);
+    if (vi)
+      return vi;
+  }
+  return NULL;
+}
+
+static XVisualInfo *
+getVisualInfoRGB(unsigned int mode)
+{
+  int list[32];
+  int n = 0;
+
+  /* Should not be looking at display mode mask if
+     __glutDisplayString is non-NULL. */
+  assert(!__glutDisplayString);
+
+  /* XXX Would a caching mechanism to minize the calls to
+     glXChooseVisual? You'd have to reference count
+     XVisualInfo* pointers.  Would also have to properly
+     interact with glutInitDisplayString. */
+
+  list[n++] = GLX_RGBA;
+  list[n++] = GLX_RED_SIZE;
+  list[n++] = 1;
+  list[n++] = GLX_GREEN_SIZE;
+  list[n++] = 1;
+  list[n++] = GLX_BLUE_SIZE;
+  list[n++] = 1;
+  if (GLUT_WIND_HAS_ALPHA(mode)) {
+    list[n++] = GLX_ALPHA_SIZE;
+    list[n++] = 1;
+  }
+  if (GLUT_WIND_IS_DOUBLE(mode)) {
+    list[n++] = GLX_DOUBLEBUFFER;
+  }
+  if (GLUT_WIND_IS_STEREO(mode)) {
+    list[n++] = GLX_STEREO;
+  }
+  if (GLUT_WIND_HAS_DEPTH(mode)) {
+    list[n++] = GLX_DEPTH_SIZE;
+    list[n++] = 1;
+  }
+  if (GLUT_WIND_HAS_STENCIL(mode)) {
+    list[n++] = GLX_STENCIL_SIZE;
+    list[n++] = 1;
+  }
+  if (GLUT_WIND_HAS_ACCUM(mode)) {
+    list[n++] = GLX_ACCUM_RED_SIZE;
+    list[n++] = 1;
+    list[n++] = GLX_ACCUM_GREEN_SIZE;
+    list[n++] = 1;
+    list[n++] = GLX_ACCUM_BLUE_SIZE;
+    list[n++] = 1;
+    if (GLUT_WIND_HAS_ALPHA(mode)) {
+      list[n++] = GLX_ACCUM_ALPHA_SIZE;
+      list[n++] = 1;
+    }
+  }
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
+  if (GLUT_WIND_IS_MULTISAMPLE(mode)) {
+    if (!__glutIsSupportedByGLX("GLX_SGIS_multisample"))
+      return NULL;
+    list[n++] = GLX_SAMPLES_SGIS;
+    /* XXX Is 4 a reasonable minimum acceptable number of
+       samples? */
+    list[n++] = 4;
+  }
+#endif
+  list[n] = (int) None; /* terminate list */
+
+  return glXChooseVisual(__glutDisplay,
+    __glutScreen, list);
+}
+
+XVisualInfo *
+__glutGetVisualInfo(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 getVisualInfoRGB(mode);
+  else
+    return getVisualInfoCI(mode);
+}
+
+XVisualInfo *
+__glutDetermineVisual(
+  unsigned int displayMode,
+  Bool * treatAsSingle,
+  XVisualInfo * (getVisualInfo) (unsigned int))
+{
+  XVisualInfo *vis;
+
+  /* Should not be looking at display mode mask if
+     __glutDisplayString is non-NULL. */
+  assert(!__glutDisplayString);
+
+  *treatAsSingle = GLUT_WIND_IS_SINGLE(displayMode);
+  vis = getVisualInfo(displayMode);
+  if (!vis) {
+    /* Fallback cases when can't get exactly what was asked
+       for... */
+    if (GLUT_WIND_IS_SINGLE(displayMode)) {
+      /* If we can't find a single buffered visual, try looking
+         for a double buffered visual.  We can treat a double
+         buffered visual as a single buffer visual by changing
+         the draw buffer to GL_FRONT and treating any swap
+         buffers as no-ops. */
+      displayMode |= GLUT_DOUBLE;
+      vis = getVisualInfo(displayMode);
+      *treatAsSingle = True;
+    }
+    if (!vis && GLUT_WIND_IS_MULTISAMPLE(displayMode)) {
+      /* If we can't seem to get multisampling (ie, not Reality
+         Engine class graphics!), go without multisampling.  It
+         is up to the application to query how many multisamples
+         were allocated (0 equals no multisampling) if the
+         application is going to use multisampling for more than
+         just antialiasing. */
+      displayMode &= ~GLUT_MULTISAMPLE;
+      vis = getVisualInfo(displayMode);
+    }
+  }
+  return vis;
+}
+
+void GLUTCALLBACK
+__glutDefaultDisplay(void)
+{
+  /* XXX Remove the warning after GLUT 3.0. */
+  __glutWarning("The following is a new check for GLUT 3.0; update your code.");
+  __glutFatalError(
+    "redisplay needed for window %d, but no display callback.",
+    __glutCurrentWindow->num + 1);
+}
+
+void GLUTCALLBACK
+__glutDefaultReshape(int width, int height)
+{
+  GLUToverlay *overlay;
+
+  /* Adjust the viewport of the window (and overlay if one
+     exists). */
+  MAKE_CURRENT_WINDOW(__glutCurrentWindow);
+  glViewport(0, 0, (GLsizei) width, (GLsizei) height);
+  overlay = __glutCurrentWindow->overlay;
+  if (overlay) {
+    MAKE_CURRENT_OVERLAY(overlay);
+    glViewport(0, 0, (GLsizei) width, (GLsizei) height);
+  }
+  /* Make sure we are current to the current layer (application
+     should be able to count on the current layer not changing
+     unless the application explicitly calls glutUseLayer). */
+  MAKE_CURRENT_LAYER(__glutCurrentWindow);
+}
+
+XVisualInfo *
+__glutDetermineWindowVisual(Bool * treatAsSingle, Bool * visAlloced, void **fbc)
+{
+  if (__glutDisplayString) {
+
+    /* __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);
+    *visAlloced = False;
+    *fbc = NULL;
+    return __glutDetermineVisualFromString(__glutDisplayString, treatAsSingle,
+      requiredWindowCriteria, numRequiredWindowCriteria, requiredWindowCriteriaMask, fbc);
+  } else {
+    *visAlloced = True;
+    *fbc = NULL;
+    return __glutDetermineVisual(__glutDisplayMode,
+      treatAsSingle, __glutGetVisualInfo);
+  }
+}
+
+/* ARGSUSED5 */  /* Only Win32 uses gameMode parameter. */
+GLUTwindow *
+__glutCreateWindow(GLUTwindow * parent,
+  int x, int y, int width, int height, int gameMode)
+{
+  GLUTwindow *window;
+  XSetWindowAttributes wa;
+  unsigned long attribMask;
+  int winnum;
+  int i;
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+  GLXFBConfigSGIX fbc;
+#else
+  void *fbc;
+#endif
+
+#if defined(_WIN32)
+  WNDCLASS wc;
+  int style;
+
+  if (!GetClassInfo(GetModuleHandle(NULL), "GLUT", &wc)) {
+    __glutOpenWin32Connection(NULL);
+  }
+#else
+  if (!__glutDisplay) {
+    __glutOpenXConnection(NULL);
+  }
+#endif
+  if (__glutGameModeWindow) {
+    __glutFatalError("cannot create windows in game mode.");
+  }
+  winnum = getUnusedWindowSlot();
+  window = (GLUTwindow *) malloc(sizeof(GLUTwindow));
+  if (!window) {
+    __glutFatalError("out of memory.");
+  }
+  window->num = winnum;
+
+#if !defined(_WIN32)
+  window->vis = __glutDetermineWindowVisual(&window->treatAsSingle,
+    &window->visAlloced, (void**) &fbc);
+  if (!window->vis) {
+    __glutFatalError(
+      "visual with necessary capabilities not found.");
+  }
+  __glutSetupColormap(window->vis, &window->colormap, &window->cmap);
+#endif
+  window->eventMask = StructureNotifyMask | ExposureMask;
+
+  attribMask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
+  wa.background_pixmap = None;
+  wa.border_pixel = 0;
+  wa.colormap = window->cmap;
+  wa.event_mask = window->eventMask;
+  if (parent) {
+    if (parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)
+      wa.event_mask |= GLUT_HACK_STOP_PROPAGATE_MASK;
+    attribMask |= CWDontPropagate;
+    wa.do_not_propagate_mask = parent->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;
+  } else {
+    wa.do_not_propagate_mask = 0;
+  }
+
+  /* Stash width and height before Win32's __glutAdjustCoords
+     possibly overwrites the values. */
+  window->width = width;
+  window->height = height;
+  window->forceReshape = True;
+  window->ignoreKeyRepeat = False;
+
+#if defined(_WIN32)
+  __glutAdjustCoords(parent ? parent->win : NULL,
+    &x, &y, &width, &height);
+  if (parent) {
+    style = WS_CHILD;
+  } else {
+    if (gameMode) {
+      /* Game mode window should be a WS_POPUP window to
+         ensure that the taskbar is hidden by it.  A standard
+         WS_OVERLAPPEDWINDOW does not hide the task bar. */
+      style = WS_POPUP | WS_MAXIMIZE;
+    } else {
+      /* A standard toplevel window with borders and such. */
+      style = WS_OVERLAPPEDWINDOW;
+    }
+  }
+  window->win = CreateWindow("GLUT", "GLUT",
+    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | style,
+    x, y, width, height, parent ? parent->win : __glutRoot,
+    NULL, GetModuleHandle(NULL), 0);
+  window->hdc = GetDC(window->win);
+  /* Must set the XHDC for fake glXChooseVisual & fake
+     glXCreateContext & fake XAllocColorCells. */
+  XHDC = window->hdc;
+  window->vis = __glutDetermineWindowVisual(&window->treatAsSingle,
+    &window->visAlloced, &fbc);
+  if (!window->vis) {
+    __glutFatalError(
+      "pixel format with necessary capabilities not found.");
+  }
+  if (!SetPixelFormat(window->hdc,
+      ChoosePixelFormat(window->hdc, window->vis),
+      window->vis)) {
+    __glutFatalError("SetPixelFormat failed during window create.");
+  }
+  __glutSetupColormap(window->vis, &window->colormap, &window->cmap);
+  /* Make sure subwindows get a windowStatus callback. */
+  if (parent) {
+    PostMessage(parent->win, WM_ACTIVATE, 0, 0);
+  }
+  window->renderDc = window->hdc;
+#else
+  window->win = XCreateWindow(__glutDisplay,
+    parent == NULL ? __glutRoot : parent->win,
+    x, y, width, height, 0,
+    window->vis->depth, InputOutput, window->vis->visual,
+    attribMask, &wa);
+#endif
+  window->renderWin = window->win;
+#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
+  {
+    window->ctx = glXCreateContext(__glutDisplay, window->vis,
+      None, __glutTryDirect);
+  }
+  if (!window->ctx) {
+    __glutFatalError(
+      "failed to create OpenGL rendering context.");
+  }
+  window->renderCtx = window->ctx;
+#if !defined(_WIN32)
+  window->isDirect = glXIsDirect(__glutDisplay, window->ctx);
+  if (__glutForceDirect) {
+    if (!window->isDirect)
+      __glutFatalError("direct rendering not possible.");
+  }
+#endif
+
+  window->parent = parent;
+  if (parent) {
+    window->siblings = parent->children;
+    parent->children = window;
+  } else {
+    window->siblings = NULL;
+  }
+  window->overlay = NULL;
+  window->children = NULL;
+  window->display = __glutDefaultDisplay;
+  window->reshape = __glutDefaultReshape;
+  window->mouse = NULL;
+  window->motion = NULL;
+  window->passive = NULL;
+  window->entry = NULL;
+  window->keyboard = NULL;
+  window->keyboardUp = NULL;
+  window->windowStatus = NULL;
+  window->visibility = NULL;
+  window->special = NULL;
+  window->specialUp = NULL;
+  window->buttonBox = NULL;
+  window->dials = NULL;
+  window->spaceMotion = NULL;
+  window->spaceRotate = NULL;
+  window->spaceButton = NULL;
+  window->tabletMotion = NULL;
+  window->tabletButton = NULL;
+#ifdef _WIN32
+  window->joystick = NULL;
+  window->joyPollInterval = 0;
+#endif
+  window->tabletPos[0] = -1;
+  window->tabletPos[1] = -1;
+  window->shownState = 0;
+  window->visState = -1;  /* not VisibilityUnobscured,
+                             VisibilityPartiallyObscured, or
+                             VisibilityFullyObscured */
+  window->entryState = -1;  /* not EnterNotify or LeaveNotify */
+
+  window->desiredConfMask = 0;
+  window->buttonUses = 0;
+  window->cursor = GLUT_CURSOR_INHERIT;
+
+  /* Setup window to be mapped when glutMainLoop starts. */
+  window->workMask = GLUT_MAP_WORK;
+#ifdef _WIN32
+  if (gameMode) {
+    /* When mapping a game mode window, just show
+       the window.  We have already created the game
+       mode window with a maximize flag at creation
+       time.  Doing a ShowWindow(window->win, SW_SHOWNORMAL)
+       would be wrong for a game mode window since it
+       would unmaximize the window. */
+    window->desiredMapState = GameModeState;
+  } else {
+    window->desiredMapState = NormalState;
+  }
+#else
+  window->desiredMapState = NormalState;
+#endif
+  window->prevWorkWin = __glutWindowWorkList;
+  __glutWindowWorkList = window;
+
+  /* Initially, no menus attached. */
+  for (i = 0; i < GLUT_MAX_MENUS; i++) {
+    window->menu[i] = 0;
+  }
+
+  /* Add this new window to the window list. */
+  __glutWindowList[winnum] = window;
+
+  /* Make the new window the current window. */
+  __glutSetWindow(window);
+
+  __glutDetermineMesaSwapHackSupport();
+
+  if (window->treatAsSingle) {
+    /* We do this because either the window really is single
+       buffered (in which case this is redundant, but harmless,
+       because this is the initial single-buffered context
+       state); or we are treating a double buffered window as a
+       single-buffered window because the system does not appear
+       to export any suitable single- buffered visuals (in which
+       the following are necessary). */
+    glDrawBuffer(GL_FRONT);
+    glReadBuffer(GL_FRONT);
+  }
+  return window;
+}
+
+/* CENTRY */
+int APIENTRY
+glutCreateWindow(const char *title)
+{
+  static int firstWindow = 1;
+  GLUTwindow *window;
+#if !defined(_WIN32)
+  XWMHints *wmHints;
+#endif
+  Window win;
+  XTextProperty textprop;
+
+  if (__glutGameModeWindow) {
+    __glutFatalError("cannot create windows in game mode.");
+  }
+  window = __glutCreateWindow(NULL,
+    __glutSizeHints.x, __glutSizeHints.y,
+    __glutInitWidth, __glutInitHeight,
+    /* not game mode */ 0);
+  win = window->win;
+  /* Setup ICCCM properties. */
+  textprop.value = (unsigned char *) title;
+  textprop.encoding = XA_STRING;
+  textprop.format = 8;
+  textprop.nitems = strlen(title);
+#if defined(_WIN32)
+  SetWindowText(win, title);
+  if (__glutIconic) {
+    window->desiredMapState = IconicState;
+  }
+#else
+  wmHints = XAllocWMHints();
+  wmHints->initial_state =
+    __glutIconic ? IconicState : NormalState;
+  wmHints->flags = StateHint;
+  XSetWMProperties(__glutDisplay, win, &textprop, &textprop,
+  /* Only put WM_COMMAND property on first window. */
+    firstWindow ? __glutArgv : NULL,
+    firstWindow ? __glutArgc : 0,
+    &__glutSizeHints, wmHints, NULL);
+  XFree(wmHints);
+  XSetWMProtocols(__glutDisplay, win, &__glutWMDeleteWindow, 1);
+#endif
+  firstWindow = 0;
+  return window->num + 1;
+}
+
+#ifdef _WIN32
+int APIENTRY
+__glutCreateWindowWithExit(const char *title, void (__cdecl *exitfunc)(int))
+{
+  __glutExitFunc = exitfunc;
+  return glutCreateWindow(title);
+}
+#endif
+
+int APIENTRY
+glutCreateSubWindow(int win, int x, int y, int width, int height)
+{
+  GLUTwindow *window;
+
+  window = __glutCreateWindow(__glutWindowList[win - 1],
+    x, y, width, height, /* not game mode */ 0);
+#if !defined(_WIN32)
+  {
+    GLUTwindow *toplevel;
+
+    toplevel = __glutToplevelOf(window);
+    if (toplevel->cmap != window->cmap) {
+      __glutPutOnWorkList(toplevel, GLUT_COLORMAP_WORK);
+    }
+  }
+#endif
+  return window->num + 1;
+}
+/* ENDCENTRY */
+
+void
+__glutDestroyWindow(GLUTwindow * window,
+  GLUTwindow * initialWindow)
+{
+  GLUTwindow **prev, *cur, *parent, *siblings;
+
+  /* Recursively destroy any children. */
+  cur = window->children;
+  while (cur) {
+    siblings = cur->siblings;
+    __glutDestroyWindow(cur, initialWindow);
+    cur = siblings;
+  }
+  /* Remove from parent's children list (only necessary for
+     non-initial windows and subwindows!). */
+  parent = window->parent;
+  if (parent && parent == initialWindow->parent) {
+    prev = &parent->children;
+    cur = parent->children;
+    while (cur) {
+      if (cur == window) {
+        *prev = cur->siblings;
+        break;
+      }
+      prev = &(cur->siblings);
+      cur = cur->siblings;
+    }
+  }
+  /* Unbind if bound to this window. */
+  if (window == __glutCurrentWindow) {
+    UNMAKE_CURRENT();
+    __glutCurrentWindow = NULL;
+  }
+  /* Begin tearing down window itself. */
+  if (window->overlay) {
+    __glutFreeOverlayFunc(window->overlay);
+  }
+  XDestroyWindow(__glutDisplay, window->win);
+  glXDestroyContext(__glutDisplay, window->ctx);
+  if (window->colormap) {
+    /* Only color index windows have colormap data structure. */
+    __glutFreeColormap(window->colormap);
+  }
+  /* NULLing the __glutWindowList helps detect is a window
+     instance has been destroyed, given a window number. */
+  __glutWindowList[window->num] = NULL;
+
+  /* Cleanup data structures that might contain window. */
+  cleanWindowWorkList(window);
+#if !defined(_WIN32)
+  cleanStaleWindowList(window);
+#endif
+  /* Remove window from the "get window cache" if it is there. */
+  if (__glutWindowCache == window)
+    __glutWindowCache = NULL;
+
+  if (window->visAlloced) {
+    /* Only free XVisualInfo* gotten from glXChooseVisual. */
+    XFree(window->vis);
+  }
+
+  if (window == __glutGameModeWindow) {
+    /* Destroying the game mode window should implicitly
+       have GLUT leave game mode. */
+    __glutCloseDownGameMode();
+  }
+
+  free(window);
+}
+
+/* CENTRY */
+void APIENTRY
+glutDestroyWindow(int win)
+{
+  GLUTwindow *window = __glutWindowList[win - 1];
+
+  if (__glutMappedMenu && __glutMenuWindow == window) {
+    __glutFatalUsage("destroying menu window not allowed while menus in use");
+  }
+#if !defined(_WIN32)
+  /* If not a toplevel window... */
+  if (window->parent) {
+    /* Destroying subwindows may change colormap requirements;
+       recalculate toplevel window's WM_COLORMAP_WINDOWS
+       property. */
+    __glutPutOnWorkList(__glutToplevelOf(window->parent),
+      GLUT_COLORMAP_WORK);
+  }
+#endif
+  __glutDestroyWindow(window, window);
+  XFlush(__glutDisplay);
+}
+/* ENDCENTRY */
+
+void
+__glutChangeWindowEventMask(long eventMask, Bool add)
+{
+  if (add) {
+    /* Add eventMask to window's event mask. */
+    if ((__glutCurrentWindow->eventMask & eventMask) !=
+      eventMask) {
+      __glutCurrentWindow->eventMask |= eventMask;
+      __glutPutOnWorkList(__glutCurrentWindow,
+        GLUT_EVENT_MASK_WORK);
+    }
+  } else {
+    /* Remove eventMask from window's event mask. */
+    if (__glutCurrentWindow->eventMask & eventMask) {
+      __glutCurrentWindow->eventMask &= ~eventMask;
+      __glutPutOnWorkList(__glutCurrentWindow,
+        GLUT_EVENT_MASK_WORK);
+    }
+  }
+}
+
+void APIENTRY
+glutDisplayFunc(GLUTdisplayCB displayFunc)
+{
+  /* XXX Remove the warning after GLUT 3.0. */
+  if (!displayFunc)
+    __glutFatalError("NULL display callback not allowed in GLUT 3.0; update your code.");
+  __glutCurrentWindow->display = displayFunc;
+}
+
+void APIENTRY
+glutMouseFunc(GLUTmouseCB mouseFunc)
+{
+  if (__glutCurrentWindow->mouse) {
+    if (!mouseFunc) {
+      /* Previous mouseFunc being disabled. */
+      __glutCurrentWindow->buttonUses--;
+      __glutChangeWindowEventMask(
+        ButtonPressMask | ButtonReleaseMask,
+        __glutCurrentWindow->buttonUses > 0);
+    }
+  } else {
+    if (mouseFunc) {
+      /* Previously no mouseFunc, new one being installed. */
+      __glutCurrentWindow->buttonUses++;
+      __glutChangeWindowEventMask(
+        ButtonPressMask | ButtonReleaseMask, True);
+    }
+  }
+  __glutCurrentWindow->mouse = mouseFunc;
+}
+
+void APIENTRY
+glutMotionFunc(GLUTmotionCB motionFunc)
+{
+  /* Hack.  Some window managers (4Dwm by default) will mask
+     motion events if the client is not selecting for button
+     press and release events. So we select for press and
+     release events too (being careful to use reference
+     counting).  */
+  if (__glutCurrentWindow->motion) {
+    if (!motionFunc) {
+      /* previous mouseFunc being disabled */
+      __glutCurrentWindow->buttonUses--;
+      __glutChangeWindowEventMask(
+        ButtonPressMask | ButtonReleaseMask,
+        __glutCurrentWindow->buttonUses > 0);
+    }
+  } else {
+    if (motionFunc) {
+      /* Previously no mouseFunc, new one being installed. */
+      __glutCurrentWindow->buttonUses++;
+      __glutChangeWindowEventMask(
+        ButtonPressMask | ButtonReleaseMask, True);
+    }
+  }
+  /* Real work of selecting for passive mouse motion.  */
+  __glutChangeWindowEventMask(
+    Button1MotionMask | Button2MotionMask | Button3MotionMask,
+    motionFunc != NULL);
+  __glutCurrentWindow->motion = motionFunc;
+}
+
+void APIENTRY
+glutPassiveMotionFunc(GLUTpassiveCB passiveMotionFunc)
+{
+  __glutChangeWindowEventMask(PointerMotionMask,
+    passiveMotionFunc != NULL);
+
+  /* Passive motion also requires watching enters and leaves so
+     that a fake passive motion event can be generated on an
+     enter. */
+  __glutChangeWindowEventMask(EnterWindowMask | LeaveWindowMask,
+    __glutCurrentWindow->entry != NULL || passiveMotionFunc != NULL);
+
+  __glutCurrentWindow->passive = passiveMotionFunc;
+}
+
+void APIENTRY
+glutEntryFunc(GLUTentryCB entryFunc)
+{
+  __glutChangeWindowEventMask(EnterWindowMask | LeaveWindowMask,
+    entryFunc != NULL || __glutCurrentWindow->passive);
+  __glutCurrentWindow->entry = entryFunc;
+  if (!entryFunc) {
+    __glutCurrentWindow->entryState = -1;
+  }
+}
+
+void APIENTRY
+glutWindowStatusFunc(GLUTwindowStatusCB windowStatusFunc)
+{
+  __glutChangeWindowEventMask(VisibilityChangeMask,
+    windowStatusFunc != NULL);
+  __glutCurrentWindow->windowStatus = windowStatusFunc;
+  if (!windowStatusFunc) {
+    /* Make state invalid. */
+    __glutCurrentWindow->visState = -1;
+  }
+}
+
+static void GLUTCALLBACK
+visibilityHelper(int status)
+{
+  if (status == GLUT_HIDDEN || status == GLUT_FULLY_COVERED)
+    __glutCurrentWindow->visibility(GLUT_NOT_VISIBLE);
+  else
+    __glutCurrentWindow->visibility(GLUT_VISIBLE);
+}
+
+void APIENTRY
+glutVisibilityFunc(GLUTvisibilityCB visibilityFunc)
+{
+  __glutCurrentWindow->visibility = visibilityFunc;
+  if (visibilityFunc)
+    glutWindowStatusFunc(visibilityHelper);
+  else
+    glutWindowStatusFunc(NULL);
+}
+
+void APIENTRY
+glutReshapeFunc(GLUTreshapeCB reshapeFunc)
+{
+  if (reshapeFunc) {
+    __glutCurrentWindow->reshape = reshapeFunc;
+  } else {
+    __glutCurrentWindow->reshape = __glutDefaultReshape;
+  }
+}
diff --git a/src/glut/glx/glut_winmisc.c b/src/glut/glx/glut_winmisc.c
new file mode 100644
index 0000000000..5a9d199a56
--- /dev/null
+++ b/src/glut/glx/glut_winmisc.c
@@ -0,0 +1,120 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994.  */
+
+/* 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_STRING atom */
+#endif
+
+#include "glutint.h"
+
+/* CENTRY */
+void APIENTRY 
+glutSetWindowTitle(const char *title)
+{
+  XTextProperty textprop;
+
+  assert(!__glutCurrentWindow->parent);
+  IGNORE_IN_GAME_MODE();
+  textprop.value = (unsigned char *) title;
+  textprop.encoding = XA_STRING;
+  textprop.format = 8;
+  textprop.nitems = strlen(title);
+  XSetWMName(__glutDisplay,
+    __glutCurrentWindow->win, &textprop);
+  XFlush(__glutDisplay);
+}
+
+void APIENTRY 
+glutSetIconTitle(const char *title)
+{
+  XTextProperty textprop;
+
+  assert(!__glutCurrentWindow->parent);
+  IGNORE_IN_GAME_MODE();
+  textprop.value = (unsigned char *) title;
+  textprop.encoding = XA_STRING;
+  textprop.format = 8;
+  textprop.nitems = strlen(title);
+  XSetWMIconName(__glutDisplay,
+    __glutCurrentWindow->win, &textprop);
+  XFlush(__glutDisplay);
+}
+
+void APIENTRY 
+glutPositionWindow(int x, int y)
+{
+  IGNORE_IN_GAME_MODE();
+  __glutCurrentWindow->desiredX = x;
+  __glutCurrentWindow->desiredY = y;
+  __glutCurrentWindow->desiredConfMask |= CWX | CWY;
+  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
+}
+
+void APIENTRY 
+glutReshapeWindow(int w, int h)
+{
+  IGNORE_IN_GAME_MODE();
+  if (w <= 0 || h <= 0)
+    __glutWarning("glutReshapeWindow: non-positive width or height not allowed");
+
+  __glutCurrentWindow->desiredWidth = w;
+  __glutCurrentWindow->desiredHeight = h;
+  __glutCurrentWindow->desiredConfMask |= CWWidth | CWHeight;
+  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
+}
+
+void APIENTRY 
+glutPopWindow(void)
+{
+  IGNORE_IN_GAME_MODE();
+  __glutCurrentWindow->desiredStack = Above;
+  __glutCurrentWindow->desiredConfMask |= CWStackMode;
+  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
+}
+
+void APIENTRY 
+glutPushWindow(void)
+{
+  IGNORE_IN_GAME_MODE();
+  __glutCurrentWindow->desiredStack = Below;
+  __glutCurrentWindow->desiredConfMask |= CWStackMode;
+  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
+}
+
+void APIENTRY 
+glutIconifyWindow(void)
+{
+  IGNORE_IN_GAME_MODE();
+  assert(!__glutCurrentWindow->parent);
+  __glutCurrentWindow->desiredMapState = IconicState;
+  __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK);
+}
+
+void APIENTRY 
+glutShowWindow(void)
+{
+  IGNORE_IN_GAME_MODE();
+  __glutCurrentWindow->desiredMapState = NormalState;
+  __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK);
+}
+
+void APIENTRY 
+glutHideWindow(void)
+{
+  IGNORE_IN_GAME_MODE();
+  __glutCurrentWindow->desiredMapState = WithdrawnState;
+  __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK);
+}
+
+/* ENDCENTRY */
diff --git a/src/glut/glx/glutbitmap.h b/src/glut/glx/glutbitmap.h
new file mode 100644
index 0000000000..9584bb129d
--- /dev/null
+++ b/src/glut/glx/glutbitmap.h
@@ -0,0 +1,32 @@
+#ifndef __glutbitmap_h__
+#define __glutbitmap_h__
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
+
+/* 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. */
+
+#define GLUT_NO_LIB_PRAGMA  /* Avoid auto library linking when building
+                               the GLUT library itself. */
+#include <GL/glut.h>
+
+typedef struct {
+  const GLsizei width;
+  const GLsizei height;
+  const GLfloat xorig;
+  const GLfloat yorig;
+  const GLfloat advance;
+  const GLubyte *bitmap;
+} BitmapCharRec, *BitmapCharPtr;
+
+typedef struct {
+  const char *name;
+  const int num_chars;
+  const int first;
+  const BitmapCharRec * const *ch;
+} BitmapFontRec, *BitmapFontPtr;
+
+typedef void *GLUTbitmapFont;
+
+#endif /* __glutbitmap_h__ */
diff --git a/src/glut/glx/glutint.h b/src/glut/glx/glutint.h
new file mode 100644
index 0000000000..752e9b356e
--- /dev/null
+++ b/src/glut/glx/glutint.h
@@ -0,0 +1,772 @@
+#ifndef __glutint_h__
+#define __glutint_h__
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
+
+/* 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. */
+
+#if defined(__CYGWIN32__)
+#include <sys/time.h>
+#endif
+
+#define SUPPORT_FORTRAN  /* With GLUT 3.7, everyone supports Fortran. */
+
+#if defined(_WIN32)
+#include "glutwin32.h"
+#else
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#endif
+
+/* added by BrianP: */
+#define APIENTRY GLAPIENTRY
+#define __cdecl GLAPIENTRY
+#define CDECL GLAPIENTRY
+
+
+#define GLUT_BUILDING_LIB  /* Building the GLUT library itself. */
+
+/* GLUT_BUILDING_LIB is used by <GL/glut.h> to 1) not #pragma link
+   with the GLUT library, and 2) avoid the Win32 atexit hack. */
+
+#include <GL/glut.h>
+
+/* This must be done after <GL/gl.h> is included.  MESA is defined
+   if the <GL/gl.h> is supplied by Brian Paul's Mesa library. */
+#if defined(MESA) && defined(_WIN32)
+/* Mesa implements "wgl" versions of GDI entry points needed for
+   using OpenGL.  Map these "wgl" versions to the GDI names via
+   macros. */
+GLAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc, CONST PIXELFORMATDESCRIPTOR *ppfd);
+GLAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd);
+GLAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc);
+GLAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc, int iPixelFormat, CONST PIXELFORMATDESCRIPTOR *ppfd);
+GLAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc);
+GLAPI HGLRC GLWINAPI wglCreateContext(HDC hdc);
+GLAPI BOOL GLWINAPI wglDeleteContext(HGLRC hglrc);
+GLAPI HGLRC GLWINAPI wglGetCurrentContext(VOID);
+GLAPI HDC GLWINAPI wglGetCurrentDC(VOID);
+GLAPI BOOL GLWINAPI wglMakeCurrent(HDC hdc,HGLRC hglrc);
+#define ChoosePixelFormat wglChoosePixelFormat
+#define DescribePixelFormat wglDescribePixelFormat
+#define GetPixelFormat wglGetPixelFormat
+#define SetPixelFormat wglSetPixelFormat
+#define SwapBuffers wglSwapBuffers
+#define GetCurrentContext wglGetCurrentContext
+#define GetCurrentDC wglGetCurrentDC
+#define MakeCurrent wglMakeCurrent
+#define CreateContext wglCreateContext
+#define DeleteContext wglDeleteContext
+#endif /* MESA */
+
+#ifdef SUPPORT_FORTRAN
+#include <GL/glutf90.h>
+#endif
+
+#ifdef __vms
+#if ( __VMS_VER < 70000000 )
+struct timeval {
+  __int64 val;
+};
+extern int sys$gettim(struct timeval *);
+#else
+#include <time.h>
+#endif
+#else
+#include <sys/types.h>
+#if !defined(_WIN32)
+#include <sys/time.h>
+#else
+#include <winsock.h>
+#endif
+#endif
+#if defined(__vms) && ( __VMS_VER < 70000000 )
+
+/* For VMS6.2 or lower :
+   One TICK on VMS is 100 nanoseconds; 0.1 microseconds or
+   0.0001 milliseconds. This means that there are 0.01
+   ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000
+   ticks/second. */
+
+#define TICKS_PER_MILLISECOND 10000
+#define TICKS_PER_SECOND      10000000
+
+#define GETTIMEOFDAY(_x) (void) sys$gettim (_x);
+
+#define ADD_TIME(dest, src1, src2) { \
+  (dest).val = (src1).val + (src2).val; \
+}
+
+#define TIMEDELTA(dest, src1, src2) { \
+  (dest).val = (src1).val - (src2).val; \
+}
+
+#define IS_AFTER(t1, t2) ((t2).val > (t1).val)
+
+#define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val)
+
+#else
+#if defined(SVR4) && !defined(sun)  /* Sun claims SVR4, but
+                                       wants 2 args. */
+#define GETTIMEOFDAY(_x) gettimeofday(_x)
+#else
+#define GETTIMEOFDAY(_x) gettimeofday(_x, NULL)
+#endif
+#define ADD_TIME(dest, src1, src2) { \
+  if(((dest).tv_usec = \
+    (src1).tv_usec + (src2).tv_usec) >= 1000000) { \
+    (dest).tv_usec -= 1000000; \
+    (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; \
+  } else { \
+    (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \
+    if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
+      (dest).tv_sec --;(dest).tv_usec += 1000000; \
+    } \
+  } \
+}
+#define TIMEDELTA(dest, src1, src2) { \
+  if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { \
+    (dest).tv_usec += 1000000; \
+    (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; \
+  } else { \
+     (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \
+  } \
+}
+#define IS_AFTER(t1, t2) \
+  (((t2).tv_sec > (t1).tv_sec) || \
+  (((t2).tv_sec == (t1).tv_sec) && \
+  ((t2).tv_usec > (t1).tv_usec)))
+#define IS_AT_OR_AFTER(t1, t2) \
+  (((t2).tv_sec > (t1).tv_sec) || \
+  (((t2).tv_sec == (t1).tv_sec) && \
+  ((t2).tv_usec >= (t1).tv_usec)))
+#endif
+
+#define IGNORE_IN_GAME_MODE() \
+  { if (__glutGameModeWindow) return; }
+
+#define GLUT_WIND_IS_RGB(x)         (((x) & GLUT_INDEX) == 0)
+#define GLUT_WIND_IS_INDEX(x)       (((x) & GLUT_INDEX) != 0)
+#define GLUT_WIND_IS_SINGLE(x)      (((x) & GLUT_DOUBLE) == 0)
+#define GLUT_WIND_IS_DOUBLE(x)      (((x) & GLUT_DOUBLE) != 0)
+#define GLUT_WIND_HAS_ACCUM(x)      (((x) & GLUT_ACCUM) != 0)
+#define GLUT_WIND_HAS_ALPHA(x)      (((x) & GLUT_ALPHA) != 0)
+#define GLUT_WIND_HAS_DEPTH(x)      (((x) & GLUT_DEPTH) != 0)
+#define GLUT_WIND_HAS_STENCIL(x)    (((x) & GLUT_STENCIL) != 0)
+#define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0)
+#define GLUT_WIND_IS_STEREO(x)      (((x) & GLUT_STEREO) != 0)
+#define GLUT_WIND_IS_LUMINANCE(x)   (((x) & GLUT_LUMINANCE) != 0)
+#define GLUT_MAP_WORK               (1 << 0)
+#define GLUT_EVENT_MASK_WORK        (1 << 1)
+#define GLUT_REDISPLAY_WORK         (1 << 2)
+#define GLUT_CONFIGURE_WORK         (1 << 3)
+#define GLUT_COLORMAP_WORK          (1 << 4)
+#define GLUT_DEVICE_MASK_WORK	    (1 << 5)
+#define GLUT_FINISH_WORK	    (1 << 6)
+#define GLUT_DEBUG_WORK		    (1 << 7)
+#define GLUT_DUMMY_WORK		    (1 << 8)
+#define GLUT_FULL_SCREEN_WORK       (1 << 9)
+#define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10)
+#define GLUT_REPAIR_WORK            (1 << 11)
+#define GLUT_OVERLAY_REPAIR_WORK    (1 << 12)
+
+/* Frame buffer capability macros and types. */
+#define RGBA                    0
+#define BUFFER_SIZE             1
+#define DOUBLEBUFFER            2
+#define STEREO                  3
+#define AUX_BUFFERS             4
+#define RED_SIZE                5  /* Used as mask bit for
+                                      "color selected". */
+#define GREEN_SIZE              6
+#define BLUE_SIZE               7
+#define ALPHA_SIZE              8
+#define DEPTH_SIZE              9
+#define STENCIL_SIZE            10
+#define ACCUM_RED_SIZE          11  /* Used as mask bit for
+                                       "acc selected". */
+#define ACCUM_GREEN_SIZE        12
+#define ACCUM_BLUE_SIZE         13
+#define ACCUM_ALPHA_SIZE        14
+#define LEVEL                   15
+
+#define NUM_GLXCAPS             (LEVEL + 1)
+
+#define XVISUAL                 (NUM_GLXCAPS + 0)
+#define TRANSPARENT             (NUM_GLXCAPS + 1)
+#define SAMPLES                 (NUM_GLXCAPS + 2)
+#define XSTATICGRAY             (NUM_GLXCAPS + 3)  /* Used as
+                                                      mask bit
+                                                      for "any
+                                                      visual type
+                                                      selected". */
+#define XGRAYSCALE              (NUM_GLXCAPS + 4)
+#define XSTATICCOLOR            (NUM_GLXCAPS + 5)
+#define XPSEUDOCOLOR            (NUM_GLXCAPS + 6)
+#define XTRUECOLOR              (NUM_GLXCAPS + 7)
+#define XDIRECTCOLOR            (NUM_GLXCAPS + 8)
+#define SLOW                    (NUM_GLXCAPS + 9)
+#define CONFORMANT              (NUM_GLXCAPS + 10)
+
+#define NUM_CAPS                (NUM_GLXCAPS + 11)
+
+/* Frame buffer capablities that don't have a corresponding
+   FrameBufferMode entry.  These get used as mask bits. */
+#define NUM                     (NUM_CAPS + 0)
+#define RGBA_MODE               (NUM_CAPS + 1)
+#define CI_MODE                 (NUM_CAPS + 2)
+#define LUMINANCE_MODE		(NUM_CAPS + 3)
+
+#define NONE			0
+#define EQ			1
+#define NEQ			2
+#define LTE			3
+#define GTE			4
+#define GT			5
+#define LT			6
+#define MIN			7
+
+typedef struct _Criterion {
+  int capability;
+  int comparison;
+  int value;
+} Criterion;
+
+typedef struct _FrameBufferMode {
+  XVisualInfo *vi;
+#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
+
+  /* fbc is non-NULL when the XVisualInfo* is not OpenGL-capable
+     (ie, GLX_USE_GL is false), but the SGIX_fbconfig extension shows
+     the visual's fbconfig is OpenGL-capable.  The reason for this is typically
+     an RGBA luminance fbconfig such as 16-bit StaticGray that could
+     not be advertised as a GLX visual since StaticGray visuals are
+     required (by the GLX specification) to be color index.  The
+     SGIX_fbconfig allows StaticGray visuals to instead advertised as
+     fbconfigs that can provide RGBA luminance support. */
+
+  GLXFBConfigSGIX fbc;
+#endif
+  int valid;
+  int cap[NUM_CAPS];
+} FrameBufferMode;
+
+/* DisplayMode capability macros for game mode. */
+#define DM_WIDTH        0  /* "width" */
+#define DM_HEIGHT       1  /* "height" */
+#define DM_PIXEL_DEPTH  2  /* "bpp" (bits per pixel) */
+#define DM_HERTZ        3  /* "hertz" */
+#define DM_NUM          4  /* "num" */
+
+#define NUM_DM_CAPS     (DM_NUM+1)
+
+typedef struct _DisplayMode {
+#ifdef _WIN32
+  DEVMODE devmode;
+#else
+  /* XXX The X Window System does not have a standard
+     mechanism for display setting changes.  On SGI
+     systems, GLUT could use the XSGIvc (SGI X video
+     control extension).  Perhaps this can be done in
+     a future release of GLUT. */
+#endif
+  int valid;
+  int cap[NUM_DM_CAPS];
+} DisplayMode;
+
+/* GLUT  function types */
+typedef void (GLUTCALLBACK *GLUTdisplayCB) (void);
+typedef void (GLUTCALLBACK *GLUTreshapeCB) (int, int);
+typedef void (GLUTCALLBACK *GLUTkeyboardCB) (unsigned char, int, int);
+typedef void (GLUTCALLBACK *GLUTmouseCB) (int, int, int, int);
+typedef void (GLUTCALLBACK *GLUTmotionCB) (int, int);
+typedef void (GLUTCALLBACK *GLUTpassiveCB) (int, int);
+typedef void (GLUTCALLBACK *GLUTentryCB) (int);
+typedef void (GLUTCALLBACK *GLUTvisibilityCB) (int);
+typedef void (GLUTCALLBACK *GLUTwindowStatusCB) (int);
+typedef void (GLUTCALLBACK *GLUTidleCB) (void);
+typedef void (GLUTCALLBACK *GLUTtimerCB) (int);
+typedef void (GLUTCALLBACK *GLUTmenuStateCB) (int);  /* DEPRICATED. */
+typedef void (GLUTCALLBACK *GLUTmenuStatusCB) (int, int, int);
+typedef void (GLUTCALLBACK *GLUTselectCB) (int);
+typedef void (GLUTCALLBACK *GLUTspecialCB) (int, int, int);
+typedef void (GLUTCALLBACK *GLUTspaceMotionCB) (int, int, int);
+typedef void (GLUTCALLBACK *GLUTspaceRotateCB) (int, int, int);
+typedef void (GLUTCALLBACK *GLUTspaceButtonCB) (int, int);
+typedef void (GLUTCALLBACK *GLUTdialsCB) (int, int);
+typedef void (GLUTCALLBACK *GLUTbuttonBoxCB) (int, int);
+typedef void (GLUTCALLBACK *GLUTtabletMotionCB) (int, int);
+typedef void (GLUTCALLBACK *GLUTtabletButtonCB) (int, int, int, int);
+typedef void (GLUTCALLBACK *GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z);
+
+typedef struct _GLUTcolorcell GLUTcolorcell;
+struct _GLUTcolorcell {
+  /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */
+  GLfloat component[3];
+};
+
+typedef struct _GLUTcolormap GLUTcolormap;
+struct _GLUTcolormap {
+  Visual *visual;       /* visual of the colormap */
+  Colormap cmap;        /* X colormap ID */
+  int refcnt;           /* number of windows using colormap */
+  int size;             /* number of cells in colormap */
+  int transparent;      /* transparent pixel, or -1 if opaque */
+  GLUTcolorcell *cells; /* array of cells */
+  GLUTcolormap *next;   /* next colormap in list */
+};
+
+typedef struct _GLUTwindow GLUTwindow;
+typedef struct _GLUToverlay GLUToverlay;
+struct _GLUTwindow {
+  int num;              /* Small integer window id (0-based). */
+
+  /* Window system related state. */
+#if defined(_WIN32)
+  int pf;               /* Pixel format. */
+  HDC hdc;              /* Window's Win32 device context. */
+#endif
+  Window win;           /* X window for GLUT window */
+  GLXContext ctx;       /* OpenGL context GLUT glut window */
+  XVisualInfo *vis;     /* visual for window */
+  Bool visAlloced;      /* if vis needs deallocate on destroy */
+  Colormap cmap;        /* RGB colormap for window; None if CI */
+  GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
+  GLUToverlay *overlay; /* overlay; NULL if no overlay */
+#if defined(_WIN32)
+  HDC renderDc;         /* Win32's device context for rendering. */
+#endif
+  Window renderWin;     /* X window for rendering (might be
+                           overlay) */
+  GLXContext renderCtx; /* OpenGL context for rendering (might
+                           be overlay) */
+  /* GLUT settable or visible window state. */
+  int width;            /* window width in pixels */
+  int height;           /* window height in pixels */
+  int cursor;           /* cursor name */
+  int visState;         /* visibility state (-1 is unknown) */
+  int shownState;       /* if window mapped */
+  int entryState;       /* entry state (-1 is unknown) */
+#define GLUT_MAX_MENUS              3
+
+  int menu[GLUT_MAX_MENUS];  /* attatched menu nums */
+  /* Window relationship state. */
+  GLUTwindow *parent;   /* parent window */
+  GLUTwindow *children; /* list of children */
+  GLUTwindow *siblings; /* list of siblings */
+  /* Misc. non-API visible (hidden) state. */
+  Bool treatAsSingle;   /* treat this window as single-buffered
+                           (it might be "fake" though) */
+  Bool forceReshape;    /* force reshape before display */
+#if !defined(_WIN32)
+  Bool isDirect;        /* if direct context (X11 only) */
+#endif
+  Bool usedSwapBuffers; /* if swap buffers used last display */
+  long eventMask;       /* mask of X events selected for */
+  int buttonUses;       /* number of button uses, ref cnt */
+  int tabletPos[2];     /* tablet position (-1 is invalid) */
+  /* Work list related state. */
+  unsigned int workMask;  /* mask of window work to be done */
+  GLUTwindow *prevWorkWin;  /* link list of windows to work on */
+  Bool desiredMapState; /* how to mapped window if on map work
+                           list */
+  Bool ignoreKeyRepeat;  /* if window ignores autorepeat */
+  int desiredConfMask;  /* mask of desired window configuration
+                         */
+  int desiredX;         /* desired X location */
+  int desiredY;         /* desired Y location */
+  int desiredWidth;     /* desired window width */
+  int desiredHeight;    /* desired window height */
+  int desiredStack;     /* desired window stack */
+  /* Per-window callbacks. */
+  GLUTdisplayCB display;  /* redraw */
+  GLUTreshapeCB reshape;  /* resize (width,height) */
+  GLUTmouseCB mouse;    /* mouse (button,state,x,y) */
+  GLUTmotionCB motion;  /* motion (x,y) */
+  GLUTpassiveCB passive;  /* passive motion (x,y) */
+  GLUTentryCB entry;    /* window entry/exit (state) */
+  GLUTkeyboardCB keyboard;  /* keyboard (ASCII,x,y) */
+  GLUTkeyboardCB keyboardUp;  /* keyboard up (ASCII,x,y) */
+  GLUTwindowStatusCB windowStatus;  /* window status */
+  GLUTvisibilityCB visibility;  /* visibility */
+  GLUTspecialCB special;  /* special key */
+  GLUTspecialCB specialUp;  /* special up key */
+  GLUTbuttonBoxCB buttonBox;  /* button box */
+  GLUTdialsCB dials;    /* dials */
+  GLUTspaceMotionCB spaceMotion;  /* Spaceball motion */
+  GLUTspaceRotateCB spaceRotate;  /* Spaceball rotate */
+  GLUTspaceButtonCB spaceButton;  /* Spaceball button */
+  GLUTtabletMotionCB tabletMotion;  /* tablet motion */
+  GLUTtabletButtonCB tabletButton;  /* tablet button */
+#ifdef _WIN32
+  GLUTjoystickCB joystick;  /* joystick */
+  int joyPollInterval; /* joystick polling interval */
+#endif
+#ifdef SUPPORT_FORTRAN
+  GLUTdisplayFCB fdisplay;  /* Fortran display  */
+  GLUTreshapeFCB freshape;  /* Fortran reshape  */
+  GLUTmouseFCB fmouse;  /* Fortran mouse  */
+  GLUTmotionFCB fmotion;  /* Fortran motion  */
+  GLUTpassiveFCB fpassive;  /* Fortran passive  */
+  GLUTentryFCB fentry;  /* Fortran entry  */
+  GLUTkeyboardFCB fkeyboard;  /* Fortran keyboard  */
+  GLUTkeyboardFCB fkeyboardUp;  /* Fortran keyboard up */
+  GLUTwindowStatusFCB fwindowStatus;  /* Fortran window status */
+  GLUTvisibilityFCB fvisibility;  /* Fortran visibility */
+  GLUTspecialFCB fspecial;  /* special key */
+  GLUTspecialFCB fspecialUp;  /* special key up */
+  GLUTbuttonBoxFCB fbuttonBox;  /* button box */
+  GLUTdialsFCB fdials;  /* dials */
+  GLUTspaceMotionFCB fspaceMotion;  /* Spaceball motion */
+  GLUTspaceRotateFCB fspaceRotate;  /* Spaceball rotate */
+  GLUTspaceButtonFCB fspaceButton;  /* Spaceball button */
+  GLUTtabletMotionFCB ftabletMotion;  /* tablet motion */
+  GLUTtabletButtonFCB ftabletButton;  /* tablet button */
+#ifdef _WIN32
+  GLUTjoystickFCB fjoystick;  /* joystick */
+#endif
+#endif
+};
+
+struct _GLUToverlay {
+#if defined(_WIN32)
+  int pf;
+  HDC hdc;
+#endif
+  Window win;
+  GLXContext ctx;
+  XVisualInfo *vis;     /* visual for window */
+  Bool visAlloced;      /* if vis needs deallocate on destroy */
+  Colormap cmap;        /* RGB colormap for window; None if CI */
+  GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
+  int shownState;       /* if overlay window mapped */
+  Bool treatAsSingle;   /* treat as single-buffered */
+#if !defined(_WIN32)
+  Bool isDirect;        /* if direct context */
+#endif
+  int transparentPixel; /* transparent pixel value */
+  GLUTdisplayCB display;  /* redraw  */
+#ifdef SUPPORT_FORTRAN
+  GLUTdisplayFCB fdisplay;  /* redraw  */
+#endif
+};
+
+typedef struct _GLUTstale GLUTstale;
+struct _GLUTstale {
+  GLUTwindow *window;
+  Window win;
+  GLUTstale *next;
+};
+
+extern GLUTstale *__glutStaleWindowList;
+
+#define GLUT_OVERLAY_EVENT_FILTER_MASK \
+  (ExposureMask | \
+  StructureNotifyMask | \
+  EnterWindowMask | \
+  LeaveWindowMask)
+#define GLUT_DONT_PROPAGATE_FILTER_MASK \
+  (ButtonReleaseMask | \
+  ButtonPressMask | \
+  KeyPressMask | \
+  KeyReleaseMask | \
+  PointerMotionMask | \
+  Button1MotionMask | \
+  Button2MotionMask | \
+  Button3MotionMask)
+#define GLUT_HACK_STOP_PROPAGATE_MASK \
+  (KeyPressMask | \
+  KeyReleaseMask)
+
+typedef struct _GLUTmenu GLUTmenu;
+typedef struct _GLUTmenuItem GLUTmenuItem;
+struct _GLUTmenu {
+  int id;               /* small integer menu id (0-based) */
+  Window win;           /* X window for the menu */
+  GLUTselectCB select;  /*  function of menu */
+  GLUTmenuItem *list;   /* list of menu entries */
+  int num;              /* number of entries */
+#if !defined(_WIN32)
+  Bool managed;         /* are the InputOnly windows size
+                           validated? */
+  Bool searched;	/* help detect menu loops */
+  int pixheight;        /* height of menu in pixels */
+  int pixwidth;         /* width of menu in pixels */
+#endif
+  int submenus;         /* number of submenu entries */
+  GLUTmenuItem *highlighted;  /* pointer to highlighted menu
+                                 entry, NULL not highlighted */
+  GLUTmenu *cascade;    /* currently cascading this menu  */
+  GLUTmenuItem *anchor; /* currently anchored to this entry */
+  int x;                /* current x origin relative to the
+                           root window */
+  int y;                /* current y origin relative to the
+                           root window */
+#ifdef SUPPORT_FORTRAN
+  GLUTselectFCB fselect;  /*  function of menu */
+#endif
+};
+
+struct _GLUTmenuItem {
+  Window win;           /* InputOnly X window for entry */
+  GLUTmenu *menu;       /* menu entry belongs to */
+  Bool isTrigger;       /* is a submenu trigger? */
+  int value;            /* value to return for selecting this
+                           entry; doubles as submenu id
+                           (0-base) if submenu trigger */
+#if defined(_WIN32)
+  UINT unique;          /* unique menu item id (Win32 only) */
+#endif
+  char *label;          /* __glutStrdup'ed label string */
+  int len;              /* length of label string */
+  int pixwidth;         /* width of X window in pixels */
+  GLUTmenuItem *next;   /* next menu entry on list for menu */
+};
+
+typedef struct _GLUTtimer GLUTtimer;
+struct _GLUTtimer {
+  GLUTtimer *next;      /* list of timers */
+  struct timeval timeout;  /* time to be called */
+  GLUTtimerCB func;     /* timer  (value) */
+  int value;            /*  return value */
+#ifdef SUPPORT_FORTRAN
+  GLUTtimerFCB ffunc;   /* Fortran timer  */
+#endif
+};
+
+typedef struct _GLUTeventParser GLUTeventParser;
+struct _GLUTeventParser {
+  int (*func) (XEvent *);
+  GLUTeventParser *next;
+};
+
+/* Declarations to implement glutFullScreen support with
+   mwm/4Dwm. */
+
+/* The following X property format is defined in Motif 1.1's
+   Xm/MwmUtils.h, but GLUT should not depend on that header
+   file. Note: Motif 1.2 expanded this structure with
+   uninteresting fields (to GLUT) so just stick with the
+   smaller Motif 1.1 structure. */
+typedef struct {
+#define MWM_HINTS_DECORATIONS   2
+  long flags;
+  long functions;
+  long decorations;
+  long input_mode;
+} MotifWmHints;
+
+/* Make current and buffer swap macros. */
+#ifdef _WIN32
+#define MAKE_CURRENT_LAYER(window)                                    \
+  {                                                                   \
+    HGLRC currentContext = GetCurrentContext();                       \
+    HDC currentDc = GetCurrentDC();                                   \
+                                                                      \
+    if (currentContext != window->renderCtx                           \
+      || currentDc != window->renderDc) {                             \
+      MakeCurrent(window->renderDc, window->renderCtx);               \
+    }                                                                 \
+  }
+#define MAKE_CURRENT_WINDOW(window)                                   \
+  {                                                                   \
+    HGLRC currentContext = GetCurrentContext();                       \
+    HDC currentDc = GetCurrentDC();                                   \
+                                                                      \
+    if (currentContext != window->ctx || currentDc != window->hdc) {  \
+      MakeCurrent(window->hdc, window->ctx);                          \
+    }                                                                 \
+  }
+#define MAKE_CURRENT_OVERLAY(overlay) \
+  MakeCurrent(overlay->hdc, overlay->ctx)
+#define UNMAKE_CURRENT() \
+  MakeCurrent(NULL, NULL)
+#define SWAP_BUFFERS_WINDOW(window) \
+  SwapBuffers(window->hdc)
+#define SWAP_BUFFERS_LAYER(window) \
+  SwapBuffers(window->renderDc)
+#else
+#define MAKE_CURRENT_LAYER(window) \
+  glXMakeCurrent(__glutDisplay, window->renderWin, window->renderCtx)
+#define MAKE_CURRENT_WINDOW(window) \
+  glXMakeCurrent(__glutDisplay, window->win, window->ctx)
+#define MAKE_CURRENT_OVERLAY(overlay) \
+  glXMakeCurrent(__glutDisplay, overlay->win, overlay->ctx)
+#define UNMAKE_CURRENT() \
+  glXMakeCurrent(__glutDisplay, None, NULL)
+#define SWAP_BUFFERS_WINDOW(window) \
+  glXSwapBuffers(__glutDisplay, window->win)
+#define SWAP_BUFFERS_LAYER(window) \
+  glXSwapBuffers(__glutDisplay, window->renderWin)
+#endif
+
+/* private variables from glut_event.c */
+extern GLUTwindow *__glutWindowWorkList;
+extern int __glutWindowDamaged;
+#ifdef SUPPORT_FORTRAN
+extern GLUTtimer *__glutTimerList;
+extern GLUTtimer *__glutNewTimer;
+#endif
+extern GLUTmenu *__glutMappedMenu;
+
+extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
+#if !defined(_WIN32)
+extern void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item,
+  int num, int type);
+extern void (*__glutFinishMenu)(Window win, int x, int y);
+extern void (*__glutPaintMenu)(GLUTmenu * menu);
+extern void (*__glutStartMenu)(GLUTmenu * menu,
+  GLUTwindow * window, int x, int y, int x_win, int y_win);
+extern GLUTmenu * (*__glutGetMenuByNum)(int menunum);
+extern GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu,
+  Window win, int *which);
+extern GLUTmenu * (*__glutGetMenu)(Window win);
+#endif
+
+/* private variables from glut_init.c */
+extern Atom __glutWMDeleteWindow;
+extern Display *__glutDisplay;
+extern unsigned int __glutDisplayMode;
+extern char *__glutDisplayString;
+extern XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
+  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc);
+extern GLboolean __glutDebug;
+extern GLboolean __glutForceDirect;
+extern GLboolean __glutIconic;
+extern GLboolean __glutTryDirect;
+extern Window __glutRoot;
+extern XSizeHints __glutSizeHints;
+extern char **__glutArgv;
+extern char *__glutProgramName;
+extern int __glutArgc;
+extern int __glutConnectionFD;
+extern int __glutInitHeight;
+extern int __glutInitWidth;
+extern int __glutInitX;
+extern int __glutInitY;
+extern int __glutScreen;
+extern int __glutScreenHeight;
+extern int __glutScreenWidth;
+extern Atom __glutMotifHints;
+extern unsigned int __glutModifierMask;
+#ifdef _WIN32
+extern void (__cdecl *__glutExitFunc)(int retval);
+#endif
+
+/* private variables from glut_menu.c */
+extern GLUTmenuItem *__glutItemSelected;
+extern GLUTmenu **__glutMenuList;
+extern void (GLUTCALLBACK *__glutMenuStatusFunc) (int, int, int);
+extern void __glutMenuModificationError(void);
+extern void __glutSetMenuItem(GLUTmenuItem * item,
+  const char *label, int value, Bool isTrigger);
+
+/* private variables from glut_win.c */
+extern GLUTwindow **__glutWindowList;
+extern GLUTwindow *__glutCurrentWindow;
+extern GLUTwindow *__glutMenuWindow;
+extern GLUTmenu *__glutCurrentMenu;
+extern int __glutWindowListSize;
+extern void (*__glutFreeOverlayFunc) (GLUToverlay *);
+extern XVisualInfo *__glutDetermineWindowVisual(Bool * treatAsSingle,
+  Bool * visAlloced, void **fbc);
+
+/* private variables from glut_mesa.c */
+extern int __glutMesaSwapHackSupport;
+
+/* private variables from glut_gamemode.c */
+extern GLUTwindow *__glutGameModeWindow;
+
+/* private routines from glut_cindex.c */
+extern GLUTcolormap * __glutAssociateNewColormap(XVisualInfo * vis);
+extern void __glutFreeColormap(GLUTcolormap *);
+
+/* private routines from glut_cmap.c */
+extern void __glutSetupColormap(
+  XVisualInfo * vi,
+  GLUTcolormap ** colormap,
+  Colormap * cmap);
+#if !defined(_WIN32)
+extern void __glutEstablishColormapsProperty(
+  GLUTwindow * window);
+extern GLUTwindow *__glutToplevelOf(GLUTwindow * window);
+#endif
+
+/* private routines from glut_cursor.c */
+extern void __glutSetCursor(GLUTwindow *window);
+
+/* private routines from glut_event.c */
+extern void __glutPutOnWorkList(GLUTwindow * window,
+  int work_mask);
+extern void __glutRegisterEventParser(GLUTeventParser * parser);
+extern void __glutPostRedisplay(GLUTwindow * window, int layerMask);
+
+/* private routines from glut_init.c */
+#if !defined(_WIN32)
+extern void __glutOpenXConnection(char *display);
+#else
+extern void __glutOpenWin32Connection(char *display);
+#endif
+extern void __glutInitTime(struct timeval *beginning);
+
+/* private routines for glut_menu.c (or win32_menu.c) */
+#if defined(_WIN32)
+extern GLUTmenu *__glutGetMenu(Window win);
+extern GLUTmenu *__glutGetMenuByNum(int menunum);
+extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu,
+  Window win, int *which);
+extern void __glutStartMenu(GLUTmenu * menu,
+  GLUTwindow * window, int x, int y, int x_win, int y_win);
+extern void __glutFinishMenu(Window win, int x, int y);
+#endif
+extern void __glutSetMenu(GLUTmenu * menu);
+
+/* private routines from glut_util.c */
+extern char * __glutStrdup(const char *string);
+extern void __glutWarning(char *format,...);
+extern void __glutFatalError(char *format,...);
+extern void __glutFatalUsage(char *format,...);
+
+/* private routines from glut_win.c */
+extern GLUTwindow *__glutGetWindow(Window win);
+extern void __glutChangeWindowEventMask(long mask, Bool add);
+extern XVisualInfo *__glutDetermineVisual(
+  unsigned int mode,
+  Bool * fakeSingle,
+  XVisualInfo * (getVisualInfo) (unsigned int));
+extern XVisualInfo *__glutGetVisualInfo(unsigned int mode);
+extern void __glutSetWindow(GLUTwindow * window);
+extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc,
+  int callingConvention);
+extern void GLUTCALLBACK __glutDefaultReshape(int, int);
+extern GLUTwindow *__glutCreateWindow(
+  GLUTwindow * parent,
+  int x, int y, int width, int height, int gamemode);
+extern void __glutDestroyWindow(
+  GLUTwindow * window,
+  GLUTwindow * initialWindow);
+
+#if !defined(_WIN32)
+/* private routines from glut_glxext.c */
+extern int __glutIsSupportedByGLX(char *);
+#endif
+
+/* private routines from glut_input.c */
+extern void  __glutUpdateInputDeviceMask(GLUTwindow * window);
+
+/* private routines from glut_mesa.c */
+extern void __glutDetermineMesaSwapHackSupport(void);
+
+/* private routines from glut_gameglut.c */
+extern void GLUTAPIENTRYV __glutCloseDownGameMode(void);
+
+#if defined(_WIN32)
+/* private routines from win32_*.c */
+extern LONG WINAPI __glutWindowProc(HWND win, UINT msg, WPARAM w, LPARAM l);
+extern HDC XHDC;
+#endif
+
+#endif /* __glutint_h__ */
diff --git a/src/glut/glx/glutstroke.h b/src/glut/glx/glutstroke.h
new file mode 100644
index 0000000000..cbc9e156fe
--- /dev/null
+++ b/src/glut/glx/glutstroke.h
@@ -0,0 +1,42 @@
+#ifndef __glutstroke_h__
+#define __glutstroke_h__
+
+/* Copyright (c) Mark J. Kilgard, 1994. */
+
+/* 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. */
+
+#if defined(_WIN32)
+#pragma warning (disable:4244)  /* disable bogus conversion warnings */
+#pragma warning (disable:4305)  /* VC++ 5.0 version of above warning. */
+#endif
+
+typedef struct {
+  float x;
+  float y;
+} CoordRec, *CoordPtr;
+
+typedef struct {
+  int num_coords;
+  const CoordRec *coord;
+} StrokeRec, *StrokePtr;
+
+typedef struct {
+  int num_strokes;
+  const StrokeRec *stroke;
+  float center;
+  float right;
+} StrokeCharRec, *StrokeCharPtr;
+
+typedef struct {
+  const char *name;
+  int num_chars;
+  const StrokeCharRec *ch;
+  float top;
+  float bottom;
+} StrokeFontRec, *StrokeFontPtr;
+
+typedef void *GLUTstrokeFont;
+
+#endif /* __glutstroke_h__ */
diff --git a/src/glut/glx/glutwin32.h b/src/glut/glx/glutwin32.h
new file mode 100644
index 0000000000..0852389019
--- /dev/null
+++ b/src/glut/glx/glutwin32.h
@@ -0,0 +1,48 @@
+#ifndef __glutwin32_h__
+#define __glutwin32_h__
+
+/* Copyright (c) Nate Robins, 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 "win32_x11.h"
+#include "win32_glx.h"
+
+/* We have to undef some things because Microsoft likes to pollute the
+   global namespace. */
+#undef TRANSPARENT
+
+/* Win32 "equivalent" cursors - eventually, the X glyphs should be
+   converted to Win32 cursors -- then they will look the same */
+#define XC_arrow               IDC_ARROW
+#define XC_top_left_arrow      IDC_ARROW
+#define XC_hand1               IDC_SIZEALL
+#define XC_pirate              IDC_NO
+#define XC_question_arrow      IDC_HELP
+#define XC_exchange            IDC_NO
+#define XC_spraycan            IDC_SIZEALL
+#define XC_watch               IDC_WAIT
+#define XC_xterm               IDC_IBEAM
+#define XC_crosshair           IDC_CROSS
+#define XC_sb_v_double_arrow   IDC_SIZENS
+#define XC_sb_h_double_arrow   IDC_SIZEWE
+#define XC_top_side            IDC_UPARROW
+#define XC_bottom_side         IDC_SIZENS
+#define XC_left_side           IDC_SIZEWE
+#define XC_right_side          IDC_SIZEWE
+#define XC_top_left_corner     IDC_SIZENWSE
+#define XC_top_right_corner    IDC_SIZENESW
+#define XC_bottom_right_corner IDC_SIZENWSE
+#define XC_bottom_left_corner  IDC_SIZENESW
+
+#define XA_STRING 0
+
+/* Private routines from win32_util.c */
+extern int gettimeofday(struct timeval* tp, void* tzp);
+extern void *__glutFont(void *font);
+extern int __glutGetTransparentPixel(Display *dpy, XVisualInfo *vinfo);
+extern void __glutAdjustCoords(Window parent, int *x, int *y, int *width, int *height);
+
+#endif /* __glutwin32_h__ */
diff --git a/src/glut/glx/layerutil.c b/src/glut/glx/layerutil.c
new file mode 100644
index 0000000000..80ee19514f
--- /dev/null
+++ b/src/glut/glx/layerutil.c
@@ -0,0 +1,201 @@
+
+/* Copyright (c) Mark J. Kilgard, 1993, 1994. */
+
+/* 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. */
+
+/* Based on XLayerUtil.c: Revision: 1.5 */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "layerutil.h"
+
+/* SGI optimization introduced in IRIX 6.3 to avoid X server
+   round trips for interning common X atoms. */
+#include <X11/Xatom.h>
+#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
+#include <X11/SGIFastAtom.h>
+#else
+#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
+#endif
+
+static Bool layersRead = False;
+static OverlayInfo **overlayInfoPerScreen;
+static unsigned long *numOverlaysPerScreen;
+
+static void
+findServerOverlayVisualsInfo(Display * dpy)
+{
+  static Atom overlayVisualsAtom;
+  Atom actualType;
+  Status status;
+  unsigned long sizeData, bytesLeft;
+  Window root;
+  int actualFormat, numScreens, i;
+
+  if (layersRead == False) {
+    overlayVisualsAtom = XSGIFastInternAtom(dpy,
+      "SERVER_OVERLAY_VISUALS", SGI_XA_SERVER_OVERLAY_VISUALS, True);
+    if (overlayVisualsAtom != None) {
+      numScreens = ScreenCount(dpy);
+      overlayInfoPerScreen = (OverlayInfo **)
+        malloc(numScreens * sizeof(OverlayInfo *));
+      numOverlaysPerScreen = (unsigned long *)
+        malloc(numScreens * sizeof(unsigned long));
+      if (overlayInfoPerScreen != NULL &&
+        numOverlaysPerScreen != NULL) {
+        for (i = 0; i < numScreens; i++) {
+          root = RootWindow(dpy, i);
+          status = XGetWindowProperty(dpy, root,
+            overlayVisualsAtom, 0L, (long) 10000, False,
+            overlayVisualsAtom, &actualType, &actualFormat,
+            &sizeData, &bytesLeft,
+            (unsigned char **) &overlayInfoPerScreen[i]);
+          if (status != Success ||
+            actualType != overlayVisualsAtom ||
+            actualFormat != 32 || sizeData < 4)
+            numOverlaysPerScreen[i] = 0;
+          else
+            /* Four 32-bit quantities per
+               SERVER_OVERLAY_VISUALS entry. */
+            numOverlaysPerScreen[i] = sizeData / 4;
+        }
+        layersRead = True;
+      } else {
+        if (overlayInfoPerScreen != NULL)
+          free(overlayInfoPerScreen);
+        if (numOverlaysPerScreen != NULL)
+          free(numOverlaysPerScreen);
+      }
+    }
+  }
+}
+
+int
+__glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
+{
+  int i, screen = vinfo->screen;
+  OverlayInfo *overlayInfo;
+
+  findServerOverlayVisualsInfo(dpy);
+  if (layersRead) {
+    for (i = 0; i < numOverlaysPerScreen[screen]; i++) {
+      overlayInfo = &overlayInfoPerScreen[screen][i];
+      if (vinfo->visualid == overlayInfo->overlay_visual) {
+        if (overlayInfo->transparent_type == TransparentPixel) {
+          return (int) overlayInfo->value;
+        } else {
+          return -1;
+        }
+      }
+    }
+  }
+  return -1;
+}
+
+XLayerVisualInfo *
+__glutXGetLayerVisualInfo(Display * dpy, long lvinfo_mask,
+  XLayerVisualInfo * lvinfo_template, int *nitems_return)
+{
+  XVisualInfo *vinfo;
+  XLayerVisualInfo *layerInfo;
+  int numVisuals, count, i, j;
+
+  vinfo = XGetVisualInfo(dpy, lvinfo_mask & VisualAllMask,
+    &lvinfo_template->vinfo, nitems_return);
+  if (vinfo == NULL)
+    return NULL;
+  numVisuals = *nitems_return;
+  findServerOverlayVisualsInfo(dpy);
+  layerInfo = (XLayerVisualInfo *)
+    malloc(numVisuals * sizeof(XLayerVisualInfo));
+  if (layerInfo == NULL) {
+    XFree(vinfo);
+    return NULL;
+  }
+  count = 0;
+  for (i = 0; i < numVisuals; i++) {
+    XVisualInfo *pVinfo = &vinfo[i];
+    int screen = pVinfo->screen;
+    OverlayInfo *overlayInfo = NULL;
+
+    overlayInfo = NULL;
+    if (layersRead) {
+      for (j = 0; j < numOverlaysPerScreen[screen]; j++)
+        if (pVinfo->visualid ==
+          overlayInfoPerScreen[screen][j].overlay_visual) {
+          overlayInfo = &overlayInfoPerScreen[screen][j];
+          break;
+        }
+    }
+    if (lvinfo_mask & VisualLayerMask)
+      if (overlayInfo == NULL) {
+        if (lvinfo_template->layer != 0)
+          continue;
+      } else if (lvinfo_template->layer != overlayInfo->layer)
+        continue;
+    if (lvinfo_mask & VisualTransparentType)
+      if (overlayInfo == NULL) {
+        if (lvinfo_template->type != None)
+          continue;
+      } else if (lvinfo_template->type !=
+        overlayInfo->transparent_type)
+        continue;
+    if (lvinfo_mask & VisualTransparentValue)
+      if (overlayInfo == NULL)
+        /* Non-overlay visuals have no sense of
+           TransparentValue. */
+        continue;
+      else if (lvinfo_template->value != overlayInfo->value)
+        continue;
+    layerInfo[count].vinfo = *pVinfo;
+    if (overlayInfo == NULL) {
+      layerInfo[count].layer = 0;
+      layerInfo[count].type = None;
+      layerInfo[count].value = 0;  /* meaningless */
+    } else {
+      layerInfo[count].layer = overlayInfo->layer;
+      layerInfo[count].type = overlayInfo->transparent_type;
+      layerInfo[count].value = overlayInfo->value;
+    }
+    count++;
+  }
+  XFree(vinfo);
+  *nitems_return = count;
+  if (count == 0) {
+    XFree(layerInfo);
+    return NULL;
+  } else
+    return layerInfo;
+}
+
+#if 0                   /* Unused by GLUT. */
+Status
+__glutXMatchLayerVisualInfo(Display * dpy, int screen,
+  int depth, int visualClass, int layer,
+  XLayerVisualInfo * lvinfo_return)
+{
+  XLayerVisualInfo *lvinfo;
+  XLayerVisualInfo lvinfoTemplate;
+  int nitems;
+
+  lvinfoTemplate.vinfo.screen = screen;
+  lvinfoTemplate.vinfo.depth = depth;
+#if defined(__cplusplus) || defined(c_plusplus)
+  lvinfoTemplate.vinfo.c_class = visualClass;
+#else
+  lvinfoTemplate.vinfo.class = visualClass;
+#endif
+  lvinfoTemplate.layer = layer;
+  lvinfo = __glutXGetLayerVisualInfo(dpy,
+    VisualScreenMask | VisualDepthMask |
+    VisualClassMask | VisualLayerMask,
+    &lvinfoTemplate, &nitems);
+  if (lvinfo != NULL && nitems > 0) {
+    *lvinfo_return = *lvinfo;
+    return 1;
+  } else
+    return 0;
+}
+#endif
diff --git a/src/glut/glx/layerutil.h b/src/glut/glx/layerutil.h
new file mode 100644
index 0000000000..3461077409
--- /dev/null
+++ b/src/glut/glx/layerutil.h
@@ -0,0 +1,55 @@
+#ifndef __layerutil_h__
+#define __layerutil_h__
+
+/* Copyright (c) Mark J. Kilgard, 1993, 1994. */
+
+/* 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. */
+
+/* Based on XLayerUtil.h: Revision: 1.3 */
+
+#if !defined(_WIN32)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xmd.h>
+#endif /* !_WIN32 */
+
+/* Transparent type values */
+/* None                       0 */
+#define TransparentPixel      1
+#define TransparentMask       2
+
+/* layered visual info template flags */
+#define VisualLayerMask		0x200
+#define VisualTransparentType	0x400
+#define VisualTransparentValue	0x800
+#define VisualAllLayerMask	0xFFF
+
+/* layered visual info structure */
+typedef struct _XLayerVisualInfo {
+  XVisualInfo vinfo;
+  long layer;
+  long type;
+  unsigned long value;
+} XLayerVisualInfo;
+
+/* SERVER_OVERLAY_VISUALS property element */
+typedef struct _OverlayInfo {
+  /* Avoid 64-bit portability problems by being careful to use
+     longs due to the way XGetWindowProperty is specified. Note
+     that these parameters are passed as CARD32s over X
+     protocol. */
+  long overlay_visual;
+  long transparent_type;
+  long value;
+  long layer;
+} OverlayInfo;
+
+extern int __glutGetTransparentPixel(Display *, XVisualInfo *);
+extern XLayerVisualInfo *__glutXGetLayerVisualInfo(Display *,
+  long, XLayerVisualInfo *, int *);
+extern Status __glutXMatchLayerVisualInfo(Display *,
+  int, int, int, int, XLayerVisualInfo *);
+
+#endif /* __layerutil_h__ */
diff --git a/src/glut/glx/mms_depend b/src/glut/glx/mms_depend
new file mode 100644
index 0000000000..bb0cffc1db
--- /dev/null
+++ b/src/glut/glx/mms_depend
@@ -0,0 +1,72 @@
+# DO NOT DELETE
+
+glut_8x13.obj : glutbitmap.h [-.include.gl]gl.h
+glut_9x15.obj : glutbitmap.h [-.include.gl]gl.h
+glut_bitmap.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_bitmap.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_bitmap.obj : glutbitmap.h
+glut_bwidth.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_bwidth.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_bwidth.obj : glutbitmap.h
+glut_cindex.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_cindex.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_cindex.obj : layerutil.h
+glut_cursor.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_cursor.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_dials.obj : glutint.h [-.include.gl]glx.h [-.include.gl]gl.h
+glut_dials.obj : [-.include.gl]xmesa.h [-.include.gl]glut.h [-.include.gl]glu.h
+glut_dstr.obj : glutint.h [-.include.gl]glx.h [-.include.gl]gl.h
+glut_dstr.obj : [-.include.gl]xmesa.h [-.include.gl]glut.h [-.include.gl]glu.h
+glut_event.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_event.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_ext.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_ext.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_fullscrn.obj : glutint.h [-.include.gl]glx.h [-.include.gl]gl.h
+glut_fullscrn.obj : [-.include.gl]xmesa.h [-.include.gl]glut.h
+glut_fullscrn.obj : [-.include.gl]glu.h
+glut_get.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_get.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_hel10.obj : glutbitmap.h [-.include.gl]gl.h
+glut_hel12.obj : glutbitmap.h [-.include.gl]gl.h
+glut_hel18.obj : glutbitmap.h [-.include.gl]gl.h
+glut_init.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_init.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_menu.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_menu.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h layerutil.h
+glut_mesa.obj : glutint.h [-.include.gl]glx.h [-.include.gl]gl.h
+glut_mesa.obj : [-.include.gl]xmesa.h [-.include.gl]glut.h [-.include.gl]glu.h
+glut_modifier.obj : glutint.h [-.include.gl]glx.h [-.include.gl]gl.h
+glut_modifier.obj : [-.include.gl]xmesa.h [-.include.gl]glut.h
+glut_modifier.obj : [-.include.gl]glu.h
+glut_mroman.obj : glutstroke.h
+glut_overlay.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_overlay.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_overlay.obj : layerutil.h
+glut_roman.obj : glutstroke.h
+glut_shapes.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_shapes.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_space.obj : glutint.h [-.include.gl]glx.h [-.include.gl]gl.h
+glut_space.obj : [-.include.gl]xmesa.h [-.include.gl]glut.h [-.include.gl]glu.h
+glut_stroke.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_stroke.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_stroke.obj : glutstroke.h
+glut_swidth.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_swidth.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_swidth.obj : glutstroke.h
+glut_tablet.obj : glutint.h [-.include.gl]glx.h [-.include.gl]gl.h
+glut_tablet.obj : [-.include.gl]xmesa.h [-.include.gl]glut.h [-.include.gl]glu.h
+glut_teapot.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_tr10.obj : glutbitmap.h [-.include.gl]gl.h
+glut_tr24.obj : glutbitmap.h [-.include.gl]gl.h
+glut_util.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_util.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_vidresize.obj : [-.include.gl]glx.h [-.include.gl]gl.h
+glut_vidresize.obj : [-.include.gl]xmesa.h glutint.h [-.include.gl]glut.h
+glut_vidresize.obj : [-.include.gl]glu.h
+glut_warp.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_warp.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_win.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_win.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+glut_winmisc.obj : [-.include.gl]glut.h [-.include.gl]gl.h [-.include.gl]glu.h
+glut_winmisc.obj : glutint.h [-.include.gl]glx.h [-.include.gl]xmesa.h
+layerutil.obj : layerutil.h
diff --git a/src/glut/glx/stroke.h b/src/glut/glx/stroke.h
new file mode 100644
index 0000000000..fc29680bea
--- /dev/null
+++ b/src/glut/glx/stroke.h
@@ -0,0 +1,134 @@
+/* $XConsortium: wfont.h,v 5.1 91/02/16 09:46:37 rws Exp $ */
+
+/*****************************************************************
+Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. and the X Consortium.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the names of Sun Microsystems,
+the X Consortium, and MIT not be used in advertising or publicity 
+pertaining to distribution of the software without specific, written 
+prior permission.  
+
+SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT 
+SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef WFONT_INCLUDED
+#define WFONT_INCLUDED
+
+#define WFONT_MAGIC	0x813
+#define WFONT_MAGIC_PLUS 0x715
+#define WFONT_MAGIC_PEX 0x70686e74
+#define START_PROPS 0x100
+#define START_DISPATCH(_num_props)  (START_PROPS + 160 * _num_props)
+#define START_PATH(_num_ch_, _num_props)  (START_DISPATCH(_num_props) + sizeof(Dispatch) * _num_ch_)
+#define NUM_DISPATCH	128
+
+typedef struct {
+  unsigned short x;
+  unsigned short y;
+} Path_point2dpx;
+
+typedef struct {
+  float x;
+  float y;
+} Path_point2df;
+
+typedef struct {
+  int x;
+  int y;
+  int z;
+} Path_point3di;
+
+typedef struct {
+  float x;
+  float y;
+  float z;
+} Path_point3df;
+
+typedef struct {
+  float x;
+  float y;
+  float z;
+  float w;
+} Path_point4df;
+
+typedef union {
+  Path_point2dpx *pt2dpx;
+  Path_point2df *pt2df;
+  Path_point3di *pt3di;
+  Path_point3df *pt3df;
+  Path_point4df *pt4df;
+} Path_pt_ptr;
+
+typedef enum {
+  PATH_2DF,
+  PATH_2DPX,
+  PATH_3DF,
+  PATH_3DI,
+  PATH_4DF
+} Path_type;
+
+typedef struct {
+  int n_pts;                    /* number of points in the subpath */
+  Path_pt_ptr pts;              /* pointer to them */
+  int closed;                   /* true if the subpath is closed */
+  int dcmp_flag;                /* flag for pgon dcmp, pgon type 
+                                 * and dcmped triangle type */
+} Path_subpath;
+
+typedef struct {
+  Path_type type;               /* type of vertices in this path */
+  int n_subpaths;               /* number of subpaths */
+  int n_vertices;               /* total number of vertices */
+  Path_subpath *subpaths;       /* array of subpaths */
+} Path;
+
+typedef Path *Path_handle;
+
+typedef struct {
+  char propname[80];            /* font property name */
+  char propvalue[80];           /* font property value */
+} Property;
+
+typedef struct {
+  int magic;                    /* magic number */
+  char name[80];                /* name of this font */
+  float top,                    /* extreme values */
+    bottom, max_width;
+  int num_ch;                   /* no. of fonts in the set */
+  int num_props;                /* no. of font properties */
+  Property *properties;         /* array of properties */
+} Font_header;
+
+typedef struct {
+  float center,                 /* center of the character */
+    right;                      /* right edge */
+  long offset;                  /* offset in the file of the character
+                                 * * description */
+} Dispatch;
+
+typedef struct {
+  float center, right;
+  Path strokes;
+} Ch_font;
+
+typedef struct {
+  char name[80];
+  float top, bottom, max_width;
+  int num_ch;                   /* # characters in the font */
+  Ch_font **ch_data;
+} Phg_font;
+
+#endif /*WFONT_INCLUDED */
diff --git a/src/glut/glx/win32_glx.c b/src/glut/glx/win32_glx.c
new file mode 100644
index 0000000000..ecfff44b93
--- /dev/null
+++ b/src/glut/glx/win32_glx.c
@@ -0,0 +1,256 @@
+
+/* Copyright (c) Nate Robins, 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 <stdio.h>
+#include "glutint.h"
+#include "win32_glx.h"
+
+/* global current HDC */
+extern HDC XHDC;
+
+GLXContext
+glXCreateContext(Display * display, XVisualInfo * visinfo,
+  GLXContext share, Bool direct)
+{
+  /* KLUDGE: GLX really expects a display pointer to be passed
+     in as the first parameter, but Win32 needs an HDC instead,
+     so BE SURE that the global XHDC is set before calling this
+     routine. */
+  HGLRC context;
+
+  context = CreateContext(XHDC);
+
+#if 0
+  /* XXX GLUT doesn't support it now, so don't worry about display list
+     and texture object sharing. */
+  if (share) {
+    wglShareLists(share, context);
+  }
+#endif
+
+  /* Since direct rendering is implicit, the direct flag is
+     ignored. */
+
+  return context;
+}
+
+int
+glXGetConfig(Display * display, XVisualInfo * visual, int attrib, int *value)
+{
+  if (!visual)
+    return GLX_BAD_VISUAL;
+
+  switch (attrib) {
+  case GLX_USE_GL:
+    if (visual->dwFlags & (PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW)) {
+      /* XXX Brad's Matrix Millenium II has problems creating
+         color index windows in 24-bit mode (lead to GDI crash)
+         and 32-bit mode (lead to black window).  The cColorBits
+         filed of the PIXELFORMATDESCRIPTOR returned claims to
+         have 24 and 32 bits respectively of color indices. 2^24
+         and 2^32 are ridiculously huge writable colormaps.
+         Assume that if we get back a color index
+         PIXELFORMATDESCRIPTOR with 24 or more bits, the
+         PIXELFORMATDESCRIPTOR doesn't really work and skip it.
+         -mjk */
+      if (visual->iPixelType == PFD_TYPE_COLORINDEX
+        && visual->cColorBits >= 24) {
+        *value = 0;
+      } else {
+	*value = 1;
+      }
+    } else {
+      *value = 0;
+    }
+    break;
+  case GLX_BUFFER_SIZE:
+    /* KLUDGE: if we're RGBA, return the number of bits/pixel,
+       otherwise, return 8 (we guessed at 256 colors in CI
+       mode). */
+    if (visual->iPixelType == PFD_TYPE_RGBA)
+      *value = visual->cColorBits;
+    else
+      *value = 8;
+    break;
+  case GLX_LEVEL:
+    /* The bReserved flag of the pfd contains the
+       overlay/underlay info. */
+    *value = visual->bReserved;
+    break;
+  case GLX_RGBA:
+    *value = visual->iPixelType == PFD_TYPE_RGBA;
+    break;
+  case GLX_DOUBLEBUFFER:
+    *value = visual->dwFlags & PFD_DOUBLEBUFFER;
+    break;
+  case GLX_STEREO:
+    *value = visual->dwFlags & PFD_STEREO;
+    break;
+  case GLX_AUX_BUFFERS:
+    *value = visual->cAuxBuffers;
+    break;
+  case GLX_RED_SIZE:
+    *value = visual->cRedBits;
+    break;
+  case GLX_GREEN_SIZE:
+    *value = visual->cGreenBits;
+    break;
+  case GLX_BLUE_SIZE:
+    *value = visual->cBlueBits;
+    break;
+  case GLX_ALPHA_SIZE:
+    *value = visual->cAlphaBits;
+    break;
+  case GLX_DEPTH_SIZE:
+    *value = visual->cDepthBits;
+    break;
+  case GLX_STENCIL_SIZE:
+    *value = visual->cStencilBits;
+    break;
+  case GLX_ACCUM_RED_SIZE:
+    *value = visual->cAccumRedBits;
+    break;
+  case GLX_ACCUM_GREEN_SIZE:
+    *value = visual->cAccumGreenBits;
+    break;
+  case GLX_ACCUM_BLUE_SIZE:
+    *value = visual->cAccumBlueBits;
+    break;
+  case GLX_ACCUM_ALPHA_SIZE:
+    *value = visual->cAccumAlphaBits;
+    break;
+  default:
+    return GLX_BAD_ATTRIB;
+  }
+  return 0;
+}
+
+XVisualInfo *
+glXChooseVisual(Display * display, int screen, int *attribList)
+{
+  /* KLUDGE: since we need the HDC, MAKE SURE to set XHDC
+     before calling this routine. */
+
+  int *p = attribList;
+  int pf;
+  PIXELFORMATDESCRIPTOR pfd;
+  PIXELFORMATDESCRIPTOR *match = NULL;
+  int stereo = 0;
+
+  /* Avoid seg-faults. */
+  if (!p)
+    return NULL;
+
+  memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
+  pfd.nSize = (sizeof(PIXELFORMATDESCRIPTOR));
+  pfd.nVersion = 1;
+
+  /* Defaults. */
+  pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
+  pfd.iPixelType = PFD_TYPE_COLORINDEX;
+  pfd.cColorBits = 32;
+  pfd.cDepthBits = 0;
+
+  while (*p) {
+    switch (*p) {
+    case GLX_USE_GL:
+      pfd.dwFlags |= PFD_SUPPORT_OPENGL;
+      break;
+    case GLX_BUFFER_SIZE:
+      pfd.cColorBits = *(++p);
+      break;
+    case GLX_LEVEL:
+      /* the bReserved flag of the pfd contains the
+         overlay/underlay info. */
+      pfd.bReserved = *(++p);
+      break;
+    case GLX_RGBA:
+      pfd.iPixelType = PFD_TYPE_RGBA;
+      break;
+    case GLX_DOUBLEBUFFER:
+      pfd.dwFlags |= PFD_DOUBLEBUFFER;
+      break;
+    case GLX_STEREO:
+      stereo = 1;
+      pfd.dwFlags |= PFD_STEREO;
+      break;
+    case GLX_AUX_BUFFERS:
+      pfd.cAuxBuffers = *(++p);
+      break;
+    case GLX_RED_SIZE:
+      pfd.cRedBits = 8; /* Try to get the maximum. */
+      ++p;
+      break;
+    case GLX_GREEN_SIZE:
+      pfd.cGreenBits = 8;
+      ++p;
+      break;
+    case GLX_BLUE_SIZE:
+      pfd.cBlueBits = 8;
+      ++p;
+      break;
+    case GLX_ALPHA_SIZE:
+      pfd.cAlphaBits = 8;
+      ++p;
+      break;
+    case GLX_DEPTH_SIZE:
+      pfd.cDepthBits = 32;
+      ++p;
+      break;
+    case GLX_STENCIL_SIZE:
+      pfd.cStencilBits = *(++p);
+      break;
+    case GLX_ACCUM_RED_SIZE:
+    case GLX_ACCUM_GREEN_SIZE:
+    case GLX_ACCUM_BLUE_SIZE:
+    case GLX_ACCUM_ALPHA_SIZE:
+      /* I believe that WGL only used the cAccumRedBits,
+	 cAccumBlueBits, cAccumGreenBits, and cAccumAlphaBits fields
+	 when returning info about the accumulation buffer precision.
+	 Only cAccumBits is used for requesting an accumulation
+	 buffer. */
+      pfd.cAccumBits = 1;
+      ++p;
+      break;
+    }
+    ++p;
+  }
+
+  /* Let Win32 choose one for us. */
+  pf = ChoosePixelFormat(XHDC, &pfd);
+  if (pf > 0) {
+    match = (PIXELFORMATDESCRIPTOR *) malloc(sizeof(PIXELFORMATDESCRIPTOR));
+    DescribePixelFormat(XHDC, pf, sizeof(PIXELFORMATDESCRIPTOR), match);
+
+    /* ChoosePixelFormat is dumb in that it will return a pixel
+       format that doesn't have stereo even if it was requested
+       so we need to make sure that if stereo was selected, we
+       got it. */
+    if (stereo) {
+      if (!(match->dwFlags & PFD_STEREO)) {
+        free(match);
+	return NULL;
+      }
+    }
+    /* XXX Brad's Matrix Millenium II has problems creating
+       color index windows in 24-bit mode (lead to GDI crash)
+       and 32-bit mode (lead to black window).  The cColorBits
+       filed of the PIXELFORMATDESCRIPTOR returned claims to
+       have 24 and 32 bits respectively of color indices. 2^24
+       and 2^32 are ridiculously huge writable colormaps.
+       Assume that if we get back a color index
+       PIXELFORMATDESCRIPTOR with 24 or more bits, the
+       PIXELFORMATDESCRIPTOR doesn't really work and skip it.
+       -mjk */
+    if (match->iPixelType == PFD_TYPE_COLORINDEX
+      && match->cColorBits >= 24) {
+      free(match);
+      return NULL;
+    }
+  }
+  return match;
+}
diff --git a/src/glut/glx/win32_glx.h b/src/glut/glx/win32_glx.h
new file mode 100644
index 0000000000..d3630e7a1e
--- /dev/null
+++ b/src/glut/glx/win32_glx.h
@@ -0,0 +1,58 @@
+#ifndef __win32_glx_h__
+#define __win32_glx_h__
+
+/* Copyright (c) Nate Robins, 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 "win32_x11.h"
+
+/* Type definitions (conversions). */
+typedef HGLRC GLXContext;
+
+#define GLX_USE_GL              1       /* support GLX rendering */
+#define GLX_BUFFER_SIZE         2       /* depth of the color buffer */
+#define GLX_LEVEL               3       /* level in plane stacking */
+#define GLX_RGBA                4       /* true if RGBA mode */
+#define GLX_DOUBLEBUFFER        5       /* double buffering supported */
+#define GLX_STEREO              6       /* stereo buffering supported */
+#define GLX_AUX_BUFFERS         7       /* number of aux buffers */
+#define GLX_RED_SIZE            8       /* number of red component bits */
+#define GLX_GREEN_SIZE          9       /* number of green component bits */
+#define GLX_BLUE_SIZE           10      /* number of blue component bits */
+#define GLX_ALPHA_SIZE          11      /* number of alpha component bits */
+#define GLX_DEPTH_SIZE          12      /* number of depth bits */
+#define GLX_STENCIL_SIZE        13      /* number of stencil bits */
+#define GLX_ACCUM_RED_SIZE      14      /* number of red accum bits */
+#define GLX_ACCUM_GREEN_SIZE    15      /* number of green accum bits */
+#define GLX_ACCUM_BLUE_SIZE     16      /* number of blue accum bits */
+#define GLX_ACCUM_ALPHA_SIZE    17      /* number of alpha accum bits */
+
+#define GLX_BAD_ATTRIB  2
+#define GLX_BAD_VISUAL  4
+
+/* Functions emulated by macros. */
+
+#define glXDestroyContext(display, context) \
+  wglDeleteContext(context)
+
+/* Function prototypes. */
+
+extern GLXContext glXCreateContext(
+  Display* display,
+  XVisualInfo* visinfo,
+  GLXContext share,
+  Bool direct);
+extern int glXGetConfig(
+  Display* display,
+  XVisualInfo* visual,
+  int attrib,
+  int* value);
+extern XVisualInfo* glXChooseVisual(
+  Display* display,
+  int screen,
+  int* attribList);
+
+#endif /* __win32_glx_h__ */
diff --git a/src/glut/glx/win32_menu.c b/src/glut/glx/win32_menu.c
new file mode 100644
index 0000000000..9b330644af
--- /dev/null
+++ b/src/glut/glx/win32_menu.c
@@ -0,0 +1,532 @@
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
+/* Copyright (c) Nate Robins, 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. */
+
+/* This file completely re-implements glut_menu.c and glut_menu2.c
+   for Win32.  Note that neither glut_menu.c nor glut_menu2.c are
+   compiled into Win32 GLUT. */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "glutint.h"
+
+void (GLUTCALLBACK *__glutMenuStatusFunc) (int, int, int);
+GLUTmenu *__glutMappedMenu;
+GLUTwindow *__glutMenuWindow;
+GLUTmenuItem *__glutItemSelected;
+unsigned __glutMenuButton;
+
+static GLUTmenu **menuList = NULL;
+static int menuListSize = 0;
+static UINT uniqueMenuHandler = 1;
+
+/* DEPRICATED, use glutMenuStatusFunc instead. */
+void APIENTRY
+glutMenuStateFunc(GLUTmenuStateCB menuStateFunc)
+{
+  __glutMenuStatusFunc = (GLUTmenuStatusCB) menuStateFunc;
+}
+
+void APIENTRY
+glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc)
+{
+  __glutMenuStatusFunc = menuStatusFunc;
+}
+
+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;
+}
+
+void
+__glutFinishMenu(Window win, int x, int y)
+{
+
+  unmapMenu(__glutMappedMenu);
+
+  /* XXX Put in a GdiFlush just in case.  Probably unnecessary. -mjk  */
+  GdiFlush();
+
+  if (__glutMenuStatusFunc) {
+    __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;
+}
+
+static void
+mapMenu(GLUTmenu * menu, int x, int y)
+{
+  TrackPopupMenu(menu->win, TPM_LEFTALIGN |
+    __glutMenuButton == TPM_RIGHTBUTTON ? 
+    TPM_RIGHTBUTTON : TPM_LEFTBUTTON,
+    x, y, 0, __glutCurrentWindow->win, NULL);
+}
+
+void
+__glutStartMenu(GLUTmenu * menu, GLUTwindow * window,
+		int x, int y, int x_win, int y_win)
+{
+  assert(__glutMappedMenu == NULL);
+  __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);
+}
+
+GLUTmenuItem *
+__glutGetUniqueMenuItem(GLUTmenu * menu, UINT unique)
+{
+  GLUTmenuItem *item;
+  int i;
+
+  i = menu->num;
+  item = menu->list;
+  while (item) {
+    if (item->unique == unique) {
+      return item;
+    }
+    if (item->isTrigger) {
+      GLUTmenuItem *subitem;
+      subitem = __glutGetUniqueMenuItem(menuList[item->value], unique);
+      if (subitem) {
+        return subitem;
+      }
+    }
+    i--;
+    item = item->next;
+  }
+  return NULL;
+}
+
+GLUTmenuItem *
+__glutGetMenuItem(GLUTmenu * menu, Window win, int *which)
+{
+  GLUTmenuItem *item;
+  int i;
+
+  i = menu->num;
+  item = menu->list;
+  while (item) {
+    if (item->win == win) {
+      *which = i;
+      return item;
+    }
+    if (item->isTrigger) {
+      GLUTmenuItem *subitem;
+
+      subitem = __glutGetMenuItem(menuList[item->value],
+        win, which);
+      if (subitem) {
+        return subitem;
+      }
+    }
+    i--;
+    item = item->next;
+  }
+  return NULL;
+}
+
+GLUTmenu *
+__glutGetMenu(Window win)
+{
+  GLUTmenu *menu;
+
+  menu = __glutMappedMenu;
+  while (menu) {
+    if (win == menu->win) {
+      return menu;
+    }
+    menu = menu->cascade;
+  }
+  return NULL;
+}
+
+GLUTmenu *
+__glutGetMenuByNum(int menunum)
+{
+  if (menunum < 1 || menunum > menuListSize) {
+    return NULL;
+  }
+  return menuList[menunum - 1];
+}
+
+static int
+getUnusedMenuSlot(void)
+{
+  int i;
+
+  /* Look for allocated, unused slot. */
+  for (i = 0; i < menuListSize; i++) {
+    if (!menuList[i]) {
+      return i;
+    }
+  }
+  /* Allocate a new slot. */
+  menuListSize++;
+  if (menuList) {
+    menuList = (GLUTmenu **)
+      realloc(menuList, 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. */
+    menuList = (GLUTmenu **) malloc(sizeof(GLUTmenu *));
+  }
+  if (!menuList) {
+    __glutFatalError("out of memory.");
+  }
+  menuList[menuListSize - 1] = NULL;
+  return menuListSize - 1;
+}
+
+static void
+menuModificationError(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.");
+}
+
+int APIENTRY
+glutCreateMenu(GLUTselectCB selectFunc)
+{
+  GLUTmenu *menu;
+  int menuid;
+
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  menuid = getUnusedMenuSlot();
+  menu = (GLUTmenu *) malloc(sizeof(GLUTmenu));
+  if (!menu) {
+    __glutFatalError("out of memory.");
+  }
+  menu->id = menuid;
+  menu->num = 0;
+  menu->submenus = 0;
+  menu->select = selectFunc;
+  menu->list = NULL;
+  menu->cascade = NULL;
+  menu->highlighted = NULL;
+  menu->anchor = NULL;
+  menu->win = CreatePopupMenu();
+  menuList[menuid] = menu;
+  __glutSetMenu(menu);
+  return menuid + 1;
+}
+
+int APIENTRY
+__glutCreateMenuWithExit(GLUTselectCB selectFunc, void (__cdecl *exitfunc)(int))
+{
+  __glutExitFunc = exitfunc;
+  return glutCreateMenu(selectFunc);
+}
+
+void APIENTRY
+glutDestroyMenu(int menunum)
+{
+  GLUTmenu *menu = __glutGetMenuByNum(menunum);
+  GLUTmenuItem *item, *next;
+
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  assert(menu->id == menunum - 1);
+  DestroyMenu(menu->win);
+  menuList[menunum - 1] = NULL;
+  /* free all menu entries */
+  item = menu->list;
+  while (item) {
+    assert(item->menu == menu);
+    next = item->next;
+    free(item->label);
+    free(item);
+    item = next;
+  }
+  if (__glutCurrentMenu == menu) {
+    __glutCurrentMenu = NULL;
+  }
+  free(menu);
+}
+
+int APIENTRY
+glutGetMenu(void)
+{
+  if (__glutCurrentMenu) {
+    return __glutCurrentMenu->id + 1;
+  } else {
+    return 0;
+  }
+}
+
+void APIENTRY
+glutSetMenu(int menuid)
+{
+  GLUTmenu *menu;
+
+  if (menuid < 1 || menuid > menuListSize) {
+    __glutWarning("glutSetMenu attempted on bogus menu.");
+    return;
+  }
+  menu = menuList[menuid - 1];
+  if (!menu) {
+    __glutWarning("glutSetMenu attempted on bogus menu.");
+    return;
+  }
+  __glutSetMenu(menu);
+}
+
+static void
+setMenuItem(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->unique = uniqueMenuHandler++;
+  if (isTrigger) {
+    AppendMenu(menu->win, MF_POPUP, (UINT)item->win, label);
+  } else {
+    AppendMenu(menu->win, MF_STRING, item->unique, label);
+  }
+}
+
+void APIENTRY
+glutAddMenuEntry(const char *label, int value)
+{
+  GLUTmenuItem *entry;
+
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  entry = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
+  if (!entry) {
+    __glutFatalError("out of memory.");
+  }
+  entry->menu = __glutCurrentMenu;
+  setMenuItem(entry, label, value, FALSE);
+  __glutCurrentMenu->num++;
+  entry->next = __glutCurrentMenu->list;
+  __glutCurrentMenu->list = entry;
+}
+
+void APIENTRY
+glutAddSubMenu(const char *label, int menu)
+{
+  GLUTmenuItem *submenu;
+  GLUTmenu     *popupmenu;
+
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  submenu = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
+  if (!submenu) {
+    __glutFatalError("out of memory.");
+  }
+  __glutCurrentMenu->submenus++;
+  submenu->menu = __glutCurrentMenu;
+  popupmenu = __glutGetMenuByNum(menu);
+  if (popupmenu) {
+    submenu->win = popupmenu->win;
+  }
+  setMenuItem(submenu, label, /* base 0 */ menu - 1, TRUE);
+  __glutCurrentMenu->num++;
+  submenu->next = __glutCurrentMenu->list;
+  __glutCurrentMenu->list = submenu;
+}
+
+void APIENTRY
+glutChangeToMenuEntry(int num, const char *label, int value)
+{
+  GLUTmenuItem *item;
+  int i;
+
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  i = __glutCurrentMenu->num;
+  item = __glutCurrentMenu->list;
+  while (item) {
+    if (i == num) {
+      if (item->isTrigger) {
+        /* If changing a submenu trigger to a menu entry, we
+           need to account for submenus.  */
+        item->menu->submenus--;
+	/* Nuke the Win32 menu. */
+	DestroyMenu(item->win);		
+      }
+      free(item->label);
+
+      item->label = strdup(label);
+      if (!item->label)
+	__glutFatalError("out of memory");
+      item->isTrigger = FALSE;
+      item->len = (int) strlen(label);
+      item->value = value;
+      item->unique = uniqueMenuHandler++;
+      ModifyMenu(__glutCurrentMenu->win, (UINT) i - 1,
+        MF_BYPOSITION | MFT_STRING, item->unique, label);
+
+      return;
+    }
+    i--;
+    item = item->next;
+  }
+  __glutWarning("Current menu has no %d item.", num);
+}
+
+void APIENTRY
+glutChangeToSubMenu(int num, const char *label, int menu)
+{
+  GLUTmenu *popupmenu;
+  GLUTmenuItem *item;
+  int i;
+
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  i = __glutCurrentMenu->num;
+  item = __glutCurrentMenu->list;
+  while (item) {
+    if (i == num) {
+      if (!item->isTrigger) {
+        /* If changing a menu entry to as submenu trigger, we
+           need to account for submenus.  */
+        item->menu->submenus++;
+	item->win = CreatePopupMenu();
+      }
+      free(item->label);
+      
+      item->label = strdup(label);
+      if (!item->label)
+	__glutFatalError("out of memory");
+      item->isTrigger = TRUE;
+      item->len = (int) strlen(label);
+      item->value = menu - 1;
+      item->unique = uniqueMenuHandler++;
+      popupmenu = __glutGetMenuByNum(menu);
+      if (popupmenu)
+	item->win = popupmenu->win;
+      ModifyMenu(__glutCurrentMenu->win, (UINT) i - 1,
+        MF_BYPOSITION | MF_POPUP, (UINT) item->win, label);
+      return;
+    }
+    i--;
+    item = item->next;
+  }
+  __glutWarning("Current menu has no %d item.", num);
+}
+
+void APIENTRY
+glutRemoveMenuItem(int num)
+{
+  GLUTmenuItem *item, **prev;
+  int i;
+
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  i = __glutCurrentMenu->num;
+  prev = &__glutCurrentMenu->list;
+  item = __glutCurrentMenu->list;
+  while (item) {
+    if (i == num) {
+      /* Found the menu item in list to remove. */
+      __glutCurrentMenu->num--;
+
+      /* Patch up menu's item list. */
+      *prev = item->next;
+
+      RemoveMenu(__glutCurrentMenu->win, (UINT) i - 1, MF_BYPOSITION);
+
+      free(item->label);
+      free(item);
+      return;
+    }
+    i--;
+    prev = &item->next;
+    item = item->next;
+  }
+  __glutWarning("Current menu has no %d item.", num);
+}
+
+void APIENTRY
+glutAttachMenu(int button)
+{
+  if (__glutCurrentWindow == __glutGameModeWindow) {
+    __glutWarning("cannot attach menus in game mode.");
+    return;
+  }
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  if (__glutCurrentWindow->menu[button] < 1) {
+    __glutCurrentWindow->buttonUses++;
+  }
+  __glutCurrentWindow->menu[button] = __glutCurrentMenu->id + 1;
+}
+
+void APIENTRY
+glutDetachMenu(int button)
+{
+  if (__glutMappedMenu) {
+    menuModificationError();
+  }
+  if (__glutCurrentWindow->menu[button] > 0) {
+    __glutCurrentWindow->buttonUses--;
+    __glutCurrentWindow->menu[button] = 0;
+  }
+}
+
diff --git a/src/glut/glx/win32_util.c b/src/glut/glx/win32_util.c
new file mode 100644
index 0000000000..d00a24210b
--- /dev/null
+++ b/src/glut/glx/win32_util.c
@@ -0,0 +1,121 @@
+
+/* Copyright (c) Nate Robins, 1997. */
+
+/* portions Copyright (c) Mark Kilgard, 1997, 1998. */
+
+/* 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 "glutint.h"
+#include "glutstroke.h"
+#include "glutbitmap.h"
+#if defined(__CYGWIN32__)
+typedef MINMAXINFO* LPMINMAXINFO;
+#else
+#include <sys/timeb.h>
+#endif
+
+/* The following added by Paul Garceau <pgarceau@teleport.com> */
+#if defined(__MINGW32__)
+#include <time.h>
+#include <windows.h>
+struct timeval;
+#endif
+
+extern StrokeFontRec glutStrokeRoman, glutStrokeMonoRoman;
+extern BitmapFontRec glutBitmap8By13, glutBitmap9By15, glutBitmapTimesRoman10, glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12, glutBitmapHelvetica18;
+
+int
+gettimeofday(struct timeval* tp, void* tzp)
+{
+  struct timeb tb;
+
+  ftime(&tb);
+  tp->tv_sec = tb.time;
+  tp->tv_usec = tb.millitm * 1000;
+
+  /* 0 indicates that the call succeeded. */
+  return 0;
+}
+
+/* To get around the fact that Microsoft DLLs only allow functions
+   to be exported and now data addresses (as Unix DSOs support), the
+   GLUT API constants such as GLUT_STROKE_ROMAN have to get passed
+   through a case statement to get mapped to the actual data structure
+   address. */
+void*
+__glutFont(void *font)
+{
+  switch((int)font) {
+  case (int)GLUT_STROKE_ROMAN:
+    return &glutStrokeRoman;
+  case (int)GLUT_STROKE_MONO_ROMAN:
+    return &glutStrokeMonoRoman;
+  case (int)GLUT_BITMAP_9_BY_15:
+    return &glutBitmap9By15;
+  case (int)GLUT_BITMAP_8_BY_13:
+    return &glutBitmap8By13;
+  case (int)GLUT_BITMAP_TIMES_ROMAN_10:
+    return &glutBitmapTimesRoman10;
+  case (int)GLUT_BITMAP_TIMES_ROMAN_24:
+    return &glutBitmapTimesRoman24;
+  case (int)GLUT_BITMAP_HELVETICA_10:
+    return &glutBitmapHelvetica10;
+  case (int)GLUT_BITMAP_HELVETICA_12:
+    return &glutBitmapHelvetica12;
+  case (int)GLUT_BITMAP_HELVETICA_18:
+    return &glutBitmapHelvetica18;
+  }
+  __glutFatalError("out of memory.");
+  /* NOTREACHED */
+}
+
+int
+__glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
+{
+  /* the transparent pixel on Win32 is always index number 0.  So if
+     we put this routine in this file, we can avoid compiling the
+     whole of layerutil.c which is where this routine normally comes
+     from. */
+  return 0;
+}
+
+void
+__glutAdjustCoords(Window parent, int* x, int* y, int* width, int* height)
+{
+  RECT rect;
+
+  /* adjust the window rectangle because Win32 thinks that the x, y,
+     width & height are the WHOLE window (including decorations),
+     whereas GLUT treats the x, y, width & height as only the CLIENT
+     area of the window. */
+  rect.left = *x; rect.top = *y;
+  rect.right = *x + *width; rect.bottom = *y + *height;
+
+  /* must adjust the coordinates according to the correct style
+     because depending on the style, there may or may not be
+     borders. */
+  AdjustWindowRect(&rect, WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
+		   (parent ? WS_CHILD : WS_OVERLAPPEDWINDOW),
+		   FALSE);
+  /* FALSE in the third parameter = window has no menu bar */
+
+  /* readjust if the x and y are offscreen */
+  if(rect.left < 0) {
+    *x = 0;
+  } else {
+    *x = rect.left;
+  }
+  
+  if(rect.top < 0) {
+    *y = 0;
+  } else {
+    *y = rect.top;
+  }
+
+  *width = rect.right - rect.left;	/* adjusted width */
+  *height = rect.bottom - rect.top;	/* adjusted height */
+}
+
diff --git a/src/glut/glx/win32_winproc.c b/src/glut/glx/win32_winproc.c
new file mode 100644
index 0000000000..2607a205cd
--- /dev/null
+++ b/src/glut/glx/win32_winproc.c
@@ -0,0 +1,789 @@
+
+/* Copyright (c) Nate Robins, 1997. */
+/* portions Copyright (c) Mark Kilgard, 1997, 1998. */
+
+/* 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 "glutint.h"
+#if defined(__CYGWIN32__)
+typedef MINMAXINFO* LPMINMAXINFO;
+#else
+#include <sys/timeb.h>
+#endif
+
+#ifdef _WIN32
+#include <mmsystem.h>  /* Win32 Multimedia API header. */
+#endif
+
+extern unsigned __glutMenuButton;
+extern GLUTidleCB __glutIdleFunc;
+extern GLUTtimer *__glutTimerList;
+extern void handleTimeouts(void);
+extern GLUTmenuItem *__glutGetUniqueMenuItem(GLUTmenu * menu, int unique);
+static HMENU __glutHMenu;
+
+void
+updateWindowState(GLUTwindow *window, int visState)
+{
+  GLUTwindow* child;
+
+  /* XXX shownState and visState are the same in Win32. */
+  window->shownState = visState;
+  if (visState != window->visState) {
+    if (window->windowStatus) {
+      window->visState = visState;
+      __glutSetWindow(window);
+      window->windowStatus(visState);
+    }
+  }
+  /* Since Win32 only sends an activate for the toplevel window,
+     update the visibility for all the child windows. */
+  child = window->children;
+  while (child) {
+    updateWindowState(child, visState);
+    child = child->siblings;
+  }
+}
+
+LONG WINAPI
+__glutWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{ 
+  POINT         point;			/* Point structure. */
+  PAINTSTRUCT   ps;			/* Paint structure. */
+  LPMINMAXINFO  minmax;			/* Minimum/maximum info structure. */
+  GLUTwindow*   window;			/* GLUT window associated with message. */
+  GLUTmenu*     menu;			/* GLUT menu associated with message. */
+  int x, y, width, height, key;
+  int button = -1;
+
+  switch(msg) {
+  case WM_CREATE:
+    return 0;
+  case WM_CLOSE:
+    if (__glutExitFunc) {
+      __glutExitFunc(0);
+    }
+    exit(0);
+    break;
+#if 0
+  case WM_DESTROY:
+    /* XXX NVidia's NT OpenGL can have problems closing down
+       its OpenGL internal data structures if we just allow
+       the process to terminate without unbinding and deleting
+       the windows context.  Apparently, DirectDraw unloads
+       before OPENGL32.DLL in the close down sequence, but
+       NVidia's NT OpenGL needs DirectDraw to close down its
+       data structures. */
+    window = __glutGetWindow(hwnd);
+    if (window) {
+      if (window->ctx) {
+        wglMakeCurrent(NULL, NULL);
+        wglDeleteContext(window->ctx);
+      }
+    }
+    return 0;
+#endif
+  case WM_PAINT:
+    window = __glutGetWindow(hwnd);
+    if (window) {
+      BeginPaint(hwnd, &ps);		/* Must have this for some Win32 reason. */
+      EndPaint(hwnd, &ps);
+      if (window->win == hwnd) {
+	__glutPostRedisplay(window, GLUT_REPAIR_WORK);
+      } else if (window->overlay && window->overlay->win == hwnd) {
+	__glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
+      }
+    }
+    return 0;
+
+  case WM_SYSKEYUP:
+  case WM_KEYUP:
+    window = __glutGetWindow(hwnd);
+    if (!window) {
+      break;
+    }
+    /* Win32 is dumb and sends these messages only to the parent
+       window.  Therefore, find out if we're in a child window and
+       call the child windows keyboard callback if we are. */
+    if (window->parent) {
+      GetCursorPos(&point);
+      ScreenToClient(hwnd, &point);
+      hwnd = ChildWindowFromPoint(hwnd, point);
+      window = __glutGetWindow(hwnd);
+    }
+    if (window->specialUp || window->keyboardUp) {
+      GetCursorPos(&point);
+      ScreenToClient(window->win, &point);
+      __glutSetWindow(window);
+      __glutModifierMask = 0;
+      if (GetKeyState(VK_SHIFT) < 0)  /* < 0 = high order bit is on */
+	__glutModifierMask |= ShiftMask;
+      if (GetKeyState(VK_SHIFT) < 0)  /* < 0 = high order bit is on */
+	__glutModifierMask |= ControlMask;
+      if (GetKeyState(VK_MENU) < 0)
+	__glutModifierMask |= Mod1Mask;
+      switch (wParam) {
+      /* *INDENT-OFF* */
+      case VK_F1:     key = GLUT_KEY_F1; break;
+      case VK_F2:     key = GLUT_KEY_F2; break;
+      case VK_F3:     key = GLUT_KEY_F3; break;
+      case VK_F4:     key = GLUT_KEY_F4; break;
+      case VK_F5:     key = GLUT_KEY_F5; break;
+      case VK_F6:     key = GLUT_KEY_F6; break;
+      case VK_F7:     key = GLUT_KEY_F7; break;
+      case VK_F8:     key = GLUT_KEY_F8; break;
+      case VK_F9:     key = GLUT_KEY_F9; break;
+      case VK_F10:    key = GLUT_KEY_F10; break;
+      case VK_F11:    key = GLUT_KEY_F11; break;
+      case VK_F12:    key = GLUT_KEY_F12; break;
+      case VK_LEFT:   key = GLUT_KEY_LEFT; break;
+      case VK_UP:     key = GLUT_KEY_UP; break;
+      case VK_RIGHT:  key = GLUT_KEY_RIGHT; break;
+      case VK_DOWN:   key = GLUT_KEY_DOWN; break;
+      case VK_PRIOR:  key = GLUT_KEY_PAGE_UP; break;
+      case VK_NEXT:   key = GLUT_KEY_PAGE_DOWN; break;
+      case VK_HOME:   key = GLUT_KEY_HOME; break;
+      case VK_END:    key = GLUT_KEY_END; break;
+      case VK_INSERT: key = GLUT_KEY_INSERT; break;
+      case VK_DELETE:
+        /* Delete is an ASCII character. */
+	if (window->keyboardUp) {
+	  window->keyboardUp((unsigned char) 127, point.x, point.y);
+	}
+	return 0;
+      /* *INDENT-ON* */
+      default:
+	if (window->keyboardUp) {
+	  key = MapVirtualKey(wParam, 2);  /* Map to ASCII. */
+	  if (isascii(key) && (key != 0)) {
+
+	    /* XXX Attempt to determine modified ASCII character
+	       is quite incomplete.  Digits, symbols, CapsLock,
+	       Ctrl, and numeric keypad are all ignored.  Fix this. */
+
+	    if (!(__glutModifierMask & ShiftMask))
+	      key = tolower(key);
+	    window->keyboardUp((unsigned char) key, point.x, point.y);
+          }
+        }
+	__glutModifierMask = (unsigned int) ~0;
+	return 0;
+      }
+      if (window->specialUp) {
+        window->specialUp(key, point.x, point.y);
+      }
+      __glutModifierMask = (unsigned int) ~0;
+    }
+    return 0;
+
+  case WM_SYSCHAR:
+  case WM_CHAR:
+    window = __glutGetWindow(hwnd);
+    if (!window) {
+      break;
+    }
+
+    /* Bit 30 of lParam is set if key already held down.  If
+       we are ignoring auto repeated key strokes for the window, bail. */
+    if (window->ignoreKeyRepeat && (lParam & (1 << 30)) ) {
+      break;
+    }
+
+    /* Win32 is dumb and sends these messages only to the parent
+       window.  Therefore, find out if we're in a child window and
+       call the child windows keyboard callback if we are. */
+    if (window->parent) {
+	GetCursorPos(&point);
+	ScreenToClient(hwnd, &point);
+	hwnd = ChildWindowFromPoint(hwnd, point);
+	window = __glutGetWindow(hwnd);
+    }
+    if (window->keyboard) {
+      GetCursorPos(&point);
+      ScreenToClient(window->win, &point);
+      __glutSetWindow(window);
+      __glutModifierMask = 0;
+      if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
+	__glutModifierMask |= ShiftMask;
+      if (GetKeyState(VK_CONTROL) < 0)
+	__glutModifierMask |= ControlMask;
+      if (GetKeyState(VK_MENU) < 0)
+	__glutModifierMask |= Mod1Mask;
+      window->keyboard((unsigned char)wParam, point.x, point.y);
+      __glutModifierMask = (unsigned int) ~0;
+    }
+    return 0;
+
+  case WM_SYSKEYDOWN:
+  case WM_KEYDOWN:
+    window = __glutGetWindow(hwnd);
+    if (!window) {
+      break;
+    }
+
+    /* Bit 30 of lParam is set if key already held down.  If
+       we are ignoring auto repeated key strokes for the window, bail. */
+    if (window->ignoreKeyRepeat && (lParam & (1 << 30)) ) {
+      break;
+    }
+
+    /* Win32 is dumb and sends these messages only to the parent
+       window.  Therefore, find out if we're in a child window and
+       call the child windows keyboard callback if we are. */
+    if (window->parent) {
+	GetCursorPos(&point);
+	ScreenToClient(hwnd, &point);
+	hwnd = ChildWindowFromPoint(hwnd, point);
+	window = __glutGetWindow(hwnd);
+    }
+    if (window->special) {
+      switch (wParam) {
+	/* *INDENT-OFF* */
+	/* function keys */
+	case VK_F1:     key = GLUT_KEY_F1; break;
+	case VK_F2:     key = GLUT_KEY_F2; break;
+	case VK_F3:     key = GLUT_KEY_F3; break;
+	case VK_F4:     key = GLUT_KEY_F4; break;
+	case VK_F5:     key = GLUT_KEY_F5; break;
+	case VK_F6:     key = GLUT_KEY_F6; break;
+	case VK_F7:     key = GLUT_KEY_F7; break;
+	case VK_F8:     key = GLUT_KEY_F8; break;
+	case VK_F9:     key = GLUT_KEY_F9; break;
+	case VK_F10:    key = GLUT_KEY_F10; break;
+	case VK_F11:    key = GLUT_KEY_F11; break;
+	case VK_F12:    key = GLUT_KEY_F12; break;
+	/* directional keys */
+	case VK_LEFT:   key = GLUT_KEY_LEFT; break;
+	case VK_UP:     key = GLUT_KEY_UP; break;
+	case VK_RIGHT:  key = GLUT_KEY_RIGHT; break;
+	case VK_DOWN:   key = GLUT_KEY_DOWN; break;
+	/* *INDENT-ON* */
+
+	case VK_PRIOR:
+	  /* VK_PRIOR is Win32's Page Up */
+	  key = GLUT_KEY_PAGE_UP;
+	  break;
+	case VK_NEXT:
+	  /* VK_NEXT is Win32's Page Down */
+	  key = GLUT_KEY_PAGE_DOWN;
+	  break;
+	case VK_HOME:
+	  key = GLUT_KEY_HOME;
+	  break;
+	case VK_END:
+	  key = GLUT_KEY_END;
+	  break;
+	case VK_INSERT:
+	  key = GLUT_KEY_INSERT;
+	  break;
+        case VK_DELETE:
+	  goto handleDelete;
+	default:
+	  goto defproc;
+      }
+      GetCursorPos(&point);
+      ScreenToClient(window->win, &point);
+      __glutSetWindow(window);
+      __glutModifierMask = 0;
+      if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
+	__glutModifierMask |= ShiftMask;
+      if (GetKeyState(VK_CONTROL) < 0)
+	__glutModifierMask |= ControlMask;
+      if (GetKeyState(VK_MENU) < 0)
+	__glutModifierMask |= Mod1Mask;
+      window->special(key, point.x, point.y);
+      __glutModifierMask = (unsigned int) ~0;
+    } else if (window->keyboard) {
+      /* Specially handle any keys that match ASCII values but
+         do not generate Windows WM_SYSCHAR or WM_CHAR messages. */
+      switch (wParam) {
+      case VK_DELETE:
+      handleDelete:
+        /* Delete is an ASCII character. */
+        GetCursorPos(&point);
+        ScreenToClient(window->win, &point);
+        __glutSetWindow(window);
+        __glutModifierMask = 0;
+        if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
+          __glutModifierMask |= ShiftMask;
+        if (GetKeyState(VK_CONTROL) < 0)
+          __glutModifierMask |= ControlMask;
+        if (GetKeyState(VK_MENU) < 0)
+          __glutModifierMask |= Mod1Mask;
+	window->keyboard((unsigned char) 127, point.x, point.y);
+        __glutModifierMask = (unsigned int) ~0;
+	return 0;
+      default:
+        /* Let the following WM_SYSCHAR or WM_CHAR message generate
+	   the keyboard callback. */
+        break;
+      }
+    }
+    return 0;
+
+  case WM_LBUTTONDOWN:
+    button = GLUT_LEFT_BUTTON;
+  case WM_MBUTTONDOWN:
+    if (button < 0)
+      button = GLUT_MIDDLE_BUTTON;
+  case WM_RBUTTONDOWN:
+    if (button < 0)
+      button = GLUT_RIGHT_BUTTON;
+    
+    /* finish the menu if we get a button down message (user must have
+       cancelled the menu). */
+    if (__glutMappedMenu) {
+      /* TODO: take this out once the menu on middle mouse stuff works
+	 properly. */
+      if (button == GLUT_MIDDLE_BUTTON)
+	return 0;
+      GetCursorPos(&point);
+      ScreenToClient(hwnd, &point);
+      __glutItemSelected = NULL;
+      __glutFinishMenu(hwnd, point.x, point.y);
+      return 0;
+    }
+
+    /* set the capture so we can get mouse events outside the window */
+    SetCapture(hwnd);
+
+    /* Win32 doesn't return the same numbers as X does when the mouse
+       goes beyond the upper or left side of the window.  roll the
+       Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
+    x = LOWORD(lParam);
+    y = HIWORD(lParam);
+    if(x & 1 << 15) x -= (1 << 16);
+    if(y & 1 << 15) y -= (1 << 16);
+	
+    window = __glutGetWindow(hwnd);
+    if (window) {
+      menu = __glutGetMenuByNum(window->menu[button]);
+      if (menu) {
+	point.x = LOWORD(lParam); point.y = HIWORD(lParam);
+	ClientToScreen(window->win, &point);
+	__glutMenuButton = button == GLUT_RIGHT_BUTTON ? TPM_RIGHTBUTTON :
+                           button == GLUT_LEFT_BUTTON  ? TPM_LEFTBUTTON :
+                           0x0001;
+	__glutStartMenu(menu, window, point.x, point.y, x, y);
+      } else if (window->mouse) {
+	
+        __glutSetWindow(window);
+	__glutModifierMask = 0;
+	if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on. */
+	  __glutModifierMask |= ShiftMask;
+	if (GetKeyState(VK_CONTROL) < 0)
+	  __glutModifierMask |= ControlMask;
+	if (GetKeyState(VK_MENU) < 0)
+	  __glutModifierMask |= Mod1Mask;
+	window->mouse(button, GLUT_DOWN, x, y);
+	__glutModifierMask = (unsigned int)~0;
+      } else {
+	/* Stray mouse events.  Ignore. */
+      }
+    }
+    return 0;
+
+  case WM_LBUTTONUP:
+    button = GLUT_LEFT_BUTTON;
+  case WM_MBUTTONUP:
+    if (button < 0)
+      button = GLUT_MIDDLE_BUTTON;
+  case WM_RBUTTONUP:
+    if (button < 0)
+      button = GLUT_RIGHT_BUTTON;
+
+    /* Bail out if we're processing a menu. */
+    if (__glutMappedMenu) {
+      GetCursorPos(&point);
+      ScreenToClient(hwnd, &point);
+      /* if we're getting the middle button up signal, then something
+	 on the menu was selected. */
+      if (button == GLUT_MIDDLE_BUTTON) {
+	return 0;
+	/* For some reason, the code below always returns -1 even
+	   though the point IS IN THE ITEM!  Therefore, just bail out if
+	   we get a middle mouse up.  The user must select using the
+	   left mouse button.  Stupid Win32. */
+#if 0
+ 	int item = MenuItemFromPoint(hwnd, __glutHMenu, point);
+ 	if (item != -1)
+ 	  __glutItemSelected = (GLUTmenuItem*)GetMenuItemID(__glutHMenu, item);
+ 	else
+ 	  __glutItemSelected = NULL;
+ 	__glutFinishMenu(hwnd, point.x, point.y);
+#endif
+      } else {
+	__glutItemSelected = NULL;
+	__glutFinishMenu(hwnd, point.x, point.y);
+      }
+      return 0;
+    }
+
+    /* Release the mouse capture. */
+    ReleaseCapture();
+
+    window = __glutGetWindow(hwnd);
+    if (window && window->mouse) {
+      /* Win32 doesn't return the same numbers as X does when the
+	 mouse goes beyond the upper or left side of the window.  roll
+	 the Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
+      x = LOWORD(lParam);
+      y = HIWORD(lParam);
+      if(x & 1 << 15) x -= (1 << 16);
+      if(y & 1 << 15) y -= (1 << 16);
+      
+      __glutSetWindow(window);
+      __glutModifierMask = 0;
+      if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
+	__glutModifierMask |= ShiftMask;
+      if (GetKeyState(VK_CONTROL) < 0)
+	__glutModifierMask |= ControlMask;
+      if (GetKeyState(VK_MENU) < 0)
+	__glutModifierMask |= Mod1Mask;
+      window->mouse(button, GLUT_UP, x, y);
+      __glutModifierMask = (unsigned int)~0;
+    } else {
+      /* Window might have been destroyed and all the 
+	 events for the window may not yet be received. */
+    }
+    return 0;
+
+  case WM_ENTERMENULOOP:
+    /* KLUDGE: create a timer that fires every 100 ms when we start a
+       menu so that we can still process the idle & timer events (that
+       way, the timers will fire during a menu pick and so will the
+       idle func. */
+    SetTimer(hwnd, 1, 1, NULL);
+    return 0;
+
+  case WM_TIMER:
+#if 0
+    /* If the timer id is 2, then this is the timer that is set up in
+       the main glut message processing loop, and we don't want to do
+       anything but acknowledge that we got it.  It is used to prevent
+       CPU spiking when an idle function is installed. */
+    if (wParam == 2)
+      return 0;
+#endif
+
+    /* only worry about the idle function and the timeouts, since
+       these are the only events we expect to process during
+       processing of a menu. */
+    /* we no longer process the idle functions (as outlined in the
+       README), since drawing can't be done until the menu has
+       finished...it's pretty lame when the animation goes on, but
+       doesn't update, so you get this weird jerkiness. */
+#if 0    
+     if (__glutIdleFunc)
+       __glutIdleFunc();
+#endif
+    if (__glutTimerList)
+      handleTimeouts();
+    return 0;
+
+  case WM_EXITMENULOOP:
+    /* nuke the above created timer...we don't need it anymore, since
+       the menu is gone now. */
+    KillTimer(hwnd, 1);
+    return 0;
+
+  case WM_MENUSELECT:
+    if (lParam != 0)
+      __glutHMenu = (HMENU)lParam;
+    return 0;
+
+  case WM_COMMAND:
+    if (__glutMappedMenu) {
+      if (GetSubMenu(__glutHMenu, LOWORD(wParam)))
+	__glutItemSelected = NULL;
+      else
+	__glutItemSelected = 
+	  __glutGetUniqueMenuItem(__glutMappedMenu, LOWORD(wParam));
+      GetCursorPos(&point);
+      ScreenToClient(hwnd, &point);
+      __glutFinishMenu(hwnd, point.x, point.y);
+    } 
+    return 0;
+
+  case WM_MOUSEMOVE:
+    if (!__glutMappedMenu) {
+      window = __glutGetWindow(hwnd);
+      if (window) {
+          /* If motion function registered _and_ buttons held *
+             down, call motion function...  */
+	x = LOWORD(lParam);
+	y = HIWORD(lParam);
+
+	/* Win32 doesn't return the same numbers as X does when the
+	   mouse goes beyond the upper or left side of the window.
+	   roll the Win32's 0..2^16 pointer co-ord range to 0..+/-2^15. */
+	if(x & 1 << 15) x -= (1 << 16);
+	if(y & 1 << 15) y -= (1 << 16);
+
+	if (window->motion && wParam &
+            (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
+	  __glutSetWindow(window);
+	  window->motion(x, y);
+	}
+	/* If passive motion function registered _and_
+	   buttons not held down, call passive motion
+	   function...  */
+	else if (window->passive &&
+		 ((wParam &
+		   (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) ==
+		  0)) {
+	  __glutSetWindow(window);
+	  window->passive(x, y);
+	}
+      }
+    } else {
+      /* Motion events are thrown away when a pop up menu is
+	 active. */
+    }
+    return 0;
+
+  case WM_GETMINMAXINFO:
+    /* this voodoo is brought to you by Win32 (again).  It allows the
+       window to be bigger than the screen, and smaller than 100x100
+       (although it doesn't seem to help the y minimum). */
+    minmax = (LPMINMAXINFO)lParam;
+    minmax->ptMaxSize.x = __glutScreenWidth;
+    minmax->ptMaxSize.y = __glutScreenHeight;
+    minmax->ptMinTrackSize.x = 0;
+    minmax->ptMinTrackSize.y = 0;
+    minmax->ptMaxTrackSize.x = __glutScreenWidth + 
+      GetSystemMetrics(SM_CXSIZE) * 2;
+    minmax->ptMaxTrackSize.y = __glutScreenHeight + 
+      GetSystemMetrics(SM_CXSIZE) * 2 + GetSystemMetrics(SM_CYCAPTION);
+    return 0;
+
+  case WM_SIZE:
+    window = __glutGetWindow(hwnd);
+    if (window) {
+      width = LOWORD(lParam);
+      height = HIWORD(lParam);
+      if (width != window->width || height != window->height) {
+#if 0  /* Win32 GLUT does not support overlays for now. */
+ 	if (window->overlay) {
+ 	  XResizeWindow(__glutDisplay, window->overlay->win, width, height);
+ 	}
+#endif
+	window->width = width;
+	window->height = height;
+	__glutSetWindow(window);
+	/* Do not execute OpenGL out of sequence with respect
+	   to the SetWindowPos request! */
+	GdiFlush();
+	window->reshape(width, height);
+	window->forceReshape = FALSE;
+	/* A reshape should be considered like posting a
+	   repair request. */
+	__glutPostRedisplay(window, GLUT_REPAIR_WORK);
+      }
+    }
+    return 0;
+
+  case WM_SETCURSOR:
+    /* If the cursor is not in the client area, then we want to send
+       this message to the default window procedure ('cause its
+       probably in the border or title, and we don't handle that
+       cursor.  otherwise, set our cursor.  Win32 makes us set the
+       cursor every time the mouse moves (DUMB!). */
+    if(LOWORD(lParam) != HTCLIENT) {
+      goto defproc;
+    }
+    window = __glutGetWindow(hwnd);
+    if (window) {
+      __glutSetCursor(window);
+    }
+    /* TODO: check out the info in DevStudio on WM_SETCURSOR in the
+       DefaultAction section. */
+    return 1;
+
+  case WM_SETFOCUS:
+    window = __glutGetWindow(hwnd);
+    if (window) {
+      window->entryState = WM_SETFOCUS;
+      if (window->entry) {
+	__glutSetWindow(window);
+	window->entry(GLUT_ENTERED);
+	/* XXX Generation of fake passive notify?  See how much
+	   work the X11 code does to support fake passive notify
+	   callbacks. */
+      }
+      if (window->joystick && __glutCurrentWindow) {
+        if (__glutCurrentWindow->joyPollInterval > 0) {
+	  MMRESULT result;
+
+	  /* Because Win32 will only let one window capture the
+	     joystick at a time, we must capture it when we get the
+	     focus and release it when we lose the focus. */
+	  result = joySetCapture(__glutCurrentWindow->win,
+	    JOYSTICKID1, 0, TRUE);
+	  if (result != JOYERR_NOERROR) {
+	    return 0;
+          }
+	  (void) joySetThreshold(JOYSTICKID1,
+            __glutCurrentWindow->joyPollInterval);
+        }
+      }
+    }
+    return 0;
+
+  case WM_KILLFOCUS:
+    window = __glutGetWindow(hwnd);
+    if (window) {
+      window->entryState = WM_KILLFOCUS;
+      if (window->entry) {
+	__glutSetWindow(window);
+	window->entry(GLUT_LEFT);
+      }
+      if (window->joystick && __glutCurrentWindow) {
+	if (__glutCurrentWindow->joyPollInterval > 0) {
+	  /* Because Win32 will only let one window capture the
+	     joystick at a time, we must capture it when we get the
+	     focus and release it when we lose the focus. */
+	    (void) joyReleaseCapture(JOYSTICKID1);
+        }
+      }
+    }
+    return 0;
+  case WM_ACTIVATE:
+    window = __glutGetWindow(hwnd);
+    /* Make sure we re-select the correct palette if needed. */
+    if (LOWORD(wParam)) {
+      PostMessage(hwnd, WM_PALETTECHANGED, 0, 0);
+    }
+    if (window) {
+      int visState;
+
+      /* HIWORD(wParam) is the minimized flag. */
+      visState = !HIWORD(wParam);
+      updateWindowState(window, visState);
+    }
+    return 0;
+
+  /* Colour Palette Management */
+  case WM_PALETTECHANGED:
+    if (hwnd == (HWND)wParam) {
+      /* Don't respond to the message that we sent! */
+      break;
+    }
+    /* fall through to WM_QUERYNEWPALETTE */
+
+  case WM_QUERYNEWPALETTE:
+    window = __glutGetWindow(hwnd);
+    if (window && window->colormap) {
+      UnrealizeObject(window->colormap->cmap);
+      SelectPalette(window->hdc, window->colormap->cmap, FALSE);
+      RealizePalette(window->hdc);
+      return TRUE;
+    }
+    return FALSE;
+
+  case MM_JOY1MOVE:
+  case MM_JOY1ZMOVE:
+    window = __glutGetWindow(hwnd);
+    if (window->joystick) {
+      JOYINFOEX jix;
+      int x, y, z;
+
+      /* Because WIN32 only supports messages for X, Y, and Z
+         translations, we must poll for the rest */
+      jix.dwSize = sizeof(jix);
+      jix.dwFlags = JOY_RETURNALL;
+      joyGetPosEx(JOYSTICKID1,&jix);
+
+#define SCALE(v)  ((int) ((v - 32767)/32.768))
+
+      /* Convert to integer for scaling. */
+      x = jix.dwXpos;
+      y = jix.dwYpos;
+      z = jix.dwZpos;
+      window->joystick(jix.dwButtons, SCALE(x), SCALE(y), SCALE(z));
+
+      return TRUE;
+    }
+    return FALSE;
+  case MM_JOY1BUTTONDOWN:
+  case MM_JOY1BUTTONUP:
+    window = __glutGetWindow(hwnd);
+    if (window->joystick) {
+      JOYINFOEX jix;
+
+      /* Because WIN32 only supports messages for X, Y, and Z
+         translations, we must poll for the rest */
+      jix.dwSize = sizeof(jix);
+      jix.dwFlags = JOY_RETURNALL;
+      joyGetPosEx(JOYSTICKID1,&jix);
+
+      return TRUE;
+    }
+    return FALSE;
+
+#if 0
+  /* Miscellaneous messages (don't really need to enumerate them,
+     but it's good to know what you're not getting sometimes). */
+  case WM_DISPLAYCHANGE:
+    break;
+  case WM_NCHITTEST:
+    /* This event is generated by every mouse move event. */
+    goto defproc;
+  case WM_NCMOUSEMOVE:
+    goto defproc;
+  case WM_NCACTIVATE:
+    goto defproc;
+  case WM_NCPAINT:
+    goto defproc;
+  case WM_NCCALCSIZE:
+    goto defproc;
+  case WM_NCCREATE:
+    goto defproc;
+  case WM_NCDESTROY:
+    goto defproc;
+  case WM_NCLBUTTONDOWN:
+    goto defproc;
+  case WM_SETTEXT:
+    goto defproc;
+  case WM_GETTEXT:
+    goto defproc;
+  case WM_ACTIVATEAPP:
+    goto defproc;
+  case WM_GETICON:
+    goto defproc;
+  case WM_ERASEBKGND:
+    goto defproc;
+  case WM_WINDOWPOSCHANGING:
+    goto defproc;
+  case WM_WINDOWPOSCHANGED:
+    goto defproc;
+  case WM_MOUSEACTIVATE:
+    goto defproc;
+  case WM_SHOWWINDOW:
+    goto defproc;
+  case WM_MOVING:
+    goto defproc;
+  case WM_MOVE:
+    goto defproc;
+  case WM_KEYUP:
+    goto defproc;
+  case WM_CAPTURECHANGED:
+    goto defproc;
+  case WM_SYSCOMMAND:
+    goto defproc;
+  case WM_ENTERSIZEMOVE:
+    goto defproc;
+  case WM_ENTERIDLE:
+    goto defproc;
+#endif
+
+  default: 
+    goto defproc;
+  }
+
+defproc:    
+  return DefWindowProc(hwnd, msg, wParam, lParam); 
+} 
diff --git a/src/glut/glx/win32_x11.c b/src/glut/glx/win32_x11.c
new file mode 100644
index 0000000000..1d138cfa2a
--- /dev/null
+++ b/src/glut/glx/win32_x11.c
@@ -0,0 +1,400 @@
+
+/* Copyright (c) Nate Robins, 1997. */
+/* portions Copyright (c) Mark Kilgard, 1998. */
+
+/* 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 "glutint.h"
+
+/* global variable that must be set for some functions to operate
+   correctly. */
+HDC XHDC;
+
+XVisualInfo*
+XGetVisualInfo(Display* display, long mask, XVisualInfo* template, int* nitems)
+{
+  /* KLUDGE: this function needs XHDC to be set to the HDC currently
+     being operated on before it is invoked! */
+
+  PIXELFORMATDESCRIPTOR* pfds;
+  int i, n;
+
+  n = DescribePixelFormat(XHDC, 0, 0, NULL);
+  pfds = (PIXELFORMATDESCRIPTOR*)malloc(sizeof(PIXELFORMATDESCRIPTOR) * n);
+  memset(pfds, 0, sizeof(PIXELFORMATDESCRIPTOR) * n);
+  
+  for (i = 0; i < n; i++) {
+    DescribePixelFormat(XHDC, i + 1, sizeof(PIXELFORMATDESCRIPTOR), &pfds[i]);
+  }
+
+  *nitems = n;
+  return pfds;
+}
+
+Colormap
+XCreateColormap(Display* display, Window root, Visual* visual, int alloc)
+{
+  /* KLUDGE: this function needs XHDC to be set to the HDC currently
+     being operated on before it is invoked! */
+
+  PIXELFORMATDESCRIPTOR pfd;
+  LOGPALETTE *logical;
+  HPALETTE    palette;
+  int n;
+
+  /* grab the pixel format */
+  memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
+  DescribePixelFormat(XHDC, GetPixelFormat(XHDC), 
+		      sizeof(PIXELFORMATDESCRIPTOR), &pfd);
+
+  if (!(pfd.dwFlags & PFD_NEED_PALETTE ||
+      pfd.iPixelType == PFD_TYPE_COLORINDEX))
+  {
+    return 0;
+  }
+
+  n = 1 << pfd.cColorBits;
+
+  /* allocate a bunch of memory for the logical palette (assume 256
+     colors in a Win32 palette */
+  logical = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
+				sizeof(PALETTEENTRY) * n);
+  memset(logical, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
+
+  /* set the entries in the logical palette */
+  logical->palVersion = 0x300;
+  logical->palNumEntries = n;
+
+  /* start with a copy of the current system palette */
+  GetSystemPaletteEntries(XHDC, 0, 256, &logical->palPalEntry[0]);
+    
+  if (pfd.iPixelType == PFD_TYPE_RGBA) {
+    int redMask = (1 << pfd.cRedBits) - 1;
+    int greenMask = (1 << pfd.cGreenBits) - 1;
+    int blueMask = (1 << pfd.cBlueBits) - 1;
+    int i;
+
+    /* fill in an RGBA color palette */
+    for (i = 0; i < n; ++i) {
+      logical->palPalEntry[i].peRed = 
+	(((i >> pfd.cRedShift)   & redMask)   * 255) / redMask;
+      logical->palPalEntry[i].peGreen = 
+	(((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
+	logical->palPalEntry[i].peBlue = 
+	(((i >> pfd.cBlueShift)  & blueMask)  * 255) / blueMask;
+      logical->palPalEntry[i].peFlags = 0;
+    }
+  }
+
+  palette = CreatePalette(logical);
+  free(logical);
+
+  SelectPalette(XHDC, palette, FALSE);
+  RealizePalette(XHDC);
+
+  return palette;
+}
+
+void
+XAllocColorCells(Display* display, Colormap colormap, Bool contig, 
+		 unsigned long plane_masks_return[], unsigned int nplanes,
+		 unsigned long pixels_return[], unsigned int npixels)
+{
+  /* NOP -- we did all the allocating in XCreateColormap! */
+}
+
+void
+XStoreColor(Display* display, Colormap colormap, XColor* color)
+{
+  /* KLUDGE: set XHDC to 0 if the palette should NOT be realized after
+     setting the color.  set XHDC to the correct HDC if it should. */
+
+  PALETTEENTRY pe;
+
+  /* X11 stores color from 0-65535, Win32 expects them to be 0-256, so
+     twiddle the bits ( / 256). */
+  pe.peRed = color->red / 256;
+  pe.peGreen = color->green / 256;
+  pe.peBlue = color->blue / 256;
+
+  /* make sure we use this flag, otherwise the colors might get mapped
+     to another place in the colormap, and when we glIndex() that
+     color, it may have moved (argh!!) */
+  pe.peFlags = PC_NOCOLLAPSE;
+
+  /* the pixel field of the XColor structure is the index into the
+     colormap */
+  SetPaletteEntries(colormap, color->pixel, 1, &pe);
+
+  if (XHDC) {
+    UnrealizeObject(colormap);
+    SelectPalette(XHDC, colormap, FALSE);
+    RealizePalette(XHDC);
+  }
+}
+
+void
+XSetWindowColormap(Display* display, Window window, Colormap colormap)
+{
+  HDC hdc = GetDC(window);
+
+  /* if the third parameter is FALSE, the logical colormap is copied
+     into the device palette when the application is in the
+     foreground, if it is TRUE, the colors are mapped into the current
+     palette in the best possible way. */
+  SelectPalette(hdc, colormap, FALSE);
+  RealizePalette(hdc);
+
+  /* note that we don't have to release the DC, since our window class
+     uses the WC_OWNDC flag! */
+}
+
+Bool
+XTranslateCoordinates(Display *display, Window src, Window dst, 
+		      int src_x, int src_y, 
+		      int* dest_x_return, int* dest_y_return,
+		      Window* child_return)
+{
+  /* KLUDGE: this isn't really a translate coordinates into some other
+  windows coordinate system...it only translates coordinates into the
+  root window (screen) coordinate system. */
+
+  POINT point;
+
+  point.x = src_x;
+  point.y = src_y;
+
+  ClientToScreen(src, &point);
+
+  *dest_x_return = point.x;
+  *dest_y_return = point.y;
+
+  /* just to make compilers happy...we don't use the return value. */
+  return True;
+}
+
+Status
+XGetGeometry(Display* display, Window window, Window* root_return, 
+	     int* x_return, int* y_return, 
+	     unsigned int* width_return, unsigned int* height_return,
+	     unsigned int *border_width_return, unsigned int* depth_return)
+{
+  /* KLUDGE: doesn't return the border_width or depth or root, x & y
+     are in screen coordinates. */
+
+  RECT rect;
+  POINT point;
+
+  GetClientRect(window, &rect);
+
+  point.x = 0;
+  point.y = 0;
+  ClientToScreen(window, &point);
+
+  *x_return = point.x;
+  *y_return = point.y;
+  *width_return = rect.right;
+  *height_return = rect.bottom;
+
+  /* just to make compilers happy...we don't use the return value. */
+  return 1;  
+}
+
+int
+DisplayWidthMM(Display* display, int screen)
+{
+  int width;
+  HWND hwnd = GetDesktopWindow();
+  HDC hdc = GetDC(hwnd);
+  
+  width = GetDeviceCaps(hdc, HORZSIZE);
+
+  /* make sure to release this DC (it's the desktops, not ours) */
+  ReleaseDC(hwnd, hdc);
+
+  return width;
+}
+
+int
+DisplayHeightMM(Display* display, int screen)
+{
+  int height;
+  HWND hwnd = GetDesktopWindow();
+  HDC hdc = GetDC(hwnd);
+  
+  height = GetDeviceCaps(hdc, VERTSIZE);
+
+  /* make sure to release this DC (it's the desktops, not ours) */
+  ReleaseDC(hwnd, hdc);
+
+  return height;
+}
+
+void
+XWarpPointer(Display* display, Window src, Window dst, 
+	     int src_x, int src_y, int src_width, int src_height,
+	     int dst_x, int dst_y)
+{
+  /* KLUDGE: this isn't really a warp pointer into some other windows
+  coordinate system...it only warps the pointer into the root window
+  (screen) coordinate system. */
+
+  POINT point;
+
+  point.x = dst_x;
+  point.y = dst_y;
+  ClientToScreen(dst, &point);
+
+  SetCursorPos(point.x, point.y);
+}
+
+int
+XPending(Display* display)
+{
+  /* similar functionality...I don't think that it is exact, but this
+     will have to do. */
+  MSG msg;
+
+  return PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
+}
+
+/* the following function was stolen from the X sources as indicated. */
+
+/* Copyright 	Massachusetts Institute of Technology  1985, 1986, 1987 */
+/* $XConsortium: XParseGeom.c,v 11.18 91/02/21 17:23:05 rws Exp $ */
+
+/*
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation, and that the name of M.I.T. not be used in advertising or
+publicity pertaining to distribution of the software without specific,
+written prior permission.  M.I.T. makes no representations about the
+suitability of this software for any purpose.  It is provided "as is"
+without express or implied warranty.
+*/
+
+/*
+ *    XParseGeometry parses strings of the form
+ *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
+ *   width, height, xoffset, and yoffset are unsigned integers.
+ *   Example:  "=80x24+300-49"
+ *   The equal sign is optional.
+ *   It returns a bitmask that indicates which of the four values
+ *   were actually found in the string.  For each value found,
+ *   the corresponding argument is updated;  for each value
+ *   not found, the corresponding argument is left unchanged. 
+ */
+
+static int
+ReadInteger(char *string, char **NextString)
+{
+    register int Result = 0;
+    int Sign = 1;
+    
+    if (*string == '+')
+	string++;
+    else if (*string == '-')
+    {
+	string++;
+	Sign = -1;
+    }
+    for (; (*string >= '0') && (*string <= '9'); string++)
+    {
+	Result = (Result * 10) + (*string - '0');
+    }
+    *NextString = string;
+    if (Sign >= 0)
+	return (Result);
+    else
+	return (-Result);
+}
+
+int XParseGeometry(char *string, int *x, int *y, unsigned int *width, unsigned int *height)
+{
+	int mask = NoValue;
+	register char *strind;
+	unsigned int tempWidth, tempHeight;
+	int tempX, tempY;
+	char *nextCharacter;
+
+	if ( (string == NULL) || (*string == '\0')) return(mask);
+	if (*string == '=')
+		string++;  /* ignore possible '=' at beg of geometry spec */
+
+	strind = (char *)string;
+	if (*strind != '+' && *strind != '-' && *strind != 'x') {
+		tempWidth = ReadInteger(strind, &nextCharacter);
+		if (strind == nextCharacter) 
+		    return (0);
+		strind = nextCharacter;
+		mask |= WidthValue;
+	}
+
+	if (*strind == 'x' || *strind == 'X') {	
+		strind++;
+		tempHeight = ReadInteger(strind, &nextCharacter);
+		if (strind == nextCharacter)
+		    return (0);
+		strind = nextCharacter;
+		mask |= HeightValue;
+	}
+
+	if ((*strind == '+') || (*strind == '-')) {
+		if (*strind == '-') {
+  			strind++;
+			tempX = -ReadInteger(strind, &nextCharacter);
+			if (strind == nextCharacter)
+			    return (0);
+			strind = nextCharacter;
+			mask |= XNegative;
+
+		}
+		else
+		{	strind++;
+			tempX = ReadInteger(strind, &nextCharacter);
+			if (strind == nextCharacter)
+			    return(0);
+			strind = nextCharacter;
+		}
+		mask |= XValue;
+		if ((*strind == '+') || (*strind == '-')) {
+			if (*strind == '-') {
+				strind++;
+				tempY = -ReadInteger(strind, &nextCharacter);
+				if (strind == nextCharacter)
+			    	    return(0);
+				strind = nextCharacter;
+				mask |= YNegative;
+
+			}
+			else
+			{
+				strind++;
+				tempY = ReadInteger(strind, &nextCharacter);
+				if (strind == nextCharacter)
+			    	    return(0);
+				strind = nextCharacter;
+			}
+			mask |= YValue;
+		}
+	}
+	
+	/* If strind isn't at the end of the string the it's an invalid
+		geometry specification. */
+
+	if (*strind != '\0') return (0);
+
+	if (mask & XValue)
+	    *x = tempX;
+ 	if (mask & YValue)
+	    *y = tempY;
+	if (mask & WidthValue)
+            *width = tempWidth;
+	if (mask & HeightValue)
+            *height = tempHeight;
+	return (mask);
+}
diff --git a/src/glut/glx/win32_x11.h b/src/glut/glx/win32_x11.h
new file mode 100644
index 0000000000..bb49977316
--- /dev/null
+++ b/src/glut/glx/win32_x11.h
@@ -0,0 +1,319 @@
+#ifndef __win32_x11_h__
+#define __win32_x11_h__
+
+/* Copyright (c) Nate Robins, 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 <windows.h>
+
+/* Type definitions (conversions) */
+typedef int Visual;			/* Win32 equivalent of X11 type */
+typedef HWND Window;
+typedef HPALETTE Colormap;
+typedef PIXELFORMATDESCRIPTOR XVisualInfo;
+typedef BOOL Bool;
+typedef MSG XEvent;
+typedef HDC Display;
+typedef HCURSOR Cursor;
+
+typedef int Atom;			/* dummies */
+typedef int XDevice;
+typedef int Status;
+
+#define True  TRUE			/* Win32 equivalents of X11 booleans */
+#define False FALSE
+
+#define None                 0L	/* universal null resource or null atom */
+
+/* Input Event Masks. Used as event-mask window attribute and as arguments
+   to Grab requests.  Not to be confused with event names.  */
+
+#define NoEventMask			0L
+#define KeyPressMask			(1L<<0)  
+#define KeyReleaseMask			(1L<<1)  
+#define ButtonPressMask			(1L<<2)  
+#define ButtonReleaseMask		(1L<<3)  
+#define EnterWindowMask			(1L<<4)  
+#define LeaveWindowMask			(1L<<5)  
+#define PointerMotionMask		(1L<<6)  
+#define PointerMotionHintMask		(1L<<7)  
+#define Button1MotionMask		(1L<<8)  
+#define Button2MotionMask		(1L<<9)  
+#define Button3MotionMask		(1L<<10) 
+#define Button4MotionMask		(1L<<11) 
+#define Button5MotionMask		(1L<<12) 
+#define ButtonMotionMask		(1L<<13) 
+#define KeymapStateMask			(1L<<14)
+#define ExposureMask			(1L<<15) 
+#define VisibilityChangeMask		(1L<<16) 
+#define StructureNotifyMask		(1L<<17) 
+#define ResizeRedirectMask		(1L<<18) 
+#define SubstructureNotifyMask		(1L<<19) 
+#define SubstructureRedirectMask	(1L<<20) 
+#define FocusChangeMask			(1L<<21) 
+#define PropertyChangeMask		(1L<<22) 
+#define ColormapChangeMask		(1L<<23) 
+#define OwnerGrabButtonMask		(1L<<24) 
+
+/* Key masks. Used as modifiers to GrabButton and GrabKey, results of
+   QueryPointer, state in various key-, mouse-, and button-related
+   events. */
+
+#define ShiftMask		(1<<0)
+#define LockMask		(1<<1)
+#define ControlMask		(1<<2)
+#define Mod1Mask		(1<<3)
+#define Mod2Mask		(1<<4)
+#define Mod3Mask		(1<<5)
+#define Mod4Mask		(1<<6)
+#define Mod5Mask		(1<<7)
+
+/* Window classes used by CreateWindow */
+/* Note that CopyFromParent is already defined as 0 above */
+
+#define InputOutput		1
+#define InputOnly		2
+
+/* Window attributes for CreateWindow and ChangeWindowAttributes */
+
+#define CWBackPixmap		(1L<<0)
+#define CWBackPixel		(1L<<1)
+#define CWBorderPixmap		(1L<<2)
+#define CWBorderPixel           (1L<<3)
+#define CWBitGravity		(1L<<4)
+#define CWWinGravity		(1L<<5)
+#define CWBackingStore          (1L<<6)
+#define CWBackingPlanes	        (1L<<7)
+#define CWBackingPixel	        (1L<<8)
+#define CWOverrideRedirect	(1L<<9)
+#define CWSaveUnder		(1L<<10)
+#define CWEventMask		(1L<<11)
+#define CWDontPropagate	        (1L<<12)
+#define CWColormap		(1L<<13)
+#define CWCursor	        (1L<<14)
+
+/* ConfigureWindow structure */
+
+#define CWX			(1<<0)
+#define CWY			(1<<1)
+#define CWWidth			(1<<2)
+#define CWHeight		(1<<3)
+#define CWBorderWidth		(1<<4)
+#define CWSibling		(1<<5)
+#define CWStackMode		(1<<6)
+
+
+/* Used in GetWindowAttributes reply */
+
+#define IsUnmapped		0
+#define IsUnviewable		1
+#define IsViewable		2
+
+/* Window stacking method (in configureWindow) */
+
+#define Above                   0
+#define Below                   1
+#define TopIf                   2
+#define BottomIf                3
+#define Opposite                4
+
+/* For CreateColormap */
+
+#define AllocNone		0	/* create map with no entries */
+#define AllocAll		1	/* allocate entire map writeable */
+
+
+/* Flags used in StoreNamedColor, StoreColors */
+
+#define DoRed			(1<<0)
+#define DoGreen			(1<<1)
+#define DoBlue			(1<<2)
+
+/* 
+ * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding
+ * value (x, y, width, height) was found in the parsed string.
+ */
+#define NoValue		0x0000
+#define XValue  	0x0001
+#define YValue		0x0002
+#define WidthValue  	0x0004
+#define HeightValue  	0x0008
+#define AllValues 	0x000F
+#define XNegative 	0x0010
+#define YNegative 	0x0020
+
+/* flags argument in size hints */
+#define USPosition	(1L << 0) /* user specified x, y */
+#define USSize		(1L << 1) /* user specified width, height */
+
+/* definitions for initial window state */
+#define WithdrawnState 0	/* for windows that are not mapped */
+#define NormalState 1	/* most applications want to start this way */
+#define IconicState 3	/* application wants to start as an icon */
+#define GameModeState 4  /* Win32 GLUT only (not in Xlib!). */
+
+/* Type definitions */
+
+typedef struct {
+    unsigned int background_pixmap;	/* background pixmap */
+    unsigned long background_pixel;	/* background pixel */
+    unsigned long border_pixel;	/* border pixel value */
+    long event_mask;		/* set of events that should be saved */
+    long do_not_propagate_mask;	/* set of events that should not propagate */
+    Bool override_redirect;	   /* boolean value for override-redirect */
+    Colormap colormap;		   /* color map to be associated with window */
+} XSetWindowAttributes;
+
+typedef struct {
+  unsigned long pixel;
+  unsigned short red, green, blue;
+  char flags;  /* do_red, do_green, do_blue */
+} XColor;
+
+typedef struct {
+  unsigned char *value;	   /* same as Property routines */
+  Atom encoding;	   /* prop type */
+  int format;		   /* prop data format: 8, 16, or 32 */
+  unsigned long nitems;	   /* number of data items in value */
+} XTextProperty;
+
+typedef struct {
+  long flags;	        /* marks which fields in this structure are defined */
+  int x, y;		/* obsolete for new window mgrs, but clients */
+  int width, height;	/* should set so old wm's don't mess up */
+} XSizeHints;
+
+/* Functions emulated by macros. */
+
+#define XFreeColormap(display, colormap) \
+  DeleteObject(colormap)
+
+#define XCreateFontCursor(display, shape) \
+  LoadCursor(NULL, shape)
+
+#define XDefineCursor(display, window, cursor) \
+  SetCursor(cursor)
+
+#define XFlush(display) \
+  /* Nothing. */
+
+#define DisplayWidth(display, screen) \
+  GetSystemMetrics(SM_CXSCREEN)
+
+#define DisplayHeight(display, screen) \
+  GetSystemMetrics(SM_CYSCREEN)
+
+#define XMapWindow(display, window) \
+  ShowWindow(window, SW_SHOWNORMAL)
+
+#define XUnmapWindow(display, window) \
+  ShowWindow(window, SW_HIDE)
+
+#define XIconifyWindow(display, window, screen) \
+  ShowWindow(window, SW_MINIMIZE)
+
+#define XWithdrawWindow(display, window, screen) \
+  ShowWindow(window, SW_HIDE)
+
+#define XLowerWindow(display, window) \
+  SetWindowPos(window, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE)
+
+#define XSetWMName(display, window, tp) \
+  SetWindowText(window, (tp)->value)
+
+/* There really isn't a way to set the icon name separate from the
+   windows name in Win32, so, just set the windows name. */
+#define XSetWMIconName(display, window, tp) \
+  XSetWMName(display, window, tp)
+
+#define XDestroyWindow(display, window) \
+  DestroyWindow(window)
+
+/* Anything that needs to be freed was allocated with malloc in our
+   fake X windows library for Win32, so free it with plain old
+   free(). */
+#define XFree(data) \
+  free(data)
+
+/* Nothing to be done for this...the pointer is always 'ungrabbed'
+   in Win32. */
+#define XUngrabPointer(display, time) \
+  /* Nothing. */
+
+/* Function prototypes. */
+
+extern XVisualInfo* XGetVisualInfo(
+  Display* display,
+  long mask,
+  XVisualInfo* ttemplate,  /* Avoid class with C++ keyword. */
+  int*nitems);
+
+extern Colormap XCreateColormap(
+  Display* display,
+  Window root,
+  Visual* visual,
+  int alloc);
+
+extern void XAllocColorCells(
+  Display* display,
+  Colormap colormap,
+  Bool contig, 
+  unsigned long plane_masks_return[],
+  unsigned int nplanes,
+  unsigned long pixels_return[],
+  unsigned int npixels);
+
+extern void XStoreColor(
+  Display* display,
+  Colormap colormap,
+  XColor* color);
+
+extern void XSetWindowColormap(
+  Display* display,
+  Window window,
+  Colormap colormap);
+
+extern Bool XTranslateCoordinates(
+  Display *display,
+  Window src, Window dst, 
+  int src_x, int src_y, 
+  int* dest_x_return, int* dest_y_return,
+  Window* child_return);
+
+extern Status XGetGeometry(
+  Display* display,
+  Window window,
+  Window* root_return, 
+  int* x_return, int* y_return, 
+  unsigned int* width_return, unsigned int* height_return,
+  unsigned int *border_width_return,
+  unsigned int* depth_return);
+
+extern int DisplayWidthMM(
+  Display* display,
+  int screen);
+
+extern int DisplayHeightMM(
+  Display* display,
+  int screen);
+
+extern void XWarpPointer(
+  Display* display,
+  Window src, Window dst, 
+  int src_x, int src_y,
+  int src_width, int src_height, 
+  int dst_x, int dst_y);
+
+extern int XParseGeometry(
+  char* string,
+  int* x, int* y, 
+  unsigned int* width, unsigned int* height);
+
+extern int XPending(
+  Display* display);
+
+#endif /* __win32_x11_h__ */