Initial revision
diff --git a/Demo/stdwin/python.py b/Demo/stdwin/python.py
new file mode 100755
index 0000000..bb85316
--- /dev/null
+++ b/Demo/stdwin/python.py
@@ -0,0 +1,514 @@
+#! /usr/local/python
+
+XXX This file needs some work for Python 0.9.6!!!
+
+# A STDWIN-based front end for the Python interpreter.
+#
+# This is useful if you want to avoid console I/O and instead
+# use text windows to issue commands to the interpreter.
+#
+# It supports multiple interpreter windows, each with its own context.
+#
+# BUGS AND CAVEATS:
+#
+# Although this supports multiple windows, the whole application
+# is deaf and dumb when a command is running in one window.
+#
+# Everything written to stdout or stderr is saved on a file which
+# is inserted in the window at the next input request.
+#
+# On UNIX (using X11), interrupts typed in the window will not be
+# seen until the next input request. (On the Mac, interrupts work.)
+#
+# Direct input from stdin should not be attempted.
+
+
+import sys
+import builtin
+import stdwin
+from stdwinevents import *
+import rand
+import mainloop
+
+from util import readfile # 0.9.1
+
+try:
+ import mac
+ os = mac
+except NameError:
+ import posix
+ os = posix
+
+
+# Filename used to capture output from commands; change to suit your taste
+#
+OUTFILE = '@python.stdout.tmp'
+
+
+# Stack of windows waiting for [raw_]input().
+# Element [0] is the top.
+# If there are multiple windows waiting for input, only the
+# one on top of the stack can accept input, because the way
+# raw_input() is implemented (using recursive mainloop() calls).
+#
+inputwindows = []
+
+
+# Exception raised when input is available.
+#
+InputAvailable = 'input available for raw_input (not an error)'
+
+
+# Main program. Create the window and call the mainloop.
+#
+def main():
+ # Hack so 'import python' won't load another copy
+ # of this if we were loaded though 'python python.py'.
+ # (Should really look at sys.argv[0]...)
+ if 'inputwindows' in dir(sys.modules['__main__']) and \
+ sys.modules['__main__'].inputwindows is inputwindows:
+ sys.modules['python'] = sys.modules['__main__']
+ #
+ win = makewindow()
+ mainloop.mainloop()
+
+
+# Create a new window.
+#
+def makewindow():
+ # stdwin.setdefscrollbars(0, 1) # Not in Python 0.9.1
+ # stdwin.setfont('monaco') # Not on UNIX! and not Python 0.9.1
+ # stdwin.setdefwinsize(stdwin.textwidth('in')*40, stdwin.lineheight() * 24)
+ win = stdwin.open('Python interpreter ready')
+ win.editor = win.textcreate((0,0), win.getwinsize())
+ win.outfile = OUTFILE + `rand.rand()`
+ win.globals = {} # Dictionary for user's global variables
+ win.command = '' # Partially read command
+ win.busy = 0 # Ready to accept a command
+ win.auto = 1 # [CR] executes command
+ win.insertOutput = 1 # Insert output at focus.
+ win.insertError = 1 # Insert error output at focus.
+ win.setwincursor('ibeam')
+ win.filename = '' # Empty if no file associated with this window
+ makefilemenu(win)
+ makeeditmenu(win)
+ win.dispatch = pdispatch # Event dispatch function
+ mainloop.register(win)
+ return win
+
+
+# Make a 'File' menu
+#
+def makefilemenu(win):
+ win.filemenu = mp = win.menucreate('File')
+ mp.callback = []
+ additem(mp, 'New', 'N', do_new)
+ additem(mp, 'Open...', 'O', do_open)
+ additem(mp, '', '', None)
+ additem(mp, 'Close', 'W', do_close)
+ additem(mp, 'Save', 'S', do_save)
+ additem(mp, 'Save as...', '', do_saveas)
+ additem(mp, '', '', None)
+ additem(mp, 'Quit', 'Q', do_quit)
+
+
+# Make an 'Edit' menu
+#
+def makeeditmenu(win):
+ win.editmenu = mp = win.menucreate('Edit')
+ mp.callback = []
+ additem(mp, 'Cut', 'X', do_cut)
+ additem(mp, 'Copy', 'C', do_copy)
+ additem(mp, 'Paste', 'V', do_paste)
+ additem(mp, 'Clear', '', do_clear)
+ additem(mp, '', '', None)
+ win.iauto = len(mp.callback)
+ additem(mp, 'Autoexecute', '', do_auto)
+ mp.check(win.iauto, win.auto)
+ win.insertOutputNum = len(mp.callback)
+ additem(mp, 'Insert Output', '', do_insertOutputOption)
+ win.insertErrorNum = len(mp.callback)
+ additem(mp, 'Insert Error', '', do_insertErrorOption)
+ additem(mp, 'Exec', '\r', do_exec)
+
+
+# Helper to add a menu item and callback function
+#
+def additem(mp, text, shortcut, handler):
+ if shortcut:
+ mp.additem(text, shortcut)
+ else:
+ mp.additem(text)
+ mp.callback.append(handler)
+
+
+# Dispatch a single event to the interpreter.
+# Resize events cause a resize of the editor.
+# Other events are directly sent to the editor.
+#
+# Exception: WE_COMMAND/WC_RETURN causes the current selection
+# (if not empty) or current line (if empty) to be sent to the
+# interpreter. (In the future, there should be a way to insert
+# newlines in the text; or perhaps Enter or Meta-RETURN should be
+# used to trigger execution, like in MPW, though personally I prefer
+# using a plain Return to trigger execution, as this is what I want
+# in the majority of cases.)
+#
+# Also, WE_COMMAND/WC_CANCEL cancels any command in progress.
+#
+def pdispatch(event):
+ type, win, detail = event
+ if type == WE_CLOSE:
+ do_close(win)
+ elif type == WE_SIZE:
+ win.editor.move((0, 0), win.getwinsize())
+ elif type == WE_COMMAND and detail == WC_RETURN:
+ if win.auto:
+ do_exec(win)
+ else:
+ void = win.editor.event(event)
+ elif type == WE_COMMAND and detail == WC_CANCEL:
+ if win.busy:
+ raise InputAvailable, (EOFError, None)
+ else:
+ win.command = ''
+ settitle(win)
+ elif type == WE_MENU:
+ mp, item = detail
+ mp.callback[item](win)
+ else:
+ void = win.editor.event(event)
+ if win.editor:
+ # May have been deleted by close...
+ win.setdocsize(0, win.editor.getrect()[1][1])
+ if type in (WE_CHAR, WE_COMMAND):
+ win.editor.setfocus(win.editor.getfocus())
+
+
+# Helper to set the title of the window.
+#
+def settitle(win):
+ if win.filename == '':
+ win.settitle('Python interpreter ready')
+ else:
+ win.settitle(win.filename)
+
+
+# Helper to replace the text of the focus.
+#
+def replace(win, text):
+ win.editor.replace(text)
+ # Resize the window to display the text
+ win.setdocsize(0, win.editor.getrect()[1][1]) # update the size before..
+ win.editor.setfocus(win.editor.getfocus()) # move focus to the change - dml
+
+
+# File menu handlers
+#
+def do_new(win):
+ win = makewindow()
+#
+def do_open(win):
+ try:
+ filename = stdwin.askfile('Open file', '', 0)
+ win = makewindow()
+ win.filename = filename
+ win.editor.replace(readfile(filename)) # 0.9.1
+ # win.editor.replace(open(filename, 'r').read()) # 0.9.2
+ win.editor.setfocus(0, 0)
+ win.settitle(win.filename)
+ #
+ except KeyboardInterrupt:
+ pass # Don't give an error on cancel.
+#
+def do_save(win):
+ try:
+ if win.filename == '':
+ win.filename = stdwin.askfile('Open file', '', 1)
+ f = open(win.filename, 'w')
+ f.write(win.editor.gettext())
+ #
+ except KeyboardInterrupt:
+ pass # Don't give an error on cancel.
+
+def do_saveas(win):
+ currentFilename = win.filename
+ win.filename = ''
+ do_save(win) # Use do_save with empty filename
+ if win.filename == '': # Restore the name if do_save did not set it.
+ win.filename = currentFilename
+#
+def do_close(win):
+ if win.busy:
+ stdwin.message('Can\'t close busy window')
+ return # need to fail if quitting??
+ win.editor = None # Break circular reference
+ #del win.editmenu # What about the filemenu??
+ try:
+ os.unlink(win.outfile)
+ except os.error:
+ pass
+ mainloop.unregister(win)
+#
+def do_quit(win):
+ # Call win.dispatch instead of do_close because there
+ # may be 'alien' windows in the list.
+ for win in mainloop.windows:
+ mainloop.dispatch(WE_CLOSE, win, None) # need to catch failed close
+
+
+# Edit menu handlers
+#
+def do_cut(win):
+ text = win.editor.getfocustext()
+ if not text:
+ stdwin.fleep()
+ return
+ stdwin.setcutbuffer(0, text)
+ replace(win, '')
+#
+def do_copy(win):
+ text = win.editor.getfocustext()
+ if not text:
+ stdwin.fleep()
+ return
+ stdwin.setcutbuffer(0, text)
+#
+def do_paste(win):
+ text = stdwin.getcutbuffer(0)
+ if not text:
+ stdwin.fleep()
+ return
+ replace(win, text)
+#
+def do_clear(win):
+ replace(win, '')
+
+#
+# These would be better in a preferences dialog:
+def do_auto(win):
+ win.auto = (not win.auto)
+ win.editmenu.check(win.iauto, win.auto)
+#
+def do_insertOutputOption(win):
+ win.insertOutput = (not win.insertOutput)
+ title = ['Append Output', 'Insert Output'][win.insertOutput]
+ win.editmenu.setitem(win.insertOutputNum, title)
+#
+def do_insertErrorOption(win):
+ win.insertError = (not win.insertError)
+ title = ['Error Dialog', 'Insert Error'][win.insertError]
+ win.editmenu.setitem(win.insertErrorNum, title)
+
+
+# Extract a command from the editor and execute it, or pass input to
+# an interpreter waiting for it.
+# Incomplete commands are merely placed in the window's command buffer.
+# All exceptions occurring during the execution are caught and reported.
+# (Tracebacks are currently not possible, as the interpreter does not
+# save the traceback pointer until it reaches its outermost level.)
+#
+def do_exec(win):
+ if win.busy:
+ if win not in inputwindows:
+ stdwin.message('Can\'t run recursive commands')
+ return
+ if win <> inputwindows[0]:
+ stdwin.message( \
+ 'Please complete recursive input first')
+ return
+ #
+ # Set text to the string to execute.
+ a, b = win.editor.getfocus()
+ alltext = win.editor.gettext()
+ n = len(alltext)
+ if a == b:
+ # There is no selected text, just an insert point;
+ # so execute the current line.
+ while 0 < a and alltext[a-1] <> '\n': a = a-1 # Find beginning of line.
+ while b < n and alltext[b] <> '\n': # Find end of line after b.
+ b = b+1
+ text = alltext[a:b] + '\n'
+ else:
+ # Execute exactly the selected text.
+ text = win.editor.getfocustext()
+ if text[-1:] <> '\n': # Make sure text ends with newline.
+ text = text + '\n'
+ while b < n and alltext[b] <> '\n': # Find end of line after b.
+ b = b+1
+ #
+ # Set the focus to expect the output, since there is always something.
+ # Output will be inserted at end of line after current focus,
+ # or appended to the end of the text.
+ b = [n, b][win.insertOutput]
+ win.editor.setfocus(b, b)
+ #
+ # Make sure there is a preceeding newline.
+ if alltext[b-1:b] <> '\n':
+ win.editor.replace('\n')
+ #
+ #
+ if win.busy:
+ # Send it to raw_input() below
+ raise InputAvailable, (None, text)
+ #
+ # Like the real Python interpreter, we want to execute
+ # single-line commands immediately, but save multi-line
+ # commands until they are terminated by a blank line.
+ # Unlike the real Python interpreter, we don't do any syntax
+ # checking while saving up parts of a multi-line command.
+ #
+ # The current heuristic to determine whether a command is
+ # the first line of a multi-line command simply checks whether
+ # the command ends in a colon (followed by a newline).
+ # This is not very robust (comments and continuations will
+ # confuse it), but it is usable, and simple to implement.
+ # (It even has the advantage that single-line loops etc.
+ # don't need te be terminated by a blank line.)
+ #
+ if win.command:
+ # Already continuing
+ win.command = win.command + text
+ if win.command[-2:] <> '\n\n':
+ win.settitle('Unfinished command...')
+ return # Need more...
+ else:
+ # New command
+ win.command = text
+ if text[-2:] == ':\n':
+ win.settitle('Unfinished command...')
+ return
+ command = win.command
+ win.command = ''
+ win.settitle('Executing command...')
+ #
+ # Some hacks: sys.stdout is temporarily redirected to a file,
+ # so we can intercept the command's output and insert it
+ # in the editor window; the built-in function raw_input
+ # and input() are replaced by out versions;
+ # and a second, undocumented argument
+ # to exec() is used to specify the directory holding the
+ # user's global variables. (If this wasn't done, the
+ # exec would be executed in the current local environment,
+ # and the user's assignments to globals would be lost...)
+ #
+ save_input = builtin.input
+ save_raw_input = builtin.raw_input
+ save_stdout = sys.stdout
+ save_stderr = sys.stderr
+ iwin = Input().init(win)
+ try:
+ builtin.input = iwin.input
+ builtin.raw_input = iwin.raw_input
+ sys.stdout = sys.stderr = open(win.outfile, 'w')
+ win.busy = 1
+ try:
+ exec(command, win.globals)
+ except KeyboardInterrupt:
+ pass # Don't give an error.
+ except:
+ msg = sys.exc_type
+ if sys.exc_value <> None:
+ msg = msg + ': ' + `sys.exc_value`
+ if win.insertError:
+ stdwin.fleep()
+ replace(win, msg + '\n')
+ else:
+ win.settitle('Unhandled exception')
+ stdwin.message(msg)
+ finally:
+ # Restore redirected I/O in *all* cases
+ win.busy = 0
+ sys.stderr = save_stderr
+ sys.stdout = save_stdout
+ builtin.raw_input = save_raw_input
+ builtin.input = save_input
+ settitle(win)
+ getoutput(win)
+
+
+# Read any output the command may have produced back from the file
+# and show it. Optionally insert it after the focus, like MPW does,
+# or always append at the end.
+#
+def getoutput(win):
+ filename = win.outfile
+ try:
+ fp = open(filename, 'r')
+ except:
+ stdwin.message('Can\'t read output from ' + filename)
+ return
+ #out = fp.read() # Not in Python 0.9.1
+ out = fp.read(10000) # For Python 0.9.1
+ del fp # Close it
+ if out or win.insertOutput:
+ replace(win, out)
+
+
+# Implementation of input() and raw_input().
+# This uses a class only because we must support calls
+# with and without arguments; this can't be done normally in Python,
+# but the extra, implicit argument for instance methods does the trick.
+#
+class Input:
+ #
+ def init(self, win):
+ self.win = win
+ return self
+ #
+ def input(args):
+ # Hack around call with or without argument:
+ if type(args) == type(()):
+ self, prompt = args
+ else:
+ self, prompt = args, ''
+ #
+ return eval(self.raw_input(prompt), self.win.globals)
+ #
+ def raw_input(args):
+ # Hack around call with or without argument:
+ if type(args) == type(()):
+ self, prompt = args
+ else:
+ self, prompt = args, ''
+ #
+ print prompt # Need to terminate with newline.
+ sys.stdout.close()
+ sys.stdout = sys.stderr = None
+ getoutput(self.win)
+ sys.stdout = sys.stderr = open(self.win.outfile, 'w')
+ save_title = self.win.gettitle()
+ n = len(inputwindows)
+ title = n*'(' + 'Requesting input...' + ')'*n
+ self.win.settitle(title)
+ inputwindows.insert(0, self.win)
+ try:
+ mainloop.mainloop()
+ except InputAvailable, (exc, val): # See do_exec above.
+ if exc:
+ raise exc, val
+ if val[-1:] == '\n':
+ val = val[:-1]
+ return val
+ finally:
+ del inputwindows[0]
+ self.win.settitle(save_title)
+ # If we don't catch InputAvailable, something's wrong...
+ raise EOFError
+ #
+
+
+# Currently unused function to test a command's syntax without executing it
+#
+def testsyntax(s):
+ import string
+ lines = string.splitfields(s, '\n')
+ for i in range(len(lines)): lines[i] = '\t' + lines[i]
+ lines.insert(0, 'if 0:')
+ lines.append('')
+ exec(string.joinfields(lines, '\n'))
+
+
+# Call the main program.
+#
+main()