diff --git a/Lib/plat-mac/argvemulator.py b/Lib/plat-mac/argvemulator.py
index 6103a8a20dc..2d66f1c748f 100644
--- a/Lib/plat-mac/argvemulator.py
+++ b/Lib/plat-mac/argvemulator.py
@@ -7,6 +7,7 @@ import traceback
 from Carbon import AE
 from Carbon.AppleEvents import *
 from Carbon import Evt
+from Carbon import File
 from Carbon.Events import *
 import aetools
 
@@ -16,36 +17,36 @@ class ArgvCollector:
 
     def __init__(self):
         self.quitting = 0
-        self.ae_handlers = {}
         # Remove the funny -psn_xxx_xxx argument
         if len(sys.argv) > 1 and sys.argv[1][:4] == '-psn':
             del sys.argv[1]
-        self.installaehandler('aevt', 'oapp', self.open_app)
-        self.installaehandler('aevt', 'odoc', self.open_file)
 
-    def installaehandler(self, classe, type, callback):
-        AE.AEInstallEventHandler(classe, type, self.callback_wrapper)
-        self.ae_handlers[(classe, type)] = callback
+        AE.AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, self.__runapp)
+        AE.AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, self.__openfiles)
 
     def close(self):
-        for classe, type in self.ae_handlers.keys():
-            AE.AERemoveEventHandler(classe, type)
+        AE.AERemoveEventHandler(kCoreEventClass, kAEOpenApplication)
+        AE.AERemoveEventHandler(kCoreEventClass, kAEOpenDocuments)
 
     def mainloop(self, mask = highLevelEventMask, timeout = 1*60):
+        # Note: this is not the right way to run an event loop in OSX or even
+        # "recent" versions of MacOS9. This is however code that has proven
+        # itself.
         stoptime = Evt.TickCount() + timeout
         while not self.quitting and Evt.TickCount() < stoptime:
-            self.dooneevent(mask, timeout)
+            self._dooneevent(mask, timeout)
+
+        if not self.quitting:
+            print "argvemulator: timeout waiting for arguments"
+
         self.close()
 
-    def _quit(self):
-        self.quitting = 1
-
-    def dooneevent(self, mask = highLevelEventMask, timeout = 1*60):
+    def _dooneevent(self, mask = highLevelEventMask, timeout = 1*60):
         got, event = Evt.WaitNextEvent(mask, timeout)
         if got:
-            self.lowlevelhandler(event)
+            self._lowlevelhandler(event)
 
-    def lowlevelhandler(self, event):
+    def _lowlevelhandler(self, event):
         what, message, when, where, modifiers = event
         h, v = where
         if what == kHighLevelEvent:
@@ -60,53 +61,28 @@ class ArgvCollector:
         else:
             print "Unhandled event:", event
 
-    def callback_wrapper(self, _request, _reply):
-        _parameters, _attributes = aetools.unpackevent(_request)
-        _class = _attributes['evcl'].type
-        _type = _attributes['evid'].type
 
-        if self.ae_handlers.has_key((_class, _type)):
-            _function = self.ae_handlers[(_class, _type)]
-        elif self.ae_handlers.has_key((_class, '****')):
-            _function = self.ae_handlers[(_class, '****')]
-        elif self.ae_handlers.has_key(('****', '****')):
-            _function = self.ae_handlers[('****', '****')]
-        else:
-            raise 'Cannot happen: AE callback without handler', (_class, _type)
+    def _quit(self):
+        self.quitting = 1
 
-        # XXXX Do key-to-name mapping here
-
-        _parameters['_attributes'] = _attributes
-        _parameters['_class'] = _class
-        _parameters['_type'] = _type
-        if _parameters.has_key('----'):
-            _object = _parameters['----']
-            del _parameters['----']
-            # The try/except that used to be here can mask programmer errors.
-            # Let the program crash, the programmer can always add a **args
-            # to the formal parameter list.
-            rv = _function(_object, **_parameters)
-        else:
-            #Same try/except comment as above
-            rv = _function(**_parameters)
-
-        if rv == None:
-            aetools.packevent(_reply, {})
-        else:
-            aetools.packevent(_reply, {'----':rv})
-
-    def open_app(self, **args):
+    def __runapp(self, requestevent, replyevent):
         self._quit()
 
-    def open_file(self, _object=None, **args):
-        for alias in _object:
-            fsr = alias.FSResolveAlias(None)[0]
-            pathname = fsr.as_pathname()
-            sys.argv.append(pathname)
-        self._quit()
+    def __openfiles(self, requestevent, replyevent):
+        try:
+            listdesc = requestevent.AEGetParamDesc(keyDirectObject, typeAEList)
+            for i in range(listdesc.AECountItems()):
+                aliasdesc = listdesc.AEGetNthDesc(i+1, typeAlias)[1]
+                alias = File.Alias(rawdata=aliasdesc.data)
+                fsref = alias.FSResolveAlias(None)[0]
+                pathname = fsref.as_pathname()
+                sys.argv.append(pathname)
+        except  Exception, e:
+            print "argvemulator.py warning: can't unpack an open document event"
+            import traceback
+            traceback.print_exc()
 
-    def other(self, _object=None, _class=None, _type=None, **args):
-        print 'Ignore AppleEvent', (_class, _type), 'for', _object, 'Other args:', args
+        self._quit()
 
 if __name__ == '__main__':
     ArgvCollector().mainloop()
diff --git a/Mac/scripts/BuildApplet.py b/Mac/scripts/BuildApplet.py
index 756218f1ff3..ae5e3a3270d 100644
--- a/Mac/scripts/BuildApplet.py
+++ b/Mac/scripts/BuildApplet.py
@@ -16,6 +16,18 @@ import EasyDialogs
 import buildtools
 import getopt
 
+if not sys.executable.startswith(sys.exec_prefix):
+    # Oh, the joys of using a python script to bootstrap applicatin bundles
+    # sys.executable points inside the current application bundle. Because this
+    # path contains blanks (two of them actually) this path isn't usable on
+    # #! lines. Reset sys.executable to point to the embedded python interpreter
+    sys.executable = os.path.join(sys.prefix, 
+            'Resources/Python.app/Contents/MacOS/Python')
+
+    # Just in case we're not in a framework:
+    if not os.path.exists(sys.executable):
+        sys.executable = os.path.join(sys.exec_prefix,  'bin/python')
+
 def main():
     try:
         buildapplet()