Rope Refactoring: comparison PluginRefactoringRope.py

-:a92b3272f4c1
+:f740b50380df
 """
 import os
 import contextlib
-from PyQt5.QtCore import Qt, QObject, QTranslator, QCoreApplication
+from PyQt6.QtCore import Qt, QObject, QTranslator, QCoreApplication
-from E5Gui.E5Application import e5App
+from EricWidgets.EricApplication import ericApp
 import Preferences
 import Utilities
 # Start-Of-Header
 name = "Refactoring Rope Plugin"
 author = "Detlev Offenbach <detlev@die-offenbachs.de>"
 autoactivate = True
 deactivateable = True
-version = "8.0.1"
+version = "1.0.0"
 className = "RefactoringRopePlugin"
 packageName = "RefactoringRope"
 internalPackages = "rope"
 shortDescription = "Refactoring using the Rope library."
 longDescription = (
 """This plug-in implements refactoring functionality"""
 """ using the Rope refactoring library. Additionally it implements an"""
-""" alternative auto-completion and call-tips provider. It is a"""
+""" auto-completion, call-tips and code documentation provider as well"""
-""" provider for code documentation as well."""
+""" as a mouse click handler."""
 )
 pyqtApi = 2
 doNotCompile = True
 # End-Of-Header
 def createAutoCompletionPage(configDlg):
 """
 Module function to create the autocompletion configuration page.
 @param configDlg reference to the configuration dialog
+@type ConfigurationWidget
 @return reference to the configuration page
+@rtype AutoCompletionRopePage
 """
 global refactoringRopePluginObject
 from RefactoringRope.ConfigurationPage.AutoCompletionRopePage import (
 AutoCompletionRopePage
 )
 def createCallTipsPage(configDlg):
 """
 Module function to create the calltips configuration page.
 @param configDlg reference to the configuration dialog
+@type ConfigurationWidget
 @return reference to the configuration page
+@rtype CallTipsRopePage
 """
 global refactoringRopePluginObject
 from RefactoringRope.ConfigurationPage.CallTipsRopePage import (
 CallTipsRopePage
 )
 def createMouseClickHandlerPage(configDlg):
 """
 Module function to create the mouse click handler configuration page.
 @param configDlg reference to the configuration dialog
+@type ConfigurationWidget
 @return reference to the configuration page
+@rtype MouseClickHandlerRopePage
 """
 global refactoringRopePluginObject
 from RefactoringRope.ConfigurationPage.MouseClickHandlerRopePage import (
 MouseClickHandlerRopePage
 )
 @return dictionary containing the relevant data
 @rtype dict
 """
 try:
-usesDarkPalette = e5App().usesDarkPalette()
+usesDarkPalette = ericApp().usesDarkPalette()
 except AttributeError:
-from PyQt5.QtGui import QPalette
+from PyQt6.QtGui import QPalette
-palette = e5App().palette()
+palette = ericApp().palette()
 lightness = palette.color(QPalette.Window).lightness()
 usesDarkPalette = lightness <= 128
 iconSuffix = "dark" if usesDarkPalette else "light"
 data = {
 def __init__(self, ui):
 """
 Constructor
 @param ui reference to the user interface object
-@type UI.UserInterface
+@type UserInterface
 """
 QObject.__init__(self, ui)
 self.__ui = ui
 self.__initialize()
 "CodeAssistCalltipsEnabled": False,
 "CalltipsMaxFixes": 10,
 "MouseClickEnabled": True,
-"MouseClickGotoModifiers": int(Qt.ControlModifier),
+"MouseClickGotoModifiers": (
-"MouseClickGotoButton": int(Qt.LeftButton),
+Qt.KeyboardModifier.ControlModifier |
+Qt.KeyboardModifier.AltModifier
+),
+"MouseClickGotoButton": Qt.MouseButton.LeftButton,
 }
 self.__translator = None
 self.__loadTranslator()
 @rtype tuple of (None, bool)
 """
 global refactoringRopePluginObject
 refactoringRopePluginObject = self
-e5App().getObject("PluginManager").shutdown.connect(
+ericApp().getObject("PluginManager").shutdown.connect(
 self.__shutdown)
 from RefactoringRope.CodeAssistServer import CodeAssistServer
 self.__codeAssistServer = CodeAssistServer(self, self.__ui)
 self.__codeAssistServer.activate()
 from RefactoringRope.RefactoringServer import RefactoringServer
 self.__refactoringServer = RefactoringServer(self, self.__ui)
 self.__refactoringServer.activate()
-e5App().getObject("PluginManager").shutdown.connect(
+ericApp().getObject("PluginManager").shutdown.connect(
 self.__shutdown)
-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):
 self.__refactoringServer.deactivate()
 if self.__codeAssistServer:
 self.__codeAssistServer.deactivate()
-e5App().getObject("PluginManager").shutdown.disconnect(
+ericApp().getObject("PluginManager").shutdown.disconnect(
 self.__shutdown)
-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 in self.__editors[:]:
 self.__editorClosed(editor)
 translation = "rope_{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.")
 Public method to retrieve the various refactoring settings.
 @param key the key of the value to get
 @type str
 @return the requested refactoring setting
+@rtype Any
 """
 if key in ["CodeAssistEnabled", "CodeAssistCalltipsEnabled",
 "MouseClickEnabled"]:
 return Preferences.toBool(Preferences.Prefs.settings.value(
 self.PreferencesKey + "/" + key, self.__defaults[key]))
