eric: comparison QScintilla/Shell.py

-:06e7d2941ead
+:331ac8f99cf8
 class ShellAssembly(QWidget):
 """
 Class implementing the containing widget for the shell.
 """
-def __init__(self, dbs, vm, horizontal=True, parent=None):
+def __init__(self, dbs, vm, project, horizontal=True, parent=None):
 """
 Constructor
 @param dbs reference to the debug server object
+@type DebugServer
 @param vm reference to the viewmanager object
-@param horizontal flag indicating a horizontal layout (boolean)
+@type ViewManager
-@param parent parent widget (QWidget)
+@param project reference to the project object
+@type Project
+@param horizontal flag indicating a horizontal layout
+@type bool
+@param parent parent widget
+@type QWidget
 """
 super(ShellAssembly, self).__init__(parent)
-self.__shell = Shell(dbs, vm, False, self)
+self.__shell = Shell(dbs, vm, project, False, self)
 from UI.SearchWidget import SearchWidget
 self.__searchWidget = SearchWidget(self.__shell, self, horizontal)
 self.__searchWidget.setSizePolicy(QSizePolicy.Fixed,
 QSizePolicy.Preferred)
 @signal searchStringFound(bool) emitted to indicate the search
 result
 @signal historyStyleChanged(ShellHistoryStyle) emitted to indicate a
 change of the history style
 @signal queueText(str) emitted to queue some text for processing
+@signal virtualEnvironmentChanged(str) emitted to signal the new virtual
+environment of the shell
 """
 searchStringFound = pyqtSignal(bool)
 historyStyleChanged = pyqtSignal(ShellHistoryStyle)
 queueText = pyqtSignal(str)
+virtualEnvironmentChanged = pyqtSignal(str)
-def __init__(self, dbs, vm, windowedVariant, parent=None):
+def __init__(self, dbs, vm, project, windowedVariant, parent=None):
 """
 Constructor
 @param dbs reference to the debug server object
+@type DebugServer
 @param vm reference to the viewmanager object
+@type ViewManager
+@param project reference to the project object
+@type Project
 @param windowedVariant flag indicating the shell window variant
-(boolean)
+@type bool
-@param parent parent widget (QWidget)
+@param parent parent widget
+@type QWidget
 """
 super(Shell, self).__init__(parent)
 self.setUtf8(True)
 self.vm = vm
 self.__mainWindow = parent
 self.__lastSearch = ()
 self.__windowed = windowedVariant
+self.__currentVenv = ""
 self.linesepRegExp = r"\r\n|\n|\r"
 self.passive = ((not self.__windowed) and
 Preferences.getDebugger("PassiveDbgEnabled"))
 """ using the up and down cursor keys while holding down the"""
 """ Ctrl-key. This can be switched to just the up and down"""
 """ cursor keys on the Shell page of the configuration"""
 """ dialog. Pressing these keys after some text has been"""
 """ entered will start an incremental search.</p>"""
-"""<p>The shell has some special commands. 'reset' kills the"""
+"""<p>The shell has some special commands. 'restart' kills"""
-""" shell and starts a new one. 'clear' clears the display"""
+""" the shell and starts a new one. 'clear' clears the"""
-""" of the shell window. 'start' is used to switch the shell"""
+""" display of the shell window. 'start' is used to start a"""
-""" language and must be followed by a supported language."""
+""" shell for a virtual environment and should be followed"""
-""" Supported languages are listed by the 'languages'"""
+""" by a virtual environment name. start' without a virtual"""
-""" command. 'quit' is used to exit the application.These"""
+""" environment name starts the default shell. Available"""
-""" commands (except 'languages') are available through the"""
+""" virtual environments may be listed with the 'envs' or"""
-""" window menus as well.</p>"""
+""" 'environments' commands. The active virtual environment"""
+""" can be questioned by the 'which' command. 'quit' or"""
+""" 'exit' is used to exit the application. These commands"""
+""" (except environments', 'envs' and 'which') are available"""
+""" through the window menus 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>"""
 ))
 """ using the up and down cursor keys while holding down the"""
 """ Ctrl-key. This can be switched to just the up and down"""
 """ cursor keys on the Shell page of the configuration"""
 """ dialog. Pressing these keys after some text has been"""
 """ entered will start an incremental search.</p>"""
