eric: comparison QScintilla/Shell.py

-:9a71bd9e2e37
+:6422afc7adc4
 @param horizontal flag indicating a horizontal layout (boolean)
 @param parent parent widget (QWidget)
 """
 super(ShellAssembly, self).__init__(parent)
-self.__shell = Shell(dbs, vm, self)
+self.__shell = Shell(dbs, vm, False, self)
 from UI.SearchWidget import SearchWidget
 self.__searchWidget = SearchWidget(self.__shell, self, horizontal)
 self.__searchWidget.hide()
 @signal searchStringFound(found) emitted to indicate the search
 result (boolean)
 """
 searchStringFound = pyqtSignal(bool)
-def __init__(self, dbs, vm, parent=None):
+def __init__(self, dbs, vm, windowedVariant, parent=None):
 """
 Constructor
 @param dbs reference to the debug server object
 @param vm reference to the viewmanager object
+@param windowedVariant flag indicating the shell window variant
+(boolean)
 @param parent parent widget (QWidget)
 """
 super(Shell, self).__init__(parent)
 self.setUtf8(True)
 self.vm = vm
 self.__mainWindow = parent
 self.__lastSearch = ()
+self.__windowed = windowedVariant
 self.linesepRegExp = r"\r\n|\n|\r"
-self.passive = Preferences.getDebugger("PassiveDbgEnabled")
+self.passive = ((not self.__windowed) and
+Preferences.getDebugger("PassiveDbgEnabled"))
 if self.passive:
 self.setWindowTitle(self.tr('Shell - Passive'))
 else:
 self.setWindowTitle(self.tr('Shell'))
