Committed a more or less working version.
diff --git a/Mac/Demo/resources/copyres.py b/Mac/Demo/resources/copyres.py
new file mode 100644
index 0000000..b401142
--- /dev/null
+++ b/Mac/Demo/resources/copyres.py
@@ -0,0 +1,57 @@
+from Res import *
+from Resources import *
+import MacOS
+
+READ = 1
+WRITE = 2
+smAllScripts = -3
+
+def copyres(src, dst):
+ """Copy resource from src file to dst file."""
+
+ cur = CurResFile()
+ ctor, type = MacOS.GetCreatorAndType(src)
+ input = FSpOpenResFile(src, READ)
+ try:
+ FSpCreateResFile(dst, ctor, type, smAllScripts)
+ except:
+ raw_input("%s already exists... CR to write anyway! " % dst)
+ output = FSpOpenResFile(dst, WRITE)
+ UseResFile(input)
+ ntypes = Count1Types()
+ for itype in range(1, 1+ntypes):
+ type = Get1IndType(itype)
+ nresources = Count1Resources(type)
+ for ires in range(1, 1+nresources):
+ res = Get1IndResource(type, ires)
+ res.LoadResource()
+ id, type, name = res.GetResInfo()
+ size = res.SizeResource()
+ attrs = res.GetResAttrs()
+ print id, type, name, size, hex(attrs)
+ res.DetachResource()
+ UseResFile(output)
+ try:
+ res2 = Get1Resource(type, id)
+ except (RuntimeError, Res.Error), msg:
+ res2 = None
+ if res2:
+ print "Duplicate type+id, not copied"
+ print (res2.size, res2.data)
+ print res2.GetResInfo()
+ if res2.HomeResFile() == output:
+ 'OK'
+ elif res2.HomeResFile() == input:
+ 'BAD!'
+ else:
+ print 'Home:', res2.HomeResFile()
+ else:
+ res.AddResource(type, id, name)
+ #res.SetResAttrs(attrs)
+ res.WriteResource()
+ UseResFile(input)
+ UseResFile(cur)
+ CloseResFile(output)
+ CloseResFile(input)
+
+copyres('::python.¹.rsrc', '::foo.rsrc')
diff --git a/Mac/Demo/resources/listres.py b/Mac/Demo/resources/listres.py
new file mode 100644
index 0000000..a0b2423
--- /dev/null
+++ b/Mac/Demo/resources/listres.py
@@ -0,0 +1,60 @@
+# List all resources
+
+import Res
+from Resources import *
+
+def list1resources():
+ ntypes = Res.Count1Types()
+ for itype in range(1, 1+ntypes):
+ type = Res.Get1IndType(itype)
+ print "Type:", `type`
+ nresources = Res.Count1Resources(type)
+ for i in range(1, 1 + nresources):
+ Res.SetResLoad(0)
+ res = Res.Get1IndResource(type, i)
+ Res.SetResLoad(1)
+ info(res)
+
+def listresources():
+ ntypes = Res.CountTypes()
+ for itype in range(1, 1+ntypes):
+ type = Res.GetIndType(itype)
+ print "Type:", `type`
+ nresources = Res.CountResources(type)
+ for i in range(1, 1 + nresources):
+ Res.SetResLoad(0)
+ res = Res.GetIndResource(type, i)
+ Res.SetResLoad(1)
+ info(res)
+
+def info(res):
+ print res.GetResInfo(), res.SizeResource(), decodeattrs(res.GetResAttrs())
+
+attrnames = {
+ resChanged: 'Changed',
+ resPreload: 'Preload',
+ resProtected: 'Protected',
+ resLocked: 'Locked',
+ resPurgeable: 'Purgeable',
+ resSysHeap: 'SysHeap',
+}
+
+def decodeattrs(attrs):
+ names = []
+ for bit in range(16):
+ mask = 1<<bit
+ if attrs & mask:
+ if attrnames.has_key(mask):
+ names.append(attrnames[mask])
+ else:
+ names.append(hex(mask))
+ return names
+
+def test():
+ print "=== Local resourcess ==="
+ list1resources()
+ print "=== All resources ==="
+ listresources()
+
+if __name__ == '__main__':
+ test()
diff --git a/Mac/Demo/sound/morse.py b/Mac/Demo/sound/morse.py
new file mode 100644
index 0000000..bf5fa5f
--- /dev/null
+++ b/Mac/Demo/sound/morse.py
@@ -0,0 +1,180 @@
+import sys, math, audiodev
+
+DOT = 30
+DAH = 80
+OCTAVE = 2 # 1 == 441 Hz, 2 == 882 Hz, ...
+SAMPWIDTH = 2
+FRAMERATE = 44100
+BASEFREQ = 441
+QSIZE = 20000
+
+morsetab = {
+ 'A': '.-', 'a': '.-',
+ 'B': '-...', 'b': '-...',
+ 'C': '-.-.', 'c': '-.-.',
+ 'D': '-..', 'd': '-..',
+ 'E': '.', 'e': '.',
+ 'F': '..-.', 'f': '..-.',
+ 'G': '--.', 'g': '--.',
+ 'H': '....', 'h': '....',
+ 'I': '..', 'i': '..',
+ 'J': '.---', 'j': '.---',
+ 'K': '-.-', 'k': '-.-',
+ 'L': '.-..', 'l': '.-..',
+ 'M': '--', 'm': '--',
+ 'N': '-.', 'n': '-.',
+ 'O': '---', 'o': '---',
+ 'P': '.--.', 'p': '.--.',
+ 'Q': '--.-', 'q': '--.-',
+ 'R': '.-.', 'r': '.-.',
+ 'S': '...', 's': '...',
+ 'T': '-', 't': '-',
+ 'U': '..-', 'u': '..-',
+ 'V': '...-', 'v': '...-',
+ 'W': '.--', 'w': '.--',
+ 'X': '-..-', 'x': '-..-',
+ 'Y': '-.--', 'y': '-.--',
+ 'Z': '--..', 'z': '--..',
+ '0': '-----',
+ '1': '.----',
+ '2': '..---',
+ '3': '...--',
+ '4': '....-',
+ '5': '.....',
+ '6': '-....',
+ '7': '--...',
+ '8': '---..',
+ '9': '----.',
+ ',': '--..--',
+ '.': '.-.-.-',
+ '?': '..--..',
+ ';': '-.-.-.',
+ ':': '---...',
+ "'": '.----.',
+ '-': '-....-',
+ '/': '-..-.',
+ '(': '-.--.-',
+ ')': '-.--.-',
+ '_': '..--.-',
+ ' ': ' '
+}
+
+# If we play at 44.1 kHz (which we do), then if we produce one sine
+# wave in 100 samples, we get a tone of 441 Hz. If we produce two
+# sine waves in these 100 samples, we get a tone of 882 Hz. 882 Hz
+# appears to be a nice one for playing morse code.
+def mkwave(octave):
+ global sinewave, nowave
+ sinewave = ''
+ n = int(FRAMERATE / BASEFREQ)
+ for i in range(n):
+ val = int(math.sin(2 * math.pi * i * octave / n) * 0x7fff)
+ sample = chr((val >> 8) & 255) + chr(val & 255)
+ sinewave = sinewave + sample[:SAMPWIDTH]
+ nowave = '\0' * (n*SAMPWIDTH)
+
+mkwave(OCTAVE)
+
+class BufferedAudioDev:
+ def __init__(self, *args):
+ import audiodev
+ self._base = apply(audiodev.AudioDev, args)
+ self._buffer = []
+ self._filled = 0
+ self._addmethods(self._base, self._base.__class__)
+ def _addmethods(self, inst, cls):
+ for name in cls.__dict__.keys():
+ if not hasattr(self, name):
+ try:
+ setattr(self, name, getattr(inst, name))
+ except:
+ pass
+ for basecls in cls.__bases__:
+ self._addmethods(self, inst, basecls)
+ def writeframesraw(self, frames):
+ self._buffer.append(frames)
+ self._filled = self._filled + len(frames)
+ if self._filled >= QSIZE:
+ self.flush()
+ def wait(self):
+ self.flush()
+ self._base.wait()
+ def flush(self):
+ print 'flush: %d blocks, %d bytes' % (len(self._buffer), self._filled)
+ if self._buffer:
+ import string
+ self._base.writeframes(string.joinfields(self._buffer, ''))
+ self._buffer = []
+ self._filled = 0
+
+def main(args = sys.argv[1:]):
+ import getopt, string
+ try:
+ opts, args = getopt.getopt(args, 'o:p:')
+ except getopt.error:
+ sys.stderr.write('Usage ' + sys.argv[0] +
+ ' [ -o outfile ] [ args ] ...\n')
+ sys.exit(1)
+ dev = None
+ for o, a in opts:
+ if o == '-o':
+ import aifc
+ dev = aifc.open(a, 'w')
+ dev.setframerate(FRAMERATE)
+ dev.setsampwidth(SAMPWIDTH)
+ dev.setnchannels(1)
+ if o == '-p':
+ mkwave(string.atoi(a))
+ if not dev:
+ dev = BufferedAudioDev()
+ dev.setoutrate(FRAMERATE)
+ dev.setsampwidth(SAMPWIDTH)
+ dev.setnchannels(1)
+ dev.close = dev.stop
+ if args:
+ line = string.join(args)
+ else:
+ line = sys.stdin.readline()
+ while line:
+ print line
+ mline = morse(line)
+ print mline
+ play(mline, dev)
+ if hasattr(dev, 'wait'):
+ dev.wait()
+ if not args:
+ line = sys.stdin.readline()
+ else:
+ line = ''
+ dev.close()
+
+# Convert a string to morse code with \001 between the characters in
+# the string.
+def morse(line):
+ res = ''
+ for c in line:
+ try:
+ res = res + morsetab[c] + '\001'
+ except KeyError:
+ pass
+ return res
+
+# Play a line of morse code.
+def play(line, dev):
+ for c in line:
+ if c == '.':
+ sine(dev, DOT)
+ elif c == '-':
+ sine(dev, DAH)
+ else:
+ pause(dev, DAH)
+ pause(dev, DOT)
+
+def sine(dev, length):
+ dev.writeframesraw(sinewave*length)
+
+def pause(dev, length):
+ dev.writeframesraw(nowave*length)
+
+if __name__ == '__main__' or sys.argv[0] == __name__:
+ main()
diff --git a/Mac/Demo/sound/playaiff.py b/Mac/Demo/sound/playaiff.py
new file mode 100644
index 0000000..1022fc8
--- /dev/null
+++ b/Mac/Demo/sound/playaiff.py
@@ -0,0 +1,45 @@
+from Sound import *
+import Snd
+
+import aifc, audioop
+
+fn = 'f:just samples:2ndbeat.aif'
+af = aifc.open(fn, 'r')
+print af.getparams()
+print 'nframes =', af.getnframes()
+print 'nchannels =', af.getnchannels()
+print 'framerate =', af.getframerate()
+nframes = min(af.getnframes(), 100000)
+frames = af.readframes(nframes)
+print 'len(frames) =', len(frames)
+print repr(frames[:100])
+frames = audioop.add(frames, '\x80'*len(frames), 1)
+print repr(frames[:100])
+
+import struct
+
+header1 = struct.pack('llhhllbbl',
+ 0,
+ af.getnchannels(),
+ af.getframerate(),0,
+ 0,
+ 0,
+ 0xFF,
+ 60,
+ nframes)
+print repr(header1)
+header2 = struct.pack('llhlll', 0, 0, 0, 0, 0, 0)
+header3 = struct.pack('hhlll',
+ af.getsampwidth()*8,
+ 0,
+ 0,
+ 0,
+ 0)
+print repr(header3)
+header = header1 + header2 + header3
+
+buffer = header + frames
+
+chan = Snd.SndNewChannel(5,0x00C0)
+
+Snd.SndDoCommand(chan, (bufferCmd, 0, buffer), 0)
diff --git a/Mac/Lib/Audio_mac.py b/Mac/Lib/Audio_mac.py
new file mode 100644
index 0000000..373f16a
--- /dev/null
+++ b/Mac/Lib/Audio_mac.py
@@ -0,0 +1,108 @@
+QSIZE = 100000
+
+class Play_Audio_mac:
+
+ def __init__(self):
+ self._chan = None
+ self._qsize = QSIZE
+ self._outrate = 22254
+ self._sampwidth = 1
+ self._nchannels = 1
+ self._gc = []
+
+ def __del__(self):
+ self.stop()
+
+ def wait(self):
+ import time
+ while self.getfilled():
+ time.sleep(0.1)
+ self._chan = None
+ self._gc = []
+
+ def stop(self, quietNow = 1):
+ ##chan = self._chan
+ self._chan = None
+ ##chan.SndDisposeChannel(1)
+ self._gc = []
+
+ def setoutrate(self, outrate):
+ self._outrate = outrate
+
+ def setsampwidth(self, sampwidth):
+ self._sampwidth = sampwidth
+
+ def setnchannels(self, nchannels):
+ self._nchannels = nchannels
+
+ def writeframes(self, data):
+ import time
+ from Sound import *
+ import struct
+ if not self._chan:
+ import Snd
+ self._chan = Snd.SndNewChannel(5, 0, self._callback)
+ nframes = len(data) / self._nchannels / self._sampwidth
+ if len(data) != nframes * self._nchannels * self._sampwidth:
+ raise ValueError, 'data is not a whole number of frames'
+ while self._gc and \
+ self.getfilled() + nframes > \
+ self._qsize / self._nchannels / self._sampwidth:
+ time.sleep(0.1)
+ if self._sampwidth == 1:
+ import audioop
+ data = audioop.add(data, '\x80'*len(data), 1)
+ h1 = struct.pack('llhhllbbl',
+ id(data)+12,
+ self._nchannels,
+ self._outrate, 0,
+ 0,
+ 0,
+ extSH,
+ 60,
+ nframes)
+ h2 = 22*'\0'
+ h3 = struct.pack('hhlll',
+ self._sampwidth*8,
+ 0,
+ 0,
+ 0,
+ 0)
+ header = h1+h2+h3
+ self._gc.append((header, data))
+ self._chan.SndDoCommand((bufferCmd, 0, header), 0)
+ self._chan.SndDoCommand((callBackCmd, 0, 0), 0)
+
+ def _callback(self, *args):
+ del self._gc[0]
+
+ def getfilled(self):
+ filled = 0
+ for header, data in self._gc:
+ filled = filled + len(data)
+ return filled / self._nchannels / self._sampwidth
+
+ def getfillable(self):
+ return self._qsize - self.getfilled()
+
+ def ulaw2lin(self, data):
+ import audioop
+ return audioop.ulaw2lin(data, 2)
+
+def test(fn = 'f:just samples:just.aif'):
+ import aifc
+ af = aifc.open(fn, 'r')
+ print af.getparams()
+ p = Play_Audio_mac()
+ p.setoutrate(af.getframerate())
+ p.setsampwidth(af.getsampwidth())
+ p.setnchannels(af.getnchannels())
+ BUFSIZ = 10000
+ while 1:
+ data = af.readframes(BUFSIZ)
+ if not data: break
+ p.writeframes(data)
+ p.wait()
+
+if __name__ == '__main__':
+ test()
diff --git a/Mac/Lib/audiodev.py b/Mac/Lib/audiodev.py
new file mode 100644
index 0000000..adfeb96
--- /dev/null
+++ b/Mac/Lib/audiodev.py
@@ -0,0 +1,241 @@
+error = 'audiodev.error'
+
+class Play_Audio_sgi:
+ # Private instance variables
+ access frameratelist, nchannelslist, sampwidthlist, oldparams, \
+ params, config, inited_outrate, inited_width, \
+ inited_nchannels, port, converter, classinited: private
+
+ classinited = 0
+ frameratelist = nchannelslist = sampwidthlist = None
+
+ def initclass(self):
+ import AL
+ Play_Audio_sgi.frameratelist = [
+ (48000, AL.RATE_48000),
+ (44100, AL.RATE_44100),
+ (32000, AL.RATE_32000),
+ (22050, AL.RATE_22050),
+ (16000, AL.RATE_16000),
+ (11025, AL.RATE_11025),
+ ( 8000, AL.RATE_8000),
+ ]
+ Play_Audio_sgi.nchannelslist = [
+ (1, AL.MONO),
+ (2, AL.STEREO),
+ ]
+ Play_Audio_sgi.sampwidthlist = [
+ (1, AL.SAMPLE_8),
+ (2, AL.SAMPLE_16),
+ (3, AL.SAMPLE_24),
+ ]
+ Play_Audio_sgi.classinited = 1
+
+ def __init__(self):
+ import al, AL
+ if not self.classinited:
+ self.initclass()
+ self.oldparams = []
+ self.params = [AL.OUTPUT_RATE, 0]
+ self.config = al.newconfig()
+ self.inited_outrate = 0
+ self.inited_width = 0
+ self.inited_nchannels = 0
+ self.converter = None
+ self.port = None
+ return
+
+ def __del__(self):
+ if self.port:
+ self.stop()
+ if self.oldparams:
+ import al, AL
+ al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
+ self.oldparams = []
+
+ def wait(self):
+ if not self.port:
+ return
+ import time
+ while self.port.getfilled() > 0:
+ time.sleep(0.1)
+ self.stop()
+
+ def stop(self):
+ if self.port:
+ self.port.closeport()
+ self.port = None
+ if self.oldparams:
+ import al, AL
+ al.setparams(AL.DEFAULT_DEVICE, self.oldparams)
+ self.oldparams = []
+
+ def setoutrate(self, rate):
+ for (raw, cooked) in self.frameratelist:
+ if rate == raw:
+ self.params[1] = cooked
+ self.inited_outrate = 1
+ break
+ else:
+ raise error, 'bad output rate'
+
+ def setsampwidth(self, width):
+ for (raw, cooked) in self.sampwidthlist:
+ if width == raw:
+ self.config.setwidth(cooked)
+ self.inited_width = 1
+ break
+ else:
+ if width == 0:
+ import AL
+ self.inited_width = 0
+ self.config.setwidth(AL.SAMPLE_16)
+ self.converter = self.ulaw2lin
+ else:
+ raise error, 'bad sample width'
+
+ def setnchannels(self, nchannels):
+ for (raw, cooked) in self.nchannelslist:
+ if nchannels == raw:
+ self.config.setchannels(cooked)
+ self.inited_nchannels = 1
+ break
+ else:
+ raise error, 'bad # of channels'
+
+ def writeframes(self, data):
+ if not (self.inited_outrate and self.inited_nchannels):
+ raise error, 'params not specified'
+ if not self.port:
+ import al, AL
+ self.port = al.openport('Python', 'w', self.config)
+ self.oldparams = self.params[:]
+ al.getparams(AL.DEFAULT_DEVICE, self.oldparams)
+ al.setparams(AL.DEFAULT_DEVICE, self.params)
+ if self.converter:
+ data = self.converter(data)
+ self.port.writesamps(data)
+
+ def getfilled(self):
+ if self.port:
+ return self.port.getfilled()
+ else:
+ return 0
+
+ def getfillable(self):
+ if self.port:
+ return self.port.getfillable()
+ else:
+ return self.config.getqueuesize()
+
+ # private methods
+ access *: private
+
+ def ulaw2lin(self, data):
+ import audioop
+ return audioop.ulaw2lin(data, 2)
+
+class Play_Audio_sun:
+ access outrate, sampwidth, nchannels, inited_outrate, inited_width, \
+ inited_nchannels, converter: private
+
+ def __init__(self):
+ self.outrate = 0
+ self.sampwidth = 0
+ self.nchannels = 0
+ self.inited_outrate = 0
+ self.inited_width = 0
+ self.inited_nchannels = 0
+ self.converter = None
+ self.port = None
+ return
+
+ def __del__(self):
+ self.stop()
+
+ def setoutrate(self, rate):
+ self.outrate = rate
+ self.inited_outrate = 1
+
+ def setsampwidth(self, width):
+ self.sampwidth = width
+ self.inited_width = 1
+
+ def setnchannels(self, nchannels):
+ self.nchannels = nchannels
+ self.inited_nchannels = 1
+
+ def writeframes(self, data):
+ if not (self.inited_outrate and self.inited_width and self.inited_nchannels):
+ raise error, 'params not specified'
+ if not self.port:
+ import sunaudiodev, SUNAUDIODEV
+ self.port = sunaudiodev.open('w')
+ info = self.port.getinfo()
+ info.o_sample_rate = self.outrate
+ info.o_channels = self.nchannels
+ if self.sampwidth == 0:
+ info.o_precision = 8
+ self.o_encoding = ENCODING_ULAW
+ else:
+ info.o_precision = 8 * self.sampwidth
+ info.o_encoding = SUNAUDIODEV.ENCODING_LINEAR
+ self.port.setinfo(info)
+ if self.converter:
+ data = self.converter(data)
+ self.port.write(data)
+
+ def wait(self):
+ if not self.port:
+ return
+ self.port.drain()
+ self.stop()
+
+ def stop(self):
+ if self.port:
+ self.port.flush()
+ self.port.close()
+ self.port = None
+
+ def getfilled(self):
+ if self.port:
+ return self.port.obufcount()
+ else:
+ return 0
+
+ def getfillable(self):
+ return BUFFERSIZE - self.getfilled()
+
+def AudioDev():
+ try:
+ import al
+ return Play_Audio_sgi()
+ except ImportError:
+ try:
+ import sunaudiodev
+ return Play_Audio_sun()
+ except ImportError:
+ try:
+ import Audio_mac
+ return Audio_mac.Play_Audio_mac()
+ except ImportError:
+ raise error, 'no audio device'
+
+def test(fn = 'f:just samples:just.aif'):
+ import aifc
+ af = aifc.open(fn, 'r')
+ print fn, af.getparams()
+ p = AudioDev()
+ p.setoutrate(af.getframerate())
+ p.setsampwidth(af.getsampwidth())
+ p.setnchannels(af.getnchannels())
+ BUFSIZ = af.getframerate()/af.getsampwidth()/af.getnchannels()
+ while 1:
+ data = af.readframes(BUFSIZ)
+ if not data: break
+ print len(data)
+ p.writeframes(data)
+ p.wait()
+
+if __name__ == '__main__':
+ test()
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)
diff --git a/Mac/Lib/toolbox/AppleEvents.py b/Mac/Lib/toolbox/AppleEvents.py
new file mode 100644
index 0000000..b3780d0
--- /dev/null
+++ b/Mac/Lib/toolbox/AppleEvents.py
@@ -0,0 +1,103 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:AppleEvents.h'
+typeBoolean = 'bool'
+typeChar = 'TEXT'
+typeSMInt = 'shor'
+typeInteger = 'long'
+typeSMFloat = 'sing'
+typeFloat = 'doub'
+typeLongInteger = 'long'
+typeShortInteger = 'shor'
+typeLongFloat = 'doub'
+typeShortFloat = 'sing'
+typeExtended = 'exte'
+typeComp = 'comp'
+typeMagnitude = 'magn'
+typeAEList = 'list'
+typeAERecord = 'reco'
+typeAppleEvent = 'aevt'
+typeTrue = 'true'
+typeFalse = 'fals'
+typeAlias = 'alis'
+typeEnumerated = 'enum'
+typeType = 'type'
+typeAppParameters = 'appa'
+typeProperty = 'prop'
+typeFSS = 'fss '
+typeKeyword = 'keyw'
+typeSectionH = 'sect'
+typeWildCard = '****'
+typeApplSignature = 'sign'
+typeSessionID = 'ssid'
+typeTargetID = 'targ'
+typeProcessSerialNumber = 'psn '
+typeNull = 'null'
+keyDirectObject = '----'
+keyErrorNumber = 'errn'
+keyErrorString = 'errs'
+keyProcessSerialNumber = 'psn '
+keyTransactionIDAttr = 'tran'
+keyReturnIDAttr = 'rtid'
+keyEventClassAttr = 'evcl'
+keyEventIDAttr = 'evid'
+keyAddressAttr = 'addr'
+keyOptionalKeywordAttr = 'optk'
+keyTimeoutAttr = 'timo'
+keyInteractLevelAttr = 'inte'
+keyEventSourceAttr = 'esrc'
+keyMissedKeywordAttr = 'miss'
+keyOriginalAddressAttr = 'from'
+keyPreDispatch = 'phac'
+keySelectProc = 'selh'
+keyAERecorderCount = 'recr'
+keyAEVersion = 'vers'
+kCoreEventClass = 'aevt'
+kAEOpenApplication = 'oapp'
+kAEOpenDocuments = 'odoc'
+kAEPrintDocuments = 'pdoc'
+kAEQuitApplication = 'quit'
+kAEAnswer = 'ansr'
+kAEApplicationDied = 'obit'
+kAENoReply = 0x00000001
+kAEQueueReply = 0x00000002
+kAEWaitReply = 0x00000003
+kAENeverInteract = 0x00000010
+kAECanInteract = 0x00000020
+kAEAlwaysInteract = 0x00000030
+kAECanSwitchLayer = 0x00000040
+kAEDontReconnect = 0x00000080
+kAEDontRecord = 0x00001000
+kAEDontExecute = 0x00002000
+kAENormalPriority = 0x00000000
+kAEStartRecording = 'reca'
+kAEStopRecording = 'recc'
+kAENotifyStartRecording = 'rec1'
+kAENotifyStopRecording = 'rec0'
+kAENotifyRecording = 'recr'
+kAutoGenerateReturnID = -1
+kAnyTransactionID = 0
+kAEDefaultTimeout = -1
+kNoTimeOut = -2
+kAENoDispatch = 0
+kAEUseStandardDispatch = -1
+errAECoercionFail = -1700
+errAEDescNotFound = -1701
+errAECorruptData = -1702
+errAEWrongDataType = -1703
+errAENotAEDesc = -1704
+errAEBadListItem = -1705
+errAENewerVersion = -1706
+errAENotAppleEvent = -1707
+errAEEventNotHandled = -1708
+errAEReplyNotValid = -1709
+errAEUnknownSendMode = -1710
+errAEWaitCanceled = -1711
+errAETimeout = -1712
+errAENoUserInteraction = -1713
+errAENotASpecialFunction = -1714
+errAEParamMissed = -1715
+errAEUnknownAddressType = -1716
+errAEHandlerNotFound = -1717
+errAEReplyNotArrived = -1718
+errAEIllegalIndex = -1719
+errAEUnknownObjectType = -1731
+errAERecordingIsAlreadyOn = -1732
diff --git a/Mac/Lib/toolbox/Controls.py b/Mac/Lib/toolbox/Controls.py
new file mode 100644
index 0000000..c95ea11
--- /dev/null
+++ b/Mac/Lib/toolbox/Controls.py
@@ -0,0 +1,41 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Controls.h'
+pushButProc = 0
+checkBoxProc = 1
+radioButProc = 2
+useWFont = 8
+scrollBarProc = 16
+inButton = 10
+inCheckBox = 11
+inUpButton = 20
+inDownButton = 21
+inPageUp = 22
+inPageDown = 23
+inThumb = 129
+popupMenuProc = 1008
+inLabel = 1
+inMenu = 2
+inTriangle = 4
+popupUseWFont = 1 << 3
+popupTitleOutline = 1 << 11
+popupTitleExtend = 1 << 14
+popupTitleLeftJust = 0x00000000
+popupTitleCenterJust = 0x00000001
+popupTitleRightJust = 0x000000FF
+noConstraint = 0
+hAxisOnly = 1
+vAxisOnly = 2
+drawCntl = 0
+testCntl = 1
+calcCRgns = 2
+initCntl = 3
+dispCntl = 4
+posCntl = 5
+thumbCntl = 6
+dragCntl = 7
+autoTrack = 8
+calcCntlRgn = 10
+calcThumbRgn = 11
+cFrameColor = 0
+cBodyColor = 1
+cTextColor = 2
+cThumbColor = 3
diff --git a/Mac/Lib/toolbox/Dialogs.py b/Mac/Lib/toolbox/Dialogs.py
new file mode 100644
index 0000000..297568c
--- /dev/null
+++ b/Mac/Lib/toolbox/Dialogs.py
@@ -0,0 +1,20 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Dialogs.h'
+ctrlItem = 4
+btnCtrl = 0
+chkCtrl = 1
+radCtrl = 2
+resCtrl = 3
+statText = 8
+editText = 16
+iconItem = 32
+picItem = 64
+userItem = 0
+itemDisable = 128
+ok = 1
+cancel = 2
+stopIcon = 0
+noteIcon = 1
+cautionIcon = 2
+overlayDITL = 0
+appendDITLRight = 1
+appendDITLBottom = 2
diff --git a/Mac/Lib/toolbox/Events.py b/Mac/Lib/toolbox/Events.py
new file mode 100644
index 0000000..ac32c3f
--- /dev/null
+++ b/Mac/Lib/toolbox/Events.py
@@ -0,0 +1,49 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Events.h'
+nullEvent = 0
+mouseDown = 1
+mouseUp = 2
+keyDown = 3
+keyUp = 4
+autoKey = 5
+updateEvt = 6
+diskEvt = 7
+activateEvt = 8
+osEvt = 15
+mDownMask = 2
+mUpMask = 4
+keyDownMask = 8
+keyUpMask = 16
+autoKeyMask = 32
+updateMask = 64
+diskMask = 128
+activMask = 256
+highLevelEventMask = 1024
+osMask = -32768
+everyEvent = -1
+charCodeMask = 0x000000FF
+keyCodeMask = 0x0000FF00
+adbAddrMask = 0x00FF0000
+osEvtMessageMask = 0xFF000000
+mouseMovedMessage = 0xFA
+suspendResumeMessage = 0x01
+resumeFlag = 1
+convertClipboardFlag = 2
+activeFlag = 1
+btnState = 128
+cmdKey = 256
+shiftKey = 512
+alphaLock = 1024
+optionKey = 2048
+controlKey = 4096
+networkEvt = 10
+driverEvt = 11
+app1Evt = 12
+app2Evt = 13
+app3Evt = 14
+app4Evt = 15
+networkMask = 1024
+driverMask = 2048
+app1Mask = 4096
+app2Mask = 8192
+app3Mask = 16384
+app4Mask = -32768
diff --git a/Mac/Lib/toolbox/Menus.py b/Mac/Lib/toolbox/Menus.py
new file mode 100644
index 0000000..11b9a48
--- /dev/null
+++ b/Mac/Lib/toolbox/Menus.py
@@ -0,0 +1,12 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Menus.h'
+mDrawMsg = 0
+mChooseMsg = 1
+mSizeMsg = 2
+mDrawItemMsg = 4
+mCalcItemMsg = 5
+textMenuProc = 0
+hMenuCmd = 27
+hierMenu = -1
+mPopUpMsg = 3
+mctAllItems = -98
+mctLastIDIndic = -99 /*last color table entry has this in ID field*/
diff --git a/Mac/Lib/toolbox/Resources.py b/Mac/Lib/toolbox/Resources.py
new file mode 100644
index 0000000..743c656
--- /dev/null
+++ b/Mac/Lib/toolbox/Resources.py
@@ -0,0 +1,12 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Resources.h'
+resSysHeap = 64
+resPurgeable = 32
+resLocked = 16
+resProtected = 8
+resPreload = 4
+resChanged = 2
+mapReadOnly = 128
+mapCompact = 64
+mapChanged = 32
+mapTrue = 0xFFFF
+mapFalse = 0xFF00
diff --git a/Mac/Lib/toolbox/Sound.py b/Mac/Lib/toolbox/Sound.py
new file mode 100644
index 0000000..600adcd
--- /dev/null
+++ b/Mac/Lib/toolbox/Sound.py
@@ -0,0 +1,101 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Sound.h'
+swMode = -1
+ftMode = 1
+ffMode = 0
+rate22khz = 0x56EE8BA3
+rate11khz = 0x2B7745D1
+squareWaveSynth = 1
+waveTableSynth = 3
+sampledSynth = 5
+MACE3snthID = 11
+MACE6snthID = 13
+nullCmd = 0
+initCmd = 1
+freeCmd = 2
+quietCmd = 3
+flushCmd = 4
+reInitCmd = 5
+waitCmd = 10
+pauseCmd = 11
+resumeCmd = 12
+callBackCmd = 13
+syncCmd = 14
+emptyCmd = 15
+tickleCmd = 20
+requestNextCmd = 21
+howOftenCmd = 22
+wakeUpCmd = 23
+availableCmd = 24
+versionCmd = 25
+totalLoadCmd = 26
+loadCmd = 27
+scaleCmd = 30
+tempoCmd = 31
+freqDurationCmd = 40
+restCmd = 41
+freqCmd = 42
+ampCmd = 43
+timbreCmd = 44
+getAmpCmd = 45
+waveTableCmd = 60
+phaseCmd = 61
+soundCmd = 80
+bufferCmd = 81
+rateCmd = 82
+continueCmd = 83
+doubleBufferCmd = 84
+getRateCmd = 85
+sizeCmd = 90
+convertCmd = 91
+stdQLength = 128
+dataOffsetFlag = 0x8000
+waveInitChannelMask = 0x07
+waveInitChannel0 = 0x04
+waveInitChannel1 = 0x05
+waveInitChannel2 = 0x06
+waveInitChannel3 = 0x07
+initPanMask = 0x0003
+initSRateMask = 0x0030
+initStereoMask = 0x00C0
+initCompMask = 0xFF00
+initChanLeft = 0x0002
+initChanRight = 0x0003
+initNoInterp = 0x0004
+initNoDrop = 0x0008
+initMono = 0x0080
+initStereo = 0x00C0
+initMACE3 = 0x0300
+initMACE6 = 0x0400
+initChan0 = 0x0004
+initChan1 = 0x0005
+initChan2 = 0x0006
+initChan3 = 0x0007
+stdSH = 0x00
+extSH = 0xFF
+cmpSH = 0xFE
+notCompressed = 0
+twoToOne = 1
+eightToThree = 2
+threeToOne = 3
+sixToOne = 4
+outsideCmpSH = 0
+insideCmpSH = 1
+aceSuccess = 0
+aceMemFull = 1
+aceNilBlock = 2
+aceBadComp = 3
+aceBadEncode = 4
+aceBadDest = 5
+aceBadCmd = 6
+sixToOnePacketSize = 8
+threeToOnePacketSize = 16
+stateBlockSize = 64
+leftOverBlockSize = 32
+firstSoundFormat = 0x0001
+secondSoundFormat = 0x0002
+dbBufferReady = 0x00000001
+dbLastBuffer = 0x00000004
+sysBeepDisable = 0x0000
+sysBeepEnable = 0x0001
+unitTypeNoSelection = 0xFFFF
+unitTypeSeconds = 0x0000
diff --git a/Mac/Lib/toolbox/Windows.py b/Mac/Lib/toolbox/Windows.py
new file mode 100644
index 0000000..5d5bd7a
--- /dev/null
+++ b/Mac/Lib/toolbox/Windows.py
@@ -0,0 +1,41 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Windows.h'
+documentProc = 0
+dBoxProc = 1
+plainDBox = 2
+altDBoxProc = 3
+noGrowDocProc = 4
+movableDBoxProc = 5
+zoomDocProc = 8
+zoomNoGrow = 12
+rDocProc = 16
+dialogKind = 2
+userKind = 8
+inDesk = 0
+inMenuBar = 1
+inSysWindow = 2
+inContent = 3
+inDrag = 4
+inGrow = 5
+inGoAway = 6
+inZoomIn = 7
+inZoomOut = 8
+wDraw = 0
+wHit = 1
+wCalcRgns = 2
+wNew = 3
+wDispose = 4
+wGrow = 5
+wDrawGIcon = 6
+wNoHit = 0
+wInContent = 1
+wInDrag = 2
+wInGrow = 3
+wInGoAway = 4
+wInZoomIn = 5
+wInZoomOut = 6
+deskPatID = 16
+wContentColor = 0
+wFrameColor = 1
+wTextColor = 2
+wHiliteColor = 3
+wTitleBarColor = 4
diff --git a/Mac/Lib/toolbox/aetools.py b/Mac/Lib/toolbox/aetools.py
new file mode 100644
index 0000000..745bce7
--- /dev/null
+++ b/Mac/Lib/toolbox/aetools.py
@@ -0,0 +1,296 @@
+import struct
+import types
+import AE
+import MacOS
+import StringIO
+
+AEDescType = type(AE.AECreateDesc('TEXT', ''))
+
+def pack(x):
+ if x == None:
+ return AE.AECreateDesc('null', '')
+ t = type(x)
+ if t == AEDescType:
+ return x
+ if t == types.IntType:
+ return AE.AECreateDesc('long', struct.pack('l', x))
+ if t == types.FloatType:
+ return AE.AECreateDesc('exte', struct.pack('d', x)[2:])
+ if t == types.StringType:
+ return AE.AECreateDesc('TEXT', x)
+ if t == types.ListType:
+ list = AE.AECreateList('', 0)
+ for item in x:
+ list.AEPutDesc(0, pack(item))
+ return list
+ if t == types.TupleType:
+ t, d = x
+ return AE.AECreateDesc(t, d)
+ if t == types.DictionaryType:
+ record = AE.AECreateList('', 1)
+ for key, value in x.items():
+ record.AEPutKeyDesc(key, pack(value))
+ if t == types.InstanceType and hasattr(x, '__aepack__'):
+ return x.__aepack__()
+ return AE.AECreateDesc('TEXT', repr(x)) # Copout
+
+def unpack(desc):
+ t = desc.type
+ if t == 'TEXT':
+ return desc.data
+ if t == 'fals':
+ return 0
+ if t == 'true':
+ return 1
+ if t == 'long':
+ return struct.unpack('l', desc.data)[0]
+ if t == 'shor':
+ return struct.unpack('h', desc.data)[0]
+ if t == 'sing':
+ return struct.unpack('f', desc.data)[0]
+ if t == 'exte':
+ data = desc.data
+ return struct.unpack('d', data[:2] + data)[0]
+ if t in ('doub', 'comp', 'magn'):
+ return unpack(desc.AECoerceDesc('exte'))
+ if t == 'enum':
+ return ('enum', desc.data)
+ if t == 'null':
+ return None
+ if t == 'list':
+ l = []
+ for i in range(desc.AECountItems()):
+ keyword, item = desc.AEGetNthDesc(i+1, '****')
+ l.append(unpack(item))
+ return l
+ if t == 'reco':
+ d = {}
+ for i in range(desc.AECountItems()):
+ keyword, item = desc.AEGetNthDesc(i+1, '****')
+ d[keyword] = unpack(item)
+ return d
+ if t == 'obj ':
+ return unpackobject(desc.data)
+ return desc.type, desc.data # Copout
+
+class Object:
+ def __init__(self, dict = {}):
+ self.dict = dict
+ for key, value in dict.items():
+ self.dict[key] = value
+ def __repr__(self):
+ return "Object(%s)" % `self.dict`
+ def __str__(self):
+ want = self.dict['want']
+ form = self.dict['form']
+ seld = self.dict['seld']
+ s = "%s %s %s" % (nicewant(want), niceform(form), niceseld(seld))
+ fr = self.dict['from']
+ if fr:
+ s = s + " of " + str(fr)
+ return s
+ def __aepack__(self):
+ f = StringIO.StringIO()
+ putlong(f, len(self.dict))
+ putlong(f, 0)
+ for key, value in self.dict.items():
+ putcode(f, key)
+ desc = pack(value)
+ putcode(f, desc.type)
+ data = desc.data
+ putlong(f, len(data))
+ f.write(data)
+ return AE.AECreateDesc('obj ', f.getvalue())
+
+def nicewant(want):
+ if type(want) == types.TupleType and len(want) == 2:
+ return reallynicewant(want)
+ else:
+ return `want`
+
+def reallynicewant((t, w)):
+ if t != 'type': return `t, w`
+ # These should be taken from the "elements" of the 'aete' resource
+ if w == 'cins': return 'insertion point'
+ if w == 'cha ': return 'character'
+ if w == 'word': return 'word'
+ if w == 'para': return 'paragraph'
+ if w == 'ccel': return 'cell'
+ if w == 'ccol': return 'column'
+ if w == 'crow': return 'row'
+ if w == 'crng': return 'range'
+ if w == 'wind': return 'window'
+ if w == 'docu': return 'document'
+ return `w`
+
+def niceform(form):
+ if type(form) == types.TupleType and len(form) == 2:
+ return reallyniceform(form)
+ else:
+ return `form`
+
+def reallyniceform((t, f)):
+ if t <> 'enum': return `t, f`
+ if f == 'indx': return ''
+ if f == 'name': return ''
+ if f == 'rele': return ''
+ return `f`
+
+def niceseld(seld):
+ if type(seld) == types.TupleType and len(seld) == 2:
+ return reallyniceseld(seld)
+ else:
+ return `seld`
+
+def reallyniceseld((t, s)):
+ if t == 'long': return `s`
+ if t == 'TEXT': return `s`
+ if t == 'enum':
+ if s == 'next': return 'after'
+ if s == 'prev': return 'before'
+ return `t, s`
+
+def unpackobject(data):
+ f = StringIO.StringIO(data)
+ nkey = getlong(f)
+ dumm = getlong(f)
+ dict = {}
+ for i in range(nkey):
+ keyw = getcode(f)
+ type = getcode(f)
+ size = getlong(f)
+ if size:
+ data = f.read(size)
+ else:
+ data = ''
+ desc = AE.AECreateDesc(type, data)
+ dict[keyw] = unpack(desc)
+ return Object(dict)
+
+
+# --- get various data types from a "file"
+
+def getword(f, *args):
+ getalgn(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):
+ getalgn(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 getcode(f, *args):
+ getalgn(f)
+ s = f.read(4)
+ if len(s) < 4:
+ raise EOFError, 'in getcode' + 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 getalgn(f):
+ if f.tell() & 1:
+ c = f.read(1)
+ ##if c <> '\0':
+ ## print 'align:', `c`
+
+# ---- end get routines
+
+
+# ---- put various data types to a "file"
+
+def putlong(f, value):
+ putalgn(f)
+ f.write(chr((value>>24)&0xff))
+ f.write(chr((value>>16)&0xff))
+ f.write(chr((value>>8)&0xff))
+ f.write(chr(value&0xff))
+
+def putword(f, value):
+ putalgn(f)
+ f.write(chr((value>>8)&0xff))
+ f.write(chr(value&0xff))
+
+def putcode(f, value):
+ if type(value) != types.StringType or len(value) != 4:
+ raise TypeError, "ostype must be 4-char string"
+ putalgn(f)
+ 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)
+
+def putalgn(f):
+ if f.tell() & 1:
+ f.write('\0')
+
+# ---- end put routines
+
+
+aekeywords = [
+ 'tran',
+ 'rtid',
+ 'evcl',
+ 'evid',
+ 'addr',
+ 'optk',
+ 'timo',
+ 'inte', # this attribute is read only - will be set in AESend
+ 'esrc', # this attribute is read only
+ 'miss', # this attribute is read only
+ 'from' # new in 1.0.1
+]
+
+def missed(ae):
+ try:
+ desc = ae.AEGetAttributeDesc('miss', 'keyw')
+ except AE.Error, msg:
+ return None
+ return desc.data
+
+def unpackevent(ae):
+ parameters = {}
+ while 1:
+ key = missed(ae)
+ if not key: break
+ parameters[key] = unpack(ae.AEGetParamDesc(key, '****'))
+ attributes = {}
+ for key in aekeywords:
+ try:
+ desc = ae.AEGetAttributeDesc(key, '****')
+ except (AE.Error, MacOS.Error), msg:
+ if msg[0] != -1701:
+ raise sys.exc_type, sys.exc_value
+ continue
+ attributes[key] = unpack(desc)
+ return parameters, attributes
+
+def packevent(ae, parameters = {}, attributes = {}):
+ for key, value in parameters.items():
+ ae.AEPutParamDesc(key, pack(value))
+ for key, value in attributes.items():
+ ae.AEPutAttributeDesc(key, pack(value))
+
+def test():
+ target = AE.AECreateDesc('sign', 'KAHL')
+ ae = AE.AECreateAppleEvent('aevt', 'oapp', target, -1, 0)
+ print unpackevent(ae)
+
+if __name__ == '__main__':
+ test()
diff --git a/Mac/Modules/ae/AEmodule.c b/Mac/Modules/ae/AEmodule.c
new file mode 100644
index 0000000..544c4e2
--- /dev/null
+++ b/Mac/Modules/ae/AEmodule.c
@@ -0,0 +1,1257 @@
+
+/* =========================== Module AE ============================ */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+#include <AppleEvents.h>
+
+#ifdef THINK_C
+#define AEFilterProcPtr EventFilterProcPtr
+#define AEEventHandlerProcPtr EventHandlerProcPtr
+#endif
+
+static pascal OSErr GenericEventHandler(); /* Forward */
+
+static pascal Boolean AEIdleProc(EventRecord *theEvent, long *sleepTime, RgnHandle *mouseRgn)
+{
+ (void) PyMac_Idle();
+ return 0;
+}
+
+static PyObject *AE_Error;
+
+/* ----------------------- Object type AEDesc ----------------------- */
+
+staticforward PyTypeObject AEDesc_Type;
+
+#define AEDesc_Check(x) ((x)->ob_type == &AEDesc_Type)
+
+typedef struct AEDescObject {
+ PyObject_HEAD
+ AEDesc ob_itself;
+} AEDescObject;
+
+static PyObject *AEDesc_New(itself)
+ const AEDesc *itself;
+{
+ AEDescObject *it;
+ it = PyObject_NEW(AEDescObject, &AEDesc_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = *itself;
+ return (PyObject *)it;
+}
+static AEDesc_Convert(v, p_itself)
+ PyObject *v;
+ AEDesc *p_itself;
+{
+ if (!AEDesc_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "AEDesc required");
+ return 0;
+ }
+ *p_itself = ((AEDescObject *)v)->ob_itself;
+ return 1;
+}
+
+static void AEDesc_dealloc(self)
+ AEDescObject *self;
+{
+ AEDisposeDesc(&self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *AEDesc_AECoerceDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DescType toType;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &toType))
+ return NULL;
+ _err = AECoerceDesc(&_self->ob_itself,
+ toType,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ return _res;
+}
+
+static PyObject *AEDesc_AEDuplicateDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AEDuplicateDesc(&_self->ob_itself,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ return _res;
+}
+
+static PyObject *AEDesc_AECountItems(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long theCount;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AECountItems(&_self->ob_itself,
+ &theCount);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ theCount);
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutPtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ DescType typeCode;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "lO&s#",
+ &index,
+ PyMac_GetOSType, &typeCode,
+ &dataPtr__in__, &dataPtr__len__))
+ return NULL;
+ _err = AEPutPtr(&_self->ob_itself,
+ index,
+ typeCode,
+ dataPtr__in__, dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ AEDesc theAEDesc;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &index,
+ AEDesc_Convert, &theAEDesc))
+ return NULL;
+ _err = AEPutDesc(&_self->ob_itself,
+ index,
+ &theAEDesc);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetNthPtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ DescType desiredType;
+ AEKeyword theAEKeyword;
+ DescType typeCode;
+ char *dataPtr__out__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "lO&l",
+ &index,
+ PyMac_GetOSType, &desiredType,
+ &dataPtr__len__))
+ return NULL;
+ if ((dataPtr__out__ = malloc(dataPtr__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto dataPtr__error__;
+ }
+ _err = AEGetNthPtr(&_self->ob_itself,
+ index,
+ desiredType,
+ &theAEKeyword,
+ &typeCode,
+ dataPtr__out__, dataPtr__len__, &dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&s#",
+ PyMac_BuildOSType, theAEKeyword,
+ PyMac_BuildOSType, typeCode,
+ dataPtr__out__, dataPtr__len__);
+ free(dataPtr__out__);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetNthDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ DescType desiredType;
+ AEKeyword theAEKeyword;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, "lO&",
+ &index,
+ PyMac_GetOSType, &desiredType))
+ return NULL;
+ _err = AEGetNthDesc(&_self->ob_itself,
+ index,
+ desiredType,
+ &theAEKeyword,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&O&",
+ PyMac_BuildOSType, theAEKeyword,
+ AEDesc_New, &result);
+ return _res;
+}
+
+static PyObject *AEDesc_AESizeOfNthItem(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ DescType typeCode;
+ Size dataSize;
+ if (!PyArg_ParseTuple(_args, "l",
+ &index))
+ return NULL;
+ _err = AESizeOfNthItem(&_self->ob_itself,
+ index,
+ &typeCode,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&l",
+ PyMac_BuildOSType, typeCode,
+ dataSize);
+ return _res;
+}
+
+static PyObject *AEDesc_AEDeleteItem(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long index;
+ if (!PyArg_ParseTuple(_args, "l",
+ &index))
+ return NULL;
+ _err = AEDeleteItem(&_self->ob_itself,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutKeyPtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType typeCode;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "O&O&s#",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &typeCode,
+ &dataPtr__in__, &dataPtr__len__))
+ return NULL;
+ _err = AEPutKeyPtr(&_self->ob_itself,
+ theAEKeyword,
+ typeCode,
+ dataPtr__in__, dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutKeyDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ AEDesc theAEDesc;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEKeyword,
+ AEDesc_Convert, &theAEDesc))
+ return NULL;
+ _err = AEPutKeyDesc(&_self->ob_itself,
+ theAEKeyword,
+ &theAEDesc);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetKeyPtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType desiredType;
+ DescType typeCode;
+ char *dataPtr__out__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &desiredType,
+ &dataPtr__len__))
+ return NULL;
+ if ((dataPtr__out__ = malloc(dataPtr__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto dataPtr__error__;
+ }
+ _err = AEGetKeyPtr(&_self->ob_itself,
+ theAEKeyword,
+ desiredType,
+ &typeCode,
+ dataPtr__out__, dataPtr__len__, &dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&s#",
+ PyMac_BuildOSType, typeCode,
+ dataPtr__out__, dataPtr__len__);
+ free(dataPtr__out__);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetKeyDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType desiredType;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &desiredType))
+ return NULL;
+ _err = AEGetKeyDesc(&_self->ob_itself,
+ theAEKeyword,
+ desiredType,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ return _res;
+}
+
+static PyObject *AEDesc_AESizeOfKeyDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType typeCode;
+ Size dataSize;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theAEKeyword))
+ return NULL;
+ _err = AESizeOfKeyDesc(&_self->ob_itself,
+ theAEKeyword,
+ &typeCode,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&l",
+ PyMac_BuildOSType, typeCode,
+ dataSize);
+ return _res;
+}
+
+static PyObject *AEDesc_AEDeleteKeyDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theAEKeyword))
+ return NULL;
+ _err = AEDeleteKeyDesc(&_self->ob_itself,
+ theAEKeyword);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutParamPtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType typeCode;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "O&O&s#",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &typeCode,
+ &dataPtr__in__, &dataPtr__len__))
+ return NULL;
+ _err = AEPutParamPtr(&_self->ob_itself,
+ theAEKeyword,
+ typeCode,
+ dataPtr__in__, dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutParamDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ AEDesc theAEDesc;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEKeyword,
+ AEDesc_Convert, &theAEDesc))
+ return NULL;
+ _err = AEPutParamDesc(&_self->ob_itself,
+ theAEKeyword,
+ &theAEDesc);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetParamPtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType desiredType;
+ DescType typeCode;
+ char *dataPtr__out__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &desiredType,
+ &dataPtr__len__))
+ return NULL;
+ if ((dataPtr__out__ = malloc(dataPtr__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto dataPtr__error__;
+ }
+ _err = AEGetParamPtr(&_self->ob_itself,
+ theAEKeyword,
+ desiredType,
+ &typeCode,
+ dataPtr__out__, dataPtr__len__, &dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&s#",
+ PyMac_BuildOSType, typeCode,
+ dataPtr__out__, dataPtr__len__);
+ free(dataPtr__out__);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetParamDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType desiredType;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &desiredType))
+ return NULL;
+ _err = AEGetParamDesc(&_self->ob_itself,
+ theAEKeyword,
+ desiredType,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ return _res;
+}
+
+static PyObject *AEDesc_AESizeOfParam(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType typeCode;
+ Size dataSize;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theAEKeyword))
+ return NULL;
+ _err = AESizeOfParam(&_self->ob_itself,
+ theAEKeyword,
+ &typeCode,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&l",
+ PyMac_BuildOSType, typeCode,
+ dataSize);
+ return _res;
+}
+
+static PyObject *AEDesc_AEDeleteParam(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theAEKeyword))
+ return NULL;
+ _err = AEDeleteParam(&_self->ob_itself,
+ theAEKeyword);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetAttributePtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType desiredType;
+ DescType typeCode;
+ char *dataPtr__out__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &desiredType,
+ &dataPtr__len__))
+ return NULL;
+ if ((dataPtr__out__ = malloc(dataPtr__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto dataPtr__error__;
+ }
+ _err = AEGetAttributePtr(&_self->ob_itself,
+ theAEKeyword,
+ desiredType,
+ &typeCode,
+ dataPtr__out__, dataPtr__len__, &dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&s#",
+ PyMac_BuildOSType, typeCode,
+ dataPtr__out__, dataPtr__len__);
+ free(dataPtr__out__);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEGetAttributeDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType desiredType;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &desiredType))
+ return NULL;
+ _err = AEGetAttributeDesc(&_self->ob_itself,
+ theAEKeyword,
+ desiredType,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ return _res;
+}
+
+static PyObject *AEDesc_AESizeOfAttribute(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType typeCode;
+ Size dataSize;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theAEKeyword))
+ return NULL;
+ _err = AESizeOfAttribute(&_self->ob_itself,
+ theAEKeyword,
+ &typeCode,
+ &dataSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&l",
+ PyMac_BuildOSType, typeCode,
+ dataSize);
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutAttributePtr(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ DescType typeCode;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ if (!PyArg_ParseTuple(_args, "O&O&s#",
+ PyMac_GetOSType, &theAEKeyword,
+ PyMac_GetOSType, &typeCode,
+ &dataPtr__in__, &dataPtr__len__))
+ return NULL;
+ _err = AEPutAttributePtr(&_self->ob_itself,
+ theAEKeyword,
+ typeCode,
+ dataPtr__in__, dataPtr__len__);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AEDesc_AEPutAttributeDesc(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword theAEKeyword;
+ AEDesc theAEDesc;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEKeyword,
+ AEDesc_Convert, &theAEDesc))
+ return NULL;
+ _err = AEPutAttributeDesc(&_self->ob_itself,
+ theAEKeyword,
+ &theAEDesc);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AESend(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AppleEvent reply;
+ AESendMode sendMode;
+ AESendPriority sendPriority;
+ long timeOutInTicks;
+ if (!PyArg_ParseTuple(_args, "lhl",
+ &sendMode,
+ &sendPriority,
+ &timeOutInTicks))
+ return NULL;
+ _err = AESend(&_self->ob_itself,
+ &reply,
+ sendMode,
+ sendPriority,
+ timeOutInTicks,
+ AEIdleProc,
+ (AEFilterProcPtr)0);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &reply);
+ return _res;
+}
+
+static PyObject *AEDesc_AEResetTimer(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AEResetTimer(&_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AESuspendTheCurrentEvent(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AESuspendTheCurrentEvent(&_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AEResumeTheCurrentEvent(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AppleEvent reply;
+ AEEventHandlerProcPtr dispatcher__proc__ = GenericEventHandler;
+ PyObject *dispatcher;
+ if (!PyArg_ParseTuple(_args, "O&O",
+ AEDesc_Convert, &reply,
+ &dispatcher))
+ return NULL;
+ _err = AEResumeTheCurrentEvent(&_self->ob_itself,
+ &reply,
+ dispatcher__proc__, (long)dispatcher);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AEDesc_AESetTheCurrentEvent(_self, _args)
+ AEDescObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AESetTheCurrentEvent(&_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef AEDesc_methods[] = {
+ {"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1,
+ "(DescType toType) -> (AEDesc result)"},
+ {"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1,
+ "() -> (AEDesc result)"},
+ {"AECountItems", (PyCFunction)AEDesc_AECountItems, 1,
+ "() -> (long theCount)"},
+ {"AEPutPtr", (PyCFunction)AEDesc_AEPutPtr, 1,
+ "(long index, DescType typeCode, Buffer dataPtr) -> None"},
+ {"AEPutDesc", (PyCFunction)AEDesc_AEPutDesc, 1,
+ "(long index, AEDesc theAEDesc) -> None"},
+ {"AEGetNthPtr", (PyCFunction)AEDesc_AEGetNthPtr, 1,
+ "(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)"},
+ {"AEGetNthDesc", (PyCFunction)AEDesc_AEGetNthDesc, 1,
+ "(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)"},
+ {"AESizeOfNthItem", (PyCFunction)AEDesc_AESizeOfNthItem, 1,
+ "(long index) -> (DescType typeCode, Size dataSize)"},
+ {"AEDeleteItem", (PyCFunction)AEDesc_AEDeleteItem, 1,
+ "(long index) -> None"},
+ {"AEPutKeyPtr", (PyCFunction)AEDesc_AEPutKeyPtr, 1,
+ "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
+ {"AEPutKeyDesc", (PyCFunction)AEDesc_AEPutKeyDesc, 1,
+ "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
+ {"AEGetKeyPtr", (PyCFunction)AEDesc_AEGetKeyPtr, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
+ {"AEGetKeyDesc", (PyCFunction)AEDesc_AEGetKeyDesc, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
+ {"AESizeOfKeyDesc", (PyCFunction)AEDesc_AESizeOfKeyDesc, 1,
+ "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
+ {"AEDeleteKeyDesc", (PyCFunction)AEDesc_AEDeleteKeyDesc, 1,
+ "(AEKeyword theAEKeyword) -> None"},
+ {"AEPutParamPtr", (PyCFunction)AEDesc_AEPutParamPtr, 1,
+ "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
+ {"AEPutParamDesc", (PyCFunction)AEDesc_AEPutParamDesc, 1,
+ "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
+ {"AEGetParamPtr", (PyCFunction)AEDesc_AEGetParamPtr, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
+ {"AEGetParamDesc", (PyCFunction)AEDesc_AEGetParamDesc, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
+ {"AESizeOfParam", (PyCFunction)AEDesc_AESizeOfParam, 1,
+ "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
+ {"AEDeleteParam", (PyCFunction)AEDesc_AEDeleteParam, 1,
+ "(AEKeyword theAEKeyword) -> None"},
+ {"AEGetAttributePtr", (PyCFunction)AEDesc_AEGetAttributePtr, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
+ {"AEGetAttributeDesc", (PyCFunction)AEDesc_AEGetAttributeDesc, 1,
+ "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
+ {"AESizeOfAttribute", (PyCFunction)AEDesc_AESizeOfAttribute, 1,
+ "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
+ {"AEPutAttributePtr", (PyCFunction)AEDesc_AEPutAttributePtr, 1,
+ "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
+ {"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1,
+ "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
+ {"AESend", (PyCFunction)AEDesc_AESend, 1,
+ "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"},
+ {"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
+ "() -> None"},
+ {"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
+ "() -> None"},
+ {"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
+ "(AppleEvent reply, EventHandler dispatcher) -> None"},
+ {"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
+ "() -> None"},
+ {NULL, NULL, 0}
+};
+
+static PyMethodChain AEDesc_chain = { AEDesc_methods, NULL };
+
+static PyObject *AEDesc_getattr(self, name)
+ AEDescObject *self;
+ char *name;
+{
+
+ if (strcmp(name, "type") == 0)
+ return PyMac_BuildOSType(self->ob_itself.descriptorType);
+ if (strcmp(name, "data") == 0) {
+ PyObject *res;
+ char state;
+ state = HGetState(self->ob_itself.dataHandle);
+ HLock(self->ob_itself.dataHandle);
+ res = PyString_FromStringAndSize(
+ *self->ob_itself.dataHandle,
+ GetHandleSize(self->ob_itself.dataHandle));
+ HUnlock(self->ob_itself.dataHandle);
+ HSetState(self->ob_itself.dataHandle, state);
+ return res;
+ }
+ if (strcmp(name, "__members__") == 0)
+ return Py_BuildValue("[ss]", "data", "type");
+
+ return Py_FindMethodInChain(&AEDesc_chain, (PyObject *)self, name);
+}
+
+#define AEDesc_setattr NULL
+
+static PyTypeObject AEDesc_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "AEDesc", /*tp_name*/
+ sizeof(AEDescObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) AEDesc_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) AEDesc_getattr, /*tp_getattr*/
+ (setattrfunc) AEDesc_setattr, /*tp_setattr*/
+};
+
+/* --------------------- End object type AEDesc --------------------- */
+
+
+static PyObject *AE_AECreateDesc(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DescType typeCode;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, "O&s#",
+ PyMac_GetOSType, &typeCode,
+ &dataPtr__in__, &dataPtr__len__))
+ return NULL;
+ _err = AECreateDesc(typeCode,
+ dataPtr__in__, dataPtr__len__,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AE_AECoercePtr(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ DescType typeCode;
+ char *dataPtr__in__;
+ long dataPtr__len__;
+ DescType toType;
+ AEDesc result;
+ if (!PyArg_ParseTuple(_args, "O&s#O&",
+ PyMac_GetOSType, &typeCode,
+ &dataPtr__in__, &dataPtr__len__,
+ PyMac_GetOSType, &toType))
+ return NULL;
+ _err = AECoercePtr(typeCode,
+ dataPtr__in__, dataPtr__len__,
+ toType,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ dataPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AE_AECreateList(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ char *factoringPtr__in__;
+ long factoringPtr__len__;
+ Boolean isRecord;
+ AEDescList resultList;
+ if (!PyArg_ParseTuple(_args, "s#b",
+ &factoringPtr__in__, &factoringPtr__len__,
+ &isRecord))
+ return NULL;
+ _err = AECreateList(factoringPtr__in__, factoringPtr__len__,
+ isRecord,
+ &resultList);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &resultList);
+ factoringPtr__error__: ;
+ return _res;
+}
+
+static PyObject *AE_AECreateAppleEvent(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEEventClass theAEEventClass;
+ AEEventID theAEEventID;
+ AEAddressDesc target;
+ short returnID;
+ long transactionID;
+ AppleEvent result;
+ if (!PyArg_ParseTuple(_args, "O&O&O&hl",
+ PyMac_GetOSType, &theAEEventClass,
+ PyMac_GetOSType, &theAEEventID,
+ AEDesc_Convert, &target,
+ &returnID,
+ &transactionID))
+ return NULL;
+ _err = AECreateAppleEvent(theAEEventClass,
+ theAEEventID,
+ &target,
+ returnID,
+ transactionID,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &result);
+ return _res;
+}
+
+static PyObject *AE_AEProcessAppleEvent(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ EventRecord theEventRecord;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &theEventRecord))
+ return NULL;
+ _err = AEProcessAppleEvent(&theEventRecord);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AE_AEGetTheCurrentEvent(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AppleEvent theAppleEvent;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AEGetTheCurrentEvent(&theAppleEvent);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ AEDesc_New, &theAppleEvent);
+ return _res;
+}
+
+static PyObject *AE_AEGetInteractionAllowed(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEInteractAllowed level;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = AEGetInteractionAllowed(&level);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ level);
+ return _res;
+}
+
+static PyObject *AE_AESetInteractionAllowed(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEInteractAllowed level;
+ if (!PyArg_ParseTuple(_args, "b",
+ &level))
+ return NULL;
+ _err = AESetInteractionAllowed(level);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AE_AEInteractWithUser(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ long timeOutInTicks;
+ if (!PyArg_ParseTuple(_args, "l",
+ &timeOutInTicks))
+ return NULL;
+ _err = AEInteractWithUser(timeOutInTicks,
+ (NMRecPtr)0,
+ AEIdleProc);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AE_AEInstallEventHandler(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEEventClass theAEEventClass;
+ AEEventID theAEEventID;
+ AEEventHandlerProcPtr handler__proc__ = GenericEventHandler;
+ PyObject *handler;
+ if (!PyArg_ParseTuple(_args, "O&O&O",
+ PyMac_GetOSType, &theAEEventClass,
+ PyMac_GetOSType, &theAEEventID,
+ &handler))
+ return NULL;
+ _err = AEInstallEventHandler(theAEEventClass,
+ theAEEventID,
+ handler__proc__, (long)handler,
+ 0);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AE_AERemoveEventHandler(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEEventClass theAEEventClass;
+ AEEventID theAEEventID;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theAEEventClass,
+ PyMac_GetOSType, &theAEEventID))
+ return NULL;
+ _err = AERemoveEventHandler(theAEEventClass,
+ theAEEventID,
+ GenericEventHandler,
+ 0);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *AE_AEManagerInfo(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ AEKeyword keyWord;
+ long result;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &keyWord))
+ return NULL;
+ _err = AEManagerInfo(keyWord,
+ &result);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ result);
+ return _res;
+}
+
+static PyMethodDef AE_methods[] = {
+ {"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
+ "(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"},
+ {"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
+ "(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"},
+ {"AECreateList", (PyCFunction)AE_AECreateList, 1,
+ "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"},
+ {"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
+ "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, short returnID, long transactionID) -> (AppleEvent result)"},
+ {"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
+ "(EventRecord theEventRecord) -> None"},
+ {"AEGetTheCurrentEvent", (PyCFunction)AE_AEGetTheCurrentEvent, 1,
+ "() -> (AppleEvent theAppleEvent)"},
+ {"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
+ "() -> (AEInteractAllowed level)"},
+ {"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
+ "(AEInteractAllowed level) -> None"},
+ {"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
+ "(long timeOutInTicks) -> None"},
+ {"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
+ "(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None"},
+ {"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
+ "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None"},
+ {"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
+ "(AEKeyword keyWord) -> (long result)"},
+ {NULL, NULL, 0}
+};
+
+
+
+static pascal OSErr
+GenericEventHandler(const AppleEvent *request, AppleEvent *reply, long refcon)
+{
+ PyObject *handler = (PyObject *)refcon;
+ AEDescObject *requestObject, *replyObject;
+ PyObject *args, *res;
+ if ((requestObject = (AEDescObject *)AEDesc_New(request)) == NULL) {
+ return -1;
+ }
+ if ((replyObject = (AEDescObject *)AEDesc_New(reply)) == NULL) {
+ Py_DECREF(requestObject);
+ return -1;
+ }
+ if ((args = Py_BuildValue("OO", requestObject, replyObject)) == NULL) {
+ Py_DECREF(requestObject);
+ Py_DECREF(replyObject);
+ return -1;
+ }
+ res = PyEval_CallObject(handler, args);
+ requestObject->ob_itself.descriptorType = 'null';
+ requestObject->ob_itself.dataHandle = NULL;
+ replyObject->ob_itself.descriptorType = 'null';
+ replyObject->ob_itself.dataHandle = NULL;
+ Py_DECREF(args);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return noErr;
+}
+
+
+void initAE()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("AE", AE_methods);
+ d = PyModule_GetDict(m);
+ AE_Error = PyMac_GetOSErrException();
+ if (AE_Error == NULL ||
+ PyDict_SetItemString(d, "Error", AE_Error) != 0)
+ Py_FatalError("can't initialize AE.Error");
+}
+
+/* ========================= End module AE ========================== */
+
diff --git a/Mac/Modules/ae/aegen.py b/Mac/Modules/ae/aegen.py
new file mode 100644
index 0000000..ea9b3b6
--- /dev/null
+++ b/Mac/Modules/ae/aegen.py
@@ -0,0 +1,314 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:AppleEvents.h'
+
+f = AEFunction(OSErr, 'AECreateDesc',
+ (DescType, 'typeCode', InMode),
+ (InBuffer, 'dataPtr', InMode),
+ (AEDesc, 'result', OutMode),
+)
+functions.append(f)
+
+f = AEFunction(OSErr, 'AECoercePtr',
+ (DescType, 'typeCode', InMode),
+ (InBuffer, 'dataPtr', InMode),
+ (DescType, 'toType', InMode),
+ (AEDesc, 'result', OutMode),
+)
+functions.append(f)
+
+f = AEMethod(OSErr, 'AECoerceDesc',
+ (AEDesc_ptr, 'theAEDesc', InMode),
+ (DescType, 'toType', InMode),
+ (AEDesc, 'result', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEDuplicateDesc',
+ (AEDesc_ptr, 'theAEDesc', InMode),
+ (AEDesc, 'result', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEFunction(OSErr, 'AECreateList',
+ (InBuffer, 'factoringPtr', InMode),
+ (Boolean, 'isRecord', InMode),
+ (AEDescList, 'resultList', OutMode),
+)
+functions.append(f)
+
+f = AEMethod(OSErr, 'AECountItems',
+ (AEDescList_ptr, 'theAEDescList', InMode),
+ (long, 'theCount', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutPtr',
+ (AEDescList_ptr, 'theAEDescList', InMode),
+ (long, 'index', InMode),
+ (DescType, 'typeCode', InMode),
+ (InBuffer, 'dataPtr', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutDesc',
+ (AEDescList_ptr, 'theAEDescList', InMode),
+ (long, 'index', InMode),
+ (AEDesc_ptr, 'theAEDesc', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetNthPtr',
+ (AEDescList_ptr, 'theAEDescList', InMode),
+ (long, 'index', InMode),
+ (DescType, 'desiredType', InMode),
+ (AEKeyword, 'theAEKeyword', OutMode),
+ (DescType, 'typeCode', OutMode),
+ (VarVarOutBuffer, 'dataPtr', InOutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetNthDesc',
+ (AEDescList_ptr, 'theAEDescList', InMode),
+ (long, 'index', InMode),
+ (DescType, 'desiredType', InMode),
+ (AEKeyword, 'theAEKeyword', OutMode),
+ (AEDesc, 'result', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AESizeOfNthItem',
+ (AEDescList_ptr, 'theAEDescList', InMode),
+ (long, 'index', InMode),
+ (DescType, 'typeCode', OutMode),
+ (Size, 'dataSize', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEDeleteItem',
+ (AEDescList_ptr, 'theAEDescList', InMode),
+ (long, 'index', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutKeyPtr',
+ (AERecord_ptr, 'theAERecord', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'typeCode', InMode),
+ (InBuffer, 'dataPtr', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutKeyDesc',
+ (AERecord_ptr, 'theAERecord', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (AEDesc_ptr, 'theAEDesc', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetKeyPtr',
+ (AERecord_ptr, 'theAERecord', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'desiredType', InMode),
+ (DescType, 'typeCode', OutMode),
+ (VarVarOutBuffer, 'dataPtr', InOutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetKeyDesc',
+ (AERecord_ptr, 'theAERecord', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'desiredType', InMode),
+ (AEDesc, 'result', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AESizeOfKeyDesc',
+ (AERecord_ptr, 'theAERecord', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'typeCode', OutMode),
+ (Size, 'dataSize', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEDeleteKeyDesc',
+ (AERecord_ptr, 'theAERecord', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutParamPtr',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'typeCode', InMode),
+ (InBuffer, 'dataPtr', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutParamDesc',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (AEDesc_ptr, 'theAEDesc', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetParamPtr',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'desiredType', InMode),
+ (DescType, 'typeCode', OutMode),
+ (VarVarOutBuffer, 'dataPtr', InOutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetParamDesc',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'desiredType', InMode),
+ (AEDesc, 'result', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AESizeOfParam',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'typeCode', OutMode),
+ (Size, 'dataSize', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEDeleteParam',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetAttributePtr',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'desiredType', InMode),
+ (DescType, 'typeCode', OutMode),
+ (VarVarOutBuffer, 'dataPtr', InOutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEGetAttributeDesc',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'desiredType', InMode),
+ (AEDesc, 'result', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AESizeOfAttribute',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'typeCode', OutMode),
+ (Size, 'dataSize', OutMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutAttributePtr',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (DescType, 'typeCode', InMode),
+ (InBuffer, 'dataPtr', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEPutAttributeDesc',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AEKeyword, 'theAEKeyword', InMode),
+ (AEDesc_ptr, 'theAEDesc', InMode),
+)
+aedescmethods.append(f)
+
+f = AEFunction(OSErr, 'AECreateAppleEvent',
+ (AEEventClass, 'theAEEventClass', InMode),
+ (AEEventID, 'theAEEventID', InMode),
+ (AEAddressDesc_ptr, 'target', InMode),
+ (short, 'returnID', InMode),
+ (long, 'transactionID', InMode),
+ (AppleEvent, 'result', OutMode),
+)
+functions.append(f)
+
+f = AEMethod(OSErr, 'AESend',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AppleEvent, 'reply', OutMode),
+ (AESendMode, 'sendMode', InMode),
+ (AESendPriority, 'sendPriority', InMode),
+ (long, 'timeOutInTicks', InMode),
+ (IdleProcPtr, 'idleProc', InMode),
+ (EventFilterProcPtr, 'filterProc', InMode),
+)
+aedescmethods.append(f)
+
+f = AEFunction(OSErr, 'AEProcessAppleEvent',
+ (EventRecord_ptr, 'theEventRecord', InMode),
+)
+functions.append(f)
+
+f = AEMethod(OSErr, 'AEResetTimer',
+ (AppleEvent_ptr, 'reply', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AESuspendTheCurrentEvent',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+)
+aedescmethods.append(f)
+
+f = AEMethod(OSErr, 'AEResumeTheCurrentEvent',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+ (AppleEvent_ptr, 'reply', InMode),
+ (EventHandler, 'dispatcher', InMode),
+)
+aedescmethods.append(f)
+
+f = AEFunction(OSErr, 'AEGetTheCurrentEvent',
+ (AppleEvent, 'theAppleEvent', OutMode),
+)
+functions.append(f)
+
+f = AEMethod(OSErr, 'AESetTheCurrentEvent',
+ (AppleEvent_ptr, 'theAppleEvent', InMode),
+)
+aedescmethods.append(f)
+
+f = AEFunction(OSErr, 'AEGetInteractionAllowed',
+ (AEInteractAllowed, 'level', OutMode),
+)
+functions.append(f)
+
+f = AEFunction(OSErr, 'AESetInteractionAllowed',
+ (AEInteractAllowed, 'level', InMode),
+)
+functions.append(f)
+
+f = AEFunction(OSErr, 'AEInteractWithUser',
+ (long, 'timeOutInTicks', InMode),
+ (NMRecPtr, 'nmReqPtr', InMode),
+ (IdleProcPtr, 'idleProc', InMode),
+)
+functions.append(f)
+
+f = AEFunction(OSErr, 'AEInstallEventHandler',
+ (AEEventClass, 'theAEEventClass', InMode),
+ (AEEventID, 'theAEEventID', InMode),
+ (EventHandler, 'handler', InMode),
+ (AlwaysFalse, 'isSysHandler', InMode),
+)
+functions.append(f)
+
+f = AEFunction(OSErr, 'AERemoveEventHandler',
+ (AEEventClass, 'theAEEventClass', InMode),
+ (AEEventID, 'theAEEventID', InMode),
+ (EventHandlerProcPtr, 'handler', InMode),
+ (AlwaysFalse, 'isSysHandler', InMode),
+)
+functions.append(f)
+
+f = AEFunction(OSErr, 'AEManagerInfo',
+ (AEKeyword, 'keyWord', InMode),
+ (long, 'result', OutMode),
+)
+functions.append(f)
diff --git a/Mac/Modules/ae/aescan.py b/Mac/Modules/ae/aescan.py
new file mode 100644
index 0000000..75003ec
--- /dev/null
+++ b/Mac/Modules/ae/aescan.py
@@ -0,0 +1,71 @@
+# Scan AppleEvents.h header file, generate aegen.py and AppleEvents.py files.
+# Then run aesupport to generate AEmodule.c.
+0# (Should learn how to tell the compiler to compile it as well.)
+
+import sys
+import os
+import string
+import regex
+import regsub
+import MacOS
+
+from scantools import Scanner
+
+def main():
+ input = "AppleEvents.h"
+ output = "aegen.py"
+ defsoutput = "AppleEvents.py"
+ scanner = AppleEventsScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done Scanning and Generating, now doing 'import aesupport' ==="
+ import aesupport
+ print "=== Done 'import aesupport'. It's up to you to compile AEmodule.c ==="
+
+class AppleEventsScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "AEFunction"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ if t[-4:] == "_ptr" and m == "InMode" and \
+ t[:-4] in ("AEDesc", "AEAddressDesc", "AEDescList",
+ "AERecord", "AppleEvent"):
+ classname = "AEMethod"
+ listname = "aedescmethods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ "AEDisposeDesc",
+ "AEGetEventHandler",
+ ]
+
+ def makeblacklisttypes(self):
+ return [
+ "ProcPtr",
+ "AEArrayType",
+ ]
+
+ def makerepairinstructions(self):
+ return [
+ ([("Boolean", "isSysHandler", "InMode")],
+ [("AlwaysFalse", "*", "*")]),
+
+ ([("void_ptr", "*", "InMode"), ("Size", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("EventHandlerProcPtr", "*", "InMode"), ("long", "*", "InMode")],
+ [("EventHandler", "*", "*")]),
+
+ ([("EventHandlerProcPtr", "*", "OutMode"), ("long", "*", "OutMode")],
+ [("EventHandler", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("Size", "*", "InMode"),
+ ("Size", "*", "OutMode")],
+ [("VarVarOutBuffer", "*", "InOutMode")]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/ae/aesupport.py b/Mac/Modules/ae/aesupport.py
new file mode 100644
index 0000000..49f072b
--- /dev/null
+++ b/Mac/Modules/ae/aesupport.py
@@ -0,0 +1,168 @@
+# This script will generate the AppleEvents interface for Python.
+# It uses the "bgen" package to generate C code.
+# It execs the file aegen.py which contain the function definitions
+# (aegen.py was generated by aescan.py, scanning the <AppleEvents.h> header file).
+
+
+from macsupport import *
+
+
+AEArrayType = Type("AEArrayType", "c")
+AESendMode = Type("AESendMode", "l")
+AESendPriority = Type("AESendPriority", "h")
+AEInteractAllowed = Type("AEInteractAllowed", "b")
+
+
+AEEventClass = OSTypeType('AEEventClass')
+AEEventID = OSTypeType('AEEventID')
+AEKeyword = OSTypeType('AEKeyword')
+DescType = OSTypeType('DescType')
+
+
+AEDesc = OpaqueType('AEDesc')
+AEDesc_ptr = OpaqueType('AEDesc')
+
+AEAddressDesc = OpaqueType('AEAddressDesc', 'AEDesc')
+AEAddressDesc_ptr = OpaqueType('AEAddressDesc', 'AEDesc')
+
+AEDescList = OpaqueType('AEDescList', 'AEDesc')
+AEDescList_ptr = OpaqueType('AEDescList', 'AEDesc')
+
+AERecord = OpaqueType('AERecord', 'AEDesc')
+AERecord_ptr = OpaqueType('AERecord', 'AEDesc')
+
+AppleEvent = OpaqueType('AppleEvent', 'AEDesc')
+AppleEvent_ptr = OpaqueType('AppleEvent', 'AEDesc')
+
+
+class EHType(Type):
+ def __init__(self, name = 'EventHandler', format = ''):
+ Type.__init__(self, name, format)
+ def declare(self, name):
+ Output("AEEventHandlerProcPtr %s__proc__ = GenericEventHandler;", name)
+ Output("PyObject *%s;", name)
+ def getargsFormat(self):
+ return "O"
+ def getargsArgs(self, name):
+ return "&%s" % name
+ def passInput(self, name):
+ return "%s__proc__, (long)%s" % (name, name)
+ def passOutput(self, name):
+ return "&%s__proc__, (long *)&%s" % (name, name)
+ def mkvalueFormat(self):
+ return "O"
+ def mkvalueArgs(self, name):
+ return name
+
+class EHNoRefConType(EHType):
+ def passInput(self, name):
+ return "GenericEventHandler"
+
+EventHandler = EHType()
+EventHandlerNoRefCon = EHNoRefConType()
+
+
+IdleProcPtr = FakeType("AEIdleProc")
+EventFilterProcPtr = FakeType("(AEFilterProcPtr)0")
+NMRecPtr = FakeType("(NMRecPtr)0")
+EventHandlerProcPtr = FakeType("GenericEventHandler")
+AlwaysFalse = FakeType("0")
+
+
+AEFunction = OSErrFunctionGenerator
+AEMethod = OSErrMethodGenerator
+
+
+includestuff = includestuff + """
+#include <AppleEvents.h>
+
+#ifdef THINK_C
+#define AEFilterProcPtr EventFilterProcPtr
+#define AEEventHandlerProcPtr EventHandlerProcPtr
+#endif
+
+static pascal OSErr GenericEventHandler(); /* Forward */
+
+static pascal Boolean AEIdleProc(EventRecord *theEvent, long *sleepTime, RgnHandle *mouseRgn)
+{
+ return !PyMac_Idle();
+}
+"""
+
+finalstuff = finalstuff + """
+static pascal OSErr
+GenericEventHandler(const AppleEvent *request, AppleEvent *reply, long refcon)
+{
+ PyObject *handler = (PyObject *)refcon;
+ AEDescObject *requestObject, *replyObject;
+ PyObject *args, *res;
+ if ((requestObject = (AEDescObject *)AEDesc_New(request)) == NULL) {
+ return -1;
+ }
+ if ((replyObject = (AEDescObject *)AEDesc_New(reply)) == NULL) {
+ Py_DECREF(requestObject);
+ return -1;
+ }
+ if ((args = Py_BuildValue("OO", requestObject, replyObject)) == NULL) {
+ Py_DECREF(requestObject);
+ Py_DECREF(replyObject);
+ return -1;
+ }
+ res = PyEval_CallObject(handler, args);
+ requestObject->ob_itself.descriptorType = 'null';
+ requestObject->ob_itself.dataHandle = NULL;
+ replyObject->ob_itself.descriptorType = 'null';
+ replyObject->ob_itself.dataHandle = NULL;
+ Py_DECREF(args);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return noErr;
+}
+"""
+
+module = MacModule('AE', 'AE', includestuff, finalstuff, initstuff)
+
+class AEDescDefiniton(ObjectDefinition):
+
+ def __init__(self, name, prefix = None, itselftype = None):
+ ObjectDefinition.__init__(self, name, prefix or name, itselftype or name)
+ self.argref = "*"
+
+ def outputFreeIt(self, name):
+ Output("AEDisposeDesc(&%s);", name)
+
+ def outputGetattrHook(self):
+ Output("""
+if (strcmp(name, "type") == 0)
+ return PyMac_BuildOSType(self->ob_itself.descriptorType);
+if (strcmp(name, "data") == 0) {
+ PyObject *res;
+ char state;
+ state = HGetState(self->ob_itself.dataHandle);
+ HLock(self->ob_itself.dataHandle);
+ res = PyString_FromStringAndSize(
+ *self->ob_itself.dataHandle,
+ GetHandleSize(self->ob_itself.dataHandle));
+ HUnlock(self->ob_itself.dataHandle);
+ HSetState(self->ob_itself.dataHandle, state);
+ return res;
+}
+if (strcmp(name, "__members__") == 0)
+ return Py_BuildValue("[ss]", "data", "type");
+""")
+
+
+aedescobject = AEDescDefiniton('AEDesc')
+module.addobject(aedescobject)
+
+functions = []
+aedescmethods = []
+
+execfile('aegen.py')
+
+for f in functions: module.add(f)
+for f in aedescmethods: aedescobject.add(f)
+
+SetOutputFileName('AEmodule.c')
+module.generate()
diff --git a/Mac/Modules/ctl/Ctlmodule.c b/Mac/Modules/ctl/Ctlmodule.c
new file mode 100644
index 0000000..fb1459a
--- /dev/null
+++ b/Mac/Modules/ctl/Ctlmodule.c
@@ -0,0 +1,691 @@
+
+/* =========================== Module Ctl =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+extern PyObject *WinObj_WhichWindow(WindowPtr);
+
+#include <Controls.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+extern PyObject *CtlObj_WhichControl(ControlHandle); /* Forward */
+
+#ifdef THINK_C
+#define ControlActionUPP ProcPtr
+#endif
+
+static PyObject *Ctl_Error;
+
+/* ---------------------- Object type Control ----------------------- */
+
+PyTypeObject Control_Type;
+
+#define CtlObj_Check(x) ((x)->ob_type == &Control_Type)
+
+typedef struct ControlObject {
+ PyObject_HEAD
+ ControlHandle ob_itself;
+} ControlObject;
+
+PyObject *CtlObj_New(itself)
+ const ControlHandle itself;
+{
+ ControlObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(ControlObject, &Control_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ SetCRefCon(itself, (long)it);
+ return (PyObject *)it;
+}
+CtlObj_Convert(v, p_itself)
+ PyObject *v;
+ ControlHandle *p_itself;
+{
+ if (!CtlObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Control required");
+ return 0;
+ }
+ *p_itself = ((ControlObject *)v)->ob_itself;
+ return 1;
+}
+
+static void CtlObj_dealloc(self)
+ ControlObject *self;
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *CtlObj_SetCTitle(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, title))
+ return NULL;
+ SetCTitle(_self->ob_itself,
+ title);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetCTitle(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, title))
+ return NULL;
+ GetCTitle(_self->ob_itself,
+ title);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_DisposeControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DisposeControl(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_HideControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ HideControl(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_ShowControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowControl(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_Draw1Control(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ Draw1Control(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_HiliteControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short hiliteState;
+ if (!PyArg_ParseTuple(_args, "h",
+ &hiliteState))
+ return NULL;
+ HiliteControl(_self->ob_itself,
+ hiliteState);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_MoveControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short h;
+ short v;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &h,
+ &v))
+ return NULL;
+ MoveControl(_self->ob_itself,
+ h,
+ v);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SizeControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short w;
+ short h;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &w,
+ &h))
+ return NULL;
+ SizeControl(_self->ob_itself,
+ w,
+ h);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_SetCtlValue(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short theValue;
+ if (!PyArg_ParseTuple(_args, "h",
+ &theValue))
+ return NULL;
+ SetCtlValue(_self->ob_itself,
+ theValue);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetCtlValue(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCtlValue(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetCtlMin(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short minValue;
+ if (!PyArg_ParseTuple(_args, "h",
+ &minValue))
+ return NULL;
+ SetCtlMin(_self->ob_itself,
+ minValue);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetCtlMin(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCtlMin(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetCtlMax(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short maxValue;
+ if (!PyArg_ParseTuple(_args, "h",
+ &maxValue))
+ return NULL;
+ SetCtlMax(_self->ob_itself,
+ maxValue);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetCtlMax(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCtlMax(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_SetCRefCon(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long data;
+ if (!PyArg_ParseTuple(_args, "l",
+ &data))
+ return NULL;
+ SetCRefCon(_self->ob_itself,
+ data);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_GetCRefCon(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCRefCon(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_DragControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Point startPt;
+ Rect limitRect;
+ Rect slopRect;
+ short axis;
+ if (!PyArg_ParseTuple(_args, "O&O&O&h",
+ PyMac_GetPoint, &startPt,
+ PyMac_GetRect, &limitRect,
+ PyMac_GetRect, &slopRect,
+ &axis))
+ return NULL;
+ DragControl(_self->ob_itself,
+ startPt,
+ &limitRect,
+ &slopRect,
+ axis);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *CtlObj_TestControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Point thePt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = TestControl(_self->ob_itself,
+ thePt);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_TrackControl(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Point thePoint;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePoint))
+ return NULL;
+ _rv = TrackControl(_self->ob_itself,
+ thePoint,
+ (ControlActionUPP)0);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *CtlObj_GetCVariant(_self, _args)
+ ControlObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetCVariant(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef CtlObj_methods[] = {
+ {"SetCTitle", (PyCFunction)CtlObj_SetCTitle, 1,
+ "(Str255 title) -> None"},
+ {"GetCTitle", (PyCFunction)CtlObj_GetCTitle, 1,
+ "(Str255 title) -> None"},
+ {"DisposeControl", (PyCFunction)CtlObj_DisposeControl, 1,
+ "() -> None"},
+ {"HideControl", (PyCFunction)CtlObj_HideControl, 1,
+ "() -> None"},
+ {"ShowControl", (PyCFunction)CtlObj_ShowControl, 1,
+ "() -> None"},
+ {"Draw1Control", (PyCFunction)CtlObj_Draw1Control, 1,
+ "() -> None"},
+ {"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1,
+ "(short hiliteState) -> None"},
+ {"MoveControl", (PyCFunction)CtlObj_MoveControl, 1,
+ "(short h, short v) -> None"},
+ {"SizeControl", (PyCFunction)CtlObj_SizeControl, 1,
+ "(short w, short h) -> None"},
+ {"SetCtlValue", (PyCFunction)CtlObj_SetCtlValue, 1,
+ "(short theValue) -> None"},
+ {"GetCtlValue", (PyCFunction)CtlObj_GetCtlValue, 1,
+ "() -> (short _rv)"},
+ {"SetCtlMin", (PyCFunction)CtlObj_SetCtlMin, 1,
+ "(short minValue) -> None"},
+ {"GetCtlMin", (PyCFunction)CtlObj_GetCtlMin, 1,
+ "() -> (short _rv)"},
+ {"SetCtlMax", (PyCFunction)CtlObj_SetCtlMax, 1,
+ "(short maxValue) -> None"},
+ {"GetCtlMax", (PyCFunction)CtlObj_GetCtlMax, 1,
+ "() -> (short _rv)"},
+ {"SetCRefCon", (PyCFunction)CtlObj_SetCRefCon, 1,
+ "(long data) -> None"},
+ {"GetCRefCon", (PyCFunction)CtlObj_GetCRefCon, 1,
+ "() -> (long _rv)"},
+ {"DragControl", (PyCFunction)CtlObj_DragControl, 1,
+ "(Point startPt, Rect limitRect, Rect slopRect, short axis) -> None"},
+ {"TestControl", (PyCFunction)CtlObj_TestControl, 1,
+ "(Point thePt) -> (short _rv)"},
+ {"TrackControl", (PyCFunction)CtlObj_TrackControl, 1,
+ "(Point thePoint) -> (short _rv)"},
+ {"GetCVariant", (PyCFunction)CtlObj_GetCVariant, 1,
+ "() -> (short _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain CtlObj_chain = { CtlObj_methods, NULL };
+
+static PyObject *CtlObj_getattr(self, name)
+ ControlObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&CtlObj_chain, (PyObject *)self, name);
+}
+
+#define CtlObj_setattr NULL
+
+PyTypeObject Control_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Control", /*tp_name*/
+ sizeof(ControlObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) CtlObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) CtlObj_getattr, /*tp_getattr*/
+ (setattrfunc) CtlObj_setattr, /*tp_setattr*/
+};
+
+/* -------------------- End object type Control --------------------- */
+
+
+static PyObject *Ctl_NewControl(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ WindowPtr theWindow;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ short value;
+ short min;
+ short max;
+ short procID;
+ long refCon;
+ if (!PyArg_ParseTuple(_args, "O&O&O&bhhhhl",
+ WinObj_Convert, &theWindow,
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &value,
+ &min,
+ &max,
+ &procID,
+ &refCon))
+ return NULL;
+ _rv = NewControl(theWindow,
+ &boundsRect,
+ title,
+ visible,
+ value,
+ min,
+ max,
+ procID,
+ refCon);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Ctl_GetNewControl(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ControlHandle _rv;
+ short controlID;
+ WindowPtr owner;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &controlID,
+ WinObj_Convert, &owner))
+ return NULL;
+ _rv = GetNewControl(controlID,
+ owner);
+ _res = Py_BuildValue("O&",
+ CtlObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Ctl_KillControls(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &theWindow))
+ return NULL;
+ KillControls(theWindow);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_DrawControls(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &theWindow))
+ return NULL;
+ DrawControls(theWindow);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_UpdtControl(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &theWindow))
+ return NULL;
+ UpdtControl(theWindow,
+ theWindow->visRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_UpdateControls(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &theWindow))
+ return NULL;
+ UpdateControls(theWindow,
+ theWindow->visRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Ctl_FindControl(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Point thePoint;
+ WindowPtr theWindow;
+ ControlHandle theControl;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &thePoint,
+ WinObj_Convert, &theWindow))
+ return NULL;
+ _rv = FindControl(thePoint,
+ theWindow,
+ &theControl);
+ _res = Py_BuildValue("hO&",
+ _rv,
+ CtlObj_WhichControl, theControl);
+ return _res;
+}
+
+static PyMethodDef Ctl_methods[] = {
+ {"NewControl", (PyCFunction)Ctl_NewControl, 1,
+ "(WindowPtr theWindow, Rect boundsRect, Str255 title, Boolean visible, short value, short min, short max, short procID, long refCon) -> (ControlHandle _rv)"},
+ {"GetNewControl", (PyCFunction)Ctl_GetNewControl, 1,
+ "(short controlID, WindowPtr owner) -> (ControlHandle _rv)"},
+ {"KillControls", (PyCFunction)Ctl_KillControls, 1,
+ "(WindowPtr theWindow) -> None"},
+ {"DrawControls", (PyCFunction)Ctl_DrawControls, 1,
+ "(WindowPtr theWindow) -> None"},
+ {"UpdtControl", (PyCFunction)Ctl_UpdtControl, 1,
+ "(WindowPtr theWindow) -> None"},
+ {"UpdateControls", (PyCFunction)Ctl_UpdateControls, 1,
+ "(WindowPtr theWindow) -> None"},
+ {"FindControl", (PyCFunction)Ctl_FindControl, 1,
+ "(Point thePoint, WindowPtr theWindow) -> (short _rv, ControlHandle theControl)"},
+ {NULL, NULL, 0}
+};
+
+
+
+PyObject *
+CtlObj_WhichControl(ControlHandle c)
+{
+ PyObject *it;
+
+ /* XXX What if we find a control belonging to some other package? */
+ if (c == NULL)
+ it = NULL;
+ else
+ it = (PyObject *) GetCRefCon(c);
+ if (it == NULL || ((ControlObject *)it)->ob_itself != c)
+ it = Py_None;
+ Py_INCREF(it);
+ return it;
+}
+
+
+void initCtl()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("Ctl", Ctl_methods);
+ d = PyModule_GetDict(m);
+ Ctl_Error = PyMac_GetOSErrException();
+ if (Ctl_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Ctl_Error) != 0)
+ Py_FatalError("can't initialize Ctl.Error");
+}
+
+/* ========================= End module Ctl ========================= */
+
diff --git a/Mac/Modules/ctl/ctlgen.py b/Mac/Modules/ctl/ctlgen.py
new file mode 100644
index 0000000..fcbf0f4
--- /dev/null
+++ b/Mac/Modules/ctl/ctlgen.py
@@ -0,0 +1,172 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Controls.h'
+
+f = Function(ControlHandle, 'NewControl',
+ (WindowPtr, 'theWindow', InMode),
+ (Rect_ptr, 'boundsRect', InMode),
+ (ConstStr255Param, 'title', InMode),
+ (Boolean, 'visible', InMode),
+ (short, 'value', InMode),
+ (short, 'min', InMode),
+ (short, 'max', InMode),
+ (short, 'procID', InMode),
+ (long, 'refCon', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'SetCTitle',
+ (ControlHandle, 'theControl', InMode),
+ (ConstStr255Param, 'title', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'GetCTitle',
+ (ControlHandle, 'theControl', InMode),
+ (Str255, 'title', InMode),
+)
+methods.append(f)
+
+f = Function(ControlHandle, 'GetNewControl',
+ (short, 'controlID', InMode),
+ (WindowPtr, 'owner', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'DisposeControl',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Function(void, 'KillControls',
+ (WindowPtr, 'theWindow', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'HideControl',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'ShowControl',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Function(void, 'DrawControls',
+ (WindowPtr, 'theWindow', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'Draw1Control',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'HiliteControl',
+ (ControlHandle, 'theControl', InMode),
+ (short, 'hiliteState', InMode),
+)
+methods.append(f)
+
+f = Function(void, 'UpdtControl',
+ (WindowPtr, 'theWindow', InMode),
+ (RgnHandle, 'updateRgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'UpdateControls',
+ (WindowPtr, 'theWindow', InMode),
+ (RgnHandle, 'updateRgn', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'MoveControl',
+ (ControlHandle, 'theControl', InMode),
+ (short, 'h', InMode),
+ (short, 'v', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SizeControl',
+ (ControlHandle, 'theControl', InMode),
+ (short, 'w', InMode),
+ (short, 'h', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetCtlValue',
+ (ControlHandle, 'theControl', InMode),
+ (short, 'theValue', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'GetCtlValue',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetCtlMin',
+ (ControlHandle, 'theControl', InMode),
+ (short, 'minValue', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'GetCtlMin',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetCtlMax',
+ (ControlHandle, 'theControl', InMode),
+ (short, 'maxValue', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'GetCtlMax',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetCRefCon',
+ (ControlHandle, 'theControl', InMode),
+ (long, 'data', InMode),
+)
+methods.append(f)
+
+f = Method(long, 'GetCRefCon',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'DragControl',
+ (ControlHandle, 'theControl', InMode),
+ (Point, 'startPt', InMode),
+ (Rect_ptr, 'limitRect', InMode),
+ (Rect_ptr, 'slopRect', InMode),
+ (short, 'axis', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'TestControl',
+ (ControlHandle, 'theControl', InMode),
+ (Point, 'thePt', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'TrackControl',
+ (ControlHandle, 'theControl', InMode),
+ (Point, 'thePoint', InMode),
+ (FakeType('(ControlActionUPP)0'), 'actionProc', InMode),
+)
+methods.append(f)
+
+f = Function(short, 'FindControl',
+ (Point, 'thePoint', InMode),
+ (WindowPtr, 'theWindow', InMode),
+ (ExistingControlHandle, 'theControl', OutMode),
+)
+functions.append(f)
+
+f = Method(short, 'GetCVariant',
+ (ControlHandle, 'theControl', InMode),
+)
+methods.append(f)
diff --git a/Mac/Modules/ctl/ctlscan.py b/Mac/Modules/ctl/ctlscan.py
new file mode 100644
index 0000000..f104e8d
--- /dev/null
+++ b/Mac/Modules/ctl/ctlscan.py
@@ -0,0 +1,60 @@
+# Scan <Controls.h>, generating ctlgen.py.
+
+from scantools import Scanner
+
+def main():
+ input = "Controls.h"
+ output = "ctlgen.py"
+ defsoutput = "Controls.py"
+ scanner = MyScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done scanning and generating, now doing 'import ctlsupport' ==="
+ import ctlsupport
+ print "=== Done. It's up to you to compile Ctlmodule.c ==="
+
+class MyScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "Function"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ if t == "ControlHandle" and m == "InMode":
+ classname = "Method"
+ listname = "methods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ 'DisposeControl' # Implied by deletion of control object
+ 'KillControls', # Implied by close of dialog
+ 'SetCtlAction',
+ ]
+
+ def makeblacklisttypes(self):
+ return [
+ 'ProcPtr',
+ 'CCTabHandle',
+ 'AuxCtlHandle',
+ ]
+
+ def makerepairinstructions(self):
+ return [
+ ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+ ("long", "*", "OutMode")],
+ [("VarVarOutBuffer", "*", "InOutMode")]),
+
+ # For TrackControl
+ ([("ProcPtr", "actionProc", "InMode")],
+ [("FakeType('(ControlActionUPP)0')", "*", "*")]),
+
+ ([("ControlHandle", "*", "OutMode")],
+ [("ExistingControlHandle", "*", "*")]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/ctl/ctlsupport.py b/Mac/Modules/ctl/ctlsupport.py
new file mode 100644
index 0000000..97b1f33
--- /dev/null
+++ b/Mac/Modules/ctl/ctlsupport.py
@@ -0,0 +1,86 @@
+# This script generates a Python interface for an Apple Macintosh Manager.
+# It uses the "bgen" package to generate C code.
+# The function specifications are generated by scanning the mamager's header file,
+# using the "scantools" package (customized for this particular manager).
+
+import string
+
+# Declarations that change for each manager
+MACHEADERFILE = 'Controls.h' # The Apple header file
+MODNAME = 'Ctl' # The name of the module
+OBJECTNAME = 'Control' # The basic name of the objects used here
+
+# The following is *usually* unchanged but may still require tuning
+MODPREFIX = MODNAME # The prefix for module-wide routines
+OBJECTTYPE = OBJECTNAME + 'Handle' # The C type used to represent them
+OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods
+INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
+OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
+
+from macsupport import *
+
+# Create the type objects
+
+ControlHandle = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX)
+ExistingControlHandle = OpaqueByValueType(OBJECTTYPE, "CtlObj_WhichControl", "BUG")
+
+RgnHandle = FakeType("theWindow->visRgn") # XXX
+
+includestuff = includestuff + """
+#include <%s>""" % MACHEADERFILE + """
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+extern PyObject *CtlObj_WhichControl(ControlHandle); /* Forward */
+
+#ifdef THINK_C
+#define ControlActionUPP ProcPtr
+#endif
+"""
+
+finalstuff = finalstuff + """
+PyObject *
+CtlObj_WhichControl(ControlHandle c)
+{
+ PyObject *it;
+
+ /* XXX What if we find a control belonging to some other package? */
+ if (c == NULL)
+ it = NULL;
+ else
+ it = (PyObject *) GetCRefCon(c);
+ if (it == NULL || ((ControlObject *)it)->ob_itself != c)
+ it = Py_None;
+ Py_INCREF(it);
+ return it;
+}
+"""
+
+class MyObjectDefinition(GlobalObjectDefinition):
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+ def outputInitStructMembers(self):
+ GlobalObjectDefinition.outputInitStructMembers(self)
+ Output("SetCRefCon(itself, (long)it);")
+
+# Create the generator groups and link them
+module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
+object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE)
+module.addobject(object)
+
+# Create the generator classes used to populate the lists
+Function = OSErrFunctionGenerator
+Method = OSErrMethodGenerator
+
+# Create and populate the lists
+functions = []
+methods = []
+execfile(INPUTFILE)
+
+# add the populated lists to the generator groups
+for f in functions: module.add(f)
+for f in methods: object.add(f)
+
+# generate output (open the output file as late as possible)
+SetOutputFileName(OUTPUTFILE)
+module.generate()
diff --git a/Mac/Modules/dlg/Dlgmodule.c b/Mac/Modules/dlg/Dlgmodule.c
new file mode 100644
index 0000000..b03f24f
--- /dev/null
+++ b/Mac/Modules/dlg/Dlgmodule.c
@@ -0,0 +1,905 @@
+
+/* =========================== Module Dlg =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+extern PyObject *WinObj_WhichWindow(WindowPtr);
+
+#include <Dialogs.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+/* XXX Shouldn't this be a stack? */
+static PyObject *Dlg_FilterProc_callback = NULL;
+
+static PyObject *DlgObj_New(DialogPtr); /* Forward */
+
+static pascal Boolean Dlg_UnivFilterProc(DialogPtr dialog,
+ EventRecord *event,
+ short *itemHit)
+{
+ Boolean rv;
+ PyObject *args, *res;
+ PyObject *callback = Dlg_FilterProc_callback;
+ if (callback == NULL)
+ return 0; /* Default behavior */
+ Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */
+ args = Py_BuildValue("O&s#", DlgObj_New, dialog, event, sizeof(EventRecord));
+ if (args == NULL)
+ res = NULL;
+ else {
+ res = PyEval_CallObject(callback, args);
+ Py_DECREF(args);
+ }
+ if (res == NULL) {
+ fprintf(stderr, "Exception in Dialog Filter\n");
+ PyErr_Print();
+ *itemHit = -1; /* Fake return item */
+ return 1; /* We handled it */
+ }
+ else {
+ Dlg_FilterProc_callback = callback;
+ if (PyInt_Check(res)) {
+ *itemHit = PyInt_AsLong(res);
+ rv = 1;
+ }
+ else
+ rv = PyObject_IsTrue(res);
+ }
+ Py_DECREF(res);
+ return rv;
+}
+
+static ModalFilterProcPtr
+Dlg_PassFilterProc(PyObject *callback)
+{
+ PyObject *tmp = Dlg_FilterProc_callback;
+ Dlg_FilterProc_callback = NULL;
+ if (callback == Py_None) {
+ Py_XDECREF(tmp);
+ return NULL;
+ }
+ Py_INCREF(callback);
+ Dlg_FilterProc_callback = callback;
+ Py_XDECREF(tmp);
+ return &Dlg_UnivFilterProc;
+}
+
+extern PyMethodChain WinObj_chain;
+
+static PyObject *Dlg_Error;
+
+/* ----------------------- Object type Dialog ----------------------- */
+
+PyTypeObject Dialog_Type;
+
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+typedef struct DialogObject {
+ PyObject_HEAD
+ DialogPtr ob_itself;
+} DialogObject;
+
+PyObject *DlgObj_New(itself)
+ const DialogPtr itself;
+{
+ DialogObject *it;
+ if (itself == NULL) return Py_None;
+ it = PyObject_NEW(DialogObject, &Dialog_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ SetWRefCon(itself, (long)it);
+ return (PyObject *)it;
+}
+DlgObj_Convert(v, p_itself)
+ PyObject *v;
+ DialogPtr *p_itself;
+{
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v);
+ return 1; }
+ if (!DlgObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Dialog required");
+ return 0;
+ }
+ *p_itself = ((DialogObject *)v)->ob_itself;
+ return 1;
+}
+
+static void DlgObj_dealloc(self)
+ DialogObject *self;
+{
+ DisposeDialog(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *DlgObj_DrawDialog(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DrawDialog(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_UpdtDialog(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ UpdtDialog(_self->ob_itself,
+ _self->ob_itself->visRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_UpdateDialog(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ UpdateDialog(_self->ob_itself,
+ _self->ob_itself->visRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_GetDItem(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short itemNo;
+ short itemType;
+ Handle item;
+ Rect box;
+ if (!PyArg_ParseTuple(_args, "h",
+ &itemNo))
+ return NULL;
+ GetDItem(_self->ob_itself,
+ itemNo,
+ &itemType,
+ &item,
+ &box);
+ _res = Py_BuildValue("hO&O&",
+ itemType,
+ ResObj_New, item,
+ PyMac_BuildRect, &box);
+ return _res;
+}
+
+static PyObject *DlgObj_SetDItem(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short itemNo;
+ short itemType;
+ Handle item;
+ Rect box;
+ if (!PyArg_ParseTuple(_args, "hhO&O&",
+ &itemNo,
+ &itemType,
+ ResObj_Convert, &item,
+ PyMac_GetRect, &box))
+ return NULL;
+ SetDItem(_self->ob_itself,
+ itemNo,
+ itemType,
+ item,
+ &box);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_HideDItem(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short itemNo;
+ if (!PyArg_ParseTuple(_args, "h",
+ &itemNo))
+ return NULL;
+ HideDItem(_self->ob_itself,
+ itemNo);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_ShowDItem(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short itemNo;
+ if (!PyArg_ParseTuple(_args, "h",
+ &itemNo))
+ return NULL;
+ ShowDItem(_self->ob_itself,
+ itemNo);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_SelIText(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short itemNo;
+ short strtSel;
+ short endSel;
+ if (!PyArg_ParseTuple(_args, "hhh",
+ &itemNo,
+ &strtSel,
+ &endSel))
+ return NULL;
+ SelIText(_self->ob_itself,
+ itemNo,
+ strtSel,
+ endSel);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_FindDItem(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Point thePt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = FindDItem(_self->ob_itself,
+ thePt);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_DlgCut(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DlgCut(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_DlgPaste(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DlgPaste(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_DlgCopy(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DlgCopy(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_DlgDelete(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DlgDelete(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_AppendDITL(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle theHandle;
+ DITLMethod method;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ ResObj_Convert, &theHandle,
+ &method))
+ return NULL;
+ AppendDITL(_self->ob_itself,
+ theHandle,
+ method);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *DlgObj_CountDITL(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountDITL(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *DlgObj_ShortenDITL(_self, _args)
+ DialogObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short numberItems;
+ if (!PyArg_ParseTuple(_args, "h",
+ &numberItems))
+ return NULL;
+ ShortenDITL(_self->ob_itself,
+ numberItems);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef DlgObj_methods[] = {
+ {"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1,
+ "() -> None"},
+ {"UpdtDialog", (PyCFunction)DlgObj_UpdtDialog, 1,
+ "() -> None"},
+ {"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1,
+ "() -> None"},
+ {"GetDItem", (PyCFunction)DlgObj_GetDItem, 1,
+ "(short itemNo) -> (short itemType, Handle item, Rect box)"},
+ {"SetDItem", (PyCFunction)DlgObj_SetDItem, 1,
+ "(short itemNo, short itemType, Handle item, Rect box) -> None"},
+ {"HideDItem", (PyCFunction)DlgObj_HideDItem, 1,
+ "(short itemNo) -> None"},
+ {"ShowDItem", (PyCFunction)DlgObj_ShowDItem, 1,
+ "(short itemNo) -> None"},
+ {"SelIText", (PyCFunction)DlgObj_SelIText, 1,
+ "(short itemNo, short strtSel, short endSel) -> None"},
+ {"FindDItem", (PyCFunction)DlgObj_FindDItem, 1,
+ "(Point thePt) -> (short _rv)"},
+ {"DlgCut", (PyCFunction)DlgObj_DlgCut, 1,
+ "() -> None"},
+ {"DlgPaste", (PyCFunction)DlgObj_DlgPaste, 1,
+ "() -> None"},
+ {"DlgCopy", (PyCFunction)DlgObj_DlgCopy, 1,
+ "() -> None"},
+ {"DlgDelete", (PyCFunction)DlgObj_DlgDelete, 1,
+ "() -> None"},
+ {"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1,
+ "(Handle theHandle, DITLMethod method) -> None"},
+ {"CountDITL", (PyCFunction)DlgObj_CountDITL, 1,
+ "() -> (short _rv)"},
+ {"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1,
+ "(short numberItems) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain DlgObj_chain = { DlgObj_methods, &WinObj_chain };
+
+static PyObject *DlgObj_getattr(self, name)
+ DialogObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&DlgObj_chain, (PyObject *)self, name);
+}
+
+#define DlgObj_setattr NULL
+
+PyTypeObject Dialog_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Dialog", /*tp_name*/
+ sizeof(DialogObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) DlgObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) DlgObj_getattr, /*tp_getattr*/
+ (setattrfunc) DlgObj_setattr, /*tp_setattr*/
+};
+
+/* --------------------- End object type Dialog --------------------- */
+
+
+static PyObject *Dlg_NewDialog(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ short procID;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ long refCon;
+ Handle itmLstHndl;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &procID,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon,
+ ResObj_Convert, &itmLstHndl))
+ return NULL;
+ _rv = NewDialog((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ procID,
+ behind,
+ goAwayFlag,
+ refCon,
+ itmLstHndl);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_GetNewDialog(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ short dialogID;
+ WindowPtr behind;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &dialogID,
+ WinObj_Convert, &behind))
+ return NULL;
+ _rv = GetNewDialog(dialogID,
+ (void *)0,
+ behind);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_CouldDialog(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short dialogID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &dialogID))
+ return NULL;
+ CouldDialog(dialogID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_FreeDialog(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short dialogID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &dialogID))
+ return NULL;
+ FreeDialog(dialogID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_ParamText(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 param0;
+ Str255 param1;
+ Str255 param2;
+ Str255 param3;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&",
+ PyMac_GetStr255, param0,
+ PyMac_GetStr255, param1,
+ PyMac_GetStr255, param2,
+ PyMac_GetStr255, param3))
+ return NULL;
+ ParamText(param0,
+ param1,
+ param2,
+ param3);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_ModalDialog(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ PyObject* filterProc;
+ short itemHit;
+ if (!PyArg_ParseTuple(_args, "O",
+ &filterProc))
+ return NULL;
+ ModalDialog(Dlg_PassFilterProc(filterProc),
+ &itemHit);
+ _res = Py_BuildValue("h",
+ itemHit);
+ return _res;
+}
+
+static PyObject *Dlg_IsDialogEvent(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &theEvent))
+ return NULL;
+ _rv = IsDialogEvent(&theEvent);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_DialogSelect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord theEvent;
+ DialogPtr theDialog;
+ short itemHit;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetEventRecord, &theEvent))
+ return NULL;
+ _rv = DialogSelect(&theEvent,
+ &theDialog,
+ &itemHit);
+ _res = Py_BuildValue("bO&h",
+ _rv,
+ WinObj_WhichWindow, theDialog,
+ itemHit);
+ return _res;
+}
+
+static PyObject *Dlg_Alert(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short alertID;
+ PyObject* filterProc;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &filterProc))
+ return NULL;
+ _rv = Alert(alertID,
+ Dlg_PassFilterProc(filterProc));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_StopAlert(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short alertID;
+ PyObject* filterProc;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &filterProc))
+ return NULL;
+ _rv = StopAlert(alertID,
+ Dlg_PassFilterProc(filterProc));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_NoteAlert(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short alertID;
+ PyObject* filterProc;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &filterProc))
+ return NULL;
+ _rv = NoteAlert(alertID,
+ Dlg_PassFilterProc(filterProc));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_CautionAlert(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short alertID;
+ PyObject* filterProc;
+ if (!PyArg_ParseTuple(_args, "hO",
+ &alertID,
+ &filterProc))
+ return NULL;
+ _rv = CautionAlert(alertID,
+ Dlg_PassFilterProc(filterProc));
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Dlg_CouldAlert(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short alertID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &alertID))
+ return NULL;
+ CouldAlert(alertID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_FreeAlert(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short alertID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &alertID))
+ return NULL;
+ FreeAlert(alertID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_GetIText(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle item;
+ Str255 text;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &item))
+ return NULL;
+ GetIText(item,
+ text);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, text);
+ return _res;
+}
+
+static PyObject *Dlg_SetIText(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle item;
+ Str255 text;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, &item,
+ PyMac_GetStr255, text))
+ return NULL;
+ SetIText(item,
+ text);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_NewCDialog(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ DialogPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ short procID;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ long refCon;
+ Handle items;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &procID,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon,
+ ResObj_Convert, &items))
+ return NULL;
+ _rv = NewCDialog((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ procID,
+ behind,
+ goAwayFlag,
+ refCon,
+ items);
+ _res = Py_BuildValue("O&",
+ DlgObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Dlg_ResetAlrtStage(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ResetAlrtStage();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Dlg_SetDAFont(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short fontNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &fontNum))
+ return NULL;
+ SetDAFont(fontNum);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef Dlg_methods[] = {
+ {"NewDialog", (PyCFunction)Dlg_NewDialog, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle itmLstHndl) -> (DialogPtr _rv)"},
+ {"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1,
+ "(short dialogID, WindowPtr behind) -> (DialogPtr _rv)"},
+ {"CouldDialog", (PyCFunction)Dlg_CouldDialog, 1,
+ "(short dialogID) -> None"},
+ {"FreeDialog", (PyCFunction)Dlg_FreeDialog, 1,
+ "(short dialogID) -> None"},
+ {"ParamText", (PyCFunction)Dlg_ParamText, 1,
+ "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
+ {"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1,
+ "(PyObject* filterProc) -> (short itemHit)"},
+ {"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1,
+ "(EventRecord theEvent) -> (Boolean _rv)"},
+ {"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1,
+ "(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, short itemHit)"},
+ {"Alert", (PyCFunction)Dlg_Alert, 1,
+ "(short alertID, PyObject* filterProc) -> (short _rv)"},
+ {"StopAlert", (PyCFunction)Dlg_StopAlert, 1,
+ "(short alertID, PyObject* filterProc) -> (short _rv)"},
+ {"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1,
+ "(short alertID, PyObject* filterProc) -> (short _rv)"},
+ {"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1,
+ "(short alertID, PyObject* filterProc) -> (short _rv)"},
+ {"CouldAlert", (PyCFunction)Dlg_CouldAlert, 1,
+ "(short alertID) -> None"},
+ {"FreeAlert", (PyCFunction)Dlg_FreeAlert, 1,
+ "(short alertID) -> None"},
+ {"GetIText", (PyCFunction)Dlg_GetIText, 1,
+ "(Handle item) -> (Str255 text)"},
+ {"SetIText", (PyCFunction)Dlg_SetIText, 1,
+ "(Handle item, Str255 text) -> None"},
+ {"NewCDialog", (PyCFunction)Dlg_NewCDialog, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon, Handle items) -> (DialogPtr _rv)"},
+ {"ResetAlrtStage", (PyCFunction)Dlg_ResetAlrtStage, 1,
+ "() -> None"},
+ {"SetDAFont", (PyCFunction)Dlg_SetDAFont, 1,
+ "(short fontNum) -> None"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void initDlg()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("Dlg", Dlg_methods);
+ d = PyModule_GetDict(m);
+ Dlg_Error = PyMac_GetOSErrException();
+ if (Dlg_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Dlg_Error) != 0)
+ Py_FatalError("can't initialize Dlg.Error");
+}
+
+/* ========================= End module Dlg ========================= */
+
diff --git a/Mac/Modules/dlg/dlggen.py b/Mac/Modules/dlg/dlggen.py
new file mode 100644
index 0000000..ea64ab7
--- /dev/null
+++ b/Mac/Modules/dlg/dlggen.py
@@ -0,0 +1,224 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Dialogs.h'
+
+f = Function(DialogPtr, 'NewDialog',
+ (NullStorage, 'wStorage', InMode),
+ (Rect_ptr, 'boundsRect', InMode),
+ (ConstStr255Param, 'title', InMode),
+ (Boolean, 'visible', InMode),
+ (short, 'procID', InMode),
+ (WindowPtr, 'behind', InMode),
+ (Boolean, 'goAwayFlag', InMode),
+ (long, 'refCon', InMode),
+ (Handle, 'itmLstHndl', InMode),
+)
+functions.append(f)
+
+f = Function(DialogPtr, 'GetNewDialog',
+ (short, 'dialogID', InMode),
+ (NullStorage, 'dStorage', InMode),
+ (WindowPtr, 'behind', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'CouldDialog',
+ (short, 'dialogID', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FreeDialog',
+ (short, 'dialogID', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ParamText',
+ (ConstStr255Param, 'param0', InMode),
+ (ConstStr255Param, 'param1', InMode),
+ (ConstStr255Param, 'param2', InMode),
+ (ConstStr255Param, 'param3', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ModalDialog',
+ (ModalFilterProcPtr, 'filterProc', InMode),
+ (short, 'itemHit', OutMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'IsDialogEvent',
+ (EventRecord_ptr, 'theEvent', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'DialogSelect',
+ (EventRecord_ptr, 'theEvent', InMode),
+ (ExistingDialogPtr, 'theDialog', OutMode),
+ (short, 'itemHit', OutMode),
+)
+functions.append(f)
+
+f = Method(void, 'DrawDialog',
+ (DialogPtr, 'theDialog', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'UpdtDialog',
+ (DialogPtr, 'theDialog', InMode),
+ (RgnHandle, 'updateRgn', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'UpdateDialog',
+ (DialogPtr, 'theDialog', InMode),
+ (RgnHandle, 'updateRgn', InMode),
+)
+methods.append(f)
+
+f = Function(short, 'Alert',
+ (short, 'alertID', InMode),
+ (ModalFilterProcPtr, 'filterProc', InMode),
+)
+functions.append(f)
+
+f = Function(short, 'StopAlert',
+ (short, 'alertID', InMode),
+ (ModalFilterProcPtr, 'filterProc', InMode),
+)
+functions.append(f)
+
+f = Function(short, 'NoteAlert',
+ (short, 'alertID', InMode),
+ (ModalFilterProcPtr, 'filterProc', InMode),
+)
+functions.append(f)
+
+f = Function(short, 'CautionAlert',
+ (short, 'alertID', InMode),
+ (ModalFilterProcPtr, 'filterProc', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'CouldAlert',
+ (short, 'alertID', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FreeAlert',
+ (short, 'alertID', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'GetDItem',
+ (DialogPtr, 'theDialog', InMode),
+ (short, 'itemNo', InMode),
+ (short, 'itemType', OutMode),
+ (Handle, 'item', OutMode),
+ (Rect, 'box', OutMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetDItem',
+ (DialogPtr, 'theDialog', InMode),
+ (short, 'itemNo', InMode),
+ (short, 'itemType', InMode),
+ (Handle, 'item', InMode),
+ (Rect_ptr, 'box', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'HideDItem',
+ (DialogPtr, 'theDialog', InMode),
+ (short, 'itemNo', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'ShowDItem',
+ (DialogPtr, 'theDialog', InMode),
+ (short, 'itemNo', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SelIText',
+ (DialogPtr, 'theDialog', InMode),
+ (short, 'itemNo', InMode),
+ (short, 'strtSel', InMode),
+ (short, 'endSel', InMode),
+)
+methods.append(f)
+
+f = Function(void, 'GetIText',
+ (Handle, 'item', InMode),
+ (Str255, 'text', OutMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetIText',
+ (Handle, 'item', InMode),
+ (ConstStr255Param, 'text', InMode),
+)
+functions.append(f)
+
+f = Method(short, 'FindDItem',
+ (DialogPtr, 'theDialog', InMode),
+ (Point, 'thePt', InMode),
+)
+methods.append(f)
+
+f = Function(DialogPtr, 'NewCDialog',
+ (NullStorage, 'dStorage', InMode),
+ (Rect_ptr, 'boundsRect', InMode),
+ (ConstStr255Param, 'title', InMode),
+ (Boolean, 'visible', InMode),
+ (short, 'procID', InMode),
+ (WindowPtr, 'behind', InMode),
+ (Boolean, 'goAwayFlag', InMode),
+ (long, 'refCon', InMode),
+ (Handle, 'items', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ResetAlrtStage',
+)
+functions.append(f)
+
+f = Method(void, 'DlgCut',
+ (DialogPtr, 'theDialog', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'DlgPaste',
+ (DialogPtr, 'theDialog', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'DlgCopy',
+ (DialogPtr, 'theDialog', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'DlgDelete',
+ (DialogPtr, 'theDialog', InMode),
+)
+methods.append(f)
+
+f = Function(void, 'SetDAFont',
+ (short, 'fontNum', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'AppendDITL',
+ (DialogPtr, 'theDialog', InMode),
+ (Handle, 'theHandle', InMode),
+ (DITLMethod, 'method', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'CountDITL',
+ (DialogPtr, 'theDialog', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'ShortenDITL',
+ (DialogPtr, 'theDialog', InMode),
+ (short, 'numberItems', InMode),
+)
+methods.append(f)
diff --git a/Mac/Modules/dlg/dlgscan.py b/Mac/Modules/dlg/dlgscan.py
new file mode 100644
index 0000000..2a410f6
--- /dev/null
+++ b/Mac/Modules/dlg/dlgscan.py
@@ -0,0 +1,67 @@
+# Scan an Apple header file, generating a Python file of generator calls.
+
+from scantools import Scanner
+
+LONG = "Dialogs"
+SHORT = "dlg"
+OBJECT = "DialogPtr"
+
+def main():
+ input = LONG + ".h"
+ output = SHORT + "gen.py"
+ defsoutput = LONG + ".py"
+ scanner = MyScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done scanning and generating, now importing the generated code... ==="
+ exec "import " + SHORT + "support"
+ print "=== Done. It's up to you to compile it now! ==="
+
+class MyScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "Function"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ if t == "DialogPtr" and m == "InMode":
+ classname = "Method"
+ listname = "methods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ 'InitDialogs',
+ 'ErrorSound',
+ # Dialogs are disposed when the object is deleted
+ 'CloseDialog',
+ 'DisposDialog',
+ 'DisposeDialog',
+ ]
+
+ def makeblacklisttypes(self):
+ return [
+ ]
+
+ def makerepairinstructions(self):
+ return [
+ ([("Str255", "*", "InMode")],
+ [("*", "*", "OutMode")]),
+
+ ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+ ("long", "*", "OutMode")],
+ [("VarVarOutBuffer", "*", "InOutMode")]),
+
+ # NewDialog ETC.
+ ([("void", "*", "OutMode")],
+ [("NullStorage", "*", "InMode")]),
+
+ ([("DialogPtr", "*", "OutMode")],
+ [("ExistingDialogPtr", "*", "*")]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/dlg/dlgsupport.py b/Mac/Modules/dlg/dlgsupport.py
new file mode 100644
index 0000000..85e72bb
--- /dev/null
+++ b/Mac/Modules/dlg/dlgsupport.py
@@ -0,0 +1,121 @@
+# This script generates the Dialogs interface for Python.
+# It uses the "bgen" package to generate C code.
+# It execs the file dlggen.py which contain the function definitions
+# (dlggen.py was generated by dlgscan.py, scanning the <Dialogs.h> header file).
+
+from macsupport import *
+
+# Create the type objects
+
+DialogPtr = OpaqueByValueType("DialogPtr", "DlgObj")
+
+ModalFilterProcPtr = InputOnlyType("PyObject*", "O")
+ModalFilterProcPtr.passInput = lambda name: "Dlg_PassFilterProc(%s)" % name
+
+RgnHandle = FakeType("_self->ob_itself->visRgn") # XXX
+
+DITLMethod = Type("DITLMethod", "h")
+
+includestuff = includestuff + """
+#include <Dialogs.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+/* XXX Shouldn't this be a stack? */
+static PyObject *Dlg_FilterProc_callback = NULL;
+
+static PyObject *DlgObj_New(DialogPtr); /* Forward */
+
+static pascal Boolean Dlg_UnivFilterProc(DialogPtr dialog,
+ EventRecord *event,
+ short *itemHit)
+{
+ Boolean rv;
+ PyObject *args, *res;
+ PyObject *callback = Dlg_FilterProc_callback;
+ if (callback == NULL)
+ return 0; /* Default behavior */
+ Dlg_FilterProc_callback = NULL; /* We'll restore it when call successful */
+ args = Py_BuildValue("O&s#", DlgObj_New, dialog, event, sizeof(EventRecord));
+ if (args == NULL)
+ res = NULL;
+ else {
+ res = PyEval_CallObject(callback, args);
+ Py_DECREF(args);
+ }
+ if (res == NULL) {
+ fprintf(stderr, "Exception in Dialog Filter\\n");
+ PyErr_Print();
+ *itemHit = -1; /* Fake return item */
+ return 1; /* We handled it */
+ }
+ else {
+ Dlg_FilterProc_callback = callback;
+ if (PyInt_Check(res)) {
+ *itemHit = PyInt_AsLong(res);
+ rv = 1;
+ }
+ else
+ rv = PyObject_IsTrue(res);
+ }
+ Py_DECREF(res);
+ return rv;
+}
+
+static ModalFilterProcPtr
+Dlg_PassFilterProc(PyObject *callback)
+{
+ PyObject *tmp = Dlg_FilterProc_callback;
+ Dlg_FilterProc_callback = NULL;
+ if (callback == Py_None) {
+ Py_XDECREF(tmp);
+ return NULL;
+ }
+ Py_INCREF(callback);
+ Dlg_FilterProc_callback = callback;
+ Py_XDECREF(tmp);
+ return &Dlg_UnivFilterProc;
+}
+
+extern PyMethodChain WinObj_chain;
+"""
+
+
+# Define a class which specializes our object definition
+class MyObjectDefinition(GlobalObjectDefinition):
+ def __init__(self, name, prefix = None, itselftype = None):
+ GlobalObjectDefinition.__init__(self, name, prefix, itselftype)
+ self.basechain = "&WinObj_chain"
+ def outputInitStructMembers(self):
+ GlobalObjectDefinition.outputInitStructMembers(self)
+ Output("SetWRefCon(itself, (long)it);")
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return Py_None;")
+ def outputCheckConvertArg(self):
+ Output("if (v == Py_None) { *p_itself = NULL; return 1; }")
+ Output("if (PyInt_Check(v)) { *p_itself = (DialogPtr)PyInt_AsLong(v);")
+ Output(" return 1; }")
+ def outputFreeIt(self, itselfname):
+ Output("DisposeDialog(%s);", itselfname)
+
+# Create the generator groups and link them
+module = MacModule('Dlg', 'Dlg', includestuff, finalstuff, initstuff)
+object = MyObjectDefinition('Dialog', 'DlgObj', 'DialogPtr')
+module.addobject(object)
+
+# Create the generator classes used to populate the lists
+Function = OSErrFunctionGenerator
+Method = OSErrMethodGenerator
+
+# Create and populate the lists
+functions = []
+methods = []
+execfile("dlggen.py")
+
+# add the populated lists to the generator groups
+for f in functions: module.add(f)
+for f in methods: object.add(f)
+
+# generate output
+SetOutputFileName('Dlgmodule.c')
+module.generate()
diff --git a/Mac/Modules/evt/Evtmodule.c b/Mac/Modules/evt/Evtmodule.c
new file mode 100644
index 0000000..074a33e
--- /dev/null
+++ b/Mac/Modules/evt/Evtmodule.c
@@ -0,0 +1,228 @@
+
+/* =========================== Module Evt =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+#include <Events.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+static PyObject *Evt_Error;
+
+static PyObject *Evt_GetNextEvent(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short eventMask;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "h",
+ &eventMask))
+ return NULL;
+ _rv = GetNextEvent(eventMask,
+ &theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+
+static PyObject *Evt_WaitNextEvent(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short eventMask;
+ EventRecord theEvent;
+ unsigned long sleep;
+ if (!PyArg_ParseTuple(_args, "hl",
+ &eventMask,
+ &sleep))
+ return NULL;
+ _rv = WaitNextEvent(eventMask,
+ &theEvent,
+ sleep,
+ (RgnHandle)0);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+
+static PyObject *Evt_EventAvail(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ short eventMask;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, "h",
+ &eventMask))
+ return NULL;
+ _rv = EventAvail(eventMask,
+ &theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+
+static PyObject *Evt_GetMouse(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Point mouseLoc;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetMouse(&mouseLoc);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, mouseLoc);
+ return _res;
+}
+
+static PyObject *Evt_Button(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = Button();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_StillDown(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = StillDown();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_WaitMouseUp(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = WaitMouseUp();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_GetKeys(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ KeyMap theKeys__out__;
+ int theKeys__len__;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetKeys(theKeys__out__);
+ _res = Py_BuildValue("s#",
+ (char *)&theKeys__out__, sizeof(KeyMap));
+ theKeys__error__: ;
+ return _res;
+}
+
+static PyObject *Evt_TickCount(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = TickCount();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef Evt_methods[] = {
+ {"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,
+ "(short eventMask) -> (Boolean _rv, EventRecord theEvent)"},
+ {"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1,
+ "(short eventMask, unsigned long sleep) -> (Boolean _rv, EventRecord theEvent)"},
+ {"EventAvail", (PyCFunction)Evt_EventAvail, 1,
+ "(short eventMask) -> (Boolean _rv, EventRecord theEvent)"},
+ {"GetMouse", (PyCFunction)Evt_GetMouse, 1,
+ "() -> (Point mouseLoc)"},
+ {"Button", (PyCFunction)Evt_Button, 1,
+ "() -> (Boolean _rv)"},
+ {"StillDown", (PyCFunction)Evt_StillDown, 1,
+ "() -> (Boolean _rv)"},
+ {"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1,
+ "() -> (Boolean _rv)"},
+ {"GetKeys", (PyCFunction)Evt_GetKeys, 1,
+ "() -> (KeyMap theKeys)"},
+ {"TickCount", (PyCFunction)Evt_TickCount, 1,
+ "() -> (long _rv)"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void initEvt()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("Evt", Evt_methods);
+ d = PyModule_GetDict(m);
+ Evt_Error = PyMac_GetOSErrException();
+ if (Evt_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Evt_Error) != 0)
+ Py_FatalError("can't initialize Evt.Error");
+}
+
+/* ========================= End module Evt ========================= */
+
diff --git a/Mac/Modules/evt/evtgen.py b/Mac/Modules/evt/evtgen.py
new file mode 100644
index 0000000..ff30b8d
--- /dev/null
+++ b/Mac/Modules/evt/evtgen.py
@@ -0,0 +1,47 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Events.h'
+
+f = Function(Boolean, 'GetNextEvent',
+ (short, 'eventMask', InMode),
+ (EventRecord, 'theEvent', OutMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'WaitNextEvent',
+ (short, 'eventMask', InMode),
+ (EventRecord, 'theEvent', OutMode),
+ (unsigned_long, 'sleep', InMode),
+ (RgnHandle, 'mouseRgn', InMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'EventAvail',
+ (short, 'eventMask', InMode),
+ (EventRecord, 'theEvent', OutMode),
+)
+functions.append(f)
+
+f = Function(void, 'GetMouse',
+ (Point, 'mouseLoc', OutMode),
+)
+functions.append(f)
+
+f = Function(Boolean, 'Button',
+)
+functions.append(f)
+
+f = Function(Boolean, 'StillDown',
+)
+functions.append(f)
+
+f = Function(Boolean, 'WaitMouseUp',
+)
+functions.append(f)
+
+f = Function(void, 'GetKeys',
+ (KeyMap, 'theKeys', OutMode),
+)
+functions.append(f)
+
+f = Function(long, 'TickCount',
+)
+functions.append(f)
diff --git a/Mac/Modules/evt/evtscan.py b/Mac/Modules/evt/evtscan.py
new file mode 100644
index 0000000..517db71
--- /dev/null
+++ b/Mac/Modules/evt/evtscan.py
@@ -0,0 +1,59 @@
+# Scan an Apple header file, generating a Python file of generator calls.
+
+from scantools import Scanner
+
+LONG = "Events"
+SHORT = "evt"
+OBJECT = "NOTUSED"
+
+def main():
+ input = LONG + ".h"
+ output = SHORT + "gen.py"
+ defsoutput = LONG + ".py"
+ scanner = MyScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done scanning and generating, now importing the generated code... ==="
+ exec "import " + SHORT + "support"
+ print "=== Done. It's up to you to compile it now! ==="
+
+class MyScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "Function"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ # This is non-functional today
+ if t == OBJECT and m == "InMode":
+ classname = "Method"
+ listname = "methods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ ]
+
+ def makeblacklisttypes(self):
+ return [
+ ]
+
+ def makerepairinstructions(self):
+ return [
+ ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+ ("long", "*", "OutMode")],
+ [("VarVarOutBuffer", "*", "InOutMode")]),
+
+ ([("void", "wStorage", "OutMode")],
+ [("NullStorage", "*", "InMode")]),
+
+ # GetKeys
+ ([('KeyMap', 'theKeys', 'InMode')],
+ [('*', '*', 'OutMode')]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/evt/evtsupport.py b/Mac/Modules/evt/evtsupport.py
new file mode 100644
index 0000000..4798619
--- /dev/null
+++ b/Mac/Modules/evt/evtsupport.py
@@ -0,0 +1,74 @@
+# This script generates a Python interface for an Apple Macintosh Manager.
+# It uses the "bgen" package to generate C code.
+# The function specifications are generated by scanning the mamager's header file,
+# using the "scantools" package (customized for this particular manager).
+
+import string
+
+# Declarations that change for each manager
+MACHEADERFILE = 'Events.h' # The Apple header file
+MODNAME = 'Evt' # The name of the module
+OBJECTNAME = 'Event' # The basic name of the objects used here
+KIND = 'Record' # Usually 'Ptr' or 'Handle'
+
+# The following is *usually* unchanged but may still require tuning
+MODPREFIX = MODNAME # The prefix for module-wide routines
+OBJECTTYPE = OBJECTNAME + KIND # The C type used to represent them
+OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods
+INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
+OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
+
+from macsupport import *
+
+# Create the type objects
+
+WindowPtr = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX)
+WindowPeek = OpaqueByValueType("WindowPeek", OBJECTPREFIX)
+
+RgnHandle = FakeType("(RgnHandle)0") # XXX
+
+KeyMap = ArrayOutputBufferType("KeyMap")
+
+includestuff = includestuff + """
+#include <%s>""" % MACHEADERFILE + """
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+"""
+
+class MyObjectDefinition(GlobalObjectDefinition):
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+ def outputCheckConvertArg(self):
+ OutLbrace("if (DlgObj_Check(v))")
+ Output("*p_itself = ((WindowObject *)v)->ob_itself;")
+ Output("return 1;")
+ OutRbrace()
+ Out("""
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
+ """)
+
+# From here on it's basically all boiler plate...
+
+# Create the generator groups and link them
+module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
+##object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE)
+##module.addobject(object)
+
+# Create the generator classes used to populate the lists
+Function = OSErrFunctionGenerator
+##Method = OSErrMethodGenerator
+
+# Create and populate the lists
+functions = []
+##methods = []
+execfile(INPUTFILE)
+
+# add the populated lists to the generator groups
+# (in a different wordl the scan program would generate this)
+for f in functions: module.add(f)
+##for f in methods: object.add(f)
+
+# generate output (open the output file as late as possible)
+SetOutputFileName(OUTPUTFILE)
+module.generate()
diff --git a/Mac/Modules/menu/Menumodule.c b/Mac/Modules/menu/Menumodule.c
new file mode 100644
index 0000000..78c4f60
--- /dev/null
+++ b/Mac/Modules/menu/Menumodule.c
@@ -0,0 +1,908 @@
+
+/* ========================== Module Menu =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+extern PyObject *WinObj_WhichWindow(WindowPtr);
+
+#include <Menus.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+static PyObject *Menu_Error;
+
+/* ------------------------ Object type Menu ------------------------ */
+
+PyTypeObject Menu_Type;
+
+#define MenuObj_Check(x) ((x)->ob_type == &Menu_Type)
+
+typedef struct MenuObject {
+ PyObject_HEAD
+ MenuHandle ob_itself;
+} MenuObject;
+
+PyObject *MenuObj_New(itself)
+ const MenuHandle itself;
+{
+ MenuObject *it;
+ it = PyObject_NEW(MenuObject, &Menu_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+MenuObj_Convert(v, p_itself)
+ PyObject *v;
+ MenuHandle *p_itself;
+{
+ if (!MenuObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Menu required");
+ return 0;
+ }
+ *p_itself = ((MenuObject *)v)->ob_itself;
+ return 1;
+}
+
+static void MenuObj_dealloc(self)
+ MenuObject *self;
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *MenuObj_DisposeMenu(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DisposeMenu(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_AppendMenu(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 data;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, data))
+ return NULL;
+ AppendMenu(_self->ob_itself,
+ data);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_AddResMenu(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ AddResMenu(_self->ob_itself,
+ theType);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertResMenu(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short afterItem;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &afterItem))
+ return NULL;
+ InsertResMenu(_self->ob_itself,
+ theType,
+ afterItem);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsertMenu(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short beforeID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &beforeID))
+ return NULL;
+ InsertMenu(_self->ob_itself,
+ beforeID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_InsMenuItem(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 itemString;
+ short afterItem;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetStr255, itemString,
+ &afterItem))
+ return NULL;
+ InsMenuItem(_self->ob_itself,
+ itemString,
+ afterItem);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_DelMenuItem(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ DelMenuItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_SetItem(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ Str255 itemString;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &item,
+ PyMac_GetStr255, itemString))
+ return NULL;
+ SetItem(_self->ob_itself,
+ item,
+ itemString);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItem(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ Str255 itemString;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItem(_self->ob_itself,
+ item,
+ itemString);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, itemString);
+ return _res;
+}
+
+static PyObject *MenuObj_DisableItem(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ DisableItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_EnableItem(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ EnableItem(_self->ob_itself,
+ item);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_CheckItem(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ Boolean checked;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &item,
+ &checked))
+ return NULL;
+ CheckItem(_self->ob_itself,
+ item,
+ checked);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemMark(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ short markChar;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &markChar))
+ return NULL;
+ SetItemMark(_self->ob_itself,
+ item,
+ markChar);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemMark(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ short markChar;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemMark(_self->ob_itself,
+ item,
+ &markChar);
+ _res = Py_BuildValue("h",
+ markChar);
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemIcon(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ short iconIndex;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &iconIndex))
+ return NULL;
+ SetItemIcon(_self->ob_itself,
+ item,
+ iconIndex);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemIcon(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ short iconIndex;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemIcon(_self->ob_itself,
+ item,
+ &iconIndex);
+ _res = Py_BuildValue("h",
+ iconIndex);
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemStyle(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ short chStyle;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &chStyle))
+ return NULL;
+ SetItemStyle(_self->ob_itself,
+ item,
+ chStyle);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemStyle(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ Style chStyle;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemStyle(_self->ob_itself,
+ item,
+ &chStyle);
+ _res = Py_BuildValue("b",
+ chStyle);
+ return _res;
+}
+
+static PyObject *MenuObj_CalcMenuSize(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CalcMenuSize(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_CountMItems(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountMItems(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *MenuObj_GetItemCmd(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ short cmdChar;
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
+ return NULL;
+ GetItemCmd(_self->ob_itself,
+ item,
+ &cmdChar);
+ _res = Py_BuildValue("h",
+ cmdChar);
+ return _res;
+}
+
+static PyObject *MenuObj_SetItemCmd(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short item;
+ short cmdChar;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &item,
+ &cmdChar))
+ return NULL;
+ SetItemCmd(_self->ob_itself,
+ item,
+ cmdChar);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *MenuObj_PopUpMenuSelect(_self, _args)
+ MenuObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ short top;
+ short left;
+ short popUpItem;
+ if (!PyArg_ParseTuple(_args, "hhh",
+ &top,
+ &left,
+ &popUpItem))
+ return NULL;
+ _rv = PopUpMenuSelect(_self->ob_itself,
+ top,
+ left,
+ popUpItem);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyMethodDef MenuObj_methods[] = {
+ {"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1,
+ "() -> None"},
+ {"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1,
+ "(Str255 data) -> None"},
+ {"AddResMenu", (PyCFunction)MenuObj_AddResMenu, 1,
+ "(ResType theType) -> None"},
+ {"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
+ "(ResType theType, short afterItem) -> None"},
+ {"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1,
+ "(short beforeID) -> None"},
+ {"InsMenuItem", (PyCFunction)MenuObj_InsMenuItem, 1,
+ "(Str255 itemString, short afterItem) -> None"},
+ {"DelMenuItem", (PyCFunction)MenuObj_DelMenuItem, 1,
+ "(short item) -> None"},
+ {"SetItem", (PyCFunction)MenuObj_SetItem, 1,
+ "(short item, Str255 itemString) -> None"},
+ {"GetItem", (PyCFunction)MenuObj_GetItem, 1,
+ "(short item) -> (Str255 itemString)"},
+ {"DisableItem", (PyCFunction)MenuObj_DisableItem, 1,
+ "(short item) -> None"},
+ {"EnableItem", (PyCFunction)MenuObj_EnableItem, 1,
+ "(short item) -> None"},
+ {"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
+ "(short item, Boolean checked) -> None"},
+ {"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1,
+ "(short item, short markChar) -> None"},
+ {"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1,
+ "(short item) -> (short markChar)"},
+ {"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1,
+ "(short item, short iconIndex) -> None"},
+ {"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1,
+ "(short item) -> (short iconIndex)"},
+ {"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1,
+ "(short item, short chStyle) -> None"},
+ {"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1,
+ "(short item) -> (Style chStyle)"},
+ {"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
+ "() -> None"},
+ {"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
+ "() -> (short _rv)"},
+ {"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
+ "(short item) -> (short cmdChar)"},
+ {"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
+ "(short item, short cmdChar) -> None"},
+ {"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
+ "(short top, short left, short popUpItem) -> (long _rv)"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain MenuObj_chain = { MenuObj_methods, NULL };
+
+static PyObject *MenuObj_getattr(self, name)
+ MenuObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&MenuObj_chain, (PyObject *)self, name);
+}
+
+#define MenuObj_setattr NULL
+
+PyTypeObject Menu_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Menu", /*tp_name*/
+ sizeof(MenuObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) MenuObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) MenuObj_getattr, /*tp_getattr*/
+ (setattrfunc) MenuObj_setattr, /*tp_setattr*/
+};
+
+/* ---------------------- End object type Menu ---------------------- */
+
+
+static PyObject *Menu_InitMenus(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InitMenus();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_NewMenu(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ short menuID;
+ Str255 menuTitle;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &menuID,
+ PyMac_GetStr255, menuTitle))
+ return NULL;
+ _rv = NewMenu(menuID,
+ menuTitle);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_GetMenu(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ short resourceID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resourceID))
+ return NULL;
+ _rv = GetMenu(resourceID);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_DrawMenuBar(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DrawMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_InvalMenuBar(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InvalMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_DeleteMenu(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ DeleteMenu(menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_ClearMenuBar(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClearMenuBar();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_GetNewMBar(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ short menuBarID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuBarID))
+ return NULL;
+ _rv = GetNewMBar(menuBarID);
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_GetMenuBar(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMenuBar();
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_SetMenuBar(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle menuList;
+ if (!PyArg_ParseTuple(_args, "O&",
+ ResObj_Convert, &menuList))
+ return NULL;
+ SetMenuBar(menuList);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_MenuKey(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ short ch;
+ if (!PyArg_ParseTuple(_args, "h",
+ &ch))
+ return NULL;
+ _rv = MenuKey(ch);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_HiliteMenu(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ HiliteMenu(menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_GetMHandle(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+ short menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ _rv = GetMHandle(menuID);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Menu_FlashMenuBar(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short menuID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &menuID))
+ return NULL;
+ FlashMenuBar(menuID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_SetMenuFlash(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short count;
+ if (!PyArg_ParseTuple(_args, "h",
+ &count))
+ return NULL;
+ SetMenuFlash(count);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_MenuSelect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Point startPt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &startPt))
+ return NULL;
+ _rv = MenuSelect(startPt);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_InitProcMenu(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short resID;
+ if (!PyArg_ParseTuple(_args, "h",
+ &resID))
+ return NULL;
+ InitProcMenu(resID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Menu_MenuChoice(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MenuChoice();
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Menu_DelMCEntries(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short menuID;
+ short menuItem;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &menuID,
+ &menuItem))
+ return NULL;
+ DelMCEntries(menuID,
+ menuItem);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef Menu_methods[] = {
+ {"InitMenus", (PyCFunction)Menu_InitMenus, 1,
+ "() -> None"},
+ {"NewMenu", (PyCFunction)Menu_NewMenu, 1,
+ "(short menuID, Str255 menuTitle) -> (MenuHandle _rv)"},
+ {"GetMenu", (PyCFunction)Menu_GetMenu, 1,
+ "(short resourceID) -> (MenuHandle _rv)"},
+ {"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
+ "() -> None"},
+ {"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
+ "() -> None"},
+ {"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1,
+ "(short menuID) -> None"},
+ {"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
+ "() -> None"},
+ {"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
+ "(short menuBarID) -> (Handle _rv)"},
+ {"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
+ "() -> (Handle _rv)"},
+ {"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
+ "(Handle menuList) -> None"},
+ {"MenuKey", (PyCFunction)Menu_MenuKey, 1,
+ "(short ch) -> (long _rv)"},
+ {"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1,
+ "(short menuID) -> None"},
+ {"GetMHandle", (PyCFunction)Menu_GetMHandle, 1,
+ "(short menuID) -> (MenuHandle _rv)"},
+ {"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
+ "(short menuID) -> None"},
+ {"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
+ "(short count) -> None"},
+ {"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
+ "(Point startPt) -> (long _rv)"},
+ {"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1,
+ "(short resID) -> None"},
+ {"MenuChoice", (PyCFunction)Menu_MenuChoice, 1,
+ "() -> (long _rv)"},
+ {"DelMCEntries", (PyCFunction)Menu_DelMCEntries, 1,
+ "(short menuID, short menuItem) -> None"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void initMenu()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("Menu", Menu_methods);
+ d = PyModule_GetDict(m);
+ Menu_Error = PyMac_GetOSErrException();
+ if (Menu_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Menu_Error) != 0)
+ Py_FatalError("can't initialize Menu.Error");
+}
+
+/* ======================== End module Menu ========================= */
+
diff --git a/Mac/Modules/menu/menugen.py b/Mac/Modules/menu/menugen.py
new file mode 100644
index 0000000..30315b8
--- /dev/null
+++ b/Mac/Modules/menu/menugen.py
@@ -0,0 +1,242 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Menus.h'
+
+f = Function(void, 'InitMenus',
+)
+functions.append(f)
+
+f = Function(MenuHandle, 'NewMenu',
+ (short, 'menuID', InMode),
+ (Str255, 'menuTitle', InMode),
+)
+functions.append(f)
+
+f = Function(MenuHandle, 'GetMenu',
+ (short, 'resourceID', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'DisposeMenu',
+ (MenuHandle, 'theMenu', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'AppendMenu',
+ (MenuHandle, 'menu', InMode),
+ (ConstStr255Param, 'data', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'AddResMenu',
+ (MenuHandle, 'theMenu', InMode),
+ (ResType, 'theType', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'InsertResMenu',
+ (MenuHandle, 'theMenu', InMode),
+ (ResType, 'theType', InMode),
+ (short, 'afterItem', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'InsertMenu',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'beforeID', InMode),
+)
+methods.append(f)
+
+f = Function(void, 'DrawMenuBar',
+)
+functions.append(f)
+
+f = Function(void, 'InvalMenuBar',
+)
+functions.append(f)
+
+f = Function(void, 'DeleteMenu',
+ (short, 'menuID', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ClearMenuBar',
+)
+functions.append(f)
+
+f = Function(Handle, 'GetNewMBar',
+ (short, 'menuBarID', InMode),
+)
+functions.append(f)
+
+f = Function(Handle, 'GetMenuBar',
+)
+functions.append(f)
+
+f = Function(void, 'SetMenuBar',
+ (Handle, 'menuList', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'InsMenuItem',
+ (MenuHandle, 'theMenu', InMode),
+ (ConstStr255Param, 'itemString', InMode),
+ (short, 'afterItem', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'DelMenuItem',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+)
+methods.append(f)
+
+f = Function(long, 'MenuKey',
+ (short, 'ch', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'HiliteMenu',
+ (short, 'menuID', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'SetItem',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (ConstStr255Param, 'itemString', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'GetItem',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (Str255, 'itemString', OutMode),
+)
+methods.append(f)
+
+f = Method(void, 'DisableItem',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'EnableItem',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'CheckItem',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (Boolean, 'checked', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetItemMark',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (short, 'markChar', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'GetItemMark',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (short, 'markChar', OutMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetItemIcon',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (short, 'iconIndex', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'GetItemIcon',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (short, 'iconIndex', OutMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetItemStyle',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (short, 'chStyle', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'GetItemStyle',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (Style, 'chStyle', OutMode),
+)
+methods.append(f)
+
+f = Method(void, 'CalcMenuSize',
+ (MenuHandle, 'theMenu', InMode),
+)
+methods.append(f)
+
+f = Method(short, 'CountMItems',
+ (MenuHandle, 'theMenu', InMode),
+)
+methods.append(f)
+
+f = Function(MenuHandle, 'GetMHandle',
+ (short, 'menuID', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'FlashMenuBar',
+ (short, 'menuID', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetMenuFlash',
+ (short, 'count', InMode),
+)
+functions.append(f)
+
+f = Function(long, 'MenuSelect',
+ (Point, 'startPt', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'InitProcMenu',
+ (short, 'resID', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'GetItemCmd',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (short, 'cmdChar', OutMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetItemCmd',
+ (MenuHandle, 'theMenu', InMode),
+ (short, 'item', InMode),
+ (short, 'cmdChar', InMode),
+)
+methods.append(f)
+
+f = Method(long, 'PopUpMenuSelect',
+ (MenuHandle, 'menu', InMode),
+ (short, 'top', InMode),
+ (short, 'left', InMode),
+ (short, 'popUpItem', InMode),
+)
+methods.append(f)
+
+f = Function(long, 'MenuChoice',
+)
+functions.append(f)
+
+f = Function(void, 'DelMCEntries',
+ (short, 'menuID', InMode),
+ (short, 'menuItem', InMode),
+)
+functions.append(f)
diff --git a/Mac/Modules/menu/menuscan.py b/Mac/Modules/menu/menuscan.py
new file mode 100644
index 0000000..b120052
--- /dev/null
+++ b/Mac/Modules/menu/menuscan.py
@@ -0,0 +1,53 @@
+# Scan <Menus.h>, generating menugen.py.
+
+from scantools import Scanner
+
+def main():
+ input = "Menus.h"
+ output = "menugen.py"
+ defsoutput = "Menus.py"
+ scanner = MyScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done scanning and generating, now doing 'import menusupport' ==="
+ import menusupport
+ print "=== Done. It's up to you to compile Menumodule.c ==="
+
+class MyScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "Function"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ if t == "MenuHandle" and m == "InMode":
+ classname = "Method"
+ listname = "methods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ ]
+
+ def makeblacklisttypes(self):
+ return [
+ 'MCTableHandle',
+ 'MCEntryPtr',
+ 'MCTablePtr',
+ ]
+
+ def makerepairinstructions(self):
+ return [
+ ([("Str255", "itemString", "InMode")],
+ [("*", "*", "OutMode")]),
+
+ ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+ ("long", "*", "OutMode")],
+ [("VarVarOutBuffer", "*", "InOutMode")]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/menu/menusupport.py b/Mac/Modules/menu/menusupport.py
new file mode 100644
index 0000000..c3fb3be
--- /dev/null
+++ b/Mac/Modules/menu/menusupport.py
@@ -0,0 +1,55 @@
+# This script generates a Python interface for an Apple Macintosh Manager.
+# It uses the "bgen" package to generate C code.
+# The function specifications are generated by scanning the mamager's header file,
+# using the "scantools" package (customized for this particular manager).
+
+import string
+
+# Declarations that change for each manager
+MACHEADERFILE = 'Menus.h' # The Apple header file
+MODNAME = 'Menu' # The name of the module
+OBJECTNAME = 'Menu' # The basic name of the objects used here
+
+# The following is *usually* unchanged but may still require tuning
+MODPREFIX = MODNAME # The prefix for module-wide routines
+OBJECTTYPE = OBJECTNAME + 'Handle' # The C type used to represent them
+OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods
+INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
+OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
+
+from macsupport import *
+
+# Create the type objects
+
+MenuHandle = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX)
+
+includestuff = includestuff + """
+#include <%s>""" % MACHEADERFILE + """
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+"""
+
+class MyObjectDefinition(GlobalObjectDefinition):
+ pass
+
+# Create the generator groups and link them
+module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
+object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE)
+module.addobject(object)
+
+# Create the generator classes used to populate the lists
+Function = OSErrFunctionGenerator
+Method = OSErrMethodGenerator
+
+# Create and populate the lists
+functions = []
+methods = []
+execfile(INPUTFILE)
+
+# add the populated lists to the generator groups
+for f in functions: module.add(f)
+for f in methods: object.add(f)
+
+# generate output (open the output file as late as possible)
+SetOutputFileName(OUTPUTFILE)
+module.generate()
diff --git a/Mac/Modules/qd/Qdmodule.c b/Mac/Modules/qd/Qdmodule.c
new file mode 100644
index 0000000..2f88857
--- /dev/null
+++ b/Mac/Modules/qd/Qdmodule.c
@@ -0,0 +1,168 @@
+
+/* =========================== Module Qd ============================ */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+extern PyObject *WinObj_WhichWindow(WindowPtr);
+
+#include <QuickDraw.h>
+#include <Desk.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+static PyObject *Qd_Error;
+
+static PyObject *Qd_GlobalToLocal(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Point thePoint;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePoint))
+ return NULL;
+ GlobalToLocal(&thePoint);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, thePoint);
+ return _res;
+}
+
+static PyObject *Qd_LocalToGlobal(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Point thePoint;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePoint))
+ return NULL;
+ LocalToGlobal(&thePoint);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildPoint, thePoint);
+ return _res;
+}
+
+static PyObject *Qd_SetPort(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr thePort;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &thePort))
+ return NULL;
+ SetPort(thePort);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_ClipRect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ ClipRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_EraseRect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Rect r;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &r))
+ return NULL;
+ EraseRect(&r);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_OpenDeskAcc(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, name))
+ return NULL;
+ OpenDeskAcc(name);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef Qd_methods[] = {
+ {"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
+ "(Point thePoint) -> (Point thePoint)"},
+ {"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
+ "(Point thePoint) -> (Point thePoint)"},
+ {"SetPort", (PyCFunction)Qd_SetPort, 1,
+ "(WindowPtr thePort) -> None"},
+ {"ClipRect", (PyCFunction)Qd_ClipRect, 1,
+ "(Rect r) -> None"},
+ {"EraseRect", (PyCFunction)Qd_EraseRect, 1,
+ "(Rect r) -> None"},
+ {"OpenDeskAcc", (PyCFunction)Qd_OpenDeskAcc, 1,
+ "(Str255 name) -> None"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+void initQd()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("Qd", Qd_methods);
+ d = PyModule_GetDict(m);
+ Qd_Error = PyMac_GetOSErrException();
+ if (Qd_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Qd_Error) != 0)
+ Py_FatalError("can't initialize Qd.Error");
+}
+
+/* ========================= End module Qd ========================== */
+
diff --git a/Mac/Modules/qd/qdedit.py b/Mac/Modules/qd/qdedit.py
new file mode 100644
index 0000000..2242c5a
--- /dev/null
+++ b/Mac/Modules/qd/qdedit.py
@@ -0,0 +1,29 @@
+f = Function(void, 'GlobalToLocal',
+ (Point, 'thePoint', InOutMode),
+)
+functions.append(f)
+
+f = Function(void, 'LocalToGlobal',
+ (Point, 'thePoint', InOutMode),
+)
+functions.append(f)
+
+f = Function(void, 'SetPort',
+ (WindowPtr, 'thePort', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ClipRect',
+ (Rect, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'EraseRect',
+ (Rect, 'r', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'OpenDeskAcc',
+ (Str255, 'name', InMode),
+)
+functions.append(f)
diff --git a/Mac/Modules/qd/qdsupport.py b/Mac/Modules/qd/qdsupport.py
new file mode 100644
index 0000000..e98b27a
--- /dev/null
+++ b/Mac/Modules/qd/qdsupport.py
@@ -0,0 +1,72 @@
+# This script generates a Python interface for an Apple Macintosh Manager.
+# It uses the "bgen" package to generate C code.
+# The function specifications are generated by scanning the mamager's header file,
+# using the "scantools" package (customized for this particular manager).
+
+import string
+
+# Declarations that change for each manager
+MACHEADERFILE = 'QuickDraw.h' # The Apple header file
+MODNAME = 'Qd' # The name of the module
+OBJECTNAME = 'Graf' # The basic name of the objects used here
+
+# The following is *usually* unchanged but may still require tuning
+MODPREFIX = MODNAME # The prefix for module-wide routines
+OBJECTTYPE = OBJECTNAME + 'Ptr' # The C type used to represent them
+OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods
+INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
+EXTRAFILE = string.lower(MODPREFIX) + 'edit.py' # A similar file but hand-made
+OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
+
+from macsupport import *
+
+# Create the type objects
+
+includestuff = includestuff + """
+#include <%s>""" % MACHEADERFILE + """
+#include <Desk.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+"""
+
+class MyObjectDefinition(GlobalObjectDefinition):
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+ def outputCheckConvertArg(self):
+ OutLbrace("if (DlgObj_Check(v))")
+ Output("*p_itself = ((WindowObject *)v)->ob_itself;")
+ Output("return 1;")
+ OutRbrace()
+ Out("""
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
+ """)
+ def outputFreeIt(self, itselfname):
+ Output("DisposeWindow(%s);", itselfname)
+
+# From here on it's basically all boiler plate...
+
+# Create the generator groups and link them
+module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
+##object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE)
+##module.addobject(object)
+
+# Create the generator classes used to populate the lists
+Function = OSErrFunctionGenerator
+Method = OSErrMethodGenerator
+
+# Create and populate the lists
+functions = []
+methods = []
+#execfile(INPUTFILE)
+execfile(EXTRAFILE)
+
+# add the populated lists to the generator groups
+# (in a different wordl the scan program would generate this)
+for f in functions: module.add(f)
+for f in methods: object.add(f)
+
+# generate output (open the output file as late as possible)
+SetOutputFileName(OUTPUTFILE)
+module.generate()
+SetOutputFile() # Close it
diff --git a/Mac/Modules/res/Resmodule.c b/Mac/Modules/res/Resmodule.c
new file mode 100644
index 0000000..484bca6
--- /dev/null
+++ b/Mac/Modules/res/Resmodule.c
@@ -0,0 +1,1256 @@
+
+/* =========================== Module Res =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+#include <Resources.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+static PyObject *Res_Error;
+
+/* ---------------------- Object type Resource ---------------------- */
+
+PyTypeObject Resource_Type;
+
+#define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
+
+typedef struct ResourceObject {
+ PyObject_HEAD
+ Handle ob_itself;
+} ResourceObject;
+
+PyObject *ResObj_New(itself)
+ const Handle itself;
+{
+ ResourceObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(ResourceObject, &Resource_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ return (PyObject *)it;
+}
+ResObj_Convert(v, p_itself)
+ PyObject *v;
+ Handle *p_itself;
+{
+ if (!ResObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Resource required");
+ return 0;
+ }
+ *p_itself = ((ResourceObject *)v)->ob_itself;
+ return 1;
+}
+
+static void ResObj_dealloc(self)
+ ResourceObject *self;
+{
+ /* Cleanup of self->ob_itself goes here */
+ PyMem_DEL(self);
+}
+
+static PyObject *ResObj_HomeResFile(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = HomeResFile(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_LoadResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ LoadResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_ReleaseResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ReleaseResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_DetachResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DetachResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_GetResAttrs(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetResAttrs(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_GetResInfo(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short theID;
+ ResType theType;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetResInfo(_self->ob_itself,
+ &theID,
+ &theType,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("hO&O&",
+ theID,
+ PyMac_BuildOSType, theType,
+ PyMac_BuildStr255, name);
+ return _res;
+}
+
+static PyObject *ResObj_SetResInfo(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short theID;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &theID,
+ PyMac_GetStr255, name))
+ return NULL;
+ SetResInfo(_self->ob_itself,
+ theID,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_AddResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short theID;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&hO&",
+ PyMac_GetOSType, &theType,
+ &theID,
+ PyMac_GetStr255, name))
+ return NULL;
+ AddResource(_self->ob_itself,
+ theType,
+ theID,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_SizeResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = SizeResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_MaxSizeRsrc(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MaxSizeRsrc(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_RsrcMapEntry(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = RsrcMapEntry(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *ResObj_SetResAttrs(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short attrs;
+ if (!PyArg_ParseTuple(_args, "h",
+ &attrs))
+ return NULL;
+ SetResAttrs(_self->ob_itself,
+ attrs);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_ChangedResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ChangedResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_RmveResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ RmveResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_WriteResource(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ WriteResource(_self->ob_itself);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *ResObj_SetResourceSize(_self, _args)
+ ResourceObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long newSize;
+ if (!PyArg_ParseTuple(_args, "l",
+ &newSize))
+ return NULL;
+ SetResourceSize(_self->ob_itself,
+ newSize);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef ResObj_methods[] = {
+ {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
+ "() -> (short _rv)"},
+ {"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
+ "() -> None"},
+ {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
+ "() -> None"},
+ {"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
+ "() -> None"},
+ {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
+ "() -> (short _rv)"},
+ {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
+ "() -> (short theID, ResType theType, Str255 name)"},
+ {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
+ "(short theID, Str255 name) -> None"},
+ {"AddResource", (PyCFunction)ResObj_AddResource, 1,
+ "(ResType theType, short theID, Str255 name) -> None"},
+ {"SizeResource", (PyCFunction)ResObj_SizeResource, 1,
+ "() -> (long _rv)"},
+ {"MaxSizeRsrc", (PyCFunction)ResObj_MaxSizeRsrc, 1,
+ "() -> (long _rv)"},
+ {"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
+ "() -> (long _rv)"},
+ {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
+ "(short attrs) -> None"},
+ {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
+ "() -> None"},
+ {"RmveResource", (PyCFunction)ResObj_RmveResource, 1,
+ "() -> None"},
+ {"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
+ "() -> None"},
+ {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
+ "(long newSize) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain ResObj_chain = { ResObj_methods, NULL };
+
+static PyObject *ResObj_getattr(self, name)
+ ResourceObject *self;
+ char *name;
+{
+
+ if (strcmp(name, "size") == 0)
+ return PyInt_FromLong(GetHandleSize(self->ob_itself));
+ if (strcmp(name, "data") == 0) {
+ PyObject *res;
+ char state;
+ state = HGetState(self->ob_itself);
+ HLock(self->ob_itself);
+ res = PyString_FromStringAndSize(
+ *self->ob_itself,
+ GetHandleSize(self->ob_itself));
+ HUnlock(self->ob_itself);
+ HSetState(self->ob_itself, state);
+ return res;
+ }
+ if (strcmp(name, "__members__") == 0)
+ return Py_BuildValue("[ss]", "data", "size");
+
+ return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
+}
+
+#define ResObj_setattr NULL
+
+PyTypeObject Resource_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Resource", /*tp_name*/
+ sizeof(ResourceObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) ResObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) ResObj_getattr, /*tp_getattr*/
+ (setattrfunc) ResObj_setattr, /*tp_setattr*/
+};
+
+/* -------------------- End object type Resource -------------------- */
+
+
+static PyObject *Res_InitResources(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = InitResources();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_RsrcZoneInit(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ RsrcZoneInit();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_CloseResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ CloseResFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_ResError(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = ResError();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_CurResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CurResFile();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_CreateResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 fileName;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, fileName))
+ return NULL;
+ CreateResFile(fileName);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_OpenResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Str255 fileName;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, fileName))
+ return NULL;
+ _rv = OpenResFile(fileName);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_UseResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ UseResFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_CountTypes(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CountTypes();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_Count1Types(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = Count1Types();
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_GetIndType(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ GetIndType(&theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ PyMac_BuildOSType, theType);
+ return _res;
+}
+
+static PyObject *Res_Get1IndType(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "h",
+ &index))
+ return NULL;
+ Get1IndType(&theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ PyMac_BuildOSType, theType);
+ return _res;
+}
+
+static PyObject *Res_SetResLoad(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean load;
+ if (!PyArg_ParseTuple(_args, "b",
+ &load))
+ return NULL;
+ SetResLoad(load);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_CountResources(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = CountResources(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_Count1Resources(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = Count1Resources(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_GetIndResource(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &index))
+ return NULL;
+ _rv = GetIndResource(theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_Get1IndResource(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short index;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &index))
+ return NULL;
+ _rv = Get1IndResource(theType,
+ index);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_GetResource(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short theID;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &theID))
+ return NULL;
+ _rv = GetResource(theType,
+ theID);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_Get1Resource(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short theID;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &theID))
+ return NULL;
+ _rv = Get1Resource(theType,
+ theID);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_GetNamedResource(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theType,
+ PyMac_GetStr255, name))
+ return NULL;
+ _rv = GetNamedResource(theType,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_Get1NamedResource(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ Str255 name;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetOSType, &theType,
+ PyMac_GetStr255, name))
+ return NULL;
+ _rv = Get1NamedResource(theType,
+ name);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_UniqueID(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = UniqueID(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_Unique1ID(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ ResType theType;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetOSType, &theType))
+ return NULL;
+ _rv = Unique1ID(theType);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_UpdateResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ UpdateResFile(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_SetResPurge(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean install;
+ if (!PyArg_ParseTuple(_args, "b",
+ &install))
+ return NULL;
+ SetResPurge(install);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_GetResFileAttrs(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short refNum;
+ if (!PyArg_ParseTuple(_args, "h",
+ &refNum))
+ return NULL;
+ _rv = GetResFileAttrs(refNum);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_SetResFileAttrs(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short refNum;
+ short attrs;
+ if (!PyArg_ParseTuple(_args, "hh",
+ &refNum,
+ &attrs))
+ return NULL;
+ SetResFileAttrs(refNum,
+ attrs);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_OpenRFPerm(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Str255 fileName;
+ short vRefNum;
+ char permission;
+ if (!PyArg_ParseTuple(_args, "O&hc",
+ PyMac_GetStr255, fileName,
+ &vRefNum,
+ &permission))
+ return NULL;
+ _rv = OpenRFPerm(fileName,
+ vRefNum,
+ permission);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_RGetResource(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Handle _rv;
+ ResType theType;
+ short theID;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetOSType, &theType,
+ &theID))
+ return NULL;
+ _rv = RGetResource(theType,
+ theID);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("O&",
+ ResObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Res_HOpenResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ short vRefNum;
+ long dirID;
+ Str255 fileName;
+ char permission;
+ if (!PyArg_ParseTuple(_args, "hlO&c",
+ &vRefNum,
+ &dirID,
+ PyMac_GetStr255, fileName,
+ &permission))
+ return NULL;
+ _rv = HOpenResFile(vRefNum,
+ dirID,
+ fileName,
+ permission);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_HCreateResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short vRefNum;
+ long dirID;
+ Str255 fileName;
+ if (!PyArg_ParseTuple(_args, "hlO&",
+ &vRefNum,
+ &dirID,
+ PyMac_GetStr255, fileName))
+ return NULL;
+ HCreateResFile(vRefNum,
+ dirID,
+ fileName);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Res_FSpOpenResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ FSSpec spec;
+ SignedByte permission;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ PyMac_GetFSSpec, &spec,
+ &permission))
+ return NULL;
+ _rv = FSpOpenResFile(&spec,
+ permission);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Res_FSpCreateResFile(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ FSSpec spec;
+ OSType creator;
+ OSType fileType;
+ ScriptCode scriptTag;
+ if (!PyArg_ParseTuple(_args, "O&O&O&h",
+ PyMac_GetFSSpec, &spec,
+ PyMac_GetOSType, &creator,
+ PyMac_GetOSType, &fileType,
+ &scriptTag))
+ return NULL;
+ FSpCreateResFile(&spec,
+ creator,
+ fileType,
+ scriptTag);
+ {
+ OSErr _err = ResError();
+ if (_err != noErr) return PyMac_Error(_err);
+ }
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef Res_methods[] = {
+ {"InitResources", (PyCFunction)Res_InitResources, 1,
+ "() -> (short _rv)"},
+ {"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
+ "() -> None"},
+ {"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
+ "(short refNum) -> None"},
+ {"ResError", (PyCFunction)Res_ResError, 1,
+ "() -> (short _rv)"},
+ {"CurResFile", (PyCFunction)Res_CurResFile, 1,
+ "() -> (short _rv)"},
+ {"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
+ "(Str255 fileName) -> None"},
+ {"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
+ "(Str255 fileName) -> (short _rv)"},
+ {"UseResFile", (PyCFunction)Res_UseResFile, 1,
+ "(short refNum) -> None"},
+ {"CountTypes", (PyCFunction)Res_CountTypes, 1,
+ "() -> (short _rv)"},
+ {"Count1Types", (PyCFunction)Res_Count1Types, 1,
+ "() -> (short _rv)"},
+ {"GetIndType", (PyCFunction)Res_GetIndType, 1,
+ "(short index) -> (ResType theType)"},
+ {"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
+ "(short index) -> (ResType theType)"},
+ {"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
+ "(Boolean load) -> None"},
+ {"CountResources", (PyCFunction)Res_CountResources, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
+ "(ResType theType, short index) -> (Handle _rv)"},
+ {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
+ "(ResType theType, short index) -> (Handle _rv)"},
+ {"GetResource", (PyCFunction)Res_GetResource, 1,
+ "(ResType theType, short theID) -> (Handle _rv)"},
+ {"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
+ "(ResType theType, short theID) -> (Handle _rv)"},
+ {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
+ "(ResType theType, Str255 name) -> (Handle _rv)"},
+ {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
+ "(ResType theType, Str255 name) -> (Handle _rv)"},
+ {"UniqueID", (PyCFunction)Res_UniqueID, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
+ "(ResType theType) -> (short _rv)"},
+ {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
+ "(short refNum) -> None"},
+ {"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
+ "(Boolean install) -> None"},
+ {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
+ "(short refNum) -> (short _rv)"},
+ {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
+ "(short refNum, short attrs) -> None"},
+ {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
+ "(Str255 fileName, short vRefNum, char permission) -> (short _rv)"},
+ {"RGetResource", (PyCFunction)Res_RGetResource, 1,
+ "(ResType theType, short theID) -> (Handle _rv)"},
+ {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
+ "(short vRefNum, long dirID, Str255 fileName, char permission) -> (short _rv)"},
+ {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
+ "(short vRefNum, long dirID, Str255 fileName) -> None"},
+ {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
+ "(FSSpec spec, SignedByte permission) -> (short _rv)"},
+ {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
+ "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
+ {NULL, NULL, 0}
+};
+
+
+
+
+
+void initRes()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+
+ m = Py_InitModule("Res", Res_methods);
+ d = PyModule_GetDict(m);
+ Res_Error = PyMac_GetOSErrException();
+ if (Res_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Res_Error) != 0)
+ Py_FatalError("can't initialize Res.Error");
+}
+
+/* ========================= End module Res ========================= */
+
diff --git a/Mac/Modules/res/resgen.py b/Mac/Modules/res/resgen.py
new file mode 100644
index 0000000..3716e9e
--- /dev/null
+++ b/Mac/Modules/res/resgen.py
@@ -0,0 +1,271 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Resources.h'
+
+f = ResFunction(short, 'InitResources',
+)
+functions.append(f)
+
+f = ResFunction(void, 'RsrcZoneInit',
+)
+functions.append(f)
+
+f = ResFunction(void, 'CloseResFile',
+ (short, 'refNum', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'ResError',
+)
+functions.append(f)
+
+f = ResFunction(short, 'CurResFile',
+)
+functions.append(f)
+
+f = ResMethod(short, 'HomeResFile',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResFunction(void, 'CreateResFile',
+ (ConstStr255Param, 'fileName', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'OpenResFile',
+ (ConstStr255Param, 'fileName', InMode),
+)
+functions.append(f)
+
+f = ResFunction(void, 'UseResFile',
+ (short, 'refNum', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'CountTypes',
+)
+functions.append(f)
+
+f = ResFunction(short, 'Count1Types',
+)
+functions.append(f)
+
+f = ResFunction(void, 'GetIndType',
+ (ResType, 'theType', OutMode),
+ (short, 'index', InMode),
+)
+functions.append(f)
+
+f = ResFunction(void, 'Get1IndType',
+ (ResType, 'theType', OutMode),
+ (short, 'index', InMode),
+)
+functions.append(f)
+
+f = ResFunction(void, 'SetResLoad',
+ (Boolean, 'load', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'CountResources',
+ (ResType, 'theType', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'Count1Resources',
+ (ResType, 'theType', InMode),
+)
+functions.append(f)
+
+f = ResFunction(Handle, 'GetIndResource',
+ (ResType, 'theType', InMode),
+ (short, 'index', InMode),
+)
+functions.append(f)
+
+f = ResFunction(Handle, 'Get1IndResource',
+ (ResType, 'theType', InMode),
+ (short, 'index', InMode),
+)
+functions.append(f)
+
+f = ResFunction(Handle, 'GetResource',
+ (ResType, 'theType', InMode),
+ (short, 'theID', InMode),
+)
+functions.append(f)
+
+f = ResFunction(Handle, 'Get1Resource',
+ (ResType, 'theType', InMode),
+ (short, 'theID', InMode),
+)
+functions.append(f)
+
+f = ResFunction(Handle, 'GetNamedResource',
+ (ResType, 'theType', InMode),
+ (ConstStr255Param, 'name', InMode),
+)
+functions.append(f)
+
+f = ResFunction(Handle, 'Get1NamedResource',
+ (ResType, 'theType', InMode),
+ (ConstStr255Param, 'name', InMode),
+)
+functions.append(f)
+
+f = ResMethod(void, 'LoadResource',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'ReleaseResource',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'DetachResource',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResFunction(short, 'UniqueID',
+ (ResType, 'theType', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'Unique1ID',
+ (ResType, 'theType', InMode),
+)
+functions.append(f)
+
+f = ResMethod(short, 'GetResAttrs',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'GetResInfo',
+ (Handle, 'theResource', InMode),
+ (short, 'theID', OutMode),
+ (ResType, 'theType', OutMode),
+ (Str255, 'name', OutMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'SetResInfo',
+ (Handle, 'theResource', InMode),
+ (short, 'theID', InMode),
+ (ConstStr255Param, 'name', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'AddResource',
+ (Handle, 'theResource', InMode),
+ (ResType, 'theType', InMode),
+ (short, 'theID', InMode),
+ (ConstStr255Param, 'name', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(long, 'SizeResource',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(long, 'MaxSizeRsrc',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(long, 'RsrcMapEntry',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'SetResAttrs',
+ (Handle, 'theResource', InMode),
+ (short, 'attrs', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'ChangedResource',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResMethod(void, 'RmveResource',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResFunction(void, 'UpdateResFile',
+ (short, 'refNum', InMode),
+)
+functions.append(f)
+
+f = ResMethod(void, 'WriteResource',
+ (Handle, 'theResource', InMode),
+)
+resmethods.append(f)
+
+f = ResFunction(void, 'SetResPurge',
+ (Boolean, 'install', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'GetResFileAttrs',
+ (short, 'refNum', InMode),
+)
+functions.append(f)
+
+f = ResFunction(void, 'SetResFileAttrs',
+ (short, 'refNum', InMode),
+ (short, 'attrs', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'OpenRFPerm',
+ (ConstStr255Param, 'fileName', InMode),
+ (short, 'vRefNum', InMode),
+ (char, 'permission', InMode),
+)
+functions.append(f)
+
+f = ResFunction(Handle, 'RGetResource',
+ (ResType, 'theType', InMode),
+ (short, 'theID', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'HOpenResFile',
+ (short, 'vRefNum', InMode),
+ (long, 'dirID', InMode),
+ (ConstStr255Param, 'fileName', InMode),
+ (char, 'permission', InMode),
+)
+functions.append(f)
+
+f = ResFunction(void, 'HCreateResFile',
+ (short, 'vRefNum', InMode),
+ (long, 'dirID', InMode),
+ (ConstStr255Param, 'fileName', InMode),
+)
+functions.append(f)
+
+f = ResFunction(short, 'FSpOpenResFile',
+ (FSSpec_ptr, 'spec', InMode),
+ (SignedByte, 'permission', InMode),
+)
+functions.append(f)
+
+f = ResFunction(void, 'FSpCreateResFile',
+ (FSSpec_ptr, 'spec', InMode),
+ (OSType, 'creator', InMode),
+ (OSType, 'fileType', InMode),
+ (ScriptCode, 'scriptTag', InMode),
+)
+functions.append(f)
+
+f = ResMethod(void, 'SetResourceSize',
+ (Handle, 'theResource', InMode),
+ (long, 'newSize', InMode),
+)
+resmethods.append(f)
diff --git a/Mac/Modules/res/resscan.py b/Mac/Modules/res/resscan.py
new file mode 100644
index 0000000..42bb389
--- /dev/null
+++ b/Mac/Modules/res/resscan.py
@@ -0,0 +1,60 @@
+# Scan Resources.h header file, generate resgen.py and Resources.py files.
+# Then run ressupport to generate Resmodule.c.
+# (Should learn how to tell the compiler to compile it as well.)
+
+import sys
+import os
+import string
+import regex
+import regsub
+import MacOS
+
+from scantools import Scanner
+
+def main():
+ input = "Resources.h"
+ output = "resgen.py"
+ defsoutput = "Resources.py"
+ scanner = ResourcesScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done scanning and generating, now doing 'import ressupport' ==="
+ import ressupport
+ print "=== Done 'import ressupport'. It's up to you to compile Resmodule.c ==="
+
+class ResourcesScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "ResFunction"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ if t == "Handle" and m == "InMode":
+ classname = "ResMethod"
+ listname = "resmethods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ "ReadPartialResource",
+ "WritePartialResource",
+ ]
+
+ def makerepairinstructions(self):
+ return [
+ ([("Str255", "*", "InMode")],
+ [("*", "*", "OutMode")]),
+
+ ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode")],
+ [("InOutBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+ ("long", "*", "OutMode")],
+ [("OutBuffer", "*", "InOutMode")]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/res/ressupport.py b/Mac/Modules/res/ressupport.py
new file mode 100644
index 0000000..5c0d70f
--- /dev/null
+++ b/Mac/Modules/res/ressupport.py
@@ -0,0 +1,77 @@
+# This script will generate the Resources interface for Python.
+# It uses the "bgen" package to generate C code.
+# It execs the file resgen.py which contain the function definitions
+# (resgen.py was generated by resscan.py, scanning the <Resources.h> header file).
+
+from macsupport import *
+
+
+class ResMixIn:
+
+ def checkit(self):
+ OutLbrace()
+ Output("OSErr _err = ResError();")
+ Output("if (_err != noErr) return PyMac_Error(_err);")
+ OutRbrace()
+ FunctionGenerator.checkit(self) # XXX
+
+class ResFunction(ResMixIn, FunctionGenerator): pass
+class ResMethod(ResMixIn, MethodGenerator): pass
+
+# includestuff etc. are imported from macsupport
+
+includestuff = includestuff + """
+#include <Resources.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+"""
+
+finalstuff = finalstuff + """
+"""
+
+initstuff = initstuff + """
+"""
+
+module = MacModule('Res', 'Res', includestuff, finalstuff, initstuff)
+
+getattrHookCode = """
+if (strcmp(name, "size") == 0)
+ return PyInt_FromLong(GetHandleSize(self->ob_itself));
+if (strcmp(name, "data") == 0) {
+ PyObject *res;
+ char state;
+ state = HGetState(self->ob_itself);
+ HLock(self->ob_itself);
+ res = PyString_FromStringAndSize(
+ *self->ob_itself,
+ GetHandleSize(self->ob_itself));
+ HUnlock(self->ob_itself);
+ HSetState(self->ob_itself, state);
+ return res;
+}
+if (strcmp(name, "__members__") == 0)
+ return Py_BuildValue("[ss]", "data", "size");
+"""
+
+class ResDefiniton(GlobalObjectDefinition):
+
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+
+ def outputGetattrHook(self):
+ Output(getattrHookCode)
+
+
+resobject = ResDefiniton('Resource', 'ResObj', 'Handle')
+module.addobject(resobject)
+
+functions = []
+resmethods = []
+
+execfile('resgen.py')
+
+for f in functions: module.add(f)
+for f in resmethods: resobject.add(f)
+
+SetOutputFileName('Resmodule.c')
+module.generate()
diff --git a/Mac/Modules/snd/Sndmodule.c b/Mac/Modules/snd/Sndmodule.c
new file mode 100644
index 0000000..0f71b0d
--- /dev/null
+++ b/Mac/Modules/snd/Sndmodule.c
@@ -0,0 +1,786 @@
+
+/* =========================== Module Snd =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+#include <Sound.h>
+
+#ifndef __MWERKS__
+#define SndCallBackUPP ProcPtr
+#define NewSndCallBackProc(x) (x)
+#define SndListHandle Handle
+#endif
+
+#include <OSUtils.h> /* for Set(Current)A5 */
+
+/* Create a SndCommand object (an (int, int, int) tuple) */
+static PyObject *
+SndCmd_New(SndCommand *pc)
+{
+ return Py_BuildValue("hhl", pc->cmd, pc->param1, pc->param2);
+}
+
+/* Convert a SndCommand argument */
+static int
+SndCmd_Convert(PyObject *v, SndCommand *pc)
+{
+ int len;
+ pc->param1 = 0;
+ pc->param2 = 0;
+ if (PyTuple_Check(v)) {
+ if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
+ return 1;
+ PyErr_Clear();
+ return PyArg_ParseTuple(v, "hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
+ }
+ return PyArg_Parse(v, "h", &pc->cmd);
+}
+
+/* Create a NumVersion object (a quintuple of integers) */
+static PyObject *
+NumVer_New(NumVersion nv)
+{
+ return Py_BuildValue("iiiii",
+ nv.majorRev,
+ nv.minorRev,
+ nv.bugFixRev,
+ nv.stage,
+ nv.nonRelRev);
+}
+
+static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
+
+static PyObject *Snd_Error;
+
+/* --------------------- Object type SndChannel --------------------- */
+
+staticforward PyTypeObject SndChannel_Type;
+
+#define SndCh_Check(x) ((x)->ob_type == &SndChannel_Type)
+
+typedef struct SndChannelObject {
+ PyObject_HEAD
+ SndChannelPtr ob_itself;
+ /* Members used to implement callbacks: */
+ PyObject *ob_callback;
+ long ob_A5;
+ SndCommand ob_cmd;
+} SndChannelObject;
+
+static PyObject *SndCh_New(itself)
+ const SndChannelPtr itself;
+{
+ SndChannelObject *it;
+ it = PyObject_NEW(SndChannelObject, &SndChannel_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->ob_callback = NULL;
+ it->ob_A5 = SetCurrentA5();
+ return (PyObject *)it;
+}
+static SndCh_Convert(v, p_itself)
+ PyObject *v;
+ SndChannelPtr *p_itself;
+{
+ if (!SndCh_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "SndChannel required");
+ return 0;
+ }
+ *p_itself = ((SndChannelObject *)v)->ob_itself;
+ return 1;
+}
+
+static void SndCh_dealloc(self)
+ SndChannelObject *self;
+{
+ SndDisposeChannel(self->ob_itself, 1);
+ Py_XDECREF(self->ob_callback);
+ PyMem_DEL(self);
+}
+
+static PyObject *SndCh_SndDoCommand(_self, _args)
+ SndChannelObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndCommand cmd;
+ Boolean noWait;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ SndCmd_Convert, &cmd,
+ &noWait))
+ return NULL;
+ _err = SndDoCommand(_self->ob_itself,
+ &cmd,
+ noWait);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndDoImmediate(_self, _args)
+ SndChannelObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndCommand cmd;
+ if (!PyArg_ParseTuple(_args, "O&",
+ SndCmd_Convert, &cmd))
+ return NULL;
+ _err = SndDoImmediate(_self->ob_itself,
+ &cmd);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndPlay(_self, _args)
+ SndChannelObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Handle sndHdl;
+ Boolean async;
+ if (!PyArg_ParseTuple(_args, "O&b",
+ ResObj_Convert, &sndHdl,
+ &async))
+ return NULL;
+ _err = SndPlay(_self->ob_itself,
+ sndHdl,
+ async);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndStartFilePlay(_self, _args)
+ SndChannelObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short fRefNum;
+ short resNum;
+ long bufferSize;
+ Boolean async;
+ if (!PyArg_ParseTuple(_args, "hhlb",
+ &fRefNum,
+ &resNum,
+ &bufferSize,
+ &async))
+ return NULL;
+ _err = SndStartFilePlay(_self->ob_itself,
+ fRefNum,
+ resNum,
+ bufferSize,
+ 0,
+ 0,
+ 0,
+ async);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndPauseFilePlay(_self, _args)
+ SndChannelObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = SndPauseFilePlay(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndStopFilePlay(_self, _args)
+ SndChannelObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Boolean async;
+ if (!PyArg_ParseTuple(_args, "b",
+ &async))
+ return NULL;
+ _err = SndStopFilePlay(_self->ob_itself,
+ async);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *SndCh_SndChannelStatus(_self, _args)
+ SndChannelObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short theLength;
+ SCStatus theStatus__out__;
+ int theStatus__len__;
+ if (!PyArg_ParseTuple(_args, "h",
+ &theLength))
+ return NULL;
+ _err = SndChannelStatus(_self->ob_itself,
+ theLength,
+ &theStatus__out__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("s#",
+ (char *)&theStatus__out__, sizeof(SCStatus));
+ theStatus__error__: ;
+ return _res;
+}
+
+static PyMethodDef SndCh_methods[] = {
+ {"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1,
+ "(SndCommand cmd, Boolean noWait) -> None"},
+ {"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1,
+ "(SndCommand cmd) -> None"},
+ {"SndPlay", (PyCFunction)SndCh_SndPlay, 1,
+ "(Handle sndHdl, Boolean async) -> None"},
+ {"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1,
+ "(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"},
+ {"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1,
+ "() -> None"},
+ {"SndStopFilePlay", (PyCFunction)SndCh_SndStopFilePlay, 1,
+ "(Boolean async) -> None"},
+ {"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1,
+ "(short theLength) -> (SCStatus theStatus)"},
+ {NULL, NULL, 0}
+};
+
+static PyMethodChain SndCh_chain = { SndCh_methods, NULL };
+
+static PyObject *SndCh_getattr(self, name)
+ SndChannelObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&SndCh_chain, (PyObject *)self, name);
+}
+
+#define SndCh_setattr NULL
+
+static PyTypeObject SndChannel_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "SndChannel", /*tp_name*/
+ sizeof(SndChannelObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) SndCh_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) SndCh_getattr, /*tp_getattr*/
+ (setattrfunc) SndCh_setattr, /*tp_setattr*/
+};
+
+/* ------------------- End object type SndChannel ------------------- */
+
+
+static PyObject *Snd_SndNewChannel(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ SndChannelPtr chan = 0;
+ short synth;
+ long init;
+ PyObject* userRoutine;
+ if (!PyArg_ParseTuple(_args, "hlO",
+ &synth,
+ &init,
+ &userRoutine))
+ return NULL;
+ if (userRoutine != Py_None && !callable(userRoutine))
+ {
+ PyErr_SetString(PyExc_TypeError, "callback must be callable");
+ goto userRoutine__error__;
+ }
+ _err = SndNewChannel(&chan,
+ synth,
+ init,
+ (SndCallBackProcPtr)&SndCh_UserRoutine);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ SndCh_New, chan);
+ if (_res != NULL && userRoutine != Py_None)
+ {
+ SndChannelObject *p = (SndChannelObject *)_res;
+ p->ob_itself->userInfo = (long)p;
+ Py_INCREF(userRoutine);
+ p->ob_callback = userRoutine;
+ }
+ userRoutine__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_SndControl(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short id;
+ SndCommand cmd;
+ if (!PyArg_ParseTuple(_args, "h",
+ &id))
+ return NULL;
+ _err = SndControl(id,
+ &cmd);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ SndCmd_New, &cmd);
+ return _res;
+}
+
+static PyObject *Snd_SetSoundVol(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short level;
+ if (!PyArg_ParseTuple(_args, "h",
+ &level))
+ return NULL;
+ SetSoundVol(level);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_GetSoundVol(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short level;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetSoundVol(&level);
+ _res = Py_BuildValue("h",
+ level);
+ return _res;
+}
+
+static PyObject *Snd_StartSound(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ char *synthRec__in__;
+ long synthRec__len__;
+ if (!PyArg_ParseTuple(_args, "s#",
+ &synthRec__in__, &synthRec__len__))
+ return NULL;
+ StartSound(synthRec__in__, synthRec__len__,
+ (SndCompletionProcPtr)0);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ synthRec__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_StopSound(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ StopSound();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_SoundDone(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = SoundDone();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Snd_SndSoundManagerVersion(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ NumVersion _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = SndSoundManagerVersion();
+ _res = Py_BuildValue("O&",
+ NumVer_New, _rv);
+ return _res;
+}
+
+static PyObject *Snd_SndManagerStatus(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short theLength;
+ SMStatus theStatus__out__;
+ int theStatus__len__;
+ if (!PyArg_ParseTuple(_args, "h",
+ &theLength))
+ return NULL;
+ _err = SndManagerStatus(theLength,
+ &theStatus__out__);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("s#",
+ (char *)&theStatus__out__, sizeof(SMStatus));
+ theStatus__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_SndGetSysBeepState(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short sysBeepState;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SndGetSysBeepState(&sysBeepState);
+ _res = Py_BuildValue("h",
+ sysBeepState);
+ return _res;
+}
+
+static PyObject *Snd_SndSetSysBeepState(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ short sysBeepState;
+ if (!PyArg_ParseTuple(_args, "h",
+ &sysBeepState))
+ return NULL;
+ _err = SndSetSysBeepState(sysBeepState);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Snd_MACEVersion(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ NumVersion _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = MACEVersion();
+ _res = Py_BuildValue("O&",
+ NumVer_New, _rv);
+ return _res;
+}
+
+static PyObject *Snd_Comp3to1(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ char *state__in__;
+ char state__out__[128];
+ int state__len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__len__,
+ &state__in__, &state__len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ if (state__len__ != 128)
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be 128");
+ goto state__error__;
+ }
+ Comp3to1(buffer__in__, buffer__out__, buffer__len__,
+ state__in__, state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, buffer__len__,
+ state__out__, 128);
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_Exp1to3(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ char *state__in__;
+ char state__out__[128];
+ int state__len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__len__,
+ &state__in__, &state__len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ if (state__len__ != 128)
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be 128");
+ goto state__error__;
+ }
+ Exp1to3(buffer__in__, buffer__out__, buffer__len__,
+ state__in__, state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, buffer__len__,
+ state__out__, 128);
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_Comp6to1(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ char *state__in__;
+ char state__out__[128];
+ int state__len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__len__,
+ &state__in__, &state__len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ if (state__len__ != 128)
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be 128");
+ goto state__error__;
+ }
+ Comp6to1(buffer__in__, buffer__out__, buffer__len__,
+ state__in__, state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, buffer__len__,
+ state__out__, 128);
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+
+static PyObject *Snd_Exp1to6(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ char *buffer__in__;
+ char *buffer__out__;
+ long buffer__len__;
+ char *state__in__;
+ char state__out__[128];
+ int state__len__;
+ unsigned long numChannels;
+ unsigned long whichChannel;
+ if (!PyArg_ParseTuple(_args, "s#s#ll",
+ &buffer__in__, &buffer__len__,
+ &state__in__, &state__len__,
+ &numChannels,
+ &whichChannel))
+ return NULL;
+ if ((buffer__out__ = malloc(buffer__len__)) == NULL)
+ {
+ PyErr_NoMemory();
+ goto buffer__error__;
+ }
+ if (state__len__ != 128)
+ {
+ PyErr_SetString(PyExc_TypeError, "buffer length should be 128");
+ goto state__error__;
+ }
+ Exp1to6(buffer__in__, buffer__out__, buffer__len__,
+ state__in__, state__out__,
+ numChannels,
+ whichChannel);
+ _res = Py_BuildValue("s#s#",
+ buffer__out__, buffer__len__,
+ state__out__, 128);
+ state__error__: ;
+ free(buffer__out__);
+ buffer__error__: ;
+ return _res;
+}
+
+static PyMethodDef Snd_methods[] = {
+ {"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1,
+ "(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"},
+ {"SndControl", (PyCFunction)Snd_SndControl, 1,
+ "(short id) -> (SndCommand cmd)"},
+ {"SetSoundVol", (PyCFunction)Snd_SetSoundVol, 1,
+ "(short level) -> None"},
+ {"GetSoundVol", (PyCFunction)Snd_GetSoundVol, 1,
+ "() -> (short level)"},
+ {"StartSound", (PyCFunction)Snd_StartSound, 1,
+ "(Buffer synthRec) -> None"},
+ {"StopSound", (PyCFunction)Snd_StopSound, 1,
+ "() -> None"},
+ {"SoundDone", (PyCFunction)Snd_SoundDone, 1,
+ "() -> (Boolean _rv)"},
+ {"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1,
+ "() -> (NumVersion _rv)"},
+ {"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1,
+ "(short theLength) -> (SMStatus theStatus)"},
+ {"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1,
+ "() -> (short sysBeepState)"},
+ {"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1,
+ "(short sysBeepState) -> None"},
+ {"MACEVersion", (PyCFunction)Snd_MACEVersion, 1,
+ "() -> (NumVersion _rv)"},
+ {"Comp3to1", (PyCFunction)Snd_Comp3to1, 1,
+ "(Buffer buffer, Buffer state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, Buffer state)"},
+ {"Exp1to3", (PyCFunction)Snd_Exp1to3, 1,
+ "(Buffer buffer, Buffer state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, Buffer state)"},
+ {"Comp6to1", (PyCFunction)Snd_Comp6to1, 1,
+ "(Buffer buffer, Buffer state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, Buffer state)"},
+ {"Exp1to6", (PyCFunction)Snd_Exp1to6, 1,
+ "(Buffer buffer, Buffer state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, Buffer state)"},
+ {NULL, NULL, 0}
+};
+
+
+
+/* Routine passed to Py_AddPendingCall -- call the Python callback */
+static int
+SndCh_CallCallBack(arg)
+ void *arg;
+{
+ SndChannelObject *p = (SndChannelObject *)arg;
+ PyObject *args;
+ PyObject *res;
+ args = Py_BuildValue("(O(hhl))",
+ p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
+ res = PyEval_CallObject(p->ob_callback, args);
+ Py_DECREF(args);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
+}
+
+/* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
+static pascal void
+SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
+{
+ SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
+ if (p->ob_callback != NULL) {
+ long A5 = SetA5(p->ob_A5);
+ p->ob_cmd = *cmd;
+ Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
+ SetA5(A5);
+ }
+}
+
+
+void initSnd()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+
+ m = Py_InitModule("Snd", Snd_methods);
+ d = PyModule_GetDict(m);
+ Snd_Error = PyMac_GetOSErrException();
+ if (Snd_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Snd_Error) != 0)
+ Py_FatalError("can't initialize Snd.Error");
+}
+
+/* ========================= End module Snd ========================= */
+
diff --git a/Mac/Modules/snd/sndgen.py b/Mac/Modules/snd/sndgen.py
new file mode 100644
index 0000000..2c77a1f
--- /dev/null
+++ b/Mac/Modules/snd/sndgen.py
@@ -0,0 +1,131 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Sound.h'
+
+f = SndMethod(OSErr, 'SndDoCommand',
+ (SndChannelPtr, 'chan', InMode),
+ (SndCommand_ptr, 'cmd', InMode),
+ (Boolean, 'noWait', InMode),
+)
+sndmethods.append(f)
+
+f = SndMethod(OSErr, 'SndDoImmediate',
+ (SndChannelPtr, 'chan', InMode),
+ (SndCommand_ptr, 'cmd', InMode),
+)
+sndmethods.append(f)
+
+f = SndFunction(OSErr, 'SndNewChannel',
+ (SndChannelPtr, 'chan', OutMode),
+ (short, 'synth', InMode),
+ (long, 'init', InMode),
+ (SndCallBackProcPtr, 'userRoutine', InMode),
+)
+functions.append(f)
+
+f = SndMethod(OSErr, 'SndPlay',
+ (SndChannelPtr, 'chan', InMode),
+ (SndListHandle, 'sndHdl', InMode),
+ (Boolean, 'async', InMode),
+)
+sndmethods.append(f)
+
+f = SndFunction(OSErr, 'SndControl',
+ (short, 'id', InMode),
+ (SndCommand, 'cmd', OutMode),
+)
+functions.append(f)
+
+f = SndFunction(void, 'SetSoundVol',
+ (short, 'level', InMode),
+)
+functions.append(f)
+
+f = SndFunction(void, 'GetSoundVol',
+ (short, 'level', OutMode),
+)
+functions.append(f)
+
+f = SndFunction(NumVersion, 'SndSoundManagerVersion',
+)
+functions.append(f)
+
+f = SndMethod(OSErr, 'SndStartFilePlay',
+ (SndChannelPtr, 'chan', InMode),
+ (short, 'fRefNum', InMode),
+ (short, 'resNum', InMode),
+ (long, 'bufferSize', InMode),
+ (FakeType('0'), 'theBuffer', InMode),
+ (AudioSelectionPtr, 'theSelection', InMode),
+ (ProcPtr, 'theCompletion', InMode),
+ (Boolean, 'async', InMode),
+)
+sndmethods.append(f)
+
+f = SndMethod(OSErr, 'SndPauseFilePlay',
+ (SndChannelPtr, 'chan', InMode),
+)
+sndmethods.append(f)
+
+f = SndMethod(OSErr, 'SndStopFilePlay',
+ (SndChannelPtr, 'chan', InMode),
+ (Boolean, 'async', InMode),
+)
+sndmethods.append(f)
+
+f = SndMethod(OSErr, 'SndChannelStatus',
+ (SndChannelPtr, 'chan', InMode),
+ (short, 'theLength', InMode),
+ (SCStatus, 'theStatus', OutMode),
+)
+sndmethods.append(f)
+
+f = SndFunction(OSErr, 'SndManagerStatus',
+ (short, 'theLength', InMode),
+ (SMStatus, 'theStatus', OutMode),
+)
+functions.append(f)
+
+f = SndFunction(void, 'SndGetSysBeepState',
+ (short, 'sysBeepState', OutMode),
+)
+functions.append(f)
+
+f = SndFunction(OSErr, 'SndSetSysBeepState',
+ (short, 'sysBeepState', InMode),
+)
+functions.append(f)
+
+f = SndFunction(NumVersion, 'MACEVersion',
+)
+functions.append(f)
+
+f = SndFunction(void, 'Comp3to1',
+ (InOutBuffer, 'buffer', InOutMode),
+ (InOutBuf128, 'state', InOutMode),
+ (unsigned_long, 'numChannels', InMode),
+ (unsigned_long, 'whichChannel', InMode),
+)
+functions.append(f)
+
+f = SndFunction(void, 'Exp1to3',
+ (InOutBuffer, 'buffer', InOutMode),
+ (InOutBuf128, 'state', InOutMode),
+ (unsigned_long, 'numChannels', InMode),
+ (unsigned_long, 'whichChannel', InMode),
+)
+functions.append(f)
+
+f = SndFunction(void, 'Comp6to1',
+ (InOutBuffer, 'buffer', InOutMode),
+ (InOutBuf128, 'state', InOutMode),
+ (unsigned_long, 'numChannels', InMode),
+ (unsigned_long, 'whichChannel', InMode),
+)
+functions.append(f)
+
+f = SndFunction(void, 'Exp1to6',
+ (InOutBuffer, 'buffer', InOutMode),
+ (InOutBuf128, 'state', InOutMode),
+ (unsigned_long, 'numChannels', InMode),
+ (unsigned_long, 'whichChannel', InMode),
+)
+functions.append(f)
diff --git a/Mac/Modules/snd/sndscan.py b/Mac/Modules/snd/sndscan.py
new file mode 100644
index 0000000..b63691b
--- /dev/null
+++ b/Mac/Modules/snd/sndscan.py
@@ -0,0 +1,84 @@
+# Scan Sound.h header file, generate sndgen.py and Sound.py files.
+# Then import sndsupport (which execs sndgen.py) to generate Sndmodule.c.
+# (Should learn how to tell the compiler to compile it as well.)
+
+from scantools import Scanner
+
+def main():
+ input = "Sound.h"
+ output = "sndgen.py"
+ defsoutput = "Sound.py"
+ scanner = SoundScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done scanning and generating, now doing 'import sndsupport' ==="
+ import sndsupport
+ print "=== Done. It's up to you to compile Sndmodule.c ==="
+
+class SoundScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "SndFunction"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ if t == "SndChannelPtr" and m == "InMode":
+ classname = "SndMethod"
+ listname = "sndmethods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ 'SndDisposeChannel', # automatic on deallocation
+ 'SndAddModifier', # for internal use only
+ 'SndPlayDoubleBuffer', # very low level routine
+ # Obsolete:
+ 'StartSound',
+ 'StopSound',
+ 'SoundDone',
+
+ ]
+
+ def makeblacklisttypes(self):
+ return [
+ ]
+
+ def makerepairinstructions(self):
+ return [
+ ([("Str255", "*", "InMode")],
+ [("*", "*", "OutMode")]),
+
+ ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+ ("long", "*", "OutMode")],
+ [("VarVarOutBuffer", "*", "InOutMode")]),
+
+ ([("SCStatusPtr", "*", "InMode")],
+ [("SCStatus", "*", "OutMode")]),
+
+ ([("SMStatusPtr", "*", "InMode")],
+ [("SMStatus", "*", "OutMode")]),
+
+ # For SndPlay's SndListHandle argument
+ ([("Handle", "sndHdl", "InMode")],
+ [("SndListHandle", "*", "*")]),
+
+ # For SndStartFilePlay
+ ([("long", "bufferSize", "InMode"), ("void", "theBuffer", "OutMode")],
+ [("*", "*", "*"), ("FakeType('0')", "*", "InMode")]),
+
+ # For Comp3to1 etc.
+ ([("void_ptr", "inBuffer", "InMode"),
+ ("void", "outBuffer", "OutMode"),
+ ("unsigned_long", "cnt", "InMode")],
+ [("InOutBuffer", "buffer", "InOutMode")]),
+
+ # Ditto
+ ([("void_ptr", "inState", "InMode"), ("void", "outState", "OutMode")],
+ [("InOutBuf128", "state", "InOutMode")]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/snd/sndsupport.py b/Mac/Modules/snd/sndsupport.py
new file mode 100644
index 0000000..3516fa6
--- /dev/null
+++ b/Mac/Modules/snd/sndsupport.py
@@ -0,0 +1,218 @@
+# This script generates the Sound interface for Python.
+# It uses the "bgen" package to generate C code.
+# It execs the file sndgen.py which contain the function definitions
+# (sndgen.py was generated by sndscan.py, scanning the <Sound.h> header file).
+
+from macsupport import *
+
+
+# define our own function and module generators
+
+class SndMixIn: pass
+
+class SndFunction(SndMixIn, OSErrFunctionGenerator): pass
+class SndMethod(SndMixIn, OSErrMethodGenerator): pass
+
+
+# includestuff etc. are imported from macsupport
+
+includestuff = includestuff + """
+#include <Sound.h>
+
+#ifndef __MWERKS__
+#define SndCallBackUPP ProcPtr
+#define NewSndCallBackProc(x) (x)
+#define SndListHandle Handle
+#endif
+"""
+
+initstuff = initstuff + """
+"""
+
+
+# define types used for arguments (in addition to standard and macsupport types)
+
+class SndChannelPtrType(OpaqueByValueType):
+ def declare(self, name):
+ # Initializing all SndChannelPtr objects to 0 saves
+ # special-casing NewSndChannel(), where it is formally an
+ # input-output parameter but we treat it as output-only
+ # (since Python users are not supposed to allocate memory)
+ Output("SndChannelPtr %s = 0;", name)
+
+SndChannelPtr = SndChannelPtrType('SndChannelPtr', 'SndCh')
+
+SndCommand = OpaqueType('SndCommand', 'SndCmd')
+SndCommand_ptr = OpaqueType('SndCommand', 'SndCmd')
+SndListHandle = OpaqueByValueType("SndListHandle", "ResObj")
+
+class SndCallBackType(InputOnlyType):
+ def __init__(self):
+ Type.__init__(self, 'PyObject*', 'O')
+ def getargsCheck(self, name):
+ Output("if (%s != Py_None && !callable(%s))", name, name)
+ OutLbrace()
+ Output('PyErr_SetString(PyExc_TypeError, "callback must be callable");')
+ Output("goto %s__error__;", name)
+ OutRbrace()
+ def passInput(self, name):
+ return "(SndCallBackProcPtr)&SndCh_UserRoutine"
+ def cleanup(self, name):
+ # XXX This knows it is executing inside the SndNewChannel wrapper
+ Output("if (_res != NULL && %s != Py_None)", name)
+ OutLbrace()
+ Output("SndChannelObject *p = (SndChannelObject *)_res;")
+ Output("p->ob_itself->userInfo = (long)p;")
+ Output("Py_INCREF(%s);", name)
+ Output("p->ob_callback = %s;", name)
+ OutRbrace()
+ DedentLevel()
+ Output(" %s__error__: ;", name)
+ IndentLevel()
+
+SndCallBackProcPtr = SndCallBackType()
+
+SndCompletionProcPtr = FakeType('(SndCompletionProcPtr)0') # XXX
+
+NumVersion = OpaqueByValueType('NumVersion', 'NumVer')
+
+InOutBuf128 = FixedInputOutputBufferType(128)
+
+AudioSelectionPtr = FakeType('0') # XXX
+
+ProcPtr = FakeType('0') # XXX
+
+SCStatus = StructOutputBufferType('SCStatus')
+SMStatus = StructOutputBufferType('SMStatus')
+
+includestuff = includestuff + """
+#include <OSUtils.h> /* for Set(Current)A5 */
+
+/* Create a SndCommand object (an (int, int, int) tuple) */
+static PyObject *
+SndCmd_New(SndCommand *pc)
+{
+ return Py_BuildValue("hhl", pc->cmd, pc->param1, pc->param2);
+}
+
+/* Convert a SndCommand argument */
+static int
+SndCmd_Convert(PyObject *v, SndCommand *pc)
+{
+ int len;
+ pc->param1 = 0;
+ pc->param2 = 0;
+ if (PyTuple_Check(v)) {
+ if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
+ return 1;
+ PyErr_Clear();
+ return PyArg_ParseTuple(v, "hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
+ }
+ return PyArg_Parse(v, "h", &pc->cmd);
+}
+
+/* Create a NumVersion object (a quintuple of integers) */
+static PyObject *
+NumVer_New(NumVersion nv)
+{
+ return Py_BuildValue("iiiii",
+ nv.majorRev,
+#ifdef THINK_C
+ nv.minorRev,
+ nv.bugFixRev,
+#else
+ (nv.minorAndBugRev>>4) & 0xf,
+ nv.minorAndBugRev & 0xf,
+#endif
+ nv.stage,
+ nv.nonRelRev);
+}
+
+static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
+"""
+
+
+finalstuff = finalstuff + """
+/* Routine passed to Py_AddPendingCall -- call the Python callback */
+static int
+SndCh_CallCallBack(arg)
+ void *arg;
+{
+ SndChannelObject *p = (SndChannelObject *)arg;
+ PyObject *args;
+ PyObject *res;
+ args = Py_BuildValue("(O(hhl))",
+ p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
+ res = PyEval_CallObject(p->ob_callback, args);
+ Py_DECREF(args);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
+}
+
+/* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
+static pascal void
+SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
+{
+ SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
+ if (p->ob_callback != NULL) {
+ long A5 = SetA5(p->ob_A5);
+ p->ob_cmd = *cmd;
+ Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
+ SetA5(A5);
+ }
+}
+"""
+
+
+# create the module and object definition and link them
+
+class SndObjectDefinition(ObjectDefinition):
+
+ def outputStructMembers(self):
+ ObjectDefinition.outputStructMembers(self)
+ Output("/* Members used to implement callbacks: */")
+ Output("PyObject *ob_callback;")
+ Output("long ob_A5;");
+ Output("SndCommand ob_cmd;")
+
+ def outputInitStructMembers(self):
+ ObjectDefinition.outputInitStructMembers(self)
+ Output("it->ob_callback = NULL;")
+ Output("it->ob_A5 = SetCurrentA5();");
+
+ def outputCleanupStructMembers(self):
+ ObjectDefinition.outputCleanupStructMembers(self)
+ Output("Py_XDECREF(self->ob_callback);")
+
+ def outputFreeIt(self, itselfname):
+ Output("SndDisposeChannel(%s, 1);", itselfname)
+
+
+sndobject = SndObjectDefinition('SndChannel', 'SndCh', 'SndChannelPtr')
+module = MacModule('Snd', 'Snd', includestuff, finalstuff, initstuff)
+module.addobject(sndobject)
+
+
+# create lists of functions and object methods
+
+functions = []
+sndmethods = []
+
+
+# populate the lists
+
+execfile('sndgen.py')
+
+
+# add the functions and methods to the module and object, respectively
+
+for f in functions: module.add(f)
+for f in sndmethods: sndobject.add(f)
+
+
+# generate output
+
+SetOutputFileName('Sndmodule.c')
+module.generate()
diff --git a/Mac/Modules/win/Winmodule.c b/Mac/Modules/win/Winmodule.c
new file mode 100644
index 0000000..3f60d37
--- /dev/null
+++ b/Mac/Modules/win/Winmodule.c
@@ -0,0 +1,872 @@
+
+/* =========================== Module Win =========================== */
+
+#include "Python.h"
+
+
+
+#define SystemSevenOrLater 1
+
+#include "macglue.h"
+#include <Memory.h>
+#include <Dialogs.h>
+#include <Menus.h>
+#include <Controls.h>
+
+extern PyObject *ResObj_New(Handle);
+extern int ResObj_Convert(PyObject *, Handle *);
+
+extern PyObject *WinObj_New(WindowPtr);
+extern int WinObj_Convert(PyObject *, WindowPtr *);
+
+extern PyObject *DlgObj_New(DialogPtr);
+extern int DlgObj_Convert(PyObject *, DialogPtr *);
+extern PyTypeObject Dialog_Type;
+#define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
+
+extern PyObject *MenuObj_New(MenuHandle);
+extern int MenuObj_Convert(PyObject *, MenuHandle *);
+
+extern PyObject *CtlObj_New(ControlHandle);
+extern int CtlObj_Convert(PyObject *, ControlHandle *);
+
+extern PyObject *WinObj_WhichWindow(WindowPtr);
+
+#include <Windows.h>
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+#ifdef __MWERKS__
+#define WindowPeek WindowPtr
+#endif
+
+extern PyObject *WinObj_WhichWindow(WindowPtr w); /* Forward */
+
+static PyObject *Win_Error;
+
+/* ----------------------- Object type Window ----------------------- */
+
+PyTypeObject Window_Type;
+
+#define WinObj_Check(x) ((x)->ob_type == &Window_Type)
+
+typedef struct WindowObject {
+ PyObject_HEAD
+ WindowPtr ob_itself;
+} WindowObject;
+
+PyObject *WinObj_New(itself)
+ const WindowPtr itself;
+{
+ WindowObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(WindowObject, &Window_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ SetWRefCon(itself, (long)it);
+ return (PyObject *)it;
+}
+WinObj_Convert(v, p_itself)
+ PyObject *v;
+ WindowPtr *p_itself;
+{
+ if (DlgObj_Check(v)) {
+ *p_itself = ((WindowObject *)v)->ob_itself;
+ return 1;
+ }
+
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
+
+ if (!WinObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "Window required");
+ return 0;
+ }
+ *p_itself = ((WindowObject *)v)->ob_itself;
+ return 1;
+}
+
+static void WinObj_dealloc(self)
+ WindowObject *self;
+{
+ DisposeWindow(self->ob_itself);
+ PyMem_DEL(self);
+}
+
+static PyObject *WinObj_GetWTitle(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ GetWTitle(_self->ob_itself,
+ title);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildStr255, title);
+ return _res;
+}
+
+static PyObject *WinObj_SelectWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SelectWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_HideWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ HideWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ShowWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ShowWindow(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ShowHide(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean showFlag;
+ if (!PyArg_ParseTuple(_args, "b",
+ &showFlag))
+ return NULL;
+ ShowHide(_self->ob_itself,
+ showFlag);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_HiliteWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean fHilite;
+ if (!PyArg_ParseTuple(_args, "b",
+ &fHilite))
+ return NULL;
+ HiliteWindow(_self->ob_itself,
+ fHilite);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_BringToFront(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ BringToFront(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SendBehind(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr behindWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ WinObj_Convert, &behindWindow))
+ return NULL;
+ SendBehind(_self->ob_itself,
+ behindWindow);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_DrawGrowIcon(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ DrawGrowIcon(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_MoveWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short hGlobal;
+ short vGlobal;
+ Boolean front;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &hGlobal,
+ &vGlobal,
+ &front))
+ return NULL;
+ MoveWindow(_self->ob_itself,
+ hGlobal,
+ vGlobal,
+ front);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SizeWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short w;
+ short h;
+ Boolean fUpdate;
+ if (!PyArg_ParseTuple(_args, "hhb",
+ &w,
+ &h,
+ &fUpdate))
+ return NULL;
+ SizeWindow(_self->ob_itself,
+ w,
+ h,
+ fUpdate);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_ZoomWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short partCode;
+ Boolean front;
+ if (!PyArg_ParseTuple(_args, "hb",
+ &partCode,
+ &front))
+ return NULL;
+ ZoomWindow(_self->ob_itself,
+ partCode,
+ front);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_BeginUpdate(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ BeginUpdate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_EndUpdate(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ EndUpdate(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SetWRefCon(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long data;
+ if (!PyArg_ParseTuple(_args, "l",
+ &data))
+ return NULL;
+ SetWRefCon(_self->ob_itself,
+ data);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GetWRefCon(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWRefCon(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_ClipAbove(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ ClipAbove((WindowPeek)(_self->ob_itself));
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_SaveOld(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SaveOld((WindowPeek)(_self->ob_itself));
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_DrawNew(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean update;
+ if (!PyArg_ParseTuple(_args, "b",
+ &update))
+ return NULL;
+ DrawNew((WindowPeek)(_self->ob_itself),
+ update);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_CalcVis(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ CalcVis((WindowPeek)(_self->ob_itself));
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_GrowWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Point startPt;
+ Rect bBox;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &startPt,
+ PyMac_GetRect, &bBox))
+ return NULL;
+ _rv = GrowWindow(_self->ob_itself,
+ startPt,
+ &bBox);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_TrackBox(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point thePt;
+ short partCode;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetPoint, &thePt,
+ &partCode))
+ return NULL;
+ _rv = TrackBox(_self->ob_itself,
+ thePt,
+ partCode);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_GetWVariant(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetWVariant(_self->ob_itself);
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_SetWTitle(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Str255 title;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetStr255, title))
+ return NULL;
+ SetWTitle(_self->ob_itself,
+ title);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *WinObj_TrackGoAway(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Point thePt;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = TrackGoAway(_self->ob_itself,
+ thePt);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *WinObj_DragWindow(_self, _args)
+ WindowObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Point startPt;
+ Rect boundsRect;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetPoint, &startPt,
+ PyMac_GetRect, &boundsRect))
+ return NULL;
+ DragWindow(_self->ob_itself,
+ startPt,
+ &boundsRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyMethodDef WinObj_methods[] = {
+ {"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
+ "() -> (Str255 title)"},
+ {"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
+ "() -> None"},
+ {"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
+ "() -> None"},
+ {"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
+ "() -> None"},
+ {"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
+ "(Boolean showFlag) -> None"},
+ {"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
+ "(Boolean fHilite) -> None"},
+ {"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
+ "() -> None"},
+ {"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
+ "(WindowPtr behindWindow) -> None"},
+ {"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
+ "() -> None"},
+ {"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
+ "(short hGlobal, short vGlobal, Boolean front) -> None"},
+ {"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
+ "(short w, short h, Boolean fUpdate) -> None"},
+ {"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
+ "(short partCode, Boolean front) -> None"},
+ {"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
+ "() -> None"},
+ {"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
+ "() -> None"},
+ {"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
+ "(long data) -> None"},
+ {"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
+ "() -> (long _rv)"},
+ {"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
+ "() -> None"},
+ {"SaveOld", (PyCFunction)WinObj_SaveOld, 1,
+ "() -> None"},
+ {"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
+ "(Boolean update) -> None"},
+ {"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
+ "() -> None"},
+ {"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
+ "(Point startPt, Rect bBox) -> (long _rv)"},
+ {"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
+ "(Point thePt, short partCode) -> (Boolean _rv)"},
+ {"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
+ "() -> (short _rv)"},
+ {"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
+ "(Str255 title) -> None"},
+ {"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
+ "(Point thePt) -> (Boolean _rv)"},
+ {"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
+ "(Point startPt, Rect boundsRect) -> None"},
+ {NULL, NULL, 0}
+};
+
+PyMethodChain WinObj_chain = { WinObj_methods, NULL };
+
+static PyObject *WinObj_getattr(self, name)
+ WindowObject *self;
+ char *name;
+{
+ return Py_FindMethodInChain(&WinObj_chain, (PyObject *)self, name);
+}
+
+#define WinObj_setattr NULL
+
+PyTypeObject Window_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "Window", /*tp_name*/
+ sizeof(WindowObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) WinObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) WinObj_getattr, /*tp_getattr*/
+ (setattrfunc) WinObj_setattr, /*tp_setattr*/
+};
+
+/* --------------------- End object type Window --------------------- */
+
+
+static PyObject *Win_InitWindows(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ InitWindows();
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Win_NewWindow(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ short theProc;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ long refCon;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &theProc,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon))
+ return NULL;
+ _rv = NewWindow((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ theProc,
+ behind,
+ goAwayFlag,
+ refCon);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_GetNewWindow(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ short windowID;
+ WindowPtr behind;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &windowID,
+ WinObj_Convert, &behind))
+ return NULL;
+ _rv = GetNewWindow(windowID,
+ (void *)0,
+ behind);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_FrontWindow(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = FrontWindow();
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_InvalRect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Rect badRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &badRect))
+ return NULL;
+ InvalRect(&badRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Win_ValidRect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Rect goodRect;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetRect, &goodRect))
+ return NULL;
+ ValidRect(&goodRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Win_CheckUpdate(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord theEvent;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CheckUpdate(&theEvent);
+ _res = Py_BuildValue("bO&",
+ _rv,
+ PyMac_BuildEventRecord, &theEvent);
+ return _res;
+}
+
+static PyObject *Win_FindWindow(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ short _rv;
+ Point thePoint;
+ WindowPtr theWindow;
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetPoint, &thePoint))
+ return NULL;
+ _rv = FindWindow(thePoint,
+ &theWindow);
+ _res = Py_BuildValue("hO&",
+ _rv,
+ WinObj_WhichWindow, theWindow);
+ return _res;
+}
+
+static PyObject *Win_PinRect(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ long _rv;
+ Rect theRect;
+ Point thePt;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ PyMac_GetRect, &theRect,
+ PyMac_GetPoint, &thePt))
+ return NULL;
+ _rv = PinRect(&theRect,
+ thePt);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Win_NewCWindow(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ Rect boundsRect;
+ Str255 title;
+ Boolean visible;
+ short procID;
+ WindowPtr behind;
+ Boolean goAwayFlag;
+ long refCon;
+ if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
+ PyMac_GetRect, &boundsRect,
+ PyMac_GetStr255, title,
+ &visible,
+ &procID,
+ WinObj_Convert, &behind,
+ &goAwayFlag,
+ &refCon))
+ return NULL;
+ _rv = NewCWindow((void *)0,
+ &boundsRect,
+ title,
+ visible,
+ procID,
+ behind,
+ goAwayFlag,
+ refCon);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Win_GetNewCWindow(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ WindowPtr _rv;
+ short windowID;
+ WindowPtr behind;
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &windowID,
+ WinObj_Convert, &behind))
+ return NULL;
+ _rv = GetNewCWindow(windowID,
+ (void *)0,
+ behind);
+ _res = Py_BuildValue("O&",
+ WinObj_New, _rv);
+ return _res;
+}
+
+static PyMethodDef Win_methods[] = {
+ {"InitWindows", (PyCFunction)Win_InitWindows, 1,
+ "() -> None"},
+ {"NewWindow", (PyCFunction)Win_NewWindow, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
+ {"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
+ "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+ {"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
+ "() -> (WindowPtr _rv)"},
+ {"InvalRect", (PyCFunction)Win_InvalRect, 1,
+ "(Rect badRect) -> None"},
+ {"ValidRect", (PyCFunction)Win_ValidRect, 1,
+ "(Rect goodRect) -> None"},
+ {"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
+ "() -> (Boolean _rv, EventRecord theEvent)"},
+ {"FindWindow", (PyCFunction)Win_FindWindow, 1,
+ "(Point thePoint) -> (short _rv, WindowPtr theWindow)"},
+ {"PinRect", (PyCFunction)Win_PinRect, 1,
+ "(Rect theRect, Point thePt) -> (long _rv)"},
+ {"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
+ "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
+ {"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
+ "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
+ {NULL, NULL, 0}
+};
+
+
+
+/* Return the object corresponding to the window, or NULL */
+
+PyObject *
+WinObj_WhichWindow(w)
+ WindowPtr w;
+{
+ PyObject *it;
+
+ /* XXX What if we find a stdwin window or a window belonging
+ to some other package? */
+ it = (PyObject *) GetWRefCon(w);
+ if (it == NULL || ((WindowObject *)it)->ob_itself != w)
+ it = Py_None;
+ Py_INCREF(it);
+ return it;
+}
+
+
+void initWin()
+{
+ PyObject *m;
+ PyObject *d;
+
+
+
+
+ m = Py_InitModule("Win", Win_methods);
+ d = PyModule_GetDict(m);
+ Win_Error = PyMac_GetOSErrException();
+ if (Win_Error == NULL ||
+ PyDict_SetItemString(d, "Error", Win_Error) != 0)
+ Py_FatalError("can't initialize Win.Error");
+}
+
+/* ========================= End module Win ========================= */
+
diff --git a/Mac/Modules/win/wingen.py b/Mac/Modules/win/wingen.py
new file mode 100644
index 0000000..a8c0cc2
--- /dev/null
+++ b/Mac/Modules/win/wingen.py
@@ -0,0 +1,226 @@
+# Generated from 'D:Development:THINK C:Mac #includes:Apple #includes:Windows.h'
+
+f = Function(void, 'InitWindows',
+)
+functions.append(f)
+
+f = Function(WindowPtr, 'NewWindow',
+ (NullStorage, 'wStorage', InMode),
+ (Rect_ptr, 'boundsRect', InMode),
+ (ConstStr255Param, 'title', InMode),
+ (Boolean, 'visible', InMode),
+ (short, 'theProc', InMode),
+ (WindowPtr, 'behind', InMode),
+ (Boolean, 'goAwayFlag', InMode),
+ (long, 'refCon', InMode),
+)
+functions.append(f)
+
+f = Function(WindowPtr, 'GetNewWindow',
+ (short, 'windowID', InMode),
+ (NullStorage, 'wStorage', InMode),
+ (WindowPtr, 'behind', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'GetWTitle',
+ (WindowPtr, 'theWindow', InMode),
+ (Str255, 'title', OutMode),
+)
+methods.append(f)
+
+f = Method(void, 'SelectWindow',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'HideWindow',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'ShowWindow',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'ShowHide',
+ (WindowPtr, 'theWindow', InMode),
+ (Boolean, 'showFlag', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'HiliteWindow',
+ (WindowPtr, 'theWindow', InMode),
+ (Boolean, 'fHilite', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'BringToFront',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SendBehind',
+ (WindowPtr, 'theWindow', InMode),
+ (WindowPtr, 'behindWindow', InMode),
+)
+methods.append(f)
+
+f = Function(WindowPtr, 'FrontWindow',
+)
+functions.append(f)
+
+f = Method(void, 'DrawGrowIcon',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'MoveWindow',
+ (WindowPtr, 'theWindow', InMode),
+ (short, 'hGlobal', InMode),
+ (short, 'vGlobal', InMode),
+ (Boolean, 'front', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SizeWindow',
+ (WindowPtr, 'theWindow', InMode),
+ (short, 'w', InMode),
+ (short, 'h', InMode),
+ (Boolean, 'fUpdate', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'ZoomWindow',
+ (WindowPtr, 'theWindow', InMode),
+ (short, 'partCode', InMode),
+ (Boolean, 'front', InMode),
+)
+methods.append(f)
+
+f = Function(void, 'InvalRect',
+ (Rect_ptr, 'badRect', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'ValidRect',
+ (Rect_ptr, 'goodRect', InMode),
+)
+functions.append(f)
+
+f = Method(void, 'BeginUpdate',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'EndUpdate',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetWRefCon',
+ (WindowPtr, 'theWindow', InMode),
+ (long, 'data', InMode),
+)
+methods.append(f)
+
+f = Method(long, 'GetWRefCon',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Function(Boolean, 'CheckUpdate',
+ (EventRecord, 'theEvent', OutMode),
+)
+functions.append(f)
+
+f = Method(void, 'ClipAbove',
+ (WindowPeek, 'window', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SaveOld',
+ (WindowPeek, 'window', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'DrawNew',
+ (WindowPeek, 'window', InMode),
+ (Boolean, 'update', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'CalcVis',
+ (WindowPeek, 'window', InMode),
+)
+methods.append(f)
+
+f = Method(long, 'GrowWindow',
+ (WindowPtr, 'theWindow', InMode),
+ (Point, 'startPt', InMode),
+ (Rect_ptr, 'bBox', InMode),
+)
+methods.append(f)
+
+f = Function(short, 'FindWindow',
+ (Point, 'thePoint', InMode),
+ (ExistingWindowPtr, 'theWindow', OutMode),
+)
+functions.append(f)
+
+f = Function(long, 'PinRect',
+ (Rect_ptr, 'theRect', InMode),
+ (Point, 'thePt', InMode),
+)
+functions.append(f)
+
+f = Method(Boolean, 'TrackBox',
+ (WindowPtr, 'theWindow', InMode),
+ (Point, 'thePt', InMode),
+ (short, 'partCode', InMode),
+)
+methods.append(f)
+
+f = Function(WindowPtr, 'NewCWindow',
+ (NullStorage, 'wStorage', InMode),
+ (Rect_ptr, 'boundsRect', InMode),
+ (ConstStr255Param, 'title', InMode),
+ (Boolean, 'visible', InMode),
+ (short, 'procID', InMode),
+ (WindowPtr, 'behind', InMode),
+ (Boolean, 'goAwayFlag', InMode),
+ (long, 'refCon', InMode),
+)
+functions.append(f)
+
+f = Function(WindowPtr, 'GetNewCWindow',
+ (short, 'windowID', InMode),
+ (NullStorage, 'wStorage', InMode),
+ (WindowPtr, 'behind', InMode),
+)
+functions.append(f)
+
+f = Method(short, 'GetWVariant',
+ (WindowPtr, 'theWindow', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'SetWTitle',
+ (WindowPtr, 'theWindow', InMode),
+ (ConstStr255Param, 'title', InMode),
+)
+methods.append(f)
+
+f = Method(Boolean, 'TrackGoAway',
+ (WindowPtr, 'theWindow', InMode),
+ (Point, 'thePt', InMode),
+)
+methods.append(f)
+
+f = Method(void, 'DragWindow',
+ (WindowPtr, 'theWindow', InMode),
+ (Point, 'startPt', InMode),
+ (Rect_ptr, 'boundsRect', InMode),
+)
+methods.append(f)
diff --git a/Mac/Modules/win/winscan.py b/Mac/Modules/win/winscan.py
new file mode 100644
index 0000000..6ae03f4
--- /dev/null
+++ b/Mac/Modules/win/winscan.py
@@ -0,0 +1,68 @@
+# Scan an Apple header file, generating a Python file of generator calls.
+
+from scantools import Scanner
+
+def main():
+ input = "Windows.h"
+ output = "wingen.py"
+ defsoutput = "Windows.py"
+ scanner = MyScanner(input, output, defsoutput)
+ scanner.scan()
+ scanner.close()
+ print "=== Done scanning and generating, now importing the generated code... ==="
+ import winsupport
+ print "=== Done. It's up to you to compile it now! ==="
+
+class MyScanner(Scanner):
+
+ def destination(self, type, name, arglist):
+ classname = "Function"
+ listname = "functions"
+ if arglist:
+ t, n, m = arglist[0]
+ if t in ("WindowPtr", "WindowPeek") and m == "InMode":
+ classname = "Method"
+ listname = "methods"
+ return classname, listname
+
+ def makeblacklistnames(self):
+ return [
+ 'DisposeWindow', # Implied when the object is deleted
+ 'CloseWindow',
+ ]
+
+ def makeblacklisttypes(self):
+ return [
+ 'ProcPtr',
+ 'GrafPtr',
+ 'CGrafPtr',
+ 'RgnHandle',
+ 'PicHandle',
+ 'WCTabHandle',
+ 'AuxWinHandle',
+ 'PixPatHandle',
+ ]
+
+ def makerepairinstructions(self):
+ return [
+
+ # GetWTitle
+ ([("Str255", "*", "InMode")],
+ [("*", "*", "OutMode")]),
+
+ ([("void_ptr", "*", "InMode"), ("long", "*", "InMode")],
+ [("InBuffer", "*", "*")]),
+
+ ([("void", "*", "OutMode"), ("long", "*", "InMode"),
+ ("long", "*", "OutMode")],
+ [("VarVarOutBuffer", "*", "InOutMode")]),
+
+ ([("void", "wStorage", "OutMode")],
+ [("NullStorage", "*", "InMode")]),
+
+ ([("WindowPtr", "*", "OutMode")],
+ [("ExistingWindowPtr", "*", "*")]),
+ ]
+
+if __name__ == "__main__":
+ main()
diff --git a/Mac/Modules/win/winsupport.py b/Mac/Modules/win/winsupport.py
new file mode 100644
index 0000000..c1057e2
--- /dev/null
+++ b/Mac/Modules/win/winsupport.py
@@ -0,0 +1,103 @@
+# This script generates a Python interface for an Apple Macintosh Manager.
+# It uses the "bgen" package to generate C code.
+# The function specifications are generated by scanning the mamager's header file,
+# using the "scantools" package (customized for this particular manager).
+
+import string
+
+# Declarations that change for each manager
+MACHEADERFILE = 'Windows.h' # The Apple header file
+MODNAME = 'Win' # The name of the module
+OBJECTNAME = 'Window' # The basic name of the objects used here
+
+# The following is *usually* unchanged but may still require tuning
+MODPREFIX = MODNAME # The prefix for module-wide routines
+OBJECTTYPE = OBJECTNAME + 'Ptr' # The C type used to represent them
+OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods
+INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
+OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
+
+from macsupport import *
+
+# Create the type objects
+
+WindowPtr = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX)
+WindowPeek = OpaqueByValueType("WindowPeek", OBJECTPREFIX)
+WindowPeek.passInput = lambda name: "(WindowPeek)(%s)" % name
+
+#RgnHandle = FakeType("theWindow->updtRgn") # XXX
+
+includestuff = includestuff + """
+#include <%s>""" % MACHEADERFILE + """
+
+#define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
+
+#ifdef __MWERKS__
+#define WindowPeek WindowPtr
+#endif
+"""
+
+finalstuff = finalstuff + """
+/* Return the object corresponding to the window, or NULL */
+
+PyObject *
+WinObj_WhichWindow(w)
+ WindowPtr w;
+{
+ PyObject *it;
+
+ /* XXX What if we find a stdwin window or a window belonging
+ to some other package? */
+ if (w == NULL)
+ it = NULL;
+ else
+ it = (PyObject *) GetWRefCon(w);
+ if (it == NULL || ((WindowObject *)it)->ob_itself != w)
+ it = Py_None;
+ Py_INCREF(it);
+ return it;
+}
+"""
+
+class MyObjectDefinition(GlobalObjectDefinition):
+ def outputCheckNewArg(self):
+ Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+ def outputInitStructMembers(self):
+ GlobalObjectDefinition.outputInitStructMembers(self)
+ Output("SetWRefCon(itself, (long)it);")
+ def outputCheckConvertArg(self):
+ OutLbrace("if (DlgObj_Check(v))")
+ Output("*p_itself = ((WindowObject *)v)->ob_itself;")
+ Output("return 1;")
+ OutRbrace()
+ Out("""
+ if (v == Py_None) { *p_itself = NULL; return 1; }
+ if (PyInt_Check(v)) { *p_itself = (WindowPtr)PyInt_AsLong(v); return 1; }
+ """)
+ def outputFreeIt(self, itselfname):
+ Output("DisposeWindow(%s);", itselfname)
+
+# From here on it's basically all boiler plate...
+
+# Create the generator groups and link them
+module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
+object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE)
+module.addobject(object)
+
+# Create the generator classes used to populate the lists
+Function = OSErrFunctionGenerator
+Method = OSErrMethodGenerator
+
+# Create and populate the lists
+functions = []
+methods = []
+execfile(INPUTFILE)
+
+# add the populated lists to the generator groups
+# (in a different wordl the scan program would generate this)
+for f in functions: module.add(f)
+for f in methods: object.add(f)
+
+# generate output (open the output file as late as possible)
+SetOutputFileName(OUTPUTFILE)
+module.generate()