-"""<p>The shell has some special commands. 'reset' kills the"""
+"""<p>The shell has some special commands. 'restart' kills"""
-""" shell and starts a new one. 'clear' clears the display"""
+""" the shell and starts a new one. 'clear' clears the"""
-""" of the shell window. 'start' is used to switch the shell"""
+""" display of the shell window. 'start' is used to start a"""
-""" language and must be followed by a supported language."""
+""" shell for a virtual environment and should be followed"""
-""" Supported languages are listed by the 'languages'"""
+""" by a virtual environment name. start' without a virtual"""
-""" command. These commands (except 'languages') are"""
+""" environment name starts the default shell. Available"""
-""" available through the context menu as well.</p>"""
+""" virtual environments may be listed with the 'envs' or"""
+""" 'environments' commands. The active virtual environment"""
+""" can be questioned by the 'which' command. These commands"""
+""" (except environments' and 'envs') 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"""
 self.__getBanner()
 if not self.__windowed:
 # Create a little language context menu
 self.lmenu = QMenu(self.tr('Start'))
-self.lmenu.aboutToShow.connect(self.__showLanguageMenu)
+self.lmenu.aboutToShow.connect(self.__showStartMenu)
 self.lmenu.triggered.connect(self.__startDebugClient)
 # Create the history context menu
 self.hmenu = QMenu(self.tr('History'))
 self.hmenu.addAction(self.tr('Select entry'), self.selectHistory)
 self.menu.addSeparator()
 self.menu.addAction(self.tr('Find'), self.__find)
 self.menu.addSeparator()
 self.menu.addAction(self.tr('Clear'), self.clear)
-self.menu.addAction(self.tr('Reset'), self.__reset)
+self.menu.addAction(self.tr('Restart'), self.doRestart)
 self.menu.addAction(
-self.tr('Reset and Clear'), self.__resetAndClear)
+self.tr('Restart and Clear'), self.doClearRestart)
 self.menu.addSeparator()
 self.menu.addMenu(self.lmenu)
+self.menu.addAction(self.tr('Active Name'), self.__showVenvName)
 self.menu.addSeparator()
 self.menu.addAction(self.tr("Configure..."), self.__configure)
 self.__bindLexer()
 self.__setTextDisplay()
 self.__queuedText = ''
 self.__blockTextProcessing = False
 self.queueText.connect(self.__concatenateText, Qt.QueuedConnection)
+self.__project = project
+if self.__project:
+self.__project.projectOpened.connect(self.__projectOpened)
+self.__project.projectClosed.connect(self.__projectClosed)
 self.grabGesture(Qt.PinchGesture)
-def __showLanguageMenu(self):
+def __showStartMenu(self):
 """
-Private slot to prepare the language submenu.
+Private slot to prepare the start submenu.
 """
 self.lmenu.clear()
-clientLanguages = self.dbs.getSupportedLanguages(shellOnly=True)
+venvManager = e5App().getObject("VirtualEnvManager")
-for language in sorted(clientLanguages):
+for venvName in sorted(venvManager.getVirtualenvNames()):
-act = self.lmenu.addAction(language)
+self.lmenu.addAction(venvName)
-act.setData(language)
+if self.__project.isOpen():
+self.lmenu.addSeparator()
+self.lmenu.addAction(self.tr("Project"))
 def __resizeLinenoMargin(self):
 """
 Private slot to resize the line numbers margin.
 """
 self.echoInput = True
 self.clientCapabilities = 0
 self.inCommandExecution = False
 self.interruptCommandExecution = False
-def __clientCapabilities(self, cap, clType):
+def __clientCapabilities(self, cap, clType, venvName):
 """
 Private slot to handle the reporting of the clients capabilities.
-@param cap client capabilities (integer)
+@param cap client capabilities
-@param clType type of the debug client (string)
+@type int
+@param clType type of the debug client
+@type str
+@param venvName name of the virtual environment
+@type str
 """
 self.clientCapabilities = cap
+self.__currentVenv = venvName
 if clType != self.clientType:
 self.clientType = clType
 self.__bindLexer(self.clientType)
 self.__setTextDisplay()
 self.__setMargin0()
 if self.clientType not in self.__historyLists:
 # load history list
 self.loadHistory(self.clientType)
 self.__history = self.__historyLists[self.clientType]
 self.__setHistoryIndex()
+self.virtualEnvironmentChanged.emit(venvName)
+Preferences.setShell("LastVirtualEnvironment", venvName)
 def __setHistoryIndex(self, index=None):
 """
 Private method to set the initial history index.
 if self.passive:
 self.__writeBanner('', '', '')
 else:
 self.dbs.remoteBanner()
-def __writeBanner(self, version, platform, dbgclient):
+def __writeBanner(self, version, platform, dbgclient, venvName):
 """
 Private method to write a banner with info from the debug client.
