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