wxPython/wxPython/lib/PyCrust/shell.py

   1 """The PyCrust Shell is an interactive text control in which a user types in
   2 commands to be sent to the interpreter. This particular shell is based on
   3 wxPython's wxStyledTextCtrl. The latest files are always available at the
   4 SourceForge project page at http://sourceforge.net/projects/pycrust/."""
   5
   6 __author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
   7 __cvsid__ = "$Id$"
   8 __version__ = "$Revision$"[11:-2]
   9
  10 from wxPython.wx import *
  11 from wxPython.stc import *
  12 import keyword
  13 import os
  14 import sys
  15 from pseudo import PseudoFileIn
  16 from pseudo import PseudoFileOut
  17 from pseudo import PseudoFileErr
  18 from version import VERSION
  19
  20
  21 if wxPlatform == '__WXMSW__':
  22     faces = { 'times'  : 'Times New Roman',
  23               'mono'   : 'Courier New',
  24               'helv'   : 'Lucida Console',
  25               'lucida' : 'Lucida Console',
  26               'other'  : 'Comic Sans MS',
  27               'size'   : 10,
  28               'lnsize' : 9,
  29               'backcol': '#FFFFFF',
  30             }
  31     # Versions of wxPython prior to 2.3.2 had a sizing bug on Win platform.
  32     # The font was 2 points too large. So we need to reduce the font size.
  33     if ((wxMAJOR_VERSION, wxMINOR_VERSION) == (2, 3) and wxRELEASE_NUMBER < 2) \
  34     or (wxMAJOR_VERSION <= 2 and wxMINOR_VERSION <= 2):
  35         faces['size'] -= 2
  36         faces['lnsize'] -= 2
  37 else:  # GTK
  38     faces = { 'times'  : 'Times',
  39               'mono'   : 'Courier',
  40               'helv'   : 'Helvetica',
  41               'other'  : 'new century schoolbook',
  42               'size'   : 12,
  43               'lnsize' : 10,
  44               'backcol': '#FFFFFF',
  45             }
  46
  47
  48 class ShellFacade:
  49     """Simplified interface to all shell-related functionality.
  50
  51     This is a semi-transparent facade, in that all attributes of other are
  52     still accessible, even though only some are visible to the user."""
  53
  54     name = 'PyCrust Shell Interface'
  55     revision = __version__
  56
  57     def __init__(self, other):
  58         """Create a ShellFacade instance."""
  59         methods = ['ask',
  60                    'clear',
  61                    'pause',
  62                    'prompt',
  63                    'quit',
  64                    'redirectStderr',
  65                    'redirectStdin',
  66                    'redirectStdout',
  67                    'run',
  68                    'runfile',
  69                   ]
  70         for method in methods:
  71             self.__dict__[method] = getattr(other, method)
  72         d = self.__dict__
  73         d['other'] = other
  74         d['help'] = 'There is no help available, yet.'
  75
  76
  77     def __getattr__(self, name):
  78         if hasattr(self.other, name):
  79             return getattr(self.other, name)
  80         else:
  81             raise AttributeError, name
  82
  83     def __setattr__(self, name, value):
  84         if self.__dict__.has_key(name):
  85             self.__dict__[name] = value
  86         elif hasattr(self.other, name):
  87             return setattr(self.other, name, value)
  88         else:
  89             raise AttributeError, name
  90
  91     def _getAttributeNames(self):
  92         """Return list of magic attributes to extend introspection."""
  93         list = ['autoCallTip',
  94                 'autoComplete',
  95                 'autoCompleteCaseInsensitive',
  96                 'autoCompleteIncludeDouble',
  97                 'autoCompleteIncludeMagic',
  98                 'autoCompleteIncludeSingle',
  99                ]
 100         list.sort()
 101         return list
 102
 103
 104 class Shell(wxStyledTextCtrl):
 105     """PyCrust Shell based on wxStyledTextCtrl."""
 106
 107     name = 'PyCrust Shell'
 108     revision = __version__
 109
 110     def __init__(self, parent, id=-1, pos=wxDefaultPosition, \
 111                  size=wxDefaultSize, style=wxCLIP_CHILDREN, introText='', \
 112                  locals=None, InterpClass=None, *args, **kwds):
 113         """Create a PyCrust Shell instance."""
 114         wxStyledTextCtrl.__init__(self, parent, id, pos, size, style)
 115         # Grab these so they can be restored by self.redirect* methods.
 116         self.stdin = sys.stdin
 117         self.stdout = sys.stdout
 118         self.stderr = sys.stderr
 119         # Add the current working directory "." to the search path.
 120         sys.path.insert(0, os.curdir)
 121         # Import a default interpreter class if one isn't provided.
 122         if InterpClass == None:
 123             from interpreter import Interpreter
 124         else:
 125             Interpreter = InterpClass
 126         # Create default locals so we have something interesting.
 127         shellLocals = {'__name__': 'PyCrust-Shell',
 128                        '__doc__': 'PyCrust-Shell, The PyCrust Python Shell.',
 129                        '__version__': VERSION,
 130                       }
 131         # Add the dictionary that was passed in.
 132         if locals:
 133             shellLocals.update(locals)
 134         self.interp = Interpreter(locals=shellLocals, \
 135                                   rawin=self.readRaw, \
 136                                   stdin=PseudoFileIn(self.readIn), \
 137                                   stdout=PseudoFileOut(self.writeOut), \
 138                                   stderr=PseudoFileErr(self.writeErr), \
 139                                   *args, **kwds)
 140         # Keep track of the most recent prompt starting and ending positions.
 141         self.promptPos = [0, 0]
 142         # Keep track of the most recent non-continuation prompt.
 143         self.prompt1Pos = [0, 0]
 144         # Keep track of multi-line commands.
 145         self.more = 0
 146         # Create the command history.  Commands are added into the front of
 147         # the list (ie. at index 0) as they are entered. self.historyIndex
 148         # is the current position in the history; it gets incremented as you
 149         # retrieve the previous command, decremented as you retrieve the
 150         # next, and reset when you hit Enter. self.historyIndex == -1 means
 151         # you're on the current command, not in the history.
 152         self.history = []
 153         self.historyIndex = -1
 154         # Assign handlers for keyboard events.
 155         EVT_KEY_DOWN(self, self.OnKeyDown)
 156         EVT_CHAR(self, self.OnChar)
 157         # Configure various defaults and user preferences.
 158         self.config()
 159         # Display the introductory banner information.
 160         try: self.showIntro(introText)
 161         except: pass
 162         # Assign some pseudo keywords to the interpreter's namespace.
 163         try: self.setBuiltinKeywords()
 164         except: pass
 165         # Add 'shell' to the interpreter's local namespace.
 166         try: self.setLocalShell()
 167         except: pass
 168         # Do this last so the user has complete control over their
 169         # environment. They can override anything they want.
 170         try: self.execStartupScript(self.interp.startupScript)
 171         except: pass
 172
 173     def destroy(self):
 174         del self.interp
 175
 176     def config(self):
 177         """Configure shell based on user preferences."""
 178         self.SetMarginType(1, wxSTC_MARGIN_NUMBER)
 179         self.SetMarginWidth(1, 40)
 180
 181         self.SetLexer(wxSTC_LEX_PYTHON)
 182         self.SetKeyWords(0, ' '.join(keyword.kwlist))
 183
 184         self.setStyles(faces)
 185         self.SetViewWhiteSpace(0)
 186         self.SetTabWidth(4)
 187         self.SetUseTabs(0)
 188         # Do we want to automatically pop up command completion options?
 189         self.autoComplete = 1
 190         self.autoCompleteIncludeMagic = 1
 191         self.autoCompleteIncludeSingle = 1
 192         self.autoCompleteIncludeDouble = 1
 193         self.autoCompleteCaseInsensitive = 1
 194         self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive)
 195         # De we want to automatically pop up command argument help?
 196         self.autoCallTip = 1
 197         self.CallTipSetBackground(wxColour(255, 255, 232))
 198
 199     def showIntro(self, text=''):
 200         """Display introductory text in the shell."""
 201         if text:
 202             if not text.endswith(os.linesep): text += os.linesep
 203             self.write(text)
 204         try:
 205             self.write(self.interp.introText)
 206         except AttributeError:
 207             pass
 208
 209     def setBuiltinKeywords(self):
 210         """Create pseudo keywords as part of builtins.
 211
 212         This is a rather clever hack that sets "close", "exit" and "quit"
 213         to a PseudoKeyword object so that we can make them do what we want.
 214         In this case what we want is to call our self.quit() method.
 215         The user can type "close", "exit" or "quit" without the final parens.
 216         """
 217 ## POB: This is having some weird side-effects so I'm taking it out.
 218 ##        import __builtin__
 219 ##        from pseudo import PseudoKeyword
 220 ##        __builtin__.close = __builtin__.exit = __builtin__.quit = \
 221 ##            PseudoKeyword(self.quit)
 222         import __builtin__
 223         from pseudo import PseudoKeyword
 224         __builtin__.close = __builtin__.exit = __builtin__.quit = \
 225             'Click on the close button to leave the application.'
 226
 227     def quit(self):
 228         """Quit the application."""
 229
 230         # XXX Good enough for now but later we want to send a close event.
 231
 232         # In the close event handler we can make sure they want to quit.
 233         # Other applications, like PythonCard, may choose to hide rather than
 234         # quit so we should just post the event and let the surrounding app
 235         # decide what it wants to do.
 236         self.write('Click on the close button to leave the application.')
 237
 238     def setLocalShell(self):
 239         """Add 'shell' to locals as reference to ShellFacade instance."""
 240         self.interp.locals['shell'] = ShellFacade(other=self)
 241
 242     def execStartupScript(self, startupScript):
 243         """Execute the user's PYTHONSTARTUP script if they have one."""
 244         if startupScript and os.path.isfile(startupScript):
 245             startupText = 'Startup script executed: ' + startupScript
 246             self.push('print %s;execfile(%s)' % \
 247                       (`startupText`, `startupScript`))
 248         else:
 249             self.push('')
 250
 251     def setStyles(self, faces):
 252         """Configure font size, typeface and color for lexer."""
 253
 254         # Default style
 255         self.StyleSetSpec(wxSTC_STYLE_DEFAULT, "face:%(mono)s,size:%(size)d" % faces)
 256
 257         self.StyleClearAll()
 258
 259         # Built in styles
 260         self.StyleSetSpec(wxSTC_STYLE_LINENUMBER, "back:#C0C0C0,face:%(mono)s,size:%(lnsize)d" % faces)
 261         self.StyleSetSpec(wxSTC_STYLE_CONTROLCHAR, "face:%(mono)s" % faces)
 262         self.StyleSetSpec(wxSTC_STYLE_BRACELIGHT, "fore:#0000FF,back:#FFFF88")
 263         self.StyleSetSpec(wxSTC_STYLE_BRACEBAD, "fore:#FF0000,back:#FFFF88")
 264
 265         # Python styles
 266         self.StyleSetSpec(wxSTC_P_DEFAULT, "face:%(mono)s" % faces)
 267         self.StyleSetSpec(wxSTC_P_COMMENTLINE, "fore:#007F00,face:%(mono)s" % faces)
 268         self.StyleSetSpec(wxSTC_P_NUMBER, "")
 269         self.StyleSetSpec(wxSTC_P_STRING, "fore:#7F007F,face:%(mono)s" % faces)
 270         self.StyleSetSpec(wxSTC_P_CHARACTER, "fore:#7F007F,face:%(mono)s" % faces)
 271         self.StyleSetSpec(wxSTC_P_WORD, "fore:#00007F,bold")
 272         self.StyleSetSpec(wxSTC_P_TRIPLE, "fore:#7F0000")
 273         self.StyleSetSpec(wxSTC_P_TRIPLEDOUBLE, "fore:#000033,back:#FFFFE8")
 274         self.StyleSetSpec(wxSTC_P_CLASSNAME, "fore:#0000FF,bold")
 275         self.StyleSetSpec(wxSTC_P_DEFNAME, "fore:#007F7F,bold")
 276         self.StyleSetSpec(wxSTC_P_OPERATOR, "")
 277         self.StyleSetSpec(wxSTC_P_IDENTIFIER, "")
 278         self.StyleSetSpec(wxSTC_P_COMMENTBLOCK, "fore:#7F7F7F")
 279         self.StyleSetSpec(wxSTC_P_STRINGEOL, "fore:#000000,face:%(mono)s,back:#E0C0E0,eolfilled" % faces)
 280
 281     def OnChar(self, event):
 282         """Keypress event handler.
 283
 284         Prevents modification of previously submitted commands/responses."""
 285         if not self.CanEdit():
 286             return
 287         key = event.KeyCode()
 288         currpos = self.GetCurrentPos()
 289         stoppos = self.promptPos[1]
 290         if key == ord('.'):
 291             # The dot or period key activates auto completion.
 292             # Get the command between the prompt and the cursor.
 293             # Add a dot to the end of the command.
 294             command = self.GetTextRange(stoppos, currpos) + '.'
 295             self.write('.')
 296             if self.autoComplete: self.autoCompleteShow(command)
 297         elif key == ord('('):
 298             # The left paren activates a call tip and cancels
 299             # an active auto completion.
 300             if self.AutoCompActive(): self.AutoCompCancel()
 301             # Get the command between the prompt and the cursor.
 302             # Add the '(' to the end of the command.
 303             command = self.GetTextRange(stoppos, currpos) + '('
 304             self.write('(')
 305             if self.autoCallTip: self.autoCallTipShow(command)
 306         # Hack to keep characters from entering when Alt or Control are down.
 307         elif event.ControlDown() or event.AltDown():
 308             pass
 309         else:
 310             # Allow the normal event handling to take place.
 311             event.Skip()
 312
 313     def OnKeyDown(self, event):
 314         """Key down event handler.
 315
 316         Prevents modification of previously submitted commands/responses."""
 317         key = event.KeyCode()
 318         currpos = self.GetCurrentPos()
 319         stoppos = self.promptPos[1]
 320         # Return is used to submit a command to the interpreter.
 321         if key == WXK_RETURN:
 322             if self.AutoCompActive(): self.AutoCompCancel()
 323             if self.CallTipActive: self.CallTipCancel()
 324             self.processLine()
 325         # If the auto-complete window is up let it do its thing.
 326         elif self.AutoCompActive():
 327             event.Skip()
 328         # Cut to the clipboard.
 329         elif event.ControlDown() and key in (ord('X'), ord('x')):
 330             self.Cut()
 331         # Copy to the clipboard.
 332         elif event.ControlDown() and not event.ShiftDown() \
 333         and key in (ord('C'), ord('c')):
 334             self.Copy()
 335         # Copy to the clipboard, including prompts.
 336         elif event.ControlDown() and event.ShiftDown() \
 337         and key in (ord('C'), ord('c')):
 338             self.CopyWithPrompts()
 339         # Paste from the clipboard.
 340         elif event.ControlDown() and key in (ord('V'), ord('v')):
 341             self.Paste()
 342         # Retrieve the previous command from the history buffer.
 343         elif (event.ControlDown() and key == WXK_UP) \
 344         or (event.AltDown() and key in (ord('P'), ord('p'))):
 345             self.OnHistoryRetrieve(step=+1)
 346         # Retrieve the next command from the history buffer.
 347         elif (event.ControlDown() and key == WXK_DOWN) \
 348         or (event.AltDown() and key in (ord('N'), ord('n'))):
 349             self.OnHistoryRetrieve(step=-1)
 350         # Search up the history for the text in front of the cursor.
 351         elif key == WXK_F8:
 352             self.OnHistorySearch()
 353         # Home needs to be aware of the prompt.
 354         elif key == WXK_HOME:
 355             if currpos >= stoppos:
 356                 if event.ShiftDown():
 357                     # Select text from current position to end of prompt.
 358                     self.SetSelection(self.GetCurrentPos(), stoppos)
 359                 else:
 360                     self.SetCurrentPos(stoppos)
 361                     self.SetAnchor(stoppos)
 362             else:
 363                 event.Skip()
 364         # Basic navigation keys should work anywhere.
 365         elif key in (WXK_END, WXK_LEFT, WXK_RIGHT, WXK_UP, WXK_DOWN, \
 366                      WXK_PRIOR, WXK_NEXT):
 367             event.Skip()
 368         # Don't backspace over the latest prompt.
 369         elif key == WXK_BACK:
 370             if currpos > self.prompt1Pos[1]:
 371                 event.Skip()
 372         # Only allow these keys after the latest prompt.
 373         elif key in (WXK_TAB, WXK_DELETE):
 374             if self.CanEdit():
 375                 event.Skip()
 376         # Don't toggle between insert mode and overwrite mode.
 377         elif key == WXK_INSERT:
 378             pass
 379         # Protect the readonly portion of the shell.
 380         elif not self.CanEdit():
 381             pass
 382         else:
 383             event.Skip()
 384
 385     def OnHistoryRetrieve(self, step):
 386         """Retrieve the previous/next command from the history buffer."""
 387         if not self.CanEdit():
 388             return
 389         startpos = self.GetCurrentPos()
 390         newindex = self.historyIndex + step
 391         if not (-1 <= newindex < len(self.history)):
 392             return
 393         self.historyIndex = newindex
 394         if newindex == -1:
 395             self.ReplaceSelection('')
 396         else:
 397             self.ReplaceSelection('')
 398             command = self.history[self.historyIndex]
 399             command = command.replace('\n', os.linesep + sys.ps2)
 400             self.ReplaceSelection(command)
 401         endpos = self.GetCurrentPos()
 402         self.SetSelection(endpos, startpos)
 403
 404     def OnHistorySearch(self):
 405         """Search up the history buffer for the text in front of the cursor."""
 406         if not self.CanEdit():
 407             return
 408         startpos = self.GetCurrentPos()
 409         # The text up to the cursor is what we search for.
 410         numCharsAfterCursor = self.GetTextLength() - startpos
 411         searchText = self.getCommand(rstrip=0)
 412         if numCharsAfterCursor > 0:
 413             searchText = searchText[:-numCharsAfterCursor]
 414         if not searchText:
 415             return
 416         # Search upwards from the current history position and loop back
 417         # to the beginning if we don't find anything.
 418         if (self.historyIndex <= -1) \
 419         or (self.historyIndex >= len(self.history)-2):
 420             searchOrder = range(len(self.history))
 421         else:
 422             searchOrder = range(self.historyIndex+1, len(self.history)) + \
 423                           range(self.historyIndex)
 424         for i in searchOrder:
 425             command = self.history[i]
 426             if command[:len(searchText)] == searchText:
 427                 # Replace the current selection with the one we've found.
 428                 self.ReplaceSelection(command[len(searchText):])
 429                 endpos = self.GetCurrentPos()
 430                 self.SetSelection(endpos, startpos)
 431                 # We've now warped into middle of the history.
 432                 self.historyIndex = i
 433                 break
 434
 435     def setStatusText(self, text):
 436         """Display status information."""
 437
 438         # This method will most likely be replaced by the enclosing app
 439         # to do something more interesting, like write to a status bar.
 440         print text
 441
 442     def processLine(self):
 443         """Process the line of text at which the user hit Enter."""
 444
 445         # The user hit ENTER and we need to decide what to do. They could be
 446         # sitting on any line in the shell.
 447
 448         thepos = self.GetCurrentPos()
 449         endpos = self.GetTextLength()
 450         # If they hit RETURN at the very bottom, execute the command.
 451         if thepos == endpos:
 452             self.interp.more = 0
 453             if self.getCommand():
 454                 command = self.GetTextRange(self.prompt1Pos[1], endpos)
 455             else:
 456                 # This is a hack, now that we allow editing of previous
 457                 # lines, which throws off our promptPos values.
 458                 newend = endpos - len(self.getCommand(rstrip=0))
 459                 command = self.GetTextRange(self.prompt1Pos[1], newend)
 460             command = command.replace(os.linesep + sys.ps2, '\n')
 461             self.push(command)
 462         # Or replace the current command with the other command.
 463         elif thepos < self.prompt1Pos[0]:
 464             theline = self.GetCurrentLine()
 465             command = self.getCommand(rstrip=0)
 466             # If the new line contains a command (even an invalid one).
 467             if command:
 468                 command = self.getMultilineCommand()
 469                 self.SetCurrentPos(endpos)
 470                 startpos = self.prompt1Pos[1]
 471                 self.SetSelection(startpos, endpos)
 472                 self.ReplaceSelection('')
 473                 self.write(command)
 474                 self.more = 0
 475             # Otherwise, put the cursor back where we started.
 476             else:
 477                 self.SetCurrentPos(thepos)
 478                 self.SetAnchor(thepos)
 479         # Or add a new line to the current single or multi-line command.
 480         elif thepos > self.prompt1Pos[1]:
 481             self.write(os.linesep)
 482             self.more = 1
 483             self.prompt()
 484
 485     def getMultilineCommand(self, rstrip=1):
 486         """Extract a multi-line command from the editor.
 487
 488         The command may not necessarily be valid Python syntax."""
 489         # XXX Need to extract real prompts here. Need to keep track of the
 490         # prompt every time a command is issued.
 491         ps1 = str(sys.ps1)
 492         ps1size = len(ps1)
 493         ps2 = str(sys.ps2)
 494         ps2size = len(ps2)
 495         # This is a total hack job, but it works.
 496         text = self.GetCurLine()[0]
 497         line = self.GetCurrentLine()
 498         while text[:ps2size] == ps2 and line > 0:
 499             line -= 1
 500             self.GotoLine(line)
 501             text = self.GetCurLine()[0]
 502         if text[:ps1size] == ps1:
 503             line = self.GetCurrentLine()
 504             self.GotoLine(line)
 505             startpos = self.GetCurrentPos() + ps1size
 506             line += 1
 507             self.GotoLine(line)
 508             while self.GetCurLine()[0][:ps2size] == ps2:
 509                 line += 1
 510                 self.GotoLine(line)
 511             stoppos = self.GetCurrentPos()
 512             command = self.GetTextRange(startpos, stoppos)
 513             command = command.replace(os.linesep + sys.ps2, '\n')
 514             command = command.rstrip()
 515             command = command.replace('\n', os.linesep + sys.ps2)
 516         else:
 517             command = ''
 518         if rstrip:
 519             command = command.rstrip()
 520         return command
 521
 522     def getCommand(self, text=None, rstrip=1):
 523         """Extract a command from text which may include a shell prompt.
 524
 525         The command may not necessarily be valid Python syntax."""
 526         if not text:
 527             text = self.GetCurLine()[0]
 528         # Strip the prompt off the front of text leaving just the command.
 529         command = self.lstripPrompt(text)
 530         if command == text:
 531             command = ''  # Real commands have prompts.
 532         if rstrip:
 533             command = command.rstrip()
 534         return command
 535
 536     def lstripPrompt(self, text):
 537         """Return text without a leading prompt."""
 538         ps1 = str(sys.ps1)
 539         ps1size = len(ps1)
 540         ps2 = str(sys.ps2)
 541         ps2size = len(ps2)
 542         # Strip the prompt off the front of text.
 543         if text[:ps1size] == ps1:
 544             text = text[ps1size:]
 545         elif text[:ps2size] == ps2:
 546             text = text[ps2size:]
 547         return text
 548
 549     def push(self, command):
 550         """Send command to the interpreter for execution."""
 551         self.write(os.linesep)
 552         self.more = self.interp.push(command)
 553         if not self.more:
 554             self.addHistory(command.rstrip())
 555         self.prompt()
 556
 557     def addHistory(self, command):
 558         """Add command to the command history."""
 559         # Reset the history position.
 560         self.historyIndex = -1
 561         # Insert this command into the history, unless it's a blank
 562         # line or the same as the last command.
 563         if command != '' \
 564         and (len(self.history) == 0 or command != self.history[0]):
 565             self.history.insert(0, command)
 566
 567     def write(self, text):
 568         """Display text in the shell.
 569
 570         Replace line endings with OS-specific endings."""
 571         text = self.fixLineEndings(text)
 572         self.AddText(text)
 573         self.EnsureCaretVisible()
 574
 575     def fixLineEndings(self, text):
 576         """Return text with line endings replaced by OS-specific endings."""
 577         lines = text.split('\r\n')
 578         for l in range(len(lines)):
 579             chunks = lines[l].split('\r')
 580             for c in range(len(chunks)):
 581                 chunks[c] = os.linesep.join(chunks[c].split('\n'))
 582             lines[l] = os.linesep.join(chunks)
 583         text = os.linesep.join(lines)
 584         return text
 585
 586     def prompt(self):
 587         """Display appropriate prompt for the context, either ps1 or ps2.
 588
 589         If this is a continuation line, autoindent as necessary."""
 590         if self.more:
 591             prompt = str(sys.ps2)
 592         else:
 593             prompt = str(sys.ps1)
 594         pos = self.GetCurLine()[1]
 595         if pos > 0: self.write(os.linesep)
 596         self.promptPos[0] = self.GetCurrentPos()
 597         if not self.more: self.prompt1Pos[0] = self.GetCurrentPos()
 598         self.write(prompt)
 599         self.promptPos[1] = self.GetCurrentPos()
 600         if not self.more:
 601             self.prompt1Pos[1] = self.GetCurrentPos()
 602             # Keep the undo feature from undoing previous responses.
 603             self.EmptyUndoBuffer()
 604         # XXX Add some autoindent magic here if more.
 605         if self.more:
 606             self.write(' '*4)  # Temporary hack indentation.
 607         self.EnsureCaretVisible()
 608         self.ScrollToColumn(0)
 609
 610     def readIn(self):
 611         """Replacement for stdin."""
 612         prompt = 'Please enter your response:'
 613         dialog = wxTextEntryDialog(None, prompt, \
 614                                    'Input Dialog (Standard)', '')
 615         try:
 616             if dialog.ShowModal() == wxID_OK:
 617                 text = dialog.GetValue()
 618                 self.write(text + os.linesep)
 619                 return text
 620         finally:
 621             dialog.Destroy()
 622         return ''
 623
 624     def readRaw(self, prompt='Please enter your response:'):
 625         """Replacement for raw_input."""
 626         dialog = wxTextEntryDialog(None, prompt, \
 627                                    'Input Dialog (Raw)', '')
 628         try:
 629             if dialog.ShowModal() == wxID_OK:
 630                 text = dialog.GetValue()
 631                 return text
 632         finally:
 633             dialog.Destroy()
 634         return ''
 635
 636     def ask(self, prompt='Please enter your response:'):
 637         """Get response from the user."""
 638         return raw_input(prompt=prompt)
 639
 640     def pause(self):
 641         """Halt execution pending a response from the user."""
 642         self.ask('Press enter to continue:')
 643
 644     def clear(self):
 645         """Delete all text from the shell."""
 646         self.ClearAll()
 647
 648     def run(self, command, prompt=1, verbose=1):
 649         """Execute command within the shell as if it was typed in directly.
 650         >>> shell.run('print "this"')
 651         >>> print "this"
 652         this
 653         >>>
 654         """
 655         # Go to the very bottom of the text.
 656         endpos = self.GetTextLength()
 657         self.SetCurrentPos(endpos)
 658         command = command.rstrip()
 659         if prompt: self.prompt()
 660         if verbose: self.write(command)
 661         self.push(command)
 662
 663     def runfile(self, filename):
 664         """Execute all commands in file as if they were typed into the shell."""
 665         file = open(filename)
 666         try:
 667             self.prompt()
 668             for command in file.readlines():
 669                 if command[:6] == 'shell.':  # Run shell methods silently.
 670                     self.run(command, prompt=0, verbose=0)
 671                 else:
 672                     self.run(command, prompt=0, verbose=1)
 673         finally:
 674             file.close()
 675
 676     def autoCompleteShow(self, command):
 677         """Display auto-completion popup list."""
 678         list = self.interp.getAutoCompleteList(command, \
 679                     includeMagic=self.autoCompleteIncludeMagic, \
 680                     includeSingle=self.autoCompleteIncludeSingle, \
 681                     includeDouble=self.autoCompleteIncludeDouble)
 682         if list:
 683             options = ' '.join(list)
 684             offset = 0
 685             self.AutoCompShow(offset, options)
 686
 687     def autoCallTipShow(self, command):
 688         """Display argument spec and docstring in a popup bubble thingie."""
 689         if self.CallTipActive: self.CallTipCancel()
 690         tip = self.interp.getCallTip(command)
 691         if tip:
 692             offset = self.GetCurrentPos()
 693             self.CallTipShow(offset, tip)
 694
 695     def writeOut(self, text):
 696         """Replacement for stdout."""
 697         self.write(text)
 698
 699     def writeErr(self, text):
 700         """Replacement for stderr."""
 701         self.write(text)
 702
 703     def redirectStdin(self, redirect=1):
 704         """If redirect is true then sys.stdin will come from the shell."""
 705         if redirect:
 706             sys.stdin = PseudoFileIn(self.readIn)
 707         else:
 708             sys.stdin = self.stdin
 709
 710     def redirectStdout(self, redirect=1):
 711         """If redirect is true then sys.stdout will go to the shell."""
 712         if redirect:
 713             sys.stdout = PseudoFileOut(self.writeOut)
 714         else:
 715             sys.stdout = self.stdout
 716
 717     def redirectStderr(self, redirect=1):
 718         """If redirect is true then sys.stderr will go to the shell."""
 719         if redirect:
 720             sys.stderr = PseudoFileErr(self.writeErr)
 721         else:
 722             sys.stderr = self.stderr
 723
 724     def CanCut(self):
 725         """Return true if text is selected and can be cut."""
 726         if self.GetSelectionStart() != self.GetSelectionEnd() \
 727         and self.GetSelectionStart() >= self.prompt1Pos[1] \
 728         and self.GetSelectionEnd() >= self.prompt1Pos[1]:
 729             return 1
 730         else:
 731             return 0
 732
 733     def CanCopy(self):
 734         """Return true if text is selected and can be copied."""
 735         return self.GetSelectionStart() != self.GetSelectionEnd()
 736
 737     def CanPaste(self):
 738         """Return true if a paste should succeed."""
 739         if self.CanEdit() and wxStyledTextCtrl.CanPaste(self):
 740             return 1
 741         else:
 742             return 0
 743
 744     def CanEdit(self):
 745         """Return true if editing should succeed."""
 746         return self.GetCurrentPos() >= self.prompt1Pos[1]
 747
 748     def Cut(self):
 749         """Remove selection and place it on the clipboard."""
 750         if self.CanCut() and self.CanCopy():
 751             if self.AutoCompActive(): self.AutoCompCancel()
 752             if self.CallTipActive: self.CallTipCancel()
 753             self.Copy()
 754             self.ReplaceSelection('')
 755
 756     def Copy(self):
 757         """Copy selection and place it on the clipboard."""
 758         if self.CanCopy():
 759             command = self.GetSelectedText()
 760             command = command.replace(os.linesep + sys.ps2, os.linesep)
 761             command = command.replace(os.linesep + sys.ps1, os.linesep)
 762             command = self.lstripPrompt(text=command)
 763             data = wxTextDataObject(command)
 764             if wxTheClipboard.Open():
 765                 wxTheClipboard.SetData(data)
 766                 wxTheClipboard.Close()
 767
 768     def CopyWithPrompts(self):
 769         """Copy selection, including prompts, and place it on the clipboard."""
 770         if self.CanCopy():
 771             command = self.GetSelectedText()
 772             data = wxTextDataObject(command)
 773             if wxTheClipboard.Open():
 774                 wxTheClipboard.SetData(data)
 775                 wxTheClipboard.Close()
 776
 777     def Paste(self):
 778         """Replace selection with clipboard contents."""
 779         if self.CanPaste():
 780             if wxTheClipboard.Open():
 781                 if wxTheClipboard.IsSupported(wxDataFormat(wxDF_TEXT)):
 782                     data = wxTextDataObject()
 783                     if wxTheClipboard.GetData(data):
 784                         command = data.GetText()
 785                         command = self.fixLineEndings(command)
 786                         command = self.lstripPrompt(text=command)
 787                         command = command.replace(os.linesep + sys.ps2, '\n')
 788                         command = command.replace(os.linesep, '\n')
 789                         command = command.replace('\n', os.linesep + sys.ps2)
 790                         self.ReplaceSelection('')
 791                         self.write(command)
 792                 wxTheClipboard.Close()
 793
 794
 795 wxID_SELECTALL = NewId()  # This *should* be defined by wxPython.
 796 ID_AUTOCOMP = NewId()
 797 ID_AUTOCOMP_SHOW = NewId()
 798 ID_AUTOCOMP_INCLUDE_MAGIC = NewId()
 799 ID_AUTOCOMP_INCLUDE_SINGLE = NewId()
 800 ID_AUTOCOMP_INCLUDE_DOUBLE = NewId()
 801 ID_CALLTIPS = NewId()
 802 ID_CALLTIPS_SHOW = NewId()
 803
 804
 805 class ShellMenu:
 806     """Mixin class to add standard menu items."""
 807
 808     def createMenus(self):
 809         m = self.fileMenu = wxMenu()
 810         m.AppendSeparator()
 811         m.Append(wxID_EXIT, 'E&xit', 'Exit PyCrust')
 812
 813         m = self.editMenu = wxMenu()
 814         m.Append(wxID_UNDO, '&Undo \tCtrl+Z', 'Undo the last action')
 815         m.Append(wxID_REDO, '&Redo \tCtrl+Y', 'Redo the last undone action')
 816         m.AppendSeparator()
 817         m.Append(wxID_CUT, 'Cu&t \tCtrl+X', 'Cut the selection')
 818         m.Append(wxID_COPY, '&Copy \tCtrl+C', 'Copy the selection')
 819         m.Append(wxID_PASTE, '&Paste \tCtrl+V', 'Paste')
 820         m.AppendSeparator()
 821         m.Append(wxID_CLEAR, 'Cle&ar', 'Delete the selection')
 822         m.Append(wxID_SELECTALL, 'Select A&ll', 'Select all text')
 823
 824         m = self.autocompMenu = wxMenu()
 825         m.Append(ID_AUTOCOMP_SHOW, 'Show Auto Completion', \
 826                  'Show auto completion during dot syntax', \
 827                  checkable=1)
 828         m.Append(ID_AUTOCOMP_INCLUDE_MAGIC, 'Include Magic Attributes', \
 829                  'Include attributes visible to __getattr__ and __setattr__', \
 830                  checkable=1)
 831         m.Append(ID_AUTOCOMP_INCLUDE_SINGLE, 'Include Single Underscores', \
 832                  'Include attibutes prefixed by a single underscore', \
 833                  checkable=1)
 834         m.Append(ID_AUTOCOMP_INCLUDE_DOUBLE, 'Include Double Underscores', \
 835                  'Include attibutes prefixed by a double underscore', \
 836                  checkable=1)
 837
 838         m = self.calltipsMenu = wxMenu()
 839         m.Append(ID_CALLTIPS_SHOW, 'Show Call Tips', \
 840                  'Show call tips with argument specifications', checkable=1)
 841
 842         m = self.optionsMenu = wxMenu()
 843         m.AppendMenu(ID_AUTOCOMP, '&Auto Completion', self.autocompMenu, \
 844                      'Auto Completion Options')
 845         m.AppendMenu(ID_CALLTIPS, '&Call Tips', self.calltipsMenu, \
 846                      'Call Tip Options')
 847
 848         m = self.helpMenu = wxMenu()
 849         m.AppendSeparator()
 850         m.Append(wxID_ABOUT, '&About...', 'About PyCrust')
 851
 852         b = self.menuBar = wxMenuBar()
 853         b.Append(self.fileMenu, '&File')
 854         b.Append(self.editMenu, '&Edit')
 855         b.Append(self.optionsMenu, '&Options')
 856         b.Append(self.helpMenu, '&Help')
 857         self.SetMenuBar(b)
 858
 859         EVT_MENU(self, wxID_EXIT, self.OnExit)
 860         EVT_MENU(self, wxID_UNDO, self.OnUndo)
 861         EVT_MENU(self, wxID_REDO, self.OnRedo)
 862         EVT_MENU(self, wxID_CUT, self.OnCut)
 863         EVT_MENU(self, wxID_COPY, self.OnCopy)
 864         EVT_MENU(self, wxID_PASTE, self.OnPaste)
 865         EVT_MENU(self, wxID_CLEAR, self.OnClear)
 866         EVT_MENU(self, wxID_SELECTALL, self.OnSelectAll)
 867         EVT_MENU(self, wxID_ABOUT, self.OnAbout)
 868         EVT_MENU(self, ID_AUTOCOMP_SHOW, \
 869                  self.OnAutoCompleteShow)
 870         EVT_MENU(self, ID_AUTOCOMP_INCLUDE_MAGIC, \
 871                  self.OnAutoCompleteIncludeMagic)
 872         EVT_MENU(self, ID_AUTOCOMP_INCLUDE_SINGLE, \
 873                  self.OnAutoCompleteIncludeSingle)
 874         EVT_MENU(self, ID_AUTOCOMP_INCLUDE_DOUBLE, \
 875                  self.OnAutoCompleteIncludeDouble)
 876         EVT_MENU(self, ID_CALLTIPS_SHOW, \
 877                  self.OnCallTipsShow)
 878
 879         EVT_UPDATE_UI(self, wxID_UNDO, self.OnUpdateMenu)
 880         EVT_UPDATE_UI(self, wxID_REDO, self.OnUpdateMenu)
 881         EVT_UPDATE_UI(self, wxID_CUT, self.OnUpdateMenu)
 882         EVT_UPDATE_UI(self, wxID_COPY, self.OnUpdateMenu)
 883         EVT_UPDATE_UI(self, wxID_PASTE, self.OnUpdateMenu)
 884         EVT_UPDATE_UI(self, wxID_CLEAR, self.OnUpdateMenu)
 885         EVT_UPDATE_UI(self, ID_AUTOCOMP_SHOW, self.OnUpdateMenu)
 886         EVT_UPDATE_UI(self, ID_AUTOCOMP_INCLUDE_MAGIC, self.OnUpdateMenu)
 887         EVT_UPDATE_UI(self, ID_AUTOCOMP_INCLUDE_SINGLE, self.OnUpdateMenu)
 888         EVT_UPDATE_UI(self, ID_AUTOCOMP_INCLUDE_DOUBLE, self.OnUpdateMenu)
 889         EVT_UPDATE_UI(self, ID_CALLTIPS_SHOW, self.OnUpdateMenu)
 890
 891     def OnExit(self, event):
 892         self.Close(true)
 893
 894     def OnUndo(self, event):
 895         self.shell.Undo()
 896
 897     def OnRedo(self, event):
 898         self.shell.Redo()
 899
 900     def OnCut(self, event):
 901         self.shell.Cut()
 902
 903     def OnCopy(self, event):
 904         self.shell.Copy()
 905
 906     def OnPaste(self, event):
 907         self.shell.Paste()
 908
 909     def OnClear(self, event):
 910         self.shell.Clear()
 911
 912     def OnSelectAll(self, event):
 913         self.shell.SelectAll()
 914
 915     def OnAbout(self, event):
 916         """Display an About PyCrust window."""
 917         import sys
 918         title = 'About PyCrust'
 919         text = 'PyCrust %s\n\n' % VERSION + \
 920                'Yet another Python shell, only flakier.\n\n' + \
 921                'Half-baked by Patrick K. O\'Brien,\n' + \
 922                'the other half is still in the oven.\n\n' + \
 923                'Shell Revision: %s\n' % self.shell.revision + \
 924                'Interpreter Revision: %s\n\n' % self.shell.interp.revision + \
 925                'Python Version: %s\n' % sys.version.split()[0] + \
 926                'wxPython Version: %s\n' % wx.__version__ + \
 927                'Platform: %s\n' % sys.platform
 928         dialog = wxMessageDialog(self, text, title, wxOK | wxICON_INFORMATION)
 929         dialog.ShowModal()
 930         dialog.Destroy()
 931
 932     def OnAutoCompleteShow(self, event):
 933         self.shell.autoComplete = event.IsChecked()
 934
 935     def OnAutoCompleteIncludeMagic(self, event):
 936         self.shell.autoCompleteIncludeMagic = event.IsChecked()
 937
 938     def OnAutoCompleteIncludeSingle(self, event):
 939         self.shell.autoCompleteIncludeSingle = event.IsChecked()
 940
 941     def OnAutoCompleteIncludeDouble(self, event):
 942         self.shell.autoCompleteIncludeDouble = event.IsChecked()
 943
 944     def OnCallTipsShow(self, event):
 945         self.shell.autoCallTip = event.IsChecked()
 946
 947     def OnUpdateMenu(self, event):
 948         """Update menu items based on current status."""
 949         id = event.GetId()
 950         if id == wxID_UNDO:
 951             event.Enable(self.shell.CanUndo())
 952         elif id == wxID_REDO:
 953             event.Enable(self.shell.CanRedo())
 954         elif id == wxID_CUT:
 955             event.Enable(self.shell.CanCut())
 956         elif id == wxID_COPY:
 957             event.Enable(self.shell.CanCopy())
 958         elif id == wxID_PASTE:
 959             event.Enable(self.shell.CanPaste())
 960         elif id == wxID_CLEAR:
 961             event.Enable(self.shell.CanCut())
 962         elif id == ID_AUTOCOMP_SHOW:
 963             event.Check(self.shell.autoComplete)
 964         elif id == ID_AUTOCOMP_INCLUDE_MAGIC:
 965             event.Check(self.shell.autoCompleteIncludeMagic)
 966         elif id == ID_AUTOCOMP_INCLUDE_SINGLE:
 967             event.Check(self.shell.autoCompleteIncludeSingle)
 968         elif id == ID_AUTOCOMP_INCLUDE_DOUBLE:
 969             event.Check(self.shell.autoCompleteIncludeDouble)
 970         elif id == ID_CALLTIPS_SHOW:
 971             event.Check(self.shell.autoCallTip)
 972
 973
 974 class ShellFrame(wxFrame, ShellMenu):
 975     """Frame containing the PyCrust shell component."""
 976
 977     name = 'PyCrust Shell Frame'
 978     revision = __version__
 979
 980     def __init__(self, parent=None, id=-1, title='PyShell', \
 981                  pos=wxDefaultPosition, size=wxDefaultSize, \
 982                  style=wxDEFAULT_FRAME_STYLE, locals=None, \
 983                  InterpClass=None, *args, **kwds):
 984         """Create a PyCrust ShellFrame instance."""
 985         wxFrame.__init__(self, parent, id, title, pos, size, style)
 986         intro = 'Welcome To PyCrust %s - The Flakiest Python Shell' % VERSION
 987         intro += '\nSponsored by Orbtech.com \96 Your Source For Python Development Services'
 988         self.CreateStatusBar()
 989         self.SetStatusText(intro)
 990         if wxPlatform == '__WXMSW__':
 991             import os
 992             filename = os.path.join(os.path.dirname(__file__), 'PyCrust.ico')
 993             icon = wxIcon(filename, wxBITMAP_TYPE_ICO)
 994             self.SetIcon(icon)
 995         self.shell = Shell(parent=self, id=-1, introText=intro, \
 996                            locals=locals, InterpClass=InterpClass, \
 997                            *args, **kwds)
 998         # Override the shell so that status messages go to the status bar.
 999         self.shell.setStatusText = self.SetStatusText
1000         self.createMenus()
1001
1002
1003
1004