eric: comparison eric6/QScintilla/Shell.py

-:e01ae92db699
+:31965986ecd1
 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,
+self.__searchWidget.setSizePolicy(QSizePolicy.Policy.Fixed,
-QSizePolicy.Preferred)
+QSizePolicy.Policy.Preferred)
 self.__searchWidget.hide()
 if horizontal:
 self.__layout = QHBoxLayout(self)
 else:
 """ 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. 'restart' kills"""
+"""<p>The shell has some special commands. '%restart' kills"""
-""" the shell and starts a new one. 'clear' clears the"""
+""" the shell and starts a new one. '%clear' clears the"""
-""" display of the shell window. 'start' is used to start a"""
+""" display of the shell window. '%start' is used to start a"""
 """ shell for a virtual environment and should be followed"""
-""" by a virtual environment name. start' without a virtual"""
+""" by a virtual environment name. '%start' without a"""
-""" environment name starts the default shell. Available"""
+""" virtual environment name starts the default shell."""
-""" virtual environments may be listed with the 'envs' or"""
+""" Available virtual environments may be listed with the"""
-""" 'environments' commands. The active virtual environment"""
+""" '%envs' or '%environments' commands. The active virtual"""
-""" can be questioned by the 'which' command. 'quit' or"""
+""" environment can be questioned by the '%which' command."""
-""" 'exit' is used to exit the application. These commands"""
+""" '%quit' or '%exit' is used to exit the application."""
-""" (except environments', 'envs' and 'which') are available"""
+""" These commands (except '%environments', '%envs' and"""
-""" through the window menus as well.</p>"""
+""" '%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. 'restart' kills"""
+"""<p>The shell has some special commands. '%restart' kills"""
-""" the shell and starts a new one. 'clear' clears the"""
+""" the shell and starts a new one. '%clear' clears the"""
-""" display of the shell window. 'start' is used to start a"""
+""" display of the shell window. '%start' is used to start a"""
 """ shell for a virtual environment and should be followed"""
-""" by a virtual environment name. start' without a virtual"""
+""" by a virtual environment name. '%start' without a"""
-""" environment name starts the default shell. Available"""
+""" virtual environment name starts the default shell."""
-""" virtual environments may be listed with the 'envs' or"""
+""" Available virtual environments may be listed with the"""
-""" 'environments' commands. The active virtual environment"""
+""" '%envs' or '%environments' commands. The active virtual"""
-""" can be questioned by the 'which' command. These commands"""
+""" environment can be questioned by the '%which' command."""
-""" (except environments' and 'envs') are available through"""
+""" These commands (except '%environments' and '%envs') are"""
-""" the context menu as well.</p>"""
+""" 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"""
 Preferences.getShell("HistoryNavigateByCursor")
 )
 self.__queuedText = ''
 self.__blockTextProcessing = False
-self.queueText.connect(self.__concatenateText, Qt.QueuedConnection)
+self.queueText.connect(self.__concatenateText,
+Qt.ConnectionType.QueuedConnection)
 self.__project = project
 if self.__project:
 self.__project.projectOpened.connect(self.__projectOpened)
 self.__project.projectClosed.connect(self.__projectClosed)
-self.grabGesture(Qt.PinchGesture)
+self.grabGesture(Qt.GestureType.PinchGesture)
 def __showStartMenu(self):
 """
 Private slot to prepare the start submenu.
 """
 """
 Private method to configure the text display.
 """
 self.setTabWidth(Preferences.getEditor("TabWidth"))
 if Preferences.getEditor("ShowWhitespace"):
-self.setWhitespaceVisibility(QsciScintilla.WsVisible)
+self.setWhitespaceVisibility(
+QsciScintilla.WhitespaceVisibility.WsVisible)
 try:
 self.setWhitespaceForegroundColor(
 Preferences.getEditorColour("WhitespaceForeground"))
 self.setWhitespaceBackgroundColor(
 Preferences.getEditorColour("WhitespaceBackground"))
 Preferences.getEditor("WhitespaceSize"))
 except AttributeError:
 # QScintilla before 2.5 doesn't support this
 pass
 else:
-self.setWhitespaceVisibility(QsciScintilla.WsInvisible)
+self.setWhitespaceVisibility(
+QsciScintilla.WhitespaceVisibility.WsInvisible)
 self.setEolVisibility(Preferences.getEditor("ShowEOL"))
 if Preferences.getEditor("BraceHighlighting"):
-self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
+self.setBraceMatching(QsciScintilla.BraceMatch.SloppyBraceMatch)
 else:
