eric: comparison src/eric7/QScintilla/Shell.py

-:e440aaf179ce
+:64157aeb0312
 def showFind(self, txt=""):
 """
 Public method to display the search widget.
-@param txt text to be shown in the combo (string)
+@param txt text to be shown in the combo
+@type str
 """
 self.__searchWidget.showFind(txt)
 def shell(self):
 """
 Public method to get a reference to the shell widget.
-@return reference to the shell widget (Shell)
+@return reference to the shell widget
+@rtype Shell
 """
 return self.__shell
 class ShellHistoryStyle(enum.Enum):
 def __bindLexer(self, language="Python3"):
 """
 Private slot to set the lexer.
-@param language lexer language to set (string)
+@param language lexer language to set
+@type str
 """
 self.language = language
 if Preferences.getShell("SyntaxHighlightingEnabled"):
 self.lexer_ = Lexers.getLexer(self.language, self)
 else:
 def __setMonospaced(self, on):
 """
 Private method to set/reset a monospaced font.
-@param on flag to indicate usage of a monospace font (boolean)
+@param on flag to indicate usage of a monospace font
+@type bool
 """
 if on:
 if not self.lexer_:
 f = Preferences.getShell("MonospacedFont")
 self.monospacedStyles(f)
 def setDebuggerUI(self, ui):
 """
 Public method to set the debugger UI.
-@param ui reference to the debugger UI object (DebugUI)
+@param ui reference to the debugger UI object
+@type DebugUI
 """
 ui.exceptionInterrupt.connect(self.__writePrompt)
 self.registerDebuggerIdMethod(ui.getSelectedDebuggerId)
 def registerDebuggerIdMethod(self, method):
 def loadHistory(self, clientType):
 """
 Public method to load the history for the given client type.
-@param clientType type of the debug client (string)
+@param clientType type of the debug client
+@type str
 """
 hl = Preferences.getSettings().value("Shell/Histories/" + clientType)
 if hl is not None:
 self.__historyLists[clientType] = hl[-self.__maxHistoryEntries :]
 else:
 def saveHistory(self, clientType):
 """
 Public method to save the history for the given client type.
-@param clientType type of the debug client (string)
+@param clientType type of the debug client
+@type str
 """
 if clientType in self.__historyLists:
 Preferences.getSettings().setValue(
 "Shell/Histories/" + clientType, self.__historyLists[clientType]
 )
 def getHistory(self, clientType):
 """
 Public method to get the history for the given client type.
-@param clientType type of the debug client (string).
+@param clientType type of the debug client. If it is None, the current
-If it is None, the current history is returned.
+history is returned.
-@return reference to the history list (list of strings)
+@type str
+@return reference to the history list
+@rtype list of str
 """
 if clientType is None:
 return self.__history
 elif clientType in self.__historyLists:
 return self.__historyLists[clientType]
 def getClientType(self):
 """
 Public slot to get the clients type.
-@return client type (string)
+@return client type
+@rtype str
 """
 return self.clientType
 def __getBanner(self):
 """
 def __clientException(self, exceptionType, exceptionMessage, stackTrace):
 """
 Private method to handle an exception of the client.
-@param exceptionType type of exception raised (string)
+@param exceptionType type of exception raised
-@param exceptionMessage message given by the exception (string)
+@type str
-@param stackTrace list of stack entries (list of string)
+@param exceptionMessage message given by the exception
+@type str
+@param stackTrace list of stack entries
+@type list of str
 """
 self.__clientError()
 if (
 not self.__windowed
 def __clientSyntaxError(self, message, filename, lineNo, characterNo):
 """
 Private method to handle a syntax error in the debugged program.
-@param message message of the syntax error (string)
+@param message message of the syntax error
+@type str
 @param filename translated filename of the syntax error position
-(string)
+@type str
-@param lineNo line number of the syntax error position (integer)
+@param lineNo line number of the syntax error position
+@type int
 @param characterNo character number of the syntax error position
-(integer)
+@type int
 """
 self.__clientError()
 if not self.__windowed and Preferences.getDebugger("ShowExceptionInShell"):
 if message is None:
 def __getEndPos(self):
 """
 Private method to return the line and column of the last character.
