wxPython/wx/py/shell.py

   1 """Shell is an interactive text control in which a user types in
   2 commands to be sent to the interpreter.  This particular shell is
   3 based on wxPython's wxStyledTextCtrl.
   4
   5 Sponsored by Orbtech - Your source for Python programming expertise."""
   6
   7 __author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
   8 __cvsid__ = "$Id$"
   9 __revision__ = "$Revision$"[11:-2]
  10
  11 import wx
  12 from wx import stc
  13
  14 import keyword
  15 import os
  16 import sys
  17 import time
  18
  19 from buffer import Buffer
  20 import dispatcher
  21 import editwindow
  22 import frame
  23 from pseudo import PseudoFileIn
  24 from pseudo import PseudoFileOut
  25 from pseudo import PseudoFileErr
  26 from version import VERSION
  27
  28 sys.ps3 = '<-- '  # Input prompt.
  29
  30 NAVKEYS = (wx.WXK_END, wx.WXK_LEFT, wx.WXK_RIGHT,
  31            wx.WXK_UP, wx.WXK_DOWN, wx.WXK_PRIOR, wx.WXK_NEXT)
  32
  33
  34 class ShellFrame(frame.Frame):
  35     """Frame containing the shell component."""
  36
  37     name = 'Shell Frame'
  38     revision = __revision__
  39
  40     def __init__(self, parent=None, id=-1, title='PyShell',
  41                  pos=wx.DefaultPosition, size=wx.DefaultSize,
  42                  style=wx.DEFAULT_FRAME_STYLE, locals=None,
  43                  InterpClass=None, *args, **kwds):
  44         """Create ShellFrame instance."""
  45         frame.Frame.__init__(self, parent, id, title, pos, size, style)
  46         intro = 'PyShell %s - The Flakiest Python Shell' % VERSION
  47         intro += '\nSponsored by Orbtech - ' + \
  48                  'Your source for Python programming expertise.'
  49         self.SetStatusText(intro.replace('\n', ', '))
  50         self.shell = Shell(parent=self, id=-1, introText=intro,
  51                            locals=locals, InterpClass=InterpClass,
  52                            *args, **kwds)
  53         # Override the shell so that status messages go to the status bar.
  54         self.shell.setStatusText = self.SetStatusText
  55
  56     def OnClose(self, event):
  57         """Event handler for closing."""
  58         # This isn't working the way I want, but I'll leave it for now.
  59         if self.shell.waiting:
  60             if event.CanVeto():
  61                 event.Veto(True)
  62         else:
  63             self.shell.destroy()
  64             self.Destroy()
  65
  66     def OnAbout(self, event):
  67         """Display an About window."""
  68         title = 'About PyShell'
  69         text = 'PyShell %s\n\n' % VERSION + \
  70                'Yet another Python shell, only flakier.\n\n' + \
  71                'Half-baked by Patrick K. O\'Brien,\n' + \
  72                'the other half is still in the oven.\n\n' + \
  73                'Shell Revision: %s\n' % self.shell.revision + \
  74                'Interpreter Revision: %s\n\n' % self.shell.interp.revision + \
  75                'Platform: %s\n' % sys.platform + \
  76                'Python Version: %s\n' % sys.version.split()[0] + \
  77                'wxPython Version: %s\n' % wx.VERSION_STRING + \
  78                ('\t(%s)\n' % ", ".join(wx.PlatformInfo[1:]))
  79         dialog = wx.MessageDialog(self, text, title,
  80                                   wx.OK | wx.ICON_INFORMATION)
  81         dialog.ShowModal()
  82         dialog.Destroy()
  83
  84
  85 class ShellFacade:
  86     """Simplified interface to all shell-related functionality.
  87
  88     This is a semi-transparent facade, in that all attributes of other
  89     are accessible, even though only some are visible to the user."""
  90
  91     name = 'Shell Interface'
  92     revision = __revision__
  93
  94     def __init__(self, other):
  95         """Create a ShellFacade instance."""
  96         d = self.__dict__
  97         d['other'] = other
  98         d['helpText'] = \
  99 """
 100 * Key bindings:
 101 Home              Go to the beginning of the command or line.
 102 Shift+Home        Select to the beginning of the command or line.
 103 Shift+End         Select to the end of the line.
 104 End               Go to the end of the line.
 105 Ctrl+C            Copy selected text, removing prompts.
 106 Ctrl+Shift+C      Copy selected text, retaining prompts.
 107 Ctrl+X            Cut selected text.
 108 Ctrl+V            Paste from clipboard.
 109 Ctrl+Shift+V      Paste and run multiple commands from clipboard.
 110 Ctrl+Up Arrow     Retrieve Previous History item.
 111 Alt+P             Retrieve Previous History item.
 112 Ctrl+Down Arrow   Retrieve Next History item.
 113 Alt+N             Retrieve Next History item.
 114 Shift+Up Arrow    Insert Previous History item.
 115 Shift+Down Arrow  Insert Next History item.
 116 F8                Command-completion of History item.
 117                   (Type a few characters of a previous command and press F8.)
 118 Ctrl+Enter        Insert new line into multiline command.
 119 Ctrl+]            Increase font size.
 120 Ctrl+[            Decrease font size.
 121 Ctrl+=            Default font size.
 122 """
 123
 124     def help(self):
 125         """Display some useful information about how to use the shell."""
 126         self.write(self.helpText)
 127
 128     def __getattr__(self, name):
 129         if hasattr(self.other, name):
 130             return getattr(self.other, name)
 131         else:
 132             raise AttributeError, name
 133
 134     def __setattr__(self, name, value):
 135         if self.__dict__.has_key(name):
 136             self.__dict__[name] = value
 137         elif hasattr(self.other, name):
 138             setattr(self.other, name, value)
 139         else:
 140             raise AttributeError, name
 141
 142     def _getAttributeNames(self):
 143         """Return list of magic attributes to extend introspection."""
 144         list = [
 145             'about',
 146             'ask',
 147             'autoCallTip',
 148             'autoComplete',
 149             'autoCompleteAutoHide',
 150             'autoCompleteCaseInsensitive',
 151             'autoCompleteIncludeDouble',
 152             'autoCompleteIncludeMagic',
 153             'autoCompleteIncludeSingle',
 154             'clear',
 155             'pause',
 156             'prompt',
 157             'quit',
 158             'redirectStderr',
 159             'redirectStdin',
 160             'redirectStdout',
 161             'run',
 162             'runfile',
 163             'wrap',
 164             'zoom',
 165             ]
 166         list.sort()
 167         return list
 168
 169
 170 class Shell(editwindow.EditWindow):
 171     """Shell based on StyledTextCtrl."""
 172
 173     name = 'Shell'
 174     revision = __revision__
 175
 176     def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
 177                  size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
 178                  introText='', locals=None, InterpClass=None, *args, **kwds):
 179         """Create Shell instance."""
 180         editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
 181         self.wrap()
 182         if locals is None:
 183             import __main__
 184             locals = __main__.__dict__
 185         # Grab these so they can be restored by self.redirect* methods.
 186         self.stdin = sys.stdin
 187         self.stdout = sys.stdout
 188         self.stderr = sys.stderr
 189         # Import a default interpreter class if one isn't provided.
 190         if InterpClass == None:
 191             from interpreter import Interpreter
 192         else:
 193             Interpreter = InterpClass
 194         # Create a replacement for stdin.
 195         self.reader = PseudoFileIn(self.readline, self.readlines)
 196         self.reader.input = ''
 197         self.reader.isreading = False
 198         # Set up the interpreter.
 199         self.interp = Interpreter(locals=locals,
 200                                   rawin=self.raw_input,
 201                                   stdin=self.reader,
 202                                   stdout=PseudoFileOut(self.writeOut),
 203                                   stderr=PseudoFileErr(self.writeErr),
 204                                   *args, **kwds)
 205         # Set up the buffer.
 206         self.buffer = Buffer()
 207         # Find out for which keycodes the interpreter will autocomplete.
 208         self.autoCompleteKeys = self.interp.getAutoCompleteKeys()
 209         # Keep track of the last non-continuation prompt positions.
 210         self.promptPosStart = 0
 211         self.promptPosEnd = 0
 212         # Keep track of multi-line commands.
 213         self.more = False
 214         # Create the command history.  Commands are added into the
 215         # front of the list (ie. at index 0) as they are entered.
 216         # self.historyIndex is the current position in the history; it
 217         # gets incremented as you retrieve the previous command,
 218         # decremented as you retrieve the next, and reset when you hit
 219         # Enter.  self.historyIndex == -1 means you're on the current
 220         # command, not in the history.
 221         self.history = []
 222         self.historyIndex = -1
 223         # Assign handlers for keyboard events.
 224         wx.EVT_CHAR(self, self.OnChar)
 225         wx.EVT_KEY_DOWN(self, self.OnKeyDown)
 226         # Assign handler for idle time.
 227         self.waiting = False
 228         wx.EVT_IDLE(self, self.OnIdle)
 229         # Display the introductory banner information.
 230         self.showIntro(introText)
 231         # Assign some pseudo keywords to the interpreter's namespace.
 232         self.setBuiltinKeywords()
 233         # Add 'shell' to the interpreter's local namespace.
 234         self.setLocalShell()
 235         # Do this last so the user has complete control over their
 236         # environment.  They can override anything they want.
 237         self.execStartupScript(self.interp.startupScript)
 238         wx.CallAfter(self.ScrollToLine, 0)
 239
 240     def destroy(self):
 241         del self.interp
 242
 243     def setFocus(self):
 244         """Set focus to the shell."""
 245         self.SetFocus()
 246
 247     def OnIdle(self, event):
 248         """Free the CPU to do other things."""
 249         if self.waiting:
 250             time.sleep(0.05)
 251         event.Skip()
 252
 253     def showIntro(self, text=''):
 254         """Display introductory text in the shell."""
 255         if text:
 256             if not text.endswith(os.linesep):
 257                 text += os.linesep
 258             self.write(text)
 259         try:
 260             self.write(self.interp.introText)
 261         except AttributeError:
 262             pass
 263
 264     def setBuiltinKeywords(self):
 265         """Create pseudo keywords as part of builtins.
 266
 267         This sets `close`, `exit` and `quit` to a helpful string.
 268         """
 269         import __builtin__
 270         __builtin__.close = __builtin__.exit = __builtin__.quit = \
 271             'Click on the close button to leave the application.'
 272
 273     def quit(self):
 274         """Quit the application."""
 275
 276         # XXX Good enough for now but later we want to send a close event.
 277
 278         # In the close event handler we can make sure they want to
 279         # quit.  Other applications, like PythonCard, may choose to
 280         # hide rather than quit so we should just post the event and
 281         # let the surrounding app decide what it wants to do.
 282         self.write('Click on the close button to leave the application.')
 283
 284     def setLocalShell(self):
 285         """Add 'shell' to locals as reference to ShellFacade instance."""
 286         self.interp.locals['shell'] = ShellFacade(other=self)
 287
 288     def execStartupScript(self, startupScript):
 289         """Execute the user's PYTHONSTARTUP script if they have one."""
 290         if startupScript and os.path.isfile(startupScript):
 291             text = 'Startup script executed: ' + startupScript
 292             self.push('print %r; execfile(%r)' % (text, startupScript))
 293         else:
 294             self.push('')
 295
 296     def about(self):
 297         """Display information about Py."""
 298         text = """
 299 Author: %r
 300 Py Version: %s
 301 Py Shell Revision: %s
 302 Py Interpreter Revision: %s
 303 Python Version: %s
 304 wxPython Version: %s
 305 Platform: %s""" % \
 306         (__author__, VERSION, self.revision, self.interp.revision,
 307          sys.version.split()[0], wx.VERSION_STRING, sys.platform)
 308         self.write(text.strip())
 309
 310     def OnChar(self, event):
 311         """Keypress event handler.
 312
 313         Only receives an event if OnKeyDown calls event.Skip() for the
 314         corresponding event."""
 315
 316         # Prevent modification of previously submitted
 317         # commands/responses.
 318         if not self.CanEdit():
 319             return
 320         key = event.KeyCode()
 321         currpos = self.GetCurrentPos()
 322         stoppos = self.promptPosEnd
 323         # Return (Enter) needs to be ignored in this handler.
 324         if key == wx.WXK_RETURN:
 325             pass
 326         elif key in self.autoCompleteKeys:
 327             # Usually the dot (period) key activates auto completion.
 328             # Get the command between the prompt and the cursor.  Add
 329             # the autocomplete character to the end of the command.
 330             if self.AutoCompActive():
 331                 self.AutoCompCancel()
 332             command = self.GetTextRange(stoppos, currpos) + chr(key)
 333             self.write(chr(key))
 334             if self.autoComplete:
 335                 self.autoCompleteShow(command)
 336         elif key == ord('('):
 337             # The left paren activates a call tip and cancels an
 338             # active auto completion.
 339             if self.AutoCompActive():
 340                 self.AutoCompCancel()
 341             # Get the command between the prompt and the cursor.  Add
 342             # the '(' to the end of the command.
 343             self.ReplaceSelection('')
 344             command = self.GetTextRange(stoppos, currpos) + '('
 345             self.write('(')
 346             self.autoCallTipShow(command)
 347         else:
 348             # Allow the normal event handling to take place.
 349             event.Skip()
 350
 351     def OnKeyDown(self, event):
 352         """Key down event handler."""
 353
 354         key = event.KeyCode()
 355         # If the auto-complete window is up let it do its thing.
 356         if self.AutoCompActive():
 357             event.Skip()
 358             return
 359         # Prevent modification of previously submitted
 360         # commands/responses.
 361         controlDown = event.ControlDown()
 362         altDown = event.AltDown()
 363         shiftDown = event.ShiftDown()
 364         currpos = self.GetCurrentPos()
 365         endpos = self.GetTextLength()
 366         selecting = self.GetSelectionStart() != self.GetSelectionEnd()
 367         # Return (Enter) is used to submit a command to the
 368         # interpreter.
 369         if not controlDown and key == wx.WXK_RETURN:
 370             if self.CallTipActive():
 371                 self.CallTipCancel()
 372             self.processLine()
 373         # Ctrl+Return (Cntrl+Enter) is used to insert a line break.
 374         elif controlDown and key == wx.WXK_RETURN:
 375             if self.CallTipActive():
 376                 self.CallTipCancel()
 377             if currpos == endpos:
 378                 self.processLine()
 379             else:
 380                 self.insertLineBreak()
 381         # Let Ctrl-Alt-* get handled normally.
 382         elif controlDown and altDown:
 383             event.Skip()
 384         # Clear the current, unexecuted command.
 385         elif key == wx.WXK_ESCAPE:
 386             if self.CallTipActive():
 387                 event.Skip()
 388             else:
 389                 self.clearCommand()
 390         # Increase font size.
 391         elif controlDown and key in (ord(']'),):
 392             dispatcher.send(signal='FontIncrease')
 393         # Decrease font size.
 394         elif controlDown and key in (ord('['),):
 395             dispatcher.send(signal='FontDecrease')
 396         # Default font size.
 397         elif controlDown and key in (ord('='),):
 398             dispatcher.send(signal='FontDefault')
 399         # Cut to the clipboard.
 400         elif (controlDown and key in (ord('X'), ord('x'))) \
 401         or (shiftDown and key == wx.WXK_DELETE):
 402             self.Cut()
 403         # Copy to the clipboard.
 404         elif controlDown and not shiftDown \
 405             and key in (ord('C'), ord('c'), wx.WXK_INSERT):
 406             self.Copy()
 407         # Copy to the clipboard, including prompts.
 408         elif controlDown and shiftDown \
 409             and key in (ord('C'), ord('c'), wx.WXK_INSERT):
 410             self.CopyWithPrompts()
 411         # Copy to the clipboard, including prefixed prompts.
 412         elif altDown and not controlDown \
 413             and key in (ord('C'), ord('c'), wx.WXK_INSERT):
 414             self.CopyWithPromptsPrefixed()
 415         # Home needs to be aware of the prompt.
 416         elif key == wx.WXK_HOME:
 417             home = self.promptPosEnd
 418             if currpos > home:
 419                 self.SetCurrentPos(home)
 420                 if not selecting and not shiftDown:
 421                     self.SetAnchor(home)
 422                     self.EnsureCaretVisible()
 423             else:
 424                 event.Skip()
 425         #
 426         # The following handlers modify text, so we need to see if
 427         # there is a selection that includes text prior to the prompt.
 428         #
 429         # Don't modify a selection with text prior to the prompt.
 430         elif selecting and key not in NAVKEYS and not self.CanEdit():
 431             pass
 432         # Paste from the clipboard.
 433         elif (controlDown and not shiftDown and key in (ord('V'), ord('v'))) \
 434                  or (shiftDown and not controlDown and key == wx.WXK_INSERT):
 435             self.Paste()
 436         # Paste from the clipboard, run commands.
 437         elif controlDown and shiftDown and key in (ord('V'), ord('v')):
 438             self.PasteAndRun()
 439         # Replace with the previous command from the history buffer.
 440         elif (controlDown and key == wx.WXK_UP) \
 441                  or (altDown and key in (ord('P'), ord('p'))):
 442             self.OnHistoryReplace(step=+1)
 443         # Replace with the next command from the history buffer.
 444         elif (controlDown and key == wx.WXK_DOWN) \
 445                  or (altDown and key in (ord('N'), ord('n'))):
 446             self.OnHistoryReplace(step=-1)
 447         # Insert the previous command from the history buffer.
 448         elif (shiftDown and key == wx.WXK_UP) and self.CanEdit():
 449             self.OnHistoryInsert(step=+1)
 450         # Insert the next command from the history buffer.
 451         elif (shiftDown and key == wx.WXK_DOWN) and self.CanEdit():
 452             self.OnHistoryInsert(step=-1)
 453         # Search up the history for the text in front of the cursor.
 454         elif key == wx.WXK_F8:
 455             self.OnHistorySearch()
 456         # Don't backspace over the latest non-continuation prompt.
 457         elif key == wx.WXK_BACK:
 458             if selecting and self.CanEdit():
 459                 event.Skip()
 460             elif currpos > self.promptPosEnd:
 461                 event.Skip()
 462         # Only allow these keys after the latest prompt.
 463         elif key in (wx.WXK_TAB, wx.WXK_DELETE):
 464             if self.CanEdit():
 465                 event.Skip()
 466         # Don't toggle between insert mode and overwrite mode.
 467         elif key == wx.WXK_INSERT:
 468             pass
 469         # Don't allow line deletion.
 470         elif controlDown and key in (ord('L'), ord('l')):
 471             pass
 472         # Don't allow line transposition.
 473         elif controlDown and key in (ord('T'), ord('t')):
 474             pass
 475         # Basic navigation keys should work anywhere.
 476         elif key in NAVKEYS:
 477             event.Skip()
 478         # Protect the readonly portion of the shell.
 479         elif not self.CanEdit():
 480             pass
 481         else:
 482             event.Skip()
 483
 484     def clearCommand(self):
 485         """Delete the current, unexecuted command."""
 486         startpos = self.promptPosEnd
 487         endpos = self.GetTextLength()
 488         self.SetSelection(startpos, endpos)
 489         self.ReplaceSelection('')
 490         self.more = False
 491
 492     def OnHistoryReplace(self, step):
 493         """Replace with the previous/next command from the history buffer."""
 494         self.clearCommand()
 495         self.replaceFromHistory(step)
 496
 497     def replaceFromHistory(self, step):
 498         """Replace selection with command from the history buffer."""
 499         ps2 = str(sys.ps2)
 500         self.ReplaceSelection('')
 501         newindex = self.historyIndex + step
 502         if -1 <= newindex <= len(self.history):
 503             self.historyIndex = newindex
 504         if 0 <= newindex <= len(self.history)-1:
 505             command = self.history[self.historyIndex]
 506             command = command.replace('\n', os.linesep + ps2)
 507             self.ReplaceSelection(command)
 508
 509     def OnHistoryInsert(self, step):
 510         """Insert the previous/next command from the history buffer."""
 511         if not self.CanEdit():
 512             return
 513         startpos = self.GetCurrentPos()
 514         self.replaceFromHistory(step)
 515         endpos = self.GetCurrentPos()
 516         self.SetSelection(endpos, startpos)
 517
 518     def OnHistorySearch(self):
 519         """Search up the history buffer for the text in front of the cursor."""
 520         if not self.CanEdit():
 521             return
 522         startpos = self.GetCurrentPos()
 523         # The text up to the cursor is what we search for.
 524         numCharsAfterCursor = self.GetTextLength() - startpos
 525         searchText = self.getCommand(rstrip=False)
 526         if numCharsAfterCursor > 0:
 527             searchText = searchText[:-numCharsAfterCursor]
 528         if not searchText:
 529             return
 530         # Search upwards from the current history position and loop
 531         # back to the beginning if we don't find anything.
 532         if (self.historyIndex <= -1) \
 533         or (self.historyIndex >= len(self.history)-2):
 534             searchOrder = range(len(self.history))
 535         else:
 536             searchOrder = range(self.historyIndex+1, len(self.history)) + \
 537                           range(self.historyIndex)
 538         for i in searchOrder:
 539             command = self.history[i]
 540             if command[:len(searchText)] == searchText:
 541                 # Replace the current selection with the one we found.
 542                 self.ReplaceSelection(command[len(searchText):])
 543                 endpos = self.GetCurrentPos()
 544                 self.SetSelection(endpos, startpos)
 545                 # We've now warped into middle of the history.
 546                 self.historyIndex = i
 547                 break
 548
 549     def setStatusText(self, text):
 550         """Display status information."""
 551
 552         # This method will likely be replaced by the enclosing app to
 553         # do something more interesting, like write to a status bar.
 554         print text
 555
 556     def insertLineBreak(self):
 557         """Insert a new line break."""
 558         if self.CanEdit():
 559             self.write(os.linesep)
 560             self.more = True
 561             self.prompt()
 562
 563     def processLine(self):
 564         """Process the line of text at which the user hit Enter."""
 565
 566         # The user hit ENTER and we need to decide what to do. They
 567         # could be sitting on any line in the shell.
 568
 569         thepos = self.GetCurrentPos()
 570         startpos = self.promptPosEnd
 571         endpos = self.GetTextLength()
 572         ps2 = str(sys.ps2)
 573         # If they hit RETURN inside the current command, execute the
 574         # command.
 575         if self.CanEdit():
 576             self.SetCurrentPos(endpos)
 577             self.interp.more = False
 578             command = self.GetTextRange(startpos, endpos)
 579             lines = command.split(os.linesep + ps2)
 580             lines = [line.rstrip() for line in lines]
 581             command = '\n'.join(lines)
 582             if self.reader.isreading:
 583                 if not command:
 584                     # Match the behavior of the standard Python shell
 585                     # when the user hits return without entering a
 586                     # value.
 587                     command = '\n'
 588                 self.reader.input = command
 589                 self.write(os.linesep)
 590             else:
 591                 self.push(command)
 592         # Or replace the current command with the other command.
 593         else:
 594             # If the line contains a command (even an invalid one).
 595             if self.getCommand(rstrip=False):
 596                 command = self.getMultilineCommand()
 597                 self.clearCommand()
 598                 self.write(command)
 599             # Otherwise, put the cursor back where we started.
 600             else:
 601                 self.SetCurrentPos(thepos)
 602                 self.SetAnchor(thepos)
 603
 604     def getMultilineCommand(self, rstrip=True):
 605         """Extract a multi-line command from the editor.
 606
 607         The command may not necessarily be valid Python syntax."""
 608         # XXX Need to extract real prompts here. Need to keep track of
 609         # the prompt every time a command is issued.
 610         ps1 = str(sys.ps1)
 611         ps1size = len(ps1)
 612         ps2 = str(sys.ps2)
 613         ps2size = len(ps2)
 614         # This is a total hack job, but it works.
 615         text = self.GetCurLine()[0]
 616         line = self.GetCurrentLine()
 617         while text[:ps2size] == ps2 and line > 0:
 618             line -= 1
 619             self.GotoLine(line)
 620             text = self.GetCurLine()[0]
 621         if text[:ps1size] == ps1:
 622             line = self.GetCurrentLine()
 623             self.GotoLine(line)
 624             startpos = self.GetCurrentPos() + ps1size
 625             line += 1
 626             self.GotoLine(line)
 627             while self.GetCurLine()[0][:ps2size] == ps2:
 628                 line += 1
 629                 self.GotoLine(line)
 630             stoppos = self.GetCurrentPos()
 631             command = self.GetTextRange(startpos, stoppos)
 632             command = command.replace(os.linesep + ps2, '\n')
 633             command = command.rstrip()
 634             command = command.replace('\n', os.linesep + ps2)
 635         else:
 636             command = ''
 637         if rstrip:
 638             command = command.rstrip()
 639         return command
 640
 641     def getCommand(self, text=None, rstrip=True):
 642         """Extract a command from text which may include a shell prompt.
 643
 644         The command may not necessarily be valid Python syntax."""
 645         if not text:
 646             text = self.GetCurLine()[0]
 647         # Strip the prompt off the front leaving just the command.
 648         command = self.lstripPrompt(text)
 649         if command == text:
 650             command = ''  # Real commands have prompts.
 651         if rstrip:
 652             command = command.rstrip()
 653         return command
 654
 655     def lstripPrompt(self, text):
 656         """Return text without a leading prompt."""
 657         ps1 = str(sys.ps1)
 658         ps1size = len(ps1)
 659         ps2 = str(sys.ps2)
 660         ps2size = len(ps2)
 661         # Strip the prompt off the front of text.
 662         if text[:ps1size] == ps1:
 663             text = text[ps1size:]
 664         elif text[:ps2size] == ps2:
 665             text = text[ps2size:]
 666         return text
 667
 668     def push(self, command):
 669         """Send command to the interpreter for execution."""
 670         self.write(os.linesep)
 671         busy = wx.BusyCursor()
 672         self.waiting = True
 673         self.more = self.interp.push(command)
 674         self.waiting = False
 675         del busy
 676         if not self.more:
 677             self.addHistory(command.rstrip())
 678         self.prompt()
 679
 680     def addHistory(self, command):
 681         """Add command to the command history."""
 682         # Reset the history position.
 683         self.historyIndex = -1
 684         # Insert this command into the history, unless it's a blank
 685         # line or the same as the last command.
 686         if command != '' \
 687         and (len(self.history) == 0 or command != self.history[0]):
 688             self.history.insert(0, command)
 689
 690     def write(self, text):
 691         """Display text in the shell.
 692
 693         Replace line endings with OS-specific endings."""
 694         text = self.fixLineEndings(text)
 695         self.AddText(text)
 696         self.EnsureCaretVisible()
 697
 698     def fixLineEndings(self, text):
 699         """Return text with line endings replaced by OS-specific endings."""
 700         lines = text.split('\r\n')
 701         for l in range(len(lines)):
 702             chunks = lines[l].split('\r')
 703             for c in range(len(chunks)):
 704                 chunks[c] = os.linesep.join(chunks[c].split('\n'))
 705             lines[l] = os.linesep.join(chunks)
 706         text = os.linesep.join(lines)
 707         return text
 708
 709     def prompt(self):
 710         """Display proper prompt for the context: ps1, ps2 or ps3.
 711
 712         If this is a continuation line, autoindent as necessary."""
 713         isreading = self.reader.isreading
 714         skip = False
 715         if isreading:
 716             prompt = str(sys.ps3)
 717         elif self.more:
 718             prompt = str(sys.ps2)
 719         else:
 720             prompt = str(sys.ps1)
 721         pos = self.GetCurLine()[1]
 722         if pos > 0:
 723             if isreading:
 724                 skip = True
 725             else:
 726                 self.write(os.linesep)
 727         if not self.more:
 728             self.promptPosStart = self.GetCurrentPos()
 729         if not skip:
 730             self.write(prompt)
 731         if not self.more:
 732             self.promptPosEnd = self.GetCurrentPos()
 733             # Keep the undo feature from undoing previous responses.
 734             self.EmptyUndoBuffer()
 735         # XXX Add some autoindent magic here if more.
 736         if self.more:
 737             self.write(' '*4)  # Temporary hack indentation.
 738         self.EnsureCaretVisible()
 739         self.ScrollToColumn(0)
 740
 741     def readline(self):
 742         """Replacement for stdin.readline()."""
 743         input = ''
 744         reader = self.reader
 745         reader.isreading = True
 746         self.prompt()
 747         try:
 748             while not reader.input:
 749                 wx.YieldIfNeeded()
 750             input = reader.input
 751         finally:
 752             reader.input = ''
 753             reader.isreading = False
 754         input = str(input)  # In case of Unicode.
 755         return input
 756
 757     def readlines(self):
 758         """Replacement for stdin.readlines()."""
 759         lines = []
 760         while lines[-1:] != ['\n']:
 761             lines.append(self.readline())
 762         return lines
 763
 764     def raw_input(self, prompt=''):
 765         """Return string based on user input."""
 766         if prompt:
 767             self.write(prompt)
 768         return self.readline()
 769
 770     def ask(self, prompt='Please enter your response:'):
 771         """Get response from the user using a dialog box."""
 772         dialog = wx.TextEntryDialog(None, prompt,
 773                                     'Input Dialog (Raw)', '')
 774         try:
 775             if dialog.ShowModal() == wx.ID_OK:
 776                 text = dialog.GetValue()
 777                 return text
 778         finally:
 779             dialog.Destroy()
 780         return ''
 781
 782     def pause(self):
 783         """Halt execution pending a response from the user."""
 784         self.ask('Press enter to continue:')
 785
 786     def clear(self):
 787         """Delete all text from the shell."""
 788         self.ClearAll()
 789
 790     def run(self, command, prompt=True, verbose=True):
 791         """Execute command as if it was typed in directly.
 792         >>> shell.run('print "this"')
 793         >>> print "this"
 794         this
 795         >>>
 796         """
 797         # Go to the very bottom of the text.
 798         endpos = self.GetTextLength()
 799         self.SetCurrentPos(endpos)
 800         command = command.rstrip()
 801         if prompt: self.prompt()
 802         if verbose: self.write(command)
 803         self.push(command)
 804
 805     def runfile(self, filename):
 806         """Execute all commands in file as if they were typed into the
 807         shell."""
 808         file = open(filename)
 809         try:
 810             self.prompt()
 811             for command in file.readlines():
 812                 if command[:6] == 'shell.':
 813                     # Run shell methods silently.
 814                     self.run(command, prompt=False, verbose=False)
 815                 else:
 816                     self.run(command, prompt=False, verbose=True)
 817         finally:
 818             file.close()
 819
 820     def autoCompleteShow(self, command):
 821         """Display auto-completion popup list."""
 822         self.AutoCompSetAutoHide(self.autoCompleteAutoHide)
 823         self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive)
 824         list = self.interp.getAutoCompleteList(command,
 825                     includeMagic=self.autoCompleteIncludeMagic,
 826                     includeSingle=self.autoCompleteIncludeSingle,
 827                     includeDouble=self.autoCompleteIncludeDouble)
 828         if list:
 829             options = ' '.join(list)
 830             offset = 0
 831             self.AutoCompShow(offset, options)
 832
 833     def autoCallTipShow(self, command):
 834         """Display argument spec and docstring in a popup window."""
 835         if self.CallTipActive():
 836             self.CallTipCancel()
 837         (name, argspec, tip) = self.interp.getCallTip(command)
 838         if tip:
 839             dispatcher.send(signal='Shell.calltip', sender=self, calltip=tip)
 840         if not self.autoCallTip:
 841             return
 842         if argspec:
 843             startpos = self.GetCurrentPos()
 844             self.write(argspec + ')')
 845             endpos = self.GetCurrentPos()
 846             self.SetSelection(endpos, startpos)
 847         if tip:
 848             curpos = self.GetCurrentPos()
 849             tippos = curpos - (len(name) + 1)
 850             fallback = curpos - self.GetColumn(curpos)
 851             # In case there isn't enough room, only go back to the
 852             # fallback.
 853             tippos = max(tippos, fallback)
 854             self.CallTipShow(tippos, tip)
 855
 856     def writeOut(self, text):
 857         """Replacement for stdout."""
 858         self.write(text)
 859
 860     def writeErr(self, text):
 861         """Replacement for stderr."""
 862         self.write(text)
 863
 864     def redirectStdin(self, redirect=True):
 865         """If redirect is true then sys.stdin will come from the shell."""
 866         if redirect:
 867             sys.stdin = self.reader
 868         else:
 869             sys.stdin = self.stdin
 870
 871     def redirectStdout(self, redirect=True):
 872         """If redirect is true then sys.stdout will go to the shell."""
 873         if redirect:
 874             sys.stdout = PseudoFileOut(self.writeOut)
 875         else:
 876             sys.stdout = self.stdout
 877
 878     def redirectStderr(self, redirect=True):
 879         """If redirect is true then sys.stderr will go to the shell."""
 880         if redirect:
 881             sys.stderr = PseudoFileErr(self.writeErr)
 882         else:
 883             sys.stderr = self.stderr
 884
 885     def CanCut(self):
 886         """Return true if text is selected and can be cut."""
 887         if self.GetSelectionStart() != self.GetSelectionEnd() \
 888                and self.GetSelectionStart() >= self.promptPosEnd \
 889                and self.GetSelectionEnd() >= self.promptPosEnd:
 890             return True
 891         else:
 892             return False
 893
 894     def CanPaste(self):
 895         """Return true if a paste should succeed."""
 896         if self.CanEdit() and editwindow.EditWindow.CanPaste(self):
 897             return True
 898         else:
 899             return False
 900
 901     def CanEdit(self):
 902         """Return true if editing should succeed."""
 903         if self.GetSelectionStart() != self.GetSelectionEnd():
 904             if self.GetSelectionStart() >= self.promptPosEnd \
 905                    and self.GetSelectionEnd() >= self.promptPosEnd:
 906                 return True
 907             else:
 908                 return False
 909         else:
 910             return self.GetCurrentPos() >= self.promptPosEnd
 911
 912     def Cut(self):
 913         """Remove selection and place it on the clipboard."""
 914         if self.CanCut() and self.CanCopy():
 915             if self.AutoCompActive():
 916                 self.AutoCompCancel()
 917             if self.CallTipActive():
 918                 self.CallTipCancel()
 919             self.Copy()
 920             self.ReplaceSelection('')
 921
 922     def Copy(self):
 923         """Copy selection and place it on the clipboard."""
 924         if self.CanCopy():
 925             ps1 = str(sys.ps1)
 926             ps2 = str(sys.ps2)
 927             command = self.GetSelectedText()
 928             command = command.replace(os.linesep + ps2, os.linesep)
 929             command = command.replace(os.linesep + ps1, os.linesep)
 930             command = self.lstripPrompt(text=command)
 931             data = wx.TextDataObject(command)
 932             self._clip(data)
 933
 934     def CopyWithPrompts(self):
 935         """Copy selection, including prompts, and place it on the clipboard."""
 936         if self.CanCopy():
 937             command = self.GetSelectedText()
 938             data = wx.TextDataObject(command)
 939             self._clip(data)
 940
 941     def CopyWithPromptsPrefixed(self):
 942         """Copy selection, including prompts prefixed with four
 943         spaces, and place it on the clipboard."""
 944         if self.CanCopy():
 945             command = self.GetSelectedText()
 946             spaces = ' ' * 4
 947             command = spaces + command.replace(os.linesep,
 948                                                os.linesep + spaces)
 949             data = wx.TextDataObject(command)
 950             self._clip(data)
 951
 952     def _clip(self, data):
 953         if wx.TheClipboard.Open():
 954             wx.TheClipboard.UsePrimarySelection(False)
 955             wx.TheClipboard.SetData(data)
 956             wx.TheClipboard.Flush()
 957             wx.TheClipboard.Close()
 958
 959     def Paste(self):
 960         """Replace selection with clipboard contents."""
 961         if self.CanPaste() and wx.TheClipboard.Open():
 962             ps2 = str(sys.ps2)
 963             if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
 964                 data = wx.TextDataObject()
 965                 if wx.TheClipboard.GetData(data):
 966                     self.ReplaceSelection('')
 967                     command = data.GetText()
 968                     command = command.rstrip()
 969                     command = self.fixLineEndings(command)
 970                     command = self.lstripPrompt(text=command)
 971                     command = command.replace(os.linesep + ps2, '\n')
 972                     command = command.replace(os.linesep, '\n')
 973                     command = command.replace('\n', os.linesep + ps2)
 974                     self.write(command)
 975             wx.TheClipboard.Close()
 976
 977     def PasteAndRun(self):
 978         """Replace selection with clipboard contents, run commands."""
 979         if wx.TheClipboard.Open():
 980             ps1 = str(sys.ps1)
 981             ps2 = str(sys.ps2)
 982             if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
 983                 data = wx.TextDataObject()
 984                 if wx.TheClipboard.GetData(data):
 985                     endpos = self.GetTextLength()
 986                     self.SetCurrentPos(endpos)
 987                     startpos = self.promptPosEnd
 988                     self.SetSelection(startpos, endpos)
 989                     self.ReplaceSelection('')
 990                     text = data.GetText()
 991                     text = text.lstrip()
 992                     text = self.fixLineEndings(text)
 993                     text = self.lstripPrompt(text)
 994                     text = text.replace(os.linesep + ps1, '\n')
 995                     text = text.replace(os.linesep + ps2, '\n')
 996                     text = text.replace(os.linesep, '\n')
 997                     lines = text.split('\n')
 998                     commands = []
 999                     command = ''
1000                     for line in lines:
1001                         if line.strip() == ps2.strip():
1002                             # If we are pasting from something like a
1003                             # web page that drops the trailing space
1004                             # from the ps2 prompt of a blank line.
1005                             line = ''
1006                         if line.strip() != '' and line.lstrip() == line:
1007                             # New command.
1008                             if command:
1009                                 # Add the previous command to the list.
1010                                 commands.append(command)
1011                             # Start a new command, which may be multiline.
1012                             command = line
1013                         else:
1014                             # Multiline command. Add to the command.
1015                             command += '\n'
1016                             command += line
1017                     commands.append(command)
1018                     for command in commands:
1019                         command = command.replace('\n', os.linesep + ps2)
1020                         self.write(command)
1021                         self.processLine()
1022             wx.TheClipboard.Close()
1023
1024     def wrap(self, wrap=True):
1025         """Sets whether text is word wrapped."""
1026         try:
1027             self.SetWrapMode(wrap)
1028         except AttributeError:
1029             return 'Wrapping is not available in this version.'
1030
1031     def zoom(self, points=0):
1032         """Set the zoom level.
1033
1034         This number of points is added to the size of all fonts.  It
1035         may be positive to magnify or negative to reduce."""
1036         self.SetZoom(points)