-else:
+elif key in ["CalltipsMaxFixes", "MaxFixes"]:
 return int(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 refactoring settings.
 @param key the key of the setting to be set
 @type str
 @param value the value to be set
+@type Any
 """
 Preferences.Prefs.settings.setValue(
 self.PreferencesKey + "/" + key, value)
 if key in ["MouseClickGotoModifiers", "MouseClickGotoButton"]:
 @return list of valid language strings
 @rtype list of str
 """
 return ["Python3", "MicroPython",
-"Pygments|Python", "Pygments|Python 2.x"]
+"Pygments|Python", "Pygments|Python 2.x",
+"Cython"]
 def __editorOpened(self, editor):
 """
 Private slot called, when a new editor was opened.
 @param editor reference to the new editor
-@type QScintilla.Editor.Editor
+@type Editor
 """
 languages = self.__determineLanguage()
 if editor.getLanguage() in languages:
 self.__connectEditor(editor)
 def __editorClosed(self, editor):
 """
 Private slot called, when an editor was closed.
 @param editor reference to the editor
-@type QScintilla.Editor.Editor
+@type Editor
 """
 if editor in self.__editors:
 editor.languageChanged.disconnect(self.__editorLanguageChanged)
 self.__disconnectEditor(editor)
 self.__editors.remove(editor)
 def __connectEditor(self, editor):
 """
 Private method to connect an editor.
 @param editor reference to the editor
-@type QScintilla.Editor.Editor
+@type Editor
 """
 editor.editorAboutToBeSaved.connect(self.__editorAboutToBeSaved)
 editor.editorSaved.connect(self.__editorSaved)
 self.__setAutoCompletionHook(editor)
 def __disconnectEditor(self, editor):
 """
 Private method to disconnect an editor.
 @param editor reference to the editor
-@type QScintilla.Editor.Editor
+@type Editor
 """
 with contextlib.suppress(TypeError):
 editor.editorAboutToBeSaved.disconnect(self.__editorAboutToBeSaved)
 editor.editorSaved.disconnect(self.__editorSaved)
 def __connectMouseClickHandler(self, editor):
 """
 Private method to connect the mouse click handler to an editor.
 @param editor reference to the editor
-@type QScintilla.Editor
+@type Editor
 """
 if self.getPreferences("MouseClickGotoButton"):
 editor.setMouseClickHandler(
 "rope",
 self.getPreferences("MouseClickGotoModifiers"),
 def __disconnectMouseClickHandler(self, editor):
 """
 Private method to disconnect the mouse click handler from an editor.
 @param editor reference to the editor
-@type QScintilla.Editor
+@type Editor
 """
 editor.removeMouseClickHandlers("rope")
 def __setAutoCompletionHook(self, editor):
 """
 Private method to set the autocompletion hook.
 @param editor reference to the editor
-@type QScintilla.Editor
+@type Editor
 """
-try:
+editor.addCompletionListHook(
-editor.addCompletionListHook(
+"rope", self.__codeAssistServer.requestCompletions, True)
-"rope", self.__codeAssistServer.requestCompletions, True)
-self.__codeAssistServer.setAsyncCompletions(True)
-except TypeError:
-# interface before 17.11
-editor.addCompletionListHook(
-"rope", self.__codeAssistServer.getCompletions)
-self.__codeAssistServer.setAsyncCompletions(False)
 def __unsetAutoCompletionHook(self, editor):
 """
 Private method to unset the autocompletion hook.
 @param editor reference to the editor
-@type QScintilla.Editor
+@type Editor
 """
 editor.removeCompletionListHook("rope")
 def __setCalltipsHook(self, editor):
 """
 Private method to set the calltip hook.
 @param editor reference to the editor
-@type QScintilla.Editor
+@type Editor
 """
 editor.addCallTipHook("rope", self.__codeAssistServer.getCallTips)
 def __unsetCalltipsHook(self, editor):
 """
 Private method to unset the calltip hook.
 @param editor reference to the editor
-@type QScintilla.Editor
+@type Editor
 """
 editor.removeCallTipHook("rope")
 def __editorAboutToBeSaved(self, filename):
 """

Mercurial Repositories > Rope Refactoring / file comparison

comparison: PluginRefactoringRope.py

PluginRefactoringRope.py