[Python-checkins] r65300 - in sandbox/trunk/ttk-gsoc/src/idlelib: PyShell.py run.py

Wed Jul 30 14:34:21 CEST 2008

Author: guilherme.polo
Date: Wed Jul 30 14:34:19 2008
New Revision: 65300
Log:
Updated idle_showwarning to python 2.6 format. Removed more dependencies on self.text
Modified:
 sandbox/trunk/ttk-gsoc/src/idlelib/PyShell.py
 sandbox/trunk/ttk-gsoc/src/idlelib/run.py
Modified: sandbox/trunk/ttk-gsoc/src/idlelib/PyShell.py
==============================================================================

--- sandbox/trunk/ttk-gsoc/src/idlelib/PyShell.py	(original)
+++ sandbox/trunk/ttk-gsoc/src/idlelib/PyShell.py	Wed Jul 30 14:34:19 2008
@@ -63,24 +63,31 @@
 except ImportError:
 pass
 else:
- def idle_showwarning(message, category, filename, lineno):
+ def idle_showwarning(message, category, filename, lineno, line=None):
 file = warning_stream
 try:
- file.write(warnings.formatwarning(message, category, filename, lineno))
+ file.write(warnings.formatwarning(message, category, filename,
+ lineno, line))
 except IOError:
 pass ## file (probably __stderr__) is invalid, warning dropped.
 warnings.showwarning = idle_showwarning
- def idle_formatwarning(message, category, filename, lineno):
+ def idle_formatwarning(message, category, filename, lineno, line=None):
 """Format warnings the IDLE way"""
 s = "\nWarning (from warnings module):\n"
 s += ' File \"%s\", line %s\n' % (filename, lineno)
- line = linecache.getline(filename, lineno).strip()
+ if line is None:
+ line = linecache.getline(filename, lineno).strip()
 if line:
 s += " %s\n" % line
 s += "%s: %s\n>>> " % (category.__name__, message)
 return s
 warnings.formatwarning = idle_formatwarning
 