-self.setWhatsThis(self.tr(
+if self.__windowed:
-"""<b>The Shell Window</b>"""
+self.setWhatsThis(self.tr(
-"""<p>This is simply an interpreter running in a window. The"""
+"""<b>The Shell Window</b>"""
-""" interpreter is the one that is used to run the program"""
+"""<p>You can use the cursor keys while entering commands."""
-""" being debugged. This means that you can execute any command"""
+""" There is also a history of commands that can be recalled"""
-""" while the program being debugged is running.</p>"""
+""" using the up and down cursor keys. Pressing the up or"""
-"""<p>You can use the cursor keys while entering commands. There"""
+""" down key after some text has been entered will start an"""
-""" is also a history of commands that can be recalled using the"""
+""" incremental search.</p>"""
-""" up and down cursor keys. Pressing the up or down key after"""
+"""<p>The shell has some special commands. 'reset' kills the"""
-""" some text has been entered will start an incremental search."""
+""" shell and starts a new one. 'clear' clears the display"""
-"""</p>"""
+""" of the shell window. 'start' is used to switch the shell"""
-"""<p>The shell has some special commands. 'reset' kills the"""
+""" language and must be followed by a supported language."""
-""" shell and starts a new one. 'clear' clears the display of"""
+""" Supported languages are listed by the 'languages'"""
-""" the shell window. 'start' is used to switch the shell"""
+""" command. 'quit' is used to exit the application.These"""
-""" language and must be followed by a supported language."""
+""" commands (except 'languages') are available through the"""
-""" Supported languages are listed by the 'languages' command."""
+""" window menus as well.</p>"""
-""" These commands (except 'languages') are available through"""
+"""<p>Pressing the Tab key after some text has been entered"""
-""" the context menu as well.</p>"""
+""" will show a list of possible completions. The relevant"""
-"""<p>Pressing the Tab key after some text has been entered will"""
+""" entry may be selected from this list. If only one entry"""
-""" show a list of possible commandline completions. The"""
+""" is available, this will be inserted automatically.</p>"""
-""" relevant entry may be selected from this list. If only one"""
+))
-""" entry is available, this will inserted automatically.</p>"""
+else:
-"""<p>In passive debugging mode the shell is only available"""
+self.setWhatsThis(self.tr(
-""" after the program to be debugged has connected to the IDE"""
+"""<b>The Shell Window</b>"""
-""" until it has finished. This is indicated by a different"""
+"""<p>This is simply an interpreter running in a window. The"""
-""" prompt and by an indication in the window caption.</p>"""
+""" interpreter is the one that is used to run the program"""
-))
+""" being debugged. This means that you can execute any"""
+""" command while the program being debugged is running.</p>"""
+"""<p>You can use the cursor keys while entering commands."""
+""" There is also a history of commands that can be recalled"""
+""" using the up and down cursor keys. Pressing the up or"""
+""" down key after some text has been entered will start an"""
+""" incremental search.</p>"""
+"""<p>The shell has some special commands. 'reset' kills the"""
+""" shell and starts a new one. 'clear' clears the display"""
+""" of the shell window. 'start' is used to switch the shell"""
+""" language and must be followed by a supported language."""
+""" Supported languages are listed by the 'languages'"""
+""" command. These commands (except 'languages') are"""
+""" available through the context menu as well.</p>"""
+"""<p>Pressing the Tab key after some text has been entered"""
+""" will show a list of possible completions. The relevant"""
+""" entry may be selected from this list. If only one entry"""
+""" is available, this will be inserted automatically.</p>"""
+"""<p>In passive debugging mode the shell is only available"""
+""" 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)
-self.__showStdOutErr = Preferences.getShell("ShowStdOutErr")
+if self.__windowed:
+self.__showStdOutErr = True
+else:
+self.__showStdOutErr = Preferences.getShell("ShowStdOutErr")
 if self.__showStdOutErr:
 dbs.clientProcessStdout.connect(self.__writeStdOut)
 dbs.clientProcessStderr.connect(self.__writeStdErr)
 dbs.clientOutput.connect(self.__write)
 dbs.clientStatement.connect(self.__clientStatement)
 sys.ps2 = "... "
 if self.passive:
 self.__getBanner()
-# Create a little language context menu
+if not self.__windowed:
-self.lmenu = QMenu(self.tr('Start'))
+# Create a little language context menu
-self.lmenu.aboutToShow.connect(self.__showLanguageMenu)
+self.lmenu = QMenu(self.tr('Start'))
-self.lmenu.triggered.connect(self.__startDebugClient)
+self.lmenu.aboutToShow.connect(self.__showLanguageMenu)
+self.lmenu.triggered.connect(self.__startDebugClient)
-# Create the history context menu
-self.hmenu = QMenu(self.tr('History'))
+# Create the history context menu
-self.hmenu.addAction(self.tr('Select entry'), self.__selectHistory)
+self.hmenu = QMenu(self.tr('History'))
-self.hmenu.addAction(self.tr('Show'), self.__showHistory)
+self.hmenu.addAction(self.tr('Select entry'), self.selectHistory)
-self.hmenu.addAction(self.tr('Clear'), self.__clearHistory)
+self.hmenu.addAction(self.tr('Show'), self.showHistory)
+self.hmenu.addAction(self.tr('Clear'), self.clearHistory)
-# Create a little context menu
-self.menu = QMenu(self)
+# Create a little context menu
-self.menu.addAction(self.tr('Cut'), self.cut)
+self.menu = QMenu(self)
-self.menu.addAction(self.tr('Copy'), self.copy)
+self.menu.addAction(self.tr('Cut'), self.cut)
-self.menu.addAction(self.tr('Paste'), self.paste)
+self.menu.addAction(self.tr('Copy'), self.copy)
-self.menu.addMenu(self.hmenu)
+self.menu.addAction(self.tr('Paste'), self.paste)
-self.menu.addSeparator()
+self.menu.addMenu(self.hmenu)
-self.menu.addAction(self.tr('Find'), self.__find)
+self.menu.addSeparator()
-self.menu.addSeparator()
+self.menu.addAction(self.tr('Find'), self.__find)
-self.menu.addAction(self.tr('Clear'), self.clear)
+self.menu.addSeparator()
-self.menu.addAction(self.tr('Reset'), self.__reset)
+self.menu.addAction(self.tr('Clear'), self.clear)
-self.menu.addAction(
+self.menu.addAction(self.tr('Reset'), self.__reset)
-self.tr('Reset and Clear'), self.__resetAndClear)
+self.menu.addAction(
-self.menu.addSeparator()
+self.tr('Reset and Clear'), self.__resetAndClear)
-self.menu.addMenu(self.lmenu)
+self.menu.addSeparator()
-self.menu.addSeparator()
+self.menu.addMenu(self.lmenu)
-self.menu.addAction(self.tr("Configure..."), self.__configure)
+self.menu.addSeparator()
+self.menu.addAction(self.tr("Configure..."), self.__configure)
 self.__bindLexer()
 self.__setTextDisplay()
 self.__setMargin0()
 QsciScintilla.SCI_CHARRIGHT: self.__QScintillaCharRight,
 QsciScintilla.SCI_WORDLEFT: self.__QScintillaWordLeft,
 QsciScintilla.SCI_WORDRIGHT: self.__QScintillaWordRight,
 QsciScintilla.SCI_VCHOME: self.__QScintillaVCHome,
 QsciScintilla.SCI_LINEEND: self.__QScintillaLineEnd,
-QsciScintilla.SCI_LINEUP: self.__QScintillaLineUp,
+QsciScintilla.SCI_LINEUP: self.__QScintillaCommand,
-QsciScintilla.SCI_LINEDOWN: self.__QScintillaLineDown,
+QsciScintilla.SCI_LINEDOWN: self.__QScintillaCommand,
+QsciScintilla.SCI_LINESCROLLUP: self.__QScintillaHistoryUp,
+QsciScintilla.SCI_LINESCROLLDOWN: self.__QScintillaHistoryDown,
 QsciScintilla.SCI_PAGEUP: self.__QScintillaAutoCompletionCommand,
 QsciScintilla.SCI_PAGEDOWN: self.__QScintillaAutoCompletionCommand,
 QsciScintilla.SCI_CANCEL: self.__QScintillaAutoCompletionCommand,
 elif clientType in self.historyLists:
 return self.historyLists[clientType]
 else:
 return []
-def __clearHistory(self):
+def clearHistory(self):
 """
-Private slot to clear the current history.
+Public slot to clear the current history.
 """
 if self.clientType:
 self.historyLists[self.clientType] = []
 self.history = self.historyLists[self.clientType]
 else:
 self.history = []
 self.histidx = -1
-def __selectHistory(self):
+def selectHistory(self):
 """
-Private slot to select a history entry to execute.
+Public slot to select a history entry to execute.
 """
 cmd, ok = QInputDialog.getItem(
 self,
 self.tr("Select History"),
 self.tr("Select the history entry to execute"
 self.history,
 0, False)
 if ok:
 self.__insertHistory(cmd)
-def __showHistory(self):
+def showHistory(self):
 """
-Private slot to show the shell history dialog.
+Public slot to show the shell history dialog.
 """
 from .ShellHistoryDialog import ShellHistoryDialog
 dlg = ShellHistoryDialog(self.history, self.vm, self)
 if dlg.exec_() == QDialog.Accepted:
 self.historyLists[self.clientType] = dlg.getHistory()
 for clientType in Preferences.Prefs.settings.childKeys():
 self.historyLists[clientType] = []
 self.saveHistory(clientType)
 Preferences.Prefs.settings.endGroup()
-self.__clearHistory()
+self.clearHistory()
 def getClientType(self):
 """
 Public slot to get the clients type.
 def __writePrompt(self):
 """
 Private method to write the prompt.
 """
 self.__write(self.inContinue and sys.ps2 or sys.ps1)
+# little trick to get the cursor position registered within QScintilla
+self.SendScintilla(QsciScintilla.SCI_CHARLEFT)
+self.SendScintilla(QsciScintilla.SCI_CHARRIGHT)
 def __clientStatement(self, more):
 """
 Private method to handle the response from the debugger client.
 @param exceptionMessage message given by the exception (string)
 @param stackTrace list of stack entries (list of string)
 """
 self .__clientError()
-if Preferences.getDebugger("ShowExceptionInShell"):
+if not self.__windowed and \
+Preferences.getDebugger("ShowExceptionInShell"):
 if exceptionType:
 if stackTrace:
 self.__write(
 self.tr('Exception "{0}"\n{1}\nFile: {2}, Line: {3}\n')
 .format(
 @param characterNo character number of the syntax error position
 (integer)
 """
 self .__clientError()
-if Preferences.getDebugger("ShowExceptionInShell"):
+if not self.__windowed and \
+Preferences.getDebugger("ShowExceptionInShell"):
 if message is None:
 self.__write(self.tr("Unspecified syntax error.\n"))
 else:
 self.__write(
 self.tr('Syntax error "{1}" in file {0} at line {2},'
 else:
 self.__insertTextNoEcho(txt)
 else:
 ev.ignore()
+def __QScintillaCommand(self, cmd):
+"""
+Private method to send the command to QScintilla.
+@param cmd QScintilla command
+"""
+self.SendScintilla(cmd)
 def __QScintillaTab(self, cmd):
 """
 Private method to handle the Tab key.
 @param cmd QScintilla command
 buf = buf.replace(sys.ps1, "")
 if buf.startswith(sys.ps2):
 buf = buf.replace(sys.ps2, "")
 self.insert('\n')
 self.__executeCommand(buf)
+else:
+txt = ""
+line, col = self.getCursorPosition()
+if self.hasSelectedText():
+lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+if line == lineFrom:
+txt = self.text(line)[indexFrom:].rstrip()
+elif line == lineTo:
+txt = self.text(line)[:indexTo]
+else:
+txt = self.text(line)[col:].rstrip()
+if txt:
+line, col = self.__getEndPos()
+self.setCursorPosition(line, col)
+self.insert(txt)
 def __QScintillaLeftCommand(self, method, allLinesAllowed=False):
 """
 Private method to handle a QScintilla command working to the left.
 elif self.text(line).startswith(sys.ps2):
 if col > len(sys.ps2):
 method()
 elif col > 0:
 method()
+else:
+method()
 def __QScintillaCharLeft(self):
 """
 Private method to handle the Cursor Left command.
 """
 Private method to handle a QScintilla command working to the right.
 @param method shell method to execute
 """
 if self.__isCursorOnLastLine():
+method()
+else:
 method()
 def __QScintillaCharRight(self):
 """
 Private method to handle the Cursor Right command.
 if self.isListActive():
 self.SendScintilla(cmd)
 elif self.__isCursorOnLastLine():
 self.moveCursorToEOL()
-def __QScintillaLineUp(self, cmd):
+def __QScintillaHistoryUp(self, cmd):
 """
-Private method to handle the Up key.
+Private method to handle the Ctrl+Up key.
 @param cmd QScintilla command
 """
-if self.isListActive():
+line, col = self.__getEndPos()
-self.SendScintilla(cmd)
+buf = self.text(line)
-else:
+if buf.startswith(sys.ps1):
-line, col = self.__getEndPos()
+buf = buf.replace(sys.ps1, "")
-buf = self.text(line)
+if buf.startswith(sys.ps2):
-if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps2, "")
-buf = buf.replace(sys.ps1, "")
+if buf and self.incrementalSearchActive:
-if buf.startswith(sys.ps2):
+if self.incrementalSearchString:
-buf = buf.replace(sys.ps2, "")
+idx = self.__rsearchHistory(self.incrementalSearchString,
-if buf and self.incrementalSearchActive:
+self.histidx)
-if self.incrementalSearchString:
+if idx >= 0:
-idx = self.__rsearchHistory(self.incrementalSearchString,
+self.histidx = idx
-self.histidx)
+self.__useHistory()
-if idx >= 0:
-self.histidx = idx
-self.__useHistory()
-else:
-idx = self.__rsearchHistory(buf)
-if idx >= 0:
-self.histidx = idx
-self.incrementalSearchString = buf
-self.__useHistory()
 else:
-if self.histidx < 0:
+idx = self.__rsearchHistory(buf)
-self.histidx = len(self.history)
+if idx >= 0:
-if self.histidx > 0:
+self.histidx = idx
-self.histidx = self.histidx - 1
+self.incrementalSearchString = buf
 self.__useHistory()
+else:
-def __QScintillaLineDown(self, cmd):
+if self.histidx < 0:
-"""
+self.histidx = len(self.history)
-Private method to handle the Down key.
+if self.histidx > 0:
+self.histidx = self.histidx - 1
+self.__useHistory()
+def __QScintillaHistoryDown(self, cmd):
+"""
+Private method to handle the Ctrl+Down key.
 @param cmd QScintilla command
 """
-if self.isListActive():
+line, col = self.__getEndPos()
-self.SendScintilla(cmd)
+buf = self.text(line)
-else:
+if buf.startswith(sys.ps1):
-line, col = self.__getEndPos()
+buf = buf.replace(sys.ps1, "")
-buf = self.text(line)
+if buf.startswith(sys.ps2):
-if buf.startswith(sys.ps1):
+buf = buf.replace(sys.ps2, "")
-buf = buf.replace(sys.ps1, "")
+if buf and self.incrementalSearchActive:
-if buf.startswith(sys.ps2):
+if self.incrementalSearchString:
-buf = buf.replace(sys.ps2, "")
+idx = self.__searchHistory(
-if buf and self.incrementalSearchActive:
+self.incrementalSearchString, self.histidx)
-if self.incrementalSearchString:
+if idx >= 0:
-idx = self.__searchHistory(
+self.histidx = idx
-self.incrementalSearchString, self.histidx)
+self.__useHistory()
-if idx >= 0:
-self.histidx = idx
-self.__useHistory()
-else:
-idx = self.__searchHistory(buf)
-if idx >= 0:
-self.histidx = idx
-self.incrementalSearchString = buf
-self.__useHistory()
 else:
-if self.histidx >= 0 and self.histidx < len(self.history):
+idx = self.__searchHistory(buf)
-self.histidx += 1
+if idx >= 0:
+self.histidx = idx
+self.incrementalSearchString = buf
 self.__useHistory()
+else:
+if self.histidx >= 0 and self.histidx < len(self.history):
+self.histidx += 1
+self.__useHistory()
 def __QScintillaCharLeftExtend(self):
 """
 Private method to handle the Extend Selection Left command.
 """
 self.dbs.startClient(False)
 if self.passive:
 return
 else:
 cmd = ''
+elif cmd in ["quit", "quit()"] and self.__windowed:
+# call main window quit()
+self.vm.quit()
+return
 self.dbs.remoteStatement(cmd)
 while self.inCommandExecution:
 try:
 QApplication.processEvents()
 """
 Protected method to show our own context menu.
 @param ev context menu event (QContextMenuEvent)
 """
-self.menu.popup(ev.globalPos())
+if not self.__windowed:
-ev.accept()
+self.menu.popup(ev.globalPos())
+ev.accept()
 def clear(self):
 """
 Public slot to clear the display.
 """
 """
 Protected method to handle the drop event.
 @param event the drop event (QDropEvent)
 """
-if event.mimeData().hasUrls():
+if event.mimeData().hasUrls() and not self.__windowed:
 for url in event.mimeData().urls():
 fname = url.toLocalFile()
 if fname:
 if not QFileInfo(fname).isDir():
 self.vm.openSourceFile(fname)

Mercurial Repositories > eric / file comparison

comparison: QScintilla/Shell.py

QScintilla/Shell.py