starting over

8 files changed, 1213 insertions, 1213 deletions

diff --git a/demo/sgi/gl/README b/demo/sgi/gl/README
index f191cf5..a2cd17a 100644
--- a/demo/sgi/gl/README
+++ b/demo/sgi/gl/README
@@ -1,22 +1,22 @@
 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
+GL programming in Python.  Most demos require the Z-buffer (aka
 24-bitplane) option.
 
-backface Demonstrates the 'backface' GL function.
+backface	Demonstrates the 'backface' GL function.
 
-kites Show 3 flying kites. Demonstrates the rendering speed
- obtainable by Python programs.
+kites		Show 3 flying kites.  Demonstrates the rendering speed
+		obtainable by Python programs.
 
-mclock A colorful clock with more options than you can
- remember. Works on 8-bit machines (but allows more
- colors on 24-bit machines).
+mclock		A colorful clock with more options than you can
+		remember.  Works on 8-bit machines (but allows more
+		colors on 24-bit machines).
 
-mixing Demonstrates the effect of color mixing: through
- frequent color switching it gives the effect of white
- light.
+mixing		Demonstrates the effect of color mixing: through
+		frequent color switching it gives the effect of white
+		light.
 
-nurbs A simple demonstration of the 'nurbs' GL functions.
+nurbs		A simple demonstration of the 'nurbs' GL functions.
 
-zrgb Displays a 3-D Gouraud-shaded figure which can be moved
- around with the mouse.
+zrgb		Displays a 3-D Gouraud-shaded figure which can be moved
+		around with the mouse.
diff --git a/demo/sgi/gl/backface.py b/demo/sgi/gl/backface.py
index 5936f75..8192589 100755
--- a/demo/sgi/gl/backface.py
+++ b/demo/sgi/gl/backface.py
@@ -1,9 +1,9 @@
 #! /ufs/guido/bin/sgi/python
 
-# backface
+#   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.
+#   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 *
@@ -13,128 +13,128 @@ 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)
+	#
+	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)
+	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()
+	#
+	# 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()
+	#
+	pushmatrix()
+	rotate(2*x, 'x')
+	rotate(2*y, 'y')
+	color(BLACK)
+	clear()
+	cube()        
+	popmatrix()
+	swapbuffers()
 
 
 main ()
diff --git a/demo/sgi/gl/kites.py b/demo/sgi/gl/kites.py
index 764ad2c..36dc5d7 100755
--- a/demo/sgi/gl/kites.py
+++ b/demo/sgi/gl/kites.py
@@ -12,15 +12,15 @@
 #
 # This program show 3 kites flying around the screen. It uses
 #
-# * bgnpolygon, endpolygon
-# * v3, n3
-# * lmdef, lmbind
+# 	* bgnpolygon, endpolygon
+# 	* v3, n3
+# 	* lmdef, lmbind
 #
 # Usage :
-#
-# ESC -> exit program
-# MOUSE3 -> freeze toggle
-# MOUSE2 -> one step (use this in freeze state)
+# 
+# 	ESC 	-> exit program
+# 	MOUSE3 	-> freeze toggle
+# 	MOUSE2 	-> one step (use this in freeze state)
 
 from GL import *
 from gl import *
@@ -32,28 +32,28 @@ from math import *
 # 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()
+	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 contructor 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
+	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
@@ -64,10 +64,10 @@ kite = mkobj ()
 # drawobject : draw a triangle. with bgnpolygon
 #
 def drawobject () :
- #
- bgnpolygon()
- vnarray (kite)
- endpolygon()
+	#
+	bgnpolygon()
+	vnarray (kite)
+	endpolygon()
 
 #
 # identity matrix
@@ -75,7 +75,7 @@ def drawobject () :
 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
+# the rgb-value of light-blue 
 #
 LightBlue = (43,169,255)
 
@@ -102,93 +102,93 @@ model = [AMBIENT,0.2,0.2,0.2,LMNULL]
 # 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
+	#
+	# 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
+	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)
+	initgl ()
+	GoForIt (0)
 
 #
 # exec main
 #
-main ()
+main  ()
diff --git a/demo/sgi/gl/mclock.doc b/demo/sgi/gl/mclock.doc
index 610e9ab..256e062 100644
--- a/demo/sgi/gl/mclock.doc
+++ b/demo/sgi/gl/mclock.doc
@@ -8,7 +8,7 @@ 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
+alarm and a gong.  These may require some explanation beyond what's in
 the usage message.
 
 Menu