+def _callback(func, *myargs):
+ def w(*args):
+ return func(*(args + myargs))
+ return w
+
 def extended_linecache_checkcache(filename=None,
 orig_checkcache=linecache.checkcache):
 """Extend linecache.checkcache to preserve the <pyshell#...> entries
@@ -108,59 +115,67 @@
 class PyShellEditorWindow(EditorWindow):
 "Regular text edit window in IDLE, supports breakpoints"
 
+ rmenu_specs = [("Set Breakpoint", "<<set-breakpoint-here>>"),
+ ("Clear Breakpoint", "<<clear-breakpoint-here>>")]
+
 def __init__(self, *args):
- self.breakpoints = []
+ #self.breakpoints = []
 EditorWindow.__init__(self, *args)
- # XXX more things to be done after page is created
- self.text.bind("<<set-breakpoint-here>>", self.set_breakpoint_here)
- self.text.bind("<<clear-breakpoint-here>>", self.clear_breakpoint_here)
- self.text.bind("<<open-python-shell>>", self.flist.open_shell)
+
+ self.top.bind('<<tab-created>>', self._configure_new_tab)
+ self._configure_new_tab()
 
 self.breakpointPath = os.path.join(idleConf.GetUserCfgDir(),
- 'breakpoints.lst')
+ 'breakpoints.lst')
+
+ def _configure_new_tab(self, event=None):
+ page = self.text_notebook.last_page().editpage
+ page.breakpoints = []
+ text = page.text
+
+ text.bind("<<set-breakpoint-here>>",
+ _callback(self._set_breakpoint_here, text, page))
+ text.bind("<<clear-breakpoint-here>>",
+ _callback(self._clear_breakpoint_here, text, page))
+ text.bind("<<open-python-shell>>", self.flist.open_shell)
+
 # whenever a file is changed, restore breakpoints
- if self.io.filename: self.restore_file_breaks()
- def filename_changed_hook(old_hook=self.io.filename_change_hook,
+ if page.io.filename: self.restore_file_breaks(text, page)
+ def filename_changed_hook(old_hook=page.io.filename_change_hook,
 self=self):
- self.restore_file_breaks()
+ self.restore_file_breaks(text, page)
 old_hook()
- self.io.set_filename_change_hook(filename_changed_hook)
+ page.io.set_filename_change_hook(filename_changed_hook)
 
- rmenu_specs = [("Set Breakpoint", "<<set-breakpoint-here>>"),
- ("Clear Breakpoint", "<<clear-breakpoint-here>>")]
-
- def set_breakpoint(self, lineno):
- text = self.text
- filename = self.io.filename
+ def set_breakpoint(self, lineno, text, page):
+ filename = page.io.filename
 text.tag_add("BREAK", "%d.0" % lineno, "%d.0" % (lineno+1))
 try:
- i = self.breakpoints.index(lineno)
+ i = page.breakpoints.index(lineno)
 except ValueError: # only add if missing, i.e. do once
- self.breakpoints.append(lineno)
+ page.breakpoints.append(lineno)
 try: # update the subprocess debugger
 debug = self.flist.pyshell.interp.debugger
 debug.set_breakpoint_here(filename, lineno)
 except: # but debugger may not be active right now....
 pass
 
- def set_breakpoint_here(self, event=None):
- text = self.text
- filename = self.io.filename
+ def _set_breakpoint_here(self, event=None, text=None, page=None):
+ filename = page.io.filename
 if not filename:
 text.bell()
 return
 lineno = int(float(text.index("insert")))
- self.set_breakpoint(lineno)
+ self.set_breakpoint(lineno, text, page)
 
- def clear_breakpoint_here(self, event=None):
- text = self.text
- filename = self.io.filename
+ def _clear_breakpoint_here(self, event=None, text=None, page=None):
+ filename = page.io.filename
 if not filename:
 text.bell()
 return
 lineno = int(float(text.index("insert")))
 try:
- self.breakpoints.remove(lineno)
+ page.breakpoints.remove(lineno)
 except:
 pass
 text.tag_remove("BREAK", "insert linestart",\
@@ -172,13 +187,17 @@
 pass
 
 def clear_file_breaks(self):
- if self.breakpoints:
- text = self.text
- filename = self.io.filename
+ for page in self.text_notebook.pages.itervalues():
+ page = page.editpage
+ text = page.text
+ filename = page.io.filename
+
+ if not page.breakpoints:
+ continue
 if not filename:
 text.bell()
- return
- self.breakpoints = []
+ continue
+ page.breakpoints = []
 text.tag_remove("BREAK", "1.0", END)
 try:
 debug = self.flist.pyshell.interp.debugger
@@ -186,7 +205,7 @@
 except:
 pass
 
- def store_file_breaks(self):
+ def store_file_breaks(self, page):
 "Save breakpoints when file is saved"
 # XXX 13 Dec 2002 KBK Currently the file must be saved before it can
 # be run. The breaks are saved at that time. If we introduce
@@ -209,8 +228,8 @@
 # debugger is loaded) is updated during the save, the visible
 # breaks stay synched with the subprocess even if one of these
 # unexpected breakpoint deletions occurs.
- breaks = self.breakpoints
- filename = self.io.filename
+ breaks = page.breakpoints
+ filename = page.io.filename
 try:
 lines = open(self.breakpointPath,"r").readlines()
 except IOError:
@@ -219,31 +238,31 @@
 for line in lines:
 if not line.startswith(filename + '='):
 new_file.write(line)
- self.update_breakpoints()
- breaks = self.breakpoints
+ self.update_breakpoints(page)
+ breaks = page.breakpoints
 if breaks:
 new_file.write(filename + '=' + str(breaks) + '\n')
 new_file.close()
 
- def restore_file_breaks(self):
- self.text.update() # this enables setting "BREAK" tags to be visible
- filename = self.io.filename
+ def restore_file_breaks(self, text, page):
+ text.update() # this enables setting "BREAK" tags to be visible
+ filename = page.io.filename
 if filename is None:
 return
 if os.path.isfile(self.breakpointPath):
- lines = open(self.breakpointPath,"r").readlines()
+ lines = open(self.breakpointPath, "r").readlines()
 for line in lines:
 if line.startswith(filename + '='):
 breakpoint_linenumbers = eval(line[len(filename)+1:])
 for breakpoint_linenumber in breakpoint_linenumbers:
- self.set_breakpoint(breakpoint_linenumber)
+ self.set_breakpoint(breakpoint_linenumber, text, page)
 
- def update_breakpoints(self):
- "Retrieves all the breakpoints in the current window"
- text = self.text
+ def update_breakpoints(self, page):
+ "Retrieves all the breakpoints in the current page"
+ text = page.text
 ranges = text.tag_ranges("BREAK")
 linenumber_list = self.ranges_to_linenumbers(ranges)
- self.breakpoints = linenumber_list
+ page.breakpoints = linenumber_list
 
 def ranges_to_linenumbers(self, ranges):
 lines = []
@@ -829,20 +848,10 @@
 self.indentwidth = 8
 self.context_use_ps1 = True
 #
- text = self.text
- # XXX needs to be done after a page is created
- text.configure(wrap="char")
- text.bind("<<newline-and-indent>>", self.enter_callback)
- text.bind("<<plain-newline-and-indent>>", self.linefeed_callback)
- text.bind("<<interrupt-execution>>", self.cancel_callback)
- text.bind("<<end-of-file>>", self.eof_callback)
- text.bind("<<open-stack-viewer>>", self.open_stack_viewer)
- text.bind("<<toggle-debugger>>", self.toggle_debugger)
- text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)
- if use_subprocess:
- text.bind("<<view-restart>>", self.view_restart_mark)
- text.bind("<<restart-shell>>", self.restart_shell)
- #
+ self.text = None
+ self.textpage = None
+ self._configure_new_tab()
+
 self.save_stdout = sys.stdout
 self.save_stderr = sys.stderr
 self.save_stdin = sys.stdin
@@ -854,14 +863,37 @@
 sys.stdout = self.stdout
 sys.stderr = self.stderr
 sys.stdin = self
- #
- self.history = self.History(self.text)
- #
+
 self.pollinterval = 50 # millisec
 
 if TTK:
 self.set_theme(Style(self.root))
 
+ def _configure_new_tab(self, event=None):
+ # select the last page (the one added)
+ page = self.text_notebook.last_page().editpage
+ self.text = text = page.text
+ self.textpage = page
+
+ text.configure(wrap="char")
+ text.bind("<<newline-and-indent>>",
+ _callback(self._enter_callback, text))
+ text.bind("<<plain-newline-and-indent>>",
+ _callback(self._linefeed_callback, text))
+ text.bind("<<interrupt-execution>>",
+ _callback(self._cancel_callback, text))
+ text.bind("<<end-of-file>>",
+ _callback(self._eof_callback, text))
+ text.bind("<<toggle-debugger>>", self._toggle_debugger)
+ text.bind("<<toggle-jit-stack-viewer>>", self._toggle_jit_stack_viewer)
+ text.bind("<<open-stack-viewer>>", self.open_stack_viewer)
+ if use_subprocess:
+ text.bind("<<view-restart>>",
+ _callback(self._view_restart_mark, text))
+ text.bind("<<restart-shell>>", self.restart_shell)
+
+ page.history = self.History(text)
+
 def get_standard_extension_names(self):
 return idleConf.GetExtensions(shell_only=True)
 
@@ -882,11 +914,11 @@
 ttkstyle.theme_use(idleConf.GetOption('main', 'Theme',
 'displaytheme'))
 
- def toggle_debugger(self, event=None):
+ def _toggle_debugger(self, event=None):
 if self.executing:
 tkMessageBox.showerror("Don't debug now",
 "You can only toggle the debugger when idle",
- master=self.text)
+ master=self.text_notebook)
 self.set_debugger_indicator()
 return "break"
 else:
@@ -900,7 +932,7 @@
 db = self.interp.getdebugger()
 self.setvar("<<toggle-debugger>>", not not db)
 
- def toggle_jit_stack_viewer(self, event=None):
+ def _toggle_jit_stack_viewer(self, event=None):
 pass # All we need is the variable
 
 def close_debugger(self):
@@ -946,7 +978,7 @@
 "Kill?",
 "The program is still running!\n Do you want to kill it?",
 default="ok",
- parent=self.text)
+ parent=self.text_notebook)
 if response is False:
 return "cancel"
 if self.reading:
@@ -954,7 +986,7 @@
 self.canceled = True
 self.closing = True
 # Wait for poll_subprocess() rescheduling to stop
- self.text.after(2 * self.pollinterval, self.close2)
+ self.text_notebook.after(2 * self.pollinterval, self.close2)
 
 def close2(self):
 return EditorWindow.close(self)
@@ -972,7 +1004,9 @@
 self.interp = None
 self.console = None
 self.flist.pyshell = None
- self.history = None
+ for page in self.text_notebook.pages.itervalues():
+ page.editpage.history = None
+
 EditorWindow._close(self)
 
 def ispythonsource(self, filename):
@@ -1012,38 +1046,12 @@
 Tkinter._default_root = None # 03Jan04 KBK What's this?
 return True
 
- def readline(self):
- save = self.reading
- try:
- self.reading = 1
- self.top.mainloop() # nested mainloop()
- finally:
- self.reading = save
- line = self.text.get("iomark", "end-1c")
- if len(line) == 0: # may be EOF if we quit our mainloop with Ctrl-C
- line = "\n"
- if isinstance(line, unicode):
- import IOBinding
- try:
- line = line.encode(IOBinding.encoding)
- except UnicodeError:
- pass
- self.resetoutput()
- if self.canceled:
- self.canceled = 0
- if not use_subprocess:
- raise KeyboardInterrupt
- if self.endoffile:
- self.endoffile = 0
- line = ""
- return line
-
 def isatty(self):
 return True
 
- def cancel_callback(self, event=None):
+ def _cancel_callback(self, event=None, text=None):
 try:
- if self.text.compare("sel.first", "!=", "sel.last"):
+ if text.compare("sel.first", "!=", "sel.last"):
 return # Active selection -- always use default binding
 except:
 pass
@@ -1063,11 +1071,11 @@
 self.top.quit() # exit the nested mainloop() in readline()
 return "break"
 
- def eof_callback(self, event):
+ def _eof_callback(self, event, text):
 if self.executing and not self.reading:
 return # Let the default binding (delete next char) take over
- if not (self.text.compare("iomark", "==", "insert") and
- self.text.compare("insert", "==", "end-1c")):
+ if not (text.compare("iomark", "==", "insert") and
+ text.compare("insert", "==", "end-1c")):
 return # Let the default binding (delete next char) take over
 if not self.executing:
 self.resetoutput()
@@ -1078,24 +1086,24 @@
 self.top.quit()
 return "break"
 
- def linefeed_callback(self, event):
+ def _linefeed_callback(self, event, text):
 # Insert a linefeed without entering anything (still autoindented)
 if self.reading:
- self.text.insert("insert", "\n")
- self.text.see("insert")
+ text.insert("insert", "\n")
+ text.see("insert")
 else:
 self.newline_and_indent_event(event)
 return "break"
 
- def enter_callback(self, event):
+ def _enter_callback(self, event, text):
 if self.executing and not self.reading:
 return # Let the default binding (insert '\n') take over
 # If some text is selected, recall the selection
 # (but only if this before the I/O mark)
 try:
- sel = self.text.get("sel.first", "sel.last")
+ sel = text.get("sel.first", "sel.last")
 if sel:
- if self.text.compare("sel.last", "<=", "iomark"):
+ if text.compare("sel.last", "<=", "iomark"):
 self.recall(sel, event)
 return "break"
 except:
@@ -1103,51 +1111,52 @@
 # If we're strictly before the line containing iomark, recall
 # the current line, less a leading prompt, less leading or
 # trailing whitespace
- if self.text.compare("insert", "<", "iomark linestart"):
+ if text.compare("insert", "<", "iomark linestart"):
 # Check if there's a relevant stdin range -- if so, use it
- prev = self.text.tag_prevrange("stdin", "insert")
- if prev and self.text.compare("insert", "<", prev[1]):
- self.recall(self.text.get(prev[0], prev[1]), event)
+ prev = text.tag_prevrange("stdin", "insert")
+ if prev and text.compare("insert", "<", prev[1]):
+ self.recall(text.get(prev[0], prev[1]), event)
 return "break"
- next = self.text.tag_nextrange("stdin", "insert")
- if next and self.text.compare("insert lineend", ">=", next[0]):
- self.recall(self.text.get(next[0], next[1]), event)
+ next = text.tag_nextrange("stdin", "insert")
+ if next and text.compare("insert lineend", ">=", next[0]):
+ self.recall(text.get(next[0], next[1]), event)
 return "break"
 # No stdin mark -- just get the current line, less any prompt
- indices = self.text.tag_nextrange("console", "insert linestart")
+ indices = text.tag_nextrange("console", "insert linestart")
 if indices and \
- self.text.compare(indices[0], "<=", "insert linestart"):
- self.recall(self.text.get(indices[1], "insert lineend"), event)
+ text.compare(indices[0], "<=", "insert linestart"):
+ self.recall(text.get(indices[1], "insert lineend"), event)
 else:
- self.recall(self.text.get("insert linestart", "insert lineend"), event)
+ self.recall(text.get("insert linestart", "insert lineend"),
+ event)
 return "break"
 # If we're between the beginning of the line and the iomark, i.e.
 # in the prompt area, move to the end of the prompt
- if self.text.compare("insert", "<", "iomark"):
- self.text.mark_set("insert", "iomark")
+ if text.compare("insert", "<", "iomark"):
+ text.mark_set("insert", "iomark")
 # If we're in the current input and there's only whitespace
 # beyond the cursor, erase that whitespace first
- s = self.text.get("insert", "end-1c")
+ s = text.get("insert", "end-1c")
 if s and not s.strip():
- self.text.delete("insert", "end-1c")
+ text.delete("insert", "end-1c")
 # If we're in the current input before its last line,
 # insert a newline right at the insert point
- if self.text.compare("insert", "<", "end-1c linestart"):
+ if text.compare("insert", "<", "end-1c linestart"):
 self.newline_and_indent_event(event)
 return "break"
 # We're in the last line; append a newline and submit it
- self.text.mark_set("insert", "end-1c")
+ text.mark_set("insert", "end-1c")
 if self.reading:
- self.text.insert("insert", "\n")
- self.text.see("insert")
+ text.insert("insert", "\n")
+ text.see("insert")
 else:
 self.newline_and_indent_event(event)
- self.text.tag_add("stdin", "iomark", "end-1c")
- self.text.update_idletasks()
+ text.tag_add("stdin", "iomark", "end-1c")
+ text.update_idletasks()
 if self.reading:
 self.top.quit() # Break out of recursive mainloop() in raw_input()
 else:
- self.runit()
+ self._runit(text)
 return "break"
 
 def recall(self, s, event):
@@ -1176,8 +1185,8 @@
 self.text.see("insert")
 self.text.undo_block_stop()
 
- def runit(self):
- line = self.text.get("iomark", "end-1c")
+ def _runit(self, text):
+ line = text.get("iomark", "end-1c")
 # Strip off last newline and surrounding whitespace.
 # (To allow you to hit return twice to end a statement.)
 i = len(line)
@@ -1199,14 +1208,14 @@
 tkMessageBox.showerror("No stack trace",
 "There is no stack trace yet.\n"
 "(sys.last_traceback is not defined)",
- master=self.text)
+ master=self.text_notebook)
 return
 from StackViewer import StackBrowser
 sv = StackBrowser(self.root, self.flist)
 
- def view_restart_mark(self, event=None):
- self.text.see("iomark")
- self.text.see("restart")
+ def _view_restart_mark(self, event=None, text=None):
+ text.see("iomark")
+ text.see("restart")
 
 def restart_shell(self, event=None):
 self.interp.restart_subprocess()
@@ -1226,8 +1235,8 @@
 
 def resetoutput(self):
 source = self.text.get("iomark", "end-1c")
- if self.history:
- self.history.history_store(source)
+ if self.textpage.history:
+ self.textpage.history.history_store(source)
 if self.text.get("end-2c") != "\n":
 self.text.insert("end-1c", "\n")
 self.text.mark_set("iomark", "end-1c")
Modified: sandbox/trunk/ttk-gsoc/src/idlelib/run.py
==============================================================================
--- sandbox/trunk/ttk-gsoc/src/idlelib/run.py	(original)
+++ sandbox/trunk/ttk-gsoc/src/idlelib/run.py	Wed Jul 30 14:34:19 2008
@@ -24,11 +24,13 @@
 except ImportError:
 pass
 else:
- def idle_formatwarning_subproc(message, category, filename, lineno):
+ def idle_formatwarning_subproc(message, category, filename, lineno,
+ line=None):
 """Format warnings the IDLE way"""
 s = "\nWarning (from warnings module):\n"
 s += ' File \"%s\", line %s\n' % (filename, lineno)
- line = linecache.getline(filename, lineno).strip()
+ if line is None:
+ line = linecache.getline(filename, lineno).strip()
 if line:
 s += " %s\n" % line
 s += "%s: %s\n" % (category.__name__, message)
