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