First Checked In.
diff --git a/Mac/Tools/IDE/Wapplication.py b/Mac/Tools/IDE/Wapplication.py
new file mode 100644
index 0000000..8db9a1a
--- /dev/null
+++ b/Mac/Tools/IDE/Wapplication.py
@@ -0,0 +1,411 @@
+import FrameWork
+import Win
+import Qd
+import Evt
+import MacOS
+import Events
+import traceback
+from types import *
+
+import Menu; MenuToolbox = Menu; del Menu
+
+
+class Application(FrameWork.Application):
+
+ def __init__(self, signature='Pyth'):
+ import W
+ W.setapplication(self, signature)
+ FrameWork.Application.__init__(self)
+ self._suspended = 0
+ self.quitting = 0
+ self.debugger_quitting = 1
+ self.DebuggerQuit = 'DebuggerQuitDummyException'
+ self._idlefuncs = []
+ # map certain F key codes to equivalent command-letter combos (JJS)
+ self.fkeymaps = {122:"z", 120:"x", 99:"c", 118:"v"}
+
+ def mainloop(self, mask=FrameWork.everyEvent, wait=0):
+ import W
+ self.quitting = 0
+ saveyield = MacOS.EnableAppswitch(-1)
+ try:
+ while not self.quitting:
+ try:
+ self.do1event(mask, wait)
+ except W.AlertError, detail:
+ MacOS.EnableAppswitch(-1)
+ W.Message(detail)
+ except self.DebuggerQuit:
+ MacOS.EnableAppswitch(-1)
+ except:
+ MacOS.EnableAppswitch(-1)
+ import PyEdit
+ PyEdit.tracebackwindow.traceback()
+ finally:
+ MacOS.EnableAppswitch(1)
+
+ def debugger_mainloop(self, mask=FrameWork.everyEvent, wait=0):
+ import W
+ self.debugger_quitting = 0
+ saveyield = MacOS.EnableAppswitch(-1)
+ try:
+ while not self.quitting and not self.debugger_quitting:
+ try:
+ self.do1event(mask, wait)
+ except W.AlertError, detail:
+ W.Message(detail)
+ except:
+ import PyEdit
+ PyEdit.tracebackwindow.traceback()
+ finally:
+ MacOS.EnableAppswitch(saveyield)
+
+ def breathe(self, wait=1):
+ import W
+ ok, event = Evt.WaitNextEvent(FrameWork.updateMask |
+ FrameWork.mDownMask | FrameWork.osMask |
+ FrameWork.activMask,
+ wait)
+ if ok:
+ (what, message, when, where, modifiers) = event
+ #print FrameWork.eventname[what]
+ if FrameWork.eventname[what] == 'mouseDown':
+ partcode, wid = Win.FindWindow(where)
+ if FrameWork.partname[partcode] <> 'inDesk':
+ return
+ else:
+ W.SetCursor('watch')
+ self.dispatch(event)
+
+ def refreshwindows(self, wait=1):
+ import W
+ while 1:
+ ok, event = Evt.WaitNextEvent(FrameWork.updateMask, wait)
+ if not ok:
+ break
+ self.dispatch(event)
+
+ def addidlefunc(self, func):
+ self._idlefuncs.append(func)
+
+ def removeidlefunc(self, func):
+ self._idlefuncs.remove(func)
+
+ def idle(self, event):
+ if not self._suspended:
+ if not self.do_frontWindowMethod("idle", event):
+ Qd.InitCursor()
+ if self._idlefuncs:
+ for func in self._idlefuncs:
+ try:
+ func()
+ except:
+ import sys
+ sys.stderr.write("exception in idle function %s; killed:\n" % `func`)
+ traceback.print_exc()
+ self._idlefuncs.remove(func)
+ break
+
+ def do_frontWindowMethod(self, attr, *args):
+ wid = Win.FrontWindow()
+ if wid and self._windows.has_key(wid):
+ window = self._windows[wid]
+ if hasattr(window, attr):
+ handler = getattr(window, attr)
+ apply(handler, args)
+ return 1
+
+ def appendwindow(self, wid, window):
+ self._windows[wid] = window
+ self.makeopenwindowsmenu()
+
+ def removewindow(self, wid):
+ del self._windows[wid]
+ self.makeopenwindowsmenu()
+
+ def do_key(self, event):
+ (what, message, when, where, modifiers) = event
+ ch = chr(message & FrameWork.charCodeMask)
+ rest = message & ~FrameWork.charCodeMask
+ keycode = (message & FrameWork.keyCodeMask) >> 8
+ if keycode in self.fkeymaps.keys(): # JJS
+ ch = self.fkeymaps[keycode]
+ modifiers = modifiers | FrameWork.cmdKey
+ wid = Win.FrontWindow()
+ if modifiers & FrameWork.cmdKey and not modifiers & FrameWork.shiftKey:
+ if wid and self._windows.has_key(wid):
+ self.checkmenus(self._windows[wid])
+ else:
+ self.checkmenus(None)
+ event = (what, ord(ch) | rest, when, where, modifiers)
+ result = MenuToolbox.MenuKey(ord(ch))
+ id = (result>>16) & 0xffff # Hi word
+ item = result & 0xffff # Lo word
+ if id:
+ self.do_rawmenu(id, item, None, event)
+ return # here! we had a menukey!
+ #else:
+ # print "XXX Command-" +`ch`
+ # See whether the front window wants it
+ if wid and self._windows.has_key(wid):
+ window = self._windows[wid]
+ try:
+ do_char = window.do_char
+ except AttributeError:
+ do_char = self.do_char
+ do_char(ch, event)
+ # else it wasn't for us, sigh...
+
+ def do_inMenuBar(self, partcode, window, event):
+ Qd.InitCursor()
+ (what, message, when, where, modifiers) = event
+ self.checkopenwindowsmenu()
+ wid = Win.FrontWindow()
+ if wid and self._windows.has_key(wid):
+ self.checkmenus(self._windows[wid])
+ else:
+ self.checkmenus(None)
+ result = MenuToolbox.MenuSelect(where)
+ id = (result>>16) & 0xffff # Hi word
+ item = result & 0xffff # Lo word
+ self.do_rawmenu(id, item, window, event)
+
+ def do_updateEvt(self, event):
+ (what, message, when, where, modifiers) = event
+ wid = Win.WhichWindow(message)
+ if wid and self._windows.has_key(wid):
+ window = self._windows[wid]
+ window.do_rawupdate(wid, event)
+ else:
+ if wid:
+ wid.HideWindow()
+ import sys
+ sys.stderr.write("XXX killed unknown (crashed?) Python window.\n")
+ else:
+ MacOS.HandleEvent(event)
+
+ def suspendresume(self, onoff):
+ pass
+
+ def do_suspendresume(self, event):
+ self._suspended = not event[1] & 1
+ FrameWork.Application.do_suspendresume(self, event)
+
+ def checkopenwindowsmenu(self):
+ if self._openwindowscheckmark:
+ self.openwindowsmenu.menu.CheckItem(self._openwindowscheckmark, 0)
+ window = Win.FrontWindow()
+ if window:
+ for item, wid in self._openwindows.items():
+ if wid == window:
+ #self.pythonwindowsmenuitem.check(1)
+ self.openwindowsmenu.menu.CheckItem(item, 1)
+ self._openwindowscheckmark = item
+ break
+ else:
+ self._openwindowscheckmark = 0
+ #if self._openwindows:
+ # self.pythonwindowsmenuitem.enable(1)
+ #else:
+ # self.pythonwindowsmenuitem.enable(0)
+
+ def checkmenus(self, window):
+ for item in self._menustocheck:
+ callback = item.menu.items[item.item-1][2]
+ if type(callback) <> StringType:
+ item.enable(1)
+ elif hasattr(window, "domenu_" + callback):
+ if hasattr(window, "can_" + callback):
+ canhandler = getattr(window, "can_" + callback)
+ if canhandler(item):
+ item.enable(1)
+ else:
+ item.enable(0)
+ else:
+ item.enable(1)
+ else:
+ item.enable(0)
+
+ def enablemenubar(self, onoff):
+ for m in self.menubar.menus.values():
+ if onoff:
+ m.menu.EnableItem(0)
+ else:
+ m.menu.DisableItem(0)
+ MenuToolbox.DrawMenuBar()
+
+ def makemenubar(self):
+ self.menubar = MenuBar(self)
+ FrameWork.AppleMenu(self.menubar, self.getabouttext(), self.do_about)
+ self.makeusermenus()
+
+ def scriptswalk(self, top, menu):
+ import os, macfs, string
+ try:
+ names = os.listdir(top)
+ except os.error:
+ FrameWork.MenuItem(menu, '(Scripts Folder not found)', None, None)
+ return
+ savedir = os.getcwd()
+ os.chdir(top)
+ for name in names:
+ fss, isdir, isalias = macfs.ResolveAliasFile(name)
+ path = fss.as_pathname()
+ name = string.strip(name)
+ if name[-3:] == '---':
+ menu.addseparator()
+ elif isdir:
+ submenu = FrameWork.SubMenu(menu, name)
+ self.scriptswalk(path, submenu)
+ else:
+ creator, type = fss.GetCreatorType()
+ if type == 'TEXT':
+ if name[-3:] == '.py':
+ name = name[:-3]
+ item = FrameWork.MenuItem(menu, name, None, self.domenu_script)
+ self._scripts[(menu.id, item.item)] = path
+ os.chdir(savedir)
+
+ def domenu_script(self, id, item, window, event):
+ (what, message, when, where, modifiers) = event
+ path = self._scripts[(id, item)]
+ import os
+ if not os.path.exists(path):
+ self.makescriptsmenu()
+ import W
+ raise W.AlertError, "File not found."
+ if ord(Evt.GetKeys()[7]) & 4:
+ self.openscript(path)
+ else:
+ import W, MacOS, sys
+ W.SetCursor("watch")
+ sys.argv = [path]
+ #cwd = os.getcwd()
+ #os.chdir(os.path.dirname(path) + ':')
+ try:
+ # xxx if there is a script window for this file,
+ # exec in that window's namespace.
+ # xxx what to do when it's not saved???
+ # promt to save?
+ MacOS.EnableAppswitch(0)
+ execfile(path, {'__name__': '__main__', '__file__': path})
+ except W.AlertError, detail:
+ MacOS.EnableAppswitch(-1)
+ raise W.AlertError, detail
+ except KeyboardInterrupt:
+ MacOS.EnableAppswitch(-1)
+ except:
+ MacOS.EnableAppswitch(-1)
+ import PyEdit
+ PyEdit.tracebackwindow.traceback(1)
+ else:
+ MacOS.EnableAppswitch(-1)
+ #os.chdir(cwd)
+
+ def openscript(self, filename, lineno=None, charoffset=0, modname=""):
+ import os, PyEdit, W
+ editor = self.getscript(filename)
+ if editor:
+ editor.select()
+ elif os.path.exists(filename):
+ editor = PyEdit.Editor(filename)
+ elif filename[-3:] == '.py' or filename[-4:] == '.pyc':
+ import imp
+ if not modname:
+ if filename[-1] == 'c':
+ modname = os.path.basename(filename)[:-4]
+ else:
+ modname = os.path.basename(filename)[:-3]
+ try:
+ # XXX This does not work correctly with packages!
+ # XXX The docs say we should do it manually, pack, then sub, then sub2 etc.
+ # XXX It says we should use imp.load_module(), but that *reloads* a package,
+ # XXX and that's the last thing we want here.
+ f, filename, (suff, mode, dummy) = imp.find_module(modname)
+ except ImportError:
+ raise W.AlertError, "CanÕt find file for Ò%sÓ" % modname
+ else:
+ if not f:
+ raise W.AlertError, "CanÕt find file for Ò%sÓ" % modname
+ f.close()
+ if suff == '.py':
+ self.openscript(filename, lineno, charoffset)
+ return
+ else:
+ raise W.AlertError, "CanÕt find file for Ò%sÓ" % modname
+ else:
+ raise W.AlertError, "CanÕt find file Ô%sÕ" % filename
+ if lineno is not None:
+ editor.selectline(lineno, charoffset)
+ return editor
+
+ def getscript(self, filename):
+ if filename[:1] == '<' and filename[-1:] == '>':
+ filename = filename[1:-1]
+ import string
+ lowpath = string.lower(filename)
+ for wid, window in self._windows.items():
+ if hasattr(window, "path") and lowpath == string.lower(window.path):
+ return window
+ elif hasattr(window, "path") and filename == wid.GetWTitle():
+ return window
+
+ def getprefs(self):
+ import MacPrefs
+ return MacPrefs.GetPrefs(self.preffilepath)
+
+ def do_editorprefs(self, *args):
+ import PyEdit
+ PyEdit.EditorDefaultSettings()
+
+
+
+class MenuBar(FrameWork.MenuBar):
+
+ possibleIDs = range(10, 256)
+
+ def getnextid(self):
+ id = self.possibleIDs[0]
+ del self.possibleIDs[0]
+ return id
+
+ def __init__(self, parent = None):
+ self.bar = MenuToolbox.GetMenuBar()
+ MenuToolbox.ClearMenuBar()
+ self.menus = {}
+ self.parent = parent
+
+ def dispatch(self, id, item, window, event):
+ if self.menus.has_key(id):
+ self.menus[id].dispatch(id, item, window, event)
+
+ def delmenu(self, id):
+ MenuToolbox.DeleteMenu(id)
+ if id in self.possibleIDs:
+ print "XXX duplicate menu ID!", id
+ self.possibleIDs.append(id)
+
+
+class Menu(FrameWork.Menu):
+
+ def dispatch(self, id, item, window, event):
+ title, shortcut, callback, kind = self.items[item-1]
+ if type(callback) == StringType:
+ callback = self._getmenuhandler(callback)
+ if callback:
+ import W
+ W.CallbackCall(callback, 0, id, item, window, event)
+
+ def _getmenuhandler(self, callback):
+ menuhandler = None
+ wid = Win.FrontWindow()
+ if wid and self.bar.parent._windows.has_key(wid):
+ window = self.bar.parent._windows[wid]
+ if hasattr(window, "domenu_" + callback):
+ menuhandler = getattr(window, "domenu_" + callback)
+ elif hasattr(self.bar.parent, "domenu_" + callback):
+ menuhandler = getattr(self.bar.parent, "domenu_" + callback)
+ elif hasattr(self.bar.parent, "domenu_" + callback):
+ menuhandler = getattr(self.bar.parent, "domenu_" + callback)
+ return menuhandler
+