From 663631725ee2d633d9ec5821cd48953ffd188d00 Mon Sep 17 00:00:00 2001 From: ftrapero Date: Tue, 27 Jun 2017 12:08:38 +0200 Subject: Squashed 'nx-X11/extras/Mesa_6.4.2/' content from commit 475b1f7 git-subtree-dir: nx-X11/extras/Mesa_6.4.2 git-subtree-split: 475b1f7b56fa36ef4f3b22a749f88a98ddc0d502 --- src/glut/beos/Makefile | 97 ++ src/glut/beos/beos_x11.cpp | 181 +++ src/glut/beos/beos_x11.h | 33 + src/glut/beos/glutBlocker.cpp | 69 + src/glut/beos/glutBlocker.h | 47 + src/glut/beos/glutCallback.cpp | 171 +++ src/glut/beos/glutColor.cpp | 32 + src/glut/beos/glutCursor.cpp | 90 ++ src/glut/beos/glutCursors.h | 3083 +++++++++++++++++++++++++++++++++++++++ src/glut/beos/glutDstr.cpp | 83 ++ src/glut/beos/glutEvent.cpp | 695 +++++++++ src/glut/beos/glutGet.cpp | 211 +++ src/glut/beos/glutInit.cpp | 263 ++++ src/glut/beos/glutMenu.cpp | 326 +++++ src/glut/beos/glutMenu.h | 84 ++ src/glut/beos/glutOverlay.cpp | 47 + src/glut/beos/glutState.h | 71 + src/glut/beos/glutWindow.cpp | 633 ++++++++ src/glut/beos/glutWindow.h | 119 ++ src/glut/beos/glut_8x13.c | 2073 ++++++++++++++++++++++++++ src/glut/beos/glut_9x15.c | 2075 ++++++++++++++++++++++++++ src/glut/beos/glut_bitmap.c | 57 + src/glut/beos/glut_bwidth.c | 58 + src/glut/beos/glut_ext.c | 201 +++ src/glut/beos/glut_hel10.c | 1778 ++++++++++++++++++++++ src/glut/beos/glut_hel12.c | 1788 +++++++++++++++++++++++ src/glut/beos/glut_hel18.c | 1897 ++++++++++++++++++++++++ src/glut/beos/glut_mroman.c | 2451 +++++++++++++++++++++++++++++++ src/glut/beos/glut_roman.c | 2451 +++++++++++++++++++++++++++++++ src/glut/beos/glut_shapes.c | 596 ++++++++ src/glut/beos/glut_stroke.c | 42 + src/glut/beos/glut_swidth.c | 58 + src/glut/beos/glut_teapot.c | 210 +++ src/glut/beos/glut_tr10.c | 1777 ++++++++++++++++++++++ src/glut/beos/glut_tr24.c | 2060 ++++++++++++++++++++++++++ src/glut/beos/glut_util.c | 81 + src/glut/beos/glut_vidresize.c | 230 +++ src/glut/beos/glutbitmap.h | 30 + src/glut/beos/glutint.h | 814 +++++++++++ src/glut/beos/glutstroke.h | 42 + src/glut/dos/Makefile.DJ | 126 ++ src/glut/dos/PC_HW/pc_hw.c | 163 +++ src/glut/dos/PC_HW/pc_hw.h | 229 +++ src/glut/dos/PC_HW/pc_irq.S | 182 +++ src/glut/dos/PC_HW/pc_keyb.c | 540 +++++++ src/glut/dos/PC_HW/pc_mouse.c | 293 ++++ src/glut/dos/PC_HW/pc_timer.c | 327 +++++ src/glut/dos/bitmap.c | 115 ++ src/glut/dos/callback.c | 204 +++ src/glut/dos/color.c | 53 + src/glut/dos/extens.c | 70 + src/glut/dos/f8x13.c | 1183 +++++++++++++++ src/glut/dos/f9x15.c | 1407 ++++++++++++++++++ src/glut/dos/hel10.c | 1019 +++++++++++++ src/glut/dos/hel12.c | 1029 +++++++++++++ src/glut/dos/hel18.c | 1138 +++++++++++++++ src/glut/dos/init.c | 223 +++ src/glut/dos/internal.h | 197 +++ src/glut/dos/loop.c | 245 ++++ src/glut/dos/menu.c | 130 ++ src/glut/dos/mouse.c | 55 + src/glut/dos/mroman.c | 2783 +++++++++++++++++++++++++++++++++++ src/glut/dos/overlay.c | 93 ++ src/glut/dos/roman.c | 2783 +++++++++++++++++++++++++++++++++++ src/glut/dos/shapes.c | 1143 +++++++++++++++ src/glut/dos/state.c | 238 +++ src/glut/dos/stroke.c | 118 ++ src/glut/dos/teapot.c | 201 +++ src/glut/dos/tr10.c | 1018 +++++++++++++ src/glut/dos/tr24.c | 1301 +++++++++++++++++ src/glut/dos/util.c | 74 + src/glut/dos/window.c | 325 +++++ src/glut/ggi/Makefile | 52 + src/glut/ggi/debug.h | 259 ++++ src/glut/ggi/ggiglut.c | 959 ++++++++++++ src/glut/glx/Makefile | 113 ++ src/glut/glx/Makefile.cygnus | 110 ++ src/glut/glx/Makefile.sgi | 189 +++ src/glut/glx/Makefile.win | 99 ++ src/glut/glx/capturexfont.c | 356 +++++ src/glut/glx/descrip.mms | 208 +++ src/glut/glx/fxglut.def | 103 ++ src/glut/glx/glut.def | 131 ++ src/glut/glx/glut_8x13.c | 2073 ++++++++++++++++++++++++++ src/glut/glx/glut_9x15.c | 2075 ++++++++++++++++++++++++++ src/glut/glx/glut_bitmap.c | 57 + src/glut/glx/glut_bwidth.c | 58 + src/glut/glx/glut_cindex.c | 252 ++++ src/glut/glx/glut_cmap.c | 399 +++++ src/glut/glx/glut_cursor.c | 201 +++ src/glut/glx/glut_dials.c | 26 + src/glut/glx/glut_dstr.c | 1627 +++++++++++++++++++++ src/glut/glx/glut_event.c | 1377 +++++++++++++++++ src/glut/glx/glut_ext.c | 201 +++ src/glut/glx/glut_fbc.c | 164 +++ src/glut/glx/glut_fullscrn.c | 56 + src/glut/glx/glut_gamemode.c | 678 +++++++++ src/glut/glx/glut_get.c | 220 +++ src/glut/glx/glut_glxext.c | 255 ++++ src/glut/glx/glut_hel10.c | 1778 ++++++++++++++++++++++ src/glut/glx/glut_hel12.c | 1788 +++++++++++++++++++++++ src/glut/glx/glut_hel18.c | 1897 ++++++++++++++++++++++++ src/glut/glx/glut_init.c | 390 +++++ src/glut/glx/glut_input.c | 639 ++++++++ src/glut/glx/glut_joy.c | 82 ++ src/glut/glx/glut_key.c | 29 + src/glut/glx/glut_keyctrl.c | 29 + src/glut/glx/glut_keyup.c | 29 + src/glut/glx/glut_menu.c | 1014 +++++++++++++ src/glut/glx/glut_menu2.c | 189 +++ src/glut/glx/glut_mesa.c | 57 + src/glut/glx/glut_modifier.c | 31 + src/glut/glx/glut_mroman.c | 2451 +++++++++++++++++++++++++++++++ src/glut/glx/glut_overlay.c | 611 ++++++++ src/glut/glx/glut_roman.c | 2451 +++++++++++++++++++++++++++++++ src/glut/glx/glut_shapes.c | 596 ++++++++ src/glut/glx/glut_space.c | 35 + src/glut/glx/glut_stroke.c | 42 + src/glut/glx/glut_swap.c | 67 + src/glut/glx/glut_swidth.c | 58 + src/glut/glx/glut_tablet.c | 33 + src/glut/glx/glut_teapot.c | 210 +++ src/glut/glx/glut_tr10.c | 1777 ++++++++++++++++++++++ src/glut/glx/glut_tr24.c | 2060 ++++++++++++++++++++++++++ src/glut/glx/glut_util.c | 86 ++ src/glut/glx/glut_vidresize.c | 231 +++ src/glut/glx/glut_warp.c | 23 + src/glut/glx/glut_win.c | 1016 +++++++++++++ src/glut/glx/glut_winmisc.c | 124 ++ src/glut/glx/glutbitmap.h | 32 + src/glut/glx/glutint.h | 812 +++++++++++ src/glut/glx/glutstroke.h | 42 + src/glut/glx/glutwin32.h | 96 ++ src/glut/glx/layerutil.c | 204 +++ src/glut/glx/layerutil.h | 59 + src/glut/glx/mms_depend | 72 + src/glut/glx/stroke.h | 134 ++ src/glut/glx/win32_glx.c | 256 ++++ src/glut/glx/win32_glx.h | 58 + src/glut/glx/win32_menu.c | 531 +++++++ src/glut/glx/win32_util.c | 120 ++ src/glut/glx/win32_winproc.c | 784 ++++++++++ src/glut/glx/win32_x11.c | 400 +++++ src/glut/glx/win32_x11.h | 326 +++++ src/glut/mini/Makefile | 80 + src/glut/mini/bitmap.c | 56 + src/glut/mini/callback.c | 152 ++ src/glut/mini/color.c | 46 + src/glut/mini/globals.c | 61 + src/glut/mini/init.c | 59 + src/glut/mini/internal.h | 78 + src/glut/mini/menu.c | 86 ++ src/glut/mini/models.c | 598 ++++++++ src/glut/mini/overlay.c | 60 + src/glut/mini/state.c | 70 + src/glut/mini/teapot.c | 214 +++ src/glut/mini/window.c | 273 ++++ src/glut/os2/Makefile | 420 ++++++ src/glut/os2/WarpWin.cpp | 420 ++++++ src/glut/os2/glutOverlay.cpp | 133 ++ src/glut/os2/glut_8x13.cpp | 2076 ++++++++++++++++++++++++++ src/glut/os2/glut_9x15.cpp | 2077 ++++++++++++++++++++++++++ src/glut/os2/glut_bitmap.cpp | 57 + src/glut/os2/glut_cindex.cpp | 259 ++++ src/glut/os2/glut_cmap.cpp | 399 +++++ src/glut/os2/glut_cursor.cpp | 210 +++ src/glut/os2/glut_event.cpp | 1399 ++++++++++++++++++ src/glut/os2/glut_ext.cpp | 204 +++ src/glut/os2/glut_fullscrn.cpp | 38 + src/glut/os2/glut_gamemode.cpp | 680 +++++++++ src/glut/os2/glut_get.cpp | 232 +++ src/glut/os2/glut_hel10.cpp | 1781 ++++++++++++++++++++++ src/glut/os2/glut_hel12.cpp | 1791 +++++++++++++++++++++++ src/glut/os2/glut_hel18.cpp | 1900 ++++++++++++++++++++++++ src/glut/os2/glut_init.cpp | 451 ++++++ src/glut/os2/glut_input.cpp | 628 ++++++++ src/glut/os2/glut_key.cpp | 29 + src/glut/os2/glut_keyctrl.cpp | 29 + src/glut/os2/glut_keyup.cpp | 29 + src/glut/os2/glut_mesa.cpp | 57 + src/glut/os2/glut_modifier.cpp | 31 + src/glut/os2/glut_roman.cpp | 2451 +++++++++++++++++++++++++++++++ src/glut/os2/glut_shapes.cpp | 595 ++++++++ src/glut/os2/glut_stroke.cpp | 42 + src/glut/os2/glut_swap.cpp | 67 + src/glut/os2/glut_teapot.cpp | 210 +++ src/glut/os2/glut_tr24.cpp | 2063 ++++++++++++++++++++++++++ src/glut/os2/glut_util.cpp | 90 ++ src/glut/os2/glut_vidresize.cpp | 232 +++ src/glut/os2/glut_warp.cpp | 29 + src/glut/os2/glut_win.cpp | 1221 ++++++++++++++++ src/glut/os2/glut_winmisc.cpp | 127 ++ src/glut/os2/glutbitmap.h | 32 + src/glut/os2/glutos2.h | 36 + src/glut/os2/glutstroke.h | 42 + src/glut/os2/layerutil.h | 59 + src/glut/os2/libGlut.DEF | 94 ++ src/glut/os2/os2_glx.cpp | 146 ++ src/glut/os2/os2_menu.cpp | 533 +++++++ src/glut/os2/os2_winproc.cpp | 1297 ++++++++++++++++ src/glut/os2/src-glut_os2pm.zip | Bin 0 -> 141239 bytes 201 files changed, 108685 insertions(+) create mode 100644 src/glut/beos/Makefile create mode 100644 src/glut/beos/beos_x11.cpp create mode 100644 src/glut/beos/beos_x11.h create mode 100644 src/glut/beos/glutBlocker.cpp create mode 100644 src/glut/beos/glutBlocker.h create mode 100644 src/glut/beos/glutCallback.cpp create mode 100644 src/glut/beos/glutColor.cpp create mode 100644 src/glut/beos/glutCursor.cpp create mode 100644 src/glut/beos/glutCursors.h create mode 100644 src/glut/beos/glutDstr.cpp create mode 100644 src/glut/beos/glutEvent.cpp create mode 100644 src/glut/beos/glutGet.cpp create mode 100644 src/glut/beos/glutInit.cpp create mode 100644 src/glut/beos/glutMenu.cpp create mode 100644 src/glut/beos/glutMenu.h create mode 100644 src/glut/beos/glutOverlay.cpp create mode 100644 src/glut/beos/glutState.h create mode 100644 src/glut/beos/glutWindow.cpp create mode 100644 src/glut/beos/glutWindow.h create mode 100644 src/glut/beos/glut_8x13.c create mode 100644 src/glut/beos/glut_9x15.c create mode 100644 src/glut/beos/glut_bitmap.c create mode 100644 src/glut/beos/glut_bwidth.c create mode 100644 src/glut/beos/glut_ext.c create mode 100644 src/glut/beos/glut_hel10.c create mode 100644 src/glut/beos/glut_hel12.c create mode 100644 src/glut/beos/glut_hel18.c create mode 100644 src/glut/beos/glut_mroman.c create mode 100644 src/glut/beos/glut_roman.c create mode 100644 src/glut/beos/glut_shapes.c create mode 100644 src/glut/beos/glut_stroke.c create mode 100644 src/glut/beos/glut_swidth.c create mode 100644 src/glut/beos/glut_teapot.c create mode 100644 src/glut/beos/glut_tr10.c create mode 100644 src/glut/beos/glut_tr24.c create mode 100644 src/glut/beos/glut_util.c create mode 100644 src/glut/beos/glut_vidresize.c create mode 100644 src/glut/beos/glutbitmap.h create mode 100644 src/glut/beos/glutint.h create mode 100644 src/glut/beos/glutstroke.h create mode 100644 src/glut/dos/Makefile.DJ create mode 100644 src/glut/dos/PC_HW/pc_hw.c create mode 100644 src/glut/dos/PC_HW/pc_hw.h create mode 100644 src/glut/dos/PC_HW/pc_irq.S create mode 100644 src/glut/dos/PC_HW/pc_keyb.c create mode 100644 src/glut/dos/PC_HW/pc_mouse.c create mode 100644 src/glut/dos/PC_HW/pc_timer.c create mode 100644 src/glut/dos/bitmap.c create mode 100644 src/glut/dos/callback.c create mode 100644 src/glut/dos/color.c create mode 100644 src/glut/dos/extens.c create mode 100644 src/glut/dos/f8x13.c create mode 100644 src/glut/dos/f9x15.c create mode 100644 src/glut/dos/hel10.c create mode 100644 src/glut/dos/hel12.c create mode 100644 src/glut/dos/hel18.c create mode 100644 src/glut/dos/init.c create mode 100644 src/glut/dos/internal.h create mode 100644 src/glut/dos/loop.c create mode 100644 src/glut/dos/menu.c create mode 100644 src/glut/dos/mouse.c create mode 100644 src/glut/dos/mroman.c create mode 100644 src/glut/dos/overlay.c create mode 100644 src/glut/dos/roman.c create mode 100644 src/glut/dos/shapes.c create mode 100644 src/glut/dos/state.c create mode 100644 src/glut/dos/stroke.c create mode 100644 src/glut/dos/teapot.c create mode 100644 src/glut/dos/tr10.c create mode 100644 src/glut/dos/tr24.c create mode 100644 src/glut/dos/util.c create mode 100644 src/glut/dos/window.c create mode 100644 src/glut/ggi/Makefile create mode 100644 src/glut/ggi/debug.h create mode 100644 src/glut/ggi/ggiglut.c create mode 100644 src/glut/glx/Makefile create mode 100644 src/glut/glx/Makefile.cygnus create mode 100644 src/glut/glx/Makefile.sgi create mode 100644 src/glut/glx/Makefile.win create mode 100644 src/glut/glx/capturexfont.c create mode 100644 src/glut/glx/descrip.mms create mode 100644 src/glut/glx/fxglut.def create mode 100644 src/glut/glx/glut.def create mode 100644 src/glut/glx/glut_8x13.c create mode 100644 src/glut/glx/glut_9x15.c create mode 100644 src/glut/glx/glut_bitmap.c create mode 100644 src/glut/glx/glut_bwidth.c create mode 100644 src/glut/glx/glut_cindex.c create mode 100644 src/glut/glx/glut_cmap.c create mode 100644 src/glut/glx/glut_cursor.c create mode 100644 src/glut/glx/glut_dials.c create mode 100644 src/glut/glx/glut_dstr.c create mode 100644 src/glut/glx/glut_event.c create mode 100644 src/glut/glx/glut_ext.c create mode 100644 src/glut/glx/glut_fbc.c create mode 100644 src/glut/glx/glut_fullscrn.c create mode 100644 src/glut/glx/glut_gamemode.c create mode 100644 src/glut/glx/glut_get.c create mode 100644 src/glut/glx/glut_glxext.c create mode 100644 src/glut/glx/glut_hel10.c create mode 100644 src/glut/glx/glut_hel12.c create mode 100644 src/glut/glx/glut_hel18.c create mode 100644 src/glut/glx/glut_init.c create mode 100644 src/glut/glx/glut_input.c create mode 100644 src/glut/glx/glut_joy.c create mode 100644 src/glut/glx/glut_key.c create mode 100644 src/glut/glx/glut_keyctrl.c create mode 100644 src/glut/glx/glut_keyup.c create mode 100644 src/glut/glx/glut_menu.c create mode 100644 src/glut/glx/glut_menu2.c create mode 100644 src/glut/glx/glut_mesa.c create mode 100644 src/glut/glx/glut_modifier.c create mode 100644 src/glut/glx/glut_mroman.c create mode 100644 src/glut/glx/glut_overlay.c create mode 100644 src/glut/glx/glut_roman.c create mode 100644 src/glut/glx/glut_shapes.c create mode 100644 src/glut/glx/glut_space.c create mode 100644 src/glut/glx/glut_stroke.c create mode 100644 src/glut/glx/glut_swap.c create mode 100644 src/glut/glx/glut_swidth.c create mode 100644 src/glut/glx/glut_tablet.c create mode 100644 src/glut/glx/glut_teapot.c create mode 100644 src/glut/glx/glut_tr10.c create mode 100644 src/glut/glx/glut_tr24.c create mode 100644 src/glut/glx/glut_util.c create mode 100644 src/glut/glx/glut_vidresize.c create mode 100644 src/glut/glx/glut_warp.c create mode 100644 src/glut/glx/glut_win.c create mode 100644 src/glut/glx/glut_winmisc.c create mode 100644 src/glut/glx/glutbitmap.h create mode 100644 src/glut/glx/glutint.h create mode 100644 src/glut/glx/glutstroke.h create mode 100644 src/glut/glx/glutwin32.h create mode 100644 src/glut/glx/layerutil.c create mode 100644 src/glut/glx/layerutil.h create mode 100644 src/glut/glx/mms_depend create mode 100644 src/glut/glx/stroke.h create mode 100644 src/glut/glx/win32_glx.c create mode 100644 src/glut/glx/win32_glx.h create mode 100644 src/glut/glx/win32_menu.c create mode 100644 src/glut/glx/win32_util.c create mode 100644 src/glut/glx/win32_winproc.c create mode 100644 src/glut/glx/win32_x11.c create mode 100644 src/glut/glx/win32_x11.h create mode 100644 src/glut/mini/Makefile create mode 100644 src/glut/mini/bitmap.c create mode 100644 src/glut/mini/callback.c create mode 100644 src/glut/mini/color.c create mode 100644 src/glut/mini/globals.c create mode 100644 src/glut/mini/init.c create mode 100644 src/glut/mini/internal.h create mode 100644 src/glut/mini/menu.c create mode 100644 src/glut/mini/models.c create mode 100644 src/glut/mini/overlay.c create mode 100644 src/glut/mini/state.c create mode 100644 src/glut/mini/teapot.c create mode 100644 src/glut/mini/window.c create mode 100644 src/glut/os2/Makefile create mode 100644 src/glut/os2/WarpWin.cpp create mode 100644 src/glut/os2/glutOverlay.cpp create mode 100644 src/glut/os2/glut_8x13.cpp create mode 100644 src/glut/os2/glut_9x15.cpp create mode 100644 src/glut/os2/glut_bitmap.cpp create mode 100644 src/glut/os2/glut_cindex.cpp create mode 100644 src/glut/os2/glut_cmap.cpp create mode 100644 src/glut/os2/glut_cursor.cpp create mode 100644 src/glut/os2/glut_event.cpp create mode 100644 src/glut/os2/glut_ext.cpp create mode 100644 src/glut/os2/glut_fullscrn.cpp create mode 100644 src/glut/os2/glut_gamemode.cpp create mode 100644 src/glut/os2/glut_get.cpp create mode 100644 src/glut/os2/glut_hel10.cpp create mode 100644 src/glut/os2/glut_hel12.cpp create mode 100644 src/glut/os2/glut_hel18.cpp create mode 100644 src/glut/os2/glut_init.cpp create mode 100644 src/glut/os2/glut_input.cpp create mode 100644 src/glut/os2/glut_key.cpp create mode 100644 src/glut/os2/glut_keyctrl.cpp create mode 100644 src/glut/os2/glut_keyup.cpp create mode 100644 src/glut/os2/glut_mesa.cpp create mode 100644 src/glut/os2/glut_modifier.cpp create mode 100644 src/glut/os2/glut_roman.cpp create mode 100644 src/glut/os2/glut_shapes.cpp create mode 100644 src/glut/os2/glut_stroke.cpp create mode 100644 src/glut/os2/glut_swap.cpp create mode 100644 src/glut/os2/glut_teapot.cpp create mode 100644 src/glut/os2/glut_tr24.cpp create mode 100644 src/glut/os2/glut_util.cpp create mode 100644 src/glut/os2/glut_vidresize.cpp create mode 100644 src/glut/os2/glut_warp.cpp create mode 100644 src/glut/os2/glut_win.cpp create mode 100644 src/glut/os2/glut_winmisc.cpp create mode 100644 src/glut/os2/glutbitmap.h create mode 100644 src/glut/os2/glutos2.h create mode 100644 src/glut/os2/glutstroke.h create mode 100644 src/glut/os2/layerutil.h create mode 100644 src/glut/os2/libGlut.DEF create mode 100644 src/glut/os2/os2_glx.cpp create mode 100644 src/glut/os2/os2_menu.cpp create mode 100644 src/glut/os2/os2_winproc.cpp create mode 100644 src/glut/os2/src-glut_os2pm.zip (limited to 'src/glut') diff --git a/src/glut/beos/Makefile b/src/glut/beos/Makefile new file mode 100644 index 000000000..d9cf32565 --- /dev/null +++ b/src/glut/beos/Makefile @@ -0,0 +1,97 @@ +# 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. + +# src/glut/beos/Makefile + +TOP = ../../.. +include $(TOP)/configs/current + +GLUT_MAJOR = 3 +GLUT_MINOR = 7 +GLUT_TINY = 1 + +CPP_SOURCES = \ + glutBlocker.cpp \ + glutInit.cpp \ + glutWindow.cpp \ + glutEvent.cpp \ + glutCallback.cpp \ + glutOverlay.cpp \ + glutGet.cpp \ + glutColor.cpp \ + glutCursor.cpp \ + glutMenu.cpp \ + glutDstr.cpp \ + beos_x11.cpp + +C_SOURCES = \ + glut_8x13.c \ + glut_9x15.c \ + glut_bitmap.c \ + glut_bwidth.c \ + glut_hel10.c \ + glut_hel12.c \ + glut_hel18.c \ + glut_tr10.c \ + glut_tr24.c \ + glut_mroman.c \ + glut_roman.c \ + glut_stroke.c \ + glut_swidth.c \ + glut_shapes.c \ + glut_teapot.c \ + glut_vidresize.c \ + glut_util.c \ + glut_ext.c + +OBJECTS = \ + $(CPP_SOURCES:.cpp=.o) \ + $(C_SOURCES:.c=.o) + +INCLUDES = \ + -I. \ + -I- \ + -I$(TOP)/include + +# Rules + +.cpp.o: + $(CC) -c $< $(INCLUDES) $(CFLAGS) $(GLUT_CFLAGS) -o $@ + +.c.o: + $(CC) -c $< $(INCLUDES) $(CFLAGS) $(GLUT_CFLAGS) -o $@ + + +# ---- TARGETS + +default: $(LIB_DIR) $(LIB_DIR)/$(GLUT_LIB_NAME) + +# Create the lib directory if missing +$(LIB_DIR): + mkdir $(LIB_DIR) + +# Make the library +$(LIB_DIR)/$(GLUT_LIB_NAME): depend $(OBJECTS) + @$(TOP)/bin/mklib -o $(GLUT_LIB) -major $(GLUT_MAJOR) -minor $(GLUT_MINOR) -patch $(GLUT_TINY) \ + -install $(LIB_DIR) $(MKLIB_OPTIONS) $(GLUT_LIB_DEPS) \ + $(OBJECTS) + +clean: + -rm -f *.o + +depend: $(SOURCES) + touch depend + $(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(SOURCES) > /dev/null + +include depend diff --git a/src/glut/beos/beos_x11.cpp b/src/glut/beos/beos_x11.cpp new file mode 100644 index 000000000..2d1bc655c --- /dev/null +++ b/src/glut/beos/beos_x11.cpp @@ -0,0 +1,181 @@ + +/* 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 +#include +#include "beos_x11.h" + +/* NOTE: These functions require a BApplication to be instantiated first */ +int DisplayWidth() { + BScreen s; + return s.Frame().IntegerWidth() + 1; +} + +int DisplayHeight() { + BScreen s; + return s.Frame().IntegerHeight() + 1; +} + +/* 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. +*/ + +#if 0 // Not used currently... + +/* + *Returns pointer to first char ins search which is also in what, else NULL. + */ +static char *strscan (char *search, char *what) +{ + int i, len = strlen (what); + char c; + + while ((c = *(search++))) { + for (i = 0; i < len; i++) + if (c == what [i]) + return (--search); + } + return (NULL); +} + +#endif + +/* + * XParseGeometry parses strings of the form + * "=x{+-}{+-}", 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=0, tempHeight=0; + int tempX=0, tempY=0; + 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/beos/beos_x11.h b/src/glut/beos/beos_x11.h new file mode 100644 index 000000000..966dddd5e --- /dev/null +++ b/src/glut/beos/beos_x11.h @@ -0,0 +1,33 @@ +#ifndef __beos_x11_h__ +#define __beos_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. */ + +/* + * 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 + +/* Function prototypes. */ + +extern int DisplayWidth(); +extern int DisplayHeight(); + +extern int XParseGeometry( + char* string, + int* x, int* y, + unsigned int* width, unsigned int* height); + +#endif /* __beos_x11_h__ */ diff --git a/src/glut/beos/glutBlocker.cpp b/src/glut/beos/glutBlocker.cpp new file mode 100644 index 000000000..aa948522b --- /dev/null +++ b/src/glut/beos/glutBlocker.cpp @@ -0,0 +1,69 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * FILE: glutBlocker.cpp + * + * DESCRIPTION: helper class for GLUT event loop. + * if a window receives an event, wake up the event loop. + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include "glutBlocker.h" + +/*********************************************************** + * Global variable + ***********************************************************/ +GlutBlocker gBlock; + +/*********************************************************** + * Member functions + ***********************************************************/ +GlutBlocker::GlutBlocker() { + gSem = create_sem(1, "gSem"); + eSem = create_sem(0, "eSem"); + events = false; + sleeping = false; +} + +GlutBlocker::~GlutBlocker() { + delete_sem(eSem); + delete_sem(gSem); +} + +void GlutBlocker::WaitEvent() { + acquire_sem(gSem); + if(!events) { // wait for new event + sleeping = true; + release_sem(gSem); + acquire_sem(eSem); // next event will release eSem + } else { + release_sem(gSem); + } +} + +void GlutBlocker::WaitEvent(bigtime_t usecs) { + acquire_sem(gSem); + if(!events) { // wait for new event + sleeping = true; + release_sem(gSem); + acquire_sem_etc(eSem, 1, B_TIMEOUT, usecs); // wait for next event or timeout + } else { + release_sem(gSem); + } +} + +void GlutBlocker::NewEvent() { + acquire_sem(gSem); + events = true; // next call to WaitEvent returns immediately + if(sleeping) { + sleeping = false; + release_sem(eSem); // if event loop is blocking, wake it up + } + release_sem(gSem); +} diff --git a/src/glut/beos/glutBlocker.h b/src/glut/beos/glutBlocker.h new file mode 100644 index 000000000..fc9e4cc30 --- /dev/null +++ b/src/glut/beos/glutBlocker.h @@ -0,0 +1,47 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * FILE: glutBlocker.h + * + * DESCRIPTION: helper class for GLUT event loop. + * if a window receives an event, wake up the event loop. + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include + +/*********************************************************** + * CLASS: GlutBlocker + * + * DESCRIPTION: Fairly naive, but safe implementation. + * global semaphore controls access to state + * event semaphore blocks WaitEvent() call if necessary + * (this is basically a condition variable class) + ***********************************************************/ +class GlutBlocker { +public: + GlutBlocker(); + ~GlutBlocker(); + void WaitEvent(); // wait for new event + void WaitEvent(bigtime_t usecs); // wait with timeout + void NewEvent(); // new event from a window (may need to wakeup main thread) + void QuickNewEvent() { events = true; } // new event from main thread + void ClearEvents() { events = false; } // clear counter at beginning of event loop + bool PendingEvent() { return events; } // XPending() equivalent +private: + sem_id gSem; + sem_id eSem; + bool events; // are there any new events? + bool sleeping; // is someone sleeping on eSem? +}; + +/*********************************************************** + * Global variable + ***********************************************************/ +extern GlutBlocker gBlock; diff --git a/src/glut/beos/glutCallback.cpp b/src/glut/beos/glutCallback.cpp new file mode 100644 index 000000000..cf3daaaf3 --- /dev/null +++ b/src/glut/beos/glutCallback.cpp @@ -0,0 +1,171 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutCallback.cpp + * + * DESCRIPTION: put all the callback setting routines in + * one place + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include "glutint.h" +#include "glutState.h" + +/*********************************************************** + * Window related callbacks + ***********************************************************/ +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."); + gState.currentWindow->display = displayFunc; +} + +void APIENTRY +glutKeyboardFunc(GLUTkeyboardCB keyboardFunc) +{ + gState.currentWindow->keyboard = keyboardFunc; +} + +void APIENTRY +glutSpecialFunc(GLUTspecialCB specialFunc) +{ + gState.currentWindow->special = specialFunc; +} + +void APIENTRY +glutMouseFunc(GLUTmouseCB mouseFunc) +{ + gState.currentWindow->mouse = mouseFunc; +} + +void APIENTRY +glutMotionFunc(GLUTmotionCB motionFunc) +{ + gState.currentWindow->motion = motionFunc; +} + +void APIENTRY +glutPassiveMotionFunc(GLUTpassiveCB passiveMotionFunc) +{ + gState.currentWindow->passive = passiveMotionFunc; +} + +void APIENTRY +glutEntryFunc(GLUTentryCB entryFunc) +{ + gState.currentWindow->entry = entryFunc; + if (!entryFunc) { + gState.currentWindow->entryState = -1; + } +} + +void APIENTRY +glutWindowStatusFunc(GLUTwindowStatusCB windowStatusFunc) +{ + gState.currentWindow->windowStatus = windowStatusFunc; +} + +static void +visibilityHelper(int status) +{ + if (status == GLUT_HIDDEN || status == GLUT_FULLY_COVERED) + gState.currentWindow->visibility(GLUT_NOT_VISIBLE); + else + gState.currentWindow->visibility(GLUT_VISIBLE); +} + +void APIENTRY +glutVisibilityFunc(GLUTvisibilityCB visibilityFunc) +{ + gState.currentWindow->visibility = visibilityFunc; + if (visibilityFunc) + glutWindowStatusFunc(visibilityHelper); + else + glutWindowStatusFunc(NULL); +} + +void APIENTRY +glutReshapeFunc(GLUTreshapeCB reshapeFunc) +{ + if (reshapeFunc) { + gState.currentWindow->reshape = reshapeFunc; + } else { + gState.currentWindow->reshape = __glutDefaultReshape; + } +} + +/*********************************************************** + * General callbacks (timer callback in glutEvent.cpp) + ***********************************************************/ +/* DEPRICATED, use glutMenuStatusFunc instead. */ +void APIENTRY +glutMenuStateFunc(GLUTmenuStateCB menuStateFunc) +{ + gState.menuStatus = (GLUTmenuStatusCB) menuStateFunc; +} + +void APIENTRY +glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc) +{ + gState.menuStatus = menuStatusFunc; +} + +void APIENTRY +glutIdleFunc(GLUTidleCB idleFunc) +{ + gState.idle = idleFunc; +} + +/*********************************************************** + * Unsupported callbacks + ***********************************************************/ +void APIENTRY +glutOverlayDisplayFunc(GLUTdisplayCB displayFunc) +{ +} + +void APIENTRY +glutSpaceballMotionFunc(GLUTspaceMotionCB spaceMotionFunc) +{ +} + +void APIENTRY +glutSpaceballRotateFunc(GLUTspaceRotateCB spaceRotateFunc) +{ +} + +void APIENTRY +glutSpaceballButtonFunc(GLUTspaceButtonCB spaceButtonFunc) +{ +} + +void APIENTRY +glutButtonBoxFunc(GLUTbuttonBoxCB buttonBoxFunc) +{ +} + +void APIENTRY +glutDialsFunc(GLUTdialsCB dialsFunc) +{ +} + +void APIENTRY +glutTabletMotionFunc(GLUTtabletMotionCB tabletMotionFunc) +{ +} + +void APIENTRY +glutTabletButtonFunc(GLUTtabletButtonCB tabletButtonFunc) +{ +} diff --git a/src/glut/beos/glutColor.cpp b/src/glut/beos/glutColor.cpp new file mode 100644 index 000000000..d9f7739ae --- /dev/null +++ b/src/glut/beos/glutColor.cpp @@ -0,0 +1,32 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutColor.cpp + * + * DESCRIPTION: we don't support indexed color, so this code is + * really simple + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include "glutint.h" + +void glutSetColor(int cell, GLfloat red, GLfloat green, GLfloat blue) { + __glutWarning("glutSetColor: current window is RGBA"); +} + +GLfloat glutGetColor(int cell, int component) { + __glutWarning("glutGetColor: current window is RGBA"); + return -1.0; +} + +void glutCopyColormap(int win) { + __glutWarning("glutCopyColormap: color index not supported in BeOS"); +} diff --git a/src/glut/beos/glutCursor.cpp b/src/glut/beos/glutCursor.cpp new file mode 100644 index 000000000..3081fff44 --- /dev/null +++ b/src/glut/beos/glutCursor.cpp @@ -0,0 +1,90 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutCursor.cpp + * + * DESCRIPTION: code for handling custom mouse cursors + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include "glutint.h" +#include "glutState.h" +#include "glutCursors.h" + +static const unsigned char *cursorTable[] = { + XC_arrow, /* GLUT_CURSOR_RIGHT_ARROW */ + XC_top_left_arrow, /* GLUT_CURSOR_LEFT_ARROW */ + XC_hand1, /* GLUT_CURSOR_INFO */ + XC_pirate, /* GLUT_CURSOR_DESTROY */ + XC_question_arrow, /* GLUT_CURSOR_HELP */ + XC_exchange, /* GLUT_CURSOR_CYCLE */ + XC_spraycan, /* GLUT_CURSOR_SPRAY */ + XC_watch, /* GLUT_CURSOR_WAIT */ + XC_xterm, /* GLUT_CURSOR_TEXT */ + XC_crosshair, /* GLUT_CURSOR_CROSSHAIR */ + XC_sb_v_double_arrow, /* GLUT_CURSOR_UP_DOWN */ + XC_sb_h_double_arrow, /* GLUT_CURSOR_LEFT_RIGHT */ + XC_top_side, /* GLUT_CURSOR_TOP_SIDE */ + XC_bottom_side, /* GLUT_CURSOR_BOTTOM_SIDE */ + XC_left_side, /* GLUT_CURSOR_LEFT_SIDE */ + XC_right_side, /* GLUT_CURSOR_RIGHT_SIDE */ + XC_top_left_corner, /* GLUT_CURSOR_TOP_LEFT_CORNER */ + XC_top_right_corner, /* GLUT_CURSOR_TOP_RIGHT_CORNER */ + XC_bottom_right_corner, /* GLUT_CURSOR_BOTTOM_RIGHT_CORNER */ + XC_bottom_left_corner, /* GLUT_CURSOR_BOTTOM_LEFT_CORNER */ +}; + +/*********************************************************** + * FUNCTION: glutSetCursor (4.13) + * + * DESCRIPTION: set a new mouse cursor for current window + ***********************************************************/ +void glutSetCursor(int cursor) { + gState.currentWindow->Window()->Lock(); + gState.currentWindow->cursor = cursor; + __glutSetCursor(cursor); + gState.currentWindow->Window()->Unlock(); +} + +/*********************************************************** + * FUNCTION: __glutSetCursor + * + * DESCRIPTION: the actual cursor changing routine + ***********************************************************/ +void __glutSetCursor(int cursor) { + int realcursor = cursor; + if (cursor < 0 || cursor > GLUT_CURSOR_BOTTOM_LEFT_CORNER) { + switch(cursor) { + case GLUT_CURSOR_INHERIT: + return; // don't change cursor + case GLUT_CURSOR_NONE: + // this hides the cursor until the user moves the mouse + // change it to HideCursor() AT YOUR OWN RISK! + be_app->ObscureCursor(); + return; + case GLUT_CURSOR_FULL_CROSSHAIR: + realcursor = GLUT_CURSOR_CROSSHAIR; + break; + default: + __glutWarning("unknown cursor\n"); + return; + } + } + be_app->SetCursor(cursorTable[realcursor]); +} + +/*********************************************************** + * FUNCTION: glutWarpPointer (x.xx) + * + * DESCRIPTION: move the mouse pointer to a new location + * (note: can't do this in BeOS!) + ***********************************************************/ +void glutWarpPointer(int x, int y) { } diff --git a/src/glut/beos/glutCursors.h b/src/glut/beos/glutCursors.h new file mode 100644 index 000000000..59f6951e2 --- /dev/null +++ b/src/glut/beos/glutCursors.h @@ -0,0 +1,3083 @@ +/* cursors.h: X Window standard cursor shapes */ +/* Generated by bdftobcursor */ + +const unsigned char XC_X_cursor[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x70, 0xe, + 0x78, 0x1e, + 0x7c, 0x3e, + 0x3e, 0x7c, + 0x1f, 0xf8, + 0xf, 0xf0, + 0x7, 0xe0, + 0x7, 0xe0, + 0xf, 0xf0, + 0x1f, 0xf8, + 0x3e, 0x7c, + 0x7c, 0x3e, + 0x78, 0x1e, + 0x70, 0xe, + 0x0, 0x0, + /* mask */ + 0xf0, 0xf, + 0xf8, 0x1f, + 0xfc, 0x3f, + 0xfe, 0x7f, + 0x7f, 0xfe, + 0x3f, 0xfc, + 0x1f, 0xf8, + 0xf, 0xf0, + 0xf, 0xf0, + 0x1f, 0xf8, + 0x3f, 0xfc, + 0x7f, 0xfe, + 0xfe, 0x7f, + 0xfc, 0x3f, + 0xf8, 0x1f, + 0xf0, 0xf, +}; + +const unsigned char XC_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 2, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x60, 0x0, + 0x78, 0x0, + 0x3e, 0x0, + 0x3f, 0x80, + 0x1f, 0xe0, + 0x1f, 0xf8, + 0xf, 0x80, + 0xf, 0xc0, + 0x6, 0xe0, + 0x6, 0x70, + 0x2, 0x38, + 0x2, 0x1c, + 0x0, 0xe, + 0x0, 0x4, + 0x0, 0x0, + /* mask */ + 0xe0, 0x0, + 0xf8, 0x0, + 0xfe, 0x0, + 0x7f, 0x80, + 0x7f, 0xe0, + 0x3f, 0xf8, + 0x3f, 0xfc, + 0x1f, 0xfc, + 0x1f, 0xe0, + 0xf, 0xf0, + 0xf, 0xf8, + 0x7, 0x7c, + 0x7, 0x3e, + 0x2, 0x1f, + 0x0, 0xe, + 0x0, 0x4, +}; + +const unsigned char XC_based_arrow_down[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 12, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0xf, 0xf0, + 0x0, 0x0, + 0xf, 0xf0, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x5, 0xa0, + 0x3, 0xc0, + 0x1, 0x80, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x3, 0xc0, + 0x3, 0xc0, + 0xf, 0xf0, + 0xf, 0xf0, + 0xf, 0xf0, + 0x7, 0xe0, + 0x3, 0xc0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_based_arrow_up[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 12, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x1, 0x80, + 0x3, 0xc0, + 0x5, 0xa0, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0xf, 0xf0, + 0x0, 0x0, + 0xf, 0xf0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x1, 0x80, + 0x3, 0xc0, + 0xf, 0xf0, + 0xf, 0xf0, + 0xf, 0xf0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_boat[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 2, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x80, + 0x3, 0xe0, + 0x6, 0x11, + 0xff, 0xff, + 0x18, 0x0, + 0x4, 0x0, + 0x2, 0x0, + 0x3, 0xff, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0xe0, + 0x3, 0xf0, + 0x7, 0xf9, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x1f, 0xff, + 0x7, 0xff, + 0x3, 0xff, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_bogosity[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x38, 0x8e, + 0x8, 0x88, + 0x8, 0x88, + 0x8, 0x88, + 0x3f, 0xfe, + 0x28, 0x8a, + 0x28, 0x8a, + 0x28, 0x8a, + 0x28, 0x8a, + 0x3f, 0xfe, + 0x8, 0x88, + 0x8, 0x88, + 0x8, 0x88, + 0x38, 0x8e, + 0x0, 0x0, + /* mask */ + 0x7d, 0xdf, + 0x7d, 0xdf, + 0x7d, 0xdf, + 0x1d, 0xdc, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7d, 0xdf, + 0x7d, 0xdf, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x1d, 0xdc, + 0x7d, 0xdf, + 0x7d, 0xdf, + 0x7d, 0xdf, +}; + +const unsigned char XC_bottom_left_corner[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 14, 15, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x6, + 0x0, 0x6, + 0x10, 0x46, + 0x8, 0x46, + 0x4, 0x46, + 0x2, 0x46, + 0x1, 0x46, + 0x0, 0xc6, + 0x1f, 0xc6, + 0x0, 0x6, + 0x0, 0x6, + 0x0, 0x6, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x0, 0x0, + /* mask */ + 0x0, 0xf, + 0x0, 0xf, + 0x30, 0xef, + 0x38, 0xef, + 0x1c, 0xef, + 0xe, 0xef, + 0x7, 0xef, + 0x3, 0xef, + 0x3f, 0xef, + 0x3f, 0xef, + 0x3f, 0xef, + 0x0, 0xf, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, +}; + +const unsigned char XC_bottom_right_corner[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 14, 2, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x60, 0x0, + 0x60, 0x0, + 0x62, 0x8, + 0x62, 0x10, + 0x62, 0x20, + 0x62, 0x40, + 0x62, 0x80, + 0x63, 0x0, + 0x63, 0xf8, + 0x60, 0x0, + 0x60, 0x0, + 0x60, 0x0, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x0, 0x0, + /* mask */ + 0xf0, 0x0, + 0xf0, 0x0, + 0xf7, 0xc, + 0xf7, 0x1c, + 0xf7, 0x38, + 0xf7, 0x70, + 0xf7, 0xe0, + 0xf7, 0xc0, + 0xf7, 0xfc, + 0xf7, 0xfc, + 0xf7, 0xfc, + 0xf0, 0x0, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, +}; + +const unsigned char XC_bottom_side[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 14, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x8, 0x88, + 0x4, 0x90, + 0x2, 0xa0, + 0x1, 0xc0, + 0x0, 0x80, + 0x0, 0x0, + 0x3f, 0xfe, + 0x3f, 0xfe, + 0x0, 0x0, + /* mask */ + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x19, 0xcc, + 0x1d, 0xdc, + 0xf, 0xf8, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, +}; + +const unsigned char XC_bottom_tee[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 12, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_box_spiral[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 7, /* y,x of hotspot */ + /* data */ + 0xff, 0xff, + 0x0, 0x1, + 0x7f, 0xfd, + 0x40, 0x5, + 0x5f, 0xf5, + 0x50, 0x15, + 0x57, 0xd5, + 0x54, 0x55, + 0x55, 0x55, + 0x55, 0xd5, + 0x54, 0x15, + 0x57, 0xf5, + 0x50, 0x5, + 0x5f, 0xfd, + 0x40, 0x1, + 0x7f, 0xff, + /* mask */ + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, +}; + +const unsigned char XC_center_ptr[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x81, 0x80, + 0x1, 0x80, + 0x3, 0xc0, + 0x3, 0xc0, + 0x7, 0xe0, + 0x7, 0xe0, + 0xf, 0xf0, + 0xf, 0xf0, + 0x19, 0x98, + 0x11, 0x88, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x0, 0x0, + /* mask */ + 0x83, 0xc0, + 0x3, 0xc0, + 0x7, 0xe0, + 0x7, 0xe0, + 0xf, 0xf0, + 0xf, 0xf0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3b, 0xdc, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, +}; + +const unsigned char XC_circle[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x3, 0xc0, + 0xf, 0xf0, + 0x1f, 0xf8, + 0x3c, 0x3c, + 0x38, 0x1c, + 0x70, 0xe, + 0x70, 0xe, + 0x70, 0xe, + 0x70, 0xe, + 0x38, 0x1c, + 0x3c, 0x3c, + 0x1f, 0xf8, + 0xf, 0xf0, + 0x3, 0xc0, + 0x0, 0x0, + /* mask */ + 0x7, 0xe0, + 0x1f, 0xf8, + 0x3f, 0xfc, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0xfc, 0x3f, + 0xf8, 0x1f, + 0xf8, 0x1f, + 0xf8, 0x1f, + 0xf8, 0x1f, + 0xfc, 0x3f, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x3f, 0xfc, + 0x1f, 0xf8, + 0x7, 0xe0, +}; + +const unsigned char XC_clock[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 3, 9, /* y,x of hotspot */ + /* data */ + 0x1f, 0xf8, + 0x33, 0xcc, + 0x66, 0x26, + 0x49, 0x92, + 0x48, 0xf2, + 0x44, 0x22, + 0x63, 0xc6, + 0x3f, 0xfc, + 0x29, 0x94, + 0x29, 0x94, + 0x29, 0x94, + 0x2b, 0xd4, + 0x69, 0x96, + 0x78, 0x1e, + 0x7f, 0xfe, + 0x7f, 0xfe, + /* mask */ + 0x1f, 0xfe, + 0x39, 0xf7, + 0x77, 0xdb, + 0x6d, 0xed, + 0x6f, 0xfd, + 0x66, 0xf9, + 0x73, 0xf3, + 0x3f, 0xff, + 0x35, 0xeb, + 0x35, 0xeb, + 0x35, 0xeb, + 0x37, 0xfb, + 0x75, 0xeb, + 0x7c, 0xcf, + 0x7f, 0xff, + 0x7f, 0xff, +}; + +const unsigned char XC_coffee_mug[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 9, 8, /* y,x of hotspot */ + /* data */ + 0x8f, 0xf8, + 0x10, 0x4, + 0x60, 0x6, + 0x58, 0xa, + 0x47, 0xf2, + 0x40, 0x3, + 0x40, 0x3, + 0x40, 0x2, + 0x40, 0x2, + 0x58, 0x9a, + 0x55, 0x56, + 0x55, 0xd7, + 0x59, 0x5b, + 0x40, 0x2, + 0x40, 0x2, + 0x3f, 0xfc, + /* mask */ + 0xf, 0xf8, + 0x1f, 0xfc, + 0xff, 0xfe, + 0xff, 0xfe, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xfe, + 0xff, 0xfe, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xfe, + 0x3f, 0xfc, +}; + +const unsigned char XC_cross[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 9, /* y,x of hotspot */ + /* data */ + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0xff, 0x7f, + 0x0, 0x0, + 0xff, 0x7f, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x0, 0x0, + /* mask */ + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, +}; + +const unsigned char XC_cross_reverse[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 9, /* y,x of hotspot */ + /* data */ + 0x21, 0x42, + 0x51, 0x45, + 0x29, 0x4a, + 0x15, 0x54, + 0xb, 0x68, + 0x5, 0x50, + 0xfe, 0xbf, + 0x1, 0x40, + 0xfe, 0xbf, + 0x5, 0x50, + 0xb, 0x68, + 0x15, 0x54, + 0x29, 0x4a, + 0x51, 0x45, + 0x21, 0x42, + 0x0, 0x0, + /* mask */ + 0x33, 0x66, + 0xdb, 0x6d, + 0x6f, 0x7b, + 0x37, 0x76, + 0x1b, 0x6c, + 0xfd, 0x5f, + 0xfe, 0x3f, + 0x0, 0x80, + 0xfe, 0x3f, + 0xfd, 0x5f, + 0x1b, 0x6c, + 0x37, 0x76, + 0x6f, 0x7b, + 0xdb, 0x6d, + 0x33, 0x66, + 0x0, 0x0, +}; + +const unsigned char XC_crosshair[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0xff, 0x7f, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x0, + /* mask */ + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, +}; + +const unsigned char XC_diamond_cross[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x81, 0x40, + 0x3, 0x60, + 0x5, 0x50, + 0x9, 0x48, + 0x11, 0x44, + 0x21, 0x42, + 0x7f, 0x7f, + 0x0, 0x0, + 0x7f, 0x7f, + 0x21, 0x42, + 0x11, 0x44, + 0x9, 0x48, + 0x5, 0x50, + 0x3, 0x60, + 0x1, 0x40, + 0x0, 0x0, + /* mask */ + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0x1d, 0xdc, + 0x39, 0xce, + 0x71, 0xc7, + 0xff, 0xff, + 0xff, 0x7f, + 0xff, 0xff, + 0x71, 0xc7, + 0x39, 0xce, + 0x1d, 0xdc, + 0xf, 0xf8, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, +}; + +const unsigned char XC_dot[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x83, 0xc0, + 0xf, 0xf0, + 0xf, 0xf0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0xf, 0xf0, + 0xf, 0xf0, + 0x3, 0xc0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x87, 0xe0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x7, 0xe0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_dotbox[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x7f, 0xfc, + 0x20, 0x4, + 0x20, 0x4, + 0x20, 0x4, + 0x20, 0x4, + 0x21, 0x84, + 0x21, 0x84, + 0x20, 0x4, + 0x20, 0x4, + 0x20, 0x4, + 0x20, 0x4, + 0x3f, 0xfc, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x70, 0xe, + 0x70, 0xe, + 0x73, 0xce, + 0x73, 0xce, + 0x73, 0xce, + 0x73, 0xce, + 0x70, 0xe, + 0x70, 0xe, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x0, 0x0, +}; + +const unsigned char XC_double_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x81, 0x80, + 0x3, 0xc0, + 0x7, 0xe0, + 0xd, 0xb0, + 0x19, 0x98, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x19, 0x98, + 0xd, 0xb0, + 0x7, 0xe0, + 0x3, 0xc0, + 0x1, 0x80, + 0x0, 0x0, + /* mask */ + 0x83, 0xc0, + 0x7, 0xe0, + 0xf, 0xf0, + 0x1f, 0xf8, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x1f, 0xf8, + 0xf, 0xf0, + 0x7, 0xe0, + 0x3, 0xc0, +}; + +const unsigned char XC_draft_large[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 1, /* y,x of hotspot */ + /* data */ + 0xc0, 0x0, + 0x30, 0x0, + 0x3c, 0x0, + 0x1f, 0x0, + 0x1f, 0xc0, + 0xf, 0xf0, + 0xf, 0xfc, + 0x7, 0x80, + 0x7, 0x40, + 0x3, 0x20, + 0x3, 0x10, + 0x1, 0x8, + 0x1, 0x4, + 0x0, 0x2, + 0x0, 0x1, + 0x0, 0x0, + /* mask */ + 0x60, 0x0, + 0x78, 0x0, + 0x7e, 0x0, + 0x3f, 0x80, + 0x1f, 0xe0, + 0x1f, 0xf8, + 0xf, 0xfe, + 0xf, 0xfe, + 0x7, 0xe0, + 0x7, 0xf0, + 0x3, 0xb8, + 0x3, 0x9c, + 0x1, 0x8e, + 0x1, 0x87, + 0x0, 0x3, + 0x0, 0x1, +}; + +const unsigned char XC_draft_small[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 1, /* y,x of hotspot */ + /* data */ + 0x40, 0x0, + 0x30, 0x0, + 0x3c, 0x0, + 0x1f, 0x0, + 0x1f, 0xc0, + 0xe, 0x0, + 0xd, 0x0, + 0x4, 0x80, + 0x4, 0x40, + 0x0, 0x20, + 0x0, 0x10, + 0x0, 0x8, + 0x0, 0x4, + 0x0, 0x2, + 0x0, 0x1, + 0x0, 0x0, + /* mask */ + 0x60, 0x0, + 0x78, 0x0, + 0x3e, 0x0, + 0x3f, 0x80, + 0x1f, 0xe0, + 0x1f, 0xe0, + 0xf, 0x80, + 0xf, 0xc0, + 0x6, 0xe0, + 0x2, 0x70, + 0x0, 0x38, + 0x0, 0x1c, + 0x0, 0xe, + 0x0, 0x7, + 0x0, 0x3, + 0x0, 0x0, +}; + +const unsigned char XC_draped_box[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x7f, 0xfc, + 0x22, 0x44, + 0x26, 0x64, + 0x2c, 0x34, + 0x38, 0x1c, + 0x21, 0x84, + 0x21, 0x84, + 0x38, 0x1c, + 0x2c, 0x34, + 0x26, 0x64, + 0x22, 0x44, + 0x3f, 0xfc, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x67, 0xe6, + 0x6f, 0xf6, + 0x7e, 0x7e, + 0x7d, 0xbe, + 0x7b, 0xde, + 0x7b, 0xde, + 0x7d, 0xbe, + 0x7e, 0x7e, + 0x6f, 0xf6, + 0x67, 0xe6, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x0, 0x0, +}; + +const unsigned char XC_exchange[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x7, 0xe2, + 0xf, 0xf6, + 0x18, 0x3e, + 0x10, 0x12, + 0x0, 0x32, + 0x0, 0x7e, + 0x0, 0x0, + 0x0, 0x0, + 0x7e, 0x0, + 0x4c, 0x0, + 0x48, 0x8, + 0x7c, 0x18, + 0x6f, 0xf0, + 0x47, 0xe0, + 0x0, 0x0, + /* mask */ + 0x7, 0xe3, + 0xf, 0xf7, + 0x1f, 0xff, + 0x3f, 0xff, + 0x38, 0x3f, + 0x30, 0xff, + 0x0, 0xff, + 0x0, 0xff, + 0xff, 0x0, + 0xff, 0x0, + 0xfe, 0xc, + 0xfc, 0x1c, + 0xff, 0xfc, + 0xff, 0xf8, + 0xef, 0xf0, + 0xc7, 0xe0, +}; + +const unsigned char XC_fleur[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x1, 0x80, + 0x3, 0xc0, + 0x7, 0xe0, + 0x1, 0x80, + 0x11, 0x88, + 0x31, 0x8c, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x31, 0x8c, + 0x11, 0x88, + 0x1, 0x80, + 0x7, 0xe0, + 0x3, 0xc0, + 0x1, 0x80, + 0x0, 0x0, + /* mask */ + 0x3, 0xc0, + 0x7, 0xc0, + 0x7, 0xe0, + 0xf, 0xf0, + 0x17, 0xe8, + 0x3b, 0xdc, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x3b, 0xdc, + 0x17, 0xe8, + 0xf, 0xf0, + 0x7, 0xe0, + 0x3, 0xc0, + 0x3, 0xc0, +}; + +const unsigned char XC_gobbler[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 2, 2, /* y,x of hotspot */ + /* data */ + 0x1e, 0x0, + 0xe, 0x0, + 0xcc, 0x1, + 0xd, 0xf9, + 0xf, 0xff, + 0xc, 0x7f, + 0xc, 0x3f, + 0x1c, 0x6, + 0xf, 0x0, + 0x7, 0xf8, + 0x0, 0x10, + 0x0, 0x10, + 0x0, 0x10, + 0x0, 0x10, + 0x0, 0x78, + 0x0, 0x0, + /* mask */ + 0x3f, 0x0, + 0x3f, 0x0, + 0xff, 0x3, + 0xff, 0xff, + 0xff, 0xff, + 0x3f, 0xff, + 0x3f, 0xff, + 0x3f, 0xff, + 0x3f, 0xff, + 0x3f, 0xff, + 0x1f, 0xfe, + 0xf, 0xf8, + 0x0, 0x38, + 0x0, 0x38, + 0x0, 0xfc, + 0x0, 0xfc, +}; + +const unsigned char XC_gumby[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 14, /* y,x of hotspot */ + /* data */ + 0x0, 0xfc, + 0x1, 0x8, + 0x2, 0x13, + 0x5, 0x57, + 0x4, 0x13, + 0x5, 0xd3, + 0x3c, 0x1f, + 0xfc, 0x1c, + 0xe4, 0x10, + 0xe4, 0x10, + 0xf4, 0x90, + 0xe4, 0x90, + 0x4, 0x90, + 0x8, 0x88, + 0x10, 0x84, + 0x1f, 0x7c, + /* mask */ + 0x0, 0xfc, + 0x1, 0xfb, + 0x3, 0xf7, + 0x7, 0xff, + 0x7, 0xf7, + 0x3f, 0xf7, + 0x7f, 0xff, + 0xff, 0xff, + 0xf7, 0xfc, + 0xf7, 0xf0, + 0xff, 0xf0, + 0xf7, 0xf0, + 0xe7, 0xf0, + 0xf, 0xf8, + 0x1f, 0xfc, + 0x1f, 0x7c, +}; + +const unsigned char XC_hand1[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 2, /* y,x of hotspot */ + /* data */ + 0x30, 0x0, + 0x3c, 0x0, + 0xf, 0x0, + 0x7, 0x80, + 0x3, 0xc0, + 0x7, 0xe0, + 0xf, 0xf0, + 0x7, 0xf4, + 0xf, 0xfe, + 0xf, 0xfa, + 0x7, 0xe0, + 0x3, 0xe0, + 0x0, 0x52, + 0x0, 0x46, + 0x0, 0x2c, + 0x0, 0x18, + /* mask */ + 0xb8, 0x0, + 0x3e, 0x0, + 0x1f, 0x80, + 0xf, 0xc0, + 0x7, 0xe0, + 0xf, 0xf0, + 0x1f, 0xfc, + 0x1f, 0xfe, + 0x1f, 0xfe, + 0x1f, 0xfe, + 0xf, 0xfe, + 0x7, 0xfe, + 0x3, 0xfe, + 0x0, 0xfe, + 0x0, 0x7e, + 0x0, 0x3c, +}; + +const unsigned char XC_hand2[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 15, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x1, 0xfe, + 0x2, 0x1, + 0x4, 0x7e, + 0x8, 0x8, + 0x8, 0x70, + 0x8, 0x8, + 0x14, 0x70, + 0x22, 0x8, + 0x41, 0x30, + 0x20, 0xc0, + 0x12, 0x40, + 0x8, 0x80, + 0x5, 0x0, + 0x2, 0x0, + 0x0, 0x0, + /* mask */ + 0x1, 0xfe, + 0x3, 0xff, + 0x7, 0xff, + 0xf, 0xff, + 0x1f, 0xfe, + 0x1f, 0xf8, + 0x1f, 0xfc, + 0x3f, 0xf8, + 0x7f, 0xfc, + 0xff, 0xf8, + 0x7f, 0xf0, + 0x3f, 0xe0, + 0x1f, 0xc0, + 0xf, 0x80, + 0x7, 0x0, + 0x2, 0x0, +}; + +const unsigned char XC_heart[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 9, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x1f, 0x7c, + 0x31, 0xc6, + 0x60, 0x83, + 0x40, 0x1, + 0x40, 0x1, + 0x40, 0x1, + 0x40, 0x1, + 0x60, 0x3, + 0x30, 0x6, + 0x18, 0xc, + 0xc, 0x18, + 0x6, 0x30, + 0x3, 0x60, + 0x1, 0xc0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x9f, 0x7c, + 0x3f, 0xfe, + 0x71, 0xc7, + 0x60, 0x83, + 0x60, 0x3, + 0x60, 0x3, + 0x61, 0x43, + 0x70, 0x87, + 0x38, 0xe, + 0x1c, 0x1c, + 0xe, 0x38, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, + 0x0, 0x0, +}; + +const unsigned char XC_icon[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0xff, 0xff, + 0xaa, 0xab, + 0xd5, 0x55, + 0xaa, 0xab, + 0xd0, 0x5, + 0xa0, 0xb, + 0xd0, 0x5, + 0xa0, 0xb, + 0xd0, 0x5, + 0xa0, 0xb, + 0xd0, 0x5, + 0xa0, 0xb, + 0xd5, 0x55, + 0xaa, 0xab, + 0xd5, 0x55, + 0xff, 0xff, + /* mask */ + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, +}; + +const unsigned char XC_iron_cross[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x3f, 0xfc, + 0x1f, 0xf8, + 0x4f, 0xf2, + 0x67, 0xe6, + 0x73, 0xce, + 0x79, 0x9e, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x79, 0x9e, + 0x73, 0xce, + 0x67, 0xe6, + 0x4f, 0xf2, + 0x1f, 0xf8, + 0x3f, 0xfc, + 0x0, 0x0, + /* mask */ + 0x3f, 0xfc, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x7f, 0xfe, + 0x7f, 0xfe, + 0x3f, 0xfc, +}; + +const unsigned char XC_left_ptr[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 12, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x10, + 0x0, 0x30, + 0x0, 0x70, + 0x0, 0xf0, + 0x1, 0xf0, + 0x3, 0xf0, + 0x7, 0xf0, + 0xf, 0xf0, + 0x1, 0xf0, + 0x1, 0xb0, + 0x3, 0x10, + 0x3, 0x0, + 0x6, 0x0, + 0x6, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x18, + 0x0, 0x38, + 0x0, 0x78, + 0x0, 0xf8, + 0x1, 0xf8, + 0x3, 0xf8, + 0x7, 0xf8, + 0xf, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x3, 0xf8, + 0x7, 0xb8, + 0x7, 0x98, + 0xf, 0x0, + 0xf, 0x0, + 0x6, 0x0, +}; + +const unsigned char XC_left_side[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 15, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x6, + 0x0, 0x6, + 0x1, 0x6, + 0x0, 0x86, + 0x0, 0x46, + 0x0, 0x26, + 0x7f, 0xf6, + 0x0, 0x26, + 0x0, 0x46, + 0x0, 0x86, + 0x1, 0x6, + 0x0, 0x6, + 0x0, 0x6, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0xf, + 0x0, 0xf, + 0x3, 0xf, + 0x3, 0x8f, + 0x1, 0xcf, + 0x0, 0xef, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x0, 0xef, + 0x1, 0xcf, + 0x3, 0x8f, + 0x3, 0xf, + 0x0, 0xf, + 0x0, 0xf, + 0x0, 0x0, +}; + +const unsigned char XC_left_tee[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 13, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x80, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x0, + /* mask */ + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, +}; + +const unsigned char XC_leftbutton[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0xc0, 0x1, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xa2, 0x22, + 0xaa, 0xa2, + 0xaa, 0xa2, + 0xaa, 0xa2, + 0xaa, 0xa2, + 0xa2, 0x22, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xc0, 0x1, + /* mask */ + 0xbf, 0xfe, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x3f, 0xfe, +}; + +const unsigned char XC_ll_angle[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 12, 13, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x80, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_lr_angle[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 12, 4, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x98, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_man[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 5, 2, /* y,x of hotspot */ + /* data */ + 0x1, 0xc0, + 0xf, 0x78, + 0x1, 0x40, + 0x0, 0x81, + 0xe1, 0xc2, + 0xd2, 0x24, + 0xe, 0xb8, + 0x2, 0xa0, + 0x2, 0x20, + 0x1, 0x40, + 0x2, 0x20, + 0x4, 0x90, + 0x9, 0x48, + 0xa, 0x28, + 0x3c, 0x1e, + 0xfc, 0x1f, + /* mask */ + 0x7, 0xf8, + 0xf, 0xfc, + 0x1f, 0xfc, + 0x41, 0xc3, + 0xe3, 0xe7, + 0xff, 0xfe, + 0xdf, 0xfc, + 0xf, 0xf8, + 0x7, 0xe0, + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0x1f, 0xfc, + 0x3f, 0x7e, + 0xfe, 0x3f, + 0xfe, 0x3f, +}; + +const unsigned char XC_middlebutton[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0xc0, 0x1, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xa2, 0x22, + 0xaa, 0x2a, + 0xaa, 0x2a, + 0xaa, 0x2a, + 0xaa, 0x2a, + 0xa2, 0x22, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xc0, 0x1, + /* mask */ + 0xbf, 0xfe, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x3f, 0xfe, +}; + +const unsigned char XC_mouse[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 2, 11, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0xe0, + 0x0, 0x30, + 0x0, 0x60, + 0x0, 0xc0, + 0x1f, 0xfe, + 0x20, 0x1, + 0x6c, 0xcd, + 0x6c, 0xcd, + 0x6c, 0xcd, + 0x60, 0x1, + 0x60, 0x1, + 0x38, 0x6, + 0x6, 0x18, + 0x1, 0xe0, + 0x0, 0x0, + /* mask */ + 0x1, 0xf0, + 0x0, 0x78, + 0x0, 0xf0, + 0x0, 0xe0, + 0x1f, 0xfe, + 0x3f, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xef, 0xfc, + 0x7, 0xf8, + 0x3, 0xf0, + 0x1, 0xe0, +}; + +const unsigned char XC_pencil[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 15, 3, /* y,x of hotspot */ + /* data */ + 0x40, 0x38, + 0x0, 0x44, + 0x0, 0xc4, + 0x1, 0x48, + 0x1, 0x78, + 0x2, 0x10, + 0x2, 0x20, + 0x4, 0x20, + 0x4, 0x40, + 0x8, 0xc0, + 0x8, 0x80, + 0x11, 0x0, + 0x1e, 0x0, + 0x1c, 0x0, + 0x18, 0x0, + 0x10, 0x0, + /* mask */ + 0x80, 0x7e, + 0x0, 0xfe, + 0x1, 0xfe, + 0x1, 0xfc, + 0x3, 0xf8, + 0x3, 0xf8, + 0x7, 0xf0, + 0x7, 0xe0, + 0xf, 0xe0, + 0xf, 0xc0, + 0x1f, 0xc0, + 0x3f, 0x80, + 0x3f, 0x0, + 0x3e, 0x0, + 0x3c, 0x0, + 0x38, 0x0, +}; + +const unsigned char XC_pirate[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 12, 8, /* y,x of hotspot */ + /* data */ + 0x1, 0xe0, + 0x3, 0xf0, + 0x7, 0xf8, + 0xc, 0xcc, + 0xc, 0xcc, + 0x7, 0xf8, + 0x3, 0xf0, + 0x1, 0xe0, + 0x21, 0xe1, + 0x61, 0xe1, + 0x10, 0xc2, + 0xe, 0x1c, + 0x1, 0xe0, + 0x47, 0xf8, + 0x7c, 0xf, + 0x20, 0x1, + /* mask */ + 0x3, 0xf0, + 0x7, 0xf8, + 0xf, 0xfc, + 0x1f, 0xfe, + 0x1f, 0xfe, + 0xf, 0xfc, + 0x7, 0xf8, + 0x83, 0xf1, + 0xe3, 0xf1, + 0xf3, 0xf3, + 0x39, 0xef, + 0x1e, 0x1e, + 0x1, 0xe0, + 0xc7, 0xfe, + 0xff, 0xff, + 0x7c, 0xf, +}; + +const unsigned char XC_plus[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x81, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_question_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x83, 0xe0, + 0x7, 0xf0, + 0xe, 0x38, + 0xc, 0x18, + 0xc, 0x38, + 0xe, 0x30, + 0x7, 0x0, + 0x3, 0xc0, + 0x1, 0xc0, + 0x1, 0x40, + 0x1, 0x40, + 0x7, 0x70, + 0x3, 0x60, + 0x1, 0xc0, + 0x0, 0x80, + 0x0, 0x0, + /* mask */ + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0x1f, 0xfc, + 0x1e, 0x3c, + 0x1e, 0x7c, + 0x1f, 0x78, + 0xf, 0xf0, + 0x7, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, +}; + +const unsigned char XC_right_ptr[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 5, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x8, 0x0, + 0xc, 0x0, + 0xe, 0x0, + 0xf, 0x0, + 0xf, 0x80, + 0xf, 0xc0, + 0xf, 0xe0, + 0xf, 0xf0, + 0xf, 0x80, + 0xd, 0x80, + 0x8, 0xc0, + 0x0, 0xc0, + 0x0, 0x60, + 0x0, 0x60, + 0x0, 0x0, + /* mask */ + 0x18, 0x0, + 0x1c, 0x0, + 0x1e, 0x0, + 0x1f, 0x0, + 0x1f, 0x80, + 0x1f, 0xc0, + 0x1f, 0xe0, + 0x1f, 0xf0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x1f, 0xc0, + 0x1d, 0xe0, + 0x19, 0xe0, + 0x0, 0xf0, + 0x0, 0xf0, + 0x0, 0x60, +}; + +const unsigned char XC_right_side[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 2, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x60, 0x0, + 0x60, 0x0, + 0x60, 0x80, + 0x61, 0x0, + 0x62, 0x0, + 0x64, 0x0, + 0x6f, 0xfe, + 0x64, 0x0, + 0x62, 0x0, + 0x61, 0x0, + 0x60, 0x80, + 0x60, 0x0, + 0x60, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0xf0, 0x0, + 0xf0, 0x0, + 0xf0, 0xc0, + 0xf1, 0xc0, + 0xf3, 0x80, + 0xf7, 0x0, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xf7, 0x0, + 0xf3, 0x80, + 0xf1, 0xc0, + 0xf0, 0xc0, + 0xf0, 0x0, + 0xf0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_right_tee[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 4, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x98, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x0, 0x0, + /* mask */ + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, +}; + +const unsigned char XC_rightbutton[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0xc0, 0x1, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xa2, 0x22, + 0xa2, 0xaa, + 0xa2, 0xaa, + 0xa2, 0xaa, + 0xa2, 0xaa, + 0xa2, 0x22, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xbf, 0xfe, + 0xc0, 0x1, + /* mask */ + 0xbf, 0xfe, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x3f, 0xfe, +}; + +const unsigned char XC_rtl_logo[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 9, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x7f, 0xfe, + 0x44, 0x2, + 0x44, 0x2, + 0x44, 0x2, + 0x47, 0xfe, + 0x44, 0x22, + 0x44, 0x22, + 0x44, 0x22, + 0x44, 0x22, + 0x7f, 0xe2, + 0x40, 0x22, + 0x40, 0x22, + 0x40, 0x22, + 0x7f, 0xfe, + 0x0, 0x0, + /* mask */ + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xee, 0x7, + 0xef, 0xff, + 0xef, 0xff, + 0xef, 0xff, + 0xee, 0x77, + 0xee, 0x77, + 0xff, 0xf7, + 0xff, 0xf7, + 0xff, 0xf7, + 0xe0, 0x77, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, +}; + +const unsigned char XC_sailboat[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x42, 0x0, + 0x2, 0x0, + 0x6, 0x80, + 0x6, 0x80, + 0x6, 0xc0, + 0xe, 0xc0, + 0xe, 0xe0, + 0xe, 0xe0, + 0x1e, 0xf0, + 0x1e, 0xf0, + 0x1e, 0xf8, + 0x3e, 0xf8, + 0x1c, 0x7c, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x3, 0x0, + 0x7, 0x0, + 0x7, 0x80, + 0xf, 0xc0, + 0xf, 0xc0, + 0xf, 0xe0, + 0x1f, 0xe0, + 0x1f, 0xf0, + 0x1f, 0xf0, + 0x3f, 0xf8, + 0x3f, 0xf8, + 0x3f, 0xfc, + 0xff, 0xfc, + 0xff, 0xfe, + 0x1f, 0xff, + 0x7, 0xfe, +}; + +const unsigned char XC_sb_down_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 15, 8, /* y,x of hotspot */ + /* data */ + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, + 0x0, 0x80, + 0x0, 0x0, + /* mask */ + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0xf, 0xf8, + 0xf, 0xf8, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, + 0x0, 0x80, +}; + +const unsigned char XC_sb_h_double_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x8, 0x8, + 0x18, 0xc, + 0x3f, 0xfe, + 0x78, 0xf, + 0x3f, 0xfe, + 0x18, 0xc, + 0x8, 0x8, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x8c, 0x18, + 0x1c, 0x1c, + 0x3f, 0xfe, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x3f, 0xfe, + 0x1c, 0x1c, + 0xc, 0x18, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_sb_left_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 16, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x8, + 0x0, 0xc, + 0x7f, 0xfe, + 0x0, 0xf, + 0x7f, 0xfe, + 0x0, 0xc, + 0x0, 0x8, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x30, + 0x0, 0x38, + 0xff, 0xfc, + 0xff, 0xfe, + 0xff, 0xff, + 0xff, 0xfe, + 0xff, 0xfc, + 0x0, 0x38, + 0x0, 0x30, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_sb_right_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 0, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x8, 0x0, + 0x18, 0x0, + 0x3f, 0xff, + 0x78, 0x0, + 0x3f, 0xff, + 0x18, 0x0, + 0x8, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0xc, 0x0, + 0x1c, 0x0, + 0x3f, 0xff, + 0x7f, 0xff, + 0xff, 0xff, + 0x7f, 0xff, + 0x3f, 0xff, + 0x1c, 0x0, + 0xc, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_sb_up_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x80, + 0x9, 0xc0, + 0x3, 0xe0, + 0x7, 0xf0, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x0, 0x0, + /* mask */ + 0x0, 0x80, + 0x1, 0xc0, + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0xf, 0xf8, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, +}; + +const unsigned char XC_sb_v_double_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x80, + 0x9, 0xc0, + 0x3, 0xe0, + 0x7, 0xf0, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, + 0x0, 0x80, + 0x0, 0x0, + /* mask */ + 0x1, 0xc0, + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0xf, 0xf8, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0x3, 0xe0, + 0xf, 0xf8, + 0xf, 0xf8, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, + 0x0, 0x0, +}; + +const unsigned char XC_shuttle[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 5, /* y,x of hotspot */ + /* data */ + 0x84, 0x0, + 0xe, 0x0, + 0x1f, 0x0, + 0x7b, 0x80, + 0x7b, 0xa0, + 0x7b, 0x90, + 0x7b, 0x88, + 0x7b, 0x88, + 0x7b, 0x88, + 0x7b, 0x88, + 0x7b, 0x8c, + 0x7b, 0x8e, + 0x7b, 0xbf, + 0x11, 0x18, + 0x1e, 0x0, + 0xc, 0x0, + /* mask */ + 0x1c, 0x0, + 0x3e, 0x0, + 0x7f, 0x0, + 0xff, 0x0, + 0xff, 0x60, + 0xff, 0x70, + 0xff, 0x78, + 0xff, 0x78, + 0xff, 0x78, + 0xff, 0x78, + 0xff, 0x7c, + 0xff, 0x7e, + 0xff, 0x7f, + 0x7f, 0x7e, + 0x7e, 0x30, + 0x3c, 0x0, +}; + +const unsigned char XC_sizing[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x81, 0xfe, + 0x0, 0x2, + 0x0, 0x2, + 0x0, 0x2, + 0x7, 0xe2, + 0x4, 0x22, + 0x44, 0x22, + 0x44, 0x22, + 0x44, 0x20, + 0x47, 0xe0, + 0x48, 0x0, + 0x50, 0x0, + 0x60, 0x0, + 0x7f, 0x80, + 0x0, 0x0, + /* mask */ + 0x3, 0xff, + 0x3, 0xff, + 0x3, 0xff, + 0x0, 0x7, + 0xf, 0xf7, + 0xf, 0xf7, + 0xef, 0xf7, + 0xee, 0x77, + 0xee, 0x77, + 0xef, 0xf7, + 0xef, 0xf0, + 0xff, 0xf0, + 0xf8, 0x0, + 0xff, 0xc0, + 0xff, 0xc0, + 0xff, 0xc0, +}; + +const unsigned char XC_spider[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 10, /* y,x of hotspot */ + /* data */ + 0x8, 0x4, + 0x4, 0x8, + 0x4, 0x8, + 0x2, 0x10, + 0x2, 0x10, + 0xe1, 0xe1, + 0x19, 0xe6, + 0x7, 0xf8, + 0x7, 0xf8, + 0x19, 0xe6, + 0xe1, 0xe1, + 0x2, 0x10, + 0x2, 0x10, + 0x4, 0x8, + 0x4, 0x8, + 0x8, 0x4, + /* mask */ + 0x18, 0x6, + 0xc, 0xc, + 0x4, 0x8, + 0x6, 0x18, + 0x83, 0xf1, + 0xf3, 0xf3, + 0x3b, 0xf6, + 0xf, 0xfc, + 0x7, 0xfc, + 0x1f, 0xf6, + 0xf3, 0xf3, + 0x83, 0xf1, + 0x2, 0x18, + 0x6, 0x18, + 0xc, 0xc, + 0x18, 0x6, +}; + +const unsigned char XC_spraycan[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 2, 4, /* y,x of hotspot */ + /* data */ + 0x98, 0x0, + 0x2, 0x0, + 0x18, 0xb0, + 0x2, 0x78, + 0x18, 0x58, + 0x0, 0xfc, + 0x0, 0x84, + 0x0, 0x9c, + 0x0, 0x94, + 0x0, 0x9c, + 0x0, 0x94, + 0x0, 0x9c, + 0x0, 0x9c, + 0x0, 0x84, + 0x0, 0x84, + 0x0, 0xfc, + /* mask */ + 0x30, 0x0, + 0x34, 0x60, + 0x35, 0xf0, + 0x35, 0xf0, + 0x35, 0xf8, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, + 0x3, 0xfc, +}; + +const unsigned char XC_star[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x80, 0x80, + 0x1, 0x40, + 0x1, 0x40, + 0x1, 0x40, + 0x2, 0x20, + 0x2, 0x20, + 0x2, 0x20, + 0x1c, 0x9c, + 0x60, 0x3, + 0x1c, 0x1c, + 0x4, 0x90, + 0x9, 0x48, + 0x12, 0x24, + 0x14, 0x14, + 0x18, 0xc, + 0x10, 0x4, + /* mask */ + 0x0, 0x80, + 0x1, 0xc0, + 0x1, 0xc0, + 0x3, 0x60, + 0x3, 0x60, + 0x6, 0x30, + 0x1e, 0x38, + 0x7c, 0x9f, + 0xe0, 0x3, + 0x7c, 0x1f, + 0x1c, 0x9c, + 0x19, 0xcc, + 0x33, 0x66, + 0x36, 0x36, + 0x3c, 0x1e, + 0x38, 0xe, +}; + +const unsigned char XC_target[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x81, 0xc0, + 0x7, 0xf0, + 0xe, 0x38, + 0x18, 0xc, + 0x30, 0x6, + 0x60, 0x83, + 0x61, 0x43, + 0x60, 0x83, + 0x30, 0x6, + 0x18, 0xc, + 0xe, 0x38, + 0x7, 0xf0, + 0x1, 0xc0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0x1e, 0x3c, + 0x38, 0xe, + 0x70, 0x87, + 0xe1, 0xc3, + 0xe3, 0x63, + 0xe1, 0xc3, + 0x70, 0x87, + 0x38, 0xe, + 0x1e, 0x3c, + 0xf, 0xf8, + 0x3, 0xe0, + 0x0, 0x0, +}; + +const unsigned char XC_tcross[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 7, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0xc0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x3f, 0xfe, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x0, 0x0, +}; + +const unsigned char XC_top_left_arrow[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 15, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x80, 0x6, + 0x0, 0x1e, + 0x0, 0x7c, + 0x1, 0xfc, + 0x7, 0xf8, + 0x1f, 0xf8, + 0x1, 0xf0, + 0x1, 0xf0, + 0x2, 0x60, + 0x4, 0x60, + 0x8, 0x40, + 0x10, 0x40, + 0x20, 0x0, + 0x40, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x7, + 0x0, 0x1f, + 0x0, 0x7f, + 0x1, 0xfe, + 0x7, 0xfe, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xf8, + 0x3, 0xf8, + 0x7, 0xf0, + 0xe, 0xf0, + 0x1c, 0xe0, + 0x38, 0xe0, + 0x70, 0xe0, + 0xe0, 0x0, + 0xc0, 0x0, +}; + +const unsigned char XC_top_left_corner[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 15, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0xff, 0xfe, + 0x7f, 0xfe, + 0x0, 0x6, + 0x0, 0x6, + 0x0, 0x6, + 0x1f, 0xc6, + 0x0, 0xc6, + 0x1, 0x46, + 0x2, 0x46, + 0x4, 0x46, + 0x8, 0x46, + 0x10, 0x46, + 0x0, 0x6, + 0x0, 0x6, + 0x0, 0x0, + /* mask */ + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x0, 0xf, + 0x3f, 0xef, + 0x3f, 0xef, + 0x3f, 0xef, + 0x3, 0xef, + 0x7, 0xef, + 0xe, 0xef, + 0x1c, 0xef, + 0x38, 0xef, + 0x30, 0xef, + 0x0, 0xf, + 0x0, 0xf, +}; + +const unsigned char XC_top_right_corner[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 2, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0xff, 0xfe, + 0x7f, 0xfe, + 0x60, 0x0, + 0x60, 0x0, + 0x60, 0x0, + 0x63, 0xf8, + 0x63, 0x0, + 0x62, 0x80, + 0x62, 0x40, + 0x62, 0x20, + 0x62, 0x10, + 0x62, 0x8, + 0x60, 0x0, + 0x60, 0x0, + 0x0, 0x0, + /* mask */ + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xf0, 0x0, + 0xf7, 0xfc, + 0xf7, 0xfc, + 0xf7, 0xfc, + 0xf7, 0xc0, + 0xf7, 0xe0, + 0xf7, 0x70, + 0xf7, 0x38, + 0xf7, 0x1c, + 0xf7, 0xc, + 0xf0, 0x0, + 0xf0, 0x0, +}; + +const unsigned char XC_top_side[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 1, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0xff, 0xfe, + 0x3f, 0xfe, + 0x0, 0x0, + 0x0, 0x80, + 0x1, 0xc0, + 0x2, 0xa0, + 0x4, 0x90, + 0x8, 0x88, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x0, + /* mask */ + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x7f, 0xff, + 0x1, 0xc0, + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0x1d, 0xdc, + 0x19, 0xcc, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, +}; + +const unsigned char XC_top_tee[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 3, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0xff, 0xfe, + 0x7f, 0xfe, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x1, 0x80, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x3, 0xc0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_trek[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 0, 8, /* y,x of hotspot */ + /* data */ + 0x8, 0x80, + 0x8, 0x0, + 0x1, 0xc0, + 0x3, 0xe0, + 0x7, 0xf0, + 0x7, 0x70, + 0x7, 0xf0, + 0x3, 0xe0, + 0x1, 0xc0, + 0x0, 0x80, + 0x5, 0xd0, + 0x6, 0xb0, + 0x4, 0x90, + 0x4, 0x10, + 0x4, 0x10, + 0x4, 0x10, + /* mask */ + 0x1, 0xc0, + 0x1, 0xc0, + 0x3, 0xe0, + 0x7, 0xf0, + 0xf, 0xf8, + 0xf, 0xf8, + 0xf, 0xf8, + 0x7, 0xf0, + 0x3, 0xe0, + 0x5, 0xd0, + 0xf, 0xf8, + 0xf, 0xf8, + 0xf, 0xf8, + 0xe, 0xb8, + 0xe, 0xb8, + 0xe, 0x38, +}; + +const unsigned char XC_ul_angle[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 3, 13, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x18, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x3c, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_umbrella[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 3, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x89, 0x10, + 0x14, 0x40, + 0x65, 0x92, + 0x13, 0xe4, + 0xc, 0x98, + 0x30, 0x86, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x2, 0x80, + 0x2, 0x80, + 0x1, 0x0, + 0x0, 0x0, + /* mask */ + 0x76, 0xe8, + 0xdf, 0xfb, + 0x3f, 0xfd, + 0xff, 0xfe, + 0x3f, 0xff, + 0xff, 0xff, + 0x79, 0xcf, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x7, 0xc0, + 0x7, 0xc0, + 0x7, 0xc0, + 0x7, 0xc0, + 0x3, 0x80, +}; + +const unsigned char XC_ur_angle[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 3, 4, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x1f, 0xf8, + 0x1f, 0xf8, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x18, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + /* mask */ + 0x0, 0x0, + 0x0, 0x0, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3f, 0xfc, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x3c, 0x0, + 0x0, 0x0, + 0x0, 0x0, +}; + +const unsigned char XC_watch[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 9, 1, /* y,x of hotspot */ + /* data */ + 0x7, 0xf8, + 0x7, 0xf8, + 0x7, 0xf8, + 0xf, 0xfc, + 0x18, 0x86, + 0x30, 0x83, + 0xe0, 0x81, + 0xe1, 0xc1, + 0xe1, 0xc1, + 0xe0, 0x21, + 0x30, 0x13, + 0x18, 0x6, + 0xf, 0xfc, + 0x7, 0xf8, + 0x7, 0xf8, + 0x7, 0xf8, + /* mask */ + 0xf, 0xfc, + 0xf, 0xfc, + 0xf, 0xfc, + 0x1f, 0xfe, + 0x3f, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0xff, 0xff, + 0x3f, 0xff, + 0x1f, 0xfe, + 0xf, 0xfc, + 0xf, 0xfc, + 0xf, 0xfc, +}; + +const unsigned char XC_xterm[] = { + 16, /* 16x16 size */ + 1, /* 1 bit depth */ + 8, 8, /* y,x of hotspot */ + /* data */ + 0x0, 0x0, + 0xf, 0x70, + 0x9, 0xc0, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x0, 0x80, + 0x1, 0xc0, + 0x7, 0x70, + 0x0, 0x0, + /* mask */ + 0xf, 0x78, + 0xf, 0xf8, + 0xf, 0xf8, + 0x3, 0xe0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x1, 0xc0, + 0x3, 0xe0, + 0xf, 0xf8, + 0xf, 0xf8, + 0xf, 0x78, +}; + diff --git a/src/glut/beos/glutDstr.cpp b/src/glut/beos/glutDstr.cpp new file mode 100644 index 000000000..281a03970 --- /dev/null +++ b/src/glut/beos/glutDstr.cpp @@ -0,0 +1,83 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutDstr.cpp + * + * DESCRIPTION: convert display string into a Be options variable + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include +#include "glutint.h" +#include "glutState.h" + +/*********************************************************** + * FUNCTION: glutInitDisplayString + * + * DESCRIPTION: sets the display string variable + ***********************************************************/ +void APIENTRY +glutInitDisplayString(const char *string) +{ + if (gState.displayString) { + free(gState.displayString); + } + if (string) { + gState.displayString = strdup(string); + if (!gState.displayString) + __glutFatalError("out of memory."); + } else + gState.displayString = NULL; +} + +/*********************************************************** + * FUNCTION: __glutConvertDisplayModeFromString + * + * DESCRIPTION: converts the current display mode into a BGLView + * display mode, printing warnings as appropriate. + * + * PARAMETERS: if options is non-NULL, the current display mode is + * returned in it. + * + * RETURNS: 1 if the current display mode is possible, else 0 + ***********************************************************/ +int __glutConvertDisplayModeFromString(unsigned long *options) { + ulong newoptions = 0; + + char *word = strtok(gState.displayString, " \t"); + do { + char *cstr = strpbrk(word, "=> +#include "glutint.h" +#include "glutState.h" +#include "glutBlocker.h" + +/*********************************************************** + * CLASS: GLUTtimer + * + * DESCRIPTION: list of timer callbacks + ***********************************************************/ +struct GLUTtimer { + GLUTtimer *next; // list of timers + bigtime_t timeout; // time to be called + GLUTtimerCB func; // function to call + int value; // value +}; + +/*********************************************************** + * Private variables + ***********************************************************/ +static GLUTtimer *__glutTimerList = 0; // list of timer callbacks +static GLUTtimer *freeTimerList = 0; + +/*********************************************************** + * FUNCTION: glutTimerFunc (7.19) + * + * DESCRIPTION: register a new timer callback + ***********************************************************/ +void APIENTRY +glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value) +{ + GLUTtimer *timer, *other; + GLUTtimer **prevptr; + + if (!timerFunc) + return; + + if (freeTimerList) { + timer = freeTimerList; + freeTimerList = timer->next; + } else { + timer = new GLUTtimer(); + if (!timer) + __glutFatalError("out of memory."); + } + + timer->func = timerFunc; + timer->value = value; + timer->next = NULL; + timer->timeout = system_time() + (interval*1000); // 1000 ticks in a millisecond + prevptr = &__glutTimerList; + other = *prevptr; + while (other && (other->timeout < timer->timeout)) { + prevptr = &other->next; + other = *prevptr; + } + timer->next = other; + *prevptr = timer; +} + +/*********************************************************** + * FUNCTION: handleTimeouts + * + * DESCRIPTION: private function to handle outstanding timeouts + ***********************************************************/ +static void +handleTimeouts(void) +{ + bigtime_t now; + GLUTtimer *timer; + + /* Assumption is that __glutTimerList is already determined + to be non-NULL. */ + now = system_time(); + while (__glutTimerList->timeout <= now) { + timer = __glutTimerList; + if(gState.currentWindow) + gState.currentWindow->LockGL(); + timer->func(timer->value); + if(gState.currentWindow) + gState.currentWindow->UnlockGL(); + __glutTimerList = timer->next; + timer->next = freeTimerList; + freeTimerList = timer; + if (!__glutTimerList) + break; + } +} + + +/*********************************************************** + * FUNCTION: processEventsAndTimeouts + * + * DESCRIPTION: clear gBlock, then check all windows for events + ***********************************************************/ +static void +processEventsAndTimeouts(void) +{ + gBlock.WaitEvent(); // if there is already an event, returns + // immediately, otherwise wait forever + gBlock.ClearEvents(); + + if(gState.quitAll) + exit(0); // exit handler cleans up windows and quits nicely + + if (gState.currentWindow) + gState.currentWindow->LockGL(); + for(int i=0; ianyevents) { + win->anyevents = false; + if (win->reshapeEvent) { + win->reshapeEvent = false; + __glutSetWindow(win); + win->reshape(win->m_width, win->m_height); + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->displayEvent) { + win->displayEvent = false; + __glutSetWindow(win); + win->display(); + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->mouseEvent) { + win->mouseEvent = false; + __glutSetWindow(win); + if (win->mouse) { + gState.modifierKeys = win->modifierKeys; + win->mouse(win->button, win->mouseState, win->mouseX, win->mouseY); + gState.modifierKeys = ~0; + } + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->menuEvent) { + win->menuEvent = false; + __glutSetWindow(win); + GlutMenu *menu = __glutGetMenuByNum(win->menuNumber); + if (menu) { + gState.currentMenu = menu; + menu->select(win->menuValue); + } + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->statusEvent) { + win->statusEvent = false; + __glutSetWindow(win); + if (gState.menuStatus) { + gState.currentMenu = __glutGetMenuByNum(win->menuNumber); + gState.menuStatus(win->menuStatus, win->statusX, win->statusY); + } + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->motionEvent) { + win->motionEvent = false; + __glutSetWindow(win); + if (win->motion) + win->motion(win->motionX, win->motionY); + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->passiveEvent) { + win->passiveEvent = false; + __glutSetWindow(win); + if (win->passive) + win->passive(win->passiveX, win->passiveY); + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->keybEvent) { + win->keybEvent = false; + __glutSetWindow(win); + if (win->keyboard) { + gState.modifierKeys = win->modifierKeys; + win->keyboard(win->key, win->keyX, win->keyY); + gState.modifierKeys = ~0; + } + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->specialEvent) { + win->specialEvent = false; + __glutSetWindow(win); + if (win->special) { + gState.modifierKeys = win->modifierKeys; + win->special(win->specialKey, win->specialX, win->specialY); + gState.modifierKeys = ~0; + } + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->entryEvent) { + win->entryEvent = false; + __glutSetWindow(win); + if (win->entry) + win->entry(win->entryState); + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + + if (win->windowStatusEvent) { + win->windowStatusEvent = false; + __glutSetWindow(win); + if (win->windowStatus) + win->windowStatus(win->visState); + } + if (!gState.windowList[i]) + continue; // window was destroyed by callback! + } + } + } + if (gState.currentWindow) + gState.currentWindow->UnlockGL(); + + // This code isn't necessary since BGLView automatically traps errors +#if 0 + if(gState.debug) { + for(int i=0; iLockGL(); + glutReportErrors(); + gState.windowList[i]->UnlockGL(); + } + } + } +#endif + if (__glutTimerList) { + handleTimeouts(); + } +} + +/*********************************************************** + * FUNCTION: waitForSomething + * + * DESCRIPTION: use gBlock to wait for a new event or timeout + ***********************************************************/ +static void +waitForSomething(void) +{ + bigtime_t timeout = __glutTimerList->timeout; + bigtime_t now = system_time(); + + if (gBlock.PendingEvent()) + goto immediatelyHandleEvent; + + if(timeout>now) + gBlock.WaitEvent(timeout-now); + if (gBlock.PendingEvent()) { + immediatelyHandleEvent: + processEventsAndTimeouts(); + } else { + if (__glutTimerList) + handleTimeouts(); + } +} + +/*********************************************************** + * FUNCTION: idleWait + * + * DESCRIPTION: check for events, then call idle function + ***********************************************************/ +static void +idleWait(void) +{ + if (gBlock.PendingEvent()) { + processEventsAndTimeouts(); + } else { + if (__glutTimerList) + handleTimeouts(); + } + /* Make sure idle func still exists! */ + if(gState.currentWindow) + gState.currentWindow->LockGL(); + if (gState.idle) { + gState.idle(); + } + if(gState.currentWindow) + gState.currentWindow->UnlockGL(); +} + +/*********************************************************** + * FUNCTION: glutMainLoop (3.1) + * + * DESCRIPTION: enter the event processing loop + ***********************************************************/ +void glutMainLoop() +{ + if (!gState.windowListSize) + __glutFatalUsage("main loop entered with no windows created."); + + if(gState.currentWindow) + gState.currentWindow->UnlockGL(); + + for (;;) { + if (gState.idle) { + idleWait(); + } else { + if (__glutTimerList) { + waitForSomething(); + } else { + processEventsAndTimeouts(); + } + } + } +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: KeyDown + * + * DESCRIPTION: handles keyboard and special events + ***********************************************************/ +void GlutWindow::KeyDown(const char *s, int32 slen) +{ + ulong aChar = s[0]; + BGLView::KeyDown(s,slen); + + BPoint p; + + switch (aChar) { + case B_FUNCTION_KEY: + switch(Window()->CurrentMessage()->FindInt32("key")) { + case B_F1_KEY: + aChar = GLUT_KEY_F1; + goto specialLabel; + case B_F2_KEY: + aChar = GLUT_KEY_F2; + goto specialLabel; + case B_F3_KEY: + aChar = GLUT_KEY_F3; + goto specialLabel; + case B_F4_KEY: + aChar = GLUT_KEY_F4; + goto specialLabel; + case B_F5_KEY: + aChar = GLUT_KEY_F5; + goto specialLabel; + case B_F6_KEY: + aChar = GLUT_KEY_F6; + goto specialLabel; + case B_F7_KEY: + aChar = GLUT_KEY_F7; + goto specialLabel; + case B_F8_KEY: + aChar = GLUT_KEY_F8; + goto specialLabel; + case B_F9_KEY: + aChar = GLUT_KEY_F9; + goto specialLabel; + case B_F10_KEY: + aChar = GLUT_KEY_F10; + goto specialLabel; + case B_F11_KEY: + aChar = GLUT_KEY_F11; + goto specialLabel; + case B_F12_KEY: + aChar = GLUT_KEY_F12; + goto specialLabel; + default: + return; + } + case B_LEFT_ARROW: + aChar = GLUT_KEY_LEFT; + goto specialLabel; + case B_UP_ARROW: + aChar = GLUT_KEY_UP; + goto specialLabel; + case B_RIGHT_ARROW: + aChar = GLUT_KEY_RIGHT; + goto specialLabel; + case B_DOWN_ARROW: + aChar = GLUT_KEY_DOWN; + goto specialLabel; + case B_PAGE_UP: + aChar = GLUT_KEY_PAGE_UP; + goto specialLabel; + case B_PAGE_DOWN: + aChar = GLUT_KEY_PAGE_DOWN; + goto specialLabel; + case B_HOME: + aChar = GLUT_KEY_HOME; + goto specialLabel; + case B_END: + aChar = GLUT_KEY_END; + goto specialLabel; + case B_INSERT: + aChar = GLUT_KEY_INSERT; +specialLabel: + if (special) { + anyevents = specialEvent = true; + GetMouse(&p,&m_buttons); + specialKey = aChar; + specialX = (int)p.x; + specialY = (int)p.y; + goto setModifiers; // set the modifier variable + } + return; + + default: + break; + } + + if (keyboard) { + anyevents = keybEvent = true; + GetMouse(&p,&m_buttons); + key = aChar; + keyX = (int)p.x; + keyY = (int)p.y; +setModifiers: + modifierKeys = 0; + uint32 beMod = Window()->CurrentMessage()->FindInt32("modifiers"); + if(beMod & B_SHIFT_KEY) + modifierKeys |= GLUT_ACTIVE_SHIFT; + if(beMod & B_CONTROL_KEY) + modifierKeys |= GLUT_ACTIVE_CTRL; + if(beMod & B_OPTION_KEY) { + // since the window traps B_COMMAND_KEY, we'll have to settle + // for the option key.. but we need to get the raw character, + // not the Unicode-enhanced version + key = Window()->CurrentMessage()->FindInt32("raw_char"); + modifierKeys |= GLUT_ACTIVE_ALT; + } + gBlock.NewEvent(); + } +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: MouseDown + * + * DESCRIPTION: handles mouse and menustatus events + ***********************************************************/ +void GlutWindow::MouseDown(BPoint point) +{ + BGLView::MouseDown(point); + MouseCheck(); +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: MouseCheck + * + * DESCRIPTION: checks for button state changes + ***********************************************************/ +void GlutWindow::MouseCheck() +{ + if (mouseEvent) + return; // we already have an outstanding mouse event + + BPoint point; + uint32 newButtons; + GetMouse(&point, &newButtons); + if (m_buttons != newButtons) { + if (newButtons&B_PRIMARY_MOUSE_BUTTON && !(m_buttons&B_PRIMARY_MOUSE_BUTTON)) { + button = GLUT_LEFT_BUTTON; + mouseState = GLUT_DOWN; + } else if (m_buttons&B_PRIMARY_MOUSE_BUTTON && !(newButtons&B_PRIMARY_MOUSE_BUTTON)) { + button = GLUT_LEFT_BUTTON; + mouseState = GLUT_UP; + } else if (newButtons&B_SECONDARY_MOUSE_BUTTON && !(m_buttons&B_SECONDARY_MOUSE_BUTTON)) { + button = GLUT_RIGHT_BUTTON; + mouseState = GLUT_DOWN; + } else if (m_buttons&B_SECONDARY_MOUSE_BUTTON && !(newButtons&B_SECONDARY_MOUSE_BUTTON)) { + button = GLUT_RIGHT_BUTTON; + mouseState = GLUT_UP; + } else if (newButtons&B_TERTIARY_MOUSE_BUTTON && !(m_buttons&B_TERTIARY_MOUSE_BUTTON)) { + button = GLUT_MIDDLE_BUTTON; + mouseState = GLUT_DOWN; + } else if (m_buttons&B_TERTIARY_MOUSE_BUTTON && !(newButtons&B_TERTIARY_MOUSE_BUTTON)) { + button = GLUT_MIDDLE_BUTTON; + mouseState = GLUT_UP; + } + } else { + return; // no change, return + } + m_buttons = newButtons; + + if (mouseState == GLUT_DOWN) { + BWindow *w = Window(); + GlutMenu *m = __glutGetMenuByNum(menu[button]); + if (m) { + if (gState.menuStatus) { + anyevents = statusEvent = true; + menuNumber = menu[button]; + menuStatus = GLUT_MENU_IN_USE; + statusX = (int)point.x; + statusY = (int)point.y; + gBlock.NewEvent(); + } + BRect bounds = w->Frame(); + point.x += bounds.left; + point.y += bounds.top; + GlutPopUp *bmenu = static_cast(m->CreateBMenu()); // start menu + bmenu->point = point; + bmenu->win = this; + thread_id menu_thread = spawn_thread(MenuThread, "menu thread", B_NORMAL_PRIORITY, bmenu); + resume_thread(menu_thread); + return; + } + } + + if (mouse) { + anyevents = mouseEvent = true; + mouseX = (int)point.x; + mouseY = (int)point.y; + modifierKeys = 0; + uint32 beMod = modifiers(); + if(beMod & B_SHIFT_KEY) + modifierKeys |= GLUT_ACTIVE_SHIFT; + if(beMod & B_CONTROL_KEY) + modifierKeys |= GLUT_ACTIVE_CTRL; + if(beMod & B_OPTION_KEY) { + modifierKeys |= GLUT_ACTIVE_ALT; + } + gBlock.NewEvent(); + } +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: MouseMoved + * + * DESCRIPTION: handles entry, motion, and passive events + ***********************************************************/ +void GlutWindow::MouseMoved(BPoint point, + ulong transit, const BMessage *msg) +{ + BGLView::MouseMoved(point,transit,msg); + + if(transit != B_INSIDE_VIEW) { + if (entry) { + anyevents = entryEvent = true; + gBlock.NewEvent(); + } + if (transit == B_ENTERED_VIEW) { + entryState = GLUT_ENTERED; + MakeFocus(); // make me the current focus + __glutSetCursor(cursor); + } else + entryState = GLUT_LEFT; + } + + MouseCheck(); + if(m_buttons) { + if(motion) { + anyevents = motionEvent = true; + motionX = (int)point.x; + motionY = (int)point.y; + gBlock.NewEvent(); + } + } else { + if(passive) { + anyevents = passiveEvent = true; + passiveX = (int)point.x; + passiveY = (int)point.y; + gBlock.NewEvent(); + } + } +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: FrameResized + * + * DESCRIPTION: handles reshape event + ***********************************************************/ +void GlutWindow::FrameResized(float width, float height) +{ + BGLView::FrameResized(width, height); + if (visible) { + anyevents = reshapeEvent = true; + m_width = (int)(width)+1; + m_height = (int)(height)+1; + gBlock.NewEvent(); + } +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: Draw + * + * DESCRIPTION: handles reshape and display events + ***********************************************************/ +void GlutWindow::Draw(BRect updateRect) +{ + BGLView::Draw(updateRect); + BRect frame = Frame(); + if (m_width != (frame.Width()+1) || m_height != (frame.Height()+1)) { + FrameResized(frame.Width(), frame.Height()); + } + Window()->Lock(); + if (visible) { + anyevents = displayEvent = true; + gBlock.NewEvent(); + } + Window()->Unlock(); +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: Pulse + * + * DESCRIPTION: handles mouse up event (MouseUp is broken) + ***********************************************************/ +void GlutWindow::Pulse() +{ + BGLView::Pulse(); + if (m_buttons) { // if there are buttons pressed + MouseCheck(); + } +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: ErrorCallback + * + * DESCRIPTION: handles GL error messages + ***********************************************************/ +void GlutWindow::ErrorCallback(GLenum errorCode) { + __glutWarning("GL error: %s", gluErrorString(errorCode)); +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: MenuThread + * + * DESCRIPTION: a new thread to launch popup menu, wait + * wait for response, then clean up afterwards and + * send appropriate messages + ***********************************************************/ +long GlutWindow::MenuThread(void *m) { + GlutPopUp *bmenu = static_cast(m); + GlutWindow *win = bmenu->win; // my window + GlutBMenuItem *result = (GlutBMenuItem*)bmenu->Go(bmenu->point); + win->Window()->Lock(); + win->anyevents = win->statusEvent = true; + win->menuStatus = GLUT_MENU_NOT_IN_USE; + win->menuNumber = bmenu->menu; + BPoint cursor; + uint32 buttons; + win->GetMouse(&cursor, &buttons); + win->statusX = (int)cursor.x; + win->statusY = (int)cursor.y; + if(result && result->menu) { + win->menuEvent = true; + win->menuNumber = result->menu; // in case it was a submenu + win->menuValue = result->value; + } + win->Window()->Unlock(); + gBlock.NewEvent(); + delete bmenu; + return 0; +} diff --git a/src/glut/beos/glutGet.cpp b/src/glut/beos/glutGet.cpp new file mode 100644 index 000000000..04a8479b9 --- /dev/null +++ b/src/glut/beos/glutGet.cpp @@ -0,0 +1,211 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutGet.cpp + * + * DESCRIPTION: get state information from GL + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include +#include + +#include "glutint.h" +#include "glutState.h" + +/*********************************************************** + * Global variables + ***********************************************************/ +// rough guess, since we don't know how big the monitor really is +const float dots_per_mm = (72/25.4); // dots per millimeter + +/*********************************************************** + * FUNCTION: glutGet (9.1) + * + * DESCRIPTION: retrieve window and GL state + ***********************************************************/ +int glutGet(GLenum state) { + switch(state) { + case GLUT_WINDOW_X: + {BAutolock winlock(gState.currentWindow->Window()); // need to lock the window + if (gState.currentWindow->parent) + return (int)gState.currentWindow->Frame().left; + else + return (int)gState.currentWindow->Window()->Frame().left; + } + case GLUT_WINDOW_Y: + {BAutolock winlock(gState.currentWindow->Window()); + if (gState.currentWindow->parent) + return (int)gState.currentWindow->Frame().top; + else + return (int)gState.currentWindow->Window()->Frame().top; + } + case GLUT_WINDOW_WIDTH: + {BAutolock winlock(gState.currentWindow->Window()); + return gState.currentWindow->m_width; + } + case GLUT_WINDOW_HEIGHT: + {BAutolock winlock(gState.currentWindow->Window()); + return gState.currentWindow->m_height; + } + case GLUT_WINDOW_PARENT: + {BAutolock winlock(gState.currentWindow->Window()); + if(gState.currentWindow->parent) + return gState.currentWindow->parent->num + 1; + else + return 0; + } + case GLUT_WINDOW_NUM_CHILDREN: + {BAutolock winlock(gState.currentWindow->Window()); + int num = 0; + GlutWindow *children = gState.currentWindow->children; + while (children) { + num++; + children = children->siblings; + } + return num; + } + case GLUT_WINDOW_BUFFER_SIZE: // best guesses + case GLUT_WINDOW_DEPTH_SIZE: + return 32; + + case GLUT_WINDOW_STENCIL_SIZE: + case GLUT_WINDOW_RED_SIZE: // always 24-bit color + case GLUT_WINDOW_GREEN_SIZE: + case GLUT_WINDOW_BLUE_SIZE: + case GLUT_WINDOW_ALPHA_SIZE: + case GLUT_WINDOW_ACCUM_RED_SIZE: + case GLUT_WINDOW_ACCUM_GREEN_SIZE: + case GLUT_WINDOW_ACCUM_BLUE_SIZE: + case GLUT_WINDOW_ACCUM_ALPHA_SIZE: + return 8; + + case GLUT_WINDOW_DOUBLEBUFFER: // always double-buffered RGBA + case GLUT_WINDOW_RGBA: + return 1; + + case GLUT_WINDOW_COLORMAP_SIZE: // don't support these + case GLUT_WINDOW_NUM_SAMPLES: + case GLUT_WINDOW_STEREO: + return 0; + + case GLUT_WINDOW_CURSOR: + return gState.currentWindow->cursor; // don't need to lock window since it won't change + + case GLUT_SCREEN_WIDTH: + return (int)(BScreen().Frame().Width()) + 1; + case GLUT_SCREEN_HEIGHT: + return (int)(BScreen().Frame().Height()) + 1; + case GLUT_SCREEN_WIDTH_MM: + return (int)((BScreen().Frame().Width() + 1) / dots_per_mm); + case GLUT_SCREEN_HEIGHT_MM: + return (int)((BScreen().Frame().Height() + 1) / dots_per_mm); + case GLUT_MENU_NUM_ITEMS: + return gState.currentMenu->num; + case GLUT_DISPLAY_MODE_POSSIBLE: + return __glutConvertDisplayMode(0); // returns 1 if possible + case GLUT_INIT_DISPLAY_MODE: + return gState.displayMode; + case GLUT_INIT_WINDOW_X: + return gState.initX; + case GLUT_INIT_WINDOW_Y: + return gState.initY; + case GLUT_INIT_WINDOW_WIDTH: + return gState.initWidth; + case GLUT_INIT_WINDOW_HEIGHT: + return gState.initHeight; + case GLUT_ELAPSED_TIME: + bigtime_t elapsed, beginning, now; + __glutInitTime(&beginning); + now = system_time(); + elapsed = now - beginning; + return (int) (elapsed / 1000); // 1000 ticks in a millisecond + default: + __glutWarning("invalid glutGet parameter: %d", state); + return -1; + } +} + +/*********************************************************** + * FUNCTION: glutLayerGet (9.2) + * + * DESCRIPTION: since we don't support layers, this is easy + ***********************************************************/ +int glutLayerGet(GLenum info) { + switch(info) { + case GLUT_OVERLAY_POSSIBLE: + case GLUT_HAS_OVERLAY: + return 0; + case GLUT_LAYER_IN_USE: + return GLUT_NORMAL; + case GLUT_TRANSPARENT_INDEX: + return -1; + case GLUT_NORMAL_DAMAGED: + return gState.currentWindow->displayEvent; + case GLUT_OVERLAY_DAMAGED: + return -1; + default: + __glutWarning("invalid glutLayerGet param: %d", info); + return -1; + } +} + +/*********************************************************** + * FUNCTION: glutDeviceGet (9.3) + * + * DESCRIPTION: get info about I/O devices we support + * easy, since BeOS only supports a keyboard and mouse now + ***********************************************************/ +int glutDeviceGet(GLenum info) { + switch(info) { + case GLUT_HAS_KEYBOARD: + case GLUT_HAS_MOUSE: + return 1; + + case GLUT_HAS_SPACEBALL: + case GLUT_HAS_DIAL_AND_BUTTON_BOX: + case GLUT_HAS_TABLET: + case GLUT_NUM_SPACEBALL_BUTTONS: + case GLUT_NUM_BUTTON_BOX_BUTTONS: + case GLUT_NUM_DIALS: + case GLUT_NUM_TABLET_BUTTONS: + return 0; + + case GLUT_NUM_MOUSE_BUTTONS: + { + int32 mouseButtons = 3; // good guess + if(get_mouse_type(&mouseButtons) != B_OK) { + __glutWarning("error getting number of mouse buttons"); + } + return mouseButtons; + } + + default: + __glutWarning("invalid glutDeviceGet parameter: %d", info); + return -1; + } +} + +/*********************************************************** + * FUNCTION: glutGetModifiers (9.4) + * + * DESCRIPTION: get the modifier key state for the current window + ***********************************************************/ +int glutGetModifiers() { + if(gState.modifierKeys == (int) ~0) { + __glutWarning( + "glutCurrentModifiers: do not call outside core input callback."); + return 0; + } + return gState.modifierKeys; +} + diff --git a/src/glut/beos/glutInit.cpp b/src/glut/beos/glutInit.cpp new file mode 100644 index 000000000..401081328 --- /dev/null +++ b/src/glut/beos/glutInit.cpp @@ -0,0 +1,263 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutInit.cpp + * + * DESCRIPTION: initialize GLUT state + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include +#include +#include "glutint.h" +#include "glutState.h" +#include "glutBlocker.h" +#include "beos_x11.h" + +/*********************************************************** + * Global variables + ***********************************************************/ +GlutState gState; +char *__glutProgramName = NULL; + +/*********************************************************** + * Private variables + ***********************************************************/ +static int __glutArgc; +static char **__glutArgv; + +/*********************************************************** + * FUNCTION: __glutInitTime + * + * DESCRIPTION: set up start time variable + ***********************************************************/ +void __glutInitTime(bigtime_t *beginning) +{ + static int beenhere = 0; + static bigtime_t genesis; + + if (!beenhere) { + genesis = system_time(); + beenhere = 1; + } + *beginning = genesis; +} + +/*********************************************************** + * FUNCTION: removeArgs + * + * DESCRIPTION: helper function for glutInit to remove args + * from argv variable passed in + ***********************************************************/ +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; +} + +/*********************************************************** + * FUNCTION: bAppThread + * + * DESCRIPTION: starts the BApplication message loop running + ***********************************************************/ +static int32 bAppThread(void *arg) { + be_app->Lock(); + return be_app->Run(); +} + +/*********************************************************** + * FUNCTION: sigHandler + * + * DESCRIPTION: shuts down the app on CTRL-C + ***********************************************************/ +static void sigHandler(int) { + gState.quitAll = true; + gBlock.NewEvent(); +} + +/*********************************************************** + * FUNCTION: glutInit (2.1) + * + * DESCRIPTION: create BApplication, parse cmd-line arguments, + * and set up gState structure. + ***********************************************************/ +void glutInit(int *argcp, char **argv) { + char *str, *geometry = NULL; + int i; + + if (gState.display) { + __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] = strdup(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")) { + __glutWarning("-display option only valid for X glut."); + if (++i >= __glutArgc) { + __glutFatalError( + "follow -display option with X display name."); + } + 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")) { + __glutWarning("-direct option only valid for X glut."); + removeArgs(argcp, &argv[1], 1); + } else if (!strcmp(__glutArgv[i], "-indirect")) { + __glutWarning("-indirect option only valid for X glut."); + removeArgs(argcp, &argv[1], 1); + } else if (!strcmp(__glutArgv[i], "-iconic")) { + __glutWarning("-iconic option doesn't make sense in BeOS."); + removeArgs(argcp, &argv[1], 1); + } else if (!strcmp(__glutArgv[i], "-gldebug")) { + gState.debug = true; + removeArgs(argcp, &argv[1], 1); + } else if (!strcmp(__glutArgv[i], "-sync")) { + __glutWarning("-sync option only valid for X glut."); + removeArgs(argcp, &argv[1], 1); + } else { + /* Once unknown option encountered, stop command line + processing. */ + break; + } + } + + __glutInit(); /* Create BApplication first so DisplayWidth() works */ + 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) + gState.initWidth = width; + } + if (HeightValue & flags) { + /* Careful because X does not allow zero or negative + height windows */ + if (height > 0) + gState.initHeight = height; + } + if (XValue & flags) { + if (XNegative & flags) + x = DisplayWidth() + x - gState.initWidth; + /* Play safe: reject negative X locations */ + if (x >= 0) + gState.initX = x; + } + if (YValue & flags) { + if (YNegative & flags) + y = DisplayHeight() + y - gState.initHeight; + /* Play safe: reject negative Y locations */ + if (y >= 0) + gState.initY = y; + } + } +} + +/*********************************************************** + * FUNCTION: __glutInit + * + * DESCRIPTION: create BApplication, parse cmd-line arguments, + * and set up gState structure. + ***********************************************************/ +void __glutInit() { + // open BApplication + gState.display = new BApplication("application/x-glut-demo"); + be_app->Unlock(); + gState.appthread = spawn_thread(bAppThread, "BApplication", B_NORMAL_PRIORITY, 0); + resume_thread(gState.appthread); + + bigtime_t unused; + __glutInitTime(&unused); + + /* set atexit() function to destroy all windows before exiting */ + if(atexit(__glutDestroyAllWindows)) + __glutFatalError("can't set exit handler"); + + /* similarly, destroy all windows on CTRL-C */ + signal(SIGINT, sigHandler); +} + +/*********************************************************** + * FUNCTION: glutInitWindowPosition (2.2) + * + * DESCRIPTION: set initial window position + ***********************************************************/ +void glutInitWindowPosition(int x, int y) { + gState.initX = x; + gState.initY = y; +} + +/*********************************************************** + * FUNCTION: glutInitWindowSize (2.2) + * + * DESCRIPTION: set initial window size + ***********************************************************/ +void glutInitWindowSize(int width, int height) { + gState.initWidth = width; + gState.initHeight = height; +} + +/*********************************************************** + * FUNCTION: glutInitDisplayMode (2.3) + * + * DESCRIPTION: set initial display mode + ***********************************************************/ +void glutInitDisplayMode(unsigned int mode) { + gState.displayMode = mode; +} diff --git a/src/glut/beos/glutMenu.cpp b/src/glut/beos/glutMenu.cpp new file mode 100644 index 000000000..2f9e6a2c6 --- /dev/null +++ b/src/glut/beos/glutMenu.cpp @@ -0,0 +1,326 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * FILE: glutMenu.cpp + * + * DESCRIPTION: code for popup menu handling + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include +#include "glutint.h" +#include "glutState.h" + +/*********************************************************** + * Private variables + ***********************************************************/ +static GlutMenu **menuList = 0; +static int menuListSize = 0; + +/*********************************************************** + * FUNCTION: getUnusedMenuSlot + * + * DESCRIPTION: helper function to get a new menu slot + ***********************************************************/ +GlutMenu *__glutGetMenuByNum(int menunum) +{ + if (menunum < 1 || menunum > menuListSize) { + return NULL; + } + return menuList[menunum - 1]; +} + +/*********************************************************** + * FUNCTION: getUnusedMenuSlot + * + * DESCRIPTION: helper function to get a new menu slot + ***********************************************************/ +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++; + menuList = (GlutMenu **) + realloc(menuList, menuListSize * sizeof(GlutMenu *)); + if (!menuList) + __glutFatalError("out of memory."); + menuList[menuListSize - 1] = NULL; + return menuListSize - 1; +} + +/*********************************************************** + * FUNCTION: glutCreateMenu (6.1) + * + * DESCRIPTION: create a new menu + ***********************************************************/ +int APIENTRY +glutCreateMenu(GLUTselectCB selectFunc) +{ + GlutMenu *menu; + int menuid; + + menuid = getUnusedMenuSlot(); + menu = new GlutMenu(menuid, selectFunc); // constructor sets up members + menuList[menuid] = menu; + gState.currentMenu = menu; + return menuid + 1; +} + +/*********************************************************** + * FUNCTION: glutSetMenu (6.2) + * glutGetMenu + * + * DESCRIPTION: set and get the current menu + ***********************************************************/ +int APIENTRY +glutGetMenu(void) +{ + if (gState.currentMenu) { + return gState.currentMenu->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; + } + gState.currentMenu = menu; +} + +/*********************************************************** + * FUNCTION: glutDestroyMenu (6.3) + * + * DESCRIPTION: destroy the specified menu + ***********************************************************/ +void APIENTRY +glutDestroyMenu(int menunum) +{ + GlutMenu *menu = __glutGetMenuByNum(menunum); + menuList[menunum - 1] = 0; + if (gState.currentMenu == menu) { + gState.currentMenu = 0; + } + delete menu; +} + +/*********************************************************** + * FUNCTION: glutAddMenuEntry (6.4) + * + * DESCRIPTION: add a new menu item + ***********************************************************/ +void +glutAddMenuEntry(const char *label, int value) +{ + new GlutMenuItem(gState.currentMenu, false, value, label); +} + +/*********************************************************** + * FUNCTION: glutAddSubMenu (6.5) + * + * DESCRIPTION: add a new submenu + ***********************************************************/ +void +glutAddSubMenu(const char *label, int menu) +{ + new GlutMenuItem(gState.currentMenu, true, menu-1, label); +} + +/*********************************************************** + * FUNCTION: glutChangeToMenuEntry (6.6) + * + * DESCRIPTION: change menuitem into a menu entry + ***********************************************************/ +void +glutChangeToMenuEntry(int num, const char *label, int value) +{ + GlutMenuItem *item; + int i; + + i = gState.currentMenu->num; + item = gState.currentMenu->list; + while (item) { + if (i == num) { + free(item->label); + item->label = strdup(label); + item->isTrigger = false; + item->value = value; + return; + } + i--; + item = item->next; + } + __glutWarning("Current menu has no %d item.", num); +} + +/*********************************************************** + * FUNCTION: glutChangeToSubMenu (6.7) + * + * DESCRIPTION: change menuitem into a submenu + ***********************************************************/ +void +glutChangeToSubMenu(int num, const char *label, int menu) +{ + GlutMenuItem *item; + int i; + + i = gState.currentMenu->num; + item = gState.currentMenu->list; + while (item) { + if (i == num) { + free(item->label); + item->label = strdup(label); + item->isTrigger = true; + item->value = menu-1; + return; + } + i--; + item = item->next; + } + __glutWarning("Current menu has no %d item.", num); +} + +/*********************************************************** + * FUNCTION: glutRemoveMenuItem (6.8) + * + * DESCRIPTION: remove a menu item + ***********************************************************/ +void +glutRemoveMenuItem(int num) +{ + GlutMenuItem *item, **prev; + int i; + + i = gState.currentMenu->num; + prev = &gState.currentMenu->list; + item = gState.currentMenu->list; + + while (item) { + if (i == num) { + gState.currentMenu->num--; + + /* Patch up menu's item list. */ + *prev = item->next; + + free(item->label); + delete item; + return; + } + i--; + prev = &item->next; + item = item->next; + } + __glutWarning("Current menu has no %d item.", num); +} + +/*********************************************************** + * FUNCTION: glutAttachMenu (6.9) + * glutDetachMenu + * + * DESCRIPTION: attach and detach menu from view + ***********************************************************/ +void +glutAttachMenu(int button) +{ + gState.currentWindow->menu[button] = gState.currentMenu->id + 1; +} + +void +glutDetachMenu(int button) +{ + gState.currentWindow->menu[button] = 0; +} + +/*********************************************************** + * CLASS: GlutMenu + * + * FUNCTION: CreateBMenu + * + * DESCRIPTION: construct a BPopupMenu for this menu + ***********************************************************/ +BMenu *GlutMenu::CreateBMenu(bool toplevel) { + BMenu *bpopup; + if(toplevel) { + bpopup = new GlutPopUp(id+1); + } else { + bpopup = new BMenu(""); + } + GlutMenuItem *item = list; + while (item) { + GlutBMenuItem *bitem; + if(item->isTrigger) { + // recursively call CreateBMenu + bitem = new GlutBMenuItem(menuList[item->value]->CreateBMenu(false)); + bitem->SetLabel(item->label); + bitem->menu = 0; // real menu items start at 1 + bitem->value = 0; + } else { + bitem = new GlutBMenuItem(item->label); + bitem->menu = id + 1; + bitem->value = item->value; + } + bpopup->AddItem(bitem, 0); + item = item->next; + } + return bpopup; +} + +/*********************************************************** + * CLASS: GlutMenu + * + * FUNCTION: (destructor) + * + * DESCRIPTION: destroy the menu and its items (but not submenus!) + ***********************************************************/ +GlutMenu::~GlutMenu() { + while (list) { + GlutMenuItem *next = list->next; + delete list; + list = next; + } +} + +/*********************************************************** + * CLASS: GlutMenuItem + * + * FUNCTION: (constructor) + * + * DESCRIPTION: construct the new menu item and add to parent + ***********************************************************/ +GlutMenuItem::GlutMenuItem(GlutMenu *n_menu, bool n_trig, int n_value, const char *n_label) +{ + menu = n_menu; + isTrigger = n_trig; + value = n_value; + label = strdup(n_label); + next = menu->list; + menu->list = this; + menu->num++; +} diff --git a/src/glut/beos/glutMenu.h b/src/glut/beos/glutMenu.h new file mode 100644 index 000000000..1ee170694 --- /dev/null +++ b/src/glut/beos/glutMenu.h @@ -0,0 +1,84 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * FILE: glutMenu.h + * + * DESCRIPTION: the GlutMenu class is a simple popup menu + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include +#include + +/*********************************************************** + * Definitions + ***********************************************************/ +const int32 MENU_ITEM = 'menu'; + +/*********************************************************** + * CLASS: GlutMenu + ***********************************************************/ +class GlutMenuItem; +class GlutPopUp; +class GlutMenu { +public: + GlutMenu(int n_id, GLUTselectCB n_select) { + id = n_id; + select = n_select; + list = 0; + num = 0; + } + ~GlutMenu(); + BMenu *CreateBMenu(bool toplevel=true); // construct BPopUpMenu + + // public data + int id; + GLUTselectCB select; // callback function + GlutMenuItem *list; // list of menu items + int num; // number of items +}; + +/*********************************************************** + * CLASS: GlutMenuItem + ***********************************************************/ +class GlutMenuItem { +public: + GlutMenuItem(GlutMenu *n_menu, bool n_trig, int n_value, const char *n_label); + + // public data + GlutMenu *menu; // parent menu + bool isTrigger; // are we a submenu? + int value; // value to send, or submenu id if isTrigger + char *label; // strdup'ed label string + GlutMenuItem *next; // next menu entry on list +}; + +/*********************************************************** + * CLASS: GlutPopUp + ***********************************************************/ +class GlutPopUp : public BPopUpMenu { +public: + GlutPopUp(int m) : BPopUpMenu(0, false, false) { menu = m;} + + BPoint point; // point to start menu + GlutWindow *win; // pointer to my window + int menu; // my menu number +}; + +/*********************************************************** + * CLASS: GlutBMenuItem + ***********************************************************/ +class GlutBMenuItem : public BMenuItem { +public: + GlutBMenuItem(const char *name) : BMenuItem(name, 0) {} + GlutBMenuItem(BMenu* menu) : BMenuItem(menu) {} + int menu, value; +}; diff --git a/src/glut/beos/glutOverlay.cpp b/src/glut/beos/glutOverlay.cpp new file mode 100644 index 000000000..fed757fe9 --- /dev/null +++ b/src/glut/beos/glutOverlay.cpp @@ -0,0 +1,47 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutOverlay.cpp + * + * DESCRIPTION: we don't support overlays, so this code is + * really simple + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include "glutint.h" + +void glutEstablishOverlay() { + __glutFatalError("BeOS lacks overlay support."); +} + +void glutUseLayer(GLenum layer) { + // ignore +} + +void glutRemoveOverlay() { + // ignore +} + +void glutPostOverlayRedisplay() { + // ignore +} + +void glutShowOverlay() { + // ignore +} + +void glutHideOverlay() { + // ignore +} + +void glutPostWindowOverlayRedisplay(int win) { + // ignore +} diff --git a/src/glut/beos/glutState.h b/src/glut/beos/glutState.h new file mode 100644 index 000000000..9c44eb6b5 --- /dev/null +++ b/src/glut/beos/glutState.h @@ -0,0 +1,71 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutState.h + * + * DESCRIPTION: the global state for GLUT + * (takes the place of glutint.h in the C version) + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include "glutWindow.h" +#include "glutMenu.h" + +/*********************************************************** + * CLASS: GlutState + * + * DESCRIPTION: all the global state variables + ***********************************************************/ +struct GlutState { + BApplication *display; + thread_id appthread; + + int initX, initY; // initial window position + int initWidth, initHeight; // initial window size + unsigned int displayMode; // initial display mode + char *displayString; // verbose display mode + + GlutWindow *currentWindow; // current window + GlutMenu *currentMenu; // current menu + + GlutWindow **windowList; // array of pointers to windows + int windowListSize; // size of window list + + GLUTidleCB idle; // idle callback + GLUTmenuStatusCB menuStatus; // menu status callback + int modifierKeys; // only valid during keyboard callback + + bool debug; // call glGetError + bool quitAll; // quit + + GlutState() { + display = 0; + appthread = 0; + initX = initY = -1; + initWidth = initHeight = 300; + displayMode = GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH; + displayString = 0; + currentWindow = 0; + currentMenu = 0; + windowList = 0; + windowListSize = 0; + idle = 0; + menuStatus = 0; + modifierKeys = ~0; + debug = quitAll = false; + } +}; + +/*********************************************************** + * Global variable (declared in glutInit.cpp) + ***********************************************************/ +extern GlutState gState; diff --git a/src/glut/beos/glutWindow.cpp b/src/glut/beos/glutWindow.cpp new file mode 100644 index 000000000..66ea2a00a --- /dev/null +++ b/src/glut/beos/glutWindow.cpp @@ -0,0 +1,633 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutWindow.cpp + * + * DESCRIPTION: all the routines for dealing with GlutWindows + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include "glutint.h" +#include "glutState.h" +#include "glutBlocker.h" + +/*********************************************************** + * FUNCTION: getUnusedWindowSlot + * + * DESCRIPTION: helper function to get a new window slot + ***********************************************************/ +static int +getUnusedWindowSlot() +{ + int i; + + /* Look for allocated, unused slot. */ + for (i = 0; i < gState.windowListSize; i++) { + if (!gState.windowList[i]) { + return i; + } + } + /* Allocate a new slot. */ + gState.windowListSize++; + gState.windowList = (GlutWindow **) + realloc(gState.windowList, + gState.windowListSize * sizeof(GlutWindow *)); + + if (!gState.windowList) + __glutFatalError("out of memory."); + gState.windowList[gState.windowListSize - 1] = NULL; + return gState.windowListSize - 1; +} + +/*********************************************************** + * FUNCTION: __glutDefaultDisplay + * __glutDefaultReshape + * + * DESCRIPTION: default display and reshape functions + ***********************************************************/ +static void +__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.", + gState.currentWindow->num + 1); +} + +void +__glutDefaultReshape(int width, int height) +{ + /* Adjust the viewport of the window */ + glViewport(0, 0, (GLsizei) width, (GLsizei) height); +} + +/*********************************************************** + * CLASS: GlutWindow + * + * FUNCTION: (constructor) + * + * DESCRIPTION: creates a new GLUT window + * note: subwindows don't resize, but top-level windows + * follow all sides + ***********************************************************/ +GlutWindow::GlutWindow(GlutWindow *nparent, char *name, + int x, int y, int width, int height, ulong options) : + BGLView( + (nparent ? BRect(x,y,x+width-1,y+height-1) : + BRect(0,0,width-1,height-1)), name, + (nparent ? B_FOLLOW_NONE : B_FOLLOW_ALL_SIDES), + B_WILL_DRAW|B_FRAME_EVENTS|B_FULL_UPDATE_ON_RESIZE|B_PULSE_NEEDED, + options) +{ + // add myself to window list + num = getUnusedWindowSlot(); + gState.windowList[num] = this; + + // set up parent/children relationships + parent = nparent; + if (parent) { + siblings = parent->children; + parent->children = this; + } else { + siblings = 0; + } + children = 0; + + // initialize variables + cursor = GLUT_CURSOR_INHERIT; // default cursor + for (int i = 0; i < GLUT_MAX_MENUS; i++) { + menu[i] = 0; + } + m_width = width; + m_height = height; + m_buttons = 0; + + // clear callbacks + display = __glutDefaultDisplay; + reshape = __glutDefaultReshape; + mouse = 0; + motion = 0; + passive = 0; + entry = 0; + keyboard = 0; + visibility = 0; + special = 0; + windowStatus = 0; + + // clear event counters + anyevents = 1; + displayEvent = 1; // get a reshape and a display event right away + reshapeEvent = 1; + mouseEvent = 0; + motionEvent = 0; + passiveEvent = 0; + entryEvent = 0; + keybEvent = 0; + windowStatusEvent = 0; // DirectConnected() will report change in + visState = -1; // visibility + specialEvent = 0; + statusEvent = 0; + menuEvent = 0; + visible = true; + gBlock.QuickNewEvent(); + + // if i'm a subwindow, add me to my parent view + if (parent) { + parent->Window()->Lock(); + parent->AddChild(this); + parent->Window()->Unlock(); + } else { + // if I'm a top-level window, create my BWindow + GlutBWindow *mybwindow = new GlutBWindow( + BRect(x,y,x+width-1,y+height-1), name); + mybwindow->AddChild(this); + mybwindow->bgl = this; + mybwindow->Show(); + } + + // give me the keyboard focus (focus follows mouse, X style, as + // implemented in GlutWindow::MouseMoved()) + Window()->Lock(); + MakeFocus(); + Window()->Unlock(); + + // make myself the default window + __glutSetWindow(this); +} + +/*********************************************************** + * FUNCTION: glutCreateWindow (4.1) + * + * DESCRIPTION: creates a new GLUT window + ***********************************************************/ +int glutCreateWindow(const char *name) { + if (!be_app) + __glutInit(); + + ulong options; + if (!__glutConvertDisplayMode(&options)) { + __glutWarning("visual with necessary capabilities not found."); + } + + // if X or Y is negative, then start at a reasonable position + bool defaultxy = (gState.initX < 0) || (gState.initY < 0); + + GlutWindow *window = new GlutWindow(0, const_cast(name), + (defaultxy ? 50 : gState.initX), (defaultxy ? 50 : gState.initY), + gState.initWidth, gState.initHeight, options); + + return window->num + 1; +} + +/*********************************************************** + * FUNCTION: glutCreateSubWindow (4.2) + * + * DESCRIPTION: creates a new GLUT subwindow + * Note: a subwindow is a GlutWindow (which is actually + * a BGLView) without its own BWindow + ***********************************************************/ +int glutCreateSubWindow(int win, int x, int y, int width, int height) { + ulong options; + if (!__glutConvertDisplayMode(&options)) { + __glutFatalError("visual with necessary capabilities not found."); + } + + GlutWindow *window = new GlutWindow(gState.windowList[win-1], "child", + x, y, width, height, options); + + return window->num + 1; +} + +/*********************************************************** + * FUNCTION: __glutSetWindow + * + * DESCRIPTION: set the current window (utility function) + ***********************************************************/ +void +__glutSetWindow(GlutWindow * window) +{ + if (gState.currentWindow) + gState.currentWindow->UnlockGL(); + gState.currentWindow = window; + gState.currentWindow->LockGL(); +} + +/*********************************************************** + * FUNCTION: glutSetWindow (4.3) + * glutGetWindow + * + * DESCRIPTION: set and get the current window + ***********************************************************/ +void glutSetWindow(int win) { + GlutWindow *window; + + if (win < 1 || win > gState.windowListSize) { + __glutWarning("glutSetWindow attempted on bogus window."); + return; + } + window = gState.windowList[win - 1]; + if (!window) { + __glutWarning("glutSetWindow attempted on bogus window."); + return; + } + __glutSetWindow(window); +} + +int glutGetWindow() { + if (gState.currentWindow) { + return gState.currentWindow->num + 1; + } else { + return 0; + } +} + +/*********************************************************** + * FUNCTION: __glutDestroyWindow + * + * DESCRIPTION: recursively set entries to 0 + ***********************************************************/ +static void +__glutDestroyWindow(GlutWindow *window, GlutWindow *initialWindow) { + // first, find all children recursively and set their entries to 0 + GlutWindow *cur = window->children; + while (cur) { + GlutWindow *siblings = cur->siblings; + __glutDestroyWindow(cur, initialWindow); + cur = siblings; + } + + /* Remove from parent's children list (only necessary for + non-initial windows and subwindows!). */ + GlutWindow *parent = window->parent; + if (parent && parent == initialWindow->parent) { + GlutWindow **prev = &parent->children; + cur = parent->children; + while (cur) { + if (cur == window) { + *prev = cur->siblings; + break; + } + prev = &(cur->siblings); + cur = cur->siblings; + } + } + + // finally, check if we are the current window, and set to 0 + if (gState.currentWindow == window) { + gState.currentWindow = 0; + } + gState.windowList[window->num] = 0; +} + +/*********************************************************** + * FUNCTION: glutDestroyWindow (4.4) + * + * DESCRIPTION: destroy window and all its children + ***********************************************************/ +void glutDestroyWindow(int win) { + // can't destroy a window if another window has the GL context + if (gState.currentWindow) + gState.currentWindow->UnlockGL(); + + // lock the window + GlutWindow *window = gState.windowList[win-1]; + BWindow *bwindow = window->Window(); + bwindow->Lock(); + + // if win is the current window, set current window to 0 + if (gState.currentWindow == window) { + gState.currentWindow = 0; + } + + // recursively set child entries to 0 + __glutDestroyWindow(window, window); + + // try flushing OpenGL + window->LockGL(); + glFlush(); + window->UnlockGL(); + + // now, if the window was top-level, delete its BWindow + if(!window->parent) { + bwindow->Quit(); + } else { + // else, detach it from the BWindow and delete it + window->RemoveSelf(); + delete window; + bwindow->Unlock(); + } + // relock GL if the current window is still valid + if(gState.currentWindow) + gState.currentWindow->LockGL(); +} + +/*********************************************************** + * FUNCTION: __glutDestroyAllWindows + * + * DESCRIPTION: destroy all windows when exit() is called + * this seems to be necessary to avoid delays + * and crashes when using BDirectWindow + ***********************************************************/ +void __glutDestroyAllWindows() { + for(int i=0; iLock(); + gState.display->Quit(); + status_t ignored; + wait_for_thread(gState.appthread, &ignored); +} + +/*********************************************************** + * FUNCTION: glutPostRedisplay (4.5) + * + * DESCRIPTION: mark window as needing redisplay + ***********************************************************/ +void glutPostRedisplay() { + gState.currentWindow->Window()->Lock(); + gState.currentWindow->anyevents = true; + gState.currentWindow->displayEvent = true; + gState.currentWindow->Window()->Unlock(); + gBlock.QuickNewEvent(); +} + +/*********************************************************** + * FUNCTION: glutPostWindowRedisplay + * + * DESCRIPTION: mark window as needing redisplay + ***********************************************************/ +void glutPostWindowRedisplay(int win) { + GlutWindow *gwin = gState.windowList[win - 1]; + gwin->Window()->Lock(); + gwin->anyevents = true; + gwin->displayEvent = true; + gwin->Window()->Unlock(); + gBlock.QuickNewEvent(); +} + +/*********************************************************** + * FUNCTION: glutSwapBuffers (4.6) + * + * DESCRIPTION: swap buffers + ***********************************************************/ +void glutSwapBuffers() { + gState.currentWindow->SwapBuffers(); +} + +/*********************************************************** + * FUNCTION: glutPositionWindow (4.7) + * + * DESCRIPTION: move window + ***********************************************************/ +void glutPositionWindow(int x, int y) { + BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + win->Lock(); + if (gState.currentWindow->parent) + gState.currentWindow->MoveTo(x, y); // move the child view + else { + if(win->IsFullScreen()) { + win->SetFullScreen(false); + } + win->MoveTo(x, y); // move the window + } + win->Unlock(); +} + +/*********************************************************** + * FUNCTION: glutReshapeWindow (4.8) + * + * DESCRIPTION: reshape window (we'll catch the callback + * when the view gets a Draw() message + ***********************************************************/ +void glutReshapeWindow(int width, int height) { + BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + win->Lock(); + if (gState.currentWindow->parent) + gState.currentWindow->ResizeTo(width-1, height-1); // resize the child + else { + if(win->IsFullScreen()) { + win->SetFullScreen(false); + } + win->ResizeTo(width-1, height-1); // resize the parent + } + win->Unlock(); +} + +/*********************************************************** + * FUNCTION: glutFullScreen (4.9) + * + * DESCRIPTION: makes the window full screen + ***********************************************************/ +void glutFullScreen() { + BDirectWindow *win = dynamic_cast(gState.currentWindow->Window()); + win->Lock(); + win->SetFullScreen(true); + win->Unlock(); +} + +/*********************************************************** + * FUNCTION: glutPopWindow (4.10) + * glutPushWindow + * + * DESCRIPTION: change the stacking order of the current window + * NOTE: I can't figure out how to do this for windows, + * and there is no concept of "stacking order" for + * subwindows, so these are currently no-ops. + ***********************************************************/ +void glutPopWindow() { } +void glutPushWindow() { } + +/*********************************************************** + * FUNCTION: glutShowWindow (4.11) + * glutHideWindow + * glutIconifyWindow + * + * DESCRIPTION: change display status of current window + ***********************************************************/ +void glutShowWindow() { + gState.currentWindow->Window()->Lock(); + if (gState.currentWindow->parent) // subwindow + gState.currentWindow->Show(); + else { + if(gState.currentWindow->Window()->IsHidden()) + gState.currentWindow->Window()->Show(); // show the actual BWindow + gState.currentWindow->Window()->Minimize(false); + } + gState.currentWindow->Window()->Unlock(); +} + +void glutHideWindow() { + gState.currentWindow->Window()->Lock(); + if (gState.currentWindow->parent) // subwindow + gState.currentWindow->Hide(); + else + gState.currentWindow->Window()->Hide(); // show the actual BWindow + gState.currentWindow->Window()->Unlock(); +} + +void glutIconifyWindow() { + if(gState.currentWindow->parent) + __glutFatalError("can't iconify a subwindow"); + + gState.currentWindow->Window()->Lock(); + gState.currentWindow->Window()->Minimize(true); + gState.currentWindow->Window()->Unlock(); +} + +/*********************************************************** + * FUNCTION: glutSetWindowTitle (4.12) + * glutSetIconTitle + * + * DESCRIPTION: set the window title (icon title is same) + ***********************************************************/ +void glutSetWindowTitle(const char *name) { + if (gState.currentWindow->parent) + __glutFatalError("glutSetWindowTitle: isn't a top-level window"); + + gState.currentWindow->Window()->Lock(); + gState.currentWindow->Window()->SetTitle(name); + gState.currentWindow->Window()->Unlock(); +} + +void glutSetIconTitle(const char *name) { + glutSetWindowTitle(name); +} + +/*********************************************************** + * FUNCTION: __glutConvertDisplayMode + * + * DESCRIPTION: converts the current display mode into a BGLView + * display mode, printing warnings as appropriate. + * + * PARAMETERS: if options is non-NULL, the current display mode is + * returned in it. + * + * RETURNS: 1 if the current display mode is possible, else 0 + ***********************************************************/ +int __glutConvertDisplayMode(unsigned long *options) { + if (gState.displayString) { + /* __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. This big ugly code is in glutDstr.cpp */ + return __glutConvertDisplayModeFromString(options); + } + + if(options) { + ulong newoptions = 0; + if(gState.displayMode & GLUT_ACCUM) + newoptions |= BGL_ACCUM; + if(gState.displayMode & GLUT_ALPHA) + newoptions |= BGL_ALPHA; + if(gState.displayMode & GLUT_DEPTH) + newoptions |= BGL_DEPTH; + if(gState.displayMode & GLUT_DOUBLE) + newoptions |= BGL_DOUBLE; + if(gState.displayMode & GLUT_STENCIL) + newoptions |= BGL_STENCIL; + *options = newoptions; + } + + if(gState.displayMode & GLUT_INDEX) { + __glutWarning("BeOS doesn't support indexed color"); + return 0; + } + if(gState.displayMode & GLUT_MULTISAMPLE) { + return 1; // try to go without multisampling + } + if(gState.displayMode & GLUT_STEREO) { + __glutWarning("BeOS doesn't support stereo windows"); + return 0; + } + if(gState.displayMode & GLUT_LUMINANCE) { + __glutWarning("BeOS doesn't support luminance color model"); + return 0; + } + return 1; // visual supported +} + +/*********************************************************** + * CLASS: GlutBWindow + * + * DESCRIPTION: very thin wrapper around BWindow + ***********************************************************/ +GlutBWindow::GlutBWindow(BRect frame, char *name) : + BDirectWindow(frame, name, B_TITLED_WINDOW, 0) { + fConnectionDisabled = false; + bgl = 0; + SetPulseRate(100000); + + if (!SupportsWindowMode()) { + __glutFatalError("video card doesn't support windowed operation"); + } +} + +void GlutBWindow::DirectConnected( direct_buffer_info *info ) { + bgl->DirectConnected(info); + if(bgl && !fConnectionDisabled) { + bgl->EnableDirectMode(true); + } + int newVisState; + if((info->buffer_state & B_DIRECT_MODE_MASK) == B_DIRECT_START) { + bgl->visible = true; + } + if(!bgl->visible || info->buffer_state == B_DIRECT_STOP) + newVisState = GLUT_HIDDEN; + else { + if (info->clip_list_count == 0) + newVisState = GLUT_FULLY_COVERED; + else if (info->clip_list_count == 1) + newVisState = GLUT_FULLY_RETAINED; + else + newVisState = GLUT_PARTIALLY_RETAINED; + } + if(newVisState != bgl->visState) { + bgl->visState = newVisState; + bgl->anyevents = bgl->windowStatusEvent = true; + gBlock.NewEvent(); + } +} + +GlutBWindow::~GlutBWindow() { + fConnectionDisabled = true; + if(bgl) { + bgl->EnableDirectMode(false); + } + if(!IsHidden()) + Hide(); + Sync(); +} + +bool GlutBWindow::QuitRequested() { + gState.quitAll = true; + gBlock.NewEvent(); + return false; // don't quit now, wait for main thread to do it +} + +void GlutBWindow::Minimize(bool minimize) { + bgl->visible = !minimize; + BWindow::Minimize(minimize); +} + +void GlutBWindow::Hide() { + BWindow::Hide(); + bgl->visible = false; +} + +void GlutBWindow::Show() { + BWindow::Show(); + bgl->visible = true; +} diff --git a/src/glut/beos/glutWindow.h b/src/glut/beos/glutWindow.h new file mode 100644 index 000000000..d3ac18626 --- /dev/null +++ b/src/glut/beos/glutWindow.h @@ -0,0 +1,119 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. Copyright (C) 1999, Jake Hamby. + * + * 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. + * + * + * FILE: glutWindow.h + * + * DESCRIPTION: the GlutWindow class saves all events for + * handling by main thread + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include +#include + +/*********************************************************** + * CLASS: GlutWindow + * + * INHERITS FROM: BGLView (NOT BWindow!) + * + * DESCRIPTION: all information needed for windows and + * subwindows (handled as similarly as possible) + ***********************************************************/ +class GlutWindow : public BGLView { +public: + GlutWindow(GlutWindow *nparent, char *name, int x, int y, int width, + int height, ulong options); + + void KeyDown(const char *bytes, int32 numBytes); + void MouseDown(BPoint point); + void MouseMoved(BPoint point, uint32 transit, const BMessage *message); + void FrameResized(float width, float height); + void Draw(BRect updateRect); + void Pulse(); // needed since MouseUp() is broken + void MouseCheck(); // check for button state changes + void ErrorCallback(GLenum errorCode); + + static long MenuThread(void *menu); + + int num; // window number returned to user + int cursor; // my cursor +#define GLUT_MAX_MENUS 3 + int menu[GLUT_MAX_MENUS]; // my popup menus + int m_width, m_height; // the last width and height reported to GLUT + uint32 m_buttons; // the last mouse button state + + /* Window relationship state. */ + GlutWindow *parent; /* parent window */ + GlutWindow *children; /* first child window */ + GlutWindow *siblings; /* next sibling */ + + // leave out buttons and dials callbacks that we don't support + 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) */ + GLUTvisibilityCB visibility; /* visibility */ + GLUTspecialCB special; /* special key */ + GLUTwindowStatusCB windowStatus; /* window status */ + + bool anyevents; // were any events received? + bool displayEvent; // call display + bool reshapeEvent; // call reshape + bool mouseEvent; // call mouse + bool motionEvent; // call motion + bool passiveEvent; // call passive + bool entryEvent; // call entry + bool keybEvent; // call keyboard + bool windowStatusEvent; // call visibility + bool specialEvent; // call special + bool statusEvent; // menu status changed + bool menuEvent; // menu selected + + int button, mouseState; // for mouse callback + int mouseX, mouseY; // for mouse callback + int motionX, motionY; // for motion callback + int passiveX, passiveY; // for passive callback + int entryState; // for entry callback + unsigned char key; // for keyboard callback + int keyX, keyY; // for keyboard callback + int visState; // for visibility callback + int specialKey; // for special key callback + int specialX, specialY; // for special callback + int modifierKeys; // modifier key state + int menuStatus; // for status callback + int statusX, statusY; // for status callback + int menuNumber; // for menu and status callbacks + int menuValue; // for menu callback + bool visible; // for visibility callback +}; + +/*********************************************************** + * CLASS: GlutBWindow + * + * INHERITS FROM: BDirectWindow + * + * DESCRIPTION: basically a BWindow that won't quit + ***********************************************************/ +class GlutBWindow : public BDirectWindow { +public: + GlutBWindow(BRect frame, char *name); + ~GlutBWindow(); + void DirectConnected(direct_buffer_info *info); + bool QuitRequested(); // exits app + void Minimize(bool minimized); // minimized windows are not visible + void Hide(); + void Show(); + GlutWindow *bgl; + bool fConnectionDisabled; +}; diff --git a/src/glut/beos/glut_8x13.c b/src/glut/beos/glut_8x13.c new file mode 100644 index 000000000..843c63d35 --- /dev/null +++ b/src/glut/beos/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/beos/glut_9x15.c b/src/glut/beos/glut_9x15.c new file mode 100644 index 000000000..2d5c004e4 --- /dev/null +++ b/src/glut/beos/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/beos/glut_bitmap.c b/src/glut/beos/glut_bitmap.c new file mode 100644 index 000000000..f1afdd7a0 --- /dev/null +++ b/src/glut/beos/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/beos/glut_bwidth.c b/src/glut/beos/glut_bwidth.c new file mode 100644 index 000000000..bee5e8827 --- /dev/null +++ b/src/glut/beos/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/beos/glut_ext.c b/src/glut/beos/glut_ext.c new file mode 100644 index 000000000..334f31f1a --- /dev/null +++ b/src/glut/beos/glut_ext.c @@ -0,0 +1,201 @@ + +/* 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 +#include + +#include "glutint.h" + +/* CENTRY */ +int GLUTAPIENTRY +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; +} + + +struct name_address_pair { + const char *name; + const GLUTproc address; +}; + +static struct name_address_pair glut_functions[] = { + { "glutInit", (const GLUTproc) glutInit }, + { "glutInitDisplayMode", (const GLUTproc) glutInitDisplayMode }, + { "glutInitDisplayString", (const GLUTproc) glutInitDisplayString }, + { "glutInitWindowPosition", (const GLUTproc) glutInitWindowPosition }, + { "glutInitWindowSize", (const GLUTproc) glutInitWindowSize }, + { "glutMainLoop", (const GLUTproc) glutMainLoop }, + { "glutCreateWindow", (const GLUTproc) glutCreateWindow }, + { "glutCreateSubWindow", (const GLUTproc) glutCreateSubWindow }, + { "glutDestroyWindow", (const GLUTproc) glutDestroyWindow }, + { "glutPostRedisplay", (const GLUTproc) glutPostRedisplay }, + { "glutPostWindowRedisplay", (const GLUTproc) glutPostWindowRedisplay }, + { "glutSwapBuffers", (const GLUTproc) glutSwapBuffers }, + { "glutGetWindow", (const GLUTproc) glutGetWindow }, + { "glutSetWindow", (const GLUTproc) glutSetWindow }, + { "glutSetWindowTitle", (const GLUTproc) glutSetWindowTitle }, + { "glutSetIconTitle", (const GLUTproc) glutSetIconTitle }, + { "glutPositionWindow", (const GLUTproc) glutPositionWindow }, + { "glutReshapeWindow", (const GLUTproc) glutReshapeWindow }, + { "glutPopWindow", (const GLUTproc) glutPopWindow }, + { "glutPushWindow", (const GLUTproc) glutPushWindow }, + { "glutIconifyWindow", (const GLUTproc) glutIconifyWindow }, + { "glutShowWindow", (const GLUTproc) glutShowWindow }, + { "glutHideWindow", (const GLUTproc) glutHideWindow }, + { "glutFullScreen", (const GLUTproc) glutFullScreen }, + { "glutSetCursor", (const GLUTproc) glutSetCursor }, + { "glutWarpPointer", (const GLUTproc) glutWarpPointer }, + { "glutEstablishOverlay", (const GLUTproc) glutEstablishOverlay }, + { "glutRemoveOverlay", (const GLUTproc) glutRemoveOverlay }, + { "glutUseLayer", (const GLUTproc) glutUseLayer }, + { "glutPostOverlayRedisplay", (const GLUTproc) glutPostOverlayRedisplay }, + { "glutPostWindowOverlayRedisplay", (const GLUTproc) glutPostWindowOverlayRedisplay }, + { "glutShowOverlay", (const GLUTproc) glutShowOverlay }, + { "glutHideOverlay", (const GLUTproc) glutHideOverlay }, + { "glutCreateMenu", (const GLUTproc) glutCreateMenu }, + { "glutDestroyMenu", (const GLUTproc) glutDestroyMenu }, + { "glutGetMenu", (const GLUTproc) glutGetMenu }, + { "glutSetMenu", (const GLUTproc) glutSetMenu }, + { "glutAddMenuEntry", (const GLUTproc) glutAddMenuEntry }, + { "glutAddSubMenu", (const GLUTproc) glutAddSubMenu }, + { "glutChangeToMenuEntry", (const GLUTproc) glutChangeToMenuEntry }, + { "glutChangeToSubMenu", (const GLUTproc) glutChangeToSubMenu }, + { "glutRemoveMenuItem", (const GLUTproc) glutRemoveMenuItem }, + { "glutAttachMenu", (const GLUTproc) glutAttachMenu }, + { "glutDetachMenu", (const GLUTproc) glutDetachMenu }, + { "glutDisplayFunc", (const GLUTproc) glutDisplayFunc }, + { "glutReshapeFunc", (const GLUTproc) glutReshapeFunc }, + { "glutKeyboardFunc", (const GLUTproc) glutKeyboardFunc }, + { "glutMouseFunc", (const GLUTproc) glutMouseFunc }, + { "glutMotionFunc", (const GLUTproc) glutMotionFunc }, + { "glutPassiveMotionFunc", (const GLUTproc) glutPassiveMotionFunc }, + { "glutEntryFunc", (const GLUTproc) glutEntryFunc }, + { "glutVisibilityFunc", (const GLUTproc) glutVisibilityFunc }, + { "glutIdleFunc", (const GLUTproc) glutIdleFunc }, + { "glutTimerFunc", (const GLUTproc) glutTimerFunc }, + { "glutMenuStateFunc", (const GLUTproc) glutMenuStateFunc }, + { "glutSpecialFunc", (const GLUTproc) glutSpecialFunc }, + { "glutSpaceballMotionFunc", (const GLUTproc) glutSpaceballMotionFunc }, + { "glutSpaceballRotateFunc", (const GLUTproc) glutSpaceballRotateFunc }, + { "glutSpaceballButtonFunc", (const GLUTproc) glutSpaceballButtonFunc }, + { "glutButtonBoxFunc", (const GLUTproc) glutButtonBoxFunc }, + { "glutDialsFunc", (const GLUTproc) glutDialsFunc }, + { "glutTabletMotionFunc", (const GLUTproc) glutTabletMotionFunc }, + { "glutTabletButtonFunc", (const GLUTproc) glutTabletButtonFunc }, + { "glutMenuStatusFunc", (const GLUTproc) glutMenuStatusFunc }, + { "glutOverlayDisplayFunc", (const GLUTproc) glutOverlayDisplayFunc }, + { "glutWindowStatusFunc", (const GLUTproc) glutWindowStatusFunc }, +// { "glutKeyboardUpFunc", (const GLUTproc) glutKeyboardUpFunc }, +// { "glutSpecialUpFunc", (const GLUTproc) glutSpecialUpFunc }, +// { "glutJoystickFunc", (const GLUTproc) glutJoystickFunc }, + { "glutSetColor", (const GLUTproc) glutSetColor }, + { "glutGetColor", (const GLUTproc) glutGetColor }, + { "glutCopyColormap", (const GLUTproc) glutCopyColormap }, + { "glutGet", (const GLUTproc) glutGet }, + { "glutDeviceGet", (const GLUTproc) glutDeviceGet }, + { "glutExtensionSupported", (const GLUTproc) glutExtensionSupported }, + { "glutGetModifiers", (const GLUTproc) glutGetModifiers }, + { "glutLayerGet", (const GLUTproc) glutLayerGet }, + { "glutGetProcAddress", (const GLUTproc) glutGetProcAddress }, + { "glutBitmapCharacter", (const GLUTproc) glutBitmapCharacter }, + { "glutBitmapWidth", (const GLUTproc) glutBitmapWidth }, + { "glutStrokeCharacter", (const GLUTproc) glutStrokeCharacter }, + { "glutStrokeWidth", (const GLUTproc) glutStrokeWidth }, + { "glutBitmapLength", (const GLUTproc) glutBitmapLength }, + { "glutStrokeLength", (const GLUTproc) glutStrokeLength }, + { "glutWireSphere", (const GLUTproc) glutWireSphere }, + { "glutSolidSphere", (const GLUTproc) glutSolidSphere }, + { "glutWireCone", (const GLUTproc) glutWireCone }, + { "glutSolidCone", (const GLUTproc) glutSolidCone }, + { "glutWireCube", (const GLUTproc) glutWireCube }, + { "glutSolidCube", (const GLUTproc) glutSolidCube }, + { "glutWireTorus", (const GLUTproc) glutWireTorus }, + { "glutSolidTorus", (const GLUTproc) glutSolidTorus }, + { "glutWireDodecahedron", (const GLUTproc) glutWireDodecahedron }, + { "glutSolidDodecahedron", (const GLUTproc) glutSolidDodecahedron }, + { "glutWireTeapot", (const GLUTproc) glutWireTeapot }, + { "glutSolidTeapot", (const GLUTproc) glutSolidTeapot }, + { "glutWireOctahedron", (const GLUTproc) glutWireOctahedron }, + { "glutSolidOctahedron", (const GLUTproc) glutSolidOctahedron }, + { "glutWireTetrahedron", (const GLUTproc) glutWireTetrahedron }, + { "glutSolidTetrahedron", (const GLUTproc) glutSolidTetrahedron }, + { "glutWireIcosahedron", (const GLUTproc) glutWireIcosahedron }, + { "glutSolidIcosahedron", (const GLUTproc) glutSolidIcosahedron }, + { "glutVideoResizeGet", (const GLUTproc) glutVideoResizeGet }, + { "glutSetupVideoResizing", (const GLUTproc) glutSetupVideoResizing }, + { "glutStopVideoResizing", (const GLUTproc) glutStopVideoResizing }, + { "glutVideoResize", (const GLUTproc) glutVideoResize }, + { "glutVideoPan", (const GLUTproc) glutVideoPan }, + { "glutReportErrors", (const GLUTproc) glutReportErrors }, +// { "glutIgnoreKeyRepeat", (const GLUTproc) glutIgnoreKeyRepeat }, +// { "glutSetKeyRepeat", (const GLUTproc) glutSetKeyRepeat }, +// { "glutForceJoystickFunc", (const GLUTproc) glutForceJoystickFunc }, +// { "glutGameModeString", (const GLUTproc) glutGameModeString }, +// { "glutEnterGameMode", (const GLUTproc) glutEnterGameMode }, +// { "glutLeaveGameMode", (const GLUTproc) glutLeaveGameMode }, +// { "glutGameModeGet", (const GLUTproc) glutGameModeGet }, + { NULL, NULL } +}; + + +/* XXX This isn't an official GLUT function, yet */ +GLUTproc GLUTAPIENTRY +glutGetProcAddress(const char *procName) +{ + /* Try GLUT functions first */ + int i; + for (i = 0; glut_functions[i].name; i++) { + if (strcmp(glut_functions[i].name, procName) == 0) + return glut_functions[i].address; + } + + /* Try core GL functions */ +#if defined(_WIN32) + return (GLUTProc) wglGetProcAddress((LPCSTR) procName); +#elif defined(GLX_ARB_get_proc_address) + return (GLUTProc) glXGetProcAddressARB((const GLubyte *) procName); +#else + return NULL; +#endif +} + + +/* ENDCENTRY */ diff --git a/src/glut/beos/glut_hel10.c b/src/glut/beos/glut_hel10.c new file mode 100644 index 000000000..703cef38f --- /dev/null +++ b/src/glut/beos/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/beos/glut_hel12.c b/src/glut/beos/glut_hel12.c new file mode 100644 index 000000000..68aed8a2b --- /dev/null +++ b/src/glut/beos/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/beos/glut_hel18.c b/src/glut/beos/glut_hel18.c new file mode 100644 index 000000000..f0800843e --- /dev/null +++ b/src/glut/beos/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/beos/glut_mroman.c b/src/glut/beos/glut_mroman.c new file mode 100644 index 000000000..a29f043b4 --- /dev/null +++ b/src/glut/beos/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/beos/glut_roman.c b/src/glut/beos/glut_roman.c new file mode 100644 index 000000000..af2b4ec95 --- /dev/null +++ b/src/glut/beos/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/beos/glut_shapes.c b/src/glut/beos/glut_shapes.c new file mode 100644 index 000000000..ce5bebb2b --- /dev/null +++ b/src/glut/beos/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 +#include "glutint.h" + +/* Some 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/beos/glut_stroke.c b/src/glut/beos/glut_stroke.c new file mode 100644 index 000000000..2fe408be1 --- /dev/null +++ b/src/glut/beos/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/beos/glut_swidth.c b/src/glut/beos/glut_swidth.c new file mode 100644 index 000000000..e1b737457 --- /dev/null +++ b/src/glut/beos/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/beos/glut_teapot.c b/src/glut/beos/glut_teapot.c new file mode 100644 index 000000000..3c9bdc1ab --- /dev/null +++ b/src/glut/beos/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(14, scale, GL_FILL); +} + +void APIENTRY +glutWireTeapot(GLdouble scale) +{ + teapot(10, scale, GL_LINE); +} + +/* ENDCENTRY */ diff --git a/src/glut/beos/glut_tr10.c b/src/glut/beos/glut_tr10.c new file mode 100644 index 000000000..0fac8070c --- /dev/null +++ b/src/glut/beos/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/beos/glut_tr24.c b/src/glut/beos/glut_tr24.c new file mode 100644 index 000000000..22b0e5160 --- /dev/null +++ b/src/glut/beos/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/beos/glut_util.c b/src/glut/beos/glut_util.c new file mode 100644 index 000000000..29e79513a --- /dev/null +++ b/src/glut/beos/glut_util.c @@ -0,0 +1,81 @@ + +/* 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 +#include +#include +#include + +#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); + 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/beos/glut_vidresize.c b/src/glut/beos/glut_vidresize.c new file mode 100644 index 000000000..a9d9e632f --- /dev/null +++ b/src/glut/beos/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 + +#if !defined(_WIN32) && !defined(__BEOS__) +#include +#endif + +#ifdef __sgi +#include +#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/beos/glutbitmap.h b/src/glut/beos/glutbitmap.h new file mode 100644 index 000000000..32bf53c09 --- /dev/null +++ b/src/glut/beos/glutbitmap.h @@ -0,0 +1,30 @@ +#ifndef __glutbitmap_h__ +#define __glutbitmap_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. */ + +#include + +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/beos/glutint.h b/src/glut/beos/glutint.h new file mode 100644 index 000000000..06b417e9c --- /dev/null +++ b/src/glut/beos/glutint.h @@ -0,0 +1,814 @@ +#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 +#endif + +#if defined(_WIN32) +#include "glutwin32.h" +#elif !defined(__BEOS__) +#ifdef __sgi +#define SUPPORT_FORTRAN +#endif +#include +#include +#include +#endif + +#include + +/* Non-Win32 platforms need APIENTRY defined to nothing + because all the GLUT routines have the APIENTRY prefix + to make Win32 happy. */ +#ifndef APIENTRY +#define APIENTRY +#endif + +#ifdef __vms +#if ( __VMS_VER < 70000000 ) +struct timeval { + __int64 val; +}; +extern int sys$gettim(struct timeval *); +#else +#include +#endif +#else +#include +#if !defined(_WIN32) +#include +#else +#include +#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; } + +/* BeOS doesn't need most of this file */ +#ifndef __BEOS__ + +#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; + +#endif /* BeOS */ + +/* GLUT function types */ +typedef void (*GLUTdisplayCB) (void); +typedef void (*GLUTreshapeCB) (int, int); +typedef void (*GLUTkeyboardCB) (unsigned char, int, int); +typedef void (*GLUTmouseCB) (int, int, int, int); +typedef void (*GLUTmotionCB) (int, int); +typedef void (*GLUTpassiveCB) (int, int); +typedef void (*GLUTentryCB) (int); +typedef void (*GLUTvisibilityCB) (int); +typedef void (*GLUTwindowStatusCB) (int); +typedef void (*GLUTidleCB) (void); +typedef void (*GLUTtimerCB) (int); +typedef void (*GLUTmenuStateCB) (int); /* DEPRICATED. */ +typedef void (*GLUTmenuStatusCB) (int, int, int); +typedef void (*GLUTselectCB) (int); +typedef void (*GLUTspecialCB) (int, int, int); +typedef void (*GLUTspaceMotionCB) (int, int, int); +typedef void (*GLUTspaceRotateCB) (int, int, int); +typedef void (*GLUTspaceButtonCB) (int, int); +typedef void (*GLUTdialsCB) (int, int); +typedef void (*GLUTbuttonBoxCB) (int, int); +typedef void (*GLUTtabletMotionCB) (int, int); +typedef void (*GLUTtabletButtonCB) (int, int, int, int); +typedef void (*GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z); +#ifdef SUPPORT_FORTRAN +typedef void (*GLUTdisplayFCB) (void); +typedef void (*GLUTreshapeFCB) (int *, int *); +/* NOTE the pressed key is int, not unsigned char for Fortran! */ +typedef void (*GLUTkeyboardFCB) (int *, int *, int *); +typedef void (*GLUTmouseFCB) (int *, int *, int *, int *); +typedef void (*GLUTmotionFCB) (int *, int *); +typedef void (*GLUTpassiveFCB) (int *, int *); +typedef void (*GLUTentryFCB) (int *); +typedef void (*GLUTvisibilityFCB) (int *); +typedef void (*GLUTwindowStatusFCB) (int *); +typedef void (*GLUTidleFCB) (void); +typedef void (*GLUTtimerFCB) (int *); +typedef void (*GLUTmenuStateFCB) (int *); /* DEPRICATED. */ +typedef void (*GLUTmenuStatusFCB) (int *, int *, int *); +typedef void (*GLUTselectFCB) (int *); +typedef void (*GLUTspecialFCB) (int *, int *, int *); +typedef void (*GLUTspaceMotionFCB) (int *, int *, int *); +typedef void (*GLUTspaceRotateFCB) (int *, int *, int *); +typedef void (*GLUTspaceButtonFCB) (int *, int *); +typedef void (*GLUTdialsFCB) (int *, int *); +typedef void (*GLUTbuttonBoxFCB) (int *, int *); +typedef void (*GLUTtabletMotionFCB) (int *, int *); +typedef void (*GLUTtabletButtonFCB) (int *, int *, int *, int *); +typedef void (*GLUTjoystickFCB) (unsigned int *buttonMask, int *x, int *y, int *z); +#endif + +#ifndef __BEOS__ + +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 + /* Special Fortran display unneeded since no + parameters! */ + 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 visibility + */ + 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 */ + /* Special Fortran display unneeded since no + parameters! */ +}; + +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 = wglGetCurrentContext(); \ + HDC currentDc = wglGetCurrentDC(); \ + \ + if (currentContext != window->renderCtx \ + || currentDc != window->renderDc) { \ + wglMakeCurrent(window->renderDc, window->renderCtx); \ + } \ + } +#define MAKE_CURRENT_WINDOW(window) \ + { \ + HGLRC currentContext = wglGetCurrentContext(); \ + HDC currentDc = wglGetCurrentDC(); \ + \ + if (currentContext != window->ctx || currentDc != window->hdc) { \ + wglMakeCurrent(window->hdc, window->ctx); \ + } \ + } +#define MAKE_CURRENT_OVERLAY(overlay) \ + wglMakeCurrent(overlay->hdc, overlay->ctx) +#define UNMAKE_CURRENT() \ + wglMakeCurrent(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; +#endif /* BeOS */ +extern char *__glutProgramName; +#ifndef __BEOS__ +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; + +/* private variables from glut_menu.c */ +extern GLUTmenuItem *__glutItemSelected; +extern GLUTmenu **__glutMenuList; +extern void (*__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); + +#endif /* BeOS */ +#ifdef __cplusplus +extern "C" { +#endif +/* 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,...); +#ifdef __cplusplus +} +#endif +#ifndef __BEOS__ + +/* 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 __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 __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 + +#else /* BeOS */ +/* BeOS specific C++ function prototypes */ +#ifdef __cplusplus + +#include + +/* private routines from glutInit.cpp */ +void __glutInitTime(bigtime_t *beginning); +void __glutInit(); + +/* private routines from glutMenu.cpp */ +class GlutMenu; // avoid including glutMenu.h +GlutMenu *__glutGetMenuByNum(int menunum); + +/* private routines from glutWindow.cpp */ +int __glutConvertDisplayMode(unsigned long *options); +void __glutDefaultReshape(int width, int height); +class GlutWindow; // avoid including glutWindow.h in every source file +void __glutSetWindow(GlutWindow * window); +void __glutDestroyAllWindows(); + +/* private routines from glutDstr.cpp */ +int __glutConvertDisplayModeFromString(unsigned long *options); + +/* private routines from glutCursor.cpp */ +void __glutSetCursor(int cursor); + +#endif /* __cplusplus */ +#endif /* BeOS */ + +#endif /* __glutint_h__ */ diff --git a/src/glut/beos/glutstroke.h b/src/glut/beos/glutstroke.h new file mode 100644 index 000000000..cbc9e156f --- /dev/null +++ b/src/glut/beos/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/dos/Makefile.DJ b/src/glut/dos/Makefile.DJ new file mode 100644 index 000000000..7e4e0b857 --- /dev/null +++ b/src/glut/dos/Makefile.DJ @@ -0,0 +1,126 @@ +# DOS/DJGPP Mesa Utility Toolkit +# Version: 1.0 +# +# Copyright (C) 2005 Daniel Borca All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +# +# Available options: +# +# Environment variables: +# CFLAGS +# +# GLIDE path to Glide3 SDK; used to resolve DXEs. +# default = $(TOP)/glide3 +# +# Targets: +# all: build GLUT +# clean: remove object files +# + + + +.PHONY: all clean + +TOP = ../../.. +GLIDE ?= $(TOP)/glide3 +LIBDIR = $(TOP)/lib +GLUT_LIB = libglut.a +GLUT_DXE = glut.dxe +GLUT_IMP = libiglut.a + +export LD_LIBRARY_PATH := $(LD_LIBRARY_PATH);$(LIBDIR);$(GLIDE)/lib + +CC = gcc +CFLAGS += -I$(TOP)/include -I. -IPC_HW +CFLAGS += -DGLUT_IMPORT_LIB + +AR = ar +ARFLAGS = crus + +HAVEDXE3 = $(wildcard $(DJDIR)/bin/dxe3gen.exe) + +ifeq ($(wildcard $(addsuffix /rm.exe,$(subst ;, ,$(PATH)))),) +UNLINK = del $(subst /,\,$(1)) +else +UNLINK = $(RM) $(1) +endif + +CORE_SOURCES = \ + loop.c \ + callback.c \ + color.c \ + extens.c \ + init.c \ + menu.c \ + mouse.c \ + overlay.c \ + state.c \ + util.c \ + window.c \ + f8x13.c \ + f9x15.c \ + hel10.c \ + hel12.c \ + hel18.c \ + tr10.c \ + tr24.c \ + mroman.c \ + roman.c \ + bitmap.c \ + stroke.c \ + teapot.c \ + shapes.c + +PC_HW_SOURCES = \ + PC_HW/pc_hw.c \ + PC_HW/pc_keyb.c \ + PC_HW/pc_mouse.c \ + PC_HW/pc_timer.c \ + PC_HW/pc_irq.S + +SOURCES = $(CORE_SOURCES) $(PC_HW_SOURCES) + +OBJECTS = $(addsuffix .o,$(basename $(SOURCES))) + +.c.o: + $(CC) -o $@ $(CFLAGS) -c $< +.S.o: + $(CC) -o $@ $(CFLAGS) -c $< +.s.o: + $(CC) -o $@ $(CFLAGS) -x assembler-with-cpp -c $< + +all: $(LIBDIR)/$(GLUT_LIB) $(LIBDIR)/$(GLUT_DXE) $(LIBDIR)/$(GLUT_IMP) + +$(LIBDIR)/$(GLUT_LIB): $(OBJECTS) + $(AR) $(ARFLAGS) $@ $^ + +$(LIBDIR)/$(GLUT_DXE) $(LIBDIR)/$(GLUT_IMP): $(OBJECTS) +ifeq ($(HAVEDXE3),) + $(warning Missing DXE3 package... Skipping $(GLUT_DXE)) +else + -dxe3gen -o $(LIBDIR)/$(GLUT_DXE) -Y $(LIBDIR)/$(GLUT_IMP) -D "MesaGLUT DJGPP" -E _glut -P gl.dxe -U $^ +endif + +clean: + -$(call UNLINK,*.o) + -$(call UNLINK,PC_HW/*.o) + +-include depend diff --git a/src/glut/dos/PC_HW/pc_hw.c b/src/glut/dos/PC_HW/pc_hw.c new file mode 100644 index 000000000..100b37216 --- /dev/null +++ b/src/glut/dos/PC_HW/pc_hw.c @@ -0,0 +1,163 @@ +/* + * PC/HW routine collection v1.3 for DOS/DJGPP + * + * Copyright (C) 2002 - Daniel Borca + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include +#include +#include /* for mode definitions */ +#include +#include +#include + +#include "pc_hw.h" + + +/* + * atexit + */ +#define MAX_ATEXIT 32 + +static volatile int atexitcnt; +static VFUNC atexittbl[MAX_ATEXIT]; + + +static void __attribute__((destructor)) +doexit (void) +{ + while (atexitcnt) atexittbl[--atexitcnt](); +} + + +int +pc_clexit (VFUNC f) +{ + int i; + + for (i = 0; i < atexitcnt; i++) { + if (atexittbl[i] == f) { + for (atexitcnt--; i < atexitcnt; i++) atexittbl[i] = atexittbl[i+1]; + atexittbl[i] = 0; + return 0; + } + } + return -1; +} + + +int +pc_atexit (VFUNC f) +{ + pc_clexit(f); + if (atexitcnt < MAX_ATEXIT) { + atexittbl[atexitcnt++] = f; + return 0; + } + return -1; +} + + +/* + * locked memory allocation + */ +void * +pc_malloc (size_t size) +{ + void *p = malloc(size); + + if (p) { + if (_go32_dpmi_lock_data(p, size)) { + free(p); + return NULL; + } + } + + return p; +} + + +/* + * standard redirection + */ +static char outname[L_tmpnam]; +static int h_out, h_outbak; +static char errname[L_tmpnam]; +static int h_err, h_errbak; + + +int +pc_open_stdout (void) +{ + tmpnam(outname); + + if ((h_out=open(outname, O_WRONLY | O_CREAT | O_TEXT | O_TRUNC, S_IREAD | S_IWRITE)) > 0) { + h_outbak = dup(STDOUT_FILENO); + fflush(stdout); + dup2(h_out, STDOUT_FILENO); + } + + return h_out; +} + + +void +pc_close_stdout (void) +{ + FILE *f; + char *line = alloca(512); + + if (h_out > 0) { + dup2(h_outbak, STDOUT_FILENO); + close(h_out); + close(h_outbak); + + f = fopen(outname, "rt"); + while (fgets(line, 512, f)) { + fputs(line, stdout); + } + fclose(f); + + remove(outname); + } +} + + +int +pc_open_stderr (void) +{ + tmpnam(errname); + + if ((h_err=open(errname, O_WRONLY | O_CREAT | O_TEXT | O_TRUNC, S_IREAD | S_IWRITE)) > 0) { + h_errbak = dup(STDERR_FILENO); + fflush(stderr); + dup2(h_err, STDERR_FILENO); + } + + return h_err; +} + + +void +pc_close_stderr (void) +{ + FILE *f; + char *line = alloca(512); + + if (h_err > 0) { + dup2(h_errbak, STDERR_FILENO); + close(h_err); + close(h_errbak); + + f = fopen(errname, "rt"); + while (fgets(line, 512, f)) { + fputs(line, stderr); + } + fclose(f); + + remove(errname); + } +} diff --git a/src/glut/dos/PC_HW/pc_hw.h b/src/glut/dos/PC_HW/pc_hw.h new file mode 100644 index 000000000..41948ec99 --- /dev/null +++ b/src/glut/dos/PC_HW/pc_hw.h @@ -0,0 +1,229 @@ +/* + * PC/HW routine collection v1.4 for DOS/DJGPP + * + * Copyright (C) 2002 - Daniel Borca + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#ifndef PC_HW_H_included +#define PC_HW_H_included + +#include +#include + +/* + * misc C definitions + */ +#define FALSE 0 +#define TRUE !FALSE + +#define SQR(x) ((x) * (x)) + +#define MIN(x,y) (((x) < (y)) ? (x) : (y)) +#define MAX(x,y) (((x) > (y)) ? (x) : (y)) +#define MID(x,y,z) MAX((x), MIN((y), (z))) + +typedef void (*VFUNC) (void); +typedef void (*PFUNC) (void *); +typedef void (*MFUNC) (int x, int y, int z, int b); + +/* + * atexit + */ +int pc_atexit (VFUNC f); +int pc_clexit (VFUNC f); + +/* + * locked memory + */ +#define ENDOFUNC(x) static void x##_end() { } +#define LOCKFUNC(x) _go32_dpmi_lock_code((void *)x, (long)x##_end - (long)x) +#define LOCKDATA(x) _go32_dpmi_lock_data((void *)&x, sizeof(x)) +#define LOCKBUFF(x, l) _go32_dpmi_lock_data((void *)x, l) + +void *pc_malloc (size_t size); + +/* + * IRQ + */ +#define ENABLE() __asm __volatile ("sti") +#define DISABLE() __asm __volatile ("cli") + +extern int pc_install_irq (int i, int (*handler) ()); +extern int pc_remove_irq (int i); + +/* + * keyboard + */ +#define KB_SHIFT_FLAG 0x0001 +#define KB_CTRL_FLAG 0x0002 +#define KB_ALT_FLAG 0x0004 +#define KB_LWIN_FLAG 0x0008 +#define KB_RWIN_FLAG 0x0010 +#define KB_MENU_FLAG 0x0020 +#define KB_SCROLOCK_FLAG 0x0100 +#define KB_NUMLOCK_FLAG 0x0200 +#define KB_CAPSLOCK_FLAG 0x0400 +#define KB_INALTSEQ_FLAG 0x0800 +#define KB_ACCENT1_FLAG 0x1000 +#define KB_ACCENT2_FLAG 0x2000 +#define KB_ACCENT3_FLAG 0x4000 +#define KB_ACCENT4_FLAG 0x8000 + +#define KEY_A 1 +#define KEY_B 2 +#define KEY_C 3 +#define KEY_D 4 +#define KEY_E 5 +#define KEY_F 6 +#define KEY_G 7 +#define KEY_H 8 +#define KEY_I 9 +#define KEY_J 10 +#define KEY_K 11 +#define KEY_L 12 +#define KEY_M 13 +#define KEY_N 14 +#define KEY_O 15 +#define KEY_P 16 +#define KEY_Q 17 +#define KEY_R 18 +#define KEY_S 19 +#define KEY_T 20 +#define KEY_U 21 +#define KEY_V 22 +#define KEY_W 23 +#define KEY_X 24 +#define KEY_Y 25 +#define KEY_Z 26 +#define KEY_0 27 +#define KEY_1 28 +#define KEY_2 29 +#define KEY_3 30 +#define KEY_4 31 +#define KEY_5 32 +#define KEY_6 33 +#define KEY_7 34 +#define KEY_8 35 +#define KEY_9 36 +#define KEY_0_PAD 37 +#define KEY_1_PAD 38 +#define KEY_2_PAD 39 +#define KEY_3_PAD 40 +#define KEY_4_PAD 41 +#define KEY_5_PAD 42 +#define KEY_6_PAD 43 +#define KEY_7_PAD 44 +#define KEY_8_PAD 45 +#define KEY_9_PAD 46 +#define KEY_F1 47 +#define KEY_F2 48 +#define KEY_F3 49 +#define KEY_F4 50 +#define KEY_F5 51 +#define KEY_F6 52 +#define KEY_F7 53 +#define KEY_F8 54 +#define KEY_F9 55 +#define KEY_F10 56 +#define KEY_F11 57 +#define KEY_F12 58 +#define KEY_ESC 59 +#define KEY_TILDE 60 +#define KEY_MINUS 61 +#define KEY_EQUALS 62 +#define KEY_BACKSPACE 63 +#define KEY_TAB 64 +#define KEY_OPENBRACE 65 +#define KEY_CLOSEBRACE 66 +#define KEY_ENTER 67 +#define KEY_COLON 68 +#define KEY_QUOTE 69 +#define KEY_BACKSLASH 70 +#define KEY_BACKSLASH2 71 +#define KEY_COMMA 72 +#define KEY_STOP 73 +#define KEY_SLASH 74 +#define KEY_SPACE 75 +#define KEY_INSERT 76 +#define KEY_DEL 77 +#define KEY_HOME 78 +#define KEY_END 79 +#define KEY_PGUP 80 +#define KEY_PGDN 81 +#define KEY_LEFT 82 +#define KEY_RIGHT 83 +#define KEY_UP 84 +#define KEY_DOWN 85 +#define KEY_SLASH_PAD 86 +#define KEY_ASTERISK 87 +#define KEY_MINUS_PAD 88 +#define KEY_PLUS_PAD 89 +#define KEY_DEL_PAD 90 +#define KEY_ENTER_PAD 91 +#define KEY_PRTSCR 92 +#define KEY_PAUSE 93 +#define KEY_ABNT_C1 94 +#define KEY_YEN 95 +#define KEY_KANA 96 +#define KEY_CONVERT 97 +#define KEY_NOCONVERT 98 +#define KEY_AT 99 +#define KEY_CIRCUMFLEX 100 +#define KEY_COLON2 101 +#define KEY_KANJI 102 + +#define KEY_MODIFIERS 103 + +#define KEY_LSHIFT 103 +#define KEY_RSHIFT 104 +#define KEY_LCONTROL 105 +#define KEY_RCONTROL 106 +#define KEY_ALT 107 +#define KEY_ALTGR 108 +#define KEY_LWIN 109 +#define KEY_RWIN 110 +#define KEY_MENU 111 +#define KEY_SCRLOCK 112 +#define KEY_NUMLOCK 113 +#define KEY_CAPSLOCK 114 + +#define KEY_MAX 115 + +int pc_install_keyb (void); +void pc_remove_keyb (void); +int pc_keypressed (void); +int pc_readkey (void); +int pc_keydown (int code); +int pc_keyshifts (void); + +/* + * timer + */ +int pc_install_int (PFUNC func, void *parm, unsigned int freq); +int pc_remove_int (int fid); +int pc_adjust_int (int fid, unsigned int freq); +void pc_remove_timer (void); + +/* + * mouse + */ +int pc_install_mouse (void); +void pc_remove_mouse (void); +MFUNC pc_install_mouse_handler (MFUNC handler); +void pc_mouse_area (int x1, int y1, int x2, int y2); +void pc_mouse_speed (int xspeed, int yspeed); +int pc_query_mouse (int *x, int *y, int *z); +void pc_warp_mouse (int x, int y); + +/* + * standard redirection + */ +int pc_open_stdout (void); +int pc_open_stderr (void); +void pc_close_stdout (void); +void pc_close_stderr (void); + +#endif diff --git a/src/glut/dos/PC_HW/pc_irq.S b/src/glut/dos/PC_HW/pc_irq.S new file mode 100644 index 000000000..7d62ac74c --- /dev/null +++ b/src/glut/dos/PC_HW/pc_irq.S @@ -0,0 +1,182 @@ +/* + * PC/HW routine collection v1.3 for DOS/DJGPP + * + * Copyright (C) 2002 - Daniel Borca + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + + .file "pc_irq.S" + + .text + +#define IRQ_STACK_SIZE 16384 + +#define IRQ_WRAPPER_LEN (__irq_wrapper_1-__irq_wrapper_0) +#define IRQ_OLD (__irq_old_0-__irq_wrapper_0) +#define IRQ_HOOK (__irq_hook_0-__irq_wrapper_0) +#define IRQ_STACK (__irq_stack_0-__irq_wrapper_0) + + .balign 4 +common: + movw $0x0400, %ax + int $0x31 + + movl %ss:8(%ebp), %ebx + cmpl $15, %ebx + jbe 0f + fail: + orl $-1, %eax + popl %edi + popl %ebx + leave + ret + + 0: + movl %ebx, %edi + imull $IRQ_WRAPPER_LEN, %edi + addl $__irq_wrapper_0, %edi + + cmpb $7, %bl + jbe 1f + movb %dl, %dh + subb $8, %dh + 1: + addb %dh, %bl + ret + + .balign 4 + .global _pc_install_irq +_pc_install_irq: + pushl %ebp + movl %esp, %ebp + pushl %ebx + pushl %edi + + call common + + cmpl $0, IRQ_HOOK(%edi) + jne fail + + pushl $IRQ_WRAPPER_LEN + pushl %edi + call __go32_dpmi_lock_code + addl $8, %esp + testl %eax, %eax + jnz fail + + pushl $IRQ_STACK_SIZE + call _pc_malloc + popl %edx + testl %eax, %eax + jz fail + addl %edx, %eax + movl %eax, IRQ_STACK(%edi) + + movl ___djgpp_ds_alias, %eax + movl %eax, IRQ_STACK+4(%edi) + + movl %ss:12(%ebp), %eax + movl %eax, IRQ_HOOK(%edi) + + movw $0x0204, %ax + int $0x31 + movl %edx, IRQ_OLD(%edi) + movw %cx, IRQ_OLD+4(%edi) + movw $0x0205, %ax + movl %edi, %edx + movl %cs, %ecx + int $0x31 + + done: + xorl %eax, %eax + popl %edi + popl %ebx + leave + ret + + .balign 4 + .global _pc_remove_irq +_pc_remove_irq: + pushl %ebp + movl %esp, %ebp + pushl %ebx + pushl %edi + + call common + + cmpl $0, IRQ_HOOK(%edi) + je fail + + movl $0, IRQ_HOOK(%edi) + + movw $0x0205, %ax + movl IRQ_OLD(%edi), %edx + movl IRQ_OLD+4(%edi), %ecx + int $0x31 + + movl IRQ_STACK(%edi), %eax + subl $IRQ_STACK_SIZE, %eax + pushl %eax + call _free + popl %eax + + jmp done + +#define WRAPPER(x) ; \ + .balign 4 ; \ +__irq_wrapper_##x: ; \ + pushal ; \ + pushl %ds ; \ + pushl %es ; \ + pushl %fs ; \ + pushl %gs ; \ + movl %ss, %ebx ; \ + movl %esp, %esi ; \ + lss %cs:__irq_stack_##x, %esp ; \ + pushl %ss ; \ + pushl %ss ; \ + popl %es ; \ + popl %ds ; \ + movl ___djgpp_dos_sel, %fs ; \ + pushl %fs ; \ + popl %gs ; \ + call *__irq_hook_##x ; \ + movl %ebx, %ss ; \ + movl %esi, %esp ; \ + testl %eax, %eax ; \ + popl %gs ; \ + popl %fs ; \ + popl %es ; \ + popl %ds ; \ + popal ; \ + jz __irq_ignore_##x ; \ +__irq_bypass_##x: ; \ + ljmp *%cs:__irq_old_##x ; \ +__irq_ignore_##x: ; \ + iret ; \ + .balign 4 ; \ +__irq_old_##x: ; \ + .long 0, 0 ; \ +__irq_hook_##x: ; \ + .long 0 ; \ +__irq_stack_##x: ; \ + .long 0, 0 + + WRAPPER(0); + WRAPPER(1); + WRAPPER(2); + WRAPPER(3); + WRAPPER(4); + WRAPPER(5); + WRAPPER(6); + WRAPPER(7); + WRAPPER(8); + WRAPPER(9); + WRAPPER(10); + WRAPPER(11); + WRAPPER(12); + WRAPPER(13); + WRAPPER(14); + WRAPPER(15); diff --git a/src/glut/dos/PC_HW/pc_keyb.c b/src/glut/dos/PC_HW/pc_keyb.c new file mode 100644 index 000000000..d7e3257b9 --- /dev/null +++ b/src/glut/dos/PC_HW/pc_keyb.c @@ -0,0 +1,540 @@ +/* + * PC/HW routine collection v1.3 for DOS/DJGPP + * + * Copyright (C) 2002 - Daniel Borca + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include +#include +#include + +#include "pc_hw.h" + + +#define KEYB_IRQ 1 + +#define KEY_BUFFER_SIZE 64 + +#define KB_MODIFIERS (KB_SHIFT_FLAG | KB_CTRL_FLAG | KB_ALT_FLAG | KB_LWIN_FLAG | KB_RWIN_FLAG | KB_MENU_FLAG) +#define KB_LED_FLAGS (KB_SCROLOCK_FLAG | KB_NUMLOCK_FLAG | KB_CAPSLOCK_FLAG) + +static int keyboard_installed; + +static volatile struct { + volatile int start, end; + volatile int key[KEY_BUFFER_SIZE]; +} key_buffer; + +static volatile int key_enhanced, key_pause_loop, key_shifts; +static int leds_ok = TRUE; +static int in_a_terrupt = FALSE; +static volatile char pc_key[KEY_MAX]; + + +/* convert Allegro format scancodes into key_shifts flag bits */ +static unsigned short modifier_table[KEY_MAX - KEY_MODIFIERS] = { + KB_SHIFT_FLAG, KB_SHIFT_FLAG, KB_CTRL_FLAG, + KB_CTRL_FLAG, KB_ALT_FLAG, KB_ALT_FLAG, + KB_LWIN_FLAG, KB_RWIN_FLAG, KB_MENU_FLAG, + KB_SCROLOCK_FLAG, KB_NUMLOCK_FLAG, KB_CAPSLOCK_FLAG +}; + + +/* lookup table for converting hardware scancodes into Allegro format */ +static unsigned char hw_to_mycode[128] = { + /* 0x00 */ 0, KEY_ESC, KEY_1, KEY_2, + /* 0x04 */ KEY_3, KEY_4, KEY_5, KEY_6, + /* 0x08 */ KEY_7, KEY_8, KEY_9, KEY_0, + /* 0x0C */ KEY_MINUS, KEY_EQUALS, KEY_BACKSPACE, KEY_TAB, + /* 0x10 */ KEY_Q, KEY_W, KEY_E, KEY_R, + /* 0x14 */ KEY_T, KEY_Y, KEY_U, KEY_I, + /* 0x18 */ KEY_O, KEY_P, KEY_OPENBRACE, KEY_CLOSEBRACE, + /* 0x1C */ KEY_ENTER, KEY_LCONTROL, KEY_A, KEY_S, + /* 0x20 */ KEY_D, KEY_F, KEY_G, KEY_H, + /* 0x24 */ KEY_J, KEY_K, KEY_L, KEY_COLON, + /* 0x28 */ KEY_QUOTE, KEY_TILDE, KEY_LSHIFT, KEY_BACKSLASH, + /* 0x2C */ KEY_Z, KEY_X, KEY_C, KEY_V, + /* 0x30 */ KEY_B, KEY_N, KEY_M, KEY_COMMA, + /* 0x34 */ KEY_STOP, KEY_SLASH, KEY_RSHIFT, KEY_ASTERISK, + /* 0x38 */ KEY_ALT, KEY_SPACE, KEY_CAPSLOCK, KEY_F1, + /* 0x3C */ KEY_F2, KEY_F3, KEY_F4, KEY_F5, + /* 0x40 */ KEY_F6, KEY_F7, KEY_F8, KEY_F9, + /* 0x44 */ KEY_F10, KEY_NUMLOCK, KEY_SCRLOCK, KEY_7_PAD, + /* 0x48 */ KEY_8_PAD, KEY_9_PAD, KEY_MINUS_PAD, KEY_4_PAD, + /* 0x4C */ KEY_5_PAD, KEY_6_PAD, KEY_PLUS_PAD, KEY_1_PAD, + /* 0x50 */ KEY_2_PAD, KEY_3_PAD, KEY_0_PAD, KEY_DEL_PAD, + /* 0x54 */ KEY_PRTSCR, 0, KEY_BACKSLASH2, KEY_F11, + /* 0x58 */ KEY_F12, 0, 0, KEY_LWIN, + /* 0x5C */ KEY_RWIN, KEY_MENU, 0, 0, + /* 0x60 */ 0, 0, 0, 0, + /* 0x64 */ 0, 0, 0, 0, + /* 0x68 */ 0, 0, 0, 0, + /* 0x6C */ 0, 0, 0, 0, + /* 0x70 */ KEY_KANA, 0, 0, KEY_ABNT_C1, + /* 0x74 */ 0, 0, 0, 0, + /* 0x78 */ 0, KEY_CONVERT, 0, KEY_NOCONVERT, + /* 0x7C */ 0, KEY_YEN, 0, 0 +}; + + +/* lookup table for converting extended hardware codes into Allegro format */ +static unsigned char hw_to_mycode_ex[128] = { + /* 0x00 */ 0, KEY_ESC, KEY_1, KEY_2, + /* 0x04 */ KEY_3, KEY_4, KEY_5, KEY_6, + /* 0x08 */ KEY_7, KEY_8, KEY_9, KEY_0, + /* 0x0C */ KEY_MINUS, KEY_EQUALS, KEY_BACKSPACE, KEY_TAB, + /* 0x10 */ KEY_CIRCUMFLEX, KEY_AT, KEY_COLON2, KEY_R, + /* 0x14 */ KEY_KANJI, KEY_Y, KEY_U, KEY_I, + /* 0x18 */ KEY_O, KEY_P, KEY_OPENBRACE, KEY_CLOSEBRACE, + /* 0x1C */ KEY_ENTER_PAD, KEY_RCONTROL, KEY_A, KEY_S, + /* 0x20 */ KEY_D, KEY_F, KEY_G, KEY_H, + /* 0x24 */ KEY_J, KEY_K, KEY_L, KEY_COLON, + /* 0x28 */ KEY_QUOTE, KEY_TILDE, 0, KEY_BACKSLASH, + /* 0x2C */ KEY_Z, KEY_X, KEY_C, KEY_V, + /* 0x30 */ KEY_B, KEY_N, KEY_M, KEY_COMMA, + /* 0x34 */ KEY_STOP, KEY_SLASH_PAD, 0, KEY_PRTSCR, + /* 0x38 */ KEY_ALTGR, KEY_SPACE, KEY_CAPSLOCK, KEY_F1, + /* 0x3C */ KEY_F2, KEY_F3, KEY_F4, KEY_F5, + /* 0x40 */ KEY_F6, KEY_F7, KEY_F8, KEY_F9, + /* 0x44 */ KEY_F10, KEY_NUMLOCK, KEY_PAUSE, KEY_HOME, + /* 0x48 */ KEY_UP, KEY_PGUP, KEY_MINUS_PAD, KEY_LEFT, + /* 0x4C */ KEY_5_PAD, KEY_RIGHT, KEY_PLUS_PAD, KEY_END, + /* 0x50 */ KEY_DOWN, KEY_PGDN, KEY_INSERT, KEY_DEL, + /* 0x54 */ KEY_PRTSCR, 0, KEY_BACKSLASH2, KEY_F11, + /* 0x58 */ KEY_F12, 0, 0, KEY_LWIN, + /* 0x5C */ KEY_RWIN, KEY_MENU, 0, 0, + /* 0x60 */ 0, 0, 0, 0, + /* 0x64 */ 0, 0, 0, 0, + /* 0x68 */ 0, 0, 0, 0, + /* 0x6C */ 0, 0, 0, 0, + /* 0x70 */ 0, 0, 0, 0, + /* 0x74 */ 0, 0, 0, 0, + /* 0x78 */ 0, 0, 0, 0, + /* 0x7C */ 0, 0, 0, 0 +}; + + +/* default mapping table for the US keyboard layout */ +static unsigned short standard_key_ascii_table[KEY_MAX] = { + /* start */ 0, + /* alphabet */ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', + /* numbers */ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + /* numpad */ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + /* func keys */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* misc chars */ 27, '`', '-', '=', 8, 9, '[', ']', 13, ';', '\'', '\\', '\\', ',', '.', '/', ' ', + /* controls */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* numpad */ '/', '*', '-', '+', '.', 13, + /* modifiers */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + + +/* capslock mapping table for the US keyboard layout */ +static unsigned short standard_key_capslock_table[KEY_MAX] = { + /* start */ 0, + /* alphabet */ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + /* numbers */ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + /* numpad */ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + /* func keys */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* misc chars */ 27, '`', '-', '=', 8, 9, '[', ']', 13, ';', '\'', '\\', '\\', ',', '.', '/', ' ', + /* controls */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* numpad */ '/', '*', '-', '+', '.', 13, + /* modifiers */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + + +/* shifted mapping table for the US keyboard layout */ +static unsigned short standard_key_shift_table[KEY_MAX] = { + /* start */ 0, + /* alphabet */ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + /* numbers */ ')', '!', '@', '#', '$', '%', '^', '&', '*', '(', + /* numpad */ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + /* func keys */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* misc chars */ 27, '~', '_', '+', 8, 9, '{', '}', 13, ':', '"', '|', '|', '<', '>', '?', ' ', + /* controls */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* numpad */ '/', '*', '-', '+', '.', 13, + /* modifiers */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + + +/* ctrl+key mapping table for the US keyboard layout */ +static unsigned short standard_key_control_table[KEY_MAX] = { + /* start */ 0, + /* alphabet */ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + /* numbers */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + /* numpad */ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + /* func keys */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* misc chars */ 27, 2, 2, 2, 127, 127, 2, 2, 10, 2, 2, 2, 2, 2, 2, 2, 2, + /* controls */ 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, + /* numpad */ 2, 2, 2, 2, 2, 10, + /* modifiers */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + + +/* convert numeric pad scancodes into arrow codes */ +static unsigned char numlock_table[10] = { + KEY_INSERT, KEY_END, KEY_DOWN, KEY_PGDN, KEY_LEFT, + KEY_5_PAD, KEY_RIGHT, KEY_HOME, KEY_UP, KEY_PGUP +}; + + +/* kb_wait_for_write_ready: + * Wait for the keyboard controller to set the ready-for-write bit. + */ +static __inline int +kb_wait_for_write_ready (void) +{ + int timeout = 4096; + + while ((timeout > 0) && (inportb(0x64) & 2)) timeout--; + + return (timeout > 0); +} + + +/* kb_wait_for_read_ready: + * Wait for the keyboard controller to set the ready-for-read bit. + */ +static __inline int +kb_wait_for_read_ready (void) +{ + int timeout = 16384; + + while ((timeout > 0) && (!(inportb(0x64) & 1))) timeout--; + + return (timeout > 0); +} + + +/* kb_send_data: + * Sends a byte to the keyboard controller. Returns 1 if all OK. + */ +static __inline int +kb_send_data (unsigned char data) +{ + int resends = 4; + int timeout, temp; + + do { + if (!kb_wait_for_write_ready()) + return 0; + + outportb(0x60, data); + timeout = 4096; + + while (--timeout > 0) { + if (!kb_wait_for_read_ready()) + return 0; + + temp = inportb(0x60); + + if (temp == 0xFA) + return 1; + + if (temp == 0xFE) + break; + } + } while ((resends-- > 0) && (timeout > 0)); + + return 0; +} + + +static void +update_leds (int leds) +{ + if (leds_ok) { + if (!in_a_terrupt) + DISABLE(); + + if (!kb_send_data(0xED)) { + kb_send_data(0xF4); + leds_ok = FALSE; + } else if (!kb_send_data((leds >> 8) & 7)) { + kb_send_data(0xF4); + leds_ok = FALSE; + } + + if (!in_a_terrupt) + ENABLE(); + } +} ENDOFUNC(update_leds) + + +static void +inject_key (int scancode) +{ + unsigned short *table; + + if ((scancode >= KEY_0_PAD) && (scancode <= KEY_9_PAD)) { + if (((key_shifts & KB_NUMLOCK_FLAG) != 0) == ((key_shifts & KB_SHIFT_FLAG) != 0)) { + scancode = numlock_table[scancode - KEY_0_PAD]; + } + table = standard_key_ascii_table; + } else if (key_shifts & KB_CTRL_FLAG) { + table = standard_key_control_table; + } else if (key_shifts & KB_SHIFT_FLAG) { + if (key_shifts & KB_CAPSLOCK_FLAG) { + if (standard_key_ascii_table[scancode] == standard_key_capslock_table[scancode]) { + table = standard_key_shift_table; + } else { + table = standard_key_ascii_table; + } + } else { + table = standard_key_shift_table; + } + } else if (key_shifts & KB_CAPSLOCK_FLAG) { + table = standard_key_capslock_table; + } else { + table = standard_key_ascii_table; + } + + key_buffer.key[key_buffer.end++] = (scancode << 16) | table[scancode]; + + if (key_buffer.end >= KEY_BUFFER_SIZE) + key_buffer.end = 0; + if (key_buffer.end == key_buffer.start) { + key_buffer.start++; + if (key_buffer.start >= KEY_BUFFER_SIZE) + key_buffer.start = 0; + } +} ENDOFUNC(inject_key) + + +static void +handle_code (int scancode, int keycode) +{ + in_a_terrupt++; + + if (keycode == 0) { /* pause */ + inject_key(scancode); + pc_key[KEY_PAUSE] ^= TRUE; + } else if (scancode) { + int flag; + + if (scancode >= KEY_MODIFIERS) { + flag = modifier_table[scancode - KEY_MODIFIERS]; + } else { + flag = 0; + } + if ((char)keycode < 0) { /* release */ + pc_key[scancode] = FALSE; + if (flag & KB_MODIFIERS) { + key_shifts &= ~flag; + } + } else { /* keypress */ + pc_key[scancode] = TRUE; + if (flag & KB_MODIFIERS) { + key_shifts |= flag; + } + if (flag & KB_LED_FLAGS) { + key_shifts ^= flag; + update_leds(key_shifts); + } + if (scancode < KEY_MODIFIERS) { + inject_key(scancode); + } + } + } + + in_a_terrupt--; +} ENDOFUNC(handle_code) + + +static int +keyboard () +{ + unsigned char temp, scancode; + + temp = inportb(0x60); + + if (temp <= 0xe1) { + if (key_pause_loop) { + if (!--key_pause_loop) handle_code(KEY_PAUSE, 0); + } else + switch (temp) { + case 0xe0: + key_enhanced = TRUE; + break; + case 0xe1: + key_pause_loop = 5; + break; + default: + if (key_enhanced) { + key_enhanced = FALSE; + scancode = hw_to_mycode_ex[temp & 0x7f]; + } else { + scancode = hw_to_mycode[temp & 0x7f]; + } + handle_code(scancode, temp); + } + } + + if (((temp==0x4F)||(temp==0x53))&&(key_shifts&KB_CTRL_FLAG)&&(key_shifts&KB_ALT_FLAG)) { + /* Hack alert: + * only SIGINT (but not Ctrl-Break) + * calls the destructors and will safely clean up + */ + __asm("\n\ + movb $0x79, %%al \n\ + call ___djgpp_hw_exception \n\ + ":::"%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "memory"); + } + + __asm("\n\ + inb $0x61, %%al \n\ + movb %%al, %%ah \n\ + orb $0x80, %%al \n\ + outb %%al, $0x61 \n\ + xchgb %%al, %%ah \n\ + outb %%al, $0x61 \n\ + movb $0x20, %%al \n\ + outb %%al, $0x20 \n\ + ":::"%eax"); + return 0; +} ENDOFUNC(keyboard) + + +int +pc_keypressed (void) +{ + return (key_buffer.start!=key_buffer.end); +} + + +int +pc_readkey (void) +{ + if (keyboard_installed) { + int key; + + while (key_buffer.start == key_buffer.end) { + __dpmi_yield(); + } + + DISABLE(); + key = key_buffer.key[key_buffer.start++]; + if (key_buffer.start >= KEY_BUFFER_SIZE) + key_buffer.start = 0; + ENABLE(); + + return key; + } else { + return 0; + } +} + + +int +pc_keydown (int code) +{ + return pc_key[code]; +} + + +int +pc_keyshifts (void) +{ + return key_shifts; +} + + +void +pc_remove_keyb (void) +{ + if (keyboard_installed) { + int s1, s2, s3; + + keyboard_installed = FALSE; + pc_clexit(pc_remove_keyb); + + DISABLE(); + _farsetsel(__djgpp_dos_sel); + _farnspokew(0x41c, _farnspeekw(0x41a)); + + s1 = _farnspeekb(0x417) & 0x80; + s2 = _farnspeekb(0x418) & 0xFC; + s3 = _farnspeekb(0x496) & 0xF3; + + if (pc_key[KEY_RSHIFT]) { s1 |= 1; } + if (pc_key[KEY_LSHIFT]) { s1 |= 2; } + if (pc_key[KEY_LCONTROL]) { s2 |= 1; s1 |= 4; } + if (pc_key[KEY_ALT]) { s1 |= 8; s2 |= 2; } + if (pc_key[KEY_RCONTROL]) { s1 |= 4; s3 |= 4; } + if (pc_key[KEY_ALTGR]) { s1 |= 8; s3 |= 8; } + + if (key_shifts & KB_SCROLOCK_FLAG) s1 |= 16; + if (key_shifts & KB_NUMLOCK_FLAG) s1 |= 32; + if (key_shifts & KB_CAPSLOCK_FLAG) s1 |= 64; + + _farnspokeb(0x417, s1); + _farnspokeb(0x418, s2); + _farnspokeb(0x496, s3); + update_leds(key_shifts); + + ENABLE(); + pc_remove_irq(KEYB_IRQ); + } +} + + +int +pc_install_keyb (void) +{ + if (keyboard_installed || pc_install_irq(KEYB_IRQ, keyboard)) { + return -1; + } else { + int s1, s2, s3; + + LOCKDATA(key_buffer); + LOCKDATA(key_enhanced); + LOCKDATA(key_pause_loop); + LOCKDATA(key_shifts); + LOCKDATA(leds_ok); + LOCKDATA(in_a_terrupt); + LOCKDATA(pc_key); + LOCKDATA(modifier_table); + LOCKDATA(hw_to_mycode); + LOCKDATA(hw_to_mycode_ex); + LOCKDATA(standard_key_ascii_table); + LOCKDATA(standard_key_capslock_table); + LOCKDATA(standard_key_shift_table); + LOCKDATA(standard_key_control_table); + LOCKDATA(numlock_table); + LOCKFUNC(update_leds); + LOCKFUNC(inject_key); + LOCKFUNC(handle_code); + LOCKFUNC(keyboard); + + DISABLE(); + _farsetsel(__djgpp_dos_sel); + _farnspokew(0x41c, _farnspeekw(0x41a)); + + key_shifts = 0; + s1 = _farnspeekb(0x417); + s2 = _farnspeekb(0x418); + s3 = _farnspeekb(0x496); + + if (s1 & 1) { key_shifts |= KB_SHIFT_FLAG; pc_key[KEY_RSHIFT] = TRUE; } + if (s1 & 2) { key_shifts |= KB_SHIFT_FLAG; pc_key[KEY_LSHIFT] = TRUE; } + if (s2 & 1) { key_shifts |= KB_CTRL_FLAG; pc_key[KEY_LCONTROL] = TRUE; } + if (s2 & 2) { key_shifts |= KB_ALT_FLAG; pc_key[KEY_ALT] = TRUE; } + if (s3 & 4) { key_shifts |= KB_CTRL_FLAG; pc_key[KEY_RCONTROL] = TRUE; } + if (s3 & 8) { key_shifts |= KB_ALT_FLAG; pc_key[KEY_ALTGR] = TRUE; } + + if (s1 & 16) key_shifts |= KB_SCROLOCK_FLAG; + if (s1 & 32) key_shifts |= KB_NUMLOCK_FLAG; + if (s1 & 64) key_shifts |= KB_CAPSLOCK_FLAG; + update_leds(key_shifts); + + key_enhanced = key_pause_loop = 0; + key_buffer.start = key_buffer.end = 0; + ENABLE(); + + pc_atexit(pc_remove_keyb); + keyboard_installed = TRUE; + return 0; + } +} diff --git a/src/glut/dos/PC_HW/pc_mouse.c b/src/glut/dos/PC_HW/pc_mouse.c new file mode 100644 index 000000000..5bf99d367 --- /dev/null +++ b/src/glut/dos/PC_HW/pc_mouse.c @@ -0,0 +1,293 @@ +/* + * PC/HW routine collection v1.3 for DOS/DJGPP + * + * Copyright (C) 2002 - Daniel Borca + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include +#include +#include + +#include "pc_hw.h" + + +#define PC_CUTE_WHEEL 1 /* CuteMouse WheelAPI */ + +#define MOUSE_STACK_SIZE 16384 + +#define CLEAR_MICKEYS() \ + do { \ + __asm __volatile ("movw $0xb, %%ax; int $0x33":::"%eax", "%ecx", "%edx"); \ + ox = oy = 0; \ + } while (0) + +extern void mouse_wrap (void); +extern int mouse_wrap_end[]; + +static MFUNC mouse_func; +static long mouse_callback; +static __dpmi_regs mouse_regs; + +static volatile struct { + volatile int x, y, z, b; +} pc_mouse; + +static int minx = 0; +static int maxx = 319; +static int miny = 0; +static int maxy = 199; +static int minz = 0; +static int maxz = 255; + +static int sx = 2; +static int sy = 2; + +static int emulat3 = FALSE; + +static int ox, oy; + + +static void +mouse (__dpmi_regs *r) +{ + int nx = (signed short)r->x.si / sx; + int ny = (signed short)r->x.di / sy; + int dx = nx - ox; + int dy = ny - oy; +#if PC_CUTE_WHEEL + int dz = (signed char)r->h.bh; +#endif + ox = nx; + oy = ny; + + pc_mouse.b = r->h.bl; + pc_mouse.x = MID(minx, pc_mouse.x + dx, maxx); + pc_mouse.y = MID(miny, pc_mouse.y + dy, maxy); +#if PC_CUTE_WHEEL + pc_mouse.z = MID(minz, pc_mouse.z + dz, maxz); +#endif + + if (emulat3) { + if ((pc_mouse.b & 3) == 3) { + pc_mouse.b = 4; + } + } + + if (mouse_func) { + mouse_func(pc_mouse.x, pc_mouse.y, pc_mouse.z, pc_mouse.b); + } +} ENDOFUNC(mouse) + + +void +pc_remove_mouse (void) +{ + if (mouse_callback) { + pc_clexit(pc_remove_mouse); + __asm("\n\ + movl %%edx, %%ecx \n\ + shrl $16, %%ecx \n\ + movw $0x0304, %%ax \n\ + int $0x31 \n\ + movw $0x000c, %%ax \n\ + xorl %%ecx, %%ecx \n\ + int $0x33 \n\ + "::"d"(mouse_callback):"%eax", "%ecx"); + + mouse_callback = 0; + + free((void *)(mouse_wrap_end[0] - MOUSE_STACK_SIZE)); + } +} + + +int +pc_install_mouse (void) +{ + int buttons; + + /* fail if already call-backed */ + if (mouse_callback) { + return 0; + } + + /* reset mouse and get status */ + __asm("\n\ + xorl %%eax, %%eax \n\ + int $0x33 \n\ + andl %%ebx, %%eax \n\ + movl %%eax, %0 \n\ + ":"=g" (buttons)::"%eax", "%ebx"); + if (!buttons) { + return 0; + } + + /* lock wrapper */ + LOCKDATA(mouse_func); + LOCKDATA(mouse_callback); + LOCKDATA(mouse_regs); + LOCKDATA(pc_mouse); + LOCKDATA(minx); + LOCKDATA(maxx); + LOCKDATA(miny); + LOCKDATA(maxy); + LOCKDATA(minz); + LOCKDATA(maxz); + LOCKDATA(sx); + LOCKDATA(sy); + LOCKDATA(emulat3); + LOCKDATA(ox); + LOCKDATA(oy); + LOCKFUNC(mouse); + LOCKFUNC(mouse_wrap); + + mouse_wrap_end[1] = __djgpp_ds_alias; + /* grab a locked stack */ + if ((mouse_wrap_end[0] = (int)pc_malloc(MOUSE_STACK_SIZE)) == NULL) { + return 0; + } + + /* try to hook a call-back */ + __asm("\n\ + pushl %%ds \n\ + pushl %%es \n\ + movw $0x0303, %%ax \n\ + pushl %%ds \n\ + pushl %%cs \n\ + popl %%ds \n\ + popl %%es \n\ + int $0x31 \n\ + popl %%es \n\ + popl %%ds \n\ + jc 0f \n\ + shll $16, %%ecx \n\ + movw %%dx, %%cx \n\ + movl %%ecx, %0 \n\ + 0: \n\ + ":"=g"(mouse_callback) + :"S" (mouse_wrap), "D"(&mouse_regs) + :"%eax", "%ecx", "%edx"); + if (!mouse_callback) { + free((void *)mouse_wrap_end[0]); + return 0; + } + + /* adjust stack */ + mouse_wrap_end[0] += MOUSE_STACK_SIZE; + + /* install the handler */ + mouse_regs.x.ax = 0x000c; +#if PC_CUTE_WHEEL + mouse_regs.x.cx = 0x7f | 0x80; +#else + mouse_regs.x.cx = 0x7f; +#endif + mouse_regs.x.dx = mouse_callback & 0xffff; + mouse_regs.x.es = mouse_callback >> 16; + __dpmi_int(0x33, &mouse_regs); + + CLEAR_MICKEYS(); + + emulat3 = (buttons < 3); + pc_atexit(pc_remove_mouse); + return buttons; +} + + +MFUNC +pc_install_mouse_handler (MFUNC handler) +{ + MFUNC old; + + if (!mouse_callback && !pc_install_mouse()) { + return NULL; + } + + old = mouse_func; + mouse_func = handler; + return old; +} + + +void +pc_mouse_area (int x1, int y1, int x2, int y2) +{ + minx = x1; + maxx = x2; + miny = y1; + maxy = y2; +} + + +void +pc_mouse_speed (int xspeed, int yspeed) +{ + DISABLE(); + + sx = MAX(1, xspeed); + sy = MAX(1, yspeed); + + ENABLE(); +} + + +int +pc_query_mouse (int *x, int *y, int *z) +{ + *x = pc_mouse.x; + *y = pc_mouse.y; + *z = pc_mouse.z; + return pc_mouse.b; +} + + +void +pc_warp_mouse (int x, int y) +{ + CLEAR_MICKEYS(); + + pc_mouse.x = MID(minx, x, maxx); + pc_mouse.y = MID(miny, y, maxy); + + if (mouse_func) { + mouse_func(pc_mouse.x, pc_mouse.y, pc_mouse.z, pc_mouse.b); + } +} + + +/* Hack alert: + * `mouse_wrap_end' actually holds the + * address of stack in a safe data selector. + */ +__asm("\n\ + .text \n\ + .p2align 5,,31 \n\ + .global _mouse_wrap \n\ +_mouse_wrap: \n\ + cld \n\ + lodsl \n\ + movl %eax, %es:42(%edi) \n\ + addw $4, %es:46(%edi) \n\ + pushl %es \n\ + movl %ss, %ebx \n\ + movl %esp, %esi \n\ + lss %cs:_mouse_wrap_end, %esp\n\ + pushl %ss \n\ + pushl %ss \n\ + popl %es \n\ + popl %ds \n\ + movl ___djgpp_dos_sel, %fs \n\ + pushl %fs \n\ + popl %gs \n\ + pushl %edi \n\ + call _mouse \n\ + popl %edi \n\ + movl %ebx, %ss \n\ + movl %esi, %esp \n\ + popl %es \n\ + iret \n\ + .global _mouse_wrap_end \n\ +_mouse_wrap_end:.long 0, 0"); diff --git a/src/glut/dos/PC_HW/pc_timer.c b/src/glut/dos/PC_HW/pc_timer.c new file mode 100644 index 000000000..e7cbe70a1 --- /dev/null +++ b/src/glut/dos/PC_HW/pc_timer.c @@ -0,0 +1,327 @@ +/* + * PC/HW routine collection v1.5 for DOS/DJGPP + * + * Copyright (C) 2002 - Daniel Borca + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include +#include + +#include "pc_hw.h" + +#define TIMER_IRQ 0 + +#define MAX_TIMERS 8 + +#define PIT_FREQ 0x1234DD + +#define ADJUST(timer, basefreq) timer.counter = PIT_FREQ * timer.freq / SQR(basefreq) + +#define unvolatile(__v, __t) __extension__ ({union { volatile __t __cp; __t __p; } __q; __q.__cp = __v; __q.__p;}) + +static int timer_installed; + +typedef struct { + volatile unsigned int counter, clock_ticks, freq; + volatile PFUNC func; + volatile void *parm; +} TIMER; + +static TIMER timer_main, timer_func[MAX_TIMERS]; + + +/* Desc: main timer callback + * + * In : - + * Out : 0 to bypass BIOS, 1 to chain to BIOS + * + * Note: - + */ +static int +timer () +{ + int i; + + for (i = 0; i < MAX_TIMERS; i++) { + TIMER *t = &timer_func[i]; + if (t->func) { + t->clock_ticks += t->counter; + if (t->clock_ticks >= timer_main.counter) { + t->clock_ticks -= timer_main.counter; + t->func(unvolatile(t->parm, void *)); + } + } + } + + timer_main.clock_ticks += timer_main.counter; + if (timer_main.clock_ticks >= 0x10000) { + timer_main.clock_ticks -= 0x10000; + return 1; + } else { + outportb(0x20, 0x20); + return 0; + } +} ENDOFUNC(timer) + + +/* Desc: uninstall timer engine + * + * In : - + * Out : - + * + * Note: - + */ +void +pc_remove_timer (void) +{ + if (timer_installed) { + timer_installed = FALSE; + pc_clexit(pc_remove_timer); + + DISABLE(); + outportb(0x43, 0x34); + outportb(0x40, 0); + outportb(0x40, 0); + ENABLE(); + + pc_remove_irq(TIMER_IRQ); + } +} + + +/* Desc: remove timerfunc + * + * In : timerfunc id + * Out : 0 if success + * + * Note: tries to relax the main timer whenever possible + */ +int +pc_remove_int (int fid) +{ + int i; + unsigned int freq = 0; + + /* are we installed? */ + if (!timer_installed) { + return -1; + } + + /* sanity check */ + if ((fid < 0) || (fid >= MAX_TIMERS) || (timer_func[fid].func == NULL)) { + return -1; + } + timer_func[fid].func = NULL; + + /* scan for maximum frequency */ + for (i = 0; i < MAX_TIMERS; i++) { + TIMER *t = &timer_func[i]; + if (t->func) { + if (freq < t->freq) { + freq = t->freq; + } + } + } + + /* if there are no callbacks left, cleanup */ + if (!freq) { + pc_remove_timer(); + return 0; + } + + /* if we just lowered the maximum frequency, try to relax the timer engine */ + if (freq < timer_main.freq) { + unsigned int new_counter = PIT_FREQ / freq; + + DISABLE(); + + for (i = 0; i < MAX_TIMERS; i++) { + if (timer_func[i].func) { + ADJUST(timer_func[i], freq); + } + } + + outportb(0x43, 0x34); + outportb(0x40, (unsigned char)new_counter); + outportb(0x40, (unsigned char)(new_counter>>8)); + timer_main.clock_ticks = 0; + timer_main.counter = new_counter; + timer_main.freq = freq; + + ENABLE(); + } + + return 0; +} ENDOFUNC(pc_remove_int) + + +/* Desc: adjust timerfunc + * + * In : timerfunc id, new frequency (Hz) + * Out : 0 if success + * + * Note: might change the main timer frequency + */ +int +pc_adjust_int (int fid, unsigned int freq) +{ + int i; + + /* are we installed? */ + if (!timer_installed) { + return -1; + } + + /* sanity check */ + if ((fid < 0) || (fid >= MAX_TIMERS) || (timer_func[fid].func == NULL)) { + return -1; + } + timer_func[fid].freq = freq; + + /* scan for maximum frequency */ + freq = 0; + for (i = 0; i < MAX_TIMERS; i++) { + TIMER *t = &timer_func[i]; + if (t->func) { + if (freq < t->freq) { + freq = t->freq; + } + } + } + + /* update main timer / sons to match highest frequency */ + DISABLE(); + + /* using '>' is correct still (and avoids updating + * the HW timer too often), but doesn't relax the timer! + */ + if (freq != timer_main.freq) { + unsigned int new_counter = PIT_FREQ / freq; + + for (i = 0; i < MAX_TIMERS; i++) { + if (timer_func[i].func) { + ADJUST(timer_func[i], freq); + } + } + + outportb(0x43, 0x34); + outportb(0x40, (unsigned char)new_counter); + outportb(0x40, (unsigned char)(new_counter>>8)); + timer_main.clock_ticks = 0; + timer_main.counter = new_counter; + timer_main.freq = freq; + } else { + ADJUST(timer_func[fid], timer_main.freq); + } + + ENABLE(); + + return 0; +} ENDOFUNC(pc_adjust_int) + + +/* Desc: install timer engine + * + * In : - + * Out : 0 for success + * + * Note: initial frequency is 18.2 Hz + */ +static int +install_timer (void) +{ + if (timer_installed || pc_install_irq(TIMER_IRQ, timer)) { + return -1; + } else { + memset(timer_func, 0, sizeof(timer_func)); + + LOCKDATA(timer_func); + LOCKDATA(timer_main); + LOCKFUNC(timer); + LOCKFUNC(pc_adjust_int); + LOCKFUNC(pc_remove_int); + + timer_main.counter = 0x10000; + + DISABLE(); + outportb(0x43, 0x34); + outportb(0x40, 0); + outportb(0x40, 0); + timer_main.clock_ticks = 0; + ENABLE(); + + pc_atexit(pc_remove_timer); + timer_installed = TRUE; + return 0; + } +} + + +/* Desc: install timerfunc + * + * In : callback function, opaque pointer to be passed to callee, freq (Hz) + * Out : timerfunc id (0 .. MAX_TIMERS-1) + * + * Note: returns -1 if error + */ +int +pc_install_int (PFUNC func, void *parm, unsigned int freq) +{ + int i; + TIMER *t = NULL; + + /* ensure the timer engine is set up */ + if (!timer_installed) { + if (install_timer()) { + return -1; + } + } + + /* find an empty slot */ + for (i = 0; i < MAX_TIMERS; i++) { + if (!timer_func[i].func) { + t = &timer_func[i]; + break; + } + } + if (t == NULL) { + return -1; + } + + DISABLE(); + + t->func = func; + t->parm = parm; + t->freq = freq; + t->clock_ticks = 0; + + /* update main timer / sons to match highest frequency */ + if (freq > timer_main.freq) { + unsigned int new_counter = PIT_FREQ / freq; + + for (i = 0; i < MAX_TIMERS; i++) { + if (timer_func[i].func) { + ADJUST(timer_func[i], freq); + } + } + + outportb(0x43, 0x34); + outportb(0x40, (unsigned char)new_counter); + outportb(0x40, (unsigned char)(new_counter>>8)); + timer_main.clock_ticks = 0; + timer_main.counter = new_counter; + timer_main.freq = freq; + } else { + /* t == &timer_func[i] */ + ADJUST(timer_func[i], timer_main.freq); + } + + i = t - timer_func; + + ENABLE(); + + return i; +} diff --git a/src/glut/dos/bitmap.c b/src/glut/dos/bitmap.c new file mode 100644 index 000000000..6d6b91e1c --- /dev/null +++ b/src/glut/dos/bitmap.c @@ -0,0 +1,115 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "internal.h" + + +void APIENTRY +glutBitmapCharacter (void *font, int c) +{ + const GLUTBitmapFont *bfp = _glut_font(font); + const GLUTBitmapChar *bcp; + + if (c >= bfp->num || !(bcp = bfp->table[c])) + return; + + glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); + + 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(bcp->width, bcp->height, bcp->xorig, bcp->yorig, + bcp->xmove, 0, bcp->bitmap); + + glPopClientAttrib(); +} + + +void APIENTRY +glutBitmapString (void *font, const unsigned char *string) +{ + const GLUTBitmapFont *bfp = _glut_font(font); + const GLUTBitmapChar *bcp; + unsigned char c; + + glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); + + 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); + + while ((c = *(string++))) { + if (c < bfp->num && (bcp = bfp->table[c])) + glBitmap(bcp->width, bcp->height, bcp->xorig, + bcp->yorig, bcp->xmove, 0, bcp->bitmap); + } + + glPopClientAttrib(); +} + + +int APIENTRY +glutBitmapWidth (void *font, int c) +{ + const GLUTBitmapFont *bfp = _glut_font(font); + const GLUTBitmapChar *bcp; + + if (c >= bfp->num || !(bcp = bfp->table[c])) + return 0; + + return bcp->xmove; +} + + +int APIENTRY +glutBitmapLength (void *font, const unsigned char *string) +{ + const GLUTBitmapFont *bfp = _glut_font(font); + const GLUTBitmapChar *bcp; + unsigned char c; + int length = 0; + + while ((c = *(string++))) { + if (c < bfp->num && (bcp = bfp->table[c])) + length += bcp->xmove; + } + + return length; +} + + +int APIENTRY +glutBitmapHeight (void *font) +{ + const GLUTBitmapFont *bfp = _glut_font(font); + + return bfp->height; +} diff --git a/src/glut/dos/callback.c b/src/glut/dos/callback.c new file mode 100644 index 000000000..b6cc58fea --- /dev/null +++ b/src/glut/dos/callback.c @@ -0,0 +1,204 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "internal.h" + + +GLUTSShotCB _glut_timer_cb[MAX_TIMER_CB]; + +GLUTidleCB _glut_idle_func = NULL; + + +void APIENTRY +glutDisplayFunc (GLUTdisplayCB func) +{ + _glut_current->display = func; +} + + +void APIENTRY +glutReshapeFunc (GLUTreshapeCB func) +{ + _glut_current->reshape = func; +} + + +void APIENTRY +glutKeyboardFunc (GLUTkeyboardCB func) +{ + _glut_current->keyboard = func; +} + + +void APIENTRY +glutMouseFunc (GLUTmouseCB func) +{ + _glut_current->mouse = func; +} + + +void APIENTRY +glutMotionFunc (GLUTmotionCB func) +{ + _glut_current->motion = func; +} + + +void APIENTRY +glutPassiveMotionFunc (GLUTpassiveCB func) +{ + _glut_current->passive = func; +} + + +void APIENTRY +glutEntryFunc (GLUTentryCB func) +{ + _glut_current->entry = func; +} + + +void APIENTRY +glutVisibilityFunc (GLUTvisibilityCB func) +{ + _glut_current->visibility = func; +} + + +void APIENTRY +glutWindowStatusFunc (GLUTwindowStatusCB func) +{ + _glut_current->windowStatus = func; +} + + +void APIENTRY +glutIdleFunc (GLUTidleCB func) +{ + _glut_idle_func = func; +} + + +void APIENTRY +glutTimerFunc (unsigned int millis, GLUTtimerCB func, int value) +{ + int i; + + if (millis > 0) { + for (i = 0; i < MAX_TIMER_CB; i++) { + GLUTSShotCB *cb = &_glut_timer_cb[i]; + if (cb->func == NULL) { + cb->value = value; + cb->func = func; + cb->time = glutGet(GLUT_ELAPSED_TIME) + millis; + break; + } + } + } +} + + +void APIENTRY +glutSpecialFunc (GLUTspecialCB func) +{ + _glut_current->special = func; +} + + +void APIENTRY +glutSpaceballMotionFunc (GLUTspaceMotionCB func) +{ + _glut_current->spaceMotion = func; +} + + +void APIENTRY +glutSpaceballRotateFunc (GLUTspaceRotateCB func) +{ + _glut_current->spaceRotate = func; +} + + +void APIENTRY +glutSpaceballButtonFunc (GLUTspaceButtonCB func) +{ + _glut_current->spaceButton = func; +} + + +void APIENTRY +glutDialsFunc (GLUTdialsCB func) +{ + _glut_current->dials = func; +} + + +void APIENTRY +glutButtonBoxFunc (GLUTbuttonBoxCB func) +{ + _glut_current->buttonBox = func; +} + + +void APIENTRY +glutTabletMotionFunc (GLUTtabletMotionCB func) +{ + _glut_current->tabletMotion = func; +} + + +void APIENTRY +glutTabletButtonFunc (GLUTtabletButtonCB func) +{ + _glut_current->tabletButton = func; +} + + +void APIENTRY +glutJoystickFunc (GLUTjoystickCB func, int interval) +{ + _glut_current->joystick = func; +} + + +void APIENTRY +glutKeyboardUpFunc (GLUTkeyboardCB func) +{ + _glut_current->keyboardUp = func; +} + + +void APIENTRY +glutSpecialUpFunc (GLUTspecialCB func) +{ + _glut_current->specialUp = func; +} + + +void APIENTRY +glutMouseWheelFunc (GLUTmouseWheelCB func) +{ + _glut_current->mouseWheel = func; +} diff --git a/src/glut/dos/color.c b/src/glut/dos/color.c new file mode 100644 index 000000000..5ffc1209a --- /dev/null +++ b/src/glut/dos/color.c @@ -0,0 +1,53 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "internal.h" + + +#define CLAMP(i) ((i) > 1.0F ? 1.0F : ((i) < 0.0F ? 0.0F : (i))) + + +void APIENTRY +glutSetColor (int ndx, GLfloat red, GLfloat green, GLfloat blue) +{ + if (_glut_default.mode & GLUT_INDEX) { + if ((ndx >= 0) && (ndx < (256 - RESERVED_COLORS))) { + DMesaSetCI(ndx, CLAMP(red), CLAMP(green), CLAMP(blue)); + } + } +} + + +GLfloat APIENTRY +glutGetColor (int ndx, int component) +{ + return 0.0; +} + + +void APIENTRY +glutCopyColormap (int win) +{ +} diff --git a/src/glut/dos/extens.c b/src/glut/dos/extens.c new file mode 100644 index 000000000..8bb867264 --- /dev/null +++ b/src/glut/dos/extens.c @@ -0,0 +1,70 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include + +#include "internal.h" + + +int APIENTRY +glutExtensionSupported (const char *extension) +{ + static const GLubyte *extensions = NULL; + const GLubyte *last, *where; + + /* Extension names should not have spaces. */ + if (strchr(extension, ' ') || *extension == '\0') { + return GL_FALSE; + } + + /* Not my problem if you don't have a valid OpenGL context */ + if (!extensions) { + extensions = glGetString(GL_EXTENSIONS); + } + if (!extensions) { + return GL_FALSE; + } + + /* Take care of sub-strings etc. */ + for (last = extensions;;) { + if ((where = (GLubyte *)strstr((const char *)last, extension)) == NULL) { + return GL_FALSE; + } + last = where + strlen(extension); + if (where == extensions || *(where - 1) == ' ') { + if (*last == ' ' || *last == '\0') { + return GL_TRUE; + } + } + } +} + + +GLUTproc APIENTRY +glutGetProcAddress (const char *procName) +{ + /* TODO - handle glut namespace */ + return (GLUTproc)DMesaGetProcAddress(procName); +} diff --git a/src/glut/dos/f8x13.c b/src/glut/dos/f8x13.c new file mode 100644 index 000000000..bbf58b52b --- /dev/null +++ b/src/glut/dos/f8x13.c @@ -0,0 +1,1183 @@ +/* autogenerated by bdf2c! do not edit */ + +/* "Public domain font. Share and enjoy." */ + + +#include "internal.h" +/* +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; +*/ + + +static const unsigned char ch0data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch0 = { 8, 13, 0, 2, 8, ch0data }; + +static const unsigned char ch1data[] = { + 0x0,0x0,0x0,0x10,0x38,0x7c,0xfe,0x7c,0x38,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch1 = { 8, 13, 0, 2, 8, ch1data }; + +static const unsigned char ch2data[] = { + 0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x0 +}; +static const GLUTBitmapChar ch2 = { 8, 13, 0, 2, 8, ch2data }; + +static const unsigned char ch3data[] = { + 0x8,0x8,0x8,0x3e,0x88,0x88,0xf8,0x88,0x88,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch3 = { 8, 13, 0, 2, 8, ch3data }; + +static const unsigned char ch4data[] = { + 0x10,0x10,0x1c,0x10,0x9e,0x80,0xe0,0x80,0xf0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch4 = { 8, 13, 0, 2, 8, ch4data }; + +static const unsigned char ch5data[] = { + 0x22,0x22,0x3c,0x22,0x3c,0x78,0x80,0x80,0x78,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch5 = { 8, 13, 0, 2, 8, ch5data }; + +static const unsigned char ch6data[] = { + 0x20,0x20,0x3c,0x20,0x3e,0xf8,0x80,0x80,0x80,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch6 = { 8, 13, 0, 2, 8, ch6data }; + +static const unsigned char ch7data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x38,0x44,0x44,0x38,0x0,0x0 +}; +static const GLUTBitmapChar ch7 = { 8, 13, 0, 2, 8, ch7data }; + +static const unsigned char ch8data[] = { + 0x0,0x0,0xfe,0x10,0x10,0xfe,0x10,0x10,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch8 = { 8, 13, 0, 2, 8, ch8data }; + +static const unsigned char ch9data[] = { + 0x3e,0x20,0x20,0x20,0x88,0x98,0xa8,0xc8,0x88,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch9 = { 8, 13, 0, 2, 8, ch9data }; + +static const unsigned char ch10data[] = { + 0x8,0x8,0x8,0x8,0x3e,0x20,0x50,0x88,0x88,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch10 = { 8, 13, 0, 2, 8, ch10data }; + +static const unsigned char ch11data[] = { + 0x0,0x0,0x0,0x0,0x0,0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch11 = { 8, 13, 0, 2, 8, ch11data }; + +static const unsigned char ch12data[] = { + 0x10,0x10,0x10,0x10,0x10,0xf0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch12 = { 8, 13, 0, 2, 8, ch12data }; + +static const unsigned char ch13data[] = { + 0x10,0x10,0x10,0x10,0x10,0x1f,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch13 = { 8, 13, 0, 2, 8, ch13data }; + +static const unsigned char ch14data[] = { + 0x0,0x0,0x0,0x0,0x0,0x1f,0x10,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch14 = { 8, 13, 0, 2, 8, ch14data }; + +static const unsigned char ch15data[] = { + 0x10,0x10,0x10,0x10,0x10,0xff,0x10,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch15 = { 8, 13, 0, 2, 8, ch15data }; + +static const unsigned char ch16data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch16 = { 8, 13, 0, 2, 8, ch16data }; + +static const unsigned char ch17data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch17 = { 8, 13, 0, 2, 8, ch17data }; + +static const unsigned char ch18data[] = { + 0x0,0x0,0x0,0x0,0x0,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch18 = { 8, 13, 0, 2, 8, ch18data }; + +static const unsigned char ch19data[] = { + 0x0,0x0,0x0,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch19 = { 8, 13, 0, 2, 8, ch19data }; + +static const unsigned char ch20data[] = { + 0x0,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch20 = { 8, 13, 0, 2, 8, ch20data }; + +static const unsigned char ch21data[] = { + 0x10,0x10,0x10,0x10,0x10,0x1f,0x10,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch21 = { 8, 13, 0, 2, 8, ch21data }; + +static const unsigned char ch22data[] = { + 0x10,0x10,0x10,0x10,0x10,0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch22 = { 8, 13, 0, 2, 8, ch22data }; + +static const unsigned char ch23data[] = { + 0x0,0x0,0x0,0x0,0x0,0xff,0x10,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch23 = { 8, 13, 0, 2, 8, ch23data }; + +static const unsigned char ch24data[] = { + 0x10,0x10,0x10,0x10,0x10,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch24 = { 8, 13, 0, 2, 8, ch24data }; + +static const unsigned char ch25data[] = { + 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch25 = { 8, 13, 0, 2, 8, ch25data }; + +static const unsigned char ch26data[] = { + 0x0,0x0,0xfe,0x2,0x8,0x20,0x80,0x20,0x8,0x2,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch26 = { 8, 13, 0, 2, 8, ch26data }; + +static const unsigned char ch27data[] = { + 0x0,0x0,0xfe,0x80,0x20,0x8,0x2,0x8,0x20,0x80,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch27 = { 8, 13, 0, 2, 8, ch27data }; + +static const unsigned char ch28data[] = { + 0x0,0x0,0x44,0x24,0x24,0x24,0x24,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch28 = { 8, 13, 0, 2, 8, ch28data }; + +static const unsigned char ch29data[] = { + 0x0,0x0,0x80,0x40,0xfe,0x10,0xfe,0x4,0x2,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch29 = { 8, 13, 0, 2, 8, ch29data }; + +static const unsigned char ch30data[] = { + 0x0,0x0,0xdc,0x62,0x20,0x20,0x20,0x70,0x20,0x22,0x1c,0x0,0x0 +}; +static const GLUTBitmapChar ch30 = { 8, 13, 0, 2, 8, ch30data }; + +static const unsigned char ch31data[] = { + 0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch31 = { 8, 13, 0, 2, 8, ch31data }; + +static const unsigned char ch32data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch32 = { 8, 13, 0, 2, 8, ch32data }; + +static const unsigned char ch33data[] = { + 0x0,0x0,0x10,0x0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch33 = { 8, 13, 0, 2, 8, ch33data }; + +static const unsigned char ch34data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x24,0x24,0x24,0x0,0x0 +}; +static const GLUTBitmapChar ch34 = { 8, 13, 0, 2, 8, ch34data }; + +static const unsigned char ch35data[] = { + 0x0,0x0,0x0,0x24,0x24,0x7e,0x24,0x7e,0x24,0x24,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch35 = { 8, 13, 0, 2, 8, ch35data }; + +static const unsigned char ch36data[] = { + 0x0,0x0,0x0,0x10,0x78,0x14,0x38,0x50,0x3c,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch36 = { 8, 13, 0, 2, 8, ch36data }; + +static const unsigned char ch37data[] = { + 0x0,0x0,0x44,0x2a,0x24,0x10,0x8,0x8,0x24,0x52,0x22,0x0,0x0 +}; +static const GLUTBitmapChar ch37 = { 8, 13, 0, 2, 8, ch37data }; + +static const unsigned char ch38data[] = { + 0x0,0x0,0x3a,0x44,0x4a,0x30,0x48,0x48,0x30,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch38 = { 8, 13, 0, 2, 8, ch38data }; + +static const unsigned char ch39data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30,0x38,0x0,0x0 +}; +static const GLUTBitmapChar ch39 = { 8, 13, 0, 2, 8, ch39data }; + +static const unsigned char ch40data[] = { + 0x0,0x0,0x4,0x8,0x8,0x10,0x10,0x10,0x8,0x8,0x4,0x0,0x0 +}; +static const GLUTBitmapChar ch40 = { 8, 13, 0, 2, 8, ch40data }; + +static const unsigned char ch41data[] = { + 0x0,0x0,0x20,0x10,0x10,0x8,0x8,0x8,0x10,0x10,0x20,0x0,0x0 +}; +static const GLUTBitmapChar ch41 = { 8, 13, 0, 2, 8, ch41data }; + +static const unsigned char ch42data[] = { + 0x0,0x0,0x0,0x0,0x24,0x18,0x7e,0x18,0x24,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch42 = { 8, 13, 0, 2, 8, ch42data }; + +static const unsigned char ch43data[] = { + 0x0,0x0,0x0,0x0,0x10,0x10,0x7c,0x10,0x10,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch43 = { 8, 13, 0, 2, 8, ch43data }; + +static const unsigned char ch44data[] = { + 0x0,0x40,0x30,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch44 = { 8, 13, 0, 2, 8, ch44data }; + +static const unsigned char ch45data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch45 = { 8, 13, 0, 2, 8, ch45data }; + +static const unsigned char ch46data[] = { + 0x0,0x10,0x38,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch46 = { 8, 13, 0, 2, 8, ch46data }; + +static const unsigned char ch47data[] = { + 0x0,0x0,0x80,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0x2,0x0,0x0 +}; +static const GLUTBitmapChar ch47 = { 8, 13, 0, 2, 8, ch47data }; + +static const unsigned char ch48data[] = { + 0x0,0x0,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x0,0x0 +}; +static const GLUTBitmapChar ch48 = { 8, 13, 0, 2, 8, ch48data }; + +static const unsigned char ch49data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x10,0x50,0x30,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch49 = { 8, 13, 0, 2, 8, ch49data }; + +static const unsigned char ch50data[] = { + 0x0,0x0,0x7e,0x40,0x20,0x18,0x4,0x2,0x42,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch50 = { 8, 13, 0, 2, 8, ch50data }; + +static const unsigned char ch51data[] = { + 0x0,0x0,0x3c,0x42,0x2,0x2,0x1c,0x8,0x4,0x2,0x7e,0x0,0x0 +}; +static const GLUTBitmapChar ch51 = { 8, 13, 0, 2, 8, ch51data }; + +static const unsigned char ch52data[] = { + 0x0,0x0,0x4,0x4,0x7e,0x44,0x44,0x24,0x14,0xc,0x4,0x0,0x0 +}; +static const GLUTBitmapChar ch52 = { 8, 13, 0, 2, 8, ch52data }; + +static const unsigned char ch53data[] = { + 0x0,0x0,0x3c,0x42,0x2,0x2,0x62,0x5c,0x40,0x40,0x7e,0x0,0x0 +}; +static const GLUTBitmapChar ch53 = { 8, 13, 0, 2, 8, ch53data }; + +static const unsigned char ch54data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x62,0x5c,0x40,0x40,0x20,0x1c,0x0,0x0 +}; +static const GLUTBitmapChar ch54 = { 8, 13, 0, 2, 8, ch54data }; + +static const unsigned char ch55data[] = { + 0x0,0x0,0x20,0x20,0x10,0x10,0x8,0x8,0x4,0x2,0x7e,0x0,0x0 +}; +static const GLUTBitmapChar ch55 = { 8, 13, 0, 2, 8, ch55data }; + +static const unsigned char ch56data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x3c,0x42,0x42,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch56 = { 8, 13, 0, 2, 8, ch56data }; + +static const unsigned char ch57data[] = { + 0x0,0x0,0x38,0x4,0x2,0x2,0x3a,0x46,0x42,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch57 = { 8, 13, 0, 2, 8, ch57data }; + +static const unsigned char ch58data[] = { + 0x0,0x10,0x38,0x10,0x0,0x0,0x10,0x38,0x10,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch58 = { 8, 13, 0, 2, 8, ch58data }; + +static const unsigned char ch59data[] = { + 0x0,0x40,0x30,0x38,0x0,0x0,0x10,0x38,0x10,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch59 = { 8, 13, 0, 2, 8, ch59data }; + +static const unsigned char ch60data[] = { + 0x0,0x0,0x2,0x4,0x8,0x10,0x20,0x10,0x8,0x4,0x2,0x0,0x0 +}; +static const GLUTBitmapChar ch60 = { 8, 13, 0, 2, 8, ch60data }; + +static const unsigned char ch61data[] = { + 0x0,0x0,0x0,0x0,0x7e,0x0,0x0,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch61 = { 8, 13, 0, 2, 8, ch61data }; + +static const unsigned char ch62data[] = { + 0x0,0x0,0x40,0x20,0x10,0x8,0x4,0x8,0x10,0x20,0x40,0x0,0x0 +}; +static const GLUTBitmapChar ch62 = { 8, 13, 0, 2, 8, ch62data }; + +static const unsigned char ch63data[] = { + 0x0,0x0,0x8,0x0,0x8,0x8,0x4,0x2,0x42,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch63 = { 8, 13, 0, 2, 8, ch63data }; + +static const unsigned char ch64data[] = { + 0x0,0x0,0x3c,0x40,0x4a,0x56,0x52,0x4e,0x42,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch64 = { 8, 13, 0, 2, 8, ch64data }; + +static const unsigned char ch65data[] = { + 0x0,0x0,0x42,0x42,0x42,0x7e,0x42,0x42,0x42,0x24,0x18,0x0,0x0 +}; +static const GLUTBitmapChar ch65 = { 8, 13, 0, 2, 8, ch65data }; + +static const unsigned char ch66data[] = { + 0x0,0x0,0xfc,0x42,0x42,0x42,0x7c,0x42,0x42,0x42,0xfc,0x0,0x0 +}; +static const GLUTBitmapChar ch66 = { 8, 13, 0, 2, 8, ch66data }; + +static const unsigned char ch67data[] = { + 0x0,0x0,0x3c,0x42,0x40,0x40,0x40,0x40,0x40,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch67 = { 8, 13, 0, 2, 8, ch67data }; + +static const unsigned char ch68data[] = { + 0x0,0x0,0xfc,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0xfc,0x0,0x0 +}; +static const GLUTBitmapChar ch68 = { 8, 13, 0, 2, 8, ch68data }; + +static const unsigned char ch69data[] = { + 0x0,0x0,0x7e,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0x7e,0x0,0x0 +}; +static const GLUTBitmapChar ch69 = { 8, 13, 0, 2, 8, ch69data }; + +static const unsigned char ch70data[] = { + 0x0,0x0,0x40,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0x7e,0x0,0x0 +}; +static const GLUTBitmapChar ch70 = { 8, 13, 0, 2, 8, ch70data }; + +static const unsigned char ch71data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x4e,0x40,0x40,0x40,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch71 = { 8, 13, 0, 2, 8, ch71data }; + +static const unsigned char ch72data[] = { + 0x0,0x0,0x42,0x42,0x42,0x42,0x7e,0x42,0x42,0x42,0x42,0x0,0x0 +}; +static const GLUTBitmapChar ch72 = { 8, 13, 0, 2, 8, ch72data }; + +static const unsigned char ch73data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7c,0x0,0x0 +}; +static const GLUTBitmapChar ch73 = { 8, 13, 0, 2, 8, ch73data }; + +static const unsigned char ch74data[] = { + 0x0,0x0,0x38,0x44,0x4,0x4,0x4,0x4,0x4,0x4,0x1e,0x0,0x0 +}; +static const GLUTBitmapChar ch74 = { 8, 13, 0, 2, 8, ch74data }; + +static const unsigned char ch75data[] = { + 0x0,0x0,0x42,0x44,0x48,0x50,0x60,0x50,0x48,0x44,0x42,0x0,0x0 +}; +static const GLUTBitmapChar ch75 = { 8, 13, 0, 2, 8, ch75data }; + +static const unsigned char ch76data[] = { + 0x0,0x0,0x7e,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x0 +}; +static const GLUTBitmapChar ch76 = { 8, 13, 0, 2, 8, ch76data }; + +static const unsigned char ch77data[] = { + 0x0,0x0,0x82,0x82,0x82,0x92,0x92,0xaa,0xc6,0x82,0x82,0x0,0x0 +}; +static const GLUTBitmapChar ch77 = { 8, 13, 0, 2, 8, ch77data }; + +static const unsigned char ch78data[] = { + 0x0,0x0,0x42,0x42,0x42,0x46,0x4a,0x52,0x62,0x42,0x42,0x0,0x0 +}; +static const GLUTBitmapChar ch78 = { 8, 13, 0, 2, 8, ch78data }; + +static const unsigned char ch79data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch79 = { 8, 13, 0, 2, 8, ch79data }; + +static const unsigned char ch80data[] = { + 0x0,0x0,0x40,0x40,0x40,0x40,0x7c,0x42,0x42,0x42,0x7c,0x0,0x0 +}; +static const GLUTBitmapChar ch80 = { 8, 13, 0, 2, 8, ch80data }; + +static const unsigned char ch81data[] = { + 0x0,0x2,0x3c,0x4a,0x52,0x42,0x42,0x42,0x42,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch81 = { 8, 13, 0, 2, 8, ch81data }; + +static const unsigned char ch82data[] = { + 0x0,0x0,0x42,0x44,0x48,0x50,0x7c,0x42,0x42,0x42,0x7c,0x0,0x0 +}; +static const GLUTBitmapChar ch82 = { 8, 13, 0, 2, 8, ch82data }; + +static const unsigned char ch83data[] = { + 0x0,0x0,0x3c,0x42,0x2,0x2,0x3c,0x40,0x40,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch83 = { 8, 13, 0, 2, 8, ch83data }; + +static const unsigned char ch84data[] = { + 0x0,0x0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xfe,0x0,0x0 +}; +static const GLUTBitmapChar ch84 = { 8, 13, 0, 2, 8, ch84data }; + +static const unsigned char ch85data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x0,0x0 +}; +static const GLUTBitmapChar ch85 = { 8, 13, 0, 2, 8, ch85data }; + +static const unsigned char ch86data[] = { + 0x0,0x0,0x10,0x28,0x28,0x28,0x44,0x44,0x44,0x82,0x82,0x0,0x0 +}; +static const GLUTBitmapChar ch86 = { 8, 13, 0, 2, 8, ch86data }; + +static const unsigned char ch87data[] = { + 0x0,0x0,0x44,0xaa,0x92,0x92,0x92,0x82,0x82,0x82,0x82,0x0,0x0 +}; +static const GLUTBitmapChar ch87 = { 8, 13, 0, 2, 8, ch87data }; + +static const unsigned char ch88data[] = { + 0x0,0x0,0x82,0x82,0x44,0x28,0x10,0x28,0x44,0x82,0x82,0x0,0x0 +}; +static const GLUTBitmapChar ch88 = { 8, 13, 0, 2, 8, ch88data }; + +static const unsigned char ch89data[] = { + 0x0,0x0,0x10,0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,0x0,0x0 +}; +static const GLUTBitmapChar ch89 = { 8, 13, 0, 2, 8, ch89data }; + +static const unsigned char ch90data[] = { + 0x0,0x0,0x7e,0x40,0x40,0x20,0x10,0x8,0x4,0x2,0x7e,0x0,0x0 +}; +static const GLUTBitmapChar ch90 = { 8, 13, 0, 2, 8, ch90data }; + +static const unsigned char ch91data[] = { + 0x0,0x0,0x3c,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch91 = { 8, 13, 0, 2, 8, ch91data }; + +static const unsigned char ch92data[] = { + 0x0,0x0,0x2,0x2,0x4,0x8,0x10,0x20,0x40,0x80,0x80,0x0,0x0 +}; +static const GLUTBitmapChar ch92 = { 8, 13, 0, 2, 8, ch92data }; + +static const unsigned char ch93data[] = { + 0x0,0x0,0x78,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x78,0x0,0x0 +}; +static const GLUTBitmapChar ch93 = { 8, 13, 0, 2, 8, ch93data }; + +static const unsigned char ch94data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x44,0x28,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch94 = { 8, 13, 0, 2, 8, ch94data }; + +static const unsigned char ch95data[] = { + 0x0,0xfe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch95 = { 8, 13, 0, 2, 8, ch95data }; + +static const unsigned char ch96data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x18,0x38,0x0,0x0 +}; +static const GLUTBitmapChar ch96 = { 8, 13, 0, 2, 8, ch96data }; + +static const unsigned char ch97data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x3e,0x2,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch97 = { 8, 13, 0, 2, 8, ch97data }; + +static const unsigned char ch98data[] = { + 0x0,0x0,0x5c,0x62,0x42,0x42,0x62,0x5c,0x40,0x40,0x40,0x0,0x0 +}; +static const GLUTBitmapChar ch98 = { 8, 13, 0, 2, 8, ch98data }; + +static const unsigned char ch99data[] = { + 0x0,0x0,0x3c,0x42,0x40,0x40,0x42,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch99 = { 8, 13, 0, 2, 8, ch99data }; + +static const unsigned char ch100data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x42,0x46,0x3a,0x2,0x2,0x2,0x0,0x0 +}; +static const GLUTBitmapChar ch100 = { 8, 13, 0, 2, 8, ch100data }; + +static const unsigned char ch101data[] = { + 0x0,0x0,0x3c,0x42,0x40,0x7e,0x42,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch101 = { 8, 13, 0, 2, 8, ch101data }; + +static const unsigned char ch102data[] = { + 0x0,0x0,0x20,0x20,0x20,0x20,0x7c,0x20,0x20,0x22,0x1c,0x0,0x0 +}; +static const GLUTBitmapChar ch102 = { 8, 13, 0, 2, 8, ch102data }; + +static const unsigned char ch103data[] = { + 0x3c,0x42,0x3c,0x40,0x38,0x44,0x44,0x3a,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch103 = { 8, 13, 0, 2, 8, ch103data }; + +static const unsigned char ch104data[] = { + 0x0,0x0,0x42,0x42,0x42,0x42,0x62,0x5c,0x40,0x40,0x40,0x0,0x0 +}; +static const GLUTBitmapChar ch104 = { 8, 13, 0, 2, 8, ch104data }; + +static const unsigned char ch105data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x30,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch105 = { 8, 13, 0, 2, 8, ch105data }; + +static const unsigned char ch106data[] = { + 0x38,0x44,0x44,0x4,0x4,0x4,0x4,0xc,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch106 = { 8, 13, 0, 2, 8, ch106data }; + +static const unsigned char ch107data[] = { + 0x0,0x0,0x42,0x44,0x48,0x70,0x48,0x44,0x40,0x40,0x40,0x0,0x0 +}; +static const GLUTBitmapChar ch107 = { 8, 13, 0, 2, 8, ch107data }; + +static const unsigned char ch108data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x30,0x0,0x0 +}; +static const GLUTBitmapChar ch108 = { 8, 13, 0, 2, 8, ch108data }; + +static const unsigned char ch109data[] = { + 0x0,0x0,0x82,0x92,0x92,0x92,0x92,0xec,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch109 = { 8, 13, 0, 2, 8, ch109data }; + +static const unsigned char ch110data[] = { + 0x0,0x0,0x42,0x42,0x42,0x42,0x62,0x5c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch110 = { 8, 13, 0, 2, 8, ch110data }; + +static const unsigned char ch111data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch111 = { 8, 13, 0, 2, 8, ch111data }; + +static const unsigned char ch112data[] = { + 0x40,0x40,0x40,0x5c,0x62,0x42,0x62,0x5c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch112 = { 8, 13, 0, 2, 8, ch112data }; + +static const unsigned char ch113data[] = { + 0x2,0x2,0x2,0x3a,0x46,0x42,0x46,0x3a,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch113 = { 8, 13, 0, 2, 8, ch113data }; + +static const unsigned char ch114data[] = { + 0x0,0x0,0x20,0x20,0x20,0x20,0x22,0x5c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch114 = { 8, 13, 0, 2, 8, ch114data }; + +static const unsigned char ch115data[] = { + 0x0,0x0,0x3c,0x42,0xc,0x30,0x42,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch115 = { 8, 13, 0, 2, 8, ch115data }; + +static const unsigned char ch116data[] = { + 0x0,0x0,0x1c,0x22,0x20,0x20,0x20,0x7c,0x20,0x20,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch116 = { 8, 13, 0, 2, 8, ch116data }; + +static const unsigned char ch117data[] = { + 0x0,0x0,0x3a,0x44,0x44,0x44,0x44,0x44,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch117 = { 8, 13, 0, 2, 8, ch117data }; + +static const unsigned char ch118data[] = { + 0x0,0x0,0x10,0x28,0x28,0x44,0x44,0x44,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch118 = { 8, 13, 0, 2, 8, ch118data }; + +static const unsigned char ch119data[] = { + 0x0,0x0,0x44,0xaa,0x92,0x92,0x82,0x82,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch119 = { 8, 13, 0, 2, 8, ch119data }; + +static const unsigned char ch120data[] = { + 0x0,0x0,0x42,0x24,0x18,0x18,0x24,0x42,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch120 = { 8, 13, 0, 2, 8, ch120data }; + +static const unsigned char ch121data[] = { + 0x3c,0x42,0x2,0x3a,0x46,0x42,0x42,0x42,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch121 = { 8, 13, 0, 2, 8, ch121data }; + +static const unsigned char ch122data[] = { + 0x0,0x0,0x7e,0x20,0x10,0x8,0x4,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch122 = { 8, 13, 0, 2, 8, ch122data }; + +static const unsigned char ch123data[] = { + 0x0,0x0,0xe,0x10,0x10,0x8,0x30,0x8,0x10,0x10,0xe,0x0,0x0 +}; +static const GLUTBitmapChar ch123 = { 8, 13, 0, 2, 8, ch123data }; + +static const unsigned char ch124data[] = { + 0x0,0x0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch124 = { 8, 13, 0, 2, 8, ch124data }; + +static const unsigned char ch125data[] = { + 0x0,0x0,0x70,0x8,0x8,0x10,0xc,0x10,0x8,0x8,0x70,0x0,0x0 +}; +static const GLUTBitmapChar ch125 = { 8, 13, 0, 2, 8, ch125data }; + +static const unsigned char ch126data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x54,0x24,0x0,0x0 +}; +static const GLUTBitmapChar ch126 = { 8, 13, 0, 2, 8, ch126data }; + +static const unsigned char ch127data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch127 = { 8, 13, 0, 2, 8, ch127data }; + +static const unsigned char ch160data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch160 = { 8, 13, 0, 2, 8, ch160data }; + +static const unsigned char ch161data[] = { + 0x0,0x0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x0,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch161 = { 8, 13, 0, 2, 8, ch161data }; + +static const unsigned char ch162data[] = { + 0x0,0x0,0x0,0x10,0x38,0x54,0x50,0x50,0x54,0x38,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch162 = { 8, 13, 0, 2, 8, ch162data }; + +static const unsigned char ch163data[] = { + 0x0,0x0,0xdc,0x62,0x20,0x20,0x20,0x70,0x20,0x22,0x1c,0x0,0x0 +}; +static const GLUTBitmapChar ch163 = { 8, 13, 0, 2, 8, ch163data }; + +static const unsigned char ch164data[] = { + 0x0,0x0,0x0,0x42,0x3c,0x24,0x24,0x3c,0x42,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch164 = { 8, 13, 0, 2, 8, ch164data }; + +static const unsigned char ch165data[] = { + 0x0,0x0,0x10,0x10,0x7c,0x10,0x7c,0x28,0x44,0x82,0x82,0x0,0x0 +}; +static const GLUTBitmapChar ch165 = { 8, 13, 0, 2, 8, ch165data }; + +static const unsigned char ch166data[] = { + 0x0,0x0,0x10,0x10,0x10,0x10,0x0,0x10,0x10,0x10,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch166 = { 8, 13, 0, 2, 8, ch166data }; + +static const unsigned char ch167data[] = { + 0x0,0x0,0x18,0x24,0x4,0x18,0x24,0x24,0x18,0x20,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch167 = { 8, 13, 0, 2, 8, ch167data }; + +static const unsigned char ch168data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6c,0x0,0x0 +}; +static const GLUTBitmapChar ch168 = { 8, 13, 0, 2, 8, ch168data }; + +static const unsigned char ch169data[] = { + 0x0,0x0,0x0,0x38,0x44,0x92,0xaa,0xa2,0xaa,0x92,0x44,0x38,0x0 +}; +static const GLUTBitmapChar ch169 = { 8, 13, 0, 2, 8, ch169data }; + +static const unsigned char ch170data[] = { + 0x0,0x0,0x0,0x0,0x7c,0x0,0x3c,0x44,0x3c,0x4,0x38,0x0,0x0 +}; +static const GLUTBitmapChar ch170 = { 8, 13, 0, 2, 8, ch170data }; + +static const unsigned char ch171data[] = { + 0x0,0x0,0x0,0x12,0x24,0x48,0x90,0x48,0x24,0x12,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch171 = { 8, 13, 0, 2, 8, ch171data }; + +static const unsigned char ch172data[] = { + 0x0,0x0,0x0,0x2,0x2,0x2,0x7e,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch172 = { 8, 13, 0, 2, 8, ch172data }; + +static const unsigned char ch173data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch173 = { 8, 13, 0, 2, 8, ch173data }; + +static const unsigned char ch174data[] = { + 0x0,0x0,0x0,0x38,0x44,0xaa,0xb2,0xaa,0xaa,0x92,0x44,0x38,0x0 +}; +static const GLUTBitmapChar ch174 = { 8, 13, 0, 2, 8, ch174data }; + +static const unsigned char ch175data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x0 +}; +static const GLUTBitmapChar ch175 = { 8, 13, 0, 2, 8, ch175data }; + +static const unsigned char ch176data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x24,0x24,0x18,0x0,0x0 +}; +static const GLUTBitmapChar ch176 = { 8, 13, 0, 2, 8, ch176data }; + +static const unsigned char ch177data[] = { + 0x0,0x0,0x0,0x7c,0x0,0x10,0x10,0x7c,0x10,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch177 = { 8, 13, 0, 2, 8, ch177data }; + +static const unsigned char ch178data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x78,0x40,0x30,0x8,0x48,0x30,0x0 +}; +static const GLUTBitmapChar ch178 = { 8, 13, 0, 2, 8, ch178data }; + +static const unsigned char ch179data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x48,0x8,0x10,0x48,0x30,0x0 +}; +static const GLUTBitmapChar ch179 = { 8, 13, 0, 2, 8, ch179data }; + +static const unsigned char ch180data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch180 = { 8, 13, 0, 2, 8, ch180data }; + +static const unsigned char ch181data[] = { + 0x0,0x40,0x5a,0x66,0x42,0x42,0x42,0x42,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch181 = { 8, 13, 0, 2, 8, ch181data }; + +static const unsigned char ch182data[] = { + 0x0,0x0,0x14,0x14,0x14,0x14,0x34,0x74,0x74,0x74,0x3e,0x0,0x0 +}; +static const GLUTBitmapChar ch182 = { 8, 13, 0, 2, 8, ch182data }; + +static const unsigned char ch183data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch183 = { 8, 13, 0, 2, 8, ch183data }; + +static const unsigned char ch184data[] = { + 0x18,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch184 = { 8, 13, 0, 2, 8, ch184data }; + +static const unsigned char ch185data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x20,0x20,0x20,0x60,0x20,0x0 +}; +static const GLUTBitmapChar ch185 = { 8, 13, 0, 2, 8, ch185data }; + +static const unsigned char ch186data[] = { + 0x0,0x0,0x0,0x0,0x0,0x78,0x0,0x30,0x48,0x48,0x30,0x0,0x0 +}; +static const GLUTBitmapChar ch186 = { 8, 13, 0, 2, 8, ch186data }; + +static const unsigned char ch187data[] = { + 0x0,0x0,0x0,0x90,0x48,0x24,0x12,0x24,0x48,0x90,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch187 = { 8, 13, 0, 2, 8, ch187data }; + +static const unsigned char ch188data[] = { + 0x0,0x0,0x6,0x1a,0x12,0xa,0xe6,0x42,0x40,0x40,0xc0,0x40,0x0 +}; +static const GLUTBitmapChar ch188 = { 8, 13, 0, 2, 8, ch188data }; + +static const unsigned char ch189data[] = { + 0x0,0x0,0x1e,0x10,0xc,0x2,0xf2,0x4c,0x40,0x40,0xc0,0x40,0x0 +}; +static const GLUTBitmapChar ch189 = { 8, 13, 0, 2, 8, ch189data }; + +static const unsigned char ch190data[] = { + 0x0,0x0,0x6,0x1a,0x12,0xa,0x66,0x92,0x10,0x20,0x90,0x60,0x0 +}; +static const GLUTBitmapChar ch190 = { 8, 13, 0, 2, 8, ch190data }; + +static const unsigned char ch191data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x40,0x20,0x10,0x10,0x0,0x10,0x0,0x0 +}; +static const GLUTBitmapChar ch191 = { 8, 13, 0, 2, 8, ch191data }; + +static const unsigned char ch192data[] = { + 0x0,0x0,0x42,0x42,0x7e,0x42,0x42,0x24,0x18,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch192 = { 8, 13, 0, 2, 8, ch192data }; + +static const unsigned char ch193data[] = { + 0x0,0x0,0x42,0x42,0x7e,0x42,0x42,0x24,0x18,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch193 = { 8, 13, 0, 2, 8, ch193data }; + +static const unsigned char ch194data[] = { + 0x0,0x0,0x42,0x42,0x7e,0x42,0x42,0x24,0x18,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch194 = { 8, 13, 0, 2, 8, ch194data }; + +static const unsigned char ch195data[] = { + 0x0,0x0,0x42,0x42,0x7e,0x42,0x42,0x24,0x18,0x0,0x28,0x14,0x0 +}; +static const GLUTBitmapChar ch195 = { 8, 13, 0, 2, 8, ch195data }; + +static const unsigned char ch196data[] = { + 0x0,0x0,0x42,0x42,0x7e,0x42,0x42,0x24,0x18,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch196 = { 8, 13, 0, 2, 8, ch196data }; + +static const unsigned char ch197data[] = { + 0x0,0x0,0x42,0x42,0x7e,0x42,0x42,0x24,0x18,0x18,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch197 = { 8, 13, 0, 2, 8, ch197data }; + +static const unsigned char ch198data[] = { + 0x0,0x0,0x9e,0x90,0x90,0xf0,0x9c,0x90,0x90,0x90,0x6e,0x0,0x0 +}; +static const GLUTBitmapChar ch198 = { 8, 13, 0, 2, 8, ch198data }; + +static const unsigned char ch199data[] = { + 0x10,0x8,0x3c,0x42,0x40,0x40,0x40,0x40,0x40,0x42,0x3c,0x0,0x0 +}; +static const GLUTBitmapChar ch199 = { 8, 13, 0, 2, 8, ch199data }; + +static const unsigned char ch200data[] = { + 0x0,0x0,0x7e,0x40,0x40,0x78,0x40,0x40,0x7e,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch200 = { 8, 13, 0, 2, 8, ch200data }; + +static const unsigned char ch201data[] = { + 0x0,0x0,0x7e,0x40,0x40,0x78,0x40,0x40,0x7e,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch201 = { 8, 13, 0, 2, 8, ch201data }; + +static const unsigned char ch202data[] = { + 0x0,0x0,0x7e,0x40,0x40,0x78,0x40,0x40,0x7e,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch202 = { 8, 13, 0, 2, 8, ch202data }; + +static const unsigned char ch203data[] = { + 0x0,0x0,0x7e,0x40,0x40,0x78,0x40,0x40,0x7e,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch203 = { 8, 13, 0, 2, 8, ch203data }; + +static const unsigned char ch204data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x10,0x7c,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch204 = { 8, 13, 0, 2, 8, ch204data }; + +static const unsigned char ch205data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x10,0x7c,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch205 = { 8, 13, 0, 2, 8, ch205data }; + +static const unsigned char ch206data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x10,0x7c,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch206 = { 8, 13, 0, 2, 8, ch206data }; + +static const unsigned char ch207data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x10,0x7c,0x0,0x28,0x28,0x0 +}; +static const GLUTBitmapChar ch207 = { 8, 13, 0, 2, 8, ch207data }; + +static const unsigned char ch208data[] = { + 0x0,0x0,0xfc,0x42,0x42,0x42,0xe2,0x42,0x42,0x42,0xfc,0x0,0x0 +}; +static const GLUTBitmapChar ch208 = { 8, 13, 0, 2, 8, ch208data }; + +static const unsigned char ch209data[] = { + 0x0,0x0,0x82,0x86,0x8a,0x92,0xa2,0xc2,0x82,0x0,0x28,0x14,0x0 +}; +static const GLUTBitmapChar ch209 = { 8, 13, 0, 2, 8, ch209data }; + +static const unsigned char ch210data[] = { + 0x0,0x0,0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch210 = { 8, 13, 0, 2, 8, ch210data }; + +static const unsigned char ch211data[] = { + 0x0,0x0,0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch211 = { 8, 13, 0, 2, 8, ch211data }; + +static const unsigned char ch212data[] = { + 0x0,0x0,0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch212 = { 8, 13, 0, 2, 8, ch212data }; + +static const unsigned char ch213data[] = { + 0x0,0x0,0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x28,0x14,0x0 +}; +static const GLUTBitmapChar ch213 = { 8, 13, 0, 2, 8, ch213data }; + +static const unsigned char ch214data[] = { + 0x0,0x0,0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x28,0x28,0x0 +}; +static const GLUTBitmapChar ch214 = { 8, 13, 0, 2, 8, ch214data }; + +static const unsigned char ch215data[] = { + 0x0,0x0,0x0,0x42,0x24,0x18,0x18,0x24,0x42,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch215 = { 8, 13, 0, 2, 8, ch215data }; + +static const unsigned char ch216data[] = { + 0x0,0x40,0x3c,0x62,0x52,0x52,0x52,0x4a,0x4a,0x46,0x3c,0x2,0x0 +}; +static const GLUTBitmapChar ch216 = { 8, 13, 0, 2, 8, ch216data }; + +static const unsigned char ch217data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x42,0x42,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch217 = { 8, 13, 0, 2, 8, ch217data }; + +static const unsigned char ch218data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x42,0x42,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch218 = { 8, 13, 0, 2, 8, ch218data }; + +static const unsigned char ch219data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x42,0x42,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch219 = { 8, 13, 0, 2, 8, ch219data }; + +static const unsigned char ch220data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x42,0x42,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch220 = { 8, 13, 0, 2, 8, ch220data }; + +static const unsigned char ch221data[] = { + 0x0,0x0,0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch221 = { 8, 13, 0, 2, 8, ch221data }; + +static const unsigned char ch222data[] = { + 0x0,0x0,0x40,0x40,0x40,0x7c,0x42,0x42,0x42,0x7c,0x40,0x0,0x0 +}; +static const GLUTBitmapChar ch222 = { 8, 13, 0, 2, 8, ch222data }; + +static const unsigned char ch223data[] = { + 0x0,0x40,0x5c,0x62,0x42,0x42,0x7c,0x42,0x42,0x3c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch223 = { 8, 13, 0, 2, 8, ch223data }; + +static const unsigned char ch224data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x3e,0x2,0x3c,0x0,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch224 = { 8, 13, 0, 2, 8, ch224data }; + +static const unsigned char ch225data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x3e,0x2,0x3c,0x0,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch225 = { 8, 13, 0, 2, 8, ch225data }; + +static const unsigned char ch226data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x3e,0x2,0x3c,0x0,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch226 = { 8, 13, 0, 2, 8, ch226data }; + +static const unsigned char ch227data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x3e,0x2,0x3c,0x0,0x0,0x28,0x14,0x0 +}; +static const GLUTBitmapChar ch227 = { 8, 13, 0, 2, 8, ch227data }; + +static const unsigned char ch228data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x3e,0x2,0x3c,0x0,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch228 = { 8, 13, 0, 2, 8, ch228data }; + +static const unsigned char ch229data[] = { + 0x0,0x0,0x3a,0x46,0x42,0x3e,0x2,0x3c,0x0,0x18,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch229 = { 8, 13, 0, 2, 8, ch229data }; + +static const unsigned char ch230data[] = { + 0x0,0x0,0x6c,0x92,0x90,0x7c,0x12,0x6c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch230 = { 8, 13, 0, 2, 8, ch230data }; + +static const unsigned char ch231data[] = { + 0x10,0x8,0x3c,0x42,0x40,0x40,0x42,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch231 = { 8, 13, 0, 2, 8, ch231data }; + +static const unsigned char ch232data[] = { + 0x0,0x0,0x3c,0x42,0x40,0x7e,0x42,0x3c,0x0,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch232 = { 8, 13, 0, 2, 8, ch232data }; + +static const unsigned char ch233data[] = { + 0x0,0x0,0x3c,0x42,0x40,0x7e,0x42,0x3c,0x0,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch233 = { 8, 13, 0, 2, 8, ch233data }; + +static const unsigned char ch234data[] = { + 0x0,0x0,0x3c,0x42,0x40,0x7e,0x42,0x3c,0x0,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch234 = { 8, 13, 0, 2, 8, ch234data }; + +static const unsigned char ch235data[] = { + 0x0,0x0,0x3c,0x42,0x40,0x7e,0x42,0x3c,0x0,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch235 = { 8, 13, 0, 2, 8, ch235data }; + +static const unsigned char ch236data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x30,0x0,0x0,0x10,0x20,0x0 +}; +static const GLUTBitmapChar ch236 = { 8, 13, 0, 2, 8, ch236data }; + +static const unsigned char ch237data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x30,0x0,0x0,0x20,0x10,0x0 +}; +static const GLUTBitmapChar ch237 = { 8, 13, 0, 2, 8, ch237data }; + +static const unsigned char ch238data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x30,0x0,0x0,0x48,0x30,0x0 +}; +static const GLUTBitmapChar ch238 = { 8, 13, 0, 2, 8, ch238data }; + +static const unsigned char ch239data[] = { + 0x0,0x0,0x7c,0x10,0x10,0x10,0x10,0x30,0x0,0x0,0x28,0x28,0x0 +}; +static const GLUTBitmapChar ch239 = { 8, 13, 0, 2, 8, ch239data }; + +static const unsigned char ch240data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x3c,0x4,0x28,0x18,0x24,0x0 +}; +static const GLUTBitmapChar ch240 = { 8, 13, 0, 2, 8, ch240data }; + +static const unsigned char ch241data[] = { + 0x0,0x0,0x42,0x42,0x42,0x42,0x62,0x5c,0x0,0x0,0x28,0x14,0x0 +}; +static const GLUTBitmapChar ch241 = { 8, 13, 0, 2, 8, ch241data }; + +static const unsigned char ch242data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x3c,0x0,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch242 = { 8, 13, 0, 2, 8, ch242data }; + +static const unsigned char ch243data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x3c,0x0,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch243 = { 8, 13, 0, 2, 8, ch243data }; + +static const unsigned char ch244data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x3c,0x0,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch244 = { 8, 13, 0, 2, 8, ch244data }; + +static const unsigned char ch245data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x3c,0x0,0x0,0x28,0x14,0x0 +}; +static const GLUTBitmapChar ch245 = { 8, 13, 0, 2, 8, ch245data }; + +static const unsigned char ch246data[] = { + 0x0,0x0,0x3c,0x42,0x42,0x42,0x42,0x3c,0x0,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch246 = { 8, 13, 0, 2, 8, ch246data }; + +static const unsigned char ch247data[] = { + 0x0,0x0,0x0,0x10,0x10,0x0,0x7c,0x0,0x10,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch247 = { 8, 13, 0, 2, 8, ch247data }; + +static const unsigned char ch248data[] = { + 0x0,0x40,0x3c,0x62,0x52,0x4a,0x46,0x3c,0x2,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch248 = { 8, 13, 0, 2, 8, ch248data }; + +static const unsigned char ch249data[] = { + 0x0,0x0,0x3a,0x44,0x44,0x44,0x44,0x44,0x0,0x0,0x8,0x10,0x0 +}; +static const GLUTBitmapChar ch249 = { 8, 13, 0, 2, 8, ch249data }; + +static const unsigned char ch250data[] = { + 0x0,0x0,0x3a,0x44,0x44,0x44,0x44,0x44,0x0,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch250 = { 8, 13, 0, 2, 8, ch250data }; + +static const unsigned char ch251data[] = { + 0x0,0x0,0x3a,0x44,0x44,0x44,0x44,0x44,0x0,0x0,0x24,0x18,0x0 +}; +static const GLUTBitmapChar ch251 = { 8, 13, 0, 2, 8, ch251data }; + +static const unsigned char ch252data[] = { + 0x0,0x0,0x3a,0x44,0x44,0x44,0x44,0x44,0x0,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch252 = { 8, 13, 0, 2, 8, ch252data }; + +static const unsigned char ch253data[] = { + 0x3c,0x42,0x2,0x3a,0x46,0x42,0x42,0x42,0x0,0x0,0x10,0x8,0x0 +}; +static const GLUTBitmapChar ch253 = { 8, 13, 0, 2, 8, ch253data }; + +static const unsigned char ch254data[] = { + 0x40,0x40,0x5c,0x62,0x42,0x42,0x62,0x5c,0x40,0x40,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch254 = { 8, 13, 0, 2, 8, ch254data }; + +static const unsigned char ch255data[] = { + 0x3c,0x42,0x2,0x3a,0x46,0x42,0x42,0x42,0x0,0x0,0x24,0x24,0x0 +}; +static const GLUTBitmapChar ch255 = { 8, 13, 0, 2, 8, ch255data }; + + +static const GLUTBitmapChar *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 GLUTBitmapFont glutBitmap8By13 = { + "-Misc-Fixed-Medium-R-Normal--13-120-75-75-C-80-ISO8859-1", + 13, 256, chars +}; diff --git a/src/glut/dos/f9x15.c b/src/glut/dos/f9x15.c new file mode 100644 index 000000000..0e7cd6da5 --- /dev/null +++ b/src/glut/dos/f9x15.c @@ -0,0 +1,1407 @@ +/* autogenerated by bdf2c! do not edit */ + +/* "Public domain terminal emulator font. Share and enjoy." */ + + +#include "internal.h" +/* +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; +*/ + + +static const unsigned char ch0data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch0 = { 9, 15, 0, 3, 9, ch0data }; + +static const unsigned char ch1data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x1c,0x0,0x3e,0x0,0x7f,0x0,0x3e,0x0, + 0x1c,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch1 = { 9, 15, 0, 3, 9, ch1data }; + +static const unsigned char ch2data[] = { + 0x55,0x0,0xaa,0x0,0x55,0x0,0xaa,0x0,0x55,0x0,0xaa,0x0,0x55,0x0,0xaa,0x0, + 0x55,0x0,0xaa,0x0,0x55,0x0,0xaa,0x0,0x55,0x0,0xaa,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch2 = { 9, 15, 0, 3, 9, ch2data }; + +static const unsigned char ch3data[] = { + 0x0,0x0,0x4,0x0,0x4,0x0,0x4,0x0,0x1f,0x0,0x0,0x0,0x44,0x0,0x44,0x0, + 0x7c,0x0,0x44,0x0,0x44,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch3 = { 9, 15, 0, 3, 9, ch3data }; + +static const unsigned char ch4data[] = { + 0x0,0x0,0x8,0x0,0x8,0x0,0xe,0x0,0x8,0x0,0xf,0x0,0x40,0x0,0x40,0x0, + 0x70,0x0,0x40,0x0,0x78,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch4 = { 9, 15, 0, 3, 9, ch4data }; + +static const unsigned char ch5data[] = { + 0x0,0x0,0x11,0x0,0x11,0x0,0x1e,0x0,0x11,0x0,0x1e,0x0,0x0,0x0,0x3c,0x0, + 0x40,0x0,0x40,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch5 = { 9, 15, 0, 3, 9, ch5data }; + +static const unsigned char ch6data[] = { + 0x0,0x0,0x10,0x0,0x10,0x0,0x1e,0x0,0x10,0x0,0x1f,0x0,0x0,0x0,0x7c,0x0, + 0x40,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch6 = { 9, 15, 0, 3, 9, ch6data }; + +static const unsigned char ch7data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x1c,0x0,0x22,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch7 = { 9, 15, 0, 3, 9, ch7data }; + +static const unsigned char ch8data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x8,0x0,0x8,0x0,0x7f,0x0,0x8,0x0, + 0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch8 = { 9, 15, 0, 3, 9, ch8data }; + +static const unsigned char ch9data[] = { + 0x0,0x0,0x1f,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x44,0x0,0x4c,0x0, + 0x54,0x0,0x64,0x0,0x44,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch9 = { 9, 15, 0, 3, 9, ch9data }; + +static const unsigned char ch10data[] = { + 0x0,0x0,0x4,0x0,0x4,0x0,0x4,0x0,0x4,0x0,0x1f,0x0,0x0,0x0,0x10,0x0, + 0x28,0x0,0x44,0x0,0x44,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch10 = { 9, 15, 0, 3, 9, ch10data }; + +static const unsigned char ch11data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0 +}; +static const GLUTBitmapChar ch11 = { 9, 15, 0, 3, 9, ch11data }; + +static const unsigned char ch12data[] = { + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xf8,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch12 = { 9, 15, 0, 3, 9, ch12data }; + +static const unsigned char ch13data[] = { + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xf,0x80,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch13 = { 9, 15, 0, 3, 9, ch13data }; + +static const unsigned char ch14data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x80,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0 +}; +static const GLUTBitmapChar ch14 = { 9, 15, 0, 3, 9, ch14data }; + +static const unsigned char 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 GLUTBitmapChar ch15 = { 9, 15, 0, 3, 9, ch15data }; + +static const unsigned char ch16data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0xff,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch16 = { 9, 15, 0, 3, 9, ch16data }; + +static const unsigned char ch17data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0xff,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch17 = { 9, 15, 0, 3, 9, ch17data }; + +static const unsigned char ch18data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0x80,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch18 = { 9, 15, 0, 3, 9, ch18data }; + +static const unsigned char ch19data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0x80,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch19 = { 9, 15, 0, 3, 9, ch19data }; + +static const unsigned char ch20data[] = { + 0x0,0x0,0x0,0x0,0xff,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch20 = { 9, 15, 0, 3, 9, ch20data }; + +static const unsigned char ch21data[] = { + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xf,0x80,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0 +}; +static const GLUTBitmapChar ch21 = { 9, 15, 0, 3, 9, ch21data }; + +static const unsigned char ch22data[] = { + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xf8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0 +}; +static const GLUTBitmapChar ch22 = { 9, 15, 0, 3, 9, ch22data }; + +static const unsigned char ch23data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0x80,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0 +}; +static const GLUTBitmapChar ch23 = { 9, 15, 0, 3, 9, ch23data }; + +static const unsigned char ch24data[] = { + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xff,0x80,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch24 = { 9, 15, 0, 3, 9, ch24data }; + +static const unsigned char ch25data[] = { + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0 +}; +static const GLUTBitmapChar ch25 = { 9, 15, 0, 3, 9, ch25data }; + +static const unsigned char ch26data[] = { + 0x0,0x0,0x3f,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x4,0x0,0x8,0x0,0x10,0x0, + 0x10,0x0,0x8,0x0,0x4,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch26 = { 9, 15, 0, 3, 9, ch26data }; + +static const unsigned char ch27data[] = { + 0x0,0x0,0x7f,0x0,0x0,0x0,0x40,0x0,0x20,0x0,0x10,0x0,0x8,0x0,0x4,0x0, + 0x4,0x0,0x8,0x0,0x10,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch27 = { 9, 15, 0, 3, 9, ch27data }; + +static const unsigned char ch28data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x22,0x0,0x12,0x0,0x12,0x0,0x12,0x0,0x12,0x0, + 0x12,0x0,0x7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch28 = { 9, 15, 0, 3, 9, ch28data }; + +static const unsigned char ch29data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x20,0x0,0x7f,0x0,0x8,0x0,0x7f,0x0, + 0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch29 = { 9, 15, 0, 3, 9, ch29data }; + +static const unsigned char ch30data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x2e,0x0,0x51,0x0,0x30,0x0,0x10,0x0,0x10,0x0, + 0x7c,0x0,0x10,0x0,0x10,0x0,0x11,0x0,0xe,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch30 = { 9, 15, 0, 3, 9, ch30data }; + +static const unsigned char ch31data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0xc,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch31 = { 9, 15, 0, 3, 9, ch31data }; + +static const unsigned char ch32data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch32 = { 9, 15, 0, 3, 9, ch32data }; + +static const unsigned char ch33data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch33 = { 9, 15, 0, 3, 9, ch33data }; + +static const unsigned char ch34data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch34 = { 9, 15, 0, 3, 9, ch34data }; + +static const unsigned char ch35data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x24,0x0,0x24,0x0,0x7e,0x0,0x24,0x0, + 0x24,0x0,0x7e,0x0,0x24,0x0,0x24,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch35 = { 9, 15, 0, 3, 9, ch35data }; + +static const unsigned char ch36data[] = { + 0x0,0x0,0x0,0x0,0x8,0x0,0x3e,0x0,0x49,0x0,0x9,0x0,0x9,0x0,0xa,0x0, + 0x1c,0x0,0x28,0x0,0x48,0x0,0x49,0x0,0x3e,0x0,0x8,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch36 = { 9, 15, 0, 3, 9, ch36data }; + +static const unsigned char ch37data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x42,0x0,0x25,0x0,0x25,0x0,0x12,0x0,0x8,0x0, + 0x8,0x0,0x24,0x0,0x52,0x0,0x52,0x0,0x21,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch37 = { 9, 15, 0, 3, 9, ch37data }; + +static const unsigned char ch38data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x31,0x0,0x4a,0x0,0x44,0x0,0x4a,0x0,0x31,0x0, + 0x30,0x0,0x48,0x0,0x48,0x0,0x48,0x0,0x30,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch38 = { 9, 15, 0, 3, 9, ch38data }; + +static const unsigned char ch39data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x10,0x0,0x8,0x0,0x4,0x0,0x6,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch39 = { 9, 15, 0, 3, 9, ch39data }; + +static const unsigned char ch40data[] = { + 0x0,0x0,0x0,0x0,0x4,0x0,0x8,0x0,0x8,0x0,0x10,0x0,0x10,0x0,0x10,0x0, + 0x10,0x0,0x10,0x0,0x10,0x0,0x8,0x0,0x8,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch40 = { 9, 15, 0, 3, 9, ch40data }; + +static const unsigned char ch41data[] = { + 0x0,0x0,0x0,0x0,0x10,0x0,0x8,0x0,0x8,0x0,0x4,0x0,0x4,0x0,0x4,0x0, + 0x4,0x0,0x4,0x0,0x4,0x0,0x8,0x0,0x8,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch41 = { 9, 15, 0, 3, 9, ch41data }; + +static const unsigned char ch42data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x49,0x0,0x2a,0x0,0x1c,0x0, + 0x2a,0x0,0x49,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch42 = { 9, 15, 0, 3, 9, ch42data }; + +static const unsigned char ch43data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x7f,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch43 = { 9, 15, 0, 3, 9, ch43data }; + +static const unsigned char ch44data[] = { + 0x8,0x0,0x4,0x0,0x4,0x0,0xc,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch44 = { 9, 15, 0, 3, 9, ch44data }; + +static const unsigned char ch45data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch45 = { 9, 15, 0, 3, 9, ch45data }; + +static const unsigned char ch46data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch46 = { 9, 15, 0, 3, 9, ch46data }; + +static const unsigned char ch47data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x20,0x0,0x20,0x0,0x10,0x0,0x8,0x0, + 0x8,0x0,0x4,0x0,0x2,0x0,0x2,0x0,0x1,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch47 = { 9, 15, 0, 3, 9, ch47data }; + +static const unsigned char ch48data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x0,0x22,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch48 = { 9, 15, 0, 3, 9, ch48data }; + +static const unsigned char ch49data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x48,0x0,0x28,0x0,0x18,0x0,0x8,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch49 = { 9, 15, 0, 3, 9, ch49data }; + +static const unsigned char ch50data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x40,0x0,0x20,0x0,0x18,0x0,0x4,0x0, + 0x2,0x0,0x1,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch50 = { 9, 15, 0, 3, 9, ch50data }; + +static const unsigned char ch51data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x1,0x0,0x1,0x0,0x1,0x0, + 0xe,0x0,0x4,0x0,0x2,0x0,0x1,0x0,0x7f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch51 = { 9, 15, 0, 3, 9, ch51data }; + +static const unsigned char ch52data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x2,0x0,0x7f,0x0,0x42,0x0, + 0x22,0x0,0x12,0x0,0xa,0x0,0x6,0x0,0x2,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch52 = { 9, 15, 0, 3, 9, ch52data }; + +static const unsigned char ch53data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x1,0x0,0x1,0x0,0x1,0x0, + 0x61,0x0,0x5e,0x0,0x40,0x0,0x40,0x0,0x7f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch53 = { 9, 15, 0, 3, 9, ch53data }; + +static const unsigned char ch54data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x61,0x0, + 0x5e,0x0,0x40,0x0,0x40,0x0,0x20,0x0,0x1e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch54 = { 9, 15, 0, 3, 9, ch54data }; + +static const unsigned char ch55data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x20,0x0,0x10,0x0,0x10,0x0,0x8,0x0, + 0x4,0x0,0x2,0x0,0x1,0x0,0x1,0x0,0x7f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch55 = { 9, 15, 0, 3, 9, ch55data }; + +static const unsigned char ch56data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x1c,0x0,0x22,0x0,0x41,0x0,0x41,0x0,0x22,0x0, + 0x1c,0x0,0x22,0x0,0x41,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch56 = { 9, 15, 0, 3, 9, ch56data }; + +static const unsigned char ch57data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x2,0x0,0x1,0x0,0x1,0x0,0x3d,0x0, + 0x43,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch57 = { 9, 15, 0, 3, 9, ch57data }; + +static const unsigned char ch58data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0xc,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch58 = { 9, 15, 0, 3, 9, ch58data }; + +static const unsigned char ch59data[] = { + 0x8,0x0,0x4,0x0,0x4,0x0,0xc,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0xc,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch59 = { 9, 15, 0, 3, 9, ch59data }; + +static const unsigned char ch60data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x4,0x0,0x8,0x0,0x10,0x0,0x20,0x0, + 0x20,0x0,0x10,0x0,0x8,0x0,0x4,0x0,0x2,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch60 = { 9, 15, 0, 3, 9, ch60data }; + +static const unsigned char ch61data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x0,0x0,0x0,0x0, + 0x7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch61 = { 9, 15, 0, 3, 9, ch61data }; + +static const unsigned char ch62data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x10,0x0,0x8,0x0,0x4,0x0,0x2,0x0, + 0x2,0x0,0x4,0x0,0x8,0x0,0x10,0x0,0x20,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch62 = { 9, 15, 0, 3, 9, ch62data }; + +static const unsigned char ch63data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x4,0x0, + 0x2,0x0,0x1,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch63 = { 9, 15, 0, 3, 9, ch63data }; + +static const unsigned char ch64data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x40,0x0,0x40,0x0,0x4d,0x0,0x53,0x0, + 0x51,0x0,0x4f,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch64 = { 9, 15, 0, 3, 9, ch64data }; + +static const unsigned char ch65data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x22,0x0,0x14,0x0,0x8,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch65 = { 9, 15, 0, 3, 9, ch65data }; + +static const unsigned char ch66data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x21,0x0,0x21,0x0,0x21,0x0,0x21,0x0, + 0x3e,0x0,0x21,0x0,0x21,0x0,0x21,0x0,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch66 = { 9, 15, 0, 3, 9, ch66data }; + +static const unsigned char ch67data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x40,0x0,0x40,0x0,0x40,0x0, + 0x40,0x0,0x40,0x0,0x40,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch67 = { 9, 15, 0, 3, 9, ch67data }; + +static const unsigned char ch68data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x21,0x0,0x21,0x0,0x21,0x0,0x21,0x0, + 0x21,0x0,0x21,0x0,0x21,0x0,0x21,0x0,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch68 = { 9, 15, 0, 3, 9, ch68data }; + +static const unsigned char ch69data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x20,0x0, + 0x3c,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x7f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch69 = { 9, 15, 0, 3, 9, ch69data }; + +static const unsigned char ch70data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x20,0x0, + 0x3c,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x7f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch70 = { 9, 15, 0, 3, 9, ch70data }; + +static const unsigned char ch71data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x47,0x0, + 0x40,0x0,0x40,0x0,0x40,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch71 = { 9, 15, 0, 3, 9, ch71data }; + +static const unsigned char ch72data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x7f,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch72 = { 9, 15, 0, 3, 9, ch72data }; + +static const unsigned char ch73data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch73 = { 9, 15, 0, 3, 9, ch73data }; + +static const unsigned char ch74data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x42,0x0,0x2,0x0,0x2,0x0,0x2,0x0, + 0x2,0x0,0x2,0x0,0x2,0x0,0x2,0x0,0xf,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch74 = { 9, 15, 0, 3, 9, ch74data }; + +static const unsigned char ch75data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x42,0x0,0x44,0x0,0x48,0x0,0x50,0x0, + 0x70,0x0,0x48,0x0,0x44,0x0,0x42,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch75 = { 9, 15, 0, 3, 9, ch75data }; + +static const unsigned char ch76data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0, + 0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch76 = { 9, 15, 0, 3, 9, ch76data }; + +static const unsigned char ch77data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x49,0x0,0x49,0x0, + 0x55,0x0,0x55,0x0,0x63,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch77 = { 9, 15, 0, 3, 9, ch77data }; + +static const unsigned char ch78data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x43,0x0,0x45,0x0, + 0x49,0x0,0x51,0x0,0x61,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch78 = { 9, 15, 0, 3, 9, ch78data }; + +static const unsigned char ch79data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch79 = { 9, 15, 0, 3, 9, ch79data }; + +static const unsigned char ch80data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0, + 0x7e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch80 = { 9, 15, 0, 3, 9, ch80data }; + +static const unsigned char ch81data[] = { + 0x0,0x0,0x3,0x0,0x4,0x0,0x3e,0x0,0x49,0x0,0x51,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch81 = { 9, 15, 0, 3, 9, ch81data }; + +static const unsigned char ch82data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x42,0x0,0x44,0x0,0x48,0x0, + 0x7e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch82 = { 9, 15, 0, 3, 9, ch82data }; + +static const unsigned char ch83data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x1,0x0,0x6,0x0, + 0x38,0x0,0x40,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch83 = { 9, 15, 0, 3, 9, ch83data }; + +static const unsigned char ch84data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x7f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch84 = { 9, 15, 0, 3, 9, ch84data }; + +static const unsigned char ch85data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch85 = { 9, 15, 0, 3, 9, ch85data }; + +static const unsigned char ch86data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x14,0x0,0x14,0x0,0x14,0x0,0x22,0x0, + 0x22,0x0,0x22,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch86 = { 9, 15, 0, 3, 9, ch86data }; + +static const unsigned char ch87data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x49,0x0, + 0x49,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch87 = { 9, 15, 0, 3, 9, ch87data }; + +static const unsigned char ch88data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x22,0x0,0x14,0x0,0x8,0x0, + 0x8,0x0,0x14,0x0,0x22,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch88 = { 9, 15, 0, 3, 9, ch88data }; + +static const unsigned char ch89data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x14,0x0,0x22,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch89 = { 9, 15, 0, 3, 9, ch89data }; + +static const unsigned char ch90data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x40,0x0,0x40,0x0,0x20,0x0,0x10,0x0, + 0x8,0x0,0x4,0x0,0x2,0x0,0x1,0x0,0x7f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch90 = { 9, 15, 0, 3, 9, ch90data }; + +static const unsigned char ch91data[] = { + 0x0,0x0,0x0,0x0,0x1e,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x10,0x0, + 0x10,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x1e,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch91 = { 9, 15, 0, 3, 9, ch91data }; + +static const unsigned char ch92data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x2,0x0,0x4,0x0,0x8,0x0, + 0x8,0x0,0x10,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch92 = { 9, 15, 0, 3, 9, ch92data }; + +static const unsigned char ch93data[] = { + 0x0,0x0,0x0,0x0,0x3c,0x0,0x4,0x0,0x4,0x0,0x4,0x0,0x4,0x0,0x4,0x0, + 0x4,0x0,0x4,0x0,0x4,0x0,0x4,0x0,0x4,0x0,0x3c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch93 = { 9, 15, 0, 3, 9, ch93data }; + +static const unsigned char ch94data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x41,0x0,0x22,0x0,0x14,0x0,0x8,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch94 = { 9, 15, 0, 3, 9, ch94data }; + +static const unsigned char ch95data[] = { + 0x0,0x0,0x0,0x0,0xff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch95 = { 9, 15, 0, 3, 9, ch95data }; + +static const unsigned char ch96data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x2,0x0,0x4,0x0,0x8,0x0,0x18,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch96 = { 9, 15, 0, 3, 9, ch96data }; + +static const unsigned char ch97data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x3f,0x0,0x1,0x0, + 0x1,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch97 = { 9, 15, 0, 3, 9, ch97data }; + +static const unsigned char ch98data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x5e,0x0,0x61,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x61,0x0,0x5e,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch98 = { 9, 15, 0, 3, 9, ch98data }; + +static const unsigned char ch99data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x40,0x0,0x40,0x0,0x40,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch99 = { 9, 15, 0, 3, 9, ch99data }; + +static const unsigned char ch100data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x43,0x0,0x3d,0x0,0x1,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch100 = { 9, 15, 0, 3, 9, ch100data }; + +static const unsigned char ch101data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x40,0x0,0x40,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch101 = { 9, 15, 0, 3, 9, ch101data }; + +static const unsigned char ch102data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x10,0x0,0x7c,0x0, + 0x10,0x0,0x10,0x0,0x11,0x0,0x11,0x0,0xe,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch102 = { 9, 15, 0, 3, 9, ch102data }; + +static const unsigned char ch103data[] = { + 0x3e,0x0,0x41,0x0,0x41,0x0,0x3e,0x0,0x40,0x0,0x3c,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x3d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch103 = { 9, 15, 0, 3, 9, ch103data }; + +static const unsigned char ch104data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x61,0x0,0x5e,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch104 = { 9, 15, 0, 3, 9, ch104data }; + +static const unsigned char ch105data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x38,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch105 = { 9, 15, 0, 3, 9, ch105data }; + +static const unsigned char ch106data[] = { + 0x3c,0x0,0x42,0x0,0x42,0x0,0x42,0x0,0x2,0x0,0x2,0x0,0x2,0x0,0x2,0x0, + 0x2,0x0,0xe,0x0,0x0,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch106 = { 9, 15, 0, 3, 9, ch106data }; + +static const unsigned char ch107data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x46,0x0,0x58,0x0,0x60,0x0,0x58,0x0, + 0x46,0x0,0x41,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch107 = { 9, 15, 0, 3, 9, ch107data }; + +static const unsigned char ch108data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x38,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch108 = { 9, 15, 0, 3, 9, ch108data }; + +static const unsigned char ch109data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x49,0x0,0x49,0x0,0x49,0x0,0x49,0x0, + 0x49,0x0,0x76,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch109 = { 9, 15, 0, 3, 9, ch109data }; + +static const unsigned char ch110data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x61,0x0,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch110 = { 9, 15, 0, 3, 9, ch110data }; + +static const unsigned char ch111data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch111 = { 9, 15, 0, 3, 9, ch111data }; + +static const unsigned char ch112data[] = { + 0x40,0x0,0x40,0x0,0x40,0x0,0x5e,0x0,0x61,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x61,0x0,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch112 = { 9, 15, 0, 3, 9, ch112data }; + +static const unsigned char ch113data[] = { + 0x1,0x0,0x1,0x0,0x1,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x43,0x0,0x3d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch113 = { 9, 15, 0, 3, 9, ch113data }; + +static const unsigned char ch114data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x21,0x0, + 0x31,0x0,0x4e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch114 = { 9, 15, 0, 3, 9, ch114data }; + +static const unsigned char ch115data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x1,0x0,0x3e,0x0,0x40,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch115 = { 9, 15, 0, 3, 9, ch115data }; + +static const unsigned char ch116data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x11,0x0,0x10,0x0,0x10,0x0,0x10,0x0, + 0x10,0x0,0x7e,0x0,0x10,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch116 = { 9, 15, 0, 3, 9, ch116data }; + +static const unsigned char ch117data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x42,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch117 = { 9, 15, 0, 3, 9, ch117data }; + +static const unsigned char ch118data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x14,0x0,0x14,0x0,0x22,0x0,0x22,0x0, + 0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch118 = { 9, 15, 0, 3, 9, ch118data }; + +static const unsigned char ch119data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x49,0x0, + 0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch119 = { 9, 15, 0, 3, 9, ch119data }; + +static const unsigned char ch120data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x22,0x0,0x14,0x0,0x8,0x0,0x14,0x0, + 0x22,0x0,0x41,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch120 = { 9, 15, 0, 3, 9, ch120data }; + +static const unsigned char ch121data[] = { + 0x3c,0x0,0x42,0x0,0x2,0x0,0x3a,0x0,0x46,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch121 = { 9, 15, 0, 3, 9, ch121data }; + +static const unsigned char ch122data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x20,0x0,0x10,0x0,0x8,0x0,0x4,0x0, + 0x2,0x0,0x7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch122 = { 9, 15, 0, 3, 9, ch122data }; + +static const unsigned char ch123data[] = { + 0x0,0x0,0x0,0x0,0x7,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x4,0x0,0x18,0x0, + 0x18,0x0,0x4,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x7,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch123 = { 9, 15, 0, 3, 9, ch123data }; + +static const unsigned char ch124data[] = { + 0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch124 = { 9, 15, 0, 3, 9, ch124data }; + +static const unsigned char ch125data[] = { + 0x0,0x0,0x0,0x0,0x70,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x10,0x0,0xc,0x0, + 0xc,0x0,0x10,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x70,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch125 = { 9, 15, 0, 3, 9, ch125data }; + +static const unsigned char ch126data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x46,0x0,0x49,0x0,0x31,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch126 = { 9, 15, 0, 3, 9, ch126data }; + +static const unsigned char ch127data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch127 = { 9, 15, 0, 3, 9, ch127data }; + +static const unsigned char ch160data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch160 = { 9, 15, 0, 3, 9, ch160data }; + +static const unsigned char ch161data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch161 = { 9, 15, 0, 3, 9, ch161data }; + +static const unsigned char ch162data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x3c,0x0,0x52,0x0,0x50,0x0,0x48,0x0, + 0x4a,0x0,0x3c,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch162 = { 9, 15, 0, 3, 9, ch162data }; + +static const unsigned char ch163data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x2e,0x0,0x51,0x0,0x30,0x0,0x10,0x0,0x10,0x0, + 0x7c,0x0,0x10,0x0,0x10,0x0,0x11,0x0,0xe,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch163 = { 9, 15, 0, 3, 9, ch163data }; + +static const unsigned char ch164data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x3e,0x0, + 0x22,0x0,0x22,0x0,0x3e,0x0,0x41,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch164 = { 9, 15, 0, 3, 9, ch164data }; + +static const unsigned char ch165data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x3e,0x0,0x8,0x0, + 0x3e,0x0,0x14,0x0,0x22,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch165 = { 9, 15, 0, 3, 9, ch165data }; + +static const unsigned char ch166data[] = { + 0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0, + 0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch166 = { 9, 15, 0, 3, 9, ch166data }; + +static const unsigned char ch167data[] = { + 0x0,0x0,0x0,0x0,0x1c,0x0,0x22,0x0,0x2,0x0,0x1c,0x0,0x22,0x0,0x22,0x0, + 0x22,0x0,0x1c,0x0,0x20,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch167 = { 9, 15, 0, 3, 9, ch167data }; + +static const unsigned char ch168data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch168 = { 9, 15, 0, 3, 9, ch168data }; + +static const unsigned char ch169data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x42,0x0,0x99,0x0,0xa5,0x0, + 0xa1,0x0,0xa5,0x0,0x99,0x0,0x42,0x0,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch169 = { 9, 15, 0, 3, 9, ch169data }; + +static const unsigned char ch170data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f,0x0,0x0,0x0, + 0xf,0x0,0x12,0x0,0xe,0x0,0x12,0x0,0xc,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch170 = { 9, 15, 0, 3, 9, ch170data }; + +static const unsigned char ch171data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9,0x0,0x12,0x0,0x24,0x0,0x48,0x0, + 0x48,0x0,0x24,0x0,0x12,0x0,0x9,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch171 = { 9, 15, 0, 3, 9, ch171data }; + +static const unsigned char ch172data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x2,0x0, + 0x7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch172 = { 9, 15, 0, 3, 9, ch172data }; + +static const unsigned char ch173data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch173 = { 9, 15, 0, 3, 9, ch173data }; + +static const unsigned char ch174data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x42,0x0,0xa5,0x0,0xa9,0x0, + 0xbd,0x0,0xa5,0x0,0xb9,0x0,0x42,0x0,0x3c,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch174 = { 9, 15, 0, 3, 9, ch174data }; + +static const unsigned char ch175data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch175 = { 9, 15, 0, 3, 9, ch175data }; + +static const unsigned char ch176data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0xc,0x0,0x12,0x0,0x12,0x0,0xc,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch176 = { 9, 15, 0, 3, 9, ch176data }; + +static const unsigned char ch177data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x0,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x7f,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch177 = { 9, 15, 0, 3, 9, ch177data }; + +static const unsigned char ch178data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78,0x0, + 0x40,0x0,0x30,0x0,0x8,0x0,0x48,0x0,0x30,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch178 = { 9, 15, 0, 3, 9, ch178data }; + +static const unsigned char ch179data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0, + 0x48,0x0,0x8,0x0,0x10,0x0,0x48,0x0,0x30,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch179 = { 9, 15, 0, 3, 9, ch179data }; + +static const unsigned char ch180data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch180 = { 9, 15, 0, 3, 9, ch180data }; + +static const unsigned char ch181data[] = { + 0x0,0x0,0x40,0x0,0x40,0x0,0x5d,0x0,0x63,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch181 = { 9, 15, 0, 3, 9, ch181data }; + +static const unsigned char ch182data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x5,0x0,0x5,0x0,0x5,0x0,0x5,0x0,0x5,0x0, + 0x3d,0x0,0x45,0x0,0x45,0x0,0x45,0x0,0x3f,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch182 = { 9, 15, 0, 3, 9, ch182data }; + +static const unsigned char ch183data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0, + 0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch183 = { 9, 15, 0, 3, 9, ch183data }; + +static const unsigned char ch184data[] = { + 0x18,0x0,0x24,0x0,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch184 = { 9, 15, 0, 3, 9, ch184data }; + +static const unsigned char ch185data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x70,0x0, + 0x20,0x0,0x20,0x0,0x20,0x0,0x60,0x0,0x20,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch185 = { 9, 15, 0, 3, 9, ch185data }; + +static const unsigned char ch186data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, + 0x7c,0x0,0x0,0x0,0x38,0x0,0x44,0x0,0x44,0x0,0x38,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch186 = { 9, 15, 0, 3, 9, ch186data }; + +static const unsigned char ch187data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x48,0x0,0x24,0x0,0x12,0x0,0x9,0x0, + 0x9,0x0,0x12,0x0,0x24,0x0,0x48,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch187 = { 9, 15, 0, 3, 9, ch187data }; + +static const unsigned char ch188data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0xd,0x0,0x9,0x0,0x5,0x0,0x73,0x0, + 0x21,0x0,0x20,0x0,0x20,0x0,0x60,0x0,0x20,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch188 = { 9, 15, 0, 3, 9, ch188data }; + +static const unsigned char ch189data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0x8,0x0,0x6,0x0,0x1,0x0,0x79,0x0, + 0x26,0x0,0x20,0x0,0x20,0x0,0x60,0x0,0x20,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch189 = { 9, 15, 0, 3, 9, ch189data }; + +static const unsigned char ch190data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0xd,0x0,0x9,0x0,0x5,0x0,0x33,0x0, + 0x49,0x0,0x8,0x0,0x10,0x0,0x48,0x0,0x30,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch190 = { 9, 15, 0, 3, 9, ch190data }; + +static const unsigned char ch191data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x40,0x0,0x20,0x0, + 0x10,0x0,0x8,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch191 = { 9, 15, 0, 3, 9, ch191data }; + +static const unsigned char ch192data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch192 = { 9, 15, 0, 3, 9, ch192data }; + +static const unsigned char ch193data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch193 = { 9, 15, 0, 3, 9, ch193data }; + +static const unsigned char ch194data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch194 = { 9, 15, 0, 3, 9, ch194data }; + +static const unsigned char ch195data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x28,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch195 = { 9, 15, 0, 3, 9, ch195data }; + +static const unsigned char ch196data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x22,0x0,0x1c,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch196 = { 9, 15, 0, 3, 9, ch196data }; + +static const unsigned char ch197data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x22,0x0,0x1c,0x0,0x8,0x0,0x14,0x0,0x8,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch197 = { 9, 15, 0, 3, 9, ch197data }; + +static const unsigned char ch198data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x4f,0x0,0x48,0x0,0x48,0x0,0x48,0x0,0x7e,0x0, + 0x48,0x0,0x48,0x0,0x48,0x0,0x48,0x0,0x37,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch198 = { 9, 15, 0, 3, 9, ch198data }; + +static const unsigned char ch199data[] = { + 0x18,0x0,0x24,0x0,0xc,0x0,0x3e,0x0,0x41,0x0,0x40,0x0,0x40,0x0,0x40,0x0, + 0x40,0x0,0x40,0x0,0x40,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch199 = { 9, 15, 0, 3, 9, ch199data }; + +static const unsigned char ch200data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x3c,0x0, + 0x20,0x0,0x20,0x0,0x7f,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch200 = { 9, 15, 0, 3, 9, ch200data }; + +static const unsigned char ch201data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x3c,0x0, + 0x20,0x0,0x20,0x0,0x7f,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch201 = { 9, 15, 0, 3, 9, ch201data }; + +static const unsigned char ch202data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x3c,0x0, + 0x20,0x0,0x20,0x0,0x7f,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch202 = { 9, 15, 0, 3, 9, ch202data }; + +static const unsigned char ch203data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7f,0x0,0x20,0x0,0x20,0x0,0x20,0x0,0x3c,0x0, + 0x20,0x0,0x20,0x0,0x7f,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch203 = { 9, 15, 0, 3, 9, ch203data }; + +static const unsigned char ch204data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x3e,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch204 = { 9, 15, 0, 3, 9, ch204data }; + +static const unsigned char ch205data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x3e,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch205 = { 9, 15, 0, 3, 9, ch205data }; + +static const unsigned char ch206data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x3e,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch206 = { 9, 15, 0, 3, 9, ch206data }; + +static const unsigned char ch207data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x8,0x0,0x3e,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch207 = { 9, 15, 0, 3, 9, ch207data }; + +static const unsigned char ch208data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x7e,0x0,0x21,0x0,0x21,0x0,0x21,0x0,0x21,0x0, + 0x79,0x0,0x21,0x0,0x21,0x0,0x21,0x0,0x7e,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch208 = { 9, 15, 0, 3, 9, ch208data }; + +static const unsigned char ch209data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x43,0x0,0x45,0x0,0x49,0x0,0x49,0x0, + 0x51,0x0,0x61,0x0,0x41,0x0,0x0,0x0,0x28,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch209 = { 9, 15, 0, 3, 9, ch209data }; + +static const unsigned char ch210data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch210 = { 9, 15, 0, 3, 9, ch210data }; + +static const unsigned char ch211data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch211 = { 9, 15, 0, 3, 9, ch211data }; + +static const unsigned char ch212data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch212 = { 9, 15, 0, 3, 9, ch212data }; + +static const unsigned char ch213data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x28,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch213 = { 9, 15, 0, 3, 9, ch213data }; + +static const unsigned char ch214data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch214 = { 9, 15, 0, 3, 9, ch214data }; + +static const unsigned char ch215data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x22,0x0,0x14,0x0,0x8,0x0, + 0x14,0x0,0x22,0x0,0x41,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch215 = { 9, 15, 0, 3, 9, ch215data }; + +static const unsigned char ch216data[] = { + 0x0,0x0,0x0,0x0,0x40,0x0,0x3e,0x0,0x61,0x0,0x51,0x0,0x51,0x0,0x49,0x0, + 0x49,0x0,0x45,0x0,0x45,0x0,0x43,0x0,0x3e,0x0,0x1,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch216 = { 9, 15, 0, 3, 9, ch216data }; + +static const unsigned char ch217data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch217 = { 9, 15, 0, 3, 9, ch217data }; + +static const unsigned char ch218data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch218 = { 9, 15, 0, 3, 9, ch218data }; + +static const unsigned char ch219data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch219 = { 9, 15, 0, 3, 9, ch219data }; + +static const unsigned char ch220data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch220 = { 9, 15, 0, 3, 9, ch220data }; + +static const unsigned char ch221data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x14,0x0, + 0x22,0x0,0x41,0x0,0x41,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch221 = { 9, 15, 0, 3, 9, ch221data }; + +static const unsigned char ch222data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0x7e,0x0,0x41,0x0, + 0x41,0x0,0x41,0x0,0x7e,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch222 = { 9, 15, 0, 3, 9, ch222data }; + +static const unsigned char ch223data[] = { + 0x0,0x0,0x0,0x0,0x40,0x0,0x5e,0x0,0x61,0x0,0x41,0x0,0x41,0x0,0x7e,0x0, + 0x41,0x0,0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch223 = { 9, 15, 0, 3, 9, ch223data }; + +static const unsigned char ch224data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x3f,0x0,0x1,0x0, + 0x1,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch224 = { 9, 15, 0, 3, 9, ch224data }; + +static const unsigned char ch225data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x3f,0x0,0x1,0x0, + 0x1,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch225 = { 9, 15, 0, 3, 9, ch225data }; + +static const unsigned char ch226data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x3f,0x0,0x1,0x0, + 0x1,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch226 = { 9, 15, 0, 3, 9, ch226data }; + +static const unsigned char ch227data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x3f,0x0,0x1,0x0, + 0x1,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch227 = { 9, 15, 0, 3, 9, ch227data }; + +static const unsigned char ch228data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x3f,0x0,0x1,0x0, + 0x1,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch228 = { 9, 15, 0, 3, 9, ch228data }; + +static const unsigned char ch229data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x43,0x0,0x41,0x0,0x3f,0x0,0x1,0x0, + 0x1,0x0,0x3e,0x0,0x0,0x0,0xc,0x0,0x12,0x0,0xc,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch229 = { 9, 15, 0, 3, 9, ch229data }; + +static const unsigned char ch230data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x37,0x0,0x49,0x0,0x48,0x0,0x3e,0x0,0x9,0x0, + 0x49,0x0,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch230 = { 9, 15, 0, 3, 9, ch230data }; + +static const unsigned char ch231data[] = { + 0x18,0x0,0x24,0x0,0xc,0x0,0x3e,0x0,0x41,0x0,0x40,0x0,0x40,0x0,0x40,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch231 = { 9, 15, 0, 3, 9, ch231data }; + +static const unsigned char ch232data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x40,0x0,0x40,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch232 = { 9, 15, 0, 3, 9, ch232data }; + +static const unsigned char ch233data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x40,0x0,0x40,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch233 = { 9, 15, 0, 3, 9, ch233data }; + +static const unsigned char ch234data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x40,0x0,0x40,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch234 = { 9, 15, 0, 3, 9, ch234data }; + +static const unsigned char ch235data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x40,0x0,0x40,0x0,0x7f,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch235 = { 9, 15, 0, 3, 9, ch235data }; + +static const unsigned char ch236data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x38,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch236 = { 9, 15, 0, 3, 9, ch236data }; + +static const unsigned char ch237data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x38,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch237 = { 9, 15, 0, 3, 9, ch237data }; + +static const unsigned char ch238data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x38,0x0,0x0,0x0,0x0,0x0,0x24,0x0,0x18,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch238 = { 9, 15, 0, 3, 9, ch238data }; + +static const unsigned char ch239data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0, + 0x8,0x0,0x38,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch239 = { 9, 15, 0, 3, 9, ch239data }; + +static const unsigned char ch240data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x4,0x0,0x28,0x0,0x18,0x0,0x24,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch240 = { 9, 15, 0, 3, 9, ch240data }; + +static const unsigned char ch241data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x61,0x0,0x5e,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch241 = { 9, 15, 0, 3, 9, ch241data }; + +static const unsigned char ch242data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch242 = { 9, 15, 0, 3, 9, ch242data }; + +static const unsigned char ch243data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch243 = { 9, 15, 0, 3, 9, ch243data }; + +static const unsigned char ch244data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch244 = { 9, 15, 0, 3, 9, ch244data }; + +static const unsigned char ch245data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch245 = { 9, 15, 0, 3, 9, ch245data }; + +static const unsigned char ch246data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3e,0x0,0x41,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x41,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch246 = { 9, 15, 0, 3, 9, ch246data }; + +static const unsigned char ch247data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x1c,0x0,0x8,0x0,0x0,0x0,0x7f,0x0, + 0x0,0x0,0x8,0x0,0x1c,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch247 = { 9, 15, 0, 3, 9, ch247data }; + +static const unsigned char ch248data[] = { + 0x0,0x0,0x0,0x0,0x40,0x0,0x3e,0x0,0x51,0x0,0x51,0x0,0x49,0x0,0x45,0x0, + 0x45,0x0,0x3e,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch248 = { 9, 15, 0, 3, 9, ch248data }; + +static const unsigned char ch249data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x42,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x10,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch249 = { 9, 15, 0, 3, 9, ch249data }; + +static const unsigned char ch250data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x42,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch250 = { 9, 15, 0, 3, 9, ch250data }; + +static const unsigned char ch251data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x42,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0x22,0x0,0x1c,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch251 = { 9, 15, 0, 3, 9, ch251data }; + +static const unsigned char ch252data[] = { + 0x0,0x0,0x0,0x0,0x0,0x0,0x3d,0x0,0x42,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch252 = { 9, 15, 0, 3, 9, ch252data }; + +static const unsigned char ch253data[] = { + 0x3c,0x0,0x42,0x0,0x2,0x0,0x3a,0x0,0x46,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x4,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch253 = { 9, 15, 0, 3, 9, ch253data }; + +static const unsigned char ch254data[] = { + 0x40,0x0,0x40,0x0,0x40,0x0,0x5e,0x0,0x61,0x0,0x41,0x0,0x41,0x0,0x41,0x0, + 0x61,0x0,0x5e,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch254 = { 9, 15, 0, 3, 9, ch254data }; + +static const unsigned char ch255data[] = { + 0x3c,0x0,0x42,0x0,0x2,0x0,0x3a,0x0,0x46,0x0,0x42,0x0,0x42,0x0,0x42,0x0, + 0x42,0x0,0x42,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x14,0x0,0x0,0x0 +}; +static const GLUTBitmapChar ch255 = { 9, 15, 0, 3, 9, ch255data }; + + +static const GLUTBitmapChar *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 GLUTBitmapFont glutBitmap9By15 = { + "-Misc-Fixed-Medium-R-Normal--15-140-75-75-C-90-ISO8859-1", + 15, 256, chars +}; diff --git a/src/glut/dos/hel10.c b/src/glut/dos/hel10.c new file mode 100644 index 000000000..3d24ffee1 --- /dev/null +++ b/src/glut/dos/hel10.c @@ -0,0 +1,1019 @@ +/* autogenerated by bdf2c! do not edit */ + +/* "Copyright (c) 1984, 1987 Adobe Systems Incorporated. All Rights Reserved. Copyright (c) 1988, 1991 Digital Equipment Corporation. All Rights Reserved." */ + + +#include "internal.h" +/* +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; +*/ + + +static const unsigned char ch32data[] = { + 0x0 +}; +static const GLUTBitmapChar ch32 = { 1, 1, 0, 0, 3, ch32data }; + +static const unsigned char ch33data[] = { + 0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch33 = { 1, 8, -1, 0, 3, ch33data }; + +static const unsigned char ch34data[] = { + 0xa0,0xa0 +}; +static const GLUTBitmapChar ch34 = { 3, 2, -1, -6, 4, ch34data }; + +static const unsigned char ch35data[] = { + 0x50,0x50,0xf8,0x28,0x7c,0x28,0x28 +}; +static const GLUTBitmapChar ch35 = { 6, 7, 0, 0, 6, ch35data }; + +static const unsigned char ch36data[] = { + 0x20,0x70,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20 +}; +static const GLUTBitmapChar ch36 = { 5, 9, 0, 1, 6, ch36data }; + +static const unsigned char ch37data[] = { + 0x26,0x29,0x16,0x10,0x8,0x68,0x94,0x64 +}; +static const GLUTBitmapChar ch37 = { 8, 8, 0, 0, 9, ch37data }; + +static const unsigned char ch38data[] = { + 0x64,0x98,0x98,0xa4,0x60,0x50,0x50,0x20 +}; +static const GLUTBitmapChar ch38 = { 6, 8, -1, 0, 8, ch38data }; + +static const unsigned char ch39data[] = { + 0x80,0x40,0x40 +}; +static const GLUTBitmapChar ch39 = { 2, 3, -1, -5, 3, ch39data }; + +static const unsigned char ch40data[] = { + 0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x40,0x40,0x20 +}; +static const GLUTBitmapChar ch40 = { 3, 10, 0, 2, 4, ch40data }; + +static const unsigned char ch41data[] = { + 0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x40,0x40,0x80 +}; +static const GLUTBitmapChar ch41 = { 3, 10, -1, 2, 4, ch41data }; + +static const unsigned char ch42data[] = { + 0xa0,0x40,0xa0 +}; +static const GLUTBitmapChar ch42 = { 3, 3, 0, -5, 4, ch42data }; + +static const unsigned char ch43data[] = { + 0x20,0x20,0xf8,0x20,0x20 +}; +static const GLUTBitmapChar ch43 = { 5, 5, 0, -1, 6, ch43data }; + +static const unsigned char ch44data[] = { + 0x80,0x40,0x40 +}; +static const GLUTBitmapChar ch44 = { 2, 3, 0, 2, 3, ch44data }; + +static const unsigned char ch45data[] = { + 0xf8 +}; +static const GLUTBitmapChar ch45 = { 5, 1, -1, -3, 7, ch45data }; + +static const unsigned char ch46data[] = { + 0x80 +}; +static const GLUTBitmapChar ch46 = { 1, 1, -1, 0, 3, ch46data }; + +static const unsigned char ch47data[] = { + 0x80,0x80,0x40,0x40,0x40,0x40,0x20,0x20 +}; +static const GLUTBitmapChar ch47 = { 3, 8, 0, 0, 3, ch47data }; + +static const unsigned char ch48data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch48 = { 5, 8, 0, 0, 6, ch48data }; + +static const unsigned char ch49data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0xc0,0x40 +}; +static const GLUTBitmapChar ch49 = { 2, 8, -1, 0, 6, ch49data }; + +static const unsigned char ch50data[] = { + 0xf8,0x80,0x40,0x30,0x8,0x8,0x88,0x70 +}; +static const GLUTBitmapChar ch50 = { 5, 8, 0, 0, 6, ch50data }; + +static const unsigned char ch51data[] = { + 0x70,0x88,0x8,0x8,0x30,0x8,0x88,0x70 +}; +static const GLUTBitmapChar ch51 = { 5, 8, 0, 0, 6, ch51data }; + +static const unsigned char ch52data[] = { + 0x10,0x10,0xf8,0x90,0x50,0x50,0x30,0x10 +}; +static const GLUTBitmapChar ch52 = { 5, 8, 0, 0, 6, ch52data }; + +static const unsigned char ch53data[] = { + 0x70,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8 +}; +static const GLUTBitmapChar ch53 = { 5, 8, 0, 0, 6, ch53data }; + +static const unsigned char ch54data[] = { + 0x70,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70 +}; +static const GLUTBitmapChar ch54 = { 5, 8, 0, 0, 6, ch54data }; + +static const unsigned char ch55data[] = { + 0x40,0x40,0x20,0x20,0x10,0x10,0x8,0xf8 +}; +static const GLUTBitmapChar ch55 = { 5, 8, 0, 0, 6, ch55data }; + +static const unsigned char ch56data[] = { + 0x70,0x88,0x88,0x88,0x70,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch56 = { 5, 8, 0, 0, 6, ch56data }; + +static const unsigned char ch57data[] = { + 0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch57 = { 5, 8, 0, 0, 6, ch57data }; + +static const unsigned char ch58data[] = { + 0x80,0x0,0x0,0x0,0x0,0x80 +}; +static const GLUTBitmapChar ch58 = { 1, 6, -1, 0, 3, ch58data }; + +static const unsigned char ch59data[] = { + 0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40 +}; +static const GLUTBitmapChar ch59 = { 2, 8, 0, 2, 3, ch59data }; + +static const unsigned char ch60data[] = { + 0x20,0x40,0x80,0x40,0x20 +}; +static const GLUTBitmapChar ch60 = { 3, 5, -1, -1, 6, ch60data }; + +static const unsigned char ch61data[] = { + 0xf0,0x0,0xf0 +}; +static const GLUTBitmapChar ch61 = { 4, 3, 0, -2, 5, ch61data }; + +static const unsigned char ch62data[] = { + 0x80,0x40,0x20,0x40,0x80 +}; +static const GLUTBitmapChar ch62 = { 3, 5, -1, -1, 6, ch62data }; + +static const unsigned char ch63data[] = { + 0x40,0x0,0x40,0x40,0x20,0x10,0x90,0x60 +}; +static const GLUTBitmapChar ch63 = { 4, 8, -1, 0, 6, ch63data }; + +static const unsigned char ch64data[] = { + 0x3e,0x0,0x40,0x0,0x9b,0x0,0xa4,0x80,0xa4,0x80,0xa2,0x40,0x92,0x40,0x4d,0x40, + 0x20,0x80,0x1f,0x0 +}; +static const GLUTBitmapChar ch64 = { 10, 10, 0, 2, 11, ch64data }; + +static const unsigned char ch65data[] = { + 0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10 +}; +static const GLUTBitmapChar ch65 = { 7, 8, 0, 0, 7, ch65data }; + +static const unsigned char ch66data[] = { + 0xf0,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0 +}; +static const GLUTBitmapChar ch66 = { 5, 8, -1, 0, 7, ch66data }; + +static const unsigned char ch67data[] = { + 0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78 +}; +static const GLUTBitmapChar ch67 = { 6, 8, -1, 0, 8, ch67data }; + +static const unsigned char ch68data[] = { + 0xf0,0x88,0x84,0x84,0x84,0x84,0x88,0xf0 +}; +static const GLUTBitmapChar ch68 = { 6, 8, -1, 0, 8, ch68data }; + +static const unsigned char ch69data[] = { + 0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8 +}; +static const GLUTBitmapChar ch69 = { 5, 8, -1, 0, 7, ch69data }; + +static const unsigned char ch70data[] = { + 0x80,0x80,0x80,0x80,0xf0,0x80,0x80,0xf8 +}; +static const GLUTBitmapChar ch70 = { 5, 8, -1, 0, 6, ch70data }; + +static const unsigned char ch71data[] = { + 0x74,0x8c,0x84,0x8c,0x80,0x80,0x84,0x78 +}; +static const GLUTBitmapChar ch71 = { 6, 8, -1, 0, 8, ch71data }; + +static const unsigned char ch72data[] = { + 0x84,0x84,0x84,0x84,0xfc,0x84,0x84,0x84 +}; +static const GLUTBitmapChar ch72 = { 6, 8, -1, 0, 8, ch72data }; + +static const unsigned char ch73data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch73 = { 1, 8, -1, 0, 3, ch73data }; + +static const unsigned char ch74data[] = { + 0x60,0x90,0x10,0x10,0x10,0x10,0x10,0x10 +}; +static const GLUTBitmapChar ch74 = { 4, 8, 0, 0, 5, ch74data }; + +static const unsigned char ch75data[] = { + 0x88,0x88,0x90,0x90,0xe0,0xa0,0x90,0x88 +}; +static const GLUTBitmapChar ch75 = { 5, 8, -1, 0, 7, ch75data }; + +static const unsigned char ch76data[] = { + 0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch76 = { 4, 8, -1, 0, 6, ch76data }; + +static const unsigned char ch77data[] = { + 0x92,0x92,0x92,0xaa,0xaa,0xc6,0xc6,0x82 +}; +static const GLUTBitmapChar ch77 = { 7, 8, -1, 0, 9, ch77data }; + +static const unsigned char ch78data[] = { + 0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4 +}; +static const GLUTBitmapChar ch78 = { 6, 8, -1, 0, 8, ch78data }; + +static const unsigned char ch79data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78 +}; +static const GLUTBitmapChar ch79 = { 6, 8, -1, 0, 8, ch79data }; + +static const unsigned char ch80data[] = { + 0x80,0x80,0x80,0x80,0xf0,0x88,0x88,0xf0 +}; +static const GLUTBitmapChar ch80 = { 5, 8, -1, 0, 7, ch80data }; + +static const unsigned char ch81data[] = { + 0x2,0x7c,0x8c,0x94,0x84,0x84,0x84,0x84,0x78 +}; +static const GLUTBitmapChar ch81 = { 7, 9, -1, 1, 8, ch81data }; + +static const unsigned char ch82data[] = { + 0x88,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0 +}; +static const GLUTBitmapChar ch82 = { 5, 8, -1, 0, 7, ch82data }; + +static const unsigned char ch83data[] = { + 0x70,0x88,0x88,0x8,0x70,0x80,0x88,0x70 +}; +static const GLUTBitmapChar ch83 = { 5, 8, -1, 0, 7, ch83data }; + +static const unsigned char ch84data[] = { + 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8 +}; +static const GLUTBitmapChar ch84 = { 5, 8, 0, 0, 5, ch84data }; + +static const unsigned char ch85data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84 +}; +static const GLUTBitmapChar ch85 = { 6, 8, -1, 0, 8, ch85data }; + +static const unsigned char ch86data[] = { + 0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82 +}; +static const GLUTBitmapChar ch86 = { 7, 8, 0, 0, 7, ch86data }; + +static const unsigned char ch87data[] = { + 0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80 +}; +static const GLUTBitmapChar ch87 = { 9, 8, 0, 0, 9, ch87data }; + +static const unsigned char ch88data[] = { + 0x88,0x88,0x50,0x50,0x20,0x50,0x88,0x88 +}; +static const GLUTBitmapChar ch88 = { 5, 8, -1, 0, 7, ch88data }; + +static const unsigned char ch89data[] = { + 0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82 +}; +static const GLUTBitmapChar ch89 = { 7, 8, 0, 0, 7, ch89data }; + +static const unsigned char ch90data[] = { + 0xf8,0x80,0x40,0x20,0x20,0x10,0x8,0xf8 +}; +static const GLUTBitmapChar ch90 = { 5, 8, -1, 0, 7, ch90data }; + +static const unsigned char ch91data[] = { + 0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0 +}; +static const GLUTBitmapChar ch91 = { 2, 10, -1, 2, 3, ch91data }; + +static const unsigned char ch92data[] = { + 0x20,0x20,0x40,0x40,0x40,0x40,0x80,0x80 +}; +static const GLUTBitmapChar ch92 = { 3, 8, 0, 0, 3, ch92data }; + +static const unsigned char ch93data[] = { + 0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0 +}; +static const GLUTBitmapChar ch93 = { 2, 10, 0, 2, 3, ch93data }; + +static const unsigned char ch94data[] = { + 0x88,0x50,0x50,0x20,0x20 +}; +static const GLUTBitmapChar ch94 = { 5, 5, 0, -3, 6, ch94data }; + +static const unsigned char ch95data[] = { + 0xfc +}; +static const GLUTBitmapChar ch95 = { 6, 1, 0, 2, 6, ch95data }; + +static const unsigned char ch96data[] = { + 0x80,0x80,0x40 +}; +static const GLUTBitmapChar ch96 = { 2, 3, 0, -5, 3, ch96data }; + +static const unsigned char ch97data[] = { + 0x68,0x90,0x90,0x70,0x10,0xe0 +}; +static const GLUTBitmapChar ch97 = { 5, 6, 0, 0, 5, ch97data }; + +static const unsigned char ch98data[] = { + 0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80 +}; +static const GLUTBitmapChar ch98 = { 5, 8, 0, 0, 6, ch98data }; + +static const unsigned char ch99data[] = { + 0x60,0x90,0x80,0x80,0x90,0x60 +}; +static const GLUTBitmapChar ch99 = { 4, 6, 0, 0, 5, ch99data }; + +static const unsigned char ch100data[] = { + 0x68,0x98,0x88,0x88,0x98,0x68,0x8,0x8 +}; +static const GLUTBitmapChar ch100 = { 5, 8, 0, 0, 6, ch100data }; + +static const unsigned char ch101data[] = { + 0x60,0x90,0x80,0xf0,0x90,0x60 +}; +static const GLUTBitmapChar ch101 = { 4, 6, 0, 0, 5, ch101data }; + +static const unsigned char ch102data[] = { + 0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30 +}; +static const GLUTBitmapChar ch102 = { 4, 8, 0, 0, 4, ch102data }; + +static const unsigned char ch103data[] = { + 0x70,0x8,0x68,0x98,0x88,0x88,0x98,0x68 +}; +static const GLUTBitmapChar ch103 = { 5, 8, 0, 2, 6, ch103data }; + +static const unsigned char ch104data[] = { + 0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80 +}; +static const GLUTBitmapChar ch104 = { 5, 8, 0, 0, 6, ch104data }; + +static const unsigned char ch105data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80 +}; +static const GLUTBitmapChar ch105 = { 1, 8, 0, 0, 2, ch105data }; + +static const unsigned char ch106data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80 +}; +static const GLUTBitmapChar ch106 = { 1, 9, 0, 1, 2, ch106data }; + +static const unsigned char ch107data[] = { + 0x90,0x90,0xa0,0xc0,0xa0,0x90,0x80,0x80 +}; +static const GLUTBitmapChar ch107 = { 4, 8, 0, 0, 5, ch107data }; + +static const unsigned char ch108data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch108 = { 1, 8, 0, 0, 2, ch108data }; + +static const unsigned char ch109data[] = { + 0x92,0x92,0x92,0x92,0x92,0xec +}; +static const GLUTBitmapChar ch109 = { 7, 6, 0, 0, 8, ch109data }; + +static const unsigned char ch110data[] = { + 0x88,0x88,0x88,0x88,0xc8,0xb0 +}; +static const GLUTBitmapChar ch110 = { 5, 6, 0, 0, 6, ch110data }; + +static const unsigned char ch111data[] = { + 0x70,0x88,0x88,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch111 = { 5, 6, 0, 0, 6, ch111data }; + +static const unsigned char ch112data[] = { + 0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0 +}; +static const GLUTBitmapChar ch112 = { 5, 8, 0, 2, 6, ch112data }; + +static const unsigned char ch113data[] = { + 0x8,0x8,0x68,0x98,0x88,0x88,0x98,0x68 +}; +static const GLUTBitmapChar ch113 = { 5, 8, 0, 2, 6, ch113data }; + +static const unsigned char ch114data[] = { + 0x80,0x80,0x80,0x80,0xc0,0xa0 +}; +static const GLUTBitmapChar ch114 = { 3, 6, 0, 0, 4, ch114data }; + +static const unsigned char ch115data[] = { + 0x60,0x90,0x10,0x60,0x90,0x60 +}; +static const GLUTBitmapChar ch115 = { 4, 6, 0, 0, 5, ch115data }; + +static const unsigned char ch116data[] = { + 0x60,0x40,0x40,0x40,0x40,0xe0,0x40,0x40 +}; +static const GLUTBitmapChar ch116 = { 3, 8, 0, 0, 4, ch116data }; + +static const unsigned char ch117data[] = { + 0x70,0x90,0x90,0x90,0x90,0x90 +}; +static const GLUTBitmapChar ch117 = { 4, 6, 0, 0, 5, ch117data }; + +static const unsigned char ch118data[] = { + 0x20,0x20,0x50,0x50,0x88,0x88 +}; +static const GLUTBitmapChar ch118 = { 5, 6, 0, 0, 6, ch118data }; + +static const unsigned char ch119data[] = { + 0x28,0x28,0x54,0x54,0x92,0x92 +}; +static const GLUTBitmapChar ch119 = { 7, 6, 0, 0, 8, ch119data }; + +static const unsigned char ch120data[] = { + 0x88,0x88,0x50,0x20,0x50,0x88 +}; +static const GLUTBitmapChar ch120 = { 5, 6, 0, 0, 6, ch120data }; + +static const unsigned char ch121data[] = { + 0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90 +}; +static const GLUTBitmapChar ch121 = { 4, 8, 0, 2, 5, ch121data }; + +static const unsigned char ch122data[] = { + 0xf0,0x80,0x40,0x20,0x10,0xf0 +}; +static const GLUTBitmapChar ch122 = { 4, 6, 0, 0, 5, ch122data }; + +static const unsigned char ch123data[] = { + 0x20,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20 +}; +static const GLUTBitmapChar ch123 = { 3, 10, 0, 2, 3, ch123data }; + +static const unsigned char ch124data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch124 = { 1, 10, -1, 2, 3, ch124data }; + +static const unsigned char ch125data[] = { + 0x80,0x40,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80 +}; +static const GLUTBitmapChar ch125 = { 3, 10, 0, 2, 3, ch125data }; + +static const unsigned char ch126data[] = { + 0x98,0x64 +}; +static const GLUTBitmapChar ch126 = { 6, 2, 0, -3, 7, ch126data }; + +static const unsigned char ch160data[] = { + 0x0 +}; +static const GLUTBitmapChar ch160 = { 1, 1, 0, 0, 3, ch160data }; + +static const unsigned char ch161data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80 +}; +static const GLUTBitmapChar ch161 = { 1, 8, -1, 2, 3, ch161data }; + +static const unsigned char ch162data[] = { + 0x40,0x70,0xa8,0xa0,0xa0,0xa8,0x70,0x10 +}; +static const GLUTBitmapChar ch162 = { 5, 8, 0, 1, 6, ch162data }; + +static const unsigned char ch163data[] = { + 0xb0,0x48,0x40,0x40,0xe0,0x40,0x48,0x30 +}; +static const GLUTBitmapChar ch163 = { 5, 8, 0, 0, 6, ch163data }; + +static const unsigned char ch164data[] = { + 0x90,0x60,0x90,0x90,0x60,0x90 +}; +static const GLUTBitmapChar ch164 = { 4, 6, 0, -1, 5, ch164data }; + +static const unsigned char ch165data[] = { + 0x20,0xf8,0x20,0xf8,0x50,0x50,0x88,0x88 +}; +static const GLUTBitmapChar ch165 = { 5, 8, 0, 0, 6, ch165data }; + +static const unsigned char ch166data[] = { + 0x80,0x80,0x80,0x80,0x0,0x0,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch166 = { 1, 10, -1, 2, 3, ch166data }; + +static const unsigned char ch167data[] = { + 0x70,0x88,0x18,0x70,0xc8,0x98,0x70,0xc0,0x88,0x70 +}; +static const GLUTBitmapChar ch167 = { 5, 10, 0, 2, 6, ch167data }; + +static const unsigned char ch168data[] = { + 0xa0 +}; +static const GLUTBitmapChar ch168 = { 3, 1, 0, -7, 3, ch168data }; + +static const unsigned char ch169data[] = { + 0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38 +}; +static const GLUTBitmapChar ch169 = { 7, 7, -1, 0, 9, ch169data }; + +static const unsigned char ch170data[] = { + 0xe0,0x0,0xa0,0x20,0xe0 +}; +static const GLUTBitmapChar ch170 = { 3, 5, 0, -3, 4, ch170data }; + +static const unsigned char ch171data[] = { + 0x28,0x50,0xa0,0x50,0x28 +}; +static const GLUTBitmapChar ch171 = { 5, 5, 0, 0, 6, ch171data }; + +static const unsigned char ch172data[] = { + 0x8,0x8,0xf8 +}; +static const GLUTBitmapChar ch172 = { 5, 3, -1, -2, 7, ch172data }; + +static const unsigned char ch173data[] = { + 0xe0 +}; +static const GLUTBitmapChar ch173 = { 3, 1, 0, -3, 4, ch173data }; + +static const unsigned char ch174data[] = { + 0x38,0x44,0xaa,0xb2,0xba,0x44,0x38 +}; +static const GLUTBitmapChar ch174 = { 7, 7, -1, 0, 9, ch174data }; + +static const unsigned char ch175data[] = { + 0xe0 +}; +static const GLUTBitmapChar ch175 = { 3, 1, 0, -7, 3, ch175data }; + +static const unsigned char ch176data[] = { + 0x60,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch176 = { 4, 4, 0, -3, 4, ch176data }; + +static const unsigned char ch177data[] = { + 0xf8,0x0,0x20,0x20,0xf8,0x20,0x20 +}; +static const GLUTBitmapChar ch177 = { 5, 7, 0, 0, 6, ch177data }; + +static const unsigned char ch178data[] = { + 0xe0,0x40,0xa0,0x60 +}; +static const GLUTBitmapChar ch178 = { 3, 4, 0, -3, 3, ch178data }; + +static const unsigned char ch179data[] = { + 0xc0,0x20,0x40,0xe0 +}; +static const GLUTBitmapChar ch179 = { 3, 4, 0, -3, 3, ch179data }; + +static const unsigned char ch180data[] = { + 0x80,0x40 +}; +static const GLUTBitmapChar ch180 = { 2, 2, 0, -6, 3, ch180data }; + +static const unsigned char ch181data[] = { + 0x80,0x80,0xf0,0x90,0x90,0x90,0x90,0x90 +}; +static const GLUTBitmapChar ch181 = { 4, 8, 0, 2, 5, ch181data }; + +static const unsigned char ch182data[] = { + 0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c +}; +static const GLUTBitmapChar ch182 = { 6, 10, 0, 2, 6, ch182data }; + +static const unsigned char ch183data[] = { + 0xc0 +}; +static const GLUTBitmapChar ch183 = { 2, 1, 0, -3, 3, ch183data }; + +static const unsigned char ch184data[] = { + 0xc0,0x40 +}; +static const GLUTBitmapChar ch184 = { 2, 2, 0, 2, 3, ch184data }; + +static const unsigned char ch185data[] = { + 0x40,0x40,0xc0,0x40 +}; +static const GLUTBitmapChar ch185 = { 2, 4, 0, -3, 3, ch185data }; + +static const unsigned char ch186data[] = { + 0xe0,0x0,0xe0,0xa0,0xe0 +}; +static const GLUTBitmapChar ch186 = { 3, 5, 0, -3, 4, ch186data }; + +static const unsigned char ch187data[] = { + 0xa0,0x50,0x28,0x50,0xa0 +}; +static const GLUTBitmapChar ch187 = { 5, 5, 0, 0, 6, ch187data }; + +static const unsigned char ch188data[] = { + 0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0x48,0x0,0x44,0x0,0xc4,0x0,0x42,0x0 +}; +static const GLUTBitmapChar ch188 = { 9, 8, 0, 0, 9, ch188data }; + +static const unsigned char ch189data[] = { + 0x27,0x12,0x15,0xb,0x48,0x44,0xc4,0x42 +}; +static const GLUTBitmapChar ch189 = { 8, 8, 0, 0, 9, ch189data }; + +static const unsigned char ch190data[] = { + 0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0xc8,0x0,0x24,0x0,0x44,0x0,0xe2,0x0 +}; +static const GLUTBitmapChar ch190 = { 9, 8, 0, 0, 9, ch190data }; + +static const unsigned char ch191data[] = { + 0x60,0x90,0x80,0x40,0x20,0x20,0x0,0x20 +}; +static const GLUTBitmapChar ch191 = { 4, 8, -1, 2, 6, ch191data }; + +static const unsigned char ch192data[] = { + 0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch192 = { 7, 11, 0, 0, 7, ch192data }; + +static const unsigned char ch193data[] = { + 0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch193 = { 7, 11, 0, 0, 7, ch193data }; + +static const unsigned char ch194data[] = { + 0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch194 = { 7, 11, 0, 0, 7, ch194data }; + +static const unsigned char ch195data[] = { + 0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x14 +}; +static const GLUTBitmapChar ch195 = { 7, 11, 0, 0, 7, ch195data }; + +static const unsigned char ch196data[] = { + 0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28 +}; +static const GLUTBitmapChar ch196 = { 7, 10, 0, 0, 7, ch196data }; + +static const unsigned char ch197data[] = { + 0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x10,0x28,0x10 +}; +static const GLUTBitmapChar ch197 = { 7, 11, 0, 0, 7, ch197data }; + +static const unsigned char ch198data[] = { + 0x8f,0x80,0x88,0x0,0x78,0x0,0x48,0x0,0x2f,0x80,0x28,0x0,0x18,0x0,0x1f,0x80 +}; +static const GLUTBitmapChar ch198 = { 9, 8, 0, 0, 10, ch198data }; + +static const unsigned char ch199data[] = { + 0x30,0x10,0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78 +}; +static const GLUTBitmapChar ch199 = { 6, 10, -1, 2, 8, ch199data }; + +static const unsigned char ch200data[] = { + 0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch200 = { 5, 11, -1, 0, 7, ch200data }; + +static const unsigned char ch201data[] = { + 0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch201 = { 5, 11, -1, 0, 7, ch201data }; + +static const unsigned char ch202data[] = { + 0xf8,0x80,0x80,0xf8,0x80,0x80,0x80,0xf8,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch202 = { 5, 11, -1, 0, 7, ch202data }; + +static const unsigned char ch203data[] = { + 0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x50 +}; +static const GLUTBitmapChar ch203 = { 5, 10, -1, 0, 7, ch203data }; + +static const unsigned char ch204data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch204 = { 2, 11, 0, 0, 3, ch204data }; + +static const unsigned char ch205data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40 +}; +static const GLUTBitmapChar ch205 = { 2, 11, -1, 0, 3, ch205data }; + +static const unsigned char ch206data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch206 = { 3, 11, 0, 0, 3, ch206data }; + +static const unsigned char ch207data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0 +}; +static const GLUTBitmapChar ch207 = { 3, 10, 0, 0, 3, ch207data }; + +static const unsigned char ch208data[] = { + 0x78,0x44,0x42,0x42,0xf2,0x42,0x44,0x78 +}; +static const GLUTBitmapChar ch208 = { 7, 8, 0, 0, 8, ch208data }; + +static const unsigned char ch209data[] = { + 0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch209 = { 6, 11, -1, 0, 8, ch209data }; + +static const unsigned char ch210data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch210 = { 6, 11, -1, 0, 8, ch210data }; + +static const unsigned char ch211data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch211 = { 6, 11, -1, 0, 8, ch211data }; + +static const unsigned char ch212data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch212 = { 6, 11, -1, 0, 8, ch212data }; + +static const unsigned char ch213data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch213 = { 6, 11, -1, 0, 8, ch213data }; + +static const unsigned char ch214data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x48 +}; +static const GLUTBitmapChar ch214 = { 6, 10, -1, 0, 8, ch214data }; + +static const unsigned char ch215data[] = { + 0x88,0x50,0x20,0x50,0x88 +}; +static const GLUTBitmapChar ch215 = { 5, 5, 0, -1, 6, ch215data }; + +static const unsigned char ch216data[] = { + 0x80,0x78,0xc4,0xa4,0xa4,0x94,0x94,0x8c,0x78,0x4 +}; +static const GLUTBitmapChar ch216 = { 6, 10, -1, 1, 8, ch216data }; + +static const unsigned char ch217data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch217 = { 6, 11, -1, 0, 8, ch217data }; + +static const unsigned char ch218data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch218 = { 6, 11, -1, 0, 8, ch218data }; + +static const unsigned char ch219data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch219 = { 6, 11, -1, 0, 8, ch219data }; + +static const unsigned char ch220data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48 +}; +static const GLUTBitmapChar ch220 = { 6, 10, -1, 0, 8, ch220data }; + +static const unsigned char ch221data[] = { + 0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch221 = { 7, 11, 0, 0, 7, ch221data }; + +static const unsigned char ch222data[] = { + 0x80,0x80,0xf0,0x88,0x88,0xf0,0x80,0x80 +}; +static const GLUTBitmapChar ch222 = { 5, 8, -1, 0, 7, ch222data }; + +static const unsigned char ch223data[] = { + 0xa0,0x90,0x90,0x90,0xa0,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch223 = { 4, 8, 0, 0, 5, ch223data }; + +static const unsigned char ch224data[] = { + 0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch224 = { 5, 9, 0, 0, 5, ch224data }; + +static const unsigned char ch225data[] = { + 0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch225 = { 5, 9, 0, 0, 5, ch225data }; + +static const unsigned char ch226data[] = { + 0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch226 = { 5, 9, 0, 0, 5, ch226data }; + +static const unsigned char ch227data[] = { + 0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0xa0,0x50 +}; +static const GLUTBitmapChar ch227 = { 5, 9, 0, 0, 5, ch227data }; + +static const unsigned char ch228data[] = { + 0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50 +}; +static const GLUTBitmapChar ch228 = { 5, 8, 0, 0, 5, ch228data }; + +static const unsigned char ch229data[] = { + 0x68,0x90,0x90,0x70,0x10,0xe0,0x20,0x50,0x20 +}; +static const GLUTBitmapChar ch229 = { 5, 9, 0, 0, 5, ch229data }; + +static const unsigned char ch230data[] = { + 0x6c,0x92,0x90,0x7e,0x12,0xec +}; +static const GLUTBitmapChar ch230 = { 7, 6, 0, 0, 8, ch230data }; + +static const unsigned char ch231data[] = { + 0x60,0x20,0x60,0x90,0x80,0x80,0x90,0x60 +}; +static const GLUTBitmapChar ch231 = { 4, 8, 0, 2, 5, ch231data }; + +static const unsigned char ch232data[] = { + 0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch232 = { 4, 9, 0, 0, 5, ch232data }; + +static const unsigned char ch233data[] = { + 0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch233 = { 4, 9, 0, 0, 5, ch233data }; + +static const unsigned char ch234data[] = { + 0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch234 = { 4, 9, 0, 0, 5, ch234data }; + +static const unsigned char ch235data[] = { + 0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50 +}; +static const GLUTBitmapChar ch235 = { 4, 8, 0, 0, 5, ch235data }; + +static const unsigned char ch236data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch236 = { 2, 9, 1, 0, 2, ch236data }; + +static const unsigned char ch237data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40 +}; +static const GLUTBitmapChar ch237 = { 2, 9, 0, 0, 2, ch237data }; + +static const unsigned char ch238data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch238 = { 3, 9, 1, 0, 2, ch238data }; + +static const unsigned char ch239data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0 +}; +static const GLUTBitmapChar ch239 = { 3, 8, 0, 0, 2, ch239data }; + +static const unsigned char ch240data[] = { + 0x70,0x88,0x88,0x88,0x88,0x78,0x90,0x60,0x50 +}; +static const GLUTBitmapChar ch240 = { 5, 9, 0, 0, 6, ch240data }; + +static const unsigned char ch241data[] = { + 0x90,0x90,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50 +}; +static const GLUTBitmapChar ch241 = { 4, 9, 0, 0, 5, ch241data }; + +static const unsigned char ch242data[] = { + 0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch242 = { 5, 9, 0, 0, 6, ch242data }; + +static const unsigned char ch243data[] = { + 0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch243 = { 5, 9, 0, 0, 6, ch243data }; + +static const unsigned char ch244data[] = { + 0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch244 = { 5, 9, 0, 0, 6, ch244data }; + +static const unsigned char ch245data[] = { + 0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch245 = { 5, 9, 0, 0, 6, ch245data }; + +static const unsigned char ch246data[] = { + 0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50 +}; +static const GLUTBitmapChar ch246 = { 5, 8, 0, 0, 6, ch246data }; + +static const unsigned char ch247data[] = { + 0x20,0x0,0xf8,0x0,0x20 +}; +static const GLUTBitmapChar ch247 = { 5, 5, 0, -1, 6, ch247data }; + +static const unsigned char ch248data[] = { + 0x70,0x88,0xc8,0xa8,0x98,0x74 +}; +static const GLUTBitmapChar ch248 = { 6, 6, 0, 0, 6, ch248data }; + +static const unsigned char ch249data[] = { + 0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch249 = { 4, 9, 0, 0, 5, ch249data }; + +static const unsigned char ch250data[] = { + 0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch250 = { 4, 9, 0, 0, 5, ch250data }; + +static const unsigned char ch251data[] = { + 0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch251 = { 4, 9, 0, 0, 5, ch251data }; + +static const unsigned char ch252data[] = { + 0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50 +}; +static const GLUTBitmapChar ch252 = { 4, 8, 0, 0, 5, ch252data }; + +static const unsigned char ch253data[] = { + 0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch253 = { 4, 11, 0, 2, 5, ch253data }; + +static const unsigned char ch254data[] = { + 0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80 +}; +static const GLUTBitmapChar ch254 = { 5, 10, 0, 2, 6, ch254data }; + +static const unsigned char ch255data[] = { + 0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x50 +}; +static const GLUTBitmapChar ch255 = { 4, 10, 0, 2, 5, ch255data }; + + +static const GLUTBitmapChar *chars[] = { + 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, + &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 GLUTBitmapFont glutBitmapHelvetica10 = { + "-Adobe-Helvetica-Medium-R-Normal--10-100-75-75-P-56-ISO8859-1", + 13, 256, chars +}; diff --git a/src/glut/dos/hel12.c b/src/glut/dos/hel12.c new file mode 100644 index 000000000..0fe8b0919 --- /dev/null +++ b/src/glut/dos/hel12.c @@ -0,0 +1,1029 @@ +/* autogenerated by bdf2c! do not edit */ + +/* "Copyright (c) 1984, 1987 Adobe Systems Incorporated. All Rights Reserved. Copyright (c) 1988, 1991 Digital Equipment Corporation. All Rights Reserved." */ + + +#include "internal.h" +/* +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; +*/ + + +static const unsigned char ch32data[] = { + 0x0 +}; +static const GLUTBitmapChar ch32 = { 1, 1, 0, 0, 4, ch32data }; + +static const unsigned char ch33data[] = { + 0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch33 = { 1, 9, -1, 0, 3, ch33data }; + +static const unsigned char ch34data[] = { + 0xa0,0xa0,0xa0 +}; +static const GLUTBitmapChar ch34 = { 3, 3, -1, -6, 5, ch34data }; + +static const unsigned char ch35data[] = { + 0x50,0x50,0x50,0xfc,0x28,0xfc,0x28,0x28 +}; +static const GLUTBitmapChar ch35 = { 6, 8, 0, 0, 7, ch35data }; + +static const unsigned char ch36data[] = { + 0x20,0x70,0xa8,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20 +}; +static const GLUTBitmapChar ch36 = { 5, 10, -1, 1, 7, ch36data }; + +static const unsigned char ch37data[] = { + 0x23,0x0,0x14,0x80,0x14,0x80,0x13,0x0,0x8,0x0,0x68,0x0,0x94,0x0,0x94,0x0, + 0x62,0x0 +}; +static const GLUTBitmapChar ch37 = { 9, 9, -1, 0, 11, ch37data }; + +static const unsigned char ch38data[] = { + 0x72,0x8c,0x84,0x8a,0x50,0x30,0x48,0x48,0x30 +}; +static const GLUTBitmapChar ch38 = { 7, 9, -1, 0, 9, ch38data }; + +static const unsigned char ch39data[] = { + 0x80,0x40,0xc0 +}; +static const GLUTBitmapChar ch39 = { 2, 3, -1, -6, 3, ch39data }; + +static const unsigned char ch40data[] = { + 0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x20 +}; +static const GLUTBitmapChar ch40 = { 3, 12, -1, 3, 4, ch40data }; + +static const unsigned char ch41data[] = { + 0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x20,0x20,0x40,0x40,0x80 +}; +static const GLUTBitmapChar ch41 = { 3, 12, 0, 3, 4, ch41data }; + +static const unsigned char ch42data[] = { + 0xa0,0x40,0xa0 +}; +static const GLUTBitmapChar ch42 = { 3, 3, -1, -6, 5, ch42data }; + +static const unsigned char ch43data[] = { + 0x20,0x20,0xf8,0x20,0x20 +}; +static const GLUTBitmapChar ch43 = { 5, 5, -1, -1, 7, ch43data }; + +static const unsigned char ch44data[] = { + 0x80,0x40,0x40 +}; +static const GLUTBitmapChar ch44 = { 2, 3, -1, 2, 4, ch44data }; + +static const unsigned char ch45data[] = { + 0xf8 +}; +static const GLUTBitmapChar ch45 = { 5, 1, -1, -3, 8, ch45data }; + +static const unsigned char ch46data[] = { + 0x80 +}; +static const GLUTBitmapChar ch46 = { 1, 1, -1, 0, 3, ch46data }; + +static const unsigned char ch47data[] = { + 0x80,0x80,0x40,0x40,0x40,0x20,0x20,0x10,0x10 +}; +static const GLUTBitmapChar ch47 = { 4, 9, 0, 0, 4, ch47data }; + +static const unsigned char ch48data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch48 = { 5, 9, -1, 0, 7, ch48data }; + +static const unsigned char ch49data[] = { + 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xe0,0x20 +}; +static const GLUTBitmapChar ch49 = { 3, 9, -1, 0, 7, ch49data }; + +static const unsigned char ch50data[] = { + 0xf8,0x80,0x80,0x40,0x20,0x10,0x8,0x88,0x70 +}; +static const GLUTBitmapChar ch50 = { 5, 9, -1, 0, 7, ch50data }; + +static const unsigned char ch51data[] = { + 0x70,0x88,0x88,0x8,0x8,0x30,0x8,0x88,0x70 +}; +static const GLUTBitmapChar ch51 = { 5, 9, -1, 0, 7, ch51data }; + +static const unsigned char ch52data[] = { + 0x8,0x8,0xfc,0x88,0x48,0x28,0x28,0x18,0x8 +}; +static const GLUTBitmapChar ch52 = { 6, 9, 0, 0, 7, ch52data }; + +static const unsigned char ch53data[] = { + 0x70,0x88,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8 +}; +static const GLUTBitmapChar ch53 = { 5, 9, -1, 0, 7, ch53data }; + +static const unsigned char ch54data[] = { + 0x70,0x88,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70 +}; +static const GLUTBitmapChar ch54 = { 5, 9, -1, 0, 7, ch54data }; + +static const unsigned char ch55data[] = { + 0x40,0x40,0x20,0x20,0x20,0x10,0x10,0x8,0xf8 +}; +static const GLUTBitmapChar ch55 = { 5, 9, -1, 0, 7, ch55data }; + +static const unsigned char ch56data[] = { + 0x70,0x88,0x88,0x88,0x88,0x70,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch56 = { 5, 9, -1, 0, 7, ch56data }; + +static const unsigned char ch57data[] = { + 0x70,0x88,0x8,0x8,0x78,0x88,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch57 = { 5, 9, -1, 0, 7, ch57data }; + +static const unsigned char ch58data[] = { + 0x80,0x0,0x0,0x0,0x0,0x80 +}; +static const GLUTBitmapChar ch58 = { 1, 6, -1, 0, 3, ch58data }; + +static const unsigned char ch59data[] = { + 0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40 +}; +static const GLUTBitmapChar ch59 = { 2, 8, 0, 2, 3, ch59data }; + +static const unsigned char ch60data[] = { + 0xc,0x30,0xc0,0x30,0xc +}; +static const GLUTBitmapChar ch60 = { 6, 5, 0, -1, 7, ch60data }; + +static const unsigned char ch61data[] = { + 0xf8,0x0,0xf8 +}; +static const GLUTBitmapChar ch61 = { 5, 3, -1, -2, 7, ch61data }; + +static const unsigned char ch62data[] = { + 0xc0,0x30,0xc,0x30,0xc0 +}; +static const GLUTBitmapChar ch62 = { 6, 5, -1, -1, 7, ch62data }; + +static const unsigned char ch63data[] = { + 0x20,0x0,0x20,0x20,0x10,0x10,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch63 = { 5, 9, -1, 0, 7, ch63data }; + +static const unsigned char ch64data[] = { + 0x3e,0x0,0x40,0x0,0x9b,0x0,0xa6,0x80,0xa2,0x40,0xa2,0x40,0x92,0x40,0x4d,0x40, + 0x60,0x80,0x1f,0x0 +}; +static const GLUTBitmapChar ch64 = { 10, 10, -1, 1, 12, ch64data }; + +static const unsigned char ch65data[] = { + 0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x28,0x10 +}; +static const GLUTBitmapChar ch65 = { 7, 9, -1, 0, 9, ch65data }; + +static const unsigned char ch66data[] = { + 0xf8,0x84,0x84,0x84,0xf8,0x84,0x84,0x84,0xf8 +}; +static const GLUTBitmapChar ch66 = { 6, 9, -1, 0, 8, ch66data }; + +static const unsigned char ch67data[] = { + 0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c +}; +static const GLUTBitmapChar ch67 = { 7, 9, -1, 0, 9, ch67data }; + +static const unsigned char ch68data[] = { + 0xf8,0x84,0x82,0x82,0x82,0x82,0x82,0x84,0xf8 +}; +static const GLUTBitmapChar ch68 = { 7, 9, -1, 0, 9, ch68data }; + +static const unsigned char ch69data[] = { + 0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc +}; +static const GLUTBitmapChar ch69 = { 6, 9, -1, 0, 8, ch69data }; + +static const unsigned char ch70data[] = { + 0x80,0x80,0x80,0x80,0xf8,0x80,0x80,0x80,0xfc +}; +static const GLUTBitmapChar ch70 = { 6, 9, -1, 0, 8, ch70data }; + +static const unsigned char ch71data[] = { + 0x3a,0x46,0x82,0x82,0x8e,0x80,0x80,0x42,0x3c +}; +static const GLUTBitmapChar ch71 = { 7, 9, -1, 0, 9, ch71data }; + +static const unsigned char ch72data[] = { + 0x82,0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x82 +}; +static const GLUTBitmapChar ch72 = { 7, 9, -1, 0, 9, ch72data }; + +static const unsigned char ch73data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch73 = { 1, 9, -1, 0, 3, ch73data }; + +static const unsigned char ch74data[] = { + 0x70,0x88,0x88,0x8,0x8,0x8,0x8,0x8,0x8 +}; +static const GLUTBitmapChar ch74 = { 5, 9, -1, 0, 7, ch74data }; + +static const unsigned char ch75data[] = { + 0x82,0x84,0x88,0x90,0xe0,0xa0,0x90,0x88,0x84 +}; +static const GLUTBitmapChar ch75 = { 7, 9, -1, 0, 8, ch75data }; + +static const unsigned char ch76data[] = { + 0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch76 = { 5, 9, -1, 0, 7, ch76data }; + +static const unsigned char ch77data[] = { + 0x88,0x80,0x88,0x80,0x94,0x80,0x94,0x80,0xa2,0x80,0xa2,0x80,0xc1,0x80,0xc1,0x80, + 0x80,0x80 +}; +static const GLUTBitmapChar ch77 = { 9, 9, -1, 0, 11, ch77data }; + +static const unsigned char ch78data[] = { + 0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82 +}; +static const GLUTBitmapChar ch78 = { 7, 9, -1, 0, 9, ch78data }; + +static const unsigned char ch79data[] = { + 0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c +}; +static const GLUTBitmapChar ch79 = { 8, 9, -1, 0, 10, ch79data }; + +static const unsigned char ch80data[] = { + 0x80,0x80,0x80,0x80,0xf8,0x84,0x84,0x84,0xf8 +}; +static const GLUTBitmapChar ch80 = { 6, 9, -1, 0, 8, ch80data }; + +static const unsigned char ch81data[] = { + 0x3d,0x42,0x85,0x89,0x81,0x81,0x81,0x42,0x3c +}; +static const GLUTBitmapChar ch81 = { 8, 9, -1, 0, 10, ch81data }; + +static const unsigned char ch82data[] = { + 0x84,0x84,0x84,0x88,0xf8,0x84,0x84,0x84,0xf8 +}; +static const GLUTBitmapChar ch82 = { 6, 9, -1, 0, 8, ch82data }; + +static const unsigned char ch83data[] = { + 0x78,0x84,0x84,0x4,0x18,0x60,0x80,0x84,0x78 +}; +static const GLUTBitmapChar ch83 = { 6, 9, -1, 0, 8, ch83data }; + +static const unsigned char ch84data[] = { + 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xfe +}; +static const GLUTBitmapChar ch84 = { 7, 9, 0, 0, 7, ch84data }; + +static const unsigned char ch85data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84 +}; +static const GLUTBitmapChar ch85 = { 6, 9, -1, 0, 8, ch85data }; + +static const unsigned char ch86data[] = { + 0x10,0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82 +}; +static const GLUTBitmapChar ch86 = { 7, 9, -1, 0, 9, ch86data }; + +static const unsigned char ch87data[] = { + 0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0x49,0x0,0x88,0x80,0x88,0x80, + 0x88,0x80 +}; +static const GLUTBitmapChar ch87 = { 9, 9, -1, 0, 11, ch87data }; + +static const unsigned char ch88data[] = { + 0x82,0x44,0x44,0x28,0x10,0x28,0x44,0x44,0x82 +}; +static const GLUTBitmapChar ch88 = { 7, 9, -1, 0, 9, ch88data }; + +static const unsigned char ch89data[] = { + 0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82 +}; +static const GLUTBitmapChar ch89 = { 7, 9, -1, 0, 9, ch89data }; + +static const unsigned char ch90data[] = { + 0xfe,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0xfe +}; +static const GLUTBitmapChar ch90 = { 7, 9, -1, 0, 9, ch90data }; + +static const unsigned char ch91data[] = { + 0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0 +}; +static const GLUTBitmapChar ch91 = { 2, 12, -1, 3, 3, ch91data }; + +static const unsigned char ch92data[] = { + 0x10,0x10,0x20,0x20,0x20,0x40,0x40,0x80,0x80 +}; +static const GLUTBitmapChar ch92 = { 4, 9, 0, 0, 4, ch92data }; + +static const unsigned char ch93data[] = { + 0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0 +}; +static const GLUTBitmapChar ch93 = { 2, 12, 0, 3, 3, ch93data }; + +static const unsigned char ch94data[] = { + 0x88,0x50,0x20 +}; +static const GLUTBitmapChar ch94 = { 5, 3, 0, -5, 6, ch94data }; + +static const unsigned char ch95data[] = { + 0xfe +}; +static const GLUTBitmapChar ch95 = { 7, 1, 0, 2, 7, ch95data }; + +static const unsigned char ch96data[] = { + 0xc0,0x80,0x40 +}; +static const GLUTBitmapChar ch96 = { 2, 3, 0, -6, 3, ch96data }; + +static const unsigned char ch97data[] = { + 0x74,0x88,0x88,0x78,0x8,0x88,0x70 +}; +static const GLUTBitmapChar ch97 = { 6, 7, -1, 0, 7, ch97data }; + +static const unsigned char ch98data[] = { + 0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80 +}; +static const GLUTBitmapChar ch98 = { 5, 9, -1, 0, 7, ch98data }; + +static const unsigned char ch99data[] = { + 0x70,0x88,0x80,0x80,0x80,0x88,0x70 +}; +static const GLUTBitmapChar ch99 = { 5, 7, -1, 0, 7, ch99data }; + +static const unsigned char ch100data[] = { + 0x68,0x98,0x88,0x88,0x88,0x98,0x68,0x8,0x8 +}; +static const GLUTBitmapChar ch100 = { 5, 9, -1, 0, 7, ch100data }; + +static const unsigned char ch101data[] = { + 0x70,0x88,0x80,0xf8,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch101 = { 5, 7, -1, 0, 7, ch101data }; + +static const unsigned char ch102data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30 +}; +static const GLUTBitmapChar ch102 = { 4, 9, 0, 0, 3, ch102data }; + +static const unsigned char ch103data[] = { + 0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68 +}; +static const GLUTBitmapChar ch103 = { 5, 10, -1, 3, 7, ch103data }; + +static const unsigned char ch104data[] = { + 0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80 +}; +static const GLUTBitmapChar ch104 = { 5, 9, -1, 0, 7, ch104data }; + +static const unsigned char ch105data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80 +}; +static const GLUTBitmapChar ch105 = { 1, 9, -1, 0, 3, ch105data }; + +static const unsigned char ch106data[] = { + 0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40 +}; +static const GLUTBitmapChar ch106 = { 2, 12, 0, 3, 3, ch106data }; + +static const unsigned char ch107data[] = { + 0x88,0x90,0xa0,0xc0,0xc0,0xa0,0x90,0x80,0x80 +}; +static const GLUTBitmapChar ch107 = { 5, 9, -1, 0, 6, ch107data }; + +static const unsigned char ch108data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch108 = { 1, 9, -1, 0, 3, ch108data }; + +static const unsigned char ch109data[] = { + 0x92,0x92,0x92,0x92,0x92,0xda,0xa4 +}; +static const GLUTBitmapChar ch109 = { 7, 7, -1, 0, 9, ch109data }; + +static const unsigned char ch110data[] = { + 0x88,0x88,0x88,0x88,0x88,0xc8,0xb0 +}; +static const GLUTBitmapChar ch110 = { 5, 7, -1, 0, 7, ch110data }; + +static const unsigned char ch111data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch111 = { 5, 7, -1, 0, 7, ch111data }; + +static const unsigned char ch112data[] = { + 0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0 +}; +static const GLUTBitmapChar ch112 = { 5, 10, -1, 3, 7, ch112data }; + +static const unsigned char ch113data[] = { + 0x8,0x8,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68 +}; +static const GLUTBitmapChar ch113 = { 5, 10, -1, 3, 7, ch113data }; + +static const unsigned char ch114data[] = { + 0x80,0x80,0x80,0x80,0x80,0xc0,0xa0 +}; +static const GLUTBitmapChar ch114 = { 3, 7, -1, 0, 4, ch114data }; + +static const unsigned char ch115data[] = { + 0x60,0x90,0x10,0x60,0x80,0x90,0x60 +}; +static const GLUTBitmapChar ch115 = { 4, 7, -1, 0, 6, ch115data }; + +static const unsigned char ch116data[] = { + 0x60,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x40 +}; +static const GLUTBitmapChar ch116 = { 3, 9, 0, 0, 3, ch116data }; + +static const unsigned char ch117data[] = { + 0x68,0x98,0x88,0x88,0x88,0x88,0x88 +}; +static const GLUTBitmapChar ch117 = { 5, 7, -1, 0, 7, ch117data }; + +static const unsigned char ch118data[] = { + 0x20,0x20,0x50,0x50,0x88,0x88,0x88 +}; +static const GLUTBitmapChar ch118 = { 5, 7, -1, 0, 7, ch118data }; + +static const unsigned char ch119data[] = { + 0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80 +}; +static const GLUTBitmapChar ch119 = { 9, 7, 0, 0, 9, ch119data }; + +static const unsigned char ch120data[] = { + 0x84,0x84,0x48,0x30,0x30,0x48,0x84 +}; +static const GLUTBitmapChar ch120 = { 6, 7, 0, 0, 6, ch120data }; + +static const unsigned char ch121data[] = { + 0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88 +}; +static const GLUTBitmapChar ch121 = { 5, 10, -1, 3, 7, ch121data }; + +static const unsigned char ch122data[] = { + 0xf0,0x80,0x40,0x40,0x20,0x10,0xf0 +}; +static const GLUTBitmapChar ch122 = { 4, 7, -1, 0, 6, ch122data }; + +static const unsigned char ch123data[] = { + 0x30,0x40,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x40,0x30 +}; +static const GLUTBitmapChar ch123 = { 4, 12, 0, 3, 4, ch123data }; + +static const unsigned char ch124data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch124 = { 1, 12, -1, 3, 3, ch124data }; + +static const unsigned char ch125data[] = { + 0xc0,0x20,0x20,0x20,0x20,0x20,0x10,0x20,0x20,0x20,0x20,0xc0 +}; +static const GLUTBitmapChar ch125 = { 4, 12, 0, 3, 4, ch125data }; + +static const unsigned char ch126data[] = { + 0x98,0x64 +}; +static const GLUTBitmapChar ch126 = { 6, 2, 0, -3, 7, ch126data }; + +static const unsigned char ch160data[] = { + 0x0 +}; +static const GLUTBitmapChar ch160 = { 1, 1, 0, 0, 4, ch160data }; + +static const unsigned char ch161data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80 +}; +static const GLUTBitmapChar ch161 = { 1, 10, -1, 3, 3, ch161data }; + +static const unsigned char ch162data[] = { + 0x40,0x70,0xc8,0xa0,0xa0,0xa0,0xa8,0x70,0x10 +}; +static const GLUTBitmapChar ch162 = { 5, 9, -1, 1, 7, ch162data }; + +static const unsigned char ch163data[] = { + 0xb0,0x48,0x20,0x20,0xf0,0x40,0x40,0x48,0x30 +}; +static const GLUTBitmapChar ch163 = { 5, 9, -1, 0, 7, ch163data }; + +static const unsigned char ch164data[] = { + 0x84,0x78,0x48,0x48,0x78,0x84 +}; +static const GLUTBitmapChar ch164 = { 6, 6, 0, -1, 7, ch164data }; + +static const unsigned char ch165data[] = { + 0x20,0x20,0xf8,0x20,0xf8,0x20,0x50,0x88,0x88 +}; +static const GLUTBitmapChar ch165 = { 5, 9, -1, 0, 7, ch165data }; + +static const unsigned char ch166data[] = { + 0x80,0x80,0x80,0x80,0x0,0x0,0x0,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch166 = { 1, 11, -1, 2, 3, ch166data }; + +static const unsigned char ch167data[] = { + 0x70,0x88,0x8,0x30,0x48,0x88,0x88,0x90,0x60,0x80,0x88,0x70 +}; +static const GLUTBitmapChar ch167 = { 5, 12, 0, 3, 6, ch167data }; + +static const unsigned char ch168data[] = { + 0xa0 +}; +static const GLUTBitmapChar ch168 = { 3, 1, 0, -8, 3, ch168data }; + +static const unsigned char ch169data[] = { + 0x3e,0x0,0x41,0x0,0x9c,0x80,0xa2,0x80,0xa0,0x80,0xa2,0x80,0x9c,0x80,0x41,0x0, + 0x3e,0x0 +}; +static const GLUTBitmapChar ch169 = { 9, 9, -1, 0, 11, ch169data }; + +static const unsigned char ch170data[] = { + 0xe0,0x0,0xa0,0x20,0xe0 +}; +static const GLUTBitmapChar ch170 = { 3, 5, -1, -4, 5, ch170data }; + +static const unsigned char ch171data[] = { + 0x28,0x50,0xa0,0x50,0x28 +}; +static const GLUTBitmapChar ch171 = { 5, 5, -1, -1, 7, ch171data }; + +static const unsigned char ch172data[] = { + 0x4,0x4,0x4,0xfc +}; +static const GLUTBitmapChar ch172 = { 6, 4, -1, -2, 8, ch172data }; + +static const unsigned char ch173data[] = { + 0xf0 +}; +static const GLUTBitmapChar ch173 = { 4, 1, 0, -3, 5, ch173data }; + +static const unsigned char ch174data[] = { + 0x3e,0x0,0x41,0x0,0x94,0x80,0x94,0x80,0x98,0x80,0x94,0x80,0x9c,0x80,0x41,0x0, + 0x3e,0x0 +}; +static const GLUTBitmapChar ch174 = { 9, 9, -1, 0, 11, ch174data }; + +static const unsigned char ch175data[] = { + 0xf0 +}; +static const GLUTBitmapChar ch175 = { 4, 1, 0, -8, 4, ch175data }; + +static const unsigned char ch176data[] = { + 0x60,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch176 = { 4, 4, 0, -4, 5, ch176data }; + +static const unsigned char ch177data[] = { + 0xf8,0x0,0x20,0x20,0xf8,0x20,0x20 +}; +static const GLUTBitmapChar ch177 = { 5, 7, -1, 0, 7, ch177data }; + +static const unsigned char ch178data[] = { + 0xf0,0x40,0x20,0x90,0x60 +}; +static const GLUTBitmapChar ch178 = { 4, 5, 0, -3, 4, ch178data }; + +static const unsigned char ch179data[] = { + 0xc0,0x20,0x40,0x20,0xe0 +}; +static const GLUTBitmapChar ch179 = { 3, 5, 0, -3, 4, ch179data }; + +static const unsigned char ch180data[] = { + 0x80,0x40 +}; +static const GLUTBitmapChar ch180 = { 2, 2, 0, -8, 2, ch180data }; + +static const unsigned char ch181data[] = { + 0x80,0x80,0x80,0xe8,0x98,0x88,0x88,0x88,0x88,0x88 +}; +static const GLUTBitmapChar ch181 = { 5, 10, -1, 3, 7, ch181data }; + +static const unsigned char ch182data[] = { + 0x28,0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x68,0x3c +}; +static const GLUTBitmapChar ch182 = { 6, 12, 0, 3, 7, ch182data }; + +static const unsigned char ch183data[] = { + 0x80 +}; +static const GLUTBitmapChar ch183 = { 1, 1, -1, -3, 3, ch183data }; + +static const unsigned char ch184data[] = { + 0xc0,0x20,0x20,0x40 +}; +static const GLUTBitmapChar ch184 = { 3, 4, 0, 3, 3, ch184data }; + +static const unsigned char ch185data[] = { + 0x40,0x40,0x40,0xc0,0x40 +}; +static const GLUTBitmapChar ch185 = { 2, 5, -1, -3, 4, ch185data }; + +static const unsigned char ch186data[] = { + 0xe0,0x0,0xe0,0xa0,0xe0 +}; +static const GLUTBitmapChar ch186 = { 3, 5, -1, -4, 5, ch186data }; + +static const unsigned char ch187data[] = { + 0xa0,0x50,0x28,0x50,0xa0 +}; +static const GLUTBitmapChar ch187 = { 5, 5, -1, -1, 7, ch187data }; + +static const unsigned char ch188data[] = { + 0x41,0x0,0x27,0x80,0x15,0x0,0x13,0x0,0x49,0x0,0x44,0x0,0x44,0x0,0xc2,0x0, + 0x41,0x0 +}; +static const GLUTBitmapChar ch188 = { 9, 9, 0, 0, 10, ch188data }; + +static const unsigned char ch189data[] = { + 0x47,0x80,0x22,0x0,0x11,0x0,0x14,0x80,0x4b,0x0,0x48,0x0,0x44,0x0,0xc2,0x0, + 0x41,0x0 +}; +static const GLUTBitmapChar ch189 = { 9, 9, 0, 0, 10, ch189data }; + +static const unsigned char ch190data[] = { + 0x21,0x0,0x17,0x80,0x15,0x0,0xb,0x0,0xc9,0x0,0x24,0x0,0x44,0x0,0x22,0x0, + 0xe1,0x0 +}; +static const GLUTBitmapChar ch190 = { 9, 9, 0, 0, 10, ch190data }; + +static const unsigned char ch191data[] = { + 0x70,0x88,0x88,0x40,0x40,0x20,0x20,0x0,0x20 +}; +static const GLUTBitmapChar ch191 = { 5, 9, -1, 3, 7, ch191data }; + +static const unsigned char ch192data[] = { + 0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch192 = { 7, 12, -1, 0, 9, ch192data }; + +static const unsigned char ch193data[] = { + 0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch193 = { 7, 12, -1, 0, 9, ch193data }; + +static const unsigned char ch194data[] = { + 0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch194 = { 7, 12, -1, 0, 9, ch194data }; + +static const unsigned char ch195data[] = { + 0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x14 +}; +static const GLUTBitmapChar ch195 = { 7, 12, -1, 0, 9, ch195data }; + +static const unsigned char ch196data[] = { + 0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28 +}; +static const GLUTBitmapChar ch196 = { 7, 11, -1, 0, 9, ch196data }; + +static const unsigned char ch197data[] = { + 0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x10,0x28,0x10 +}; +static const GLUTBitmapChar ch197 = { 7, 12, -1, 0, 9, ch197data }; + +static const unsigned char ch198data[] = { + 0x8f,0x80,0x88,0x0,0x88,0x0,0x78,0x0,0x4f,0x80,0x48,0x0,0x28,0x0,0x28,0x0, + 0x1f,0x80 +}; +static const GLUTBitmapChar ch198 = { 9, 9, -1, 0, 11, ch198data }; + +static const unsigned char ch199data[] = { + 0x30,0x8,0x8,0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c +}; +static const GLUTBitmapChar ch199 = { 7, 12, -1, 3, 9, ch199data }; + +static const unsigned char ch200data[] = { + 0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch200 = { 6, 12, -1, 0, 8, ch200data }; + +static const unsigned char ch201data[] = { + 0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch201 = { 6, 12, -1, 0, 8, ch201data }; + +static const unsigned char ch202data[] = { + 0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch202 = { 6, 12, -1, 0, 8, ch202data }; + +static const unsigned char ch203data[] = { + 0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28 +}; +static const GLUTBitmapChar ch203 = { 6, 11, -1, 0, 8, ch203data }; + +static const unsigned char ch204data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch204 = { 2, 12, 0, 0, 3, ch204data }; + +static const unsigned char ch205data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40 +}; +static const GLUTBitmapChar ch205 = { 2, 12, -1, 0, 3, ch205data }; + +static const unsigned char ch206data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch206 = { 3, 12, 0, 0, 3, ch206data }; + +static const unsigned char ch207data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0 +}; +static const GLUTBitmapChar ch207 = { 3, 11, 0, 0, 3, ch207data }; + +static const unsigned char ch208data[] = { + 0x7c,0x42,0x41,0x41,0xf1,0x41,0x41,0x42,0x7c +}; +static const GLUTBitmapChar ch208 = { 8, 9, 0, 0, 9, ch208data }; + +static const unsigned char ch209data[] = { + 0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82,0x0,0x28,0x14 +}; +static const GLUTBitmapChar ch209 = { 7, 12, -1, 0, 9, ch209data }; + +static const unsigned char ch210data[] = { + 0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x10 +}; +static const GLUTBitmapChar ch210 = { 8, 12, -1, 0, 10, ch210data }; + +static const unsigned char ch211data[] = { + 0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x4 +}; +static const GLUTBitmapChar ch211 = { 8, 12, -1, 0, 10, ch211data }; + +static const unsigned char ch212data[] = { + 0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x14,0x8 +}; +static const GLUTBitmapChar ch212 = { 8, 12, -1, 0, 10, ch212data }; + +static const unsigned char ch213data[] = { + 0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x28,0x14 +}; +static const GLUTBitmapChar ch213 = { 8, 12, -1, 0, 10, ch213data }; + +static const unsigned char ch214data[] = { + 0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x24 +}; +static const GLUTBitmapChar ch214 = { 8, 11, -1, 0, 10, ch214data }; + +static const unsigned char ch215data[] = { + 0x88,0x50,0x20,0x50,0x88 +}; +static const GLUTBitmapChar ch215 = { 5, 5, -1, -1, 7, ch215data }; + +static const unsigned char 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 GLUTBitmapChar ch216 = { 10, 11, 0, 1, 10, ch216data }; + +static const unsigned char ch217data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch217 = { 6, 12, -1, 0, 8, ch217data }; + +static const unsigned char ch218data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch218 = { 6, 12, -1, 0, 8, ch218data }; + +static const unsigned char ch219data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch219 = { 6, 12, -1, 0, 8, ch219data }; + +static const unsigned char ch220data[] = { + 0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48 +}; +static const GLUTBitmapChar ch220 = { 6, 11, -1, 0, 8, ch220data }; + +static const unsigned char ch221data[] = { + 0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch221 = { 7, 12, -1, 0, 9, ch221data }; + +static const unsigned char ch222data[] = { + 0x80,0x80,0xf8,0x84,0x84,0x84,0xf8,0x80,0x80 +}; +static const GLUTBitmapChar ch222 = { 6, 9, -1, 0, 8, ch222data }; + +static const unsigned char ch223data[] = { + 0xb0,0x88,0x88,0x88,0xb0,0x88,0x88,0x88,0x70 +}; +static const GLUTBitmapChar ch223 = { 5, 9, -1, 0, 7, ch223data }; + +static const unsigned char ch224data[] = { + 0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch224 = { 6, 10, -1, 0, 7, ch224data }; + +static const unsigned char ch225data[] = { + 0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch225 = { 6, 10, -1, 0, 7, ch225data }; + +static const unsigned char ch226data[] = { + 0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch226 = { 6, 10, -1, 0, 7, ch226data }; + +static const unsigned char ch227data[] = { + 0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch227 = { 6, 10, -1, 0, 7, ch227data }; + +static const unsigned char ch228data[] = { + 0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50 +}; +static const GLUTBitmapChar ch228 = { 6, 9, -1, 0, 7, ch228data }; + +static const unsigned char ch229data[] = { + 0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x30,0x48,0x30 +}; +static const GLUTBitmapChar ch229 = { 6, 10, -1, 0, 7, ch229data }; + +static const unsigned char ch230data[] = { + 0x77,0x0,0x88,0x80,0x88,0x0,0x7f,0x80,0x8,0x80,0x88,0x80,0x77,0x0 +}; +static const GLUTBitmapChar ch230 = { 9, 7, -1, 0, 11, ch230data }; + +static const unsigned char ch231data[] = { + 0x60,0x10,0x20,0x70,0x88,0x80,0x80,0x80,0x88,0x70 +}; +static const GLUTBitmapChar ch231 = { 5, 10, -1, 3, 7, ch231data }; + +static const unsigned char ch232data[] = { + 0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch232 = { 5, 10, -1, 0, 7, ch232data }; + +static const unsigned char ch233data[] = { + 0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch233 = { 5, 10, -1, 0, 7, ch233data }; + +static const unsigned char ch234data[] = { + 0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch234 = { 5, 10, -1, 0, 7, ch234data }; + +static const unsigned char ch235data[] = { + 0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50 +}; +static const GLUTBitmapChar ch235 = { 5, 9, -1, 0, 7, ch235data }; + +static const unsigned char ch236data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch236 = { 2, 10, 0, 0, 3, ch236data }; + +static const unsigned char ch237data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40 +}; +static const GLUTBitmapChar ch237 = { 2, 10, -1, 0, 3, ch237data }; + +static const unsigned char ch238data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch238 = { 3, 10, 0, 0, 3, ch238data }; + +static const unsigned char ch239data[] = { + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0 +}; +static const GLUTBitmapChar ch239 = { 3, 9, 0, 0, 3, ch239data }; + +static const unsigned char ch240data[] = { + 0x70,0x88,0x88,0x88,0x88,0x78,0x8,0x50,0x30,0x68 +}; +static const GLUTBitmapChar ch240 = { 5, 10, -1, 0, 7, ch240data }; + +static const unsigned char ch241data[] = { + 0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch241 = { 5, 10, -1, 0, 7, ch241data }; + +static const unsigned char ch242data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch242 = { 5, 10, -1, 0, 7, ch242data }; + +static const unsigned char ch243data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch243 = { 5, 10, -1, 0, 7, ch243data }; + +static const unsigned char ch244data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch244 = { 5, 10, -1, 0, 7, ch244data }; + +static const unsigned char ch245data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch245 = { 5, 10, -1, 0, 7, ch245data }; + +static const unsigned char ch246data[] = { + 0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50 +}; +static const GLUTBitmapChar ch246 = { 5, 9, -1, 0, 7, ch246data }; + +static const unsigned char ch247data[] = { + 0x20,0x0,0xf8,0x0,0x20 +}; +static const GLUTBitmapChar ch247 = { 5, 5, -1, -1, 7, ch247data }; + +static const unsigned char ch248data[] = { + 0xb8,0x44,0x64,0x54,0x4c,0x44,0x3a +}; +static const GLUTBitmapChar ch248 = { 7, 7, 0, 0, 7, ch248data }; + +static const unsigned char ch249data[] = { + 0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch249 = { 5, 10, -1, 0, 7, ch249data }; + +static const unsigned char ch250data[] = { + 0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch250 = { 5, 10, -1, 0, 7, ch250data }; + +static const unsigned char ch251data[] = { + 0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch251 = { 5, 10, -1, 0, 7, ch251data }; + +static const unsigned char ch252data[] = { + 0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50 +}; +static const GLUTBitmapChar ch252 = { 5, 9, -1, 0, 7, ch252data }; + +static const unsigned char ch253data[] = { + 0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch253 = { 5, 13, -1, 3, 7, ch253data }; + +static const unsigned char ch254data[] = { + 0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80 +}; +static const GLUTBitmapChar ch254 = { 5, 12, -1, 3, 7, ch254data }; + +static const unsigned char ch255data[] = { + 0xc0,0x20,0x20,0x20,0x30,0x50,0x50,0x48,0x88,0x88,0x0,0x50 +}; +static const GLUTBitmapChar ch255 = { 5, 12, -1, 3, 7, ch255data }; + + +static const GLUTBitmapChar *chars[] = { + 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, + &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 GLUTBitmapFont glutBitmapHelvetica12 = { + "-Adobe-Helvetica-Medium-R-Normal--12-120-75-75-P-67-ISO8859-1", + 15, 256, chars +}; diff --git a/src/glut/dos/hel18.c b/src/glut/dos/hel18.c new file mode 100644 index 000000000..f4d4340e3 --- /dev/null +++ b/src/glut/dos/hel18.c @@ -0,0 +1,1138 @@ +/* autogenerated by bdf2c! do not edit */ + +/* "Copyright (c) 1984, 1987 Adobe Systems Incorporated. All Rights Reserved. Copyright (c) 1988, 1991 Digital Equipment Corporation. All Rights Reserved." */ + + +#include "internal.h" +/* +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; +*/ + + +static const unsigned char ch32data[] = { + 0x0 +}; +static const GLUTBitmapChar ch32 = { 1, 1, 0, 0, 5, ch32data }; + +static const unsigned char ch33data[] = { + 0xc0,0xc0,0x0,0x0,0x80,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch33 = { 2, 14, -2, 0, 6, ch33data }; + +static const unsigned char ch34data[] = { + 0x90,0x90,0xd8,0xd8,0xd8 +}; +static const GLUTBitmapChar ch34 = { 5, 5, 0, -9, 5, ch34data }; + +static const unsigned char 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 GLUTBitmapChar ch35 = { 10, 13, 0, 0, 10, ch35data }; + +static const unsigned char 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 GLUTBitmapChar ch36 = { 9, 16, -1, 2, 10, ch36data }; + +static const unsigned char 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 GLUTBitmapChar ch37 = { 14, 13, -1, 0, 16, ch37data }; + +static const unsigned char 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 GLUTBitmapChar ch38 = { 12, 13, -1, 0, 13, ch38data }; + +static const unsigned char ch39data[] = { + 0x80,0x40,0x40,0xc0,0xc0 +}; +static const GLUTBitmapChar ch39 = { 2, 5, -1, -9, 4, ch39data }; + +static const unsigned char ch40data[] = { + 0x10,0x30,0x60,0x60,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x60,0x60, + 0x30,0x10 +}; +static const GLUTBitmapChar ch40 = { 4, 18, -1, 4, 6, ch40data }; + +static const unsigned char ch41data[] = { + 0x80,0xc0,0x60,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0x60, + 0xc0,0x80 +}; +static const GLUTBitmapChar ch41 = { 4, 18, -1, 4, 6, ch41data }; + +static const unsigned char ch42data[] = { + 0x88,0x70,0x70,0xf8,0x20,0x20 +}; +static const GLUTBitmapChar ch42 = { 5, 6, -1, -8, 7, ch42data }; + +static const unsigned char ch43data[] = { + 0x18,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18,0x18 +}; +static const GLUTBitmapChar ch43 = { 8, 10, -1, 0, 10, ch43data }; + +static const unsigned char ch44data[] = { + 0x80,0x40,0x40,0xc0,0xc0 +}; +static const GLUTBitmapChar ch44 = { 2, 5, -1, 3, 5, ch44data }; + +static const unsigned char ch45data[] = { + 0xff,0xff +}; +static const GLUTBitmapChar ch45 = { 8, 2, -1, -4, 11, ch45data }; + +static const unsigned char ch46data[] = { + 0xc0,0xc0 +}; +static const GLUTBitmapChar ch46 = { 2, 2, -1, 0, 5, ch46data }; + +static const unsigned char ch47data[] = { + 0xc0,0xc0,0x40,0x40,0x60,0x60,0x20,0x20,0x30,0x30,0x10,0x10,0x18,0x18 +}; +static const GLUTBitmapChar ch47 = { 5, 14, 0, 0, 5, ch47data }; + +static const unsigned char ch48data[] = { + 0x3c,0x7e,0x66,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x66,0x7e,0x3c +}; +static const GLUTBitmapChar ch48 = { 8, 13, -1, 0, 10, ch48data }; + +static const unsigned char ch49data[] = { + 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xf8,0xf8,0x18 +}; +static const GLUTBitmapChar ch49 = { 5, 13, -2, 0, 10, ch49data }; + +static const unsigned char ch50data[] = { + 0xff,0xff,0xc0,0xe0,0x70,0x38,0x1c,0xe,0x7,0x3,0xc3,0xfe,0x3c +}; +static const GLUTBitmapChar ch50 = { 8, 13, -1, 0, 10, ch50data }; + +static const unsigned char ch51data[] = { + 0x3c,0x7e,0xc7,0xc3,0x3,0x7,0x1e,0x1c,0x6,0xc3,0xc3,0x7e,0x3c +}; +static const GLUTBitmapChar ch51 = { 8, 13, -1, 0, 10, ch51data }; + +static const unsigned char 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 GLUTBitmapChar ch52 = { 9, 13, -1, 0, 10, ch52data }; + +static const unsigned char ch53data[] = { + 0x7c,0xfe,0xc7,0xc3,0x3,0x3,0xc7,0xfe,0xfc,0xc0,0xc0,0xfe,0xfe +}; +static const GLUTBitmapChar ch53 = { 8, 13, -1, 0, 10, ch53data }; + +static const unsigned char ch54data[] = { + 0x3c,0x7e,0xe3,0xc3,0xc3,0xc3,0xfe,0xdc,0xc0,0xc0,0x63,0x7f,0x3c +}; +static const GLUTBitmapChar ch54 = { 8, 13, -1, 0, 10, ch54data }; + +static const unsigned char ch55data[] = { + 0x60,0x60,0x30,0x30,0x30,0x18,0x18,0xc,0xc,0x6,0x3,0xff,0xff +}; +static const GLUTBitmapChar ch55 = { 8, 13, -1, 0, 10, ch55data }; + +static const unsigned char ch56data[] = { + 0x3c,0x7e,0xe7,0xc3,0xc3,0x66,0x7e,0x66,0xc3,0xc3,0xe7,0x7e,0x3c +}; +static const GLUTBitmapChar ch56 = { 8, 13, -1, 0, 10, ch56data }; + +static const unsigned char ch57data[] = { + 0x7c,0xfe,0xc6,0x3,0x3,0x3b,0x7f,0xc3,0xc3,0xc3,0xc7,0x7e,0x3c +}; +static const GLUTBitmapChar ch57 = { 8, 13, -1, 0, 10, ch57data }; + +static const unsigned char ch58data[] = { + 0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch58 = { 2, 10, -1, 0, 5, ch58data }; + +static const unsigned char ch59data[] = { + 0x80,0x40,0x40,0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch59 = { 2, 13, -1, 3, 5, ch59data }; + +static const unsigned char ch60data[] = { + 0x3,0xf,0x3c,0x70,0xc0,0x70,0x3c,0xf,0x3 +}; +static const GLUTBitmapChar ch60 = { 8, 9, -1, 0, 10, ch60data }; + +static const unsigned char ch61data[] = { + 0xfe,0xfe,0x0,0x0,0xfe,0xfe +}; +static const GLUTBitmapChar ch61 = { 7, 6, -2, -2, 11, ch61data }; + +static const unsigned char ch62data[] = { + 0xc0,0xf0,0x3c,0xe,0x3,0xe,0x3c,0xf0,0xc0 +}; +static const GLUTBitmapChar ch62 = { 8, 9, -1, 0, 10, ch62data }; + +static const unsigned char ch63data[] = { + 0x30,0x30,0x0,0x0,0x30,0x30,0x30,0x38,0x1c,0xe,0xc6,0xc6,0xfe,0x7c +}; +static const GLUTBitmapChar ch63 = { 7, 14, -1, 0, 10, ch63data }; + +static const unsigned char 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 GLUTBitmapChar ch64 = { 16, 17, -1, 3, 18, ch64data }; + +static const unsigned char 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 GLUTBitmapChar ch65 = { 12, 14, 0, 0, 12, ch65data }; + +static const unsigned char 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 GLUTBitmapChar ch66 = { 11, 14, -1, 0, 13, ch66data }; + +static const unsigned char 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 GLUTBitmapChar ch67 = { 12, 14, -1, 0, 14, ch67data }; + +static const unsigned char 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 GLUTBitmapChar ch68 = { 11, 14, -1, 0, 13, ch68data }; + +static const unsigned char 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 GLUTBitmapChar ch69 = { 9, 14, -1, 0, 11, ch69data }; + +static const unsigned char 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 GLUTBitmapChar ch70 = { 9, 14, -1, 0, 11, ch70data }; + +static const unsigned char 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 GLUTBitmapChar ch71 = { 12, 14, -1, 0, 14, ch71data }; + +static const unsigned char 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 GLUTBitmapChar ch72 = { 11, 14, -1, 0, 13, ch72data }; + +static const unsigned char ch73data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch73 = { 2, 14, -2, 0, 6, ch73data }; + +static const unsigned char ch74data[] = { + 0x3c,0x7e,0xe7,0xc3,0xc3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3 +}; +static const GLUTBitmapChar ch74 = { 8, 14, -1, 0, 10, ch74data }; + +static const unsigned char 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 GLUTBitmapChar ch75 = { 12, 14, -1, 0, 13, ch75data }; + +static const unsigned char ch76data[] = { + 0xff,0xff,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch76 = { 8, 14, -1, 0, 10, ch76data }; + +static const unsigned char 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 GLUTBitmapChar ch77 = { 14, 14, -1, 0, 16, ch77data }; + +static const unsigned char 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 GLUTBitmapChar ch78 = { 11, 14, -1, 0, 13, ch78data }; + +static const unsigned char 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 GLUTBitmapChar ch79 = { 13, 14, -1, 0, 15, ch79data }; + +static const unsigned char 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 GLUTBitmapChar ch80 = { 10, 14, -1, 0, 12, ch80data }; + +static const unsigned char 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 GLUTBitmapChar ch81 = { 13, 15, -1, 1, 15, ch81data }; + +static const unsigned char 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 GLUTBitmapChar ch82 = { 10, 14, -1, 0, 12, ch82data }; + +static const unsigned char 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 GLUTBitmapChar ch83 = { 11, 14, -1, 0, 13, ch83data }; + +static const unsigned char 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 GLUTBitmapChar ch84 = { 10, 14, -1, 0, 12, ch84data }; + +static const unsigned char 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 GLUTBitmapChar ch85 = { 11, 14, -1, 0, 13, ch85data }; + +static const unsigned char 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 GLUTBitmapChar ch86 = { 12, 14, -1, 0, 14, ch86data }; + +static const unsigned char 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 GLUTBitmapChar ch87 = { 16, 14, -1, 0, 18, ch87data }; + +static const unsigned char 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 GLUTBitmapChar ch88 = { 11, 14, -1, 0, 13, ch88data }; + +static const unsigned char 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 GLUTBitmapChar ch89 = { 12, 14, -1, 0, 14, ch89data }; + +static const unsigned char 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 GLUTBitmapChar ch90 = { 10, 14, -1, 0, 12, ch90data }; + +static const unsigned char ch91data[] = { + 0xf0,0xf0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, + 0xf0,0xf0 +}; +static const GLUTBitmapChar ch91 = { 4, 18, -1, 4, 5, ch91data }; + +static const unsigned char ch92data[] = { + 0x18,0x18,0x10,0x10,0x30,0x30,0x20,0x20,0x60,0x60,0x40,0x40,0xc0,0xc0 +}; +static const GLUTBitmapChar ch92 = { 5, 14, 0, 0, 5, ch92data }; + +static const unsigned char ch93data[] = { + 0xf0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30, + 0xf0,0xf0 +}; +static const GLUTBitmapChar ch93 = { 4, 18, 0, 4, 5, ch93data }; + +static const unsigned char ch94data[] = { + 0x82,0xc6,0x6c,0x38,0x10 +}; +static const GLUTBitmapChar ch94 = { 7, 5, -1, -8, 9, ch94data }; + +static const unsigned char ch95data[] = { + 0xff,0xc0,0xff,0xc0 +}; +static const GLUTBitmapChar ch95 = { 10, 2, 0, 4, 10, ch95data }; + +static const unsigned char ch96data[] = { + 0xc0,0xc0,0x80,0x80,0x40 +}; +static const GLUTBitmapChar ch96 = { 2, 5, -1, -9, 4, ch96data }; + +static const unsigned char ch97data[] = { + 0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c +}; +static const GLUTBitmapChar ch97 = { 7, 10, -1, 0, 9, ch97data }; + +static const unsigned char 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 GLUTBitmapChar ch98 = { 9, 14, -1, 0, 11, ch98data }; + +static const unsigned char ch99data[] = { + 0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e +}; +static const GLUTBitmapChar ch99 = { 8, 10, -1, 0, 10, ch99data }; + +static const unsigned char 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 GLUTBitmapChar ch100 = { 9, 14, -1, 0, 11, ch100data }; + +static const unsigned char ch101data[] = { + 0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c +}; +static const GLUTBitmapChar ch101 = { 8, 10, -1, 0, 10, ch101data }; + +static const unsigned char ch102data[] = { + 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x3c,0x1c +}; +static const GLUTBitmapChar ch102 = { 6, 14, 0, 0, 6, ch102data }; + +static const unsigned char 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 GLUTBitmapChar ch103 = { 9, 14, -1, 4, 11, ch103data }; + +static const unsigned char ch104data[] = { + 0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0xc0,0xc0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch104 = { 8, 14, -1, 0, 10, ch104data }; + +static const unsigned char ch105data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch105 = { 2, 14, -1, 0, 4, ch105data }; + +static const unsigned char ch106data[] = { + 0xe0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x0, + 0x30,0x30 +}; +static const GLUTBitmapChar ch106 = { 4, 18, 1, 4, 4, ch106data }; + +static const unsigned char ch107data[] = { + 0xc7,0xc6,0xce,0xcc,0xd8,0xf8,0xf0,0xd8,0xcc,0xc6,0xc0,0xc0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch107 = { 8, 14, -1, 0, 9, ch107data }; + +static const unsigned char ch108data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch108 = { 2, 14, -1, 0, 4, ch108data }; + +static const unsigned char ch109data[] = { + 0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xe7,0x30, + 0xde,0xf0,0xcc,0x60 +}; +static const GLUTBitmapChar ch109 = { 12, 10, -1, 0, 14, ch109data }; + +static const unsigned char ch110data[] = { + 0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce +}; +static const GLUTBitmapChar ch110 = { 8, 10, -1, 0, 10, ch110data }; + +static const unsigned char ch111data[] = { + 0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0, + 0x7f,0x0,0x3e,0x0 +}; +static const GLUTBitmapChar ch111 = { 9, 10, -1, 0, 11, ch111data }; + +static const unsigned char 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 GLUTBitmapChar ch112 = { 9, 14, -1, 4, 11, ch112data }; + +static const unsigned char 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 GLUTBitmapChar ch113 = { 9, 14, -1, 4, 11, ch113data }; + +static const unsigned char ch114data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xe0,0xd8,0xd8 +}; +static const GLUTBitmapChar ch114 = { 5, 10, -1, 0, 6, ch114data }; + +static const unsigned char ch115data[] = { + 0x78,0xfc,0xc6,0x6,0x3e,0xfc,0xc0,0xc6,0x7e,0x3c +}; +static const GLUTBitmapChar ch115 = { 7, 10, -1, 0, 9, ch115data }; + +static const unsigned char ch116data[] = { + 0x18,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x30 +}; +static const GLUTBitmapChar ch116 = { 6, 13, 0, 0, 6, ch116data }; + +static const unsigned char ch117data[] = { + 0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3 +}; +static const GLUTBitmapChar ch117 = { 8, 10, -1, 0, 10, ch117data }; + +static const unsigned char ch118data[] = { + 0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3 +}; +static const GLUTBitmapChar ch118 = { 8, 10, -1, 0, 10, ch118data }; + +static const unsigned char ch119data[] = { + 0x19,0x80,0x19,0x80,0x39,0xc0,0x29,0x40,0x69,0x60,0x66,0x60,0x66,0x60,0xc6,0x30, + 0xc6,0x30,0xc6,0x30 +}; +static const GLUTBitmapChar ch119 = { 12, 10, -1, 0, 14, ch119data }; + +static const unsigned char ch120data[] = { + 0xc3,0xe7,0x66,0x3c,0x18,0x18,0x3c,0x66,0xe7,0xc3 +}; +static const GLUTBitmapChar ch120 = { 8, 10, -1, 0, 10, ch120data }; + +static const unsigned char ch121data[] = { + 0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3 +}; +static const GLUTBitmapChar ch121 = { 8, 14, -1, 4, 10, ch121data }; + +static const unsigned char ch122data[] = { + 0xfe,0xfe,0xc0,0x60,0x30,0x18,0xc,0x6,0xfe,0xfe +}; +static const GLUTBitmapChar ch122 = { 7, 10, -1, 0, 9, ch122data }; + +static const unsigned char ch123data[] = { + 0xc,0x18,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0xc0,0x60,0x30,0x30,0x30,0x30,0x30, + 0x18,0xc +}; +static const GLUTBitmapChar ch123 = { 6, 18, 0, 4, 6, ch123data }; + +static const unsigned char ch124data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, + 0xc0,0xc0 +}; +static const GLUTBitmapChar ch124 = { 2, 18, -1, 4, 4, ch124data }; + +static const unsigned char ch125data[] = { + 0xc0,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x18,0xc,0x18,0x30,0x30,0x30,0x30,0x30, + 0x60,0xc0 +}; +static const GLUTBitmapChar ch125 = { 6, 18, 0, 4, 6, ch125data }; + +static const unsigned char ch126data[] = { + 0xcc,0x7e,0x33 +}; +static const GLUTBitmapChar ch126 = { 8, 3, -1, -4, 10, ch126data }; + +static const unsigned char ch160data[] = { + 0x0 +}; +static const GLUTBitmapChar ch160 = { 1, 1, 0, 0, 5, ch160data }; + +static const unsigned char ch161data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x40,0x40,0x0,0x0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch161 = { 2, 14, -2, 4, 6, ch161data }; + +static const unsigned char ch162data[] = { + 0x10,0x10,0x3e,0x7f,0x6b,0xc8,0xc8,0xc8,0xc8,0x6b,0x7f,0x3e,0x4,0x4 +}; +static const GLUTBitmapChar ch162 = { 8, 14, -1, 2, 10, ch162data }; + +static const unsigned char 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 GLUTBitmapChar ch163 = { 9, 13, 0, 0, 10, ch163data }; + +static const unsigned char ch164data[] = { + 0xc3,0xff,0x66,0x66,0x66,0xff,0xc3 +}; +static const GLUTBitmapChar ch164 = { 8, 7, -1, -3, 10, ch164data }; + +static const unsigned char ch165data[] = { + 0x18,0x18,0x18,0x18,0xff,0x18,0xff,0x3c,0x66,0x66,0x66,0xc3,0xc3 +}; +static const GLUTBitmapChar ch165 = { 8, 13, -1, 0, 10, ch165data }; + +static const unsigned char ch166data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, + 0xc0 +}; +static const GLUTBitmapChar ch166 = { 2, 17, -1, 3, 4, ch166data }; + +static const unsigned char ch167data[] = { + 0x3c,0x7e,0xc3,0xc3,0x7,0xe,0x3e,0x73,0xe3,0xc3,0xc7,0x6e,0x7c,0xf0,0xc3,0xc3, + 0x7e,0x3c +}; +static const GLUTBitmapChar ch167 = { 8, 18, -1, 4, 10, ch167data }; + +static const unsigned char ch168data[] = { + 0xd8,0xd8 +}; +static const GLUTBitmapChar ch168 = { 5, 2, 0, -11, 6, ch168data }; + +static const unsigned char 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 GLUTBitmapChar ch169 = { 13, 13, -1, 0, 15, ch169data }; + +static const unsigned char ch170data[] = { + 0xf8,0x0,0x68,0xd8,0x48,0x38,0xc8,0x70 +}; +static const GLUTBitmapChar ch170 = { 5, 8, -1, -6, 7, ch170data }; + +static const unsigned char ch171data[] = { + 0x12,0x36,0x6c,0xd8,0xd8,0x6c,0x36,0x12 +}; +static const GLUTBitmapChar ch171 = { 7, 8, -1, -1, 9, ch171data }; + +static const unsigned char ch172data[] = { + 0x1,0x80,0x1,0x80,0x1,0x80,0xff,0x80,0xff,0x80 +}; +static const GLUTBitmapChar ch172 = { 9, 5, -1, -3, 11, ch172data }; + +static const unsigned char ch173data[] = { + 0xf8,0xf8 +}; +static const GLUTBitmapChar ch173 = { 5, 2, -1, -4, 7, ch173data }; + +static const unsigned char 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 GLUTBitmapChar ch174 = { 13, 13, -1, 0, 14, ch174data }; + +static const unsigned char ch175data[] = { + 0xf8 +}; +static const GLUTBitmapChar ch175 = { 5, 1, 0, -12, 5, ch175data }; + +static const unsigned char ch176data[] = { + 0x70,0xd8,0x88,0xd8,0x70 +}; +static const GLUTBitmapChar ch176 = { 5, 5, -1, -8, 7, ch176data }; + +static const unsigned char ch177data[] = { + 0xff,0xff,0x0,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18 +}; +static const GLUTBitmapChar ch177 = { 8, 11, -1, 0, 10, ch177data }; + +static const unsigned char ch178data[] = { + 0xf8,0xf8,0x60,0x30,0x18,0x98,0xf8,0x70 +}; +static const GLUTBitmapChar ch178 = { 5, 8, 0, -5, 6, ch178data }; + +static const unsigned char ch179data[] = { + 0x70,0xf8,0x98,0x30,0x30,0x98,0xf8,0x70 +}; +static const GLUTBitmapChar ch179 = { 5, 8, 0, -5, 6, ch179data }; + +static const unsigned char ch180data[] = { + 0xc0,0x60,0x30 +}; +static const GLUTBitmapChar ch180 = { 4, 3, 0, -11, 4, ch180data }; + +static const unsigned char ch181data[] = { + 0xc0,0xc0,0xc0,0xc0,0xdb,0xff,0xe7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3 +}; +static const GLUTBitmapChar ch181 = { 8, 14, -1, 4, 10, ch181data }; + +static const unsigned char ch182data[] = { + 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x32,0x72,0xf2,0xf2,0xf2,0xf2, + 0x72,0x3f +}; +static const GLUTBitmapChar ch182 = { 8, 18, -1, 4, 10, ch182data }; + +static const unsigned char ch183data[] = { + 0xc0,0xc0 +}; +static const GLUTBitmapChar ch183 = { 2, 2, -1, -4, 4, ch183data }; + +static const unsigned char ch184data[] = { + 0xf0,0xd8,0x18,0x70,0x60 +}; +static const GLUTBitmapChar ch184 = { 5, 5, 0, 4, 5, ch184data }; + +static const unsigned char ch185data[] = { + 0x60,0x60,0x60,0x60,0x60,0xe0,0xe0,0x60 +}; +static const GLUTBitmapChar ch185 = { 3, 8, -1, -5, 6, ch185data }; + +static const unsigned char ch186data[] = { + 0xf8,0x0,0x70,0xd8,0x88,0x88,0xd8,0x70 +}; +static const GLUTBitmapChar ch186 = { 5, 8, -1, -6, 7, ch186data }; + +static const unsigned char ch187data[] = { + 0x90,0xd8,0x6c,0x36,0x36,0x6c,0xd8,0x90 +}; +static const GLUTBitmapChar ch187 = { 7, 8, -1, -1, 9, ch187data }; + +static const unsigned char 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 GLUTBitmapChar ch188 = { 13, 13, -1, 0, 15, ch188data }; + +static const unsigned char 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 GLUTBitmapChar ch189 = { 13, 13, -1, 0, 15, ch189data }; + +static const unsigned char 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 GLUTBitmapChar ch190 = { 14, 13, 0, 0, 15, ch190data }; + +static const unsigned char ch191data[] = { + 0x7c,0xfe,0xc6,0xc6,0xe0,0x70,0x38,0x18,0x18,0x18,0x0,0x0,0x18,0x18 +}; +static const GLUTBitmapChar ch191 = { 7, 14, -1, 4, 10, ch191data }; + +static const unsigned char 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 GLUTBitmapChar ch192 = { 12, 18, 0, 0, 12, ch192data }; + +static const unsigned char 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 GLUTBitmapChar ch193 = { 12, 18, 0, 0, 12, ch193data }; + +static const unsigned char 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 GLUTBitmapChar ch194 = { 12, 18, 0, 0, 12, ch194data }; + +static const unsigned char 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 GLUTBitmapChar ch195 = { 12, 18, 0, 0, 12, ch195data }; + +static const unsigned char 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 GLUTBitmapChar ch196 = { 12, 17, 0, 0, 12, ch196data }; + +static const unsigned char 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 GLUTBitmapChar ch197 = { 12, 18, 0, 0, 12, ch197data }; + +static const unsigned char 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 GLUTBitmapChar ch198 = { 16, 14, -1, 0, 18, ch198data }; + +static const unsigned char 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 GLUTBitmapChar ch199 = { 12, 18, -1, 4, 14, ch199data }; + +static const unsigned char 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 GLUTBitmapChar ch200 = { 9, 18, -1, 0, 11, ch200data }; + +static const unsigned char 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 GLUTBitmapChar ch201 = { 9, 18, -1, 0, 11, ch201data }; + +static const unsigned char 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 GLUTBitmapChar ch202 = { 9, 18, -1, 0, 11, ch202data }; + +static const unsigned char 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 GLUTBitmapChar ch203 = { 9, 17, -1, 0, 11, ch203data }; + +static const unsigned char ch204data[] = { + 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x30, + 0x60,0xc0 +}; +static const GLUTBitmapChar ch204 = { 4, 18, 0, 0, 6, ch204data }; + +static const unsigned char ch205data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0xc0, + 0x60,0x30 +}; +static const GLUTBitmapChar ch205 = { 4, 18, -2, 0, 6, ch205data }; + +static const unsigned char ch206data[] = { + 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc, + 0x78,0x30 +}; +static const GLUTBitmapChar ch206 = { 6, 18, 0, 0, 6, ch206data }; + +static const unsigned char ch207data[] = { + 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc, + 0xcc +}; +static const GLUTBitmapChar ch207 = { 6, 17, 0, 0, 6, ch207data }; + +static const unsigned char 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 GLUTBitmapChar ch208 = { 12, 14, 0, 0, 13, ch208data }; + +static const unsigned char 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 GLUTBitmapChar ch209 = { 11, 18, -1, 0, 13, ch209data }; + +static const unsigned char 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 GLUTBitmapChar ch210 = { 13, 18, -1, 0, 15, ch210data }; + +static const unsigned char 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 GLUTBitmapChar ch211 = { 13, 18, -1, 0, 15, ch211data }; + +static const unsigned char 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 GLUTBitmapChar ch212 = { 13, 18, -1, 0, 15, ch212data }; + +static const unsigned char 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 GLUTBitmapChar ch213 = { 13, 18, -1, 0, 15, ch213data }; + +static const unsigned char 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 GLUTBitmapChar ch214 = { 13, 17, -1, 0, 15, ch214data }; + +static const unsigned char ch215data[] = { + 0xc0,0xc0,0x61,0x80,0x33,0x0,0x1e,0x0,0xc,0x0,0x1e,0x0,0x33,0x0,0x61,0x80, + 0xc0,0xc0 +}; +static const GLUTBitmapChar ch215 = { 10, 9, 0, 0, 10, ch215data }; + +static const unsigned char 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 GLUTBitmapChar ch216 = { 14, 14, 0, 0, 15, ch216data }; + +static const unsigned char 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 GLUTBitmapChar ch217 = { 11, 18, -1, 0, 13, ch217data }; + +static const unsigned char 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 GLUTBitmapChar ch218 = { 11, 18, -1, 0, 13, ch218data }; + +static const unsigned char 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 GLUTBitmapChar ch219 = { 11, 18, -1, 0, 13, ch219data }; + +static const unsigned char 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 GLUTBitmapChar ch220 = { 11, 17, -1, 0, 13, ch220data }; + +static const unsigned char 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 GLUTBitmapChar ch221 = { 12, 18, -1, 0, 14, ch221data }; + +static const unsigned char 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 GLUTBitmapChar ch222 = { 10, 14, -1, 0, 12, ch222data }; + +static const unsigned char ch223data[] = { + 0xdc,0xde,0xc6,0xc6,0xc6,0xc6,0xdc,0xdc,0xc6,0xc6,0xc6,0xc6,0x7c,0x38 +}; +static const GLUTBitmapChar ch223 = { 7, 14, -1, 0, 9, ch223data }; + +static const unsigned char ch224data[] = { + 0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x18,0x30,0x60 +}; +static const GLUTBitmapChar ch224 = { 7, 14, -1, 0, 9, ch224data }; + +static const unsigned char ch225data[] = { + 0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x30,0x18,0xc +}; +static const GLUTBitmapChar ch225 = { 7, 14, -1, 0, 9, ch225data }; + +static const unsigned char ch226data[] = { + 0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x66,0x3c,0x18 +}; +static const GLUTBitmapChar ch226 = { 7, 14, -1, 0, 9, ch226data }; + +static const unsigned char ch227data[] = { + 0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x4c,0x5a,0x32 +}; +static const GLUTBitmapChar ch227 = { 7, 14, -1, 0, 9, ch227data }; + +static const unsigned char ch228data[] = { + 0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x6c,0x6c +}; +static const GLUTBitmapChar ch228 = { 7, 13, -1, 0, 9, ch228data }; + +static const unsigned char ch229data[] = { + 0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x38,0x6c,0x6c,0x38 +}; +static const GLUTBitmapChar ch229 = { 7, 14, -1, 0, 9, ch229data }; + +static const unsigned char ch230data[] = { + 0x75,0xe0,0xef,0xf8,0xc7,0x18,0xc6,0x0,0xe6,0x0,0x7f,0xf8,0xe,0x18,0xc6,0x18, + 0xef,0xf0,0x7d,0xe0 +}; +static const GLUTBitmapChar ch230 = { 13, 10, -1, 0, 15, ch230data }; + +static const unsigned char ch231data[] = { + 0x78,0x6c,0xc,0x38,0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e +}; +static const GLUTBitmapChar ch231 = { 8, 14, -1, 4, 10, ch231data }; + +static const unsigned char ch232data[] = { + 0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0x30,0x60 +}; +static const GLUTBitmapChar ch232 = { 8, 14, -1, 0, 10, ch232data }; + +static const unsigned char ch233data[] = { + 0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0xc,0x6 +}; +static const GLUTBitmapChar ch233 = { 8, 14, -1, 0, 10, ch233data }; + +static const unsigned char ch234data[] = { + 0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x66,0x3c,0x18 +}; +static const GLUTBitmapChar ch234 = { 8, 14, -1, 0, 10, ch234data }; + +static const unsigned char ch235data[] = { + 0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x36,0x36 +}; +static const GLUTBitmapChar ch235 = { 8, 13, -1, 0, 10, ch235data }; + +static const unsigned char ch236data[] = { + 0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0x30,0x60,0xc0 +}; +static const GLUTBitmapChar ch236 = { 4, 14, 0, 0, 4, ch236data }; + +static const unsigned char ch237data[] = { + 0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xc0,0x60,0x30 +}; +static const GLUTBitmapChar ch237 = { 4, 14, 0, 0, 4, ch237data }; + +static const unsigned char ch238data[] = { + 0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,0x78,0x30 +}; +static const GLUTBitmapChar ch238 = { 6, 14, 1, 0, 4, ch238data }; + +static const unsigned char ch239data[] = { + 0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xd8,0xd8 +}; +static const GLUTBitmapChar ch239 = { 5, 13, 0, 0, 4, ch239data }; + +static const unsigned char 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 GLUTBitmapChar ch240 = { 9, 14, -1, 0, 11, ch240data }; + +static const unsigned char ch241data[] = { + 0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0x0,0x4c,0x5a,0x32 +}; +static const GLUTBitmapChar ch241 = { 8, 14, -1, 0, 10, ch241data }; + +static const unsigned char 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 GLUTBitmapChar ch242 = { 9, 14, -1, 0, 11, ch242data }; + +static const unsigned char 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 GLUTBitmapChar ch243 = { 9, 14, -1, 0, 11, ch243data }; + +static const unsigned char 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 GLUTBitmapChar ch244 = { 9, 14, -1, 0, 11, ch244data }; + +static const unsigned char 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 GLUTBitmapChar ch245 = { 9, 14, -1, 0, 11, ch245data }; + +static const unsigned char 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 GLUTBitmapChar ch246 = { 9, 13, -1, 0, 11, ch246data }; + +static const unsigned char ch247data[] = { + 0x18,0x18,0x0,0xff,0xff,0x0,0x18,0x18 +}; +static const GLUTBitmapChar ch247 = { 8, 8, -1, -1, 10, ch247data }; + +static const unsigned char ch248data[] = { + 0xce,0x0,0x7f,0x80,0x31,0x80,0x78,0xc0,0x6c,0xc0,0x66,0xc0,0x63,0xc0,0x31,0x80, + 0x3f,0xc0,0xe,0x60 +}; +static const GLUTBitmapChar ch248 = { 11, 10, 0, 0, 11, ch248data }; + +static const unsigned char ch249data[] = { + 0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0xc,0x18,0x30 +}; +static const GLUTBitmapChar ch249 = { 8, 14, -1, 0, 10, ch249data }; + +static const unsigned char ch250data[] = { + 0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x18,0xc,0x6 +}; +static const GLUTBitmapChar ch250 = { 8, 14, -1, 0, 10, ch250data }; + +static const unsigned char ch251data[] = { + 0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x3c,0x18 +}; +static const GLUTBitmapChar ch251 = { 8, 14, -1, 0, 10, ch251data }; + +static const unsigned char ch252data[] = { + 0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x66 +}; +static const GLUTBitmapChar ch252 = { 8, 13, -1, 0, 10, ch252data }; + +static const unsigned char ch253data[] = { + 0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x18, + 0xc,0x6 +}; +static const GLUTBitmapChar ch253 = { 8, 18, -1, 4, 10, ch253data }; + +static const unsigned char 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 GLUTBitmapChar ch254 = { 9, 18, -1, 4, 11, ch254data }; + +static const unsigned char ch255data[] = { + 0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x66, + 0x66 +}; +static const GLUTBitmapChar ch255 = { 8, 17, -1, 4, 10, ch255data }; + + +static const GLUTBitmapChar *chars[] = { + 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, + &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 GLUTBitmapFont glutBitmapHelvetica18 = { + "-Adobe-Helvetica-Medium-R-Normal--18-180-75-75-P-98-ISO8859-1", + 22, 256, chars +}; diff --git a/src/glut/dos/init.c b/src/glut/dos/init.c new file mode 100644 index 000000000..3a98dcf0a --- /dev/null +++ b/src/glut/dos/init.c @@ -0,0 +1,223 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include +#include +#include +#include + +#include "internal.h" + + +char *__glutProgramName = NULL; + +GLUTvisual _glut_visual = { + 16, 8, 16, 8, 16, /* bpp, alpha, depth, stencil, accum */ + + { 0, 0 }, 0, /* geometry */ + + 0 /* flags */ +}; + +GLUTdefault _glut_default = { + 0, 0, /* glutInitWindowPosition */ + 300, 300, /* glutInitWindowSize */ + 0 /* glutInitDisplayMode */ +}; + +GLuint _glut_fps = 0; + +static char *init_string; + + +void +_glut_fatal (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); + exit(1); +} + + +/* strdup is actually not a standard ANSI C or POSIX routine + * so implement a private one for GLUT. + */ +static char * +_glut_strdup (const char *string) +{ + if (string != NULL) { + int len = strlen(string) + 1; + char *p = malloc(len); + if (p != NULL) { + return strcpy(p, string); + } + } + return NULL; +} + + +void APIENTRY +glutInit (int *argc, char **argv) +{ + char *str; + const char *env; + + if ((env = getenv("DMESA_GLUT_BPP")) != NULL) { + _glut_visual.bpp = atoi(env); + } + if ((env = getenv("DMESA_GLUT_ALPHA")) != NULL) { + _glut_visual.alpha = atoi(env); + } + if ((env = getenv("DMESA_GLUT_DEPTH")) != NULL) { + _glut_visual.depth = atoi(env); + } + if ((env = getenv("DMESA_GLUT_STENCIL")) != NULL) { + _glut_visual.stencil = atoi(env); + } + if ((env = getenv("DMESA_GLUT_ACCUM")) != NULL) { + _glut_visual.accum = atoi(env); + } + if ((env = getenv("DMESA_GLUT_REFRESH")) != NULL) { + _glut_visual.refresh = atoi(env); + } + + /* Determine program name. */ + str = strrchr(argv[0], '/'); + if (str == NULL) { + str = argv[0]; + } else { + str++; + } + __glutProgramName = _glut_strdup(str); + + /* check if GLUT_FPS env var is set */ + if ((env = getenv("GLUT_FPS")) != NULL) { + if ((_glut_fps = atoi(env)) <= 0) { + _glut_fps = 5000; /* 5000 milliseconds */ + } + } + + /* Initialize timer */ + glutGet(GLUT_ELAPSED_TIME); +} + + +void APIENTRY +glutInitDisplayMode (unsigned int mode) +{ + _glut_default.mode = mode; +} + + +void APIENTRY +glutInitWindowPosition (int x, int y) +{ + _glut_default.x = x; + _glut_default.y = y; +} + + +void APIENTRY +glutInitWindowSize (int width, int height) +{ + _glut_default.width = width; + _glut_default.height = height; +} + + +void APIENTRY +glutInitDisplayString (const char *string) +{ + init_string = _glut_strdup(string); +} + + +void APIENTRY +glutSetOption (GLenum pname, int value) +{ + switch (pname) { + case GLUT_INIT_WINDOW_X: + _glut_default.x = value; + break; + case GLUT_INIT_WINDOW_Y: + _glut_default.y = value; + break; + } +} + + +void APIENTRY +glutForceJoystickFunc (void) +{ +} + + +void APIENTRY +glutIgnoreKeyRepeat (int ignore) +{ +} + + +void APIENTRY +glutSetKeyRepeat (int repeatMode) +{ +} + + +void APIENTRY +glutVideoPan (int x, int y, int w, int h) +{ +} + + +int APIENTRY +glutVideoResizeGet( GLenum eWhat ) +{ + return 0; +} + + +void APIENTRY +glutSetupVideoResizing (void) +{ +} + + +void APIENTRY +glutStopVideoResizing (void) +{ +} + + +void APIENTRY +glutVideoResize (int x, int y, int w, int h) +{ +} diff --git a/src/glut/dos/internal.h b/src/glut/dos/internal.h new file mode 100644 index 000000000..063c2d00d --- /dev/null +++ b/src/glut/dos/internal.h @@ -0,0 +1,197 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#ifndef INTERNAL_H_included +#define INTERNAL_H_included + +#include + +#include "GL/dmesa.h" + + +#define MAX_WINDOWS 2 +#define MAX_TIMER_CB 8 +#define RESERVED_COLORS 0 + + +/* 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); /* DEPRECATED. */ +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, int, int, int); + +typedef void (GLUTCALLBACK *GLUTdestroyCB) (void); +typedef void (GLUTCALLBACK *GLUTmouseWheelCB) (int, int, int, int); +typedef void (GLUTCALLBACK *GLUTmenuDestroyCB) (void); + + +typedef struct { + GLuint bpp, alpha; + GLuint depth, stencil; + GLuint accum; + + GLint geometry[2]; + GLuint refresh; + + GLint flags; +} GLUTvisual; + +typedef struct { + GLint x, y; + GLint width, height; + GLuint mode; +} GLUTdefault; + +typedef struct { + void (*func) (int); + int value; + int time; +} GLUTSShotCB; + +typedef struct GLUTwindow { + int num; /* window id */ + + DMesaContext context; + DMesaBuffer buffer; + + int show_mouse; + GLboolean redisplay; + + /* GLUT settable or visible window state. */ + int xpos; + int ypos; + int width; /* window width in pixels */ + int height; /* window height in pixels */ + + /* 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 */ + GLUTjoystickCB joystick; /* joystick */ + + GLUTdestroyCB destroy; /* destroy */ + GLUTmouseWheelCB mouseWheel; /* mouse wheel */ + + /* specific data */ + void *data; +} GLUTwindow; + +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; + +typedef struct { + const GLfloat x, y; +} GLUTStrokeVertex; + +typedef struct { + const unsigned num; + const GLUTStrokeVertex *vertex; +} GLUTStrokeStrip; + +typedef struct { + const GLfloat right; + const unsigned num; + const GLUTStrokeStrip *strip; +} GLUTStrokeChar; + +typedef struct { + const char *name; + const unsigned num; + const GLUTStrokeChar *const *table; + const GLfloat height; + const GLfloat descent; +} GLUTStrokeFont; + + +extern char *__glutProgramName; + +extern GLUTvisual _glut_visual; +extern GLUTdefault _glut_default; + +extern GLuint _glut_fps; +extern GLUTidleCB _glut_idle_func; +extern GLUTmenuStatusCB _glut_menu_status_func; +extern GLUTSShotCB _glut_timer_cb[]; + +extern GLUTwindow *_glut_current, *_glut_windows[]; + +extern int _glut_mouse; /* number of buttons, if mouse installed */ +extern int _glut_mouse_x, _glut_mouse_y; /* mouse coords, relative to current win */ + + +extern void _glut_mouse_init (void); +extern void _glut_fatal(char *format,...); +extern void *_glut_font (void *font); + + +#include "pc_hw/pc_hw.h" + +#endif diff --git a/src/glut/dos/loop.c b/src/glut/dos/loop.c new file mode 100644 index 000000000..36c3adc3f --- /dev/null +++ b/src/glut/dos/loop.c @@ -0,0 +1,245 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include + +#include +#include "GL/dmesa.h" + +#include "PC_HW/pc_hw.h" +#include "internal.h" + + +static int looping = 0; + + +#define DO_REDISPLAY(w, ccin, ccout) \ + do { \ + if (w->redisplay && w->display) { \ + int rv = GL_TRUE; \ + \ + idle = GL_FALSE; \ + w->redisplay = GL_FALSE; \ + \ + /* test IN condition (whether we need to `MakeCurrent') */\ + if (ccin) { \ + rv = DMesaMakeCurrent(w->context, w->buffer); \ + } \ + \ + /* do the display only if `MakeCurrent' didn't failed */ \ + if (rv) { \ + if (w->show_mouse && !(_glut_default.mode & GLUT_DOUBLE)) {\ + /* XXX scare mouse */ \ + w->display(); \ + /* XXX unscare mouse */ \ + } else { \ + w->display(); \ + } \ + \ + /* update OUT condition */ \ + ccout; \ + } \ + } \ + } while (0) + + +void APIENTRY +glutMainLoopEvent (void) +{ + int i, n; + GLUTwindow *w; + GLboolean idle; + static int old_mouse_x = 0; + static int old_mouse_y = 0; + static int old_mouse_b = 0; + + static GLboolean virgin = GL_TRUE; + if (virgin) { + pc_install_keyb(); + _glut_mouse_init(); + + for (i = 0; i < MAX_WINDOWS; i++) { + w = _glut_windows[i]; + if (w != NULL) { + glutSetWindow(w->num); + glutPostRedisplay(); + if (w->reshape) { + w->reshape(w->width, w->height); + } + if (w->visibility) { + w->visibility(GLUT_VISIBLE); + } + } + } + virgin = GL_FALSE; + } + + idle = GL_TRUE; + + n = 0; + for (i = 0; i < MAX_WINDOWS; i++) { + w = _glut_windows[i]; + if ((w != NULL) && (w != _glut_current)) { + /* 1) redisplay `w' + * 2) `MakeCurrent' always + * 3) update number of non-default windows + */ + DO_REDISPLAY(w, GL_TRUE, n++); + } + } + /* 1) redisplay `_glut_current' + * 2) `MakeCurrent' only if we previously did non-default windows + * 3) don't update anything + */ + DO_REDISPLAY(_glut_current, n, n); + + if (_glut_mouse) { + int mouse_x; + int mouse_y; + int mouse_z; + int mouse_b; + + /* query mouse */ + mouse_b = pc_query_mouse(&mouse_x, &mouse_y, &mouse_z); + + /* relative to window coordinates */ + _glut_mouse_x = mouse_x - _glut_current->xpos; + _glut_mouse_y = mouse_y - _glut_current->ypos; + + /* mouse was moved? */ + if ((mouse_x != old_mouse_x) || (mouse_y != old_mouse_y)) { + idle = GL_FALSE; + old_mouse_x = mouse_x; + old_mouse_y = mouse_y; + + if (mouse_b) { + /* any button pressed */ + if (_glut_current->motion) { + _glut_current->motion(_glut_mouse_x, _glut_mouse_y); + } + } else { + /* no button pressed */ + if (_glut_current->passive) { + _glut_current->passive(_glut_mouse_x, _glut_mouse_y); + } + } + } + + /* button state changed? */ + if (mouse_b != old_mouse_b) { + GLUTmouseCB mouse_func; + + if ((mouse_func = _glut_current->mouse)) { + if ((old_mouse_b & 1) && !(mouse_b & 1)) + mouse_func(GLUT_LEFT_BUTTON, GLUT_UP, _glut_mouse_x, _glut_mouse_y); + else if (!(old_mouse_b & 1) && (mouse_b & 1)) + mouse_func(GLUT_LEFT_BUTTON, GLUT_DOWN, _glut_mouse_x, _glut_mouse_y); + + if ((old_mouse_b & 2) && !(mouse_b & 2)) + mouse_func(GLUT_RIGHT_BUTTON, GLUT_UP, _glut_mouse_x, _glut_mouse_y); + else if (!(old_mouse_b & 2) && (mouse_b & 2)) + mouse_func(GLUT_RIGHT_BUTTON, GLUT_DOWN, _glut_mouse_x, _glut_mouse_y); + + if ((old_mouse_b & 4) && !(mouse_b & 4)) + mouse_func(GLUT_MIDDLE_BUTTON, GLUT_UP, _glut_mouse_x, _glut_mouse_y); + else if (!(old_mouse_b & 3) && (mouse_b & 4)) + mouse_func(GLUT_MIDDLE_BUTTON, GLUT_DOWN, _glut_mouse_x, _glut_mouse_y); + } + + idle = GL_FALSE; + old_mouse_b = mouse_b; + } + } + + if (pc_keypressed()) { + int key; + int glut_key; + + idle = GL_FALSE; + key = pc_readkey(); + + switch (key>>16) { + case KEY_F1: glut_key = GLUT_KEY_F1; goto special; + case KEY_F2: glut_key = GLUT_KEY_F2; goto special; + case KEY_F3: glut_key = GLUT_KEY_F3; goto special; + case KEY_F4: glut_key = GLUT_KEY_F4; goto special; + case KEY_F5: glut_key = GLUT_KEY_F5; goto special; + case KEY_F6: glut_key = GLUT_KEY_F6; goto special; + case KEY_F7: glut_key = GLUT_KEY_F7; goto special; + case KEY_F8: glut_key = GLUT_KEY_F8; goto special; + case KEY_F9: glut_key = GLUT_KEY_F9; goto special; + case KEY_F10: glut_key = GLUT_KEY_F10; goto special; + case KEY_F11: glut_key = GLUT_KEY_F11; goto special; + case KEY_F12: glut_key = GLUT_KEY_F12; goto special; + case KEY_LEFT: glut_key = GLUT_KEY_LEFT; goto special; + case KEY_UP: glut_key = GLUT_KEY_UP; goto special; + case KEY_RIGHT: glut_key = GLUT_KEY_RIGHT; goto special; + case KEY_DOWN: glut_key = GLUT_KEY_DOWN; goto special; + case KEY_PGUP: glut_key = GLUT_KEY_PAGE_UP; goto special; + case KEY_PGDN: glut_key = GLUT_KEY_PAGE_DOWN; goto special; + case KEY_HOME: glut_key = GLUT_KEY_HOME; goto special; + case KEY_END: glut_key = GLUT_KEY_END; goto special; + case KEY_INSERT: glut_key = GLUT_KEY_INSERT; goto special; + special: + if (_glut_current->special) { + _glut_current->special(glut_key, _glut_mouse_x, _glut_mouse_y); + } + break; + default: + if (_glut_current->keyboard) { + _glut_current->keyboard(key & 0xFF, _glut_mouse_x, _glut_mouse_y); + } + } + } + + if (idle && _glut_idle_func) + _glut_idle_func(); + + for (i = 0; i < MAX_TIMER_CB; i++) { + int time = glutGet(GLUT_ELAPSED_TIME); + GLUTSShotCB *cb = &_glut_timer_cb[i]; + if (cb->func && (time >= cb->time)) { + cb->func(cb->value); + cb->func = NULL; + } + } +} + + +void APIENTRY +glutMainLoop (void) +{ + looping++; + while (looping) { + glutMainLoopEvent(); + } +} + + +void APIENTRY +glutLeaveMainLoop (void) +{ + looping--; +} diff --git a/src/glut/dos/menu.c b/src/glut/dos/menu.c new file mode 100644 index 000000000..857d2b4a4 --- /dev/null +++ b/src/glut/dos/menu.c @@ -0,0 +1,130 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "internal.h" + + +GLUTmenuStatusCB _glut_menu_status_func = NULL; + + +void APIENTRY +glutMenuStateFunc (GLUTmenuStateCB func) +{ + _glut_menu_status_func = (GLUTmenuStatusCB)func; +} + + +void APIENTRY +glutMenuStatusFunc (GLUTmenuStatusCB func) +{ + _glut_menu_status_func = func; +} + + +int APIENTRY +glutCreateMenu (GLUTselectCB func) +{ + return 0; +} + + +void APIENTRY +glutDestroyMenu (int menu) +{ +} + + +int APIENTRY +glutGetMenu (void) +{ + return 0; +} + + +void APIENTRY +glutSetMenu (int menu) +{ +} + + +void APIENTRY +glutAddMenuEntry (const char *label, int value) +{ +} + + +void APIENTRY +glutAddSubMenu (const char *label, int submenu) +{ +} + + +void APIENTRY +glutChangeToMenuEntry (int item, const char *label, int value) +{ +} + + +void APIENTRY +glutChangeToSubMenu (int item, const char *label, int submenu) +{ +} + + +void APIENTRY +glutRemoveMenuItem (int item) +{ +} + + +void APIENTRY +glutAttachMenu (int button) +{ +} + + +void APIENTRY +glutDetachMenu (int button) +{ +} + + +void APIENTRY +glutMenuDestroyFunc ( void (* callback)( void ) ) +{ +} + + +void * APIENTRY +glutGetMenuData (void) +{ + return NULL; +} + + +void APIENTRY +glutSetMenuData (void *data) +{ +} diff --git a/src/glut/dos/mouse.c b/src/glut/dos/mouse.c new file mode 100644 index 000000000..945e2a5c1 --- /dev/null +++ b/src/glut/dos/mouse.c @@ -0,0 +1,55 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "internal.h" + + +int _glut_mouse; +int _glut_mouse_x = 0, _glut_mouse_y = 0; + + +void +_glut_mouse_init (void) +{ + if ((_glut_mouse = pc_install_mouse())) { + pc_mouse_area(_glut_current->xpos, _glut_current->ypos, _glut_current->xpos + _glut_current->width - 1, _glut_current->ypos + _glut_current->height - 1); + + _glut_current->show_mouse = (_glut_current->mouse || _glut_current->motion || _glut_current->passive); + } +} + + +void APIENTRY +glutSetCursor (int cursor) +{ + /* XXX completely futile until full mouse support (maybe never) */ +} + + +void APIENTRY +glutWarpPointer (int x, int y) +{ + pc_warp_mouse(x, y); +} diff --git a/src/glut/dos/mroman.c b/src/glut/dos/mroman.c new file mode 100644 index 000000000..5bf76dbf7 --- /dev/null +++ b/src/glut/dos/mroman.c @@ -0,0 +1,2783 @@ + +/* GENERATED FILE -- DO NOT MODIFY */ + +#include "internal.h" + +/* char: 0x20 */ + +static const GLUTStrokeStrip ch32st[] = +{ +}; + +static const GLUTStrokeChar ch32 = {104.7619f,0,ch32st}; + +/* char: 0x21 */ + +static const GLUTStrokeVertex ch33st0[] = +{ + {52.3810f,100.0000f}, + {52.3810f,33.3333f} +}; + +static const GLUTStrokeVertex ch33st1[] = +{ + {52.3810f,9.5238f}, + {47.6191f,4.7619f}, + {52.3810f,0.0000f}, + {57.1429f,4.7619f}, + {52.3810f,9.5238f} +}; + +static const GLUTStrokeStrip ch33st[] = +{ + {2,ch33st0}, + {5,ch33st1} +}; + +static const GLUTStrokeChar ch33 = {104.7619f,2,ch33st}; + +/* char: 0x22 */ + +static const GLUTStrokeVertex ch34st0[] = +{ + {33.3334f,100.0000f}, + {33.3334f,66.6667f} +}; + +static const GLUTStrokeVertex ch34st1[] = +{ + {71.4286f,100.0000f}, + {71.4286f,66.6667f} +}; + +static const GLUTStrokeStrip ch34st[] = +{ + {2,ch34st0}, + {2,ch34st1} +}; + +static const GLUTStrokeChar ch34 = {104.7619f,2,ch34st}; + +/* char: 0x23 */ + +static const GLUTStrokeVertex ch35st0[] = +{ + {54.7619f,119.0476f}, + {21.4286f,-33.3333f} +}; + +static const GLUTStrokeVertex ch35st1[] = +{ + {83.3334f,119.0476f}, + {50.0000f,-33.3333f} +}; + +static const GLUTStrokeVertex ch35st2[] = +{ + {21.4286f,57.1429f}, + {88.0952f,57.1429f} +}; + +static const GLUTStrokeVertex ch35st3[] = +{ + {16.6667f,28.5714f}, + {83.3334f,28.5714f} +}; + +static const GLUTStrokeStrip ch35st[] = +{ + {2,ch35st0}, + {2,ch35st1}, + {2,ch35st2}, + {2,ch35st3} +}; + +static const GLUTStrokeChar ch35 = {104.7619f,4,ch35st}; + +/* char: 0x24 */ + +static const GLUTStrokeVertex ch36st0[] = +{ + {42.8571f,119.0476f}, + {42.8571f,-19.0476f} +}; + +static const GLUTStrokeVertex ch36st1[] = +{ + {61.9047f,119.0476f}, + {61.9047f,-19.0476f} +}; + +static const GLUTStrokeVertex ch36st2[] = +{ + {85.7143f,85.7143f}, + {76.1905f,95.2381f}, + {61.9047f,100.0000f}, + {42.8571f,100.0000f}, + {28.5714f,95.2381f}, + {19.0476f,85.7143f}, + {19.0476f,76.1905f}, + {23.8095f,66.6667f}, + {28.5714f,61.9048f}, + {38.0952f,57.1429f}, + {66.6666f,47.6190f}, + {76.1905f,42.8571f}, + {80.9524f,38.0952f}, + {85.7143f,28.5714f}, + {85.7143f,14.2857f}, + {76.1905f,4.7619f}, + {61.9047f,0.0000f}, + {42.8571f,0.0000f}, + {28.5714f,4.7619f}, + {19.0476f,14.2857f} +}; + +static const GLUTStrokeStrip ch36st[] = +{ + {2,ch36st0}, + {2,ch36st1}, + {20,ch36st2} +}; + +static const GLUTStrokeChar ch36 = {104.7619f,3,ch36st}; + +/* char: 0x25 */ + +static const GLUTStrokeVertex ch37st0[] = +{ + {95.2381f,100.0000f}, + {9.5238f,0.0000f} +}; + +static const GLUTStrokeVertex ch37st1[] = +{ + {33.3333f,100.0000f}, + {42.8571f,90.4762f}, + {42.8571f,80.9524f}, + {38.0952f,71.4286f}, + {28.5714f,66.6667f}, + {19.0476f,66.6667f}, + {9.5238f,76.1905f}, + {9.5238f,85.7143f}, + {14.2857f,95.2381f}, + {23.8095f,100.0000f}, + {33.3333f,100.0000f}, + {42.8571f,95.2381f}, + {57.1428f,90.4762f}, + {71.4286f,90.4762f}, + {85.7143f,95.2381f}, + {95.2381f,100.0000f} +}; + +static const GLUTStrokeVertex ch37st2[] = +{ + {76.1905f,33.3333f}, + {66.6667f,28.5714f}, + {61.9048f,19.0476f}, + {61.9048f,9.5238f}, + {71.4286f,0.0000f}, + {80.9524f,0.0000f}, + {90.4762f,4.7619f}, + {95.2381f,14.2857f}, + {95.2381f,23.8095f}, + {85.7143f,33.3333f}, + {76.1905f,33.3333f} +}; + +static const GLUTStrokeStrip ch37st[] = +{ + {2,ch37st0}, + {16,ch37st1}, + {11,ch37st2} +}; + +static const GLUTStrokeChar ch37 = {104.7619f,3,ch37st}; + +/* char: 0x26 */ + +static const GLUTStrokeVertex ch38st0[] = +{ + {100.0000f,57.1429f}, + {100.0000f,61.9048f}, + {95.2381f,66.6667f}, + {90.4762f,66.6667f}, + {85.7143f,61.9048f}, + {80.9524f,52.3810f}, + {71.4286f,28.5714f}, + {61.9048f,14.2857f}, + {52.3809f,4.7619f}, + {42.8571f,0.0000f}, + {23.8095f,0.0000f}, + {14.2857f,4.7619f}, + {9.5238f,9.5238f}, + {4.7619f,19.0476f}, + {4.7619f,28.5714f}, + {9.5238f,38.0952f}, + {14.2857f,42.8571f}, + {47.6190f,61.9048f}, + {52.3809f,66.6667f}, + {57.1429f,76.1905f}, + {57.1429f,85.7143f}, + {52.3809f,95.2381f}, + {42.8571f,100.0000f}, + {33.3333f,95.2381f}, + {28.5714f,85.7143f}, + {28.5714f,76.1905f}, + {33.3333f,61.9048f}, + {42.8571f,47.6190f}, + {66.6667f,14.2857f}, + {76.1905f,4.7619f}, + {85.7143f,0.0000f}, + {95.2381f,0.0000f}, + {100.0000f,4.7619f}, + {100.0000f,9.5238f} +}; + +static const GLUTStrokeStrip ch38st[] = +{ + {34,ch38st0} +}; + +static const GLUTStrokeChar ch38 = {104.7619f,1,ch38st}; + +/* char: 0x27 */ + +static const GLUTStrokeVertex ch39st0[] = +{ + {52.3810f,100.0000f}, + {52.3810f,66.6667f} +}; + +static const GLUTStrokeStrip ch39st[] = +{ + {2,ch39st0} +}; + +static const GLUTStrokeChar ch39 = {104.7619f,1,ch39st}; + +/* char: 0x28 */ + +static const GLUTStrokeVertex ch40st0[] = +{ + {69.0476f,119.0476f}, + {59.5238f,109.5238f}, + {50.0000f,95.2381f}, + {40.4762f,76.1905f}, + {35.7143f,52.3810f}, + {35.7143f,33.3333f}, + {40.4762f,9.5238f}, + {50.0000f,-9.5238f}, + {59.5238f,-23.8095f}, + {69.0476f,-33.3333f} +}; + +static const GLUTStrokeStrip ch40st[] = +{ + {10,ch40st0} +}; + +static const GLUTStrokeChar ch40 = {104.7619f,1,ch40st}; + +/* char: 0x29 */ + +static const GLUTStrokeVertex ch41st0[] = +{ + {35.7143f,119.0476f}, + {45.2381f,109.5238f}, + {54.7619f,95.2381f}, + {64.2857f,76.1905f}, + {69.0476f,52.3810f}, + {69.0476f,33.3333f}, + {64.2857f,9.5238f}, + {54.7619f,-9.5238f}, + {45.2381f,-23.8095f}, + {35.7143f,-33.3333f} +}; + +static const GLUTStrokeStrip ch41st[] = +{ + {10,ch41st0} +}; + +static const GLUTStrokeChar ch41 = {104.7619f,1,ch41st}; + +/* char: 0x2a */ + +static const GLUTStrokeVertex ch42st0[] = +{ + {52.3810f,71.4286f}, + {52.3810f,14.2857f} +}; + +static const GLUTStrokeVertex ch42st1[] = +{ + {28.5715f,57.1429f}, + {76.1905f,28.5714f} +}; + +static const GLUTStrokeVertex ch42st2[] = +{ + {76.1905f,57.1429f}, + {28.5715f,28.5714f} +}; + +static const GLUTStrokeStrip ch42st[] = +{ + {2,ch42st0}, + {2,ch42st1}, + {2,ch42st2} +}; + +static const GLUTStrokeChar ch42 = {104.7619f,3,ch42st}; + +/* char: 0x2b */ + +static const GLUTStrokeVertex ch43st0[] = +{ + {52.3809f,85.7143f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeVertex ch43st1[] = +{ + {9.5238f,42.8571f}, + {95.2381f,42.8571f} +}; + +static const GLUTStrokeStrip ch43st[] = +{ + {2,ch43st0}, + {2,ch43st1} +}; + +static const GLUTStrokeChar ch43 = {104.7619f,2,ch43st}; + +/* char: 0x2c */ + +static const GLUTStrokeVertex ch44st0[] = +{ + {57.1429f,4.7619f}, + {52.3810f,0.0000f}, + {47.6191f,4.7619f}, + {52.3810f,9.5238f}, + {57.1429f,4.7619f}, + {57.1429f,-4.7619f}, + {52.3810f,-14.2857f}, + {47.6191f,-19.0476f} +}; + +static const GLUTStrokeStrip ch44st[] = +{ + {8,ch44st0} +}; + +static const GLUTStrokeChar ch44 = {104.7619f,1,ch44st}; + +/* char: 0x2d */ + +static const GLUTStrokeVertex ch45st0[] = +{ + {9.5238f,42.8571f}, + {95.2381f,42.8571f} +}; + +static const GLUTStrokeStrip ch45st[] = +{ + {2,ch45st0} +}; + +static const GLUTStrokeChar ch45 = {104.7619f,1,ch45st}; + +/* char: 0x2e */ + +static const GLUTStrokeVertex ch46st0[] = +{ + {52.3810f,9.5238f}, + {47.6191f,4.7619f}, + {52.3810f,0.0000f}, + {57.1429f,4.7619f}, + {52.3810f,9.5238f} +}; + +static const GLUTStrokeStrip ch46st[] = +{ + {5,ch46st0} +}; + +static const GLUTStrokeChar ch46 = {104.7619f,1,ch46st}; + +/* char: 0x2f */ + +static const GLUTStrokeVertex ch47st0[] = +{ + {19.0476f,-14.2857f}, + {85.7143f,100.0000f} +}; + +static const GLUTStrokeStrip ch47st[] = +{ + {2,ch47st0} +}; + +static const GLUTStrokeChar ch47 = {104.7619f,1,ch47st}; + +/* char: 0x30 */ + +static const GLUTStrokeVertex ch48st0[] = +{ + {47.6190f,100.0000f}, + {33.3333f,95.2381f}, + {23.8095f,80.9524f}, + {19.0476f,57.1429f}, + {19.0476f,42.8571f}, + {23.8095f,19.0476f}, + {33.3333f,4.7619f}, + {47.6190f,0.0000f}, + {57.1428f,0.0000f}, + {71.4286f,4.7619f}, + {80.9524f,19.0476f}, + {85.7143f,42.8571f}, + {85.7143f,57.1429f}, + {80.9524f,80.9524f}, + {71.4286f,95.2381f}, + {57.1428f,100.0000f}, + {47.6190f,100.0000f} +}; + +static const GLUTStrokeStrip ch48st[] = +{ + {17,ch48st0} +}; + +static const GLUTStrokeChar ch48 = {104.7619f,1,ch48st}; + +/* char: 0x31 */ + +static const GLUTStrokeVertex ch49st0[] = +{ + {40.4762f,80.9524f}, + {50.0000f,85.7143f}, + {64.2857f,100.0000f}, + {64.2857f,0.0000f} +}; + +static const GLUTStrokeStrip ch49st[] = +{ + {4,ch49st0} +}; + +static const GLUTStrokeChar ch49 = {104.7619f,1,ch49st}; + +/* char: 0x32 */ + +static const GLUTStrokeVertex ch50st0[] = +{ + {23.8095f,76.1905f}, + {23.8095f,80.9524f}, + {28.5714f,90.4762f}, + {33.3333f,95.2381f}, + {42.8571f,100.0000f}, + {61.9047f,100.0000f}, + {71.4286f,95.2381f}, + {76.1905f,90.4762f}, + {80.9524f,80.9524f}, + {80.9524f,71.4286f}, + {76.1905f,61.9048f}, + {66.6666f,47.6190f}, + {19.0476f,0.0000f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeStrip ch50st[] = +{ + {14,ch50st0} +}; + +static const GLUTStrokeChar ch50 = {104.7619f,1,ch50st}; + +/* char: 0x33 */ + +static const GLUTStrokeVertex ch51st0[] = +{ + {28.5714f,100.0000f}, + {80.9524f,100.0000f}, + {52.3809f,61.9048f}, + {66.6666f,61.9048f}, + {76.1905f,57.1429f}, + {80.9524f,52.3810f}, + {85.7143f,38.0952f}, + {85.7143f,28.5714f}, + {80.9524f,14.2857f}, + {71.4286f,4.7619f}, + {57.1428f,0.0000f}, + {42.8571f,0.0000f}, + {28.5714f,4.7619f}, + {23.8095f,9.5238f}, + {19.0476f,19.0476f} +}; + +static const GLUTStrokeStrip ch51st[] = +{ + {15,ch51st0} +}; + +static const GLUTStrokeChar ch51 = {104.7619f,1,ch51st}; + +/* char: 0x34 */ + +static const GLUTStrokeVertex ch52st0[] = +{ + {64.2857f,100.0000f}, + {16.6667f,33.3333f}, + {88.0952f,33.3333f} +}; + +static const GLUTStrokeVertex ch52st1[] = +{ + {64.2857f,100.0000f}, + {64.2857f,0.0000f} +}; + +static const GLUTStrokeStrip ch52st[] = +{ + {3,ch52st0}, + {2,ch52st1} +}; + +static const GLUTStrokeChar ch52 = {104.7619f,2,ch52st}; + +/* char: 0x35 */ + +static const GLUTStrokeVertex ch53st0[] = +{ + {76.1905f,100.0000f}, + {28.5714f,100.0000f}, + {23.8095f,57.1429f}, + {28.5714f,61.9048f}, + {42.8571f,66.6667f}, + {57.1428f,66.6667f}, + {71.4286f,61.9048f}, + {80.9524f,52.3810f}, + {85.7143f,38.0952f}, + {85.7143f,28.5714f}, + {80.9524f,14.2857f}, + {71.4286f,4.7619f}, + {57.1428f,0.0000f}, + {42.8571f,0.0000f}, + {28.5714f,4.7619f}, + {23.8095f,9.5238f}, + {19.0476f,19.0476f} +}; + +static const GLUTStrokeStrip ch53st[] = +{ + {17,ch53st0} +}; + +static const GLUTStrokeChar ch53 = {104.7619f,1,ch53st}; + +/* char: 0x36 */ + +static const GLUTStrokeVertex ch54st0[] = +{ + {78.5714f,85.7143f}, + {73.8096f,95.2381f}, + {59.5238f,100.0000f}, + {50.0000f,100.0000f}, + {35.7143f,95.2381f}, + {26.1905f,80.9524f}, + {21.4286f,57.1429f}, + {21.4286f,33.3333f}, + {26.1905f,14.2857f}, + {35.7143f,4.7619f}, + {50.0000f,0.0000f}, + {54.7619f,0.0000f}, + {69.0476f,4.7619f}, + {78.5714f,14.2857f}, + {83.3334f,28.5714f}, + {83.3334f,33.3333f}, + {78.5714f,47.6190f}, + {69.0476f,57.1429f}, + {54.7619f,61.9048f}, + {50.0000f,61.9048f}, + {35.7143f,57.1429f}, + {26.1905f,47.6190f}, + {21.4286f,33.3333f} +}; + +static const GLUTStrokeStrip ch54st[] = +{ + {23,ch54st0} +}; + +static const GLUTStrokeChar ch54 = {104.7619f,1,ch54st}; + +/* char: 0x37 */ + +static const GLUTStrokeVertex ch55st0[] = +{ + {85.7143f,100.0000f}, + {38.0952f,0.0000f} +}; + +static const GLUTStrokeVertex ch55st1[] = +{ + {19.0476f,100.0000f}, + {85.7143f,100.0000f} +}; + +static const GLUTStrokeStrip ch55st[] = +{ + {2,ch55st0}, + {2,ch55st1} +}; + +static const GLUTStrokeChar ch55 = {104.7619f,2,ch55st}; + +/* char: 0x38 */ + +static const GLUTStrokeVertex ch56st0[] = +{ + {42.8571f,100.0000f}, + {28.5714f,95.2381f}, + {23.8095f,85.7143f}, + {23.8095f,76.1905f}, + {28.5714f,66.6667f}, + {38.0952f,61.9048f}, + {57.1428f,57.1429f}, + {71.4286f,52.3810f}, + {80.9524f,42.8571f}, + {85.7143f,33.3333f}, + {85.7143f,19.0476f}, + {80.9524f,9.5238f}, + {76.1905f,4.7619f}, + {61.9047f,0.0000f}, + {42.8571f,0.0000f}, + {28.5714f,4.7619f}, + {23.8095f,9.5238f}, + {19.0476f,19.0476f}, + {19.0476f,33.3333f}, + {23.8095f,42.8571f}, + {33.3333f,52.3810f}, + {47.6190f,57.1429f}, + {66.6666f,61.9048f}, + {76.1905f,66.6667f}, + {80.9524f,76.1905f}, + {80.9524f,85.7143f}, + {76.1905f,95.2381f}, + {61.9047f,100.0000f}, + {42.8571f,100.0000f} +}; + +static const GLUTStrokeStrip ch56st[] = +{ + {29,ch56st0} +}; + +static const GLUTStrokeChar ch56 = {104.7619f,1,ch56st}; + +/* char: 0x39 */ + +static const GLUTStrokeVertex ch57st0[] = +{ + {83.3334f,66.6667f}, + {78.5714f,52.3810f}, + {69.0476f,42.8571f}, + {54.7619f,38.0952f}, + {50.0000f,38.0952f}, + {35.7143f,42.8571f}, + {26.1905f,52.3810f}, + {21.4286f,66.6667f}, + {21.4286f,71.4286f}, + {26.1905f,85.7143f}, + {35.7143f,95.2381f}, + {50.0000f,100.0000f}, + {54.7619f,100.0000f}, + {69.0476f,95.2381f}, + {78.5714f,85.7143f}, + {83.3334f,66.6667f}, + {83.3334f,42.8571f}, + {78.5714f,19.0476f}, + {69.0476f,4.7619f}, + {54.7619f,0.0000f}, + {45.2381f,0.0000f}, + {30.9524f,4.7619f}, + {26.1905f,14.2857f} +}; + +static const GLUTStrokeStrip ch57st[] = +{ + {23,ch57st0} +}; + +static const GLUTStrokeChar ch57 = {104.7619f,1,ch57st}; + +/* char: 0x3a */ + +static const GLUTStrokeVertex ch58st0[] = +{ + {52.3810f,66.6667f}, + {47.6191f,61.9048f}, + {52.3810f,57.1429f}, + {57.1429f,61.9048f}, + {52.3810f,66.6667f} +}; + +static const GLUTStrokeVertex ch58st1[] = +{ + {52.3810f,9.5238f}, + {47.6191f,4.7619f}, + {52.3810f,0.0000f}, + {57.1429f,4.7619f}, + {52.3810f,9.5238f} +}; + +static const GLUTStrokeStrip ch58st[] = +{ + {5,ch58st0}, + {5,ch58st1} +}; + +static const GLUTStrokeChar ch58 = {104.7619f,2,ch58st}; + +/* char: 0x3b */ + +static const GLUTStrokeVertex ch59st0[] = +{ + {52.3810f,66.6667f}, + {47.6191f,61.9048f}, + {52.3810f,57.1429f}, + {57.1429f,61.9048f}, + {52.3810f,66.6667f} +}; + +static const GLUTStrokeVertex ch59st1[] = +{ + {57.1429f,4.7619f}, + {52.3810f,0.0000f}, + {47.6191f,4.7619f}, + {52.3810f,9.5238f}, + {57.1429f,4.7619f}, + {57.1429f,-4.7619f}, + {52.3810f,-14.2857f}, + {47.6191f,-19.0476f} +}; + +static const GLUTStrokeStrip ch59st[] = +{ + {5,ch59st0}, + {8,ch59st1} +}; + +static const GLUTStrokeChar ch59 = {104.7619f,2,ch59st}; + +/* char: 0x3c */ + +static const GLUTStrokeVertex ch60st0[] = +{ + {90.4762f,85.7143f}, + {14.2857f,42.8571f}, + {90.4762f,0.0000f} +}; + +static const GLUTStrokeStrip ch60st[] = +{ + {3,ch60st0} +}; + +static const GLUTStrokeChar ch60 = {104.7619f,1,ch60st}; + +/* char: 0x3d */ + +static const GLUTStrokeVertex ch61st0[] = +{ + {9.5238f,57.1429f}, + {95.2381f,57.1429f} +}; + +static const GLUTStrokeVertex ch61st1[] = +{ + {9.5238f,28.5714f}, + {95.2381f,28.5714f} +}; + +static const GLUTStrokeStrip ch61st[] = +{ + {2,ch61st0}, + {2,ch61st1} +}; + +static const GLUTStrokeChar ch61 = {104.7619f,2,ch61st}; + +/* char: 0x3e */ + +static const GLUTStrokeVertex ch62st0[] = +{ + {14.2857f,85.7143f}, + {90.4762f,42.8571f}, + {14.2857f,0.0000f} +}; + +static const GLUTStrokeStrip ch62st[] = +{ + {3,ch62st0} +}; + +static const GLUTStrokeChar ch62 = {104.7619f,1,ch62st}; + +/* char: 0x3f */ + +static const GLUTStrokeVertex ch63st0[] = +{ + {23.8095f,76.1905f}, + {23.8095f,80.9524f}, + {28.5714f,90.4762f}, + {33.3333f,95.2381f}, + {42.8571f,100.0000f}, + {61.9047f,100.0000f}, + {71.4285f,95.2381f}, + {76.1905f,90.4762f}, + {80.9524f,80.9524f}, + {80.9524f,71.4286f}, + {76.1905f,61.9048f}, + {71.4285f,57.1429f}, + {52.3809f,47.6190f}, + {52.3809f,33.3333f} +}; + +static const GLUTStrokeVertex ch63st1[] = +{ + {52.3809f,9.5238f}, + {47.6190f,4.7619f}, + {52.3809f,0.0000f}, + {57.1428f,4.7619f}, + {52.3809f,9.5238f} +}; + +static const GLUTStrokeStrip ch63st[] = +{ + {14,ch63st0}, + {5,ch63st1} +}; + +static const GLUTStrokeChar ch63 = {104.7619f,2,ch63st}; + +/* char: 0x40 */ + +static const GLUTStrokeVertex ch64st0[] = +{ + {64.2857f,52.3810f}, + {54.7619f,57.1429f}, + {45.2381f,57.1429f}, + {40.4762f,47.6190f}, + {40.4762f,42.8571f}, + {45.2381f,33.3333f}, + {54.7619f,33.3333f}, + {64.2857f,38.0952f} +}; + +static const GLUTStrokeVertex ch64st1[] = +{ + {64.2857f,57.1429f}, + {64.2857f,38.0952f}, + {69.0476f,33.3333f}, + {78.5714f,33.3333f}, + {83.3334f,42.8571f}, + {83.3334f,47.6190f}, + {78.5714f,61.9048f}, + {69.0476f,71.4286f}, + {54.7619f,76.1905f}, + {50.0000f,76.1905f}, + {35.7143f,71.4286f}, + {26.1905f,61.9048f}, + {21.4286f,47.6190f}, + {21.4286f,42.8571f}, + {26.1905f,28.5714f}, + {35.7143f,19.0476f}, + {50.0000f,14.2857f}, + {54.7619f,14.2857f}, + {69.0476f,19.0476f} +}; + +static const GLUTStrokeStrip ch64st[] = +{ + {8,ch64st0}, + {19,ch64st1} +}; + +static const GLUTStrokeChar ch64 = {104.7619f,2,ch64st}; + +/* char: 0x41 */ + +static const GLUTStrokeVertex ch65st0[] = +{ + {52.3809f,100.0000f}, + {14.2857f,0.0000f} +}; + +static const GLUTStrokeVertex ch65st1[] = +{ + {52.3809f,100.0000f}, + {90.4762f,0.0000f} +}; + +static const GLUTStrokeVertex ch65st2[] = +{ + {28.5714f,33.3333f}, + {76.1905f,33.3333f} +}; + +static const GLUTStrokeStrip ch65st[] = +{ + {2,ch65st0}, + {2,ch65st1}, + {2,ch65st2} +}; + +static const GLUTStrokeChar ch65 = {104.7619f,3,ch65st}; + +/* char: 0x42 */ + +static const GLUTStrokeVertex ch66st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch66st1[] = +{ + {19.0476f,100.0000f}, + {61.9047f,100.0000f}, + {76.1905f,95.2381f}, + {80.9524f,90.4762f}, + {85.7143f,80.9524f}, + {85.7143f,71.4286f}, + {80.9524f,61.9048f}, + {76.1905f,57.1429f}, + {61.9047f,52.3810f} +}; + +static const GLUTStrokeVertex ch66st2[] = +{ + {19.0476f,52.3810f}, + {61.9047f,52.3810f}, + {76.1905f,47.6190f}, + {80.9524f,42.8571f}, + {85.7143f,33.3333f}, + {85.7143f,19.0476f}, + {80.9524f,9.5238f}, + {76.1905f,4.7619f}, + {61.9047f,0.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeStrip ch66st[] = +{ + {2,ch66st0}, + {9,ch66st1}, + {10,ch66st2} +}; + +static const GLUTStrokeChar ch66 = {104.7619f,3,ch66st}; + +/* char: 0x43 */ + +static const GLUTStrokeVertex ch67st0[] = +{ + {88.0952f,76.1905f}, + {83.3334f,85.7143f}, + {73.8096f,95.2381f}, + {64.2857f,100.0000f}, + {45.2381f,100.0000f}, + {35.7143f,95.2381f}, + {26.1905f,85.7143f}, + {21.4286f,76.1905f}, + {16.6667f,61.9048f}, + {16.6667f,38.0952f}, + {21.4286f,23.8095f}, + {26.1905f,14.2857f}, + {35.7143f,4.7619f}, + {45.2381f,0.0000f}, + {64.2857f,0.0000f}, + {73.8096f,4.7619f}, + {83.3334f,14.2857f}, + {88.0952f,23.8095f} +}; + +static const GLUTStrokeStrip ch67st[] = +{ + {18,ch67st0} +}; + +static const GLUTStrokeChar ch67 = {104.7619f,1,ch67st}; + +/* char: 0x44 */ + +static const GLUTStrokeVertex ch68st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch68st1[] = +{ + {19.0476f,100.0000f}, + {52.3809f,100.0000f}, + {66.6666f,95.2381f}, + {76.1905f,85.7143f}, + {80.9524f,76.1905f}, + {85.7143f,61.9048f}, + {85.7143f,38.0952f}, + {80.9524f,23.8095f}, + {76.1905f,14.2857f}, + {66.6666f,4.7619f}, + {52.3809f,0.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeStrip ch68st[] = +{ + {2,ch68st0}, + {12,ch68st1} +}; + +static const GLUTStrokeChar ch68 = {104.7619f,2,ch68st}; + +/* char: 0x45 */ + +static const GLUTStrokeVertex ch69st0[] = +{ + {21.4286f,100.0000f}, + {21.4286f,0.0000f} +}; + +static const GLUTStrokeVertex ch69st1[] = +{ + {21.4286f,100.0000f}, + {83.3334f,100.0000f} +}; + +static const GLUTStrokeVertex ch69st2[] = +{ + {21.4286f,52.3810f}, + {59.5238f,52.3810f} +}; + +static const GLUTStrokeVertex ch69st3[] = +{ + {21.4286f,0.0000f}, + {83.3334f,0.0000f} +}; + +static const GLUTStrokeStrip ch69st[] = +{ + {2,ch69st0}, + {2,ch69st1}, + {2,ch69st2}, + {2,ch69st3} +}; + +static const GLUTStrokeChar ch69 = {104.7619f,4,ch69st}; + +/* char: 0x46 */ + +static const GLUTStrokeVertex ch70st0[] = +{ + {21.4286f,100.0000f}, + {21.4286f,0.0000f} +}; + +static const GLUTStrokeVertex ch70st1[] = +{ + {21.4286f,100.0000f}, + {83.3334f,100.0000f} +}; + +static const GLUTStrokeVertex ch70st2[] = +{ + {21.4286f,52.3810f}, + {59.5238f,52.3810f} +}; + +static const GLUTStrokeStrip ch70st[] = +{ + {2,ch70st0}, + {2,ch70st1}, + {2,ch70st2} +}; + +static const GLUTStrokeChar ch70 = {104.7619f,3,ch70st}; + +/* char: 0x47 */ + +static const GLUTStrokeVertex ch71st0[] = +{ + {88.0952f,76.1905f}, + {83.3334f,85.7143f}, + {73.8096f,95.2381f}, + {64.2857f,100.0000f}, + {45.2381f,100.0000f}, + {35.7143f,95.2381f}, + {26.1905f,85.7143f}, + {21.4286f,76.1905f}, + {16.6667f,61.9048f}, + {16.6667f,38.0952f}, + {21.4286f,23.8095f}, + {26.1905f,14.2857f}, + {35.7143f,4.7619f}, + {45.2381f,0.0000f}, + {64.2857f,0.0000f}, + {73.8096f,4.7619f}, + {83.3334f,14.2857f}, + {88.0952f,23.8095f}, + {88.0952f,38.0952f} +}; + +static const GLUTStrokeVertex ch71st1[] = +{ + {64.2857f,38.0952f}, + {88.0952f,38.0952f} +}; + +static const GLUTStrokeStrip ch71st[] = +{ + {19,ch71st0}, + {2,ch71st1} +}; + +static const GLUTStrokeChar ch71 = {104.7619f,2,ch71st}; + +/* char: 0x48 */ + +static const GLUTStrokeVertex ch72st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch72st1[] = +{ + {85.7143f,100.0000f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeVertex ch72st2[] = +{ + {19.0476f,52.3810f}, + {85.7143f,52.3810f} +}; + +static const GLUTStrokeStrip ch72st[] = +{ + {2,ch72st0}, + {2,ch72st1}, + {2,ch72st2} +}; + +static const GLUTStrokeChar ch72 = {104.7619f,3,ch72st}; + +/* char: 0x49 */ + +static const GLUTStrokeVertex ch73st0[] = +{ + {52.3810f,100.0000f}, + {52.3810f,0.0000f} +}; + +static const GLUTStrokeStrip ch73st[] = +{ + {2,ch73st0} +}; + +static const GLUTStrokeChar ch73 = {104.7619f,1,ch73st}; + +/* char: 0x4a */ + +static const GLUTStrokeVertex ch74st0[] = +{ + {76.1905f,100.0000f}, + {76.1905f,23.8095f}, + {71.4286f,9.5238f}, + {66.6667f,4.7619f}, + {57.1429f,0.0000f}, + {47.6191f,0.0000f}, + {38.0953f,4.7619f}, + {33.3334f,9.5238f}, + {28.5715f,23.8095f}, + {28.5715f,33.3333f} +}; + +static const GLUTStrokeStrip ch74st[] = +{ + {10,ch74st0} +}; + +static const GLUTStrokeChar ch74 = {104.7619f,1,ch74st}; + +/* char: 0x4b */ + +static const GLUTStrokeVertex ch75st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch75st1[] = +{ + {85.7143f,100.0000f}, + {19.0476f,33.3333f} +}; + +static const GLUTStrokeVertex ch75st2[] = +{ + {42.8571f,57.1429f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeStrip ch75st[] = +{ + {2,ch75st0}, + {2,ch75st1}, + {2,ch75st2} +}; + +static const GLUTStrokeChar ch75 = {104.7619f,3,ch75st}; + +/* char: 0x4c */ + +static const GLUTStrokeVertex ch76st0[] = +{ + {23.8095f,100.0000f}, + {23.8095f,0.0000f} +}; + +static const GLUTStrokeVertex ch76st1[] = +{ + {23.8095f,0.0000f}, + {80.9524f,0.0000f} +}; + +static const GLUTStrokeStrip ch76st[] = +{ + {2,ch76st0}, + {2,ch76st1} +}; + +static const GLUTStrokeChar ch76 = {104.7619f,2,ch76st}; + +/* char: 0x4d */ + +static const GLUTStrokeVertex ch77st0[] = +{ + {14.2857f,100.0000f}, + {14.2857f,0.0000f} +}; + +static const GLUTStrokeVertex ch77st1[] = +{ + {14.2857f,100.0000f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeVertex ch77st2[] = +{ + {90.4762f,100.0000f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeVertex ch77st3[] = +{ + {90.4762f,100.0000f}, + {90.4762f,0.0000f} +}; + +static const GLUTStrokeStrip ch77st[] = +{ + {2,ch77st0}, + {2,ch77st1}, + {2,ch77st2}, + {2,ch77st3} +}; + +static const GLUTStrokeChar ch77 = {104.7619f,4,ch77st}; + +/* char: 0x4e */ + +static const GLUTStrokeVertex ch78st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch78st1[] = +{ + {19.0476f,100.0000f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeVertex ch78st2[] = +{ + {85.7143f,100.0000f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeStrip ch78st[] = +{ + {2,ch78st0}, + {2,ch78st1}, + {2,ch78st2} +}; + +static const GLUTStrokeChar ch78 = {104.7619f,3,ch78st}; + +/* char: 0x4f */ + +static const GLUTStrokeVertex ch79st0[] = +{ + {42.8571f,100.0000f}, + {33.3333f,95.2381f}, + {23.8095f,85.7143f}, + {19.0476f,76.1905f}, + {14.2857f,61.9048f}, + {14.2857f,38.0952f}, + {19.0476f,23.8095f}, + {23.8095f,14.2857f}, + {33.3333f,4.7619f}, + {42.8571f,0.0000f}, + {61.9047f,0.0000f}, + {71.4286f,4.7619f}, + {80.9524f,14.2857f}, + {85.7143f,23.8095f}, + {90.4762f,38.0952f}, + {90.4762f,61.9048f}, + {85.7143f,76.1905f}, + {80.9524f,85.7143f}, + {71.4286f,95.2381f}, + {61.9047f,100.0000f}, + {42.8571f,100.0000f} +}; + +static const GLUTStrokeStrip ch79st[] = +{ + {21,ch79st0} +}; + +static const GLUTStrokeChar ch79 = {104.7619f,1,ch79st}; + +/* char: 0x50 */ + +static const GLUTStrokeVertex ch80st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch80st1[] = +{ + {19.0476f,100.0000f}, + {61.9047f,100.0000f}, + {76.1905f,95.2381f}, + {80.9524f,90.4762f}, + {85.7143f,80.9524f}, + {85.7143f,66.6667f}, + {80.9524f,57.1429f}, + {76.1905f,52.3810f}, + {61.9047f,47.6190f}, + {19.0476f,47.6190f} +}; + +static const GLUTStrokeStrip ch80st[] = +{ + {2,ch80st0}, + {10,ch80st1} +}; + +static const GLUTStrokeChar ch80 = {104.7619f,2,ch80st}; + +/* char: 0x51 */ + +static const GLUTStrokeVertex ch81st0[] = +{ + {42.8571f,100.0000f}, + {33.3333f,95.2381f}, + {23.8095f,85.7143f}, + {19.0476f,76.1905f}, + {14.2857f,61.9048f}, + {14.2857f,38.0952f}, + {19.0476f,23.8095f}, + {23.8095f,14.2857f}, + {33.3333f,4.7619f}, + {42.8571f,0.0000f}, + {61.9047f,0.0000f}, + {71.4286f,4.7619f}, + {80.9524f,14.2857f}, + {85.7143f,23.8095f}, + {90.4762f,38.0952f}, + {90.4762f,61.9048f}, + {85.7143f,76.1905f}, + {80.9524f,85.7143f}, + {71.4286f,95.2381f}, + {61.9047f,100.0000f}, + {42.8571f,100.0000f} +}; + +static const GLUTStrokeVertex ch81st1[] = +{ + {57.1428f,19.0476f}, + {85.7143f,-9.5238f} +}; + +static const GLUTStrokeStrip ch81st[] = +{ + {21,ch81st0}, + {2,ch81st1} +}; + +static const GLUTStrokeChar ch81 = {104.7619f,2,ch81st}; + +/* char: 0x52 */ + +static const GLUTStrokeVertex ch82st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch82st1[] = +{ + {19.0476f,100.0000f}, + {61.9047f,100.0000f}, + {76.1905f,95.2381f}, + {80.9524f,90.4762f}, + {85.7143f,80.9524f}, + {85.7143f,71.4286f}, + {80.9524f,61.9048f}, + {76.1905f,57.1429f}, + {61.9047f,52.3810f}, + {19.0476f,52.3810f} +}; + +static const GLUTStrokeVertex ch82st2[] = +{ + {52.3809f,52.3810f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeStrip ch82st[] = +{ + {2,ch82st0}, + {10,ch82st1}, + {2,ch82st2} +}; + +static const GLUTStrokeChar ch82 = {104.7619f,3,ch82st}; + +/* char: 0x53 */ + +static const GLUTStrokeVertex ch83st0[] = +{ + {85.7143f,85.7143f}, + {76.1905f,95.2381f}, + {61.9047f,100.0000f}, + {42.8571f,100.0000f}, + {28.5714f,95.2381f}, + {19.0476f,85.7143f}, + {19.0476f,76.1905f}, + {23.8095f,66.6667f}, + {28.5714f,61.9048f}, + {38.0952f,57.1429f}, + {66.6666f,47.6190f}, + {76.1905f,42.8571f}, + {80.9524f,38.0952f}, + {85.7143f,28.5714f}, + {85.7143f,14.2857f}, + {76.1905f,4.7619f}, + {61.9047f,0.0000f}, + {42.8571f,0.0000f}, + {28.5714f,4.7619f}, + {19.0476f,14.2857f} +}; + +static const GLUTStrokeStrip ch83st[] = +{ + {20,ch83st0} +}; + +static const GLUTStrokeChar ch83 = {104.7619f,1,ch83st}; + +/* char: 0x54 */ + +static const GLUTStrokeVertex ch84st0[] = +{ + {52.3809f,100.0000f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeVertex ch84st1[] = +{ + {19.0476f,100.0000f}, + {85.7143f,100.0000f} +}; + +static const GLUTStrokeStrip ch84st[] = +{ + {2,ch84st0}, + {2,ch84st1} +}; + +static const GLUTStrokeChar ch84 = {104.7619f,2,ch84st}; + +/* char: 0x55 */ + +static const GLUTStrokeVertex ch85st0[] = +{ + {19.0476f,100.0000f}, + {19.0476f,28.5714f}, + {23.8095f,14.2857f}, + {33.3333f,4.7619f}, + {47.6190f,0.0000f}, + {57.1428f,0.0000f}, + {71.4286f,4.7619f}, + {80.9524f,14.2857f}, + {85.7143f,28.5714f}, + {85.7143f,100.0000f} +}; + +static const GLUTStrokeStrip ch85st[] = +{ + {10,ch85st0} +}; + +static const GLUTStrokeChar ch85 = {104.7619f,1,ch85st}; + +/* char: 0x56 */ + +static const GLUTStrokeVertex ch86st0[] = +{ + {14.2857f,100.0000f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeVertex ch86st1[] = +{ + {90.4762f,100.0000f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeStrip ch86st[] = +{ + {2,ch86st0}, + {2,ch86st1} +}; + +static const GLUTStrokeChar ch86 = {104.7619f,2,ch86st}; + +/* char: 0x57 */ + +static const GLUTStrokeVertex ch87st0[] = +{ + {4.7619f,100.0000f}, + {28.5714f,0.0000f} +}; + +static const GLUTStrokeVertex ch87st1[] = +{ + {52.3809f,100.0000f}, + {28.5714f,0.0000f} +}; + +static const GLUTStrokeVertex ch87st2[] = +{ + {52.3809f,100.0000f}, + {76.1905f,0.0000f} +}; + +static const GLUTStrokeVertex ch87st3[] = +{ + {100.0000f,100.0000f}, + {76.1905f,0.0000f} +}; + +static const GLUTStrokeStrip ch87st[] = +{ + {2,ch87st0}, + {2,ch87st1}, + {2,ch87st2}, + {2,ch87st3} +}; + +static const GLUTStrokeChar ch87 = {104.7619f,4,ch87st}; + +/* char: 0x58 */ + +static const GLUTStrokeVertex ch88st0[] = +{ + {19.0476f,100.0000f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeVertex ch88st1[] = +{ + {85.7143f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeStrip ch88st[] = +{ + {2,ch88st0}, + {2,ch88st1} +}; + +static const GLUTStrokeChar ch88 = {104.7619f,2,ch88st}; + +/* char: 0x59 */ + +static const GLUTStrokeVertex ch89st0[] = +{ + {14.2857f,100.0000f}, + {52.3809f,52.3810f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeVertex ch89st1[] = +{ + {90.4762f,100.0000f}, + {52.3809f,52.3810f} +}; + +static const GLUTStrokeStrip ch89st[] = +{ + {3,ch89st0}, + {2,ch89st1} +}; + +static const GLUTStrokeChar ch89 = {104.7619f,2,ch89st}; + +/* char: 0x5a */ + +static const GLUTStrokeVertex ch90st0[] = +{ + {85.7143f,100.0000f}, + {19.0476f,0.0000f} +}; + +static const GLUTStrokeVertex ch90st1[] = +{ + {19.0476f,100.0000f}, + {85.7143f,100.0000f} +}; + +static const GLUTStrokeVertex ch90st2[] = +{ + {19.0476f,0.0000f}, + {85.7143f,0.0000f} +}; + +static const GLUTStrokeStrip ch90st[] = +{ + {2,ch90st0}, + {2,ch90st1}, + {2,ch90st2} +}; + +static const GLUTStrokeChar ch90 = {104.7619f,3,ch90st}; + +/* char: 0x5b */ + +static const GLUTStrokeVertex ch91st0[] = +{ + {35.7143f,119.0476f}, + {35.7143f,-33.3333f} +}; + +static const GLUTStrokeVertex ch91st1[] = +{ + {40.4762f,119.0476f}, + {40.4762f,-33.3333f} +}; + +static const GLUTStrokeVertex ch91st2[] = +{ + {35.7143f,119.0476f}, + {69.0476f,119.0476f} +}; + +static const GLUTStrokeVertex ch91st3[] = +{ + {35.7143f,-33.3333f}, + {69.0476f,-33.3333f} +}; + +static const GLUTStrokeStrip ch91st[] = +{ + {2,ch91st0}, + {2,ch91st1}, + {2,ch91st2}, + {2,ch91st3} +}; + +static const GLUTStrokeChar ch91 = {104.7619f,4,ch91st}; + +/* char: 0x5c */ + +static const GLUTStrokeVertex ch92st0[] = +{ + {19.0476f,100.0000f}, + {85.7143f,-14.2857f} +}; + +static const GLUTStrokeStrip ch92st[] = +{ + {2,ch92st0} +}; + +static const GLUTStrokeChar ch92 = {104.7619f,1,ch92st}; + +/* char: 0x5d */ + +static const GLUTStrokeVertex ch93st0[] = +{ + {64.2857f,119.0476f}, + {64.2857f,-33.3333f} +}; + +static const GLUTStrokeVertex ch93st1[] = +{ + {69.0476f,119.0476f}, + {69.0476f,-33.3333f} +}; + +static const GLUTStrokeVertex ch93st2[] = +{ + {35.7143f,119.0476f}, + {69.0476f,119.0476f} +}; + +static const GLUTStrokeVertex ch93st3[] = +{ + {35.7143f,-33.3333f}, + {69.0476f,-33.3333f} +}; + +static const GLUTStrokeStrip ch93st[] = +{ + {2,ch93st0}, + {2,ch93st1}, + {2,ch93st2}, + {2,ch93st3} +}; + +static const GLUTStrokeChar ch93 = {104.7619f,4,ch93st}; + +/* char: 0x5e */ + +static const GLUTStrokeVertex ch94st0[] = +{ + {52.3809f,109.5238f}, + {14.2857f,42.8571f} +}; + +static const GLUTStrokeVertex ch94st1[] = +{ + {52.3809f,109.5238f}, + {90.4762f,42.8571f} +}; + +static const GLUTStrokeStrip ch94st[] = +{ + {2,ch94st0}, + {2,ch94st1} +}; + +static const GLUTStrokeChar ch94 = {104.7619f,2,ch94st}; + +/* char: 0x5f */ + +static const GLUTStrokeVertex ch95st0[] = +{ + {0.0000f,-33.3333f}, + {104.7619f,-33.3333f}, + {104.7619f,-28.5714f}, + {0.0000f,-28.5714f}, + {0.0000f,-33.3333f} +}; + +static const GLUTStrokeStrip ch95st[] = +{ + {5,ch95st0} +}; + +static const GLUTStrokeChar ch95 = {104.7619f,1,ch95st}; + +/* char: 0x60 */ + +static const GLUTStrokeVertex ch96st0[] = +{ + {42.8572f,100.0000f}, + {66.6667f,71.4286f} +}; + +static const GLUTStrokeVertex ch96st1[] = +{ + {42.8572f,100.0000f}, + {38.0953f,95.2381f}, + {66.6667f,71.4286f} +}; + +static const GLUTStrokeStrip ch96st[] = +{ + {2,ch96st0}, + {3,ch96st1} +}; + +static const GLUTStrokeChar ch96 = {104.7619f,2,ch96st}; + +/* char: 0x61 */ + +static const GLUTStrokeVertex ch97st0[] = +{ + {80.9524f,66.6667f}, + {80.9524f,0.0000f} +}; + +static const GLUTStrokeVertex ch97st1[] = +{ + {80.9524f,52.3810f}, + {71.4285f,61.9048f}, + {61.9047f,66.6667f}, + {47.6190f,66.6667f}, + {38.0952f,61.9048f}, + {28.5714f,52.3810f}, + {23.8095f,38.0952f}, + {23.8095f,28.5714f}, + {28.5714f,14.2857f}, + {38.0952f,4.7619f}, + {47.6190f,0.0000f}, + {61.9047f,0.0000f}, + {71.4285f,4.7619f}, + {80.9524f,14.2857f} +}; + +static const GLUTStrokeStrip ch97st[] = +{ + {2,ch97st0}, + {14,ch97st1} +}; + +static const GLUTStrokeChar ch97 = {104.7619f,2,ch97st}; + +/* char: 0x62 */ + +static const GLUTStrokeVertex ch98st0[] = +{ + {23.8095f,100.0000f}, + {23.8095f,0.0000f} +}; + +static const GLUTStrokeVertex ch98st1[] = +{ + {23.8095f,52.3810f}, + {33.3333f,61.9048f}, + {42.8571f,66.6667f}, + {57.1428f,66.6667f}, + {66.6666f,61.9048f}, + {76.1905f,52.3810f}, + {80.9524f,38.0952f}, + {80.9524f,28.5714f}, + {76.1905f,14.2857f}, + {66.6666f,4.7619f}, + {57.1428f,0.0000f}, + {42.8571f,0.0000f}, + {33.3333f,4.7619f}, + {23.8095f,14.2857f} +}; + +static const GLUTStrokeStrip ch98st[] = +{ + {2,ch98st0}, + {14,ch98st1} +}; + +static const GLUTStrokeChar ch98 = {104.7619f,2,ch98st}; + +/* char: 0x63 */ + +static const GLUTStrokeVertex ch99st0[] = +{ + {80.9524f,52.3810f}, + {71.4285f,61.9048f}, + {61.9047f,66.6667f}, + {47.6190f,66.6667f}, + {38.0952f,61.9048f}, + {28.5714f,52.3810f}, + {23.8095f,38.0952f}, + {23.8095f,28.5714f}, + {28.5714f,14.2857f}, + {38.0952f,4.7619f}, + {47.6190f,0.0000f}, + {61.9047f,0.0000f}, + {71.4285f,4.7619f}, + {80.9524f,14.2857f} +}; + +static const GLUTStrokeStrip ch99st[] = +{ + {14,ch99st0} +}; + +static const GLUTStrokeChar ch99 = {104.7619f,1,ch99st}; + +/* char: 0x64 */ + +static const GLUTStrokeVertex ch100st0[] = +{ + {80.9524f,100.0000f}, + {80.9524f,0.0000f} +}; + +static const GLUTStrokeVertex ch100st1[] = +{ + {80.9524f,52.3810f}, + {71.4285f,61.9048f}, + {61.9047f,66.6667f}, + {47.6190f,66.6667f}, + {38.0952f,61.9048f}, + {28.5714f,52.3810f}, + {23.8095f,38.0952f}, + {23.8095f,28.5714f}, + {28.5714f,14.2857f}, + {38.0952f,4.7619f}, + {47.6190f,0.0000f}, + {61.9047f,0.0000f}, + {71.4285f,4.7619f}, + {80.9524f,14.2857f} +}; + +static const GLUTStrokeStrip ch100st[] = +{ + {2,ch100st0}, + {14,ch100st1} +}; + +static const GLUTStrokeChar ch100 = {104.7619f,2,ch100st}; + +/* char: 0x65 */ + +static const GLUTStrokeVertex ch101st0[] = +{ + {23.8095f,38.0952f}, + {80.9524f,38.0952f}, + {80.9524f,47.6190f}, + {76.1905f,57.1429f}, + {71.4285f,61.9048f}, + {61.9047f,66.6667f}, + {47.6190f,66.6667f}, + {38.0952f,61.9048f}, + {28.5714f,52.3810f}, + {23.8095f,38.0952f}, + {23.8095f,28.5714f}, + {28.5714f,14.2857f}, + {38.0952f,4.7619f}, + {47.6190f,0.0000f}, + {61.9047f,0.0000f}, + {71.4285f,4.7619f}, + {80.9524f,14.2857f} +}; + +static const GLUTStrokeStrip ch101st[] = +{ + {17,ch101st0} +}; + +static const GLUTStrokeChar ch101 = {104.7619f,1,ch101st}; + +/* char: 0x66 */ + +static const GLUTStrokeVertex ch102st0[] = +{ + {71.4286f,100.0000f}, + {61.9048f,100.0000f}, + {52.3810f,95.2381f}, + {47.6191f,80.9524f}, + {47.6191f,0.0000f} +}; + +static const GLUTStrokeVertex ch102st1[] = +{ + {33.3334f,66.6667f}, + {66.6667f,66.6667f} +}; + +static const GLUTStrokeStrip ch102st[] = +{ + {5,ch102st0}, + {2,ch102st1} +}; + +static const GLUTStrokeChar ch102 = {104.7619f,2,ch102st}; + +/* char: 0x67 */ + +static const GLUTStrokeVertex ch103st0[] = +{ + {80.9524f,66.6667f}, + {80.9524f,-9.5238f}, + {76.1905f,-23.8095f}, + {71.4285f,-28.5714f}, + {61.9047f,-33.3333f}, + {47.6190f,-33.3333f}, + {38.0952f,-28.5714f} +}; + +static const GLUTStrokeVertex ch103st1[] = +{ + {80.9524f,52.3810f}, + {71.4285f,61.9048f}, + {61.9047f,66.6667f}, + {47.6190f,66.6667f}, + {38.0952f,61.9048f}, + {28.5714f,52.3810f}, + {23.8095f,38.0952f}, + {23.8095f,28.5714f}, + {28.5714f,14.2857f}, + {38.0952f,4.7619f}, + {47.6190f,0.0000f}, + {61.9047f,0.0000f}, + {71.4285f,4.7619f}, + {80.9524f,14.2857f} +}; + +static const GLUTStrokeStrip ch103st[] = +{ + {7,ch103st0}, + {14,ch103st1} +}; + +static const GLUTStrokeChar ch103 = {104.7619f,2,ch103st}; + +/* char: 0x68 */ + +static const GLUTStrokeVertex ch104st0[] = +{ + {26.1905f,100.0000f}, + {26.1905f,0.0000f} +}; + +static const GLUTStrokeVertex ch104st1[] = +{ + {26.1905f,47.6190f}, + {40.4762f,61.9048f}, + {50.0000f,66.6667f}, + {64.2857f,66.6667f}, + {73.8095f,61.9048f}, + {78.5715f,47.6190f}, + {78.5715f,0.0000f} +}; + +static const GLUTStrokeStrip ch104st[] = +{ + {2,ch104st0}, + {7,ch104st1} +}; + +static const GLUTStrokeChar ch104 = {104.7619f,2,ch104st}; + +/* char: 0x69 */ + +static const GLUTStrokeVertex ch105st0[] = +{ + {47.6191f,100.0000f}, + {52.3810f,95.2381f}, + {57.1429f,100.0000f}, + {52.3810f,104.7619f}, + {47.6191f,100.0000f} +}; + +static const GLUTStrokeVertex ch105st1[] = +{ + {52.3810f,66.6667f}, + {52.3810f,0.0000f} +}; + +static const GLUTStrokeStrip ch105st[] = +{ + {5,ch105st0}, + {2,ch105st1} +}; + +static const GLUTStrokeChar ch105 = {104.7619f,2,ch105st}; + +/* char: 0x6a */ + +static const GLUTStrokeVertex ch106st0[] = +{ + {57.1429f,100.0000f}, + {61.9048f,95.2381f}, + {66.6667f,100.0000f}, + {61.9048f,104.7619f}, + {57.1429f,100.0000f} +}; + +static const GLUTStrokeVertex ch106st1[] = +{ + {61.9048f,66.6667f}, + {61.9048f,-14.2857f}, + {57.1429f,-28.5714f}, + {47.6191f,-33.3333f}, + {38.0953f,-33.3333f} +}; + +static const GLUTStrokeStrip ch106st[] = +{ + {5,ch106st0}, + {5,ch106st1} +}; + +static const GLUTStrokeChar ch106 = {104.7619f,2,ch106st}; + +/* char: 0x6b */ + +static const GLUTStrokeVertex ch107st0[] = +{ + {26.1905f,100.0000f}, + {26.1905f,0.0000f} +}; + +static const GLUTStrokeVertex ch107st1[] = +{ + {73.8095f,66.6667f}, + {26.1905f,19.0476f} +}; + +static const GLUTStrokeVertex ch107st2[] = +{ + {45.2381f,38.0952f}, + {78.5715f,0.0000f} +}; + +static const GLUTStrokeStrip ch107st[] = +{ + {2,ch107st0}, + {2,ch107st1}, + {2,ch107st2} +}; + +static const GLUTStrokeChar ch107 = {104.7619f,3,ch107st}; + +/* char: 0x6c */ + +static const GLUTStrokeVertex ch108st0[] = +{ + {52.3810f,100.0000f}, + {52.3810f,0.0000f} +}; + +static const GLUTStrokeStrip ch108st[] = +{ + {2,ch108st0} +}; + +static const GLUTStrokeChar ch108 = {104.7619f,1,ch108st}; + +/* char: 0x6d */ + +static const GLUTStrokeVertex ch109st0[] = +{ + {0.0000f,66.6667f}, + {0.0000f,0.0000f} +}; + +static const GLUTStrokeVertex ch109st1[] = +{ + {0.0000f,47.6190f}, + {14.2857f,61.9048f}, + {23.8095f,66.6667f}, + {38.0952f,66.6667f}, + {47.6190f,61.9048f}, + {52.3810f,47.6190f}, + {52.3810f,0.0000f} +}; + +static const GLUTStrokeVertex ch109st2[] = +{ + {52.3810f,47.6190f}, + {66.6667f,61.9048f}, + {76.1905f,66.6667f}, + {90.4762f,66.6667f}, + {100.0000f,61.9048f}, + {104.7619f,47.6190f}, + {104.7619f,0.0000f} +}; + +static const GLUTStrokeStrip ch109st[] = +{ + {2,ch109st0}, + {7,ch109st1}, + {7,ch109st2} +}; + +static const GLUTStrokeChar ch109 = {104.7619f,3,ch109st}; + +/* char: 0x6e */ + +static const GLUTStrokeVertex ch110st0[] = +{ + {26.1905f,66.6667f}, + {26.1905f,0.0000f} +}; + +static const GLUTStrokeVertex ch110st1[] = +{ + {26.1905f,47.6190f}, + {40.4762f,61.9048f}, + {50.0000f,66.6667f}, + {64.2857f,66.6667f}, + {73.8095f,61.9048f}, + {78.5715f,47.6190f}, + {78.5715f,0.0000f} +}; + +static const GLUTStrokeStrip ch110st[] = +{ + {2,ch110st0}, + {7,ch110st1} +}; + +static const GLUTStrokeChar ch110 = {104.7619f,2,ch110st}; + +/* char: 0x6f */ + +static const GLUTStrokeVertex ch111st0[] = +{ + {45.2381f,66.6667f}, + {35.7143f,61.9048f}, + {26.1905f,52.3810f}, + {21.4286f,38.0952f}, + {21.4286f,28.5714f}, + {26.1905f,14.2857f}, + {35.7143f,4.7619f}, + {45.2381f,0.0000f}, + {59.5238f,0.0000f}, + {69.0476f,4.7619f}, + {78.5714f,14.2857f}, + {83.3334f,28.5714f}, + {83.3334f,38.0952f}, + {78.5714f,52.3810f}, + {69.0476f,61.9048f}, + {59.5238f,66.6667f}, + {45.2381f,66.6667f} +}; + +static const GLUTStrokeStrip ch111st[] = +{ + {17,ch111st0} +}; + +static const GLUTStrokeChar ch111 = {104.7619f,1,ch111st}; + +/* char: 0x70 */ + +static const GLUTStrokeVertex ch112st0[] = +{ + {23.8095f,66.6667f}, + {23.8095f,-33.3333f} +}; + +static const GLUTStrokeVertex ch112st1[] = +{ + {23.8095f,52.3810f}, + {33.3333f,61.9048f}, + {42.8571f,66.6667f}, + {57.1428f,66.6667f}, + {66.6666f,61.9048f}, + {76.1905f,52.3810f}, + {80.9524f,38.0952f}, + {80.9524f,28.5714f}, + {76.1905f,14.2857f}, + {66.6666f,4.7619f}, + {57.1428f,0.0000f}, + {42.8571f,0.0000f}, + {33.3333f,4.7619f}, + {23.8095f,14.2857f} +}; + +static const GLUTStrokeStrip ch112st[] = +{ + {2,ch112st0}, + {14,ch112st1} +}; + +static const GLUTStrokeChar ch112 = {104.7619f,2,ch112st}; + +/* char: 0x71 */ + +static const GLUTStrokeVertex ch113st0[] = +{ + {80.9524f,66.6667f}, + {80.9524f,-33.3333f} +}; + +static const GLUTStrokeVertex ch113st1[] = +{ + {80.9524f,52.3810f}, + {71.4285f,61.9048f}, + {61.9047f,66.6667f}, + {47.6190f,66.6667f}, + {38.0952f,61.9048f}, + {28.5714f,52.3810f}, + {23.8095f,38.0952f}, + {23.8095f,28.5714f}, + {28.5714f,14.2857f}, + {38.0952f,4.7619f}, + {47.6190f,0.0000f}, + {61.9047f,0.0000f}, + {71.4285f,4.7619f}, + {80.9524f,14.2857f} +}; + +static const GLUTStrokeStrip ch113st[] = +{ + {2,ch113st0}, + {14,ch113st1} +}; + +static const GLUTStrokeChar ch113 = {104.7619f,2,ch113st}; + +/* char: 0x72 */ + +static const GLUTStrokeVertex ch114st0[] = +{ + {33.3334f,66.6667f}, + {33.3334f,0.0000f} +}; + +static const GLUTStrokeVertex ch114st1[] = +{ + {33.3334f,38.0952f}, + {38.0953f,52.3810f}, + {47.6191f,61.9048f}, + {57.1429f,66.6667f}, + {71.4286f,66.6667f} +}; + +static const GLUTStrokeStrip ch114st[] = +{ + {2,ch114st0}, + {5,ch114st1} +}; + +static const GLUTStrokeChar ch114 = {104.7619f,2,ch114st}; + +/* char: 0x73 */ + +static const GLUTStrokeVertex ch115st0[] = +{ + {78.5715f,52.3810f}, + {73.8095f,61.9048f}, + {59.5238f,66.6667f}, + {45.2381f,66.6667f}, + {30.9524f,61.9048f}, + {26.1905f,52.3810f}, + {30.9524f,42.8571f}, + {40.4762f,38.0952f}, + {64.2857f,33.3333f}, + {73.8095f,28.5714f}, + {78.5715f,19.0476f}, + {78.5715f,14.2857f}, + {73.8095f,4.7619f}, + {59.5238f,0.0000f}, + {45.2381f,0.0000f}, + {30.9524f,4.7619f}, + {26.1905f,14.2857f} +}; + +static const GLUTStrokeStrip ch115st[] = +{ + {17,ch115st0} +}; + +static const GLUTStrokeChar ch115 = {104.7619f,1,ch115st}; + +/* char: 0x74 */ + +static const GLUTStrokeVertex ch116st0[] = +{ + {47.6191f,100.0000f}, + {47.6191f,19.0476f}, + {52.3810f,4.7619f}, + {61.9048f,0.0000f}, + {71.4286f,0.0000f} +}; + +static const GLUTStrokeVertex ch116st1[] = +{ + {33.3334f,66.6667f}, + {66.6667f,66.6667f} +}; + +static const GLUTStrokeStrip ch116st[] = +{ + {5,ch116st0}, + {2,ch116st1} +}; + +static const GLUTStrokeChar ch116 = {104.7619f,2,ch116st}; + +/* char: 0x75 */ + +static const GLUTStrokeVertex ch117st0[] = +{ + {26.1905f,66.6667f}, + {26.1905f,19.0476f}, + {30.9524f,4.7619f}, + {40.4762f,0.0000f}, + {54.7619f,0.0000f}, + {64.2857f,4.7619f}, + {78.5715f,19.0476f} +}; + +static const GLUTStrokeVertex ch117st1[] = +{ + {78.5715f,66.6667f}, + {78.5715f,0.0000f} +}; + +static const GLUTStrokeStrip ch117st[] = +{ + {7,ch117st0}, + {2,ch117st1} +}; + +static const GLUTStrokeChar ch117 = {104.7619f,2,ch117st}; + +/* char: 0x76 */ + +static const GLUTStrokeVertex ch118st0[] = +{ + {23.8095f,66.6667f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeVertex ch118st1[] = +{ + {80.9524f,66.6667f}, + {52.3809f,0.0000f} +}; + +static const GLUTStrokeStrip ch118st[] = +{ + {2,ch118st0}, + {2,ch118st1} +}; + +static const GLUTStrokeChar ch118 = {104.7619f,2,ch118st}; + +/* char: 0x77 */ + +static const GLUTStrokeVertex ch119st0[] = +{ + {14.2857f,66.6667f}, + {33.3333f,0.0000f} +}; + +static const GLUTStrokeVertex ch119st1[] = +{ + {52.3809f,66.6667f}, + {33.3333f,0.0000f} +}; + +static const GLUTStrokeVertex ch119st2[] = +{ + {52.3809f,66.6667f}, + {71.4286f,0.0000f} +}; + +static const GLUTStrokeVertex ch119st3[] = +{ + {90.4762f,66.6667f}, + {71.4286f,0.0000f} +}; + +static const GLUTStrokeStrip ch119st[] = +{ + {2,ch119st0}, + {2,ch119st1}, + {2,ch119st2}, + {2,ch119st3} +}; + +static const GLUTStrokeChar ch119 = {104.7619f,4,ch119st}; + +/* char: 0x78 */ + +static const GLUTStrokeVertex ch120st0[] = +{ + {26.1905f,66.6667f}, + {78.5715f,0.0000f} +}; + +static const GLUTStrokeVertex ch120st1[] = +{ + {78.5715f,66.6667f}, + {26.1905f,0.0000f} +}; + +static const GLUTStrokeStrip ch120st[] = +{ + {2,ch120st0}, + {2,ch120st1} +}; + +static const GLUTStrokeChar ch120 = {104.7619f,2,ch120st}; + +/* char: 0x79 */ + +static const GLUTStrokeVertex ch121st0[] = +{ + {26.1905f,66.6667f}, + {54.7619f,0.0000f} +}; + +static const GLUTStrokeVertex ch121st1[] = +{ + {83.3334f,66.6667f}, + {54.7619f,0.0000f}, + {45.2381f,-19.0476f}, + {35.7143f,-28.5714f}, + {26.1905f,-33.3333f}, + {21.4286f,-33.3333f} +}; + +static const GLUTStrokeStrip ch121st[] = +{ + {2,ch121st0}, + {6,ch121st1} +}; + +static const GLUTStrokeChar ch121 = {104.7619f,2,ch121st}; + +/* char: 0x7a */ + +static const GLUTStrokeVertex ch122st0[] = +{ + {78.5715f,66.6667f}, + {26.1905f,0.0000f} +}; + +static const GLUTStrokeVertex ch122st1[] = +{ + {26.1905f,66.6667f}, + {78.5715f,66.6667f} +}; + +static const GLUTStrokeVertex ch122st2[] = +{ + {26.1905f,0.0000f}, + {78.5715f,0.0000f} +}; + +static const GLUTStrokeStrip ch122st[] = +{ + {2,ch122st0}, + {2,ch122st1}, + {2,ch122st2} +}; + +static const GLUTStrokeChar ch122 = {104.7619f,3,ch122st}; + +/* char: 0x7b */ + +static const GLUTStrokeVertex ch123st0[] = +{ + {64.2857f,119.0476f}, + {54.7619f,114.2857f}, + {50.0000f,109.5238f}, + {45.2381f,100.0000f}, + {45.2381f,90.4762f}, + {50.0000f,80.9524f}, + {54.7619f,76.1905f}, + {59.5238f,66.6667f}, + {59.5238f,57.1429f}, + {50.0000f,47.6190f} +}; + +static const GLUTStrokeVertex ch123st1[] = +{ + {54.7619f,114.2857f}, + {50.0000f,104.7619f}, + {50.0000f,95.2381f}, + {54.7619f,85.7143f}, + {59.5238f,80.9524f}, + {64.2857f,71.4286f}, + {64.2857f,61.9048f}, + {59.5238f,52.3810f}, + {40.4762f,42.8571f}, + {59.5238f,33.3333f}, + {64.2857f,23.8095f}, + {64.2857f,14.2857f}, + {59.5238f,4.7619f}, + {54.7619f,0.0000f}, + {50.0000f,-9.5238f}, + {50.0000f,-19.0476f}, + {54.7619f,-28.5714f} +}; + +static const GLUTStrokeVertex ch123st2[] = +{ + {50.0000f,38.0952f}, + {59.5238f,28.5714f}, + {59.5238f,19.0476f}, + {54.7619f,9.5238f}, + {50.0000f,4.7619f}, + {45.2381f,-4.7619f}, + {45.2381f,-14.2857f}, + {50.0000f,-23.8095f}, + {54.7619f,-28.5714f}, + {64.2857f,-33.3333f} +}; + +static const GLUTStrokeStrip ch123st[] = +{ + {10,ch123st0}, + {17,ch123st1}, + {10,ch123st2} +}; + +static const GLUTStrokeChar ch123 = {104.7619f,3,ch123st}; + +/* char: 0x7c */ + +static const GLUTStrokeVertex ch124st0[] = +{ + {52.3810f,119.0476f}, + {52.3810f,-33.3333f} +}; + +static const GLUTStrokeStrip ch124st[] = +{ + {2,ch124st0} +}; + +static const GLUTStrokeChar ch124 = {104.7619f,1,ch124st}; + +/* char: 0x7d */ + +static const GLUTStrokeVertex ch125st0[] = +{ + {40.4762f,119.0476f}, + {50.0000f,114.2857f}, + {54.7619f,109.5238f}, + {59.5238f,100.0000f}, + {59.5238f,90.4762f}, + {54.7619f,80.9524f}, + {50.0000f,76.1905f}, + {45.2381f,66.6667f}, + {45.2381f,57.1429f}, + {54.7619f,47.6190f} +}; + +static const GLUTStrokeVertex ch125st1[] = +{ + {50.0000f,114.2857f}, + {54.7619f,104.7619f}, + {54.7619f,95.2381f}, + {50.0000f,85.7143f}, + {45.2381f,80.9524f}, + {40.4762f,71.4286f}, + {40.4762f,61.9048f}, + {45.2381f,52.3810f}, + {64.2857f,42.8571f}, + {45.2381f,33.3333f}, + {40.4762f,23.8095f}, + {40.4762f,14.2857f}, + {45.2381f,4.7619f}, + {50.0000f,0.0000f}, + {54.7619f,-9.5238f}, + {54.7619f,-19.0476f}, + {50.0000f,-28.5714f} +}; + +static const GLUTStrokeVertex ch125st2[] = +{ + {54.7619f,38.0952f}, + {45.2381f,28.5714f}, + {45.2381f,19.0476f}, + {50.0000f,9.5238f}, + {54.7619f,4.7619f}, + {59.5238f,-4.7619f}, + {59.5238f,-14.2857f}, + {54.7619f,-23.8095f}, + {50.0000f,-28.5714f}, + {40.4762f,-33.3333f} +}; + +static const GLUTStrokeStrip ch125st[] = +{ + {10,ch125st0}, + {17,ch125st1}, + {10,ch125st2} +}; + +static const GLUTStrokeChar ch125 = {104.7619f,3,ch125st}; + +/* char: 0x7e */ + +static const GLUTStrokeVertex ch126st0[] = +{ + {9.5238f,28.5714f}, + {9.5238f,38.0952f}, + {14.2857f,52.3810f}, + {23.8095f,57.1429f}, + {33.3333f,57.1429f}, + {42.8571f,52.3810f}, + {61.9048f,38.0952f}, + {71.4286f,33.3333f}, + {80.9524f,33.3333f}, + {90.4762f,38.0952f}, + {95.2381f,47.6190f} +}; + +static const GLUTStrokeVertex ch126st1[] = +{ + {9.5238f,38.0952f}, + {14.2857f,47.6190f}, + {23.8095f,52.3810f}, + {33.3333f,52.3810f}, + {42.8571f,47.6190f}, + {61.9048f,33.3333f}, + {71.4286f,28.5714f}, + {80.9524f,28.5714f}, + {90.4762f,33.3333f}, + {95.2381f,47.6190f}, + {95.2381f,57.1429f} +}; + +static const GLUTStrokeStrip ch126st[] = +{ + {11,ch126st0}, + {11,ch126st1} +}; + +static const GLUTStrokeChar ch126 = {104.7619f,2,ch126st}; + +static const GLUTStrokeChar *chars[] = +{ + 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, + &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 +}; + +const GLUTStrokeFont glutStrokeMonoRoman = {"MonoRoman",128,chars,152.3809f,33.3333f}; diff --git a/src/glut/dos/overlay.c b/src/glut/dos/overlay.c new file mode 100644 index 000000000..46d3a3957 --- /dev/null +++ b/src/glut/dos/overlay.c @@ -0,0 +1,93 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "internal.h" + + +int APIENTRY +glutLayerGet (GLenum info) +{ + switch (info) { + case GLUT_OVERLAY_POSSIBLE: + case GLUT_HAS_OVERLAY: + return GL_FALSE; + case GLUT_LAYER_IN_USE: + return GLUT_NORMAL; + case GLUT_NORMAL_DAMAGED: + return GL_FALSE; + case GLUT_OVERLAY_DAMAGED: + case GLUT_TRANSPARENT_INDEX: + default: + return -1; + } +} + + +void APIENTRY +glutOverlayDisplayFunc (GLUTdisplayCB func) +{ +} + + +void APIENTRY +glutEstablishOverlay (void) +{ +} + + +void APIENTRY +glutRemoveOverlay (void) +{ +} + + +void APIENTRY +glutUseLayer (GLenum layer) +{ +} + + +void APIENTRY +glutPostOverlayRedisplay (void) +{ +} + + +void APIENTRY +glutShowOverlay (void) +{ +} + + +void APIENTRY +glutHideOverlay (void) +{ +} + + +void APIENTRY +glutPostWindowOverlayRedisplay (int win) +{ +} diff --git a/src/glut/dos/roman.c b/src/glut/dos/roman.c new file mode 100644 index 000000000..89867c8f6 --- /dev/null +++ b/src/glut/dos/roman.c @@ -0,0 +1,2783 @@ + +/* GENERATED FILE -- DO NOT MODIFY */ + +#include "internal.h" + +/* char: 0x20 */ + +static const GLUTStrokeStrip ch32st[] = +{ +}; + +static const GLUTStrokeChar ch32 = {104.7619f,0,ch32st}; + +/* char: 0x21 */ + +static const GLUTStrokeVertex ch33st0[] = +{ + {13.3819f,100.0000f}, + {13.3819f,33.3333f} +}; + +static const GLUTStrokeVertex ch33st1[] = +{ + {13.3819f,9.5238f}, + {8.6200f,4.7619f}, + {13.3819f,0.0000f}, + {18.1438f,4.7619f}, + {13.3819f,9.5238f} +}; + +static const GLUTStrokeStrip ch33st[] = +{ + {2,ch33st0}, + {5,ch33st1} +}; + +static const GLUTStrokeChar ch33 = {26.6238f,2,ch33st}; + +/* char: 0x22 */ + +static const GLUTStrokeVertex ch34st0[] = +{ + {4.0200f,100.0000f}, + {4.0200f,66.6667f} +}; + +static const GLUTStrokeVertex ch34st1[] = +{ + {42.1152f,100.0000f}, + {42.1152f,66.6667f} +}; + +static const GLUTStrokeStrip ch34st[] = +{ + {2,ch34st0}, + {2,ch34st1} +}; + +static const GLUTStrokeChar ch34 = {51.4352f,2,ch34st}; + +/* char: 0x23 */ + +static const GLUTStrokeVertex ch35st0[] = +{ + {41.2952f,119.0476f}, + {7.9619f,-33.3333f} +}; + +static const GLUTStrokeVertex ch35st1[] = +{ + {69.8667f,119.0476f}, + {36.5333f,-33.3333f} +}; + +static const GLUTStrokeVertex ch35st2[] = +{ + {7.9619f,57.1429f}, + {74.6286f,57.1429f} +}; + +static const GLUTStrokeVertex ch35st3[] = +{ + {3.2000f,28.5714f}, + {69.8667f,28.5714f} +}; + +static const GLUTStrokeStrip ch35st[] = +{ + {2,ch35st0}, + {2,ch35st1}, + {2,ch35st2}, + {2,ch35st3} +}; + +static const GLUTStrokeChar ch35 = {79.4886f,4,ch35st}; + +/* char: 0x24 */ + +static const GLUTStrokeVertex ch36st0[] = +{ + {28.6295f,119.0476f}, + {28.6295f,-19.0476f} +}; + +static const GLUTStrokeVertex ch36st1[] = +{ + {47.6771f,119.0476f}, + {47.6771f,-19.0476f} +}; + +static const GLUTStrokeVertex ch36st2[] = +{ + {71.4867f,85.7143f}, + {61.9629f,95.2381f}, + {47.6771f,100.0000f}, + {28.6295f,100.0000f}, + {14.3438f,95.2381f}, + {4.8200f,85.7143f}, + {4.8200f,76.1905f}, + {9.5819f,66.6667f}, + {14.3438f,61.9048f}, + {23.8676f,57.1429f}, + {52.4390f,47.6190f}, + {61.9629f,42.8571f}, + {66.7248f,38.0952f}, + {71.4867f,28.5714f}, + {71.4867f,14.2857f}, + {61.9629f,4.7619f}, + {47.6771f,0.0000f}, + {28.6295f,0.0000f}, + {14.3438f,4.7619f}, + {4.8200f,14.2857f} +}; + +static const GLUTStrokeStrip ch36st[] = +{ + {2,ch36st0}, + {2,ch36st1}, + {20,ch36st2} +}; + +static const GLUTStrokeChar ch36 = {76.2067f,3,ch36st}; + +/* char: 0x25 */ + +static const GLUTStrokeVertex ch37st0[] = +{ + {92.0743f,100.0000f}, + {6.3600f,0.0000f} +}; + +static const GLUTStrokeVertex ch37st1[] = +{ + {30.1695f,100.0000f}, + {39.6933f,90.4762f}, + {39.6933f,80.9524f}, + {34.9314f,71.4286f}, + {25.4076f,66.6667f}, + {15.8838f,66.6667f}, + {6.3600f,76.1905f}, + {6.3600f,85.7143f}, + {11.1219f,95.2381f}, + {20.6457f,100.0000f}, + {30.1695f,100.0000f}, + {39.6933f,95.2381f}, + {53.9790f,90.4762f}, + {68.2648f,90.4762f}, + {82.5505f,95.2381f}, + {92.0743f,100.0000f} +}; + +static const GLUTStrokeVertex ch37st2[] = +{ + {73.0267f,33.3333f}, + {63.5029f,28.5714f}, + {58.7410f,19.0476f}, + {58.7410f,9.5238f}, + {68.2648f,0.0000f}, + {77.7886f,0.0000f}, + {87.3124f,4.7619f}, + {92.0743f,14.2857f}, + {92.0743f,23.8095f}, + {82.5505f,33.3333f}, + {73.0267f,33.3333f} +}; + +static const GLUTStrokeStrip ch37st[] = +{ + {2,ch37st0}, + {16,ch37st1}, + {11,ch37st2} +}; + +static const GLUTStrokeChar ch37 = {96.5743f,3,ch37st}; + +/* char: 0x26 */ + +static const GLUTStrokeVertex ch38st0[] = +{ + {101.2181f,57.1429f}, + {101.2181f,61.9048f}, + {96.4562f,66.6667f}, + {91.6943f,66.6667f}, + {86.9324f,61.9048f}, + {82.1705f,52.3810f}, + {72.6467f,28.5714f}, + {63.1229f,14.2857f}, + {53.5990f,4.7619f}, + {44.0752f,0.0000f}, + {25.0276f,0.0000f}, + {15.5038f,4.7619f}, + {10.7419f,9.5238f}, + {5.9800f,19.0476f}, + {5.9800f,28.5714f}, + {10.7419f,38.0952f}, + {15.5038f,42.8571f}, + {48.8371f,61.9048f}, + {53.5990f,66.6667f}, + {58.3610f,76.1905f}, + {58.3610f,85.7143f}, + {53.5990f,95.2381f}, + {44.0752f,100.0000f}, + {34.5514f,95.2381f}, + {29.7895f,85.7143f}, + {29.7895f,76.1905f}, + {34.5514f,61.9048f}, + {44.0752f,47.6190f}, + {67.8848f,14.2857f}, + {77.4086f,4.7619f}, + {86.9324f,0.0000f}, + {96.4562f,0.0000f}, + {101.2181f,4.7619f}, + {101.2181f,9.5238f} +}; + +static const GLUTStrokeStrip ch38st[] = +{ + {34,ch38st0} +}; + +static const GLUTStrokeChar ch38 = {101.7581f,1,ch38st}; + +/* char: 0x27 */ + +static const GLUTStrokeVertex ch39st0[] = +{ + {4.4400f,100.0000f}, + {4.4400f,66.6667f} +}; + +static const GLUTStrokeStrip ch39st[] = +{ + {2,ch39st0} +}; + +static const GLUTStrokeChar ch39 = {13.6200f,1,ch39st}; + +/* char: 0x28 */ + +static const GLUTStrokeVertex ch40st0[] = +{ + {40.9133f,119.0476f}, + {31.3895f,109.5238f}, + {21.8657f,95.2381f}, + {12.3419f,76.1905f}, + {7.5800f,52.3810f}, + {7.5800f,33.3333f}, + {12.3419f,9.5238f}, + {21.8657f,-9.5238f}, + {31.3895f,-23.8095f}, + {40.9133f,-33.3333f} +}; + +static const GLUTStrokeStrip ch40st[] = +{ + {10,ch40st0} +}; + +static const GLUTStrokeChar ch40 = {47.1733f,1,ch40st}; + +/* char: 0x29 */ + +static const GLUTStrokeVertex ch41st0[] = +{ + {5.2800f,119.0476f}, + {14.8038f,109.5238f}, + {24.3276f,95.2381f}, + {33.8514f,76.1905f}, + {38.6133f,52.3810f}, + {38.6133f,33.3333f}, + {33.8514f,9.5238f}, + {24.3276f,-9.5238f}, + {14.8038f,-23.8095f}, + {5.2800f,-33.3333f} +}; + +static const GLUTStrokeStrip ch41st[] = +{ + {10,ch41st0} +}; + +static const GLUTStrokeChar ch41 = {47.5333f,1,ch41st}; + +/* char: 0x2a */ + +static const GLUTStrokeVertex ch42st0[] = +{ + {30.7695f,71.4286f}, + {30.7695f,14.2857f} +}; + +static const GLUTStrokeVertex ch42st1[] = +{ + {6.9600f,57.1429f}, + {54.5790f,28.5714f} +}; + +static const GLUTStrokeVertex ch42st2[] = +{ + {54.5790f,57.1429f}, + {6.9600f,28.5714f} +}; + +static const GLUTStrokeStrip ch42st[] = +{ + {2,ch42st0}, + {2,ch42st1}, + {2,ch42st2} +}; + +static const GLUTStrokeChar ch42 = {59.4390f,3,ch42st}; + +/* char: 0x2b */ + +static const GLUTStrokeVertex ch43st0[] = +{ + {48.8371f,85.7143f}, + {48.8371f,0.0000f} +}; + +static const GLUTStrokeVertex ch43st1[] = +{ + {5.9800f,42.8571f}, + {91.6943f,42.8571f} +}; + +static const GLUTStrokeStrip ch43st[] = +{ + {2,ch43st0}, + {2,ch43st1} +}; + +static const GLUTStrokeChar ch43 = {97.2543f,2,ch43st}; + +/* char: 0x2c */ + +static const GLUTStrokeVertex ch44st0[] = +{ + {18.2838f,4.7619f}, + {13.5219f,0.0000f}, + {8.7600f,4.7619f}, + {13.5219f,9.5238f}, + {18.2838f,4.7619f}, + {18.2838f,-4.7619f}, + {13.5219f,-14.2857f}, + {8.7600f,-19.0476f} +}; + +static const GLUTStrokeStrip ch44st[] = +{ + {8,ch44st0} +}; + +static const GLUTStrokeChar ch44 = {26.0638f,1,ch44st}; + +/* char: 0x2d */ + +static const GLUTStrokeVertex ch45st0[] = +{ + {7.3800f,42.8571f}, + {93.0943f,42.8571f} +}; + +static const GLUTStrokeStrip ch45st[] = +{ + {2,ch45st0} +}; + +static const GLUTStrokeChar ch45 = {100.7543f,1,ch45st}; + +/* char: 0x2e */ + +static const GLUTStrokeVertex ch46st0[] = +{ + {13.1019f,9.5238f}, + {8.3400f,4.7619f}, + {13.1019f,0.0000f}, + {17.8638f,4.7619f}, + {13.1019f,9.5238f} +}; + +static const GLUTStrokeStrip ch46st[] = +{ + {5,ch46st0} +}; + +static const GLUTStrokeChar ch46 = {26.4838f,1,ch46st}; + +/* char: 0x2f */ + +static const GLUTStrokeVertex ch47st0[] = +{ + {7.2400f,-14.2857f}, + {73.9067f,100.0000f} +}; + +static const GLUTStrokeStrip ch47st[] = +{ + {2,ch47st0} +}; + +static const GLUTStrokeChar ch47 = {82.1067f,1,ch47st}; + +/* char: 0x30 */ + +static const GLUTStrokeVertex ch48st0[] = +{ + {33.5514f,100.0000f}, + {19.2657f,95.2381f}, + {9.7419f,80.9524f}, + {4.9800f,57.1429f}, + {4.9800f,42.8571f}, + {9.7419f,19.0476f}, + {19.2657f,4.7619f}, + {33.5514f,0.0000f}, + {43.0752f,0.0000f}, + {57.3610f,4.7619f}, + {66.8848f,19.0476f}, + {71.6467f,42.8571f}, + {71.6467f,57.1429f}, + {66.8848f,80.9524f}, + {57.3610f,95.2381f}, + {43.0752f,100.0000f}, + {33.5514f,100.0000f} +}; + +static const GLUTStrokeStrip ch48st[] = +{ + {17,ch48st0} +}; + +static const GLUTStrokeChar ch48 = {77.0667f,1,ch48st}; + +/* char: 0x31 */ + +static const GLUTStrokeVertex ch49st0[] = +{ + {11.8200f,80.9524f}, + {21.3438f,85.7143f}, + {35.6295f,100.0000f}, + {35.6295f,0.0000f} +}; + +static const GLUTStrokeStrip ch49st[] = +{ + {4,ch49st0} +}; + +static const GLUTStrokeChar ch49 = {66.5295f,1,ch49st}; + +/* char: 0x32 */ + +static const GLUTStrokeVertex ch50st0[] = +{ + {10.1819f,76.1905f}, + {10.1819f,80.9524f}, + {14.9438f,90.4762f}, + {19.7057f,95.2381f}, + {29.2295f,100.0000f}, + {48.2771f,100.0000f}, + {57.8010f,95.2381f}, + {62.5629f,90.4762f}, + {67.3248f,80.9524f}, + {67.3248f,71.4286f}, + {62.5629f,61.9048f}, + {53.0390f,47.6190f}, + {5.4200f,0.0000f}, + {72.0867f,0.0000f} +}; + +static const GLUTStrokeStrip ch50st[] = +{ + {14,ch50st0} +}; + +static const GLUTStrokeChar ch50 = {77.6467f,1,ch50st}; + +/* char: 0x33 */ + +static const GLUTStrokeVertex ch51st0[] = +{ + {14.5238f,100.0000f}, + {66.9048f,100.0000f}, + {38.3333f,61.9048f}, + {52.6190f,61.9048f}, + {62.1429f,57.1429f}, + {66.9048f,52.3810f}, + {71.6667f,38.0952f}, + {71.6667f,28.5714f}, + {66.9048f,14.2857f}, + {57.3810f,4.7619f}, + {43.0952f,0.0000f}, + {28.8095f,0.0000f}, + {14.5238f,4.7619f}, + {9.7619f,9.5238f}, + {5.0000f,19.0476f} +}; + +static const GLUTStrokeStrip ch51st[] = +{ + {15,ch51st0} +}; + +static const GLUTStrokeChar ch51 = {77.0467f,1,ch51st}; + +/* char: 0x34 */ + +static const GLUTStrokeVertex ch52st0[] = +{ + {51.4990f,100.0000f}, + {3.8800f,33.3333f}, + {75.3086f,33.3333f} +}; + +static const GLUTStrokeVertex ch52st1[] = +{ + {51.4990f,100.0000f}, + {51.4990f,0.0000f} +}; + +static const GLUTStrokeStrip ch52st[] = +{ + {3,ch52st0}, + {2,ch52st1} +}; + +static const GLUTStrokeChar ch52 = {80.1686f,2,ch52st}; + +/* char: 0x35 */ + +static const GLUTStrokeVertex ch53st0[] = +{ + {62.0029f,100.0000f}, + {14.3838f,100.0000f}, + {9.6219f,57.1429f}, + {14.3838f,61.9048f}, + {28.6695f,66.6667f}, + {42.9552f,66.6667f}, + {57.2410f,61.9048f}, + {66.7648f,52.3810f}, + {71.5267f,38.0952f}, + {71.5267f,28.5714f}, + {66.7648f,14.2857f}, + {57.2410f,4.7619f}, + {42.9552f,0.0000f}, + {28.6695f,0.0000f}, + {14.3838f,4.7619f}, + {9.6219f,9.5238f}, + {4.8600f,19.0476f} +}; + +static const GLUTStrokeStrip ch53st[] = +{ + {17,ch53st0} +}; + +static const GLUTStrokeChar ch53 = {77.6867f,1,ch53st}; + +/* char: 0x36 */ + +static const GLUTStrokeVertex ch54st0[] = +{ + {62.7229f,85.7143f}, + {57.9610f,95.2381f}, + {43.6752f,100.0000f}, + {34.1514f,100.0000f}, + {19.8657f,95.2381f}, + {10.3419f,80.9524f}, + {5.5800f,57.1429f}, + {5.5800f,33.3333f}, + {10.3419f,14.2857f}, + {19.8657f,4.7619f}, + {34.1514f,0.0000f}, + {38.9133f,0.0000f}, + {53.1990f,4.7619f}, + {62.7229f,14.2857f}, + {67.4848f,28.5714f}, + {67.4848f,33.3333f}, + {62.7229f,47.6190f}, + {53.1990f,57.1429f}, + {38.9133f,61.9048f}, + {34.1514f,61.9048f}, + {19.8657f,57.1429f}, + {10.3419f,47.6190f}, + {5.5800f,33.3333f} +}; + +static const GLUTStrokeStrip ch54st[] = +{ + {23,ch54st0} +}; + +static const GLUTStrokeChar ch54 = {73.8048f,1,ch54st}; + +/* char: 0x37 */ + +static const GLUTStrokeVertex ch55st0[] = +{ + {72.2267f,100.0000f}, + {24.6076f,0.0000f} +}; + +static const GLUTStrokeVertex ch55st1[] = +{ + {5.5600f,100.0000f}, + {72.2267f,100.0000f} +}; + +static const GLUTStrokeStrip ch55st[] = +{ + {2,ch55st0}, + {2,ch55st1} +}; + +static const GLUTStrokeChar ch55 = {77.2267f,2,ch55st}; + +/* char: 0x38 */ + +static const GLUTStrokeVertex ch56st0[] = +{ + {29.4095f,100.0000f}, + {15.1238f,95.2381f}, + {10.3619f,85.7143f}, + {10.3619f,76.1905f}, + {15.1238f,66.6667f}, + {24.6476f,61.9048f}, + {43.6952f,57.1429f}, + {57.9810f,52.3810f}, + {67.5048f,42.8571f}, + {72.2667f,33.3333f}, + {72.2667f,19.0476f}, + {67.5048f,9.5238f}, + {62.7429f,4.7619f}, + {48.4571f,0.0000f}, + {29.4095f,0.0000f}, + {15.1238f,4.7619f}, + {10.3619f,9.5238f}, + {5.6000f,19.0476f}, + {5.6000f,33.3333f}, + {10.3619f,42.8571f}, + {19.8857f,52.3810f}, + {34.1714f,57.1429f}, + {53.2190f,61.9048f}, + {62.7429f,66.6667f}, + {67.5048f,76.1905f}, + {67.5048f,85.7143f}, + {62.7429f,95.2381f}, + {48.4571f,100.0000f}, + {29.4095f,100.0000f} +}; + +static const GLUTStrokeStrip ch56st[] = +{ + {29,ch56st0} +}; + +static const GLUTStrokeChar ch56 = {77.6667f,1,ch56st}; + +/* char: 0x39 */ + +static const GLUTStrokeVertex ch57st0[] = +{ + {68.5048f,66.6667f}, + {63.7429f,52.3810f}, + {54.2190f,42.8571f}, + {39.9333f,38.0952f}, + {35.1714f,38.0952f}, + {20.8857f,42.8571f}, + {11.3619f,52.3810f}, + {6.6000f,66.6667f}, + {6.6000f,71.4286f}, + {11.3619f,85.7143f}, + {20.8857f,95.2381f}, + {35.1714f,100.0000f}, + {39.9333f,100.0000f}, + {54.2190f,95.2381f}, + {63.7429f,85.7143f}, + {68.5048f,66.6667f}, + {68.5048f,42.8571f}, + {63.7429f,19.0476f}, + {54.2190f,4.7619f}, + {39.9333f,0.0000f}, + {30.4095f,0.0000f}, + {16.1238f,4.7619f}, + {11.3619f,14.2857f} +}; + +static const GLUTStrokeStrip ch57st[] = +{ + {23,ch57st0} +}; + +static const GLUTStrokeChar ch57 = {74.0648f,1,ch57st}; + +/* char: 0x3a */ + +static const GLUTStrokeVertex ch58st0[] = +{ + {14.0819f,66.6667f}, + {9.3200f,61.9048f}, + {14.0819f,57.1429f}, + {18.8438f,61.9048f}, + {14.0819f,66.6667f} +}; + +static const GLUTStrokeVertex ch58st1[] = +{ + {14.0819f,9.5238f}, + {9.3200f,4.7619f}, + {14.0819f,0.0000f}, + {18.8438f,4.7619f}, + {14.0819f,9.5238f} +}; + +static const GLUTStrokeStrip ch58st[] = +{ + {5,ch58st0}, + {5,ch58st1} +}; + +static const GLUTStrokeChar ch58 = {26.2238f,2,ch58st}; + +/* char: 0x3b */ + +static const GLUTStrokeVertex ch59st0[] = +{ + {12.9619f,66.6667f}, + {8.2000f,61.9048f}, + {12.9619f,57.1429f}, + {17.7238f,61.9048f}, + {12.9619f,66.6667f} +}; + +static const GLUTStrokeVertex ch59st1[] = +{ + {17.7238f,4.7619f}, + {12.9619f,0.0000f}, + {8.2000f,4.7619f}, + {12.9619f,9.5238f}, + {17.7238f,4.7619f}, + {17.7238f,-4.7619f}, + {12.9619f,-14.2857f}, + {8.2000f,-19.0476f} +}; + +static const GLUTStrokeStrip ch59st[] = +{ + {5,ch59st0}, + {8,ch59st1} +}; + +static const GLUTStrokeChar ch59 = {26.3038f,2,ch59st}; + +/* char: 0x3c */ + +static const GLUTStrokeVertex ch60st0[] = +{ + {79.2505f,85.7143f}, + {3.0600f,42.8571f}, + {79.2505f,0.0000f} +}; + +static const GLUTStrokeStrip ch60st[] = +{ + {3,ch60st0} +}; + +static const GLUTStrokeChar ch60 = {81.6105f,1,ch60st}; + +/* char: 0x3d */ + +static const GLUTStrokeVertex ch61st0[] = +{ + {5.7000f,57.1429f}, + {91.4143f,57.1429f} +}; + +static const GLUTStrokeVertex ch61st1[] = +{ + {5.7000f,28.5714f}, + {91.4143f,28.5714f} +}; + +static const GLUTStrokeStrip ch61st[] = +{ + {2,ch61st0}, + {2,ch61st1} +}; + +static const GLUTStrokeChar ch61 = {97.2543f,2,ch61st}; + +/* char: 0x3e */ + +static const GLUTStrokeVertex ch62st0[] = +{ + {2.7800f,85.7143f}, + {78.9705f,42.8571f}, + {2.7800f,0.0000f} +}; + +static const GLUTStrokeStrip ch62st[] = +{ + {3,ch62st0} +}; + +static const GLUTStrokeChar ch62 = {81.6105f,1,ch62st}; + +/* char: 0x3f */ + +static const GLUTStrokeVertex ch63st0[] = +{ + {8.4200f,76.1905f}, + {8.4200f,80.9524f}, + {13.1819f,90.4762f}, + {17.9438f,95.2381f}, + {27.4676f,100.0000f}, + {46.5152f,100.0000f}, + {56.0390f,95.2381f}, + {60.8010f,90.4762f}, + {65.5629f,80.9524f}, + {65.5629f,71.4286f}, + {60.8010f,61.9048f}, + {56.0390f,57.1429f}, + {36.9914f,47.6190f}, + {36.9914f,33.3333f} +}; + +static const GLUTStrokeVertex ch63st1[] = +{ + {36.9914f,9.5238f}, + {32.2295f,4.7619f}, + {36.9914f,0.0000f}, + {41.7533f,4.7619f}, + {36.9914f,9.5238f} +}; + +static const GLUTStrokeStrip ch63st[] = +{ + {14,ch63st0}, + {5,ch63st1} +}; + +static const GLUTStrokeChar ch63 = {73.9029f,2,ch63st}; + +/* char: 0x40 */ + +static const GLUTStrokeVertex ch64st0[] = +{ + {49.2171f,52.3810f}, + {39.6933f,57.1429f}, + {30.1695f,57.1429f}, + {25.4076f,47.6190f}, + {25.4076f,42.8571f}, + {30.1695f,33.3333f}, + {39.6933f,33.3333f}, + {49.2171f,38.0952f} +}; + +static const GLUTStrokeVertex ch64st1[] = +{ + {49.2171f,57.1429f}, + {49.2171f,38.0952f}, + {53.9790f,33.3333f}, + {63.5029f,33.3333f}, + {68.2648f,42.8571f}, + {68.2648f,47.6190f}, + {63.5029f,61.9048f}, + {53.9790f,71.4286f}, + {39.6933f,76.1905f}, + {34.9314f,76.1905f}, + {20.6457f,71.4286f}, + {11.1219f,61.9048f}, + {6.3600f,47.6190f}, + {6.3600f,42.8571f}, + {11.1219f,28.5714f}, + {20.6457f,19.0476f}, + {34.9314f,14.2857f}, + {39.6933f,14.2857f}, + {53.9790f,19.0476f} +}; + +static const GLUTStrokeStrip ch64st[] = +{ + {8,ch64st0}, + {19,ch64st1} +}; + +static const GLUTStrokeChar ch64 = {74.3648f,2,ch64st}; + +/* char: 0x41 */ + +static const GLUTStrokeVertex ch65st0[] = +{ + {40.5952f,100.0000f}, + {2.5000f,0.0000f} +}; + +static const GLUTStrokeVertex ch65st1[] = +{ + {40.5952f,100.0000f}, + {78.6905f,0.0000f} +}; + +static const GLUTStrokeVertex ch65st2[] = +{ + {16.7857f,33.3333f}, + {64.4048f,33.3333f} +}; + +static const GLUTStrokeStrip ch65st[] = +{ + {2,ch65st0}, + {2,ch65st1}, + {2,ch65st2} +}; + +static const GLUTStrokeChar ch65 = {80.4905f,3,ch65st}; + +/* char: 0x42 */ + +static const GLUTStrokeVertex ch66st0[] = +{ + {11.4200f,100.0000f}, + {11.4200f,0.0000f} +}; + +static const GLUTStrokeVertex ch66st1[] = +{ + {11.4200f,100.0000f}, + {54.2771f,100.0000f}, + {68.5629f,95.2381f}, + {73.3248f,90.4762f}, + {78.0867f,80.9524f}, + {78.0867f,71.4286f}, + {73.3248f,61.9048f}, + {68.5629f,57.1429f}, + {54.2771f,52.3810f} +}; + +static const GLUTStrokeVertex ch66st2[] = +{ + {11.4200f,52.3810f}, + {54.2771f,52.3810f}, + {68.5629f,47.6190f}, + {73.3248f,42.8571f}, + {78.0867f,33.3333f}, + {78.0867f,19.0476f}, + {73.3248f,9.5238f}, + {68.5629f,4.7619f}, + {54.2771f,0.0000f}, + {11.4200f,0.0000f} +}; + +static const GLUTStrokeStrip ch66st[] = +{ + {2,ch66st0}, + {9,ch66st1}, + {10,ch66st2} +}; + +static const GLUTStrokeChar ch66 = {83.6267f,3,ch66st}; + +/* char: 0x43 */ + +static const GLUTStrokeVertex ch67st0[] = +{ + {78.0886f,76.1905f}, + {73.3267f,85.7143f}, + {63.8029f,95.2381f}, + {54.2790f,100.0000f}, + {35.2314f,100.0000f}, + {25.7076f,95.2381f}, + {16.1838f,85.7143f}, + {11.4219f,76.1905f}, + {6.6600f,61.9048f}, + {6.6600f,38.0952f}, + {11.4219f,23.8095f}, + {16.1838f,14.2857f}, + {25.7076f,4.7619f}, + {35.2314f,0.0000f}, + {54.2790f,0.0000f}, + {63.8029f,4.7619f}, + {73.3267f,14.2857f}, + {78.0886f,23.8095f} +}; + +static const GLUTStrokeStrip ch67st[] = +{ + {18,ch67st0} +}; + +static const GLUTStrokeChar ch67 = {84.4886f,1,ch67st}; + +/* char: 0x44 */ + +static const GLUTStrokeVertex ch68st0[] = +{ + {11.9600f,100.0000f}, + {11.9600f,0.0000f} +}; + +static const GLUTStrokeVertex ch68st1[] = +{ + {11.9600f,100.0000f}, + {45.2933f,100.0000f}, + {59.5790f,95.2381f}, + {69.1029f,85.7143f}, + {73.8648f,76.1905f}, + {78.6267f,61.9048f}, + {78.6267f,38.0952f}, + {73.8648f,23.8095f}, + {69.1029f,14.2857f}, + {59.5790f,4.7619f}, + {45.2933f,0.0000f}, + {11.9600f,0.0000f} +}; + +static const GLUTStrokeStrip ch68st[] = +{ + {2,ch68st0}, + {12,ch68st1} +}; + +static const GLUTStrokeChar ch68 = {85.2867f,2,ch68st}; + +/* char: 0x45 */ + +static const GLUTStrokeVertex ch69st0[] = +{ + {11.4200f,100.0000f}, + {11.4200f,0.0000f} +}; + +static const GLUTStrokeVertex ch69st1[] = +{ + {11.4200f,100.0000f}, + {73.3248f,100.0000f} +}; + +static const GLUTStrokeVertex ch69st2[] = +{ + {11.4200f,52.3810f}, + {49.5152f,52.3810f} +}; + +static const GLUTStrokeVertex ch69st3[] = +{ + {11.4200f,0.0000f}, + {73.3248f,0.0000f} +}; + +static const GLUTStrokeStrip ch69st[] = +{ + {2,ch69st0}, + {2,ch69st1}, + {2,ch69st2}, + {2,ch69st3} +}; + +static const GLUTStrokeChar ch69 = {78.1848f,4,ch69st}; + +/* char: 0x46 */ + +static const GLUTStrokeVertex ch70st0[] = +{ + {11.4200f,100.0000f}, + {11.4200f,0.0000f} +}; + +static const GLUTStrokeVertex ch70st1[] = +{ + {11.4200f,100.0000f}, + {73.3248f,100.0000f} +}; + +static const GLUTStrokeVertex ch70st2[] = +{ + {11.4200f,52.3810f}, + {49.5152f,52.3810f} +}; + +static const GLUTStrokeStrip ch70st[] = +{ + {2,ch70st0}, + {2,ch70st1}, + {2,ch70st2} +}; + +static const GLUTStrokeChar ch70 = {78.7448f,3,ch70st}; + +/* char: 0x47 */ + +static const GLUTStrokeVertex ch71st0[] = +{ + {78.4886f,76.1905f}, + {73.7267f,85.7143f}, + {64.2029f,95.2381f}, + {54.6790f,100.0000f}, + {35.6314f,100.0000f}, + {26.1076f,95.2381f}, + {16.5838f,85.7143f}, + {11.8219f,76.1905f}, + {7.0600f,61.9048f}, + {7.0600f,38.0952f}, + {11.8219f,23.8095f}, + {16.5838f,14.2857f}, + {26.1076f,4.7619f}, + {35.6314f,0.0000f}, + {54.6790f,0.0000f}, + {64.2029f,4.7619f}, + {73.7267f,14.2857f}, + {78.4886f,23.8095f}, + {78.4886f,38.0952f} +}; + +static const GLUTStrokeVertex ch71st1[] = +{ + {54.6790f,38.0952f}, + {78.4886f,38.0952f} +}; + +static const GLUTStrokeStrip ch71st[] = +{ + {19,ch71st0}, + {2,ch71st1} +}; + +static const GLUTStrokeChar ch71 = {89.7686f,2,ch71st}; + +/* char: 0x48 */ + +static const GLUTStrokeVertex ch72st0[] = +{ + {11.4200f,100.0000f}, + {11.4200f,0.0000f} +}; + +static const GLUTStrokeVertex ch72st1[] = +{ + {78.0867f,100.0000f}, + {78.0867f,0.0000f} +}; + +static const GLUTStrokeVertex ch72st2[] = +{ + {11.4200f,52.3810f}, + {78.0867f,52.3810f} +}; + +static const GLUTStrokeStrip ch72st[] = +{ + {2,ch72st0}, + {2,ch72st1}, + {2,ch72st2} +}; + +static const GLUTStrokeChar ch72 = {89.0867f,3,ch72st}; + +/* char: 0x49 */ + +static const GLUTStrokeVertex ch73st0[] = +{ + {10.8600f,100.0000f}, + {10.8600f,0.0000f} +}; + +static const GLUTStrokeStrip ch73st[] = +{ + {2,ch73st0} +}; + +static const GLUTStrokeChar ch73 = {21.3000f,1,ch73st}; + +/* char: 0x4a */ + +static const GLUTStrokeVertex ch74st0[] = +{ + {50.1190f,100.0000f}, + {50.1190f,23.8095f}, + {45.3571f,9.5238f}, + {40.5952f,4.7619f}, + {31.0714f,0.0000f}, + {21.5476f,0.0000f}, + {12.0238f,4.7619f}, + {7.2619f,9.5238f}, + {2.5000f,23.8095f}, + {2.5000f,33.3333f} +}; + +static const GLUTStrokeStrip ch74st[] = +{ + {10,ch74st0} +}; + +static const GLUTStrokeChar ch74 = {59.9990f,1,ch74st}; + +/* char: 0x4b */ + +static const GLUTStrokeVertex ch75st0[] = +{ + {11.2800f,100.0000f}, + {11.2800f,0.0000f} +}; + +static const GLUTStrokeVertex ch75st1[] = +{ + {77.9467f,100.0000f}, + {11.2800f,33.3333f} +}; + +static const GLUTStrokeVertex ch75st2[] = +{ + {35.0895f,57.1429f}, + {77.9467f,0.0000f} +}; + +static const GLUTStrokeStrip ch75st[] = +{ + {2,ch75st0}, + {2,ch75st1}, + {2,ch75st2} +}; + +static const GLUTStrokeChar ch75 = {79.3267f,3,ch75st}; + +/* char: 0x4c */ + +static const GLUTStrokeVertex ch76st0[] = +{ + {11.6800f,100.0000f}, + {11.6800f,0.0000f} +}; + +static const GLUTStrokeVertex ch76st1[] = +{ + {11.6800f,0.0000f}, + {68.8229f,0.0000f} +}; + +static const GLUTStrokeStrip ch76st[] = +{ + {2,ch76st0}, + {2,ch76st1} +}; + +static const GLUTStrokeChar ch76 = {71.3229f,2,ch76st}; + +/* char: 0x4d */ + +static const GLUTStrokeVertex ch77st0[] = +{ + {10.8600f,100.0000f}, + {10.8600f,0.0000f} +}; + +static const GLUTStrokeVertex ch77st1[] = +{ + {10.8600f,100.0000f}, + {48.9552f,0.0000f} +}; + +static const GLUTStrokeVertex ch77st2[] = +{ + {87.0505f,100.0000f}, + {48.9552f,0.0000f} +}; + +static const GLUTStrokeVertex ch77st3[] = +{ + {87.0505f,100.0000f}, + {87.0505f,0.0000f} +}; + +static const GLUTStrokeStrip ch77st[] = +{ + {2,ch77st0}, + {2,ch77st1}, + {2,ch77st2}, + {2,ch77st3} +}; + +static const GLUTStrokeChar ch77 = {97.2105f,4,ch77st}; + +/* char: 0x4e */ + +static const GLUTStrokeVertex ch78st0[] = +{ + {11.1400f,100.0000f}, + {11.1400f,0.0000f} +}; + +static const GLUTStrokeVertex ch78st1[] = +{ + {11.1400f,100.0000f}, + {77.8067f,0.0000f} +}; + +static const GLUTStrokeVertex ch78st2[] = +{ + {77.8067f,100.0000f}, + {77.8067f,0.0000f} +}; + +static const GLUTStrokeStrip ch78st[] = +{ + {2,ch78st0}, + {2,ch78st1}, + {2,ch78st2} +}; + +static const GLUTStrokeChar ch78 = {88.8067f,3,ch78st}; + +/* char: 0x4f */ + +static const GLUTStrokeVertex ch79st0[] = +{ + {34.8114f,100.0000f}, + {25.2876f,95.2381f}, + {15.7638f,85.7143f}, + {11.0019f,76.1905f}, + {6.2400f,61.9048f}, + {6.2400f,38.0952f}, + {11.0019f,23.8095f}, + {15.7638f,14.2857f}, + {25.2876f,4.7619f}, + {34.8114f,0.0000f}, + {53.8590f,0.0000f}, + {63.3829f,4.7619f}, + {72.9067f,14.2857f}, + {77.6686f,23.8095f}, + {82.4305f,38.0952f}, + {82.4305f,61.9048f}, + {77.6686f,76.1905f}, + {72.9067f,85.7143f}, + {63.3829f,95.2381f}, + {53.8590f,100.0000f}, + {34.8114f,100.0000f} +}; + +static const GLUTStrokeStrip ch79st[] = +{ + {21,ch79st0} +}; + +static const GLUTStrokeChar ch79 = {88.8305f,1,ch79st}; + +/* char: 0x50 */ + +static const GLUTStrokeVertex ch80st0[] = +{ + {12.1000f,100.0000f}, + {12.1000f,0.0000f} +}; + +static const GLUTStrokeVertex ch80st1[] = +{ + {12.1000f,100.0000f}, + {54.9571f,100.0000f}, + {69.2429f,95.2381f}, + {74.0048f,90.4762f}, + {78.7667f,80.9524f}, + {78.7667f,66.6667f}, + {74.0048f,57.1429f}, + {69.2429f,52.3810f}, + {54.9571f,47.6190f}, + {12.1000f,47.6190f} +}; + +static const GLUTStrokeStrip ch80st[] = +{ + {2,ch80st0}, + {10,ch80st1} +}; + +static const GLUTStrokeChar ch80 = {85.6667f,2,ch80st}; + +/* char: 0x51 */ + +static const GLUTStrokeVertex ch81st0[] = +{ + {33.8714f,100.0000f}, + {24.3476f,95.2381f}, + {14.8238f,85.7143f}, + {10.0619f,76.1905f}, + {5.3000f,61.9048f}, + {5.3000f,38.0952f}, + {10.0619f,23.8095f}, + {14.8238f,14.2857f}, + {24.3476f,4.7619f}, + {33.8714f,0.0000f}, + {52.9190f,0.0000f}, + {62.4429f,4.7619f}, + {71.9667f,14.2857f}, + {76.7286f,23.8095f}, + {81.4905f,38.0952f}, + {81.4905f,61.9048f}, + {76.7286f,76.1905f}, + {71.9667f,85.7143f}, + {62.4429f,95.2381f}, + {52.9190f,100.0000f}, + {33.8714f,100.0000f} +}; + +static const GLUTStrokeVertex ch81st1[] = +{ + {48.1571f,19.0476f}, + {76.7286f,-9.5238f} +}; + +static const GLUTStrokeStrip ch81st[] = +{ + {21,ch81st0}, + {2,ch81st1} +}; + +static const GLUTStrokeChar ch81 = {88.0905f,2,ch81st}; + +/* char: 0x52 */ + +static const GLUTStrokeVertex ch82st0[] = +{ + {11.6800f,100.0000f}, + {11.6800f,0.0000f} +}; + +static const GLUTStrokeVertex ch82st1[] = +{ + {11.6800f,100.0000f}, + {54.5371f,100.0000f}, + {68.8229f,95.2381f}, + {73.5848f,90.4762f}, + {78.3467f,80.9524f}, + {78.3467f,71.4286f}, + {73.5848f,61.9048f}, + {68.8229f,57.1429f}, + {54.5371f,52.3810f}, + {11.6800f,52.3810f} +}; + +static const GLUTStrokeVertex ch82st2[] = +{ + {45.0133f,52.3810f}, + {78.3467f,0.0000f} +}; + +static const GLUTStrokeStrip ch82st[] = +{ + {2,ch82st0}, + {10,ch82st1}, + {2,ch82st2} +}; + +static const GLUTStrokeChar ch82 = {82.3667f,3,ch82st}; + +/* char: 0x53 */ + +static const GLUTStrokeVertex ch83st0[] = +{ + {74.6667f,85.7143f}, + {65.1429f,95.2381f}, + {50.8571f,100.0000f}, + {31.8095f,100.0000f}, + {17.5238f,95.2381f}, + {8.0000f,85.7143f}, + {8.0000f,76.1905f}, + {12.7619f,66.6667f}, + {17.5238f,61.9048f}, + {27.0476f,57.1429f}, + {55.6190f,47.6190f}, + {65.1429f,42.8571f}, + {69.9048f,38.0952f}, + {74.6667f,28.5714f}, + {74.6667f,14.2857f}, + {65.1429f,4.7619f}, + {50.8571f,0.0000f}, + {31.8095f,0.0000f}, + {17.5238f,4.7619f}, + {8.0000f,14.2857f} +}; + +static const GLUTStrokeStrip ch83st[] = +{ + {20,ch83st0} +}; + +static const GLUTStrokeChar ch83 = {80.8267f,1,ch83st}; + +/* char: 0x54 */ + +static const GLUTStrokeVertex ch84st0[] = +{ + {35.6933f,100.0000f}, + {35.6933f,0.0000f} +}; + +static const GLUTStrokeVertex ch84st1[] = +{ + {2.3600f,100.0000f}, + {69.0267f,100.0000f} +}; + +static const GLUTStrokeStrip ch84st[] = +{ + {2,ch84st0}, + {2,ch84st1} +}; + +static const GLUTStrokeChar ch84 = {71.9467f,2,ch84st}; + +/* char: 0x55 */ + +static const GLUTStrokeVertex ch85st0[] = +{ + {11.5400f,100.0000f}, + {11.5400f,28.5714f}, + {16.3019f,14.2857f}, + {25.8257f,4.7619f}, + {40.1114f,0.0000f}, + {49.6352f,0.0000f}, + {63.9210f,4.7619f}, + {73.4448f,14.2857f}, + {78.2067f,28.5714f}, + {78.2067f,100.0000f} +}; + +static const GLUTStrokeStrip ch85st[] = +{ + {10,ch85st0} +}; + +static const GLUTStrokeChar ch85 = {89.4867f,1,ch85st}; + +/* char: 0x56 */ + +static const GLUTStrokeVertex ch86st0[] = +{ + {2.3600f,100.0000f}, + {40.4552f,0.0000f} +}; + +static const GLUTStrokeVertex ch86st1[] = +{ + {78.5505f,100.0000f}, + {40.4552f,0.0000f} +}; + +static const GLUTStrokeStrip ch86st[] = +{ + {2,ch86st0}, + {2,ch86st1} +}; + +static const GLUTStrokeChar ch86 = {81.6105f,2,ch86st}; + +/* char: 0x57 */ + +static const GLUTStrokeVertex ch87st0[] = +{ + {2.2200f,100.0000f}, + {26.0295f,0.0000f} +}; + +static const GLUTStrokeVertex ch87st1[] = +{ + {49.8390f,100.0000f}, + {26.0295f,0.0000f} +}; + +static const GLUTStrokeVertex ch87st2[] = +{ + {49.8390f,100.0000f}, + {73.6486f,0.0000f} +}; + +static const GLUTStrokeVertex ch87st3[] = +{ + {97.4581f,100.0000f}, + {73.6486f,0.0000f} +}; + +static const GLUTStrokeStrip ch87st[] = +{ + {2,ch87st0}, + {2,ch87st1}, + {2,ch87st2}, + {2,ch87st3} +}; + +static const GLUTStrokeChar ch87 = {100.5181f,4,ch87st}; + +/* char: 0x58 */ + +static const GLUTStrokeVertex ch88st0[] = +{ + {2.5000f,100.0000f}, + {69.1667f,0.0000f} +}; + +static const GLUTStrokeVertex ch88st1[] = +{ + {69.1667f,100.0000f}, + {2.5000f,0.0000f} +}; + +static const GLUTStrokeStrip ch88st[] = +{ + {2,ch88st0}, + {2,ch88st1} +}; + +static const GLUTStrokeChar ch88 = {72.3667f,2,ch88st}; + +/* char: 0x59 */ + +static const GLUTStrokeVertex ch89st0[] = +{ + {1.5200f,100.0000f}, + {39.6152f,52.3810f}, + {39.6152f,0.0000f} +}; + +static const GLUTStrokeVertex ch89st1[] = +{ + {77.7105f,100.0000f}, + {39.6152f,52.3810f} +}; + +static const GLUTStrokeStrip ch89st[] = +{ + {3,ch89st0}, + {2,ch89st1} +}; + +static const GLUTStrokeChar ch89 = {79.6505f,2,ch89st}; + +/* char: 0x5a */ + +static const GLUTStrokeVertex ch90st0[] = +{ + {69.1667f,100.0000f}, + {2.5000f,0.0000f} +}; + +static const GLUTStrokeVertex ch90st1[] = +{ + {2.5000f,100.0000f}, + {69.1667f,100.0000f} +}; + +static const GLUTStrokeVertex ch90st2[] = +{ + {2.5000f,0.0000f}, + {69.1667f,0.0000f} +}; + +static const GLUTStrokeStrip ch90st[] = +{ + {2,ch90st0}, + {2,ch90st1}, + {2,ch90st2} +}; + +static const GLUTStrokeChar ch90 = {73.7467f,3,ch90st}; + +/* char: 0x5b */ + +static const GLUTStrokeVertex ch91st0[] = +{ + {7.7800f,119.0476f}, + {7.7800f,-33.3333f} +}; + +static const GLUTStrokeVertex ch91st1[] = +{ + {12.5419f,119.0476f}, + {12.5419f,-33.3333f} +}; + +static const GLUTStrokeVertex ch91st2[] = +{ + {7.7800f,119.0476f}, + {41.1133f,119.0476f} +}; + +static const GLUTStrokeVertex ch91st3[] = +{ + {7.7800f,-33.3333f}, + {41.1133f,-33.3333f} +}; + +static const GLUTStrokeStrip ch91st[] = +{ + {2,ch91st0}, + {2,ch91st1}, + {2,ch91st2}, + {2,ch91st3} +}; + +static const GLUTStrokeChar ch91 = {46.1133f,4,ch91st}; + +/* char: 0x5c */ + +static const GLUTStrokeVertex ch92st0[] = +{ + {5.8400f,100.0000f}, + {72.5067f,-14.2857f} +}; + +static const GLUTStrokeStrip ch92st[] = +{ + {2,ch92st0} +}; + +static const GLUTStrokeChar ch92 = {78.2067f,1,ch92st}; + +/* char: 0x5d */ + +static const GLUTStrokeVertex ch93st0[] = +{ + {33.0114f,119.0476f}, + {33.0114f,-33.3333f} +}; + +static const GLUTStrokeVertex ch93st1[] = +{ + {37.7733f,119.0476f}, + {37.7733f,-33.3333f} +}; + +static const GLUTStrokeVertex ch93st2[] = +{ + {4.4400f,119.0476f}, + {37.7733f,119.0476f} +}; + +static const GLUTStrokeVertex ch93st3[] = +{ + {4.4400f,-33.3333f}, + {37.7733f,-33.3333f} +}; + +static const GLUTStrokeStrip ch93st[] = +{ + {2,ch93st0}, + {2,ch93st1}, + {2,ch93st2}, + {2,ch93st3} +}; + +static const GLUTStrokeChar ch93 = {46.3933f,4,ch93st}; + +/* char: 0x5e */ + +static const GLUTStrokeVertex ch94st0[] = +{ + {44.0752f,109.5238f}, + {5.9800f,42.8571f} +}; + +static const GLUTStrokeVertex ch94st1[] = +{ + {44.0752f,109.5238f}, + {82.1705f,42.8571f} +}; + +static const GLUTStrokeStrip ch94st[] = +{ + {2,ch94st0}, + {2,ch94st1} +}; + +static const GLUTStrokeChar ch94 = {90.2305f,2,ch94st}; + +/* char: 0x5f */ + +static const GLUTStrokeVertex ch95st0[] = +{ + {-1.1000f,-33.3333f}, + {103.6619f,-33.3333f}, + {103.6619f,-28.5714f}, + {-1.1000f,-28.5714f}, + {-1.1000f,-33.3333f} +}; + +static const GLUTStrokeStrip ch95st[] = +{ + {5,ch95st0} +}; + +static const GLUTStrokeChar ch95 = {104.0619f,1,ch95st}; + +/* char: 0x60 */ + +static const GLUTStrokeVertex ch96st0[] = +{ + {33.0219f,100.0000f}, + {56.8314f,71.4286f} +}; + +static const GLUTStrokeVertex ch96st1[] = +{ + {33.0219f,100.0000f}, + {28.2600f,95.2381f}, + {56.8314f,71.4286f} +}; + +static const GLUTStrokeStrip ch96st[] = +{ + {2,ch96st0}, + {3,ch96st1} +}; + +static const GLUTStrokeChar ch96 = {83.5714f,2,ch96st}; + +/* char: 0x61 */ + +static const GLUTStrokeVertex ch97st0[] = +{ + {63.8229f,66.6667f}, + {63.8229f,0.0000f} +}; + +static const GLUTStrokeVertex ch97st1[] = +{ + {63.8229f,52.3810f}, + {54.2990f,61.9048f}, + {44.7752f,66.6667f}, + {30.4895f,66.6667f}, + {20.9657f,61.9048f}, + {11.4419f,52.3810f}, + {6.6800f,38.0952f}, + {6.6800f,28.5714f}, + {11.4419f,14.2857f}, + {20.9657f,4.7619f}, + {30.4895f,0.0000f}, + {44.7752f,0.0000f}, + {54.2990f,4.7619f}, + {63.8229f,14.2857f} +}; + +static const GLUTStrokeStrip ch97st[] = +{ + {2,ch97st0}, + {14,ch97st1} +}; + +static const GLUTStrokeChar ch97 = {66.6029f,2,ch97st}; + +/* char: 0x62 */ + +static const GLUTStrokeVertex ch98st0[] = +{ + {8.7600f,100.0000f}, + {8.7600f,0.0000f} +}; + +static const GLUTStrokeVertex ch98st1[] = +{ + {8.7600f,52.3810f}, + {18.2838f,61.9048f}, + {27.8076f,66.6667f}, + {42.0933f,66.6667f}, + {51.6171f,61.9048f}, + {61.1410f,52.3810f}, + {65.9029f,38.0952f}, + {65.9029f,28.5714f}, + {61.1410f,14.2857f}, + {51.6171f,4.7619f}, + {42.0933f,0.0000f}, + {27.8076f,0.0000f}, + {18.2838f,4.7619f}, + {8.7600f,14.2857f} +}; + +static const GLUTStrokeStrip ch98st[] = +{ + {2,ch98st0}, + {14,ch98st1} +}; + +static const GLUTStrokeChar ch98 = {70.4629f,2,ch98st}; + +/* char: 0x63 */ + +static const GLUTStrokeVertex ch99st0[] = +{ + {62.6629f,52.3810f}, + {53.1390f,61.9048f}, + {43.6152f,66.6667f}, + {29.3295f,66.6667f}, + {19.8057f,61.9048f}, + {10.2819f,52.3810f}, + {5.5200f,38.0952f}, + {5.5200f,28.5714f}, + {10.2819f,14.2857f}, + {19.8057f,4.7619f}, + {29.3295f,0.0000f}, + {43.6152f,0.0000f}, + {53.1390f,4.7619f}, + {62.6629f,14.2857f} +}; + +static const GLUTStrokeStrip ch99st[] = +{ + {14,ch99st0} +}; + +static const GLUTStrokeChar ch99 = {68.9229f,1,ch99st}; + +/* char: 0x64 */ + +static const GLUTStrokeVertex ch100st0[] = +{ + {61.7829f,100.0000f}, + {61.7829f,0.0000f} +}; + +static const GLUTStrokeVertex ch100st1[] = +{ + {61.7829f,52.3810f}, + {52.2590f,61.9048f}, + {42.7352f,66.6667f}, + {28.4495f,66.6667f}, + {18.9257f,61.9048f}, + {9.4019f,52.3810f}, + {4.6400f,38.0952f}, + {4.6400f,28.5714f}, + {9.4019f,14.2857f}, + {18.9257f,4.7619f}, + {28.4495f,0.0000f}, + {42.7352f,0.0000f}, + {52.2590f,4.7619f}, + {61.7829f,14.2857f} +}; + +static const GLUTStrokeStrip ch100st[] = +{ + {2,ch100st0}, + {14,ch100st1} +}; + +static const GLUTStrokeChar ch100 = {70.2629f,2,ch100st}; + +/* char: 0x65 */ + +static const GLUTStrokeVertex ch101st0[] = +{ + {5.7200f,38.0952f}, + {62.8629f,38.0952f}, + {62.8629f,47.6190f}, + {58.1010f,57.1429f}, + {53.3390f,61.9048f}, + {43.8152f,66.6667f}, + {29.5295f,66.6667f}, + {20.0057f,61.9048f}, + {10.4819f,52.3810f}, + {5.7200f,38.0952f}, + {5.7200f,28.5714f}, + {10.4819f,14.2857f}, + {20.0057f,4.7619f}, + {29.5295f,0.0000f}, + {43.8152f,0.0000f}, + {53.3390f,4.7619f}, + {62.8629f,14.2857f} +}; + +static const GLUTStrokeStrip ch101st[] = +{ + {17,ch101st0} +}; + +static const GLUTStrokeChar ch101 = {68.5229f,1,ch101st}; + +/* char: 0x66 */ + +static const GLUTStrokeVertex ch102st0[] = +{ + {38.7752f,100.0000f}, + {29.2514f,100.0000f}, + {19.7276f,95.2381f}, + {14.9657f,80.9524f}, + {14.9657f,0.0000f} +}; + +static const GLUTStrokeVertex ch102st1[] = +{ + {0.6800f,66.6667f}, + {34.0133f,66.6667f} +}; + +static const GLUTStrokeStrip ch102st[] = +{ + {5,ch102st0}, + {2,ch102st1} +}; + +static const GLUTStrokeChar ch102 = {38.6552f,2,ch102st}; + +/* char: 0x67 */ + +static const GLUTStrokeVertex ch103st0[] = +{ + {62.5029f,66.6667f}, + {62.5029f,-9.5238f}, + {57.7410f,-23.8095f}, + {52.9790f,-28.5714f}, + {43.4552f,-33.3333f}, + {29.1695f,-33.3333f}, + {19.6457f,-28.5714f} +}; + +static const GLUTStrokeVertex ch103st1[] = +{ + {62.5029f,52.3810f}, + {52.9790f,61.9048f}, + {43.4552f,66.6667f}, + {29.1695f,66.6667f}, + {19.6457f,61.9048f}, + {10.1219f,52.3810f}, + {5.3600f,38.0952f}, + {5.3600f,28.5714f}, + {10.1219f,14.2857f}, + {19.6457f,4.7619f}, + {29.1695f,0.0000f}, + {43.4552f,0.0000f}, + {52.9790f,4.7619f}, + {62.5029f,14.2857f} +}; + +static const GLUTStrokeStrip ch103st[] = +{ + {7,ch103st0}, + {14,ch103st1} +}; + +static const GLUTStrokeChar ch103 = {70.9829f,2,ch103st}; + +/* char: 0x68 */ + +static const GLUTStrokeVertex ch104st0[] = +{ + {9.6000f,100.0000f}, + {9.6000f,0.0000f} +}; + +static const GLUTStrokeVertex ch104st1[] = +{ + {9.6000f,47.6190f}, + {23.8857f,61.9048f}, + {33.4095f,66.6667f}, + {47.6952f,66.6667f}, + {57.2190f,61.9048f}, + {61.9810f,47.6190f}, + {61.9810f,0.0000f} +}; + +static const GLUTStrokeStrip ch104st[] = +{ + {2,ch104st0}, + {7,ch104st1} +}; + +static const GLUTStrokeChar ch104 = {71.0210f,2,ch104st}; + +/* char: 0x69 */ + +static const GLUTStrokeVertex ch105st0[] = +{ + {10.0200f,100.0000f}, + {14.7819f,95.2381f}, + {19.5438f,100.0000f}, + {14.7819f,104.7619f}, + {10.0200f,100.0000f} +}; + +static const GLUTStrokeVertex ch105st1[] = +{ + {14.7819f,66.6667f}, + {14.7819f,0.0000f} +}; + +static const GLUTStrokeStrip ch105st[] = +{ + {5,ch105st0}, + {2,ch105st1} +}; + +static const GLUTStrokeChar ch105 = {28.8638f,2,ch105st}; + +/* char: 0x6a */ + +static const GLUTStrokeVertex ch106st0[] = +{ + {17.3876f,100.0000f}, + {22.1495f,95.2381f}, + {26.9114f,100.0000f}, + {22.1495f,104.7619f}, + {17.3876f,100.0000f} +}; + +static const GLUTStrokeVertex ch106st1[] = +{ + {22.1495f,66.6667f}, + {22.1495f,-14.2857f}, + {17.3876f,-28.5714f}, + {7.8638f,-33.3333f}, + {-1.6600f,-33.3333f} +}; + +static const GLUTStrokeStrip ch106st[] = +{ + {5,ch106st0}, + {5,ch106st1} +}; + +static const GLUTStrokeChar ch106 = {36.2314f,2,ch106st}; + +/* char: 0x6b */ + +static const GLUTStrokeVertex ch107st0[] = +{ + {9.6000f,100.0000f}, + {9.6000f,0.0000f} +}; + +static const GLUTStrokeVertex ch107st1[] = +{ + {57.2190f,66.6667f}, + {9.6000f,19.0476f} +}; + +static const GLUTStrokeVertex ch107st2[] = +{ + {28.6476f,38.0952f}, + {61.9810f,0.0000f} +}; + +static const GLUTStrokeStrip ch107st[] = +{ + {2,ch107st0}, + {2,ch107st1}, + {2,ch107st2} +}; + +static const GLUTStrokeChar ch107 = {62.5210f,3,ch107st}; + +/* char: 0x6c */ + +static const GLUTStrokeVertex ch108st0[] = +{ + {10.0200f,100.0000f}, + {10.0200f,0.0000f} +}; + +static const GLUTStrokeStrip ch108st[] = +{ + {2,ch108st0} +}; + +static const GLUTStrokeChar ch108 = {19.3400f,1,ch108st}; + +/* char: 0x6d */ + +static const GLUTStrokeVertex ch109st0[] = +{ + {9.6000f,66.6667f}, + {9.6000f,0.0000f} +}; + +static const GLUTStrokeVertex ch109st1[] = +{ + {9.6000f,47.6190f}, + {23.8857f,61.9048f}, + {33.4095f,66.6667f}, + {47.6952f,66.6667f}, + {57.2190f,61.9048f}, + {61.9810f,47.6190f}, + {61.9810f,0.0000f} +}; + +static const GLUTStrokeVertex ch109st2[] = +{ + {61.9810f,47.6190f}, + {76.2667f,61.9048f}, + {85.7905f,66.6667f}, + {100.0762f,66.6667f}, + {109.6000f,61.9048f}, + {114.3619f,47.6190f}, + {114.3619f,0.0000f} +}; + +static const GLUTStrokeStrip ch109st[] = +{ + {2,ch109st0}, + {7,ch109st1}, + {7,ch109st2} +}; + +static const GLUTStrokeChar ch109 = {123.9619f,3,ch109st}; + +/* char: 0x6e */ + +static const GLUTStrokeVertex ch110st0[] = +{ + {9.1800f,66.6667f}, + {9.1800f,0.0000f} +}; + +static const GLUTStrokeVertex ch110st1[] = +{ + {9.1800f,47.6190f}, + {23.4657f,61.9048f}, + {32.9895f,66.6667f}, + {47.2752f,66.6667f}, + {56.7990f,61.9048f}, + {61.5610f,47.6190f}, + {61.5610f,0.0000f} +}; + +static const GLUTStrokeStrip ch110st[] = +{ + {2,ch110st0}, + {7,ch110st1} +}; + +static const GLUTStrokeChar ch110 = {70.8810f,2,ch110st}; + +/* char: 0x6f */ + +static const GLUTStrokeVertex ch111st0[] = +{ + {28.7895f,66.6667f}, + {19.2657f,61.9048f}, + {9.7419f,52.3810f}, + {4.9800f,38.0952f}, + {4.9800f,28.5714f}, + {9.7419f,14.2857f}, + {19.2657f,4.7619f}, + {28.7895f,0.0000f}, + {43.0752f,0.0000f}, + {52.5990f,4.7619f}, + {62.1229f,14.2857f}, + {66.8848f,28.5714f}, + {66.8848f,38.0952f}, + {62.1229f,52.3810f}, + {52.5990f,61.9048f}, + {43.0752f,66.6667f}, + {28.7895f,66.6667f} +}; + +static const GLUTStrokeStrip ch111st[] = +{ + {17,ch111st0} +}; + +static const GLUTStrokeChar ch111 = {71.7448f,1,ch111st}; + +/* char: 0x70 */ + +static const GLUTStrokeVertex ch112st0[] = +{ + {9.4600f,66.6667f}, + {9.4600f,-33.3333f} +}; + +static const GLUTStrokeVertex ch112st1[] = +{ + {9.4600f,52.3810f}, + {18.9838f,61.9048f}, + {28.5076f,66.6667f}, + {42.7933f,66.6667f}, + {52.3171f,61.9048f}, + {61.8410f,52.3810f}, + {66.6029f,38.0952f}, + {66.6029f,28.5714f}, + {61.8410f,14.2857f}, + {52.3171f,4.7619f}, + {42.7933f,0.0000f}, + {28.5076f,0.0000f}, + {18.9838f,4.7619f}, + {9.4600f,14.2857f} +}; + +static const GLUTStrokeStrip ch112st[] = +{ + {2,ch112st0}, + {14,ch112st1} +}; + +static const GLUTStrokeChar ch112 = {70.8029f,2,ch112st}; + +/* char: 0x71 */ + +static const GLUTStrokeVertex ch113st0[] = +{ + {61.9829f,66.6667f}, + {61.9829f,-33.3333f} +}; + +static const GLUTStrokeVertex ch113st1[] = +{ + {61.9829f,52.3810f}, + {52.4590f,61.9048f}, + {42.9352f,66.6667f}, + {28.6495f,66.6667f}, + {19.1257f,61.9048f}, + {9.6019f,52.3810f}, + {4.8400f,38.0952f}, + {4.8400f,28.5714f}, + {9.6019f,14.2857f}, + {19.1257f,4.7619f}, + {28.6495f,0.0000f}, + {42.9352f,0.0000f}, + {52.4590f,4.7619f}, + {61.9829f,14.2857f} +}; + +static const GLUTStrokeStrip ch113st[] = +{ + {2,ch113st0}, + {14,ch113st1} +}; + +static const GLUTStrokeChar ch113 = {70.7429f,2,ch113st}; + +/* char: 0x72 */ + +static const GLUTStrokeVertex ch114st0[] = +{ + {9.4600f,66.6667f}, + {9.4600f,0.0000f} +}; + +static const GLUTStrokeVertex ch114st1[] = +{ + {9.4600f,38.0952f}, + {14.2219f,52.3810f}, + {23.7457f,61.9048f}, + {33.2695f,66.6667f}, + {47.5552f,66.6667f} +}; + +static const GLUTStrokeStrip ch114st[] = +{ + {2,ch114st0}, + {5,ch114st1} +}; + +static const GLUTStrokeChar ch114 = {49.4952f,2,ch114st}; + +/* char: 0x73 */ + +static const GLUTStrokeVertex ch115st0[] = +{ + {57.0810f,52.3810f}, + {52.3190f,61.9048f}, + {38.0333f,66.6667f}, + {23.7476f,66.6667f}, + {9.4619f,61.9048f}, + {4.7000f,52.3810f}, + {9.4619f,42.8571f}, + {18.9857f,38.0952f}, + {42.7952f,33.3333f}, + {52.3190f,28.5714f}, + {57.0810f,19.0476f}, + {57.0810f,14.2857f}, + {52.3190f,4.7619f}, + {38.0333f,0.0000f}, + {23.7476f,0.0000f}, + {9.4619f,4.7619f}, + {4.7000f,14.2857f} +}; + +static const GLUTStrokeStrip ch115st[] = +{ + {17,ch115st0} +}; + +static const GLUTStrokeChar ch115 = {62.3210f,1,ch115st}; + +/* char: 0x74 */ + +static const GLUTStrokeVertex ch116st0[] = +{ + {14.8257f,100.0000f}, + {14.8257f,19.0476f}, + {19.5876f,4.7619f}, + {29.1114f,0.0000f}, + {38.6352f,0.0000f} +}; + +static const GLUTStrokeVertex ch116st1[] = +{ + {0.5400f,66.6667f}, + {33.8733f,66.6667f} +}; + +static const GLUTStrokeStrip ch116st[] = +{ + {5,ch116st0}, + {2,ch116st1} +}; + +static const GLUTStrokeChar ch116 = {39.3152f,2,ch116st}; + +/* char: 0x75 */ + +static const GLUTStrokeVertex ch117st0[] = +{ + {9.4600f,66.6667f}, + {9.4600f,19.0476f}, + {14.2219f,4.7619f}, + {23.7457f,0.0000f}, + {38.0314f,0.0000f}, + {47.5552f,4.7619f}, + {61.8410f,19.0476f} +}; + +static const GLUTStrokeVertex ch117st1[] = +{ + {61.8410f,66.6667f}, + {61.8410f,0.0000f} +}; + +static const GLUTStrokeStrip ch117st[] = +{ + {7,ch117st0}, + {2,ch117st1} +}; + +static const GLUTStrokeChar ch117 = {71.1610f,2,ch117st}; + +/* char: 0x76 */ + +static const GLUTStrokeVertex ch118st0[] = +{ + {1.8000f,66.6667f}, + {30.3714f,0.0000f} +}; + +static const GLUTStrokeVertex ch118st1[] = +{ + {58.9429f,66.6667f}, + {30.3714f,0.0000f} +}; + +static const GLUTStrokeStrip ch118st[] = +{ + {2,ch118st0}, + {2,ch118st1} +}; + +static const GLUTStrokeChar ch118 = {60.6029f,2,ch118st}; + +/* char: 0x77 */ + +static const GLUTStrokeVertex ch119st0[] = +{ + {2.5000f,66.6667f}, + {21.5476f,0.0000f} +}; + +static const GLUTStrokeVertex ch119st1[] = +{ + {40.5952f,66.6667f}, + {21.5476f,0.0000f} +}; + +static const GLUTStrokeVertex ch119st2[] = +{ + {40.5952f,66.6667f}, + {59.6429f,0.0000f} +}; + +static const GLUTStrokeVertex ch119st3[] = +{ + {78.6905f,66.6667f}, + {59.6429f,0.0000f} +}; + +static const GLUTStrokeStrip ch119st[] = +{ + {2,ch119st0}, + {2,ch119st1}, + {2,ch119st2}, + {2,ch119st3} +}; + +static const GLUTStrokeChar ch119 = {80.4905f,4,ch119st}; + +/* char: 0x78 */ + +static const GLUTStrokeVertex ch120st0[] = +{ + {1.6600f,66.6667f}, + {54.0410f,0.0000f} +}; + +static const GLUTStrokeVertex ch120st1[] = +{ + {54.0410f,66.6667f}, + {1.6600f,0.0000f} +}; + +static const GLUTStrokeStrip ch120st[] = +{ + {2,ch120st0}, + {2,ch120st1} +}; + +static const GLUTStrokeChar ch120 = {56.4010f,2,ch120st}; + +/* char: 0x79 */ + +static const GLUTStrokeVertex ch121st0[] = +{ + {6.5619f,66.6667f}, + {35.1333f,0.0000f} +}; + +static const GLUTStrokeVertex ch121st1[] = +{ + {63.7048f,66.6667f}, + {35.1333f,0.0000f}, + {25.6095f,-19.0476f}, + {16.0857f,-28.5714f}, + {6.5619f,-33.3333f}, + {1.8000f,-33.3333f} +}; + +static const GLUTStrokeStrip ch121st[] = +{ + {2,ch121st0}, + {6,ch121st1} +}; + +static const GLUTStrokeChar ch121 = {66.0648f,2,ch121st}; + +/* char: 0x7a */ + +static const GLUTStrokeVertex ch122st0[] = +{ + {56.8210f,66.6667f}, + {4.4400f,0.0000f} +}; + +static const GLUTStrokeVertex ch122st1[] = +{ + {4.4400f,66.6667f}, + {56.8210f,66.6667f} +}; + +static const GLUTStrokeVertex ch122st2[] = +{ + {4.4400f,0.0000f}, + {56.8210f,0.0000f} +}; + +static const GLUTStrokeStrip ch122st[] = +{ + {2,ch122st0}, + {2,ch122st1}, + {2,ch122st2} +}; + +static const GLUTStrokeChar ch122 = {61.8210f,3,ch122st}; + +/* char: 0x7b */ + +static const GLUTStrokeVertex ch123st0[] = +{ + {31.1895f,119.0476f}, + {21.6657f,114.2857f}, + {16.9038f,109.5238f}, + {12.1419f,100.0000f}, + {12.1419f,90.4762f}, + {16.9038f,80.9524f}, + {21.6657f,76.1905f}, + {26.4276f,66.6667f}, + {26.4276f,57.1429f}, + {16.9038f,47.6190f} +}; + +static const GLUTStrokeVertex ch123st1[] = +{ + {21.6657f,114.2857f}, + {16.9038f,104.7619f}, + {16.9038f,95.2381f}, + {21.6657f,85.7143f}, + {26.4276f,80.9524f}, + {31.1895f,71.4286f}, + {31.1895f,61.9048f}, + {26.4276f,52.3810f}, + {7.3800f,42.8571f}, + {26.4276f,33.3333f}, + {31.1895f,23.8095f}, + {31.1895f,14.2857f}, + {26.4276f,4.7619f}, + {21.6657f,0.0000f}, + {16.9038f,-9.5238f}, + {16.9038f,-19.0476f}, + {21.6657f,-28.5714f} +}; + +static const GLUTStrokeVertex ch123st2[] = +{ + {16.9038f,38.0952f}, + {26.4276f,28.5714f}, + {26.4276f,19.0476f}, + {21.6657f,9.5238f}, + {16.9038f,4.7619f}, + {12.1419f,-4.7619f}, + {12.1419f,-14.2857f}, + {16.9038f,-23.8095f}, + {21.6657f,-28.5714f}, + {31.1895f,-33.3333f} +}; + +static const GLUTStrokeStrip ch123st[] = +{ + {10,ch123st0}, + {17,ch123st1}, + {10,ch123st2} +}; + +static const GLUTStrokeChar ch123 = {41.6295f,3,ch123st}; + +/* char: 0x7c */ + +static const GLUTStrokeVertex ch124st0[] = +{ + {11.5400f,119.0476f}, + {11.5400f,-33.3333f} +}; + +static const GLUTStrokeStrip ch124st[] = +{ + {2,ch124st0} +}; + +static const GLUTStrokeChar ch124 = {23.7800f,1,ch124st}; + +/* char: 0x7d */ + +static const GLUTStrokeVertex ch125st0[] = +{ + {9.1800f,119.0476f}, + {18.7038f,114.2857f}, + {23.4657f,109.5238f}, + {28.2276f,100.0000f}, + {28.2276f,90.4762f}, + {23.4657f,80.9524f}, + {18.7038f,76.1905f}, + {13.9419f,66.6667f}, + {13.9419f,57.1429f}, + {23.4657f,47.6190f} +}; + +static const GLUTStrokeVertex ch125st1[] = +{ + {18.7038f,114.2857f}, + {23.4657f,104.7619f}, + {23.4657f,95.2381f}, + {18.7038f,85.7143f}, + {13.9419f,80.9524f}, + {9.1800f,71.4286f}, + {9.1800f,61.9048f}, + {13.9419f,52.3810f}, + {32.9895f,42.8571f}, + {13.9419f,33.3333f}, + {9.1800f,23.8095f}, + {9.1800f,14.2857f}, + {13.9419f,4.7619f}, + {18.7038f,0.0000f}, + {23.4657f,-9.5238f}, + {23.4657f,-19.0476f}, + {18.7038f,-28.5714f} +}; + +static const GLUTStrokeVertex ch125st2[] = +{ + {23.4657f,38.0952f}, + {13.9419f,28.5714f}, + {13.9419f,19.0476f}, + {18.7038f,9.5238f}, + {23.4657f,4.7619f}, + {28.2276f,-4.7619f}, + {28.2276f,-14.2857f}, + {23.4657f,-23.8095f}, + {18.7038f,-28.5714f}, + {9.1800f,-33.3333f} +}; + +static const GLUTStrokeStrip ch125st[] = +{ + {10,ch125st0}, + {17,ch125st1}, + {10,ch125st2} +}; + +static const GLUTStrokeChar ch125 = {41.4695f,3,ch125st}; + +/* char: 0x7e */ + +static const GLUTStrokeVertex ch126st0[] = +{ + {2.9200f,28.5714f}, + {2.9200f,38.0952f}, + {7.6819f,52.3810f}, + {17.2057f,57.1429f}, + {26.7295f,57.1429f}, + {36.2533f,52.3810f}, + {55.3010f,38.0952f}, + {64.8248f,33.3333f}, + {74.3486f,33.3333f}, + {83.8724f,38.0952f}, + {88.6343f,47.6190f} +}; + +static const GLUTStrokeVertex ch126st1[] = +{ + {2.9200f,38.0952f}, + {7.6819f,47.6190f}, + {17.2057f,52.3810f}, + {26.7295f,52.3810f}, + {36.2533f,47.6190f}, + {55.3010f,33.3333f}, + {64.8248f,28.5714f}, + {74.3486f,28.5714f}, + {83.8724f,33.3333f}, + {88.6343f,47.6190f}, + {88.6343f,57.1429f} +}; + +static const GLUTStrokeStrip ch126st[] = +{ + {11,ch126st0}, + {11,ch126st1} +}; + +static const GLUTStrokeChar ch126 = {91.2743f,2,ch126st}; + +static const GLUTStrokeChar *chars[] = +{ + 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, + &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 +}; + +const GLUTStrokeFont glutStrokeRoman = {"Roman",128,chars,152.3809f,33.3333f}; diff --git a/src/glut/dos/shapes.c b/src/glut/dos/shapes.c new file mode 100644 index 000000000..4edebe90e --- /dev/null +++ b/src/glut/dos/shapes.c @@ -0,0 +1,1143 @@ +/* + * freeglut_geometry.c + * + * Freeglut geometry rendering methods. + * + * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved. + * Written by Pawel W. Olszta, + * Creation date: Fri Dec 3 1999 + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include "internal.h" + +/* + * TODO BEFORE THE STABLE RELEASE: + * + * Following functions have been contributed by Andreas Umbach. + * + * glutWireCube() -- looks OK + * glutSolidCube() -- OK + * + * Those functions have been implemented by John Fay. + * + * glutWireTorus() -- looks OK + * glutSolidTorus() -- looks OK + * glutWireDodecahedron() -- looks OK + * glutSolidDodecahedron() -- looks OK + * glutWireOctahedron() -- looks OK + * glutSolidOctahedron() -- looks OK + * glutWireTetrahedron() -- looks OK + * glutSolidTetrahedron() -- looks OK + * glutWireIcosahedron() -- looks OK + * glutSolidIcosahedron() -- looks OK + * + * The Following functions have been updated by Nigel Stewart, based + * on FreeGLUT 2.0.0 implementations: + * + * glutWireSphere() -- looks OK + * glutSolidSphere() -- looks OK + * glutWireCone() -- looks OK + * glutSolidCone() -- looks OK + */ + + +/* -- INTERFACE FUNCTIONS -------------------------------------------------- */ + +/* + * Draws a wireframed cube. Code contributed by Andreas Umbach + */ +void GLUTAPIENTRY glutWireCube( GLdouble dSize ) +{ + double size = dSize * 0.5; + +# define V(a,b,c) glVertex3d( a size, b size, c size ); +# define N(a,b,c) glNormal3d( a, b, c ); + + /* + * PWO: I dared to convert the code to use macros... + */ + glBegin( GL_LINE_LOOP ); N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+); glEnd(); + glBegin( GL_LINE_LOOP ); N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+); glEnd(); + glBegin( GL_LINE_LOOP ); N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+); glEnd(); + glBegin( GL_LINE_LOOP ); N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-); glEnd(); + glBegin( GL_LINE_LOOP ); N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+); glEnd(); + glBegin( GL_LINE_LOOP ); N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-); glEnd(); + +# undef V +# undef N +} + +/* + * Draws a solid cube. Code contributed by Andreas Umbach + */ +void GLUTAPIENTRY glutSolidCube( GLdouble dSize ) +{ + double size = dSize * 0.5; + +# define V(a,b,c) glVertex3d( a size, b size, c size ); +# define N(a,b,c) glNormal3d( a, b, c ); + + /* + * PWO: Again, I dared to convert the code to use macros... + */ + glBegin( GL_QUADS ); + N( 1.0, 0.0, 0.0); V(+,-,+); V(+,-,-); V(+,+,-); V(+,+,+); + N( 0.0, 1.0, 0.0); V(+,+,+); V(+,+,-); V(-,+,-); V(-,+,+); + N( 0.0, 0.0, 1.0); V(+,+,+); V(-,+,+); V(-,-,+); V(+,-,+); + N(-1.0, 0.0, 0.0); V(-,-,+); V(-,+,+); V(-,+,-); V(-,-,-); + N( 0.0,-1.0, 0.0); V(-,-,+); V(-,-,-); V(+,-,-); V(+,-,+); + N( 0.0, 0.0,-1.0); V(-,-,-); V(-,+,-); V(+,+,-); V(+,-,-); + glEnd(); + +# undef V +# undef N +} + +/* + * Compute lookup table of cos and sin values forming a cirle + * + * Notes: + * It is the responsibility of the caller to free these tables + * The size of the table is (n+1) to form a connected loop + * The last entry is exactly the same as the first + * The sign of n can be flipped to get the reverse loop + */ + +static void circleTable(double **sint,double **cost,const int n) +{ + int i; + + /* Table size, the sign of n flips the circle direction */ + + const int size = abs(n); + + /* Determine the angle between samples */ + + const double angle = 2*M_PI/(double)n; + + /* Allocate memory for n samples, plus duplicate of first entry at the end */ + + *sint = (double *) calloc(sizeof(double), size+1); + *cost = (double *) calloc(sizeof(double), size+1); + + /* Bail out if memory allocation fails, fgError never returns */ + + if (!(*sint) || !(*cost)) + { + free(*sint); + free(*cost); + _glut_fatal("Failed to allocate memory in circleTable"); + } + + /* Compute cos and sin around the circle */ + + for (i=0; i=0; j--) + { + glNormal3d(cost1[j]*r1, sint1[j]*r1, z1 ); + glVertex3d(cost1[j]*r1*radius, sint1[j]*r1*radius, z1*radius); + } + + glEnd(); + + /* Cover each stack with a quad strip, except the top and bottom stacks */ + + for( i=1; i=0; j--) + glVertex3d(cost[j]*radius, sint[j]*radius, height); + glEnd(); + + /* Do the stacks */ + + z0 = 0.0; + z1 = zStep; + + for (i=1; i<=stacks; i++) + { + if (i==stacks) + z1 = height; + + glBegin(GL_QUAD_STRIP); + for (j=0; j<=slices; j++ ) + { + glNormal3d(cost[j], sint[j], 0.0 ); + glVertex3d(cost[j]*radius, sint[j]*radius, z0 ); + glVertex3d(cost[j]*radius, sint[j]*radius, z1 ); + } + glEnd(); + + z0 = z1; z1 += zStep; + } + + /* Release sin and cos tables */ + + free(sint); + free(cost); +} + +/* + * Draws a wire cylinder + */ +void GLUTAPIENTRY glutWireCylinder(GLdouble radius, GLdouble height, GLint slices, GLint stacks) +{ + int i,j; + + /* Step in z and radius as stacks are drawn. */ + + double z = 0.0; + const double zStep = height/stacks; + + /* Pre-computed circle */ + + double *sint,*cost; + circleTable(&sint,&cost,-slices); + + /* Draw the stacks... */ + + for (i=0; i<=stacks; i++) + { + if (i==stacks) + z = height; + + glBegin(GL_LINE_LOOP); + + for( j=0; j + +#include "internal.h" + + +#define FREQUENCY 100 /* set this to zero to use the default timer */ + + +static int timer_installed; +#if FREQUENCY +static volatile int ticks; + + +static void +ticks_timer (void *p) +{ + (void)p; + ticks++; +} ENDOFUNC(ticks_timer) +#else +#include + +static struct timeval then; +#endif + + +int APIENTRY +glutGet (GLenum type) +{ + switch (type) { + case GLUT_WINDOW_X: + return _glut_current->xpos; + case GLUT_WINDOW_Y: + return _glut_current->ypos; + case GLUT_WINDOW_WIDTH: + return _glut_current->width; + case GLUT_WINDOW_HEIGHT: + return _glut_current->height; + case GLUT_WINDOW_STENCIL_SIZE: + return _glut_visual.stencil; + case GLUT_WINDOW_DEPTH_SIZE: + return _glut_visual.depth; + case GLUT_WINDOW_RGBA: + return !(_glut_default.mode & GLUT_INDEX); + case GLUT_WINDOW_COLORMAP_SIZE: + return (_glut_default.mode & GLUT_INDEX) ? (256 - RESERVED_COLORS) : 0; + case GLUT_SCREEN_WIDTH: + return _glut_visual.geometry[0]; + case GLUT_SCREEN_HEIGHT: + return _glut_visual.geometry[1]; + case GLUT_INIT_WINDOW_X: + return _glut_default.x; + case GLUT_INIT_WINDOW_Y: + return _glut_default.y; + case GLUT_INIT_WINDOW_WIDTH: + return _glut_default.width; + case GLUT_INIT_WINDOW_HEIGHT: + return _glut_default.height; + case GLUT_INIT_DISPLAY_MODE: + return _glut_default.mode; + case GLUT_ELAPSED_TIME: +#if FREQUENCY + if (!timer_installed) { + timer_installed = GL_TRUE; + LOCKDATA(ticks); + LOCKFUNC(ticks_timer); + pc_install_int(ticks_timer, NULL, FREQUENCY); + } + return ticks * 1000 / FREQUENCY; +#else + if (!timer_installed) { + timer_installed = GL_TRUE; + gettimeofday(&then, NULL); + return 0; + } else { + struct timeval now; + gettimeofday(&now, NULL); + return (now.tv_usec - then.tv_usec) / 1000 + + (now.tv_sec - then.tv_sec) * 1000; + } +#endif + default: + return -1; + } +} + + +int APIENTRY +glutDeviceGet (GLenum type) +{ + switch (type) { + case GLUT_HAS_KEYBOARD: + return GL_TRUE; + case GLUT_HAS_MOUSE: + return (_glut_mouse != 0); + case GLUT_NUM_MOUSE_BUTTONS: + return _glut_mouse; + case GLUT_HAS_SPACEBALL: + case GLUT_HAS_DIAL_AND_BUTTON_BOX: + case GLUT_HAS_TABLET: + return GL_FALSE; + case GLUT_NUM_SPACEBALL_BUTTONS: + case GLUT_NUM_BUTTON_BOX_BUTTONS: + case GLUT_NUM_DIALS: + case GLUT_NUM_TABLET_BUTTONS: + return 0; + default: + return -1; + } +} + + +int APIENTRY +glutGetModifiers (void) +{ + int mod = 0; + int shifts = pc_keyshifts(); + + if (shifts & (KB_SHIFT_FLAG | KB_CAPSLOCK_FLAG)) { + mod |= GLUT_ACTIVE_SHIFT; + } + + if (shifts & KB_ALT_FLAG) { + mod |= GLUT_ACTIVE_ALT; + } + + if (shifts & KB_CTRL_FLAG) { + mod |= GLUT_ACTIVE_CTRL; + } + + return mod; +} + + +void APIENTRY +glutReportErrors (void) +{ + /* reports all the OpenGL errors that happened till now */ +} + + +/* GAME MODE + * Hack alert: incomplete... what is GameMode, anyway? + */ +static GLint game; +static GLboolean game_possible; +static GLboolean game_active; +static GLuint game_width; +static GLuint game_height; +static GLuint game_bpp; +static GLuint game_refresh; + + +void APIENTRY +glutGameModeString (const char *string) +{ + if (sscanf(string, "%ux%u:%u@%u", &game_width, &game_height, &game_bpp, &game_refresh) == 4) { + game_possible = GL_TRUE; + } +} + + +int APIENTRY +glutGameModeGet (GLenum mode) +{ + switch (mode) { + case GLUT_GAME_MODE_ACTIVE: + return game_active; + case GLUT_GAME_MODE_POSSIBLE: + return game_possible && !_glut_current; + case GLUT_GAME_MODE_WIDTH: + return game_active ? (int)game_width : -1; + case GLUT_GAME_MODE_HEIGHT: + return game_active ? (int)game_height : -1; + case GLUT_GAME_MODE_PIXEL_DEPTH: + return game_active ? (int)game_bpp : -1; + case GLUT_GAME_MODE_REFRESH_RATE: + return game_active ? (int)game_refresh : -1; + default: + return -1; + } +} + + +int APIENTRY +glutEnterGameMode (void) +{ + if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) { + _glut_visual.bpp = game_bpp; + _glut_visual.refresh = game_refresh; + + glutInitWindowSize(game_width, game_height); + + if ((game = glutCreateWindow("")) > 0) { + game_active = GL_TRUE; + } + + return game; + } else { + return 0; + } +} + + +void GLUTAPIENTRY +glutLeaveGameMode (void) +{ + if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE)) { + game_active = GL_FALSE; + + glutDestroyWindow(game); + } +} diff --git a/src/glut/dos/stroke.c b/src/glut/dos/stroke.c new file mode 100644 index 000000000..aa2c06a7d --- /dev/null +++ b/src/glut/dos/stroke.c @@ -0,0 +1,118 @@ +/* + * FxGLUT version 0.12 - GLUT for Voodoo 1 and 2 under Linux + * Copyright (C) 1999 Christopher John Purnell + * cjp@lost.org.uk + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "internal.h" + + +void +glutStrokeCharacter (void *font, int c) +{ + const GLUTStrokeFont *sfp = _glut_font(font); + const GLUTStrokeChar *scp; + const GLUTStrokeStrip *ssp; + const GLUTStrokeVertex *svp; + unsigned i, j; + + if (((unsigned)c) >= sfp->num || !(scp = sfp->table[c])) + return; + + ssp = scp->strip; + + for (i = 0; i < scp->num; i++, ssp++) { + svp = ssp->vertex; + + glBegin(GL_LINE_STRIP); + for (j = 0; j < ssp->num; j++, svp++) { + glVertex2f(svp->x, svp->y); + } + glEnd(); + } + + glTranslatef(scp->right, 0.0, 0.0); +} + + +void +glutStrokeString (void *font, const unsigned char *string) +{ + const GLUTStrokeFont *sfp = _glut_font(font); + const GLUTStrokeChar *scp; + const GLUTStrokeStrip *ssp; + const GLUTStrokeVertex *svp; + unsigned char c; + unsigned i, j; + + while ((c = *(string++))) { + if (c < sfp->num && (scp = sfp->table[c])) { + ssp = scp->strip; + + for (i = 0; i < scp->num; i++, ssp++) { + svp = ssp->vertex; + + glBegin(GL_LINE_STRIP); + for (j = 0; j < ssp->num; j++, svp++) { + glVertex2f(svp->x, svp->y); + } + glEnd(); + } + + glTranslatef(scp->right, 0.0, 0.0); + } + } +} + + +int +glutStrokeWidth (void *font, int c) +{ + const GLUTStrokeFont *sfp = _glut_font(font); + const GLUTStrokeChar *scp; + + if (((unsigned)c) >= sfp->num || !(scp = sfp->table[c])) + return 0; + + return scp->right; +} + + +int +glutStrokeLength (void *font, const unsigned char *string) +{ + const GLUTStrokeFont *sfp = _glut_font(font); + const GLUTStrokeChar *scp; + unsigned char c; + int length = 0; + + while ((c = *(string++))) { + if (c < sfp->num && (scp = sfp->table[c])) + length += scp->right; + } + + return length; +} + + +GLfloat +glutStrokeHeight (void *font) +{ + const GLUTStrokeFont *sfp = _glut_font(font); + + return sfp->height; +} diff --git a/src/glut/dos/teapot.c b/src/glut/dos/teapot.c new file mode 100644 index 000000000..8d02eb49f --- /dev/null +++ b/src/glut/dos/teapot.c @@ -0,0 +1,201 @@ +/* + * (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 "internal.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] = +{ + { 102, 103, 104, 105, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15 }, /* rim */ + { 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27 }, /* body */ + { 24, 25, 26, 27, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40 }, + { 96, 96, 96, 96, 97, 98, 99, 100, + 101, 101, 101, 101, 0, 1, 2, 3 }, /* lid */ + { 0, 1, 2, 3, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117 }, + { 118, 118, 118, 118, 124, 122, 119, 121, + 123, 126, 125, 120, 40, 39, 38, 37 }, /* bottom */ + { 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56 }, /* handle */ + { 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 28, 65, 66, 67 }, + { 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83 }, /* spout */ + { 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95 } +}; + +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} } +}; + +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(); +} + +void glutWireTeapot(GLdouble size) +{ + teapot(10, size, GL_LINE); +} + +void glutSolidTeapot(GLdouble size) +{ + teapot(7, size, GL_FILL); +} diff --git a/src/glut/dos/tr10.c b/src/glut/dos/tr10.c new file mode 100644 index 000000000..a1e03f3e1 --- /dev/null +++ b/src/glut/dos/tr10.c @@ -0,0 +1,1018 @@ +/* autogenerated by bdf2c! do not edit */ + +/* "Copyright (c) 1984, 1987 Adobe Systems Incorporated. All Rights Reserved. Copyright (c) 1988, 1991 Digital Equipment Corporation. All Rights Reserved." */ + + +#include "internal.h" +/* +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; +*/ + + +static const unsigned char ch32data[] = { + 0x0 +}; +static const GLUTBitmapChar ch32 = { 1, 1, 0, 0, 2, ch32data }; + +static const unsigned char ch33data[] = { + 0x80,0x0,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch33 = { 1, 7, -1, 0, 3, ch33data }; + +static const unsigned char ch34data[] = { + 0xa0,0xa0 +}; +static const GLUTBitmapChar ch34 = { 3, 2, 0, -5, 4, ch34data }; + +static const unsigned char ch35data[] = { + 0x50,0x50,0xf8,0x50,0xf8,0x50,0x50 +}; +static const GLUTBitmapChar ch35 = { 5, 7, 0, 0, 5, ch35data }; + +static const unsigned char ch36data[] = { + 0x20,0xe0,0x90,0x10,0x60,0x80,0x90,0x70,0x20 +}; +static const GLUTBitmapChar ch36 = { 4, 9, 0, 1, 5, ch36data }; + +static const unsigned char ch37data[] = { + 0x44,0x2a,0x2a,0x56,0xa8,0xa4,0x7e +}; +static const GLUTBitmapChar ch37 = { 7, 7, 0, 0, 8, ch37data }; + +static const unsigned char ch38data[] = { + 0x76,0x8d,0x98,0x74,0x6e,0x50,0x30 +}; +static const GLUTBitmapChar ch38 = { 8, 7, 0, 0, 8, ch38data }; + +static const unsigned char ch39data[] = { + 0x40,0xc0 +}; +static const GLUTBitmapChar ch39 = { 2, 2, 0, -5, 3, ch39data }; + +static const unsigned char ch40data[] = { + 0x20,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x20 +}; +static const GLUTBitmapChar ch40 = { 3, 9, 0, 2, 4, ch40data }; + +static const unsigned char ch41data[] = { + 0x80,0x40,0x40,0x20,0x20,0x20,0x40,0x40,0x80 +}; +static const GLUTBitmapChar ch41 = { 3, 9, 0, 2, 4, ch41data }; + +static const unsigned char ch42data[] = { + 0xa0,0x40,0xa0 +}; +static const GLUTBitmapChar ch42 = { 3, 3, 0, -4, 5, ch42data }; + +static const unsigned char ch43data[] = { + 0x20,0x20,0xf8,0x20,0x20 +}; +static const GLUTBitmapChar ch43 = { 5, 5, 0, 0, 6, ch43data }; + +static const unsigned char ch44data[] = { + 0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch44 = { 1, 3, -1, 2, 3, ch44data }; + +static const unsigned char ch45data[] = { + 0xf0 +}; +static const GLUTBitmapChar ch45 = { 4, 1, -1, -2, 7, ch45data }; + +static const unsigned char ch46data[] = { + 0x80 +}; +static const GLUTBitmapChar ch46 = { 1, 1, -1, 0, 3, ch46data }; + +static const unsigned char ch47data[] = { + 0x80,0x80,0x40,0x40,0x40,0x20,0x20 +}; +static const GLUTBitmapChar ch47 = { 3, 7, 0, 0, 3, ch47data }; + +static const unsigned char ch48data[] = { + 0x60,0x90,0x90,0x90,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch48 = { 4, 7, 0, 0, 5, ch48data }; + +static const unsigned char ch49data[] = { + 0xe0,0x40,0x40,0x40,0x40,0xc0,0x40 +}; +static const GLUTBitmapChar ch49 = { 3, 7, -1, 0, 5, ch49data }; + +static const unsigned char ch50data[] = { + 0xf0,0x40,0x20,0x20,0x10,0x90,0x60 +}; +static const GLUTBitmapChar ch50 = { 4, 7, 0, 0, 5, ch50data }; + +static const unsigned char ch51data[] = { + 0xe0,0x10,0x10,0x60,0x10,0x90,0x60 +}; +static const GLUTBitmapChar ch51 = { 4, 7, 0, 0, 5, ch51data }; + +static const unsigned char ch52data[] = { + 0x10,0x10,0xf8,0x90,0x50,0x30,0x10 +}; +static const GLUTBitmapChar ch52 = { 5, 7, 0, 0, 5, ch52data }; + +static const unsigned char ch53data[] = { + 0xe0,0x90,0x10,0x10,0xe0,0x40,0x70 +}; +static const GLUTBitmapChar ch53 = { 4, 7, 0, 0, 5, ch53data }; + +static const unsigned char ch54data[] = { + 0x60,0x90,0x90,0x90,0xe0,0x40,0x30 +}; +static const GLUTBitmapChar ch54 = { 4, 7, 0, 0, 5, ch54data }; + +static const unsigned char ch55data[] = { + 0x40,0x40,0x40,0x20,0x20,0x90,0xf0 +}; +static const GLUTBitmapChar ch55 = { 4, 7, 0, 0, 5, ch55data }; + +static const unsigned char ch56data[] = { + 0x60,0x90,0x90,0x60,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch56 = { 4, 7, 0, 0, 5, ch56data }; + +static const unsigned char ch57data[] = { + 0xc0,0x20,0x70,0x90,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch57 = { 4, 7, 0, 0, 5, ch57data }; + +static const unsigned char ch58data[] = { + 0x80,0x0,0x0,0x0,0x80 +}; +static const GLUTBitmapChar ch58 = { 1, 5, -1, 0, 3, ch58data }; + +static const unsigned char ch59data[] = { + 0x80,0x80,0x80,0x0,0x0,0x0,0x80 +}; +static const GLUTBitmapChar ch59 = { 1, 7, -1, 2, 3, ch59data }; + +static const unsigned char ch60data[] = { + 0x20,0x40,0x80,0x40,0x20 +}; +static const GLUTBitmapChar ch60 = { 3, 5, -1, 0, 5, ch60data }; + +static const unsigned char ch61data[] = { + 0xf8,0x0,0xf8 +}; +static const GLUTBitmapChar ch61 = { 5, 3, 0, -1, 6, ch61data }; + +static const unsigned char ch62data[] = { + 0x80,0x40,0x20,0x40,0x80 +}; +static const GLUTBitmapChar ch62 = { 3, 5, 0, 0, 5, ch62data }; + +static const unsigned char ch63data[] = { + 0x40,0x0,0x40,0x40,0x20,0xa0,0xe0 +}; +static const GLUTBitmapChar ch63 = { 3, 7, 0, 0, 4, ch63data }; + +static const unsigned char ch64data[] = { + 0x3e,0x40,0x92,0xad,0xa5,0xa5,0x9d,0x42,0x3c +}; +static const GLUTBitmapChar ch64 = { 8, 9, 0, 2, 9, ch64data }; + +static const unsigned char ch65data[] = { + 0xee,0x44,0x7c,0x28,0x28,0x38,0x10 +}; +static const GLUTBitmapChar ch65 = { 7, 7, 0, 0, 8, ch65data }; + +static const unsigned char ch66data[] = { + 0xf0,0x48,0x48,0x70,0x48,0x48,0xf0 +}; +static const GLUTBitmapChar ch66 = { 5, 7, 0, 0, 6, ch66data }; + +static const unsigned char ch67data[] = { + 0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c +}; +static const GLUTBitmapChar ch67 = { 6, 7, 0, 0, 7, ch67data }; + +static const unsigned char ch68data[] = { + 0xf8,0x4c,0x44,0x44,0x44,0x4c,0xf8 +}; +static const GLUTBitmapChar ch68 = { 6, 7, 0, 0, 7, ch68data }; + +static const unsigned char ch69data[] = { + 0xf8,0x48,0x40,0x70,0x40,0x48,0xf8 +}; +static const GLUTBitmapChar ch69 = { 5, 7, 0, 0, 6, ch69data }; + +static const unsigned char ch70data[] = { + 0xe0,0x40,0x40,0x70,0x40,0x48,0xf8 +}; +static const GLUTBitmapChar ch70 = { 5, 7, 0, 0, 6, ch70data }; + +static const unsigned char ch71data[] = { + 0x78,0xc4,0x84,0x9c,0x80,0xc4,0x7c +}; +static const GLUTBitmapChar ch71 = { 6, 7, 0, 0, 7, ch71data }; + +static const unsigned char ch72data[] = { + 0xee,0x44,0x44,0x7c,0x44,0x44,0xee +}; +static const GLUTBitmapChar ch72 = { 7, 7, 0, 0, 8, ch72data }; + +static const unsigned char ch73data[] = { + 0xe0,0x40,0x40,0x40,0x40,0x40,0xe0 +}; +static const GLUTBitmapChar ch73 = { 3, 7, 0, 0, 4, ch73data }; + +static const unsigned char ch74data[] = { + 0xc0,0xa0,0x20,0x20,0x20,0x20,0x70 +}; +static const GLUTBitmapChar ch74 = { 4, 7, 0, 0, 4, ch74data }; + +static const unsigned char ch75data[] = { + 0xec,0x48,0x50,0x60,0x50,0x48,0xec +}; +static const GLUTBitmapChar ch75 = { 6, 7, 0, 0, 7, ch75data }; + +static const unsigned char ch76data[] = { + 0xf8,0x48,0x40,0x40,0x40,0x40,0xe0 +}; +static const GLUTBitmapChar ch76 = { 5, 7, 0, 0, 6, ch76data }; + +static const unsigned char ch77data[] = { + 0xeb,0x80,0x49,0x0,0x55,0x0,0x55,0x0,0x63,0x0,0x63,0x0,0xe3,0x80 +}; +static const GLUTBitmapChar ch77 = { 9, 7, 0, 0, 10, ch77data }; + +static const unsigned char ch78data[] = { + 0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee +}; +static const GLUTBitmapChar ch78 = { 7, 7, 0, 0, 8, ch78data }; + +static const unsigned char ch79data[] = { + 0x78,0xcc,0x84,0x84,0x84,0xcc,0x78 +}; +static const GLUTBitmapChar ch79 = { 6, 7, 0, 0, 7, ch79data }; + +static const unsigned char ch80data[] = { + 0xe0,0x40,0x40,0x70,0x48,0x48,0xf0 +}; +static const GLUTBitmapChar ch80 = { 5, 7, 0, 0, 6, ch80data }; + +static const unsigned char ch81data[] = { + 0xc,0x18,0x70,0xcc,0x84,0x84,0x84,0xcc,0x78 +}; +static const GLUTBitmapChar ch81 = { 6, 9, 0, 2, 7, ch81data }; + +static const unsigned char ch82data[] = { + 0xec,0x48,0x50,0x70,0x48,0x48,0xf0 +}; +static const GLUTBitmapChar ch82 = { 6, 7, 0, 0, 7, ch82data }; + +static const unsigned char ch83data[] = { + 0xe0,0x90,0x10,0x60,0xc0,0x90,0x70 +}; +static const GLUTBitmapChar ch83 = { 4, 7, 0, 0, 5, ch83data }; + +static const unsigned char ch84data[] = { + 0x70,0x20,0x20,0x20,0x20,0xa8,0xf8 +}; +static const GLUTBitmapChar ch84 = { 5, 7, 0, 0, 6, ch84data }; + +static const unsigned char ch85data[] = { + 0x38,0x6c,0x44,0x44,0x44,0x44,0xee +}; +static const GLUTBitmapChar ch85 = { 7, 7, 0, 0, 8, ch85data }; + +static const unsigned char ch86data[] = { + 0x10,0x10,0x28,0x28,0x6c,0x44,0xee +}; +static const GLUTBitmapChar ch86 = { 7, 7, 0, 0, 8, ch86data }; + +static const unsigned char ch87data[] = { + 0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0xc9,0x80,0x88,0x80,0xdd,0xc0 +}; +static const GLUTBitmapChar ch87 = { 10, 7, 0, 0, 10, ch87data }; + +static const unsigned char ch88data[] = { + 0xee,0x44,0x28,0x10,0x28,0x44,0xee +}; +static const GLUTBitmapChar ch88 = { 7, 7, 0, 0, 8, ch88data }; + +static const unsigned char ch89data[] = { + 0x38,0x10,0x10,0x28,0x28,0x44,0xee +}; +static const GLUTBitmapChar ch89 = { 7, 7, 0, 0, 8, ch89data }; + +static const unsigned char ch90data[] = { + 0xf8,0x88,0x40,0x20,0x10,0x88,0xf8 +}; +static const GLUTBitmapChar ch90 = { 5, 7, 0, 0, 6, ch90data }; + +static const unsigned char ch91data[] = { + 0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0 +}; +static const GLUTBitmapChar ch91 = { 2, 9, 0, 2, 3, ch91data }; + +static const unsigned char ch92data[] = { + 0x20,0x20,0x40,0x40,0x40,0x80,0x80 +}; +static const GLUTBitmapChar ch92 = { 3, 7, 0, 0, 3, ch92data }; + +static const unsigned char ch93data[] = { + 0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0 +}; +static const GLUTBitmapChar ch93 = { 2, 9, 0, 2, 3, ch93data }; + +static const unsigned char ch94data[] = { + 0xa0,0xa0,0x40 +}; +static const GLUTBitmapChar ch94 = { 3, 3, -1, -4, 5, ch94data }; + +static const unsigned char ch95data[] = { + 0xf8 +}; +static const GLUTBitmapChar ch95 = { 5, 1, 0, 3, 5, ch95data }; + +static const unsigned char ch96data[] = { + 0xc0,0x80 +}; +static const GLUTBitmapChar ch96 = { 2, 2, 0, -5, 3, ch96data }; + +static const unsigned char ch97data[] = { + 0xe0,0xa0,0x60,0x20,0xc0 +}; +static const GLUTBitmapChar ch97 = { 3, 5, 0, 0, 4, ch97data }; + +static const unsigned char ch98data[] = { + 0xe0,0x90,0x90,0x90,0xe0,0x80,0x80 +}; +static const GLUTBitmapChar ch98 = { 4, 7, 0, 0, 5, ch98data }; + +static const unsigned char ch99data[] = { + 0x60,0x80,0x80,0x80,0x60 +}; +static const GLUTBitmapChar ch99 = { 3, 5, 0, 0, 4, ch99data }; + +static const unsigned char ch100data[] = { + 0x68,0x90,0x90,0x90,0x70,0x10,0x30 +}; +static const GLUTBitmapChar ch100 = { 5, 7, 0, 0, 5, ch100data }; + +static const unsigned char ch101data[] = { + 0x60,0x80,0xc0,0xa0,0x60 +}; +static const GLUTBitmapChar ch101 = { 3, 5, 0, 0, 4, ch101data }; + +static const unsigned char ch102data[] = { + 0xe0,0x40,0x40,0x40,0xe0,0x40,0x30 +}; +static const GLUTBitmapChar ch102 = { 4, 7, 0, 0, 4, ch102data }; + +static const unsigned char ch103data[] = { + 0xe0,0x90,0x60,0x40,0xa0,0xa0,0x70 +}; +static const GLUTBitmapChar ch103 = { 4, 7, 0, 2, 5, ch103data }; + +static const unsigned char ch104data[] = { + 0xd8,0x90,0x90,0x90,0xe0,0x80,0x80 +}; +static const GLUTBitmapChar ch104 = { 5, 7, 0, 0, 5, ch104data }; + +static const unsigned char ch105data[] = { + 0x40,0x40,0x40,0x40,0xc0,0x0,0x40 +}; +static const GLUTBitmapChar ch105 = { 2, 7, 0, 0, 3, ch105data }; + +static const unsigned char ch106data[] = { + 0x80,0x40,0x40,0x40,0x40,0x40,0xc0,0x0,0x40 +}; +static const GLUTBitmapChar ch106 = { 2, 9, 0, 2, 3, ch106data }; + +static const unsigned char ch107data[] = { + 0x98,0x90,0xe0,0xa0,0x90,0x80,0x80 +}; +static const GLUTBitmapChar ch107 = { 5, 7, 0, 0, 5, ch107data }; + +static const unsigned char ch108data[] = { + 0xe0,0x40,0x40,0x40,0x40,0x40,0xc0 +}; +static const GLUTBitmapChar ch108 = { 3, 7, 0, 0, 4, ch108data }; + +static const unsigned char ch109data[] = { + 0xdb,0x92,0x92,0x92,0xec +}; +static const GLUTBitmapChar ch109 = { 8, 5, 0, 0, 8, ch109data }; + +static const unsigned char ch110data[] = { + 0xd8,0x90,0x90,0x90,0xe0 +}; +static const GLUTBitmapChar ch110 = { 5, 5, 0, 0, 5, ch110data }; + +static const unsigned char ch111data[] = { + 0x60,0x90,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch111 = { 4, 5, 0, 0, 5, ch111data }; + +static const unsigned char ch112data[] = { + 0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0 +}; +static const GLUTBitmapChar ch112 = { 4, 7, 0, 2, 5, ch112data }; + +static const unsigned char ch113data[] = { + 0x38,0x10,0x70,0x90,0x90,0x90,0x70 +}; +static const GLUTBitmapChar ch113 = { 5, 7, 0, 2, 5, ch113data }; + +static const unsigned char ch114data[] = { + 0xe0,0x40,0x40,0x60,0xa0 +}; +static const GLUTBitmapChar ch114 = { 3, 5, 0, 0, 4, ch114data }; + +static const unsigned char ch115data[] = { + 0xe0,0x20,0x60,0x80,0xe0 +}; +static const GLUTBitmapChar ch115 = { 3, 5, 0, 0, 4, ch115data }; + +static const unsigned char ch116data[] = { + 0x30,0x40,0x40,0x40,0xe0,0x40 +}; +static const GLUTBitmapChar ch116 = { 4, 6, 0, 0, 4, ch116data }; + +static const unsigned char ch117data[] = { + 0x68,0x90,0x90,0x90,0x90 +}; +static const GLUTBitmapChar ch117 = { 5, 5, 0, 0, 5, ch117data }; + +static const unsigned char ch118data[] = { + 0x20,0x60,0x50,0x90,0xd8 +}; +static const GLUTBitmapChar ch118 = { 5, 5, 0, 0, 5, ch118data }; + +static const unsigned char ch119data[] = { + 0x28,0x6c,0x54,0x92,0xdb +}; +static const GLUTBitmapChar ch119 = { 8, 5, 0, 0, 8, ch119data }; + +static const unsigned char ch120data[] = { + 0xd8,0x50,0x20,0x50,0xd8 +}; +static const GLUTBitmapChar ch120 = { 5, 5, 0, 0, 6, ch120data }; + +static const unsigned char ch121data[] = { + 0x40,0x40,0x20,0x30,0x50,0x48,0xdc +}; +static const GLUTBitmapChar ch121 = { 6, 7, 1, 2, 5, ch121data }; + +static const unsigned char ch122data[] = { + 0xf0,0x90,0x40,0x20,0xf0 +}; +static const GLUTBitmapChar ch122 = { 4, 5, 0, 0, 5, ch122data }; + +static const unsigned char ch123data[] = { + 0x20,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20 +}; +static const GLUTBitmapChar ch123 = { 3, 9, 0, 2, 4, ch123data }; + +static const unsigned char ch124data[] = { + 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch124 = { 1, 9, 0, 2, 2, ch124data }; + +static const unsigned char ch125data[] = { + 0x80,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80 +}; +static const GLUTBitmapChar ch125 = { 3, 9, 0, 2, 4, ch125data }; + +static const unsigned char ch126data[] = { + 0x98,0x64 +}; +static const GLUTBitmapChar ch126 = { 6, 2, 0, -2, 7, ch126data }; + +static const unsigned char ch160data[] = { + 0x0 +}; +static const GLUTBitmapChar ch160 = { 1, 1, 0, 0, 2, ch160data }; + +static const unsigned char ch161data[] = { + 0x80,0x80,0x80,0x80,0x80,0x0,0x80 +}; +static const GLUTBitmapChar ch161 = { 1, 7, -1, 2, 3, ch161data }; + +static const unsigned char ch162data[] = { + 0x80,0xe0,0x90,0x80,0x90,0x70,0x10 +}; +static const GLUTBitmapChar ch162 = { 4, 7, 0, 1, 5, ch162data }; + +static const unsigned char ch163data[] = { + 0xf0,0xc8,0x40,0xe0,0x40,0x50,0x30 +}; +static const GLUTBitmapChar ch163 = { 5, 7, 0, 0, 5, ch163data }; + +static const unsigned char ch164data[] = { + 0x88,0x70,0x50,0x50,0x70,0x88 +}; +static const GLUTBitmapChar ch164 = { 5, 6, 0, -1, 5, ch164data }; + +static const unsigned char ch165data[] = { + 0x70,0x20,0xf8,0x20,0xd8,0x50,0x88 +}; +static const GLUTBitmapChar ch165 = { 5, 7, 0, 0, 5, ch165data }; + +static const unsigned char ch166data[] = { + 0x80,0x80,0x80,0x0,0x80,0x80,0x80 +}; +static const GLUTBitmapChar ch166 = { 1, 7, 0, 0, 2, ch166data }; + +static const unsigned char ch167data[] = { + 0xe0,0x90,0x20,0x50,0x90,0xa0,0x40,0x90,0x70 +}; +static const GLUTBitmapChar ch167 = { 4, 9, 0, 1, 5, ch167data }; + +static const unsigned char ch168data[] = { + 0xa0 +}; +static const GLUTBitmapChar ch168 = { 3, 1, -1, -6, 5, ch168data }; + +static const unsigned char ch169data[] = { + 0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38 +}; +static const GLUTBitmapChar ch169 = { 7, 7, -1, 0, 9, ch169data }; + +static const unsigned char ch170data[] = { + 0xe0,0x0,0xa0,0x20,0xc0 +}; +static const GLUTBitmapChar ch170 = { 3, 5, 0, -2, 4, ch170data }; + +static const unsigned char ch171data[] = { + 0x50,0xa0,0xa0,0x50 +}; +static const GLUTBitmapChar ch171 = { 4, 4, 0, -1, 5, ch171data }; + +static const unsigned char ch172data[] = { + 0x8,0x8,0xf8 +}; +static const GLUTBitmapChar ch172 = { 5, 3, -1, -1, 7, ch172data }; + +static const unsigned char ch173data[] = { + 0xe0 +}; +static const GLUTBitmapChar ch173 = { 3, 1, 0, -2, 4, ch173data }; + +static const unsigned char ch174data[] = { + 0x38,0x44,0xaa,0xb2,0xba,0x44,0x38 +}; +static const GLUTBitmapChar ch174 = { 7, 7, -1, 0, 9, ch174data }; + +static const unsigned char ch175data[] = { + 0xe0 +}; +static const GLUTBitmapChar ch175 = { 3, 1, 0, -6, 4, ch175data }; + +static const unsigned char ch176data[] = { + 0x60,0x90,0x90,0x60 +}; +static const GLUTBitmapChar ch176 = { 4, 4, 0, -3, 4, ch176data }; + +static const unsigned char ch177data[] = { + 0xf8,0x0,0x20,0x20,0xf8,0x20,0x20 +}; +static const GLUTBitmapChar ch177 = { 5, 7, 0, 0, 6, ch177data }; + +static const unsigned char ch178data[] = { + 0xe0,0x40,0xa0,0x60 +}; +static const GLUTBitmapChar ch178 = { 3, 4, 0, -3, 3, ch178data }; + +static const unsigned char ch179data[] = { + 0xc0,0x20,0x40,0xe0 +}; +static const GLUTBitmapChar ch179 = { 3, 4, 0, -3, 3, ch179data }; + +static const unsigned char ch180data[] = { + 0x80,0x40 +}; +static const GLUTBitmapChar ch180 = { 2, 2, 0, -5, 3, ch180data }; + +static const unsigned char ch181data[] = { + 0x80,0x80,0xe8,0x90,0x90,0x90,0x90 +}; +static const GLUTBitmapChar ch181 = { 5, 7, 0, 2, 5, ch181data }; + +static const unsigned char ch182data[] = { + 0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c +}; +static const GLUTBitmapChar ch182 = { 6, 9, 0, 2, 6, ch182data }; + +static const unsigned char ch183data[] = { + 0x80 +}; +static const GLUTBitmapChar ch183 = { 1, 1, 0, -2, 2, ch183data }; + +static const unsigned char ch184data[] = { + 0xc0,0x20,0x40 +}; +static const GLUTBitmapChar ch184 = { 3, 3, 0, 3, 4, ch184data }; + +static const unsigned char ch185data[] = { + 0xe0,0x40,0xc0,0x40 +}; +static const GLUTBitmapChar ch185 = { 3, 4, 0, -3, 3, ch185data }; + +static const unsigned char ch186data[] = { + 0xe0,0x0,0x40,0xa0,0x40 +}; +static const GLUTBitmapChar ch186 = { 3, 5, 0, -2, 4, ch186data }; + +static const unsigned char ch187data[] = { + 0xa0,0x50,0x50,0xa0 +}; +static const GLUTBitmapChar ch187 = { 4, 4, 0, -1, 5, ch187data }; + +static const unsigned char ch188data[] = { + 0x44,0x3e,0x2c,0xf4,0x48,0xc8,0x44 +}; +static const GLUTBitmapChar ch188 = { 7, 7, 0, 0, 8, ch188data }; + +static const unsigned char ch189data[] = { + 0x4e,0x24,0x2a,0xf6,0x48,0xc8,0x44 +}; +static const GLUTBitmapChar ch189 = { 7, 7, 0, 0, 8, ch189data }; + +static const unsigned char ch190data[] = { + 0x44,0x3e,0x2c,0xd4,0x28,0x48,0xe4 +}; +static const GLUTBitmapChar ch190 = { 7, 7, 0, 0, 8, ch190data }; + +static const unsigned char ch191data[] = { + 0xe0,0xa0,0x80,0x40,0x40,0x0,0x40 +}; +static const GLUTBitmapChar ch191 = { 3, 7, 0, 2, 4, ch191data }; + +static const unsigned char ch192data[] = { + 0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch192 = { 7, 10, 0, 0, 8, ch192data }; + +static const unsigned char ch193data[] = { + 0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch193 = { 7, 10, 0, 0, 8, ch193data }; + +static const unsigned char ch194data[] = { + 0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch194 = { 7, 10, 0, 0, 8, ch194data }; + +static const unsigned char ch195data[] = { + 0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x14 +}; +static const GLUTBitmapChar ch195 = { 7, 10, 0, 0, 8, ch195data }; + +static const unsigned char ch196data[] = { + 0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28 +}; +static const GLUTBitmapChar ch196 = { 7, 9, 0, 0, 8, ch196data }; + +static const unsigned char ch197data[] = { + 0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x10,0x28,0x10 +}; +static const GLUTBitmapChar ch197 = { 7, 10, 0, 0, 8, ch197data }; + +static const unsigned char ch198data[] = { + 0xef,0x49,0x78,0x2e,0x28,0x39,0x1f +}; +static const GLUTBitmapChar ch198 = { 8, 7, 0, 0, 9, ch198data }; + +static const unsigned char ch199data[] = { + 0x60,0x10,0x20,0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c +}; +static const GLUTBitmapChar ch199 = { 6, 10, 0, 3, 7, ch199data }; + +static const unsigned char ch200data[] = { + 0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch200 = { 5, 10, 0, 0, 6, ch200data }; + +static const unsigned char ch201data[] = { + 0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch201 = { 5, 10, 0, 0, 6, ch201data }; + +static const unsigned char ch202data[] = { + 0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch202 = { 5, 10, 0, 0, 6, ch202data }; + +static const unsigned char ch203data[] = { + 0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50 +}; +static const GLUTBitmapChar ch203 = { 5, 9, 0, 0, 6, ch203data }; + +static const unsigned char ch204data[] = { + 0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch204 = { 3, 10, 0, 0, 4, ch204data }; + +static const unsigned char ch205data[] = { + 0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch205 = { 3, 10, 0, 0, 4, ch205data }; + +static const unsigned char ch206data[] = { + 0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch206 = { 3, 10, 0, 0, 4, ch206data }; + +static const unsigned char ch207data[] = { + 0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0 +}; +static const GLUTBitmapChar ch207 = { 3, 9, 0, 0, 4, ch207data }; + +static const unsigned char ch208data[] = { + 0xf8,0x4c,0x44,0xe4,0x44,0x4c,0xf8 +}; +static const GLUTBitmapChar ch208 = { 6, 7, 0, 0, 7, ch208data }; + +static const unsigned char ch209data[] = { + 0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch209 = { 7, 10, 0, 0, 8, ch209data }; + +static const unsigned char ch210data[] = { + 0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch210 = { 6, 10, 0, 0, 7, ch210data }; + +static const unsigned char ch211data[] = { + 0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch211 = { 6, 10, 0, 0, 7, ch211data }; + +static const unsigned char ch212data[] = { + 0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch212 = { 6, 10, 0, 0, 7, ch212data }; + +static const unsigned char ch213data[] = { + 0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x28 +}; +static const GLUTBitmapChar ch213 = { 6, 10, 0, 0, 7, ch213data }; + +static const unsigned char ch214data[] = { + 0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50 +}; +static const GLUTBitmapChar ch214 = { 6, 9, 0, 0, 7, ch214data }; + +static const unsigned char ch215data[] = { + 0x88,0x50,0x20,0x50,0x88 +}; +static const GLUTBitmapChar ch215 = { 5, 5, 0, 0, 6, ch215data }; + +static const unsigned char ch216data[] = { + 0x80,0x7c,0x66,0x52,0x52,0x4a,0x66,0x3e,0x1 +}; +static const GLUTBitmapChar ch216 = { 8, 9, 0, 1, 8, ch216data }; + +static const unsigned char ch217data[] = { + 0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x20 +}; +static const GLUTBitmapChar ch217 = { 7, 10, 0, 0, 8, ch217data }; + +static const unsigned char ch218data[] = { + 0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch218 = { 7, 10, 0, 0, 8, ch218data }; + +static const unsigned char ch219data[] = { + 0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28,0x10 +}; +static const GLUTBitmapChar ch219 = { 7, 10, 0, 0, 8, ch219data }; + +static const unsigned char ch220data[] = { + 0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28 +}; +static const GLUTBitmapChar ch220 = { 7, 9, 0, 0, 8, ch220data }; + +static const unsigned char ch221data[] = { + 0x38,0x10,0x10,0x28,0x28,0x44,0xee,0x0,0x10,0x8 +}; +static const GLUTBitmapChar ch221 = { 7, 10, 0, 0, 8, ch221data }; + +static const unsigned char ch222data[] = { + 0xe0,0x40,0x70,0x48,0x70,0x40,0xe0 +}; +static const GLUTBitmapChar ch222 = { 5, 7, 0, 0, 6, ch222data }; + +static const unsigned char ch223data[] = { + 0xe0,0x50,0x50,0x60,0x50,0x50,0x20 +}; +static const GLUTBitmapChar ch223 = { 4, 7, 0, 0, 5, ch223data }; + +static const unsigned char ch224data[] = { + 0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch224 = { 3, 8, 0, 0, 4, ch224data }; + +static const unsigned char ch225data[] = { + 0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch225 = { 3, 8, 0, 0, 4, ch225data }; + +static const unsigned char ch226data[] = { + 0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch226 = { 3, 8, 0, 0, 4, ch226data }; + +static const unsigned char ch227data[] = { + 0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x50 +}; +static const GLUTBitmapChar ch227 = { 4, 8, 0, 0, 4, ch227data }; + +static const unsigned char ch228data[] = { + 0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0 +}; +static const GLUTBitmapChar ch228 = { 3, 7, 0, 0, 4, ch228data }; + +static const unsigned char ch229data[] = { + 0xe0,0xa0,0x60,0x20,0xc0,0x40,0xa0,0x40 +}; +static const GLUTBitmapChar ch229 = { 3, 8, 0, 0, 4, ch229data }; + +static const unsigned char ch230data[] = { + 0xd8,0xa0,0x70,0x28,0xd8 +}; +static const GLUTBitmapChar ch230 = { 5, 5, 0, 0, 6, ch230data }; + +static const unsigned char ch231data[] = { + 0xc0,0x20,0x40,0x60,0x80,0x80,0x80,0x60 +}; +static const GLUTBitmapChar ch231 = { 3, 8, 0, 3, 4, ch231data }; + +static const unsigned char ch232data[] = { + 0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch232 = { 3, 8, 0, 0, 4, ch232data }; + +static const unsigned char ch233data[] = { + 0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch233 = { 3, 8, 0, 0, 4, ch233data }; + +static const unsigned char ch234data[] = { + 0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch234 = { 3, 8, 0, 0, 4, ch234data }; + +static const unsigned char ch235data[] = { + 0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0 +}; +static const GLUTBitmapChar ch235 = { 3, 7, 0, 0, 4, ch235data }; + +static const unsigned char ch236data[] = { + 0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x80 +}; +static const GLUTBitmapChar ch236 = { 3, 8, 0, 0, 4, ch236data }; + +static const unsigned char ch237data[] = { + 0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch237 = { 3, 8, 0, 0, 4, ch237data }; + +static const unsigned char ch238data[] = { + 0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch238 = { 3, 8, 0, 0, 4, ch238data }; + +static const unsigned char ch239data[] = { + 0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0 +}; +static const GLUTBitmapChar ch239 = { 3, 7, 0, 0, 4, ch239data }; + +static const unsigned char ch240data[] = { + 0x60,0x90,0x90,0x90,0x70,0xa0,0x70,0x40 +}; +static const GLUTBitmapChar ch240 = { 4, 8, 0, 0, 5, ch240data }; + +static const unsigned char ch241data[] = { + 0xd8,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50 +}; +static const GLUTBitmapChar ch241 = { 5, 8, 0, 0, 5, ch241data }; + +static const unsigned char ch242data[] = { + 0x60,0x90,0x90,0x90,0x60,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch242 = { 4, 8, 0, 0, 5, ch242data }; + +static const unsigned char ch243data[] = { + 0x60,0x90,0x90,0x90,0x60,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch243 = { 4, 8, 0, 0, 5, ch243data }; + +static const unsigned char ch244data[] = { + 0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x40 +}; +static const GLUTBitmapChar ch244 = { 4, 8, 0, 0, 5, ch244data }; + +static const unsigned char ch245data[] = { + 0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x50 +}; +static const GLUTBitmapChar ch245 = { 4, 8, 0, 0, 5, ch245data }; + +static const unsigned char ch246data[] = { + 0x60,0x90,0x90,0x90,0x60,0x0,0xa0 +}; +static const GLUTBitmapChar ch246 = { 4, 7, 0, 0, 5, ch246data }; + +static const unsigned char ch247data[] = { + 0x20,0x0,0xf8,0x0,0x20 +}; +static const GLUTBitmapChar ch247 = { 5, 5, 0, 0, 6, ch247data }; + +static const unsigned char ch248data[] = { + 0x80,0x70,0x48,0x48,0x48,0x38,0x4 +}; +static const GLUTBitmapChar ch248 = { 6, 7, 1, 1, 5, ch248data }; + +static const unsigned char ch249data[] = { + 0x68,0x90,0x90,0x90,0x90,0x0,0x20,0x40 +}; +static const GLUTBitmapChar ch249 = { 5, 8, 0, 0, 5, ch249data }; + +static const unsigned char ch250data[] = { + 0x68,0x90,0x90,0x90,0x90,0x0,0x40,0x20 +}; +static const GLUTBitmapChar ch250 = { 5, 8, 0, 0, 5, ch250data }; + +static const unsigned char ch251data[] = { + 0x68,0x90,0x90,0x90,0x90,0x0,0x50,0x20 +}; +static const GLUTBitmapChar ch251 = { 5, 8, 0, 0, 5, ch251data }; + +static const unsigned char ch252data[] = { + 0x68,0x90,0x90,0x90,0x90,0x0,0x50 +}; +static const GLUTBitmapChar ch252 = { 5, 7, 0, 0, 5, ch252data }; + +static const unsigned char ch253data[] = { + 0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0x20,0x10 +}; +static const GLUTBitmapChar ch253 = { 5, 10, 0, 2, 5, ch253data }; + +static const unsigned char ch254data[] = { + 0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0,0x80,0x80 +}; +static const GLUTBitmapChar ch254 = { 4, 9, 0, 2, 5, ch254data }; + +static const unsigned char ch255data[] = { + 0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0xa0 +}; +static const GLUTBitmapChar ch255 = { 5, 9, 0, 2, 5, ch255data }; + + +static const GLUTBitmapChar *chars[] = { + 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, + &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 GLUTBitmapFont glutBitmapTimesRoman10 = { + "-Adobe-Times-Medium-R-Normal--10-100-75-75-P-54-ISO8859-1", + 13, 256, chars +}; diff --git a/src/glut/dos/tr24.c b/src/glut/dos/tr24.c new file mode 100644 index 000000000..2dd2a78c8 --- /dev/null +++ b/src/glut/dos/tr24.c @@ -0,0 +1,1301 @@ +/* autogenerated by bdf2c! do not edit */ + +/* "Copyright (c) 1984, 1987 Adobe Systems Incorporated. All Rights Reserved. Copyright (c) 1988, 1991 Digital Equipment Corporation. All Rights Reserved." */ + + +#include "internal.h" +/* +typedef struct { + int width, height; + int xorig, yorig; + int xmove; + const unsigned char *bitmap; +} GLUTBitmapChar; + +typedef struct { + const char *name; + int height; + int num; + const GLUTBitmapChar *const *table; +} GLUTBitmapFont; +*/ + + +static const unsigned char ch32data[] = { + 0x0 +}; +static const GLUTBitmapChar ch32 = { 1, 1, 0, 0, 6, ch32data }; + +static const unsigned char ch33data[] = { + 0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, + 0xc0 +}; +static const GLUTBitmapChar ch33 = { 2, 17, -3, 0, 8, ch33data }; + +static const unsigned char ch34data[] = { + 0x88,0xcc,0xcc,0xcc,0xcc +}; +static const GLUTBitmapChar ch34 = { 6, 5, -1, -12, 10, ch34data }; + +static const unsigned char 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 GLUTBitmapChar ch35 = { 11, 17, -1, 0, 13, ch35data }; + +static const unsigned char 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 GLUTBitmapChar ch36 = { 11, 21, 0, 2, 12, ch36data }; + +static const unsigned char 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 GLUTBitmapChar ch37 = { 17, 16, -1, 0, 19, ch37data }; + +static const unsigned char 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 GLUTBitmapChar ch38 = { 16, 17, -1, 0, 18, ch38data }; + +static const unsigned char ch39data[] = { + 0xc0,0x60,0x20,0xe0,0xc0 +}; +static const GLUTBitmapChar ch39 = { 3, 5, -3, -12, 8, ch39data }; + +static const unsigned char 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 GLUTBitmapChar ch40 = { 6, 22, -1, 5, 8, ch40data }; + +static const unsigned char 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 GLUTBitmapChar ch41 = { 6, 22, -1, 5, 8, ch41data }; + +static const unsigned char ch42data[] = { + 0x8,0x0,0x1c,0x0,0xc9,0x80,0xeb,0x80,0x1c,0x0,0xeb,0x80,0xc9,0x80,0x1c,0x0, + 0x8,0x0 +}; +static const GLUTBitmapChar ch42 = { 9, 9, -2, -8, 12, ch42data }; + +static const unsigned char 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 GLUTBitmapChar ch43 = { 12, 12, -1, -1, 14, ch43data }; + +static const unsigned char ch44data[] = { + 0xc0,0x60,0x20,0xe0,0xc0 +}; +static const GLUTBitmapChar ch44 = { 3, 5, -2, 3, 7, ch44data }; + +static const unsigned char ch45data[] = { + 0xff,0xf0,0xff,0xf0 +}; +static const GLUTBitmapChar ch45 = { 12, 2, -1, -6, 14, ch45data }; + +static const unsigned char ch46data[] = { + 0xc0,0xc0 +}; +static const GLUTBitmapChar ch46 = { 2, 2, -2, 0, 6, ch46data }; + +static const unsigned char ch47data[] = { + 0xc0,0xc0,0xc0,0x60,0x60,0x20,0x30,0x30,0x10,0x18,0x18,0x8,0xc,0xc,0x4,0x6, + 0x6,0x3,0x3,0x3 +}; +static const GLUTBitmapChar ch47 = { 8, 20, 1, 3, 7, ch47data }; + +static const unsigned char 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 GLUTBitmapChar ch48 = { 10, 17, -1, 0, 12, ch48data }; + +static const unsigned char ch49data[] = { + 0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x78,0x18, + 0x8 +}; +static const GLUTBitmapChar ch49 = { 8, 17, -2, 0, 12, ch49data }; + +static const unsigned char 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 GLUTBitmapChar ch50 = { 10, 17, -1, 0, 12, ch50data }; + +static const unsigned char 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 GLUTBitmapChar ch51 = { 9, 17, -1, 0, 12, ch51data }; + +static const unsigned char 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 GLUTBitmapChar ch52 = { 10, 17, -1, 0, 12, ch52data }; + +static const unsigned char 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 GLUTBitmapChar ch53 = { 10, 17, -1, 0, 12, ch53data }; + +static const unsigned char 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 GLUTBitmapChar ch54 = { 10, 17, -1, 0, 12, ch54data }; + +static const unsigned char 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 GLUTBitmapChar ch55 = { 10, 17, -1, 0, 12, ch55data }; + +static const unsigned char 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 GLUTBitmapChar ch56 = { 10, 17, -1, 0, 12, ch56data }; + +static const unsigned char 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 GLUTBitmapChar ch57 = { 10, 17, -1, 0, 12, ch57data }; + +static const unsigned char ch58data[] = { + 0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch58 = { 2, 11, -2, 0, 6, ch58data }; + +static const unsigned char ch59data[] = { + 0xc0,0x60,0x20,0xe0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0 +}; +static const GLUTBitmapChar ch59 = { 3, 14, -2, 3, 7, ch59data }; + +static const unsigned char 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 GLUTBitmapChar ch60 = { 11, 11, -1, -1, 13, ch60data }; + +static const unsigned char ch61data[] = { + 0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0 +}; +static const GLUTBitmapChar ch61 = { 12, 6, -1, -4, 14, ch61data }; + +static const unsigned char 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 GLUTBitmapChar ch62 = { 11, 11, -1, -1, 13, ch62data }; + +static const unsigned char ch63data[] = { + 0x30,0x30,0x0,0x0,0x10,0x10,0x10,0x18,0x18,0xc,0xe,0x7,0xc3,0xc3,0x83,0xc6, + 0x7c +}; +static const GLUTBitmapChar ch63 = { 8, 17, -2, 0, 11, ch63data }; + +static const unsigned char 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 GLUTBitmapChar ch64 = { 18, 20, -2, 3, 22, ch64data }; + +static const unsigned char 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 GLUTBitmapChar ch65 = { 17, 17, 0, 0, 17, ch65data }; + +static const unsigned char 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 GLUTBitmapChar ch66 = { 14, 17, -1, 0, 16, ch66data }; + +static const unsigned char 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 GLUTBitmapChar ch67 = { 14, 17, -1, 0, 16, ch67data }; + +static const unsigned char 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 GLUTBitmapChar ch68 = { 15, 17, -1, 0, 17, ch68data }; + +static const unsigned char 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 GLUTBitmapChar ch69 = { 13, 17, -1, 0, 15, ch69data }; + +static const unsigned char 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 GLUTBitmapChar ch70 = { 12, 17, -1, 0, 14, ch70data }; + +static const unsigned char 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 GLUTBitmapChar ch71 = { 16, 17, -1, 0, 18, ch71data }; + +static const unsigned char 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 GLUTBitmapChar ch72 = { 17, 17, -1, 0, 19, ch72data }; + +static const unsigned char ch73data[] = { + 0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30, + 0xfc +}; +static const GLUTBitmapChar ch73 = { 6, 17, -1, 0, 8, ch73data }; + +static const unsigned char 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 GLUTBitmapChar ch74 = { 9, 17, -1, 0, 11, ch74data }; + +static const unsigned char 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 GLUTBitmapChar ch75 = { 16, 17, -1, 0, 17, ch75data }; + +static const unsigned char 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 GLUTBitmapChar ch76 = { 13, 17, -1, 0, 14, ch76data }; + +static const unsigned char 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 GLUTBitmapChar ch77 = { 21, 17, -1, 0, 22, ch77data }; + +static const unsigned char 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 GLUTBitmapChar ch78 = { 16, 17, -1, 0, 18, ch78data }; + +static const unsigned char 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 GLUTBitmapChar ch79 = { 16, 17, -1, 0, 18, ch79data }; + +static const unsigned char 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 GLUTBitmapChar ch80 = { 13, 17, -1, 0, 15, ch80data }; + +static const unsigned char 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 GLUTBitmapChar ch81 = { 16, 22, -1, 5, 18, ch81data }; + +static const unsigned char 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 GLUTBitmapChar ch82 = { 15, 17, -1, 0, 16, ch82data }; + +static const unsigned char 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 GLUTBitmapChar ch83 = { 11, 17, -1, 0, 13, ch83data }; + +static const unsigned char 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 GLUTBitmapChar ch84 = { 14, 17, -1, 0, 16, ch84data }; + +static const unsigned char 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 GLUTBitmapChar ch85 = { 16, 17, -1, 0, 18, ch85data }; + +static const unsigned char 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 GLUTBitmapChar ch86 = { 17, 17, 0, 0, 17, ch86data }; + +static const unsigned char 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 GLUTBitmapChar ch87 = { 23, 17, 0, 0, 23, ch87data }; + +static const unsigned char 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 GLUTBitmapChar ch88 = { 18, 17, 0, 0, 18, ch88data }; + +static const unsigned char 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 GLUTBitmapChar ch89 = { 16, 17, 0, 0, 16, ch89data }; + +static const unsigned char 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 GLUTBitmapChar ch90 = { 13, 17, -1, 0, 15, ch90data }; + +static const unsigned char ch91data[] = { + 0xf8,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, + 0xc0,0xc0,0xc0,0xc0,0xf8 +}; +static const GLUTBitmapChar ch91 = { 5, 21, -2, 4, 8, ch91data }; + +static const unsigned char ch92data[] = { + 0x6,0x6,0x4,0xc,0xc,0x8,0x18,0x18,0x10,0x30,0x30,0x20,0x60,0x60,0x40,0xc0, + 0xc0 +}; +static const GLUTBitmapChar ch92 = { 7, 17, 0, 0, 7, ch92data }; + +static const unsigned char ch93data[] = { + 0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, + 0x18,0x18,0x18,0x18,0xf8 +}; +static const GLUTBitmapChar ch93 = { 5, 21, -1, 4, 8, ch93data }; + +static const unsigned char ch94data[] = { + 0x80,0x80,0xc1,0x80,0x41,0x0,0x63,0x0,0x22,0x0,0x36,0x0,0x14,0x0,0x1c,0x0, + 0x8,0x0 +}; +static const GLUTBitmapChar ch94 = { 9, 9, -1, -8, 11, ch94data }; + +static const unsigned char ch95data[] = { + 0xff,0xf8,0xff,0xf8 +}; +static const GLUTBitmapChar ch95 = { 13, 2, 0, 5, 13, ch95data }; + +static const unsigned char ch96data[] = { + 0x60,0xe0,0x80,0xc0,0x60 +}; +static const GLUTBitmapChar ch96 = { 3, 5, -2, -12, 7, ch96data }; + +static const unsigned char 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 GLUTBitmapChar ch97 = { 9, 12, -1, 0, 11, ch97data }; + +static const unsigned char 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 GLUTBitmapChar ch98 = { 10, 17, -1, 0, 12, ch98data }; + +static const unsigned char 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 GLUTBitmapChar ch99 = { 9, 12, -1, 0, 11, ch99data }; + +static const unsigned char 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 GLUTBitmapChar ch100 = { 10, 17, -1, 0, 12, ch100data }; + +static const unsigned char 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 GLUTBitmapChar ch101 = { 9, 12, -1, 0, 11, ch101data }; + +static const unsigned char ch102data[] = { + 0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x30,0x30,0x30,0x16, + 0xe +}; +static const GLUTBitmapChar ch102 = { 7, 17, 0, 0, 7, ch102data }; + +static const unsigned char 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 GLUTBitmapChar ch103 = { 11, 17, -1, 5, 12, ch103data }; + +static const unsigned char 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 GLUTBitmapChar ch104 = { 11, 17, -1, 0, 13, ch104data }; + +static const unsigned char ch105data[] = { + 0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x0,0x0,0x60, + 0x60 +}; +static const GLUTBitmapChar ch105 = { 4, 17, -1, 0, 6, ch105data }; + +static const unsigned char 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 GLUTBitmapChar ch106 = { 4, 22, 0, 5, 6, ch106data }; + +static const unsigned char 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 GLUTBitmapChar ch107 = { 11, 17, -1, 0, 12, ch107data }; + +static const unsigned char ch108data[] = { + 0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60, + 0xe0 +}; +static const GLUTBitmapChar ch108 = { 4, 17, -1, 0, 6, ch108data }; + +static const unsigned char 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 GLUTBitmapChar ch109 = { 18, 12, -1, 0, 20, ch109data }; + +static const unsigned char 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 GLUTBitmapChar ch110 = { 11, 12, -1, 0, 13, ch110data }; + +static const unsigned char 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 GLUTBitmapChar ch111 = { 10, 12, -1, 0, 12, ch111data }; + +static const unsigned char 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 GLUTBitmapChar ch112 = { 10, 17, -1, 5, 12, ch112data }; + +static const unsigned char 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 GLUTBitmapChar ch113 = { 10, 17, -1, 5, 12, ch113data }; + +static const unsigned char ch114data[] = { + 0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x76,0x6e,0xe6 +}; +static const GLUTBitmapChar ch114 = { 7, 12, -1, 0, 8, ch114data }; + +static const unsigned char ch115data[] = { + 0xf8,0xc6,0x83,0x3,0x7,0x1e,0x7c,0x70,0xe0,0xc2,0x66,0x3e +}; +static const GLUTBitmapChar ch115 = { 8, 12, -1, 0, 10, ch115data }; + +static const unsigned char ch116data[] = { + 0x1c,0x32,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x70,0x30,0x10 +}; +static const GLUTBitmapChar ch116 = { 7, 15, 0, 0, 7, ch116data }; + +static const unsigned char 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 GLUTBitmapChar ch117 = { 11, 12, -1, 0, 13, ch117data }; + +static const unsigned char 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 GLUTBitmapChar ch118 = { 11, 12, 0, 0, 11, ch118data }; + +static const unsigned char 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 GLUTBitmapChar ch119 = { 17, 12, 0, 0, 17, ch119data }; + +static const unsigned char 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 GLUTBitmapChar ch120 = { 11, 12, -1, 0, 13, ch120data }; + +static const unsigned char 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 GLUTBitmapChar ch121 = { 11, 17, 0, 5, 11, ch121data }; + +static const unsigned char ch122data[] = { + 0xff,0xc3,0x61,0x70,0x30,0x38,0x18,0x1c,0xe,0x86,0xc3,0xff +}; +static const GLUTBitmapChar ch122 = { 8, 12, -1, 0, 10, ch122data }; + +static const unsigned char 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 GLUTBitmapChar ch123 = { 8, 22, -1, 5, 10, ch123data }; + +static const unsigned char ch124data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, + 0xc0 +}; +static const GLUTBitmapChar ch124 = { 2, 17, -2, 0, 6, ch124data }; + +static const unsigned char 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 GLUTBitmapChar ch125 = { 8, 22, -1, 5, 10, ch125data }; + +static const unsigned char ch126data[] = { + 0x83,0x80,0xc7,0xc0,0x7c,0x60,0x38,0x20 +}; +static const GLUTBitmapChar ch126 = { 11, 4, -1, -5, 13, ch126data }; + +static const unsigned char ch160data[] = { + 0x0 +}; +static const GLUTBitmapChar ch160 = { 1, 1, 0, 0, 6, ch160data }; + +static const unsigned char ch161data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0, + 0xc0 +}; +static const GLUTBitmapChar ch161 = { 2, 17, -4, 5, 8, ch161data }; + +static const unsigned char 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 GLUTBitmapChar ch162 = { 9, 16, -1, 2, 12, ch162data }; + +static const unsigned char 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 GLUTBitmapChar ch163 = { 10, 17, -1, 0, 12, ch163data }; + +static const unsigned char 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 GLUTBitmapChar ch164 = { 11, 12, -1, -3, 13, ch164data }; + +static const unsigned char 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 GLUTBitmapChar ch165 = { 14, 17, 0, 0, 14, ch165data }; + +static const unsigned char ch166data[] = { + 0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, + 0xc0 +}; +static const GLUTBitmapChar ch166 = { 2, 17, -2, 0, 6, ch166data }; + +static const unsigned char ch167data[] = { + 0x38,0x64,0x62,0x6,0xe,0x1c,0x38,0x74,0xe2,0xc3,0x83,0x87,0x4e,0x3c,0x38,0x70, + 0x60,0x46,0x26,0x1c +}; +static const GLUTBitmapChar ch167 = { 8, 20, -2, 2, 12, ch167data }; + +static const unsigned char ch168data[] = { + 0xcc,0xcc +}; +static const GLUTBitmapChar ch168 = { 6, 2, -1, -14, 8, ch168data }; + +static const unsigned char 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 GLUTBitmapChar ch169 = { 17, 17, -1, 0, 19, ch169data }; + +static const unsigned char ch170data[] = { + 0x7e,0x0,0x76,0xcc,0xcc,0x7c,0xc,0xcc,0x78 +}; +static const GLUTBitmapChar ch170 = { 7, 9, 0, -8, 8, ch170data }; + +static const unsigned char ch171data[] = { + 0x8,0x80,0x19,0x80,0x33,0x0,0x66,0x0,0xcc,0x0,0xcc,0x0,0x66,0x0,0x33,0x0, + 0x19,0x80,0x8,0x80 +}; +static const GLUTBitmapChar ch171 = { 9, 10, -2, -1, 13, ch171data }; + +static const unsigned char ch172data[] = { + 0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0xff,0xf0,0xff,0xf0 +}; +static const GLUTBitmapChar ch172 = { 12, 7, -1, -3, 14, ch172data }; + +static const unsigned char ch173data[] = { + 0xfe,0xfe +}; +static const GLUTBitmapChar ch173 = { 7, 2, -1, -5, 9, ch173data }; + +static const unsigned char 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 GLUTBitmapChar ch174 = { 17, 17, -1, 0, 19, ch174data }; + +static const unsigned char ch175data[] = { + 0xfc,0xfc +}; +static const GLUTBitmapChar ch175 = { 6, 2, -1, -14, 8, ch175data }; + +static const unsigned char ch176data[] = { + 0x38,0x44,0x82,0x82,0x82,0x44,0x38 +}; +static const GLUTBitmapChar ch176 = { 7, 7, -1, -10, 9, ch176data }; + +static const unsigned char 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 GLUTBitmapChar ch177 = { 12, 15, -1, 0, 14, ch177data }; + +static const unsigned char ch178data[] = { + 0xfc,0x44,0x20,0x30,0x10,0x8,0xc,0x8c,0x4c,0x38 +}; +static const GLUTBitmapChar ch178 = { 6, 10, 0, -7, 7, ch178data }; + +static const unsigned char ch179data[] = { + 0x70,0x88,0x8c,0xc,0x8,0x30,0x8,0x8c,0x4c,0x38 +}; +static const GLUTBitmapChar ch179 = { 6, 10, 0, -7, 7, ch179data }; + +static const unsigned char ch180data[] = { + 0x80,0x60,0x38,0x18 +}; +static const GLUTBitmapChar ch180 = { 5, 4, -2, -13, 8, ch180data }; + +static const unsigned char 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 GLUTBitmapChar ch181 = { 11, 17, -1, 5, 13, ch181data }; + +static const unsigned char 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 GLUTBitmapChar ch182 = { 9, 22, -1, 5, 11, ch182data }; + +static const unsigned char ch183data[] = { + 0xc0,0xc0 +}; +static const GLUTBitmapChar ch183 = { 2, 2, -2, -6, 6, ch183data }; + +static const unsigned char ch184data[] = { + 0x78,0xcc,0xc,0x3c,0x30,0x10 +}; +static const GLUTBitmapChar ch184 = { 6, 6, -1, 6, 8, ch184data }; + +static const unsigned char ch185data[] = { + 0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xa0,0x60,0x20 +}; +static const GLUTBitmapChar ch185 = { 5, 10, -1, -7, 7, ch185data }; + +static const unsigned char ch186data[] = { + 0xfc,0x0,0x78,0xcc,0xcc,0xcc,0xcc,0xcc,0x78 +}; +static const GLUTBitmapChar ch186 = { 6, 9, -1, -8, 8, ch186data }; + +static const unsigned char ch187data[] = { + 0x88,0x0,0xcc,0x0,0x66,0x0,0x33,0x0,0x19,0x80,0x19,0x80,0x33,0x0,0x66,0x0, + 0xcc,0x0,0x88,0x0 +}; +static const GLUTBitmapChar ch187 = { 9, 10, -2, -1, 12, ch187data }; + +static const unsigned char 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 GLUTBitmapChar ch188 = { 16, 17, -1, 0, 18, ch188data }; + +static const unsigned char 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 GLUTBitmapChar ch189 = { 15, 17, -1, 0, 18, ch189data }; + +static const unsigned char 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 GLUTBitmapChar ch190 = { 17, 17, 0, 0, 18, ch190data }; + +static const unsigned char ch191data[] = { + 0x3e,0x63,0xc1,0xc3,0xc3,0xe0,0x70,0x30,0x38,0x18,0x18,0x8,0x8,0x0,0x0,0xc, + 0xc +}; +static const GLUTBitmapChar ch191 = { 8, 17, -1, 5, 11, ch191data }; + +static const unsigned char 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 GLUTBitmapChar ch192 = { 17, 22, 0, 0, 17, ch192data }; + +static const unsigned char 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 GLUTBitmapChar ch193 = { 17, 22, 0, 0, 17, ch193data }; + +static const unsigned char 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 GLUTBitmapChar ch194 = { 17, 22, 0, 0, 17, ch194data }; + +static const unsigned char 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 GLUTBitmapChar ch195 = { 17, 21, 0, 0, 17, ch195data }; + +static const unsigned char 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 GLUTBitmapChar ch196 = { 17, 21, 0, 0, 17, ch196data }; + +static const unsigned char 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 GLUTBitmapChar ch197 = { 17, 21, 0, 0, 17, ch197data }; + +static const unsigned char 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 GLUTBitmapChar ch198 = { 20, 17, 0, 0, 21, ch198data }; + +static const unsigned char 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 GLUTBitmapChar ch199 = { 14, 23, -1, 6, 16, ch199data }; + +static const unsigned char 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 GLUTBitmapChar ch200 = { 13, 22, -1, 0, 15, ch200data }; + +static const unsigned char 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 GLUTBitmapChar ch201 = { 13, 22, -1, 0, 15, ch201data }; + +static const unsigned char 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 GLUTBitmapChar ch202 = { 13, 22, -1, 0, 15, ch202data }; + +static const unsigned char 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 GLUTBitmapChar ch203 = { 13, 21, -1, 0, 15, ch203data }; + +static const unsigned char 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 GLUTBitmapChar ch204 = { 6, 22, -1, 0, 8, ch204data }; + +static const unsigned char 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 GLUTBitmapChar ch205 = { 6, 22, -1, 0, 8, ch205data }; + +static const unsigned char 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 GLUTBitmapChar ch206 = { 8, 22, -1, 0, 8, ch206data }; + +static const unsigned char ch207data[] = { + 0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30, + 0xfc,0x0,0x0,0xcc,0xcc +}; +static const GLUTBitmapChar ch207 = { 6, 21, -1, 0, 8, ch207data }; + +static const unsigned char 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 GLUTBitmapChar ch208 = { 16, 17, 0, 0, 17, ch208data }; + +static const unsigned char 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 GLUTBitmapChar ch209 = { 16, 21, -1, 0, 18, ch209data }; + +static const unsigned char 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 GLUTBitmapChar ch210 = { 16, 22, -1, 0, 18, ch210data }; + +static const unsigned char 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 GLUTBitmapChar ch211 = { 16, 22, -1, 0, 18, ch211data }; + +static const unsigned char 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 GLUTBitmapChar ch212 = { 16, 22, -1, 0, 18, ch212data }; + +static const unsigned char 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 GLUTBitmapChar ch213 = { 16, 21, -1, 0, 18, ch213data }; + +static const unsigned char 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 GLUTBitmapChar ch214 = { 16, 21, -1, 0, 18, ch214data }; + +static const unsigned char 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 GLUTBitmapChar ch215 = { 10, 11, -2, -1, 14, ch215data }; + +static const unsigned char 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 GLUTBitmapChar ch216 = { 16, 19, -1, 1, 18, ch216data }; + +static const unsigned char 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 GLUTBitmapChar ch217 = { 16, 22, -1, 0, 18, ch217data }; + +static const unsigned char 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 GLUTBitmapChar ch218 = { 16, 22, -1, 0, 18, ch218data }; + +static const unsigned char 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 GLUTBitmapChar ch219 = { 16, 22, -1, 0, 18, ch219data }; + +static const unsigned char 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 GLUTBitmapChar ch220 = { 16, 21, -1, 0, 18, ch220data }; + +static const unsigned char 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 GLUTBitmapChar ch221 = { 16, 22, 0, 0, 16, ch221data }; + +static const unsigned char 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 GLUTBitmapChar ch222 = { 13, 17, -1, 0, 15, ch222data }; + +static const unsigned char 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 GLUTBitmapChar ch223 = { 10, 17, -1, 0, 12, ch223data }; + +static const unsigned char 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 GLUTBitmapChar ch224 = { 9, 17, -1, 0, 11, ch224data }; + +static const unsigned char 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 GLUTBitmapChar ch225 = { 9, 17, -1, 0, 11, ch225data }; + +static const unsigned char 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 GLUTBitmapChar ch226 = { 9, 17, -1, 0, 11, ch226data }; + +static const unsigned char 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 GLUTBitmapChar ch227 = { 9, 16, -1, 0, 11, ch227data }; + +static const unsigned char 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 GLUTBitmapChar ch228 = { 9, 16, -1, 0, 11, ch228data }; + +static const unsigned char 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 GLUTBitmapChar ch229 = { 9, 17, -1, 0, 11, ch229data }; + +static const unsigned char 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 GLUTBitmapChar ch230 = { 14, 12, -1, 0, 16, ch230data }; + +static const unsigned char 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 GLUTBitmapChar ch231 = { 9, 18, -1, 6, 11, ch231data }; + +static const unsigned char 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 GLUTBitmapChar ch232 = { 9, 17, -1, 0, 11, ch232data }; + +static const unsigned char 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 GLUTBitmapChar ch233 = { 9, 17, -1, 0, 11, ch233data }; + +static const unsigned char 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 GLUTBitmapChar ch234 = { 9, 17, -1, 0, 11, ch234data }; + +static const unsigned char 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 GLUTBitmapChar ch235 = { 9, 16, -1, 0, 11, ch235data }; + +static const unsigned char ch236data[] = { + 0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x8,0x30,0xe0, + 0xc0 +}; +static const GLUTBitmapChar ch236 = { 5, 17, 0, 0, 6, ch236data }; + +static const unsigned char ch237data[] = { + 0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x80,0x60,0x38, + 0x18 +}; +static const GLUTBitmapChar ch237 = { 5, 17, -1, 0, 6, ch237data }; + +static const unsigned char ch238data[] = { + 0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x84,0x48,0x78, + 0x30 +}; +static const GLUTBitmapChar ch238 = { 6, 17, 0, 0, 6, ch238data }; + +static const unsigned char ch239data[] = { + 0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x0,0xcc,0xcc +}; +static const GLUTBitmapChar ch239 = { 6, 16, 0, 0, 6, ch239data }; + +static const unsigned char 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 GLUTBitmapChar ch240 = { 10, 17, -1, 0, 12, ch240data }; + +static const unsigned char 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 GLUTBitmapChar ch241 = { 11, 16, -1, 0, 13, ch241data }; + +static const unsigned char 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 GLUTBitmapChar ch242 = { 10, 17, -1, 0, 12, ch242data }; + +static const unsigned char 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 GLUTBitmapChar ch243 = { 10, 17, -1, 0, 12, ch243data }; + +static const unsigned char 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 GLUTBitmapChar ch244 = { 10, 17, -1, 0, 12, ch244data }; + +static const unsigned char 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 GLUTBitmapChar ch245 = { 10, 16, -1, 0, 12, ch245data }; + +static const unsigned char 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 GLUTBitmapChar ch246 = { 10, 16, -1, 0, 12, ch246data }; + +static const unsigned char ch247data[] = { + 0x6,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0, + 0x6,0x0,0x6,0x0 +}; +static const GLUTBitmapChar ch247 = { 12, 10, -1, -2, 14, ch247data }; + +static const unsigned char 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 GLUTBitmapChar ch248 = { 10, 14, -1, 1, 12, ch248data }; + +static const unsigned char 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 GLUTBitmapChar ch249 = { 11, 17, -1, 0, 13, ch249data }; + +static const unsigned char 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 GLUTBitmapChar ch250 = { 11, 17, -1, 0, 13, ch250data }; + +static const unsigned char 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 GLUTBitmapChar ch251 = { 11, 17, -1, 0, 13, ch251data }; + +static const unsigned char 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 GLUTBitmapChar ch252 = { 11, 16, -1, 0, 13, ch252data }; + +static const unsigned char 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 GLUTBitmapChar ch253 = { 11, 22, 0, 5, 11, ch253data }; + +static const unsigned char 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 GLUTBitmapChar ch254 = { 10, 22, -1, 5, 12, ch254data }; + +static const unsigned char 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 GLUTBitmapChar ch255 = { 11, 21, 0, 5, 11, ch255data }; + + +static const GLUTBitmapChar *chars[] = { + 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, + &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 GLUTBitmapFont glutBitmapTimesRoman24 = { + "-Adobe-Times-Medium-R-Normal--24-240-75-75-P-124-ISO8859-1", + 28, 256, chars +}; diff --git a/src/glut/dos/util.c b/src/glut/dos/util.c new file mode 100644 index 000000000..df126443d --- /dev/null +++ b/src/glut/dos/util.c @@ -0,0 +1,74 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "internal.h" + + +extern GLUTStrokeFont glutStrokeRoman, glutStrokeMonoRoman; +extern GLUTBitmapFont glutBitmap8By13, glutBitmap9By15, glutBitmapTimesRoman10, glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12, glutBitmapHelvetica18; + +/* To get around the fact that DJGPP DXEs only allow functions + to be exported and no 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 * +_glut_font (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; + default: + if ((font == &glutStrokeRoman) || + (font == &glutStrokeMonoRoman) || + (font == &glutBitmap9By15) || + (font == &glutBitmap8By13) || + (font == &glutBitmapTimesRoman10) || + (font == &glutBitmapTimesRoman24) || + (font == &glutBitmapHelvetica10) || + (font == &glutBitmapHelvetica12) || + (font == &glutBitmapHelvetica18)) { + return font; + } + _glut_fatal("bad font!"); + return NULL; + } +} diff --git a/src/glut/dos/window.c b/src/glut/dos/window.c new file mode 100644 index 000000000..b922746a9 --- /dev/null +++ b/src/glut/dos/window.c @@ -0,0 +1,325 @@ +/* + * DOS/DJGPP Mesa Utility Toolkit + * Version: 1.0 + * + * Copyright (C) 2005 Daniel Borca All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include + +#include "internal.h" + + +static GLuint swaptime, swapcount; + +static DMesaVisual visual = NULL; + +GLUTwindow *_glut_current, *_glut_windows[MAX_WINDOWS]; + + +static void +clean (void) +{ + int i; + + for (i=1; i<=MAX_WINDOWS; i++) { + glutDestroyWindow(i); + } + if (visual) DMesaDestroyVisual(visual); + + pc_close_stdout(); + pc_close_stderr(); +} + + +static GLUTwindow * +_glut_window (int win) +{ + if (win > 0 && --win < MAX_WINDOWS) { + return _glut_windows[win]; + } + return NULL; +} + + +int APIENTRY +glutCreateWindow (const char *title) +{ + int i; + int m8width = (_glut_default.width + 7) & ~7; + + /* We set the Visual once. This will be our desktop (graphic mode). + * We should do this in the `glutInit' code, but we don't have any idea + * about its geometry. Supposedly, when we are about to create one + * window, we have a slight idea about resolution. + */ + if (!visual) { + if ((visual=DMesaCreateVisual(_glut_default.x + m8width, _glut_default.y + _glut_default.height, _glut_visual.bpp, _glut_visual.refresh, + _glut_default.mode & GLUT_DOUBLE, + !(_glut_default.mode & GLUT_INDEX), + (_glut_default.mode & GLUT_ALPHA ) ? _glut_visual.alpha : 0, + (_glut_default.mode & GLUT_DEPTH ) ? _glut_visual.depth : 0, + (_glut_default.mode & GLUT_STENCIL) ? _glut_visual.stencil : 0, + (_glut_default.mode & GLUT_ACCUM ) ? _glut_visual.accum : 0))==NULL) { + return 0; + } + + DMesaGetIntegerv(DMESA_GET_SCREEN_SIZE, _glut_visual.geometry); + DMesaGetIntegerv(DMESA_GET_DRIVER_CAPS, &_glut_visual.flags); + + /* Also hook stdio/stderr once */ + pc_open_stdout(); + pc_open_stderr(); + pc_atexit(clean); + } + + /* Search for an empty slot. + * Each window has its own rendering Context and its own Buffer. + */ + for (i=0; inum = ++i; + w->xpos = _glut_default.x; + w->ypos = _glut_default.y; + w->width = m8width; + w->height = _glut_default.height; + w->context = c; + w->buffer = b; + + return i; + } + } + + return 0; +} + + +int APIENTRY +glutCreateSubWindow (int win, int x, int y, int width, int height) +{ + return GL_FALSE; +} + + +void APIENTRY +glutDestroyWindow (int win) +{ + GLUTwindow *w = _glut_window(win); + if (w != NULL) { + if (w->destroy) { + w->destroy(); + } + DMesaMakeCurrent(NULL, NULL); + DMesaDestroyBuffer(w->buffer); + DMesaDestroyContext(w->context); + free(w); + _glut_windows[win - 1] = NULL; + } +} + + +void APIENTRY +glutPostRedisplay (void) +{ + _glut_current->redisplay = GL_TRUE; +} + + +void APIENTRY +glutSwapBuffers (void) +{ + if (_glut_current->show_mouse) { + /* XXX scare mouse */ + DMesaSwapBuffers(_glut_current->buffer); + /* XXX unscare mouse */ + } else { + DMesaSwapBuffers(_glut_current->buffer); + } + + if (_glut_fps) { + GLint t = glutGet(GLUT_ELAPSED_TIME); + swapcount++; + if (swaptime == 0) + swaptime = t; + else if (t - swaptime > _glut_fps) { + double time = 0.001 * (t - swaptime); + double fps = (double)swapcount / time; + fprintf(stderr, "GLUT: %d frames in %.2f seconds = %.2f FPS\n", swapcount, time, fps); + swaptime = t; + swapcount = 0; + } + } +} + + +int APIENTRY +glutGetWindow (void) +{ + return _glut_current->num; +} + + +void APIENTRY +glutSetWindow (int win) +{ + GLUTwindow *w = _glut_window(win); + if (w != NULL) { + _glut_current = w; + DMesaMakeCurrent(_glut_current->context, _glut_current->buffer); + } +} + + +void APIENTRY +glutSetWindowTitle (const char *title) +{ +} + + +void APIENTRY +glutSetIconTitle (const char *title) +{ +} + + +void APIENTRY +glutPositionWindow (int x, int y) +{ + if (DMesaMoveBuffer(x, y)) { + _glut_current->xpos = x; + _glut_current->ypos = y; + } +} + + +void APIENTRY +glutReshapeWindow (int width, int height) +{ + if (DMesaResizeBuffer(width, height)) { + _glut_current->width = width; + _glut_current->height = height; + if (_glut_current->reshape) { + _glut_current->reshape(width, height); + } else { + glViewport(0, 0, width, height); + } + } +} + + +void APIENTRY +glutFullScreen (void) +{ +} + + +void APIENTRY +glutPopWindow (void) +{ +} + + +void APIENTRY +glutPushWindow (void) +{ +} + + +void APIENTRY +glutIconifyWindow (void) +{ +} + + +void APIENTRY +glutShowWindow (void) +{ +} + + +void APIENTRY +glutHideWindow (void) +{ +} + + +void APIENTRY +glutCloseFunc (GLUTdestroyCB destroy) +{ + _glut_current->destroy = destroy; +} + + +void APIENTRY +glutPostWindowRedisplay (int win) +{ + GLUTwindow *w = _glut_window(win); + if (w != NULL) { + w->redisplay = GL_TRUE; + } +} + + +void * APIENTRY +glutGetWindowData (void) +{ + return _glut_current->data; +} + + +void APIENTRY +glutSetWindowData (void *data) +{ + _glut_current->data = data; +} diff --git a/src/glut/ggi/Makefile b/src/glut/ggi/Makefile new file mode 100644 index 000000000..61cfceeb2 --- /dev/null +++ b/src/glut/ggi/Makefile @@ -0,0 +1,52 @@ +# Makefile for GLUT for ggi + +TOP = ../../.. + +include $(TOP)/configs/current + + +##### MACROS ##### + +GLUT_MAJOR = 3 +GLUT_MINOR = 7 +GLUT_TINY = 1 + +SOURCES = \ + ggiglut.c + + +OBJECTS = $(SOURCES:.c=.o) + + +##### RULES ##### + +.c.o: + $(CC) -c -I$(TOP)/include $(CFLAGS) $(GLUT_CFLAGS) $< + + + +##### TARGETS ##### + +default: $(LIB_DIR)/$(GLUT_LIB_NAME) + + +# Make the library +$(LIB_DIR)/$(GLUT_LIB_NAME): depend $(OBJECTS) + $(TOP)/bin/mklib -o $(GLUT_LIB) -linker '$(CC)' \ + -major $(GLUT_MAJOR) -minor $(GLUT_MINOR) \ + -patch $(GLUT_TINY) $(MKLIB_OPTIONS) -install $(LIB_DIR) \ + $(GLUT_LIB_DEPS) $(OBJECTS) + + +clean: + -rm -f *.o *~ + -rm -f *.lo + -rm -f *.la + -rm -rf .libs + + +depend: $(SOURCES) + touch depend + $(MKDEP) $(MKDEP_OPTIONS) -I$(TOP)/include $(SOURCES) + +include depend diff --git a/src/glut/ggi/debug.h b/src/glut/ggi/debug.h new file mode 100644 index 000000000..da329a1d9 --- /dev/null +++ b/src/glut/ggi/debug.h @@ -0,0 +1,259 @@ +/* $Id: debug.h,v 1.1 2000/11/19 07:41:26 jtaylor Exp $ +****************************************************************************** + + GGIMesa debugging macros + + Copyright (C) 1998-1999 Marcus Sundberg [marcus@ggi-project.org] + Copyright (C) 1999-2000 Jon Taylor [taylorj@ggi-project.org] + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +****************************************************************************** +*/ + +#ifndef _GGI_GLUT_INTERNAL_DEBUG_H +#define _GGI_GLUT_INTERNAL_DEBUG_H + +#define DEBUG + +#include +#include +#include +#include + + +__BEGIN_DECLS + +/* Exported variables */ +#ifdef BUILDING_GGIGLUT +extern uint32 _ggiglutDebugState; +extern int _ggiglutDebugSync; +#else +IMPORTVAR uint32 _ggiglutDebugState; +IMPORTVAR int _ggiglutDebugSync; +#endif + +__END_DECLS + + +/* Debugging types + * bit 0 is reserved! */ + +#define GGIGLUTDEBUG_CORE (1<<1) /* 2 */ +#define GGIGLUTDEBUG_MODE (1<<2) /* 4 */ +#define GGIGLUTDEBUG_COLOR (1<<3) /* 8 */ +#define GGIGLUTDEBUG_DRAW (1<<4) /* 16 */ +#define GGIGLUTDEBUG_MISC (1<<5) /* 32 */ +#define GGIGLUTDEBUG_LIBS (1<<6) /* 64 */ +#define GGIGLUTDEBUG_EVENTS (1<<7) /* 128 */ + +#define GGIGLUTDEBUG_ALL 0xffffffff + +#ifdef __GNUC__ + +#ifdef DEBUG +#define GGIGLUTDPRINT(form,args...) if (_ggiglutDebugState) { ggDPrintf(_ggiglutDebugSync, "GGIGLUT",form, ##args); } +#define GGIGLUTDPRINT_CORE(form,args...) if (_ggiglutDebugState & GGIGLUTDEBUG_CORE) { ggDPrintf(_ggiglutDebugSync,"GGIGLUT",form, ##args); } +#define GGIGLUTDPRINT_MODE(form,args...) if (_ggiglutDebugState & GGIGLUTDEBUG_MODE) { ggDPrintf(_ggiglutDebugSync,"GGIGLUT",form, ##args); } +#define GGIGLUTDPRINT_COLOR(form,args...) if (_ggiglutDebugState & GGIGLUTDEBUG_COLOR) { ggDPrintf(_ggiglutDebugSync,"GGIGLUT",form, ##args); } +#define GGIGLUTDPRINT_DRAW(form,args...) if (_ggiglutDebugState & GGIGLUTDEBUG_DRAW) { ggDPrintf(_ggiglutDebugSync,"GGIGLUT",form, ##args); } +#define GGIGLUTDPRINT_MISC(form,args...) if (_ggiglutDebugState & GGIGLUTDEBUG_MISC) { ggDPrintf(_ggiglutDebugSync,"GGIGLUT",form, ##args); } +#define GGIGLUTDPRINT_LIBS(form,args...) if (_ggiglutDebugState & GGIGLUTDEBUG_LIBS) { ggDPrintf(_ggiglutDebugSync,"GGIGLUT",form, ##args); } +#define GGIGLUTDPRINT_EVENTS(form,args...) if (_ggiglutDebugState & GGIGLUTDEBUG_EVENTS) { ggDPrintf(_ggiglutDebugSync,"GGIGLUT",form, ##args); } +#else /* DEBUG */ +#define GGIGLUTDPRINT(form,args...) do{}while(0) +#define GGIGLUTDPRINT_CORE(form,args...) do{}while(0) +#define GGIGLUTDPRINT_MODE(form,args...) do{}while(0) +#define GGIGLUTDPRINT_COLOR(form,args...) do{}while(0) +#define GGIGLUTDPRINT_DRAW(form,args...) do{}while(0) +#define GGIGLUTDPRINT_MISC(form,args...) do{}while(0) +#define GGIGLUTDPRINT_LIBS(form,args...) do{}while(0) +#define GGIGLUTDPRINT_EVENTS(form,args...) do{}while(0) +#endif /* DEBUG */ + +#else /* __GNUC__ */ + +__BEGIN_DECLS + +static inline void GGIGLUTDPRINT(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +static inline void GGIGLUTDPRINT_CORE(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState & GGIDEBUG_CORE) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +static inline void GGIGLUTDPRINT_MODE(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState & GGIDEBUG_MODE) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +static inline void GGIGLUTDPRINT_COLOR(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState & GGIDEBUG_COLOR) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +static inline void GGIGLUTDPRINT_DRAW(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState & GGIDEBUG_DRAW) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +static inline void GGIGLUTDPRINT_MISC(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState & GGIDEBUG_MISC) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +static inline void GGIGLUTDPRINT_LIBS(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState & GGIDEBUG_LIBS) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +static inline void GGIGLUTDPRINT_EVENTS(const char *form,...) +{ +#ifdef DEBUG + if (_ggiDebugState & GGIDEBUG_EVENTS) { + va_list args; + + fprintf(stderr, "GGIGLUT: "); + va_start(args, form); + vfprintf(stderr, form, args); + va_end(args); + if (_ggiglutDebugSync) fflush(stderr); + } +#endif +} + +__END_DECLS + +#endif /* __GNUC__ */ + +#ifdef DEBUG +#define GGIGLUT_ASSERT(x,str) \ +{ if (!(x)) { \ + fprintf(stderr,"GGIGLUT:%s:%d: INTERNAL ERROR: %s\n",__FILE__,__LINE__,str); \ + exit(1); \ +} } +#define GGIGLUT_APPASSERT(x,str) \ +{ if (!(x)) { \ + fprintf(stderr,"GGIGLUT:%s:%d: APPLICATION ERROR: %s\n",__FILE__,__LINE__,str); \ + exit(1); \ +} } +#else /* DEBUG */ +#define GGIGLUT_ASSERT(x,str) do{}while(0) +#define GGIGLUT_APPASSERT(x,str) do{}while(0) +#endif /* DEBUG */ + +#ifdef DEBUG +# define GGIGLUTD0(x) x +#else +# define GGIGLUTD0(x) /* empty */ +#endif + +#ifdef GGIGLUTDLEV +# if GGIGLUTDLEV == 1 +# define GGIGLUTD1(x) x +# define GGIGLUTD2(x) /* empty */ +# define GGIGLUTD3(x) /* empty */ +# elif GGIGLUTDLEV == 2 +# define GGIGLUTD1(x) x +# define GGIGLUTD2(x) x +# define GGIGLUTD3(x) /* empty */ +# elif GGIGLUTDLEV > 2 +# define GGIGLUTD1(x) x +# define GGIGLUTD2(x) x +# define GGIGLUTD3(x) x +# endif +#else +# define GGIGLUTD1(x) /* empty */ +# define GGIGLUTD2(x) /* empty */ +# define GGIGLUTD3(x) /* empty */ +#endif + +#endif /* _GGI_MESA_INTERNAL_DEBUG_H */ diff --git a/src/glut/ggi/ggiglut.c b/src/glut/ggi/ggiglut.c new file mode 100644 index 000000000..2fe65a154 --- /dev/null +++ b/src/glut/ggi/ggiglut.c @@ -0,0 +1,959 @@ +/* ************************************************************************** + * ggiglut.c + * ************************************************************************** + * + * Copyright (C) 1998 Uwe Maurer - uwe_maurer@t-online.de + * Copyright (C) 1999 James Simmons + * Copyright (C) 1999 Jon Taylor + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * ************************************************************************** + * To-do: + * - Make everything use the portable ggi_* types + * + */ + +#define BUILDING_GGIGLUT + +#define WIDTH 640 +#define HEIGHT 480 +#define GRAPHTYPE_RGB GT_16BIT +#define GRAPHTYPE_INDEX GT_8BIT + +/*************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include "GL/ggimesa.h" +#include "debug.h" + +#include +#include + +int _ggiglutDebugSync = 0; +uint32 _ggiglutDebugState = 0; + +char *__glutProgramName = "GGI"; + +static ggi_visual_t __glut_vis; + +static ggi_mesa_context_t __glut_ctx; + +//static int __glut_width = WIDTH; +//static int __glut_height = HEIGHT; +//static ggi_graphtype __glut_gt_rgb = GRAPHTYPE_RGB; +//static ggi_graphtype __glut_gt_index = GRAPHTYPE_INDEX; +static int __glut_width = GGI_AUTO; +static int __glut_height = GGI_AUTO; +static ggi_graphtype __glut_gt_rgb = GT_AUTO; +static ggi_graphtype __glut_gt_index = GT_8BIT; +static int __glut_init = GL_FALSE; + +static int mousex = WIDTH / 2; +static int mousey = HEIGHT / 2; +static int mouse_moved = GL_FALSE; +static int mouse_down = GL_FALSE; +static int mouse_showcursor = GL_FALSE; + +static void (*__glut_reshape)(int, int); +static void (*__glut_display)(void); +static void (*__glut_idle)(void); +static void (*__glut_keyboard)(unsigned char, int, int); +static void (*__glut_special)(int, int, int); +static void (*__glut_mouse)(int, int, int, int); +static void (*__glut_motion)(int, int); +static void (*__glut_passive_motion)(int, int); +static void (*__glut_visibility)(int); + +static unsigned int __glut_mode = GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH; + +static int __glut_mod_keys = 0; + +static int __glut_redisplay = GL_FALSE; + +/* Menu */ +static int __glut_menubutton = -1; +static int __glut_menuactive = GL_FALSE; + +#define MAX_ENTRIES 64 + +typedef struct menu_s +{ + char *label[MAX_ENTRIES]; + int value[MAX_ENTRIES]; + struct menu_s * submenu[MAX_ENTRIES]; + void (*func)(int); + int max_strlen; + int num_entries; +} menu_t; + +static menu_t *mainmenu; +static menu_t *curmenu; +static menu_t *activemenu; + +void glutInit(int *argc, char **argv) +{ + ggi_graphtype gt; + int i, k; + char *str; + + GGIGLUTDPRINT_CORE("glutInit() called\n"); + + #define REMOVE {for (k=i;k<*argc-1;k++) argv[k]=argv[k+1]; \ + (*argc)--; i--; } + + if (__glut_init) return; + + str = getenv("GGIGLUT_DEBUG"); + if (str != NULL) { + _ggiglutDebugState = atoi(str); + fprintf(stderr, "Debugging=%d\n", _ggiglutDebugState); + GGIGLUTDPRINT_CORE("Debugging=%d\n", _ggiglutDebugState); + } + + str = getenv("GGIGLUT_DEBUGSYNC"); + if (str != NULL) { + _ggiglutDebugSync = 1; + } + + if (argc && argv) + { + + for (i = 1; i < *argc; i++) + { + if (strcmp(argv[i], "-mouse") == 0) + { + mouse_showcursor = GL_TRUE; + REMOVE; + } + else + if (strcmp(argv[i], "-bpp") == 0 && (i + 1) < (*argc)) + { + switch(atoi(argv[i + 1])) + { + case 4: gt = GT_4BIT; break; + case 8: gt = GT_8BIT; break; + case 15: gt = GT_15BIT; break; + case 16: gt = GT_16BIT; break; + case 24: gt = GT_24BIT; break; + case 32: gt = GT_32BIT; break; + default: + ggiPanic("\"%s\" bits per pixel?\n", argv[i+1]); + } + __glut_gt_rgb = __glut_gt_index = gt; + REMOVE; + REMOVE; + } + else + if (strcmp(argv[i], "-size") == 0 && (i + 2) < (*argc)) + { + __glut_width = atoi(argv[i + 1]); + __glut_height = atoi(argv[i + 2]); + REMOVE; + REMOVE; + REMOVE; + } + } + } + + if (ggiInit() < 0) + { + ggiPanic("ggiInit() failed!\n"); + } + __glut_init = GL_TRUE; + +#undef REMOVE +} + +void glutInitWindowPosition(int x, int y) +{ + GGIGLUTDPRINT_CORE("glutInitWindowPosition() called\n"); +} + +void glutInitWindowSize(int x, int y) +{ + GGIGLUTDPRINT_CORE("glutInitWindowsSize() called\n"); +} + +void glutFullScreen(void) +{ + GGIGLUTDPRINT_CORE("glutFullScreen() called\n"); +} + +void glutInitDisplayMode(unsigned int mode) +{ + GGIGLUTDPRINT_CORE("glutInitDisplayMode() called\n"); + + __glut_mode = mode; +} + +void glutInitDisplayString(const char *string) +{ + GGIGLUTDPRINT_CORE("glutInitDisplayString(%s) called\n", string); +} + +int glutCreateWindow(const char *title) +{ + ggi_graphtype gt; + ggi_mode mode = + { + 1, + { GGI_AUTO, GGI_AUTO }, + { GGI_AUTO, GGI_AUTO }, + { 0, 0 }, + GT_AUTO, + { GGI_AUTO, GGI_AUTO } + }; + int frames; + int rgb; + int err; + + GGIGLUTDPRINT_CORE("glutCreateWindow() called\n"); + + if (!__glut_init) + glutInit(NULL, NULL); + + GGIGLUTDPRINT("GGIGLUT: %s\n", title); + + rgb = !(__glut_mode & GLUT_INDEX); + frames = (__glut_mode & GLUT_DOUBLE) ? 2 : 1; + + gt = (rgb) ? __glut_gt_rgb : __glut_gt_index; + + __glut_vis = ggiOpen(NULL); + if (__glut_vis == NULL) + { + ggiPanic("ggiOpen() failed!\n"); + /* return GL_FALSE; */ + } + + ggiSetFlags(__glut_vis, GGIFLAG_ASYNC); + + ggiCheckMode(__glut_vis, &mode); + + err = ggiSetMode(__glut_vis, &mode); + if (err < 0) + { + ggiPanic("Can't set graphic mode!\n"); + /* return GL_FALSE; */ + } + + if (ggiMesaExtendVisual(__glut_vis, GL_FALSE, GL_FALSE, + 16, 0, 0, 0, 0, 0, 1) < 0) + { + ggiPanic("GGIMesaSetVisual failed!\n"); + } + + __glut_ctx = ggiMesaCreateContext(__glut_vis); + + if (__glut_ctx == NULL) + ggiPanic("Can't create mesa-context\n"); + + ggiGetMode(__glut_vis, &mode); + + + __glut_width = mode.visible.x; + __glut_height = mode.visible.y; + + mousex = mode.visible.x / 2; + mousey = mode.visible.y / 2; + + ggiMesaMakeCurrent(__glut_ctx, __glut_vis); + + if (__glut_reshape) + __glut_reshape(__glut_width, __glut_height); + + return GL_TRUE; +} + +void glutReshapeFunc(void (*func)(int, int)) +{ + GGIGLUTDPRINT_CORE("glutReshapeFunc() called\n"); + + __glut_reshape = func; + if (__glut_vis && __glut_reshape) + __glut_reshape(__glut_width, __glut_height); +} + +void glutKeyboardFunc(void (*keyboard)(unsigned char key, int x, int y)) +{ + GGIGLUTDPRINT_CORE("glutKeyBoardFunc() called\n"); + + __glut_keyboard = keyboard; +} + +int glutGetModifiers(void) +{ + GGIGLUTDPRINT_CORE("glutGetModifiers() called\n"); + + return __glut_mod_keys; +} + +void glutEntryFunc(void (*func)(int state)) +{ + GGIGLUTDPRINT_CORE("glutEntryFunc() called\n"); +} + +void glutVisibilitFunc(void (*func)(int state)) +{ + GGIGLUTDPRINT_CORE("glutVisibilityFunc() called\n"); +} + +void glutTimerFunc(unsigned int millis, void (*func)(int value), int value) +{ + GGIGLUTDPRINT_CORE("glutTimerFunc() called\n"); +} + +void glutMenuStateFunc(void (*func)(int state)) +{ + GGIGLUTDPRINT_CORE("glutMenuStateFunc() called\n"); +} + +int glutGet(GLenum type) +{ + GGIGLUTDPRINT_CORE("glutGet() called\n"); + + switch(type) + { + case GLUT_WINDOW_X: + return 0; + case GLUT_WINDOW_Y: + return 0; + case GLUT_WINDOW_WIDTH: + return __glut_width; + case GLUT_WINDOW_HEIGHT: + return __glut_height; + case GLUT_MENU_NUM_ITEMS: + if (curmenu) + return curmenu->num_entries; + else + return 0; + default: + GGIGLUTDPRINT("glutGet: unknown type %i\n", type); + } + return 0; +} + +void glutSpecialFunc(void (*special)(int key, int x, int y)) +{ + GGIGLUTDPRINT_CORE("glutSpecialFunc() called\n"); + + __glut_special=special; +} + +void glutDisplayFunc(void (*disp)(void)) +{ + GGIGLUTDPRINT_CORE("glutDisplayFunc() called\n"); + __glut_display=disp; +} + +void glutSetColor(int index, GLfloat red, GLfloat green, GLfloat blue) +{ + ggi_color c; + GLfloat max; + + GGIGLUTDPRINT_CORE("glutSetColor() called\n"); + + if (red > 1.0) red = 1.0; + if (red < 0.0) red = 0.0; + if (green > 1.0) green = 1.0; + if (green < 0.0) green = 0.0; + if (blue > 1.0) blue = 1.0; + if (blue < 0.0) blue = 0.0; + + max = (float)((1 << GGI_COLOR_PRECISION) - 1); + + c.r = (int)(max * red); + c.g = (int)(max * green); + c.b = (int)(max * blue); + ggiSetPalette(__glut_vis, index, 1, &c); +} + +void glutPostRedisplay(void) +{ + GGIGLUTDPRINT_CORE("glutPostRedisplay() called\n"); + + __glut_redisplay = GL_TRUE; +} + +void glutPostWindowRedisplay(int win) +{ + GGIGLUTDPRINT_CORE("glutPostWindowRedisplay() called\n"); + + __glut_redisplay = GL_TRUE; +} + +void glutSwapBuffers(void) +{ + GGIGLUTDPRINT_CORE("glutSwapBuffers() called\n"); + + ggiMesaSwapBuffers(); +} + +void glutIdleFunc(void (*idle)(void)) +{ + GGIGLUTDPRINT_CORE("glutIdleFunc() called\n"); + + __glut_idle = idle; +} + +static void keyboard(ggi_event *ev) +{ + int sym; + int modifer = 0, key = 0; + + GGIGLUTDPRINT_CORE("keyboard() called\n"); + + sym = ev->key.sym; + + modifer = ev->key.modifiers; + if (modifer == GII_KM_SHIFT) + __glut_mod_keys |= GLUT_ACTIVE_SHIFT; + if (modifer == GII_KM_CTRL) + __glut_mod_keys |= GLUT_ACTIVE_CTRL; + if (modifer == GII_KM_ALT) + __glut_mod_keys |= GLUT_ACTIVE_ALT; + + /* if (__glut_special && key) __glut_special(GII_KTYP(key),0,0); */ + + if (__glut_keyboard) +// __glut_keyboard(GII_UNICODE(sym), 0, 0); + __glut_keyboard(sym, 0, 0); +} + +static void mouseabs(ggi_event *ev) +{ + int oldx = mousex; + int oldy = mousey; + + mousex = ev->pmove.x; + mousey = ev->pmove.y; + + if (mousex < 0) mousex = 0; + if (mousey < 0) mousey = 0; + if (mousex >= __glut_width) mousex = __glut_width - 1; + if (mousey >= __glut_height) mousey = __glut_height - 1; + + if (mousex != oldx || mousey != oldy) mouse_moved = GL_TRUE; +} + +static void mouse(ggi_event *ev) +{ + int oldx = mousex; + int oldy = mousey; + + GGIGLUTDPRINT_CORE("mouse() called\n"); + + mousex += ev->pmove.x >> 1; + mousey += ev->pmove.y >> 1; + + if (mousex < 0) mousex = 0; + if (mousey < 0) mousey = 0; + if (mousex >= __glut_width) mousex = __glut_width - 1; + if (mousey >= __glut_height) mousey = __glut_height - 1; + + if (mousex != oldx || mousey != oldy) mouse_moved = GL_TRUE; + +} + +static void showmenu(void); +static int clickmenu(void); +static void updatemouse(void); +static void drawmouse(void); + +static void mousemove(void) +{ + GGIGLUTDPRINT_CORE("mousemove() called\n"); + + if (mouse_moved) { + if (__glut_motion && mouse_down) { + __glut_motion(mousex,mousey); + } + + if (__glut_passive_motion && (!mouse_down)) { + __glut_passive_motion(mousex,mousey); + } + + if (__glut_menuactive) updatemouse(); + mouse_moved=GL_FALSE; + } +} + +static void button(ggi_event *ev) +{ + int i; + int btn[4] = { + 0, + GLUT_LEFT_BUTTON, + GLUT_RIGHT_BUTTON, + GLUT_MIDDLE_BUTTON + }; + + GGIGLUTDPRINT_CORE("button() called\n"); + + mousemove(); + + if (ev->pbutton.button <= 3) { /* GGI can have >3 buttons ! */ + char state = ev->any.type == evPtrButtonPress ? GLUT_DOWN : GLUT_UP; + if (__glut_menuactive) { + if (state == GLUT_UP && clickmenu()) { + glutPostRedisplay(); + __glut_menuactive = GL_FALSE; + } + } else + if (btn[ev->pbutton.button] == __glut_menubutton) { + __glut_menuactive = GL_TRUE; + activemenu = mainmenu; + showmenu(); + } else + if (__glut_mouse) { + __glut_mouse(btn[ev->pbutton.button], state, mousex, mousey); + } + if (state == GLUT_DOWN) { + mouse_down |= (1 << (ev->pbutton.button - 1)); + } + else mouse_down &= ~( 1 << (ev->pbutton.button - 1)); + } +} + +void glutMainLoop(void) +{ + ggi_event ev; + ggi_event_mask evmask = (emKeyPress | emKeyRepeat | emPtrMove | emPtrButton); + + GGIGLUTDPRINT_CORE("glutMainLoop() called\n"); + + ggiSetEventMask(__glut_vis, evmask); + + glutPostRedisplay(); + + if (__glut_visibility) + __glut_visibility(GLUT_VISIBLE); + + while (1) + { + if (!__glut_menuactive) + { + if (__glut_idle) + __glut_idle(); + if (__glut_redisplay && __glut_display) + { + __glut_redisplay = GL_FALSE; + __glut_display(); + } + } + + while (1) + { + struct timeval t = {0, 0}; + + if (ggiEventPoll(__glut_vis, evmask, &t) == 0) + break; + + ggiEventRead(__glut_vis, &ev, evmask); + + switch (ev.any.type) + { + case evKeyPress: + case evKeyRepeat: + keyboard(&ev); + break; + case evPtrAbsolute: + mouseabs(&ev); + break; + case evPtrRelative: + mouse(&ev); + break; + case evPtrButtonPress: + case evPtrButtonRelease: + button(&ev); + break; + } + } + mousemove(); + } +} + +static void showmenu() +{ + int y,i; + ggi_color col = { 0xffff, 0xffff, 0xffff }; + + GGIGLUTDPRINT_CORE("showmenu() called\n"); + + ggiSetGCForeground(__glut_vis,ggiMapColor(__glut_vis,&col)); + ggiSetOrigin(__glut_vis,0,0); + + for (y = i = 0; i < activemenu->num_entries; i++, y += 8) { + ggiPuts(__glut_vis, 0, y, activemenu->label[i]); + } + drawmouse(); +} + +static int clickmenu(void) +{ + int i; + int w, h; + + GGIGLUTDPRINT_CORE("clickmenu() called\n"); + + i = mousey / 8; + + if (i >= activemenu->num_entries) return GL_TRUE; + if (mousex >= 8 * strlen(activemenu->label[i])) return GL_TRUE; + + if (activemenu->submenu[i]) { + ggi_color col={0,0,0}; + ggiSetGCForeground(__glut_vis,ggiMapColor(__glut_vis,&col)); + h=activemenu->num_entries*8; + w=activemenu->max_strlen*8; + ggiDrawBox(__glut_vis,0,0,w,h); + activemenu=activemenu->submenu[i]; + showmenu(); + return GL_FALSE; + } + curmenu=activemenu; + activemenu->func(activemenu->value[i]); + return GL_TRUE; +} + +static int oldx=-1; +static int oldy=-1; +static char buffer[16*16*4]; + +static void updatemouse() +{ + GGIGLUTDPRINT_CORE("updatemouse() called\n"); + + ggiPutBox(__glut_vis,oldx,oldy,16,16,buffer); + drawmouse(); +} + +static void drawmouse() +{ + int x,y; + + GGIGLUTDPRINT_CORE("drawmouse() called\n"); + + x=mousex-8; + if (x<0) x=0; + y=mousey-8; + if (y<0) y=0; + ggiGetBox(__glut_vis,x,y,16,16,buffer); + ggiDrawLine(__glut_vis,mousex-2,mousey,mousex+2,mousey); + ggiDrawLine(__glut_vis,mousex,mousey-2,mousex,mousey+2); + oldx=x; + oldy=y; +} + +int glutCreateMenu(void(*func)(int)) +{ + menu_t *m; + + GGIGLUTDPRINT_CORE("glutCreateMenu() called\n"); + + m=malloc(sizeof(menu_t)); + memset(m,0,sizeof(menu_t)); + curmenu=m; + curmenu->func=func; + return (int)curmenu; +} + +static void addEntry(const char *label,int value,menu_t *submenu) +{ + int i=curmenu->num_entries; + + GGIGLUTDPRINT_CORE("addEntry() called\n"); + + /* printf("%i %i %s %p\n",i,value,label,submenu); */ + if (ilabel[i]=strdup(label); + curmenu->value[i]=value; + curmenu->submenu[i]=submenu; + + if (strlen(label)>curmenu->max_strlen) + curmenu->max_strlen=strlen(label); + curmenu->num_entries++; + } +} + +void glutAddMenuEntry(const char *label,int value) +{ + GGIGLUTDPRINT_CORE("glutAddMenuEntry() called\n"); + + addEntry(label,value,NULL); +} + +void glutAddSubMenu(const char *label,int submenu) +{ + char text[100]; + + GGIGLUTDPRINT_CORE("glutAddSubMenu() called\n"); + + if (!curmenu) return; + strncpy(text,label,98); + text[98]=0; + text[strlen(text)+1]=0; + text[strlen(text)]='>'; + + addEntry(text,0,(menu_t *) submenu); +} + +void glutAttachMenu(int button) +{ + GGIGLUTDPRINT_CORE("glutAttachMenu() called\n"); + + mainmenu=curmenu; + __glut_menubutton=button; +} + +void glutDetachMenu(int button) +{ + GGIGLUTDPRINT_CORE("glutDetachMenu() called\n"); +} + +void glutVisibilityFunc(void (*func)(int state)) +{ + GGIGLUTDPRINT_CORE("glutVisibilityFunc() called\n"); + + __glut_visibility=func; +} + +void glutMouseFunc(void (*mouse)(int, int, int, int)) +{ + GGIGLUTDPRINT_CORE("glutMouseFunc() called\n"); + + __glut_mouse=mouse; +} + +void glutMotionFunc(void (*motion)(int,int)) +{ + GGIGLUTDPRINT_CORE("glutMotionFunc() called\n"); + + __glut_motion=motion; +} + +void glutPassiveMotionFunc(void (*motion)(int,int)) +{ + GGIGLUTDPRINT_CORE("glutPassiveMotionFunc() called\n"); + + __glut_passive_motion=motion; +} + +void glutSetWindowTitle(const char *title) +{ + GGIGLUTDPRINT_CORE("glutSetWindowTitle() called\n"); +} + +void glutSetIconTitle(const char *title) +{ + GGIGLUTDPRINT_CORE("glutSetIconTitle() called\n"); +} + +void glutChangeToMenuEntry(int item,const char *label,int value) +{ + GGIGLUTDPRINT_CORE("glutChangeToMenuEntry() called\n"); + + if (item>0 && item<=curmenu->num_entries) { + item--; + free(curmenu->label[item]); + curmenu->label[item]=strdup(label); + curmenu->value[item]=value; + curmenu->submenu[item]=NULL; + } +} +void glutChangeToSubMenu(int item,const char *label,int submenu) +{ + GGIGLUTDPRINT_CORE("glutChengeToSubMenu() called\n"); + + if (item>0 && item<=curmenu->num_entries) { + item--; + free(curmenu->label[item]); + curmenu->label[item]=strdup(label); + curmenu->value[item]=0; + curmenu->submenu[item]=(menu_t *)submenu; + } +} + +void glutDestroyMenu(int menu) +{ + menu_t *m=(menu_t *)menu; + int i; + + GGIGLUTDPRINT_CORE("glutDestroyMenu() called\n"); + + for (i=0;inum_entries;i++) { + free(m->label[i]); + } + free(m); +} + +int glutCreateSubWindow(int win,int x,int y,int w,int h) +{ + GGIGLUTDPRINT_CORE("glutCreateSubWindow() called\n"); + + return 0; +} + +void glutDestroyWindow(int win) +{ + GGIGLUTDPRINT_CORE("glutDestroyWindow() called\n"); +} + +int glutGetWindow(void) +{ + GGIGLUTDPRINT_CORE("glutGetWindow() called\n"); + + return 0; +} + +void glutSetWindow(int win) +{ + GGIGLUTDPRINT_CORE("glutSetWindow() called\n"); +} + +void glutPositionWindow(int x,int y) +{ + GGIGLUTDPRINT_CORE("glutPositionWindow() called\n"); +} + +void glutReshapeWindow(int x,int y) +{ + GGIGLUTDPRINT_CORE("glutReshapeWindow() called\n"); +} + +void glutPushWindow(void) +{ + GGIGLUTDPRINT_CORE("glutPushWindow() called\n"); +} + +void glutPopWindow(void) +{ + GGIGLUTDPRINT_CORE("glutPopWindow() called\n"); +} + +void glutIconifyWindow(void) +{ + GGIGLUTDPRINT_CORE("glutIconifyWindow() called\n"); +} + +void glutShowWindow() +{ + GGIGLUTDPRINT_CORE("glutShowWindow() called\n"); +} + +void glutHideWindow() +{ + GGIGLUTDPRINT_CORE("glutHideWindow() called\n"); +} + +void glutSetCursor(int cursor) +{ + GGIGLUTDPRINT_CORE("glutSetCursor() called\n"); +} + +void glutWarpPointer(int x,int y) +{ + GGIGLUTDPRINT_CORE("glutWarpPointer() called\n"); +} + +void glutEstablishOverlay(void) +{ + GGIGLUTDPRINT_CORE("glutEstablishOverlay() called\n"); +} + +void glutRemoveOverlay(void) +{ + GGIGLUTDPRINT_CORE("glutRemoveOverlay() called\n"); +} + +void glutUseLayer(GLenum layer) +{ + GGIGLUTDPRINT_CORE("glutUseLayer() called\n"); +} + +int glutLayerGet(GLenum type) +{ + GGIGLUTDPRINT_CORE("glutLayerGet() called\n"); + return 0; +} + +void glutPostOverlayRedisplay(void) +{ + GGIGLUTDPRINT_CORE("glutPostOverlayRedisplay() called\n"); +} + +void glutPostWindowOverlayRedisplay(int w) +{ + GGIGLUTDPRINT_CORE("glutPostWindowOverlayRedisplay() called\n"); +} + +void glutShowOverlay(void) +{ + GGIGLUTDPRINT_CORE("glutShowOverlay() called\n"); +} + +void glutHideOverlay(void) +{ + GGIGLUTDPRINT_CORE("glutHideOverlay() called\n"); +} + +int glutGetMenu(void) +{ + GGIGLUTDPRINT_CORE("glutGetMenu() called\n"); + return 0; +} + +void glutSetMenu(int menu) +{ + GGIGLUTDPRINT_CORE("glutSetMenu() called\n"); +} + +void glutRemoveMenuItem(int item) +{ + GGIGLUTDPRINT_CORE("glutRemoveMenuItem() called\n"); +} + +void glutSpaceBallMotionFunc(void (*func)(int key,int x,int y)) +{ + GGIGLUTDPRINT_CORE("glutSpaceBallMotionFunc() called\n"); +} + +void glutSpaceBallRotateFunc(void (*func)(int x,int y,int z)) +{ + GGIGLUTDPRINT_CORE("glutSpaceBallRotateFunc() called\n"); +} + +void glutSpaceBallButtonFunc(void (*func)(int button,int state)) +{ + GGIGLUTDPRINT_CORE("glutSpaceBallButtonFunc() called\n"); +} + +void glutCopyColormap(int win) +{ + GGIGLUTDPRINT_CORE("glutCopyColormap() called\n"); +} + +int glutDeviceGet(GLenum param) +{ + GGIGLUTDPRINT_CORE("glutDeviceGet() called\n"); + + return 0; +} diff --git a/src/glut/glx/Makefile b/src/glut/glx/Makefile new file mode 100644 index 000000000..3a85d3eb9 --- /dev/null +++ b/src/glut/glx/Makefile @@ -0,0 +1,113 @@ +# 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. + + +TOP = ../../.. + +include $(TOP)/configs/current + + +##### MACROS ##### + +GLUT_MAJOR = 3 +GLUT_MINOR = 7 +GLUT_TINY = 1 + +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 = $(SOURCES:.c=.o) + + +##### RULES ##### + +.c.o: + $(CC) -c -I$(TOP)/include $(CFLAGS) $(GLUT_CFLAGS) $< + + + +##### TARGETS ##### + +default: $(LIB_DIR)/$(GLUT_LIB_NAME) + + +# Make the library +$(LIB_DIR)/$(GLUT_LIB_NAME): depend $(OBJECTS) + $(TOP)/bin/mklib -o $(GLUT_LIB) -linker '$(CC)' \ + -major $(GLUT_MAJOR) -minor $(GLUT_MINOR) -patch $(GLUT_TINY) \ + $(MKLIB_OPTIONS) -install $(LIB_DIR) \ + $(GLUT_LIB_DEPS) $(OBJECTS) + + +clean: + -rm -f *.o *~ + -rm -f *.lo + -rm -f *.la + -rm -rf .libs + -rm -rf depend depend.bak + + +depend: $(SOURCES) + @ echo "running $(MKDEP)" + @ touch depend + @ $(MKDEP) $(MKDEP_OPTIONS) -I$(TOP)/include $(SOURCES) \ + > /dev/null + +include depend diff --git a/src/glut/glx/Makefile.cygnus b/src/glut/glx/Makefile.cygnus new file mode 100644 index 000000000..5d5fa6912 --- /dev/null +++ b/src/glut/glx/Makefile.cygnus @@ -0,0 +1,110 @@ +# Makefile.cygnus for Cygnus-Win32 target +# /Stephane Rehel, November 16 1997 + +# Makefile for GLUT 3.7 +# +# 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 = 7 +GLUT_TINY = 0 + +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) $(GLUT_TINY) $(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 000000000..9514c324d --- /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 000000000..4ce7f6fc7 --- /dev/null +++ b/src/glut/glx/Makefile.win @@ -0,0 +1,99 @@ +# Makefile for Win32 + +!include + +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 + +!include "$(TOP)/mesawin32.mak" + +glutdll : $(GLUTDLL) + +!IFDEF NODEBUG +OPTIMIZE_CFLAGS = -DNDEBUG +!ENDIF + +CFLAGS = $(cvarsdll) $(CFLAGS) $(OPTIMIZE_CFLAGS) -DMESA -DBUILD_GL32 +LFLAGS = $(dlllflags) $(lcommon) $(LFLAGS) + +OBJS = $(SRCS:.c=.obj) +MS_LIBS = ../lib/$(MESALIB) ../lib/$(GLULIB) winmm.lib $(guilibsdll) +SGI_LIBS = $(SGI_OPENGL) $(SGI_GLU) winmm.lib $(guilibsdll) + +MesaGlut.dll : $(OBJS) glut.def + $(link) $(LFLAGS) -out:MesaGlut.dll -def:glut.def $(OBJS) $(MS_LIBS) + @echo "copying GLUT dynamic link library to lib directory..." + -copy $(GLUTDLL) ..\lib + @echo "copying GLUT import library to lib directory..." + -copy $(GLUTLIB) ..\lib + +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 000000000..b99e79305 --- /dev/null +++ b/src/glut/glx/capturexfont.c @@ -0,0 +1,356 @@ + +/* 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 */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include +#include +#include +#include + +#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 000000000..5a536aa87 --- /dev/null +++ b/src/glut/glx/descrip.mms @@ -0,0 +1,208 @@ +# Makefile for GLUT for VMS +# contributed by Jouk Jansen joukj@hrem.stm.tudelft.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/name=(as_is,short) + +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 + +OBJECTS0=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 + +OBJECTS1=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 + +OBJECTS2=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 + +OBJECTS3=glut_warp.obj,\ +glut_win.obj,\ +glut_winmisc.obj,\ +layerutil.obj + +##### RULES ##### + +VERSION=Glut V3.7 + +##### TARGETS ##### + +# Make the library +$(LIBDIR)$(GLUT_LIB) : $(OBJECTS0) $(OBJECTS1) $(OBJECTS2) $(OBJECTS3) + @ $(MAKELIB) $(GLUT_LIB) $(OBJECTS0) + @ library $(GLUT_LIB) $(OBJECTS1) + @ library $(GLUT_LIB) $(OBJECTS2) + @ library $(GLUT_LIB) $(OBJECTS3) + @ rename $(GLUT_LIB)* $(LIBDIR) +.ifdef SHARE + @ WRITE_ SYS$OUTPUT " generating mesagl1.opt" + @ OPEN_/WRITE FILE mesagl1.opt + @ WRITE_ FILE "!" + @ WRITE_ FILE "! mesagl1.opt generated by DESCRIP.$(MMS_EXT)" + @ WRITE_ FILE "!" + @ WRITE_ FILE "IDENTIFICATION=""$(VERSION)""" + @ WRITE_ FILE "GSMATCH=LEQUAL,3,7 + @ WRITE_ FILE "$(OBJECTS0)" + @ WRITE_ FILE "$(OBJECTS1)" + @ WRITE_ FILE "$(OBJECTS2)" + @ WRITE_ FILE "$(OBJECTS3)" + @ WRITE_ FILE "[---.lib]libmesaglu.exe/SHARE" + @ WRITE_ FILE "[---.lib]libmesagl.exe/SHARE" + @ write file "sys$library:decw$xmulibshr.exe/share" + @ WRITE_ FILE "SYS$SHARE:DECW$XEXTLIBSHR/SHARE" + @ WRITE_ FILE "SYS$SHARE:DECW$XLIBSHR/SHARE" + @ CLOSE_ FILE + @ WRITE_ SYS$OUTPUT " generating mesagl.map ..." + @ CXXLINK_/NODEB/NOSHARE/NOEXE/MAP=mesagl.map/FULL mesagl1.opt/OPT + @ WRITE_ SYS$OUTPUT " analyzing mesagl.map ..." + @ @[---.vms]ANALYZE_MAP.COM mesagl.map mesagl.opt + @ WRITE_ SYS$OUTPUT " linking $(GLUT_SHAR) ..." + @ CXXLINK_/NODEB/SHARE=$(GLUT_SHAR)/MAP=mesagl.map/FULL mesagl1.opt/opt,mesagl.opt/opt + @ rename $(GLUT_SHAR)* $(LIBDIR) +.endif + +clean : + delete *.obj;* + purge + +include mms_depend. + +glut_8x13.obj : glut_8x13.c +glut_9x15.obj : glut_9x15.c +glut_bitmap.obj : glut_bitmap.c +glut_bwidth.obj : glut_bwidth.c +glut_cindex.obj : glut_cindex.c +glut_cmap.obj : glut_cmap.c +glut_cursor.obj : glut_cursor.c +glut_dials.obj : glut_dials.c +glut_dstr.obj : glut_dstr.c +glut_event.obj : glut_event.c +glut_ext.obj : glut_ext.c +glut_fullscrn.obj : glut_fullscrn.c +glut_gamemode.obj : glut_gamemode.c +glut_get.obj : glut_get.c +glut_glxext.obj : glut_glxext.c +glut_hel10.obj : glut_hel10.c +glut_hel12.obj : glut_hel12.c +glut_hel18.obj : glut_hel18.c +glut_init.obj : glut_init.c +glut_input.obj : glut_input.c +glut_joy.obj : glut_joy.c +glut_key.obj : glut_key.c +glut_keyctrl.obj : glut_keyctrl.c +glut_keyup.obj : glut_keyup.c +glut_menu.obj : glut_menu.c +glut_menu2.obj : glut_menu2.c +glut_mesa.obj : glut_mesa.c +glut_modifier.obj : glut_modifier.c +glut_mroman.obj : glut_mroman.c +glut_overlay.obj : glut_overlay.c +glut_roman.obj : glut_roman.c +glut_shapes.obj : glut_shapes.c +glut_space.obj : glut_space.c +glut_stroke.obj : glut_stroke.c +glut_swap.obj : glut_swap.c +glut_swidth.obj : glut_swidth.c +glut_tablet.obj : glut_tablet.c +glut_teapot.obj : glut_teapot.c +glut_tr10.obj : glut_tr10.c +glut_tr24.obj : glut_tr24.c +glut_util.obj : glut_util.c +glut_vidresize.obj : glut_vidresize.c +glut_warp.obj : glut_warp.c +glut_win.obj : glut_win.c +glut_winmisc.obj : glut_winmisc.c +layerutil.obj : layerutil.c diff --git a/src/glut/glx/fxglut.def b/src/glut/glx/fxglut.def new file mode 100644 index 000000000..ff6ffb1d3 --- /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.def b/src/glut/glx/glut.def new file mode 100644 index 000000000..d5e0e0cf2 --- /dev/null +++ b/src/glut/glx/glut.def @@ -0,0 +1,131 @@ +DESCRIPTION 'OpenGL Utility Toolkit for Win32' + +VERSION 3.7 + +EXPORTS + + glutAddMenuEntry + glutAddSubMenu + glutAttachMenu + glutBitmapCharacter + glutBitmapLength + glutBitmapWidth + glutButtonBoxFunc + glutChangeToMenuEntry + glutChangeToSubMenu + glutCopyColormap + glutCreateMenu + __glutCreateMenuWithExit + glutCreateSubWindow + glutCreateWindow + __glutCreateWindowWithExit + glutDestroyMenu + glutDestroyWindow + glutDetachMenu + glutDeviceGet + glutDialsFunc + glutDisplayFunc + glutEnterGameMode + glutEntryFunc + glutEstablishOverlay + glutExtensionSupported + glutForceJoystickFunc + glutFullScreen + glutGameModeGet + glutGameModeString + glutGet + glutGetColor + glutGetMenu + glutGetModifiers + glutGetWindow + glutHideOverlay + glutHideWindow + glutIconifyWindow + glutIdleFunc + glutIgnoreKeyRepeat + glutInit + __glutInitWithExit + glutInitDisplayMode + glutInitDisplayString + glutInitWindowPosition + glutInitWindowSize + glutJoystickFunc + glutKeyboardFunc + glutKeyboardUpFunc + glutLayerGet + glutLeaveGameMode + glutMainLoop + glutMenuStateFunc + glutMenuStatusFunc + glutMotionFunc + glutMouseFunc + glutOverlayDisplayFunc + glutPassiveMotionFunc + glutPopWindow + glutPositionWindow + glutPostOverlayRedisplay + glutPostRedisplay + glutPostWindowOverlayRedisplay + glutPostWindowRedisplay + glutPushWindow + glutRemoveMenuItem + glutRemoveOverlay + glutReportErrors + glutReshapeFunc + glutReshapeWindow + glutSetColor + glutSetCursor + glutSetIconTitle + glutSetKeyRepeat + glutSetMenu + glutSetWindow + glutSetWindowTitle + glutSetupVideoResizing + glutShowOverlay + glutShowWindow + glutSolidCone + glutSolidCube + glutSolidDodecahedron + glutSolidIcosahedron + glutSolidOctahedron + glutSolidSphere + glutSolidTeapot + glutSolidTetrahedron + glutSolidTorus + glutSpaceballButtonFunc + glutSpaceballMotionFunc + glutSpaceballRotateFunc + glutSpecialFunc + glutSpecialUpFunc + glutStopVideoResizing + glutStrokeCharacter + glutStrokeLength + glutStrokeWidth + glutSwapBuffers + glutTabletButtonFunc + glutTabletMotionFunc + glutTimerFunc + glutUseLayer + glutVideoPan + glutVideoResize + glutVideoResizeGet + glutVisibilityFunc + glutWarpPointer + glutWindowStatusFunc + glutWireCone + glutWireCube + glutWireDodecahedron + glutWireIcosahedron + glutWireOctahedron + glutWireSphere + glutWireTeapot + glutWireTetrahedron + glutWireTorus + glutStrokeRoman + glutBitmap9By15 + glutBitmapHelvetica10 + glutBitmapHelvetica18 + glutBitmapTimesRoman24 +; __glutSetFCB +; __glutGetFCB + diff --git a/src/glut/glx/glut_8x13.c b/src/glut/glx/glut_8x13.c new file mode 100644 index 000000000..843c63d35 --- /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 000000000..2d5c004e4 --- /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 000000000..8fec7f117 --- /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 GLUTAPIENTRY +glutBitmapCharacter(GLUTbitmapFont font, int c) +{ + const BitmapCharRec *ch; + BitmapFontPtr fontinfo; + GLint swapbytes, lsbfirst, rowlength; + GLint skiprows, skippixels, alignment; + +#if defined(_WIN32) || defined(GLUT_IMPORT_LIB) + 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 000000000..f9cdb184d --- /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 GLUTAPIENTRY +glutBitmapWidth(GLUTbitmapFont font, int c) +{ + BitmapFontPtr fontinfo; + const BitmapCharRec *ch; + +#if defined(_WIN32) || defined(GLUT_IMPORT_LIB) + 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 GLUTAPIENTRY +glutBitmapLength(GLUTbitmapFont font, const unsigned char *string) +{ + int c, length; + BitmapFontPtr fontinfo; + const BitmapCharRec *ch; + +#if defined(_WIN32) || defined(GLUT_IMPORT_LIB) + 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 000000000..d0c12bf3a --- /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 +#include "glutint.h" + +#define CLAMP(i) ((i) > 1.0 ? 1.0 : ((i) < 0.0 ? 0.0 : (i))) + +/* CENTRY */ +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 000000000..1c496ad66 --- /dev/null +++ b/src/glut/glx/glut_cmap.c @@ -0,0 +1,399 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include /* SunOS multithreaded assert() needs . Lame. */ +#include +#if !defined(_WIN32) +#include +#include +#include /* for XA_RGB_DEFAULT_MAP atom */ +#if defined(__vms) +#include /* for XmuLookupStandardColormap */ +#else +#include /* 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 +#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 000000000..797cb49fb --- /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 /* For XA_CURSOR */ +#include +#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 char *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, &value); + if (rc == Success && actualFormat == 32 && n >= 1) { + cursor = ((unsigned long *)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 = 0; + + 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 = (HICON) IDC_CROSS; +#else + if (fullCrosshairCusor == None) { + fullCrosshairCusor = getFullCrosshairCursor(); + } + xcursor = fullCrosshairCusor; +#endif + break; + } + } + XDefineCursor(__glutDisplay, + window->win, xcursor); + XFlush(__glutDisplay); +} + +/* CENTRY */ +void GLUTAPIENTRY +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 000000000..e015b91bc --- /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 GLUTAPIENTRY +glutButtonBoxFunc(GLUTbuttonBoxCB buttonBoxFunc) +{ + __glutCurrentWindow->buttonBox = buttonBoxFunc; + __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask; + __glutPutOnWorkList(__glutCurrentWindow, + GLUT_DEVICE_MASK_WORK); +} + +void GLUTAPIENTRY +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 000000000..981e88ffa --- /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 +#include +#include +#include +#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 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 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 = __glut_glXGetFBConfigFromVisualSGIX(__glutDisplay, vlist[i]); + if (fbc) { + rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay, fbc, + GLX_FBCONFIG_ID_SGIX, &fbconfigID); + if ((rc == 0) && (fbconfigID != None)) { + rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay, fbc, + GLX_DRAWABLE_TYPE_SGIX, &drawType); + if ((rc == 0) && (drawType & GLX_WINDOW_BIT_SGIX)) { + rc = __glut_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 = __glut_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 despite claiming to support + GLX_EXT_visual_rating. */ +#ifndef GLX_VISUAL_CAVEAT_EXT +#define GLX_VISUAL_CAVEAT_EXT 0x20 +#endif + + rc = __glut_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 despite claiming to + support GLX_EXT_visual_info. */ +#ifndef GLX_TRANSPARENT_TYPE_EXT +#define GLX_TRANSPARENT_TYPE_EXT 0x23 +#endif + + rc = __glut_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 = __glut_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 = 0, 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 = 0; + int rgb, rgba, acc, acca, count, i; + + cstr = strpbrk(word, "=>': + 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 GLUTAPIENTRY +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 = fgets(buffer, 1023, stdin); + 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 000000000..e453fe038 --- /dev/null +++ b/src/glut/glx/glut_event.c @@ -0,0 +1,1377 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include +#include /* 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 . */ + +#if !defined(_WIN32) +# ifdef __sgi +# include /* prototype for bzero used by FD_ZERO */ +# endif +# if (defined(SVR4) || defined(CRAY) || defined(AIXV3)) && !defined(FD_SETSIZE) +# include /* select system call interface */ +# ifdef luna +# include +# endif +# endif + /* AIX 4.2 fubar-ed , so go to heroic measures to get it */ +# if defined(AIXV4) && !defined(NFDBITS) +# include +# endif +#endif /* !_WIN32 */ + +#include + +#if !defined(_WIN32) +# if defined(__vms) && ( __VMS_VER < 70000000 ) +# include +# else +# ifndef __vms +# include +# endif +# endif +# include +# include +# include +#else +# ifdef __CYGWIN32__ +# include +# else +# include +# endif +# ifdef __hpux + /* XXX Bert Gijsbers 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 +# endif +#endif /* !_WIN32 */ + +#include "glutint.h" + +#if defined(__vms) && ( __VMS_VER < 70000000 ) +#include +#include +extern int SYS$CLREF(int efn); +extern int SYS$SETIMR(unsigned int efn, struct timeval6 *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 */ + +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 GLUTAPIENTRY +glutIdleFunc(GLUTidleCB idleFunc) +{ + __glutIdleFunc = idleFunc; +} + +void GLUTAPIENTRY +glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value) +{ + GLUTtimer *timer, *other; + GLUTtimer **prevptr; +#ifdef OLD_VMS + struct timeval6 now; +#else + struct timeval now; +#endif + + 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) +{ +#ifdef OLD_VMS + struct timeval6 now; +#else + struct timeval now; +#endif + 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; + __glutTimerList = timer->next; + timer->func(timer->value); + 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 GLUTAPIENTRY +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 GLUTAPIENTRY +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; + } +#ifndef VMS + /* the combination ConectionNumber-select is buggy on VMS. Sometimes it + * fails. This part of the code hangs the program on VMS7.2. But even + * without it the program seems to run correctly. + * Note that this is a bug in the VMS/DECWindows run-time-libraries. + * Compaq engeneering does not want or is not able to make a fix. + * (last sentence is a quotation from Compaq when I reported the + * problem January 2000) */ + 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 + } +} + +#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 timeval6 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 +#ifdef OLD_VMS + struct timeval6 now, timeout, waittime; +#else + struct timeval now, timeout, waittime; +#endif +#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 GLUTAPIENTRY +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 000000000..922a94b20 --- /dev/null +++ b/src/glut/glx/glut_ext.c @@ -0,0 +1,201 @@ + +/* 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 +#include + +#include "glutint.h" + +/* CENTRY */ +int GLUTAPIENTRY +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; +} + + +struct name_address_pair { + const char *name; + const GLUTproc address; +}; + +static struct name_address_pair glut_functions[] = { + { "glutInit", (const GLUTproc) glutInit }, + { "glutInitDisplayMode", (const GLUTproc) glutInitDisplayMode }, + { "glutInitDisplayString", (const GLUTproc) glutInitDisplayString }, + { "glutInitWindowPosition", (const GLUTproc) glutInitWindowPosition }, + { "glutInitWindowSize", (const GLUTproc) glutInitWindowSize }, + { "glutMainLoop", (const GLUTproc) glutMainLoop }, + { "glutCreateWindow", (const GLUTproc) glutCreateWindow }, + { "glutCreateSubWindow", (const GLUTproc) glutCreateSubWindow }, + { "glutDestroyWindow", (const GLUTproc) glutDestroyWindow }, + { "glutPostRedisplay", (const GLUTproc) glutPostRedisplay }, + { "glutPostWindowRedisplay", (const GLUTproc) glutPostWindowRedisplay }, + { "glutSwapBuffers", (const GLUTproc) glutSwapBuffers }, + { "glutGetWindow", (const GLUTproc) glutGetWindow }, + { "glutSetWindow", (const GLUTproc) glutSetWindow }, + { "glutSetWindowTitle", (const GLUTproc) glutSetWindowTitle }, + { "glutSetIconTitle", (const GLUTproc) glutSetIconTitle }, + { "glutPositionWindow", (const GLUTproc) glutPositionWindow }, + { "glutReshapeWindow", (const GLUTproc) glutReshapeWindow }, + { "glutPopWindow", (const GLUTproc) glutPopWindow }, + { "glutPushWindow", (const GLUTproc) glutPushWindow }, + { "glutIconifyWindow", (const GLUTproc) glutIconifyWindow }, + { "glutShowWindow", (const GLUTproc) glutShowWindow }, + { "glutHideWindow", (const GLUTproc) glutHideWindow }, + { "glutFullScreen", (const GLUTproc) glutFullScreen }, + { "glutSetCursor", (const GLUTproc) glutSetCursor }, + { "glutWarpPointer", (const GLUTproc) glutWarpPointer }, + { "glutEstablishOverlay", (const GLUTproc) glutEstablishOverlay }, + { "glutRemoveOverlay", (const GLUTproc) glutRemoveOverlay }, + { "glutUseLayer", (const GLUTproc) glutUseLayer }, + { "glutPostOverlayRedisplay", (const GLUTproc) glutPostOverlayRedisplay }, + { "glutPostWindowOverlayRedisplay", (const GLUTproc) glutPostWindowOverlayRedisplay }, + { "glutShowOverlay", (const GLUTproc) glutShowOverlay }, + { "glutHideOverlay", (const GLUTproc) glutHideOverlay }, + { "glutCreateMenu", (const GLUTproc) glutCreateMenu }, + { "glutDestroyMenu", (const GLUTproc) glutDestroyMenu }, + { "glutGetMenu", (const GLUTproc) glutGetMenu }, + { "glutSetMenu", (const GLUTproc) glutSetMenu }, + { "glutAddMenuEntry", (const GLUTproc) glutAddMenuEntry }, + { "glutAddSubMenu", (const GLUTproc) glutAddSubMenu }, + { "glutChangeToMenuEntry", (const GLUTproc) glutChangeToMenuEntry }, + { "glutChangeToSubMenu", (const GLUTproc) glutChangeToSubMenu }, + { "glutRemoveMenuItem", (const GLUTproc) glutRemoveMenuItem }, + { "glutAttachMenu", (const GLUTproc) glutAttachMenu }, + { "glutDetachMenu", (const GLUTproc) glutDetachMenu }, + { "glutDisplayFunc", (const GLUTproc) glutDisplayFunc }, + { "glutReshapeFunc", (const GLUTproc) glutReshapeFunc }, + { "glutKeyboardFunc", (const GLUTproc) glutKeyboardFunc }, + { "glutMouseFunc", (const GLUTproc) glutMouseFunc }, + { "glutMotionFunc", (const GLUTproc) glutMotionFunc }, + { "glutPassiveMotionFunc", (const GLUTproc) glutPassiveMotionFunc }, + { "glutEntryFunc", (const GLUTproc) glutEntryFunc }, + { "glutVisibilityFunc", (const GLUTproc) glutVisibilityFunc }, + { "glutIdleFunc", (const GLUTproc) glutIdleFunc }, + { "glutTimerFunc", (const GLUTproc) glutTimerFunc }, + { "glutMenuStateFunc", (const GLUTproc) glutMenuStateFunc }, + { "glutSpecialFunc", (const GLUTproc) glutSpecialFunc }, + { "glutSpaceballMotionFunc", (const GLUTproc) glutSpaceballMotionFunc }, + { "glutSpaceballRotateFunc", (const GLUTproc) glutSpaceballRotateFunc }, + { "glutSpaceballButtonFunc", (const GLUTproc) glutSpaceballButtonFunc }, + { "glutButtonBoxFunc", (const GLUTproc) glutButtonBoxFunc }, + { "glutDialsFunc", (const GLUTproc) glutDialsFunc }, + { "glutTabletMotionFunc", (const GLUTproc) glutTabletMotionFunc }, + { "glutTabletButtonFunc", (const GLUTproc) glutTabletButtonFunc }, + { "glutMenuStatusFunc", (const GLUTproc) glutMenuStatusFunc }, + { "glutOverlayDisplayFunc", (const GLUTproc) glutOverlayDisplayFunc }, + { "glutWindowStatusFunc", (const GLUTproc) glutWindowStatusFunc }, + { "glutKeyboardUpFunc", (const GLUTproc) glutKeyboardUpFunc }, + { "glutSpecialUpFunc", (const GLUTproc) glutSpecialUpFunc }, + { "glutJoystickFunc", (const GLUTproc) glutJoystickFunc }, + { "glutSetColor", (const GLUTproc) glutSetColor }, + { "glutGetColor", (const GLUTproc) glutGetColor }, + { "glutCopyColormap", (const GLUTproc) glutCopyColormap }, + { "glutGet", (const GLUTproc) glutGet }, + { "glutDeviceGet", (const GLUTproc) glutDeviceGet }, + { "glutExtensionSupported", (const GLUTproc) glutExtensionSupported }, + { "glutGetModifiers", (const GLUTproc) glutGetModifiers }, + { "glutLayerGet", (const GLUTproc) glutLayerGet }, + { "glutGetProcAddress", (const GLUTproc) glutGetProcAddress }, + { "glutBitmapCharacter", (const GLUTproc) glutBitmapCharacter }, + { "glutBitmapWidth", (const GLUTproc) glutBitmapWidth }, + { "glutStrokeCharacter", (const GLUTproc) glutStrokeCharacter }, + { "glutStrokeWidth", (const GLUTproc) glutStrokeWidth }, + { "glutBitmapLength", (const GLUTproc) glutBitmapLength }, + { "glutStrokeLength", (const GLUTproc) glutStrokeLength }, + { "glutWireSphere", (const GLUTproc) glutWireSphere }, + { "glutSolidSphere", (const GLUTproc) glutSolidSphere }, + { "glutWireCone", (const GLUTproc) glutWireCone }, + { "glutSolidCone", (const GLUTproc) glutSolidCone }, + { "glutWireCube", (const GLUTproc) glutWireCube }, + { "glutSolidCube", (const GLUTproc) glutSolidCube }, + { "glutWireTorus", (const GLUTproc) glutWireTorus }, + { "glutSolidTorus", (const GLUTproc) glutSolidTorus }, + { "glutWireDodecahedron", (const GLUTproc) glutWireDodecahedron }, + { "glutSolidDodecahedron", (const GLUTproc) glutSolidDodecahedron }, + { "glutWireTeapot", (const GLUTproc) glutWireTeapot }, + { "glutSolidTeapot", (const GLUTproc) glutSolidTeapot }, + { "glutWireOctahedron", (const GLUTproc) glutWireOctahedron }, + { "glutSolidOctahedron", (const GLUTproc) glutSolidOctahedron }, + { "glutWireTetrahedron", (const GLUTproc) glutWireTetrahedron }, + { "glutSolidTetrahedron", (const GLUTproc) glutSolidTetrahedron }, + { "glutWireIcosahedron", (const GLUTproc) glutWireIcosahedron }, + { "glutSolidIcosahedron", (const GLUTproc) glutSolidIcosahedron }, + { "glutVideoResizeGet", (const GLUTproc) glutVideoResizeGet }, + { "glutSetupVideoResizing", (const GLUTproc) glutSetupVideoResizing }, + { "glutStopVideoResizing", (const GLUTproc) glutStopVideoResizing }, + { "glutVideoResize", (const GLUTproc) glutVideoResize }, + { "glutVideoPan", (const GLUTproc) glutVideoPan }, + { "glutReportErrors", (const GLUTproc) glutReportErrors }, + { "glutIgnoreKeyRepeat", (const GLUTproc) glutIgnoreKeyRepeat }, + { "glutSetKeyRepeat", (const GLUTproc) glutSetKeyRepeat }, + { "glutForceJoystickFunc", (const GLUTproc) glutForceJoystickFunc }, + { "glutGameModeString", (const GLUTproc) glutGameModeString }, + { "glutEnterGameMode", (const GLUTproc) glutEnterGameMode }, + { "glutLeaveGameMode", (const GLUTproc) glutLeaveGameMode }, + { "glutGameModeGet", (const GLUTproc) glutGameModeGet }, + { NULL, NULL } +}; + + +/* XXX This isn't an official GLUT function, yet */ +GLUTproc GLUTAPIENTRY +glutGetProcAddress(const char *procName) +{ + /* Try GLUT functions first */ + int i; + for (i = 0; glut_functions[i].name; i++) { + if (strcmp(glut_functions[i].name, procName) == 0) + return glut_functions[i].address; + } + + /* Try core GL functions */ +#if defined(_WIN32) + return (GLUTproc) wglGetProcAddress((LPCSTR) procName); +#elif defined(GLX_ARB_get_proc_address) + return (GLUTproc) glXGetProcAddressARB((const GLubyte *) procName); +#else + return NULL; +#endif +} + + +/* ENDCENTRY */ diff --git a/src/glut/glx/glut_fbc.c b/src/glut/glx/glut_fbc.c new file mode 100644 index 000000000..deb46c3d8 --- /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 GLUTAPIENTRY +__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* GLUTAPIENTRY +__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 000000000..aab3b4876 --- /dev/null +++ b/src/glut/glx/glut_fullscrn.c @@ -0,0 +1,56 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include /* SunOS multithreaded assert() needs . Lame. */ +#include + +#if !defined(_WIN32) +#include +#include +#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 +#else +#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how) +#endif + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +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 000000000..3ffeafee5 --- /dev/null +++ b/src/glut/glx/glut_gamemode.c @@ -0,0 +1,678 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include + +#include "glutint.h" + +#ifndef _WIN32 +#include +#include + +/* 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 +#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 +__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 GLUTAPIENTRY +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 = 0, 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 = 0; + + cstr = strpbrk(word, "=>': + 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 GLUTAPIENTRY +glutGameModeString(const char *string) +{ + Criterion *criteria; + int ncriteria; + + initGameModeSupport(); + criteria = parseDisplayString(string, &ncriteria); + currentDm = findMatch(dmodes, ndmodes, criteria, ncriteria); + free(criteria); +} + +int GLUTAPIENTRY +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(¤tDm->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 GLUTAPIENTRY +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 000000000..9c1ca6caa --- /dev/null +++ b/src/glut/glx/glut_get.c @@ -0,0 +1,220 @@ + +/* 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 +#include /* SunOS 4 needs NULL defined for GETTIMEOFDAY macro. */ +#include "glutint.h" + +/* CENTRY */ +int GLUTAPIENTRY +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: + { +#ifdef OLD_VMS + struct timeval6 elapsed, beginning, now; +#else + struct timeval elapsed, beginning, now; +#endif + + __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 000000000..71b67e075 --- /dev/null +++ b/src/glut/glx/glut_glxext.c @@ -0,0 +1,255 @@ + +/* 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 +#include +#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 + + + +/* + * Wrapping of GLX extension functions. + * Technically, we should do a runtime test to see if we've got the + * glXGetProcAddressARB() function. I think GLX_ARB_get_proc_address + * is pretty widely supported now and any system that has + * GLX_ARB_get_proc_address defined in its header files should be OK + * at runtime. + */ + +int +__glut_glXBindChannelToWindowSGIX(Display *dpy, int screen, + int channel, Window window) +{ +#ifdef GLX_ARB_get_proc_address + typedef int (*glXBindChannelToWindowSGIX_t) (Display *, int, int, Window); + static glXBindChannelToWindowSGIX_t glXBindChannelToWindowSGIX_ptr = NULL; + if (!glXBindChannelToWindowSGIX_ptr) { + glXBindChannelToWindowSGIX_ptr = (glXBindChannelToWindowSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXBindChannelToWindowSGIX"); + } + if (glXBindChannelToWindowSGIX_ptr) + return (*glXBindChannelToWindowSGIX_ptr)(dpy, screen, channel, window); + else + return 0; +#elif defined(GLX_SGIX_video_resize) + return glXBindChannelToWindowSGIX(dpy, screen, channel, window); +#else + return 0; +#endif +} + + +int +__glut_glXChannelRectSGIX(Display *dpy, int screen, int channel, + int x, int y, int w, int h) +{ +#ifdef GLX_ARB_get_proc_address + typedef int (*glXChannelRectSGIX_t)(Display *, int, int, int, int, int, int); + static glXChannelRectSGIX_t glXChannelRectSGIX_ptr = NULL; + if (!glXChannelRectSGIX_ptr) { + glXChannelRectSGIX_ptr = (glXChannelRectSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXChannelRectSGIX"); + } + if (glXChannelRectSGIX_ptr) + return (*glXChannelRectSGIX_ptr)(dpy, screen, channel, x, y, w, h); + else + return 0; +#elif defined(GLX_SGIX_video_resize) + return glXChannelRectSGIX(dpy, screen, channel, x, y, w, h); +#else + return 0; +#endif +} + + +int +__glut_glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, + int *x, int *y, int *w, int *h) +{ +#ifdef GLX_ARB_get_proc_address + typedef int (*glXQueryChannelRectSGIX_t)(Display *, int, int, + int *, int *, int *, int *); + static glXQueryChannelRectSGIX_t glXQueryChannelRectSGIX_ptr = NULL; + if (!glXQueryChannelRectSGIX_ptr) { + glXQueryChannelRectSGIX_ptr = (glXQueryChannelRectSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXQueryChannelRectSGIX"); + } + if (glXQueryChannelRectSGIX_ptr) + return (*glXQueryChannelRectSGIX_ptr)(dpy, screen, channel, x, y, w, h); + else + return 0; +#elif defined(GLX_SGIX_video_resize) + return glXQueryChannelRectSGIX(dpy, screen, channel, x, y, w, h); +#else + return 0; +#endif +} + + +int +__glut_glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, + int *dx, int *dy, int *dw, int *dh) +{ +#ifdef GLX_ARB_get_proc_address + typedef int (*glXQueryChannelDeltasSGIX_t)(Display *, int, int, + int *, int *, int *, int *); + static glXQueryChannelDeltasSGIX_t glXQueryChannelDeltasSGIX_ptr = NULL; + if (!glXQueryChannelDeltasSGIX_ptr) { + glXQueryChannelDeltasSGIX_ptr = (glXQueryChannelDeltasSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXQueryChannelDeltasSGIX"); + } + if (glXQueryChannelDeltasSGIX_ptr) + return (*glXQueryChannelDeltasSGIX_ptr)(dpy, screen, channel, + dx, dy, dw, dh); + else + return 0; +#elif defined(GLX_SGIX_video_resize) + return glXQueryChannelDeltasSGIX(dpy, screen, channel, dx, dy, dw, dh); +#else + return 0; +#endif +} + + +int +__glut_glXChannelRectSyncSGIX(Display *dpy, int screen, + int channel, GLenum synctype) +{ +#ifdef GLX_ARB_get_proc_address + typedef int (*glXChannelRectSyncSGIX_t)(Display *, int, int, GLenum); + static glXChannelRectSyncSGIX_t glXChannelRectSyncSGIX_ptr = NULL; + if (!glXChannelRectSyncSGIX_ptr) { + glXChannelRectSyncSGIX_ptr = (glXChannelRectSyncSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXChannelRectSyncSGIX"); + } + if (glXChannelRectSyncSGIX_ptr) + return (*glXChannelRectSyncSGIX_ptr)(dpy, screen, channel, synctype); + else + return 0; +#elif defined(GLX_SGIX_video_resize) + return glXChannelRectSyncSGIX(dpy, screen, channel, synctype); +#else + return 0; +#endif +} + + + +GLXContext +__glut_glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, + int render_type, GLXContext share_list, + Bool direct) +{ +#ifdef GLX_ARB_get_proc_address + typedef GLXContext (*glXCreateContextWithConfigSGIX_t)(Display *, + GLXFBConfigSGIX, int, GLXContext, Bool); + static glXCreateContextWithConfigSGIX_t glXCreateContextWithConfig_ptr = NULL; + if (!glXCreateContextWithConfig_ptr) { + glXCreateContextWithConfig_ptr = (glXCreateContextWithConfigSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXCreateContextWithConfigSGIX"); + } + if (glXCreateContextWithConfig_ptr) + return (*glXCreateContextWithConfig_ptr)(dpy, config, render_type, + share_list, direct); + else + return 0; +#elif defined(GLX_SGIX_fbconfig) + return glXCreateContextWithConfigSGIX(dpy, config, render_type, + share_list, direct); +#else + return 0; +#endif +} + + +int +__glut_glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, + int attribute, int *value) +{ +#ifdef GLX_ARB_get_proc_address + typedef int (*glXGetFBConfigAttribSGIX_t)(Display *, + GLXFBConfigSGIX, int, int *); + static glXGetFBConfigAttribSGIX_t glXGetFBConfigAttrib_ptr = NULL; + if (!glXGetFBConfigAttrib_ptr) { + glXGetFBConfigAttrib_ptr = (glXGetFBConfigAttribSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttribSGIX"); + } + if (glXGetFBConfigAttrib_ptr) + return (*glXGetFBConfigAttrib_ptr)(dpy, config, attribute, value); + else + return 0; +#elif defined(GLX_SGIX_fbconfig) + return glXGetFBConfigAttribSGIX(dpy, config, attribute, value); +#else + return 0; +#endif +} + + +GLXFBConfigSGIX +__glut_glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis) +{ +#ifdef GLX_ARB_get_proc_address + typedef GLXFBConfigSGIX (*glXGetFBConfigFromVisualSGIX_t)(Display *, + XVisualInfo *); + static glXGetFBConfigFromVisualSGIX_t glXGetFBConfigFromVisual_ptr = NULL; + if (!glXGetFBConfigFromVisual_ptr) { + glXGetFBConfigFromVisual_ptr = (glXGetFBConfigFromVisualSGIX_t) + glXGetProcAddressARB((const GLubyte *) "glXGetFBConfigFromVisualSGIX"); + } + if (glXGetFBConfigFromVisual_ptr) + return (*glXGetFBConfigFromVisual_ptr)(dpy, vis); + else + return 0; +#elif defined(GLX_SGIX_fbconfig) + return glXGetFBConfigFromVisualSGIX(dpy, vis); +#else + return 0; +#endif +} + + + + diff --git a/src/glut/glx/glut_hel10.c b/src/glut/glx/glut_hel10.c new file mode 100644 index 000000000..703cef38f --- /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 000000000..68aed8a2b --- /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 000000000..f0800843e --- /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 000000000..b1a42a328 --- /dev/null +++ b/src/glut/glx/glut_init.c @@ -0,0 +1,390 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include + +#if !defined(_WIN32) +#include +#include +#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 +#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 /* 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 +#ifdef OLD_VMS + __glutInitTime(struct timeval6 *beginning) +#else + __glutInitTime(struct timeval *beginning) +#endif +{ + static int beenhere = 0; +#ifdef OLD_VMS + static struct timeval6 genesis; +#else + static struct timeval genesis; +#endif + + 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 GLUTAPIENTRY +glutInit(int *argcp, char **argv) +{ + char *display = NULL; + char *str, *geometry = NULL; +#ifdef OLD_VMS + struct timeval6 unused; +#else + struct timeval unused; +#endif + 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); + + /* check if GLUT_FPS env var is set */ + { + const char *fps = getenv("GLUT_FPS"); + if (fps) { + sscanf(fps, "%d", &__glutFPS); + if (__glutFPS <= 0) + __glutFPS = 5000; /* 5000 milliseconds */ + } + } +} + +#ifdef _WIN32 +void GLUTAPIENTRY +__glutInitWithExit(int *argcp, char **argv, void (__cdecl *exitfunc)(int)) +{ + __glutExitFunc = exitfunc; + glutInit(argcp, argv); +} +#endif + +/* CENTRY */ +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 000000000..add3df7c3 --- /dev/null +++ b/src/glut/glx/glut_input.c @@ -0,0 +1,639 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include + +#if !defined(_WIN32) +#include +#if defined(__vms) +#include +#else +#include +#endif +#include +#else +#include +#ifndef __CYGWIN32__ +#include /* Win32 Multimedia API header. */ +#endif +#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 */ + +static 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; + JOYCAPS joyCaps; + + memset(&info, 0, sizeof(JOYINFOEX)); + info.dwSize = sizeof(JOYINFOEX); + info.dwFlags = JOY_RETURNALL; + + if (joyGetPosEx(JOYSTICKID1,&info) != JOYERR_NOERROR) { + __glutHasJoystick = 1; + joyGetDevCaps(JOYSTICKID1, &joyCaps, sizeof(joyCaps)); + __glutNumJoystickButtons = joyCaps.wNumButtons; + __glutNumJoystickAxes = joyCaps.wNumAxes; + } else { + __glutHasJoystick = 0; + __glutNumJoystickButtons = 0; + __glutNumJoystickAxes = 0; + } + } +#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 = 0, btns = 0, dials = 0; + 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 GLUTAPIENTRY +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 000000000..a4528ae1c --- /dev/null +++ b/src/glut/glx/glut_joy.c @@ -0,0 +1,82 @@ + +/* 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 +#ifndef __CYGWIN32__ +#include /* Win32 Multimedia API header. */ +#endif +#endif + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 000000000..3e1f7e52c --- /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 + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +glutKeyboardFunc(GLUTkeyboardCB keyboardFunc) +{ + __glutChangeWindowEventMask(KeyPressMask, + keyboardFunc != NULL || __glutCurrentWindow->special != NULL); + __glutCurrentWindow->keyboard = keyboardFunc; +} + +void GLUTAPIENTRY +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 000000000..c76912e10 --- /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 GLUTAPIENTRY +glutIgnoreKeyRepeat(int ignore) +{ + __glutCurrentWindow->ignoreKeyRepeat = ignore; +} + +void GLUTAPIENTRY +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 000000000..ae97b2f96 --- /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 + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +glutKeyboardUpFunc(GLUTkeyboardCB keyboardUpFunc) +{ + __glutChangeWindowEventMask(KeyReleaseMask, + keyboardUpFunc != NULL || __glutCurrentWindow->specialUp != NULL); + __glutCurrentWindow->keyboardUp = keyboardUpFunc; +} + +void GLUTAPIENTRY +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 000000000..4e2cac279 --- /dev/null +++ b/src/glut/glx/glut_menu.c @@ -0,0 +1,1014 @@ + +/* Copyright (c) Mark J. Kilgard, 1994, 1997. */ + +/* This program is freely distributable without licensing fees + and is provided without guarantee or warrantee expressed or + implied. This program is -not- in the public domain. */ + +/* The Win32 GLUT file win32_menu.c completely re-implements all + the menuing functionality implemented. This file is used only by + the X Window System version of GLUT. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include +#include + +#include +#include +#include /* for XC_arrow */ + +#include "glutint.h" +#include "layerutil.h" + +void (CDECL *__glutMenuStatusFunc) (int, int, int); +GLUTmenuItem *__glutItemSelected; +GLUTmenu **__glutMenuList = NULL; + +static int menuListSize = 0; +static XFontStruct *menuFont = NULL; +static Cursor menuCursor; +static Colormap menuColormap; +static Visual *menuVisual; +static int menuDepth; +static int fontHeight; +static GC blackGC, grayGC, whiteGC; +static unsigned long menuBlack, menuWhite, menuGray; +static unsigned long useSaveUnders; + +/* A replacement for XAllocColor (originally by Brian Paul). + This function should never fail to allocate a color. When + XAllocColor fails, we return the nearest matching color. If + we have to allocate many colors this function isn't a great + solution; the XQueryColors() could be done just once. */ +static void +noFaultXAllocColor(Display * dpy, Colormap cmap, int cmapSize, + XColor * color) +{ + XColor *ctable, subColor; + int i, bestmatch; + double mindist; /* 3*2^16^2 exceeds 32-bit long int + precision. */ + + for (;;) { + /* First try just using XAllocColor. */ + if (XAllocColor(dpy, cmap, color)) { + return; + } + + /* Retrieve color table entries. */ + /* XXX alloca canidate. */ + ctable = (XColor *) malloc(cmapSize * sizeof(XColor)); + for (i = 0; i < cmapSize; i++) + ctable[i].pixel = i; + XQueryColors(dpy, cmap, ctable, cmapSize); + + /* Find best match. */ + bestmatch = -1; + mindist = 0.0; + for (i = 0; i < cmapSize; i++) { + double dr = (double) color->red - (double) ctable[i].red; + double dg = (double) color->green - (double) ctable[i].green; + double db = (double) color->blue - (double) ctable[i].blue; + double dist = dr * dr + dg * dg + db * db; + if (bestmatch < 0 || dist < mindist) { + bestmatch = i; + mindist = dist; + } + } + + /* Return result. */ + subColor.red = ctable[bestmatch].red; + subColor.green = ctable[bestmatch].green; + subColor.blue = ctable[bestmatch].blue; + free(ctable); + if (XAllocColor(dpy, cmap, &subColor)) { + *color = subColor; + return; + } + /* Extremely unlikely, but possibly color was deallocated + and reallocated by someone else before we could + XAllocColor the color cell we located. If so, loop + again... */ + } +} + +static int +ifSunCreator(void) +{ + char *xvendor, *glvendor, *renderer; + int isSunCreator = 0; /* Until proven that it is. */ + int savedDisplayMode = 0; + char *savedDisplayString = 0; + GLUTwindow *window; + +#define VENDOR_SUN "Sun Microsystems" +#define RENDERER_CREATOR "Creator" + + /* Check the X vendor string first. It is easier to check + than the OpenGL vendor and renderer strings since it + doesn't require a valid OpenGL rendering context. Bail + early if not connected to a Sun. */ + xvendor = ServerVendor(__glutDisplay); + if (!strncmp(xvendor, VENDOR_SUN, sizeof(VENDOR_SUN) - 1)) { + + /* We need a valid current OpenGL rendering context to be + able to call glGetString successfully. If there is not + a current window, set up a temporary one just to call + glGetString with (gag, expensive). */ + if (__glutCurrentWindow) { + window = NULL; + } else { + savedDisplayMode = __glutDisplayMode; + savedDisplayString = __glutDisplayString; + __glutDisplayMode = GLUT_RGB | GLUT_SINGLE; + __glutDisplayString = NULL; + window = __glutCreateWindow(NULL, 0, 0, 1, 1, 0); + } + + glvendor = (char *) glGetString(GL_VENDOR); + if (!strncmp(glvendor, VENDOR_SUN, sizeof(VENDOR_SUN) - 1)) { + renderer = (char *) glGetString(GL_RENDERER); + if (!strncmp(renderer, RENDERER_CREATOR, sizeof(RENDERER_CREATOR) - 1)) { + isSunCreator = 1; + } + } + /* Destroy the temporary window for glGetString if one + needed to be created. */ + if (window) { + __glutDestroyWindow(window, window); + __glutDisplayMode = savedDisplayMode; + __glutDisplayString = savedDisplayString; + } + } + return isSunCreator; +} + +static void +menuVisualSetup(void) +{ + XLayerVisualInfo template, *visual, *overlayVisuals; + XColor color; + Status status; + Bool presumablyMesa; + int layer, nVisuals, i, dummy; + unsigned long *placeHolders = NULL; + int numPlaceHolders = 0; + Bool allocateHigh; + + allocateHigh = ifSunCreator(); + + /* Start with the highest overlay layer and work down. I + don't think any hardware has more than 3 overlay layers. */ + for (layer = 3; layer > 0; layer--) { + template.layer = layer; + template.vinfo.screen = __glutScreen; + overlayVisuals = __glutXGetLayerVisualInfo(__glutDisplay, + VisualScreenMask | VisualLayerMask, &template, &nVisuals); + if (overlayVisuals) { + /* First, check if the default visual is in this layer. + If the default visual is in this layer, we try to use + it since it has pre-defined black and white pixels and + + using the default visual will probably minimize + colormap flashing problems. Suggested by Thomas Roell + (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 GLUTAPIENTRY +glutCreateMenu(GLUTselectCB selectFunc) +{ + XSetWindowAttributes wa; + GLUTmenu *menu; + int menuid; + + if (__glutMappedMenu) { + __glutMenuModificationError(); + } + if (!__glutDisplay) { + __glutOpenXConnection(NULL); + } + + installMenuCallbacks(); + + menuid = getUnusedMenuSlot(); + menu = (GLUTmenu *) malloc(sizeof(GLUTmenu)); + if (!menu) { + __glutFatalError("out of memory."); + } + menu->id = menuid; + menu->num = 0; + menu->submenus = 0; + menu->managed = False; + menu->searched = False; + menu->pixwidth = 0; + menu->select = selectFunc; + menu->list = NULL; + menu->cascade = NULL; + menu->highlighted = NULL; + menu->anchor = NULL; + menuSetup(); + wa.override_redirect = True; + wa.background_pixel = menuGray; + wa.border_pixel = menuBlack; + wa.colormap = menuColormap; + wa.event_mask = StructureNotifyMask | ExposureMask | + ButtonPressMask | ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask; + /* Save unders really only enabled if useSaveUnders is set to + CWSaveUnder, ie. using Mesa 3D. See earlier comments. */ + wa.save_under = True; + menu->win = XCreateWindow(__glutDisplay, __glutRoot, + /* Real position determined when mapped. */ + 0, 0, + /* Real size will be determined when menu is manged. */ + 1, 1, + MENU_BORDER, menuDepth, InputOutput, menuVisual, + CWOverrideRedirect | CWBackPixel | CWBorderPixel | + CWEventMask | CWColormap | useSaveUnders, + &wa); + menuGraphicsContextSetup(menu->win); + __glutMenuList[menuid] = menu; + __glutSetMenu(menu); + return menuid + 1; +} + +/* CENTRY */ +int GLUTAPIENTRY +glutGetMenu(void) +{ + if (__glutCurrentMenu) { + return __glutCurrentMenu->id + 1; + } else { + return 0; + } +} + +void GLUTAPIENTRY +glutSetMenu(int menuid) +{ + GLUTmenu *menu; + + if (menuid < 1 || menuid > menuListSize) { + __glutWarning("glutSetMenu attempted on bogus menu."); + return; + } + menu = __glutMenuList[menuid - 1]; + if (!menu) { + __glutWarning("glutSetMenu attempted on bogus menu."); + return; + } + __glutSetMenu(menu); +} +/* ENDCENTRY */ + +void +__glutSetMenuItem(GLUTmenuItem * item, const char *label, + int value, Bool isTrigger) +{ + GLUTmenu *menu; + + menu = item->menu; + item->label = __glutStrdup(label); + if (!item->label) { + __glutFatalError("out of memory."); + } + item->isTrigger = isTrigger; + item->len = (int) strlen(label); + item->value = value; + item->pixwidth = XTextWidth(menuFont, label, item->len) + 4; + if (item->pixwidth > menu->pixwidth) { + menu->pixwidth = item->pixwidth; + } + menu->managed = False; +} + +/* CENTRY */ +void GLUTAPIENTRY +glutAddMenuEntry(const char *label, int value) +{ + XSetWindowAttributes wa; + GLUTmenuItem *entry; + + if (__glutMappedMenu) { + __glutMenuModificationError(); + } + entry = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem)); + if (!entry) { + __glutFatalError("out of memory."); + } + entry->menu = __glutCurrentMenu; + __glutSetMenuItem(entry, label, value, False); + wa.event_mask = EnterWindowMask | LeaveWindowMask; + entry->win = XCreateWindow(__glutDisplay, + __glutCurrentMenu->win, MENU_GAP, + __glutCurrentMenu->num * fontHeight + MENU_GAP, /* x & y */ + entry->pixwidth, fontHeight, /* width & height */ + 0, CopyFromParent, InputOnly, CopyFromParent, + CWEventMask, &wa); + XMapWindow(__glutDisplay, entry->win); + __glutCurrentMenu->num++; + entry->next = __glutCurrentMenu->list; + __glutCurrentMenu->list = entry; +} + +void GLUTAPIENTRY +glutAddSubMenu(const char *label, int menu) +{ + XSetWindowAttributes wa; + GLUTmenuItem *submenu; + + if (__glutMappedMenu) { + __glutMenuModificationError(); + } + submenu = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem)); + if (!submenu) { + __glutFatalError("out of memory."); + } + __glutCurrentMenu->submenus++; + submenu->menu = __glutCurrentMenu; + __glutSetMenuItem(submenu, label, /* base 0 */ menu - 1, True); + wa.event_mask = EnterWindowMask | LeaveWindowMask; + submenu->win = XCreateWindow(__glutDisplay, + __glutCurrentMenu->win, MENU_GAP, + __glutCurrentMenu->num * fontHeight + MENU_GAP, /* x & y */ + submenu->pixwidth, fontHeight, /* width & height */ + 0, CopyFromParent, InputOnly, CopyFromParent, + CWEventMask, &wa); + XMapWindow(__glutDisplay, submenu->win); + __glutCurrentMenu->num++; + submenu->next = __glutCurrentMenu->list; + __glutCurrentMenu->list = submenu; +} + +void GLUTAPIENTRY +glutAttachMenu(int button) +{ + if (__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 000000000..969b8120b --- /dev/null +++ b/src/glut/glx/glut_menu2.c @@ -0,0 +1,189 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include +#include + +#include + +#include "glutint.h" +#include "layerutil.h" + +/* CENTRY */ +/* DEPRICATED, use glutMenuStatusFunc instead. */ +void GLUTAPIENTRY +glutMenuStateFunc(GLUTmenuStateCB menuStateFunc) +{ + __glutMenuStatusFunc = (GLUTmenuStatusCB) menuStateFunc; +} + +void GLUTAPIENTRY +glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc) +{ + __glutMenuStatusFunc = menuStatusFunc; +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 000000000..7e202fa07 --- /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 +#include +#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 000000000..69fa5aba9 --- /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 GLUTAPIENTRY +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 000000000..a29f043b4 --- /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 000000000..937ecb682 --- /dev/null +++ b/src/glut/glx/glut_overlay.c @@ -0,0 +1,611 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include + +#if !defined(_WIN32) +#include +#include +#include /* for XA_RGB_DEFAULT_MAP atom */ +#if defined (__vms) +#include /* for XmuLookupStandardColormap */ +#else +#include /* 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 GLUTAPIENTRY +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 = __glut_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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutPostWindowOverlayRedisplay(int win) +{ + __glutPostRedisplay(__glutWindowList[win - 1], GLUT_OVERLAY_REDISPLAY_WORK); +} + +void GLUTAPIENTRY +glutOverlayDisplayFunc(GLUTdisplayCB displayFunc) +{ + if (!__glutCurrentWindow->overlay) { + __glutWarning("glutOverlayDisplayFunc: window has no overlay established"); + return; + } + __glutCurrentWindow->overlay->display = displayFunc; +} + +void GLUTAPIENTRY +glutHideOverlay(void) +{ + if (!__glutCurrentWindow->overlay) { + __glutWarning("glutHideOverlay: window has no overlay established"); + return; + } + XUnmapWindow(__glutDisplay, __glutCurrentWindow->overlay->win); + __glutCurrentWindow->overlay->shownState = 0; +} + +void GLUTAPIENTRY +glutShowOverlay(void) +{ + if (!__glutCurrentWindow->overlay) { + __glutWarning("glutShowOverlay: window has no overlay established"); + return; + } + XMapWindow(__glutDisplay, __glutCurrentWindow->overlay->win); + __glutCurrentWindow->overlay->shownState = 1; +} + +int GLUTAPIENTRY +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 000000000..af2b4ec95 --- /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 000000000..20e21026c --- /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 +#include "glutint.h" + +/* Some 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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireCube(GLdouble size) +{ + drawBox(size, GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireDodecahedron(void) +{ + dodecahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireOctahedron(void) +{ + octahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireIcosahedron(void) +{ + icosahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireTetrahedron(void) +{ + tetrahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 000000000..cde6ea732 --- /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 GLUTAPIENTRY +glutSpaceballMotionFunc(GLUTspaceMotionCB spaceMotionFunc) +{ + __glutCurrentWindow->spaceMotion = spaceMotionFunc; + __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask; + __glutPutOnWorkList(__glutCurrentWindow, + GLUT_DEVICE_MASK_WORK); +} + +void GLUTAPIENTRY +glutSpaceballRotateFunc(GLUTspaceRotateCB spaceRotateFunc) +{ + __glutCurrentWindow->spaceRotate = spaceRotateFunc; + __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask; + __glutPutOnWorkList(__glutCurrentWindow, + GLUT_DEVICE_MASK_WORK); +} + +void GLUTAPIENTRY +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 000000000..7569012ec --- /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 GLUTAPIENTRY +glutStrokeCharacter(GLUTstrokeFont font, int c) +{ + const StrokeCharRec *ch; + const StrokeRec *stroke; + const CoordRec *coord; + StrokeFontPtr fontinfo; + int i, j; + + +#if defined(_WIN32) || defined(GLUT_IMPORT_LIB) + 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 000000000..4831b8eb3 --- /dev/null +++ b/src/glut/glx/glut_swap.c @@ -0,0 +1,67 @@ + +/* 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 +#include "glutint.h" + +GLint __glutFPS = 0; +GLint __glutSwapCount = 0; +GLint __glutSwapTime = 0; + +/* CENTRY */ +void GLUTAPIENTRY +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. */ + + if (__glutFPS) { + GLint t = glutGet(GLUT_ELAPSED_TIME); + __glutSwapCount++; + if (__glutSwapTime == 0) + __glutSwapTime = t; + else if (t - __glutSwapTime > __glutFPS) { + float time = 0.001 * (t - __glutSwapTime); + float fps = (float) __glutSwapCount / time; + fprintf(stderr, "GLUT: %d frames in %.2f seconds = %.2f FPS\n", + __glutSwapCount, time, fps); + __glutSwapTime = t; + __glutSwapCount = 0; + } + } +} +/* ENDCENTRY */ diff --git a/src/glut/glx/glut_swidth.c b/src/glut/glx/glut_swidth.c new file mode 100644 index 000000000..4717bbff5 --- /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 GLUTAPIENTRY +glutStrokeWidth(GLUTstrokeFont font, int c) +{ + StrokeFontPtr fontinfo; + const StrokeCharRec *ch; + +#if defined(_WIN32) || defined(GLUT_IMPORT_LIB) + 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 GLUTAPIENTRY +glutStrokeLength(GLUTstrokeFont font, const unsigned char *string) +{ + int c, length; + StrokeFontPtr fontinfo; + const StrokeCharRec *ch; + +#if defined(_WIN32) || defined(GLUT_IMPORT_LIB) + 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 000000000..80c68288c --- /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 + +#include "glutint.h" + +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 000000000..ff46d96b8 --- /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 GLUTAPIENTRY +glutSolidTeapot(GLdouble scale) +{ + teapot(7, scale, GL_FILL); +} + +void GLUTAPIENTRY +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 000000000..0fac8070c --- /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 000000000..22b0e5160 --- /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 000000000..4ebac64c1 --- /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 +#include +#include +#include + +#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 GLUTAPIENTRY +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 000000000..5993e8370 --- /dev/null +++ b/src/glut/glx/glut_vidresize.c @@ -0,0 +1,231 @@ + +/* 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 + +#ifdef __sgi +#include +#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. */ +#if 0 +#ifdef GLX_SYNC_FRAME_SGIX +#define GLX_SGIX_video_resize 1 +#endif +#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 int +catchXSGIvcErrors(Display * dpy, XErrorEvent * event) +{ + errorCaught = 1; + return 0; +} +#endif + +/* CENTRY */ +int GLUTAPIENTRY +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 defined(__sgi) && __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; + +#if defined(GLX_GLXEXT_PROTOTYPES) +#endif + + __glut_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; + + __glut_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 GLUTAPIENTRY +glutSetupVideoResizing(void) +{ +#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize) + if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) { + __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, __glutCurrentWindow->win); + videoResizeInUse = 1; + } else +#endif + __glutFatalError("glutEstablishVideoResizing: video resizing not possible.\n"); +} + +void GLUTAPIENTRY +glutStopVideoResizing(void) +{ +#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize) + if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) { + if (videoResizeInUse) { + __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, None); + videoResizeInUse = 0; + } + } +#endif +} + +/* ARGSUSED */ +void GLUTAPIENTRY +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. */ + __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, GLX_SYNC_SWAP_SGIX); +#endif + __glut_glXChannelRectSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, x, y, width, height); + } +#endif +} + +/* ARGSUSED */ +void GLUTAPIENTRY +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. */ + __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, GLX_SYNC_FRAME_SGIX); +#endif + __glut_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 000000000..3d48655ed --- /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 +#include +#include + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +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 000000000..4b044d084 --- /dev/null +++ b/src/glut/glx/glut_win.c @@ -0,0 +1,1016 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include +#if !defined(_WIN32) +#include +#include +#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 GLUTAPIENTRY +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 GLUTAPIENTRY +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) || defined(GLX_ARB_multisample)) + if (GLUT_WIND_IS_MULTISAMPLE(mode)) { + if (!__glutIsSupportedByGLX("GLX_SGIS_multisample") && + !__glutIsSupportedByGLX("GLX_ARB_multisample")) + return NULL; +#if defined(GLX_ARB_multisample) + list[n++] = GLX_SAMPLES_ARB; +#elif defined(GLX_SGIS_multisample) + list[n++] = GLX_SAMPLES_SGIS; +#endif + /* 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; +} + +static 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 = __glut_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 GLUTAPIENTRY +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 GLUTAPIENTRY +__glutCreateWindowWithExit(const char *title, void (__cdecl *exitfunc)(int)) +{ + __glutExitFunc = exitfunc; + return glutCreateWindow(title); +} +#endif + +int GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutEntryFunc(GLUTentryCB entryFunc) +{ + __glutChangeWindowEventMask(EnterWindowMask | LeaveWindowMask, + entryFunc != NULL || __glutCurrentWindow->passive); + __glutCurrentWindow->entry = entryFunc; + if (!entryFunc) { + __glutCurrentWindow->entryState = -1; + } +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutVisibilityFunc(GLUTvisibilityCB visibilityFunc) +{ + __glutCurrentWindow->visibility = visibilityFunc; + if (visibilityFunc) + glutWindowStatusFunc(visibilityHelper); + else + glutWindowStatusFunc(NULL); +} + +void GLUTAPIENTRY +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 000000000..0fc4c805f --- /dev/null +++ b/src/glut/glx/glut_winmisc.c @@ -0,0 +1,124 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include + +#if !defined(_WIN32) +#include +#include +#include /* for XA_STRING atom */ +#endif + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutPopWindow(void) +{ + IGNORE_IN_GAME_MODE(); + __glutCurrentWindow->desiredStack = Above; + __glutCurrentWindow->desiredConfMask |= CWStackMode; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK); +} + +void GLUTAPIENTRY +glutPushWindow(void) +{ + IGNORE_IN_GAME_MODE(); + __glutCurrentWindow->desiredStack = Below; + __glutCurrentWindow->desiredConfMask |= CWStackMode; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK); +} + +void GLUTAPIENTRY +glutIconifyWindow(void) +{ + IGNORE_IN_GAME_MODE(); + assert(!__glutCurrentWindow->parent); + __glutCurrentWindow->desiredMapState = IconicState; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK); +} + +void GLUTAPIENTRY +glutShowWindow(void) +{ + IGNORE_IN_GAME_MODE(); + __glutCurrentWindow->desiredMapState = NormalState; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK); +} + +void GLUTAPIENTRY +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 000000000..9584bb129 --- /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 + +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 000000000..6fe09ffe7 --- /dev/null +++ b/src/glut/glx/glutint.h @@ -0,0 +1,812 @@ +#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. */ + +#ifdef __VMS +#include +#endif + +#if defined(__CYGWIN32__) +#include +#endif + +#define SUPPORT_FORTRAN /* With GLUT 3.7, everyone supports Fortran. */ + +#if defined(_WIN32) +#include "glutwin32.h" +#else +#include +#include +#define GLX_GLXEXT_PROTOTYPES +#include +#endif + +#define GLUT_BUILDING_LIB /* Building the GLUT library itself. */ +#include + +#if defined(MESA) && defined(_WIN32) && !defined(__CYGWIN32__) +#include +#endif + +#ifndef _WIN32 +/* added by BrianP: */ +#ifndef APIENTRY +#define APIENTRY GLAPIENTRY +#endif +#define __cdecl GLAPIENTRY +#define CDECL GLAPIENTRY +#endif + +/* GLUT_BUILDING_LIB is used by to 1) not #pragma link + with the GLUT library, and 2) avoid the Win32 atexit hack. */ + +/* This must be done after is included. MESA is defined + if the 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. */ +#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 +#endif + +#ifdef __vms +#if ( __VMS_VER < 70000000 ) +#define OLD_VMS +struct timeval6 { + __int64 val; +}; +extern int sys$gettim(struct timeval6 *); +#else +#include +#endif +#else +#include +#if !defined(_WIN32) || defined(__CYGWIN32__) +#include +#else +#include +#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 */ +#ifdef OLD_VMS + struct timeval6 timeout; /* time to be called */ +#else + struct timeval timeout; /* time to be called */ +#endif + 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 void __glutFreeOverlay(GLUToverlay * overlay); +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); +extern void handleTimeouts(void); + +/* private routines from glut_init.c */ +#if !defined(_WIN32) +extern void __glutOpenXConnection(char *display); +#else +extern void __glutOpenWin32Connection(char *display); +#endif +#ifdef OLD_VMS +extern void __glutInitTime(struct timeval6 *beginning); +#else +extern void __glutInitTime(struct timeval *beginning); +#endif + +/* 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 *); +extern int __glut_glXBindChannelToWindowSGIX(Display *dpy, int screen, + int channel, Window window); +extern int __glut_glXChannelRectSGIX(Display *dpy, int screen, int channel, + int x, int y, int w, int h); +extern int __glut_glXQueryChannelRectSGIX(Display *dpy, int screen, + int channel, int *x, int *y, + int *w, int *h); +extern int __glut_glXQueryChannelDeltasSGIX(Display *dpy, int screen, + int channel, int *dx, int *dy, + int *dw, int *dh); +extern int __glut_glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, + GLenum synctype); +extern GLXContext __glut_glXCreateContextWithConfigSGIX(Display *dpy, + GLXFBConfigSGIX config, + int render_type, + GLXContext share_list, + Bool direct); +extern int __glut_glXGetFBConfigAttribSGIX(Display *dpy, + GLXFBConfigSGIX config, + int attribute, + int *value); +extern GLXFBConfigSGIX __glut_glXGetFBConfigFromVisualSGIX(Display *dpy, + XVisualInfo *vis); +#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 __glutCloseDownGameMode(void); + +/* private variables from glut_swap.c (BrianP) */ +extern GLint __glutFPS; +extern GLint __glutSwapCount; +extern GLint __glutSwapTime; + +#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 000000000..cbc9e156f --- /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 000000000..304eeb20a --- /dev/null +++ b/src/glut/glx/glutwin32.h @@ -0,0 +1,96 @@ +#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 */ +#ifndef __CYGWIN32__ +extern int gettimeofday(struct timeval* tp, void* tzp); +#endif +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); + + +/* Cygwin B20.1 misses the following definitions */ +#ifdef __CYGWIN32__ + +/* from winuser.h */ +#define CDS_FULLSCREEN 4 + +/* from mmsystem.h */ +#define WINMMAPI __declspec(dllimport) +typedef UINT MMRESULT; + +#define MM_JOY1MOVE 0x3A0 +#define MM_JOY1ZMOVE 0x3A2 +#define MM_JOY1BUTTONDOWN 0x3B5 +#define MM_JOY1BUTTONUP 0x3B7 + +#define JOYERR_NOERROR 0 +#define JOYERR_PARMS 165 + +#define JOY_RETURNALL 0x000000ffl + +#define JOYSTICKID1 0 + +typedef struct joyinfoex_tag { + DWORD dwSize; /* size of structure */ + DWORD dwFlags; /* flags to indicate what to return */ + DWORD dwXpos; /* x position */ + DWORD dwYpos; /* y position */ + DWORD dwZpos; /* z position */ + DWORD dwRpos; /* rudder/4th axis position */ + DWORD dwUpos; /* 5th axis position */ + DWORD dwVpos; /* 6th axis position */ + DWORD dwButtons; /* button states */ + DWORD dwButtonNumber; /* current button number pressed */ + DWORD dwPOV; /* point of view state */ + DWORD dwReserved1; /* reserved for communication between winmm & driver */ + DWORD dwReserved2; /* reserved for future expansion */ +} JOYINFOEX, *PJOYINFOEX, /* NEAR */ *NPJOYINFOEX, /* FAR */ *LPJOYINFOEX; + +WINMMAPI MMRESULT WINAPI joyGetPosEx( UINT uJoyID, LPJOYINFOEX pji); +WINMMAPI MMRESULT WINAPI joyReleaseCapture( UINT uJoyID); +WINMMAPI MMRESULT WINAPI joySetCapture( HWND hwnd, UINT uJoyID, UINT uPeriod, BOOL fChanged); +WINMMAPI MMRESULT WINAPI joySetThreshold( UINT uJoyID, UINT uThreshold); + +#endif + +#endif /* __glutwin32_h__ */ diff --git a/src/glut/glx/layerutil.c b/src/glut/glx/layerutil.c new file mode 100644 index 000000000..26ba0b602 --- /dev/null +++ b/src/glut/glx/layerutil.c @@ -0,0 +1,204 @@ + +/* 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 +#include +#include "layerutil.h" + +/* SGI optimization introduced in IRIX 6.3 to avoid X server + round trips for interning common X atoms. */ +#include +#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS) +#include +#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 000000000..8f580afe3 --- /dev/null +++ b/src/glut/glx/layerutil.h @@ -0,0 +1,59 @@ +#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 */ + +#ifdef __VMS +#include +#endif + +#if !defined(_WIN32) +#include +#include +#include +#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 000000000..98f87c29e --- /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 000000000..fc29680be --- /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 000000000..ecfff44b9 --- /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 +#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 000000000..d3630e7a1 --- /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 000000000..5ce264dcd --- /dev/null +++ b/src/glut/glx/win32_menu.c @@ -0,0 +1,531 @@ + +/* 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 +#include +#include +#include +#include + +#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 GLUTAPIENTRY +glutMenuStateFunc(GLUTmenuStateCB menuStateFunc) +{ + __glutMenuStatusFunc = (GLUTmenuStatusCB) menuStateFunc; +} + +void GLUTAPIENTRY +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((HMENU) 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 GLUTAPIENTRY +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 = (HWND) CreatePopupMenu(); + menuList[menuid] = menu; + __glutSetMenu(menu); + return menuid + 1; +} + +int GLUTAPIENTRY +__glutCreateMenuWithExit(GLUTselectCB selectFunc, void (__cdecl *exitfunc)(int)) +{ + __glutExitFunc = exitfunc; + return glutCreateMenu(selectFunc); +} + +void GLUTAPIENTRY +glutDestroyMenu(int menunum) +{ + GLUTmenu *menu = __glutGetMenuByNum(menunum); + GLUTmenuItem *item, *next; + + if (__glutMappedMenu) { + menuModificationError(); + } + assert(menu->id == menunum - 1); + DestroyMenu( (HMENU) 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 GLUTAPIENTRY +glutGetMenu(void) +{ + if (__glutCurrentMenu) { + return __glutCurrentMenu->id + 1; + } else { + return 0; + } +} + +void GLUTAPIENTRY +glutSetMenu(int menuid) +{ + GLUTmenu *menu; + + if (menuid < 1 || menuid > menuListSize) { + __glutWarning("glutSetMenu attempted on bogus menu."); + return; + } + menu = 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((HMENU) menu->win, MF_POPUP, (UINT)item->win, label); + } else { + AppendMenu((HMENU) menu->win, MF_STRING, item->unique, label); + } +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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((HMENU) 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((HMENU) __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 GLUTAPIENTRY +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 = (HWND) 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((HMENU) __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 GLUTAPIENTRY +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((HMENU) __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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 000000000..becd823a4 --- /dev/null +++ b/src/glut/glx/win32_util.c @@ -0,0 +1,120 @@ + +/* 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" +#include + +/* The following added by Paul Garceau */ +#if defined(__MINGW32__) +#include +#include +struct timeval; +#endif + +extern StrokeFontRec glutStrokeRoman, glutStrokeMonoRoman; +extern BitmapFontRec glutBitmap8By13, glutBitmap9By15, glutBitmapTimesRoman10, glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12, glutBitmapHelvetica18; + +#ifndef __CYGWIN32__ +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; +} +#endif + +/* 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("font not found."); + /* NOTREACHED */ + return NULL; /* MSVC compiler complains if there is no return at all */ +} + +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 000000000..a54bac75f --- /dev/null +++ b/src/glut/glx/win32_winproc.c @@ -0,0 +1,784 @@ + +/* 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 + +#if defined(_WIN32) && !defined(__CYGWIN32__) +#include /* Win32 Multimedia API header. */ +#endif + +extern unsigned __glutMenuButton; +extern GLUTidleCB __glutIdleFunc; +extern GLUTtimer *__glutTimerList; +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 000000000..1d138cfa2 --- /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 + * "=x{+-}{+-}", 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 000000000..1d8d048b2 --- /dev/null +++ b/src/glut/glx/win32_x11.h @@ -0,0 +1,326 @@ +#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 +#include + +/* These definitions are missing from windows.h */ +WINGDIAPI int WINAPI wglChoosePixelFormat(HDC, PIXELFORMATDESCRIPTOR *); +WINGDIAPI int WINAPI wglDescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR); +WINGDIAPI int WINAPI wglGetPixelFormat(HDC); +WINGDIAPI BOOL WINAPI wglSetPixelFormat(HDC, int, PIXELFORMATDESCRIPTOR *); +WINGDIAPI BOOL WINAPI wglSwapBuffers(HDC); + +/* 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__ */ diff --git a/src/glut/mini/Makefile b/src/glut/mini/Makefile new file mode 100644 index 000000000..cb8238494 --- /dev/null +++ b/src/glut/mini/Makefile @@ -0,0 +1,80 @@ +# subset glut + +TOP = ../../.. +include $(TOP)/configs/current + +MARK = $(TOP)/src/glut/glx + +GLUT_MAJOR = 3 +GLUT_MINOR = 7 +GLUT_TINY = 1 + +INCLUDES = -I$(TOP)/include -I$(MARK) + +CORE_SOURCES = \ + bitmap.c \ + callback.c \ + color.c \ + globals.c \ + init.c \ + menu.c \ + models.c \ + overlay.c \ + state.c \ + teapot.c \ + window.c + + +MARK_SOURCES = \ + $(MARK)/glut_8x13.c \ + $(MARK)/glut_9x15.c \ + $(MARK)/glut_hel10.c \ + $(MARK)/glut_hel12.c \ + $(MARK)/glut_hel18.c \ + $(MARK)/glut_tr10.c \ + $(MARK)/glut_tr24.c + +SOURCES = $(CORE_SOURCES) $(MARK_SOURCES) + +OBJECTS = $(SOURCES:.c=.o) + + +##### RULES ##### + +.c.o: + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + +.S.o: + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + + +##### TARGETS ##### + +default: depend $(LIB_DIR)/$(GLUT_LIB_NAME) + + +# Make the library +$(LIB_DIR)/$(GLUT_LIB_NAME): depend $(OBJECTS) + $(TOP)/bin/mklib -o $(GLUT_LIB) -linker '$(CC)' \ + -major $(GLUT_MAJOR) -minor $(GLUT_MINOR) -patch $(GLUT_TINY) \ + $(GLUT_LIB_DEPS) -install $(LIB_DIR) \ + $(MKLIB_OPTIONS) $(OBJECTS) + + +# Run 'make -f Makefile.solo dep' to update the dependencies if you change +# what's included by any source file. +depend: $(SOURCES) + touch depend + $(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(SOURCES) > /dev/null + +# Emacs tags +tags: + etags `find . -name \*.[ch]` `find ../include` + + +# Remove .o and backup files +clean: depend + -rm -f depend + -rm -f *.o *~ *.o *~ *.so libglut.so.3.7 + +include depend diff --git a/src/glut/mini/bitmap.c b/src/glut/mini/bitmap.c new file mode 100644 index 000000000..55a031af0 --- /dev/null +++ b/src/glut/mini/bitmap.c @@ -0,0 +1,56 @@ + +/* 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 "glutbitmap.h" + +void APIENTRY +glutBitmapCharacter(GLUTbitmapFont font, int c) +{ + const BitmapCharRec *ch; + BitmapFontPtr fontinfo; + GLfloat swapbytes, lsbfirst, rowlength; + GLfloat 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. */ +/* glGetFloatv(GL_UNPACK_SWAP_BYTES, &swapbytes); */ +/* glGetFloatv(GL_UNPACK_LSB_FIRST, &lsbfirst); */ +/* glGetFloatv(GL_UNPACK_ROW_LENGTH, &rowlength); */ +/* glGetFloatv(GL_UNPACK_SKIP_ROWS, &skiprows); */ +/* glGetFloatv(GL_UNPACK_SKIP_PIXELS, &skippixels); */ + glGetFloatv(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, (int)lsbfirst); */ +/* glPixelStorei(GL_UNPACK_ROW_LENGTH, (int)rowlength); */ +/* glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows); */ +/* glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels); */ + glPixelStorei(GL_UNPACK_ALIGNMENT, (int)alignment); + } +} diff --git a/src/glut/mini/callback.c b/src/glut/mini/callback.c new file mode 100644 index 000000000..d4e3101cc --- /dev/null +++ b/src/glut/mini/callback.c @@ -0,0 +1,152 @@ +/* + * Mesa 3-D graphics library + * Version: 3.4 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include "GL/glut.h" +#include "internal.h" + + +void APIENTRY glutDisplayFunc (void (GLUTCALLBACK *func) (void)) +{ + display_func = func; +} + + +void APIENTRY glutReshapeFunc (void (GLUTCALLBACK *func) (int width, int height)) +{ + reshape_func = func; +} + + +void APIENTRY glutKeyboardFunc (void (GLUTCALLBACK *func) (unsigned char key, int x, int y)) +{ + keyboard_func = func; +} + + +void APIENTRY glutMouseFunc (void (GLUTCALLBACK *func) (int button, int state, int x, int y)) +{ + mouse_func = func; +} + + +void APIENTRY glutMotionFunc (void (GLUTCALLBACK *func) (int x, int y)) +{ + motion_func = func; +} + + +void APIENTRY glutPassiveMotionFunc (void (GLUTCALLBACK *func) (int x, int y)) +{ + passive_motion_func = func; +} + + +void APIENTRY glutEntryFunc (void (GLUTCALLBACK *func) (int state)) +{ + entry_func = func; +} + + +void APIENTRY glutVisibilityFunc (void (GLUTCALLBACK *func) (int state)) +{ + visibility_func = func; +} + + +void APIENTRY glutIdleFunc (void (GLUTCALLBACK *func) (void)) +{ + idle_func = func; +} + + +void APIENTRY glutTimerFunc (unsigned int millis, void (GLUTCALLBACK *func) (int value), int value) +{ +} + + +void APIENTRY glutMenuStateFunc (void (GLUTCALLBACK *func) (int state)) +{ + menu_state_func = func; +} + + +void APIENTRY glutSpecialFunc (void (GLUTCALLBACK *func) (int key, int x, int y)) +{ + special_func = func; +} + + +void APIENTRY glutSpaceballMotionFunc (void (GLUTCALLBACK *func) (int x, int y, int z)) +{ +} + + +void APIENTRY glutSpaceballRotateFunc (void (GLUTCALLBACK *func) (int x, int y, int z)) +{ +} + + +void APIENTRY glutSpaceballButtonFunc (void (GLUTCALLBACK *func) (int button, int state)) +{ +} + + +void APIENTRY glutButtonBoxFunc (void (GLUTCALLBACK *func) (int button, int state)) +{ +} + + +void APIENTRY glutDialsFunc (void (GLUTCALLBACK *func) (int dial, int value)) +{ +} + + +void APIENTRY glutTabletMotionFunc (void (GLUTCALLBACK *func) (int x, int y)) +{ +} + + +void APIENTRY glutTabletButtonFunc (void (GLUTCALLBACK *func) (int button, int state, int x, int y)) +{ +} + + +void APIENTRY glutMenuStatusFunc (void (GLUTCALLBACK *func) (int status, int x, int y)) +{ +} + + +void APIENTRY glutOverlayDisplayFunc (void (GLUTCALLBACK *func) (void)) +{ +} + + +void APIENTRY glutWindowStatusFunc (void (GLUTCALLBACK *func) (int state)) +{ +} diff --git a/src/glut/mini/color.c b/src/glut/mini/color.c new file mode 100644 index 000000000..b53c5b669 --- /dev/null +++ b/src/glut/mini/color.c @@ -0,0 +1,46 @@ +/* + * Mesa 3-D graphics library + * Version: 3.4 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include "GL/glut.h" + + +void APIENTRY glutSetColor (int ndx, GLfloat red, GLfloat green, GLfloat blue) +{ +} + + +GLfloat APIENTRY glutGetColor (int ndx, int component) +{ + return 0.0; +} + + +void APIENTRY glutCopyColormap (int win) +{ +} diff --git a/src/glut/mini/globals.c b/src/glut/mini/globals.c new file mode 100644 index 000000000..76db53c69 --- /dev/null +++ b/src/glut/mini/globals.c @@ -0,0 +1,61 @@ +/* + * Mesa 3-D graphics library + * Version: 3.4 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include "GL/glut.h" +#include "internal.h" + +GLenum g_display_mode = 0; +GLuint g_width = DEFAULT_WIDTH; +GLuint g_height = DEFAULT_HEIGHT; +GLint g_mouse = GL_FALSE; +GLboolean g_redisplay = GL_FALSE; +GLint g_xpos = 0; +GLint g_ypos = 0; + +void (GLUTCALLBACK *display_func) (void) = 0; +void (GLUTCALLBACK *reshape_func) (int width, int height) = 0; +void (GLUTCALLBACK *keyboard_func) (unsigned char key, int x, int y) = 0; +void (GLUTCALLBACK *mouse_func) (int button, int state, int x, int y) = 0; +void (GLUTCALLBACK *motion_func) (int x, int y) = 0; +void (GLUTCALLBACK *passive_motion_func) (int x, int y) = 0; +void (GLUTCALLBACK *entry_func) (int state) = 0; +void (GLUTCALLBACK *visibility_func) (int state) = 0; +void (GLUTCALLBACK *idle_func) (void) = 0; +void (GLUTCALLBACK *menu_state_func) (int state) = 0; +void (GLUTCALLBACK *special_func) (int key, int x, int y) = 0; +void (GLUTCALLBACK *spaceball_motion_func) (int x, int y, int z) = 0; +void (GLUTCALLBACK *spaceball_rotate_func) (int x, int y, int z) = 0; +void (GLUTCALLBACK *spaceball_button_func) (int button, int state) = 0; +void (GLUTCALLBACK *button_box_func) (int button, int state) = 0; +void (GLUTCALLBACK *dials_func) (int dial, int value) = 0; +void (GLUTCALLBACK *tablet_motion_func) (int x, int y) = 0; +void (GLUTCALLBACK *tabled_button_func) (int button, int state, int x, int y) = 0; +void (GLUTCALLBACK *menu_status_func) (int status, int x, int y) = 0; +void (GLUTCALLBACK *overlay_display_func) (void) = 0; +void (GLUTCALLBACK *window_status_func) (int state) = 0; diff --git a/src/glut/mini/init.c b/src/glut/mini/init.c new file mode 100644 index 000000000..5588db9ab --- /dev/null +++ b/src/glut/mini/init.c @@ -0,0 +1,59 @@ +/* + * Mesa 3-D graphics library + * Version: 4.0 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include "GL/glut.h" +#include "internal.h" + + +void APIENTRY glutInit (int *argcp, char **argv) +{ + glutGet(GLUT_ELAPSED_TIME); +} + + +void APIENTRY glutInitDisplayMode (unsigned int mode) +{ + g_display_mode = mode; +} + + +void APIENTRY glutInitWindowPosition (int x, int y) +{ + g_xpos = x; + g_ypos = y; +} + + +void APIENTRY glutInitWindowSize (int width, int height) +{ + g_width = width; + g_height = height; +} + + diff --git a/src/glut/mini/internal.h b/src/glut/mini/internal.h new file mode 100644 index 000000000..ccd12e54a --- /dev/null +++ b/src/glut/mini/internal.h @@ -0,0 +1,78 @@ +/* + * Mesa 3-D graphics library + * Version: 4.0 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#ifndef INTERNAL_H_included +#define INTERNAL_H_included + + +#include "GL/glut.h" +/* #include "pc_hw/pc_hw.h" */ + + +#define MAX_WINDOWS 4 + +#define DEFAULT_WIDTH 640 +#define DEFAULT_HEIGHT 480 +#define DEFAULT_BPP 16 + +#define DEPTH_SIZE 16 +#define STENCIL_SIZE 8 +#define ACCUM_SIZE 16 + +extern GLenum g_display_mode; +extern GLuint g_width; +extern GLuint g_height; +extern GLint g_mouse; +extern GLboolean g_redisplay; +extern GLint g_xpos; +extern GLint g_ypos; + +extern void (GLUTCALLBACK *display_func) (void); +extern void (GLUTCALLBACK *reshape_func) (int width, int height); +extern void (GLUTCALLBACK *keyboard_func) (unsigned char key, int x, int y); +extern void (GLUTCALLBACK *mouse_func) (int button, int state, int x, int y); +extern void (GLUTCALLBACK *motion_func) (int x, int y); +extern void (GLUTCALLBACK *passive_motion_func) (int x, int y); +extern void (GLUTCALLBACK *entry_func) (int state); +extern void (GLUTCALLBACK *visibility_func) (int state); +extern void (GLUTCALLBACK *idle_func) (void); +extern void (GLUTCALLBACK *menu_state_func) (int state); +extern void (GLUTCALLBACK *special_func) (int key, int x, int y); +extern void (GLUTCALLBACK *spaceball_motion_func) (int x, int y, int z); +extern void (GLUTCALLBACK *spaceball_rotate_func) (int x, int y, int z); +extern void (GLUTCALLBACK *spaceball_button_func) (int button, int state); +extern void (GLUTCALLBACK *button_box_func) (int button, int state); +extern void (GLUTCALLBACK *dials_func) (int dial, int value); +extern void (GLUTCALLBACK *tablet_motion_func) (int x, int y); +extern void (GLUTCALLBACK *tabled_button_func) (int button, int state, int x, int y); +extern void (GLUTCALLBACK *menu_status_func) (int status, int x, int y); +extern void (GLUTCALLBACK *overlay_display_func) (void); +extern void (GLUTCALLBACK *window_status_func) (int state); + +#endif diff --git a/src/glut/mini/menu.c b/src/glut/mini/menu.c new file mode 100644 index 000000000..3c571647b --- /dev/null +++ b/src/glut/mini/menu.c @@ -0,0 +1,86 @@ +/* + * Mesa 3-D graphics library + * Version: 3.4 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include "GL/glut.h" + + +int APIENTRY glutCreateMenu (void (GLUTCALLBACK *func) (int)) +{ + return 0; +} + +void APIENTRY glutDestroyMenu (int menu) +{ +} + + +int APIENTRY glutGetMenu (void) +{ + return 0; +} + + +void APIENTRY glutSetMenu (int menu) +{ +} + + +void APIENTRY glutAddMenuEntry (const char *label, int value) +{ +} + + +void APIENTRY glutAddSubMenu (const char *label, int submenu) +{ +} + + +void APIENTRY glutChangeToMenuEntry (int item, const char *label, int value) +{ +} + + +void APIENTRY glutChangeToSubMenu (int item, const char *label, int submenu) +{ +} + + +void APIENTRY glutRemoveMenuItem (int item) +{ +} + + +void APIENTRY glutAttachMenu (int button) +{ +} + + +void APIENTRY glutDetachMenu (int button) +{ +} diff --git a/src/glut/mini/models.c b/src/glut/mini/models.c new file mode 100644 index 000000000..57f45a262 --- /dev/null +++ b/src/glut/mini/models.c @@ -0,0 +1,598 @@ + +/* 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 +#include +#include +#include "GL/glut.h" + +/* Some 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/mini/overlay.c b/src/glut/mini/overlay.c new file mode 100644 index 000000000..fc8a8e5b0 --- /dev/null +++ b/src/glut/mini/overlay.c @@ -0,0 +1,60 @@ +/* + * Mesa 3-D graphics library + * Version: 3.4 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include "GL/glut.h" + + +void APIENTRY glutEstablishOverlay (void) +{ +} + + +void APIENTRY glutRemoveOverlay (void) +{ +} + + +void APIENTRY glutUseLayer (GLenum layer) +{ +} + + +void APIENTRY glutPostOverlayRedisplay (void) +{ +} + + +void APIENTRY glutShowOverlay (void) +{ +} + + +void APIENTRY glutHideOverlay (void) +{ +} diff --git a/src/glut/mini/state.c b/src/glut/mini/state.c new file mode 100644 index 000000000..81aefc53b --- /dev/null +++ b/src/glut/mini/state.c @@ -0,0 +1,70 @@ +/* + * Mesa 3-D graphics library + * Version: 3.4 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.0 for Mesa 4.0 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include "GL/glut.h" +#include + + +#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; \ + } \ +} + +int APIENTRY glutGet (GLenum type) +{ + + switch (type) { + case GLUT_WINDOW_RGBA: + return 1; + case GLUT_ELAPSED_TIME: { + static int inited = 0; + static struct timeval elapsed, beginning, now; + if (!inited) { + gettimeofday(&beginning, 0); + inited = 1; + } + gettimeofday(&now, 0); + TIMEDELTA(elapsed, now, beginning); + /* Return elapsed milliseconds. */ + return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000)); + } + default: + return 0; + } +} + + +int APIENTRY glutDeviceGet (GLenum type) +{ + return 0; +} diff --git a/src/glut/mini/teapot.c b/src/glut/mini/teapot.c new file mode 100644 index 000000000..ec2a20776 --- /dev/null +++ b/src/glut/mini/teapot.c @@ -0,0 +1,214 @@ + +/* 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 +#include +#include "GL/glut.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; + +#if 0 + 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(); +#endif +} + +/* 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/mini/window.c b/src/glut/mini/window.c new file mode 100644 index 000000000..73266769c --- /dev/null +++ b/src/glut/mini/window.c @@ -0,0 +1,273 @@ +/* + * Mesa 3-D graphics library + * Version: 4.1 + * Copyright (C) 1995-1998 Brian Paul + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * DOS/DJGPP glut driver v1.2 for Mesa 4.1 + * + * Copyright (C) 2002 - Borca Daniel + * Email : dborca@yahoo.com + * Web : http://www.geocities.com/dborca + */ + + +#include +#include +#include "GL/glut.h" +#include "internal.h" + +#define USE_MINI_GLX 1 +#if USE_MINI_GLX +#include "GL/miniglx.h" +#else +#include +#endif + + + +static GLXContext context = 0; +static Window win; +static XVisualInfo *visinfo = 0; +static Display *dpy = 0; + + +int APIENTRY glutCreateWindow (const char *title) +{ + XSetWindowAttributes attr; + unsigned long mask; + GLXContext ctx; + int scrnum = 0; + Window root = RootWindow( dpy, scrnum ); + + if (win) + return 0; + + if (!dpy) { + dpy = XOpenDisplay(NULL); + if (!dpy) { + printf("Error: XOpenDisplay failed\n"); + exit(1); + } + } + + if (!visinfo) { + int attrib[] = {GLX_RGBA, + GLX_RED_SIZE, 1, + GLX_GREEN_SIZE, 1, + GLX_BLUE_SIZE, 1, + GLX_DEPTH_SIZE, 1, + GLX_DOUBLEBUFFER, + None }; + + + visinfo = glXChooseVisual( dpy, scrnum, attrib ); + if (!visinfo) { + printf("Error: couldn't get an RGB, Double-buffered visual\n"); + exit(1); + } + } + + /* window attributes */ + attr.background_pixel = 0; + attr.border_pixel = 0; + attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone); + attr.event_mask = StructureNotifyMask | ExposureMask; + mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; + + win = XCreateWindow( dpy, root, 0, 0, g_width, g_height, + 0, visinfo->depth, InputOutput, + visinfo->visual, mask, &attr ); + if (!win) { + printf("Error: XCreateWindow failed\n"); + exit(1); + } + + ctx = glXCreateContext( dpy, visinfo, NULL, True ); + if (!ctx) { + printf("Error: glXCreateContext failed\n"); + exit(1); + } + + if (!glXMakeCurrent( dpy, win, ctx )) { + printf("Error: glXMakeCurrent failed\n"); + exit(1); + } + + if (!(g_display_mode & GLUT_DOUBLE)) + glDrawBuffer( GL_FRONT ); + + + XMapWindow( dpy, win ); + +#if !USE_MINI_GLX + { + XEvent e; + while (1) { + XNextEvent( dpy, &e ); + if (e.type == MapNotify && e.xmap.window == win) { + break; + } + } + } +#endif + + return 1; +} + + +int APIENTRY glutCreateSubWindow (int win, int x, int y, int width, int height) +{ + return GL_FALSE; +} + + +void APIENTRY glutDestroyWindow (int idx) +{ + if (dpy && win) + XDestroyWindow( dpy, win ); + + if (dpy) + XCloseDisplay( dpy ); + + win = 0; + dpy = 0; +} + + +void APIENTRY glutPostRedisplay (void) +{ + g_redisplay = GL_TRUE; +} + + +void APIENTRY glutSwapBuffers (void) +{ +/* if (g_mouse) pc_scare_mouse(); */ + if (dpy && win) glXSwapBuffers( dpy, win ); +/* if (g_mouse) pc_unscare_mouse(); */ +} + + +int APIENTRY glutGetWindow (void) +{ + return 0; +} + + +void APIENTRY glutSetWindow (int win) +{ +} + + +void APIENTRY glutSetWindowTitle (const char *title) +{ +} + + +void APIENTRY glutSetIconTitle (const char *title) +{ +} + + +void APIENTRY glutPositionWindow (int x, int y) +{ +} + + +void APIENTRY glutReshapeWindow (int width, int height) +{ +} + + +void APIENTRY glutPopWindow (void) +{ +} + + +void APIENTRY glutPushWindow (void) +{ +} + + +void APIENTRY glutIconifyWindow (void) +{ +} + + +void APIENTRY glutShowWindow (void) +{ +} + + +void APIENTRY glutHideWindow (void) +{ +} + +void APIENTRY glutMainLoop (void) +{ + GLboolean idle; + GLboolean have_event; + XEvent evt; + int visible = 0; + + glutPostRedisplay(); + if (reshape_func) reshape_func(g_width, g_height); + + while (GL_TRUE) { + idle = GL_TRUE; + + + if (visible && idle_func) + have_event = XCheckMaskEvent( dpy, ~0, &evt ); + else + have_event = XNextEvent( dpy, &evt ); + + if (have_event) { + idle = GL_FALSE; + switch(evt.type) { + case MapNotify: + if (visibility_func) { + visibility_func(GLUT_VISIBLE); + } + visible = 1; + break; + case UnmapNotify: + if (visibility_func) { + visibility_func(GLUT_NOT_VISIBLE); + } + visible = 0; + break; + case Expose: + g_redisplay = 1; + break; + } + } + + if (visible && g_redisplay && display_func) { + idle = GL_FALSE; + g_redisplay = GL_FALSE; + + display_func(); + } + + if (visible && idle && idle_func) { + idle_func(); + } + } +} diff --git a/src/glut/os2/Makefile b/src/glut/os2/Makefile new file mode 100644 index 000000000..56ad4e4c4 --- /dev/null +++ b/src/glut/os2/Makefile @@ -0,0 +1,420 @@ +# Makefile +# Created by IBM WorkFrame/2 MakeMake at 12:46:25 on 3 June 2003 +# +# The actions included in this make file are: +# Compile::C++ Compiler +# Link::Linker +# Lib::Import Lib + +.SUFFIXES: + +.SUFFIXES: \ + .LIB .cpp .dll .obj + +.cpp.obj: + @echo " Compile::C++ Compiler " + icc.exe /I..\ /I..\X86 /I..\GL /I..\swrast /I..\swrast_setup /Ss /Wcmpcndcnscnvcpydclenuextgeninilanobsordparporppcprorearettrdtruund /Tx /O /Gm /Ge- /G5 /Gf /Gi /Oi /C %s + +{G:\EVGEN\MESA5\src-glut.os2pm}.cpp.obj: + @echo " Compile::C++ Compiler " + icc.exe /I..\ /I..\X86 /I..\GL /I..\swrast /I..\swrast_setup /Ss /Wcmpcndcnscnvcpydclenuextgeninilanobsordparporppcprorearettrdtruund /Tx /O /Gm /Ge- /G5 /Gf /Gi /Oi /C %s + +.dll.LIB: + @echo " Lib::Import Lib " + implib.exe %|dpfF.LIB %s + +{G:\EVGEN\MESA5\src-glut.os2pm}.dll.LIB: + @echo " Lib::Import Lib " + implib.exe %|dpfF.LIB %s + +all: \ + .\libGlut.LIB + +.\libGlut.dll: \ + .\os2_winproc.obj \ + .\WarpWin.obj \ + .\glutOverlay.obj \ + .\glut_8x13.obj \ + .\glut_9x15.obj \ + .\glut_bitmap.obj \ + .\glut_cindex.obj \ + .\glut_cmap.obj \ + .\glut_cursor.obj \ + .\glut_event.obj \ + .\glut_ext.obj \ + .\glut_fullscrn.obj \ + .\glut_gamemode.obj \ + .\glut_get.obj \ + .\glut_hel10.obj \ + .\glut_hel12.obj \ + .\glut_hel18.obj \ + .\glut_init.obj \ + .\glut_input.obj \ + .\glut_key.obj \ + .\glut_keyctrl.obj \ + .\glut_keyup.obj \ + .\glut_mesa.obj \ + .\glut_modifier.obj \ + .\glut_roman.obj \ + .\glut_shapes.obj \ + .\glut_stroke.obj \ + .\glut_swap.obj \ + .\glut_teapot.obj \ + .\glut_tr24.obj \ + .\glut_util.obj \ + .\glut_vidresize.obj \ + .\glut_warp.obj \ + .\glut_win.obj \ + .\glut_winmisc.obj \ + .\os2_glx.obj \ + .\os2_menu.obj \ + ..\si-glu\libGLU.lib \ + ..\MesaDll\MesaGL2.lib \ + ..\drv\DrvLoad\MesaDrvLoad.lib \ + {$(LIB)}libGlut.DEF + @echo " Link::Linker " + icc.exe @<< + /B" /dbgpack /exepack:2 /st:200000 /packd /optfunc" + /FelibGlut.dll + ..\si-glu\libGLU.lib + ..\MesaDll\MesaGL2.lib + ..\drv\DrvLoad\MesaDrvLoad.lib + libGlut.DEF + .\os2_winproc.obj + .\WarpWin.obj + .\glutOverlay.obj + .\glut_8x13.obj + .\glut_9x15.obj + .\glut_bitmap.obj + .\glut_cindex.obj + .\glut_cmap.obj + .\glut_cursor.obj + .\glut_event.obj + .\glut_ext.obj + .\glut_fullscrn.obj + .\glut_gamemode.obj + .\glut_get.obj + .\glut_hel10.obj + .\glut_hel12.obj + .\glut_hel18.obj + .\glut_init.obj + .\glut_input.obj + .\glut_key.obj + .\glut_keyctrl.obj + .\glut_keyup.obj + .\glut_mesa.obj + .\glut_modifier.obj + .\glut_roman.obj + .\glut_shapes.obj + .\glut_stroke.obj + .\glut_swap.obj + .\glut_teapot.obj + .\glut_tr24.obj + .\glut_util.obj + .\glut_vidresize.obj + .\glut_warp.obj + .\glut_win.obj + .\glut_winmisc.obj + .\os2_glx.obj + .\os2_menu.obj +<< + +.\os2_winproc.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\os2_winproc.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h \ + gl\os2mesa.h \ + gl\gl.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}gl_mangle.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}GL/os2_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}os2_config.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}os2mesadef.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}context.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glapi.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}mtypes.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glheader.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}config.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glapitable.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glthread.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}math/m_matrix.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}Trace/tr_context.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}dd.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}conf.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}GL/os2_config.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}GL/glext.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}Xthreads.h + +.\os2_menu.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\os2_menu.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\os2_glx.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\os2_glx.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + gl\os2mesa.h \ + gl\gl.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}gl_mangle.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}GL/os2_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}os2_config.h + +.\glut_winmisc.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_winmisc.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_win.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_win.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutos2.h \ + gl\os2mesa.h \ + gl\gl.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}gl_mangle.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}GL/os2_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}os2_config.h + +.\glut_warp.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_warp.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_vidresize.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_vidresize.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_util.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_util.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_tr24.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_tr24.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h + +.\glut_teapot.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_teapot.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_swap.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_swap.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_stroke.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_stroke.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutstroke.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_shapes.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_shapes.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_roman.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_roman.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutstroke.h + +.\glut_modifier.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_modifier.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_mesa.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_mesa.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_keyup.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_keyup.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_keyctrl.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_keyctrl.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_key.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_key.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_input.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_input.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_init.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_init.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_hel18.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_hel18.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h + +.\glut_hel12.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_hel12.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h + +.\glut_hel10.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_hel10.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h + +.\glut_get.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_get.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_gamemode.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_gamemode.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_fullscrn.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_fullscrn.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_ext.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_ext.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_event.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_event.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_cursor.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_cursor.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_cmap.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_cmap.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}layerutil.h + +.\glut_cindex.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_cindex.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_bitmap.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_bitmap.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\glut_9x15.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_9x15.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h + +.\glut_8x13.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glut_8x13.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h + +.\glutOverlay.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\glutOverlay.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutint.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutbitmap.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutstroke.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}glutwin32.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_x11.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}win32_glx.h + +.\WarpWin.obj: \ + G:\EVGEN\MESA5\src-glut.os2pm\WarpWin.cpp \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpWin.h \ + {G:\EVGEN\MESA5\src-glut.os2pm;..\;..\X86;..\GL;..\swrast;..\swrast_setup;$(INCLUDE);}WarpGL.h + +.\libGlut.LIB: \ + .\libGlut.dll diff --git a/src/glut/os2/WarpWin.cpp b/src/glut/os2/WarpWin.cpp new file mode 100644 index 000000000..ee746ecc7 --- /dev/null +++ b/src/glut/os2/WarpWin.cpp @@ -0,0 +1,420 @@ +/* WarpWin.c */ +/* glut for Warp */ +#include +#include + +#include "WarpWin.h" +#include "WarpGL.h" + +#define POKA 0 + +/* global variables that must be set for some functions to operate + correctly. */ +HDC XHDC; +HWND XHWND; + + +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. */ + + LONG pe; + ULONG cclr; + int r,g,b; + /* X11 stores color from 0-65535, Win32 expects them to be 0-256, so + twiddle the bits ( / 256). */ + r = color->red / 256; + g = color->green / 256; + b = color->blue / 256; + pe = LONGFromRGB(r,g,b); + /* 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 |= (PC_NOCOLLAPSE<<24); +/* This function changes the entries in a palette. */ +#if POKA +OS2: + rc = GpiSetPaletteEntries(colormap,LCOLF_CONSECRGB, color->pixel, 1, &pe); + GpiSelectPalette(hps,colormap); + WinRealizePalette(hwnd,hps,&cclr); +source Win: + if (XHDC) { + UnrealizeObject(colormap); + SelectPalette(XHDC, colormap, FALSE); + RealizePalette(XHDC); + + } +#endif +} + +void +XSetWindowColormap(Display* display, Window window, Colormap colormap) +{ +#if POKA + 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! */ +#endif +} + + +/* display, root and visual - don't used at all */ +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! */ + + HPAL palette; + int n; +#if POKA + PIXELFORMATDESCRIPTOR pfd; + LOGPALETTE *logical; + + /* 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); +#endif /* POKA */ + + return palette; +} + + + +int GetSystemMetrics( int mode) +{ RECTL rect; + + switch(mode) + { case SM_CXSCREEN: + WinQueryWindowRect(HWND_DESKTOP,&rect); + return (rect.xRight-rect.xLeft); + break; + case SM_CYSCREEN: + WinQueryWindowRect(HWND_DESKTOP,&rect); + return (rect.yTop-rect.yBottom); + break; + default: ; + } + return 0; +} +/* + * XParseGeometry parses strings of the form + * "=x{+-}{+-}", 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); +} + +int gettimeofday(struct timeval* tp, void* tzp) +{ + DATETIME DateTime; + APIRET ulrc; /* Return Code. */ + + ulrc = DosGetDateTime(&DateTime); + tp->tv_sec = 60 * (60*DateTime.hours + DateTime.minutes) + DateTime.seconds; + tp->tv_usec = DateTime.hundredths * 10000; + return 0; +} + + +int +XPending(Display* display) +{ + /* similar functionality...I don't think that it is exact, but this + will have to do. */ + QMSG msg; + extern HAB hab; /* PM anchor block handle */ + +//?? WinPeekMsg(hab + return WinPeekMsg(hab, &msg, NULLHANDLE, 0, 0, PM_NOREMOVE); +} + +void +__glutAdjustCoords(Window parent, int* x, int* y, int* width, int* height) +{ + RECTL 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.xLeft = *x; rect.yTop = *y; + rect.xRight = *x + *width; rect.yBottom = *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.xLeft < 0) { + *x = 0; + } else { + *x = rect.xLeft; + } + + if(rect.yTop < 0) { + *y = 0; + } else { + *y = rect.yTop; + } + + *width = rect.xRight - rect.xLeft; /* adjusted width */ + *height = -(rect.yBottom - rect.yTop); /* adjusted height */ +} + + +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; +} + +/* Translate point coordinates src_x and src_y from src to dst */ + +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) +{ + SWP swp_src,swp_dst; + + WinQueryWindowPos(src,&swp_src); + WinQueryWindowPos(dst,&swp_dst); + + *dest_x_return = src_x + swp_src.x - swp_dst.x; + *dest_y_return = src_y + swp_src.y - swp_dst.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. */ + SWP swp_src; + WinQueryWindowPos(window,&swp_src); + + *x_return = swp_src.x; + *y_return = swp_src.y; + *width_return = swp_src.cx; + *height_return = swp_src.cy; + + /* just to make compilers happy...we don't use the return value. */ + return 1; +} + +/* Get Display Width in millimeters */ +int +DisplayWidthMM(Display* display, int screen) +{ + int width; + LONG *pVC_Caps; + pVC_Caps = GetVideoConfig(NULLHANDLE); + width = (int)( 0.001 * pVC_Caps[CAPS_WIDTH] / pVC_Caps[CAPS_HORIZONTAL_RESOLUTION]);/* mm */ + return width; +} + +/* Get Display Height in millimeters */ +int +DisplayHeightMM(Display* display, int screen) +{ + int height; + LONG *pVC_Caps; + pVC_Caps = GetVideoConfig(NULLHANDLE); + height = (int)( 0.001 * pVC_Caps[CAPS_HEIGHT] / pVC_Caps[CAPS_VERTICAL_RESOLUTION]); /* mm */ + return height; +} + +void ScreenToClient( HWND hwnd, POINTL *point) +{ + SWP swp_src; + WinQueryWindowPos(hwnd,&swp_src); + point->x -= swp_src.x; + point->y -= swp_src.y; +} + + \ No newline at end of file diff --git a/src/glut/os2/glutOverlay.cpp b/src/glut/os2/glutOverlay.cpp new file mode 100644 index 000000000..563708de2 --- /dev/null +++ b/src/glut/os2/glutOverlay.cpp @@ -0,0 +1,133 @@ +/*********************************************************** + * Copyright (C) 1997, Be Inc. All rights reserved. + * + * FILE: glutOverlay.cpp + * + * DESCRIPTION: we don't support overlays, so this code is + * really simple + ***********************************************************/ + +/*********************************************************** + * Headers + ***********************************************************/ +#include +#include "glutint.h" +#include "glutbitmap.h" +#include "glutstroke.h" + +GLUTAPI void GLUTAPIENTRY +glutEstablishOverlay(void) +{ + __glutFatalError("OS2PM lacks overlay support."); +} + +GLUTAPI void GLUTAPIENTRY +glutUseLayer(GLenum layer) { + // ignore +} + +GLUTAPI void GLUTAPIENTRY +glutRemoveOverlay(void) { + // ignore +} + +GLUTAPI void GLUTAPIENTRY +glutPostOverlayRedisplay(void) { + // ignore +} + +GLUTAPI void GLUTAPIENTRY +glutShowOverlay(void) { + // ignore +} + +GLUTAPI void GLUTAPIENTRY glutHideOverlay(void) +{ + // ignore +} + +int GLUTAPIENTRY +glutLayerGet(GLenum param) +{ + // ignore +} + +/*********************************************************** + * Unsupported callbacks + ***********************************************************/ +GLUTAPI void GLUTAPIENTRY +glutOverlayDisplayFunc(GLUTdisplayCB displayFunc) +{ +} + +GLUTAPI void GLUTAPIENTRY +glutSpaceballMotionFunc(GLUTspaceMotionCB spaceMotionFunc) +{ +} + +GLUTAPI void GLUTAPIENTRY +glutSpaceballRotateFunc(GLUTspaceRotateCB spaceRotateFunc) +{ +} + +GLUTAPI void GLUTAPIENTRY +glutSpaceballButtonFunc(GLUTspaceButtonCB spaceButtonFunc) +{ +} + +GLUTAPI void GLUTAPIENTRY +glutButtonBoxFunc(GLUTbuttonBoxCB buttonBoxFunc) +{ +} + +GLUTAPI void GLUTAPIENTRY +glutDialsFunc(GLUTdialsCB dialsFunc) +{ +} + +GLUTAPI void GLUTAPIENTRY +glutTabletMotionFunc(GLUTtabletMotionCB tabletMotionFunc) +{ +} + +GLUTAPI void GLUTAPIENTRY +glutTabletButtonFunc(GLUTtabletButtonCB tabletButtonFunc) +{ +} +GLUTAPI void GLUTAPIENTRY +glutPostWindowOverlayRedisplay(int win) +{ // +} + +void GLUTAPIENTRY +glutInitDisplayString(const char *string) +{ // +} +void GLUTAPIENTRY +glutJoystickFunc(GLUTjoystickCB joystickFunc, int pollInterval) +{ // +} + +void GLUTAPIENTRY +glutForceJoystickFunc(void) +{ // +} + + +int GLUTAPIENTRY +glutBitmapWidth(GLUTbitmapFont font, int c) +{ return 0; +} +int GLUTAPIENTRY +glutBitmapLength(GLUTbitmapFont font, const unsigned char *string) +{ // + return 0; +} +int GLUTAPIENTRY +glutStrokeWidth(GLUTstrokeFont font, int c) +{ return 0; +} +int GLUTAPIENTRY +glutStrokeLength(GLUTstrokeFont font, const unsigned char *string) +{ return 0; +} diff --git a/src/glut/os2/glut_8x13.cpp b/src/glut/os2/glut_8x13.cpp new file mode 100644 index 000000000..e361e17cb --- /dev/null +++ b/src/glut/os2/glut_8x13.cpp @@ -0,0 +1,2076 @@ + +/* 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, +}; + +#if !defined(__IBMCPP__) +const +#endif +BitmapFontRec glutBitmap8By13 = { +"-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1", +256, +0, +chars +}; + diff --git a/src/glut/os2/glut_9x15.cpp b/src/glut/os2/glut_9x15.cpp new file mode 100644 index 000000000..a3a02a4c5 --- /dev/null +++ b/src/glut/os2/glut_9x15.cpp @@ -0,0 +1,2077 @@ + +/* 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, +}; +#if !defined(__IBMCPP__) +const +#endif + BitmapFontRec glutBitmap9By15 = { +"-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1", +256, +0, +chars +}; + diff --git a/src/glut/os2/glut_bitmap.cpp b/src/glut/os2/glut_bitmap.cpp new file mode 100644 index 000000000..789a89ae7 --- /dev/null +++ b/src/glut/os2/glut_bitmap.cpp @@ -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 GLUTAPIENTRY +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/os2/glut_cindex.cpp b/src/glut/os2/glut_cindex.cpp new file mode 100644 index 000000000..0897a3cf8 --- /dev/null +++ b/src/glut/os2/glut_cindex.cpp @@ -0,0 +1,259 @@ + +/* 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 +#include "glutint.h" + +#if defined(__OS2PM__) + #define IsWindowVisible WinIsWindowVisible +#endif + +#define CLAMP(i) ((i) > 1.0 ? 1.0 : ((i) < 0.0 ? 0.0 : (i))) + +/* CENTRY */ +void GLUTAPIENTRY +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) || defined(__OS2PM__) + 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) || defined(__OS2PM__) + 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) && !defined(__OS2PM__) + { + 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) || defined(__OS2PM__) + if (IsWindowVisible(__glutCurrentWindow->win)) { + XHDC = __glutCurrentWindow->hdc; + } else { + XHDC = 0; + } +#endif + XStoreColor(__glutDisplay, cmap->cmap, &color); +} + +GLfloat GLUTAPIENTRY +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) || defined(__OS2PM__) +#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 GLUTAPIENTRY +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) && !defined(__OS2PM__) + /* 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) && !defined(__OS2PM__) + __glutPutOnWorkList(__glutToplevelOf(window), GLUT_COLORMAP_WORK); +bla bla bla + + } 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 */ + \ No newline at end of file diff --git a/src/glut/os2/glut_cmap.cpp b/src/glut/os2/glut_cmap.cpp new file mode 100644 index 000000000..d5b8d436a --- /dev/null +++ b/src/glut/os2/glut_cmap.cpp @@ -0,0 +1,399 @@ + +/* 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. */ + +#ifdef __VMS +//EK#include +#endif + +#include +#include +#include /* SunOS multithreaded assert() needs . Lame. */ +#include +#if !defined(_WIN32) && !defined(__OS2__) + #include + #include + #include /* for XA_RGB_DEFAULT_MAP atom */ + #if defined(__vms) + #include /* for XmuLookupStandardColormap */ + #else + #include /* 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 +#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) || defined(__OS2__) + 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) || defined(__OS2__) + 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) && !defined(__OS2__) + 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) || defined(__OS2__) + 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) && !defined(__OS2__) +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/os2/glut_cursor.cpp b/src/glut/os2/glut_cursor.cpp new file mode 100644 index 000000000..9784e9b62 --- /dev/null +++ b/src/glut/os2/glut_cursor.cpp @@ -0,0 +1,210 @@ + +/* 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) && !defined(__OS2PM__) +#include /* For XA_CURSOR */ +#include +#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) && !defined(__OS2PM__) +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 && !__OS2PM__*/ + +/* 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 = 0; + + 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); + } + +#elif defined(__OS2PM__) +//todo + xcursor = None; + +#else + xcursor = None; +#endif + break; + case GLUT_CURSOR_NONE: +#if defined(_WIN32) || defined(__OS2PM__) + xcursor = NULL; +#else + if (blankCursor == None) { + blankCursor = makeBlankCursor(); + } + xcursor = blankCursor; +#endif + break; + case GLUT_CURSOR_FULL_CROSSHAIR: +#if defined(_WIN32) + xcursor = (HICON) IDC_CROSS; +#elif defined(__OS2PM__) +//todo +#else + if (fullCrosshairCusor == None) { + fullCrosshairCusor = getFullCrosshairCursor(); + } + xcursor = fullCrosshairCusor; +#endif + break; + } + } + XDefineCursor(__glutDisplay, + window->win, xcursor); + XFlush(__glutDisplay); +} + +/* CENTRY */ +void GLUTAPIENTRY +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); + } +#elif defined(__OS2PM__) +//todo +#else + __glutCurrentWindow->cursor = cursor; + __glutSetCursor(__glutCurrentWindow); +#endif +} +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_event.cpp b/src/glut/os2/glut_event.cpp new file mode 100644 index 000000000..c556ef282 --- /dev/null +++ b/src/glut/os2/glut_event.cpp @@ -0,0 +1,1399 @@ +/* glut_event.c */ +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include +#include /* 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 . */ + +#if !defined(_WIN32) +# ifdef __sgi +# include /* prototype for bzero used by FD_ZERO */ +# endif +# if (defined(SVR4) || defined(CRAY) || defined(AIXV3)) && !defined(FD_SETSIZE) +# include /* select system call interface */ +# ifdef luna +# include +# endif +# endif + /* AIX 4.2 fubar-ed , so go to heroic measures to get it */ +# if defined(AIXV4) && !defined(NFDBITS) +# include +# endif +#endif /* !_WIN32 */ + +#include + +#if defined(__OS2__) +//??? нафига ?? # include +#elif !defined(_WIN32) +# if defined(__vms) && ( __VMS_VER < 70000000 ) +# include +# else +# ifndef __vms +# include +# endif +# endif +# include +# include +# include +#else +# ifdef __CYGWIN32__ +# include +# else +# include +# endif +# ifdef __hpux + /* XXX Bert Gijsbers 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 +# endif +#endif /* !_WIN32 */ + +#include "glutint.h" + +#if defined(__vms) && ( __VMS_VER < 70000000 ) +#include +#include +extern int SYS$CLREF(int efn); +extern int SYS$SETIMR(unsigned int efn, struct timeval6 *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 */ + +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) && !defined(__OS2__) +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 GLUTAPIENTRY +glutIdleFunc(GLUTidleCB idleFunc) +{ + __glutIdleFunc = idleFunc; +} + +void GLUTAPIENTRY +glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value) +{ + GLUTtimer *timer, *other; + GLUTtimer **prevptr; +#ifdef OLD_VMS + struct timeval6 now; +#else + struct timeval now; +#endif + + 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) +{ +#ifdef OLD_VMS + struct timeval6 now; +#else + struct timeval now; +#endif + 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 GLUTAPIENTRY +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 GLUTAPIENTRY +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) && !defined(__OS2__) + +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; + } +#ifndef VMS + /* the combination ConectionNumber-select is buggy on VMS. Sometimes it + * fails. This part of the code hangs the program on VMS7.2. But even + * without it the program seems to run correctly. + * Note that this is a bug in the VMS/DECWindows run-time-libraries. + * Compaq engeneering does not want or is not able to make a fix. + * (last sentence is a quotation from Compaq when I reported the + * problem January 2000) */ + 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 + } +} + +#endif + +static void +processEventsAndTimeouts(void) +{ + do { +#if defined(__OS2__) + QMSG qmsg; /* message from message queue */ + extern HAB hab; /* PM anchor block handle */ + + if(! WinGetMsg( hab, &qmsg, 0UL, 0UL, 0UL ) ) + exit(0); + WinDispatchMsg( hab, /* PM anchor block handle */ + &qmsg ); /* pointer to message */ + +#elif 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 timeval6 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(__OS2__) + +#elif !defined(_WIN32) + fd_set fds; +#endif +#endif +#ifdef OLD_VMS + struct timeval6 now, timeout, waittime; +#else + struct timeval now, timeout, waittime; +#endif +#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(__OS2__) + +#elif !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(__OS2__) + DosSleep(0); +#elif !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) && !defined(__OS2__) + /* 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(__OS2__) + RECTL changes; + +#elif 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) && !defined(__OS2__) + /* 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 GLUTAPIENTRY +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/os2/glut_ext.cpp b/src/glut/os2/glut_ext.cpp new file mode 100644 index 000000000..feb6fbfa2 --- /dev/null +++ b/src/glut/os2/glut_ext.cpp @@ -0,0 +1,204 @@ + +/* 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 +#include + +#include "glutint.h" + +/* CENTRY */ +int GLUTAPIENTRY +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; +} + + +struct name_address_pair { + const char *name; + const void *address; +}; + +static struct name_address_pair glut_functions[] = { + { "glutInit", (const void *) glutInit }, + { "glutInitDisplayMode", (const void *) glutInitDisplayMode }, + { "glutInitDisplayString", (const void *) glutInitDisplayString }, + { "glutInitWindowPosition", (const void *) glutInitWindowPosition }, + { "glutInitWindowSize", (const void *) glutInitWindowSize }, + { "glutMainLoop", (const void *) glutMainLoop }, + { "glutCreateWindow", (const void *) glutCreateWindow }, + { "glutCreateSubWindow", (const void *) glutCreateSubWindow }, + { "glutDestroyWindow", (const void *) glutDestroyWindow }, + { "glutPostRedisplay", (const void *) glutPostRedisplay }, + { "glutPostWindowRedisplay", (const void *) glutPostWindowRedisplay }, + { "glutSwapBuffers", (const void *) glutSwapBuffers }, + { "glutGetWindow", (const void *) glutGetWindow }, + { "glutSetWindow", (const void *) glutSetWindow }, + { "glutSetWindowTitle", (const void *) glutSetWindowTitle }, + { "glutSetIconTitle", (const void *) glutSetIconTitle }, + { "glutPositionWindow", (const void *) glutPositionWindow }, + { "glutReshapeWindow", (const void *) glutReshapeWindow }, + { "glutPopWindow", (const void *) glutPopWindow }, + { "glutPushWindow", (const void *) glutPushWindow }, + { "glutIconifyWindow", (const void *) glutIconifyWindow }, + { "glutShowWindow", (const void *) glutShowWindow }, + { "glutHideWindow", (const void *) glutHideWindow }, + { "glutFullScreen", (const void *) glutFullScreen }, + { "glutSetCursor", (const void *) glutSetCursor }, + { "glutWarpPointer", (const void *) glutWarpPointer }, + { "glutEstablishOverlay", (const void *) glutEstablishOverlay }, + { "glutRemoveOverlay", (const void *) glutRemoveOverlay }, + { "glutUseLayer", (const void *) glutUseLayer }, + { "glutPostOverlayRedisplay", (const void *) glutPostOverlayRedisplay }, + { "glutPostWindowOverlayRedisplay", (const void *) glutPostWindowOverlayRedisplay }, + { "glutShowOverlay", (const void *) glutShowOverlay }, + { "glutHideOverlay", (const void *) glutHideOverlay }, + { "glutCreateMenu", (const void *) glutCreateMenu }, + { "glutDestroyMenu", (const void *) glutDestroyMenu }, + { "glutGetMenu", (const void *) glutGetMenu }, + { "glutSetMenu", (const void *) glutSetMenu }, + { "glutAddMenuEntry", (const void *) glutAddMenuEntry }, + { "glutAddSubMenu", (const void *) glutAddSubMenu }, + { "glutChangeToMenuEntry", (const void *) glutChangeToMenuEntry }, + { "glutChangeToSubMenu", (const void *) glutChangeToSubMenu }, + { "glutRemoveMenuItem", (const void *) glutRemoveMenuItem }, + { "glutAttachMenu", (const void *) glutAttachMenu }, + { "glutDetachMenu", (const void *) glutDetachMenu }, + { "glutDisplayFunc", (const void *) glutDisplayFunc }, + { "glutReshapeFunc", (const void *) glutReshapeFunc }, + { "glutKeyboardFunc", (const void *) glutKeyboardFunc }, + { "glutMouseFunc", (const void *) glutMouseFunc }, + { "glutMotionFunc", (const void *) glutMotionFunc }, + { "glutPassiveMotionFunc", (const void *) glutPassiveMotionFunc }, + { "glutEntryFunc", (const void *) glutEntryFunc }, + { "glutVisibilityFunc", (const void *) glutVisibilityFunc }, + { "glutIdleFunc", (const void *) glutIdleFunc }, + { "glutTimerFunc", (const void *) glutTimerFunc }, + { "glutMenuStateFunc", (const void *) glutMenuStateFunc }, + { "glutSpecialFunc", (const void *) glutSpecialFunc }, + { "glutSpaceballMotionFunc", (const void *) glutSpaceballMotionFunc }, + { "glutSpaceballRotateFunc", (const void *) glutSpaceballRotateFunc }, + { "glutSpaceballButtonFunc", (const void *) glutSpaceballButtonFunc }, + { "glutButtonBoxFunc", (const void *) glutButtonBoxFunc }, + { "glutDialsFunc", (const void *) glutDialsFunc }, + { "glutTabletMotionFunc", (const void *) glutTabletMotionFunc }, + { "glutTabletButtonFunc", (const void *) glutTabletButtonFunc }, + { "glutMenuStatusFunc", (const void *) glutMenuStatusFunc }, + { "glutOverlayDisplayFunc", (const void *) glutOverlayDisplayFunc }, + { "glutWindowStatusFunc", (const void *) glutWindowStatusFunc }, + { "glutKeyboardUpFunc", (const void *) glutKeyboardUpFunc }, + { "glutSpecialUpFunc", (const void *) glutSpecialUpFunc }, + { "glutJoystickFunc", (const void *) glutJoystickFunc }, + { "glutSetColor", (const void *) glutSetColor }, + { "glutGetColor", (const void *) glutGetColor }, + { "glutCopyColormap", (const void *) glutCopyColormap }, + { "glutGet", (const void *) glutGet }, + { "glutDeviceGet", (const void *) glutDeviceGet }, + { "glutExtensionSupported", (const void *) glutExtensionSupported }, + { "glutGetModifiers", (const void *) glutGetModifiers }, + { "glutLayerGet", (const void *) glutLayerGet }, + { "glutGetProcAddress", (const void *) glutGetProcAddress }, + { "glutBitmapCharacter", (const void *) glutBitmapCharacter }, + { "glutBitmapWidth", (const void *) glutBitmapWidth }, + { "glutStrokeCharacter", (const void *) glutStrokeCharacter }, + { "glutStrokeWidth", (const void *) glutStrokeWidth }, + { "glutBitmapLength", (const void *) glutBitmapLength }, + { "glutStrokeLength", (const void *) glutStrokeLength }, + { "glutWireSphere", (const void *) glutWireSphere }, + { "glutSolidSphere", (const void *) glutSolidSphere }, + { "glutWireCone", (const void *) glutWireCone }, + { "glutSolidCone", (const void *) glutSolidCone }, + { "glutWireCube", (const void *) glutWireCube }, + { "glutSolidCube", (const void *) glutSolidCube }, + { "glutWireTorus", (const void *) glutWireTorus }, + { "glutSolidTorus", (const void *) glutSolidTorus }, + { "glutWireDodecahedron", (const void *) glutWireDodecahedron }, + { "glutSolidDodecahedron", (const void *) glutSolidDodecahedron }, + { "glutWireTeapot", (const void *) glutWireTeapot }, + { "glutSolidTeapot", (const void *) glutSolidTeapot }, + { "glutWireOctahedron", (const void *) glutWireOctahedron }, + { "glutSolidOctahedron", (const void *) glutSolidOctahedron }, + { "glutWireTetrahedron", (const void *) glutWireTetrahedron }, + { "glutSolidTetrahedron", (const void *) glutSolidTetrahedron }, + { "glutWireIcosahedron", (const void *) glutWireIcosahedron }, + { "glutSolidIcosahedron", (const void *) glutSolidIcosahedron }, + { "glutVideoResizeGet", (const void *) glutVideoResizeGet }, + { "glutSetupVideoResizing", (const void *) glutSetupVideoResizing }, + { "glutStopVideoResizing", (const void *) glutStopVideoResizing }, + { "glutVideoResize", (const void *) glutVideoResize }, + { "glutVideoPan", (const void *) glutVideoPan }, + { "glutReportErrors", (const void *) glutReportErrors }, + { "glutIgnoreKeyRepeat", (const void *) glutIgnoreKeyRepeat }, + { "glutSetKeyRepeat", (const void *) glutSetKeyRepeat }, + { "glutForceJoystickFunc", (const void *) glutForceJoystickFunc }, + { "glutGameModeString", (const void *) glutGameModeString }, + { "glutEnterGameMode", (const void *) glutEnterGameMode }, + { "glutLeaveGameMode", (const void *) glutLeaveGameMode }, + { "glutGameModeGet", (const void *) glutGameModeGet }, + { NULL, NULL } +}; + + +/* XXX This isn't an official GLUT function, yet */ +void * GLUTAPIENTRY +glutGetProcAddress(const char *procName) +{ + /* Try GLUT functions first */ + int i; + for (i = 0; glut_functions[i].name; i++) { + if (strcmp(glut_functions[i].name, procName) == 0) + return (void *) glut_functions[i].address; + } + + /* Try core GL functions */ +#if defined(_WIN32) + return (void *) wglGetProcAddress((LPCSTR) procName); + +#elif defined(__OS2PM__) + return (void *) wglGetProcAddress((char *) procName); +#elif defined(GLX_ARB_get_proc_address) + return (void *) glXGetProcAddressARB((const GLubyte *) procName); +#else + return NULL; +#endif +} + + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_fullscrn.cpp b/src/glut/os2/glut_fullscrn.cpp new file mode 100644 index 000000000..d6efb68b3 --- /dev/null +++ b/src/glut/os2/glut_fullscrn.cpp @@ -0,0 +1,38 @@ + +/* 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 + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +glutFullScreen(void) +{ + assert(!__glutCurrentWindow->parent); + IGNORE_IN_GAME_MODE(); +#if !defined(_WIN32) && !defined(__OS2PM__) + 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/os2/glut_gamemode.cpp b/src/glut/os2/glut_gamemode.cpp new file mode 100644 index 000000000..50185d7b9 --- /dev/null +++ b/src/glut/os2/glut_gamemode.cpp @@ -0,0 +1,680 @@ + +/* 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 +#include +#include +#include + +#include "glutint.h" + +#if !defined(_WIN32) && !defined(__OS2__) +#include +#include + +/* 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 +#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 + +#if defined(__OS2__) +void +#else +void __cdecl +#endif +__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 GLUTAPIENTRY +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 = 0, 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 = 0; + + cstr = strpbrk(word, "=>': + 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 GLUTAPIENTRY +glutGameModeString(const char *string) +{ + Criterion *criteria; + int ncriteria; + + initGameModeSupport(); + criteria = parseDisplayString(string, &ncriteria); + currentDm = findMatch(dmodes, ndmodes, criteria, ncriteria); + free(criteria); +} + +int GLUTAPIENTRY +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(¤tDm->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) && !defined(__OS2__) + 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 GLUTAPIENTRY +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; + } +} + \ No newline at end of file diff --git a/src/glut/os2/glut_get.cpp b/src/glut/os2/glut_get.cpp new file mode 100644 index 000000000..c846f4865 --- /dev/null +++ b/src/glut/os2/glut_get.cpp @@ -0,0 +1,232 @@ + +/* 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 +#include /* SunOS 4 needs NULL defined for GETTIMEOFDAY macro. */ +#include "glutint.h" + +/* CENTRY */ +int GLUTAPIENTRY +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; +#ifdef __OS2__ + #define GET_CONFIG(attrib) \ + { if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) \ + glXGetConfig( __glutCurrentWindow->vis, attrib, &value); \ + else \ + glXGetConfig(__glutCurrentWindow->overlay->vis, attrib, &value); \ + } \ + +#else + +#define GET_CONFIG(attrib) { \ + if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \ + glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \ + attrib, &value); \ + } else { \ + glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \ + attrib, &value); \ + } \ +} +#endif + + 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) || defined(__OS2__) + /* 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: + { +#ifdef OLD_VMS + struct timeval6 elapsed, beginning, now; +#else + struct timeval elapsed, beginning, now; +#endif + + __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(__OS2__) + return wglGetPixelFormat(__glutCurrentWindow->hdc); +#elif 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/os2/glut_hel10.cpp b/src/glut/os2/glut_hel10.cpp new file mode 100644 index 000000000..6409f6181 --- /dev/null +++ b/src/glut/os2/glut_hel10.cpp @@ -0,0 +1,1781 @@ + +/* 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, +}; + +#if !defined(__IBMCPP__) +const +#endif +BitmapFontRec glutBitmapHelvetica10 = { +"-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1", +224, +32, +chars +}; + diff --git a/src/glut/os2/glut_hel12.cpp b/src/glut/os2/glut_hel12.cpp new file mode 100644 index 000000000..cbd0548b9 --- /dev/null +++ b/src/glut/os2/glut_hel12.cpp @@ -0,0 +1,1791 @@ + +/* 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, +}; + +#if !defined(__IBMCPP__) +const +#endif +BitmapFontRec glutBitmapHelvetica12 = { +"-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1", +224, +32, +chars +}; + diff --git a/src/glut/os2/glut_hel18.cpp b/src/glut/os2/glut_hel18.cpp new file mode 100644 index 000000000..26f88ec50 --- /dev/null +++ b/src/glut/os2/glut_hel18.cpp @@ -0,0 +1,1900 @@ + +/* 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, +}; + +#if !defined(__IBMCPP__) +const +#endif +BitmapFontRec glutBitmapHelvetica18 = { +"-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1", +224, +32, +chars +}; + diff --git a/src/glut/os2/glut_init.cpp b/src/glut/os2/glut_init.cpp new file mode 100644 index 000000000..da5d0735e --- /dev/null +++ b/src/glut/os2/glut_init.cpp @@ -0,0 +1,451 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include + +#if !defined(_WIN32) && !defined(__OS2__) + #include + #include +#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 +#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(__OS2__) + +MRESULT EXPENTRY GlutWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ); +MRESULT EXPENTRY GlutWindowChildProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ); + + +void __glutOpenOS2Connection(char* display) +{ + static char *classname=NULL; +extern HAB hab; /* PM anchor block handle */ +ERRORID erridErrorCode;/* last error id code */ +int ii; + + /* Make sure we register the window only once. */ + if(classname) + return; + + classname = "GLUT"; + + if ( !WinRegisterClass( hab, /* PM anchor block handle */ + classname,/* window class name */ + GlutWindowProc,/* address of window procedure*/ + CS_SIZEREDRAW, /* |CS_SYNCPAINT size changes cause redrawing */ + 0UL ) ) /* window data */ + { erridErrorCode = WinGetLastError(hab); + ii = erridErrorCode; + return; + } + + classname = "GLUTCHILD"; + + if ( !WinRegisterClass( hab, /* PM anchor block handle */ + classname,/* window class name */ + GlutWindowChildProc,/* address of window procedure*/ + CS_SIZEREDRAW, /* size changes cause redrawing */ + 0UL ) ) /* window data */ + { erridErrorCode = WinGetLastError(hab); + ii = erridErrorCode; + return; + } + + __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 = NULLHANDLE; + + /* 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; +} + +#elif defined(_WIN32) + +#ifdef __BORLANDC__ +#include /* 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 +#ifdef OLD_VMS + __glutInitTime(struct timeval6 *beginning) +#else + __glutInitTime(struct timeval *beginning) +#endif +{ + static int beenhere = 0; +#ifdef OLD_VMS + static struct timeval6 genesis; +#else + static struct timeval genesis; +#endif + + 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 GLUTAPIENTRY +glutInit(int *argcp, char **argv) +{ + char *display = NULL; + char *str, *geometry = NULL; +#ifdef OLD_VMS + struct timeval6 unused; +#else + struct timeval unused; +#endif + 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(__OS2__) + __glutOpenOS2Connection(display); +#elif 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); + + /* check if GLUT_FPS env var is set */ + { + const char *fps = getenv("GLUT_FPS"); + if (fps) { + sscanf(fps, "%d", &__glutFPS); + if (__glutFPS <= 0) + __glutFPS = 5000; /* 5000 milliseconds */ + } + } +} + +#ifdef _WIN32 +void APIENTRY +__glutInitWithExit(int *argcp, char **argv, void (__cdecl *exitfunc)(int)) +{ + __glutExitFunc = exitfunc; + glutInit(argcp, argv); +} +#endif + +/* CENTRY */ +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutInitDisplayMode(unsigned int mask) +{ + __glutDisplayMode = mask; +} + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_input.cpp b/src/glut/os2/glut_input.cpp new file mode 100644 index 000000000..c517fe124 --- /dev/null +++ b/src/glut/os2/glut_input.cpp @@ -0,0 +1,628 @@ + +/* 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 +#include +#include +#include + +#include "glutint.h" +#define POFIG 0 +#if POFIG + +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 */ + +static 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; + JOYCAPS joyCaps; + + memset(&info, 0, sizeof(JOYINFOEX)); + info.dwSize = sizeof(JOYINFOEX); + info.dwFlags = JOY_RETURNALL; + + if (joyGetPosEx(JOYSTICKID1,&info) != JOYERR_NOERROR) { + __glutHasJoystick = 1; + joyGetDevCaps(JOYSTICKID1, &joyCaps, sizeof(joyCaps)); + __glutNumJoystickButtons = joyCaps.wNumButtons; + __glutNumJoystickAxes = joyCaps.wNumAxes; + } else { + __glutHasJoystick = 0; + __glutNumJoystickButtons = 0; + __glutNumJoystickAxes = 0; + } + } +#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 = 0, btns = 0, dials = 0; + 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 */ +} + +#endif //POFIG + +/* CENTRY */ +int GLUTAPIENTRY +glutDeviceGet(GLenum param) +{ +#if POFIG + probeDevices(); +#endif + switch (param) { + case GLUT_HAS_KEYBOARD: + case GLUT_HAS_MOUSE: + /* Assume window system always has mouse and keyboard. */ + return 1; +#if POFIG + 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; +#endif //POFIG + default: + __glutWarning("invalid glutDeviceGet parameter: %d", param); + return -1; + } +} +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_key.cpp b/src/glut/os2/glut_key.cpp new file mode 100644 index 000000000..a1b9919ab --- /dev/null +++ b/src/glut/os2/glut_key.cpp @@ -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 + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +glutKeyboardFunc(GLUTkeyboardCB keyboardFunc) +{ + __glutChangeWindowEventMask(KeyPressMask, + keyboardFunc != NULL || __glutCurrentWindow->special != NULL); + __glutCurrentWindow->keyboard = keyboardFunc; +} + +void GLUTAPIENTRY +glutSpecialFunc(GLUTspecialCB specialFunc) +{ + __glutChangeWindowEventMask(KeyPressMask, + specialFunc != NULL || __glutCurrentWindow->keyboard != NULL); + __glutCurrentWindow->special = specialFunc; +} + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_keyctrl.cpp b/src/glut/os2/glut_keyctrl.cpp new file mode 100644 index 000000000..b0f3a28f7 --- /dev/null +++ b/src/glut/os2/glut_keyctrl.cpp @@ -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 GLUTAPIENTRY +glutIgnoreKeyRepeat(int ignore) +{ + __glutCurrentWindow->ignoreKeyRepeat = ignore; +} + +void GLUTAPIENTRY +glutSetKeyRepeat(int repeatMode) +{ +#if !defined(_WIN32) && !defined(__OS2PM__) + 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/os2/glut_keyup.cpp b/src/glut/os2/glut_keyup.cpp new file mode 100644 index 000000000..ada758e27 --- /dev/null +++ b/src/glut/os2/glut_keyup.cpp @@ -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 + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +glutKeyboardUpFunc(GLUTkeyboardCB keyboardUpFunc) +{ + __glutChangeWindowEventMask(KeyReleaseMask, + keyboardUpFunc != NULL || __glutCurrentWindow->specialUp != NULL); + __glutCurrentWindow->keyboardUp = keyboardUpFunc; +} + +void GLUTAPIENTRY +glutSpecialUpFunc(GLUTspecialCB specialUpFunc) +{ + __glutChangeWindowEventMask(KeyReleaseMask, + specialUpFunc != NULL || __glutCurrentWindow->keyboardUp != NULL); + __glutCurrentWindow->specialUp = specialUpFunc; +} + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_mesa.cpp b/src/glut/os2/glut_mesa.cpp new file mode 100644 index 000000000..73682a506 --- /dev/null +++ b/src/glut/os2/glut_mesa.cpp @@ -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 +#include +#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/os2/glut_modifier.cpp b/src/glut/os2/glut_modifier.cpp new file mode 100644 index 000000000..0ffa5a680 --- /dev/null +++ b/src/glut/os2/glut_modifier.cpp @@ -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 GLUTAPIENTRY +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/os2/glut_roman.cpp b/src/glut/os2/glut_roman.cpp new file mode 100644 index 000000000..8e25de8ac --- /dev/null +++ b/src/glut/os2/glut_roman.cpp @@ -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/os2/glut_shapes.cpp b/src/glut/os2/glut_shapes.cpp new file mode 100644 index 000000000..76b080951 --- /dev/null +++ b/src/glut/os2/glut_shapes.cpp @@ -0,0 +1,595 @@ + +/* 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 +#include "glutint.h" + +/* Some 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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireCube(GLdouble size) +{ + drawBox(size, GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY glutWireDodecahedron(void) +{ + dodecahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireOctahedron(void) +{ + octahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireIcosahedron(void) +{ + icosahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutWireTetrahedron(void) +{ + tetrahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +glutSolidTetrahedron(void) +{ + tetrahedron(GL_TRIANGLES); +} + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_stroke.cpp b/src/glut/os2/glut_stroke.cpp new file mode 100644 index 000000000..4823283c8 --- /dev/null +++ b/src/glut/os2/glut_stroke.cpp @@ -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 GLUTAPIENTRY +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/os2/glut_swap.cpp b/src/glut/os2/glut_swap.cpp new file mode 100644 index 000000000..210a7fc37 --- /dev/null +++ b/src/glut/os2/glut_swap.cpp @@ -0,0 +1,67 @@ + +/* 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 +#include "glutint.h" + +GLint __glutFPS = 0; +GLint __glutSwapCount = 0; +GLint __glutSwapTime = 0; + +/* CENTRY */ +void GLUTAPIENTRY +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. */ + + if (__glutFPS) { + GLint t = glutGet(GLUT_ELAPSED_TIME); + __glutSwapCount++; + if (__glutSwapTime == 0) + __glutSwapTime = t; + else if (t - __glutSwapTime > __glutFPS) { + float time = 0.001 * (t - __glutSwapTime); + float fps = (float) __glutSwapCount / time; + fprintf(stderr, "GLUT: %d frames in %.2f seconds = %.2f FPS\n", + __glutSwapCount, time, fps); + __glutSwapTime = t; + __glutSwapCount = 0; + } + } +} +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_teapot.cpp b/src/glut/os2/glut_teapot.cpp new file mode 100644 index 000000000..e2fcb5315 --- /dev/null +++ b/src/glut/os2/glut_teapot.cpp @@ -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 GLUTAPIENTRY +glutSolidTeapot(GLdouble scale) +{ + teapot(7, scale, GL_FILL); +} + +void GLUTAPIENTRY +glutWireTeapot(GLdouble scale) +{ + teapot(10, scale, GL_LINE); +} + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_tr24.cpp b/src/glut/os2/glut_tr24.cpp new file mode 100644 index 000000000..9e1234644 --- /dev/null +++ b/src/glut/os2/glut_tr24.cpp @@ -0,0 +1,2063 @@ + +/* 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, +}; + +#if !defined(__IBMCPP__) +const +#endif +BitmapFontRec glutBitmapTimesRoman24 = { +"-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1", +224, +32, +chars +}; + diff --git a/src/glut/os2/glut_util.cpp b/src/glut/os2/glut_util.cpp new file mode 100644 index 000000000..76f25020a --- /dev/null +++ b/src/glut/os2/glut_util.cpp @@ -0,0 +1,90 @@ + +/* 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 +#include +#include +#include + +#include "glutint.h" + +#if !defined(__OS2__) + +/* 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; +} +#endif + +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 GLUTAPIENTRY +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); +/* || defined(__OS2__) */ +#if defined(_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/os2/glut_vidresize.cpp b/src/glut/os2/glut_vidresize.cpp new file mode 100644 index 000000000..f9d345dcf --- /dev/null +++ b/src/glut/os2/glut_vidresize.cpp @@ -0,0 +1,232 @@ + +/* 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 + +#ifdef __sgi +#include +#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. */ +#if 0 +#ifdef GLX_SYNC_FRAME_SGIX +#define GLX_SGIX_video_resize 1 +#endif +#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 int +catchXSGIvcErrors(Display * dpy, XErrorEvent * event) +{ + errorCaught = 1; + return 0; +} +#endif + +/* CENTRY */ + +int GLUTAPIENTRY +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 defined(__sgi) && __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; + +#if defined(GLX_GLXEXT_PROTOTYPES) +#endif + + __glut_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; + + __glut_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 GLUTAPIENTRY +glutSetupVideoResizing(void) +{ +#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize) + if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) { + __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, __glutCurrentWindow->win); + videoResizeInUse = 1; + } else +#endif + __glutFatalError("glutEstablishVideoResizing: video resizing not possible.\n"); +} + +void GLUTAPIENTRY +glutStopVideoResizing(void) +{ +#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize) + if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) { + if (videoResizeInUse) { + __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, None); + videoResizeInUse = 0; + } + } +#endif +} + +/* ARGSUSED */ +void GLUTAPIENTRY +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. */ + __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, GLX_SYNC_SWAP_SGIX); +#endif + __glut_glXChannelRectSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, x, y, width, height); + } +#endif +} + +/* ARGSUSED */ +void GLUTAPIENTRY +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. */ + __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, GLX_SYNC_FRAME_SGIX); +#endif + __glut_glXChannelRectSGIX(__glutDisplay, __glutScreen, + videoResizeChannel, x, y, width, height); + } +#endif +} + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_warp.cpp b/src/glut/os2/glut_warp.cpp new file mode 100644 index 000000000..885e169d3 --- /dev/null +++ b/src/glut/os2/glut_warp.cpp @@ -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 +#include +#include + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +glutWarpPointer(int x, int y) +{ +// XWarpPointer(__glutDisplay, None, __glutCurrentWindow->win, +// 0, 0, 0, 0, x, y); + POINTL point; + point.x = x; + point.y = y; + WinMapWindowPoints(__glutCurrentWindow->win,HWND_DESKTOP,&point,1); + WinSetPointerPos(HWND_DESKTOP, point.x, point.y); + + XFlush(__glutDisplay); +} + +/* ENDCENTRY */ diff --git a/src/glut/os2/glut_win.cpp b/src/glut/os2/glut_win.cpp new file mode 100644 index 000000000..82abba87e --- /dev/null +++ b/src/glut/os2/glut_win.cpp @@ -0,0 +1,1221 @@ + +/* 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. */ + +#ifdef __VMS +#include +#endif + +#include +#include +#include +#include +#if defined(__OS2__) +#define POKA 0 + #include "WarpGL.h" + #include "glutos2.h" + #include "glutint.h" + + #include "gl\os2mesa.h" + +// +//define for resource id for main GLUT window, in samples it is defined in GL_TEST.h + #define ID_WINDOW 256 + + int evglSetPixelFormat(int iPixelFormat); + HPS hpsCurrent; + +#elif !defined(_WIN32) + +#include +#include +#endif + +#include "glutint.h" + +GLUTwindow *__glutCurrentWindow = NULL; +GLUTwindow **__glutWindowList = NULL; +int __glutWindowListSize = 0; +#if !defined(_WIN32) && !defined(__OS2__) +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) && !defined(__OS2PM__) + +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) && !defined(__OS2PM__) + { + 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 GLUTAPIENTRY +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) && !defined(__OS2__) + /* 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 GLUTAPIENTRY +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) +{ +#if POKA + 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; +#else + return + glXChooseVisual(mode); + +#endif +} + +static XVisualInfo * +getVisualInfoRGB(unsigned int mode) +{ +#if POKA + 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) || defined(GLX_ARB_multisample)) + if (GLUT_WIND_IS_MULTISAMPLE(mode)) { + if (!__glutIsSupportedByGLX("GLX_SGIS_multisample") && + !__glutIsSupportedByGLX("GLX_ARB_multisample")) + return NULL; +#if defined(GLX_ARB_multisample) + list[n++] = GLX_SAMPLES_ARB; +#elif defined(GLX_SGIS_multisample) + list[n++] = GLX_SAMPLES_SGIS; +#endif + /* 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); +#else /* POKA */ + + return + glXChooseVisual(mode); + +#endif +} + +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; +} + +static 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(__OS2PM__) + { + extern HAB hab; /* PM anchor block handle */ + CLASSINFO classinfo; + + if(!WinQueryClassInfo(hab,"GLUT", &classinfo) ) + __glutOpenOS2Connection(NULL); + } +#elif defined(_WIN32) + WNDCLASS wc; + int style; + + if (!GetClassInfo(GetModuleHandle(NULL), "GLUT", &wc)) { + __glutOpenWin32Connection(NULL); + } +#else + if (!__glutDisplay) { + __glutOpenXConnection(NULL); + } +#endif + +#ifndef __OS2PM__ + if (__glutGameModeWindow) { + __glutFatalError("cannot create windows in game mode."); + } +#endif + + winnum = getUnusedWindowSlot(); + window = (GLUTwindow *) malloc(sizeof(GLUTwindow)); + if (!window) { + __glutFatalError("out of memory."); + } + window->num = winnum; + +#if defined(__OS2PM__) + /* Add this new window to the window list. */ + __glutWindowList[winnum] = window; + window->shownState = -1; +#endif + +#if !defined(_WIN32) && !defined(__OS2PM__) + 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(__OS2PM__) + + { ULONG flStyle=0; + int ii; + ERRORID erridErrorCode;/* last error id code */ + extern HAB hab; /* PM anchor block handle */ + + if (parent) { + flStyle = WS_CLIPCHILDREN|WS_VISIBLE; + } 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. */ + flStyle = FCF_STANDARD | WS_MAXIMIZED; + } else { + /* A standard toplevel window with borders and such. */ + flStyle = FCF_STANDARD | WS_CLIPCHILDREN; +// flStyle = WS_OVERLAPPEDWINDOW; + } + } +{ + HWND hwnd; /* Window */ + ULONG ListBoxId; /* Window id */ + /* (supplied by application) */ + + + HWND hwndClient; /* handle to the client */ + HWND hwndFrame; /* handle to the frame */ + PFNWP GenericWndProc; + FRAMECDATA fcd; + RECTL rect; /* Boundary rectangle */ + + + +/************************************************/ +// flCreate = (FCF_STANDARD) & ~FCF_TASKLIST; +/**********************************/ + if (parent) + { window->frame = NULL; + + hwnd = WinCreateWindow(parent->win, /* Parent window */ + "GLUTCHILD", /* Class name */ + "", /* Window text */ + flStyle, /* Window style */ + x, y, /* Position (x,y) */ + width, height, /* Size (width,height) */ + parent->win, /* Owner window */ + HWND_TOP, /* Sibling window */ + 0, /* Window id */ + NULL, /* Control data */ + NULL); /* Pres parameters */ + + erridErrorCode = WinGetLastError(hab); + window->win = hwnd; + + window->hdc = WinOpenWindowDC(window->win); + window->hpsBuffer = hpsCurrent; + + + rect.xLeft = x; + rect.xRight = x+width; + rect.yBottom = y; + rect.yTop = y + height; + +/***** else parent *****************************/ + } else { + hwnd = WinCreateStdWindow(HWND_DESKTOP, + 0, /* WS_VISIBLE frame-window style */ + &flStyle, /* window style */ + "GLUT", /* class name */ + "GLUT",/* window title */ + 0L, /* default client style */ + NULLHANDLE, /* resource in executable file */ + ID_WINDOW, /* resource id */ + &hwndClient); /* receives client window handle */ + + erridErrorCode = WinGetLastError(hab); + window->win = hwndClient; + window->frame = hwnd; + window->hdc = WinOpenWindowDC(window->win); + + window->hpsBuffer = hpsCurrent; + + +/* converts a client window's boundaries into an equivalent frame rectangle */ + rect.xLeft = x; + rect.xRight = x+width; + rect.yBottom = y; + rect.yTop = y + height; + + /* calculate equivalent frame boundary from boundary data */ + WinCalcFrameRect(window->frame, &rect, FALSE); + } +/***** endof if(parent) *****************************/ + + /* Must set the XHDC for fake glXChooseVisual & fake + glXCreateContext & fake XAllocColorCells. */ + XHDC = window->hdc; + XHWND = window->win; + window->vis = __glutDetermineWindowVisual(&window->treatAsSingle, + &window->visAlloced, &fbc); + if (!window->vis) + { __glutFatalError( + "pixel format with necessary capabilities not found."); + } + { int rc; + rc = wglChoosePixelFormat(window->hdc, window->vis), + +// evglSetPixelFormat(2); /* int iPixelFormat 1 - doublebuffer/2 - single buffer ??*/ + wglSetPixelFormat(window->hdc,rc,window->vis); + } + __glutSetupColormap(window->vis, &window->colormap, &window->cmap); + + window->ctx = glXCreateContext(window->hpsBuffer, window->vis, + None, __glutTryDirect); + + WinSetWindowPos(hwnd, + HWND_TOP,rect.xLeft,rect.yBottom, + rect.xRight-rect.xLeft, rect.yTop-rect.yBottom, + SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW|SWP_ZORDER); /* flags*/ + + /* Make sure subwindows get a windowStatus callback. */ + if (parent) + WinPostMsg(parent->win, WM_ACTIVATE, 0, 0); + + } +} + +#elif 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 = __glut_glXCreateContextWithConfigSGIX(__glutDisplay, fbc, + GLX_RGBA_TYPE_SGIX, None, __glutTryDirect); + } else +#endif +#if defined(__OS2PM__) +// window->ctx = glXCreateContext(window->hpsBuffer, window->vis, +// None, __glutTryDirect); +#else + window->ctx = glXCreateContext(__glutDisplay, window->vis, + None, __glutTryDirect); +#endif + if (!window->ctx) { + __glutFatalError( + "failed to create OpenGL rendering context."); + } + window->renderCtx = window->ctx; +#if !defined(_WIN32) && !defined(__OS2PM__) + 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 + +#if defined(__OS2PM__) + window->wm_command = NULL; +#endif + + window->tabletPos[0] = -1; + window->tabletPos[1] = -1; +#if defined(__OS2PM__) + if(window->shownState == -1) + window->shownState = 0; + window->visState = window->shownState; +#else + window->shownState = 0; + window->visState = -1; /* not VisibilityUnobscured, + VisibilityPartiallyObscured, or + VisibilityFullyObscured */ +#endif + 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 GLUTAPIENTRY +glutCreateWindow(const char *title) +{ + static int firstWindow = 1; + GLUTwindow *window; +#if !defined(_WIN32) && !defined(__OS2__) + 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(__OS2__) + WinSetWindowText(window->frame, (PCSZ)title); + if (__glutIconic) { + window->desiredMapState = IconicState; + } +#elif 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 GLUTAPIENTRY +__glutCreateWindowWithExit(const char *title, void (__cdecl *exitfunc)(int)) +{ + __glutExitFunc = exitfunc; + return glutCreateWindow(title); +} +#endif + +int GLUTAPIENTRY +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) && !defined(__OS2__) + { + 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) && !defined(__OS2__) + 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 GLUTAPIENTRY +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) && !defined(__OS2__) + /* 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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutEntryFunc(GLUTentryCB entryFunc) +{ + __glutChangeWindowEventMask(EnterWindowMask | LeaveWindowMask, + entryFunc != NULL || __glutCurrentWindow->passive); + __glutCurrentWindow->entry = entryFunc; + if (!entryFunc) { + __glutCurrentWindow->entryState = -1; + } +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +glutVisibilityFunc(GLUTvisibilityCB visibilityFunc) +{ + __glutCurrentWindow->visibility = visibilityFunc; + + if (visibilityFunc) + { glutWindowStatusFunc(visibilityHelper); +#if defined(__OS2PM__) + if(__glutCurrentWindow->shownState >= 0) + { visibilityHelper(__glutCurrentWindow->shownState); + } +#endif + } + else + glutWindowStatusFunc(NULL); +} + +void GLUTAPIENTRY +glutReshapeFunc(GLUTreshapeCB reshapeFunc) +{ + if (reshapeFunc) { + __glutCurrentWindow->reshape = reshapeFunc; + } else { + __glutCurrentWindow->reshape = __glutDefaultReshape; + } +} + \ No newline at end of file diff --git a/src/glut/os2/glut_winmisc.cpp b/src/glut/os2/glut_winmisc.cpp new file mode 100644 index 000000000..ffa31c021 --- /dev/null +++ b/src/glut/os2/glut_winmisc.cpp @@ -0,0 +1,127 @@ + +/* 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 +#include +#include +#include + + +#include "glutint.h" + +/* CENTRY */ +void GLUTAPIENTRY +glutSetWindowTitle(const char *title) +{ +#if defined(__OS2PM__) + __glutSetWindowText(__glutCurrentWindow->win, (char *)title); + +#else + 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); +#endif +} + +void GLUTAPIENTRY +glutSetIconTitle(const char *title) +{ +#if defined(__OS2PM__) +//todo ? +#else + + 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); +#endif +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutPopWindow(void) +{ + IGNORE_IN_GAME_MODE(); + __glutCurrentWindow->desiredStack = Above; + __glutCurrentWindow->desiredConfMask |= CWStackMode; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK); +} + +void GLUTAPIENTRY +glutPushWindow(void) +{ + IGNORE_IN_GAME_MODE(); + __glutCurrentWindow->desiredStack = Below; + __glutCurrentWindow->desiredConfMask |= CWStackMode; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK); +} + +void GLUTAPIENTRY +glutIconifyWindow(void) +{ + IGNORE_IN_GAME_MODE(); + assert(!__glutCurrentWindow->parent); + __glutCurrentWindow->desiredMapState = IconicState; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK); +} + +void GLUTAPIENTRY +glutShowWindow(void) +{ + IGNORE_IN_GAME_MODE(); + __glutCurrentWindow->desiredMapState = NormalState; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK); +} + +void GLUTAPIENTRY +glutHideWindow(void) +{ + IGNORE_IN_GAME_MODE(); + __glutCurrentWindow->desiredMapState = WithdrawnState; + __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK); +} + +/* ENDCENTRY */ + \ No newline at end of file diff --git a/src/glut/os2/glutbitmap.h b/src/glut/os2/glutbitmap.h new file mode 100644 index 000000000..dc1b61af1 --- /dev/null +++ b/src/glut/os2/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 + +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/os2/glutos2.h b/src/glut/os2/glutos2.h new file mode 100644 index 000000000..533a78011 --- /dev/null +++ b/src/glut/os2/glutos2.h @@ -0,0 +1,36 @@ +#ifndef __glutos2_h__ +#define __glutos2_h__ + + +/* 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 /* __glutos2_h__ */ diff --git a/src/glut/os2/glutstroke.h b/src/glut/os2/glutstroke.h new file mode 100644 index 000000000..fbbc70d6c --- /dev/null +++ b/src/glut/os2/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/os2/layerutil.h b/src/glut/os2/layerutil.h new file mode 100644 index 000000000..3786c4d87 --- /dev/null +++ b/src/glut/os2/layerutil.h @@ -0,0 +1,59 @@ +#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 */ + +#ifdef __VMS +#include +#endif + +#if !defined(_WIN32) && !defined(__OS2__) +#include +#include +#include +#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/os2/libGlut.DEF b/src/glut/os2/libGlut.DEF new file mode 100644 index 000000000..fb92544ab --- /dev/null +++ b/src/glut/os2/libGlut.DEF @@ -0,0 +1,94 @@ + +;----------------------------------------------------- +; def Module definition file for the DLL +;----------------------------------------------------- + +LIBRARY libGlut INITINSTANCE TERMINSTANCE +PROTMODE +DATA MULTIPLE NONSHARED READWRITE LOADONCALL +CODE LOADONCALL +EXPORTS ; Names of exported functions and data + +;********************************* +;MesaGLUT + glutCommandFunc @3001 + glutCreateWindow @3002 + glutCreateSubWindow @3003 + glutDestroyWindow @3004 + glutDisplayFunc @3005 + glutEntryFunc @3006 + glutExtensionSupported @3007 + glutIdleFunc @3008 + glutInit @3009 + glutInitDisplayMode @3010 + glutInitWindowPosition @3011 + glutInitWindowSize @3012 + glutMainLoop @3013 + glutGet @3014 + glutGetColor @3015 + glutGetWindow @3016 + glutKeyboardFunc @3017 + glutMouseFunc @3018 + glutSpecialFunc @3019 + glutStrokeCharacter @3020 + glutSetColor @3021 + glutSetIconTitle @3022 + glutSetWindow @3023 + glutSetWindowTitle @3024 + + glutReshapeFunc @3025 + glutReshapeWindow @3026 + + + glutSwapBuffers @3027 + glutPostRedisplay @3028 + glutPositionWindow @3029 + glutVisibilityFunc @3030 + glutTimerFunc @3031 + glutMotionFunc @3032 + + glutCreateMenu @3033 + glutAttachMenu @3034 + glutDestroyMenu @3035 + glutAddMenuEntry @3036 + glutPassiveMotionFunc @3037 + + glutSolidCone @3038 + glutSolidCube @3039 + glutSolidDodecahedron @3040 + glutSolidOctahedron @3041 + glutSolidIcosahedron @3042 + glutSolidSphere @3043 + glutSolidTeapot @3044 + glutSolidTetrahedron @3045 + glutSolidTorus @3046 + + glutWireCone @3047 + glutWireCube @3048 + glutWireDodecahedron @3049 + glutWireIcosahedron @3050 + glutWireOctahedron @3051 + glutWireSphere @3052 + glutWireTetrahedron @3053 + glutWireTorus @3054 + glutWireTeapot @3055 + +;GL_GLEXT_PROTOTYPES + glutBitmapCharacter @3101 + glutBitmap9By15 @3102 + glutBitmapHelvetica10 @3103 + glutBitmapHelvetica12 @3104 + glutBitmapHelvetica18 @3105 + glutBitmapTimesRoman24 @3106 + glutStrokeRoman @3107 + glutBitmap8By13 @3108 + +;Global constants +; hab @12001 +; /* PM anchor block handle */ +; hpsCurrent @12002 + XHDC @12004 + XHWND @12005 + + + diff --git a/src/glut/os2/os2_glx.cpp b/src/glut/os2/os2_glx.cpp new file mode 100644 index 000000000..ca345ea05 --- /dev/null +++ b/src/glut/os2/os2_glx.cpp @@ -0,0 +1,146 @@ +/* os2_glx.c */ + +#include +#include +#include +#include "gl/gl.h" +#include "WarpGL.h" +#include "GL/os2mesa.h" + +#define POKA 0 +/* global current HDC */ + +XVisualInfo *wglDescribePixelFormat(int iPixelFormat); + +extern HDC XHDC; +extern HWND XHWND; +//extern HPS hpsCurrent; +extern HAB hab; /* PM anchor block handle */ + +GLXContext +glXCreateContext(HPS hps, 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 = wglCreateContext(XHDC,hps,hab); + + + /* Since direct rendering is implicit, the direct flag is + ignored. */ + + return context; +} + + +int +glXGetConfig(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; +#if POKA == 100 +#endif /* POKA == 100 */ + default: + return GLX_BAD_ATTRIB; + } + return 0; +} + + +XVisualInfo * glXChooseVisual(int mode) +{ int imode = 2; + if(mode & GLUT_DOUBLE) + imode = 1; + return + wglDescribePixelFormat(imode); +} + + +#if POKA +#endif /* POKA */ + + \ No newline at end of file diff --git a/src/glut/os2/os2_menu.cpp b/src/glut/os2/os2_menu.cpp new file mode 100644 index 000000000..4eef308e5 --- /dev/null +++ b/src/glut/os2/os2_menu.cpp @@ -0,0 +1,533 @@ + +/* 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 +#include +#include +#include +#include + +#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 GLUTAPIENTRY +glutMenuStateFunc(GLUTmenuStateCB menuStateFunc) +{ + __glutMenuStatusFunc = (GLUTmenuStatusCB) menuStateFunc; +} + +void GLUTAPIENTRY +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) +{ +//todo +// TrackPopupMenu((HMENU) 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 GLUTAPIENTRY +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; +//todo +// menu->win = (HWND) CreatePopupMenu(); + menuList[menuid] = menu; + __glutSetMenu(menu); + return menuid + 1; +} + + +void GLUTAPIENTRY +glutDestroyMenu(int menunum) +{ + GLUTmenu *menu = __glutGetMenuByNum(menunum); + GLUTmenuItem *item, *next; + + if (__glutMappedMenu) { + menuModificationError(); + } + assert(menu->id == menunum - 1); +//todo DestroyMenu( (HMENU) 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 GLUTAPIENTRY +glutGetMenu(void) +{ + if (__glutCurrentMenu) { + return __glutCurrentMenu->id + 1; + } else { + return 0; + } +} + +void GLUTAPIENTRY +glutSetMenu(int menuid) +{ + GLUTmenu *menu; + + if (menuid < 1 || menuid > menuListSize) { + __glutWarning("glutSetMenu attempted on bogus menu."); + return; + } + menu = 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++; +//todo +// if (isTrigger) { +// AppendMenu((HMENU) menu->win, MF_POPUP, (UINT)item->win, label); +// } else { +// AppendMenu((HMENU) menu->win, MF_STRING, item->unique, label); +// } +} + +void GLUTAPIENTRY +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 GLUTAPIENTRY +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 GLUTAPIENTRY +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. */ +//todo +// DestroyMenu((HMENU) 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++; +//todo +// ModifyMenu((HMENU) __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 GLUTAPIENTRY +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++; +//todo +// item->win = (HWND) 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; +//todo +// ModifyMenu((HMENU) __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 GLUTAPIENTRY +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; +//todo +// RemoveMenu((HMENU) __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 GLUTAPIENTRY +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 GLUTAPIENTRY +glutDetachMenu(int button) +{ + if (__glutMappedMenu) { + menuModificationError(); + } + if (__glutCurrentWindow->menu[button] > 0) { + __glutCurrentWindow->buttonUses--; + __glutCurrentWindow->menu[button] = 0; + } +} + + \ No newline at end of file diff --git a/src/glut/os2/os2_winproc.cpp b/src/glut/os2/os2_winproc.cpp new file mode 100644 index 000000000..e2d4ba9d5 --- /dev/null +++ b/src/glut/os2/os2_winproc.cpp @@ -0,0 +1,1297 @@ +/* os2_winproc.c */ + + +#define INCL_DEV +#include "WarpGL.h" +#include "GL/os2mesa.h" + + +#define _MEERROR_H_ +#include /* It is from MMPM toolkit */ +#include +#include + + +#include "os2mesadef.h" +#include "glutint.h" + + +#define POKA 0 + +#if POKA + +extern unsigned __glutMenuButton; +extern GLUTidleCB __glutIdleFunc; +extern GLUTtimer *__glutTimerList; +extern void handleTimeouts(void); +extern GLUTmenuItem *__glutGetUniqueMenuItem(GLUTmenu * menu, int unique); +static HMENU __glutHMenu; + +#endif + +extern void _mesa_ResizeBuffersMESA( void ); + + +MRESULT EXPENTRY GlutWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ); +MRESULT EXPENTRY GlutWindowChildProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ); +void updateWindowState(GLUTwindow *window, int visState); + +volatile extern HAB hab; /* PM anchor block handle */ +volatile extern HPS hpsCurrent; + +RECTL rCtls[52]; +ULONG ulNumRcls; + +MRESULT EXPENTRY GlutWindowChildProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) +{ MRESULT rc; + rc = GlutWindowProc(hwnd, msg, mp1, mp2 ); + return rc; +} + +MRESULT EXPENTRY GlutWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) +{ + HPS hps = NULLHANDLE; /* presentation space handle */ + GLUTwindow* window; /* GLUT window associated with message. */ + GLUTmenu* menu; /* GLUT menu associated with message. */ + RECTL rclClient; + POINTL point; + int button = -1,rc,key; + + +/* Process the message. */ + + switch( msg ) + { + case WM_CREATE: + { + SIZEL sizl = { 0L, 0L }; + LONG *alCaps; + HDC hdc; + + /*+-----------------------------------------------------------------+*/ + /*| The client window is being created. Create the semaphore to |*/ + /*| control access to the presentation space. Then create the |*/ + /*| thread that will draw the lines. |*/ + /*+-----------------------------------------------------------------+*/ + // DosCreateMutexSem( (PSZ)NULL, &hmtxPS, 0UL, FALSE ); + + hdc = WinOpenWindowDC(hwnd); + + /*+-----------------------------------------------------------------+*/ + /*| Create a non-cached presentation space. We will not release |*/ + /*| this PS, as we will be Selecting a Palette to this PS and then |*/ + /*| animating the palette. Upon releasing a PS the palette is no |*/ + /*| longer selected for obvious reasons. |*/ + /*+-----------------------------------------------------------------+*/ + hpsCurrent = GpiCreatePS( hab, + hdc, + &sizl, + PU_PELS | GPIF_DEFAULT | + GPIT_MICRO | GPIA_ASSOC ); +// DevQueryCaps( hdc, lStart, lCount, alCaps ); +// fPaletteCaps = alCaps[CAPS_ADDITIONAL_GRAPHICS] & CAPS_PALETTE_MANAGER; +// PaletteInit(3); + /* пеpевод hpsBuffer в pежим RGB color table */ + + GpiCreateLogColorTable(hpsCurrent,0 ,LCOLF_RGB,0,0,NULL); + GpiSetPattern(hpsCurrent,PATSYM_SOLID); + GpiSetPatternSet(hpsCurrent,LCID_DEFAULT); + + } + break; + + return 0; + case WM_CLOSE: + WinPostMsg( hwnd, WM_QUIT, NULL, NULL ); + + return 0; + + case WM_PAINT: + window = __glutGetWindow(hwnd); + if (window) + { + PWMC ctx; +// hps = WinBeginPaint(hwnd,NULLHANDLE,&rclClient); + hps = WinBeginPaint(hwnd,NULLHANDLE,&rclClient); + // blit Dive buffer to screen. + + { + SWP swp; // Window position + POINTL pointl; // Point to offset from Desktop + + // Convert the point to offset from desktop lower left. + pointl.x = 0; + pointl.y = 0; + WinMapWindowPoints ( hwnd, HWND_DESKTOP, &pointl, 1 ); + + +// ctx = window->ctx; +// ctx->xDiveScr = pointl.x; +// ctx->yDiveScr = pointl.y; + } +// rc = DiveBlitImage (ctx->hDive, +// ctx->ulDiveBufferNumber, +// DIVE_BUFFER_SCREEN ); +// + + if (window->win == hwnd) { + __glutPostRedisplay(window, GLUT_REPAIR_WORK); + } else if (window->overlay && window->overlay->win == hwnd) { + __glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK); + } + WinEndPaint(hps); + } else { + + hps = WinBeginPaint(hwnd,NULLHANDLE,&rclClient); + WinFillRect(hps, &rclClient, CLR_WHITE); + WinEndPaint(hps); + } + break; + + case WM_VRNDISABLED: + +// pwinData->fDataInProcess = TRUE; +// DiveSetupBlitter ( pwinData->hDive, 0 ); +// pwinData->fVrnDisabled = TRUE; + break; + + case WM_VRNENABLED: + { HRGN hrgn; /* Region handle */ + RGNRECT rgnCtl; /* Processing control structure */ +// RECTL rCtls[52]; +// ULONG ulNumRcls; + +// pwinData->fDataInProcess = TRUE; + hps = WinGetPS ( hwnd ); + if ( !hps ) + break; + hrgn = GpiCreateRegion ( hps, 0L, NULL ); + if ( hrgn ) + { /* NOTE: If mp1 is zero, then this was just a move message. + ** Illustrate the visible region on a WM_VRNENABLE. + */ + WinQueryVisibleRegion ( hwnd, hrgn ); + rgnCtl.ircStart = 0; + rgnCtl.crc = 50; + rgnCtl.ulDirection = 1; + + /* Get the all ORed rectangles */ + if ( GpiQueryRegionRects ( hps, hrgn, NULL, + &rgnCtl, rCtls) ) + { + ulNumRcls = rgnCtl.crcReturned; + + /* Now find the window position and size, relative to parent. + */ +// WinQueryWindowPos ( pwinData->hwndClient, &pwinData->swp ); + +// rcl.xLeft = 0; +// rcl.yBottom = 0; + + /* Convert the point to offset from desktop lower left. + */ +// pointl.x = pwinData->swp.x; +// pointl.y = pwinData->swp.y; + +// WinMapWindowPoints ( pwinData->hwndFrame, +// HWND_DESKTOP, &pointl, 1 ); + +// pwinData->cxWindowPos = pointl.x; +// pwinData->cyWindowPos = pointl.y; + + } + GpiDestroyRegion( hps, hrgn ); + } + WinReleasePS( hps ); + + } + break; + + case WM_SIZE: + window = __glutGetWindow(hwnd); + if (window) + { int width,height; + width = SHORT1FROMMP(mp2); + height = SHORT2FROMMP(mp2); + 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); + if(width <= 0 || height <= 0) + break; + _mesa_ResizeBuffersMESA(); + + /* Do not execute OpenGL out of sequence with respect + to the SetWindowPos request! */ + 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_SHOW: + window = __glutGetWindow(hwnd); + if (window) { + int visState; + visState = SHORT1FROMMP( mp1 ); + updateWindowState(window, visState); + } + 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; + visState = SHORT1FROMMP( mp1 ); + updateWindowState(window, visState); + } + return 0; + + case WM_CHAR: + { USHORT fsflags; + window = __glutGetWindow(hwnd); + if (!window) { + break; + } + fsflags = SHORT1FROMMP(mp1); +/* ?? */ + if((fsflags & KC_KEYUP) ) /* игноpиpуем отжатие кнопки, pеагиpуем только на нажатие */ + break; +/////////////////////////////////////////////////// + if(!(fsflags & KC_CHAR) ) + { + if (!(fsflags & KC_VIRTUALKEY)) + break; + key = 0; + /* Get the virtual key from mp2. */ + switch (SHORT2FROMMP(mp2)) + { +/* 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; + + case VK_PAGEUP: key = GLUT_KEY_PAGE_UP; break; + case VK_PAGEDOWN: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; + +/* 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; + case VK_ESC: key = -1; break; /* Character codes */ + case VK_SPACE: key = -1; break; + case VK_TAB: key = -1; break; + } + if(!key) + { break; /* Key Not implemented */ + } + if(key > 0) + { if (!window->special) /* не установлено обработчика */ + break; + + WinQueryPointerPos(HWND_DESKTOP,&point); + ScreenToClient(window->win, &point); + __glutSetWindow(window); + __glutModifierMask = 0; + if(WinGetKeyState(HWND_DESKTOP,VK_SHIFT) & 0x8000) /* high order bit is on */ + __glutModifierMask |= ShiftMask; + if(WinGetKeyState(HWND_DESKTOP,VK_CTRL) & 0x8000) + __glutModifierMask |= ControlMask; + if(WinGetKeyState(HWND_DESKTOP,VK_MENU) & 0x8000) + __glutModifierMask |= Mod1Mask; + window->special(key, point.x, point.y); + __glutModifierMask = (unsigned int) ~0; + return 0; + } + + } +///////////////////////////////////////////////////// + /* If we are ignoring auto repeated key strokes for the window, bail. */ + if (window->ignoreKeyRepeat && (CHAR3FROMMP(mp1)) ) + break; + if(!((unsigned char)SHORT1FROMMP(mp2)) ) /* игноpиpуем несимвольные коды */ + break; + if (window->keyboard) { + WinQueryPointerPos(HWND_DESKTOP,&point); + + ScreenToClient(window->win, &point); + __glutSetWindow(window); + __glutModifierMask = 0; + if(WinGetKeyState(HWND_DESKTOP,VK_SHIFT) & 0x8000) /* high order bit is on */ + __glutModifierMask |= ShiftMask; + if(WinGetKeyState(HWND_DESKTOP,VK_CTRL) & 0x8000) + __glutModifierMask |= ControlMask; + if(WinGetKeyState(HWND_DESKTOP,VK_MENU) & 0x8000) + __glutModifierMask |= Mod1Mask; + window->keyboard((unsigned char)SHORT1FROMMP(mp2), point.x, point.y); + __glutModifierMask = (unsigned int) ~0; + } + return 0; + } /* endof case WM_CHAR: */ +//////////////////////////////////////////////// + case WM_BUTTON1DOWN: + button = GLUT_LEFT_BUTTON; + case WM_BUTTON3DOWN: + if (button < 0) + button = GLUT_MIDDLE_BUTTON; + case WM_BUTTON2DOWN: + if (button < 0) + button = GLUT_RIGHT_BUTTON; + { POINTS psh; + psh = *((POINTS *)&mp1); + point.x = psh.x; + point.y = psh.y; + } + /* 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; + /* get current mouse pointer position */ +// WinQueryPointerPos(HWND_DESKTOP,&point); + /* map from desktop to client window */ +// WinMapWindowPoints(HWND_DESKTOP, hwnd, &point, 1); + __glutItemSelected = NULL; + __glutFinishMenu(hwnd, point.x, point.y); + return 0; + } + window = __glutGetWindow(hwnd); + if (window) { + window->buttonDownState = button+1; + menu = __glutGetMenuByNum(window->menu[button]); + if (menu) { +//todo +// __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 (WinGetKeyState(HWND_DESKTOP,VK_SHIFT) & 0x8000) /* < 0 = high order bit is on. */ + __glutModifierMask |= ShiftMask; + if (WinGetKeyState(HWND_DESKTOP,VK_CTRL) & 0x8000) + __glutModifierMask |= ControlMask; + if (WinGetKeyState(HWND_DESKTOP,VK_MENU) & 0x8000) + __glutModifierMask |= Mod1Mask; + window->mouse(button, GLUT_DOWN, point.x, point.y); + __glutModifierMask = (unsigned int)~0; + } else { + /* Stray mouse events. Ignore. */ + } + } + return 0; + + break; +/********************************************/ + case WM_BUTTON1UP: + button = GLUT_LEFT_BUTTON; + case WM_BUTTON3UP: + if (button < 0) + button = GLUT_MIDDLE_BUTTON; + case WM_BUTTON2UP: + if (button < 0) + button = GLUT_RIGHT_BUTTON; + { POINTS psh; + psh = *((POINTS *)&mp1); + point.x = psh.x; + point.y = psh.y; + } + /* Bail out if we're processing a menu. */ + /* Bail out = выброситься с парашутом */ + if (__glutMappedMenu) { + WinQueryPointerPos(HWND_DESKTOP,&point); + WinMapWindowPoints(HWND_DESKTOP, hwnd, &point, 1); + /* 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; + } + + window = __glutGetWindow(hwnd); + if(window) + window->buttonDownState = 0; + + if (window && window->mouse) { + __glutSetWindow(window); + __glutModifierMask = 0; + if (WinGetKeyState(HWND_DESKTOP,VK_SHIFT) & 0x8000) /* < 0 = high order bit is on */ + __glutModifierMask |= ShiftMask; + if (WinGetKeyState(HWND_DESKTOP,VK_CTRL) & 0x8000) + __glutModifierMask |= ControlMask; + if (WinGetKeyState(HWND_DESKTOP,VK_MENU) & 0x8000) + __glutModifierMask |= Mod1Mask; + window->mouse(button, GLUT_UP, point.x, point.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; + + + break; +////////////////////////////////////////////////// + case WM_COMMAND: + window = __glutGetWindow(hwnd); + if (window) + { if (window->wm_command) + window->wm_command(hwnd,mp1,mp2); + } + break; + + case WM_MOUSEMOVE: + if (!__glutMappedMenu) { + window = __glutGetWindow(hwnd); + if (window) { + /* If motion function registered _and_ buttons held * + down, call motion function... */ + { POINTS psh; + psh = *((POINTS *)&mp1); + point.x = psh.x; + point.y = psh.y; + } + + if (window->motion && window->buttonDownState) { + __glutSetWindow(window); + window->motion(point.x, point.y); + } + /* If passive motion function registered _and_ + buttons not held down, call passive motion + function... */ + else if (window->passive && !window->buttonDownState) { + __glutSetWindow(window); + window->passive(point.x, point.y); + } + } + } else { + /* Motion events are thrown away when a pop up menu is + active. */ + } + return 0; + + + default: + /* For all other messages, let the default window procedure process them. */ + return ( WinDefWindowProc( hwnd, msg, mp1, mp2 ) ); + + } //endof switch( msg ) + return ( WinDefWindowProc( hwnd, msg, mp1, mp2 ) ); +// return NULL; +} + +void APIENTRY glutCommandFunc(GLUTcommandCB Func) +{ +extern GLUTwindow *__glutCurrentWindow; + __glutCurrentWindow->wm_command = Func; +} + + + + +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; + } +} + +#if POKA + +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: + PostQuitMessage(0); + return 0; +#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_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); +} + +#endif + +#if defined(__OS2PM__) +Bool __glutSetWindowText(Window window, char *text) +{ + return WinSetWindowText(window, (PCSZ)text); + +} + +#endif + \ No newline at end of file diff --git a/src/glut/os2/src-glut_os2pm.zip b/src/glut/os2/src-glut_os2pm.zip new file mode 100644 index 000000000..8c8a8c7ac Binary files /dev/null and b/src/glut/os2/src-glut_os2pm.zip differ -- cgit v1.2.3