eric: comparison eric6/QScintilla/Shell.py

-:866adc8c315b
+:0acf98cd089a
 import sys
 import re
 from enum import Enum
-from PyQt5.QtCore import pyqtSignal, QFileInfo, Qt, QEvent
+from PyQt5.QtCore import pyqtSignal, pyqtSlot, QFileInfo, Qt, QEvent
 from PyQt5.QtGui import QClipboard, QPalette, QFont
 from PyQt5.QtWidgets import (
 QDialog, QInputDialog, QApplication, QMenu, QWidget, QHBoxLayout,
 QVBoxLayout, QShortcut, QSizePolicy
 )
 dbs.clientException.connect(self.__clientException)
 dbs.clientSyntaxError.connect(self.__clientSyntaxError)
 dbs.clientSignal.connect(self.__clientSignal)
 self.dbs = dbs
+self.__debugUI = None
 # Initialize instance variables.
 self.__initialise()
 self.prline = 0
 self.prcol = 0
 self.inDragDrop = False
 Public method to set the debugger UI.
 @param ui reference to the debugger UI object (DebugUI)
 """
 ui.exceptionInterrupt.connect(self.__writePrompt)
+self.__debugUI = ui
 def __initialise(self):
 """
 Private method to get ready for a new remote interpreter.
 """
 self.buff = ""
 self.inContinue = False
-self.inRawMode = False
+self.__inRawMode = False
-self.echoInput = True
+self.__echoInput = True
+self.__rawModeDebuggerId = None
+self.__rawModeQueue = []
 self.clientCapabilities = 0
 self.inCommandExecution = False
 self.interruptCommandExecution = False
 def __clientCapabilities(self, cap, clType, venvName):
 if self.passive:
 self.__writeBanner('', '', '', '')
 else:
 self.dbs.remoteBanner()
-def __writeBanner(self, version, platform, dbgclient, venvName):
+def __writeBanner(self, version, platform, venvName):
 """
 Private method to write a banner with info from the debug client.
 @param version interpreter version string
 @type str
 @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 != "":
+if platform != "":
-self.__write(
+self.__write(self.tr('{0} on {1}').format(version, platform))
-self.tr('{0} on {1}, {2}')
-.format(version, platform, dbgclient))
 else:
 self.__write(version)
 if venvName:
 self.__write("\n[{0}]".format(venvName))
 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)
+@param more flag indicating that more user input is required
-"""
+@type bool
-if not self.inRawMode:
+"""
+if not self.__inRawMode:
 self.inContinue = more
 self.__writePrompt()
 self.inCommandExecution = False
 def __clientException(self, exceptionType, exceptionMessage, stackTrace):
 @param s text to be displayed (string)
 """
 self.__write(self.tr("StdErr: {0}").format(s))
-def __raw_input(self, prompt, echo):
+def __raw_input(self, prompt, echo, debuggerId):
 """
 Private method to handle raw input.
-@param prompt prompt to be displayed
+@param prompt the input prompt
 @type str
-@param echo Flag indicating echoing of the input
+@param echo flag indicating an echoing of the input
 @type bool
-"""
+@param debuggerId ID of the debugger backend
-self.setFocus()
+@type str
-self.inRawMode = True
+"""
-self.echoInput = echo
+if self.__inRawMode:
+# we are processing another raw input event already
-# Get all text which is still waiting for output
+self.__rawModeQueue.append((debuggerId, prompt, echo))
-QApplication.processEvents()
+else:
-self.__flushQueuedText()
+self.setFocus()
+self.__inRawMode = True
-self.__write(prompt)
+self.__echoInput = echo
-line, col = self.__getEndPos()
+self.__rawModeDebuggerId = debuggerId
-self.setCursorPosition(line, col)
-buf = self.text(line)
+# Get all text which is still waiting for output
-if buf.startswith(sys.ps1):
+QApplication.processEvents()
-buf = buf.replace(sys.ps1, "")
+self.__flushQueuedText()
-if buf.startswith(sys.ps2):
-buf = buf.replace(sys.ps2, "")
+self.__write(self.tr("<{0}> {1}").format(debuggerId, prompt))
-self.prompt = buf
+line, col = self.__getEndPos()
-# move cursor to end of line
+self.setCursorPosition(line, col)
-self.moveCursorToEOL()
+buf = self.text(line)
+if buf.startswith(sys.ps1):
-def paste(self):
+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, lines=None):
 """
 Public slot to handle the paste action.
+@param lines list of lines to be inserted
+@type list of str
 """
 if self.__isCursorOnLastLine():
 line, col = self.getCursorPosition()
 lastLine = self.text(line)
 if lastLine.startswith(sys.ps1):
 col = indexFrom
 self.setCursorPosition(line, len(prompt))
 self.deleteLineRight()