-@param version interpreter version string (string)
+@param version interpreter version string
-@param platform platform of the remote interpreter (string)
+@type str
-@param dbgclient debug client variant used (string)
+@param platform platform of the remote interpreter
+@type str
+@param dbgclient debug client variant used
+@type str
+@param venvName name of the virtual environment
+@type str
 """
 super(Shell, self).clear()
 if self.passive and not self.dbs.isConnected():
 self.__write(self.tr('Passive Debug Mode'))
 self.__write(self.tr('\nNot connected'))
 else:
+self.__currentVenv = venvName
 version = version.replace("#", self.tr("No."))
 if platform != "" and dbgclient != "":
 self.__write(
 self.tr('{0} on {1}, {2}')
 .format(version, platform, dbgclient))
 else:
 self.__write(version)
+if venvName:
+self.__write("\n[{0}]".format(venvName))
+self.virtualEnvironmentChanged.emit(venvName)
+Preferences.setShell("LastVirtualEnvironment", venvName)
 self.__write('\n')
 self.__write(sys.ps1)
 def __writePrompt(self):
 """
-Private method to write the prompt.
+Private method to write the prompt using a write queue.
 """
-self.__write(self.inContinue and sys.ps2 or sys.ps1)
+self.queueText.emit(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 more flag indicating that more user input is required (boolean)
 """
 if not self.inRawMode:
 self.inContinue = more
 self.__writePrompt()
 self.inCommandExecution = False
 def __clientException(self, exceptionType, exceptionMessage, stackTrace):
 """
 Private method to handle an exception of the client.
 @param exceptionType type of exception raised (string)
 # Finally process the accumulated text
 self.__write(self.__queuedText)
 self.__queuedText = ''
 self.__blockTextProcessing = False
+# little trick to get the cursor position registered within QScintilla
+self.SendScintilla(QsciScintilla.SCI_CHARLEFT)
+self.SendScintilla(QsciScintilla.SCI_CHARRIGHT)
 def __write(self, s):
 """
 Private method to display some text without queuing.
 cmd != self.__history[self.__histidx - 1]:
 self.__setHistoryIndex(index=-1)
 else:
 self.__setHistoryIndex(historyIndex)
-if cmd.startswith('start '):
+if cmd == 'start' or cmd.startswith('start '):
 if not self.passive:
 cmdList = cmd.split(None, 1)
 if len(cmdList) < 2:
-self.dbs.startClient(False)  # same as reset
+self.dbs.startClient(False)  # start default backend
 else:
-clientLanguages = self.dbs.getSupportedLanguages(
+venvName = cmdList[1]
-shellOnly=True)
+if venvName == self.tr("Project"):
-language = cmdList[1]
+if self.__project.isOpen():
-if language not in clientLanguages:
+self.dbs.startClient(False, forProject=True)
-language = cmdList[1].capitalize()
+else:
-if language not in clientLanguages:
+self.dbs.startClient(
-language = ""
+False, venvName=self.__currentVenv)
-if language:
+# same as reset
-self.dbs.startClient(False, language)
 else:
-# language not supported or typo
+self.dbs.startClient(False, venvName=venvName)
-self.__write(
+self.__getBanner()
-self.tr(
+return
-'Shell language "{0}" not supported.\n')
-.format(cmdList[1]))
-self.__clientStatement(False)
-return
-cmd = ''
-elif cmd == 'languages':
-s = '{0}\n'.format(', '.join(sorted(
-self.dbs.getSupportedLanguages(shellOnly=True))))
-self.__write(s)
-self.__clientStatement(False)
-return
 elif cmd == 'clear':
 # Display the banner.
 self.__getBanner()
 if not self.passive:
 return
 else:
 cmd = ''
-elif cmd == 'reset':
+elif cmd in ['reset', 'restart']:
-self.dbs.startClient(False)
+self.dbs.startClient(False, venvName=self.__currentVenv)
 if self.passive:
 return
 else:
 cmd = ''
-elif cmd in ["quit", "quit()"] and self.__windowed:
+elif cmd in ['envs', 'environments']:
+venvs = e5App().getObject("VirtualEnvManager")\
+.getVirtualenvNames()
+s = self.tr('Available Virtual Environments:\n{0}\n').format(
+'\n'.join("- {0}".format(venv) for venv in sorted(venvs))
+)
+self.__write(s)
+self.__clientStatement(False)
+return
+elif cmd == 'which':
+s = self.tr("Current Virtual Environment: '{0}'\n").format(
+self.__currentVenv)
+self.__write(s)
+self.__clientStatement(False)
+return
+elif cmd in ["quit", "quit()", "exit", "exit()"] and \
+self.__windowed:
 # call main window quit()
 self.vm.quit()
 return
 self.dbs.remoteStatement(cmd)
 self.inRawMode = False
 self.echoInput = True
 self.dbs.remoteRawInput(cmd)
