Committed a more or less working version.

6 files changed, 521 insertions, 0 deletions

diff --git a/Mac/Lib/test/aete.py b/Mac/Lib/test/aete.py
new file mode 100644
index 0000000..5a91d89
--- /dev/null
+++ b/Mac/Lib/test/aete.py
@@ -0,0 +1,402 @@
+# Look for scriptable applications -- that is, applications with an 'aete' resource
+# Also contains (partially) reverse engineered 'aete' resource decoding
+
+import MacOS
+import os
+import string
+import sys
+import types
+import StringIO
+
+from Res import *
+
+def main():
+	filename = raw_input("Listing file? (default stdout): ")
+	redirect(filename, realmain)
+
+def redirect(filename, func, *args):
+	f = filename and open(filename, 'w')
+	save_stdout = sys.stdout
+	try:
+		if f: sys.stdout = f
+		return apply(func, args)
+	finally:
+		sys.stdout = save_stdout
+		if f: f.close()
+
+def realmain():
+	#list('C:Tao AppleScript:Finder Liaison:Finder Liaison 1.0')
+	#list('C:Internet:Eudora 1.4.2:Eudora1.4.2')
+	list('E:Excel 4.0:Microsoft Excel')
+	#list('C:Internet:Netscape 1.0N:Netscape 1.0N')
+	#find('C:')
+	#find('D:')
+	#find('E:')
+	#find('F:')
+
+def find(dir, maxlevel = 5):
+	hits = []
+	cur = CurResFile()
+	names = os.listdir(dir)
+	tuples = map(lambda x: (os.path.normcase(x), x), names)
+	tuples.sort()
+	names = map(lambda (x, y): y, tuples)
+	for name in names:
+		if name in (os.curdir, os.pardir): continue
+		fullname = os.path.join(dir, name)
+		if os.path.islink(fullname):
+			pass
+		if os.path.isdir(fullname):
+			if maxlevel > 0:
+				sys.stderr.write("        %s\n" % `fullname`)
+				hits = hits + find(fullname, maxlevel-1)
+		else:
+			ctor, type = MacOS.GetCreatorAndType(fullname)
+			if type == 'APPL':
+				sys.stderr.write("    %s\n" % `fullname`)
+				try:
+					rf = OpenRFPerm(fullname, 0, '\1')
+				except MacOS.Error, msg:
+					print "Error:", fullname, msg
+					continue
+				UseResFile(rf)
+				n = Count1Resources('aete')
+				if rf <> cur:
+					CloseResFile(rf)
+					UseResFile(cur)
+				if n > 1:
+					hits.append(fullname)
+					sys.stderr.write("YES!  %d in %s\n" % (n, `fullname`))
+					list(fullname)
+	return hits
+
+def list(fullname):
+	cur = CurResFile()
+	rf = OpenRFPerm(fullname, 0, '\1')
+	try:
+		UseResFile(rf)
+		resources = []
+		for i in range(Count1Resources('aete')):
+			res = Get1IndResource('aete', 1+i)
+			resources.append(res)
+		for i in range(Count1Resources('aeut')):
+			res = Get1IndResource('aeut', 1+i)
+			resources.append(res)
+		print "\nLISTING aete+aeut RESOURCE IN", `fullname`
+		for res in resources:
+			print res.GetResInfo()
+			data = res.data
+			try:
+				aete = decode(data)
+				showaete(aete)
+				f = StringIO.StringIO()
+				putaete(f, aete)
+				newdata = f.getvalue()
+				if len(newdata) == len(data):
+					if newdata == data:
+						print "putaete created identical data"
+					else:
+						newaete = decode(newdata)
+						if newaete == aete:
+							print "putaete created equivalent data"
+						else:
+							print "putaete failed the test:"
+							showaete(newaete)
+				else:
+					print "putaete created different data:"
+					print `newdata`
+			except:
+				import traceback
+				traceback.print_exc()
+			sys.stdout.flush()
+	finally:
+		if rf <> cur:
+			CloseResFile(rf)
+			UseResFile(cur)
+
+def decode(data):
+	f = StringIO.StringIO(data)
+	aete = generic(getaete, f)
+	aete = simplify(aete)
+	processed = f.tell()
+	unprocessed = len(f.read())
+	total = f.tell()
+	if unprocessed:
+		sys.stderr.write("%d processed + %d unprocessed = %d total\n" %
+		                 (processed, unprocessed, total))
+	return aete
+
+def simplify(item):
+	if type(item) is types.ListType:
+		return map(simplify, item)
+	elif type(item) == types.TupleType and len(item) == 2:
+		return simplify(item[1])
+	else:
+		return item
+
+
+# Here follows the aete resource decoder.
+# It is presented bottom-up instead of top-down because there are  direct
+# references to the lower-level part-decoders from the high-level part-decoders.
+
+def getword(f, *args):
+	getalign(f)
+	s = f.read(2)
+	if len(s) < 2:
+		raise EOFError, 'in getword' + str(args)
+	return (ord(s[0])<<8) | ord(s[1])
+
+def getlong(f, *args):
+	getalign(f)
+	s = f.read(4)
+	if len(s) < 4:
+		raise EOFError, 'in getlong' + str(args)
+	return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
+
+def getostype(f, *args):
+	getalign(f)
+	s = f.read(4)
+	if len(s) < 4:
+		raise EOFError, 'in getostype' + str(args)
+	return s
+
+def getpstr(f, *args):
+	c = f.read(1)
+	if len(c) < 1:
+		raise EOFError, 'in getpstr[1]' + str(args)
+	nbytes = ord(c)
+	if nbytes == 0: return ''
+	s = f.read(nbytes)
+	if len(s) < nbytes:
+		raise EOFError, 'in getpstr[2]' + str(args)
+	return s
+
+def getalign(f):
+	if f.tell() & 1:
+		c = f.read(1)
+		##if c <> '\0':
+		##	print 'align:', `c`
+
+def getlist(f, description, getitem):
+	count = getword(f)
+	list = []
+	for i in range(count):
+		getalign(f)
+		list.append(generic(getitem, f))
+	return list
+
+def alt_generic(what, f, *args):
+	print "generic", `what`, args
+	res = vageneric(what, f, args)
+	print '->', `res`
+	return res
+
+def generic(what, f, *args):
+	if type(what) == types.FunctionType:
+		return apply(what, (f,) + args)
+	if type(what) == types.ListType:
+		record = []
+		for thing in what:
+			item = apply(generic, thing[:1] + (f,) + thing[1:])
+			record.append((thing[1], item))
+		return record
+	return "BAD GENERIC ARGS: %s" % `what`
+
+getdata = [(getostype, "type"), (getpstr, "description"), (getword, "flags")]
+getoptarg = [(getpstr, "name"), (getostype, "keyword"), (getdata, "what")]
+getcommand = [(getpstr, "name"), (getpstr, "description"),
+	(getostype, "suite code"), (getostype, "command code"),
+	(getdata, "returns"),
+	(getdata, "accepts"),
+	(getlist, "optional arguments", getoptarg)]
+getprop = [(getpstr, "name"), (getostype, "code"), (getdata, "what")]
+getelem = [(getostype, "type"), (getlist, "accessibility", getostype)]
+getclass = [(getpstr, "name"), (getostype, "class code"), (getpstr, "description"),
+	(getlist, "properties", getprop), (getlist, "elements", getelem)]
+getenumitem = [(getpstr, "name"), (getostype, "value"), (getpstr, "description")]
+getenum = [(getostype, "enumtype"), (getlist, "enumitem", getenumitem)]
+getsuite = [(getpstr, "name"), (getpstr, "description"), (getostype, "code"),
+	(getword, "flags1"), (getword, "flags2"),
+	(getlist, "commands", getcommand),
+	(getlist, "classes", getclass),
+	(getword, "count???"), (getlist, "enums", getenum)]
+getaete = [(getword, "skip1"), (getword, "skip2"), (getword, "skip3"),
+	(getlist, "suites", getsuite)]
+
+
+# Display 'aete' resources in a friendly manner.
+# This one's done top-down again...
+
+def showaete(aete):
+	[flags1, flags2, flags3, suites] = aete
+	print "\nGlobal flags: x%x, x%x, x%x\n" % (flags1, flags2, flags3)
+	for suite in suites:
+		showsuite(suite)
+
+def showsuite(suite):
+	[name, desc, code, flags1, flags2, commands, classes, skip1, enums] = suite
+	print "\nSuite %s -- %s (%s)" % (`name`, `desc`, `code`)
+	for command in commands:
+		showcommand(command)
+	for classe in classes:
+		showclass(classe)
+	for enum in enums:
+		showenum(enum)
+
+def showcommand(command):
+	[name, desc, code, subcode, returns, accepts, arguments] = command
+	print "\n    Command %s -- %s (%s, %s)" % (`name`, `desc`, `code`, `subcode`)
+	print "        returns", showdata(returns)
+	print "        accepts", showdata(accepts)
+	for arg in arguments:
+		showargument(arg)
+
+def showargument(arg):
+	[name, keyword, what] = arg
+	print "        %s (%s)" % (name, `keyword`), showdata(what)
+
+def showclass(classe):
+	[name, code, desc, properties, elements] = classe
+	print "\n    Class %s (%s) -- %s" % (`name`, `code`, `desc`)
+	for prop in properties:
+		showproperty(prop)
+	for elem in elements:
+		showelement(elem)
+
+def showproperty(prop):
+	[name, code, what] = prop
+	print "        property %s (%s)" % (name, code), showdata(what)
+
+def showelement(elem):
+	[code, accessibility] = elem
+	print "        element %s" % `code`, "as", accessibility
+
+def showenum(enum):
+	[code, items] = enum
+	print "\n    Enum %s" % `code`
+	for item in items:
+		showitem(item)
+
+def showitem(item):
+	[name, code, desc] = item
+	print "        %s (%s) -- %s" % (`name`, `code`, `desc`)
+
+def showdata(data):
+	[type, description, flags] = data
+	return "%s -- %s %s" % (`type`, `description`, showdataflags(flags))
+
+dataflagdict = {15: "optional", 14: "list", 13: "enum", 12: "writable"}
+def showdataflags(flags):
+	bits = []
+	for i in range(16):
+		if flags & (1<<i):
+			if i in dataflagdict.keys():
+				bits.append(dataflagdict[i])
+			else:
+				bits.append(`i`)
+	return '[%s]' % string.join(bits)
+
+
+# Write an 'aete' resource.
+# Closedly modelled after showaete()...
+
+def putaete(f, aete):
+	[flags1, flags2, flags3, suites] = aete
+	putword(f, flags1)
+	putword(f, flags2)
+	putword(f, flags3)
+	putlist(f, suites, putsuite)
+
+def putsuite(f, suite):
+	[name, desc, code, flags1, flags2, commands, classes, skip1, enums] = suite
+	putpstr(f, name)
+	putpstr(f, desc)
+	putostype(f, code)
+	putword(f, flags1)
+	putword(f, flags2)
+	putlist(f, commands, putcommand)
+	putlist(f, classes, putclass)
+	putword(f, skip1)
+	putlist(f, enums, putenum)
+
+def putcommand(f, command):
+	[name, desc, code, subcode, returns, accepts, arguments] = command
+	putpstr(f, name)
+	putpstr(f, desc)
+	putostype(f, code)
+	putostype(f, subcode)
+	putdata(f, returns)
+	putdata(f, accepts)
+	putlist(f, arguments, putargument)
+
+def putargument(f, arg):
+	[name, keyword, what] = arg
+	putpstr(f, name)
+	putostype(f, keyword)
+	putdata(f, what)
+
+def putclass(f, classe):
+	[name, code, desc, properties, elements] = classe
+	putpstr(f, name)
+	putostype(f, code)
+	putpstr(f, desc)
+	putlist(f, properties, putproperty)
+	putlist(f, elements, putelement)
+
+putproperty = putargument
+
+def putelement(f, elem):
+	[code, parts] = elem
+	putostype(f, code)
+	putlist(f, parts, putostype)
+
+def putenum(f, enum):
+	[code, items] = enum
+	putostype(f, code)
+	putlist(f, items, putitem)
+
+def putitem(f, item):
+	[name, code, desc] = item
+	putpstr(f, name)
+	putostype(f, code)
+	putpstr(f, desc)
+
+def putdata(f, data):
+	[type, description, flags] = data
+	putostype(f, type)
+	putpstr(f, description)
+	putword(f, flags)
+
+def putlist(f, list, putitem):
+	putword(f, len(list))
+	for item in list:
+		putalign(f)
+		putitem(f, item)
+
+def putalign(f):
+	if f.tell() & 1:
+		f.write('\0')
+
+def putword(f, value):
+	putalign(f)
+	f.write(chr((value>>8)&0xff))
+	f.write(chr(value&0xff))
+
+def putostype(f, value):
+	putalign(f)
+	if type(value) != types.StringType or len(value) != 4:
+		raise TypeError, "ostype must be 4-char string"
+	f.write(value)
+
+def putpstr(f, value):
+	if type(value) != types.StringType or len(value) > 255:
+		raise TypeError, "pstr must be string <= 255 chars"
+	f.write(chr(len(value)) + value)
+
+
+# Call the main program
+
+if __name__ == '__main__':
+	main()
+else:
+	realmain()
diff --git a/Mac/Lib/test/tctl.py b/Mac/Lib/test/tctl.py
new file mode 100644
index 0000000..862eeb5
--- /dev/null
+++ b/Mac/Lib/test/tctl.py
@@ -0,0 +1,17 @@
+# play with controls
+
+from Dlg import *
+from Ctl import *
+from Win import *
+from Evt import *
+import time
+
+def main():
+	r = (40, 40, 400, 300)
+	w = NewWindow(r, "The Spanish Inquisition", 1, 0, -1, 1, 0x55555555)
+	w.DrawGrowIcon()
+	r = (40, 40, 100, 60)
+	c = NewControl(w, r, "SPAM!", 1, 0, 0, 1, 0, 0)
+
+
+main()
diff --git a/Mac/Lib/test/tdlg.py b/Mac/Lib/test/tdlg.py
new file mode 100644
index 0000000..f234a70
--- /dev/null
+++ b/Mac/Lib/test/tdlg.py
@@ -0,0 +1,15 @@
+# This program requires that a DLOG resource with ID=128 exists.
+# You can make one with ResEdit if necessary.
+
+from Res import *
+from Dlg import *
+
+ires = 128
+
+def filter(*args): print 'filter:', args
+
+d = GetNewDialog(ires, -1)
+while 1:
+	n = ModalDialog(filter)
+	print 'item:', n
+	if n == 1: break
diff --git a/Mac/Lib/test/tmenu.py b/Mac/Lib/test/tmenu.py
new file mode 100644
index 0000000..1b156d7
--- /dev/null
+++ b/Mac/Lib/test/tmenu.py
@@ -0,0 +1,60 @@
+# Create hierarchical menus for some volumes.
+
+import os
+from Menu import *
+
+# Since we can't (yet) list the mounted volumes, here's a list of some:
+my_volumes = ['C:', 'D:', 'E:', 'F:']
+
+def main():
+	global oldbar
+	oldbar = GetMenuBar()
+	ClearMenuBar()
+	makevolmenus(my_volumes)
+	DrawMenuBar()
+
+def reset():
+	oldbar.SetMenuBar()
+	DrawMenuBar()
+
+id = 1
+def nextid():
+	global id
+	nid = id
+	id = id+1
+	return nid
+
+def makevolmenus(volumes):
+	for vol in volumes:
+		makevolmenu(vol)
+
+def makevolmenu(vol):
+	menu = NewMenu(nextid(), vol)
+	adddirectory(menu, vol)
+	menu.InsertMenu(0)
+
+def adddirectory(menu, dir, maxdepth = 1):
+	print "adddirectory:", `dir`, maxdepth
+	files = os.listdir(dir)
+	item = 0
+	for file in files:
+		item = item+1
+		menu.AppendMenu('x')		# add a dummy string
+		menu.SetItem(item, file)	# set the actual text
+		fullname = os.path.join(dir, file)
+		if os.path.isdir(fullname):
+			menu.SetItem(item, ':' + file + ':')	# append colons
+			if maxdepth > 0:
+				id = nextid()
+				submenu = NewMenu(id, fullname)
+				adddirectory(submenu, fullname, maxdepth-1)
+				submenu.InsertMenu(-1)
+				# If the 'Cmd' is 0x1B, then the 'Mark' is the submenu id
+				menu.SetItemMark(item, id)
+				menu.SetItemCmd(item, 0x1B)
+	if not files:
+		menu.AppendMenu(':')	# dummy item to make it selectable
+	return menu
+
+if __name__ == '__main__':
+	main()
diff --git a/Mac/Lib/test/tsnd.py b/Mac/Lib/test/tsnd.py
new file mode 100644
index 0000000..ac347cb
--- /dev/null
+++ b/Mac/Lib/test/tsnd.py
@@ -0,0 +1,18 @@
+# Show off SndPlay (and some resource manager functions).
+# Get a list of all 'snd ' resources in the system and play them all.
+
+from Res import *
+from Snd import *
+
+ch = SndNewChannel(0, 0, None)
+print "Channel:", ch
+
+type = 'snd '
+
+for i in range(CountResources(type)):
+	r = GetIndResource(type, i+1)
+	print r.GetResInfo(), r.size
+	if r.GetResInfo()[0] == 1:
+		print "Skipping simple beep"
+		continue
+	ch.SndPlay(r, 0)
diff --git a/Mac/Lib/test/twin.py b/Mac/Lib/test/twin.py
new file mode 100644
index 0000000..0904d32
--- /dev/null
+++ b/Mac/Lib/test/twin.py
@@ -0,0 +1,9 @@
+# Test Win module
+
+from Win import *
+
+r = (40, 40, 400, 300)
+w = NewWindow(r, "Hello world", 1, 0, -1, 1, 0x55555555)
+w.DrawGrowIcon()
+import time
+time.sleep(10)