eric: comparison QScintilla/Shell.py

-:ce77f0b1ee67
+:9986ec0e559a
 import sys
 import re
 from PyQt4.QtCore import pyqtSignal, QFileInfo, Qt, QEvent
-from PyQt4.QtGui import QDialog, QInputDialog, QApplication, QClipboard, QMenu, \
+from PyQt4.QtGui import QDialog, QInputDialog, QApplication, QClipboard, \
-QPalette, QFont, QWidget, QHBoxLayout, QVBoxLayout, QShortcut
+QMenu, QPalette, QFont, QWidget, QHBoxLayout, QVBoxLayout, QShortcut
 from PyQt4.Qsci import QsciScintilla
 from E5Gui.E5Application import e5App
 from E5Gui import E5MessageBox
 self.__layout.addWidget(self.__shell)
 self.__layout.addWidget(self.__searchWidget)
 self.__searchWidget.searchNext.connect(self.__shell.searchNext)
 self.__searchWidget.searchPrevious.connect(self.__shell.searchPrev)
-self.__shell.searchStringFound.connect(self.__searchWidget.searchStringFound)
+self.__shell.searchStringFound.connect(
+self.__searchWidget.searchStringFound)
 def showFind(self, txt=""):
 """
 Public method to display the search widget.
 Class implementing a graphical Python shell.
 A user can enter commands that are executed in the remote
 Python interpreter.
-@signal searchStringFound(found) emitted to indicate the search result (boolean)
+@signal searchStringFound(found) emitted to indicate the search
+result (boolean)
 """
 searchStringFound = pyqtSignal(bool)
 def __init__(self, dbs, vm, parent=None):
 """
 self.setWindowTitle(self.trUtf8('Shell'))
 self.setWhatsThis(self.trUtf8(
 """<b>The Shell Window</b>"""
 """<p>This is simply an interpreter running in a window. The"""
-""" interpreter is the one that is used to run the program being debugged."""
+""" interpreter is the one that is used to run the program"""
-""" This means that you can execute any command while the program"""
+""" being debugged. This means that you can execute any command"""
-""" being debugged is running.</p>"""
+""" while the program being debugged is running.</p>"""
-"""<p>You can use the cursor keys while entering commands. There is also a"""
+"""<p>You can use the cursor keys while entering commands. There"""
-""" history of commands that can be recalled using the up and down cursor"""
+""" is also a history of commands that can be recalled using the"""
-""" keys. Pressing the up or down key after some text has been entered will"""
+""" up and down cursor keys. Pressing the up or down key after"""
-""" start an incremental search.</p>"""
+""" some text has been entered will start an incremental search."""
-"""<p>The shell has some special commands. 'reset' kills the shell"""
+"""</p>"""
-""" and starts a new one. 'clear' clears the display of the shell window."""
+"""<p>The shell has some special commands. 'reset' kills the"""
-""" 'start' is used to switch the shell language and must be followed by"""
+""" shell and starts a new one. 'clear' clears the display of"""
-""" a supported language. Supported languages are listed by the 'languages'"""
+""" the shell window. 'start' is used to switch the shell"""
-""" command. These commands (except 'languages') are available through the"""
+""" language and must be followed by a supported language."""
-""" context menu as well.</p>"""
+""" Supported languages are listed by the 'languages' command."""
-"""<p>Pressing the Tab key after some text has been entered will show"""
+""" These commands (except 'languages') are available through"""
-""" a list of possible commandline completions. The relevant entry may"""
+""" the context menu as well.</p>"""
-""" be selected from this list. If only one entry is available, this will"""
+"""<p>Pressing the Tab key after some text has been entered will"""
-""" inserted automatically.</p>"""
+""" show a list of possible commandline completions. The"""
-"""<p>In passive debugging mode the shell is only available after the"""
+""" relevant entry may be selected from this list. If only one"""
-""" program to be debugged has connected to the IDE until it has finished."""
+""" entry is available, this will inserted automatically.</p>"""
-""" This is indicated by a different prompt and by an indication in the"""
+"""<p>In passive debugging mode the shell is only available"""
-""" window caption.</p>"""
+""" after the program to be debugged has connected to the IDE"""
+""" until it has finished. This is indicated by a different"""
+""" prompt and by an indication in the window caption.</p>"""
 ))
 self.userListActivated.connect(self.__completionListSelected)
 self.linesChanged.connect(self.__resizeLinenoMargin)
 """
 Private method to configure margin 0.
 """
 # set the settings for all margins
 self.setMarginsFont(Preferences.getShell("MarginsFont"))
-self.setMarginsForegroundColor(Preferences.getEditorColour("MarginsForeground"))
+self.setMarginsForegroundColor(
-self.setMarginsBackgroundColor(Preferences.getEditorColour("MarginsBackground"))
+Preferences.getEditorColour("MarginsForeground"))
+self.setMarginsBackgroundColor(
+Preferences.getEditorColour("MarginsBackground"))
 # set margin 0 settings
 linenoMargin = Preferences.getShell("LinenoMargin")
 self.setMarginLineNumbers(0, linenoMargin)
 if linenoMargin:
 Preferences.getEditorColour("CallTipsBackground"))
 self.setCallTipsVisible(Preferences.getEditor("CallTipsVisible"))
 calltipsStyle = Preferences.getEditor("CallTipsStyle")
 if calltipsStyle == QsciScintilla.CallTipsNoContext:
 self.setCallTipsStyle(QsciScintilla.CallTipsNoContext)
-elif calltipsStyle == QsciScintilla.CallTipsNoAutoCompletionContext:
+elif calltipsStyle == \
-self.setCallTipsStyle(QsciScintilla.CallTipsNoAutoCompletionContext)
+QsciScintilla.CallTipsNoAutoCompletionContext:
+self.setCallTipsStyle(
+QsciScintilla.CallTipsNoAutoCompletionContext)
 else:
 self.setCallTipsStyle(QsciScintilla.CallTipsContext)
 else:
 self.setCallTipsStyle(QsciScintilla.CallTipsNone)
 self.__bindLexer(clType)
 self.__setTextDisplay()
 self.__setMargin0()
 self.__setAutoCompletion(clType)
 self.__setCallTips(clType)
-self.racEnabled = Preferences.getShell("AutoCompletionEnabled") and \
+self.racEnabled = \
-(cap & HasCompleter) > 0
+Preferences.getShell("AutoCompletionEnabled") and \
+(cap & HasCompleter) > 0
 if clType not in self.historyLists:
 # load history list
 self.loadHistory(clType)
 self.history = self.historyLists[clType]
 else:
 self.historyLists[clientType] = []
 def reloadHistory(self):
 """