+def __showVenvName(self):
+"""
+Private method to show the name of the active virtual environment.
+"""
+s = "\n" + self.tr("Current Virtual Environment: '{0}'\n").format(
+self.__currentVenv)
+self.__write(s)
+self.__clientStatement(False)
 def __useHistory(self):
 """
 Private method to display a command from the history.
 """
 if self.__isHistoryIndexValid():
 Public slot to clear the display.
 """
 # Display the banner.
 self.__getBanner()
-def __resetAndClear(self):
+def doClearRestart(self):
 """
-Private slot to handle the 'reset and clear' context menu entry.
+Public slot to handle the 'restart and clear' context menu entry.
 """
-self.__reset()
+self.doRestart()
 self.clear()
-def __reset(self):
+def doRestart(self):
 """
-Private slot to handle the 'reset' context menu entry.
+Public slot to handle the 'restart' context menu entry.
 """
-self.dbs.startClient(False)
+self.dbs.startClient(False, venvName=self.__currentVenv)
 def __startDebugClient(self, action):
 """
 Private slot to start a debug client according to the action
 triggered.
 @param action context menu action that was triggered (QAction)
 """
-language = action.data()
+venvName = action.text()
-self.dbs.startClient(False, language)
+if venvName == self.tr("Project"):
+self.dbs.startClient(False, forProject=True)
+else:
+self.dbs.startClient(False, venvName=venvName)
 self.__getBanner()
 def handlePreferencesChanged(self):
 """
 Public slot to handle the preferencesChanged signal.
 Private method to search for the next occurrence.
 """
 if self.__lastSearch:
 self.searchNext(*self.__lastSearch)
-def searchNext(self, txt, caseSensitive, wholeWord):
+def searchNext(self, txt, caseSensitive, wholeWord, regexp):
 """
 Public method to search the next occurrence of the given text.
-@param txt text to search for (string)
+@param txt text to search for
+@type str
 @param caseSensitive flag indicating to perform a case sensitive
-search (boolean)
+search
+@type bool
 @param wholeWord flag indicating to search for whole words
-only (boolean)
+only
-"""
+@type bool
-self.__lastSearch = (txt, caseSensitive, wholeWord)
+@param regexp flag indicating a regular expression search
+@type bool
+"""
+self.__lastSearch = (txt, caseSensitive, wholeWord, regexp)
 ok = self.findFirst(
-txt, False, caseSensitive, wholeWord, True, forward=True)
+txt, regexp, caseSensitive, wholeWord, True, forward=True,
+posix=regexp)
 self.searchStringFound.emit(ok)
 def __searchPrev(self):
 """
 Private method to search for the next occurrence.
 """
 if self.__lastSearch:
 self.searchPrev(*self.__lastSearch)
-def searchPrev(self, txt, caseSensitive, wholeWord):
+def searchPrev(self, txt, caseSensitive, wholeWord, regexp):
 """
 Public method to search the previous occurrence of the given text.
-@param txt text to search for (string)
+@param txt text to search for
+@type str
 @param caseSensitive flag indicating to perform a case sensitive
-search (boolean)
+search
+@type bool
 @param wholeWord flag indicating to search for whole words
-only (boolean)
+only
-"""
+@type bool
-self.__lastSearch = (txt, caseSensitive, wholeWord)
+@param regexp flag indicating a regular expression search
+@type bool
+"""
+self.__lastSearch = (txt, caseSensitive, wholeWord, regexp)
 if self.hasSelectedText():
 line, index = self.getSelection()[:2]
 else:
 line, index = -1, -1
 ok = self.findFirst(
-txt, False, caseSensitive, wholeWord, True,
+txt, regexp, caseSensitive, wholeWord, True,
-forward=False, line=line, index=index)
+forward=False, line=line, index=index, posix=regexp)
 self.searchStringFound.emit(ok)
 def historyStyle(self):
 """
 Public method to get the shell history style.
 @return flag indicating if history is enabled
 @rtype bool
 """
 return self.__historyStyle != ShellHistoryStyle.Disabled
+#################################################################
+## Project Support
+#################################################################
+def __projectOpened(self):
+"""
+Private slot to start the shell for the opened project.
+"""
+if Preferences.getProject("RestartShellForProject"):
+self.dbs.startClient(False, forProject=True)
+self.__getBanner()
+def __projectClosed(self):
+"""
+Private slot to restart the default shell when the project is closed.
+"""
+if Preferences.getProject("RestartShellForProject"):
+self.dbs.startClient(False)
+self.__getBanner()

Mercurial Repositories > eric / file comparison

comparison: QScintilla/Shell.py

QScintilla/Shell.py