cpython/Mac/Tools/IDE/PyDebugger.py

import sys
import bdb
import types
import os

import W
import WASTEconst
import PyBrowser
from Carbon import Qd
from Carbon import Evt
from Carbon import Lists
import MacOS
_filenames = {}

SIMPLE_TYPES = (
        types.NoneType,
        types.IntType,
        types.LongType,
        types.FloatType,
        types.ComplexType,
        types.StringType
)


class Debugger(bdb.Bdb):

    def __init__(self, title = 'Debugger'):
        bdb.Bdb.__init__(self)
        self.closed = 1
        self.title = title
        self.breaksviewer = None
        self.reset()
        self.tracing = 0
        self.tracingmonitortime = Evt.TickCount()
        self.editors = {}

        prefs = W.getapplication().getprefs()
        if prefs.debugger:
            for file, breaks in prefs.debugger.breaks.items():
                for b in breaks:
                    self.set_break(file, b)
            self.bounds, self.horpanes, self.verpanes = prefs.debugger.windowsettings
            self.tracemagic = prefs.debugger.tracemagic
        else:
            self.breaks = {}
            self.horpanes = (0.4, 0.6)
            self.verpanes = (0.3, 0.35, 0.35)
            self.bounds = (600, 400)
            self.tracemagic = 0
        self.laststacksel = None

    def canonic(self, filename):
        # override: the provided canonic() method breaks our
        # file-less Untitled windows
        return filename

    def reset(self):
        self.currentframe = None
        self.file = None
        self.laststack = None
        self.reason = 'Not running'
        self.continuewithoutdebugger = 0
        bdb.Bdb.reset(self)
        self.forget()

    def start(self, bottomframe = None, running = 0):
        W.getapplication().DebuggerQuit = bdb.BdbQuit
        from Carbon import Menu
        Menu.HiliteMenu(0)
        if self.closed:
            self.setupwidgets(self.title)
            self.closed = 0
        if not self.w.parent.debugger_quitting:
            self.w.select()
            raise W.AlertError, 'There is another debugger session busy.'
        self.reset()
        self.botframe = bottomframe
        if running:
            self.set_continue()
            self.reason = 'Running\xc9'
            self.setstate('running')
        else:
            self.set_step()
            self.reason = 'stopped'
            self.setstate('stopped')
        sys.settrace(self.trace_dispatch)

    def stop(self):
        self.set_quit()
        if self.w.parent:
            self.exit_mainloop()
            self.resetwidgets()

    def set_continue_without_debugger(self):
        sys.settrace(None)
        self.set_quit()
        self.clear_tracefuncs()
        self.continuewithoutdebugger = 1
        if hasattr(self, "w") and self.w.parent:
            self.exit_mainloop()
            self.resetwidgets()

    def clear_tracefuncs(self):
        try:
            raise 'spam'
        except:
            pass
        tb = sys.exc_info()[2]
        frame = tb.tb_frame
        while frame is not None:
            del frame.f_trace
            frame = frame.f_back

    def postmortem(self, exc_type, exc_value, traceback):
        if self.closed:
            self.setupwidgets(self.title)
            self.closed = 0
        if not self.w.parent.debugger_quitting:
            raise W.AlertError, 'There is another debugger session busy.'
        self.reset()
        if traceback:
            self.botframe = traceback.tb_frame
            while traceback.tb_next <> None:
                traceback = traceback.tb_next
            frame = traceback.tb_frame
        else:
            self.botframe = None
            frame = None
        self.w.panes.bottom.buttons.killbutton.enable(1)
        self.reason = '(dead) ' + self.formatexception(exc_type, exc_value)
        self.w.select()
        self.setup(frame, traceback)
        self.setstate('dead')
        self.showstack(self.curindex)
        self.showframe(self.curindex)

    def setupwidgets(self, title):
        self.w = w = W.Window(self.bounds, title, minsize = (500, 300))

        w.panes = W.HorizontalPanes((8, 4, -8, -8), self.horpanes)

        w.panes.browserpanes = browserpanes = W.VerticalPanes(None, self.verpanes)

        browserpanes.stacklist = W.Group(None)
        browserpanes.stacklist.title = W.TextBox((4, 0, 0, 12), 'Stack')
        browserpanes.stacklist.stack = W.List((0, 16, 0, 0), callback = self.do_stack, flags = Lists.lOnlyOne)

        browserpanes.locals = W.Group(None)
        browserpanes.locals.title = W.TextBox((4, 0, 0, 12), 'Local variables')
        browserpanes.locals.browser = PyBrowser.BrowserWidget((0, 16, 0, 0))

        browserpanes.globals = W.Group(None)
        browserpanes.globals.title = W.TextBox((4, 0, 0, 12), 'Global variables')
        browserpanes.globals.browser = PyBrowser.BrowserWidget((0, 16, 0, 0))

        w.panes.bottom = bottom = W.Group(None)
        bottom.src = src = W.Group((0, 64, 0, 0))
        source = SourceViewer((1, 1, -15, -15), readonly = 1, debugger = self)
        src.optionsmenu = W.PopupMenu((-16, 0, 16, 16), [])
        src.optionsmenu.bind('<click>', self.makeoptionsmenu)

        src._barx = W.Scrollbar((0, -16, -15, 16), source.hscroll, max = 32767)
        src._bary = W.Scrollbar((-16, 15, 16, -15), source.vscroll, max = 32767)
        src.source = source
        src.frame = W.Frame((0, 0, -15, -15))

        bottom.tracingmonitor = TracingMonitor((0, 23, 6, 6))
        bottom.state = W.TextBox((12, 24, 0, 16), self.reason)

        bottom.srctitle = W.TextBox((12, 44, 0, 16))
        bottom.buttons = buttons = W.Group((12, 0, 0, 20))

        buttons.runbutton = W.Button((0, 0, 50, 16), "Run", self.do_run)
        buttons.stopbutton = W.Button((58, 0, 50, 16), "Stop", self.do_stop)
        buttons.killbutton = W.Button((116, 0, 50, 16), "Kill", self.do_kill)
        buttons.line = W.VerticalLine((173, 0, 0, 0))
        buttons.stepbutton = W.Button((181, 0, 60, 16), "Step", self.do_step)
        buttons.stepinbutton = W.Button((249, 0, 60, 16), "Step in", self.do_stepin)
        buttons.stepoutbutton = W.Button((317, 0, 60, 16), "Step out", self.do_stepout)

        w.bind('cmdr', buttons.runbutton.push)
        w.bind('cmd.', buttons.stopbutton.push)
        w.bind('cmdk', buttons.killbutton.push)
        w.bind('cmds', buttons.stepbutton.push)
        w.bind('cmdt', buttons.stepinbutton.push)
        w.bind('cmdu', buttons.stepoutbutton.push)

        w.bind('<close>', self.close)

        w.open()
        w.xxx___select(w.panes.bottom.src.source)

    def makeoptionsmenu(self):
        options = [('Clear breakpoints', self.w.panes.bottom.src.source.clearbreakpoints),
                        ('Clear all breakpoints', self.clear_all_breaks),
                        ('Edit breakpoints\xc9', self.edit_breaks), '-',
                        (self.tracemagic and
                                'Disable __magic__ tracing' or 'Enable __magic__ tracing', self.togglemagic)]
        self.w.panes.bottom.src.optionsmenu.set(options)

    def edit_breaks(self):
        if self.breaksviewer:
            self.breaksviewer.select()
        else:
            self.breaksviewer = BreakpointsViewer(self)

    def togglemagic(self):
        self.tracemagic = not self.tracemagic

    def setstate(self, state):
        self.w.panes.bottom.tracingmonitor.reset()
        self.w.panes.bottom.state.set(self.reason)
        buttons = self.w.panes.bottom.buttons
        if state == 'stopped':
            buttons.runbutton.enable(1)
            buttons.stopbutton.enable(0)
            buttons.killbutton.enable(1)
            buttons.stepbutton.enable(1)
            buttons.stepinbutton.enable(1)
            buttons.stepoutbutton.enable(1)
        elif state == 'running':
            buttons.runbutton.enable(0)
            buttons.stopbutton.enable(1)
            buttons.killbutton.enable(1)
            buttons.stepbutton.enable(0)
            buttons.stepinbutton.enable(0)
            buttons.stepoutbutton.enable(0)
        elif state == 'idle':
            buttons.runbutton.enable(0)
            buttons.stopbutton.enable(0)
            buttons.killbutton.enable(0)
            buttons.stepbutton.enable(0)
            buttons.stepinbutton.enable(0)
            buttons.stepoutbutton.enable(0)
        elif state == 'dead':
            buttons.runbutton.enable(0)
            buttons.stopbutton.enable(0)
            buttons.killbutton.enable(1)
            buttons.stepbutton.enable(0)
            buttons.stepinbutton.enable(0)
            buttons.stepoutbutton.enable(0)
        else:
            print 'unknown state:', state

    def resetwidgets(self):
        self.reason = ''
        self.w.panes.bottom.srctitle.set('')
        self.w.panes.bottom.src.source.set('')
        self.w.panes.browserpanes.stacklist.stack.set([])
        self.w.panes.browserpanes.locals.browser.set({})
        self.w.panes.browserpanes.globals.browser.set({})
        self.setstate('idle')

    # W callbacks

    def close(self):
        self.set_quit()
        self.exit_mainloop()
        self.closed = 1

        self.unregister_editor(self.w.panes.bottom.src.source,
                        self.w.panes.bottom.src.source.file)
        self.horpanes = self.w.panes.getpanesizes()
        self.verpanes = self.w.panes.browserpanes.getpanesizes()
        self.bounds = self.w.getbounds()
        prefs = W.getapplication().getprefs()
        prefs.debugger.breaks = self.breaks
        prefs.debugger.windowsettings = self.bounds, self.horpanes, self.verpanes
        prefs.debugger.tracemagic = self.tracemagic
        prefs.save()

    # stack list callback

    def do_stack(self, isdbl):
        sel = self.w.panes.browserpanes.stacklist.stack.getselection()
        if isdbl:
            if sel:
                frame, lineno = self.stack[sel[0] + 1]
                filename = frame.f_code.co_filename
                editor = self.w._parentwindow.parent.openscript(filename, lineno)
                if self.breaks.has_key(filename):
                    editor.showbreakpoints(1)
        else:
            if sel and sel <> self.laststacksel:
                self.showframe(sel[0] + 1)
            self.laststacksel = sel

    def geteditor(self, filename):
        if filename[:1] == '<' and filename[-1:] == '>':
            editor = W.getapplication().getscript(filename[1:-1])
        else:
            editor = W.getapplication().getscript(filename)
        return editor

    # button callbacks

    def do_run(self):
        self.running()
        self.set_continue()
        self.exit_mainloop()

    def do_stop(self):
        self.set_step()

    def do_kill(self):
        self.set_quit()
        self.exit_mainloop()
        self.resetwidgets()

    def do_step(self):
        self.running()
        self.set_next(self.curframe)
        self.exit_mainloop()

    def do_stepin(self):
        self.running()
        self.set_step()
        self.exit_mainloop()

    def do_stepout(self):
        self.running()
        self.set_return(self.curframe)
        self.exit_mainloop()

    def running(self):
        W.SetCursor('watch')
        self.reason = 'Running\xc9'
        self.setstate('running')
        #self.w.panes.bottom.src.source.set('')
        #self.w.panes.browserpanes.stacklist.stack.set([])
        #self.w.panes.browserpanes.locals.browser.set({})
        #self.w.panes.browserpanes.globals.browser.set({})

    def exit_mainloop(self):
        self.w.parent.debugger_quitting = 1

    #

    def showframe(self, stackindex):
        (frame, lineno) = self.stack[stackindex]
        W.SetCursor('watch')
        filename = frame.f_code.co_filename
        if filename <> self.file:
            editor = self.geteditor(filename)
            if editor:
                self.w.panes.bottom.src.source.set(editor.get(), filename)
            else:
                try:
                    f = open(filename, 'rU')
                    data = f.read()
                    f.close()
                except IOError:
                    if filename[-3:] == '.py':
                        import imp
                        modname = os.path.basename(filename)[:-3]
                        try:
                            f, filename, (suff, mode, dummy) = imp.find_module(modname)
                        except ImportError:
                            self.w.panes.bottom.src.source.set("can't find file")
                        else:
                            if f:
                                f.close()
                            if f and suff == '.py':
                                f = open(filename, 'rU')
                                data = f.read()
                                f.close()
                                self.w.panes.bottom.src.source.set(data, filename)
                            else:
                                self.w.panes.bottom.src.source.set("can't find file")
                    else:
                        self.w.panes.bottom.src.source.set("can't find file")
                else:
                    data = data.replace('\n', '\r')
                    self.w.panes.bottom.src.source.set(data, filename)
            self.file = filename
        self.w.panes.bottom.srctitle.set('Source: ' + filename + ((lineno > 0) and (' (line %d)' % lineno) or ' '))
        self.goto_line(lineno)
        self.lineno = lineno
        self.showvars((frame, lineno))

    def showvars(self, (frame, lineno)):
        if frame.f_locals is not frame.f_globals:
            locals = frame.f_locals
        else:
            locals = {'Same as Globals':''}
        filteredlocals = {}
        for key, value in locals.items():
            # empty key is magic for Python 1.4; '.' is magic for 1.5...
            if not key or key[0] <> '.':
                filteredlocals[key] = value
        self.w.panes.browserpanes.locals.browser.set(filteredlocals)
        self.w.panes.browserpanes.globals.browser.set(frame.f_globals)

    def showstack(self, stackindex):
        stack = []
        for frame, lineno in self.stack[1:]:
            filename = frame.f_code.co_filename
            try:
                filename = _filenames[filename]
            except KeyError:
                if filename[:1] + filename[-1:] <> '<>':
                    filename = os.path.basename(filename)
                _filenames[frame.f_code.co_filename] = filename
            funcname = frame.f_code.co_name
            if funcname == '?':
                funcname = '<toplevel>'
            stack.append(filename + ': ' + funcname)
        if stack <> self.laststack:
            self.w.panes.browserpanes.stacklist.stack.set(stack)
            self.laststack = stack
        sel = [stackindex - 1]
        self.w.panes.browserpanes.stacklist.stack.setselection(sel)
        self.laststacksel = sel

    def goto_line(self, lineno):
        if lineno > 0:
            self.w.panes.bottom.src.source.selectline(lineno - 1)
        else:
            self.w.panes.bottom.src.source.setselection(0, 0)

    # bdb entry points

