Mercurial Repositories > eric / changeset
changeset
Added code to configure eric7 initially with an eric6 configuration file (only run, if no eric7 config exists yet).
Fri, 03 Sep 2021 19:14:20 +0200
- author
- Detlev Offenbach <detlev@die-offenbachs.de>
- date
- Fri, 03 Sep 2021 19:14:20 +0200
- branch
- eric7
- changeset 8571
- eb2b840bbf8f
- parent 8570
- 65ec02bfa9d2
- child 8572
- 718f80d8bcde
Added code to configure eric7 initially with an eric6 configuration file (only run, if no eric7 config exists yet).
| eric7/Preferences/__init__.py | file | annotate | diff | comparison | revisions | |
| eric7/UI/UserInterface.py | file | annotate | diff | comparison | revisions |
--- a/eric7/Preferences/__init__.py Fri Sep 03 17:24:57 2021 +0200 +++ b/eric7/Preferences/__init__.py Fri Sep 03 19:14:20 2021 +0200 @@ -1507,32 +1507,31 @@ } -def readToolGroups(prefClass=Prefs): +def readToolGroups(): """ Module function to read the tool groups configuration. - @param prefClass preferences class used as the storage area @return list of tuples defing the tool groups """ toolGroups = [] - groups = int(prefClass.settings.value("Toolgroups/Groups", 0)) + groups = int(Prefs.settings.value("Toolgroups/Groups", 0)) for groupIndex in range(groups): - groupName = prefClass.settings.value( + groupName = Prefs.settings.value( "Toolgroups/{0:02d}/Name".format(groupIndex)) group = [groupName, []] - items = int(prefClass.settings.value( + items = int(Prefs.settings.value( "Toolgroups/{0:02d}/Items".format(groupIndex), 0)) for ind in range(items): - menutext = prefClass.settings.value( + menutext = Prefs.settings.value( "Toolgroups/{0:02d}/{1:02d}/Menutext".format(groupIndex, ind)) - icon = prefClass.settings.value( + icon = Prefs.settings.value( "Toolgroups/{0:02d}/{1:02d}/Icon".format(groupIndex, ind)) - executable = prefClass.settings.value( + executable = Prefs.settings.value( "Toolgroups/{0:02d}/{1:02d}/Executable".format( groupIndex, ind)) - arguments = prefClass.settings.value( + arguments = Prefs.settings.value( "Toolgroups/{0:02d}/{1:02d}/Arguments".format(groupIndex, ind)) - redirect = prefClass.settings.value( + redirect = Prefs.settings.value( "Toolgroups/{0:02d}/{1:02d}/Redirect".format(groupIndex, ind)) if menutext: @@ -1556,46 +1555,45 @@ group[1].append(tool) toolGroups.append(group) currentGroup = int( - prefClass.settings.value("Toolgroups/Current Group", -1)) + Prefs.settings.value("Toolgroups/Current Group", -1)) return toolGroups, currentGroup -def saveToolGroups(toolGroups, currentGroup, prefClass=Prefs): +def saveToolGroups(toolGroups, currentGroup): """ Module function to write the tool groups configuration. @param toolGroups reference to the list of tool groups @param currentGroup index of the currently selected tool group (integer) - @param prefClass preferences class used as the storage area """ # first step, remove all tool group entries - prefClass.settings.remove("Toolgroups") + Prefs.settings.remove("Toolgroups") # second step, write the tool group entries - prefClass.settings.setValue("Toolgroups/Groups", len(toolGroups)) + Prefs.settings.setValue("Toolgroups/Groups", len(toolGroups)) for groupIndex, group in enumerate(toolGroups): - prefClass.settings.setValue( + Prefs.settings.setValue( "Toolgroups/{0:02d}/Name".format(groupIndex), group[0]) - prefClass.settings.setValue( + Prefs.settings.setValue( "Toolgroups/{0:02d}/Items".format(groupIndex), len(group[1])) for ind, tool in enumerate(group[1]): - prefClass.settings.setValue( + Prefs.settings.setValue( "Toolgroups/{0:02d}/{1:02d}/Menutext".format(groupIndex, ind), tool['menutext']) - prefClass.settings.setValue( + Prefs.settings.setValue( "Toolgroups/{0:02d}/{1:02d}/Icon".format(groupIndex, ind), tool['icon']) - prefClass.settings.setValue( + Prefs.settings.setValue( "Toolgroups/{0:02d}/{1:02d}/Executable".format( groupIndex, ind), tool['executable']) - prefClass.settings.setValue( + Prefs.settings.setValue( "Toolgroups/{0:02d}/{1:02d}/Arguments".format(groupIndex, ind), tool['arguments']) - prefClass.settings.setValue( + Prefs.settings.setValue( "Toolgroups/{0:02d}/{1:02d}/Redirect".format(groupIndex, ind), tool['redirect']) - prefClass.settings.setValue("Toolgroups/Current Group", currentGroup) + Prefs.settings.setValue("Toolgroups/Current Group", currentGroup) def initPreferences(): @@ -1617,24 +1615,19 @@ Prefs.settings.value("UI/SingleApplicationMode") -def syncPreferences(prefClass=Prefs): +def syncPreferences(): """ Module function to sync the preferences to disk. In addition to syncing, the central configuration store is reinitialized as well. - - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("General/Configured", True) - prefClass.settings.sync() + Prefs.settings.sync() -def exportPreferences(prefClass=Prefs): +def exportPreferences(): """ Module function to export the current preferences. - - @param prefClass preferences class used as the storage area """ filename, selectedFilter = EricFileDialog.getSaveFileNameAndFilter( None, @@ -1651,18 +1644,16 @@ ex = selectedFilter.split("(*")[1].split(")")[0] if ex: filename += ex - settingsFile = prefClass.settings.fileName() - prefClass.settings = None + settingsFile = Prefs.settings.fileName() + Prefs.settings = None shutil.copy(settingsFile, filename) initPreferences() -def importPreferences(prefClass=Prefs): +def importPreferences(): """ Module function to import preferences from a file previously saved by the export function. - - @param prefClass preferences class used as the storage area """ filename = EricFileDialog.getOpenFileName( None, @@ -1672,20 +1663,26 @@ "Preferences", "Properties File (*.ini);;All Files (*)")) if filename: - settingsFile = prefClass.settings.fileName() + settingsFile = Prefs.settings.fileName() shutil.copy(filename, settingsFile) initPreferences() -def isConfigured(prefClass=Prefs): +def isConfigured(): """ Module function to check, if the the application has been configured. - @param prefClass preferences class used as the storage area @return flag indicating the configured status (boolean) """ - return toBool(prefClass.settings.value("General/Configured", False)) - + return toBool(Prefs.settings.value("General/Configured", False)) + + +def setConfigured(): + """ + Function to set the configured flag. + """ + Prefs.settings.setValue("General/Configured", True) + def initRecentSettings(): """ @@ -1699,39 +1696,35 @@ Globals.settingsNameOrganization, Globals.settingsNameRecent) -def getVarFilters(prefClass=Prefs): +def getVarFilters(): """ Module function to retrieve the variables filter settings. - @param prefClass preferences class used as the storage area @return a tuple defining the variables filter """ - localsFilter = ast.literal_eval(prefClass.settings.value( - "Variables/LocalsFilter", prefClass.varDefaults["LocalsFilter"])) - globalsFilter = ast.literal_eval(prefClass.settings.value( - "Variables/GlobalsFilter", prefClass.varDefaults["GlobalsFilter"])) + localsFilter = ast.literal_eval(Prefs.settings.value( + "Variables/LocalsFilter", Prefs.varDefaults["LocalsFilter"])) + globalsFilter = ast.literal_eval(Prefs.settings.value( + "Variables/GlobalsFilter", Prefs.varDefaults["GlobalsFilter"])) return (localsFilter, globalsFilter) -def setVarFilters(filters, prefClass=Prefs): +def setVarFilters(filters): """ Module function to store the variables filter settings. @param filters variable filters to set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Variables/LocalsFilter", str(filters[0])) - prefClass.settings.setValue("Variables/GlobalsFilter", str(filters[1])) + Prefs.settings.setValue("Variables/LocalsFilter", str(filters[0])) + Prefs.settings.setValue("Variables/GlobalsFilter", str(filters[1])) -def getDebugger(key, prefClass=Prefs): +def getDebugger(key): """ Module function to retrieve the debugger settings. @param key the key of the value to get @type str - @param prefClass preferences class used as the storage area - @type Prefs @return the requested debugger setting @rtype Any """ @@ -1746,22 +1739,22 @@ "AutoViewSourceCode", "ShowExceptionInShell", "MultiProcessEnabled", ): - return toBool(prefClass.settings.value( - "Debugger/" + key, prefClass.debuggerDefaults[key])) + return toBool(Prefs.settings.value( + "Debugger/" + key, Prefs.debuggerDefaults[key])) elif key in ["PassiveDbgPort", "MaxVariableSize", "RecentNumber"]: return int( - prefClass.settings.value( - "Debugger/" + key, prefClass.debuggerDefaults[key])) + Prefs.settings.value( + "Debugger/" + key, Prefs.debuggerDefaults[key])) elif key in ["AllowedHosts"]: return toList( - prefClass.settings.value( - "Debugger/" + key, prefClass.debuggerDefaults[key])) + Prefs.settings.value( + "Debugger/" + key, Prefs.debuggerDefaults[key])) elif key in ["PythonInterpreter", "Python3Interpreter"]: # This code is here to ensure backward compatibility. # Keep "PythonInterpreter" for backward compatibility. newKey = "Python3VirtualEnv" - venvName = prefClass.settings.value( - "Debugger/" + newKey, prefClass.debuggerDefaults[newKey]) + venvName = Prefs.settings.value( + "Debugger/" + newKey, Prefs.debuggerDefaults[newKey]) if venvName: try: from EricWidgets.EricApplication import ericApp @@ -1776,19 +1769,19 @@ return sys.executable return interpreter elif key == "DebugClientType3": - debugClientType = prefClass.settings.value( - "Debugger/" + key, prefClass.debuggerDefaults[key]) + debugClientType = Prefs.settings.value( + "Debugger/" + key, Prefs.debuggerDefaults[key]) # Correct obsolete entry "threaded" if debugClientType == 'threaded': return "standard" else: return debugClientType else: - return prefClass.settings.value( - "Debugger/" + key, prefClass.debuggerDefaults[key]) + return Prefs.settings.value( + "Debugger/" + key, Prefs.debuggerDefaults[key]) -def setDebugger(key, value, prefClass=Prefs): +def setDebugger(key, value): """ Module function to store the debugger settings. @@ -1796,23 +1789,20 @@ @type str @param value the value to be set @type Any - @param prefClass preferences class used as the storage area - @type Prefs """ - prefClass.settings.setValue("Debugger/" + key, value) + Prefs.settings.setValue("Debugger/" + key, value) -def getPython(key, prefClass=Prefs): +def getPython(key): """ Module function to retrieve the Python settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested debugger setting """ if key == "Python3Extensions": exts = [] - for ext in getDebugger(key, prefClass).split(): + for ext in getDebugger(key, Prefs).split(): if ext.startswith("."): exts.append(ext) else: @@ -1822,26 +1812,25 @@ "ASTViewerErrorColor", "DisViewerErrorColor", "DisViewerCurrentColor", "DisViewerLabeledColor", ): - return QColor(prefClass.settings.value( - "Python/" + key, prefClass.pythonDefaults[key])) + return QColor(Prefs.settings.value( + "Python/" + key, Prefs.pythonDefaults[key])) elif key in ("DisViewerExpandCodeInfoDetails"): - return toBool(prefClass.settings.value( - "Python/" + key, prefClass.pythonDefaults[key])) + return toBool(Prefs.settings.value( + "Python/" + key, Prefs.pythonDefaults[key])) else: - return prefClass.settings.value( - "Python/" + key, prefClass.pythonDefaults[key]) + return Prefs.settings.value( + "Python/" + key, Prefs.pythonDefaults[key]) -def setPython(key, value, prefClass=Prefs): +def setPython(key, value): """ Module function to store the Python settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key == "Python3Extensions": - setDebugger(key, value, prefClass) + setDebugger(key, value, Prefs) elif key in ( "ASTViewerErrorColor", "DisViewerErrorColor", "DisViewerCurrentColor", "DisViewerLabeledColor", @@ -1850,66 +1839,61 @@ val = "#{0:8x}".format(value.rgba()) else: val = value.name() - prefClass.settings.setValue("Python/" + key, val) + Prefs.settings.setValue("Python/" + key, val) else: - prefClass.settings.setValue("Python/" + key, value) + Prefs.settings.setValue("Python/" + key, value) -def getUILanguage(prefClass=Prefs): +def getUILanguage(): """ Module function to retrieve the language for the user interface. - @param prefClass preferences class used as the storage area @return the language for the UI """ - lang = prefClass.settings.value("UI/Language", - prefClass.uiDefaults["Language"]) + lang = Prefs.settings.value("UI/Language", + Prefs.uiDefaults["Language"]) if lang in ("None", "", None): return None else: return lang -def setUILanguage(lang, prefClass=Prefs): +def setUILanguage(lang): """ Module function to store the language for the user interface. @param lang the language - @param prefClass preferences class used as the storage area """ if lang is None: - prefClass.settings.setValue("UI/Language", "None") + Prefs.settings.setValue("UI/Language", "None") else: - prefClass.settings.setValue("UI/Language", lang) + Prefs.settings.setValue("UI/Language", lang) -def getViewManager(prefClass=Prefs): +def getViewManager(): """ Module function to retrieve the selected viewmanager type. - @param prefClass preferences class used as the storage area @return the viewmanager type """ - return prefClass.settings.value( - "UI/ViewManager", prefClass.uiDefaults["ViewManager"]) + return Prefs.settings.value( + "UI/ViewManager", Prefs.uiDefaults["ViewManager"]) -def setViewManager(vm, prefClass=Prefs): +def setViewManager(vm): """ Module function to store the selected viewmanager type. @param vm the viewmanager type - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("UI/ViewManager", vm) + Prefs.settings.setValue("UI/ViewManager", vm) -def getUI(key, prefClass=Prefs): +def getUI(key): """ Module function to retrieve the various UI settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested UI setting """ if key in ["BrowsersListFoldersFirst", "BrowsersHideNonPublic", @@ -1926,36 +1910,36 @@ "ShowCondaPackageManager", "ShowCooperation", "ShowIrc", "ShowTemplateViewer", "ShowFileBrowser", "ShowSymbolsViewer", "ShowNumbersViewer", "ShowMicroPython", "UseNativeMenuBar"]: - return toBool(prefClass.settings.value( - "UI/" + key, prefClass.uiDefaults[key])) + return toBool(Prefs.settings.value( + "UI/" + key, Prefs.uiDefaults[key])) elif key in ["TabViewManagerFilenameLength", "CaptionFilenameLength", "ProxyPort/Http", "ProxyPort/Https", "ProxyPort/Ftp", "OpenOnStartup", "PerformVersionCheck", "RecentNumber", "NotificationTimeout", "SidebarDelay", "KeyboardInputInterval", "BackgroundServiceProcesses", "MinimumMessageTypeSeverity"]: - return int(prefClass.settings.value( - "UI/" + key, prefClass.uiDefaults[key])) + return int(Prefs.settings.value( + "UI/" + key, Prefs.uiDefaults[key])) elif key in ["ProxyType/Ftp", ]: - return EricFtpProxyType(int(prefClass.settings.value( - "UI/" + key, prefClass.uiDefaults[key].value))) + return EricFtpProxyType(int(Prefs.settings.value( + "UI/" + key, Prefs.uiDefaults[key].value))) elif key in ["ProxyPassword/Http", "ProxyPassword/Https", "ProxyPassword/Ftp", ]: from Utilities.crypto import pwConvert return pwConvert( - prefClass.settings.value("UI/" + key, prefClass.uiDefaults[key]), + Prefs.settings.value("UI/" + key, Prefs.uiDefaults[key]), encode=False) elif key in ("LogStdErrColour",): - col = prefClass.settings.value("UI/" + key) + col = Prefs.settings.value("UI/" + key) if col is not None: return QColor(col) else: - return prefClass.uiDefaults[key] + return Prefs.uiDefaults[key] elif key in "ViewProfiles": - profilesStr = prefClass.settings.value("UI/ViewProfiles") + profilesStr = Prefs.settings.value("UI/ViewProfiles") if profilesStr is None: # use the defaults - viewProfiles = prefClass.uiDefaults["ViewProfiles"] + viewProfiles = Prefs.uiDefaults["ViewProfiles"] else: viewProfiles = {} profiles = json.loads(profilesStr) @@ -1972,33 +1956,32 @@ viewProfiles[name][2] += profiles[name][2][3:] # side bars return viewProfiles elif key in ["ToolbarManagerState", "PreviewSplitterState"]: - state = prefClass.settings.value("UI/" + key) + state = Prefs.settings.value("UI/" + key) if state is not None: return state else: - return prefClass.uiDefaults[key] + return Prefs.uiDefaults[key] elif key in ["VersionsUrls7"]: urls = toList( - prefClass.settings.value("UI/" + key, prefClass.uiDefaults[key])) + Prefs.settings.value("UI/" + key, Prefs.uiDefaults[key])) if len(urls) == 0: - return prefClass.uiDefaults[key] + return Prefs.uiDefaults[key] else: return urls elif key in ["LogViewerStdoutFilter", "LogViewerStderrFilter", "LogViewerStdxxxFilter", "TextMimeTypes"]: return toList( - prefClass.settings.value("UI/" + key, prefClass.uiDefaults[key])) + Prefs.settings.value("UI/" + key, Prefs.uiDefaults[key])) else: - return prefClass.settings.value("UI/" + key, prefClass.uiDefaults[key]) + return Prefs.settings.value("UI/" + key, Prefs.uiDefaults[key]) -def setUI(key, value, prefClass=Prefs): +def setUI(key, value): """ Module function to store the various UI settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key == "ViewProfiles": profiles = {} @@ -2012,92 +1995,87 @@ # Splitters profiles[name][2].append(bytes(ba.toBase64()).decode()) profiles[name][2] += value[name][2][3:] # side bars - prefClass.settings.setValue("UI/" + key, json.dumps(profiles)) + Prefs.settings.setValue("UI/" + key, json.dumps(profiles)) elif key in ("LogStdErrColour",): - prefClass.settings.setValue("UI/" + key, value.name()) + Prefs.settings.setValue("UI/" + key, value.name()) elif key in ["ProxyPassword/Http", "ProxyPassword/Https", "ProxyPassword/Ftp", ]: from Utilities.crypto import pwConvert - prefClass.settings.setValue("UI/" + key, pwConvert(value, encode=True)) + Prefs.settings.setValue("UI/" + key, pwConvert(value, encode=True)) elif key in ["ProxyType/Ftp", ]: # value is an enum.Enum derived item - prefClass.settings.setValue("UI/" + key, value.value) + Prefs.settings.setValue("UI/" + key, value.value) else: - prefClass.settings.setValue("UI/" + key, value) + Prefs.settings.setValue("UI/" + key, value) -def getIcons(key, prefClass=Prefs): +def getIcons(key): """ Module function to retrieve the various Icons settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested Icons setting """ - dirlist = prefClass.settings.value("UI/Icons/" + key) + dirlist = Prefs.settings.value("UI/Icons/" + key) if dirlist is not None: return dirlist else: - return prefClass.iconsDefaults[key] + return Prefs.iconsDefaults[key] if key in ["Path"]: - return toList(prefClass.settings.value( - "UI/Icons/" + key, prefClass.iconsDefaults[key])) + return toList(Prefs.settings.value( + "UI/Icons/" + key, Prefs.iconsDefaults[key])) else: - return prefClass.settings.value( - "UI/Icons/" + key, prefClass.iconsDefaults[key]) + return Prefs.settings.value( + "UI/Icons/" + key, Prefs.iconsDefaults[key]) -def setIcons(key, value, prefClass=Prefs): +def setIcons(key, value): """ Module function to store the various Icons settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("UI/Icons/" + key, value) + Prefs.settings.setValue("UI/Icons/" + key, value) -def getCooperation(key, prefClass=Prefs): +def getCooperation(key): """ Module function to retrieve the various Cooperation settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested UI setting """ if key in ["AutoStartServer", "TryOtherPorts", "AutoAcceptConnections"]: - return toBool(prefClass.settings.value( - "Cooperation/" + key, prefClass.cooperationDefaults[key])) + return toBool(Prefs.settings.value( + "Cooperation/" + key, Prefs.cooperationDefaults[key])) elif key in ["ServerPort", "MaxPortsToTry"]: - return int(prefClass.settings.value( - "Cooperation/" + key, prefClass.cooperationDefaults[key])) + return int(Prefs.settings.value( + "Cooperation/" + key, Prefs.cooperationDefaults[key])) elif key in ["BannedUsers"]: - return toList(prefClass.settings.value( - "Cooperation/" + key, prefClass.cooperationDefaults[key])) + return toList(Prefs.settings.value( + "Cooperation/" + key, Prefs.cooperationDefaults[key])) else: - return prefClass.settings.value( - "Cooperation/" + key, prefClass.cooperationDefaults[key]) + return Prefs.settings.value( + "Cooperation/" + key, Prefs.cooperationDefaults[key]) -def setCooperation(key, value, prefClass=Prefs): +def setCooperation(key, value): """ Module function to store the various Cooperation settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Cooperation/" + key, value) + Prefs.settings.setValue("Cooperation/" + key, value) -def getEditor(key, prefClass=Prefs): +def getEditor(key): """ Module function to retrieve the various editor settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested editor setting """ if key in ["DefaultEncoding", "DefaultOpenFilter", "DefaultSaveFilter", @@ -2108,8 +2086,8 @@ "CallTipsStyle", "CallTipsPosition", "AutoCompletionSource", "EdgeMode", "EOLMode", "PythonBadIndentation"]: # no special treatment for str and PyQt6 Enum - return prefClass.settings.value( - "Editor/" + key, prefClass.editorDefaults[key]) + return Prefs.settings.value( + "Editor/" + key, Prefs.editorDefaults[key]) elif key in ["AutosaveInterval", "TabWidth", "IndentWidth", "WarnFilesize", "EdgeColumn", "CaretWidth", "CaretLineFrameWidth", @@ -2124,51 +2102,49 @@ "WrapStartIndent", "VirtualSpaceOptions", "PreviewRefreshWaitTimer", "SourceOutlineWidth", "SourceOutlineStepSize", "FoldingStyle", "MouseHoverTimeout"]: - return int(prefClass.settings.value( - "Editor/" + key, prefClass.editorDefaults[key])) + return int(Prefs.settings.value( + "Editor/" + key, Prefs.editorDefaults[key])) elif key in ["AdditionalOpenFilters", "AdditionalSaveFilters", "PreviewMarkdownFileNameExtensions", "PreviewRestFileNameExtensions", "PreviewHtmlFileNameExtensions", "PreviewQssFileNameExtensions", "FullSpellCheckExtensions"]: - return toList(prefClass.settings.value( - "Editor/" + key, prefClass.editorDefaults[key])) + return toList(Prefs.settings.value( + "Editor/" + key, Prefs.editorDefaults[key])) elif key == "TabIndentOverride": - overrideStr = prefClass.settings.value( - "Editor/" + key, prefClass.editorDefaults[key]) + overrideStr = Prefs.settings.value( + "Editor/" + key, Prefs.editorDefaults[key]) if overrideStr: return json.loads(overrideStr) else: return {} else: - return toBool(prefClass.settings.value( - "Editor/" + key, prefClass.editorDefaults[key])) + return toBool(Prefs.settings.value( + "Editor/" + key, Prefs.editorDefaults[key])) -def setEditor(key, value, prefClass=Prefs): +def setEditor(key, value): """ Module function to store the various editor settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key == "TabIndentOverride": - prefClass.settings.setValue("Editor/" + key, json.dumps(value)) + Prefs.settings.setValue("Editor/" + key, json.dumps(value)) else: - prefClass.settings.setValue("Editor/" + key, value) + Prefs.settings.setValue("Editor/" + key, value) -def getEditorColour(key, prefClass=Prefs): +def getEditorColour(key): """ Module function to retrieve the various editor marker colours. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested editor colour """ - col = prefClass.settings.value("Editor/Colour/" + key) + col = Prefs.settings.value("Editor/Colour/" + key) if col is not None: if len(col) == 9: # color string with alpha @@ -2184,49 +2160,46 @@ return QApplication.palette().color(QPalette.ColorGroup.Active, QPalette.ColorRole.Text) else: - return prefClass.editorColourDefaults[key] + return Prefs.editorColourDefaults[key] -def setEditorColour(key, value, prefClass=Prefs): +def setEditorColour(key, value): """ Module function to store the various editor marker colours. @param key the key of the colour to be set @param value the colour to be set - @param prefClass preferences class used as the storage area """ val = ("#{0:8x}".format(value.rgba()) if value.alpha() < 255 else value.name()) - prefClass.settings.setValue("Editor/Colour/" + key, val) + Prefs.settings.setValue("Editor/Colour/" + key, val) -def getEditorOtherFonts(key, prefClass=Prefs): +def getEditorOtherFonts(key): """ Module function to retrieve the various editor fonts except the lexer fonts. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested editor font (QFont) """ f = QFont() - f.fromString(prefClass.settings.value( - "Editor/Other Fonts/" + key, prefClass.editorOtherFontsDefaults[key])) + f.fromString(Prefs.settings.value( + "Editor/Other Fonts/" + key, Prefs.editorOtherFontsDefaults[key])) return f -def setEditorOtherFonts(key, font, prefClass=Prefs): +def setEditorOtherFonts(key, font): """ Module function to store the various editor fonts except the lexer fonts. @param key the key of the font to be set @param font the font to be set (QFont) - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Editor/Other Fonts/" + key, font.toString()) + Prefs.settings.setValue("Editor/Other Fonts/" + key, font.toString()) -def getEditorAPI(language, projectType="", prefClass=Prefs): +def getEditorAPI(language, projectType=""): """ Module function to retrieve the various lists of API files. @@ -2234,13 +2207,11 @@ @type str @param projectType project type of the API list @type str - @param prefClass preferences class used as the storage area - @type Prefs @return requested list of API files @rtype list of str """ key = "{0}_{1}".format(language, projectType) if projectType else language - apis = prefClass.settings.value("Editor/APIs/" + key) + apis = Prefs.settings.value("Editor/APIs/" + key) if apis is not None: if len(apis) and apis[0] == "": return [] @@ -2249,12 +2220,12 @@ else: if projectType: # try again without project type - return getEditorAPI(language, prefClass=prefClass) + return getEditorAPI(language) return [] -def setEditorAPI(language, projectType, apilist, prefClass=Prefs): +def setEditorAPI(language, projectType, apilist): """ Module function to store the various lists of API files. @@ -2264,51 +2235,46 @@ @type str @param apilist list of API files @type list of str - @param prefClass preferences class used as the storage area - @type Prefs """ key = "{0}_{1}".format(language, projectType) if projectType else language - prefClass.settings.setValue("Editor/APIs/" + key, apilist) + Prefs.settings.setValue("Editor/APIs/" + key, apilist) -def getEditorKeywords(key, prefClass=Prefs): +def getEditorKeywords(key): """ Module function to retrieve the various lists of language keywords. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested list of language keywords (list of strings) """ - keywords = prefClass.settings.value("Editor/Keywords/" + key) + keywords = Prefs.settings.value("Editor/Keywords/" + key) if keywords is not None: return keywords else: return [] -def setEditorKeywords(key, keywordsLists, prefClass=Prefs): +def setEditorKeywords(key, keywordsLists): """ Module function to store the various lists of language keywords. @param key the key of the api to be set @param keywordsLists the list of language keywords (list of strings) - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Editor/Keywords/" + key, keywordsLists) + Prefs.settings.setValue("Editor/Keywords/" + key, keywordsLists) -def getEditorLexerAssocs(prefClass=Prefs): +def getEditorLexerAssocs(): """ Module function to retrieve all lexer associations. - @param prefClass preferences class used as the storage area @return a reference to the list of lexer associations (dictionary of strings) """ editorLexerAssoc = {} - prefClass.settings.beginGroup("Editor/LexerAssociations") - keyList = prefClass.settings.childKeys() - prefClass.settings.endGroup() + Prefs.settings.beginGroup("Editor/LexerAssociations") + keyList = Prefs.settings.childKeys() + Prefs.settings.endGroup() import QScintilla.Lexers editorLexerAssocDefaults = QScintilla.Lexers.getDefaultLexerAssociations() @@ -2320,7 +2286,7 @@ else: for key in keyList: defaultValue = editorLexerAssocDefaults.get(key, "") - editorLexerAssoc[key] = prefClass.settings.value( + editorLexerAssoc[key] = Prefs.settings.value( "Editor/LexerAssociations/" + key, defaultValue) # check for new default lexer associations @@ -2330,32 +2296,30 @@ return editorLexerAssoc -def setEditorLexerAssocs(assocs, prefClass=Prefs): +def setEditorLexerAssocs(assocs): """ Module function to retrieve all lexer associations. @param assocs dictionary of lexer associations to be set - @param prefClass preferences class used as the storage area """ # first remove lexer associations that no longer exist, than save the rest - prefClass.settings.beginGroup("Editor/LexerAssociations") - keyList = prefClass.settings.childKeys() - prefClass.settings.endGroup() + Prefs.settings.beginGroup("Editor/LexerAssociations") + keyList = Prefs.settings.childKeys() + Prefs.settings.endGroup() for key in keyList: if key not in assocs: - prefClass.settings.remove("Editor/LexerAssociations/" + key) + Prefs.settings.remove("Editor/LexerAssociations/" + key) for key in assocs: - prefClass.settings.setValue( + Prefs.settings.setValue( "Editor/LexerAssociations/" + key, assocs[key]) -def getEditorLexerAssoc(filename, prefClass=Prefs): +def getEditorLexerAssoc(filename): """ Module function to retrieve a lexer association. @param filename filename used to determine the associated lexer language (string) - @param prefClass preferences class used as the storage area @return the requested lexer language (string) """ for pattern, language in list(getEditorLexerAssocs().items()): @@ -2365,311 +2329,292 @@ return "" -def getEditorTyping(key, prefClass=Prefs): +def getEditorTyping(key): """ Module function to retrieve the various editor typing settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested editor setting """ - return toBool(prefClass.settings.value( - "Editor/Typing/" + key, prefClass.editorTypingDefaults[key])) + return toBool(Prefs.settings.value( + "Editor/Typing/" + key, Prefs.editorTypingDefaults[key])) -def setEditorTyping(key, value, prefClass=Prefs): +def setEditorTyping(key, value): """ Module function to store the various editor typing settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Editor/Typing/" + key, value) + Prefs.settings.setValue("Editor/Typing/" + key, value) -def getEditorExporter(key, prefClass=Prefs): +def getEditorExporter(key): """ Module function to retrieve the various editor exporters settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested editor setting """ if key in ["RTF/Font"]: f = QFont() - f.fromString(prefClass.settings.value( - "Editor/Exporters/" + key, prefClass.editorExporterDefaults[key])) + f.fromString(Prefs.settings.value( + "Editor/Exporters/" + key, Prefs.editorExporterDefaults[key])) return f elif key in ["HTML/WYSIWYG", "HTML/Folding", "HTML/OnlyStylesUsed", "HTML/FullPathAsTitle", "HTML/UseTabs", "RTF/WYSIWYG", "RTF/UseTabs", "TeX/OnlyStylesUsed", "TeX/FullPathAsTitle", "ODT/WYSIWYG", "ODT/OnlyStylesUsed", "ODT/UseTabs"]: - return toBool(prefClass.settings.value( - "Editor/Exporters/" + key, prefClass.editorExporterDefaults[key])) + return toBool(Prefs.settings.value( + "Editor/Exporters/" + key, Prefs.editorExporterDefaults[key])) elif key in ["PDF/Magnification", "PDF/MarginLeft", "PDF/MarginRight", "PDF/MarginTop", "PDF/MarginBottom"]: - return int(prefClass.settings.value( - "Editor/Exporters/" + key, prefClass.editorExporterDefaults[key])) + return int(Prefs.settings.value( + "Editor/Exporters/" + key, Prefs.editorExporterDefaults[key])) else: - return prefClass.settings.value( - "Editor/Exporters/" + key, prefClass.editorExporterDefaults[key]) + return Prefs.settings.value( + "Editor/Exporters/" + key, Prefs.editorExporterDefaults[key]) -def setEditorExporter(key, value, prefClass=Prefs): +def setEditorExporter(key, value): """ Module function to store the various editor exporters settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["RTF/Font"]: - prefClass.settings.setValue( + Prefs.settings.setValue( "Editor/Exporters/" + key, value.toString()) else: - prefClass.settings.setValue("Editor/Exporters/" + key, value) + Prefs.settings.setValue("Editor/Exporters/" + key, value) -def getPrinter(key, prefClass=Prefs): +def getPrinter(key): """ Module function to retrieve the various printer settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested printer setting """ if key in ["ColorMode", "FirstPageFirst"]: - return toBool(prefClass.settings.value( - "Printer/" + key, prefClass.printerDefaults[key])) + return toBool(Prefs.settings.value( + "Printer/" + key, Prefs.printerDefaults[key])) elif key in ["Magnification", "Orientation", "PageSize", "Resolution"]: - return int(prefClass.settings.value( - "Printer/" + key, prefClass.printerDefaults[key])) + return int(Prefs.settings.value( + "Printer/" + key, Prefs.printerDefaults[key])) elif key in ["LeftMargin", "RightMargin", "TopMargin", "BottomMargin"]: - return float(prefClass.settings.value( - "Printer/" + key, prefClass.printerDefaults[key])) + return float(Prefs.settings.value( + "Printer/" + key, Prefs.printerDefaults[key])) elif key in ["HeaderFont"]: f = QFont() - f.fromString(prefClass.settings.value( - "Printer/" + key, prefClass.printerDefaults[key])) + f.fromString(Prefs.settings.value( + "Printer/" + key, Prefs.printerDefaults[key])) return f else: - return prefClass.settings.value( - "Printer/" + key, prefClass.printerDefaults[key]) + return Prefs.settings.value( + "Printer/" + key, Prefs.printerDefaults[key]) -def setPrinter(key, value, prefClass=Prefs): +def setPrinter(key, value): """ Module function to store the various printer settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["HeaderFont"]: - prefClass.settings.setValue("Printer/" + key, value.toString()) + Prefs.settings.setValue("Printer/" + key, value.toString()) else: - prefClass.settings.setValue("Printer/" + key, value) + Prefs.settings.setValue("Printer/" + key, value) -def getShell(key, prefClass=Prefs): +def getShell(key): """ Module function to retrieve the various shell settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested shell setting """ if key in ["MonospacedFont", "MarginsFont"]: f = QFont() - f.fromString(prefClass.settings.value( - "Shell/" + key, prefClass.shellDefaults[key])) + f.fromString(Prefs.settings.value( + "Shell/" + key, Prefs.shellDefaults[key])) return f elif key in ["MaxHistoryEntries"]: - return int(prefClass.settings.value( - "Shell/" + key, prefClass.shellDefaults[key])) + return int(Prefs.settings.value( + "Shell/" + key, Prefs.shellDefaults[key])) elif key in ["HistoryStyle"]: - return ShellHistoryStyle(int(prefClass.settings.value( - "Shell/" + key, prefClass.shellDefaults[key].value))) + return ShellHistoryStyle(int(Prefs.settings.value( + "Shell/" + key, Prefs.shellDefaults[key].value))) elif key in ["LastVirtualEnvironment"]: - return prefClass.settings.value( - "Shell/" + key, prefClass.shellDefaults[key]) + return Prefs.settings.value( + "Shell/" + key, Prefs.shellDefaults[key]) else: - return toBool(prefClass.settings.value( - "Shell/" + key, prefClass.shellDefaults[key])) + return toBool(Prefs.settings.value( + "Shell/" + key, Prefs.shellDefaults[key])) -def setShell(key, value, prefClass=Prefs): +def setShell(key, value): """ Module function to store the various shell settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["MonospacedFont", "MarginsFont"]: - prefClass.settings.setValue("Shell/" + key, value.toString()) + Prefs.settings.setValue("Shell/" + key, value.toString()) elif key in ["HistoryStyle"]: - prefClass.settings.setValue("Shell/" + key, value.value) + Prefs.settings.setValue("Shell/" + key, value.value) else: - prefClass.settings.setValue("Shell/" + key, value) + Prefs.settings.setValue("Shell/" + key, value) -def getProject(key, prefClass=Prefs): +def getProject(key): """ Module function to retrieve the various project handling settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested project setting """ if key in ["RecentNumber"]: - return int(prefClass.settings.value( - "Project/" + key, prefClass.projectDefaults[key])) + return int(Prefs.settings.value( + "Project/" + key, Prefs.projectDefaults[key])) elif key in ["DebugClientsHistory", "DebuggerInterpreterHistory"]: - return toList(prefClass.settings.value( - "Project/" + key, prefClass.projectDefaults[key])) + return toList(Prefs.settings.value( + "Project/" + key, Prefs.projectDefaults[key])) else: - return toBool(prefClass.settings.value( - "Project/" + key, prefClass.projectDefaults[key])) + return toBool(Prefs.settings.value( + "Project/" + key, Prefs.projectDefaults[key])) -def setProject(key, value, prefClass=Prefs): +def setProject(key, value): """ Module function to store the various project handling settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["DebugClientsHistory", "DebuggerInterpreterHistory"]: # max. list sizes is hard coded to 20 entries newList = [v for v in value if v] if len(newList) > 20: newList = newList[:20] - prefClass.settings.setValue("Project/" + key, newList) + Prefs.settings.setValue("Project/" + key, newList) else: - prefClass.settings.setValue("Project/" + key, value) + Prefs.settings.setValue("Project/" + key, value) -def getProjectBrowserFlags(key, prefClass=Prefs): +def getProjectBrowserFlags(key): """ Module function to retrieve the various project browser flags settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested project setting """ try: - default = prefClass.projectBrowserFlagsDefaults[key] + default = Prefs.projectBrowserFlagsDefaults[key] except KeyError: default = AllBrowsersFlag - return int(prefClass.settings.value( + return int(Prefs.settings.value( "Project/BrowserFlags/" + key, default)) -def setProjectBrowserFlags(key, value, prefClass=Prefs): +def setProjectBrowserFlags(key, value): """ Module function to store the various project browser flags settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Project/BrowserFlags/" + key, value) + Prefs.settings.setValue("Project/BrowserFlags/" + key, value) -def setProjectBrowserFlagsDefault(key, value, prefClass=Prefs): +def setProjectBrowserFlagsDefault(key, value): """ Module function to store the various project browser flags settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.projectBrowserFlagsDefaults[key] = value + Prefs.projectBrowserFlagsDefaults[key] = value -def removeProjectBrowserFlags(key, prefClass=Prefs): +def removeProjectBrowserFlags(key): """ Module function to remove a project browser flags setting. @param key the key of the setting to be removed - @param prefClass preferences class used as the storage area """ - prefClass.settings.remove("Project/BrowserFlags/" + key) + Prefs.settings.remove("Project/BrowserFlags/" + key) -def getProjectBrowserColour(key, prefClass=Prefs): +def getProjectBrowserColour(key): """ Module function to retrieve the various project browser colours. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested project browser colour """ - col = prefClass.settings.value("Project/Colour/" + key) + col = Prefs.settings.value("Project/Colour/" + key) if col is not None: return QColor(col) else: - return prefClass.projectBrowserColourDefaults[key] + return Prefs.projectBrowserColourDefaults[key] -def setProjectBrowserColour(key, value, prefClass=Prefs): +def setProjectBrowserColour(key, value): """ Module function to store the various project browser colours. @param key the key of the colour to be set @param value the colour to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Project/Colour/" + key, value.name()) + Prefs.settings.setValue("Project/Colour/" + key, value.name()) -def getMultiProject(key, prefClass=Prefs): +def getMultiProject(key): """ Module function to retrieve the various project handling settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested project setting """ if key in ["RecentNumber"]: - return int(prefClass.settings.value( - "MultiProject/" + key, prefClass.multiProjectDefaults[key])) + return int(Prefs.settings.value( + "MultiProject/" + key, Prefs.multiProjectDefaults[key])) elif key in ["OpenMasterAutomatically", "TimestampFile"]: - return toBool(prefClass.settings.value( - "MultiProject/" + key, prefClass.multiProjectDefaults[key])) + return toBool(Prefs.settings.value( + "MultiProject/" + key, Prefs.multiProjectDefaults[key])) else: - return prefClass.settings.value( - "MultiProject/" + key, prefClass.multiProjectDefaults[key]) + return Prefs.settings.value( + "MultiProject/" + key, Prefs.multiProjectDefaults[key]) -def setMultiProject(key, value, prefClass=Prefs): +def setMultiProject(key, value): """ Module function to store the various project handling settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("MultiProject/" + key, value) + Prefs.settings.setValue("MultiProject/" + key, value) -def getQtDocDir(version, prefClass=Prefs): +def getQtDocDir(version): """ Module function to retrieve the Qt5DocDir/Qt6DocDir setting. @param version Qt version to get documentation directory for @type int - @param prefClass preferences class used as the storage area @return the requested Qt5DocDir/Qt6DocDir setting @rtype str """ key = "Qt{0}DocDir".format(version) - s = prefClass.settings.value( - "Help/{0}".format(key), prefClass.helpDefaults[key]) + s = Prefs.settings.value( + "Help/{0}".format(key), Prefs.helpDefaults[key]) if s == "": s = os.getenv(key.upper(), "") if s == "": @@ -2680,111 +2625,108 @@ return s -def getHelp(key, prefClass=Prefs): +def getHelp(key): """ Module function to retrieve the various help settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested help setting """ - return prefClass.settings.value("Help/" + key, - prefClass.helpDefaults[key]) + return Prefs.settings.value("Help/" + key, + Prefs.helpDefaults[key]) -def setHelp(key, value, prefClass=Prefs): +def setHelp(key, value): """ Module function to store the various help settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Help/" + key, value) + Prefs.settings.setValue("Help/" + key, value) -def getWebBrowser(key, prefClass=Prefs): +def getWebBrowser(key): """ Module function to retrieve the various web browser settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested help setting """ - if not prefClass.webEngineSettingsIntitialized: - prefClass.initWebEngineSettingsDefaults() + if not Prefs.webEngineSettingsIntitialized: + Prefs.initWebEngineSettingsDefaults() if key in ["StandardFont", "FixedFont"]: f = QFont() - f.fromString(prefClass.settings.value( - "WebBrowser/" + key, prefClass.webBrowserDefaults[key])) + f.fromString(Prefs.settings.value( + "WebBrowser/" + key, Prefs.webBrowserDefaults[key])) return f elif key in ["SecureUrlColor", "InsecureUrlColor", "MaliciousUrlColor", "PrivateModeUrlColor"]: - col = prefClass.settings.value("WebBrowser/" + key) + col = Prefs.settings.value("WebBrowser/" + key) if col is not None: return QColor(col) else: - return prefClass.webBrowserDefaults[key] + return Prefs.webBrowserDefaults[key] elif key in ["WebSearchKeywords"]: # return a list of tuples of (keyword, engine name) keywords = [] - size = prefClass.settings.beginReadArray("WebBrowser/" + key) + size = Prefs.settings.beginReadArray("WebBrowser/" + key) for index in range(size): - prefClass.settings.setArrayIndex(index) - keyword = prefClass.settings.value("Keyword") - engineName = prefClass.settings.value("Engine") + Prefs.settings.setArrayIndex(index) + keyword = Prefs.settings.value("Keyword") + engineName = Prefs.settings.value("Engine") keywords.append((keyword, engineName)) - prefClass.settings.endArray() + Prefs.settings.endArray() return keywords elif key == "DownloadManagerDownloads": # return a list of dicts containing the URL, save location, done flag, # page URL, date/time downloaded downloads = [] - length = prefClass.settings.beginReadArray("WebBrowser/" + key) + length = Prefs.settings.beginReadArray("WebBrowser/" + key) for index in range(length): download = {} - prefClass.settings.setArrayIndex(index) - download["URL"] = prefClass.settings.value("URL") + Prefs.settings.setArrayIndex(index) + download["URL"] = Prefs.settings.value("URL") if download["URL"] is None: download["URL"] = QUrl() - download["Location"] = prefClass.settings.value("Location") - download["Done"] = toBool(prefClass.settings.value("Done")) - download["PageURL"] = prefClass.settings.value("PageURL") + download["Location"] = Prefs.settings.value("Location") + download["Done"] = toBool(Prefs.settings.value("Done")) + download["PageURL"] = Prefs.settings.value("PageURL") if download["PageURL"] is None: download["PageURL"] = QUrl() - download["Downloaded"] = prefClass.settings.value("Downloaded") + download["Downloaded"] = Prefs.settings.value("Downloaded") if download["Downloaded"] is None: download["Downloaded"] = QDateTime() elif isinstance(download["Downloaded"], str): download["Downloaded"] = QDateTime.fromString( download["Downloaded"], "yyyy-MM-dd hh:mm:ss") downloads.append(download) - prefClass.settings.endArray() + Prefs.settings.endArray() return downloads elif key == "RssFeeds": # return a list of tuples of (URL, title, icon) feeds = [] - length = prefClass.settings.beginReadArray("WebBrowser/" + key) + length = Prefs.settings.beginReadArray("WebBrowser/" + key) for index in range(length): - prefClass.settings.setArrayIndex(index) - url = prefClass.settings.value("URL") - title = prefClass.settings.value("Title") - icon = prefClass.settings.value("Icon") + Prefs.settings.setArrayIndex(index) + url = Prefs.settings.value("URL") + title = Prefs.settings.value("Title") + icon = Prefs.settings.value("Icon") feeds.append((url, title, icon)) - prefClass.settings.endArray() + Prefs.settings.endArray() return feeds elif key in ["SyncFtpPassword", "SyncEncryptionKey"]: from Utilities.crypto import pwConvert - return pwConvert(prefClass.settings.value( - "WebBrowser/" + key, prefClass.webBrowserDefaults[key]), + return pwConvert(Prefs.settings.value( + "WebBrowser/" + key, Prefs.webBrowserDefaults[key]), encode=False) elif key == "HelpViewerType": # special treatment to adjust for missing QtWebEngine - value = int(prefClass.settings.value( - "WebBrowser/" + key, prefClass.webBrowserDefaults[key])) + value = int(Prefs.settings.value( + "WebBrowser/" + key, Prefs.webBrowserDefaults[key])) if QWebEngineSettings is None: - value = prefClass.webBrowserDefaults[key] + value = Prefs.webBrowserDefaults[key] return value elif key in ["StartupBehavior", "HistoryLimit", "DownloadManagerRemovePolicy", "SyncType", "SyncFtpPort", @@ -2798,8 +2740,8 @@ "RefererTrimmingPolicy", "AcceptQuotaRequest", "AcceptProtocolHandlerRequest", ]: - return int(prefClass.settings.value( - "WebBrowser/" + key, prefClass.webBrowserDefaults[key])) + return int(Prefs.settings.value( + "WebBrowser/" + key, Prefs.webBrowserDefaults[key])) elif key in ["SingleWebBrowserWindow", "SaveGeometry", "JavaScriptEnabled", "JavaScriptCanOpenWindows", "JavaScriptCanAccessClipboard", @@ -2833,127 +2775,123 @@ "PdfViewerEnabled", "AlwaysRejectFaultyCertificates", "Accelerated2dCanvasEnabled", "AutoLoadIconsForPage", ]: - return toBool(prefClass.settings.value( - "WebBrowser/" + key, prefClass.webBrowserDefaults[key])) + return toBool(Prefs.settings.value( + "WebBrowser/" + key, Prefs.webBrowserDefaults[key])) elif key in ["GreaseMonkeyDisabledScripts", "SendRefererWhitelist", "AdBlockSubscriptions", "AdBlockExceptions", "SpellCheckLanguages", ]: - return toList(prefClass.settings.value( - "WebBrowser/" + key, prefClass.webBrowserDefaults[key])) + return toList(Prefs.settings.value( + "WebBrowser/" + key, Prefs.webBrowserDefaults[key])) elif key in ["AutoScrollDivider"]: - return float(prefClass.settings.value( - "WebBrowser/" + key, prefClass.webBrowserDefaults[key])) + return float(Prefs.settings.value( + "WebBrowser/" + key, Prefs.webBrowserDefaults[key])) elif key in ["SafeBrowsingUpdateDateTime"]: - dateTimeStr = prefClass.settings.value("WebBrowser/" + key) + dateTimeStr = Prefs.settings.value("WebBrowser/" + key) if dateTimeStr is not None: return QDateTime.fromString(dateTimeStr, Qt.DateFormat.ISODate) else: - return prefClass.webBrowserDefaults[key] + return Prefs.webBrowserDefaults[key] else: - return prefClass.settings.value("WebBrowser/" + key, - prefClass.webBrowserDefaults[key]) + return Prefs.settings.value("WebBrowser/" + key, + Prefs.webBrowserDefaults[key]) -def setWebBrowser(key, value, prefClass=Prefs): +def setWebBrowser(key, value): """ Module function to store the various web browser settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["StandardFont", "FixedFont"]: - prefClass.settings.setValue("WebBrowser/" + key, value.toString()) + Prefs.settings.setValue("WebBrowser/" + key, value.toString()) elif key in ["SecureUrlColor", "InsecureUrlColor", "MaliciousUrlColor", "PrivateModeUrlColor"]: - prefClass.settings.setValue("WebBrowser/" + key, value.name()) + Prefs.settings.setValue("WebBrowser/" + key, value.name()) elif key == "WebSearchKeywords": # value is list of tuples of (keyword, engine name) - prefClass.settings.remove("WebBrowser/" + key) - prefClass.settings.beginWriteArray("WebBrowser/" + key, len(value)) + Prefs.settings.remove("WebBrowser/" + key) + Prefs.settings.beginWriteArray("WebBrowser/" + key, len(value)) for index, v in enumerate(value): - prefClass.settings.setArrayIndex(index) - prefClass.settings.setValue("Keyword", v[0]) - prefClass.settings.setValue("Engine", v[1]) - prefClass.settings.endArray() + Prefs.settings.setArrayIndex(index) + Prefs.settings.setValue("Keyword", v[0]) + Prefs.settings.setValue("Engine", v[1]) + Prefs.settings.endArray() elif key == "DownloadManagerDownloads": # value is list of dicts containing the URL, save location, done flag, # page URL, date/time downloaded - prefClass.settings.remove("Help/" + key) - prefClass.settings.beginWriteArray("WebBrowser/" + key, len(value)) + Prefs.settings.remove("Help/" + key) + Prefs.settings.beginWriteArray("WebBrowser/" + key, len(value)) for index, v in enumerate(value): - prefClass.settings.setArrayIndex(index) - prefClass.settings.setValue("URL", v["URL"]) - prefClass.settings.setValue("Location", v["Location"]) - prefClass.settings.setValue("Done", v["Done"]) - prefClass.settings.setValue("PageURL", v["PageURL"]) - prefClass.settings.setValue( + Prefs.settings.setArrayIndex(index) + Prefs.settings.setValue("URL", v["URL"]) + Prefs.settings.setValue("Location", v["Location"]) + Prefs.settings.setValue("Done", v["Done"]) + Prefs.settings.setValue("PageURL", v["PageURL"]) + Prefs.settings.setValue( "Downloaded", v["Downloaded"].toString("yyyy-MM-dd hh:mm:ss")) - prefClass.settings.endArray() + Prefs.settings.endArray() elif key == "RssFeeds": # value is list of tuples of (URL, title, icon) - prefClass.settings.remove("WebBrowser/" + key) - prefClass.settings.beginWriteArray("WebBrowser/" + key, len(value)) + Prefs.settings.remove("WebBrowser/" + key) + Prefs.settings.beginWriteArray("WebBrowser/" + key, len(value)) for index, v in enumerate(value): - prefClass.settings.setArrayIndex(index) - prefClass.settings.setValue("URL", v[0]) - prefClass.settings.setValue("Title", v[1]) - prefClass.settings.setValue("Icon", v[2]) - prefClass.settings.endArray() + Prefs.settings.setArrayIndex(index) + Prefs.settings.setValue("URL", v[0]) + Prefs.settings.setValue("Title", v[1]) + Prefs.settings.setValue("Icon", v[2]) + Prefs.settings.endArray() elif key in ["SyncFtpPassword", "SyncEncryptionKey"]: from Utilities.crypto import pwConvert - prefClass.settings.setValue( + Prefs.settings.setValue( "WebBrowser/" + key, pwConvert(value, encode=True)) elif key in ["SafeBrowsingUpdateDateTime"]: # value is a QDateTime - prefClass.settings.setValue("WebBrowser/" + key, - value.toString(Qt.DateFormat.ISODate)) + Prefs.settings.setValue("WebBrowser/" + key, + value.toString(Qt.DateFormat.ISODate)) else: - prefClass.settings.setValue("WebBrowser/" + key, value) + Prefs.settings.setValue("WebBrowser/" + key, value) -def getSystem(key, prefClass=Prefs): +def getSystem(key): """ Module function to retrieve the various system settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested system setting """ from Utilities import supportedCodecs if key in ["StringEncoding", "IOEncoding"]: - encoding = prefClass.settings.value( - "System/" + key, prefClass.sysDefaults[key]) + encoding = Prefs.settings.value( + "System/" + key, Prefs.sysDefaults[key]) if encoding not in supportedCodecs: - encoding = prefClass.sysDefaults[key] + encoding = Prefs.sysDefaults[key] return encoding return None -def setSystem(key, value, prefClass=Prefs): +def setSystem(key, value): """ Module function to store the various system settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("System/" + key, value) + Prefs.settings.setValue("System/" + key, value) -def getQtTranslationsDir(prefClass=Prefs): +def getQtTranslationsDir(): """ Module function to retrieve the Qt6TranslationsDir setting depending on the current Qt version. - @param prefClass preferences class used as the storage area @return the requested setting (string) """ - s = prefClass.settings.value( + s = Prefs.settings.value( "Qt/Qt6TranslationsDir", - prefClass.qtDefaults["Qt6TranslationsDir"]) + Prefs.qtDefaults["Qt6TranslationsDir"]) if s == "": s = QLibraryInfo.path( QLibraryInfo.LibraryPath.TranslationsPath) @@ -2965,77 +2903,71 @@ return s -def getQt(key, prefClass=Prefs): +def getQt(key): """ Module function to retrieve the various Qt settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested Qt setting """ if key in ["Qt6TranslationsDir"]: - return getQtTranslationsDir(prefClass) + return getQtTranslationsDir() elif key in ["PyuicIndent", "Pyuic6Indent"]: - return int(prefClass.settings.value( - "Qt/" + key, prefClass.qtDefaults[key])) + return int(Prefs.settings.value( + "Qt/" + key, Prefs.qtDefaults[key])) elif key in ["PyuicFromImports", "PyuicExecute", "Pyuic6Execute", "PySide2FromImports", "PySide6FromImports"]: - return toBool(prefClass.settings.value( - "Qt/" + key, prefClass.qtDefaults[key])) + return toBool(Prefs.settings.value( + "Qt/" + key, Prefs.qtDefaults[key])) else: - return prefClass.settings.value("Qt/" + key, prefClass.qtDefaults[key]) + return Prefs.settings.value("Qt/" + key, Prefs.qtDefaults[key]) -def setQt(key, value, prefClass=Prefs): +def setQt(key, value): """ Module function to store the various Qt settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Qt/" + key, value) + Prefs.settings.setValue("Qt/" + key, value) -def getCorba(key, prefClass=Prefs): +def getCorba(key): """ Module function to retrieve the various Corba settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested corba setting """ - return prefClass.settings.value( - "Corba/" + key, prefClass.corbaDefaults[key]) + return Prefs.settings.value( + "Corba/" + key, Prefs.corbaDefaults[key]) -def setCorba(key, value, prefClass=Prefs): +def setCorba(key, value): """ Module function to store the various Corba settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Corba/" + key, value) + Prefs.settings.setValue("Corba/" + key, value) -def getProtobuf(key, prefClass=Prefs): +def getProtobuf(key): """ Module function to retrieve the various protobuf settings. @param key the key of the value to get @type str - @param prefClass preferences class used as the storage area - @type Prefs @return the requested protobuf setting @rtype any """ - return prefClass.settings.value( - "Protobuf/" + key, prefClass.protobufDefaults[key]) + return Prefs.settings.value( + "Protobuf/" + key, Prefs.protobufDefaults[key]) -def setProtobuf(key, value, prefClass=Prefs): +def setProtobuf(key, value): """ Module function to store the various protobuf settings. @@ -3043,213 +2975,200 @@ @type str @param value the value to be set @type any - @param prefClass preferences class used as the storage area - @type Prefs """ - prefClass.settings.setValue("Protobuf/" + key, value) + Prefs.settings.setValue("Protobuf/" + key, value) -def getUser(key, prefClass=Prefs): +def getUser(key): """ Module function to retrieve the various user settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key == "MailServerPassword": from Utilities.crypto import pwConvert - return pwConvert(prefClass.settings.value( - "User/" + key, prefClass.userDefaults[key]), encode=False) + return pwConvert(Prefs.settings.value( + "User/" + key, Prefs.userDefaults[key]), encode=False) elif key in ["MailServerPort"]: try: - return int(prefClass.settings.value( - "User/" + key, prefClass.userDefaults[key])) + return int(Prefs.settings.value( + "User/" + key, Prefs.userDefaults[key])) except ValueError: - return prefClass.userDefaults[key] + return Prefs.userDefaults[key] elif key in ["MailServerAuthentication", "UseSystemEmailClient", "UseMasterPassword", "SavePasswords", "UseGoogleMailOAuth2"]: - return toBool(prefClass.settings.value( - "User/" + key, prefClass.userDefaults[key])) + return toBool(Prefs.settings.value( + "User/" + key, Prefs.userDefaults[key])) elif key == "MailServerEncryption": # convert from old key 'MailServerUseTLS' - val = prefClass.settings.value("User/" + key) + val = Prefs.settings.value("User/" + key) if val is None: - if toBool(prefClass.settings.value("User/MailServerUseTLS")): + if toBool(Prefs.settings.value("User/MailServerUseTLS")): val = "TLS" else: - val = prefClass.userDefaults[key] + val = Prefs.userDefaults[key] return val else: - return prefClass.settings.value( - "User/" + key, prefClass.userDefaults[key]) + return Prefs.settings.value( + "User/" + key, Prefs.userDefaults[key]) -def setUser(key, value, prefClass=Prefs): +def setUser(key, value): """ Module function to store the various user settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key == "MailServerPassword": from Utilities.crypto import pwConvert - prefClass.settings.setValue( + Prefs.settings.setValue( "User/" + key, pwConvert(value, encode=True)) elif key == "MasterPassword": from Utilities.crypto.py3PBKDF2 import hashPassword - prefClass.settings.setValue( + Prefs.settings.setValue( "User/" + key, hashPassword(value)) else: - prefClass.settings.setValue("User/" + key, value) + Prefs.settings.setValue("User/" + key, value) -def getVCS(key, prefClass=Prefs): +def getVCS(key): """ Module function to retrieve the VCS related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["StatusMonitorInterval"]: - return int(prefClass.settings.value( - "VCS/" + key, prefClass.vcsDefaults[key])) + return int(Prefs.settings.value( + "VCS/" + key, Prefs.vcsDefaults[key])) else: - return toBool(prefClass.settings.value( - "VCS/" + key, prefClass.vcsDefaults[key])) + return toBool(Prefs.settings.value( + "VCS/" + key, Prefs.vcsDefaults[key])) -def setVCS(key, value, prefClass=Prefs): +def setVCS(key, value): """ Module function to store the VCS related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("VCS/" + key, value) + Prefs.settings.setValue("VCS/" + key, value) -def getTasks(key, prefClass=Prefs): +def getTasks(key): """ Module function to retrieve the Tasks related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["TasksFixmeColor", "TasksWarningColor", "TasksTodoColor", "TasksNoteColor", "TasksTestColor", "TasksDocuColor"]: - col = prefClass.settings.value("Tasks/" + key) + col = Prefs.settings.value("Tasks/" + key) if col is not None: return QColor(col) else: - return prefClass.tasksDefaults[key] + return Prefs.tasksDefaults[key] elif key in ["ClearOnFileClose", ]: - return toBool(prefClass.settings.value( - "Tasks/" + key, prefClass.tasksDefaults[key])) + return toBool(Prefs.settings.value( + "Tasks/" + key, Prefs.tasksDefaults[key])) else: - return prefClass.settings.value( - "Tasks/" + key, prefClass.tasksDefaults[key]) + return Prefs.settings.value( + "Tasks/" + key, Prefs.tasksDefaults[key]) -def setTasks(key, value, prefClass=Prefs): +def setTasks(key, value): """ Module function to store the Tasks related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["TasksFixmeColor", "TasksWarningColor", "TasksTodoColor", "TasksNoteColor"]: - prefClass.settings.setValue("Tasks/" + key, value.name()) + Prefs.settings.setValue("Tasks/" + key, value.name()) else: - prefClass.settings.setValue("Tasks/" + key, value) + Prefs.settings.setValue("Tasks/" + key, value) -def getTemplates(key, prefClass=Prefs): +def getTemplates(key): """ Module function to retrieve the Templates related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["SeparatorChar"]: - return prefClass.settings.value( - "Templates/" + key, prefClass.templatesDefaults[key]) + return Prefs.settings.value( + "Templates/" + key, Prefs.templatesDefaults[key]) elif key in ["EditorFont"]: f = QFont() - f.fromString(prefClass.settings.value( - "Templates/" + key, prefClass.templatesDefaults[key])) + f.fromString(Prefs.settings.value( + "Templates/" + key, Prefs.templatesDefaults[key])) return f else: - return toBool(prefClass.settings.value( - "Templates/" + key, prefClass.templatesDefaults[key])) + return toBool(Prefs.settings.value( + "Templates/" + key, Prefs.templatesDefaults[key])) -def setTemplates(key, value, prefClass=Prefs): +def setTemplates(key, value): """ Module function to store the Templates related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["EditorFont"]: - prefClass.settings.setValue("Templates/" + key, value.toString()) + Prefs.settings.setValue("Templates/" + key, value.toString()) else: - prefClass.settings.setValue("Templates/" + key, value) + Prefs.settings.setValue("Templates/" + key, value) -def getPluginManager(key, prefClass=Prefs): +def getPluginManager(key): """ Module function to retrieve the plugin manager related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["DownloadPath"]: - return prefClass.settings.value( - "PluginManager/" + key, prefClass.pluginManagerDefaults[key]) + return Prefs.settings.value( + "PluginManager/" + key, Prefs.pluginManagerDefaults[key]) elif key in ["UpdatesCheckInterval", "KeepGenerations"]: - return int(prefClass.settings.value( - "PluginManager/" + key, prefClass.pluginManagerDefaults[key])) + return int(Prefs.settings.value( + "PluginManager/" + key, Prefs.pluginManagerDefaults[key])) elif key in ["HiddenPlugins"]: - return toList(prefClass.settings.value( - "PluginManager/" + key, prefClass.pluginManagerDefaults[key])) + return toList(Prefs.settings.value( + "PluginManager/" + key, Prefs.pluginManagerDefaults[key])) else: - return toBool(prefClass.settings.value( - "PluginManager/" + key, prefClass.pluginManagerDefaults[key])) + return toBool(Prefs.settings.value( + "PluginManager/" + key, Prefs.pluginManagerDefaults[key])) -def setPluginManager(key, value, prefClass=Prefs): +def setPluginManager(key, value): """ Module function to store the plugin manager related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("PluginManager/" + key, value) + Prefs.settings.setValue("PluginManager/" + key, value) -def getGraphics(key, prefClass=Prefs): +def getGraphics(key): """ Module function to retrieve the Graphics related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["Font"]: - font = prefClass.settings.value( - "Graphics/" + key, prefClass.graphicsDefaults[key]) + font = Prefs.settings.value( + "Graphics/" + key, Prefs.graphicsDefaults[key]) if isinstance(font, QFont): # workaround for an old bug in eric < 4.4 return font @@ -3258,167 +3177,156 @@ f.fromString(font) return f else: - return prefClass.settings.value( - "Graphics/" + key, prefClass.graphicsDefaults[key]) + return Prefs.settings.value( + "Graphics/" + key, Prefs.graphicsDefaults[key]) -def setGraphics(key, value, prefClass=Prefs): +def setGraphics(key, value): """ Module function to store the Graphics related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["Font"]: - prefClass.settings.setValue("Graphics/" + key, value.toString()) + Prefs.settings.setValue("Graphics/" + key, value.toString()) else: - prefClass.settings.setValue("Graphics/" + key, value) + Prefs.settings.setValue("Graphics/" + key, value) -def getIconEditor(key, prefClass=Prefs): +def getIconEditor(key): """ Module function to retrieve the Icon Editor related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ - return prefClass.settings.value( - "IconEditor/" + key, prefClass.iconEditorDefaults[key]) + return Prefs.settings.value( + "IconEditor/" + key, Prefs.iconEditorDefaults[key]) -def setIconEditor(key, value, prefClass=Prefs): +def setIconEditor(key, value): """ Module function to store the Icon Editor related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("IconEditor/" + key, value) + Prefs.settings.setValue("IconEditor/" + key, value) -def getFlakes(key, prefClass=Prefs): +def getFlakes(key): """ Module function to retrieve the pyflakes related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["IncludeInSyntaxCheck", "IgnoreStarImportWarnings"]: - return toBool(prefClass.settings.value("Py3Flakes/" + key, - prefClass.pyflakesDefaults[key])) + return toBool(Prefs.settings.value("Py3Flakes/" + key, + Prefs.pyflakesDefaults[key])) else: - return prefClass.settings.value( - "Py3Flakes/" + key, prefClass.pyflakesDefaults[key]) + return Prefs.settings.value( + "Py3Flakes/" + key, Prefs.pyflakesDefaults[key]) -def setFlakes(key, value, prefClass=Prefs): +def setFlakes(key, value): """ Module function to store the pyflakes related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Py3Flakes/" + key, value) + Prefs.settings.setValue("Py3Flakes/" + key, value) -def getTrayStarter(key, prefClass=Prefs): +def getTrayStarter(key): """ Module function to retrieve the tray starter related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ - return prefClass.settings.value( - "TrayStarter/" + key, prefClass.trayStarterDefaults[key]) + return Prefs.settings.value( + "TrayStarter/" + key, Prefs.trayStarterDefaults[key]) -def setTrayStarter(key, value, prefClass=Prefs): +def setTrayStarter(key, value): """ Module function to store the tray starter related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("TrayStarter/" + key, value) + Prefs.settings.setValue("TrayStarter/" + key, value) -def getIrc(key, prefClass=Prefs): +def getIrc(key): """ Module function to retrieve the IRC related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["TimestampIncludeDate", "ShowTimestamps", "ShowNotifications", "NotifyJoinPart", "NotifyMessage", "NotifyNick", "EnableIrcColours", "AutoUserInfoLookup", "MarkPositionWhenHidden", "AskOnShutdown"]: - return toBool(prefClass.settings.value( - "IRC/" + key, prefClass.ircDefaults[key])) + return toBool(Prefs.settings.value( + "IRC/" + key, Prefs.ircDefaults[key])) elif key in ["AutoUserInfoMax", "AutoUserInfoInterval"]: - return int(prefClass.settings.value( - "IRC/" + key, prefClass.ircDefaults[key])) + return int(Prefs.settings.value( + "IRC/" + key, Prefs.ircDefaults[key])) else: - return prefClass.settings.value( - "IRC/" + key, prefClass.ircDefaults[key]) + return Prefs.settings.value( + "IRC/" + key, Prefs.ircDefaults[key]) -def setIrc(key, value, prefClass=Prefs): +def setIrc(key, value): """ Module function to store the IRC related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("IRC/" + key, value) + Prefs.settings.setValue("IRC/" + key, value) -def getHexEditor(key, prefClass=Prefs): +def getHexEditor(key): """ Module function to retrieve the Hex Editor related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested user setting """ if key in ["AddressAreaWidth", "RecentNumber"]: - return int(prefClass.settings.value( - "HexEditor/" + key, prefClass.hexEditorDefaults[key])) + return int(Prefs.settings.value( + "HexEditor/" + key, Prefs.hexEditorDefaults[key])) elif key in ["ShowAddressArea", "ShowAsciiArea", "OpenInOverwriteMode", "OpenReadOnly", "HighlightChanges"]: - return toBool(prefClass.settings.value( - "HexEditor/" + key, prefClass.hexEditorDefaults[key])) + return toBool(Prefs.settings.value( + "HexEditor/" + key, Prefs.hexEditorDefaults[key])) elif key in ["HighlightingBackGround", "HighlightingForeGround", "SelectionBackGround", "SelectionForeGround", "AddressAreaBackGround", "AddressAreaForeGround"]: - return QColor(prefClass.settings.value( - "HexEditor/" + key, prefClass.hexEditorDefaults[key])) + return QColor(Prefs.settings.value( + "HexEditor/" + key, Prefs.hexEditorDefaults[key])) elif key in ["Font"]: f = QFont() - f.fromString(prefClass.settings.value( - "HexEditor/" + key, prefClass.hexEditorDefaults[key])) + f.fromString(Prefs.settings.value( + "HexEditor/" + key, Prefs.hexEditorDefaults[key])) return f else: - return prefClass.settings.value( - "HexEditor/" + key, prefClass.hexEditorDefaults[key]) + return Prefs.settings.value( + "HexEditor/" + key, Prefs.hexEditorDefaults[key]) -def setHexEditor(key, value, prefClass=Prefs): +def setHexEditor(key, value): """ Module function to store the Hex Editor related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["HighlightingBackGround", "HighlightingForeGround", "SelectionBackGround", "SelectionForeGround", @@ -3427,22 +3335,21 @@ val = "#{0:8x}".format(value.rgba()) else: val = value.name() - prefClass.settings.setValue("HexEditor/" + key, val) + Prefs.settings.setValue("HexEditor/" + key, val) elif key in ["Font"]: - prefClass.settings.setValue("HexEditor/" + key, value.toString()) + Prefs.settings.setValue("HexEditor/" + key, value.toString()) else: - prefClass.settings.setValue("HexEditor/" + key, value) + Prefs.settings.setValue("HexEditor/" + key, value) -def getDiffColour(key, prefClass=Prefs): +def getDiffColour(key): """ Module function to retrieve the colours for the diff highlighter. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested diff colour """ - col = prefClass.settings.value("Diff/" + key) + col = Prefs.settings.value("Diff/" + key) if col is not None: if len(col) == 9: # color string with alpha @@ -3450,221 +3357,205 @@ else: return QColor(col) else: - return prefClass.diffColourDefaults[key] + return Prefs.diffColourDefaults[key] -def setDiffColour(key, value, prefClass=Prefs): +def setDiffColour(key, value): """ Module function to store the diff highlighter colours. @param key the key of the colour to be set @param value the colour to be set - @param prefClass preferences class used as the storage area """ val = ("#{0:8x}".format(value.rgba()) if value.alpha() < 255 else value.name()) - prefClass.settings.setValue("Diff/" + key, val) + Prefs.settings.setValue("Diff/" + key, val) -def getDocuViewer(key, prefClass=Prefs): +def getDocuViewer(key): """ Module function to retrieve the Code Documentation Viewer related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested Code Documentation Viewer value """ if key in ["ShowInfoOnOpenParenthesis"]: - return toBool(prefClass.settings.value( + return toBool(Prefs.settings.value( "CodeDocumentationViewer/" + key, - prefClass.docuViewerDefaults[key])) + Prefs.docuViewerDefaults[key])) else: - return prefClass.settings.value( + return Prefs.settings.value( "CodeDocumentationViewer/" + key, - prefClass.docuViewerDefaults[key]) + Prefs.docuViewerDefaults[key]) -def setDocuViewer(key, value, prefClass=Prefs): +def setDocuViewer(key, value): """ Module function to store the Code Documentation Viewer related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("CodeDocumentationViewer/" + key, value) + Prefs.settings.setValue("CodeDocumentationViewer/" + key, value) -def getConda(key, prefClass=Prefs): +def getConda(key): """ Module function to retrieve the conda related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested conda value """ - return prefClass.settings.value( + return Prefs.settings.value( "Conda/" + key, - prefClass.condaDefaults[key]) + Prefs.condaDefaults[key]) -def setConda(key, value, prefClass=Prefs): +def setConda(key, value): """ Module function to store the conda related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Conda/" + key, value) + Prefs.settings.setValue("Conda/" + key, value) -def getPip(key, prefClass=Prefs): +def getPip(key): """ Module function to retrieve the pip related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested pip value """ if key in ("ExcludeCondaEnvironments"): - return toBool(prefClass.settings.value( + return toBool(Prefs.settings.value( "Pip/" + key, - prefClass.pipDefaults[key])) + Prefs.pipDefaults[key])) else: - return prefClass.settings.value( + return Prefs.settings.value( "Pip/" + key, - prefClass.pipDefaults[key]) + Prefs.pipDefaults[key]) -def setPip(key, value, prefClass=Prefs): +def setPip(key, value): """ Module function to store the pip related settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ - prefClass.settings.setValue("Pip/" + key, value) + Prefs.settings.setValue("Pip/" + key, value) -def getMicroPython(key, prefClass=Prefs): +def getMicroPython(key): """ Module function to retrieve the MicroPython related settings. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested MicroPython value """ if key in ("SerialTimeout", "ChartColorTheme"): - return int(prefClass.settings.value( + return int(Prefs.settings.value( "MicroPython/" + key, - prefClass.microPythonDefaults[key])) + Prefs.microPythonDefaults[key])) elif key in ["ReplLineWrap", "SyncTimeAfterConnect", "ShowHiddenLocal", "ShowHiddenDevice"]: - return toBool(prefClass.settings.value( + return toBool(Prefs.settings.value( "MicroPython/" + key, - prefClass.microPythonDefaults[key])) + Prefs.microPythonDefaults[key])) elif key in ["IgnoredUnknownDevices", "ManualDevices"]: - jsonStr = prefClass.settings.value( + jsonStr = Prefs.settings.value( "MicroPython/" + key, - prefClass.microPythonDefaults[key]) + Prefs.microPythonDefaults[key]) if jsonStr: return json.loads(jsonStr) else: return None else: - return prefClass.settings.value( + return Prefs.settings.value( "MicroPython/" + key, - prefClass.microPythonDefaults[key]) + Prefs.microPythonDefaults[key]) -def setMicroPython(key, value, prefClass=Prefs): +def setMicroPython(key, value): """ Module function to store the pip MicroPython settings. @param key the key of the setting to be set @param value the value to be set - @param prefClass preferences class used as the storage area """ if key in ["IgnoredUnknownDevices", "ManualDevices"]: - prefClass.settings.setValue( + Prefs.settings.setValue( "MicroPython/" + key, json.dumps(value)) else: - prefClass.settings.setValue( + Prefs.settings.setValue( "MicroPython/" + key, value) -def getGeometry(key, prefClass=Prefs): +def getGeometry(key): """ Module function to retrieve the display geometry. @param key the key of the value to get - @param prefClass preferences class used as the storage area @return the requested geometry setting """ if key in ["MainMaximized"]: - return toBool(prefClass.settings.value( + return toBool(Prefs.settings.value( "Geometry/" + key, - prefClass.geometryDefaults[key])) + Prefs.geometryDefaults[key])) else: - v = prefClass.settings.value("Geometry/" + key) + v = Prefs.settings.value("Geometry/" + key) if v is not None: return v else: - return prefClass.geometryDefaults[key] + return Prefs.geometryDefaults[key] -def setGeometry(key, value, prefClass=Prefs): +def setGeometry(key, value): """ Module function to store the display geometry. @param key the key of the setting to be set @param value the geometry to be set - @param prefClass preferences class used as the storage area """ if key in ["MainMaximized"]: - prefClass.settings.setValue("Geometry/" + key, value) + Prefs.settings.setValue("Geometry/" + key, value) else: - if prefClass.resetLayout: - v = prefClass.geometryDefaults[key] + if Prefs.resetLayout: + v = Prefs.geometryDefaults[key] else: v = value - prefClass.settings.setValue("Geometry/" + key, v) + Prefs.settings.setValue("Geometry/" + key, v) -def resetLayout(prefClass=Prefs): +def resetLayout(): """ Module function to set a flag not storing the current layout. - - @param prefClass preferences class used as the storage area """ - prefClass.resetLayout = True + Prefs.resetLayout = True -def shouldResetLayout(prefClass=Prefs): +def shouldResetLayout(): """ Module function to indicate a reset of the layout. - @param prefClass preferences class used as the storage area @return flag indicating a reset of the layout (boolean) """ - return prefClass.resetLayout + return Prefs.resetLayout -def saveResetLayout(prefClass=Prefs): +def saveResetLayout(): """ Module function to save the reset layout. - - @param prefClass preferences class used as the storage area """ - if prefClass.resetLayout: - for key in list(prefClass.geometryDefaults.keys()): - prefClass.settings.setValue( + if Prefs.resetLayout: + for key in list(Prefs.geometryDefaults.keys()): + Prefs.settings.setValue( "Geometry/" + key, - prefClass.geometryDefaults[key]) + Prefs.geometryDefaults[key]) def toBool(value): @@ -3723,42 +3614,41 @@ return value -def convertPasswords(oldPassword, newPassword, prefClass=Prefs): +def convertPasswords(oldPassword, newPassword): """ Module function to convert all passwords. @param oldPassword current master password (string) @param newPassword new master password (string) - @param prefClass preferences class used as the storage area """ from Utilities.crypto import pwRecode for key in ["ProxyPassword/Http", "ProxyPassword/Https", "ProxyPassword/Ftp", ]: - prefClass.settings.setValue( + Prefs.settings.setValue( "UI/" + key, pwRecode( - prefClass.settings.value("UI/" + key, - prefClass.uiDefaults[key]), + Prefs.settings.value("UI/" + key, + Prefs.uiDefaults[key]), oldPassword, newPassword ) ) for key in ["MailServerPassword"]: - prefClass.settings.setValue( + Prefs.settings.setValue( "User/" + key, pwRecode( - prefClass.settings.value("User/" + key, - prefClass.userDefaults[key]), + Prefs.settings.value("User/" + key, + Prefs.userDefaults[key]), oldPassword, newPassword ) ) for key in ["SyncFtpPassword", "SyncEncryptionKey"]: - prefClass.settings.setValue( + Prefs.settings.setValue( "WebBrowser/" + key, pwRecode( - prefClass.settings.value("WebBrowser/" + key, - prefClass.webBrowserDefaults[key]), + Prefs.settings.value("WebBrowser/" + key, + Prefs.webBrowserDefaults[key]), oldPassword, newPassword ) @@ -3768,5 +3658,69 @@ initPreferences() initRecentSettings() +########################################################################### +## Functions to deal with existing eric6 configuration +########################################################################### + + +def eric6SettingsName(): + """ + Function to generate the settings file name for eric6. + + @return settings file name + @rtype str + """ + settingsFileName = Prefs.settings.fileName() + return settingsFileName.replace("Eric7", "Eric6").replace("eric7", "eric6") + + +def hasEric6Configuration(): + """ + Function to check, if there is an old eric6 configuration. + + @return flag indicating the existence of an eric6 configuration + @rtype bool + """ + return os.path.exists(eric6SettingsName()) + + +def importEric6Configuration(): + """ + Function to import an old eric6 configuration. + """ + conversions = ( + ("Editor/WrapLongLinesMode", QsciScintilla.WrapMode), + ("Editor/WrapVisualFlag", QsciScintilla.WrapVisualFlag), + ("Editor/WrapIndentMode", QsciScintilla.WrapIndentMode), + ("Editor/EdgeMode", QsciScintilla.EdgeMode), + ("Editor/AutoCompletionSource", QsciScintilla.AutoCompletionSource), + ("Editor/CallTipsStyle", QsciScintilla.CallTipsStyle), + ("Editor/CallTipsPosition", QsciScintilla.CallTipsPosition), + ("Editor/PythonBadIndentation", QsciLexerPython.IndentationWarning), + ("Editor/EOLMode", QsciScintilla.EolMode), + + ("WebBrowser/SearchLanguage", QLocale.Language), + + ("RefactoringRope/MouseClickGotoModifiers", Qt.KeyboardModifier), + ("RefactoringRope/MouseClickGotoButton", Qt.MouseButton), + ) + + filename = eric6SettingsName() + if filename: + settingsFile = Prefs.settings.fileName() + shutil.copy(filename, settingsFile) + initPreferences() + + # convert enum related settings + for conversion in conversions: + settingsKey, enumType = conversion + if Prefs.settings.contains(settingsKey): + Prefs.settings.setValue( + settingsKey, + enumType(int(Prefs.settings.value(settingsKey))) + ) + + syncPreferences() + # # eflag: noqa = M201, M613
--- a/eric7/UI/UserInterface.py Fri Sep 03 17:24:57 2021 +0200 +++ b/eric7/UI/UserInterface.py Fri Sep 03 19:14:20 2021 +0200 @@ -7341,12 +7341,26 @@ if not Preferences.isConfigured(): self.__initDebugToolbarsLayout() - EricMessageBox.information( - self, - self.tr("First time usage"), - self.tr("""eric has not been configured yet. """ - """The configuration dialog will be started.""")) + if Preferences.hasEric6Configuration(): + yes = EricMessageBox.yesNo( + self, + self.tr("First time usage"), + self.tr("eric7 has not been configured yet but an eric6" + " configuration was found. Shall this be" + " imported?"), + yesDefault=True + ) + if yes: + Preferences.importEric6Configuration() + else: + EricMessageBox.information( + self, + self.tr("First time usage"), + self.tr("""eric has not been configured yet. """ + """The configuration dialog will be started.""")) + self.showPreferences() + Preferences.setConfigured() def checkProjectsWorkspace(self): """