-self.setBraceMatching(QsciScintilla.NoBraceMatch)
+self.setBraceMatching(QsciScintilla.BraceMatch.NoBraceMatch)
 self.setMatchedBraceForegroundColor(
 Preferences.getEditorColour("MatchingBrace"))
 self.setMatchedBraceBackgroundColor(
 Preferences.getEditorColour("MatchingBraceBack"))
 self.setUnmatchedBraceForegroundColor(
 if Preferences.getEditor("CustomSelectionColours"):
 self.setSelectionBackgroundColor(
 Preferences.getEditorColour("SelectionBackground"))
 else:
 self.setSelectionBackgroundColor(
-QApplication.palette().color(QPalette.Highlight))
+QApplication.palette().color(QPalette.ColorRole.Highlight))
 if Preferences.getEditor("ColourizeSelText"):
 self.resetSelectionForegroundColor()
 elif Preferences.getEditor("CustomSelectionColours"):
 self.setSelectionForegroundColor(
 Preferences.getEditorColour("SelectionForeground"))
 else:
 self.setSelectionForegroundColor(
-QApplication.palette().color(QPalette.HighlightedText))
+QApplication.palette().color(
+QPalette.ColorRole.HighlightedText))
 self.setSelectionToEol(Preferences.getEditor("ExtendSelectionToEol"))
 self.setCaretForegroundColor(
 Preferences.getEditorColour("CaretForeground"))
 self.setCaretLineVisible(False)
 self.caretWidth = Preferences.getEditor("CaretWidth")
 self.setCaretWidth(self.caretWidth)
 if Preferences.getShell("WrapEnabled"):
-self.setWrapMode(QsciScintilla.WrapWord)
+self.setWrapMode(QsciScintilla.WrapMode.WrapWord)
 else:
-self.setWrapMode(QsciScintilla.WrapNone)
+self.setWrapMode(QsciScintilla.WrapMode.WrapNone)
 self.useMonospaced = Preferences.getShell("UseMonospacedFont")
 self.__setMonospaced(self.useMonospaced)
 self.setCursorFlashTime(QApplication.cursorFlashTime())
 Preferences.getEditorColour("CallTipsForeground"))
 self.setCallTipsHighlightColor(
 Preferences.getEditorColour("CallTipsHighlight"))
 self.setCallTipsVisible(Preferences.getEditor("CallTipsVisible"))
 calltipsStyle = Preferences.getEditor("CallTipsStyle")
-if calltipsStyle == QsciScintilla.CallTipsNoContext:
+if calltipsStyle == QsciScintilla.CallTipsStyle.CallTipsNoContext:
-self.setCallTipsStyle(QsciScintilla.CallTipsNoContext)
+self.setCallTipsStyle(
+QsciScintilla.CallTipsStyle.CallTipsNoContext)
 elif (
 calltipsStyle ==
-QsciScintilla.CallTipsNoAutoCompletionContext
+QsciScintilla.CallTipsStyle.CallTipsNoAutoCompletionContext
 ):
 self.setCallTipsStyle(
-QsciScintilla.CallTipsNoAutoCompletionContext)
+QsciScintilla.CallTipsStyle
+.CallTipsNoAutoCompletionContext)
 else:
-self.setCallTipsStyle(QsciScintilla.CallTipsContext)
+self.setCallTipsStyle(
-else:
+QsciScintilla.CallTipsStyle.CallTipsContext)
-self.setCallTipsStyle(QsciScintilla.CallTipsNone)
+else:
+self.setCallTipsStyle(QsciScintilla.CallTipsStyle.CallTipsNone)
 def setDebuggerUI(self, ui):
 """
 Public method to set the debugger UI.
 """
 Public slot to show the shell history dialog.
 """
 from .ShellHistoryDialog import ShellHistoryDialog
 dlg = ShellHistoryDialog(self.__history, self.vm, self)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 self.__historyLists[self.clientType], idx = dlg.getHistory()
 self.__history = self.__historyLists[self.clientType]
 self.__setHistoryIndex(index=idx)
 def clearAllHistories(self):
 Protected method to handle the mouse press event.
 @param event the mouse press event (QMouseEvent)
 """
 self.setFocus()
-if event.button() == Qt.MidButton:
+if event.button() == Qt.MouseButton.MidButton:
-lines = QApplication.clipboard().text(QClipboard.Selection)
+lines = QApplication.clipboard().text(QClipboard.Mode.Selection)
 self.paste(lines)
 else:
 super(Shell, self).mousePressEvent(event)
 def wheelEvent(self, evt):
 """
 Protected method to handle wheel events.
 @param evt reference to the wheel event (QWheelEvent)
 """
