Mac/Unsupported/twit/mactwit_app.py

   1 import FrameWork
   2 import MiniAEFrame
   3 import EasyDialogs
   4 import AE
   5 import AppleEvents
   6 import Res
   7 import sys
   8 import Qd
   9 import Evt
  10 import Events
  11 import Dlg
  12 import Win
  13 import Menu
  14 import TwitCore
  15 import mactwit_mod
  16 import mactwit_stack
  17 import mactwit_browser
  18 import mactwit_edit
  19 import macfs
  20 import string
  21
  22 # Resource-id (for checking existence)
  23 ID_MODULES=500
  24
  25 ID_ABOUT=502
  26
  27 _arrow = Qd.qd.arrow
  28 _watch = Qd.GetCursor(4).data
  29
  30 class Twit(FrameWork.Application, TwitCore.Application, MiniAEFrame.AEServer):
  31         """The twit main class - mac-dependent part"""
  32
  33         def __init__(self, sessiontype, arg=None):
  34                 # First init menus, etc.
  35                 self.app_menu_bar = Menu.GetMenuBar()
  36                 FrameWork.Application.__init__(self)
  37                 MiniAEFrame.AEServer.__init__(self)
  38                 AE.AESetInteractionAllowed(AppleEvents.kAEInteractWithAll)
  39                 self.installaehandler('aevt', 'odoc', self.ae_open_doc)
  40                 self.installaehandler('aevt', 'quit', self.do_quit)
  41                 self.installaehandler('pyth', 'EXEC', self.do_bbpyexec) # BBpy execute event
  42
  43                 self.dbg_menu_bar = Menu.GetMenuBar()
  44                 self.setstate(sessiontype)
  45                 self._quitting = 0
  46                 self.real_quit = 0
  47                 self.window_aware = 1
  48
  49                 # Next create our dialogs
  50                 self.mi_init(sessiontype, arg)
  51                 while 1:
  52                         if self.real_quit:
  53                                 break
  54                         if self.initial_cmd:
  55                                 self.to_debugger()      # Will get to mainloop via debugger
  56                         else:
  57                                 self.one_mainloop()     # Else do it ourselves.
  58
  59         def switch_to_app(self):
  60                 if not self.window_aware:
  61                         return
  62                 self.dbg_menu_bar = Menu.GetMenuBar()
  63                 Menu.SetMenuBar(self.app_menu_bar)
  64                 Menu.DrawMenuBar()
  65
  66         def switch_to_dbg(self):
  67                 if not self.window_aware:
  68                         return
  69                 self.app_menu_bar = Menu.GetMenuBar()
  70                 Menu.SetMenuBar(self.dbg_menu_bar)
  71                 Menu.DrawMenuBar()
  72                 self.run_dialog.force_redraw()
  73                 if self.module_dialog:
  74                         self.module_dialog.force_redraw()
  75
  76         def makeusermenus(self):
  77                 self.filemenu = m = FrameWork.Menu(self.menubar, "Debug")
  78                 self._openitem = FrameWork.MenuItem(m, "Run File...", "O", self.do_open)
  79                 self._runitem = FrameWork.MenuItem(m, "Run String...", "R", self.do_run)
  80                 FrameWork.Separator(m)
  81                 self._awareitem = FrameWork.MenuItem(m, "Window-aware", "", self.do_aware)
  82                 self._awareitem.check(1)
  83                 FrameWork.Separator(m)
  84                 self._quititem = FrameWork.MenuItem(m, "Quit", "Q", self.do_quit)
  85
  86                 self.controlmenu = m = FrameWork.Menu(self.menubar, "Control")
  87                 self._stepitem = FrameWork.MenuItem(m, "Step Next", "N", self.do_step)
  88                 self._stepinitem = FrameWork.MenuItem(m, "Step In", "S", self.do_stepin)
  89                 self._stepoutitem = FrameWork.MenuItem(m, "Step Out", "U", self.do_stepout)
  90                 self._continueitem = FrameWork.MenuItem(m, "Continue", "G", self.do_continue)
  91                 FrameWork.Separator(m)
  92                 self._killitem = FrameWork.MenuItem(m, "Kill", "K", self.do_kill)
  93
  94         def setstate(self, state):
  95                 self.state = state
  96                 if state == 'run':
  97                         self._stepitem.enable(1)
  98                         self._stepoutitem.enable(1)
  99                         self._stepinitem.enable(1)
 100                         self._continueitem.enable(1)
 101                         self._killitem.enable(1)
 102                 else:
 103                         self._stepitem.enable(0)
 104                         self._stepoutitem.enable(0)
 105                         self._stepinitem.enable(0)
 106                         self._continueitem.enable(0)
 107                         self._killitem.enable(0)
 108
 109         def asknewsession(self):
 110                 if self.state == 'none':
 111                         return 1
 112                 if EasyDialogs.AskYesNoCancel("Abort current debug session?") == 1:
 113                         self.quit_bdb()
 114                         return 1
 115                 return 0
 116
 117         def do_about(self, id, item, window, event):
 118                 import time
 119                 d = Dlg.GetNewDialog(ID_ABOUT, -1)
 120                 if not d:
 121                         return
 122                 w = d.GetDialogWindow()
 123                 port = w.GetWindowPort()
 124                 l, t, r, b = port.portRect
 125                 sl, st, sr, sb = Qd.qd.screenBits.bounds
 126                 x = ((sr-sl) - (r-l)) / 2
 127                 y = ((sb-st-16) - (b-t)) / 5
 128                 w.MoveWindow(x, y, 0)
 129                 w.ShowWindow()
 130                 d.DrawDialog()
 131
 132                 tp, h, rect = d.GetDialogItem(2)
 133                 x0, y0, x1, y1 = rect
 134                 ybot = y0 + 32
 135
 136                 rgn = Qd.NewRgn()
 137                 Qd.SetPort(d)
 138                 ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, 1)
 139                 if ok: return
 140                 (what, message, when, where, modifiers) = event
 141                 delta_t = 128
 142                 nexttime = when+delta_t
 143                 while ybot < y1:
 144                         # Do the animation, if it is time
 145                         if when > nexttime:
 146                                 Qd.ScrollRect((x0, y0, x1, ybot), 0, 1, rgn)
 147                                 y0 = y0 + 1
 148                                 ybot = ybot + 1
 149                                 # And update next time
 150                                 delta_t = int(delta_t*0.6)-1
 151                                 if delta_t < 0:
 152                                         delta_t = 0
 153                                 nexttime = when + delta_t
 154                         # Check for an event.
 155                         ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, 0)
 156                         if ok: return
 157                         (what, message, when, where, modifiers) = evt
 158                 while 1:
 159                         ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, -1)
 160                         if ok: return
 161
 162         def do_open(self, *args):
 163                 if not self.asknewsession():
 164                         return
 165                 fss, ok = macfs.StandardGetFile('TEXT')
 166                 if not ok: return
 167                 self.runfile(fss.as_pathname())
 168
 169         def ae_open_doc(self, object=None, **args):
 170                 if not object: return
 171                 if self.state <> 'none':
 172                         if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0:
 173                                 if not self.asknewsession():
 174                                         return
 175                 if type(object) == type([]):
 176                         object = object[0]
 177                 fss, changed = object.Resolve()
 178                 self.runfile(fss.as_pathname())
 179
 180         def do_bbpyexec(self, object=None, NAME=None, **args):
 181                 if type(object) <> type(''):
 182                         if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0:
 183                                 EasyDialogs.Message('EXEC AppleEvent arg should be a string')
 184                         return
 185                 if self.state <> 'none':
 186                         if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0:
 187                                 if not self.asknewsession():
 188                                         return
 189                 stuff = string.splitfields(object, '\r')
 190                 stuff = string.joinfields(stuff, '\n')
 191                 self.runstring(stuff)
 192
 193         def do_run(self, *args):
 194                 if not self.asknewsession():
 195                         return
 196                 self.run()
 197
 198         def do_aware(self, *args):
 199                 self.window_aware = not self.window_aware
 200                 self._awareitem.check(self.window_aware)
 201
 202         def do_quit(self, *args):
 203                 self._quit()                    # Signal FrameWork.Application to stop
 204                 self.real_quit = 1
 205                 self.quit_bdb()                 # Tell debugger to quit.
 206
 207         def do_step(self, *args):
 208                 self.run_dialog.click_step()
 209
 210         def do_stepin(self, *args):
 211                 self.run_dialog.click_step_in()
 212
 213         def do_stepout(self, *args):
 214                 self.run_dialog.click_step_out()
 215
 216         def do_continue(self, *args):
 217                 self.run_dialog.click_continue()
 218
 219         def do_kill(self, *args):
 220                 self.run_dialog.click_kill()
 221
 222         def exit_mainloop(self):
 223                 self._quit()                    # Signal FrameWork.Application to stop
 224                 self.real_quit = 0
 225
 226         def one_mainloop(self):
 227                 self.quitting = 0
 228                 self.mainloop()
 229
 230         def SetCursor(self):
 231                 Qd.SetCursor(_arrow)
 232
 233         def SetWatch(self):
 234                 Qd.SetCursor(_watch)
 235
 236         def AskString(self, *args):
 237                 return apply(EasyDialogs.AskString, args)
 238
 239         def Message(self, *args):
 240                 return apply(EasyDialogs.Message, args)
 241
 242         def new_module_browser(self, parent):
 243                 return mactwit_mod.ModuleBrowser(parent)
 244
 245         def new_stack_browser(self, parent):
 246                 return mactwit_stack.StackBrowser(parent)
 247
 248         def new_var_browser(self, parent, var):
 249                 return mactwit_browser.VarBrowser(parent).open(var)
 250
 251         def edit(self, file, line):
 252                 return mactwit_edit.edit(file, line)
 253
 254
 255 def Initialize():
 256         try:
 257                 # if this doesn't raise an error, we are an applet containing the
 258                 # necessary resources or we have been initialized already
 259                 # so we don't have to bother opening the resource file
 260                 dummy = Res.GetResource('DLOG', ID_MODULES)
 261         except Res.Error:
 262                 try:
 263                         Res.FSpOpenResFile("Twit.rsrc", 1)
 264                 except Res.Error, arg:
 265                         EasyDialogs.Message("Cannot open Twit.rsrc: "+arg[1])
 266                         sys.exit(1)
 267