--- 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
