Remove the SGI demos. These were all ancient and nobody cared enough.

10 files changed, 0 insertions, 2066 deletions

diff --git a/Demo/sgi/gl/README b/Demo/sgi/gl/README
deleted file mode 100644
index a89a502..0000000
--- a/Demo/sgi/gl/README
+++ /dev/null
@@ -1,35 +0,0 @@
-These demos run only on SGI machines and require the 'gl' built-in module.
-The demonstrate the abilities of SGI's GL library as well as the ease of
-GL programming in Python.  Most demos require the Z-buffer (aka
-24-bitplane) option.  Press ESC to get out of any of them.
-
-backface.py	Demonstrates the 'backface' GL function.
-
-kites.py	Show 3 flying kites.  Demonstrates the rendering speed
-		obtainable by Python programs.
-
-kunst.py	Cute demo showing a ball suspended on four cables in
-		the central room of the CWI building.  You can specify
-		three functions Fx(t), Fy(t), Fz(t) which define the
-		movement of the ball.  Try something like sin(t),
-		cos(t), sin(2*t).
-
-mclock.py	A colorful clock with more options than you can
-		remember.  Works on 8-bit machines, but allows more
-		colors on 24-bit machines.  See mclock.doc for more
-		info.
-
-mixing.py	Demonstrates the effect of color mixing: through
-		frequent color switching it gives the effect of white
-		light.
-
-nurbs.py	A simple demonstration of the 'nurbs' GL functions.
-		Press left mouse button to toggle surface trimming.
-
-zrgb.py		Displays a 3-D Gouraud-shaded figure which can be moved
-		around with the mouse.
-
-glstdwin/	This is quite different: a partial STDWIN emulation
-		using GL!  Requires only small changes to Python
-		programs that use STDWIN.  Some features not yet
-		implemented, e.g., scroll bars.
diff --git a/Demo/sgi/gl/backface.py b/Demo/sgi/gl/backface.py
deleted file mode 100755
index 41c69d6..0000000
--- a/Demo/sgi/gl/backface.py
+++ /dev/null
@@ -1,140 +0,0 @@
-#! /usr/bin/env python
-
-#   backface
-#
-#   draw a cube that can run with backface() turned on or off.
-#   cube is moved when LEFTMOUSE is pressed and mouse itself is moved.
-
-from gl import *
-from DEVICE import *
-from GL import *
-
-CUBE_SIZE = 200.0
-CUBE_OBJ = 1
-
-def main () :
-	#
-	x = 0
-	y = 0
-	moveit = 0
-	#
-	initialize()
-	#
-	while (1) :
-		#
-		while (qtest()) :
-			dev, val = qread()
-			#
-			if dev == ESCKEY :
-				backface(0)
-				return
-				#
-			elif dev == REDRAW :
-				reshapeviewport()
-				drawcube(x,y)
-				#
-			elif dev == LEFTMOUSE :
-				#
-				# LEFTMOUSE down
-				moveit = val
-				#
-			elif dev == BKEY :
-				backface(1)
-				drawcube(x,y)
-				#
-			elif dev == FKEY :
-				backface(0)
-				drawcube(x,y)
-				#
-		if moveit :
-			x = getvaluator(MOUSEX)
-			y = getvaluator(MOUSEY)
-			drawcube(x,y)
-
-
-def initialize () :
-	foreground ()
-	keepaspect (1, 1)
-	gid = winopen('backface')
-	winset(gid)
-	winconstraints()
-	#
-	doublebuffer()
-	gconfig()
-	shademodel(FLAT)
-	#
-	ortho(-1024.0, 1024.0, -1024.0, 1024.0, -1024.0, 1024.0)
-	#
-	qdevice(ESCKEY)
-	qdevice(REDRAW)
-	qdevice(LEFTMOUSE)
-	qdevice(BKEY)
-	qdevice(FKEY)
-	qenter(REDRAW,gid)
-	#
-	backface(1)
-
-#
-# define a cube
-def cube () :
-	#
-	# front face
-	pushmatrix()
-	translate(0.0,0.0,CUBE_SIZE)
-	color(RED)
-	rectf(-CUBE_SIZE,-CUBE_SIZE,CUBE_SIZE,CUBE_SIZE)
-	popmatrix()
-	#
-	# right face
-	pushmatrix()
-	translate(CUBE_SIZE, 0.0, 0.0)
-	rotate(900, 'y')
-	color(GREEN)
-	rectf(-CUBE_SIZE,-CUBE_SIZE,CUBE_SIZE,CUBE_SIZE)
-	popmatrix()
-	#
-	# back face
-	pushmatrix()
-	translate(0.0, 0.0, -CUBE_SIZE)
-	rotate(1800, 'y')
-	color(BLUE)
-	rectf(-CUBE_SIZE,-CUBE_SIZE,CUBE_SIZE,CUBE_SIZE)
-	popmatrix()
-	#
-	# left face
-	pushmatrix()
-	translate(-CUBE_SIZE, 0.0, 0.0)
-	rotate(-900, 'y')
-	color(CYAN)
-	rectf(-CUBE_SIZE,-CUBE_SIZE,CUBE_SIZE,CUBE_SIZE)
-	popmatrix()
-	#
-	# top face
-	pushmatrix()
-	translate(0.0, CUBE_SIZE, 0.0)
-	rotate(-900, 'x')
-	color(MAGENTA)
-	rectf(-CUBE_SIZE,-CUBE_SIZE,CUBE_SIZE,CUBE_SIZE)
-	popmatrix()
-	#
-	# bottom face
-	pushmatrix()
-	translate(0.0, -CUBE_SIZE, 0.0)
-	rotate(900, 'x')
-	color(YELLOW)
-	rectf(-CUBE_SIZE,-CUBE_SIZE,CUBE_SIZE,CUBE_SIZE)
-	popmatrix()
-
-def drawcube(x,y) :
-	#
-	pushmatrix()
-	rotate(2*x, 'x')
-	rotate(2*y, 'y')
-	color(BLACK)
-	clear()
-	cube()        
-	popmatrix()
-	swapbuffers()
-
-
-main ()
diff --git a/Demo/sgi/gl/glinfo.py b/Demo/sgi/gl/glinfo.py
deleted file mode 100755
index dae99f1..0000000
--- a/Demo/sgi/gl/glinfo.py
+++ /dev/null
@@ -1,20 +0,0 @@
-#! /usr/bin/env python
-
-# Print the values of all values that can be inquired with getgdesc().
-# See man getgdesc() for a description.
-
-import gl
-import GL
-
-def main():
-	names = []
-	maxlen = 0
-	for name in dir(GL):
-		if name[:3] == 'GD_':
-			names.append(name)
-			maxlen = max(maxlen, len(name))
-	for name in names:
-		print name + (maxlen - len(name))*' ' + '=',
-		print gl.getgdesc(getattr(GL, name))
-
-main()
diff --git a/Demo/sgi/gl/kites.py b/Demo/sgi/gl/kites.py
deleted file mode 100755
index cde69cb..0000000
--- a/Demo/sgi/gl/kites.py
+++ /dev/null
@@ -1,194 +0,0 @@
-#! /usr/bin/env python
-
-# *** This only works correctly on a 24 bit-plane machine. ***
-#
-# A simple Python program that tests the some parts of the
-# GL library. It shows the speed that can be obtained when
-# doing simple graphics.
-#
-# The bottleneck in this program is NOT Python but the graphics
-# engine; i.e Python can feed the graphics pipeline fast enough
-# on the 4D/25G.
-#
-# This program show 3 kites flying around the screen. It uses
-#
-# 	* bgnpolygon, endpolygon
-# 	* v3, n3
-# 	* lmdef, lmbind
-#
-# Usage :
-# 
-# 	ESC 	-> exit program
-# 	MOUSE3 	-> freeze toggle
-# 	MOUSE2 	-> one step (use this in freeze state)
-
-from GL import *
-from gl import *
-import DEVICE
-from math import *
-
-#
-# viewobj : sets the rotation, translation and scaling
-# set appropiate material, call drawobject()
-#
-def viewobj (r, s, t, mat) :
-	pushmatrix()
-	rot (r * 10.0, 'X')
-	rot (r * 10.0, 'Y')
-	rot (r * 10.0, 'Z')
-	scale (s[0], s[1], s[2])
-	translate (t[0], t[1], t[2])
-	lmbind(MATERIAL, mat)
-	drawobject()
-	popmatrix()
-
-#
-# makeobj : the constructor of the object
-#
-def mkobj () :
-	v0 = (-5.0 ,0.0, 0.0)
-	v1 = (0.0 ,5.0, 0.0)
-	v2 = (5.0 ,0.0, 0.0)
-	v3 = (0.0 ,2.0, 0.0)
-	n0 = (sqrt(2.0)/2.0, sqrt(2.0)/2.0, 0.0)
-	vn = ((v0, n0), (v1, n0), (v2, n0), (v3, n0))
-	#
-	return vn
-
-#
-# the object itself as an array of vertices and normals
-#
-kite = mkobj ()
-
-#
-# drawobject : draw a triangle. with bgnpolygon
-#
-def drawobject () :
-	#
-	bgnpolygon()
-	vnarray (kite)
-	endpolygon()
-
-#
-# identity matrix
-#
-idmat=[1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0,1.0]
-
-#
-# the rgb-value of light-blue 
-#
-LightBlue = (43,169,255)
-
-#
-# the different materials.
-#
-m1=[SPECULAR,0.0,0.0,0.6,DIFFUSE,0.0,0.0,0.8,SHININESS,20.0,LMNULL]
-m2=[SPECULAR,0.8,0.0,0.1,DIFFUSE,0.8,0.0,0.3,SHININESS,120.0,LMNULL]
-m3=[SPECULAR,0.0,1.0,0.0,DIFFUSE,0.0,0.6,0.0,SHININESS,120.0,LMNULL]
-
-#
-# lightsources
-#
-light1 = [LCOLOR,1.0,1.0,1.0,POSITION,15.0,15.0,0.0,1.0,LMNULL]
-light2 = [LCOLOR,1.0,1.0,1.0,POSITION,-15.0,15.0,0.0,1.0,LMNULL]
-
-#
-# the lightmodel
-#
-model = [AMBIENT,0.2,0.2,0.2,LMNULL]
-
-#
-# initgl : opens the window, configures the pipeline to 2buf and zbuf,
-# sets the viewing, defines and binds the materials
-#
-def initgl () :
-	#
-	# open window
-	#
-	foreground ()
-	keepaspect (1, 1)
-	prefposition (100, 500, 100, 500)
-	w = winopen ('PYTHON lights')
-	keepaspect (1, 1)
-	winconstraints()
-	#
-	# configure pipeline (zbuf, 2buf, GOURAUD and RGBmode)
-	#
-	zbuffer (1)
-	doublebuffer ()
-	shademodel (GOURAUD)
-	RGBmode ()
-	gconfig ()
-	#
-	# define and bind materials (set perspective BEFORE loadmat !)
-	#
-	mmode(MVIEWING)
-	perspective (900, 1.0, 1.0, 20.0)
-	loadmatrix(idmat)
-	lmdef(DEFMATERIAL, 1, m1)
-	lmdef(DEFMATERIAL, 2, m2)
-	lmdef(DEFMATERIAL, 3, m3)
-	lmdef(DEFLIGHT, 1, light1)
-	lmdef(DEFLIGHT, 2, light2)
-	lmdef(DEFLMODEL, 1, model)
-	lmbind(LIGHT0,1)
-	lmbind(LIGHT1,2)
-	lmbind(LMODEL,1)
-	#
-	# set viewing
-	#
-	lookat (0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 0)
-	#
-	# ask for the REDRAW and ESCKEY events
-	#
-	qdevice(DEVICE.MOUSE3)
-	qdevice(DEVICE.MOUSE2)
-	qdevice(DEVICE.REDRAW)
-	qdevice(DEVICE.ESCKEY)
-
-#
-# GoForIT : use 2buf to redraw the object 2n times. index i is used as 
-# the (smoothly changing) rotation angle
-#
-def GoForIt(i) :
-	freeze = 1
-	while 1 :
-		if freeze <> 0 :
-			i = i + 1
-		#
-		# clear z-buffer and clear background to light-blue
-		#
-		zclear()
-		c3i (LightBlue)
-		clear()
-		#
-		# draw the 3 traiangles scaled above each other.
-		#
-		viewobj(float(i),[1.0,1.0,1.0],[1.0,1.0,1.0],1)
-		viewobj(float(i),[0.75,0.75,0.75],[0.0,2.0,2.0],2)
-		viewobj(float(i),[0.5,0.5,0.5],[0.0,4.0,4.0],3)
-		#
-		swapbuffers()
-		#
-		if qtest() <> 0 :
-			dev, val = qread()
-			if dev == DEVICE.ESCKEY :
-				break
-			elif dev == DEVICE.REDRAW :
-				reshapeviewport ()
-			elif dev == DEVICE.MOUSE3 and val <> 0 :
-				freeze = 1 - freeze
-			elif dev == DEVICE.MOUSE2 and val <> 0 :
-				i = i + 1
-
-
-# the main program
-#
-def main () :
-	initgl ()
-	GoForIt (0)
-
-#
-# exec main
-#
-main  ()
diff --git a/Demo/sgi/gl/kunst.py b/Demo/sgi/gl/kunst.py
deleted file mode 100755
index f37f979..0000000
--- a/Demo/sgi/gl/kunst.py
+++ /dev/null
@@ -1,426 +0,0 @@
-#! /usr/bin/env python
-# Simulate the artwork in the hall.
-# Jack Jansen, Feb 91.
-
-from gl import *
-from GL import *
-from math import *
-from DEVICE import *
-import sys
-import __main__
-main_dict = __main__.__dict__
-
-SPOTDIRECTION = 103
-SPOTLIGHT = 104
-
-#
-# Make a cylinder paralel with the Z axis with center (X,Y,0)
-# and radius 1
-def mkcyl(nslice, nparts, docircle):
-        cyl = []
-        step = 2.0 / float(nslice)
-        z = -1.0
-        for i in range(nslice):
-            cyl.append(mkslice(z, z+step, nparts, docircle))
-            z = z + step
-        return drawcylinder(cyl)
-#
-# Make one part of a cylinder
-#
-def mkslice(z1, z2, nparts, docircle):
-        if docircle:
-            w1 = z1
-            w2 = z2
-            w1 = sqrt(1.0-w1*w1)
-            w2 = sqrt(1.0-w2*w2)
-            normalz = 1.0
-        else:
-            w1 = 1.0
-            w2 = 1.0
-            normalz = 0.0
-        slice = []
-        step = (2.0*pi)/float(nparts)
-        angle = 0.0
-        for i in range(nparts+1):
-            vx = cos(angle)
-            vy = sin(angle)
-            slice.append( ((vx*w1,vy*w1,z1), (vx*w1, vy*w1, z1*normalz)) )
-            slice.append( ((vx*w2,vy*w2,z2), (vx*w2, vy*w2, z2*normalz)) )
-            angle = angle + step
-        return slice
-#
-# Drawcylinder : draw the cylinder
-#
-class struct: pass
-curobj = struct()
-curobj.curobj = 1
-def drawcylinder(cyl):
-        obj = curobj.curobj
-        curobj.curobj = curobj.curobj+1
-        makeobj(obj)
-        for slice in cyl:
-            bgntmesh()
-            vnarray(slice)
-            endtmesh()
-        closeobj()
-        return obj
-#
-def drawnormals(cyl):
-        for slice in cyl:
-            for triang in slice:
-                bgnline()
-                v3f(triang[0])
-                v3f(triang[0][0] + triang[1][0], triang[0][1] + triang[1][1], triang[0][2] + triang[1][2])
-                endline()
-def drawfloors():
-        obj = curobj.curobj
-        curobj.curobj = curobj.curobj+1
-        makeobj(obj)
-        bgnpolygon()
-        v3i(4,6,-6)
-        v3i(-6,6,-6)
-        v3i(-6,-6,-6)
-        v3i(4,-6,-6)
-        endpolygon()
-        for floor in range(3):
-            pos = -1 + 5*floor
-            bgnpolygon()
-            v3i(4,4,pos)
-            v3i(-6,4,pos)
-            v3i(-6,6,pos)
-            v3i(4,6,pos)
-            endpolygon()
-            bgnpolygon()
-            v3i(-4,4,pos)
-            v3i(-4,-4,pos)
-            v3i(-6,-4,pos)
-            v3i(-6,4,pos)
-            endpolygon()
-            bgnpolygon()
-            v3i(-6,-4,pos)
-            v3i(-6,-6,pos)
-            v3i(4,-6,pos)
-            v3i(4,-4,pos)
-            endpolygon()
-        closeobj()
-        return obj
-def drawdoors():
-        obj = curobj.curobj
-        curobj.curobj = curobj.curobj+1
-        makeobj(obj)
-        for floor in range(3):
-            pos = -1+5*floor
-            bgnpolygon()
-            v3i(-2,6,pos)
-            v3i(-2,6,pos+3)
-            v3i(0,6,pos+3)
-            v3i(0,6,pos)
-            endpolygon()
-        closeobj()
-        return obj
-def drawrailing():
-        obj = curobj.curobj
-        curobj.curobj = curobj.curobj+1
-        makeobj(obj)
-        for floor in range(3):
-            pos = -1 + 5*floor
-            bgnpolygon()
-            v3i(4,4,pos)
-            v3i(4,4,pos-1)
-            v3i(-4,4,pos-1)
-            v3i(-4,4,pos)
-            endpolygon()
-            bgnpolygon()
-            v3i(-4,4,pos)
-            v3i(-4,4,pos-1)
-            v3i(-4,-4,pos-1)
-            v3i(-4,-4,pos)
-            endpolygon()
-            bgnpolygon()
-            v3i(-4,-4,pos)
-            v3i(-4,-4,pos-1)
-            v3i(4,-4,pos-1)
-            v3i(4,-4,pos)
-            endpolygon()
-        closeobj()
-        return obj
-def drawwalls():
-        obj = curobj.curobj
-        curobj.curobj = curobj.curobj+1
-        makeobj(obj)
-        bgnpolygon()
-        v3i(4,6,-6)
-        v3i(4,6,18)
-        v3i(-6,6,18)
-        v3i(-6,6,-6)
-        endpolygon()
-        bgnpolygon()
-        v3i(-6,6,-6)
-        v3i(-6,6,18)
-        v3i(-6,-6,18)
-        v3i(-6,-6,-6)
-        endpolygon()
-        bgnpolygon()
-        v3i(-6,-6,-6)
-        v3i(-6,-6,18)
-        v3i(4,-6,18)
-        v3i(4,-6,-6)
-        endpolygon()
-        bgnpolygon()
-        v3i(4,-6,-6)
-        v3i(4,-6,18)
-        v3i(4,4,18)
-        v3i(4,4,-6)
-        endpolygon()
-        closeobj()
-        return obj
-def axis():
-        bgnline()
-        cpack(0xff0000)
-        v3i(-1,0,0)
-        v3i(1,0,0)
-        v3f(1.0, 0.1, 0.1)
-        endline()
-        bgnline()
-        cpack(0xff00)
-        v3i(0,-1,0)
-        v3i(0,1,0)
-        v3f(0.1, 1.0, 0.1)
-        endline()
-        bgnline()
-        cpack(0xff)
-        v3i(0,0,-1)
-        v3i(0,0,1)
-        v3f(0.1,0.1,1.0)
-        endline()
-#
-green_velvet = [ DIFFUSE, 0.05, 0.4, 0.05, LMNULL]
-silver = [ DIFFUSE, 0.3, 0.3, 0.3, SPECULAR, 0.9, 0.9, 0.95, \
-        SHININESS, 40.0, LMNULL]
-floormat = [ AMBIENT, 0.5, 0.25, 0.15, DIFFUSE, 0.5, 0.25, 0.15, SPECULAR, 0.6, 0.3, 0.2, SHININESS, 20.0, LMNULL]
-wallmat = [ DIFFUSE, 0.4, 0.2, 0.1, AMBIENT, 0.4, 0.20, 0.10, SPECULAR, 0.0, 0.0, 0.0, SHININESS, 20.0, LMNULL]
-offwhite = [ DIFFUSE, 0.8, 0.8, 0.6, AMBIENT, 0.8, 0.8, 0.6, SPECULAR, 0.9, 0.9, 0.9, SHININESS, 30.0, LMNULL]
-doormat = [ DIFFUSE, 0.1, 0.2, 0.5, AMBIENT, 0.2, 0.4, 1.0, SPECULAR, 0.2, 0.4, 1.0, SHININESS, 60.0, LMNULL]
-
-toplight = [ LCOLOR, 1.0, 1.0, 0.5, \
-        POSITION, 0.0, 0.0, 11.0, 1.0, LMNULL]
-floor1light = [ LCOLOR, 1.0, 1.0, 1.0, POSITION, 3.9, -3.9, 0.0, 1.0, \
-        SPOTDIRECTION, 1.0, 1.0, 0.0, SPOTLIGHT, 10.0, 90.0, LMNULL]
-
-lmodel = [ AMBIENT, 0.92, 0.8, 0.5, LOCALVIEWER, 1.0, LMNULL]
-#
-def lighting():
-        lmdef(DEFMATERIAL, 1, green_velvet)
-        lmdef(DEFMATERIAL, 2, silver)
-        lmdef(DEFMATERIAL, 3, floormat)
-        lmdef(DEFMATERIAL, 4, wallmat)
-        lmdef(DEFMATERIAL, 5, offwhite)
-        lmdef(DEFMATERIAL, 6, doormat)
-        lmdef(DEFLIGHT, 1, toplight)
-        lmdef(DEFLIGHT, 2, floor1light)
-        lmdef(DEFLMODEL, 1, lmodel)
-        lmbind(MATERIAL, 1)
-        lmbind(LIGHT0, 1)
-        lmbind(LIGHT1, 2)
-        lmbind(LMODEL, 1)
-IdMat=[1.0,0.0,0.0,0.0, 0.0,1.0,0.0,0.0, 0.0,0.0,1.0,0.0, 0.0,0.0,0.0,1.0]
-#
-def defun(axis):
-        done = 0
-        while not done:
-            print 'F'+axis+'(t) = ',
-            s = sys.stdin.readline(100)
-            print
-            try:
-                s = 'def f'+axis+'(t): return '+s
-                exec(s, main_dict)
-                done = 1
-            except RuntimeError:
-                print 'Sorry, there is a syntax error in your expression'
-def getfunctions():
-        print 'Welcome to the CWI art simulator. You can now enter X, Y and Z'
-        print 'coordinates as a function of t.'
-        print 'Normal trig functions are available. Please use floating point'
-        print 'values only (so 0.0 for 0). Comments to jack@cwi.nl'
-        defun('x')
-        defun('y')
-        defun('z')
-        print 'Ok, here you go. Use mouse+right button to move up/down,'
-        print 'mouse+middle to speed up/slow down time. type ESC to quit simulation'
-def main():
-        getfunctions()
-        foreground()
-        prefposition(100,600,100,600)
-        void = winopen('cyl')
-        qdevice(ESCKEY)
-        qdevice(MOUSE1)
-        qdevice(MOUSE2)
-        qdevice(PKEY)
-        RGBmode()
-        doublebuffer()
-        gconfig()
-        zbuffer(1)
-        mmode(MVIEWING)
-        perspective(400, 1.0, 1.0, 20.0)
-        loadmatrix(IdMat)
-        vx = 0.0
-        vy = -6.0
-        vz = 0.0
-        lookat(0.0, -6.0, 0.0, 0.0, 0.0, 0.0, 0)
-        lighting()
-        t = -1.0
-        step = 1.0
-        bol = mkcyl(12,24, 1)
-        cable = mkcyl(1, 6, 0)
-        floors = drawfloors()
-        walls = drawwalls()
-        pillar = mkcyl(1,4,0)
-        railing = drawrailing()
-        doors = drawdoors()
-        shademodel(GOURAUD)
-        mousing = -1
-        pausing = 0
-        while 1:
-            #
-            # Check for some user input
-            #
-            if qtest():
-                dev, value = qread()
-                if dev == PKEY and value == 1:
-                        pausing = 1
-                if dev == ESCKEY:
-                    break
-                elif (dev==MOUSE1 or dev==MOUSE2) and value == 1:
-                    if mousing > 0:
-                        vx = 0.0
-                        vy = -6.0
-                        vz = 0.0
-                    mousing = dev
-                    oldx = getvaluator(MOUSEX)
-                    oldy = getvaluator(MOUSEY)
-                elif (dev==MOUSE1 or dev==MOUSE2):
-                    mousing = -1
-            if mousing >= 0:
-                newx = getvaluator(MOUSEX)
-                newy = getvaluator(MOUSEY)
-                if newy <> oldy and mousing==MOUSE1:
-                    vz = vz + float(newy - oldy)/100.0
-                    dist = sqrt(vx*vx + vy*vy + vz*vz)
-                    perspective(400, 1.0, 1.0, dist+16.0)
-                    loadmatrix(IdMat)
-                    if vz < 0.0:
-                        lookat(vx, vy, vz, 0.0, 0.0, 0.0, 1800)
-                    else:
-                        lookat(vx, vy, vz, 0.0, 0.0, 0.0, 0)
-                if newy <> oldy and mousing==MOUSE2:
-                    step = step * exp(float(newy-oldy)/400.0)
-            if getbutton(CTRLKEY) == 0:
-                t = t + step
-            else:
-                t = t - step
-            if getbutton(LEFTSHIFTKEY) == 0:
-                shademodel(GOURAUD)
-            else:
-                shademodel(FLAT)
-            #
-            # Draw background and axis
-            cpack(0x105090)
-            clear()
-            zclear()
-            cpack(0x905010)
-            axis()
-            #
-            # Draw object
-            #
-            bolx = fx(t)
-            boly = fy(t)
-            bolz = fz(t)
-            err = ''
-            if bolx < -4.0 or bolx > 4.0:
-                err = 'X('+`bolx`+') out of range [-4,4]'
-            if boly < -4.0 or boly > 4.0:
-                err = 'Y('+`boly`+') out of range [-4,4]'
-            if bolz < -4.0 or bolz > 8.0:
-                err = 'Z('+`bolz`+') out of range [-4,8]'
-            if not err:
-                pushmatrix()
-                translate(bolx, boly, bolz)
-                scale(0.3, 0.3, 0.3)
-                lmbind(MATERIAL, 2)
-                callobj(bol)
-                popmatrix()
-                #
-                # Draw the cables
-                #
-                bolz = bolz + 0.3
-                pushmatrix()
-                linesmooth(SML_ON)
-                bgnline()
-                v3i(-4,-4,9)
-                v3f(bolx, boly, bolz)
-                endline()
-                bgnline()
-                v3i(-4,4,9)
-                v3f(bolx, boly, bolz)
-                endline()
-                bgnline()
-                v3i(4,-4,9)
-                v3f(bolx, boly, bolz)
-                endline()
-                bgnline()
-                v3i(4,4,9)
-                v3f(bolx, boly, bolz)
-                endline()
-                popmatrix()
-            #
-            # draw the floors
-            #
-            lmbind(MATERIAL, 3)
-            callobj(floors)
-            lmbind(MATERIAL, 4)
-            callobj(walls)
-            lmbind(MATERIAL, 5)
-            pushmatrix()
-            translate(-4.5,4.5,3.0)
-            scale(0.2,0.2,9.0)
-            rotate(450,'z')
-            callobj(pillar)
-            popmatrix()
-            callobj(railing)
-            lmbind(MATERIAL, 6)
-            pushmatrix()
-            translate(0.0, -0.01, 0.0)
-            callobj(doors)
-            popmatrix()
-            if mousing == MOUSE2 or err:
-                cpack(0xff0000)
-                cmov(0.0, 0.0, 0.4)
-                charstr('t='+`t`)
-            if mousing == MOUSE2:
-                cpack(0xff0000)
-                cmov(0.0, 0.0, 0.2)
-                charstr('delta-t='+`step`)
-            if err:
-                cpack(0xff00)
-                cmov(0.0, 0.0, 0.2)
-                print err
-                charstr(err)
-                pausing = 1
-            if pausing:
-                cpack(0xff00)
-                cmov(0.0, 0.0, 0.0)
-                charstr('Pausing, type P to continue')
-            swapbuffers()
-            if pausing:
-                while 1:
-                    dv=qread()
-                    if dv==(PKEY,1):
-                        break
-                    if dv==(ESCKEY,1):
-                        sys.exit(0)
-                pausing = 0
-#
-try:
-    main()
-except KeyboardInterrupt:
-    sys.exit(1)
diff --git a/Demo/sgi/gl/mclock.doc b/Demo/sgi/gl/mclock.doc
deleted file mode 100755
index 2208f33..0000000
--- a/Demo/sgi/gl/mclock.doc
+++ /dev/null
@@ -1,60 +0,0 @@
-Newsgroups: cwi.sgi
-Subject: Re: new clock
-Distribution: cwi.sgi
-References: <2246@charon.cwi.nl>
-
-Last week I wrote:
-
->For your enjoyment I have implemented a colorful clock.
-
-The clock has now been extended with some new facilities: a menu, an
-alarm and a gong.  These may require some explanation beyond what's in
-the usage message.
-
-Menu
-----
-The right mouse button now pops up a menu that allows you to turn the
-seconds hand on or off and to switch the alarm off.
-
-Alarm
------
-
-The left and middle buttons set the alarm.  When it is on, the alarm
-time is displayed as a time on a 24 hour clock in the bottom left
-corner.  It is also indicated by two red triangles, corresponding to the
-little (hours) and big (minutes) hand.  These hands can be moved around:
-the left mouse button moves the minutes hand, the middle button moves
-the hourds hand.  Watch out for differences of twelve hours (always
-check the digital display); these can be corrected by dragging the hours
-hand once around the dial.
-
-When the alarm goes off, two things happen: a shell command specified on
-the command line with the -a option is executed (in the background), and
-the clock's colors change every two seconds, for five minutes.  You can
-also turn the alarm off by using the menu accessible through the right
-mouse button.
-
-There is no default command for the -a option; if it is not specified,
-only the changing of the colors happens.  If you have an 8 ohm speaker
-connected to the audio output of your Personal Iris, a suitable command
-would be:
-
-	mclock -a '/ufs/guido/bin/sgi/play /ufs/guido/lib/sounds/alarm'
-
-Gong
-----
-
-Some people like a clock that makes noises every hour, or even more
-often.  This is supported by the -g and -G options.  With -g you specify
-a shell command to be executed to sound the gong; with -G you can
-specify the interval between gong calls, in seconds (default is one hour).
-The shell command is executed in the background.  It is given two
-arguments: the hours (on a 24 hour clock!) and the minutes.  The
-executable Python script /ufs/guido/bin/sgi/chime is a suitable example.
-Again, this only works if you have installed a speaker (I bet 8 ohm
-speakers are going to be in demand!)
-
---
-Guido van Rossum, Centre for Mathematics and Computer Science (CWI), Amsterdam
-guido@cwi.nl or ..!hp4nl!cwi.nl!guido or guido%cwi.nl@uunet.uu.net
-"A thing of beauty is a joy till sunrise"
diff --git a/Demo/sgi/gl/mclock.py b/Demo/sgi/gl/mclock.py
deleted file mode 100755
index 6af01ba..0000000
--- a/Demo/sgi/gl/mclock.py
+++ /dev/null
@@ -1,736 +0,0 @@
-#! /usr/bin/env python
-
-# "M Clock"
-#
-# An implementation in software of an original design by Rob Juda.
-# Clock implementation: Guido van Rossum.
-# Alarm and Gong features: Sape Mullender.
-#
-# XXX TO DO:
-# add arguments to specify initial window position and size
-# find out local time zone difference automatically
-# add a date indicator
-# allow multiple alarms
-# allow the menu to change more parameters
-
-import sys
-
-from gl import *
-from GL import *
-from DEVICE import *
-import time
-import getopt
-import string
-import os
-from math import pi
-import math
-
-FULLC = 3600		# Full circle in 1/10-ths of a degree
-MIDN = 900		# Angle of the 12 o'clock position
-R, G, B = 0, 1, 2	# Indices of colors in RGB list
-
-HOUR = 3600		# Number of seconds per hour
-MINUTE = 60		# Number of seconds per minute
-
-class struct: pass	# Class to define featureless structures
-Gl = struct()		# Object to hold writable global variables
-
-# Default constants (used in multiple places)
-
-SCREENBG = 127, 156, 191
-NPARTS = 9
-TITLE = 'M Clock'
-
-# Set timezone, check for daylight saving time
-TZDIFF = time.timezone
-if time.localtime(time.time())[-1]:
-	TZDIFF = time.altzone
-
-# Default parameters
-
-Gl.foreground = 0	# If set, run in the foreground
-Gl.fullscreen = 0	# If set, run on full screen
-Gl.tzdiff = TZDIFF	# Seconds west of Greenwich (winter time)
-Gl.nparts = NPARTS	# Number of parts each circle is divided in (>= 2)
-Gl.debug = 0		# If set, print debug output
-Gl.doublebuffer = 1	# If set, use double buffering
-Gl.update = 0		# Update interval; seconds hand is suppressed if > 1
-Gl.colorsubset = 0	# If set, display only a subset of the colors
-Gl.cyan = 0		# If set, display cyan overlay (big hand)
-Gl.magenta = 0		# If set, display magenta overlay (little hand)
-Gl.yellow = 0		# If set, display yellow overlay (fixed background)
-Gl.black = 0		# If set, display black overlay (hands)
-Gl.colormap = 0		# If set, use colormap mode instead of RGB mode
-Gl.warnings = 0		# If set, print warnings
-Gl.title = ''		# Window title (default set later)
-Gl.name = 'mclock'	# Window title for resources
-Gl.border = 1		# If set, use a window border (and title)
-Gl.bg = 0, 0, 0		# Background color R, G, B value
-Gl.iconic = 0		# Set in iconic state
-Gl.fg = 255, 0, 0	# Alarm background RGB (either normal or alarm)
-Gl.ox,Gl.oy = 0,0	# Window origin
-Gl.cx,Gl.cy = 0,0	# Window size
-Gl.alarm_set = 0	# Alarm on or off
-Gl.alarm_on = 0		# Alarm is ringing
-Gl.alarm_time = 0	# Alarm time in seconds after midnight
-Gl.alarm_hours = 0	# Alarm hour setting, 24 hour clock
-Gl.alarm_minutes = 0	# Alarm minutes setting
-Gl.alarm_rgb = 0,0,0	# Alarm display RGB colors
-Gl.alarm_cmd = ''	# Command to execute when alarm goes off
-Gl.mouse2down = 0	# Mouse button state
-Gl.mouse3down = 0	# Mouse button state
-Gl.gong_cmd = ''	# Command to execute when chimes go off
-Gl.gong_int = 3600	# Gong interval
-Gl.indices = R, G, B	# Colors (permuted when alarm is on)
-
-def main():
-	#
-	sys.stdout = sys.stderr		# All output is errors/warnings etc.
-	#
-	try:
-		args = getoptions()
-	except string.atoi_error, value:
-		usage(string.atoi_error, value)
-	except getopt.error, msg:
-		usage(getopt.error, msg)
-	#
-	if args:
-		realtime = 0
-		hours = string.atoi(args[0])
-		minutes = seconds = 0
-		if args[1:]: minutes = string.atoi(args[1])
-		if args[2:]: seconds = string.atoi(args[2])
-		localtime = ((hours*60)+minutes)*60+seconds
-	else:
-		realtime = 1
-	#
-	if Gl.title == '':
-		if realtime:
-			Gl.title = TITLE
-		else:
-			title = ''
-			for arg in args: title = title + ' ' + arg
-			Gl.title = title[1:]
-			del title
-	#
-	wid = makewindow()
-	Gl.ox,Gl.oy = getorigin()
-	Gl.cx,Gl.cy = getsize()
-	initmenu()
-	clearall()
-	#
-	if not Gl.update:
-		Gl.update = 60
-	#
-	if Gl.update <= 1:
-		Gl.timernoise = 6
-	else:
-		Gl.timernoise = 60
-	noise(TIMER0, Gl.timernoise)
-	#
-	qdevice(WINSHUT)
-	qdevice(WINQUIT)
-	qdevice(ESCKEY)
-	if realtime:
-		qdevice(TIMER0)
-	qdevice(REDRAW)
-	qdevice(WINFREEZE)
-	qdevice(WINTHAW)
-	qdevice(MENUBUTTON)	# MOUSE1
-	qdevice(MOUSE3)		# Left button
-	qdevice(MOUSE2)		# Middle button
-	unqdevice(INPUTCHANGE)
-	#
-	lasttime = 0
-	Gl.change = 1
-	while 1:
-		if realtime:
-			localtime = int(time.time() - Gl.tzdiff)
-		if Gl.alarm_set:
-			if localtime%(24*HOUR) == Gl.alarm_time:
-				# Ring the alarm!
-				if Gl.debug:
-					print 'Rrrringg!'
-				Gl.alarm_on = 1
-				if Gl.alarm_cmd <> '':
-					d = os.system(Gl.alarm_cmd+' '+`Gl.alarm_time/3600`+' '+`(Gl.alarm_time/60)%60` + ' &')
-				Gl.change = 1
-				clearall()
-		if Gl.alarm_on:
-			if (localtime - Gl.alarm_time) % (24*HOUR) > 300:
-				# More than 5 minutes away from alarm
-				Gl.alarm_on = 0
-				if Gl.debug:
-					print 'Alarm turned off'
-				Gl.change = 1
-				clearall()
-				Gl.indices = R, G, B
-			else:
-				if localtime % 2 == 0:
-				  # Permute color indices
-				  Gl.indices = Gl.indices[2:] + Gl.indices[:2]
-				  Gl.change = 1
-		if Gl.gong_cmd <> '' and localtime%Gl.gong_int == 0:
-			d = os.system(Gl.gong_cmd+' '+`(localtime/3600)%24`+' '+`(localtime/60)%60` + ' &')
-		if localtime/Gl.update <> lasttime/Gl.update:
-			if Gl.debug: print 'new time'
-			Gl.change = 1
-		if Gl.change:
-			if Gl.debug: print 'drawing'
-			doit(localtime)
-			lasttime = localtime
-			Gl.change = 0
-		dev, data = qread()
-		if Gl.debug and dev <> TIMER0:
-			print dev, data
-		if dev == TIMER0:
-			if Gl.debug > 1:
-				print dev, data
-		elif dev == MOUSE3:
-			mousex = getvaluator(MOUSEX)
-			mousey = getvaluator(MOUSEY)
-			if mouseclick(3, data, mousex, mousey):
-				Gl.change = 1
-		elif dev == MOUSE2:
-			mousex = getvaluator(MOUSEX)
-			mousey = getvaluator(MOUSEY)
-			if mouseclick(2, data, mousex, mousey):
-				Gl.change = 1
-		elif dev == MOUSEX:
-			mousex = data
-			if Gl.mouse2down:
-				mouse2track(mousex, mousey)
-			if Gl.mouse3down:
-				mouse3track(mousex, mousey)
-		elif dev == MOUSEY:
-			mousey = data
-			if Gl.mouse2down:
-				mouse2track(mousex, mousey)
-			if Gl.mouse3down:
-				mouse3track(mousex, mousey)
-		elif dev == REDRAW or dev == REDRAWICONIC:
-			if Gl.debug:
-				if dev == REDRAW: print 'REDRAW'
-				else: print 'REDRAWICONIC'
-			reshapeviewport()
-			Gl.ox,Gl.oy = getorigin()
-			Gl.cx,Gl.cy = getsize()
-			Gl.change = 1
-			clearall()
-		elif dev == MENUBUTTON:
-			if Gl.debug: print 'MENUBUTTON'
-			handlemenu()
-		elif dev == WINFREEZE:
-			if Gl.debug: print 'WINFREEZE'
-			Gl.iconic = 1
-			noise(TIMER0, 60*60) # Redraw every 60 seconds only
-		elif dev == WINTHAW:
-			if Gl.debug: print 'WINTHAW'
-			Gl.iconic = 0
-			noise(TIMER0, Gl.timernoise)
-			Gl.change = 1
-		elif dev == ESCKEY or dev == WINSHUT or dev == WINQUIT:
-			if Gl.debug: print 'Exit'
-			sys.exit(0)
-
-def getoptions():
-	optlist, args = getopt.getopt(sys.argv[1:], 'A:a:B:bc:dFfG:g:n:sT:t:u:wCMYK')
-	for optname, optarg in optlist:
-		if optname == '-A':
-			Gl.fg = eval(optarg)	# Should be (r,g,b)
-		elif optname == '-a':
-			Gl.alarm_cmd = optarg
-		elif optname == '-B':
-			Gl.bg = eval(optarg)	# Should be (r,g,b)
-		elif optname == '-b':
-			Gl.border = 0
-		elif optname == '-c':
-			Gl.colormap = string.atoi(optarg)
-		elif optname == '-d':
-			Gl.debug = Gl.debug + 1
-			Gl.warnings = 1
-		elif optname == '-F':
-			Gl.foreground = 1
-		elif optname == '-f':
-			Gl.fullscreen = 1
-		elif optname == '-G':
-			Gl.gong_int = 60*string.atoi(optarg)
-		elif optname == '-g':
-			Gl.gong_cmd = optarg
-		elif optname == '-n':
-			Gl.nparts = string.atoi(optarg)
-		elif optname == '-s':
-			Gl.doublebuffer = 0
-		elif optname == '-T':
-			Gl.title = Gl.name = optarg
-		elif optname == '-t':
-			Gl.tzdiff = string.atoi(optarg)
-		elif optname == '-u':
-			Gl.update = string.atoi(optarg)
-		elif optname == '-w':
-			Gl.warnings = 1
-		elif optname == '-C':
-			Gl.cyan = Gl.colorsubset = 1
-		elif optname == '-M':
-			Gl.magenta = Gl.colorsubset = 1
-		elif optname == '-Y':
-			Gl.yellow = Gl.colorsubset = 1
-		elif optname == '-K':
-			Gl.black = Gl.colorsubset = 1
-		else:
-			print 'Unsupported option', optname
-	return args
-
-def usage(exc, msg):
-	if sys.argv:
-		progname = os.path.basename(sys.argv[0])
-	else:
-		progname = 'mclock'
-	#
-	print progname + ':',
-	if exc == string.atoi_error:
-		print 'non-numeric argument:',
-	print msg
-	#
-	print 'usage:', progname, '[options] [hh [mm [ss]]]'
-	#
-	print '-A r,g,b  : alarm background red,green,blue [255,0,0]'
-	print '-a cmd    : shell command executed when alarm goes off'
-	print '-B r,g,b  : background red,green,blue [0,0,0]'
-	print '            (-B SCREENBG uses the default screen background)'
-	print '-b        : suppress window border and title'
-	print '-c cmapid : select explicit colormap'
-	print '-d        : more debug output (implies -F, -w)'
-	print '-F        : run in foreground'
-	print '-f        : use full screen'
-	print '-G intrvl : interval between chimes in minutes [60]'
-	print '-g cmd    : shell command executed when chimes go off'
-	print '-s        : single buffer mode'
-	print '-w        : print various warnings'
-	print '-n nparts : number of parts [' + `NPARTS` + ']'
-	print '-T title  : alternate window title [\'' + TITLE + '\']'
-	print '-t tzdiff : time zone difference [' + `TZDIFF` + ']'
-	print '-u update : update interval [60]'
-	print '-CMYK     : Cyan, Magenta, Yellow or blacK overlay only'
-	print 'if hh [mm [ss]] is specified, display that time statically'
-	print 'on machines with < 12 bitplanes, -s is forced on'
-	#
-	sys.exit(2)
-
-def doit(localtime):
-	hands = makehands(localtime)
-	list = makelist(hands)
-	render(list, hands)
-
-def makehands(localtime):
-	localtime = localtime % (12*HOUR)
-	seconds_hand = MIDN + FULLC - (localtime*60) % FULLC
-	big_hand = (MIDN + FULLC - (localtime%HOUR)) % FULLC
-	little_hand = (MIDN + FULLC - ((localtime/12) % HOUR)) % FULLC
-	return little_hand, big_hand, seconds_hand
-
-def makelist(hands):
-	little_hand, big_hand, seconds_hand = hands
-	total = []
-	if Gl.cyan or not Gl.colorsubset:
-		total = total + makesublist(big_hand, Gl.indices[0])
-	if Gl.magenta or not Gl.colorsubset:
-		total = total + makesublist(little_hand, Gl.indices[1])
-	if Gl.yellow or not Gl.colorsubset:
-		total = total + makesublist(MIDN, Gl.indices[2])
-	total.sort()
-	return total
-
-def makesublist(first, icolor):
-	list = []
-	alpha = FULLC/Gl.nparts
-	a = first - alpha/2
-	for i in range(Gl.nparts):
-		angle = (a + i*alpha + FULLC) % FULLC
-		value = 255*(Gl.nparts-1-i)/(Gl.nparts-1)
-		list.append((angle, icolor, value))
-	list.sort()
-	a, icolor, value = list[0]
-	if a <> 0:
-		a, icolor, value = list[len(list)-1]
-		t = 0, icolor, value
-		list.insert(0, t)
-	return list
-
-def rgb_fg():
-	return Gl.fg
-	# Obsolete code:
-	if Gl.alarm_on:
-		return Gl.bg
-	else:
-		return Gl.fg
-
-def rgb_bg():
-	return Gl.bg
-	# Obsolete code:
-	if Gl.alarm_on:
-		return Gl.fg
-	else:
-		return Gl.bg
-
-def clearall():
-	Gl.c3i(rgb_bg())
-	clear()
-	if Gl.doublebuffer:
-		swapbuffers()
-		clear()
-
-def draw_alarm(color):
-	frontbuffer(TRUE)
-	Gl.c3i(color)
-	pushmatrix()
-	rotate(-((Gl.alarm_time/12)%3600), 'z')
-	bgnpolygon()
-	v2f( 0.00,1.00)
-	v2f( 0.04,1.05)
-	v2f(-0.04,1.05)
-	endpolygon()
-	popmatrix()
-	#
-	pushmatrix()
-	rotate(-((Gl.alarm_time)%3600), 'z')
-	bgnpolygon()
-	v2f( 0.00,1.05)
-	v2f( 0.07,1.10)
-	v2f(-0.07,1.10)
-	endpolygon()
-	popmatrix()
-	#
-	cmov2(-1.06, -1.06)
-	charstr(string.rjust(`Gl.alarm_time/3600`,2))
-	charstr(':')
-	charstr(string.zfill((Gl.alarm_time/60)%60,2))
-	frontbuffer(FALSE)
-
-def render(list, (little_hand, big_hand, seconds_hand)):
-	#
-	if Gl.colormap:
-		resetindex()
-	#
-	if not list:
-		Gl.c3i((255, 255, 255)) # White
-		circf(0.0, 0.0, 1.0)
-	else:
-		list.append((3600, 0, 255)) # Sentinel
-	#
-	rgb = [255, 255, 255]
-	a_prev = 0
-	for a, icolor, value in list:
-		if a <> a_prev:
-			[r, g, b] = rgb
-			if Gl.debug > 1:
-				print rgb, a_prev, a
-			Gl.c3i((r, g, b))
-			arcf(0.0, 0.0, 1.0, a_prev, a)
-		rgb[icolor] = value
-		a_prev = a
-	#
-	if Gl.black or not Gl.colorsubset:
-		#
-		# Draw the hands -- in black
-		#
-		Gl.c3i((0, 0, 0))
-		#
-		if Gl.update == 1 and not Gl.iconic:
-			# Seconds hand is only drawn if we update every second
-			pushmatrix()
-			rotate(seconds_hand, 'z')
-			bgnline()
-			v2f(0.0, 0.0)
-			v2f(1.0, 0.0)
-			endline()
-			popmatrix()
-		#
-		pushmatrix()
-		rotate(big_hand, 'z')
-		rectf(0.0, -0.01, 0.97, 0.01)
-		circf(0.0, 0.0, 0.01)
-		circf(0.97, 0.0, 0.01)
-		popmatrix()
-		#
-		pushmatrix()
-		rotate(little_hand, 'z')
-		rectf(0.04, -0.02, 0.63, 0.02)
-		circf(0.04, 0.0, 0.02)
-		circf(0.63, 0.0, 0.02)
-		popmatrix()
-		#
-		# Draw the alarm time, if set or being set
-		#
-		if Gl.alarm_set:
-			draw_alarm(rgb_fg())
-	#
-	if Gl.doublebuffer: swapbuffers()
-
-def makewindow():
-	#
-	if Gl.debug or Gl.foreground:
-		foreground()
-	#
-	if Gl.fullscreen:
-		scrwidth, scrheight = getgdesc(GD_XPMAX), getgdesc(GD_YPMAX)
-		prefposition(0, scrwidth-1, 0, scrheight-1)
-	else:
-		keepaspect(1, 1)
-		prefsize(80, 80)
-	#
-	if not Gl.border:
-		noborder()
-	wid = winopen(Gl.name)
-	wintitle(Gl.title)
-	#
-	if not Gl.fullscreen:
-		keepaspect(1, 1)
-		minsize(10, 10)
-		maxsize(2000, 2000)
-		iconsize(66, 66)
-		winconstraints()
-	#
-	nplanes = getplanes()
-	nmaps = getgdesc(GD_NMMAPS)
-	if Gl.warnings:
-		print nplanes, 'color planes,', nmaps, 'color maps'
-	#
-	if Gl.doublebuffer and not Gl.colormap and nplanes < 12:
-		if Gl.warnings: print 'forcing single buffer mode'
-		Gl.doublebuffer = 0
-	#
-	if Gl.colormap:
-		if not Gl.colormap:
-			Gl.colormap = nmaps - 1
-			if Gl.warnings:
-				print 'not enough color planes available',
-				print 'for RGB mode; forcing colormap mode'
-				print 'using color map number', Gl.colormap
-		if not Gl.colorsubset:
-			needed = 3
-		else:
-			needed = Gl.cyan + Gl.magenta + Gl.yellow
-		needed = needed*Gl.nparts
-		if Gl.bg <> (0, 0, 0):
-			needed = needed+1
-		if Gl.fg <> (0, 0, 0):
-			needed = needed+1
-		if Gl.doublebuffer:
-			if needed > available(nplanes/2):
-				Gl.doublebuffer = 0
-				if Gl.warnings:
-					print 'not enough colors available',
-					print 'for double buffer mode;',
-					print 'forcing single buffer mode'
-			else:
-				nplanes = nplanes/2
-		if needed > available(nplanes):
-			# Do this warning always
-			print 'still not enough colors available;',
-			print 'parts will be left white'
-			print '(needed', needed, 'but have only',
-			print available(nplanes), 'colors available)'
-	#
-	if Gl.doublebuffer:
-		doublebuffer()
-		gconfig()
-	#
-	if Gl.colormap:
-		Gl.c3i = pseudo_c3i
-		fixcolormap()
-	else:
-		Gl.c3i = c3i
-		RGBmode()
-		gconfig()
-	#
-	if Gl.fullscreen:
-		# XXX Should find out true screen size using getgdesc()
-		ortho2(-1.1*1.280, 1.1*1.280, -1.1*1.024, 1.1*1.024)
-	else:
-		ortho2(-1.1, 1.1, -1.1, 1.1)
-	#
-	return wid
-
-def available(nplanes):
-	return pow(2, nplanes) - 1	# Reserve one pixel for black
-
-def fixcolormap():
-	multimap()
-	gconfig()
-	nplanes = getplanes()
-	if Gl.warnings:
-		print 'multimap mode has', nplanes, 'color planes'
-	imap = Gl.colormap
-	Gl.startindex = pow(2, nplanes) - 1
-	Gl.stopindex = 1
-	setmap(imap)
-	mapcolor(0, 0, 0, 0) # Fixed entry for black
-	if Gl.bg <> (0, 0, 0):
-		r, g, b = Gl.bg
-		mapcolor(1, r, g, b) # Fixed entry for Gl.bg
-		Gl.stopindex = 2
-	if Gl.fg <> (0, 0, 0):
-		r, g, b = Gl.fg
-		mapcolor(2, r, g, b) # Fixed entry for Gl.fg
-		Gl.stopindex = 3
-	Gl.overflow_seen = 0
-	resetindex()
-
-def resetindex():
-	Gl.index = Gl.startindex
-
-r0g0b0 = (0, 0, 0)
-
-def pseudo_c3i(rgb):
-	if rgb == r0g0b0:
-		index = 0
-	elif rgb == Gl.bg:
-		index = 1
-	elif rgb == Gl.fg:
-		index = 2
-	else:
-		index = definecolor(rgb)
-	color(index)
-
-def definecolor(rgb):
-	index = Gl.index
-	if index < Gl.stopindex:
-		if Gl.debug: print 'definecolor hard case', rgb
-		# First see if we already have this one...
-		for index in range(Gl.stopindex, Gl.startindex+1):
-			if rgb == getmcolor(index):
-				if Gl.debug: print 'return', index
-				return index
-		# Don't clobber reserverd colormap entries
-		if not Gl.overflow_seen:
-			# Shouldn't happen any more, hence no Gl.warnings test
-			print 'mclock: out of colormap entries'
-			Gl.overflow_seen = 1
-		return Gl.stopindex
-	r, g, b = rgb
-	if Gl.debug > 1: print 'mapcolor', (index, r, g, b)
-	mapcolor(index, r, g, b)
-	Gl.index = index - 1
-	return index
-
-# Compute n**i
-def pow(n, i):
-	x = 1
-	for j in range(i): x = x*n
-	return x
-
-def mouseclick(mouse, updown, x, y):
-	if updown == 1:
-		# mouse button came down, start tracking
-		if Gl.debug:
-			print 'mouse', mouse, 'down at', x, y
-		if mouse == 2:
-			Gl.mouse2down = 1
-			mouse2track(x, y)
-		elif mouse == 3:
-			Gl.mouse3down = 1
-			mouse3track(x, y)
-		else:
-			print 'fatal error'
-		qdevice(MOUSEX)
-		qdevice(MOUSEY)
-		return 0
-	else:
-		# mouse button came up, stop tracking
-		if Gl.debug:
-			print 'mouse', mouse, 'up at', x, y
-		unqdevice(MOUSEX)
-		unqdevice(MOUSEY)
-		if mouse == 2:
-			mouse2track(x, y)
-			Gl.mouse2down = 0
-		elif mouse == 3:
-			mouse3track(x, y)
-			Gl.mouse3down = 0
-		else:
-			print 'fatal error'
-		Gl.alarm_set = 1
-		return 1
-
-def mouse3track(x, y):
-	# first compute polar coordinates from x and y
-	cx, cy = Gl.ox + Gl.cx/2, Gl.oy + Gl.cy/2
-	x, y = x - cx, y - cy
-	if (x, y) == (0, 0): return	# would cause an exception
-	minutes = int(30.5 + 30.0*math.atan2(float(-x), float(-y))/pi)
-	if minutes == 60: minutes = 0
-	a,b = Gl.alarm_minutes/15, minutes/15
-	if (a,b) == (0,3):
-		# Moved backward through 12 o'clock:
-		Gl.alarm_hours = Gl.alarm_hours - 1
-		if Gl.alarm_hours < 0: Gl.alarm_hours = Gl.alarm_hours + 24
-	if (a,b) == (3,0):
-		# Moved forward through 12 o'clock:
-		Gl.alarm_hours = Gl.alarm_hours + 1
-		if Gl.alarm_hours >= 24: Gl.alarm_hours = Gl.alarm_hours - 24
-	Gl.alarm_minutes = minutes
-	seconds = Gl.alarm_hours * HOUR + Gl.alarm_minutes * MINUTE
-	if seconds <> Gl.alarm_time:
-		draw_alarm(rgb_bg())
-		Gl.alarm_time = seconds
-		draw_alarm(rgb_fg())
-
-def mouse2track(x, y):
-	# first compute polar coordinates from x and y
-	cx, cy = Gl.ox + Gl.cx/2, Gl.oy + Gl.cy/2
-	x, y = x - cx, y - cy
-	if (x, y) == (0, 0): return	# would cause an exception
-	hours = int(6.5 - float(Gl.alarm_minutes)/60.0 + 6.0*math.atan2(float(-x), float(-y))/pi)
-	if hours == 12: hours = 0
-	if (Gl.alarm_hours,hours) == (0,11):
-		# Moved backward through midnight:
-		Gl.alarm_hours = 23
-	elif (Gl.alarm_hours,hours) == (12,11):
-		# Moved backward through noon:
-		Gl.alarm_hours = 11
-	elif (Gl.alarm_hours,hours) == (11,0):
-		# Moved forward through noon:
-		Gl.alarm_hours = 12
-	elif (Gl.alarm_hours,hours) == (23,0):
-		# Moved forward through midnight:
-		Gl.alarm_hours = 0
-	elif Gl.alarm_hours < 12:
-		Gl.alarm_hours = hours
-	else:
-		Gl.alarm_hours = hours + 12
-	seconds = Gl.alarm_hours * HOUR + Gl.alarm_minutes * MINUTE
-	if seconds <> Gl.alarm_time:
-		draw_alarm(rgb_bg())
-		Gl.alarm_time = seconds
-		draw_alarm(rgb_fg())
-
-def initmenu():
-	Gl.pup = pup = newpup()
-	addtopup(pup, 'M Clock%t|Alarm On/Off|Seconds Hand On/Off|Quit', 0)
-
-def handlemenu():
-	item = dopup(Gl.pup)
-	if item == 1:
-		# Toggle alarm
-		if Gl.alarm_set:
-			Gl.alarm_set = 0
-			Gl.alarm_on = 0
-		else:
-			Gl.alarm_set = 1
-		Gl.change = 1
-		clearall()
-	elif item == 2:
-		# Toggle Seconds Hand
-		if Gl.update == 1:
-			Gl.update = 60
-			Gl.timernoise = 60
-		else:
-			Gl.update = 1
-			Gl.timernoise = 6
-		Gl.change = 1
-	elif item == 3:
-		if Gl.debug: print 'Exit'
-		sys.exit(0)
-
-main()
diff --git a/Demo/sgi/gl/mixing.py b/Demo/sgi/gl/mixing.py
deleted file mode 100755
index 9a4c9c1..0000000
--- a/Demo/sgi/gl/mixing.py
+++ /dev/null
@@ -1,116 +0,0 @@
-#! /usr/bin/env python
-
-# Use Gouraud shading to mix colors.  Requires Z-buffer.
-# It changes the color assignments so fast that you see white.
-# Left button pauses, middle rotates the square.  ESC to quit.
-# Experiment with a larger window (too slow) or smaller window (really white).
-
-from GL import *
-from gl import *
-import DEVICE
-from math import *
-
-#
-#  tekenvlak : draw a square. with bgnpolygon
-#
-def tekenvlak (vc) :
-	bgnpolygon()
-	#vcarray (vc)
-	for i in vc :
-		c3f (i[1])
-		v3f (i[0])
-	endpolygon()
-
-#
-# tekendoos : draw a box
-#
-def tekendoos (col) :
-	v = [(-5.0,0.0,0.0),(0.0,5.0,0.0),(5.0,0.0,0.0),(0.0,-5.0,0.0)]
-	vc = [(v[0],col[0]),(v[1],col[1]),(v[2],col[2]),(v[3],col[1])]
-	tekenvlak (vc)
-
-#
-# initialize gl
-#
-def initgl () :
-	#
-	# open window
-	#
-	foreground ()
-	keepaspect (1, 1)
-	prefposition (100, 500, 100, 500)
-	w = winopen ('PYTHON RGB')
-	keepaspect (1, 1)
-	winconstraints()
-	#
-	# configure pipeline (2buf, GOURAUD and RGBmode)
-	#
-	doublebuffer ()
-	zbuffer (1)
-	shademodel (GOURAUD)
-	RGBmode ()
-	gconfig ()
-	#
-	# set viewing
-	#
-	perspective (900, 1, 1.0, 10.0)
-	polarview (10.0, 0, 0, 0)
-	#
-	# ask for the REDRAW and ESCKEY events
-	#
-	qdevice(DEVICE.MOUSE2)
-	qdevice(DEVICE.MOUSE3)
-	qdevice(DEVICE.REDRAW)
-	qdevice(DEVICE.ESCKEY)
-
-
-#
-# the color black
-#
-black = 0
-#
-# GoForIT : use 2buf to redraw the object 2n times. index i is used as 
-# the (smoothly changing) rotation angle
-#
-def GoForIt(i) :
-	col = [(255.0,0.0,0.0), (0.0,255.0,0.0), (0.0,0.0,255.0)]
-	twist = 0
-	freeze = 1
-	while 1 :
-		if freeze <> 0 :
-			col[0],col[1],col[2] = col[1],col[2],col[0]
-		#
-		# clear z-buffer and clear background to light-blue
-		#
-		zclear()
-		cpack (black)
-		clear()
-		#
-		tekendoos (col)
-		#
-		swapbuffers()
-		#
-		if qtest() <> 0 :
-			dev, val = qread()
-			if dev == DEVICE.ESCKEY :
-				break
-			elif dev == DEVICE.REDRAW :
-				reshapeviewport ()
-			elif dev == DEVICE.MOUSE2 and val <> 0 :
-				twist = twist + 30
-				perspective (900, 1, 1.0, 10.0)
-				polarview (10.0, 0, 0, twist)
-			elif dev == DEVICE.MOUSE3 and val <> 0 :
-				freeze = 1 - freeze
-
-
-# the main program
-#
-def main () :
-	initgl ()
-	GoForIt (0)
-
-#
-# exec main
-#
-main  ()
diff --git a/Demo/sgi/gl/nurbs.py b/Demo/sgi/gl/nurbs.py
deleted file mode 100755
index 6efef48..0000000
--- a/Demo/sgi/gl/nurbs.py
+++ /dev/null
@@ -1,171 +0,0 @@
-#! /usr/bin/env python
-
-# Rotate a 3D surface created using NURBS.
-#
-# Press left mouse button to toggle surface trimming.
-# Press ESC to quit.
-#
-# See the GL manual for an explanation of NURBS.
-
-from gl import *
-from GL import *
-from DEVICE import *
-
-TRUE = 1
-FALSE = 0
-ORDER = 4
-
-idmat = [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]
-
-surfknots = [-1, -1, -1, -1, 1, 1, 1, 1]
-
-def make_ctlpoints():
-	c = []
-	#
-	ci = []
-	ci.append((-2.5,  -3.7,  1.0))
-	ci.append((-1.5,  -3.7,  3.0))
-	ci.append((1.5,  -3.7, -2.5))
-	ci.append((2.5,  -3.7,  -0.75))
-	c.append(ci)
-	#
-	ci = []
-	ci.append((-2.5,  -2.0,  3.0))
-	ci.append((-1.5,  -2.0,  4.0))
-	ci.append((1.5,  -2.0,  -3.0))
-	ci.append((2.5,  -2.0,  0.0))
-	c.append(ci)
-	#
-	ci = []
-	ci.append((-2.5, 2.0,  1.0))
-	ci.append((-1.5, 2.0,  0.0))
-	ci.append((1.5,  2.0,  -1.0))
-	ci.append((2.5,  2.0,  2.0))
-	c.append(ci)
-	#
-	ci = []
-	ci.append((-2.5,  2.7,  1.25))
-	ci.append((-1.5,  2.7,  0.1))
-	ci.append((1.5,  2.7,  -0.6))
-	ci.append((2.5,  2.7,  0.2))
-	c.append(ci)
-	#
-	return c
-
-ctlpoints = make_ctlpoints()
-
-trimknots = [0., 0., 0.,  1., 1.,  2., 2.,  3., 3.,   4., 4., 4.]
-
-def make_trimpoints():
-	c = []
-	c.append((1.0, 0.0, 1.0))
-	c.append((1.0, 1.0, 1.0))
-	c.append((0.0, 2.0, 2.0))
-	c.append((-1.0, 1.0, 1.0))
-	c.append((-1.0, 0.0, 1.0))
-	c.append((-1.0, -1.0, 1.0))
-	c.append((0.0, -2.0, 2.0))
-	c.append((1.0, -1.0, 1.0) )
-	c.append((1.0, 0.0, 1.0))
-	return c
-
-trimpoints = make_trimpoints()
-
-def main():
-	init_windows()
-	setup_queue()
-	make_lights()
-	init_view()
-	#
-	set_scene()
-	setnurbsproperty( N_ERRORCHECKING, 1.0 )
-	setnurbsproperty( N_PIXEL_TOLERANCE, 50.0 )
-	trim_flag = 0
-	draw_trim_surface(trim_flag)
-	#
-	while 1:
-		while qtest():
-			dev, val = qread()
-			if dev == ESCKEY:
-				return
-			elif dev == WINQUIT:
-				dglclose(-1)	# this for DGL only
-				return
-			elif dev == REDRAW:
-				reshapeviewport()
-				set_scene()
-				draw_trim_surface(trim_flag)
-			elif dev == LEFTMOUSE:
-				if val:
-					trim_flag = (not trim_flag)
-		set_scene()
-		draw_trim_surface(trim_flag)
-
-def init_windows():
-	foreground()
-	#prefposition(0, 500, 0, 500)
-	wid = winopen('nurbs')
-	wintitle('NURBS Surface')
-	doublebuffer()
-	RGBmode()
-	gconfig()
-	lsetdepth(0x000, 0x7fffff)
-	zbuffer( TRUE )
-
-def setup_queue():
-	qdevice(ESCKEY)
-	qdevice(REDRAW)
-	qdevice(RIGHTMOUSE)
-	qdevice(WINQUIT)
-	qdevice(LEFTMOUSE) #trimming
-
-def init_view():
-	mmode(MPROJECTION)
-	ortho( -4., 4., -4., 4., -4., 4. )
-	#
-	mmode(MVIEWING)
-	loadmatrix(idmat)
-	#
-	lmbind(MATERIAL, 1)
-
-def set_scene():
-	lmbind(MATERIAL, 0)
-	RGBcolor(150,150,150)
-	lmbind(MATERIAL, 1)
-	clear()
-	zclear()
-	#
-	rotate( 100, 'y' )
-	rotate( 100, 'z' )
-
-def draw_trim_surface(trim_flag):
-	bgnsurface()
-	nurbssurface(surfknots, surfknots, ctlpoints, ORDER, ORDER, N_XYZ)
-	if trim_flag:
-		bgntrim()
-		nurbscurve(trimknots, trimpoints, ORDER-1, N_STW)
-		endtrim()
-	endsurface()
-	swapbuffers()
-
-def make_lights():
-	lmdef(DEFLMODEL,1,[])
-	lmdef(DEFLIGHT,1,[])
-	#
-	# define material #1
-	#
-	a = []
-	a = a + [EMISSION, 0.0, 0.0, 0.0]
-	a = a + [AMBIENT,  0.1, 0.1, 0.1]
-	a = a + [DIFFUSE,  0.6, 0.3, 0.3]
-	a = a + [SPECULAR,  0.0, 0.6, 0.0]
-	a = a + [SHININESS, 2.0]
-	a = a + [LMNULL]
-	lmdef(DEFMATERIAL, 1, a)
-	#
-	# turn on lighting
-	#
-	lmbind(LIGHT0, 1)
-	lmbind(LMODEL, 1)
-
-main()
diff --git a/Demo/sgi/gl/zrgb.py b/Demo/sgi/gl/zrgb.py
deleted file mode 100755
index 2ad68c9..0000000
--- a/Demo/sgi/gl/zrgb.py
+++ /dev/null
@@ -1,168 +0,0 @@
-#! /usr/bin/env python
-
-#   zrgb  (Requires Z buffer.)
-#
-# This program demostrates zbuffering 3 intersecting RGB polygons while
-# in doublebuffer mode where, movement of the mouse with the LEFTMOUSE 
-# button depressed will, rotate the 3 polygons. This is done by compound
-# rotations allowing continuous screen-oriented rotations. 
-#
-#    Press the "Esc" key to exit.  
-
-from gl import *
-from GL import *
-from DEVICE import *
-
-
-idmat=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]
-
-def main() :
-	#
-	# old and new mouse position
-	#
-	#
-	mode = 0
-	omx = 0
-	mx = 0
-	omy = 0
-	my = 0
-	#
-	objmat=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]
-	#
-	initialize ()
-	#
-	draw_scene (objmat)
-	#
-	while (1) :
-		#
-		dev, val = qread()
-		#
-		if dev == ESCKEY :
-			if val :
-				break	
-			# exit when key is going up, not down
-			# this avoids the scenario where a window 
-			# underneath this program's window
-			# would otherwise "eat up" the up-
-			# event of the Esc key being released
-			return        
-			#
-		elif dev == REDRAW :
-			reshapeviewport()
-			draw_scene(objmat)
-			#
-		elif dev == LEFTMOUSE:
-			omx = mx
-			omy = my
-			if val :
-				mode = 1
-			else :
-				mode = 0
-		elif dev == MOUSEX :
-			omx = mx
-			mx = val
-			#print omx, mx
-			objmat = update_scene(objmat,mx,my,omx,omy,mode)
-			#
-		elif dev == MOUSEY :
-			omy = my
-			my = val
-			#print omy, my
-			objmat = update_scene(objmat,mx,my,omx,omy,mode)
-			#
-
-
-def initialize () :
-	#
-	foreground ()
-	keepaspect(5, 4)
-	w = winopen('Zbuffered RGB')
-	#
-	doublebuffer()
-	RGBmode()
-	gconfig()
-	zbuffer(1)
-	lsetdepth(0x0, 0x7FFFFF)
-	#
-	qdevice(ESCKEY)
-	qdevice(LEFTMOUSE)
-	qdevice(MOUSEX)
-	qdevice(MOUSEY)
-
-def update_scene (mat, mx, my, omx, omy, mode) :
-	#
-	if mode == 1 :
-		mat = orient(mat, mx, my, omx, omy)
-		draw_scene(mat)
-	return mat
-
-def orient (mat, mx, my, omx, omy) :
-	#
-	#
-	pushmatrix()
-	loadmatrix(idmat)
-	#
-	if mx - omx : rot (float (mx - omx), 'y')
-	if omy - my : rot (float (omy - my), 'x')
-	#
-	multmatrix(mat)
-	mat = getmatrix()
-	#
-	popmatrix()
-	#
-	return mat
-
-def draw_scene (mat) :
-	RGBcolor(40, 100, 200)
-	clear()
-	zclear()
-	#
-	perspective(400, 1.25, 30.0, 60.0)
-	translate(0.0, 0.0, -40.0)
-	multmatrix(mat)
-	#
-	# skews original view to show all polygons
-	#
-	rotate(-580, 'y')
-	draw_polys()
-	#
-	swapbuffers()
-
-polygon1 = [(-10.0,-10.0,0.0),(10.0,-10.0,0.0),(-10.0,10.0,0.0)]
-
-polygon2 = [(0.0,-10.0,-10.0),(0.0,-10.0,10.0),(0.0,5.0,-10.0)]
-
-polygon3 = [(-10.0,6.0,4.0),(-10.0,3.0,4.0),(4.0,-9.0,-10.0),(4.0,-6.0,-10.0)]
-
-def draw_polys():
-	bgnpolygon()
-	cpack(0x0)
-	v3f(polygon1[0])
-	cpack(0x007F7F7F)
-	v3f(polygon1[1])
-	cpack(0x00FFFFFF)
-	v3f(polygon1[2])
-	endpolygon()
-	#
-	bgnpolygon()
-	cpack(0x0000FFFF)
-	v3f(polygon2[0])
-	cpack(0x007FFF00)
-	v3f(polygon2[1])
-	cpack(0x00FF0000)
-	v3f(polygon2[2])
-	endpolygon()
-	#
-	bgnpolygon()
-	cpack(0x0000FFFF)
-	v3f(polygon3[0])
-	cpack(0x00FF00FF)
-	v3f(polygon3[1])
-	cpack(0x00FF0000)
-	v3f(polygon3[2])
-	cpack(0x00FF00FF)
-	v3f(polygon3[3])
-	endpolygon()
-
-
-main ()