-Public method to reload the history of the currently selected client type.
+Public method to reload the history of the currently selected client
+type.
 """
 self.loadHistory(self.clientType)
 self.history = self.historyLists[self.clientType]
 self.histidx = -1
 Private slot to select a history entry to execute.
 """
 cmd, ok = QInputDialog.getItem(
 self,
 self.trUtf8("Select History"),
-self.trUtf8("Select the history entry to execute (most recent shown last)."),
+self.trUtf8("Select the history entry to execute"
+" (most recent shown last)."),
 self.history,
 0, False)
 if ok:
 self.__insertHistory(cmd)
 self.inRawMode = True
 self.echoInput = echo
 self.__write(s)
 line, col = self.__getEndPos()
 self.setCursorPosition(line, col)
-self.prompt = self.text(line)\
+buf = self.text(line)
-.replace(sys.ps1, "").replace(sys.ps2, "")
+if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps1, "")
+if buf.startswith(sys.ps2):
+buf = buf.replace(sys.ps2, "")
+self.prompt = buf
 # move cursor to end of line
 self.moveCursorToEOL()
 def paste(self):
 """
 self.insert(s)
 self.prline, self.prcol = self.getCursorPosition()
 def __insertTextNoEcho(self, s):
 """
-Private method to insert some text at the end of the buffer without echoing it.
+Private method to insert some text at the end of the buffer without
+echoing it.
 @param s text to be inserted (string)
 """
 self.buff += s
 self.prline, self.prcol = self.getCursorPosition()
 """
 if self.isListActive():
 self.SendScintilla(cmd)
 elif self.__isCursorOnLastLine():
 line, index = self.getCursorPosition()
-buf = self.text(line).replace(sys.ps1, "").replace(sys.ps2, "")
+buf = self.text(line)
+if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps1, "")
+if buf.startswith(sys.ps2):
+buf = buf.replace(sys.ps2, "")
 if self.inContinue and not buf[:index - len(sys.ps2)].strip():
 self.SendScintilla(cmd)
 elif self.racEnabled:
 self.dbs.remoteCompletion(buf)
 def __QScintillaLeftDeleteCommand(self, method):
 """
-Private method to handle a QScintilla delete command working to the left.
+Private method to handle a QScintilla delete command working to
+the left.
 @param method shell method to execute
 """
 if self.__isCursorOnLastLine():
 line, col = self.getCursorPosition()
 else:
 self.incrementalSearchString = ""
 self.incrementalSearchActive = False
 line, col = self.__getEndPos()
 self.setCursorPosition(line, col)
