#---------------------------------------------------------------------- # Name: sliceshell.py # Author: David N. Mashburn, Patrick K. O'Brien # Tags: phoenix-port #---------------------------------------------------------------------- """Slices is an interactive text control in which a user types in commands to be sent to the interpreter. This particular shell is based on wxPython's wxStyledTextCtrl. Sponsored by Orbtech - Your source for Python programming expertise. Slices is a version of shell modified by David Mashburn.""" __author__ = "David N. Mashburn <david.n.mashburn@gmail.com> / " __author__ += "Patrick K. O'Brien <pobrien@orbtech.com>" import wx from wx import stc from wx.lib.six import PY3 import keyword import os import sys import time from .buffer import Buffer from . import dispatcher from . import editor from . import editwindow from . import document from . import frame from .pseudo import PseudoFileIn from .pseudo import PseudoFileOut from .pseudo import PseudoFileErr from .version import VERSION from .magic import magic from .parse import testForContinuations from .path import ls,cd,pwd,sx sys.ps3 = '<-- ' # Input prompt. USE_MAGIC=True # Force updates from long-running commands after this many seconds PRINT_UPDATE_MAX_TIME=2 NAVKEYS = (wx.WXK_HOME, wx.WXK_END, wx.WXK_LEFT, wx.WXK_RIGHT, wx.WXK_UP, wx.WXK_DOWN, wx.WXK_PAGEUP, wx.WXK_PAGEDOWN) GROUPING_SELECTING=0 IO_SELECTING = 1 GROUPING_START = 2 GROUPING_START_FOLDED = 3 GROUPING_MIDDLE = 4 GROUPING_END = 5 INPUT_START = 6 INPUT_START_FOLDED = 7 INPUT_MIDDLE = 8 INPUT_END = 9 OUTPUT_START = 10 OUTPUT_START_FOLDED = 11 OUTPUT_MIDDLE = 12 OUTPUT_END = 13 OUTPUT_BG = 14 READLINE_BG = 15 INPUT_READLINE = 16 # Could add C integration right into the markers... # Non-editable file marker for auto-loaded files... # Weave VariableInput = 15 # Weave C code = 16 # C code = 17 (only for use with Pyrex) # Pyrex / Cython code = 18 GROUPING_MASK = ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED | 1<<GROUPING_MIDDLE | 1<<GROUPING_END ) INPUT_MASK = ( 1<<INPUT_START | 1<<INPUT_START_FOLDED | 1<<INPUT_MIDDLE | 1<<INPUT_END ) OUTPUT_MASK = ( 1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED | 1<<OUTPUT_MIDDLE | 1<<OUTPUT_END ) IO_MASK = ( INPUT_MASK | OUTPUT_MASK ) IO_START_MASK = ( 1<<INPUT_START | 1<<OUTPUT_START ) IO_START_FOLDED_MASK = ( 1<<INPUT_START_FOLDED | 1<<OUTPUT_START_FOLDED ) IO_ANY_START_MASK = ( 1<<INPUT_START | 1<<OUTPUT_START | 1<<INPUT_START_FOLDED | 1<<OUTPUT_START_FOLDED ) IO_MIDDLE_MASK = ( 1<<INPUT_MIDDLE | 1<<OUTPUT_MIDDLE ) IO_END_MASK = ( 1<<INPUT_END | 1<<OUTPUT_END ) usrBinEnvPythonText = '#!/usr/bin/env python\n' pyslicesFormatHeaderText = ['#PySlices Save Format Version 1.1 (PySlices v0.9.7.8 and later)\n', '#PySlices Save Format Version 1.2 (PySlices v0.9.8 and later)\n'] groupingStartText = '#PySlices Marker Information -- Begin Grouping Slice\n' inputStartText = '#PySlices Marker Information -- Begin Input Slice\n' outputStartText = '#PySlices Marker Information -- Begin Output Slice\n' tutorialText = """ Tutorial!!! ------------------------------------------------------------------------ PySlices is the newest member of the Py suite! It is a modified version of PyCrust that supports multi-line commands. Input and output are contained in "Slices" shown as markers in the left margin. Input Slices have RED margins (active, editable). Output Slices have BLUE margins (frozen, not editable). Commands in slices can be on more than one line, as with Sage or Mathematica. For example, the command: a=1 b=2 print(a+b) will all run in sequence, much like a script. Try running the above Input Slice by clicking somewhere in its text and using Ctrl-Return, Shift-Return, or Numpad Enter to execute. Previous commands (Old Slices) can be re-edited and run again in place. Slices can also be: * selceted (click on the margin, Shift-click for multiple selection) * folded (click the margin twice) * selected and deleted (hit delete while selected) * divided (Ctrl-D) * merged (Ctrl-M while selecting adjacent, like-colored slices) Try deleting the slice above this one by clicking on the red margin. If you want a more traditional shell feel, try enabling "Shell Mode" in "Options->Settings->Shell Mode" (or try PyCrust). In Shell Mode, two returns in a row executes the command, and Ctrl-Return and Shift-Return always print newlines. Saving and opening "sessions" is now supported! This is a little different to other shells where the history is saved. With PySlices, the whole document is saved in a simple text format! To disable this Tutorial on startup, uncheck it in the menu at: "Options->Startup->Show PySlices tutorial" PySlices may not be the best thing since sliced bread, but I hope it makes using Python a little bit sweeter! """ class SlicesShellFrame(frame.Frame, frame.ShellFrameMixin): """Frame containing the sliceshell component.""" name = 'SlicesShell Frame' def __init__(self, parent=None, id=-1, title='PySlicesShell', pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE, locals=None, InterpClass=None, config=None, dataDir=None, filename=None, *args, **kwds): """Create SlicesShellFrame instance.""" frame.Frame.__init__(self, parent, id, title, pos, size, style,shellName='PySlices') frame.ShellFrameMixin.__init__(self, config, dataDir) if size == wx.DefaultSize: self.SetSize((750, 525)) intro = 'PySlices %s - The Flakiest Python Shell... Cut Up!' % VERSION self.SetStatusText(intro.replace('\n', ', ')) self.sliceshell = SlicesShell(parent=self, id=-1, introText=intro, locals=locals, InterpClass=InterpClass, startupScript=self.startupScript, execStartupScript=self.execStartupScript, showPySlicesTutorial=self.showPySlicesTutorial, enableShellMode=self.enableShellMode, hideFoldingMargin=self.hideFoldingMargin, *args, **kwds) self.buffer = self.sliceshell.buffer # Override the shell so that status messages go to the status bar. self.sliceshell.setStatusText = self.SetStatusText self.sliceshell.SetFocus() self.LoadSettings() self.currentDirectory = os.path.expanduser('~') if filename!=None: self.bufferOpen(filename) self.Bind(wx.EVT_IDLE, self.OnIdle) def OnClose(self, event): """Event handler for closing.""" self.bufferClose() # This isn't working the way I want, but I'll leave it for now. #if self.sliceshell.waiting: # if event.CanVeto(): # event.Veto(True) #else: # # TODO: Add check for saving # self.SaveSettings() # self.sliceshell.destroy() # self.Destroy() def OnAbout(self, event): """Display an About window.""" title = 'About PySliceShell' text = 'PySliceShell %s\n\n' % VERSION + \ 'Yet another Python shell, only flakier.\n\n' + \ 'Half-baked by Patrick K. O\'Brien,\n' + \ 'the other half is still in the oven.\n\n' + \ 'Platform: %s\n' % sys.platform + \ 'Python Version: %s\n' % sys.version.split()[0] + \ 'wxPython Version: %s\n' % wx.VERSION_STRING + \ ('\t(%s)\n' % ", ".join(wx.PlatformInfo[1:])) dialog = wx.MessageDialog(self, text, title, wx.OK | wx.ICON_INFORMATION) dialog.ShowModal() dialog.Destroy() def OnHelp(self, event): """Show a help dialog.""" frame.ShellFrameMixin.OnHelp(self, event) def LoadSettings(self): if self.config is not None: frame.ShellFrameMixin.LoadSettings(self) frame.Frame.LoadSettings(self, self.config) self.sliceshell.LoadSettings(self.config) def SaveSettings(self, force=False): if self.config is not None: frame.ShellFrameMixin.SaveSettings(self,force) if self.autoSaveSettings or force: frame.Frame.SaveSettings(self, self.config) self.sliceshell.SaveSettings(self.config) def DoSaveSettings(self): if self.config is not None: self.SaveSettings(force=True) self.config.Flush() def OnEnableShellMode(self,event): """Change between Slices Mode and Shell Mode""" frame.Frame.OnEnableShellMode(self,event) self.sliceshell.ToggleShellMode(self.enableShellMode) def OnHideFoldingMargin(self,event): """Change between Slices Mode and Shell Mode""" frame.Frame.OnHideFoldingMargin(self,event) self.sliceshell.ToggleFoldingMargin(self.hideFoldingMargin) # Copied Straight from crustslices.py (update both with any changes...) # Stolen Straight from editor.EditorFrame # Modified a little... :) # || # \/ def OnIdle(self, event): """Event handler for idle time.""" self._updateTitle() event.Skip() def _updateTitle(self): """Show current title information.""" title = self.GetTitle() if self.bufferHasChanged(): if title.startswith('* '): pass else: self.SetTitle('* ' + title) else: if title.startswith('* '): self.SetTitle(title[2:]) def hasBuffer(self): """Return True if there is a current buffer.""" if self.buffer: return True else: return False def bufferClose(self): """Close buffer.""" if self.buffer.hasChanged(): cancel = self.bufferSuggestSave() if cancel: #event.Veto() return cancel self.SaveSettings() self.sliceshell.destroy() self.bufferDestroy() self.Destroy() return False def bufferCreate(self, filename=None): """Create new buffer.""" self.bufferDestroy() buffer = Buffer() self.panel = panel = wx.Panel(parent=self, id=-1) panel.Bind (wx.EVT_ERASE_BACKGROUND, lambda x: x) editor = Editor(parent=panel) panel.editor = editor sizer = wx.BoxSizer(wx.VERTICAL) sizer.Add(editor.window, 1, wx.EXPAND) panel.SetSizer(sizer) panel.SetAutoLayout(True) sizer.Layout() buffer.addEditor(editor) buffer.open(filename) self.setEditor(editor) self.editor.setFocus() self.SendSizeEvent() def bufferDestroy(self): """Destroy the current buffer.""" if self.buffer: self.editor = None self.buffer = None def bufferHasChanged(self): """Return True if buffer has changed since last save.""" if self.buffer: return self.buffer.hasChanged() else: return False def bufferNew(self): """Create new buffer.""" cancel = self.bufferSuggestSave() if cancel: return cancel #self.bufferCreate() self.clear() self.SetTitle( 'PySlices') self.sliceshell.NeedsCheckForSave=False self.sliceshell.SetSavePoint() self.buffer.doc = document.Document() self.buffer.name = 'This shell' self.buffer.modulename = self.buffer.doc.filebase cancel = False return cancel def bufferOpen(self,file=None): """Open file in buffer.""" if self.bufferHasChanged(): cancel = self.bufferSuggestSave() if cancel: return cancel if file==None: file=wx.FileSelector('Open a PySlices File', wildcard='*.pyslices', default_path=self.currentDirectory) if file!=None and file!=u'': fid=open(file,'r') self.sliceshell.LoadPySlicesFile(fid) fid.close() self.currentDirectory = os.path.split(file)[0] self.SetTitle( os.path.split(file)[1] + ' - PySlices') self.sliceshell.NeedsCheckForSave=False self.sliceshell.SetSavePoint() self.buffer.doc = document.Document(file) self.buffer.name = self.buffer.doc.filename self.buffer.modulename = self.buffer.doc.filebase self.sliceshell.ScrollToLine(0) return ## def bufferPrint(self): ## """Print buffer.""" ## pass ## def bufferRevert(self): ## """Revert buffer to version of file on disk.""" ## pass # was self.buffer.save(self): # """Save buffer.""" def simpleSave(self,confirmed=False): filepath = self.buffer.doc.filepath self.buffer.confirmed = confirmed if not filepath: return # XXX Get filename if not os.path.exists(filepath): self.buffer.confirmed = True if not self.buffer.confirmed: self.buffer.confirmed = self.buffer.overwriteConfirm(filepath) if self.buffer.confirmed: try: fid = open(filepath, 'wb') self.sliceshell.SavePySlicesFile(fid) finally: if fid: fid.close() self.sliceshell.SetSavePoint() self.SetTitle( os.path.split(filepath)[1] + ' - PySlices') self.sliceshell.NeedsCheckForSave=False def bufferSave(self): """Save buffer to its file.""" if self.buffer.doc.filepath: # self.buffer.save() self.simpleSave(confirmed=True) cancel = False else: cancel = self.bufferSaveAs() return cancel def bufferSaveAs(self): """Save buffer to a new filename.""" if self.bufferHasChanged() and self.buffer.doc.filepath: cancel = self.bufferSuggestSave() if cancel: return cancel filedir = '' if self.buffer and self.buffer.doc.filedir: filedir = self.buffer.doc.filedir result = editor.saveSingle(title='Save PySlices File',directory=filedir, wildcard='PySlices Files (*.pyslices)|*.pyslices') if result.path not in ['',None]: if result.path[-9:]!=".pyslices": result.path+=".pyslices" self.buffer.doc = document.Document(result.path) self.buffer.name = self.buffer.doc.filename self.buffer.modulename = self.buffer.doc.filebase self.simpleSave(confirmed=True) # allow overwrite cancel = False else: cancel = True return cancel def bufferSaveACopy(self): """Save buffer to a new filename.""" filedir = '' if self.buffer and self.buffer.doc.filedir: filedir = self.buffer.doc.filedir result = editor.saveSingle(title='Save a Copy of PySlices File',directory=filedir, wildcard='PySlices Files (*.pyslices)|*.pyslices') if result.path not in ['',None]: if result.path[-9:]!=".pyslices": result.path+=".pyslices" # if not os.path.exists(result.path): try: # Allow overwrite... fid = open(result.path, 'wb') self.sliceshell.SavePySlicesFile(fid) finally: if fid: fid.close() cancel = False else: cancel = True return cancel def bufferSuggestSave(self): """Suggest saving changes. Return True if user selected Cancel.""" result = editor.messageDialog(parent=None, message='%s has changed.\n' 'Would you like to save it first' '?' % self.buffer.name, title='Save current file?', style=wx.YES_NO | wx.CANCEL | wx.NO_DEFAULT | wx.CENTRE | wx.ICON_QUESTION ) if result.positive: cancel = self.bufferSave() else: cancel = result.text == 'Cancel' return cancel def updateNamespace(self): """Update the buffer namespace for autocompletion and calltips.""" if self.buffer.updateNamespace(): self.SetStatusText('Namespace updated') else: self.SetStatusText('Error executing, unable to update namespace') # TODO : Update the help text HELP_TEXT = """\ * Key bindings: Home Go to the beginning of the line. End Go to the end of the line. Shift+Home Select to the beginning of the line. Shift+End Select to the end of the line. Ctrl-Home Jump to the beginning of the slice; If already there, jump to beginning of previous slice Ctrl-End Jump to the end of the slice; If already there, jump to end of next slice Ctrl-PageUp Jump to the beginning of the shell Ctrl-PageDown Jump to the end of the shell Ctrl+C Copy selected text, removing prompts. Ctrl+Shift+C Copy selected text, retaining prompts. Alt+C Copy to the clipboard, including prefixed prompts. Ctrl+X Cut selected text. Ctrl+V Paste from clipboard. Ctrl+Shift+V Paste and run multiple commands from clipboard. Ctrl+Up Arrow Retrieve Previous History item. Alt+P Retrieve Previous History item. Ctrl+Down Arrow Retrieve Next History item. Alt+N Retrieve Next History item. Shift+Up Arrow Insert Previous History item. Shift+Down Arrow Insert Next History item. F8 Command-completion of History item. (Type a few characters of a previous command and press F8.) Ctrl+] Increase font size. Ctrl+[ Decrease font size. Ctrl+= Default font size. Ctrl-Space Show Auto Completion. Ctrl-Shift-Space Show Call Tip. Ctrl-Shift-H Complete Text from History. Ctrl+F Search Ctrl+G Search next F12 on/off "free-edit" mode For testing only -- This does not preserve markers! In "Slices Mode": Return Insert new line Enter (Numpad) Run command in slice Ctrl+Return "" Shift+Return "" In "Shell Mode": Return or Enter Insert a new line Ctrl+Return "" Shift+Return "" 2 Returns in a row Run command in slice """ class SlicesShellFacade: """Simplified interface to all shell-related functionality. This is a semi-transparent facade, in that all attributes of other are accessible, even though only some are visible to the user.""" name = 'SlicesShell Interface' def __init__(self, other): """Create a SlicesShellFacade instance.""" d = self.__dict__ d['other'] = other d['helpText'] = HELP_TEXT def help(self): """Display some useful information about how to use the slices shell.""" self.write(self.helpText,type='Output') def __getattr__(self, name): if hasattr(self.other, name): return getattr(self.other, name) else: raise AttributeError(name) def __setattr__(self, name, value): if name in self.__dict__: self.__dict__[name] = value elif hasattr(self.other, name): setattr(self.other, name, value) else: raise AttributeError(name) def _getAttributeNames(self): """Return list of magic attributes to extend introspection.""" list = [ 'about', 'ask', 'autoCallTip', 'autoComplete', 'autoCompleteAutoHide', 'autoCompleteCaseInsensitive', 'autoCompleteIncludeDouble', 'autoCompleteIncludeMagic', 'autoCompleteIncludeSingle', 'callTipInsert', 'clear', 'pause', 'prompt', 'quit', 'redirectStderr', 'redirectStdin', 'redirectStdout', 'run', 'runfile', 'wrap', 'zoom', ] list.sort() return list DISPLAY_TEXT=""" Author: %r Py Version: %s Python Version: %s wxPython Version: %s wxPython PlatformInfo: %s Platform: %s""" class SlicesShell(editwindow.EditWindow): """Notebook Shell based on StyledTextCtrl.""" name = 'SlicesShell' def __init__(self, parent, id=-1, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.CLIP_CHILDREN, introText='', locals=None, InterpClass=None, startupScript=None, execStartupScript=True, showPySlicesTutorial=True,enableShellMode=False, hideFoldingMargin=False, *args, **kwds): """Create Shell instance.""" editwindow.EditWindow.__init__(self, parent, id, pos, size, style) self.wrap() if locals is None: import __main__ locals = __main__.__dict__ # Grab these so they can be restored by self.redirect* methods. self.stdin = sys.stdin self.stdout = sys.stdout self.stderr = sys.stderr # Import a default interpreter class if one isn't provided. if InterpClass == None: from .interpreter import Interpreter else: Interpreter = InterpClass # Create a replacement for stdin. self.reader = PseudoFileIn(self.readline, self.readlines) self.reader.input = '' self.reader.isreading = False # Set up the interpreter. self.interp = Interpreter(locals=locals, rawin=self.raw_input, stdin=self.reader, stdout=PseudoFileOut(self.writeOut), stderr=PseudoFileErr(self.writeErr), *args, **kwds) # Set up the buffer. self.buffer = Buffer() self.id = self.GetId() self.buffer.addEditor(self) self.buffer.name='This shell' self.NeedsCheckForSave=False # Find out for which keycodes the interpreter will autocomplete. self.autoCompleteKeys = self.interp.getAutoCompleteKeys() # Keep track of the last non-continuation prompt positions. # Removed all references to these... solved a lot of odd bugs... # self.promptPosStart = 0 # self.promptPosEnd = 0 # Keep track of multi-line commands. self.more = False # Use Margins to track input / output / slice number self.margins = True # For use with forced updates during long-running scripts self.lastUpdate=None if self.margins: # margin 1 is already defined for the line numbers # may eventually change it back to 0 like it ought to be... self.SetMarginType(2, stc.STC_MARGIN_SYMBOL) self.SetMarginType(3, stc.STC_MARGIN_SYMBOL) self.SetMarginType(4, stc.STC_MARGIN_SYMBOL) self.SetMarginWidth(2, 22) self.SetMarginWidth(3, 22) self.SetMarginWidth(4, 12) self.SetMarginSensitive(2,True) self.SetMarginSensitive(3,True) self.SetMarginSensitive(4,True) self.SetProperty("fold", "1") # tabs are bad, use spaces self.SetProperty("tab.timmy.whinge.level", "4") self.SetMargins(0,0) self.SetMarginMask(2, GROUPING_MASK | 1<<GROUPING_SELECTING ) # Display Markers -24... self.SetMarginMask(3, IO_MASK | 1<<IO_SELECTING | 1<<READLINE_BG | 1<<INPUT_READLINE ) self.SetMarginMask(4, stc.STC_MASK_FOLDERS) # Set the mask for the line markers, too... self.SetMarginMask(1, 0) if hideFoldingMargin: self.SetMarginWidth(4, 0) self.hideFoldingMargin=hideFoldingMargin sel_color="#E0E0E0" grouping_color="black" input_color="red" output_color="blue" self.MarkerDefine(GROUPING_SELECTING, stc.STC_MARK_FULLRECT, sel_color, sel_color) self.MarkerDefine(IO_SELECTING, stc.STC_MARK_FULLRECT, sel_color, sel_color) self.MarkerDefine(GROUPING_START, stc.STC_MARK_BOXMINUS, "white", grouping_color) self.MarkerDefine(GROUPING_START_FOLDED, stc.STC_MARK_BOXPLUS, "white", grouping_color) self.MarkerDefine(GROUPING_MIDDLE, stc.STC_MARK_VLINE, "white", grouping_color) self.MarkerDefine(GROUPING_END, stc.STC_MARK_LCORNER, "white", grouping_color) self.MarkerDefine(READLINE_BG, stc.STC_MARK_FULLRECT, wx.Colour(191,191,191), wx.Colour(191,191,191)) self.MarkerDefine(INPUT_READLINE, stc.STC_MARK_CHARACTER+ord('<'), input_color, wx.Colour(191,191,191)) if enableShellMode: self.mode='ShellMode' else: self.mode='SlicesMode' self.execOnNextReturn=False if self.mode=='SlicesMode': self.MarkerDefine(INPUT_START, stc.STC_MARK_BOXMINUS, "white", input_color) self.MarkerDefine(INPUT_START_FOLDED, stc.STC_MARK_BOXPLUS, "white", input_color) self.MarkerDefine(INPUT_MIDDLE, stc.STC_MARK_VLINE, "white", input_color) self.MarkerDefine(INPUT_END, stc.STC_MARK_LCORNER, "white", input_color) elif self.mode=='ShellMode': self.MarkerDefine(INPUT_START, stc.STC_MARK_ARROWS, input_color, "white") self.MarkerDefine(INPUT_START_FOLDED, stc.STC_MARK_BOXPLUS, "white", input_color) self.MarkerDefine(INPUT_MIDDLE, stc.STC_MARK_DOTDOTDOT, input_color, "white") self.MarkerDefine(INPUT_END, stc.STC_MARK_DOTDOTDOT, input_color, "white") self.MarkerDefine(OUTPUT_START, stc.STC_MARK_BOXMINUS, "white", output_color) self.MarkerDefine(OUTPUT_START_FOLDED, stc.STC_MARK_BOXPLUS, "white", output_color) self.MarkerDefine(OUTPUT_MIDDLE, stc.STC_MARK_VLINE, "white", output_color) self.MarkerDefine(OUTPUT_END, stc.STC_MARK_LCORNER, "white", output_color) self.MarkerDefine(OUTPUT_BG, stc.STC_MARK_BACKGROUND, "white", wx.Colour(242,242,255)) # Markers for folding margin... self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, stc.STC_MARK_BOXMINUS, "white", "#808080") self.MarkerDefine(stc.STC_MARKNUM_FOLDER, stc.STC_MARK_BOXPLUS, "white", "#808080") self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, stc.STC_MARK_VLINE, "white", "#808080") self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, stc.STC_MARK_LCORNER, "white", "#808080") self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, stc.STC_MARK_BOXPLUSCONNECTED, "white", "#808080") self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080") self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER, "white", "#808080") # Create the command history. Commands are added into the # front of the list (ie. at index 0) as they are entered. # self.historyIndex is the current position in the history; it # gets incremented as you retrieve the previous command, # decremented as you retrieve the next, and reset when you hit # Enter. self.historyIndex == -1 means you're on the current # command, not in the history. self.history = [] self.historyIndex = -1 #DNM -- disable these markers... #seb add mode for "free edit" self.noteMode = 0 #self.MarkerDefine(0,stc.STC_MARK_ROUNDRECT) # marker for hidden self.searchTxt = "" # Assign handlers for keyboard events. self.Bind(wx.EVT_CHAR, self.OnChar) self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown) self.Bind(wx.stc.EVT_STC_MARGINCLICK, self.OnMarginClick) # TODO : Add a general functions to handle mouse clicks in the # TODO: STC window whose sole purpose is to make it so # TODO: that margin selection becomes unselected... # Assign handler for the context menu self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu) self.Bind(wx.EVT_UPDATE_UI, self.OnUpdateUI) # Assign handlers for edit events self.Bind(wx.EVT_MENU, lambda evt: self.Cut(), id=wx.ID_CUT) self.Bind(wx.EVT_MENU, lambda evt: self.Copy(), id=wx.ID_COPY) self.Bind(wx.EVT_MENU, lambda evt: self.CopyWithPrompts(), id=frame.ID_COPY_PLUS) self.Bind(wx.EVT_MENU, lambda evt: self.Paste(), id=wx.ID_PASTE) self.Bind(wx.EVT_MENU, lambda evt: self.PasteAndRun(), id=frame.ID_PASTE_PLUS) self.Bind(wx.EVT_MENU, lambda evt: self.SelectAll(), id=wx.ID_SELECTALL) self.Bind(wx.EVT_MENU, lambda evt: self.Clear(), id=wx.ID_CLEAR) self.Bind(wx.EVT_MENU, lambda evt: self.Undo(), id=wx.ID_UNDO) self.Bind(wx.EVT_MENU, lambda evt: self.Redo(), id=wx.ID_REDO) # Assign handler for idle time. self.waiting = False self.Bind(wx.EVT_IDLE, self.OnIdle) # Display the introductory banner information. self.showIntro(introText) outStart,outEnd,inStart,inMiddle,inEnd = [[],[],[],[],[]] # Make "executed startup script move to the top..." if showPySlicesTutorial: self.write(tutorialText,'Output') tutStart=5 testStart=16 outStart=[tutStart,testStart+3] outEnd=[tutStart-1,testStart-1] inStart=[testStart] inMiddle=[testStart+1] inEnd=[testStart+2] # Assign some pseudo keywords to the interpreter's namespace. self.setBuiltinKeywords() # Add 'shell' to the interpreter's local namespace. self.setLocalShell() # Do this last so the user has complete control over their # environment. They can override anything they want. if execStartupScript: if startupScript is None: startupScript = os.environ.get('PYTHONSTARTUP') self.execStartupScript(startupScript) else: self.prompt() outStart+=[0] outEnd+=[self.GetLineCount()-2] inStart+=[self.GetLineCount()-1] # Set all the line markers to the proper initial states... for i in range(self.GetLineCount()): self.clearGroupingMarkers(i) self.clearIOMarkers(i) if i in outStart: self.MarkerAdd(i,GROUPING_START) self.MarkerAdd(i,OUTPUT_START) # Background color is confusing for tutorial... skip it! #self.MarkerAdd(i,OUTPUT_BG) elif i in outEnd: self.MarkerAdd(i,GROUPING_END) self.MarkerAdd(i,OUTPUT_END) #self.MarkerAdd(i,OUTPUT_BG) elif i in inStart: self.MarkerAdd(i,GROUPING_START) self.MarkerAdd(i,INPUT_START) elif i in inMiddle: self.MarkerAdd(i,GROUPING_MIDDLE) self.MarkerAdd(i,INPUT_MIDDLE) elif i in inEnd: self.MarkerAdd(i,GROUPING_END) self.MarkerAdd(i,INPUT_END) else: self.MarkerAdd(i,GROUPING_MIDDLE) self.MarkerAdd(i,OUTPUT_MIDDLE) #self.MarkerAdd(i,OUTPUT_BG) self.SliceSelection=False self.runningSlice=None ## NOTE: See note at bottom of this file... ## #seb: File drag and drop ## self.SetDropTarget( FileDropTarget(self) ) #ADD UNDO # Everywhere "ADD UNDO" appears, there is new code to handle markers self.EmptyUndoBuffer() wx.CallAfter(self.ScrollToLine, 0) def ToggleShellMode(self,enableShellMode=None): if enableShellMode==None: if self.mode=='ShellMode': self.mode='SlicesMode' elif self.mode=='SlicesMode': self.mode='ShellMode' elif enableShellMode: self.mode='ShellMode' else: self.mode='SlicesMode' input_color="red" if self.mode=='SlicesMode': self.MarkerDefine(INPUT_START, stc.STC_MARK_BOXMINUS, "white", input_color) self.MarkerDefine(INPUT_START_FOLDED, stc.STC_MARK_BOXPLUS, "white", input_color) self.MarkerDefine(INPUT_MIDDLE, stc.STC_MARK_VLINE, "white", input_color) self.MarkerDefine(INPUT_END, stc.STC_MARK_LCORNER, "white", input_color) elif self.mode=='ShellMode': self.MarkerDefine(INPUT_START, stc.STC_MARK_ARROWS, input_color, "white") self.MarkerDefine(INPUT_START_FOLDED, stc.STC_MARK_BOXPLUS, "white", input_color) self.MarkerDefine(INPUT_MIDDLE, stc.STC_MARK_DOTDOTDOT, input_color, "white") self.MarkerDefine(INPUT_END, stc.STC_MARK_DOTDOTDOT, input_color, "white") def ToggleFoldingMargin(self,hideFoldingMargin=None): if hideFoldingMargin==None: self.hideFoldingMargin = not self.hideFoldingMargin else: self.hideFoldingMargin = hideFoldingMargin if self.hideFoldingMargin: self.SetMarginWidth(4, 0) else: self.SetMarginWidth(4, 12) def clearHistory(self): self.history = [] self.historyIndex = -1 dispatcher.send(signal="SlicesShell.clearHistory") def destroy(self): del self.interp def setFocus(self): """Set focus to the slices shell.""" self.SetFocus() def OnIdle(self, event): """Free the CPU to do other things.""" if self.waiting: time.sleep(0.05) event.Skip() def showIntro(self, text=''): """Display introductory text in the slices shell.""" if text: self.write(text,type='Output') try: if self.interp.introText: if text and not text.endswith(os.linesep): self.write(os.linesep,type='Output') self.write(self.interp.introText,type='Output') except AttributeError: pass def setBuiltinKeywords(self): """Create pseudo keywords as part of builtins. This sets "close", "exit" and "quit" to a helpful string. """ from wx.lib.six import PY3 if PY3: import builtins else: import __builtin__ builtins = __builtin__ builtins.close = builtins.exit = builtins.quit = \ 'Click on the close button to leave the application.' builtins.cd = cd builtins.ls = ls builtins.pwd = pwd builtins.sx = sx def quit(self): """Quit the application.""" # XXX Good enough for now but later we want to send a close event. # In the close event handler we can make sure they want to # quit. Other applications, like PythonCard, may choose to # hide rather than quit so we should just post the event and # let the surrounding app decide what it wants to do. self.write('Click on the close button to leave the application.', type='Output') def setLocalShell(self): """Add 'slicesshell' to locals as reference to ShellFacade instance.""" self.interp.locals['slicesshell'] = SlicesShellFacade(other=self) def execStartupScript(self, startupScript): """Execute the user's PYTHONSTARTUP script if they have one.""" if startupScript and os.path.isfile(startupScript): text = 'Startup script executed: ' + startupScript if PY3: self.push('print(%r)' % text) self.push('with open(%r, "r") as f:\n' ' exec(f.read())\n' % (startupScript)) else: self.push('print(%r); execfile(%r)' % (text, startupScript)) self.interp.startupScript = startupScript else: self.push('') def about(self): """Display information about Py.""" text = DISPLAY_TEXT % \ (__author__, VERSION, sys.version.split()[0], wx.VERSION_STRING, str(wx.PlatformInfo), sys.platform) self.write(text.strip(),type='Output') def BreakTextIntoCommands(self,text): """Turn a text block into multiple multi-line commands.""" #text = text.lstrip() # This should not be done! text = self.fixLineEndings(text) text = self.lstripPrompt(text) text = text.replace(os.linesep, '\n') lines = text.split('\n') continuations = testForContinuations(text) if len(continuations)==2: # Error case... return None,continuations[1] elif len(continuations)==4: stringContinuationList,indentationBlockList, \ lineContinuationList,parentheticalContinuationList = continuations commands = [] command = '' for j,line in enumerate(lines): lstrip = line.lstrip() # Get the first alnum word: first_word=[] for i in lstrip: if i.isalnum(): first_word.append(i) else: break first_word = ''.join(first_word) # Continue the command if it is blank, has indentation, # starts with else, elif,except, or finally # or previous line had a line continuation \ if j==0: stringCont = False lineCont=False else: stringCont = stringContinuationList[j-1] lineCont = lineContinuationList[j-1] if line.strip() == '' or lstrip != line or \ first_word in ['else','elif','except','finally'] or \ stringCont or lineCont: # Multiline command. Add to the command. command += '\n' command += line else: # New command. if command: # Add the previous command to the list. commands.append(command) # Start a new command, which may be multiline. command = line commands.append(command) return commands def MarkerSet(self,line,markerBitsSet): """MarkerSet is the Set command for MarkerGet""" markerBits=self.MarkerGet(line) numMarkers=14 for i in range(numMarkers): if (markerBitsSet & (1<<i)) and not (markerBits & (1<<i)): self.MarkerAdd(line,i) elif not (markerBitsSet & (1<<i)) and (markerBits & (1<<i)): self.MarkerDelete(line,i) def GetGroupingSlice(self,line_num=None): """Get the start/stop lines for the slice based on any line in the slice""" if line_num==None: line_num=self.GetCurrentLine() num_lines=self.GetLineCount() for i in range(line_num,-1,-1): if self.MarkerGet(i) & (1<<GROUPING_START | 1<<GROUPING_START_FOLDED): break start_line=i addition=0 for i in range(line_num,num_lines): if self.MarkerGet(i) & 1<<GROUPING_END: break elif (i>line_num) and ( self.MarkerGet(i) & (1<<GROUPING_START | 1<<GROUPING_START_FOLDED) ): addition=-1 break # the solo case... stop_line=i+addition return start_line,stop_line def GetIOSlice(self,line_num=None): """Get the start/stop lines for the slice based on any line in the slice""" if line_num==None: line_num=self.GetCurrentLine() num_lines=self.GetLineCount() for i in range(line_num,-1,-1): if self.MarkerGet(i) & IO_ANY_START_MASK: break start_line=i addition=0 for i in range(line_num,num_lines): if self.MarkerGet(i) & IO_END_MASK: break elif (i>line_num) and (self.MarkerGet(i) & IO_ANY_START_MASK): addition=-1 break # the solo case... stop_line=i+addition return start_line,stop_line def FoldGroupingSlice(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() start,end=self.GetGroupingSlice(line_num) self.HideLines(start+1,end) marker=self.MarkerGet(start) self.clearGroupingMarkers(start) self.MarkerAdd(start,GROUPING_START_FOLDED) self.clearIOMarkers(start) if marker & ( 1<<INPUT_START | 1<<INPUT_START_FOLDED ): self.MarkerAdd(start,INPUT_START_FOLDED) elif marker & ( 1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED ): self.MarkerAdd(start,OUTPUT_START_FOLDED) self.MarkerAdd(start,OUTPUT_BG) else: pass #print('Bad Markers!!!') def FoldIOSlice(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() start,end=self.GetIOSlice(line_num) self.HideLines(start+1,end) marker=self.MarkerGet(start) if (self.MarkerGet(start) & \ (1<<GROUPING_START | 1<<GROUPING_START_FOLDED )) and \ (self.MarkerGet(end) & 1<<GROUPING_END): self.clearGroupingMarkers(start) self.MarkerAdd(start,GROUPING_START_FOLDED) self.clearIOMarkers(start) if marker & ( 1<<INPUT_START | 1<<INPUT_START_FOLDED ): self.MarkerAdd(start,INPUT_START_FOLDED) elif marker & ( 1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED ): self.MarkerAdd(start,OUTPUT_START_FOLDED) self.MarkerAdd(start,OUTPUT_BG) else: pass #print('Bad Markers!!!') def UnFoldGroupingSlice(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() start,end=self.GetGroupingSlice(line_num) self.ShowLines(start+1,end) self.clearGroupingMarkers(start) self.MarkerAdd(start,GROUPING_START) for i in range(start,end): marker=self.MarkerGet(i) if marker & (1<<INPUT_START | 1<<INPUT_START_FOLDED): self.clearIOMarkers(i) self.MarkerAdd(i,INPUT_START) elif marker & (1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED): self.clearIOMarkers(i) self.MarkerAdd(i,OUTPUT_START) self.MarkerAdd(i,OUTPUT_BG) def UnFoldIOSlice(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() start,end=self.GetIOSlice(line_num) self.ShowLines(start+1,end) marker=self.MarkerGet(start) if (self.MarkerGet(start) & \ (1<<GROUPING_START | 1<<GROUPING_START_FOLDED )) and \ (self.MarkerGet(end) & 1<<GROUPING_END): self.clearGroupingMarkers(start) self.MarkerAdd(start,GROUPING_START) self.clearIOMarkers(start) if marker & 1<<INPUT_START_FOLDED: self.MarkerAdd(start,INPUT_START) elif marker & 1<<OUTPUT_START_FOLDED: self.MarkerAdd(start,OUTPUT_START) self.MarkerAdd(start,OUTPUT_BG) def DeleteOutputSlicesAfter(self,line_num=None): """Delete all outputs after an input""" if line_num==None: line_num=self.GetCurrentLine() num_lines=self.GetLineCount() if self.MarkerGet(line_num) & OUTPUT_MASK: #print('You can only run "DeleteOutputSlicesAfter" from an Input slice!') return startIn,endIn=self.GetIOSlice(line_num) startGrouping,endGrouping=self.GetGroupingSlice(line_num) if endIn<endGrouping: self.SetSelection(self.PositionFromLine(endIn+1), self.PositionFromLine(endGrouping+1)) self.ReplaceSelection('',sliceDeletion=True) new_pos=self.GetLineEndPosition(line_num) self.SetCurrentPos(new_pos) self.SetSelection(new_pos,new_pos) def SplitSlice(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() start_num,end_num=self.GetIOSlice(line_num) if self.MarkerGet(line_num) & INPUT_MASK: type='Input' start=INPUT_START end=INPUT_END splitGrouping=True elif self.MarkerGet(line_num) & OUTPUT_MASK: type='Output' start=OUTPUT_START end=OUTPUT_END splitGrouping=False if start_num==end_num: return # Can't split one line! elif start_num==line_num: self.clearIOMarkers(line_num+1) self.MarkerAdd(line_num+1,start) if type=='Output': self.MarkerAdd(line_num+1,OUTPUT_BG) if splitGrouping: self.clearGroupingMarkers(line_num+1) self.MarkerAdd(line_num+1,GROUPING_START) else: self.clearIOMarkers(line_num) self.MarkerAdd(line_num,start) if type=='Output': self.MarkerAdd(line_num,OUTPUT_BG) if splitGrouping: self.clearGroupingMarkers(line_num) self.MarkerAdd(line_num,GROUPING_START) if line_num-1>start_num: self.clearIOMarkers(line_num-1) self.MarkerAdd(line_num-1,end) if type=='Output': self.MarkerAdd(line_num-1,OUTPUT_BG) if splitGrouping: self.clearGroupingMarkers(line_num-1) self.MarkerAdd(line_num-1,GROUPING_END) def BackspaceWMarkers(self,force=False): # Warning: This is not good at checking for bad markers! c_before=self.GetCharAt(self.GetCurrentPos() - 1) c_after=self.GetCharAt(self.GetCurrentPos()) if c_before==0: # Disallow deleting the first line or it will destroy the markers... return False elif c_before in (ord('\n'),ord('\r')): line_num=self.GetCurrentLine() marker=self.MarkerGet(line_num) marker_before=self.MarkerGet(line_num-1) marker_after=self.MarkerGet(line_num+1) if marker_before & ( 1<<GROUPING_END ) : return False # Disallow deleting lines between slices... elif marker & ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED ) : return False # Disallow deleting lines between slices... else: if marker_before & ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED ) : self.clearGroupingMarkers(line_num) elif marker & ( 1<<GROUPING_END ) : self.clearGroupingMarkers(line_num-1) if (marker_before & 1<<INPUT_END) and force: # Special case for use in processLine self.clearIOMarkers(line_num) elif marker_before & (1<<INPUT_END | 1<<OUTPUT_END): return False # Disallow deleting lines between slices... elif marker & ( 1<<INPUT_START | 1<<INPUT_START_FOLDED ) : return False # Disallow deleting lines between slices... else: if marker_before & (1<<INPUT_START | 1<<INPUT_START_FOLDED | 1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED): self.clearIOMarkers(line_num) elif marker & ( 1<<INPUT_END | 1<<OUTPUT_END ) : self.clearIOMarkers(line_num-1) return True # If everything went well, return True and do the delete... def ForwardDeleteWMarkers(self): c_before=self.GetCharAt(self.GetCurrentPos() - 1) c_after=self.GetCharAt(self.GetCurrentPos()) if c_after==0: # Disallow deleting the first line or it will destroy the markers... return False elif c_after in (ord('\n'),ord('\r')): line_num=self.GetCurrentLine() marker=self.MarkerGet(line_num) marker_before=self.MarkerGet(line_num-1) marker_after=self.MarkerGet(line_num+1) if marker & ( 1<<GROUPING_END ) : return False # Disallow deleting lines between slices... elif marker_after & ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED ) : return False # Disallow deleting lines between slices... else: if marker & ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED ) : self.clearGroupingMarkers(line_num+1) elif marker_after & ( 1<<GROUPING_END ) : self.clearGroupingMarkers(line_num) if marker & ( 1<<INPUT_END | 1<<OUTPUT_END ) : return False # Disallow deleting lines between slices... elif marker_after & ( 1<<INPUT_START | 1<<INPUT_START_FOLDED ) : return False # Disallow deleting lines between slices... else: if marker & (1<<INPUT_START | 1<<INPUT_START_FOLDED | 1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED) : self.clearIOMarkers(line_num+1) elif marker_after & ( 1<<INPUT_END | 1<<OUTPUT_END ) : self.clearIOMarkers(line_num) return True def GetIOSelection(self): started=False start=0 end=self.GetLineCount()-1 type=None for i in range(self.GetLineCount()): if self.MarkerGet(i) & 1<<IO_SELECTING: if started==False: start=i if self.MarkerGet(i) & INPUT_MASK: type='input' elif self.MarkerGet(i) & OUTPUT_MASK: type='output' else: if self.MarkerGet(i) & INPUT_MASK: if type=='output': end=i-1 break elif self.MarkerGet(i) & OUTPUT_MASK: if type=='input': end=i-1 break started=True elif started==True: end=i-1 break if started==False: #print('No Selection!!') self.SliceSelection=False return start,end def MergeAdjacentSlices(self): """This function merges all adjacent selected slices.\n""" + \ """Right now, only IO Merging is allowed.""" started=False start=0 end=self.GetLineCount()-1 type=None for i in range(self.GetLineCount()): if self.MarkerGet(i) & 1<<IO_SELECTING: if started==False: start=i if self.MarkerGet(i) & INPUT_MASK: type='input' elif self.MarkerGet(i) & OUTPUT_MASK: type='output' else: if self.MarkerGet(i) & INPUT_MASK: if type=='output': end=i-1 break else: self.clearIOMarkers(i) self.clearGroupingMarkers(i) self.MarkerAdd(i,INPUT_MIDDLE) self.MarkerAdd(i,GROUPING_MIDDLE) elif self.MarkerGet(i) & OUTPUT_MASK: if type=='input': end=i-1 break else: self.clearIOMarkers(i) self.clearGroupingMarkers(i) self.MarkerAdd(i,OUTPUT_MIDDLE) self.MarkerAdd(i,OUTPUT_BG) self.MarkerAdd(i,GROUPING_MIDDLE) started=True elif started==True: end=i-1 break if started and end!=start: self.clearIOMarkers(end) self.clearGroupingMarkers(end) if type=='input': self.MarkerAdd(end,INPUT_END) if end+1<self.GetLineCount(): if self.MarkerGet(end+1) & OUTPUT_MASK: self.MarkerAdd(end,GROUPING_MIDDLE) else: self.MarkerAdd(end,GROUPING_END) else: self.MarkerAdd(end,GROUPING_END) else: if self.MarkerGet(start) & 1<<GROUPING_END: self.clearGroupingMarkers(start) self.MarkerAdd(start,GROUPING_MIDDLE) self.MarkerAdd(end,OUTPUT_END) self.MarkerAdd(end,OUTPUT_BG) self.MarkerAdd(end,GROUPING_END) def SliceSelectionDelete(self): """Deletion of any selected and possibly discontinuous slices.""" if not self.SliceSelection: return # collect the line numbers to be deleted... selectedSlices=[] start,end=None,None for i in range(self.GetLineCount()): if self.MarkerGet(i) & (1<<GROUPING_SELECTING | 1<<IO_SELECTING): if start==None: start=i end=i elif start!=None: selectedSlices.append([start,end]) start,end=None,None if start!=None: selectedSlices.append([start,end]) # Unselect everything self.MarginUnselectAll() self.SliceSelection=False # Going in reverse, delete the selections, fixing the markers as we go... for i in range(len(selectedSlices)-1,-1,-1): self.SetSelection(self.PositionFromLine(selectedSlices[i][0]), self.GetLineEndPosition(selectedSlices[i][1])+1) markerNext = self.MarkerGet(selectedSlices[i][1]+1) self.ReplaceSelection('',sliceDeletion=True) cur_line=self.GetCurrentLine() # If we've made a mess of the grouping markers, clean it up... if ((self.MarkerGet(cur_line-1) & 1<<GROUPING_END) and (self.MarkerGet(cur_line) & ( 1<<GROUPING_MIDDLE | 1<<GROUPING_END ) )): self.clearGroupingMarkers(cur_line) self.MarkerAdd(cur_line,GROUPING_START) elif (( self.MarkerGet(cur_line-1) & 1<<GROUPING_MIDDLE ) and ( self.MarkerGet(cur_line) & ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED ) )): self.clearGroupingMarkers(cur_line-1) self.MarkerAdd(cur_line-1,GROUPING_END) if markerNext & 1<<OUTPUT_START: self.clearIOMarkers(cur_line) self.MarkerAdd(cur_line,OUTPUT_START) self.MarkerAdd(cur_line,OUTPUT_BG) elif markerNext & 1<<OUTPUT_START_FOLDED: self.clearIOMarkers(cur_line) self.MarkerAdd(cur_line,OUTPUT_START_FOLDED) self.MarkerAdd(cur_line,OUTPUT_BG) return def OnChar(self, event): """Keypress event handler. Only receives an event if OnKeyDown calls event.Skip() for the corresponding event.""" if self.noteMode: event.Skip() return # Prevent modification of output slices if not self.CanEdit(): return key = event.GetKeyCode() currpos = self.GetCurrentPos() stoppos = self.PositionFromLine(self.GetCurrentLine()) # Return (Enter) needs to be ignored in this handler. if key in [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]: pass elif key in self.autoCompleteKeys: # Usually the dot (period) key activates auto completion. # Get the command between the prompt and the cursor. Add # the autocomplete character to the end of the command. if self.AutoCompActive(): self.AutoCompCancel() command = self.GetTextRange(stoppos, currpos) + chr(key) # write with undo wrapper... cpos=self.GetCurrentPos() s=chr(key) #ADD UNDO self.UpdateUndoHistoryBefore('insert',s,cpos,cpos+len(s), forceNewAction=False) self.write(s,type='Input') self.UpdateUndoHistoryAfter() if self.autoComplete: self.autoCompleteShow(command) elif key == ord('('): # The left paren activates a call tip and cancels an # active auto completion. if self.AutoCompActive(): self.AutoCompCancel() # Get the command between the prompt and the cursor. Add # the '(' to the end of the command. self.ReplaceSelection('') command = self.GetTextRange(stoppos, currpos) + '(' # write with undo wrapper... cpos=self.GetCurrentPos() s='(' self.UpdateUndoHistoryBefore('insert',s,cpos,cpos+len(s), forceNewAction=True) self.undoHistory[self.undoIndex]['allowsAppend']=True self.write(s,type='Input') self.UpdateUndoHistoryAfter() self.autoCallTipShow(command, self.GetCurrentPos() == self.GetTextLength()) else: # Allow the normal event handling to take place. # Use undo wrapper cpos=self.GetCurrentPos() try: s=chr(key) self.UpdateUndoHistoryBefore('insert',s,cpos,cpos+len(s)) event.Skip() self.UpdateUndoHistoryAfter() except: event.Skip() def AutoCompActiveCallback(self): numChars=self.GetTextLength()-self.TotalLengthForAutoCompActiveCallback if numChars==0: self.undoIndex-=1 del(self.undoHistory[-1]) else: uH=self.undoHistory uI=self.undoIndex cpos=uH[uI]['posStart'] s=''.join([chr(self.GetCharAt(cpos+i)) for i in range(numChars)]) s.replace(os.linesep,'\n') self.undoHistory[self.undoIndex]['charList'] = s self.undoHistory[self.undoIndex]['posEnd'] = cpos + numChars self.undoHistory[self.undoIndex]['numLines'] = len(s.split('\n')) self.UpdateUndoHistoryAfter() def OnKeyDown(self, event): """Key down event handler.""" key = event.GetKeyCode() # If the auto-complete window is up let it do its thing. if self.AutoCompActive(): if key in [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]: cpos=self.GetCurrentPos() self.UpdateUndoHistoryBefore('insert','dummy',cpos,cpos+5, forceNewAction=True) self.undoHistory[self.undoIndex]['allowsAppend'] = True self.TotalLengthForAutoCompActiveCallback=self.GetTextLength() event.Skip() wx.CallAfter(self.AutoCompActiveCallback) if key in [wx.WXK_DELETE,wx.WXK_BACK]: self.AutoCompCancel() else: event.Skip() return #DNM # Prevent modification of output slices controlDown = event.ControlDown() altDown = event.AltDown() shiftDown = event.ShiftDown() currpos = self.GetCurrentPos() endpos = self.GetTextLength() selecting = self.GetSelectionStart() != self.GetSelectionEnd() if key == wx.WXK_F12: #seb if self.noteMode: # self.promptPosStart not used anyway - or ? ## # We don't need to do this any more! ## self.promptPosEnd = self.PositionFromLine(self.GetLineCount()-1 ) + ## len(str(sys.ps1)) ## self.GotoLine(self.GetLineCount()) ## self.GotoPos(self.promptPosEnd) ## self.prompt() #make sure we have a prompt self.SetCaretForeground("black") self.SetCaretWidth(1) #default self.SetCaretPeriod(500) #default else: self.SetCaretForeground("red") self.SetCaretWidth(4) self.SetCaretPeriod(0) #steady self.noteMode = not self.noteMode return if self.noteMode: event.Skip() return doLineBreak=False doSubmitCommand=False doPass=False # Return is used to insert a line break. # In Shell Mode, hit Return or Enter twice to submit a command if ((not controlDown and not shiftDown and not altDown) and key in [wx.WXK_RETURN,]): if self.mode=='SlicesMode': doLineBreak=True elif self.mode=='ShellMode': startLine,endLine = self.GetIOSlice() startpos = self.PositionFromLine(startLine) endpos = self.GetLineEndPosition(endLine) command = self.GetTextRange(startpos, endpos) strCont,indentBlock,lineCont,parenCont = testForContinuations(command,ignoreErrors=True) lastLine = command.split('\n')[-1] if lastLine.lstrip()=='': # all whitespace... stillIndented=False elif lastLine[0]==' ': stillIndented=True else: stillIndented=False if strCont[-1] or indentBlock[-1] or lineCont[-1] or \ parenCont[-1]: doLineBreak=True elif stillIndented: new_pos=self.GetLineEndPosition(endLine) self.SetCurrentPos(new_pos) self.SetSelection(new_pos,new_pos) doLineBreak=True elif self.GetCurrentLine()!=endLine: new_pos=self.GetLineEndPosition(endLine) self.SetCurrentPos(new_pos) self.SetSelection(new_pos,new_pos) doPass = True else: doSubmitCommand=True # Enter (Shift/Ctrl + Enter/Return) submits a command to the interpreter. # In Shell Mode, hit Return or Enter twice to submit a command elif ( key in [wx.WXK_NUMPAD_ENTER,] or ( (shiftDown or controlDown) and key in [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER] ) ): if self.mode=='SlicesMode': doSubmitCommand=True elif self.mode=='ShellMode': doLineBreak=True #Only relevant in ShellMode... if doPass: pass elif doLineBreak or doSubmitCommand: if self.CallTipActive(): self.CallTipCancel() elif self.SliceSelection: for i in range(self.GetLineCount()): if self.MarkerGet(i) & 1<<GROUPING_SELECTING: self.DoMarginClick(i, 2, shiftDown, controlDown) break elif self.MarkerGet(i) & 1<<IO_SELECTING: self.DoMarginClick(i, 3, shiftDown, controlDown) break elif doLineBreak: self.insertLineBreak() #Only relevant in ShellMode... elif doSubmitCommand: self.DeleteOutputSlicesAfter() self.processLine() # Let Ctrl-Alt-* get handled normally. elif controlDown and altDown: event.Skip() # Clear the current, unexecuted command. elif key == wx.WXK_ESCAPE: if self.CallTipActive(): event.Skip() # Clear the current command elif key == wx.WXK_BACK and controlDown and shiftDown: self.clearCommand() # Increase font size. elif controlDown and key in (ord(']'), wx.WXK_NUMPAD_ADD): dispatcher.send(signal='FontIncrease') # Decrease font size. elif controlDown and key in (ord('['), wx.WXK_NUMPAD_SUBTRACT): dispatcher.send(signal='FontDecrease') # Default font size. elif controlDown and key in (ord('='), wx.WXK_NUMPAD_DIVIDE): dispatcher.send(signal='FontDefault') # Cut to the clipboard. elif (controlDown and key in (ord('X'), ord('x'))) \ or (shiftDown and key == wx.WXK_DELETE): self.Cut() # Copy to the clipboard. elif controlDown and not shiftDown \ and key in (ord('C'), ord('c'), wx.WXK_INSERT): self.Copy() # Copy to the clipboard, including prompts. elif controlDown and shiftDown \ and key in (ord('C'), ord('c'), wx.WXK_INSERT): self.CopyWithPrompts() # Copy to the clipboard, including prefixed prompts. elif altDown and not controlDown \ and key in (ord('C'), ord('c'), wx.WXK_INSERT): self.CopyWithPromptsPrefixed() # Home needs to be aware of the prompt. elif controlDown and key == wx.WXK_HOME: # Go to the beginning of the IO Slice curLine = self.GetCurrentLine() IOstart = self.GetIOSlice(curLine)[0] home = self.PositionFromLine(IOstart) if currpos == home and \ IOstart > 0: home = self.PositionFromLine(self.GetIOSlice(curLine-1)[0]) self.SetCurrentPos(home) if not selecting and not shiftDown: self.SetAnchor(home) self.EnsureCaretVisible() elif controlDown and key == wx.WXK_END: curLine = self.GetCurrentLine() IOend = self.GetIOSlice(curLine)[1] end = self.GetLineEndPosition(IOend) if currpos == end and \ IOend < self.GetLineCount()-1: end = self.GetLineEndPosition(self.GetIOSlice(curLine+1)[1]) self.SetCurrentPos(end) if not selecting and not shiftDown: self.SetAnchor(end) self.EnsureCaretVisible() elif controlDown and key == wx.WXK_PAGEUP: pos=0 if currpos > pos: self.SetCurrentPos(pos) if not selecting and not shiftDown: self.SetAnchor(pos) self.EnsureCaretVisible() elif controlDown and key == wx.WXK_PAGEDOWN: pos = self.GetLineEndPosition(self.GetLineCount()-1) if currpos < pos: self.SetCurrentPos(pos) if not selecting and not shiftDown: self.SetAnchor(pos) self.EnsureCaretVisible() elif selecting and key not in NAVKEYS and not self.CanEdit(): pass # Paste from the clipboard. elif (controlDown and not shiftDown and key in (ord('V'), ord('v'))) \ or (shiftDown and not controlDown and key == wx.WXK_INSERT): self.Paste() # Paste from the clipboard, run commands. elif controlDown and shiftDown and \ key in (ord('V'), ord('v')) and self.CanEdit(): self.PasteAndRun() # Replace with the previous command from the history buffer. elif (controlDown and not shiftDown and key == wx.WXK_UP) \ or (altDown and key in (ord('P'), ord('p'))) and self.CanEdit(): self.OnHistoryReplace(step=+1) # Replace with the next command from the history buffer. elif (controlDown and not shiftDown and key == wx.WXK_DOWN) \ or (altDown and key in (ord('N'), ord('n'))) and self.CanEdit(): self.OnHistoryReplace(step=-1) # Insert the previous command from the history buffer. elif (controlDown and shiftDown and key == wx.WXK_UP) and \ self.CanEdit(): self.OnHistoryInsert(step=+1) # Insert the next command from the history buffer. elif (controlDown and shiftDown and key == wx.WXK_DOWN) and \ self.CanEdit(): self.OnHistoryInsert(step=-1) # Ctrl-Space shows Auto Completion # Ctrl-Shift-Space shows CallTips elif controlDown and key == wx.WXK_SPACE: self.OnCallTipAutoCompleteManually(shiftDown) # Ctrl+Shift+H is used to complete Text (from already typed words) elif controlDown and shiftDown and key in [ord('H')]: self.OnShowCompHistory() # Search up the history for the text in front of the cursor. elif key == wx.WXK_F8: self.OnHistorySearch() # Don't backspace over the latest non-continuation prompt. elif key == wx.WXK_BACK: if self.SliceSelection: self.SliceSelectionDelete() wx.CallAfter(self.RestoreFirstMarker) elif selecting and self.CanEdit(): self.ReplaceSelection('') #event.Skip() elif self.CanEdit(): doDelete=True cur_line=self.GetCurrentLine() if not cur_line==0 and \ self.GetCurrentPos()==self.PositionFromLine(cur_line): if self.MarkerGet(cur_line-1) & OUTPUT_MASK: doDelete=False if doDelete: cpos=self.GetCurrentPos() s=chr(self.GetCharAt(cpos-1)) self.UpdateUndoHistoryBefore('delete',s,cpos-1,cpos) if self.BackspaceWMarkers(): event.Skip() wx.CallAfter(self.RestoreFirstMarker) elif key == wx.WXK_DELETE: if self.SliceSelection: self.SliceSelectionDelete() wx.CallAfter(self.RestoreFirstMarker) elif selecting and self.CanEdit(): self.ReplaceSelection('') #event.Skip() elif self.CanEdit(): doDelete=True cur_line=self.GetCurrentLine() if not cur_line==self.GetLineCount()-1 and \ self.GetCurrentPos()==self.GetLineEndPosition(cur_line): if self.MarkerGet(cur_line+1) & OUTPUT_MASK: doDelete=False if doDelete: cpos=self.GetCurrentPos() s=chr(self.GetCharAt(cpos)) self.UpdateUndoHistoryBefore('delete',s,cpos,cpos+1) if self.ForwardDeleteWMarkers(): event.Skip() wx.CallAfter(self.RestoreFirstMarker) # Only allow these keys after the latest prompt. elif key == wx.WXK_TAB and self.CanEdit(): # use the same mechanism as with autocmplete... cpos=self.GetCurrentPos() self.UpdateUndoHistoryBefore('insert','dummy',cpos,cpos+5, forceNewAction=True) self.undoHistory[self.undoIndex]['allowsAppend'] = True self.TotalLengthForAutoCompActiveCallback=self.GetTextLength() event.Skip() wx.CallAfter(self.AutoCompActiveCallback) # Don't toggle between insert mode and overwrite mode. elif key == wx.WXK_INSERT: pass # Don't allow line deletion. #elif controlDown and key in (ord('L'), ord('l')): # TODO : Allow line deletion eventually ?? #event.Skip() # pass # Don't allow line transposition. # Toggle Shell Mode / Slices Mode elif controlDown and key in (ord('T'), ord('t')): self.ToggleShellMode() #Open and Save now work when using CrustSlicesFrames elif controlDown and key in (ord('L'), ord('l')): #print('Load it') file=wx.FileSelector("Load File As New Slice") if file!=u'': fid=open(file,'r') self.LoadPyFileAsSlice(fid) fid.close() elif controlDown and key in (ord('D'), ord('d')): #Disallow line duplication in favor of divide slices if self.MarkerGet(self.GetCurrentLine()) & INPUT_MASK: #ADD UNDO cpos=self.GetCurrentPos() start,end = map(self.PositionFromLine, self.GetGroupingSlice(self.LineFromPosition(cpos))) self.UpdateUndoHistoryBefore('marker','',start,end, forceNewAction=True) self.SplitSlice() # Turn off selecting self.SetSelection(cpos,cpos) self.ReplaceSelection('') self.UpdateUndoHistoryAfter() elif controlDown and key in (ord('M'), ord('m')): #ADD UNDO if self.SliceSelection: cpos=self.GetCurrentPos() ioSel=self.GetIOSelection() if self.SliceSelection: start,end = map(self.PositionFromLine,ioSel) self.UpdateUndoHistoryBefore('marker','',start,end, forceNewAction=True) self.MergeAdjacentSlices() # Turn off selecting self.SetSelection(cpos,cpos) self.ReplaceSelection('') self.UpdateUndoHistoryAfter() # Change arrow keys to allow margin behaviors... elif self.SliceSelection and \ key in [wx.WXK_UP,wx.WXK_DOWN,wx.WXK_RIGHT,wx.WXK_LEFT]: # TODO : This is useful, but not optimal! if key==wx.WXK_UP: for i in range(self.GetLineCount()): if self.MarkerGet(i) & 1<<GROUPING_SELECTING: if i>0: #Grouping self.DoMarginClick(i-1, 2, shiftDown, controlDown) break elif self.MarkerGet(i) & 1<<IO_SELECTING: if i>0: #IO self.DoMarginClick(i-1, 3, shiftDown, controlDown) break elif key==wx.WXK_DOWN: for i in range(self.GetLineCount()-1,-1,-1): if self.MarkerGet(i) & 1<<GROUPING_SELECTING: if i<self.GetLineCount()-1: #Grouping self.DoMarginClick(i+1, 2, shiftDown, controlDown) break elif self.MarkerGet(i) & 1<<IO_SELECTING: if i<self.GetLineCount()-1: #IO self.DoMarginClick(i+1, 3, shiftDown, controlDown) break elif key==wx.WXK_RIGHT: for i in range(self.GetLineCount()): if self.MarkerGet(i) & 1<<GROUPING_SELECTING: self.DoMarginClick(i, 3, shiftDown, controlDown) break elif self.MarkerGet(i) & 1<<IO_SELECTING: self.MarginUnselectAll() # Go to the beginning of the IO Slice self.SetCurrentPos(self.PositionFromLine(i)) if not selecting and not shiftDown: self.SetAnchor(self.PositionFromLine(i)) self.EnsureCaretVisible() break elif key==wx.WXK_LEFT: for i in range(self.GetLineCount()): if self.MarkerGet(i) & 1<<GROUPING_SELECTING: break elif self.MarkerGet(i) & 1<<IO_SELECTING: self.DoMarginClick(i, 2, shiftDown, controlDown) break # Basic navigation keys should work anywhere. elif key in NAVKEYS: event.Skip() # Protect the readonly portion of the slices shell. elif not self.CanEdit(): pass else: # Check to see if we're selecting if self.GetSelectionEnd()>self.GetSelectionStart(): # Check to see if a normal input took place if not controlDown and not altDown and key<256: self.ReplaceSelection('') # This seems to work... event.Skip() if self.SliceSelection: if key not in [wx.WXK_UP,wx.WXK_DOWN,wx.WXK_RIGHT,wx.WXK_LEFT, wx.WXK_ALT,wx.WXK_COMMAND,wx.WXK_CONTROL,wx.WXK_SHIFT]: self.MarginUnselectAll() def MarginSelectAll(self): num_lines=self.GetLineCount() for i in range(num_lines): self.MarkerAdd(i,GROUPING_SELECTING) self.MarkerDelete(i,IO_SELECTING) def MarginUnselectAll(self): num_lines=self.GetLineCount() for i in range(num_lines): self.MarkerDelete(i,IO_SELECTING) self.MarkerDelete(i,GROUPING_SELECTING) self.SliceSelection=False def DoMarginClick(self, lineClicked, margin, shiftDown, controlDown): num_lines=self.GetLineCount() if margin==1: pass # these events are not sent right now... if margin==2: self.SliceSelection=True start,end=self.GetGroupingSlice(lineClicked) startPos=self.PositionFromLine(start) self.SetCurrentPos(startPos) self.SetSelection(startPos,startPos) start_marker=self.MarkerGet(start) if self.MarkerGet(lineClicked) & 1<<GROUPING_SELECTING: toggle=self.MarkerDelete if not shiftDown: if start_marker & 1<<GROUPING_START: self.FoldGroupingSlice(lineClicked) elif start_marker & 1<<GROUPING_START_FOLDED: self.UnFoldGroupingSlice(lineClicked) else: toggle=self.MarkerAdd if not shiftDown: self.MarginUnselectAll() for i in range(start,end+1): toggle(i,GROUPING_SELECTING) elif margin==3: self.SliceSelection=True start,end=self.GetIOSlice(lineClicked) startPos=self.PositionFromLine(start) self.SetCurrentPos(startPos) self.SetSelection(startPos,startPos) start_marker=self.MarkerGet(start) if self.MarkerGet(lineClicked) & 1<<IO_SELECTING: toggle=self.MarkerDelete if not shiftDown: if start_marker & IO_START_MASK: self.FoldIOSlice(lineClicked) elif start_marker & IO_START_FOLDED_MASK: self.UnFoldIOSlice(lineClicked) else: toggle=self.MarkerAdd if not shiftDown: self.MarginUnselectAll() for i in range(start,end+1): toggle(i,IO_SELECTING) #print(start, end) elif margin==4: # TODO : Folding ?? if 1:#self.MarkerGet(lineClicked) & ( 1<<7 | 1<<8 ): if shiftDown: self.SetFoldExpanded(lineClicked, True) self.Expand(lineClicked, True, True, 1) elif controlDown: if self.GetFoldExpanded(lineClicked): self.SetFoldExpanded(lineClicked, False) self.Expand(lineClicked, False, True, 0) else: self.SetFoldExpanded(lineClicked, True) self.Expand(lineClicked, True, True, 100) else: self.ToggleFold(lineClicked) else: self.MarginUnselectAll() if margin in [2,3]: if toggle==self.MarkerDelete and not shiftDown: self.SliceSelection=False else: self.SliceSelection=True def OnMarginClick(self, evt): # fold and unfold as neededNAVKEYS lineClicked = self.LineFromPosition(evt.GetPosition()) self.DoMarginClick(lineClicked,evt.GetMargin(),evt.GetShift(),evt.GetControl()) evt.Skip() def OnShowCompHistory(self): """Show possible autocompletion Words from already typed words.""" #copy from history his = self.history[:] #put together in one string joined = " ".join (his) import re #sort out only "good" words newlist = re.split("[ \.\[\]=}(\)\,0-9\"]", joined) #length > 1 (mix out "trash") thlist = [] for i in newlist: if len (i) > 1: thlist.append (i) #unique (no duplicate words #oneliner from german python forum => unique list unlist = [thlist[i] for i in xrange(len(thlist)) if thlist[i] not in thlist[:i]] #sort lowercase unlist.sort(lambda a, b: cmp(a.lower(), b.lower())) #this is more convenient, isn't it? self.AutoCompSetIgnoreCase(True) #join again together in a string stringlist = " ".join(unlist) #pos von 0 noch ausrechnen #how big is the offset? cpos = self.GetCurrentPos() - 1 while chr (self.GetCharAt (cpos)).isalnum(): cpos -= 1 #the most important part self.AutoCompShow(self.GetCurrentPos() - cpos -1, stringlist) def ReplaceSelection(self,text,sliceDeletion=False,*args,**kwds): startIO,endIO=self.GetIOSlice() startGrouping,endGrouping=self.GetGroupingSlice() startSel = self.LineFromPosition(self.GetSelectionStart()) endSel = self.LineFromPosition(self.GetSelectionEnd()) #ADD UNDO cpos=self.GetSelectionStart() s=self.GetSelectedText() if s!='': self.UpdateUndoHistoryBefore('delete',s,cpos,cpos+len(s), forceNewAction=True) editwindow.EditWindow.ReplaceSelection(self,'',*args,**kwds) if s!='' and not sliceDeletion: self.UpdateUndoHistoryAfter() if endSel-startSel>0 and not sliceDeletion: if endSel==endIO and startIO!=self.GetCurrentLine(): self.clearIOMarkers() self.MarkerAdd(self.GetCurrentLine(),INPUT_END) if endSel==endGrouping and startGrouping!=self.GetCurrentLine(): self.clearGroupingMarkers() self.MarkerAdd(self.GetCurrentLine(),GROUPING_END) cpos=self.GetSelectionStart() s=text if s!='': self.UpdateUndoHistoryBefore('insert',s,cpos,cpos+len(s), forceNewAction=True) self.write(text) self.UpdateUndoHistoryAfter() self.ensureSingleGroupingMarker() self.ensureSingleIOMarker() def clearCommand(self): """Delete the current, unexecuted command.""" if not self.CanEdit(): return start,end=self.GetIOSlice() startpos = self.PositionFromLine(start) endpos = self.GetLineEndPosition(end) self.SetSelection(startpos, endpos) self.ReplaceSelection('') self.more = False def OnHistoryReplace(self, step): """Replace with the previous/next command from the history buffer.""" if not self.CanEdit(): return self.clearCommand() self.replaceFromHistory(step) def replaceFromHistory(self, step): """Replace selection with command from the history buffer.""" if not self.CanEdit(): return self.ReplaceSelection('') newindex = self.historyIndex + step if -1 <= newindex <= len(self.history): self.historyIndex = newindex if 0 <= newindex <= len(self.history)-1: command = self.history[self.historyIndex] command = command.replace('\n', os.linesep)# + ps2) self.ReplaceSelection(command) def OnHistoryInsert(self, step): """Insert the previous/next command from the history buffer.""" if not self.CanEdit(): return startpos = self.GetCurrentPos() self.replaceFromHistory(step) endpos = self.GetCurrentPos() self.SetSelection(endpos, startpos) # TODO: Fix Me! def OnHistorySearch(self): """Search up the history buffer for the text in front of the cursor.""" if not self.CanEdit(): return startpos = self.GetCurrentPos() # The text up to the cursor is what we search for. numCharsAfterCursor = self.GetTextLength() - startpos searchText = self.getCommand(rstrip=False) #print('history search', startpos, numCharsAfterCursor, searchText) if numCharsAfterCursor > 0: searchText = searchText[:-numCharsAfterCursor] if not searchText: return # Search upwards from the current history position and loop # back to the beginning if we don't find anything. if (self.historyIndex <= -1) \ or (self.historyIndex >= len(self.history)-2): searchOrder = range(len(self.history)) else: searchOrder = range(self.historyIndex+1, len(self.history)) + \ range(self.historyIndex) for i in searchOrder: command = self.history[i] if command[:len(searchText)] == searchText: # Replace the current selection with the one we found. self.ReplaceSelection(command[len(searchText):]) endpos = self.GetCurrentPos() self.SetSelection(endpos, startpos) # We've now warped into middle of the history. self.historyIndex = i break def setStatusText(self, text): """Display status information.""" # This method will likely be replaced by the enclosing app to # do something more interesting, like write to a status bar. print(text) def insertLineBreak(self): """Insert a new line break.""" if not self.CanEdit(): return elif self.reader.isreading: self.processLine() return # write with undo wrapper... cpos=self.GetCurrentPos() s=os.linesep self.UpdateUndoHistoryBefore('insert',s,cpos,cpos+1) self.write(s,type='Input') self.UpdateUndoHistoryAfter() self.more = True self.prompt() def processLine(self): """Process the line of text at which the user hit Enter or Shift+RETURN.""" # The user hit ENTER (Shift+RETURN) (Shift+ENTER) and we need to # decide what to do. They could be sitting on any line in the slices shell. thepos = self.GetCurrentPos() cur_line = self.GetCurrentLine() marker=self.MarkerGet(cur_line) if marker & INPUT_MASK: pass elif marker & OUTPUT_MASK: return else: pass #print('BLANK LINE!!') startline,endline=self.GetIOSlice(cur_line) if startline==0: startpos=0 else: startpos=self.PositionFromLine(startline) endpos=self.GetLineEndPosition(endline) # If they hit ENTER inside the current command, execute the command. if self.CanEdit(): self.SetCurrentPos(endpos) self.interp.more = False command = self.GetTextRange(startpos, endpos) lines = command.split(os.linesep) lines = [line.rstrip() for line in lines] command = '\n'.join(lines) if self.reader.isreading: if not command: # Match the behavior of the standard Python shell # when the user hits return without entering a value. command = '\n' self.reader.input = command self.write(os.linesep,'Input') self.MarkerSet(self.GetCurrentLine(),READLINE_BG) self.MarkerSet(self.GetCurrentLine(),INPUT_READLINE) else: self.runningSlice = (startline,endline) self.push(command,useMultiCommand=True) #print('command: %s'%command) wx.CallLater(1, self.EnsureCaretVisible) self.runningSlice=None skip=self.BackspaceWMarkers(force=True) if skip: self.DeleteBack() if self.GetCurrentLine()==self.GetLineCount()-1: self.write(os.linesep,type='Input') cpos=self.GetCurrentLine() if self.MarkerGet(cpos-1) & OUTPUT_MASK: self.MarkerAdd(cpos-1,OUTPUT_BG) self.SplitSlice() else: cur_line=self.GetCurrentLine() new_pos=self.GetLineEndPosition(cur_line+1) self.SetSelection(new_pos,new_pos) self.SetCurrentPos(new_pos) self.EmptyUndoBuffer() self.NeedsCheckForSave=True if self.hasSyntaxError: pos=self.GetLineEndPosition(self.syntaxErrorRealLine) self.SetCurrentPos(pos) self.SetSelection(pos,pos) # Not Used!! def getMultilineCommand(self, rstrip=True): """Extract a multi-line command from the editor. The command may not necessarily be valid Python syntax.""" # DNM # XXX Need to extract real prompts here. Need to keep track of # the prompt every time a command is issued. text = self.GetCurLine()[0] line = self.GetCurrentLine() # Add Marker testing here... while text == '' and line > 0: # Need to add markers handling... line -= 1 self.GotoLine(line) text = self.GetCurLine()[0] if text=='': line = self.GetCurrentLine() self.GotoLine(line) startpos = self.GetCurrentPos() line += 1 self.GotoLine(line) while self.GetCurLine()[0]=='': line += 1 self.GotoLine(line) stoppos = self.GetCurrentPos() command = self.GetTextRange(startpos, stoppos) command = command.replace(os.linesep, '\n') command = command.rstrip() command = command.replace('\n', os.linesep) else: command = '' if rstrip: command = command.rstrip() return command def getCommand(self, text=None, rstrip=True): """Extract a command from text which may include a shell prompt. The command may not necessarily be valid Python syntax.""" if not text: text = self.GetCurLine()[0] # Strip the prompt off the front leaving just the command. command = self.lstripPrompt(text) # Change this -- Nothing has prompts! #if command == text: # command = '' # Real commands have prompts. if rstrip: command = command.rstrip() return command def lstripPrompt(self, text): """Return text without a leading prompt.""" ps1 = str(sys.ps1) ps1size = len(ps1) ps2 = str(sys.ps2) ps2size = len(ps2) # Strip the prompt off the front of text. if text[:ps1size] == ps1: text = text[ps1size:] elif text[:ps2size] == ps2: text = text[ps2size:] return text def push(self, command, silent = False,useMultiCommand=False): """Send command to the interpreter for execution.""" if not silent: self.write(os.linesep,type='Output') # TODO : What other magic might we insert here? # TODO : Is there a good reason not to include magic? if USE_MAGIC: command=magic(command) # Allows multi-component commands... self.hasSyntaxError=False if useMultiCommand: result = self.BreakTextIntoCommands(command) if result[0] == None: commands=[command] self.hasSyntaxError=True syntaxErrorLine=result[1]+1 self.syntaxErrorRealLine = self.GetCurrentLine()+result[1]-len(command.split('\n')) else: commands=result else: commands=[command] busy = wx.BusyCursor() self.waiting = True self.lastUpdate=None for i in commands: if self.hasSyntaxError: lineno=syntaxErrorLine offset=0 # not sure how to easily recover this information... self.write(' File "<input>", line '+str(lineno)+'\n '+i.split('\n')[lineno-1]+'\n'+' '*offset+' ^\nSyntaxError: invalid syntax\n','Error') else: self.more = self.interp.push(i+'\n') # (the \n stops many things from bouncing at the interpreter) # I could do the following, but I don't really like it! #if useMultiCommand: # self.SplitSlice() self.lastUpdate=None if not silent: self.MarkerAdd(self.GetIOSlice()[0],OUTPUT_BG) self.waiting = False del busy if not self.more: # could loop-add to history, too, but I don't like it! self.addHistory(command.rstrip()) if not silent: self.prompt() def addHistory(self, command): """Add command to the command history.""" # Reset the history position. self.historyIndex = -1 # Insert this command into the history, unless it's a blank # line or the same as the last command. if command!='' and ( len(self.history)==0 or command!=self.history[0] ): self.history.insert(0, command) dispatcher.send(signal="SlicesShell.addHistory", command=command) def clearGroupingMarkers(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() self.MarkerDelete(line_num,GROUPING_START) self.MarkerDelete(line_num,GROUPING_START_FOLDED) self.MarkerDelete(line_num,GROUPING_MIDDLE) self.MarkerDelete(line_num,GROUPING_END) def clearIOMarkers(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() self.MarkerDelete(line_num,INPUT_START) self.MarkerDelete(line_num,INPUT_START_FOLDED) self.MarkerDelete(line_num,INPUT_MIDDLE) self.MarkerDelete(line_num,INPUT_END) self.MarkerDelete(line_num,OUTPUT_START) self.MarkerDelete(line_num,OUTPUT_START_FOLDED) self.MarkerDelete(line_num,OUTPUT_MIDDLE) self.MarkerDelete(line_num,OUTPUT_END) self.MarkerDelete(line_num,OUTPUT_BG) self.MarkerDelete(line_num,READLINE_BG) self.MarkerDelete(line_num,INPUT_READLINE) def ensureSingleGroupingMarker(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() marker=self.MarkerGet(line_num) if marker & 1<<GROUPING_START: self.MarkerDelete(line_num,GROUPING_START_FOLDED) self.MarkerDelete(line_num,GROUPING_MIDDLE) self.MarkerDelete(line_num,GROUPING_END) elif marker & 1<<GROUPING_START_FOLDED: self.MarkerDelete(line_num,GROUPING_MIDDLE) self.MarkerDelete(line_num,GROUPING_END) elif marker & 1<<GROUPING_MIDDLE: self.MarkerDelete(line_num,GROUPING_END) elif marker & 1<<GROUPING_END: pass else: #print('ERROR! NO GROUPING MARKERS!') return 1 # Blank marker return 0 def ensureSingleIOMarker(self,line_num=None): if line_num==None: line_num=self.GetCurrentLine() marker=self.MarkerGet(line_num) if marker & INPUT_MASK: self.MarkerDelete(line_num,OUTPUT_START) self.MarkerDelete(line_num,OUTPUT_START_FOLDED) self.MarkerDelete(line_num,OUTPUT_MIDDLE) self.MarkerDelete(line_num,OUTPUT_END) self.MarkerDelete(line_num,OUTPUT_BG) [start,start_folded] = [INPUT_START,INPUT_START_FOLDED] [middle,end] = [INPUT_MIDDLE,INPUT_END] elif marker & OUTPUT_MASK: self.MarkerDelete(line_num,INPUT_START) self.MarkerDelete(line_num,INPUT_START_FOLDED) self.MarkerDelete(line_num,INPUT_MIDDLE) self.MarkerDelete(line_num,INPUT_END) [start,start_folded] = [OUTPUT_START,OUTPUT_START_FOLDED] [middle,end] = [OUTPUT_MIDDLE,OUTPUT_END] else: #print('ERROR! NO IO MARKERS!') return 1 # Blank marker if marker & 1<<start: self.MarkerDelete(line_num,start_folded) self.MarkerDelete(line_num,middle) self.MarkerDelete(line_num,end) elif marker & 1<<start_folded: self.MarkerDelete(line_num,middle) self.MarkerDelete(line_num,end) elif marker & 1<<middle: self.MarkerDelete(line_num,end) elif marker & 1<<end: pass return 0 def RestoreFirstMarker(self): first_marker=self.MarkerGet(0) self.clearGroupingMarkers(0) self.clearIOMarkers(0) if first_marker & 1<<GROUPING_START : self.MarkerAdd(0,GROUPING_START) elif first_marker & 1<<GROUPING_START_FOLDED : self.MarkerAdd(0,GROUPING_START_FOLDED) else: self.MarkerAdd(0,GROUPING_START) if first_marker & 1<<INPUT_START : self.MarkerAdd(0,INPUT_START) elif first_marker & 1<<INPUT_START_FOLDED : self.MarkerAdd(0,INPUT_START_FOLDED) elif first_marker & 1<<OUTPUT_START : self.MarkerAdd(0,OUTPUT_START) #self.MarkerAdd(0,OUTPUT_BG) # More harm than good?? elif first_marker & 1<<OUTPUT_START_FOLDED : self.MarkerAdd(0,OUTPUT_START_FOLDED) #self.MarkerAdd(0,OUTPUT_BG) # More harm than good?? else: self.MarkerAdd(0,INPUT_START) if self.doHistUpdate: self.UpdateUndoHistoryAfter() def IsAllowedPair(self,m1,m2): """This testing function ensures that two adjacent markers are valid""" i_s = 1<<INPUT_START | 1<<INPUT_START_FOLDED o_s = 1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED g_s = 1<<GROUPING_START | 1<<GROUPING_START_FOLDED i_m,o_m,g_m = 1<<INPUT_MIDDLE, 1<<OUTPUT_MIDDLE, 1<<GROUPING_MIDDLE i_e,o_e,g_e = 1<<INPUT_END, 1<<OUTPUT_END, 1<<GROUPING_END if (m1 & i_s) and (m1 & g_s): #1 if (m2 & i_s) and (m2 & g_s): return True #1 elif (m2 & i_m) and (m2 & g_m): return True #2 elif (m2 & i_e) and (m2 & g_m): return True #3 elif (m2 & i_e) and (m2 & g_e): return True #4 elif (m2 & o_s) and (m2 & g_s): return False #5 elif (m2 & o_s) and (m2 & g_m): return True #6 elif (m2 & o_s) and (m2 & g_e): return True #7 elif (m2 & o_m) and (m2 & g_m): return False #8 elif (m2 & o_e) and (m2 & g_e): return False #9 else: return False elif (m1 & i_m) and (m1 & g_m): #2 if (m2 & i_m) and (m2 & g_m): return True #2 elif (m2 & i_e) and (m2 & g_m): return True #3 elif (m2 & i_e) and (m2 & g_e): return True #4 else: return False elif (m1 & i_e) and (m1 & g_m): #3 if (m2 & o_s) and (m2 & g_m): return True #6 elif (m2 & o_s) and (m2 & g_e): return True #7 else: return False elif (m1 & i_e) and (m1 & g_e): #4 if (m2 & i_s) and (m2 & g_s): return True #1 elif (m2 & o_s) and (m2 & g_s): return True #5 else: return False elif (m1 & o_s) and (m1 & g_s): #5 if (m2 & i_s) and (m2 & g_s): return True #1 elif (m2 & i_m) and (m2 & g_m): return False #2 elif (m2 & i_e) and (m2 & g_m): return False #3 elif (m2 & i_e) and (m2 & g_e): return False #4 elif (m2 & o_s) and (m2 & g_s): return True #5 elif (m2 & o_s) and (m2 & g_m): return False #6 elif (m2 & o_s) and (m2 & g_e): return False #7 elif (m2 & o_m) and (m2 & g_m): return True #8 elif (m2 & o_e) and (m2 & g_e): return True #9 else: return False elif (m1 & o_s) and (m1 & g_m): #6 if (m2 & o_m) and (m2 & g_m): return True #8 elif (m2 & o_e) and (m2 & g_e): return True #9 else: return False elif (m1 & o_s) and (m1 & g_e): #7 if (m2 & i_s) and (m2 & g_s): return True #1 elif (m2 & o_s) and (m2 & g_s): return True #5 else: return False elif (m1 & o_m) and (m1 & g_m): #8 if (m2 & o_m) and (m2 & g_m): return True #8 elif (m2 & o_e) and (m2 & g_e): return True #9 else: return False elif (m1 & o_e) and (m1 & g_e): #9 if (m2 & i_s) and (m2 & g_s): return True #1 elif (m2 & o_s) and (m2 & g_s): return True #5 else: return False else: return False def CleanAllMarkers(self): self.RestoreFirstMarker() first_marker=self.MarkerGet(0) last_line_num=self.GetLineCount()-1 for i in range(1,last_line_num): self.ensureSingleGroupingMarker(i) self.ensureSingleIOMarker(i) previous_marker=self.MarkerGet(i-1) marker=self.MarkerGet(i) if not self.IsAllowedPair(previous_marker,marker): pass # FIX MARKER!! # FIX ME def write(self, text,type='Input',silent=False): """Display text in the slices shell. Replace line endings with OS-specific endings.""" text = self.fixLineEndings(text) split=text.split(os.linesep) self.AddText(text) # This part handles all the marker stuff that accompanies # adding or removing new lines of text... # Get the total number of lines in the Document == last line number last_line_num=self.GetLineCount()-1 # Get the line number we ended on in the write end_line_num=self.GetCurrentLine() # Get the number of returns we are using == number of lines we pasted -1 num_new_lines=text.count(os.linesep) # So if num_new_lines==0, start_line_num and end_line_num are the same start_line_num=end_line_num-num_new_lines+1 # This is a little unnecessary because there will always # be a line before if we just inserted a newline! if start_line_num == 0: previous_line_num=None else: previous_line_num=start_line_num-1 #However, this is very important... if end_line_num == last_line_num: next_line_num=None else: next_line_num=end_line_num+1 if type=='Input': start = INPUT_START start_folded = INPUT_START_FOLDED middle = INPUT_MIDDLE end = INPUT_END # preparation for more io types... opposite_start_mask = 1<<OUTPUT_START opposite_start_folded_mask = 1<<OUTPUT_START_FOLDED opposite_middle_mask = 1<<OUTPUT_MIDDLE # To test for bad writes... opposite_end_mask = 1<<OUTPUT_END # To test for bad writes... elif type in ['Output','Error']: #self.MarkerAdd(start_line_num,GROUPING_START_FOLDED) start=OUTPUT_START start_folded=OUTPUT_START_FOLDED middle=OUTPUT_MIDDLE end=OUTPUT_END # preparation for more io types... opposite_start_mask = 1<<INPUT_START opposite_start_folded_mask = 1<<INPUT_START_FOLDED opposite_middle_mask = 1<<INPUT_MIDDLE # To test for bad writes... opposite_end_mask = 1<<INPUT_END # To test for bad writes... if num_new_lines>0: #Do nothing if typing within a line... # Update the Grouping Markers # For the previous line and the start_line # Test to make sure we can write ... but not here ... # test this before we call write or before we add text... # So we assume it already obeys the rules badMarkers=False fixIOEnd=True if previous_line_num==None: # This is an impossible case, here just for completeness... self.clearGroupingMarkers(start_line_num) self.MarkerAdd(start_line_num,GROUPING_START) self.clearIOMarkers(start_line_num) self.MarkerAdd(start_line_num,start) if type in ['Output','Error']: self.MarkerAdd(start_line_num,OUTPUT_BG) else: previous_marker=self.MarkerGet(previous_line_num) if previous_marker & opposite_middle_mask: badMarkers=True if next_line_num==None: self.MarkerAdd(end_line_num,GROUPING_END) self.MarkerAdd(end_line_num,end) if type in ['Output','Error']: self.MarkerAdd(end_line_num,OUTPUT_BG) fixEndMarkers=False # May be overwritten below if start_line_num==end_line_num... else: next_marker=self.MarkerGet(next_line_num) fixEndMarkers=True if next_marker & ( opposite_middle_mask | opposite_end_mask ): badMarkers=True if not badMarkers: # ensure previous_line only has one marker & turn end into middle if previous_line_num!=None: # Adjust previous line appropriately, ensure only one marker # Only print errors if we are on input! blank=False blank=blank or self.ensureSingleGroupingMarker(previous_line_num) blank=blank or self.ensureSingleIOMarker(previous_line_num) if blank: #if type=='Input' and not silent: print('BLANK LINE!' # BAD CASE) pass if previous_marker & 1<<GROUPING_END : # Make GROUPING slice continue unless we hit # an output end and are starting a new input... if (previous_marker & OUTPUT_MASK) and type=='Input': pass else: self.MarkerDelete(previous_line_num,GROUPING_END) # ONLY CHANGING CASE self.MarkerAdd(previous_line_num,GROUPING_MIDDLE) if previous_marker & 1<<end : self.MarkerDelete(previous_line_num,end) self.MarkerAdd(previous_line_num,middle) # ONLY CHANGING CASE if type in ['Output','Error']: self.MarkerAdd(previous_line_num,OUTPUT_BG) elif previous_marker & opposite_middle_mask : # BAD CASE if type=='Input' and not silent: #print('Should have been a bad marker!') pass # We can only add input to an input slice # And can only add output to an output slice if previous_marker & ( opposite_start_mask | opposite_start_folded_mask | opposite_end_mask ): if type=='Input': self.clearGroupingMarkers(start_line_num) self.MarkerAdd(start_line_num,GROUPING_START) if start_line_num==end_line_num: fixEndMarkers=False else: if start_line_num==end_line_num: fixIOEnd=False self.clearIOMarkers(start_line_num) self.MarkerAdd(start_line_num,start) if type in ['Output','Error']: self.MarkerAdd(start_line_num,OUTPUT_BG) else: if next_line_num!=None: self.clearGroupingMarkers(start_line_num) self.clearIOMarkers(start_line_num) self.MarkerAdd(start_line_num,GROUPING_MIDDLE) self.MarkerAdd(start_line_num,middle) if type in ['Output','Error']: self.MarkerAdd(start_line_num,OUTPUT_BG) # This may be overwritten if start_line_num==end_line_num # Take care of all the middle lines... # Does nothing for only one line... for i in range(start_line_num,end_line_num): self.clearGroupingMarkers(i) self.MarkerAdd(i,GROUPING_MIDDLE) self.clearIOMarkers(i) self.MarkerAdd(i,middle) if type in ['Output','Error']: self.MarkerAdd(i,OUTPUT_BG) if fixEndMarkers: # Take care of the end_line if we haven't already done so... blank=False blank=blank or self.ensureSingleGroupingMarker(next_line_num) blank=blank or self.ensureSingleIOMarker(next_line_num) if blank: if type=='Input' and not silent: #print('BLANK LINE!' # BAD CASE) pass self.clearGroupingMarkers(end_line_num) if fixIOEnd: self.clearIOMarkers(end_line_num) if next_marker & ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED ) : self.MarkerAdd(end_line_num,GROUPING_END) elif next_marker & ( 1<<GROUPING_MIDDLE | 1<<GROUPING_END ) : self.MarkerAdd(end_line_num,GROUPING_MIDDLE) if fixIOEnd: if next_marker & ( 1<<start | 1<<start_folded ) : self.MarkerAdd(end_line_num,end) if type in ['Output','Error']: self.MarkerAdd(end_line_num,OUTPUT_BG) elif next_marker & ( 1<<middle | 1<<end ) : self.MarkerAdd(end_line_num,middle) if type in ['Output','Error']: self.MarkerAdd(end_line_num,OUTPUT_BG) elif next_marker & ( opposite_start_mask | opposite_start_folded_mask ): self.MarkerAdd(end_line_num,end) if type in ['Output','Error']: self.MarkerAdd(end_line_num,OUTPUT_BG) else: self.MarkerAdd(end_line_num,start_folded) if type in ['Output','Error']: self.MarkerAdd(end_line_num,OUTPUT_BG) if type=='Input' and not silent: #print('BAD MARKERS!') pass else: if type=='Input' and not silent: #print('BAD MARKERS!!!') pass self.EnsureCaretVisible() if self.waiting: if self.lastUpdate==None: self.lastUpdate=time.time() if time.time()-self.lastUpdate > PRINT_UPDATE_MAX_TIME: self.Update() self.lastUpdate=time.time() def fixLineEndings(self, text): """Return text with line endings replaced by OS-specific endings.""" lines = text.split('\r\n') for l in range(len(lines)): chunks = lines[l].split('\r') for c in range(len(chunks)): chunks[c] = os.linesep.join(chunks[c].split('\n')) lines[l] = os.linesep.join(chunks) text = os.linesep.join(lines) return text def prompt(self): # Autoindent added!!! """Display proper prompt for the context: ps1, ps2 or ps3. If this is a continuation line, autoindent as necessary.""" # TODO : How much of this can I do away with now without prompts?? isreading = self.reader.isreading skip = True if isreading: prompt = str(sys.ps3) elif self.more: prompt = str(sys.ps2) else: prompt = str(sys.ps1) pos = self.GetCurLine()[1] if pos > 0: if isreading: skip = True else: self.write(os.linesep,type='Input') if not self.more: # Not needed anymore! # self.promptPosStart = self.GetCurrentPos() pass if not skip: self.write(prompt,type='Input') if not self.more: # Not needed anymore! # self.promptPosEnd = self.GetCurrentPos() # Clear the undo history after running a command. self.EmptyUndoBuffer() #DNM/CP # Autoindent magic # Match the indent of the line above # UNLESS the line above ends in a colon...then add four spaces # (after valid keywords (if, else, etc...) only) if self.more: line_num=self.GetCurrentLine() currentLine=self.GetLine(line_num) previousLine=self.GetLine(line_num-1) pstrip=previousLine.strip() lstrip=previousLine.lstrip() if pstrip == '': # because it is all whitespace! indent=previousLine.strip('\n').strip('\r') else: indent=previousLine[:(len(previousLine)-len(lstrip))] if testForContinuations(previousLine,ignoreErrors=True)[1][0]: indent+=' '*4 #ADD UNDO cpos=self.GetCurrentPos() s=indent self.UpdateUndoHistoryBefore('insert',s,cpos,cpos+len(s)) self.write(s,type='Input') self.UpdateUndoHistoryAfter() self.EnsureCaretVisible() self.ScrollToColumn(0) def readline(self): """Replacement for stdin.readline().""" input = '' reader = self.reader reader.isreading = True self.prompt() # Ensure that we get a new line and that it's got an input marker... # Also need to temporarily block any other action... cLine = self.GetCurrentLine() self.clearIOMarkers(cLine) self.MarkerAdd(cLine,INPUT_START) self.MarkerAdd(cLine,READLINE_BG) self.MarkerAdd(cLine,INPUT_READLINE) try: while not reader.input: wx.YieldIfNeeded() input = reader.input finally: start,end = self.GetIOSlice() start = self.runningSlice[1] + 1 for i in range(start,end+1): self.clearIOMarkers(i) self.clearGroupingMarkers(i) self.MarkerAdd(i,OUTPUT_BG) if i == start: self.MarkerAdd(i,OUTPUT_START) elif i==end: self.MarkerAdd(i,OUTPUT_END) else: self.MarkerAdd(i,OUTPUT_MIDDLE) if i==end: self.MarkerAdd(i,GROUPING_END) else: self.MarkerAdd(i,GROUPING_MIDDLE) reader.input = '' reader.isreading = False input = str(input) # In case of Unicode. return input def readlines(self): """Replacement for stdin.readlines().""" lines = [] while lines[-1:] != ['\n']: lines.append(self.readline()) return lines def raw_input(self, prompt=''): """Return string based on user input.""" if prompt: self.write(prompt,type='Output') return self.readline() def ask(self, prompt='Please enter your response:'): """Get response from the user using a dialog box.""" dialog = wx.TextEntryDialog(None, prompt, 'Input Dialog (Raw)', '') try: if dialog.ShowModal() == wx.ID_OK: text = dialog.GetValue() return text finally: dialog.Destroy() return '' def pause(self): """Halt execution pending a response from the user.""" self.ask('Press enter to continue:') def clear(self): """Delete all text from the slices shell.""" self.ClearAll() self.MarkerAdd(0,GROUPING_START) self.MarkerAdd(0,INPUT_START) def run(self, command, prompt=True, verbose=True): """Execute command as if it was typed in directly. >>> shell.run('print("this")') >>> print("this") this >>> """ # Go to the very bottom of the text. endpos = self.GetTextLength() self.SetCurrentPos(endpos) command = command.rstrip() if prompt: self.prompt() if verbose: self.write(command,type='Input') self.push(command) # TODO : Will have to fix this to handle other kinds of errors mentioned before... def runfile(self, filename): """Execute all commands in file as if they were typed into the shell.""" file = open(filename) try: self.prompt() for command in file.readlines(): if command[:6] == 'shell.': # Run shell methods silently. self.run(command, prompt=False, verbose=False) else: self.run(command, prompt=False, verbose=True) finally: file.close() def autoCompleteShow(self, command, offset = 0): """Display auto-completion popup list.""" self.AutoCompSetAutoHide(self.autoCompleteAutoHide) self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive) list = self.interp.getAutoCompleteList(command, includeMagic=self.autoCompleteIncludeMagic, includeSingle=self.autoCompleteIncludeSingle, includeDouble=self.autoCompleteIncludeDouble) if list: options = ' '.join(list) #offset = 0 self.AutoCompShow(offset, options) def autoCallTipShow(self, command, insertcalltip = True, forceCallTip = False): """Display argument spec and docstring in a popup window.""" if self.CallTipActive(): self.CallTipCancel() (name, argspec, tip) = self.interp.getCallTip(command) if tip: dispatcher.send(signal='SlicesShell.calltip', sender=self, calltip=tip) if not self.autoCallTip and not forceCallTip: return startpos = self.GetCurrentPos() if argspec and insertcalltip and self.callTipInsert: # write with undo history... cpos=self.GetCurrentPos() s=argspec + ')' self.UpdateUndoHistoryBefore('insert',s,cpos,cpos+len(s)) self.write(s,type='Input') self.UpdateUndoHistoryAfter() endpos = self.GetCurrentPos() self.SetSelection(startpos, endpos) if tip: tippos = startpos - (len(name) + 1) fallback = startpos - self.GetColumn(startpos) # In case there isn't enough room, only go back to the fallback. tippos = max(tippos, fallback) self.CallTipShow(tippos, tip) def OnCallTipAutoCompleteManually (self, shiftDown): """AutoComplete and Calltips manually.""" if self.AutoCompActive(): self.AutoCompCancel() currpos = self.GetCurrentPos() stoppos = self.PositionFromLine(self.GetIOSlice()[0]) cpos = currpos #go back until '.' is found pointavailpos = -1 while cpos >= stoppos: if self.GetCharAt(cpos) == ord ('.'): pointavailpos = cpos break cpos -= 1 #word from non whitespace until '.' if pointavailpos != -1: #look backward for first whitespace char textbehind = self.GetTextRange (pointavailpos + 1, currpos) pointavailpos += 1 if not shiftDown: #call AutoComplete stoppos = self.PositionFromLine(self.GetIOSlice()[0]) textbefore = self.GetTextRange(stoppos, pointavailpos) self.autoCompleteShow(textbefore, len (textbehind)) else: #call CallTips cpos = pointavailpos begpos = -1 while cpos > stoppos: if chr(self.GetCharAt(cpos)).isspace(): begpos = cpos break cpos -= 1 if begpos == -1: begpos = cpos ctips = self.GetTextRange (begpos, currpos) ctindex = ctips.find ('(') if ctindex != -1 and not self.CallTipActive(): #insert calltip, if current pos is '(', otherwise show it only self.autoCallTipShow( ctips[:ctindex + 1], self.GetCharAt(currpos - 1) == ord('(') and self.GetCurrentPos() == self.GetTextLength(), True ) def writeOut(self, text): """Replacement for stdout.""" self.write(text,type='Output') # TODO : FLUSH?? How to make this update real-time... def writeErr(self, text): """Replacement for stderr.""" self.write(text,type='Error') def redirectStdin(self, redirect=True): """If redirect is true then sys.stdin will come from the shell.""" if redirect: sys.stdin = self.reader else: sys.stdin = self.stdin def redirectStdout(self, redirect=True): """If redirect is true then sys.stdout will go to the shell.""" if redirect: sys.stdout = PseudoFileOut(self.writeOut) else: sys.stdout = self.stdout def redirectStderr(self, redirect=True): """If redirect is true then sys.stderr will go to the shell.""" if redirect: sys.stderr = PseudoFileErr(self.writeErr) else: sys.stderr = self.stderr # Take a spashot of the WHOLE grouping slice (or slices) # The argument s is either what got added or deleted def UpdateUndoHistoryBefore(self,actionType,s,posStart,posEnd, forceNewAction=False): uH=self.undoHistory uI=self.undoIndex s=s.replace(os.linesep,'\n') startLine=self.LineFromPosition(posStart) if actionType=='marker': numLines = self.LineFromPosition(posEnd) - startLine else: numLines=s.count('\n') makeNewAction=forceNewAction if forceNewAction: makeNewAction=True elif self.undoIndex==-1: makeNewAction=True elif not uH[uI]['allowsAppend']: makeNewAction=True elif actionType!=uH[uI]['actionType']: makeNewAction=True elif actionType=='insert': if posStart!=uH[uI]['posEnd']: makeNewAction=True else: # This is a continuation of the previous insert uH[uI]['charList'] = uH[uI]['charList']+s uH[uI]['posEnd'] = posEnd # posStart cannot move uH[uI]['numLines'] = uH[uI]['numLines']+numLines elif actionType=='delete': # This is a forward continuation of the previous delete if posStart==uH[uI]['posStart']: uH[uI]['charList'] = uH[uI]['charList']+s uH[uI]['posEnd'] = posEnd uH[uI]['numLines'] = uH[uI]['numLines']+numLines # This is a backward continuation of the previous delete elif posEnd==uH[uI]['posStart']: uH[uI]['charList'] = s+uH[uI]['charList'] uH[uI]['posStart'] = posStart uH[uI]['startLine'] = startLine uH[uI]['numLines'] = uH[uI]['numLines']+numLines else: makeNewAction=True elif actionType=='marker': makeNewAction=True else: pass #print('Unsupported Action Type!!') if makeNewAction: del(self.undoHistory[uI+1:]) # remove actions after undoIndex uH.append({ 'actionType' : actionType, # Action type ('insert','delete','marker') 'allowsAppend': not forceNewAction, # Can action be joined with others? 'charList' : s, # Character list 'posStart' : posStart, # Cursor poition at the start of the action 'posEnd' : posEnd, # Cursor position at the end of the action 'startLine' : startLine, # Start line number, 'numLines' : numLines, # Number of newlines involved 'mBStart' : None, # Starting line for markers BEFORE action 'mAStart' : None, # Starting line for markers AFTER action 'markersBefore' : None, # [markers BEFORE action] 'markersAfter' : None # [markers AFTER action] }) self.undoIndex+=1 # Only update the before when starting a new action start = startLine if actionType=='insert': end = start else: end = start + numLines # Update Marker Info newStart=self.GetGroupingSlice(start)[0] newEnd=self.GetGroupingSlice(end)[1] self.undoHistory[self.undoIndex]['markersBefore'] = \ [self.MarkerGet(i) for i in range(newStart,newEnd+1)] self.undoHistory[self.undoIndex]['mBStart']=newStart self.doHistUpdate=True def UpdateUndoHistoryAfter(self): # s is either what got added or deleted start = self.undoHistory[self.undoIndex]['startLine'] if self.undoHistory[self.undoIndex]['actionType']=='delete': end = start else: end = start + self.undoHistory[self.undoIndex]['numLines'] newStart=min(self.GetGroupingSlice(start)[0]-1, 0) newEnd=max(self.GetGroupingSlice(end)[1]+1, self.GetLineCount()-1) self.undoHistory[self.undoIndex]['markersAfter'] = \ [self.MarkerGet(i) for i in range(newStart,newEnd+1)] self.undoHistory[self.undoIndex]['mAStart']=newStart self.doHistUpdate=False def Undo(self): #ADD UNDO #Skip undo if there are no actions... if self.undoIndex==-1: return uHI=self.undoHistory[self.undoIndex] if uHI['actionType'] in ['insert','delete']: # This will perform the opposite of the action given editwindow.EditWindow.Undo(self) elif uHI['actionType']=='marker': # No text changed, don't pass to STC pass else: #print('Unsupported actionType in undoHistory!!') return numLines=len(uHI['markersBefore']) for i in range(numLines): self.MarkerSet( uHI['mBStart']+i , uHI['markersBefore'][i] ) self.undoIndex-=1 def Redo(self): #ADD UNDO # First check to see if there are any redo operations available # Note that for redo, undoIndex=-1 is a valid input if self.undoIndex >= len(self.undoHistory)-1: return self.undoIndex+=1 uHI=self.undoHistory[self.undoIndex] if uHI['actionType'] in ['insert','delete']: # This will re-perform the given action editwindow.EditWindow.Redo(self) elif uHI['actionType']=='marker': # No text changed, don't pass to STC pass else: #print('Unsupported actionType in undoHistory!!') return numLines=len(uHI['markersAfter']) for i in range(numLines): self.MarkerSet( uHI['mAStart']+i , uHI['markersAfter'][i] ) def EmptyUndoBuffer(self): editwindow.EditWindow.EmptyUndoBuffer(self) self.undoIndex=-1 self.undoHistory=[] self.doHistUpdate=False def CanCut(self): return self.CanEdit() and \ (self.GetSelectionStart() != self.GetSelectionEnd()) def CanPaste(self): """Return true if a paste should succeed.""" if self.CanEdit() and editwindow.EditWindow.CanPaste(self): return True else: return False def CanEdit(self): """Return true if editing should succeed.""" marker=self.MarkerGet(self.GetCurrentLine()) if marker & OUTPUT_MASK: return False elif marker & INPUT_MASK: if self.reader.isreading and not \ (self.MarkerGet(self.GetCurrentLine()) & 1<<INPUT_READLINE ): return False start,end=self.GetIOSlice() sliceStartPos=self.PositionFromLine(start) sliceEndPos=self.GetLineEndPosition(end) """Return true if text is selected and can be cut.""" if self.GetSelectionStart() == self.GetSelectionEnd(): return True elif self.GetSelectionStart() != self.GetSelectionEnd() \ and self.GetSelectionStart() >= sliceStartPos \ and self.GetSelectionEnd() >= sliceStartPos \ and self.GetSelectionStart() <= sliceEndPos \ and self.GetSelectionEnd() <= sliceEndPos: return True return False def Cut(self): """Remove selection and place it on the clipboard.""" if self.CanCut() and self.CanCopy(): if self.AutoCompActive(): self.AutoCompCancel() if self.CallTipActive(): self.CallTipCancel() self.Copy() self.ReplaceSelection('') def Copy(self): """Copy selection and place it on the clipboard.""" if self.CanCopy(): ps1 = str(sys.ps1) ps2 = str(sys.ps2) command = self.GetSelectedText() command = command.replace(os.linesep + ps2, os.linesep) command = command.replace(os.linesep + ps1, os.linesep) command = self.lstripPrompt(text=command) data = wx.TextDataObject(command) self._clip(data) def CopyWithPrompts(self): """Copy selection, including prompts, and place it on the clipboard.""" if self.CanCopy(): command = self.GetSelectedText() data = wx.TextDataObject(command) self._clip(data) def CopyWithPromptsPrefixed(self): """Copy selection, including prompts prefixed with four spaces, and place it on the clipboard.""" if self.CanCopy(): command = self.GetSelectedText() spaces = ' ' * 4 command = spaces + command.replace(os.linesep, os.linesep + spaces) data = wx.TextDataObject(command) self._clip(data) def _clip(self, data): if wx.TheClipboard.Open(): wx.TheClipboard.UsePrimarySelection(False) wx.TheClipboard.SetData(data) wx.TheClipboard.Flush() wx.TheClipboard.Close() def Paste(self): """Replace selection with clipboard contents.""" #ADD UNDO if self.CanPaste() and wx.TheClipboard.Open(): ps2 = str(sys.ps2) if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)): data = wx.TextDataObject() if wx.TheClipboard.GetData(data): self.ReplaceSelection('') command = data.GetText() command = command.rstrip() command = self.fixLineEndings(command) command = self.lstripPrompt(text=command) # TODO : This is still useful... Add it back other places? command = command.replace(os.linesep + ps2, '\n') command = command.replace(os.linesep, '\n') #DNM--Don't use '... ' command = command.replace('\n', os.linesep)# + ps2) cpos=self.GetCurrentPos() s=command self.UpdateUndoHistoryBefore('insert', s, cpos, cpos+len(s), forceNewAction=True) self.write(s,type='Input') self.UpdateUndoHistoryAfter() # Makes paste -> type -> undo consistent with other STC apps self.ReplaceSelection('') wx.TheClipboard.Close() def PasteAndRun(self): """Replace selection with clipboard contents, run commands.""" text = '' if wx.TheClipboard.Open(): if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)): data = wx.TextDataObject() if wx.TheClipboard.GetData(data): text = data.GetText() wx.TheClipboard.Close() if text: self.Execute(text) def Execute(self, text): """Replace selection with text and run commands.""" start,end=self.GetIOSlice() startpos=self.PositionFromLine(start) endpos=self.GetLineEndPosition(end) self.SetCurrentPos(endpos) self.SetSelection(startpos, endpos) self.ReplaceSelection('') hasSyntaxError=False result = self.BreakTextIntoCommands(command) if result[0] == None: commands=[command] hasSyntaxError=True else: commands=result for command in commands: command = command.replace('\n', os.linesep) self.write(command) self.processLine() def wrap(self, wrap=True): """Sets whether text is word wrapped.""" try: self.SetWrapMode(wrap) except AttributeError: return 'Wrapping is not available in this version.' def zoom(self, points=0): """Set the zoom level. This number of points is added to the size of all fonts. It may be positive to magnify or negative to reduce.""" self.SetZoom(points) def LoadSettings(self, config): self.autoComplete = \ config.ReadBool('Options/AutoComplete', True) self.autoCompleteIncludeMagic = \ config.ReadBool('Options/AutoCompleteIncludeMagic', True) self.autoCompleteIncludeSingle = \ config.ReadBool('Options/AutoCompleteIncludeSingle', True) self.autoCompleteIncludeDouble = \ config.ReadBool('Options/AutoCompleteIncludeDouble', True) self.autoCallTip = \ config.ReadBool('Options/AutoCallTip', True) self.callTipInsert = \ config.ReadBool('Options/CallTipInsert', True) self.SetWrapMode(config.ReadBool('View/WrapMode', True)) self.lineNumbers = \ config.ReadBool('View/ShowLineNumbers', True) self.setDisplayLineNumbers (self.lineNumbers) zoom = config.ReadInt('View/Zoom/Shell', -99) if zoom != -99: self.SetZoom(zoom) def SaveSettings(self, config): config.WriteBool('Options/AutoComplete', self.autoComplete) config.WriteBool('Options/AutoCompleteIncludeMagic', self.autoCompleteIncludeMagic) config.WriteBool('Options/AutoCompleteIncludeSingle', self.autoCompleteIncludeSingle) config.WriteBool('Options/AutoCompleteIncludeDouble', self.autoCompleteIncludeDouble) config.WriteBool('Options/AutoCallTip', self.autoCallTip) config.WriteBool('Options/CallTipInsert', self.callTipInsert) config.WriteBool('View/WrapMode', self.GetWrapMode()) config.WriteBool('View/ShowLineNumbers', self.lineNumbers) config.WriteInt('View/Zoom/Shell', self.GetZoom()) def GetContextMenu(self): """ Create and return a context menu for the slices shell. This is used instead of the scintilla default menu in order to correctly respect our immutable buffer. """ menu = wx.Menu() menu.Append(wx.ID_UNDO, "Undo") menu.Append(wx.ID_REDO, "Redo") menu.AppendSeparator() menu.Append(wx.ID_CUT, "Cut") menu.Append(wx.ID_COPY, "Copy") menu.Append(frame.ID_COPY_PLUS, "Copy Plus") menu.Append(wx.ID_PASTE, "Paste") menu.Append(frame.ID_PASTE_PLUS, "Paste Plus") menu.Append(wx.ID_CLEAR, "Clear") menu.AppendSeparator() menu.Append(wx.ID_SELECTALL, "Select All") return menu def OnContextMenu(self, evt): menu = self.GetContextMenu() self.PopupMenu(menu) def OnUpdateUI(self, evt): id = evt.Id if id in (wx.ID_CUT, wx.ID_CLEAR): evt.Enable(self.CanCut()) elif id in (wx.ID_COPY, frame.ID_COPY_PLUS): evt.Enable(self.CanCopy()) elif id in (wx.ID_PASTE, frame.ID_PASTE_PLUS): evt.Enable(self.CanPaste()) elif id == wx.ID_UNDO: evt.Enable(self.CanUndo()) elif id == wx.ID_REDO: evt.Enable(self.CanRedo()) def LoadPySlicesFile(self,fid): invalidFileString = 'Not a valid input format' lineCount=0 groupingStartLines=[0] ioStartLines=[0] ioStartTypes=[] removeComment=False # Read the initial three (or four) lines that have version and marker information line=fid.readline() if line == usrBinEnvPythonText: line=fid.readline() # Add the option to place #!/usr/bin/env python at the top if line not in pyslicesFormatHeaderText: print(invalidFileString); return line=fid.readline() if line != groupingStartText: print(invalidFileString); return line=fid.readline() if line == inputStartText: ioStartTypes.append('input');removeComment=False elif line == outputStartText: ioStartTypes.append('output');removeComment=True else: print(invalidFileString); return self.ClearAll() # Write the file's text to the text area # Capture Marker information to for i in fid: if i==groupingStartText: groupingStartLines.append(lineCount) elif i==inputStartText: ioStartLines.append(lineCount) ioStartTypes.append('input') removeComment=False elif i==outputStartText: ioStartLines.append(lineCount) ioStartTypes.append('output') removeComment=True else: if removeComment: w=i[1:].replace(os.linesep,'\n') else: w=i.replace(os.linesep,'\n') self.write(w,'Input',silent=True) lineCount+=1 if w[-1]=='\n': lineCount+=1 for i in range(lineCount+1): self.clearGroupingMarkers(i) self.clearIOMarkers(i) doMiddle=False doEnd=False if groupingStartLines!=[]: if i == groupingStartLines[0]: self.MarkerAdd(i,GROUPING_START) del groupingStartLines[0] elif i+1 == groupingStartLines[0]: doEnd=True else: doMiddle=True elif i==lineCount-1: doEnd=True else: doMiddle=True if doMiddle: self.MarkerAdd(i,GROUPING_MIDDLE) elif doEnd: self.MarkerAdd(i,GROUPING_END) doMiddle=False doEnd=False if ioStartLines!=[]: if i == ioStartLines[0]: # Delete the old ioStartTypes (keep the current copy for later use) if i>0: del ioStartTypes[0] if ioStartTypes[0]=='input': self.MarkerAdd(i,INPUT_START) elif ioStartTypes[0]=='output': self.MarkerAdd(i,OUTPUT_START) self.MarkerAdd(i,OUTPUT_BG) else: #print('Invalid Type!') return # Only delete markers we are totally finished with... # Keep one more "StartTypes" than "StartLines" del ioStartLines[0] elif i+1 == ioStartLines[0]: doEnd=True else: doMiddle=True elif i==lineCount-1: doEnd=True else: doMiddle=True if doMiddle: if ioStartTypes[0]=='input': self.MarkerAdd(i,INPUT_MIDDLE) elif ioStartTypes[0]=='output': self.MarkerAdd(i,OUTPUT_MIDDLE) self.MarkerAdd(i,OUTPUT_BG) else: #print('Invalid Type!') return elif doEnd: if ioStartTypes[0]=='input': self.MarkerAdd(i,INPUT_END) elif ioStartTypes[0]=='output': self.MarkerAdd(i,OUTPUT_END) self.MarkerAdd(i,OUTPUT_BG) else: #print('Invalid Type!') return self.EmptyUndoBuffer() # maybe not? def SavePySlicesFile(self,fid): addComment=False fid.write(usrBinEnvPythonText.replace('\n',os.linesep)) fid.write(pyslicesFormatHeaderText[-1].replace('\n',os.linesep)) for i in range(self.GetLineCount()): markers=self.MarkerGet(i) if markers & ( 1<<GROUPING_START | 1<<GROUPING_START_FOLDED ): fid.write(groupingStartText.replace('\n',os.linesep)) if markers & ( 1<<INPUT_START | 1<<INPUT_START_FOLDED ): fid.write(inputStartText.replace('\n',os.linesep)) addComment=False if markers & ( 1<<OUTPUT_START | 1<<OUTPUT_START_FOLDED ): fid.write(outputStartText.replace('\n',os.linesep)) addComment=True if addComment: fid.write('#') fid.write(self.GetLine(i).replace('\n',os.linesep)) # FIX ME!! def LoadPyFileAsSlice(self,fid): curpos=self.GetCurrentPos() start,end = self.GetGroupingSlice() endpos=self.GetLineEndPosition(end) self.SetCurrentPos(endpos) self.SetSelection(endpos, endpos) text='\n'+fid.read() self.write(text,'Input') newpos=self.GetCurrentPos() self.SetCurrentPos(curpos) self.SetSelection(curpos,curpos) self.SplitSlice() #self.SetCurrentPos(newpos) #self.SetSelection(newpos,newpos) def hasChanged(self): """Return True if contents have changed.""" return self.GetModify() or self.NeedsCheckForSave ## NOTE: The DnD of file names is disabled until we can figure out how ## best to still allow DnD of text. ## #seb : File drag and drop ## class FileDropTarget(wx.FileDropTarget): ## def __init__(self, obj): ## wx.FileDropTarget.__init__(self) ## self.obj = obj ## def OnDropFiles(self, x, y, filenames): ## if len(filenames) == 1: ## txt = 'r\"%s\"' % filenames[0] ## else: ## txt = '( ' ## for f in filenames: ## txt += 'r\"%s\" , ' % f ## txt += ')' ## self.obj.AppendText(txt) ## pos = self.obj.GetCurrentPos() ## self.obj.SetCurrentPos( pos ) ## self.obj.SetSelection( pos, pos ) ## class TextAndFileDropTarget(wx.DropTarget): ## def __init__(self, sliceshell): ## wx.DropTarget.__init__(self) ## self.sliceshell = sliceshell ## self.compdo = wx.DataObjectComposite() ## self.textdo = wx.TextDataObject() ## self.filedo = wx.FileDataObject() ## self.compdo.Add(self.textdo) ## self.compdo.Add(self.filedo, True) ## self.SetDataObject(self.compdo) ## def OnDrop(self, x, y): ## return True ## def OnData(self, x, y, result): ## self.GetData() ## if self.textdo.GetTextLength() > 1: ## text = self.textdo.GetText() ## # *** Do somethign with the dragged text here... ## self.textdo.SetText('') ## else: ## filenames = str(self.filename.GetFilenames()) ## if len(filenames) == 1: ## txt = 'r\"%s\"' % filenames[0] ## else: ## txt = '( ' ## for f in filenames: ## txt += 'r\"%s\" , ' % f ## txt += ')' ## self.sliceshell.AppendText(txt) ## pos = self.sliceshell.GetCurrentPos() ## self.sliceshell.SetCurrentPos( pos ) ## self.sliceshell.SetSelection( pos, pos ) ## return result