#       def user_call(self, frame, argument_list):
#               self.reason = 'Calling'
#               self.interaction(frame, None)

    def user_line(self, frame):
        # This function is called when we stop or break at this line
        self.reason = 'Stopped'
        self.interaction(frame, None)

    def user_return(self, frame, return_value):
        # This function is called when a return trap is set here
        fname = frame.f_code.co_name
        if fname <> '?':
            self.reason = 'Returning from %s()' % frame.f_code.co_name
            frame.f_locals['__return__'] = return_value
        elif frame.f_back is self.botframe:
            self.reason = 'Done'
        else:
            self.reason = 'Returning'
        self.interaction(frame, None, 1)

    def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
        # This function is called when we stop or break at this line
        self.reason = self.formatexception(exc_type, exc_value)
        self.interaction(frame, exc_traceback)

    def formatexception(self, exc_type, exc_value):
        if exc_type == SyntaxError:
            try:
                value, (filename, lineno, charno, line) = exc_value
            except:
                pass
            else:
                return str(exc_type) + ': ' + str(value)
        if type(exc_type) == types.ClassType:
            nice = exc_type.__name__
        else:
            nice = str(exc_type)
        value = str(exc_value)
        if exc_value and value:
            nice = nice + ": " + value
        return nice

    def forget(self):
        self.stack = []
        self.curindex = 0
        self.curframe = None

    def setup(self, f, t, isreturning = 0):
        self.forget()
        self.stack, self.curindex = self.get_stack(f, t)
        self.curframe = self.stack[self.curindex - isreturning][0]

    def interaction(self, frame, traceback, isreturning = 0):
        saveport = Qd.GetPort()
        self.w.select()
        try:
            self.setup(frame, traceback, isreturning)
            self.setstate('stopped')
            stackindex = self.curindex
            if isreturning:
                if frame.f_back is not self.botframe:
                    stackindex = stackindex - 1
            self.showstack(stackindex)
            self.showframe(stackindex)
            self.w.parent.debugger_mainloop()
            self.forget()
        finally:
            Qd.SetPort(saveport)

    # bdb customization

    def trace_dispatch(self, frame, event, arg, TickCount = Evt.TickCount):
        if TickCount() - self.tracingmonitortime > 15:
            self.tracingmonitortime = TickCount()
            self.w.panes.bottom.tracingmonitor.toggle()
        try:
            try:
                if hasattr(MacOS, 'EnableAppswitch'):
                    MacOS.EnableAppswitch(0)
                if self.quitting:
                    # returning None is not enough, a former BdbQuit exception
                    # might have been eaten by the print statement
                    raise bdb.BdbQuit
                if event == 'line':
                    return self.dispatch_line(frame)
                if event == 'call':
                    return self.dispatch_call(frame, arg)
                if event == 'return':
                    return self.dispatch_return(frame, arg)
                if event == 'exception':
                    return self.dispatch_exception(frame, arg)
                print 'bdb.Bdb.dispatch: unknown debugging event:', repr(event)
                return self.trace_dispatch
            finally:
                if hasattr(MacOS, 'EnableAppswitch'):
                    MacOS.EnableAppswitch(-1)
        except KeyboardInterrupt:
            self.set_step()
            return self.trace_dispatch
        except bdb.BdbQuit:
            if self.continuewithoutdebugger:
                self.clear_tracefuncs()
                return
            else:
                raise bdb.BdbQuit
        except:
            print 'XXX Exception during debugger interaction.', \
                            self.formatexception(sys.exc_info[:2])
            import traceback
            traceback.print_exc()
            return self.trace_dispatch

    def dispatch_call(self, frame, arg):
        if not self.tracemagic and \
                        frame.f_code.co_name[:2] == '__' == frame.f_code.co_name[-2:] and \
                        frame.f_code.co_name <> '__init__':
            return
        if self.botframe is None:
            # First call of dispatch since reset()
            self.botframe = frame.f_back    # xxx !!! added f_back
            return self.trace_dispatch
        if not (self.stop_here(frame) or self.break_anywhere(frame)):
            # No need to trace this function
            return # None
        self.user_call(frame, arg)
        if self.quitting:
            raise bdb.BdbQuit
        return self.trace_dispatch

    def set_continue(self):
        # Don't stop except at breakpoints or when finished
        self.stopframe = self.botframe
        self.returnframe = None
        self.quitting = 0
        # unlike in bdb/pdb, there's a chance that breakpoints change
        # *while* a program (this program ;-) is running. It's actually quite likely.
        # So we don't delete frame.f_trace until the bottom frame if there are no breakpoints.

    def set_break(self, filename, lineno):
        if not self.breaks.has_key(filename):
            self.breaks[filename] = []
        list = self.breaks[filename]
        if lineno in list:
            return 'There is already a breakpoint there!'
        list.append(lineno)
        list.sort()     # I want to keep them neatly sorted; easier for drawing
        if hasattr(bdb, "Breakpoint"):
            # 1.5.2b1 specific
            bp = bdb.Breakpoint(filename, lineno, 0, None)
        self.update_breaks(filename)

    def clear_break(self, filename, lineno):
        bdb.Bdb.clear_break(self, filename, lineno)
        self.update_breaks(filename)

    def clear_all_file_breaks(self, filename):
        bdb.Bdb.clear_all_file_breaks(self, filename)
        self.update_breaks(filename)

    def clear_all_breaks(self):
        bdb.Bdb.clear_all_breaks(self)
        for editors in self.editors.values():
            for editor in editors:
                editor.drawbreakpoints()

    # special

    def toggle_break(self, filename, lineno):
        if self.get_break(filename, lineno):
            self.clear_break(filename, lineno)
        else:
            self.set_break(filename, lineno)

    def clear_breaks_above(self, filename, above):
        if not self.breaks.has_key(filename):
            return 'There are no breakpoints in that file!'
        for lineno in self.breaks[filename][:]:
            if lineno > above:
                self.breaks[filename].remove(lineno)
        if not self.breaks[filename]:
            del self.breaks[filename]

    # editor stuff

    def update_breaks(self, filename):
        if self.breaksviewer:
            self.breaksviewer.update()
        if self.editors.has_key(filename):
            for editor in self.editors[filename]:
                if editor._debugger:    # XXX
                    editor.drawbreakpoints()
                else:
                    print 'xxx dead editor!'

    def update_allbreaks(self):
        if self.breaksviewer:
            self.breaksviewer.update()
        for filename in self.breaks.keys():
            if self.editors.has_key(filename):
                for editor in self.editors[filename]:
                    if editor._debugger:    # XXX
                        editor.drawbreakpoints()
                    else:
                        print 'xxx dead editor!'

    def register_editor(self, editor, filename):
        if not filename:
            return
        if not self.editors.has_key(filename):
            self.editors[filename] = [editor]
        elif editor not in self.editors[filename]:
            self.editors[filename].append(editor)

    def unregister_editor(self, editor, filename):
        if not filename:
            return
        try:
            self.editors[filename].remove(editor)
            if not self.editors[filename]:
                del self.editors[filename]
                # if this was an untitled window, clear the breaks.
                if filename[:1] == '<' and filename[-1:] == '>' and \
                                self.breaks.has_key(filename):
                    self.clear_all_file_breaks(filename)
        except (KeyError, ValueError):
            pass