-lines = QApplication.clipboard().text()
+if lines is None:
+lines = QApplication.clipboard().text()
 lines = lastLine[:col] + lines + lastLine[col:]
 self.executeLines(lines)
 line, _ = self.getCursorPosition()
 pos = len(self.text(line)) - (len(lastLine) - col)
 self.setCursorPosition(line, pos)
-def __middleMouseButton(self):
-"""
-Private method to handle the middle mouse button press.
-"""
-lines = QApplication.clipboard().text(QClipboard.Selection)
-self.executeLines(lines)
 def executeLines(self, lines, historyIndex=None):
 """
 Public method to execute a set of lines as multiple commands.
 @param lines multiple lines of text to be executed as
 elif line.startswith(sys.ps2):
 line = line[len(sys.ps2) + indentLen:]
 else:
 line = line[indentLen:]
-if line.endswith("\r\n"):
+if line.endswith(("\r\n", "\r", "\n")):
 fullline = True
-cmd = line[:-2]
+cmd = line.rstrip()
-elif line.endswith("\r") or line.endswith("\n"):
-fullline = True
-cmd = line[:-1]
 else:
 fullline = False
 self.incrementalSearchActive = True
 self.__insertTextAtEnd(line)
 @param event the mouse press event (QMouseEvent)
 """
 self.setFocus()
 if event.button() == Qt.MidButton:
-self.__middleMouseButton()
+lines = QApplication.clipboard().text(QClipboard.Selection)
+self.paste(lines)
 else:
 super(Shell, self).mousePressEvent(event)
 def wheelEvent(self, evt):
 """
 if len(txt) and txt >= " ":
 if not self.__isCursorOnLastLine():
 line, col = self.__getEndPos()
 self.setCursorPosition(line, col)
 self.prline, self.prcol = self.getCursorPosition()
-if self.echoInput:
+if self.__echoInput:
 ac = self.isListActive()
 super(Shell, self).keyPressEvent(ev)
 self.incrementalSearchActive = True
 if ac and self.racEnabled:
-self.dbs.remoteCompletion(self.completionText + txt)
+self.dbs.remoteCompletion(
+self.__debugUI.getSelectedDebuggerId(),
+self.completionText + txt
+)
 else:
 self.__insertTextNoEcho(txt)
 else:
 ev.ignore()
 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)
+self.dbs.remoteCompletion(
+self.__debugUI.getSelectedDebuggerId(),
+buf
+)
 def __QScintillaLeftDeleteCommand(self, method):
 """
 Private method to handle a QScintilla delete command working to
 the left.
 elif col > 0:
 method()
 db = 1
 if db and ac and self.racEnabled and self.completionText:
 delta = len(self.text(line)) - oldLength
-self.dbs.remoteCompletion(self.completionText[:delta])
+self.dbs.remoteCompletion(
+self.__debugUI.getSelectedDebuggerId(),
+self.completionText[:delta]
+)
 def __QScintillaDeleteBack(self):
 """
 Private method to handle the Backspace key.
 """
 @param cmd command to be executed by debug client
 @type str
 @param historyIndex history index to be set
 @type int
 """
-if not self.inRawMode:
+if not self.__inRawMode:
 self.inCommandExecution = True
 self.interruptCommandExecution = False
 if not cmd:
 # make sure cmd is a string
 cmd = ''
 ):
 # call main window quit()
 self.vm.quit()
 return
-self.dbs.remoteStatement(cmd)
+self.dbs.remoteStatement(self.__debugUI.getSelectedDebuggerId(),
+cmd)
 while self.inCommandExecution:
 try:
 QApplication.processEvents()
 except KeyboardInterrupt:
 pass
 else:
-if not self.echoInput:
+if not self.__echoInput:
 cmd = self.buff
 self.buff = ""
 elif cmd:
 cmd = cmd[len(self.prompt):]
-self.inRawMode = False
+self.__inRawMode = False
-self.echoInput = True
+self.__echoInput = True
-self.dbs.remoteRawInput(cmd)
+self.dbs.remoteRawInput(self.__rawModeDebuggerId, cmd)
+if self.__rawModeQueue:
+debuggerId, prompt, echo = self.__rawModeQueue.pop(0)
+self.__raw_input(prompt, echo, debuggerId)
 def __showVenvName(self):
 """
 Private method to show the name of the active virtual environment.
 """
 self.dbs.clientProcessStderr.connect(self.__writeStdErr)
 else:
 self.dbs.clientProcessStdout.disconnect(self.__writeStdOut)
 self.dbs.clientProcessStderr.disconnect(self.__writeStdErr)
 self.__showStdOutErr = showStdOutErr
+@pyqtSlot(list, str)
 def __showCompletions(self, completions, text):
 """
 Private method to display the possible completions.
 @param completions list of possible completions (list of strings)

Mercurial Repositories > eric / file comparison

comparison: eric6/QScintilla/Shell.py

eric6/QScintilla/Shell.py