Selection Encloser Tool: comparison PluginSelectionEncloser.py

-:96fac1d8181f
+:a9f6842a18f6
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+"""
+Module implementing the Selection Encloser plug-in.
+"""
+from __future__ import unicode_literals    # __IGNORE_WARNING__
+import os
+import json
+from PyQt4.QtCore import QObject, QTranslator, QCoreApplication
+from PyQt4.QtGui import QAction, QMenu
+from E5Gui.E5Application import e5App
+import Preferences
+# Start-Of-Header
+name = "Selection Encloser Plug-in"
+author = "Detlev Offenbach <detlev@die-offenbachs.de>"
+autoactivate = True
+deactivateable = True
+version = "0.1.0"
+className = "SelectionEncloserPlugin"
+packageName = "SelectionEncloser"
+shortDescription = "Enclose the selection with a string."
+longDescription = \
+"""This plug-in implements a tool to enclose the selection of""" \
+""" the current editor with a string. The enclosing string is""" \
+""" selectable via a configurable menu hierarchy."""
+needsRestart = False
+pyqtApi = 2
+python2Compatible = True
+# End-Of-Header
+error = ""
+selectionEncloserPluginObject = None
+def createSelectionEncloserPage(configDlg):
+"""
+Module function to create the Selection Encloser configuration page.
+@param configDlg reference to the configuration dialog
+@return reference to the configuration page
+"""
+global selectionEncloserPluginObject
+from SelectionEncloser.ConfigurationPage.SelectionEncloserPage import \
+SelectionEncloserPage
+page = SelectionEncloserPage(selectionEncloserPluginObject)
+return page
+def getConfigData():
+"""
+Module function returning data as required by the configuration dialog.
+@return dictionary containing the relevant data
+"""
+if e5App().getObject("UserInterface").versionIsNewer('5.2.99', '20121012'):
+return {
+"selectionEncloserPage": [
+QCoreApplication.translate("SelectionEncloserPlugin",
+"Selection Encloser"),
+os.path.join("SelectionEncloser", "icons",
+"selectionEncloser.png"),
+createSelectionEncloserPage, None, None],
+}
+else:
+return {}
+def prepareUninstall():
+"""
+Module function to prepare for an uninstallation.
+"""
+Preferences.Prefs.settings.remove(SelectionEncloserPlugin.PreferencesKey)
+class SelectionEncloserPlugin(QObject):
+"""
+Class implementing the Selection Encloser plugin.
+"""
+PreferencesKey = "SelectionEncloser"
+def __init__(self, ui):
+"""
+Constructor
+@param ui reference to the user interface object (UI.UserInterface)
+"""
+QObject.__init__(self, ui)
+self.__ui = ui
+# menu is a list of lists; each list consists of a string for the
+# submenu title and a list of submenu entries. The title of the submenu
+# entry is the enclosing string.
+defaultMenu = [
+[self.tr("Quotes"), ['"', "'", '"""', "'''"]],
+]
+self.__defaults = {
+"MenuHierarchy": json.dumps(defaultMenu),
+}
+self.__translator = None
+self.__loadTranslator()
+self.__initMenu()
+self.__editors = {}
+def activate(self):
+"""
+Public method to activate this plugin.
+@return tuple of None and activation status (boolean)
+"""
+global error
+error = ""     # clear previous error
+global selectionEncloserPluginObject
+selectionEncloserPluginObject = self
+self.__ui.showMenu.connect(self.__populateMenu)
+e5App().getObject("ViewManager").editorOpenedEd.connect(
+self.__editorOpened)
+e5App().getObject("ViewManager").editorClosedEd.connect(
+self.__editorClosed)
+for editor in e5App().getObject("ViewManager").getOpenEditors():
+self.__editorOpened(editor)
+return None, True
+def deactivate(self):
+"""
+Public method to deactivate this plugin.
+"""
+self.__ui.showMenu.disconnect(self.__populateMenu)
+e5App().getObject("ViewManager").editorOpenedEd.disconnect(
+self.__editorOpened)
+e5App().getObject("ViewManager").editorClosedEd.disconnect(
+self.__editorClosed)
+for editor, acts in self.__editors.items():
+menu = editor.getMenu("Tools")
+if menu is not None:
+for act in acts:
+menu.removeAction(act)
+self.__editors = {}
+def __loadTranslator(self):
+"""
+Private method to load the translation file.
+"""
+if self.__ui is not None:
+loc = self.__ui.getLocale()
+if loc and loc != "C":
+locale_dir = os.path.join(
+os.path.dirname(__file__), "SelectionEncloser", "i18n")
+translation = "selectionencloser_{0}".format(loc)
+translator = QTranslator(None)
+loaded = translator.load(translation, locale_dir)
+if loaded:
+self.__translator = translator
+e5App().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)
+@return the requested setting
+"""
+if key in ["MenuHierarchy"]:
+return json.loads(
+Preferences.Prefs.settings.value(
+self.PreferencesKey + "/" + key, self.__defaults[key]))
+else:
+return 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 value the value to be set
+"""
+if key in ["MenuHierarchy"]:
+Preferences.Prefs.settings.setValue(
+self.PreferencesKey + "/" + key, json.dumps(value))
+else:
+Preferences.Prefs.settings.setValue(
+self.PreferencesKey + "/" + key, value)
+def __initMenu(self):
+"""
+Private method to initialize the menu.
+"""
+self.__menu = QMenu("Enclose Selection")
+self.__menu.setEnabled(False)
+self.__menu.aboutToShow.connect(self.__showMenu)
+def __populateMenu(self, name, menu):
+"""
+Private slot to populate the tools menu with our entry.
+@param name name of the menu (string)
+@param menu reference to the menu to be populated (QMenu)
+"""
+if name != "Tools":
+return
+editor = e5App().getObject("ViewManager").activeWindow()
+if not menu.isEmpty():
+menu.addSeparator()
+act = menu.addMenu(self.__menu)
+act.setEnabled(editor is not None and editor.hasSelectedText())
+def __editorOpened(self, editor):
+"""
+Private slot called, when a new editor was opened.
+@param editor reference to the new editor (QScintilla.Editor)
+"""
+menu = editor.getMenu("Tools")
+if menu is not None:
+self.__editors[editor] = []
+if not menu.isEmpty():
+act = menu.addSeparator()
+self.__editors[editor].append(act)
+act = menu.addMenu(self.__menu)
+self.__menu.setEnabled(True)
+self.__editors[editor].append(act)
+editor.showMenu.connect(self.__editorShowMenu)
+def __editorClosed(self, editor):
+"""
+Private slot called, when an editor was closed.
+@param editor reference to the editor (QScintilla.Editor)
+"""
+try:
+del self.__editors[editor]
+if not self.__editors:
+self.__menu.setEnabled(False)
+except KeyError:
+pass
+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 menu reference to the menu (QMenu)
+@param editor reference to the editor
+"""
+if menuName == "Tools":
+for act in self.__editors[editor]:
+if not act.isSeparator():
+act.setEnabled(editor.hasSelectedText())
+def __showMenu(self):
+"""
+Private slot to build the menu hierarchy.
+"""
+self.__menu.clear()
+hierarchy = self.getPreferences("MenuHierarchy")
+for menuTitle, entries in hierarchy:
+submenu = QMenu(menuTitle, self.__menu)
+for entry in entries:
+act = submenu.addAction(entry, self.__encloseSelection)
+act.setData(entry)
+self.__menu.addMenu(submenu)
+def __encloseSelection(self):
+"""
+Private slot to enclose the selection with the selected string.
+"""
+act = self.sender()
+if act is None or not isinstance(act, QAction):
+return
+editor = e5App().getObject("ViewManager").activeWindow()
+if editor is None:
+return
+if not editor.hasSelectedText():
+return
+string = act.data()
+if not string:
+return
+newText = string + editor.selectedText() + string
+editor.beginUndoAction()
+editor.replaceSelectedText(newText)
+editor.endUndoAction()

Mercurial Repositories > Selection Encloser Tool / file comparison

comparison: PluginSelectionEncloser.py

PluginSelectionEncloser.py