class SourceViewer(W.PyEditor):

    def __init__(self, *args, **kwargs):
        apply(W.PyEditor.__init__, (self,) + args, kwargs)
        self.bind('<click>', self.clickintercept)

    def clickintercept(self, point, modifiers):
        if self._parentwindow._currentwidget <> self and not self.pt_in_breaks(point):
            self._parentwindow.xxx___select(self)
            return 1

    def _getviewrect(self):
        l, t, r, b = self._bounds
        if self._debugger:
            return (l + 12, t + 2, r - 1, b - 2)
        else:
            return (l + 5, t + 2, r - 1, b - 2)

    def select(self, onoff, isclick = 0):
        if W.SelectableWidget.select(self, onoff):
            return
        self.SetPort()
        #if onoff:
        #       self.ted.WEActivate()
        #else:
        #       self.ted.WEDeactivate()
        self.drawselframe(onoff)

    def drawselframe(self, onoff):
        pass


class BreakpointsViewer:

    def __init__(self, debugger):
        self.debugger = debugger
        self.w = W.Window((300, 250), 'Breakpoints', minsize = (200, 200))
        self.w.panes = W.HorizontalPanes((8, 8, -8, -32), (0.3, 0.7))
        self.w.panes.files = W.List(None, callback = self.filehit)              #, flags = Lists.lOnlyOne)
        self.w.panes.gr = W.Group(None)
        self.w.panes.gr.breaks = W.List((0, 0, -130, 0), callback = self.linehit)       #, flags = Lists.lOnlyOne)
        self.w.panes.gr.openbutton = W.Button((-80, 4, 0, 16), 'View\xc9', self.openbuttonhit)
        self.w.panes.gr.deletebutton = W.Button((-80, 28, 0, 16), 'Delete', self.deletebuttonhit)

        self.w.bind('<close>', self.close)
        self.w.bind('backspace', self.w.panes.gr.deletebutton.push)

        self.setup()
        self.w.open()
        self.w.panes.gr.openbutton.enable(0)
        self.w.panes.gr.deletebutton.enable(0)
        self.curfile = None

    def deletebuttonhit(self):
        if self.w._currentwidget == self.w.panes.files:
            self.del_filename()
        else:
            self.del_number()
        self.checkbuttons()

    def del_number(self):
        if self.curfile is None:
            return
        sel = self.w.panes.gr.breaks.getselectedobjects()
        for lineno in sel:
            self.debugger.clear_break(self.curfile, lineno)

    def del_filename(self):
        sel = self.w.panes.files.getselectedobjects()
        for filename in sel:
            self.debugger.clear_all_file_breaks(filename)
        self.debugger.update_allbreaks()

    def setup(self):
        files = self.debugger.breaks.keys()
        files.sort()
        self.w.panes.files.set(files)

    def close(self):
        self.debugger.breaksviewer = None
        self.debugger = None

    def update(self):
        sel = self.w.panes.files.getselectedobjects()
        self.setup()
        self.w.panes.files.setselectedobjects(sel)
        sel = self.w.panes.files.getselection()
        if len(sel) == 0 and self.curfile:
            self.w.panes.files.setselectedobjects([self.curfile])
        self.filehit(0)

    def select(self):
        self.w.select()

    def selectfile(self, file):
        self.w.panes.files.setselectedobjects([file])
        self.filehit(0)

    def openbuttonhit(self):
        self.filehit(1)

    def filehit(self, isdbl):
        sel = self.w.panes.files.getselectedobjects()
        if isdbl:
            for filename in sel:
                lineno = None
                if filename == self.curfile:
                    linesel = self.w.panes.gr.breaks.getselectedobjects()
                    if linesel:
                        lineno = linesel[-1]
                    elif self.w.panes.gr.breaks:
                        lineno = self.w.panes.gr.breaks[0]
                editor = self.w._parentwindow.parent.openscript(filename, lineno)
                editor.showbreakpoints(1)
            return
        if len(sel) == 1:
            file = sel[0]
            filebreaks = self.debugger.breaks[file][:]
            if self.curfile == file:
                linesel = self.w.panes.gr.breaks.getselectedobjects()
            self.w.panes.gr.breaks.set(filebreaks)
            if self.curfile == file:
                self.w.panes.gr.breaks.setselectedobjects(linesel)
            self.curfile = file
        else:
            if len(sel) <> 0:
                self.curfile = None
            self.w.panes.gr.breaks.set([])
        self.checkbuttons()

    def linehit(self, isdbl):
        if isdbl:
            files = self.w.panes.files.getselectedobjects()
            if len(files) <> 1:
                return
            filename = files[0]
            linenos = self.w.panes.gr.breaks.getselectedobjects()
            if not linenos:
                return
            lineno = linenos[-1]
            editor = self.w._parentwindow.parent.openscript(filename, lineno)
            editor.showbreakpoints(1)
        self.checkbuttons()

    def checkbuttons(self):
        if self.w.panes.files.getselection():
            self.w.panes.gr.openbutton.enable(1)
            self.w._parentwindow.setdefaultbutton(self.w.panes.gr.openbutton)
            if self.w._currentwidget == self.w.panes.files:
                if self.w.panes.files.getselection():
                    self.w.panes.gr.deletebutton.enable(1)
                else:
                    self.w.panes.gr.deletebutton.enable(0)
            else:
                if self.w.panes.gr.breaks.getselection():
                    self.w.panes.gr.deletebutton.enable(1)
                else:
                    self.w.panes.gr.deletebutton.enable(0)
        else:
            self.w.panes.gr.openbutton.enable(0)
            self.w.panes.gr.deletebutton.enable(0)


