mirror of https://github.com/python/cpython
721 lines
29 KiB
Python
721 lines
29 KiB
Python
"""Provides access to stored IDLE configuration information.
|
|
|
|
Refer to the comments at the beginning of config-main.def for a description of
|
|
the available configuration files and the design implemented to update user
|
|
configuration information. In particular, user configuration choices which
|
|
duplicate the defaults will be removed from the user's configuration files,
|
|
and if a file becomes empty, it will be deleted.
|
|
|
|
The contents of the user files may be altered using the Options/Configure IDLE
|
|
menu to access the configuration GUI (configDialog.py), or manually.
|
|
|
|
Throughout this module there is an emphasis on returning useable defaults
|
|
when a problem occurs in returning a requested configuration value back to
|
|
idle. This is to allow IDLE to continue to function in spite of errors in
|
|
the retrieval of config information. When a default is returned instead of
|
|
a requested config value, a message is printed to stderr to aid in
|
|
configuration problem notification and resolution.
|
|
|
|
"""
|
|
import os
|
|
import sys
|
|
|
|
from idlelib import macosxSupport
|
|
from configparser import ConfigParser, NoOptionError, NoSectionError
|
|
|
|
class InvalidConfigType(Exception): pass
|
|
class InvalidConfigSet(Exception): pass
|
|
class InvalidFgBg(Exception): pass
|
|
class InvalidTheme(Exception): pass
|
|
|
|
class IdleConfParser(ConfigParser):
|
|
"""
|
|
A ConfigParser specialised for idle configuration file handling
|
|
"""
|
|
def __init__(self, cfgFile, cfgDefaults=None):
|
|
"""
|
|
cfgFile - string, fully specified configuration file name
|
|
"""
|
|
self.file=cfgFile
|
|
ConfigParser.__init__(self,defaults=cfgDefaults)
|
|
|
|
def Get(self, section, option, type=None, default=None, raw=False):
|
|
"""
|
|
Get an option value for given section/option or return default.
|
|
If type is specified, return as type.
|
|
"""
|
|
if not self.has_option(section, option):
|
|
return default
|
|
if type=='bool':
|
|
return self.getboolean(section, option)
|
|
elif type=='int':
|
|
return self.getint(section, option)
|
|
else:
|
|
return self.get(section, option, raw=raw)
|
|
|
|
def GetOptionList(self,section):
|
|
"""
|
|
Get an option list for given section
|
|
"""
|
|
if self.has_section(section):
|
|
return self.options(section)
|
|
else: #return a default value
|
|
return []
|
|
|
|
def Load(self):
|
|
"""
|
|
Load the configuration file from disk
|
|
"""
|
|
self.read(self.file)
|
|
|
|
class IdleUserConfParser(IdleConfParser):
|
|
"""
|
|
IdleConfigParser specialised for user configuration handling.
|
|
"""
|
|
|
|
def AddSection(self,section):
|
|
"""
|
|
if section doesn't exist, add it
|
|
"""
|
|
if not self.has_section(section):
|
|
self.add_section(section)
|
|
|
|
def RemoveEmptySections(self):
|
|
"""
|
|
remove any sections that have no options
|
|
"""
|
|
for section in self.sections():
|
|
if not self.GetOptionList(section):
|
|
self.remove_section(section)
|
|
|
|
def IsEmpty(self):
|
|
"""
|
|
Remove empty sections and then return 1 if parser has no sections
|
|
left, else return 0.
|
|
"""
|
|
self.RemoveEmptySections()
|
|
if self.sections():
|
|
return 0
|
|
else:
|
|
return 1
|
|
|
|
def RemoveOption(self,section,option):
|
|
"""
|
|
If section/option exists, remove it.
|
|
Returns 1 if option was removed, 0 otherwise.
|
|
"""
|
|
if self.has_section(section):
|
|
return self.remove_option(section,option)
|
|
|
|
def SetOption(self,section,option,value):
|
|
"""
|
|
Sets option to value, adding section if required.
|
|
Returns 1 if option was added or changed, otherwise 0.
|
|
"""
|
|
if self.has_option(section,option):
|
|
if self.get(section,option)==value:
|
|
return 0
|
|
else:
|
|
self.set(section,option,value)
|
|
return 1
|
|
else:
|
|
if not self.has_section(section):
|
|
self.add_section(section)
|
|
self.set(section,option,value)
|
|
return 1
|
|
|
|
def RemoveFile(self):
|
|
"""
|
|
Removes the user config file from disk if it exists.
|
|
"""
|
|
if os.path.exists(self.file):
|
|
os.remove(self.file)
|
|
|
|
def Save(self):
|
|
"""Update user configuration file.
|
|
|
|
Remove empty sections. If resulting config isn't empty, write the file
|
|
to disk. If config is empty, remove the file from disk if it exists.
|
|
|
|
"""
|
|
if not self.IsEmpty():
|
|
fname = self.file
|
|
try:
|
|
cfgFile = open(fname, 'w')
|
|
except IOError:
|
|
os.unlink(fname)
|
|
cfgFile = open(fname, 'w')
|
|
with cfgFile:
|
|
self.write(cfgFile)
|
|
else:
|
|
self.RemoveFile()
|
|
|
|
class IdleConf:
|
|
"""
|
|
holds config parsers for all idle config files:
|
|
default config files
|
|
(idle install dir)/config-main.def
|
|
(idle install dir)/config-extensions.def
|
|
(idle install dir)/config-highlight.def
|
|
(idle install dir)/config-keys.def
|
|
user config files
|
|
(user home dir)/.idlerc/config-main.cfg
|
|
(user home dir)/.idlerc/config-extensions.cfg
|
|
(user home dir)/.idlerc/config-highlight.cfg
|
|
(user home dir)/.idlerc/config-keys.cfg
|
|
"""
|
|
def __init__(self):
|
|
self.defaultCfg={}
|
|
self.userCfg={}
|
|
self.cfg={}
|
|
self.CreateConfigHandlers()
|
|
self.LoadCfgFiles()
|
|
#self.LoadCfg()
|
|
|
|
def CreateConfigHandlers(self):
|
|
"""
|
|
set up a dictionary of config parsers for default and user
|
|
configurations respectively
|
|
"""
|
|
#build idle install path
|
|
if __name__ != '__main__': # we were imported
|
|
idleDir=os.path.dirname(__file__)
|
|
else: # we were exec'ed (for testing only)
|
|
idleDir=os.path.abspath(sys.path[0])
|
|
userDir=self.GetUserCfgDir()
|
|
configTypes=('main','extensions','highlight','keys')
|
|
defCfgFiles={}
|
|
usrCfgFiles={}
|
|
for cfgType in configTypes: #build config file names
|
|
defCfgFiles[cfgType]=os.path.join(idleDir,'config-'+cfgType+'.def')
|
|
usrCfgFiles[cfgType]=os.path.join(userDir,'config-'+cfgType+'.cfg')
|
|
for cfgType in configTypes: #create config parsers
|
|
self.defaultCfg[cfgType]=IdleConfParser(defCfgFiles[cfgType])
|
|
self.userCfg[cfgType]=IdleUserConfParser(usrCfgFiles[cfgType])
|
|
|
|
def GetUserCfgDir(self):
|
|
"""
|
|
Creates (if required) and returns a filesystem directory for storing
|
|
user config files.
|
|
|
|
"""
|
|
cfgDir = '.idlerc'
|
|
userDir = os.path.expanduser('~')
|
|
if userDir != '~': # expanduser() found user home dir
|
|
if not os.path.exists(userDir):
|
|
warn = ('\n Warning: os.path.expanduser("~") points to\n '+
|
|
userDir+',\n but the path does not exist.\n')
|
|
try:
|
|
sys.stderr.write(warn)
|
|
except IOError:
|
|
pass
|
|
userDir = '~'
|
|
if userDir == "~": # still no path to home!
|
|
# traditionally IDLE has defaulted to os.getcwd(), is this adequate?
|
|
userDir = os.getcwd()
|
|
userDir = os.path.join(userDir, cfgDir)
|
|
if not os.path.exists(userDir):
|
|
try:
|
|
os.mkdir(userDir)
|
|
except (OSError, IOError):
|
|
warn = ('\n Warning: unable to create user config directory\n'+
|
|
userDir+'\n Check path and permissions.\n Exiting!\n\n')
|
|
sys.stderr.write(warn)
|
|
raise SystemExit
|
|
return userDir
|
|
|
|
def GetOption(self, configType, section, option, default=None, type=None,
|
|
warn_on_default=True, raw=False):
|
|
"""
|
|
Get an option value for given config type and given general
|
|
configuration section/option or return a default. If type is specified,
|
|
return as type. Firstly the user configuration is checked, with a
|
|
fallback to the default configuration, and a final 'catch all'
|
|
fallback to a useable passed-in default if the option isn't present in
|
|
either the user or the default configuration.
|
|
configType must be one of ('main','extensions','highlight','keys')
|
|
If a default is returned, and warn_on_default is True, a warning is
|
|
printed to stderr.
|
|
|
|
"""
|
|
try:
|
|
if self.userCfg[configType].has_option(section,option):
|
|
return self.userCfg[configType].Get(section, option,
|
|
type=type, raw=raw)
|
|
except ValueError:
|
|
warning = ('\n Warning: configHandler.py - IdleConf.GetOption -\n'
|
|
' invalid %r value for configuration option %r\n'
|
|
' from section %r: %r\n' %
|
|
(type, option, section,
|
|
self.userCfg[configType].Get(section, option,
|
|
raw=raw)))
|
|
try:
|
|
sys.stderr.write(warning)
|
|
except IOError:
|
|
pass
|
|
try:
|
|
if self.defaultCfg[configType].has_option(section,option):
|
|
return self.defaultCfg[configType].Get(section, option,
|
|
type=type, raw=raw)
|
|
except ValueError:
|
|
pass
|
|
#returning default, print warning
|
|
if warn_on_default:
|
|
warning = ('\n Warning: configHandler.py - IdleConf.GetOption -\n'
|
|
' problem retrieving configuration option %r\n'
|
|
' from section %r.\n'
|
|
' returning default value: %r\n' %
|
|
(option, section, default))
|
|
try:
|
|
sys.stderr.write(warning)
|
|
except IOError:
|
|
pass
|
|
return default
|
|
|
|
def SetOption(self, configType, section, option, value):
|
|
"""In user's config file, set section's option to value.
|
|
|
|
"""
|
|
self.userCfg[configType].SetOption(section, option, value)
|
|
|
|
def GetSectionList(self, configSet, configType):
|
|
"""
|
|
Get a list of sections from either the user or default config for
|
|
the given config type.
|
|
configSet must be either 'user' or 'default'
|
|
configType must be one of ('main','extensions','highlight','keys')
|
|
"""
|
|
if not (configType in ('main','extensions','highlight','keys')):
|
|
raise InvalidConfigType('Invalid configType specified')
|
|
if configSet == 'user':
|
|
cfgParser=self.userCfg[configType]
|
|
elif configSet == 'default':
|
|
cfgParser=self.defaultCfg[configType]
|
|
else:
|
|
raise InvalidConfigSet('Invalid configSet specified')
|
|
return cfgParser.sections()
|
|
|
|
def GetHighlight(self, theme, element, fgBg=None):
|
|
"""
|
|
return individual highlighting theme elements.
|
|
fgBg - string ('fg'or'bg') or None, if None return a dictionary
|
|
containing fg and bg colours (appropriate for passing to Tkinter in,
|
|
e.g., a tag_config call), otherwise fg or bg colour only as specified.
|
|
"""
|
|
if self.defaultCfg['highlight'].has_section(theme):
|
|
themeDict=self.GetThemeDict('default',theme)
|
|
else:
|
|
themeDict=self.GetThemeDict('user',theme)
|
|
fore=themeDict[element+'-foreground']
|
|
if element=='cursor': #there is no config value for cursor bg
|
|
back=themeDict['normal-background']
|
|
else:
|
|
back=themeDict[element+'-background']
|
|
highlight={"foreground": fore,"background": back}
|
|
if not fgBg: #return dict of both colours
|
|
return highlight
|
|
else: #return specified colour only
|
|
if fgBg == 'fg':
|
|
return highlight["foreground"]
|
|
if fgBg == 'bg':
|
|
return highlight["background"]
|
|
else:
|
|
raise InvalidFgBg('Invalid fgBg specified')
|
|
|
|
def GetThemeDict(self,type,themeName):
|
|
"""
|
|
type - string, 'default' or 'user' theme type
|
|
themeName - string, theme name
|
|
Returns a dictionary which holds {option:value} for each element
|
|
in the specified theme. Values are loaded over a set of ultimate last
|
|
fallback defaults to guarantee that all theme elements are present in
|
|
a newly created theme.
|
|
"""
|
|
if type == 'user':
|
|
cfgParser=self.userCfg['highlight']
|
|
elif type == 'default':
|
|
cfgParser=self.defaultCfg['highlight']
|
|
else:
|
|
raise InvalidTheme('Invalid theme type specified')
|
|
#foreground and background values are provded for each theme element
|
|
#(apart from cursor) even though all these values are not yet used
|
|
#by idle, to allow for their use in the future. Default values are
|
|
#generally black and white.
|
|
theme={ 'normal-foreground':'#000000',
|
|
'normal-background':'#ffffff',
|
|
'keyword-foreground':'#000000',
|
|
'keyword-background':'#ffffff',
|
|
'builtin-foreground':'#000000',
|
|
'builtin-background':'#ffffff',
|
|
'comment-foreground':'#000000',
|
|
'comment-background':'#ffffff',
|
|
'string-foreground':'#000000',
|
|
'string-background':'#ffffff',
|
|
'definition-foreground':'#000000',
|
|
'definition-background':'#ffffff',
|
|
'hilite-foreground':'#000000',
|
|
'hilite-background':'gray',
|
|
'break-foreground':'#ffffff',
|
|
'break-background':'#000000',
|
|
'hit-foreground':'#ffffff',
|
|
'hit-background':'#000000',
|
|
'error-foreground':'#ffffff',
|
|
'error-background':'#000000',
|
|
#cursor (only foreground can be set)
|
|
'cursor-foreground':'#000000',
|
|
#shell window
|
|
'stdout-foreground':'#000000',
|
|
'stdout-background':'#ffffff',
|
|
'stderr-foreground':'#000000',
|
|
'stderr-background':'#ffffff',
|
|
'console-foreground':'#000000',
|
|
'console-background':'#ffffff' }
|
|
for element in theme:
|
|
if not cfgParser.has_option(themeName,element):
|
|
#we are going to return a default, print warning
|
|
warning=('\n Warning: configHandler.py - IdleConf.GetThemeDict'
|
|
' -\n problem retrieving theme element %r'
|
|
'\n from theme %r.\n'
|
|
' returning default value: %r\n' %
|
|
(element, themeName, theme[element]))
|
|
try:
|
|
sys.stderr.write(warning)
|
|
except IOError:
|
|
pass
|
|
colour=cfgParser.Get(themeName,element,default=theme[element])
|
|
theme[element]=colour
|
|
return theme
|
|
|
|
def CurrentTheme(self):
|
|
"""
|
|
Returns the name of the currently active theme
|
|
"""
|
|
return self.GetOption('main','Theme','name',default='')
|
|
|
|
def CurrentKeys(self):
|
|
"""
|
|
Returns the name of the currently active key set
|
|
"""
|
|
return self.GetOption('main','Keys','name',default='')
|
|
|
|
def GetExtensions(self, active_only=True, editor_only=False, shell_only=False):
|
|
"""
|
|
Gets a list of all idle extensions declared in the config files.
|
|
active_only - boolean, if true only return active (enabled) extensions
|
|
"""
|
|
extns=self.RemoveKeyBindNames(
|
|
self.GetSectionList('default','extensions'))
|
|
userExtns=self.RemoveKeyBindNames(
|
|
self.GetSectionList('user','extensions'))
|
|
for extn in userExtns:
|
|
if extn not in extns: #user has added own extension
|
|
extns.append(extn)
|
|
if active_only:
|
|
activeExtns=[]
|
|
for extn in extns:
|
|
if self.GetOption('extensions', extn, 'enable', default=True,
|
|
type='bool'):
|
|
#the extension is enabled
|
|
if editor_only or shell_only:
|
|
if editor_only:
|
|
option = "enable_editor"
|
|
else:
|
|
option = "enable_shell"
|
|
if self.GetOption('extensions', extn,option,
|
|
default=True, type='bool',
|
|
warn_on_default=False):
|
|
activeExtns.append(extn)
|
|
else:
|
|
activeExtns.append(extn)
|
|
return activeExtns
|
|
else:
|
|
return extns
|
|
|
|
def RemoveKeyBindNames(self,extnNameList):
|
|
#get rid of keybinding section names
|
|
names=extnNameList
|
|
kbNameIndicies=[]
|
|
for name in names:
|
|
if name.endswith(('_bindings', '_cfgBindings')):
|
|
kbNameIndicies.append(names.index(name))
|
|
kbNameIndicies.sort()
|
|
kbNameIndicies.reverse()
|
|
for index in kbNameIndicies: #delete each keybinding section name
|
|
del(names[index])
|
|
return names
|
|
|
|
def GetExtnNameForEvent(self,virtualEvent):
|
|
"""
|
|
Returns the name of the extension that virtualEvent is bound in, or
|
|
None if not bound in any extension.
|
|
virtualEvent - string, name of the virtual event to test for, without
|
|
the enclosing '<< >>'
|
|
"""
|
|
extName=None
|
|
vEvent='<<'+virtualEvent+'>>'
|
|
for extn in self.GetExtensions(active_only=0):
|
|
for event in self.GetExtensionKeys(extn):
|
|
if event == vEvent:
|
|
extName=extn
|
|
return extName
|
|
|
|
def GetExtensionKeys(self,extensionName):
|
|
"""
|
|
returns a dictionary of the configurable keybindings for a particular
|
|
extension,as they exist in the dictionary returned by GetCurrentKeySet;
|
|
that is, where previously used bindings are disabled.
|
|
"""
|
|
keysName=extensionName+'_cfgBindings'
|
|
activeKeys=self.GetCurrentKeySet()
|
|
extKeys={}
|
|
if self.defaultCfg['extensions'].has_section(keysName):
|
|
eventNames=self.defaultCfg['extensions'].GetOptionList(keysName)
|
|
for eventName in eventNames:
|
|
event='<<'+eventName+'>>'
|
|
binding=activeKeys[event]
|
|
extKeys[event]=binding
|
|
return extKeys
|
|
|
|
def __GetRawExtensionKeys(self,extensionName):
|
|
"""
|
|
returns a dictionary of the configurable keybindings for a particular
|
|
extension, as defined in the configuration files, or an empty dictionary
|
|
if no bindings are found
|
|
"""
|
|
keysName=extensionName+'_cfgBindings'
|
|
extKeys={}
|
|
if self.defaultCfg['extensions'].has_section(keysName):
|
|
eventNames=self.defaultCfg['extensions'].GetOptionList(keysName)
|
|
for eventName in eventNames:
|
|
binding=self.GetOption('extensions',keysName,
|
|
eventName,default='').split()
|
|
event='<<'+eventName+'>>'
|
|
extKeys[event]=binding
|
|
return extKeys
|
|
|
|
def GetExtensionBindings(self,extensionName):
|
|
"""
|
|
Returns a dictionary of all the event bindings for a particular
|
|
extension. The configurable keybindings are returned as they exist in
|
|
the dictionary returned by GetCurrentKeySet; that is, where re-used
|
|
keybindings are disabled.
|
|
"""
|
|
bindsName=extensionName+'_bindings'
|
|
extBinds=self.GetExtensionKeys(extensionName)
|
|
#add the non-configurable bindings
|
|
if self.defaultCfg['extensions'].has_section(bindsName):
|
|
eventNames=self.defaultCfg['extensions'].GetOptionList(bindsName)
|
|
for eventName in eventNames:
|
|
binding=self.GetOption('extensions',bindsName,
|
|
eventName,default='').split()
|
|
event='<<'+eventName+'>>'
|
|
extBinds[event]=binding
|
|
|
|
return extBinds
|
|
|
|
def GetKeyBinding(self, keySetName, eventStr):
|
|
"""
|
|
returns the keybinding for a specific event.
|
|
keySetName - string, name of key binding set
|
|
eventStr - string, the virtual event we want the binding for,
|
|
represented as a string, eg. '<<event>>'
|
|
"""
|
|
eventName=eventStr[2:-2] #trim off the angle brackets
|
|
binding=self.GetOption('keys',keySetName,eventName,default='').split()
|
|
return binding
|
|
|
|
def GetCurrentKeySet(self):
|
|
result = self.GetKeySet(self.CurrentKeys())
|
|
|
|
if macosxSupport.runningAsOSXApp():
|
|
# We're using AquaTk, replace all keybingings that use the
|
|
# Alt key by ones that use the Option key because the former
|
|
# don't work reliably.
|
|
for k, v in result.items():
|
|
v2 = [ x.replace('<Alt-', '<Option-') for x in v ]
|
|
if v != v2:
|
|
result[k] = v2
|
|
|
|
return result
|
|
|
|
def GetKeySet(self,keySetName):
|
|
"""
|
|
Returns a dictionary of: all requested core keybindings, plus the
|
|
keybindings for all currently active extensions. If a binding defined
|
|
in an extension is already in use, that binding is disabled.
|
|
"""
|
|
keySet=self.GetCoreKeys(keySetName)
|
|
activeExtns=self.GetExtensions(active_only=1)
|
|
for extn in activeExtns:
|
|
extKeys=self.__GetRawExtensionKeys(extn)
|
|
if extKeys: #the extension defines keybindings
|
|
for event in extKeys:
|
|
if extKeys[event] in keySet.values():
|
|
#the binding is already in use
|
|
extKeys[event]='' #disable this binding
|
|
keySet[event]=extKeys[event] #add binding
|
|
return keySet
|
|
|
|
def IsCoreBinding(self,virtualEvent):
|
|
"""
|
|
returns true if the virtual event is bound in the core idle keybindings.
|
|
virtualEvent - string, name of the virtual event to test for, without
|
|
the enclosing '<< >>'
|
|
"""
|
|
return ('<<'+virtualEvent+'>>') in self.GetCoreKeys()
|
|
|
|
def GetCoreKeys(self, keySetName=None):
|
|
"""
|
|
returns the requested set of core keybindings, with fallbacks if
|
|
required.
|
|
Keybindings loaded from the config file(s) are loaded _over_ these
|
|
defaults, so if there is a problem getting any core binding there will
|
|
be an 'ultimate last resort fallback' to the CUA-ish bindings
|
|
defined here.
|
|
"""
|
|
keyBindings={
|
|
'<<copy>>': ['<Control-c>', '<Control-C>'],
|
|
'<<cut>>': ['<Control-x>', '<Control-X>'],
|
|
'<<paste>>': ['<Control-v>', '<Control-V>'],
|
|
'<<beginning-of-line>>': ['<Control-a>', '<Home>'],
|
|
'<<center-insert>>': ['<Control-l>'],
|
|
'<<close-all-windows>>': ['<Control-q>'],
|
|
'<<close-window>>': ['<Alt-F4>'],
|
|
'<<do-nothing>>': ['<Control-x>'],
|
|
'<<end-of-file>>': ['<Control-d>'],
|
|
'<<python-docs>>': ['<F1>'],
|
|
'<<python-context-help>>': ['<Shift-F1>'],
|
|
'<<history-next>>': ['<Alt-n>'],
|
|
'<<history-previous>>': ['<Alt-p>'],
|
|
'<<interrupt-execution>>': ['<Control-c>'],
|
|
'<<view-restart>>': ['<F6>'],
|
|
'<<restart-shell>>': ['<Control-F6>'],
|
|
'<<open-class-browser>>': ['<Alt-c>'],
|
|
'<<open-module>>': ['<Alt-m>'],
|
|
'<<open-new-window>>': ['<Control-n>'],
|
|
'<<open-window-from-file>>': ['<Control-o>'],
|
|
'<<plain-newline-and-indent>>': ['<Control-j>'],
|
|
'<<print-window>>': ['<Control-p>'],
|
|
'<<redo>>': ['<Control-y>'],
|
|
'<<remove-selection>>': ['<Escape>'],
|
|
'<<save-copy-of-window-as-file>>': ['<Alt-Shift-S>'],
|
|
'<<save-window-as-file>>': ['<Alt-s>'],
|
|
'<<save-window>>': ['<Control-s>'],
|
|
'<<select-all>>': ['<Alt-a>'],
|
|
'<<toggle-auto-coloring>>': ['<Control-slash>'],
|
|
'<<undo>>': ['<Control-z>'],
|
|
'<<find-again>>': ['<Control-g>', '<F3>'],
|
|
'<<find-in-files>>': ['<Alt-F3>'],
|
|
'<<find-selection>>': ['<Control-F3>'],
|
|
'<<find>>': ['<Control-f>'],
|
|
'<<replace>>': ['<Control-h>'],
|
|
'<<goto-line>>': ['<Alt-g>'],
|
|
'<<smart-backspace>>': ['<Key-BackSpace>'],
|
|
'<<newline-and-indent>>': ['<Key-Return>', '<Key-KP_Enter>'],
|
|
'<<smart-indent>>': ['<Key-Tab>'],
|
|
'<<indent-region>>': ['<Control-Key-bracketright>'],
|
|
'<<dedent-region>>': ['<Control-Key-bracketleft>'],
|
|
'<<comment-region>>': ['<Alt-Key-3>'],
|
|
'<<uncomment-region>>': ['<Alt-Key-4>'],
|
|
'<<tabify-region>>': ['<Alt-Key-5>'],
|
|
'<<untabify-region>>': ['<Alt-Key-6>'],
|
|
'<<toggle-tabs>>': ['<Alt-Key-t>'],
|
|
'<<change-indentwidth>>': ['<Alt-Key-u>'],
|
|
'<<del-word-left>>': ['<Control-Key-BackSpace>'],
|
|
'<<del-word-right>>': ['<Control-Key-Delete>']
|
|
}
|
|
if keySetName:
|
|
for event in keyBindings:
|
|
binding=self.GetKeyBinding(keySetName,event)
|
|
if binding:
|
|
keyBindings[event]=binding
|
|
else: #we are going to return a default, print warning
|
|
warning=('\n Warning: configHandler.py - IdleConf.GetCoreKeys'
|
|
' -\n problem retrieving key binding for event %r'
|
|
'\n from key set %r.\n'
|
|
' returning default value: %r\n' %
|
|
(event, keySetName, keyBindings[event]))
|
|
try:
|
|
sys.stderr.write(warning)
|
|
except IOError:
|
|
pass
|
|
return keyBindings
|
|
|
|
def GetExtraHelpSourceList(self,configSet):
|
|
"""Fetch list of extra help sources from a given configSet.
|
|
|
|
Valid configSets are 'user' or 'default'. Return a list of tuples of
|
|
the form (menu_item , path_to_help_file , option), or return the empty
|
|
list. 'option' is the sequence number of the help resource. 'option'
|
|
values determine the position of the menu items on the Help menu,
|
|
therefore the returned list must be sorted by 'option'.
|
|
|
|
"""
|
|
helpSources=[]
|
|
if configSet=='user':
|
|
cfgParser=self.userCfg['main']
|
|
elif configSet=='default':
|
|
cfgParser=self.defaultCfg['main']
|
|
else:
|
|
raise InvalidConfigSet('Invalid configSet specified')
|
|
options=cfgParser.GetOptionList('HelpFiles')
|
|
for option in options:
|
|
value=cfgParser.Get('HelpFiles',option,default=';')
|
|
if value.find(';')==-1: #malformed config entry with no ';'
|
|
menuItem='' #make these empty
|
|
helpPath='' #so value won't be added to list
|
|
else: #config entry contains ';' as expected
|
|
value=value.split(';')
|
|
menuItem=value[0].strip()
|
|
helpPath=value[1].strip()
|
|
if menuItem and helpPath: #neither are empty strings
|
|
helpSources.append( (menuItem,helpPath,option) )
|
|
helpSources.sort(key=lambda x: x[2])
|
|
return helpSources
|
|
|
|
def GetAllExtraHelpSourcesList(self):
|
|
"""
|
|
Returns a list of tuples containing the details of all additional help
|
|
sources configured, or an empty list if there are none. Tuples are of
|
|
the format returned by GetExtraHelpSourceList.
|
|
"""
|
|
allHelpSources=( self.GetExtraHelpSourceList('default')+
|
|
self.GetExtraHelpSourceList('user') )
|
|
return allHelpSources
|
|
|
|
def LoadCfgFiles(self):
|
|
"""
|
|
load all configuration files.
|
|
"""
|
|
for key in self.defaultCfg:
|
|
self.defaultCfg[key].Load()
|
|
self.userCfg[key].Load() #same keys
|
|
|
|
def SaveUserCfgFiles(self):
|
|
"""
|
|
write all loaded user configuration files back to disk
|
|
"""
|
|
for key in self.userCfg:
|
|
self.userCfg[key].Save()
|
|
|
|
idleConf=IdleConf()
|
|
|
|
### module test
|
|
if __name__ == '__main__':
|
|
def dumpCfg(cfg):
|
|
print('\n',cfg,'\n')
|
|
for key in cfg:
|
|
sections=cfg[key].sections()
|
|
print(key)
|
|
print(sections)
|
|
for section in sections:
|
|
options=cfg[key].options(section)
|
|
print(section)
|
|
print(options)
|
|
for option in options:
|
|
print(option, '=', cfg[key].Get(section,option))
|
|
dumpCfg(idleConf.defaultCfg)
|
|
dumpCfg(idleConf.userCfg)
|
|
print(idleConf.userCfg['main'].Get('Theme','name'))
|
|
#print idleConf.userCfg['highlight'].GetDefHighlight('Foo','normal')
|