eric: Preferences/__init__.py@c679fb30c8f3 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2009 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Package implementing the preferences interface.
 The preferences interface consists of a class, which defines the default
 values for all configuration items and stores the actual values. These
 values are read and written to the eric4 preferences file by module
 functions. The data is stored in a file in a subdirectory of the users home
 directory. The individual configuration data is accessed by accessor functions
 defined on the module level. The module is simply imported wherever it is needed
 with the statement 'import Preferences'. Do not use 'from Preferences import *'
 to import it.
 """
 import sys
 import os
 import fnmatch
 import shutil
 from PyQt4 import QtCore, QtGui
 from PyQt4 import Qsci
 from PyQt4.QtWebKit import QWebSettings
 import QScintilla.Lexers
 from Globals import settingsNameOrganization, settingsNameGlobal, settingsNameRecent, \
     isWindowsPlatform
 from Project.ProjectBrowserFlags import SourcesBrowserFlag, FormsBrowserFlag, \
     ResourcesBrowserFlag, TranslationsBrowserFlag, InterfacesBrowserFlag, \
     OthersBrowserFlag, AllBrowsersFlag
 class Prefs(object):
     """
     A class to hold all configuration items for the application.
     """
     # defaults for the variables window
     varDefaults = {
         "LocalsFilter" : [],
         "GlobalsFilter" : []
     }
     # defaults for the debugger
     debuggerDefaults = {
         "RemoteDbgEnabled" : False,
         "RemoteHost" : "",
         "RemoteExecution" : "",
         "PassiveDbgEnabled" : False,
         "PassiveDbgPort" : 42424,
         "PassiveDbgType" : "Python",
         "AutomaticReset" : False,
         "Autosave" : False,
         "ThreeStateBreakPoints": False,
         "SuppressClientExit" : False,
         "BreakAlways" : False,
         "CustomPythonInterpreter" : False,
         "PythonInterpreter" : "",
         "Python3Interpreter" : "",
         "RubyInterpreter" : "/usr/bin/ruby",
         "DebugClientType" : "standard",     # supported "standard", "threaded", "custom"
         "DebugClient" : "",
         "DebugClientType3" : "standard",    # supported "standard", "threaded", "custom"
         "DebugClient3" : "",
         "PythonExtensions" : ".py .pyw .ptl", # space separated list of Python extensions
         "Python3Extensions" : ".py3 .pyw3",   # space separated list of Python3 extensions
         "DebugEnvironmentReplace" : False,
         "DebugEnvironment" : "",
         "PythonRedirect" : True,
         "PythonNoEncoding" : False,
         "Python3Redirect" : True,
         "Python3NoEncoding" : False,
         "RubyRedirect" : True,
         "ConsoleDbgEnabled" : False,
         "ConsoleDbgCommand" : "",
         "PathTranslation" : False,
         "PathTranslationRemote" : "",
         "PathTranslationLocal" : "",
         "NetworkInterface" : "127.0.0.1",
     }
     debuggerDefaults["AllowedHosts"] = ["127.0.0.1", "::1%0"]
     uiDefaults = {
         "Language" : "System",
         "Style" : "System",
         "StyleSheet" : "",
         "ViewManager" : "tabview",
         "LayoutType" : "Toolboxes",
         # allowed values are "DockWindows", "FloatingWindows", "Toolboxes" and "Sidebars"
         "LayoutShellEmbedded" : 0,          # 0 = separate
                                             # 1 = embedded in debug browser
         "LayoutFileBrowserEmbedded" : 1,    # 0 = separate
                                             # 1 = embedded in debug browser
                                             # 2 = embedded in project browser
         "BrowsersListFoldersFirst" : True,
         "BrowsersHideNonPublic" : False,
         "BrowsersListContentsByOccurrence" : False,
         "LogViewerAutoRaise" : True,
         "SingleApplicationMode" : False,
         "CaptionShowsFilename" : True,
         "CaptionFilenameLength" : 100,
         "RecentNumber" : 9,
         "TopLeftByLeft" : True,
         "BottomLeftByLeft" : False,
         "TopRightByRight" : True,
         "BottomRightByRight" : False,
         "TabViewManagerFilenameLength" : 40,
         "TabViewManagerFilenameOnly" : True,
         # the order in ViewProfiles is Project-Viewer, File-Browser,
         # Debug-Viewer, Python-Shell, Log-Viewer, Task-Viewer,
         # Templates-Viewer, Multiproject-Viewer, Terminal
         "ViewProfiles" : {
             "edit"  : [
                         # visibility (0)
                         [ True,  False,  False,  True,  True,  True,  True,  True, True],
                         # saved state main window with dock windows (1)
                         "",
                         # saved states floating windows (2)
                         ["", "", "", "", "", "", "", "", ""],
                         # saved state main window with floating windows (3)
                         "",
                         # saved state main window with toolbox windows (4)
                         "",
                         # visibility of the toolboxes (5)
                         [ True,  True],
                         # saved states of the splitters and sidebars of the
                         # sidebars layout (6)
                         ["", "", "", ""],
                       ],
             "debug" : [
                         # visibility (0)
                         [ False,  False,  True,  True,  True,  True,  False,  False, True],
                         # saved state main window with dock windows (1)
                         "",
                         # saved states floating windows (2)
                         ["", "", "", "", "", "", "", "", ""],
                         # saved state main window with floating windows (3)
                         "",
                         # saved state main window with toolbox windows (4)
                         "",
                         # visibility of the toolboxes (5)
                         [ False,  True],
                         # saved states of the splitters and sidebars of the
                         # sidebars layout (6)
                         ["", "", "", ""],
                       ],
         },
         "ToolbarManagerState" : QtCore.QByteArray(),
         "ShowSplash" : True,
         "SingleCloseButton" : True,
         "PerformVersionCheck" : 4,      # 0 = off
                                         # 1 = at startup
                                         # 2 = daily
                                         # 3 = weekly
                                         # 4 = monthly
         "UseProxy" : False,
         "ProxyHost" : "",
         "ProxyPort" : 80,
         "ProxyUser" : "",
         "ProxyPassword" : "",
         "ProxyType" : 0,            # 0 = transparent HTTP proxy
                                     # 1 = caching HTTP proxy
                                     # 2 = SOCKS5 proxy
         "PluginRepositoryUrl5" : \
             "http://die-offenbachs.homelinux.org/eric/plugins5/repository.xml",
         "VersionsUrls5" : [
             "http://die-offenbachs.homelinux.org/eric/snapshots5/versions",
             "http://eric-ide.python-projects.org/snapshots5/versions",
         ],
         "OpenOnStartup" : 0,        # 0 = nothing
                                     # 1 = last file
                                     # 2 = last project
                                     # 3 = last multiproject
                                     # 4 = last global session
         "DownloadPath" : "",
         "RequestDownloadFilename" : True,
         "CheckErrorLog" : True,
         "LogStdErrColour" : QtGui.QColor(QtCore.Qt.red),
     }
     viewProfilesLength = len(uiDefaults["ViewProfiles"]["edit"][2])
     iconsDefaults = {
         "Path" : [],
     }
     # defaults for the editor settings
     editorDefaults = {
         "AutosaveInterval" : 0,
         "TabWidth" : 4,
         "IndentWidth" : 4,
         "LinenoWidth" : 4,
         "IndentationGuides" : True,
         "UnifiedMargins" : False,
         "LinenoMargin" : True,
         "FoldingMargin" : True,
         "FoldingStyle" : 1,
         "TabForIndentation" : False,
         "TabIndents" : True,
         "ConvertTabsOnLoad" : False,
         "AutomaticEOLConversion" : True,
         "ShowWhitespace" : False,
         "ShowEOL" : False,
         "UseMonospacedFont" : False,
         "WrapLongLines" : False,
         "WarnFilesize" : 512,
         "ClearBreaksOnClose" : True,
         "StripTrailingWhitespace" : False,
         "CommentColumn0" : True,
         "EdgeMode" : Qsci.QsciScintilla.EdgeNone,
         "EdgeColumn" : 80,
         "AutoIndentation" : True,
         "BraceHighlighting" : True,
         "CreateBackupFile" : False,
         "CaretLineVisible" : False,
         "CaretWidth" : 1,
         "ColourizeSelText" : False,
         "CustomSelectionColours" : False,
         "ExtendSelectionToEol" : False,
         "AutoPrepareAPIs" : False,
         "AutoCompletionEnabled" : False,
         "AutoCompletionCaseSensitivity" : True,
         "AutoCompletionReplaceWord" : False,
         "AutoCompletionShowSingle" : False,
         "AutoCompletionSource" : Qsci.QsciScintilla.AcsDocument,
         "AutoCompletionThreshold" : 2,
         "AutoCompletionFillups" : False,
         "CallTipsEnabled" : False,
         "CallTipsVisible" : 0,
         "CallTipsStyle"   : Qsci.QsciScintilla.CallTipsNoContext,
         "CallTipsScintillaOnFail" : False,  # show QScintilla calltips, if plugin fails
         "AutoCheckSyntax" : True,
         "AutoReopen" : False,
         "MiniContextMenu" : False,
         "SearchMarkersEnabled" : True,
         "QuickSearchMarkersEnabled" : True,
         "MarkOccurrencesEnabled" : True,
         "MarkOccurrencesTimeout" : 500,     # 500 milliseconds
         "AdvancedEncodingDetection" : True,
         "SpellCheckingEnabled" : True,
         "AutoSpellCheckingEnabled" : True,
         "AutoSpellCheckChunkSize" : 30,
         "SpellCheckStringsOnly" : True,
         "SpellCheckingMinWordSize" : 3,
         "SpellCheckingDefaultLanguage" : "en",
         "SpellCheckingPersonalWordList" : "",
         "SpellCheckingPersonalExcludeList" : "",
         "DefaultEncoding" : "utf-8",
         "DefaultOpenFilter" : "",
         "DefaultSaveFilter" : "",
         # All (most) lexers
         "AllFoldCompact" : True,
         # Bash specifics
         "BashFoldComment" : True,
         # CMake specifics
         "CMakeFoldAtElse" : False,
         # C++ specifics
         "CppCaseInsensitiveKeywords" : False,
         "CppFoldComment" : True,
         "CppFoldPreprocessor" : False,
         "CppFoldAtElse" : False,
         "CppIndentOpeningBrace" : False,
         "CppIndentClosingBrace" : False,
         "CppDollarsAllowed" : True,
         # CSS specifics
         "CssFoldComment" : True,
         # D specifics
         "DFoldComment" : True,
         "DFoldAtElse" : False,
         "DIndentOpeningBrace" : False,
         "DIndentClosingBrace" : False,
         # HTML specifics
         "HtmlFoldPreprocessor" : False,
         "HtmlFoldScriptComments" : False,
         "HtmlFoldScriptHeredocs" : False,
         "HtmlCaseSensitiveTags" : False,
         # Pascal specifics
         "PascalFoldComment" : True,
         "PascalFoldPreprocessor" : False,
         "PascalSmartHighlighting" : True,
         # Perl specifics
         "PerlFoldComment" : True,
         "PerlFoldPackages" : True,
         "PerlFoldPODBlocks" : True,
         # PostScript specifics
         "PostScriptTokenize" : False,
         "PostScriptLevel" : 3,
         "PostScriptFoldAtElse" : False,
         # Povray specifics
         "PovFoldComment" : True,
         "PovFoldDirectives" : False,
         # Python specifics
         "PythonBadIndentation" : True,
         "PythonFoldComment" : True,
         "PythonFoldString" : True,
         "PythonAutoIndent" : True,
         "PythonAllowV2Unicode" : True,
         "PythonAllowV3Binary" : True,
         "PythonAllowV3Bytes" : True,
         # SQL specifics
         "SqlFoldComment" : True,
         "SqlBackslashEscapes" : False,
         # VHDL specifics
         "VHDLFoldComment" : True,
         "VHDLFoldAtElse" : True,
         "VHDLFoldAtBegin" : True,
         "VHDLFoldAtParenthesis" : True,
         # XML specifics
         "XMLStyleScripts" : True,
         # YAML specifics
         "YAMLFoldComment" : False,
     }
     if isWindowsPlatform():
         editorDefaults["EOLMode"] = Qsci.QsciScintilla.EolWindows
     else:
         editorDefaults["EOLMode"] = Qsci.QsciScintilla.EolUnix
     editorColourDefaults = {
         "CurrentMarker"        : QtGui.QColor(QtCore.Qt.yellow),
         "ErrorMarker"          : QtGui.QColor(QtCore.Qt.red),
         "MatchingBrace"        : QtGui.QColor(QtCore.Qt.green),
         "MatchingBraceBack"    : QtGui.QColor(QtCore.Qt.white),
         "NonmatchingBrace"     : QtGui.QColor(QtCore.Qt.red),
         "NonmatchingBraceBack" : QtGui.QColor(QtCore.Qt.white),
         "CallTipsBackground"   : QtGui.QColor(QtCore.Qt.white),
         "CaretForeground"      : QtGui.QColor(QtCore.Qt.black),
         "CaretLineBackground"  : QtGui.QColor(QtCore.Qt.white),
         "Edge"                 : QtGui.QColor(QtCore.Qt.lightGray),
         "SelectionBackground"  : QtGui.QColor(QtCore.Qt.black),
         "SelectionForeground"  : QtGui.QColor(QtCore.Qt.white),
         "SearchMarkers"        : QtGui.QColor(QtCore.Qt.blue),
         "MarginsBackground"    : QtGui.QColor(QtCore.Qt.lightGray),
         "MarginsForeground"    : QtGui.QColor(QtCore.Qt.black),
         "FoldmarginBackground" : QtGui.QColor(230, 230, 230),
         "SpellingMarkers"      : QtGui.QColor(QtCore.Qt.red),
     }
     editorOtherFontsDefaults = {
         "MarginsFont"    : "Sans Serif,10,-1,5,50,0,0,0,0,0",
         "DefaultFont"    : "Sans Serif,10,-1,5,50,0,0,0,0,0",
         "MonospacedFont" : "Courier,10,-1,5,50,0,0,0,0,0",
     }
     editorTypingDefaults = {
         "Python/EnabledTypingAids"  : True,
         "Python/InsertClosingBrace" : True,
         "Python/IndentBrace"        : True,
         "Python/SkipBrace"          : True,
         "Python/InsertQuote"        : True,
         "Python/DedentElse"         : True,
         "Python/DedentExcept"       : True,
         "Python/Py24StyleTry"       : True,
         "Python/InsertImport"       : True,
         "Python/InsertSelf"         : True,
         "Python/InsertBlank"        : True,
         "Python/ColonDetection"     : True,
         "Python/DedentDef"          : False,
         "Ruby/EnabledTypingAids"    : True,
         "Ruby/InsertClosingBrace"   : True,
         "Ruby/IndentBrace"          : True,
         "Ruby/SkipBrace"            : True,
         "Ruby/InsertQuote"          : True,
         "Ruby/InsertBlank"          : True,
         "Ruby/InsertHereDoc"        : True,
         "Ruby/InsertInlineDoc"      : True,
     }
     editorExporterDefaults = {
         "HTML/WYSIWYG"          : True,
         "HTML/Folding"          : False,
         "HTML/OnlyStylesUsed"   : False,
         "HTML/FullPathAsTitle"  : False,
         "HTML/UseTabs"          : False,
         "RTF/WYSIWYG"           : True,
         "RTF/UseTabs"           : False,
         "RTF/Font"              : "Courier New,10,-1,5,50,0,0,0,0,0",
         "PDF/Magnification"     : 0,
         "PDF/Font"              : "Helvetica",  # must be Courier, Helvetica or Times
         "PDF/PageSize"          : "A4",         # must be A4 or Letter
         "PDF/MarginLeft"        : 36,
         "PDF/MarginRight"       : 36,
         "PDF/MarginTop"         : 36,
         "PDF/MarginBottom"      : 36,
         "TeX/OnlyStylesUsed"    : False,
         "TeX/FullPathAsTitle"   : False,
     }
     # defaults for the printer settings
     printerDefaults = {
         "PrinterName" : "",
         "ColorMode" : True,
         "FirstPageFirst" : True,
         "Magnification" : -3,
         "Orientation" : 0,
         "PageSize": 0,
         "HeaderFont" : "Serif,10,-1,5,50,0,0,0,0,0",
         "LeftMargin" : 1.0,
         "RightMargin" : 1.0,
         "TopMargin" : 1.0,
         "BottomMargin" : 1.0,
     }
     # defaults for the project settings
     projectDefaults = {
         "SearchNewFiles" : False,
         "SearchNewFilesRecursively" : False,
         "AutoIncludeNewFiles" : False,
         "AutoLoadSession" : False,
         "AutoSaveSession" : False,
         "SessionAllBreakpoints" : False,
         "CompressedProjectFiles" : False,
         "XMLTimestamp" : True,
         "AutoCompileForms" : False,
         "AutoCompileResources" : False,
         "AutoLoadDbgProperties" : False,
         "AutoSaveDbgProperties" : False,
         "HideGeneratedForms" : False,
         "FollowEditor" : True,
         "RecentNumber" : 9,
     }
     # defaults for the multi project settings
     multiProjectDefaults = {
         "OpenMasterAutomatically" : True,
         "XMLTimestamp" : True,
         "RecentNumber" : 9,
     }
     # defaults for the project browser flags settings
     projectBrowserFlagsDefaults = {
         "Qt4" :
             SourcesBrowserFlag | \
             FormsBrowserFlag | \
             ResourcesBrowserFlag | \
             TranslationsBrowserFlag | \
             InterfacesBrowserFlag | \
             OthersBrowserFlag,
         "Qt4C" :
             SourcesBrowserFlag | \
             ResourcesBrowserFlag | \
             TranslationsBrowserFlag | \
             InterfacesBrowserFlag | \
             OthersBrowserFlag,
         "E4Plugin" :
             SourcesBrowserFlag | \
             FormsBrowserFlag | \
             ResourcesBrowserFlag | \
             TranslationsBrowserFlag | \
             InterfacesBrowserFlag | \
             OthersBrowserFlag,
         "Console" :
             SourcesBrowserFlag | \
             InterfacesBrowserFlag | \
             OthersBrowserFlag,
         "Other" :
             SourcesBrowserFlag | \
             InterfacesBrowserFlag | \
             OthersBrowserFlag,
         "PySide" :
             SourcesBrowserFlag | \
             FormsBrowserFlag | \
             ResourcesBrowserFlag | \
             TranslationsBrowserFlag | \
             InterfacesBrowserFlag | \
             OthersBrowserFlag,
         "PySideC" :
             SourcesBrowserFlag | \
             ResourcesBrowserFlag | \
             TranslationsBrowserFlag | \
             InterfacesBrowserFlag | \
             OthersBrowserFlag,
     }
     # defaults for the project browser colour settings
     projectBrowserColourDefaults = {
         "Highlighted" : QtGui.QColor(QtCore.Qt.red),
         "VcsAdded"    : QtGui.QColor(QtCore.Qt.blue),
         "VcsConflict" : QtGui.QColor(QtCore.Qt.red),
         "VcsModified" : QtGui.QColor(QtCore.Qt.yellow),
         "VcsReplaced" : QtGui.QColor(QtCore.Qt.cyan),
         "VcsUpdate"   : QtGui.QColor(QtCore.Qt.green),
     }
     # defaults for the help settings
     helpDefaults = {
         "HelpViewerType" : 1,      # this coresponds with the radio button id
         "CustomViewer" : "",
         "PythonDocDir" : "",
         "QtDocDir" : "",
         "Qt4DocDir" : "",
         "PyQt4DocDir" : "",
         "PySideDocDir" : "",
         "SingleHelpWindow" : True,
         "SaveGeometry" : True,
         "HelpViewerState" : QtCore.QByteArray(),
         "WebSearchSuggestions" : True,
         "WebSearchEngine" : "Google",
         "WebSearchKeywords" : [],   # array of two tuples (keyword, search engine name)
         "DiskCacheEnabled" : True,
         "DiskCacheSize" : 50,       # 50 MB
         "AcceptCookies" : 2,        # CookieJar.AcceptOnlyFromSitesNavigatedTo
         "KeepCookiesUntil" : 0,     # CookieJar.KeepUntilExpire
         "FilterTrackingCookies" : True,
         "PrintBackgrounds" : False,
         "StartupBehavior" : 0,      # show home page
         "HomePage": "pyrc:home",
         "HistoryLimit" : 30,
         "DefaultScheme" : "file://",
         "SavePasswords" : False,
         "AdBlockEnabled" : False,
         "AdBlockSubscriptions" : [],
     }
     websettings = QWebSettings.globalSettings()
     fontFamily = websettings.fontFamily(QWebSettings.StandardFont)
     fontSize = websettings.fontSize(QWebSettings.DefaultFontSize)
     helpDefaults["StandardFont"] = QtGui.QFont(fontFamily, fontSize).toString()
     fontFamily = websettings.fontFamily(QWebSettings.FixedFont)
     fontSize = websettings.fontSize(QWebSettings.DefaultFixedFontSize)
     helpDefaults["FixedFont"] = QtGui.QFont(fontFamily, fontSize).toString()
     helpDefaults.update({
         "AutoLoadImages" :
             websettings.testAttribute(QWebSettings.AutoLoadImages),
         "UserStyleSheet" : "",
         "SaveUrlColor" : QtGui.QColor(248, 248, 210),
         "JavaEnabled" :
             websettings.testAttribute(QWebSettings.JavaEnabled),
         "JavaScriptEnabled" :
             websettings.testAttribute(QWebSettings.JavascriptEnabled),
         "JavaScriptCanOpenWindows" :
             websettings.testAttribute(QWebSettings.JavascriptCanOpenWindows),
         "JavaScriptCanAccessClipboard" :
             websettings.testAttribute(QWebSettings.JavascriptCanAccessClipboard),
         "PluginsEnabled" :
             websettings.testAttribute(QWebSettings.PluginsEnabled),
     })
     # defaults for system settings
     sysDefaults = {
         "StringEncoding" : "utf-8",
         "IOEncoding"     : "utf-8",
     }
     # defaults for the shell settings
     shellDefaults = {
         "LinenoWidth" : 4,
         "LinenoMargin" : True,
         "AutoCompletionEnabled" : True,
         "CallTipsEnabled" : True,
         "WrapEnabled" : True,
         "MaxHistoryEntries" : 100,
         "SyntaxHighlightingEnabled" : True,
         "ShowStdOutErr" : True,
         "UseMonospacedFont" : False,
         "MonospacedFont" : "Courier,10,-1,5,50,0,0,0,0,0",
         "MarginsFont" : "Sans Serif,10,-1,5,50,0,0,0,0,0",
     }
     # defaults for the terminal settings
     terminalDefaults = {
         "LinenoWidth" : 4,
         "LinenoMargin" : True,
         "MaxHistoryEntries" : 100,
         "SyntaxHighlightingEnabled" : True,
         "Shell" : "",
         "ShellInteractive" : True,
         "UseMonospacedFont" : False,
         "MonospacedFont" : "Courier,10,-1,5,50,0,0,0,0,0",
         "MarginsFont" : "Sans Serif,10,-1,5,50,0,0,0,0,0",
     }
     if sys.platform.lower().startswith("linux"):
         terminalDefaults["Shell"] = "bash"
     # defaults for Qt related stuff
     qtDefaults = {
         "Qt4TranslationsDir" : "",
         "QtToolsPrefix4" : "",
         "QtToolsPostfix4" : "",
         "Qt4Dir" : "",
     }
     # defaults for corba related stuff
     corbaDefaults = {
         "omniidl" : "omniidl"
     }
     # defaults for user related stuff
     userDefaults = {
         "Email" : "",
         "MailServer" : "",
         "Signature" : "",
         "MailServerAuthentication" : False,
         "MailServerUser" : "",
         "MailServerPassword" : "",
         "MailServerUseTLS" : False,
         "MailServerPort" : 25,
         "UseSystemEmailClient" : False,
     }
     # defaults for vcs related stuff
     vcsDefaults = {
         "AutoClose" : False,
         "AutoSaveFiles" : True,
         "AutoSaveProject" : True,
         "AutoUpdate" : False,
         "StatusMonitorInterval" : 30,
         "MonitorLocalStatus" : False,
     }
     # defaults for tasks related stuff
     tasksDefaults = {
         "TasksMarkers"       : "TO" + "DO:",
         "TasksMarkersBugfix" : "FIX" + "ME:",
         # needed to keep it from being recognized as a task
         "TasksColour"          : QtGui.QColor(QtCore.Qt.black),
         "TasksBugfixColour"    : QtGui.QColor(QtCore.Qt.red),
         "TasksBgColour"        : QtGui.QColor(QtCore.Qt.white),
         "TasksProjectBgColour" : QtGui.QColor(QtCore.Qt.lightGray),
     }
     # defaults for templates related stuff
     templatesDefaults = {
         "AutoOpenGroups" : True,
         "SingleDialog"   : False,
         "ShowTooltip"    : False,
         "SeparatorChar"  : "$",
     }
     # defaults for plugin manager related stuff
     pluginManagerDefaults = {
         "ActivateExternal" : True,
         "DownloadPath" : ""
     }
     # defaults for the printer settings
     graphicsDefaults = {
         "Font" : "SansSerif,10,-1,5,50,0,0,0,0,0"
     }
     # defaults for the icon editor
     iconEditorDefaults = {
         "IconEditorState" : QtCore.QByteArray(),
     }
     # defaults for geometry
     geometryDefaults = {
         "HelpViewerGeometry" : QtCore.QByteArray(),
         "IconEditorGeometry" : QtCore.QByteArray(),
         "MainGeometry"       : QtCore.QByteArray(),
         "MainMaximized"      : False,
     }
     # if true, revert layouts to factory defaults
     resetLayout = False
 def readToolGroups(prefClass = Prefs):
     """
     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))
     for groupIndex in range(groups):
         groupName = \
             prefClass.settings.value("Toolgroups/%02d/Name" % groupIndex)
         group = [groupName, []]
         items = int(prefClass.settings.value("Toolgroups/%02d/Items" % groupIndex, 0))
         for ind in range(items):
             menutext = prefClass.settings.value(\
                 "Toolgroups/%02d/%02d/Menutext" % (groupIndex, ind))
             icon = prefClass.settings.value(\
                 "Toolgroups/%02d/%02d/Icon" % (groupIndex, ind))
             executable = prefClass.settings.value(\
                 "Toolgroups/%02d/%02d/Executable" % (groupIndex, ind))
             arguments = prefClass.settings.value(\
                 "Toolgroups/%02d/%02d/Arguments" % (groupIndex, ind))
             redirect = prefClass.settings.value(\
                 "Toolgroups/%02d/%02d/Redirect" % (groupIndex, ind))
             if menutext:
                 if menutext == '--':
                     tool = {
                         'menutext' : '--',
                         'icon' : '',
                         'executable' : '',
                         'arguments' : '',
                         'redirect' : 'no',
                     }
                     group[1].append(tool)
                 elif executable:
                     tool = {
                         'menutext' : menutext,
                         'icon' : icon,
                         'executable' : executable,
                         'arguments' : arguments,
                         'redirect' : redirect,
                     }
                     group[1].append(tool)
         toolGroups.append(group)
     currentGroup = int(prefClass.settings.value("Toolgroups/Current Group", -1))
     return toolGroups, currentGroup
 def saveToolGroups(toolGroups, currentGroup, prefClass = Prefs):
     """
     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")
     # second step, write the tool group entries
     prefClass.settings.setValue("Toolgroups/Groups", len(toolGroups))
     groupIndex = 0
     for group in toolGroups:
         prefClass.settings.setValue("Toolgroups/%02d/Name" % groupIndex, group[0])
         prefClass.settings.setValue("Toolgroups/%02d/Items" % groupIndex, len(group[1]))
         ind = 0
         for tool in group[1]:
             prefClass.settings.setValue(\
                 "Toolgroups/%02d/%02d/Menutext" % (groupIndex, ind), tool['menutext'])
             prefClass.settings.setValue(\
                 "Toolgroups/%02d/%02d/Icon" % (groupIndex, ind), tool['icon'])
             prefClass.settings.setValue(\
                 "Toolgroups/%02d/%02d/Executable" % (groupIndex, ind), tool['executable'])
             prefClass.settings.setValue(\
                 "Toolgroups/%02d/%02d/Arguments" % (groupIndex, ind), tool['arguments'])
             prefClass.settings.setValue(\
                 "Toolgroups/%02d/%02d/Redirect" % (groupIndex, ind), tool['redirect'])
             ind += 1
         groupIndex += 1
     prefClass.settings.setValue("Toolgroups/Current Group", currentGroup)
 def initPreferences():
     """
     Module function to initialize the central configuration store.
     """
     Prefs.settings = QtCore.QSettings(
         QtCore.QSettings.IniFormat, QtCore.QSettings.UserScope,
         settingsNameOrganization, settingsNameGlobal)
     if not isWindowsPlatform():
         hp = QtCore.QDir.homePath()
         dn = QtCore.QDir(hp)
         dn.mkdir(".eric4")
     QtCore.QCoreApplication.setOrganizationName(settingsNameOrganization)
     QtCore.QCoreApplication.setApplicationName(settingsNameGlobal)
 def syncPreferences(prefClass = Prefs):
     """
     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)
     initPreferences()
 def exportPreferences(prefClass = Prefs):
     """
     Module function to export the current preferences.
     @param prefClass preferences class used as the storage area
     """
     filename = QtGui.QFileDialog.getSaveFileName(\
         None,
         QtCore.QCoreApplication.translate("Preferences", "Export Preferences"),
         "",
         "",
         QtGui.QFileDialog.Options(QtGui.QFileDialog.DontConfirmOverwrite))
     if filename:
         settingsFile = prefClass.settings.fileName()
         prefClass.settings = None
         shutil.copy(settingsFile, filename)
         initPreferences()
 def importPreferences(prefClass = Prefs):
     """
     Module function to import preferences from a file previously saved by
     the export function.
     @param prefClass preferences class used as the storage area
     """
     filename = QtGui.QFileDialog.getOpenFileName(\
         None,
         QtCore.QCoreApplication.translate("Preferences", "Import Preferences"),
         "",
         "")
     if filename:
         settingsFile = prefClass.settings.fileName()
         shutil.copy(filename, settingsFile)
         initPreferences()
 def isConfigured(prefClass = Prefs):
     """
     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))
 def initRecentSettings():
     """
     Module function to initialize the central configuration store for recently
     opened files and projects.
     This function is called once upon import of the module.
     """
     Prefs.rsettings = QtCore.QSettings(
         QtCore.QSettings.IniFormat, QtCore.QSettings.UserScope,
         settingsNameOrganization, settingsNameRecent)
 def getVarFilters(prefClass = Prefs):
     """
     Module function to retrieve the variables filter settings.
     @param prefClass preferences class used as the storage area
     @return a tuple defing the variables filter
     """
     localsFilter = eval(prefClass.settings.value("Variables/LocalsFilter",
         prefClass.varDefaults["LocalsFilter"]))
     globalsFilter = eval(prefClass.settings.value("Variables/GlobalsFilter",
         prefClass.varDefaults["GlobalsFilter"]))
     return (localsFilter, globalsFilter)
 def setVarFilters(filters, prefClass = Prefs):
     """
     Module function to store the variables filter settings.
     @param prefClass preferences class used as the storage area
     """
     prefClass.settings.setValue("Variables/LocalsFilter", unicode(filters[0]))
     prefClass.settings.setValue("Variables/GlobalsFilter", unicode(filters[1]))
 def getDebugger(key, prefClass = Prefs):
     """
     Module function to retrieve the debugger 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 in ["RemoteDbgEnabled", "PassiveDbgEnabled",
                 "CustomPythonInterpreter",
                 "AutomaticReset", "DebugEnvironmentReplace",
                 "PythonRedirect", "PythonNoEncoding",
                 "Python3Redirect", "Python3NoEncoding",
                 "RubyRedirect",
                 "ConsoleDbgEnabled", "PathTranslation",
                 "Autosave", "ThreeStateBreakPoints",
                 "SuppressClientExit", "BreakAlways",
               ]:
         return toBool(prefClass.settings.value("Debugger/" + key,
             prefClass.debuggerDefaults[key]))
     elif key in ["PassiveDbgPort"]:
         return int(
             prefClass.settings.value("Debugger/" + key, prefClass.debuggerDefaults[key]))
     elif key in ["AllowedHosts"]:
         return toList(
             prefClass.settings.value("Debugger/" + key, prefClass.debuggerDefaults[key]))
     else:
         return \
             prefClass.settings.value("Debugger/" + key, prefClass.debuggerDefaults[key])
 def setDebugger(key, value, prefClass = Prefs):
     """
     Module function to store the debugger 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("Debugger/" + key, value)
 def getPython(key, prefClass = Prefs):
     """
     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 in ["PythonExtensions", "Python3Extensions"]:
         exts = []
         for ext in getDebugger(key, prefClass).split():
             if ext.startswith("."):
                 exts.append(ext)
             else:
                 exts.append(".%s" % ext)
         return exts
 def setPython(key, value, prefClass = Prefs):
     """
     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 in ["PythonExtensions", "Python3Extensions"]:
         setDebugger(key, value, prefClass)
 def getUILanguage(prefClass = Prefs):
     """
     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"])
     if lang == "None" or lang == "" or lang is None:
         return None
     else:
         return lang
 def setUILanguage(lang, prefClass = Prefs):
     """
     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")
     else:
         prefClass.settings.setValue("UI/Language", lang)
 def getUILayout(prefClass = Prefs):
     """
     Module function to retrieve the layout for the user interface.
     @param prefClass preferences class used as the storage area
     @return the UI layout as a tuple of main layout, flag for
         an embedded shell and a value for an embedded file browser
     """
     layout = (\
         prefClass.settings.value("UI/LayoutType",
             prefClass.uiDefaults["LayoutType"]),
         toBool(prefClass.settings.value("UI/LayoutShellEmbedded",
             prefClass.uiDefaults["LayoutShellEmbedded"])),
         toBool(prefClass.settings.value("UI/LayoutFileBrowserEmbedded",
             prefClass.uiDefaults["LayoutFileBrowserEmbedded"])),
     )
     return layout
 def setUILayout(layout, prefClass = Prefs):
     """
     Module function to store the layout for the user interface.
     @param layout the layout type
     @param prefClass preferences class used as the storage area
     """
     prefClass.settings.setValue("UI/LayoutType", layout[0])
     prefClass.settings.setValue("UI/LayoutShellEmbedded", layout[1])
     prefClass.settings.setValue("UI/LayoutFileBrowserEmbedded", layout[2])
 def getViewManager(prefClass = Prefs):
     """
     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"])
 def setViewManager(vm, prefClass = Prefs):
     """
     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)
 def getUI(key, prefClass = Prefs):
     """
     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",
                 "BrowsersListContentsByOccurrence", "LogViewerAutoRaise",
                 "SingleApplicationMode", "TabViewManagerFilenameOnly",
                 "CaptionShowsFilename", "RecentNumber", "ShowSplash",
                 "SingleCloseButton", "UseProxy",
                 "TopLeftByLeft", "BottomLeftByLeft",
                 "TopRightByRight", "BottomRightByRight",
                 "RequestDownloadFilename",
                 "LayoutShellEmbedded", "LayoutFileBrowserEmbedded",
                 "CheckErrorLog"]:
         return toBool(prefClass.settings.value("UI/" + key,
             prefClass.uiDefaults[key]))
     elif key in ["TabViewManagerFilenameLength", "CaptionFilenameLength",
                  "ProxyPort", "ProxyType", "OpenOnStartup",
                  "PerformVersionCheck", ]:
         return int(prefClass.settings.value("UI/" + key,
             prefClass.uiDefaults[key]))
     elif key == "ProxyPassword":
         from Utilities import pwDecode
         return pwDecode(prefClass.settings.value("UI/" + key, prefClass.uiDefaults[key]))
     elif key in ["LogStdErrColour"]:
         col = prefClass.settings.value("UI/" + key)
         if col is not None:
             return QtGui.QColor(col)
         else:
             return prefClass.uiDefaults[key]
     elif key == "ViewProfiles":
         profiles = prefClass.settings.value("UI/ViewProfiles")
         if profiles is not None:
             viewProfiles = eval(profiles)
             for name in ["edit", "debug"]:
                 # adjust entries for individual windows
                 vpLength = len(viewProfiles[name][0])
                 if vpLength < prefClass.viewProfilesLength:
                     viewProfiles[name][0].extend(\
                         prefClass.uiDefaults["ViewProfiles"][name][0][vpLength:])
                 vpLength = len(viewProfiles[name][2])
                 if vpLength < prefClass.viewProfilesLength:
                     viewProfiles[name][2].extend(\
                         prefClass.uiDefaults["ViewProfiles"][name][2][vpLength:])
                 # adjust profile
                 vpLength = len(viewProfiles[name])
                 if vpLength < len(prefClass.uiDefaults["ViewProfiles"][name]):
                     viewProfiles[name].extend(
                         prefClass.uiDefaults["ViewProfiles"][name][vpLength:])
         else:
             viewProfiles = prefClass.uiDefaults["ViewProfiles"]
         return viewProfiles
     elif key == "ToolbarManagerState":
         toolbarManagerState = prefClass.settings.value("UI/ToolbarManagerState")
         if toolbarManagerState is not None:
             return toolbarManagerState
         else:
             return prefClass.uiDefaults["ToolbarManagerState"]
     elif key in ["VersionsUrls5"]:
         return toList(prefClass.settings.value("UI/" + key, prefClass.uiDefaults[key]))
     else:
         return prefClass.settings.value("UI/" + key, prefClass.uiDefaults[key])
 def setUI(key, value, prefClass = Prefs):
     """
     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":
         prefClass.settings.setValue("UI/" + key, unicode(value))
     elif key == "LogStdErrColour":
         prefClass.settings.setValue("UI/" + key, value.name())
     elif key == "ProxyPassword":
         from Utilities import pwEncode
         prefClass.settings.setValue("UI/" + key, pwEncode(value))
     else:
         prefClass.settings.setValue("UI/" + key, value)
 def getIcons(key, prefClass = Prefs):
     """
     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)
     if dirlist is not None:
         return dirlist
     else:
         return prefClass.iconsDefaults[key]
 def setIcons(key, value, prefClass = Prefs):
     """
     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)
 def getEditor(key, prefClass = Prefs):
     """
     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",
                "SpellCheckingDefaultLanguage", "SpellCheckingPersonalWordList",
                "SpellCheckingPersonalExcludeList"]:
         return prefClass.settings.value("Editor/" + key, prefClass.editorDefaults[key])
     elif key in ["AutosaveInterval", "TabWidth", "IndentWidth", "LinenoWidth",
                  "FoldingStyle", "WarnFilesize", "EdgeMode", "EdgeColumn",
                  "CaretWidth", "AutoCompletionSource", "AutoCompletionThreshold",
                  "CallTipsVisible", "CallTipsStyle", "MarkOccurrencesTimeout",
                  "AutoSpellCheckChunkSize", "SpellCheckingMinWordSize",
                  "PostScriptLevel", "EOLMode"]:
         return int(prefClass.settings.value("Editor/" + key,
             prefClass.editorDefaults[key]))
 




de9c2efb9d02
Started porting eric4 to Python3

Detlev Offenbach