Selection Encloser Tool: comparison PluginSelectionEncloser.py

-:face142f8fa5
+:318d7ebbdce2
 import contextlib
 import os
 import json
-from PyQt5.QtCore import QObject, QTranslator, QCoreApplication
+from PyQt6.QtCore import pyqtSlot, QObject, QTranslator, QCoreApplication
-from PyQt5.QtWidgets import QAction, QMenu
+from PyQt6.QtGui import QAction
+from PyQt6.QtWidgets import QMenu
-from E5Gui.E5Application import e5App
+from EricWidgets.EricApplication import ericApp
 import Preferences
 # Start-Of-Header
 name = "Selection Encloser Plug-in"
 author = "Detlev Offenbach <detlev@die-offenbachs.de>"
 autoactivate = True
 deactivateable = True
-version = "3.2.1"
+version = "1.0.0"
 className = "SelectionEncloserPlugin"
 packageName = "SelectionEncloser"
 shortDescription = "Enclose the selection with a string."
 longDescription = (
 """This plug-in implements a tool to enclose the selection of"""
 def createSelectionEncloserPage(configDlg):
 """
 Module function to create the Selection Encloser configuration page.
 @param configDlg reference to the configuration dialog
+@type ConfigurationWidget
 @return reference to the configuration page
+@rtype SelectionEncloserPage
 """
 global selectionEncloserPluginObject
 from SelectionEncloser.ConfigurationPage.SelectionEncloserPage import (
 SelectionEncloserPage
 )
 def getConfigData():
 """
 Module function returning data as required by the configuration dialog.
 @return dictionary containing the relevant data
-"""
+@rtype dict
-try:
+"""
-usesDarkPalette = e5App().usesDarkPalette()
+usesDarkPalette = ericApp().usesDarkPalette()
-except AttributeError:
-# for eric6 < 20.4
-from PyQt5.QtGui import QPalette
-palette = e5App().palette()
-lightness = palette.color(QPalette.Window).lightness()
-usesDarkPalette = lightness <= 128
 iconSuffix = "dark" if usesDarkPalette else "light"
 return {
 "selectionEncloserPage": [
 QCoreApplication.translate("SelectionEncloserPlugin",
 def __init__(self, ui):
 """
 Constructor
-@param ui reference to the user interface object (UI.UserInterface)
+@param ui reference to the user interface object
+@type UserInterface
 """
 super().__init__(ui)
 self.__ui = ui
 # menu is a list of lists; each list consists of a string for the
 def activate(self):
 """
 Public method to activate this plugin.
-@return tuple of None and activation status (boolean)
+@return tuple of None and activation status
+@rtype (None, bool)
 """
 global error
 error = ""     # clear previous error
 global selectionEncloserPluginObject
 act = menu.addSeparator()
 self.__mainActions.append(act)
 act = menu.addMenu(self.__menu)
 self.__mainActions.append(act)
-e5App().getObject("ViewManager").editorOpenedEd.connect(
+ericApp().getObject("ViewManager").editorOpenedEd.connect(
 self.__editorOpened)
-e5App().getObject("ViewManager").editorClosedEd.connect(
+ericApp().getObject("ViewManager").editorClosedEd.connect(
 self.__editorClosed)
-for editor in e5App().getObject("ViewManager").getOpenEditors():
+for editor in ericApp().getObject("ViewManager").getOpenEditors():
 self.__editorOpened(editor)
 return None, True
 def deactivate(self):
 if menu is not None:
 for act in self.__mainActions:
 menu.removeAction(act)
 self.__mainActions = []
-e5App().getObject("ViewManager").editorOpenedEd.disconnect(
+ericApp().getObject("ViewManager").editorOpenedEd.disconnect(
 self.__editorOpened)
-e5App().getObject("ViewManager").editorClosedEd.disconnect(
+ericApp().getObject("ViewManager").editorClosedEd.disconnect(
 self.__editorClosed)
 for editor, acts in self.__editors.items():
 editor.showMenu.disconnect(self.__editorShowMenu)
 menu = editor.getMenu("Tools")
 translation = "selectionencloser_{0}".format(loc)
 translator = QTranslator(None)
 loaded = translator.load(translation, locale_dir)
 if loaded:
 self.__translator = translator
-e5App().installTranslator(self.__translator)
+ericApp().installTranslator(self.__translator)
 else:
 print("Warning: translation file '{0}' could not be"
 " loaded.".format(translation))
 print("Using default.")
 def getPreferences(self, key):
 """
 Public method to retrieve the various settings.
-@param key the key of the value to get (string)
+@param key key of the value to get
-@return the requested setting
+@type str
+@return value of the requested setting
+@rtype Any
 """
 if key in ["MenuHierarchy"]:
 return json.loads(
 Preferences.Prefs.settings.value(
 self.PreferencesKey + "/" + key, self.__defaults[key]))
 def setPreferences(self, key, value):
 """
 Public method to store the various settings.
-@param key the key of the setting to be set (string)
+@param key key of the setting to be set
-@param value the value to be set
+@type str
+@param value value to be set
+@type Any
 """
 if key in ["MenuHierarchy"]:
 Preferences.Prefs.settings.setValue(
 self.PreferencesKey + "/" + key, json.dumps(value))
 else:
 def __populateMenu(self, name, menu):
 """
 Private slot to populate the tools menu with our entry.
-@param name name of the menu (string)
+@param name name of the menu
-@param menu reference to the menu to be populated (QMenu)
+@type str
+@param menu reference to the menu to be populated
+@type QMenu
 """
 if name not in ["Tools", "PluginTools"]:
 return
-editor = e5App().getObject("ViewManager").activeWindow()
+editor = ericApp().getObject("ViewManager").activeWindow()
 if name == "Tools":
 if not menu.isEmpty():
 menu.addSeparator()
 act = menu.addMenu(self.__menu)
 def __editorOpened(self, editor):
 """
 Private slot called, when a new editor was opened.
-@param editor reference to the new editor (QScintilla.Editor)
+@param editor reference to the new editor
+@type Editor
 """
 menu = editor.getMenu("Tools")
 if menu is not None:
 self.__editors[editor] = []
 if not menu.isEmpty():
 def __editorClosed(self, editor):
 """
 Private slot called, when an editor was closed.
-@param editor reference to the editor (QScintilla.Editor)
+@param editor reference to the editor
+@type Editor
 """
 with contextlib.suppress(KeyError):
 del self.__editors[editor]
 if not self.__editors:
 self.__menu.setEnabled(False)
 def __editorShowMenu(self, menuName, menu, editor):
 """
 Private slot called, when the the editor context menu or a submenu is
 about to be shown.
-@param menuName name of the menu to be shown (string)
+@param menuName name of the menu to be shown
-@param menu reference to the menu (QMenu)
+@type str
+@param menu reference to the menu
+@type QMenu
 @param editor reference to the editor
+@type Editor
 """
 if menuName == "Tools":
 if self.__menu.menuAction() not in menu.actions():
 # Re-add our menu
 self.__editors[editor] = []
 submenu = QMenu(menuTitle, self.__menu)
 for title, encString in entries:
 if title == '--Separator--':
 submenu.addSeparator()
 else:
-act = submenu.addAction(title, self.__encloseSelection)
+act = submenu.addAction(title)
 act.setData(encString)
+submenu.triggered.connect(self.__encloseSelection)
 self.__menu.addMenu(submenu)
-def __encloseSelection(self):
+@pyqtSlot(QAction)
+def __encloseSelection(self, act):
 """
 Private slot to enclose the selection with the selected string.
-"""
-act = self.sender()
+@param act action that triggered
-if act is None or not isinstance(act, QAction):
+@type QAction
-return
+"""
+if act is None:
-editor = e5App().getObject("ViewManager").activeWindow()
+return
+editor = ericApp().getObject("ViewManager").activeWindow()
 if editor is None:
 return
 if not editor.hasSelectedText():
 return
-string = act.data()
+encloseString = act.data()
-if not string:
+if not encloseString:
 return
-if '%s' in string:
+if '%s' in encloseString:
-newText = string % editor.selectedText()
+newText = encloseString % editor.selectedText()
-elif '{0}' in string:
+elif '{0}' in encloseString or '{}' in encloseString:
-newText = string.format(editor.selectedText())
+newText = encloseString.format(editor.selectedText())
 else:
-newText = string + editor.selectedText() + string
+newText = encloseString + editor.selectedText() + encloseString
 editor.beginUndoAction()
 editor.replaceSelectedText(newText)
 editor.endUndoAction()
 #

Mercurial Repositories > Selection Encloser Tool / file comparison

comparison: PluginSelectionEncloser.py

PluginSelectionEncloser.py