-@return tuple of two values (int, int) giving the line and column
+@return tuple of two values giving the line and column
+@rtype tuple of (int, int)
 """
 line = self.lines() - 1
 return (line, len(self.text(line)))
 def __writeQueued(self, s):
 """
 Private method to display some text using a write queue.
-@param s text to be displayed (string)
+@param s text to be displayed
+@type str
 """
 self.queueText.emit(s)
 def __concatenateText(self, text):
 """
 def __writeStdOut(self, s):
 """
 Private method to display some text with StdOut label.
-@param s text to be displayed (string)
+@param s text to be displayed
+@type str
 """
 self.__write(self.tr("StdOut: {0}").format(s))
 def __writeStdErr(self, s):
 """
 Private method to display some text with StdErr label.
-@param s text to be displayed (string)
+@param s text to be displayed
+@type str
 """
 self.__write(self.tr("StdErr: {0}").format(s))
 def __raw_input(self, prompt, echo, debuggerId):
 """
 def __insertText(self, s):
 """
 Private method to insert some text at the current cursor position.
-@param s text to be inserted (string)
+@param s text to be inserted
+@type str
 """
 line, col = self.getCursorPosition()
 self.insertAt(Utilities.filterAnsiSequences(s), line, col)
 self.setCursorPosition(line, col + len(s))
 def __insertTextAtEnd(self, s):
 """
 Private method to insert some text at the end of the command line.
-@param s text to be inserted (string)
+@param s text to be inserted
+@type str
 """
 line, col = self.__getEndPos()
 self.setCursorPosition(line, col)
 self.insert(Utilities.filterAnsiSequences(s))
 self.prline, _ = self.getCursorPosition()
 def __insertTextNoEcho(self, s):
 """
 Private method to insert some text at the end of the buffer without
 echoing it.
-@param s text to be inserted (string)
+@param s text to be inserted
+@type str
 """
 self.buff += s
 self.prline, self.prcol = self.getCursorPosition()
 def mousePressEvent(self, event):
 """
 Protected method to handle the mouse press event.
-@param event the mouse press event (QMouseEvent)
+@param event the mouse press event
+@type QMouseEvent
 """
 self.setFocus(Qt.FocusReason.MouseFocusReason)
 if event.button() == Qt.MouseButton.MiddleButton:
 lines = QApplication.clipboard().text(QClipboard.Mode.Selection)
 self.paste(lines)
 def wheelEvent(self, evt):
 """
 Protected method to handle wheel events.
-@param evt reference to the wheel event (QWheelEvent)
+@param evt reference to the wheel event
+@type QWheelEvent
 """
 if evt.modifiers() & Qt.KeyboardModifier.ControlModifier:
 delta = evt.angleDelta().y()
 if delta < 0:
 self.zoomOut()
 def event(self, evt):
 """
 Public method handling events.