@@ -19,37 +19,37 @@ 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
+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:
+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
+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
+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
+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'
+	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
+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
+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!)
diff --git a/demo/sgi/gl/mclock.py b/demo/sgi/gl/mclock.py
index 806511c..43b219c 100755
--- a/demo/sgi/gl/mclock.py
+++ b/demo/sgi/gl/mclock.py
@@ -29,701 +29,701 @@ from math import pi
 import math
 import posix
 
-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
+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
+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
+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'
-TZDIFF = -1*HOUR # <--- change this to reflect your local time zone
+TZDIFF = -1*HOUR	# <--- change this to reflect your local time zone
 
 # 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.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)
+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.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 = 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 = posix.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 = posix.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)
+	#
+	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 = 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 = posix.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 = posix.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 = 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
+	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 = 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 = 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, -c and -s are forced on'
- #
- sys.exit(2)
+	if sys.argv:
+		progname = 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, -c and -s are forced on'
+	#
+	sys.exit(2)
 
 def doit(localtime):
- hands = makehands(localtime)
- list = makelist(hands)
- render(list, hands)
+	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
+	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(little_hand, big_hand, seconds_hand):
- 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
+	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
+	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
+	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
+	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()
+	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)
+	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()
+	#
+	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:
- # XXX Should find out true screen size using getgdesc()
- prefposition(0, 1279, 0, 1023)
- else:
- keepaspect(1, 1)
- minsize(64, 64)
- #
- if not Gl.border:
- noborder()
- wid = winopen(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 nplanes < 12 or 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
+	#
+	if Gl.debug or Gl.foreground:
+		foreground()
+	#
+	if Gl.fullscreen:
+		# XXX Should find out true screen size using getgdesc()
+		prefposition(0, 1279, 0, 1023)
+	else:
+		keepaspect(1, 1)
+		minsize(64, 64)
+	#
+	if not Gl.border:
+		noborder()
+	wid = winopen(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 nplanes < 12 or 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
+	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()
+	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
+	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)
+	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
+	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
+	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
+	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())
+	# 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())
+	# 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)
+	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)
+	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
index 294e65f..85af96c 100755
--- a/demo/sgi/gl/mixing.py
+++ b/demo/sgi/gl/mixing.py
@@ -1,8 +1,8 @@
 #! /ufs/guido/bin/sgi/python
 
-# Use Gouraud shading to mix colors. Requires Z-buffer.
+# 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.
+# 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 *
@@ -11,57 +11,57 @@ import DEVICE
 from math import *
 
 #
-# tekenvlak : draw a square. with bgnpolygon
+#  tekenvlak : draw a square. with bgnpolygon
 #
 def tekenvlak (vc) :
- bgnpolygon()
- #vcarray (vc)
- for i in vc :
- c3f (i[1])
- v3f (i[0])
- endpolygon()
+	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)
+	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)
+	#
+	# 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)
 
 
 #
@@ -69,48 +69,48 @@ def initgl () :
 #
 black = 0
 #
-# GoForIT : use 2buf to redraw the object 2n times. index i is used as
+# 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
+	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)
+	initgl ()
+	GoForIt (0)
 
 #
 # exec main
 #
-main ()
+main  ()
diff --git a/demo/sgi/gl/nurbs.py b/demo/sgi/gl/nurbs.py
index ee48e23..dbcc18e 100755
--- a/demo/sgi/gl/nurbs.py
+++ b/demo/sgi/gl/nurbs.py
@@ -20,152 +20,152 @@ 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
+	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.]
+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
+	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)
+	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 )
+	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
+	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)
+	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' )
+	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()
+	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)
+	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
index c3f934a..a49b86b 100755
--- a/demo/sgi/gl/zrgb.py
+++ b/demo/sgi/gl/zrgb.py
@@ -1,13 +1,13 @@
 #! /ufs/guido/bin/sgi/python
 
-# zrgb (Requires Z buffer.)
+#   zrgb  (Requires Z buffer.)
 #
 # This program demostrates zbuffering 3 intersecting RGB polygons while
-# in doublebuffer mode where, movement of the mouse with the LEFTMOUSE
+# 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.
+# rotations allowing continuous screen-oriented rotations. 
 #
-# Press the "Esc" key to exit.
+#    Press the "Esc" key to exit.  
 
 from gl import *
 from GL import *
@@ -19,115 +19,115 @@ objmat=[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]
 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 main() :
- #
- # old and new mouse position
- #
- #
- mode = 0
- omx = 0
- mx = 0
- omy = 0
- my = 0
- #
- 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)
- #
+	#
+	# old and new mouse position
+	#
+	#
+	mode = 0
+	omx = 0
+	mx = 0
+	omy = 0
+	my = 0
+	#
+	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)
+	#
+	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
+	#
+	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
+	#
+	#
+	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()
+	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)]
 
@@ -136,34 +136,34 @@ 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()
+	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 ()