-if evt.modifiers() & Qt.ControlModifier:
+if evt.modifiers() & Qt.KeyboardModifier.ControlModifier:
 delta = evt.angleDelta().y()
 if delta < 0:
 self.zoomOut()
 elif delta > 0:
 self.zoomIn()
 Public method handling events.
 @param evt reference to the event (QEvent)
 @return flag indicating, if the event was handled (boolean)
 """
-if evt.type() == QEvent.Gesture:
+if evt.type() == QEvent.Type.Gesture:
 self.gestureEvent(evt)
 return True
 return super(Shell, self).event(evt)
 """
 Protected method handling gesture events.
 @param evt reference to the gesture event (QGestureEvent
 """
-pinch = evt.gesture(Qt.PinchGesture)
+pinch = evt.gesture(Qt.GestureType.PinchGesture)
 if pinch:
-if pinch.state() == Qt.GestureStarted:
+if pinch.state() == Qt.GestureState.GestureStarted:
 zoom = (self.getZoom() + 10) / 10.0
 pinch.setTotalScaleFactor(zoom)
-elif pinch.state() == Qt.GestureUpdated:
+elif pinch.state() == Qt.GestureState.GestureUpdated:
 zoom = int(pinch.totalScaleFactor() * 10) - 10
 if zoom <= -9:
 zoom = -9
 pinch.setTotalScaleFactor(0.1)
 elif zoom >= 20:
 ):
 self.__setHistoryIndex(index=-1)
 else:
 self.__setHistoryIndex(historyIndex)
-if cmd == 'start' or cmd.startswith('start '):
+if cmd.startswith("%"):
-if not self.passive:
+if cmd == '%start' or cmd.startswith('%start '):
-cmdList = cmd.split(None, 1)
+if not self.passive:
-if len(cmdList) < 2:
+cmdList = cmd.split(None, 1)
-self.dbs.startClient(False)  # start default backend
+if len(cmdList) < 2:
+self.dbs.startClient(False)
+# start default backend
+else:
+venvName = cmdList[1]
+if venvName == self.tr("Project"):
+if self.__project.isOpen():
+self.dbs.startClient(
+False,
+forProject=True,
+workingDir=self.__project
+.getProjectPath()
+)
+self.__currentWorkingDirectory = (
+self.__project.getProjectPath()
+)
+else:
+self.dbs.startClient(
+False,
+venvName=self.__currentVenv,
+workingDir=self
+.__currentWorkingDirectory
+)
+# same as reset
+else:
+self.dbs.startClient(False, venvName=venvName)
+self.__currentWorkingDirectory = ""
+self.__getBanner()
+return
+elif cmd == '%clear':
+# Display the banner.
+self.__getBanner()
+if not self.passive:
+return
 else:
-venvName = cmdList[1]
+cmd = ''
-if venvName == self.tr("Project"):
+elif cmd in ['%reset', '%restart']:
-if self.__project.isOpen():
+self.dbs.startClient(
-self.dbs.startClient(
+False, venvName=self.__currentVenv,
-False, forProject=True,
+workingDir=self.__currentWorkingDirectory)
-workingDir=self.__project.getProjectPath())
+if self.passive:
-self.__currentWorkingDirectory = (
+return
-self.__project.getProjectPath()
+else:
-)
+cmd = ''
-else:
+elif cmd in ['%envs', '%environments']:
-self.dbs.startClient(
+venvs = (
-False, venvName=self.__currentVenv,
+e5App().getObject("VirtualEnvManager")
-workingDir=self.__currentWorkingDirectory)
+.getVirtualenvNames()
-# same as reset
+)
-else:
+s = (
-self.dbs.startClient(False, venvName=venvName)
+self.tr('Available Virtual Environments:\n{0}\n')
-self.__currentWorkingDirectory = ""
+.format('\n'.join(
-self.__getBanner()
+"- {0}".format(venv)
+for venv in sorted(venvs)
+))
+)
+self.__write(s)
+self.__clientStatement(False)
 return
-elif cmd == 'clear':
+elif cmd == '%which':
-# Display the banner.
+s = self.tr("Current Virtual Environment: '{0}'\n").format(
-self.__getBanner()
+self.__currentVenv)
-if not self.passive:
+self.__write(s)
+self.__clientStatement(False)
 return
-else:
+elif (
-cmd = ''
+cmd in ["%quit", "%quit()", "%exit", "%exit()"] and
-elif cmd in ['reset', 'restart']:
+self.__windowed
-self.dbs.startClient(False, venvName=self.__currentVenv,
+):
-workingDir=self.__currentWorkingDirectory)
+# call main window quit()
-if self.passive:
+self.vm.quit()
 return
 else:
-cmd = ''
+self.dbs.remoteStatement(
-elif cmd in ['envs', 'environments']:
+self.__debugUI.getSelectedDebuggerId(), cmd)
-venvs = (
+while self.inCommandExecution:
-e5App().getObject("VirtualEnvManager")
+try:
-.getVirtualenvNames()
+QApplication.processEvents()
-)
+except KeyboardInterrupt:
-s = self.tr('Available Virtual Environments:\n{0}\n').format(
+pass
-'\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(self.__debugUI.getSelectedDebuggerId(),
-cmd)
-while self.inCommandExecution:
-try:
-QApplication.processEvents()
-except KeyboardInterrupt:
-pass
 else:
 if not self.__echoInput:
 cmd = self.buff
 self.buff = ""
 elif cmd:
 Private slot to restart the default shell when the project is closed.
 """
 if Preferences.getProject("RestartShellForProject"):
 self.dbs.startClient(False)
 self.__getBanner()
+#
+# eflag: noqa = M601

Mercurial Repositories > eric / file comparison

comparison: eric6/QScintilla/Shell.py

eric6/QScintilla/Shell.py