Initial revision
diff --git a/Lib/idlelib/OutputWindow.py b/Lib/idlelib/OutputWindow.py
new file mode 100644
index 0000000..12280ad
--- /dev/null
+++ b/Lib/idlelib/OutputWindow.py
@@ -0,0 +1,279 @@
+# changes by dscherer@cmu.edu
+# - OutputWindow and OnDemandOutputWindow have been hastily
+# extended to provide readline() support, an "iomark" separate
+# from the "insert" cursor, and scrolling to clear the window.
+# These changes are used by the ExecBinding module to provide
+# standard input and output for user programs. Many of the new
+# features are very similar to features of PyShell, which is a
+# subclass of OutputWindow. Someone should make some sense of
+# this.
+
+from Tkinter import *
+from EditorWindow import EditorWindow
+import re
+import tkMessageBox
+
+from UndoDelegator import UndoDelegator
+
+class OutputUndoDelegator(UndoDelegator):
+ reading = 0
+ # Forbid insert/delete before the I/O mark, in the blank lines after
+ # the output, or *anywhere* if we are not presently doing user input
+ def insert(self, index, chars, tags=None):
+ try:
+ if (self.delegate.compare(index, "<", "iomark") or
+ self.delegate.compare(index, ">", "endmark") or
+ (index!="iomark" and not self.reading)):
+ self.delegate.bell()
+ return
+ except TclError:
+ pass
+ UndoDelegator.insert(self, index, chars, tags)
+ def delete(self, index1, index2=None):
+ try:
+ if (self.delegate.compare(index1, "<", "iomark") or
+ self.delegate.compare(index1, ">", "endmark") or
+ (index2 and self.delegate.compare(index2, ">=", "endmark")) or
+ not self.reading):
+ self.delegate.bell()
+ return
+ except TclError:
+ pass
+ UndoDelegator.delete(self, index1, index2)
+
+class OutputWindow(EditorWindow):
+ """An editor window that can serve as an input and output file.
+ The input support has been rather hastily hacked in, and should
+ not be trusted.
+ """
+
+ UndoDelegator = OutputUndoDelegator
+ source_window = None
+
+ def __init__(self, *args, **keywords):
+ if keywords.has_key('source_window'):
+ self.source_window = keywords['source_window']
+ apply(EditorWindow.__init__, (self,) + args)
+ self.text.bind("<<goto-file-line>>", self.goto_file_line)
+ self.text.bind("<<newline-and-indent>>", self.enter_callback)
+ self.text.mark_set("iomark","1.0")
+ self.text.mark_gravity("iomark", LEFT)
+ self.text.mark_set("endmark","1.0")
+
+ # Customize EditorWindow
+
+ def ispythonsource(self, filename):
+ # No colorization needed
+ return 0
+
+ def short_title(self):
+ return "Output"
+
+ def long_title(self):
+ return ""
+
+ def maybesave(self):
+ # Override base class method -- don't ask any questions
+ if self.get_saved():
+ return "yes"
+ else:
+ return "no"
+
+ # Act as input file - incomplete
+
+ def set_line_and_column(self, event=None):
+ index = self.text.index(INSERT)
+ if (self.text.compare(index, ">", "endmark")):
+ self.text.mark_set("insert", "endmark")
+ self.text.see("insert")
+ EditorWindow.set_line_and_column(self)
+
+ reading = 0
+ canceled = 0
+ endoffile = 0
+
+ def readline(self):
+ save = self.reading
+ try:
+ self.reading = self.undo.reading = 1
+ self.text.mark_set("insert", "iomark")
+ self.text.see("insert")
+ self.top.mainloop()
+ finally:
+ self.reading = self.undo.reading = save
+ line = self.text.get("input", "iomark")
+ if self.canceled:
+ self.canceled = 0
+ raise KeyboardInterrupt
+ if self.endoffile:
+ self.endoffile = 0
+ return ""
+ return line or '\n'
+
+ def close(self):
+ self.interrupt()
+ return EditorWindow.close(self)
+
+ def interrupt(self):
+ if self.reading:
+ self.endoffile = 1
+ self.top.quit()
+
+ def enter_callback(self, event):
+ if self.reading and self.text.compare("insert", ">=", "iomark"):
+ self.text.mark_set("input", "iomark")
+ self.text.mark_set("iomark", "insert")
+ self.write('\n',"iomark")
+ self.text.tag_add("stdin", "input", "iomark")
+ self.text.update_idletasks()
+ self.top.quit() # Break out of recursive mainloop() in raw_input()
+
+ return "break"
+
+ # Act as output file
+
+ def write(self, s, tags=(), mark="iomark"):
+ self.text.mark_gravity(mark, RIGHT)
+ self.text.insert(mark, str(s), tags)
+ self.text.mark_gravity(mark, LEFT)
+ self.text.see(mark)
+ self.text.update()
+
+ def writelines(self, l):
+ map(self.write, l)
+
+ def flush(self):
+ pass
+
+ # Our own right-button menu
+
+ rmenu_specs = [
+ ("Go to file/line", "<<goto-file-line>>"),
+ ]
+
+ file_line_pats = [
+ r'file "([^"]*)", line (\d+)',
+ r'([^\s]+)\((\d+)\)',
+ r'([^\s]+):\s*(\d+):',
+ ]
+
+ file_line_progs = None
+
+ def goto_file_line(self, event=None):
+ if self.file_line_progs is None:
+ l = []
+ for pat in self.file_line_pats:
+ l.append(re.compile(pat, re.IGNORECASE))
+ self.file_line_progs = l
+ # x, y = self.event.x, self.event.y
+ # self.text.mark_set("insert", "@%d,%d" % (x, y))
+ line = self.text.get("insert linestart", "insert lineend")
+ result = self._file_line_helper(line)
+ if not result:
+ # Try the previous line. This is handy e.g. in tracebacks,
+ # where you tend to right-click on the displayed source line
+ line = self.text.get("insert -1line linestart",
+ "insert -1line lineend")
+ result = self._file_line_helper(line)
+ if not result:
+ tkMessageBox.showerror(
+ "No special line",
+ "The line you point at doesn't look like "
+ "a valid file name followed by a line number.",
+ master=self.text)
+ return
+ filename, lineno = result
+ edit = self.untitled(filename) or self.flist.open(filename)
+ edit.gotoline(lineno)
+ edit.wakeup()
+
+ def untitled(self, filename):
+ if filename!='Untitled' or not self.source_window or self.source_window.io.filename:
+ return None
+ return self.source_window
+
+ def _file_line_helper(self, line):
+ for prog in self.file_line_progs:
+ m = prog.search(line)
+ if m:
+ break
+ else:
+ return None
+ filename, lineno = m.group(1, 2)
+ if not self.untitled(filename):
+ try:
+ f = open(filename, "r")
+ f.close()
+ except IOError:
+ return None
+ try:
+ return filename, int(lineno)
+ except TypeError:
+ return None
+
+# This classes now used by ExecBinding.py:
+
+class OnDemandOutputWindow:
+ source_window = None
+
+ tagdefs = {
+ # XXX Should use IdlePrefs.ColorPrefs
+ "stdin": {"foreground": "black"},
+ "stdout": {"foreground": "blue"},
+ "stderr": {"foreground": "red"},
+ }
+
+ def __init__(self, flist):
+ self.flist = flist
+ self.owin = None
+ self.title = "Output"
+ self.close_hook = None
+ self.old_close = None
+
+ def owclose(self):
+ if self.close_hook:
+ self.close_hook()
+ if self.old_close:
+ self.old_close()
+
+ def set_title(self, title):
+ self.title = title
+ if self.owin and self.owin.text:
+ self.owin.saved_change_hook()
+
+ def write(self, s, tags=(), mark="iomark"):
+ if not self.owin or not self.owin.text:
+ self.setup()
+ self.owin.write(s, tags, mark)
+
+ def readline(self):
+ if not self.owin or not self.owin.text:
+ self.setup()
+ return self.owin.readline()
+
+ def scroll_clear(self):
+ if self.owin and self.owin.text:
+ lineno = self.owin.getlineno("endmark")
+ self.owin.text.mark_set("insert","endmark")
+ self.owin.text.yview(float(lineno))
+ self.owin.wakeup()
+
+ def setup(self):
+ self.owin = owin = OutputWindow(self.flist, source_window = self.source_window)
+ owin.short_title = lambda self=self: self.title
+ text = owin.text
+
+ self.old_close = owin.close_hook
+ owin.close_hook = self.owclose
+
+ # xxx Bad hack: 50 blank lines at the bottom so that
+ # we can scroll the top of the window to the output
+ # cursor in scroll_clear(). There must be a better way...
+ owin.text.mark_gravity('endmark', LEFT)
+ owin.text.insert('iomark', '\n'*50)
+ owin.text.mark_gravity('endmark', RIGHT)
+
+ for tag, cnf in self.tagdefs.items():
+ if cnf:
+ apply(text.tag_configure, (tag,), cnf)
+ text.tag_raise('sel')