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
		frame = sys.exc_traceback.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, 52, 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, 20, 0, 16), self.reason)
		
		bottom.srctitle = W.TextBox((12, 36, 0, 14))
		bottom.buttons = buttons = W.Group((12, 0, 0, 16))
		
		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, 50, 16), "Step", self.do_step)
		buttons.stepinbutton = W.Button((239, 0, 50, 16), "Step in", self.do_stepin)
		buttons.stepoutbutton = W.Button((297, 0, 50, 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, 'rb')
					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, 'rb')
								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:
					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:', `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_type, sys.exc_value)
			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:
		frame = sys.exc_traceback.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
	frame = sys.exc_traceback.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