-buf = self.text(line).replace(sys.ps1, "").replace(sys.ps2, "")
+buf = self.text(line)
+if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps1, "")
+if buf.startswith(sys.ps2):
+buf = buf.replace(sys.ps2, "")
 self.insert('\n')
 self.__executeCommand(buf)
 def __QScintillaLeftCommand(self, method, allLinesAllowed=False):
 """
 """
 if self.isListActive():
 self.SendScintilla(cmd)
 else:
 line, col = self.__getEndPos()
-buf = self.text(line).replace(sys.ps1, "").replace(sys.ps2, "")
+buf = self.text(line)
+if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps1, "")
+if buf.startswith(sys.ps2):
+buf = buf.replace(sys.ps2, "")
 if buf and self.incrementalSearchActive:
 if self.incrementalSearchString:
 idx = self.__rsearchHistory(self.incrementalSearchString,
 self.histidx)
 if idx >= 0:
 """
 if self.isListActive():
 self.SendScintilla(cmd)
 else:
 line, col = self.__getEndPos()
-buf = self.text(line).replace(sys.ps1, "").replace(sys.ps2, "")
+buf = self.text(line)
+if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps1, "")
+if buf.startswith(sys.ps2):
+buf = buf.replace(sys.ps2, "")
 if buf and self.incrementalSearchActive:
 if self.incrementalSearchString:
-idx = self.__searchHistory(self.incrementalSearchString, self.histidx)
+idx = self.__searchHistory(
+self.incrementalSearchString, self.histidx)
 if idx >= 0:
 self.histidx = idx
 self.__useHistory()
 else:
 idx = self.__searchHistory(buf)
 if language:
 self.dbs.startClient(False, language)
 else:
 # language not supported or typo
 self.__write(
-self.trUtf8('Shell language "{0}" not supported.\n')\
+self.trUtf8(
+'Shell language "{0}" not supported.\n')
 .format(cmdList[1]))
 self.__clientStatement(False)
 return
 cmd = ''
 elif cmd == 'languages':
 """
 self.dbs.startClient(False)
 def __startDebugClient(self, action):
 """
-Private slot to start a debug client accoding to the action triggered[()].
+Private slot to start a debug client according to the action
+triggered[()].
 @param action context menu action that was triggered (QAction)
 """
 language = action.data()
 self.dbs.startClient(False, language)
 """
 Protected method to handle the drag enter event.
 @param event the drag enter event (QDragEnterEvent)
 """
-self.inDragDrop = event.mimeData().hasUrls() or event.mimeData().hasText()
+self.inDragDrop = event.mimeData().hasUrls() or \
+event.mimeData().hasText()
 if self.inDragDrop:
 event.acceptProposedAction()
 else:
 super(Shell, self).dragEnterEvent(event)
 """
 if not self.__actionsAdded:
 self.addActions(self.vm.editorActGrp.actions())
 self.addActions(self.vm.copyActGrp.actions())
 self.addActions(self.vm.viewActGrp.actions())
-self.__searchShortcut = QShortcut(self.vm.searchAct.shortcut(), self,
+self.__searchShortcut = QShortcut(
+self.vm.searchAct.shortcut(), self,
 self.__find, self.__find)
-self.__searchNextShortcut = QShortcut(self.vm.searchNextAct.shortcut(), self,
+self.__searchNextShortcut = QShortcut(
+self.vm.searchNextAct.shortcut(), self,
 self.__searchNext, self.__searchNext)
-self.__searchPrevShortcut = QShortcut(self.vm.searchPrevAct.shortcut(), self,
+self.__searchPrevShortcut = QShortcut(
+self.vm.searchPrevAct.shortcut(), self,
 self.__searchPrev, self.__searchPrev)
 try:
 self.vm.editActGrp.setEnabled(False)
 self.vm.editorActGrp.setEnabled(True)
 search (boolean)
 @param wholeWord flag indicating to search for whole words
 only (boolean)
 """
 self.__lastSearch = (txt, caseSensitive, wholeWord)
-ok = self.findFirst(txt, False, caseSensitive, wholeWord, False, forward=True)
+ok = self.findFirst(txt, False, caseSensitive, wholeWord, False,
+forward=True)
 self.searchStringFound.emit(ok)
 def __searchPrev(self):
 """
 Private method to search for the next occurrence.
 self.__lastSearch = (txt, caseSensitive, wholeWord)
 if self.hasSelectedText():
 line, index = self.getSelection()[:2]
 else:
 line, index = -1, -1
-ok = self.findFirst(txt, False, caseSensitive, wholeWord, False, forward=False,
+ok = self.findFirst(txt, False, caseSensitive, wholeWord, False,
+forward=False,
 line=line, index=index)
 self.searchStringFound.emit(ok)

Mercurial Repositories > eric / file comparison

comparison: QScintilla/Shell.py

QScintilla/Shell.py