| import FrameWork |
| import MiniAEFrame |
| import EasyDialogs |
| import AE |
| import AppleEvents |
| import Res |
| import sys |
| import Qd |
| import Evt |
| import Events |
| import Dlg |
| import Win |
| import Menu |
| import TwitCore |
| import mactwit_mod |
| import mactwit_stack |
| import mactwit_browser |
| import mactwit_edit |
| import macfs |
| import string |
| |
| # Resource-id (for checking existence) |
| ID_MODULES=500 |
| |
| ID_ABOUT=502 |
| |
| _arrow = Qd.qd.arrow |
| _watch = Qd.GetCursor(4).data |
| |
| class Twit(FrameWork.Application, TwitCore.Application, MiniAEFrame.AEServer): |
| """The twit main class - mac-dependent part""" |
| |
| def __init__(self, sessiontype, arg=None): |
| # First init menus, etc. |
| self.app_menu_bar = Menu.GetMenuBar() |
| FrameWork.Application.__init__(self) |
| MiniAEFrame.AEServer.__init__(self) |
| AE.AESetInteractionAllowed(AppleEvents.kAEInteractWithAll) |
| self.installaehandler('aevt', 'odoc', self.ae_open_doc) |
| self.installaehandler('aevt', 'quit', self.do_quit) |
| self.installaehandler('pyth', 'EXEC', self.do_bbpyexec) # BBpy execute event |
| |
| self.dbg_menu_bar = Menu.GetMenuBar() |
| self.setstate(sessiontype) |
| self._quitting = 0 |
| self.real_quit = 0 |
| self.window_aware = 1 |
| |
| # Next create our dialogs |
| self.mi_init(sessiontype, arg) |
| while 1: |
| if self.real_quit: |
| break |
| if self.initial_cmd: |
| self.to_debugger() # Will get to mainloop via debugger |
| else: |
| self.one_mainloop() # Else do it ourselves. |
| |
| def switch_to_app(self): |
| if not self.window_aware: |
| return |
| self.dbg_menu_bar = Menu.GetMenuBar() |
| Menu.SetMenuBar(self.app_menu_bar) |
| Menu.DrawMenuBar() |
| |
| def switch_to_dbg(self): |
| if not self.window_aware: |
| return |
| self.app_menu_bar = Menu.GetMenuBar() |
| Menu.SetMenuBar(self.dbg_menu_bar) |
| Menu.DrawMenuBar() |
| self.run_dialog.force_redraw() |
| if self.module_dialog: |
| self.module_dialog.force_redraw() |
| |
| def makeusermenus(self): |
| self.filemenu = m = FrameWork.Menu(self.menubar, "Debug") |
| self._openitem = FrameWork.MenuItem(m, "Run File...", "O", self.do_open) |
| self._runitem = FrameWork.MenuItem(m, "Run String...", "R", self.do_run) |
| FrameWork.Separator(m) |
| self._awareitem = FrameWork.MenuItem(m, "Window-aware", "", self.do_aware) |
| self._awareitem.check(1) |
| FrameWork.Separator(m) |
| self._quititem = FrameWork.MenuItem(m, "Quit", "Q", self.do_quit) |
| |
| self.controlmenu = m = FrameWork.Menu(self.menubar, "Control") |
| self._stepitem = FrameWork.MenuItem(m, "Step Next", "N", self.do_step) |
| self._stepinitem = FrameWork.MenuItem(m, "Step In", "S", self.do_stepin) |
| self._stepoutitem = FrameWork.MenuItem(m, "Step Out", "U", self.do_stepout) |
| self._continueitem = FrameWork.MenuItem(m, "Continue", "G", self.do_continue) |
| FrameWork.Separator(m) |
| self._killitem = FrameWork.MenuItem(m, "Kill", "K", self.do_kill) |
| |
| def setstate(self, state): |
| self.state = state |
| if state == 'run': |
| self._stepitem.enable(1) |
| self._stepoutitem.enable(1) |
| self._stepinitem.enable(1) |
| self._continueitem.enable(1) |
| self._killitem.enable(1) |
| else: |
| self._stepitem.enable(0) |
| self._stepoutitem.enable(0) |
| self._stepinitem.enable(0) |
| self._continueitem.enable(0) |
| self._killitem.enable(0) |
| |
| def asknewsession(self): |
| if self.state == 'none': |
| return 1 |
| if EasyDialogs.AskYesNoCancel("Abort current debug session?") == 1: |
| self.quit_bdb() |
| return 1 |
| return 0 |
| |
| def do_about(self, id, item, window, event): |
| import time |
| d = Dlg.GetNewDialog(ID_ABOUT, -1) |
| if not d: |
| return |
| w = d.GetDialogWindow() |
| port = w.GetWindowPort() |
| l, t, r, b = port.portRect |
| sl, st, sr, sb = Qd.qd.screenBits.bounds |
| x = ((sr-sl) - (r-l)) / 2 |
| y = ((sb-st-16) - (b-t)) / 5 |
| w.MoveWindow(x, y, 0) |
| w.ShowWindow() |
| d.DrawDialog() |
| |
| tp, h, rect = d.GetDialogItem(2) |
| x0, y0, x1, y1 = rect |
| ybot = y0 + 32 |
| |
| rgn = Qd.NewRgn() |
| Qd.SetPort(d) |
| ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, 1) |
| if ok: return |
| (what, message, when, where, modifiers) = event |
| delta_t = 128 |
| nexttime = when+delta_t |
| while ybot < y1: |
| # Do the animation, if it is time |
| if when > nexttime: |
| Qd.ScrollRect((x0, y0, x1, ybot), 0, 1, rgn) |
| y0 = y0 + 1 |
| ybot = ybot + 1 |
| # And update next time |
| delta_t = int(delta_t*0.6)-1 |
| if delta_t < 0: |
| delta_t = 0 |
| nexttime = when + delta_t |
| # Check for an event. |
| ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, 0) |
| if ok: return |
| (what, message, when, where, modifiers) = evt |
| while 1: |
| ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, -1) |
| if ok: return |
| |
| def do_open(self, *args): |
| if not self.asknewsession(): |
| return |
| fss, ok = macfs.StandardGetFile('TEXT') |
| if not ok: return |
| self.runfile(fss.as_pathname()) |
| |
| def ae_open_doc(self, object=None, **args): |
| if not object: return |
| if self.state <> 'none': |
| if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0: |
| if not self.asknewsession(): |
| return |
| if type(object) == type([]): |
| object = object[0] |
| fss, changed = object.Resolve() |
| self.runfile(fss.as_pathname()) |
| |
| def do_bbpyexec(self, object=None, NAME=None, **args): |
| if type(object) <> type(''): |
| if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0: |
| EasyDialogs.Message('EXEC AppleEvent arg should be a string') |
| return |
| if self.state <> 'none': |
| if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0: |
| if not self.asknewsession(): |
| return |
| stuff = string.splitfields(object, '\r') |
| stuff = string.joinfields(stuff, '\n') |
| self.runstring(stuff) |
| |
| def do_run(self, *args): |
| if not self.asknewsession(): |
| return |
| self.run() |
| |
| def do_aware(self, *args): |
| self.window_aware = not self.window_aware |
| self._awareitem.check(self.window_aware) |
| |
| def do_quit(self, *args): |
| self._quit() # Signal FrameWork.Application to stop |
| self.real_quit = 1 |
| self.quit_bdb() # Tell debugger to quit. |
| |
| def do_step(self, *args): |
| self.run_dialog.click_step() |
| |
| def do_stepin(self, *args): |
| self.run_dialog.click_step_in() |
| |
| def do_stepout(self, *args): |
| self.run_dialog.click_step_out() |
| |
| def do_continue(self, *args): |
| self.run_dialog.click_continue() |
| |
| def do_kill(self, *args): |
| self.run_dialog.click_kill() |
| |
| def exit_mainloop(self): |
| self._quit() # Signal FrameWork.Application to stop |
| self.real_quit = 0 |
| |
| def one_mainloop(self): |
| self.quitting = 0 |
| self.mainloop() |
| |
| def SetCursor(self): |
| Qd.SetCursor(_arrow) |
| |
| def SetWatch(self): |
| Qd.SetCursor(_watch) |
| |
| def AskString(self, *args): |
| return apply(EasyDialogs.AskString, args) |
| |
| def Message(self, *args): |
| return apply(EasyDialogs.Message, args) |
| |
| def new_module_browser(self, parent): |
| return mactwit_mod.ModuleBrowser(parent) |
| |
| def new_stack_browser(self, parent): |
| return mactwit_stack.StackBrowser(parent) |
| |
| def new_var_browser(self, parent, var): |
| return mactwit_browser.VarBrowser(parent).open(var) |
| |
| def edit(self, file, line): |
| return mactwit_edit.edit(file, line) |
| |
| |
| def Initialize(): |
| try: |
| # if this doesn't raise an error, we are an applet containing the |
| # necessary resources or we have been initialized already |
| # so we don't have to bother opening the resource file |
| dummy = Res.GetResource('DLOG', ID_MODULES) |
| except Res.Error: |
| try: |
| Res.OpenResFile("Twit.rsrc") |
| except Res.Error, arg: |
| EasyDialogs.Message("Cannot open Twit.rsrc: "+arg[1]) |
| sys.exit(1) |
| |