-@param evt reference to the event (QEvent)
+@param evt reference to the event
-@return flag indicating, if the event was handled (boolean)
+@type QEvent
+@return flag indicating, if the event was handled
+@rtype bool
 """
 if evt.type() == QEvent.Type.Gesture:
 self.gestureEvent(evt)
 return True
 def gestureEvent(self, evt):
 """
 Protected method handling gesture events.
 @param evt reference to the gesture event (QGestureEvent
+@type int
 """
 pinch = evt.gesture(Qt.GestureType.PinchGesture)
 if pinch:
 if pinch.state() == Qt.GestureState.GestureStarted:
 zoom = (self.getZoom() + 10) / 10.0
 def editorCommand(self, cmd):
 """
 Public method to perform an editor command.
 @param cmd the scintilla command to be performed
+@type int
 """
 try:
 self.supportedEditorCommands[cmd]()
 except TypeError:
 self.supportedEditorCommands[cmd](cmd)
 def __isCursorOnLastLine(self):
 """
 Private method to check, if the cursor is on the last line.
-@return flag indicating that the cursor is on the last line (boolean)
+@return flag indicating that the cursor is on the last line
+@rtype bool
 """
 cline, ccol = self.getCursorPosition()
 return cline == self.lines() - 1
 def keyPressEvent(self, ev):
 """
 Protected method to handle the user input a key at a time.
 @param ev key event (QKeyEvent)
+@type int
 """
 txt = ev.text()
 # See it is text to insert.
 if len(txt) and txt >= " ":
 def __QScintillaCommand(self, cmd):
 """
 Private method to send the command to QScintilla.
 @param cmd QScintilla command
+@type int
 """
 self.SendScintilla(cmd)
 def __QScintillaTab(self, cmd):
 """
 Private method to handle the Tab key.
 @param cmd QScintilla command
+@type int
 """
 if self.isListActive():
 self.SendScintilla(cmd)
 elif self.__isCursorOnLastLine():
 line, index = self.getCursorPosition()
 """
 Private method to handle a QScintilla delete command working to
 the left.
 @param method shell method to execute
+@type int
 """
 if self.__isCursorOnLastLine():
 line, col = self.getCursorPosition()
 db = 0
 ac = self.isListActive()
 def __QScintillaNewline(self, cmd):
 """
 Private method to handle the Return key.
 @param cmd QScintilla command
+@type int
 """
 if self.__isCursorOnLastLine():
 if self.isListActive():
 self.SendScintilla(cmd)
 else:
 def __QScintillaLeftCommand(self, method, allLinesAllowed=False):
 """
 Private method to handle a QScintilla command working to the left.
 @param method shell method to execute
+@type int
 @param allLinesAllowed flag indicating that the command may be executed
-on any line (boolean)
+on any line
+@type bool
 """
 if self.__isCursorOnLastLine() or allLinesAllowed:
 line, col = self.getCursorPosition()
 if self.text(line).startswith(sys.ps1):
 if col > len(sys.ps1):
 def __QScintillaRightCommand(self, method):
 """
 Private method to handle a QScintilla command working to the right.
 @param method shell method to execute
-"""
+@type function
+"""
+# TODO: check this!
 if self.__isCursorOnLastLine():
 method()
 else:
 method()
 def __QScintillaVCHome(self, cmd):
 """
 Private method to handle the Home key.
 @param cmd QScintilla command
+@type int
 """
 if self.isListActive():
 self.SendScintilla(cmd)
 elif self.__isCursorOnLastLine():
 line, col = self.getCursorPosition()
 def __QScintillaLineEnd(self, cmd):
 """
 Private method to handle the End key.
 @param cmd QScintilla command
+@type int
 """
 if self.isListActive():
 self.SendScintilla(cmd)
 elif self.__isCursorOnLastLine():
 self.moveCursorToEOL()
 def __QScintillaCursorCommand(self, cmd):
 """
 Private method to handle the cursor commands.
 @param cmd QScintilla command
+@type int
 """
 if self.isListActive() or self.isCallTipActive():
 if cmd in (QsciScintilla.SCI_LINEUP, QsciScintilla.SCI_LINEDOWN):
 self.SendScintilla(cmd)
 else:
 def __QScintillaLineUp(self, cmd):  # noqa: U100
 """
 Private method to handle the cursor up command.
 @param cmd QScintilla command
+@type int
 """
 self.SendScintilla(QsciScintilla.SCI_LINEUP)
 def __QScintillaLineDown(self, cmd):  # noqa: U100
 """
 Private method to handle the cursor down command.
 @param cmd QScintilla command
+@type int
 """
 self.SendScintilla(QsciScintilla.SCI_LINEDOWN)
 def __QScintillaHistoryUp(self, cmd):  # noqa: U100
 """
 Private method to handle the history up command.
 @param cmd QScintilla command
+@type int
 """
 if self.isHistoryEnabled():
 line, col = self.__getEndPos()
 buf = self.text(line)
 if buf.startswith(sys.ps1):
 def __QScintillaHistoryDown(self, cmd):  # noqa: U100
 """
 Private method to handle the history down command.
 @param cmd QScintilla command
+@type int
 """
 if self.isHistoryEnabled():
 line, col = self.__getEndPos()
 buf = self.text(line)
 if buf.startswith(sys.ps1):
 def __QScintillaAutoCompletionCommand(self, cmd):
 """
 Private method to handle a command for autocompletion only.
 @param cmd QScintilla command
+@type int
 """
 if self.isListActive() or self.isCallTipActive():
 self.SendScintilla(cmd)
 def __executeCommand(self, cmd, historyIndex=None):
 def __insertHistory(self, cmd):
 """
 Private method to insert a command selected from the history.
-@param cmd history entry to be inserted (string)
+@param cmd history entry to be inserted
+@type str
 """
 self.setCursorPosition(self.prline, self.prcol)
 self.setSelection(
 self.prline, self.prcol, self.prline, self.lineLength(self.prline)
 )
 While the user is entering a multi-line command, the movement to
 the next window by the Tab key being pressed is suppressed.
 @param nextChild next window
+@type QWidget
 @return flag indicating the movement
+@rtype bool
 """
 if nextChild and self.inContinue:
 return False
 return QsciScintillaCompat.focusNextPrevChild(self, nextChild)
 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)
+@param action context menu action that was triggered
+@type QAction
 """
 venvName = action.text()
 if venvName == self.tr("Project"):
 if self.__project.isOpen():
 self.__currentWorkingDirectory = self.__project.getProjectPath()
 @pyqtSlot(list, str)
 def __showCompletions(self, completions, text):
 """
 Private method to display the possible completions.
-@param completions list of possible completions (list of strings)
+@param completions list of possible completions
-@param text text that is about to be completed (string)
+@type list of str
+@param text text that is about to be completed
+@type str
 """
 if len(completions) == 0:
 return
 if len(completions) > 1:
 def __completionListSelected(self, listId, txt):
 """
 Private slot to handle the selection from the completion list.
-@param listId the ID of the user list (should be 1) (integer)
+@param listId the ID of the user list (should be 1)
-@param txt the selected text (string)
+@type int
+@param txt the selected text
+@type str
 """
 if listId == 1:
 if self.completionText != "":
 txt = txt.replace(self.completionText, "")
 self.__insertText(txt)
 def dragEnterEvent(self, event):
 """
 Protected method to handle the drag enter event.
-@param event the drag enter event (QDragEnterEvent)
+@param event the drag enter event
+@type QDragEnterEvent
 """
 self.inDragDrop = event.mimeData().hasUrls() or event.mimeData().hasText()
 if self.inDragDrop:
 event.acceptProposedAction()
 else:
 def dragMoveEvent(self, event):
 """
 Protected method to handle the drag move event.
-@param event the drag move event (QDragMoveEvent)
+@param event the drag move event
+@type QDragMoveEvent
 """
 if self.inDragDrop:
 event.accept()
 else:
 super().dragMoveEvent(event)
 def dragLeaveEvent(self, event):
 """
 Protected method to handle the drag leave event.
-@param event the drag leave event (QDragLeaveEvent)
+@param event the drag leave event
+@type QDragLeaveEvent
 """
 if self.inDragDrop:
 self.inDragDrop = False
 event.accept()
 else:
 def dropEvent(self, event):
 """
 Protected method to handle the drop event.
-@param event the drop event (QDropEvent)
+@param event the drop event
+@type QDropEvent
 """
 if event.mimeData().hasUrls() and not self.__windowed:
 for url in event.mimeData().urls():
 fname = url.toLocalFile()
 if fname:
 def focusInEvent(self, event):
 """
 Protected method called when the shell receives focus.
-@param event the event object (QFocusEvent)
+@param event the event object
+@type QFocusEvent
 """
 if not self.__actionsAdded:
 self.addActions(self.vm.editorActGrp.actions())
 self.addActions(self.vm.copyActGrp.actions())
 self.addActions(self.vm.viewActGrp.actions())
 def focusOutEvent(self, event):
 """
 Protected method called when the shell loses focus.
-@param event the event object (QFocusEvent)
+@param event the event object
+@type QFocusEvent
 """
 with contextlib.suppress(AttributeError):
 self.vm.editorActGrp.setEnabled(False)
 if not self.__windowed:
 self.__searchShortcut.setEnabled(False)
 """
 Public slot to insert text at the current cursor position.
 The cursor is advanced to the end of the inserted text.
-@param txt text to be inserted (string)
+@param txt text to be inserted
+@type str
 """
 txt = Utilities.filterAnsiSequences(txt)
 length = len(txt)
 line, col = self.getCursorPosition()
 self.insertAt(txt, line, col)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/QScintilla/Shell.py

src/eric7/QScintilla/Shell.py