class TracingMonitor(W.Widget):

    def __init__(self, *args, **kwargs):
        apply(W.Widget.__init__, (self,) + args, kwargs)
        self.state = 0

    def toggle(self):
        if hasattr(self, "_parentwindow") and self._parentwindow is not None:
            self.state = self.state % 2 + 1
            port = Qd.GetPort()
            self.SetPort()
            self.draw()
            Qd.SetPort(port)

    def reset(self):
        if self._parentwindow:
            self.state = 0
            port = Qd.GetPort()
            self.SetPort()
            self.draw()
            Qd.SetPort(port)

    def draw(self, visRgn = None):
        if self.state == 2:
            Qd.PaintOval(self._bounds)
        else:
            Qd.EraseOval(self._bounds)


# convenience funcs

def postmortem(exc_type, exc_value, tb):
    d = getdebugger()
    d.postmortem(exc_type, exc_value, tb)

def start(bottomframe = None):
    d = getdebugger()
    d.start(bottomframe)

def startfromhere():
    d = getdebugger()
    try:
        raise 'spam'
    except:
        tb = sys.exc_info()[2]
        frame = tb.tb_frame.f_back
    d.start(frame)

def startfrombottom():
    d = getdebugger()
    d.start(_getbottomframe(), 1)

def stop():
    d = getdebugger()
    d.stop()

def cont():
    sys.settrace(None)
    d = getdebugger()
    d.set_continue_without_debugger()

def _getbottomframe():
    try:
        raise 'spam'
    except:
        pass
    tb = sys.exc_info()[2]
    frame = tb.tb_frame
    while 1:
        if frame.f_code.co_name == 'mainloop' or frame.f_back is None:
            break
        frame = frame.f_back
    return frame

_debugger = None

def getdebugger():
    if not __debug__:
        raise W.AlertError, "Can't debug in \"Optimize bytecode\" mode.\r(see \"Default startup options\" in EditPythonPreferences)"
    global _debugger
    if _debugger is None:
        _debugger = Debugger()
    return _debugger