#! /usr/bin/env python
# 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:
#
# This was written long ago as a demonstration, and slightly hacked to
# keep it up-to-date, but never as an industry-strength alternative
# interface to Python. It should be rewritten using more classes, and
# merged with something like wdb.
#
# Although this supports multiple windows, the whole application
# is deaf and dumb when a command is running in one window.
#
# Interrupt is (ab)used to signal EOF on input requests.
#
# On UNIX (using X11), interrupts typed in the window will not be
# seen until the next input or output operation. When you are stuck
# in an infinite loop, try typing ^C in the shell window where you
# started this interpreter. (On the Mac, interrupts work normally.)
import sys
import stdwin
from stdwinevents import *
import rand
import mainloop
import os
# 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
# width, height = stdwin.textwidth('in')*40, stdwin.lineheight()*24
# stdwin.setdefwinsize(width, height)
win = stdwin.open('Python interpreter ready')
win.editor = win.textcreate((0,0), win.getwinsize())
win.globals = {} # Dictionary for user's globals
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 for 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.
# Some events are treated specially.
# Most other events are passed directly to the editor.
#
def pdispatch(event):
type, win, detail = event
if not win:
win = stdwin.getactive()
if not win: return
if type == WE_CLOSE:
do_close(win)
return
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 KeyboardInterrupt
else:
win.command = ''
settitle(win)
elif type == WE_MENU:
mp, item = detail
mp.callback[item](win)
else:
void = win.editor.event(event)
if win in mainloop.windows:
# 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
# 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(open(filename, 'r').read())
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??
mainloop.unregister(win)
win.close()
#
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': # Find beginning of line
a = a-1
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 \n
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, 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:
# - The standard files are replaced by an IOWindow instance.
# - A 2nd 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_stdin = sys.stdin
save_stdout = sys.stdout
save_stderr = sys.stderr
try:
sys.stdin = sys.stdout = sys.stderr = IOWindow(win)
win.busy = 1
try:
exec(command, win.globals)
except KeyboardInterrupt:
print '[Interrupt]'
except:
if type(sys.exc_type) == type(''):
msg = sys.exc_type
else: msg = sys.exc_type.__name__
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
sys.stdin = save_stdin
settitle(win)
# Class emulating file I/O from/to a window
#
class IOWindow:
#
def __init__(self, win):
self.win = win
#
def readline(self, *unused_args):
n = len(inputwindows)
save_title = self.win.gettitle()
title = n*'(' + 'Requesting input...' + ')'*n
self.win.settitle(title)
inputwindows.insert(0, self.win)
try:
try:
mainloop.mainloop()
finally:
del inputwindows[0]
self.win.settitle(save_title)
except InputAvailable, val: # See do_exec above
return val
except KeyboardInterrupt:
raise EOFError # Until we have a "send EOF" key
# If we didn't catch InputAvailable, something's wrong...
raise EOFError
#
def write(self, text):
mainloop.check()
replace(self.win, text)
mainloop.check()
# 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()
|