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

1 files changed, 0 insertions, 736 deletions

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()