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

-:e440aaf179ce
+:64157aeb0312
 def editorCommand(self, cmd):
 """
 Public method to perform a simple editor command.
-@param cmd the scintilla command to be performed (integer)
+@param cmd the scintilla command to be performed
+@type int
 """
 if cmd == QsciScintilla.SCI_DELETEBACK:
 line, index = self.getCursorPosition()
 text = self.text(line)[index - 1 : index + 1]
 matchingPairs = ["()", "[]", "{}", "<>", "''", '""']
 def __init__(self, filename="", filetype="", parent=None, name=None):
 """
 Constructor
-@param filename name of the file to open (string)
+@param filename name of the file to open
-@param filetype type of the source file (string)
+@type str
-@param parent reference to the parent widget (QWidget)
+@param filetype type of the source file
-@param name object name of the window (string)
+@type str
+@param parent reference to the parent widget
+@type QWidget
+@param name object name of the window
+@type str
 """
 super().__init__(parent)
 if name is not None:
 self.setObjectName(name)
 self.setWindowIcon(EricPixmapCache.getIcon("editor"))
 def closeEvent(self, event):
 """
 Protected method to handle the close event.
-@param event close event (QCloseEvent)
+@param event close event
+@type QCloseEvent
 """
 if self.__maybeSave():
 self.__writeSettings()
 event.accept()
 else:
 def __save(self):
 """
 Private slot to save a file.
-@return flag indicating success (boolean)
+@return flag indicating success
+@rtype bool
 """
 if not self.__curFile:
 return self.__saveAs()
 else:
 return self.__saveFile(self.__curFile)
 def __saveAs(self):
 """
 Private slot to save a file with a new name.
-@return flag indicating success (boolean)
+@return flag indicating success
+@rtype bool
 """
 fileName = EricFileDialog.getSaveFileName(self)
 if not fileName:
 return False
 """
 Private slot to check some actions for their enable/disable status
 and set the statusbar info.
 @param setSb flag indicating an update of the status bar is wanted
-(boolean)
+@type bool
 """
 self.saveAct.setEnabled(self.__textEdit.isModified())
 self.undoAct.setEnabled(self.__textEdit.isUndoAvailable())
 self.redoAct.setEnabled(self.__textEdit.isRedoAvailable())
 def __readShortcut(self, act, category):
 """
 Private function to read a single keyboard shortcut from the settings.
-@param act reference to the action object (EricAction)
+@param act reference to the action object
-@param category category the action belongs to (string)
+@type EricAction
+@param category category the action belongs to
+@type str
 """
 if act.objectName():
 accel = Preferences.getSettings().value(
 "Shortcuts/{0}/{1}/Accel".format(category, act.objectName())
 )
 def __maybeSave(self):
 """
 Private method to ask the user to save the file, if it was modified.
-@return flag indicating, if it is ok to continue (boolean)
+@return flag indicating, if it is ok to continue
+@rtype bool
 """
 if self.__textEdit.isModified():
 ret = EricMessageBox.okToClearData(
 self,
 self.tr("eric Mini Editor"),
 def __loadFile(self, fileName, filetype=None):
 """
 Private method to load the given file.
-@param fileName name of the file to load (string)
+@param fileName name of the file to load
-@param filetype type of the source file (string)
+@type str
+@param filetype type of the source file
+@type str
 """
 self.__loadEditorConfig(fileName=fileName)
 try:
 with EricOverrideCursor():
 def __setCurrentFile(self, fileName):
 """
 Private method to register the file name of the current file.
-@param fileName name of the file to register (string)
+@param fileName name of the file to register
+@type str
 """
 self.__curFile = fileName
 shownName = (
 self.tr("Untitled")
 def getFileName(self):
 """
 Public method to return the name of the file being displayed.
-@return filename of the displayed file (string)
+@return filename of the displayed file
+@rtype str
 """
 return self.__curFile
 def __strippedName(self, fullFileName):
 """
 Private method to return the filename part of the given path.
-@param fullFileName full pathname of the given file (string)
+@param fullFileName full pathname of the given file
-@return filename part (string)
+@type str
+@return filename part
+@rtype str
 """
 return pathlib.Path(fullFileName).name
 def __modificationChanged(self, m):
 """
 Private slot to handle the modificationChanged signal.
 @param m modification status
+@type bool
 """
 self.setWindowModified(m)
 self.__checkActions()
 def __cursorPositionChanged(self, line, pos):
 """
 Private slot to handle the cursorPositionChanged signal.
 @param line line number of the cursor
+@type int
 @param pos position in line of the cursor
+@type int
 """
 lang = self.getLanguage()
 self.__setSbFile(line + 1, pos, lang)
 if Preferences.getEditor("MarkOccurrencesEnabled"):
 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.getEditorOtherFonts("MonospacedFont")
 self.__textEdit.monospacedStyles(f)
 def __printPreview(self, printer):
 """
 Private slot to generate a print preview.
 @param printer reference to the printer object
-(QScintilla.Printer.Printer)
+@type QScintilla.Printer.Printer
 """
 printer.printRange(self.__textEdit)
 #########################################################
 ## Methods needed by the context menu
 def __contextMenuRequested(self, coord):
 """
 Private slot to show the context menu.
-@param coord the position of the mouse pointer (QPoint)
+@param coord the position of the mouse pointer
+@type QPoint
 """
 self.contextMenu.popup(self.mapToGlobal(coord))
 def __initContextMenu(self):
 """
 def __initContextMenuLanguages(self):
 """
 Private method used to setup the Languages context sub menu.
-@return reference to the generated menu (QMenu)
+@return reference to the generated menu
+@rtype QMenu
 """
 menu = QMenu(self.tr("Languages"))
 self.languagesActGrp = QActionGroup(self)
 self.noLanguageAct = menu.addAction(self.tr("No Language"))
 def __showLanguagesMenu(self, pos):
 """
 Private slot to show the Languages menu of the status bar.
-@param pos position the menu should be shown at (QPoint)
+@param pos position the menu should be shown at
+@type QPoint
 """
 self.languagesMenu.exec(pos)
 def __selectPygmentsLexer(self):
 """
 def __languageMenuTriggered(self, act):
 """
 Private method to handle the selection of a lexer language.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 if act == self.noLanguageAct:
 self.__resetLanguage()
 elif act == self.pygmentsAct:
 self.setLanguage("dummy.pygments")
 def setLanguage(self, filename, initTextDisplay=True, pyname=""):
 """
 Public method to set a lexer language.
 @param filename filename used to determine the associated lexer
-language (string)
+language
+@type str
 @param initTextDisplay flag indicating an initialization of the text
-display is required as well (boolean)
+display is required as well
-@param pyname name of the pygments lexer to use (string)
+@type bool
+@param pyname name of the pygments lexer to use
+@type str
 """
 self.__bindLexer(filename, pyname=pyname)
 self.__textEdit.recolor()
 self.__checkLanguage()
 def __bindLexer(self, filename, pyname=""):
 """
 Private slot to set the correct lexer depending on language.
 @param filename filename used to determine the associated lexer
-language (string)
+language
-@param pyname name of the pygments lexer to use (string)
+@type str
+@param pyname name of the pygments lexer to use
+@type str
 """
 if self.lexer_ is not None and (
 self.lexer_.lexer() == "container" or self.lexer_.lexer() is None
 ):
 self.__textEdit.SCN_STYLENEEDED.disconnect(self.__styleNeeded)
 def __styleNeeded(self, position):
 """
 Private slot to handle the need for more styling.
-@param position end position, that needs styling (integer)
+@param position end position, that needs styling
+@type int
 """
 self.lexer_.styleText(self.__textEdit.getEndStyled(), position)
 def __bindName(self, line0):
 """
 Private method to generate a dummy filename for binding a lexer.
 @param line0 first line of text to use in the generation process
-(string)
+@type str
-@return dummy file name to be used for binding a lexer (string)
+@return dummy file name to be used for binding a lexer
+@rtype str
 """
 bindName = ""
 line0 = line0.lower()
 # check first line if it does not start with #!
 def getSRHistory(self, key):
 """
 Public method to get the search or replace history list.
 @param key list to return (must be 'search' or 'replace')
-@return the requested history list (list of strings)
+@type str
+@return the requested history list
+@rtype list of str
 """
 return self.srHistory[key][:]
 def textForFind(self):
 """
 Public method to determine the selection or the current word for the
 next find operation.
-@return selection or current word (string)
+@return selection or current word
+@rtype str
 """
 if self.__textEdit.hasSelectedText():
 text = self.__textEdit.selectedText()
 if "\r" in text or "\n" in text:
 # the selection contains at least a newline, it is
 def __getCurrentWord(self):
 """
 Private method to get the word at the current position.
 @return the word at that current position
+@rtype str
 """
 line, index = self.getCursorPosition()
 return self.__getWord(line, index)
 def showSearchWidget(self):
 def activeWindow(self):
 """
 Public method to fulfill the ViewManager interface.
-@return reference to the text edit component (QsciScintillaCompat)
+@return reference to the text edit component
+@rtype QsciScintillaCompat
 """
 return self.__textEdit
 def setSearchIndicator(self, startPos, indicLength):
 """
 Public method to set a search indicator for the given range.
-@param startPos start position of the indicator (integer)
+@param startPos start position of the indicator
-@param indicLength length of the indicator (integer)
+@type int
+@param indicLength length of the indicator
+@type int
 """
 self.__textEdit.setIndicatorRange(self.searchIndicator, startPos, indicLength)
 def clearSearchIndicators(self):
 """
 def setText(self, txt, filetype=None):
 """
 Public method to set the text programatically.
-@param txt text to be set (string)
+@param txt text to be set
-@param filetype type of the source file (string)
+@type str
+@param filetype type of the source file
+@type str
 """
 self.__textEdit.setText(txt)
 if filetype is None:
 self.filetype = ""
 def __zoomTo(self, value):
 """
 Private slot to zoom to a given value.
-@param value zoom value to be set (integer)
+@param value zoom value to be set
+@type int
 """
 self.zoomTo(value)
 self.sbZoom.setValue(self.getZoom())

Mercurial Repositories > eric / file comparison

comparison: src/eric7/QScintilla/MiniEditor.py

src/eric7/QScintilla/MiniEditor.py