| 1 |
"""idlelib.config -- Manage IDLE configuration information. |
| 2 |
|
| 3 |
The comments at the beginning of config-main.def describe the |
| 4 |
configuration files and the design implemented to update user |
| 5 |
configuration information. In particular, user configuration choices |
| 6 |
which duplicate the defaults will be removed from the user's |
| 7 |
configuration files, and if a user file becomes empty, it will be |
| 8 |
deleted. |
| 9 |
|
| 10 |
The configuration database maps options to values. Conceptually, the |
| 11 |
database keys are tuples (config-type, section, item). As implemented, |
| 12 |
there are separate dicts for default and user values. Each has |
| 13 |
config-type keys 'main', 'extensions', 'highlight', and 'keys'. The |
| 14 |
value for each key is a ConfigParser instance that maps section and item |
| 15 |
to values. For 'main' and 'extensions', user values override |
| 16 |
default values. For 'highlight' and 'keys', user sections augment the |
| 17 |
default sections (and must, therefore, have distinct names). |
| 18 |
|
| 19 |
Throughout this module there is an emphasis on returning usable defaults |
| 20 |
when a problem occurs in returning a requested configuration value back to |
| 21 |
idle. This is to allow IDLE to continue to function in spite of errors in |
| 22 |
the retrieval of config information. When a default is returned instead of |
| 23 |
a requested config value, a message is printed to stderr to aid in |
| 24 |
configuration problem notification and resolution. |
| 25 |
""" |
| 26 |
# TODOs added Oct 2014, tjr |
| 27 |
|
| 28 |
from configparser import ConfigParser |
| 29 |
import os |
| 30 |
import sys |
| 31 |
|
| 32 |
from tkinter.font import Font |
| 33 |
import idlelib |
| 34 |
|
| 35 |
class InvalidConfigType(Exception): pass |
| 36 |
class InvalidConfigSet(Exception): pass |
| 37 |
class InvalidTheme(Exception): pass |
| 38 |
|
| 39 |
class IdleConfParser(ConfigParser): |
| 40 |
""" |
| 41 |
A ConfigParser specialised for idle configuration file handling |
| 42 |
""" |
| 43 |
def __init__(self, cfgFile, cfgDefaults=None): |
| 44 |
""" |
| 45 |
cfgFile - string, fully specified configuration file name |
| 46 |
""" |
| 47 |
self.file = cfgFile # This is currently '' when testing. |
| 48 |
ConfigParser.__init__(self, defaults=cfgDefaults, strict=False) |
| 49 |
|
| 50 |
def Get(self, section, option, type=None, default=None, raw=False): |
| 51 |
""" |
| 52 |
Get an option value for given section/option or return default. |
| 53 |
If type is specified, return as type. |
| 54 |
""" |
| 55 |
# TODO Use default as fallback, at least if not None |
| 56 |
# Should also print Warning(file, section, option). |
| 57 |
# Currently may raise ValueError |
| 58 |
if not self.has_option(section, option): |
| 59 |
return default |
| 60 |
if type == 'bool': |
| 61 |
return self.getboolean(section, option) |
| 62 |
elif type == 'int': |
| 63 |
return self.getint(section, option) |
| 64 |
else: |
| 65 |
return self.get(section, option, raw=raw) |
| 66 |
|
| 67 |
def GetOptionList(self, section): |
| 68 |
"Return a list of options for given section, else []." |
| 69 |
if self.has_section(section): |
| 70 |
return self.options(section) |
| 71 |
else: #return a default value |
| 72 |
return [] |
| 73 |
|
| 74 |
def Load(self): |
| 75 |
"Load the configuration file from disk." |
| 76 |
if self.file: |
| 77 |
self.read(self.file) |
| 78 |
|
| 79 |
class IdleUserConfParser(IdleConfParser): |
| 80 |
""" |
| 81 |
IdleConfigParser specialised for user configuration handling. |
| 82 |
""" |
| 83 |
|
| 84 |
def SetOption(self, section, option, value): |
| 85 |
"""Return True if option is added or changed to value, else False. |
| 86 |
|
| 87 |
Add section if required. False means option already had value. |
| 88 |
""" |
| 89 |
if self.has_option(section, option): |
| 90 |
if self.get(section, option) == value: |
| 91 |
return False |
| 92 |
else: |
| 93 |
self.set(section, option, value) |
| 94 |
return True |
| 95 |
else: |
| 96 |
if not self.has_section(section): |
| 97 |
self.add_section(section) |
| 98 |
self.set(section, option, value) |
| 99 |
return True |
| 100 |
|
| 101 |
def RemoveOption(self, section, option): |
| 102 |
"""Return True if option is removed from section, else False. |
| 103 |
|
| 104 |
False if either section does not exist or did not have option. |
| 105 |
""" |
| 106 |
if self.has_section(section): |
| 107 |
return self.remove_option(section, option) |
| 108 |
return False |
| 109 |
|
| 110 |
def AddSection(self, section): |
| 111 |
"If section doesn't exist, add it." |
| 112 |
if not self.has_section(section): |
| 113 |
self.add_section(section) |
| 114 |
|
| 115 |
def RemoveEmptySections(self): |
| 116 |
"Remove any sections that have no options." |
| 117 |
for section in self.sections(): |
| 118 |
if not self.GetOptionList(section): |
| 119 |
self.remove_section(section) |
| 120 |
|
| 121 |
def IsEmpty(self): |
| 122 |
"Return True if no sections after removing empty sections." |
| 123 |
self.RemoveEmptySections() |
| 124 |
return not self.sections() |
| 125 |
|
| 126 |
def Save(self): |
| 127 |
"""Update user configuration file. |
| 128 |
|
| 129 |
If self not empty after removing empty sections, write the file |
| 130 |
to disk. Otherwise, remove the file from disk if it exists. |
| 131 |
""" |
| 132 |
fname = self.file |
| 133 |
if fname and fname[0] != '#': |
| 134 |
if not self.IsEmpty(): |
| 135 |
try: |
| 136 |
cfgFile = open(fname, 'w') |
| 137 |
except OSError: |
| 138 |
os.unlink(fname) |
| 139 |
cfgFile = open(fname, 'w') |
| 140 |
with cfgFile: |
| 141 |
self.write(cfgFile) |
| 142 |
elif os.path.exists(self.file): |
| 143 |
os.remove(self.file) |
| 144 |
|
| 145 |
class IdleConf: |
| 146 |
"""Hold config parsers for all idle config files in singleton instance. |
| 147 |
|
| 148 |
Default config files, self.defaultCfg -- |
| 149 |
for config_type in self.config_types: |
| 150 |
(idle install dir)/config-{config-type}.def |
| 151 |
|
| 152 |
User config files, self.userCfg -- |
| 153 |
for config_type in self.config_types: |
| 154 |
(user home dir)/.idlerc/config-{config-type}.cfg |
| 155 |
""" |
| 156 |
def __init__(self, _utest=False): |
| 157 |
self.config_types = ('main', 'highlight', 'keys', 'extensions') |
| 158 |
self.defaultCfg = {} |
| 159 |
self.userCfg = {} |
| 160 |
self.cfg = {} # TODO use to select userCfg vs defaultCfg |
| 161 |
|
| 162 |
# See https://bugs.python.org/issue4630#msg356516 for following. |
| 163 |
# self.blink_off_time = <first editor text>['insertofftime'] |
| 164 |
|
| 165 |
if not _utest: |
| 166 |
self.CreateConfigHandlers() |
| 167 |
self.LoadCfgFiles() |
| 168 |
|
| 169 |
def CreateConfigHandlers(self): |
| 170 |
"Populate default and user config parser dictionaries." |
| 171 |
idledir = os.path.dirname(__file__) |
| 172 |
self.userdir = userdir = '' if idlelib.testing else self.GetUserCfgDir() |
| 173 |
for cfg_type in self.config_types: |
| 174 |
self.defaultCfg[cfg_type] = IdleConfParser( |
| 175 |
os.path.join(idledir, f'config-{cfg_type}.def')) |
| 176 |
self.userCfg[cfg_type] = IdleUserConfParser( |
| 177 |
os.path.join(userdir or '#', f'config-{cfg_type}.cfg')) |
| 178 |
|
| 179 |
def GetUserCfgDir(self): |
| 180 |
"""Return a filesystem directory for storing user config files. |
| 181 |
|
| 182 |
Creates it if required. |
| 183 |
""" |
| 184 |
cfgDir = '.idlerc' |
| 185 |
userDir = os.path.expanduser('~') |
| 186 |
if userDir != '~': # expanduser() found user home dir |
| 187 |
if not os.path.exists(userDir): |
| 188 |
if not idlelib.testing: |
| 189 |
warn = ('\n Warning: os.path.expanduser("~") points to\n ' + |
| 190 |
userDir + ',\n but the path does not exist.') |
| 191 |
try: |
| 192 |
print(warn, file=sys.stderr) |
| 193 |
except OSError: |
| 194 |
pass |
| 195 |
userDir = '~' |
| 196 |
if userDir == "~": # still no path to home! |
| 197 |
# traditionally IDLE has defaulted to os.getcwd(), is this adequate? |
| 198 |
userDir = os.getcwd() |
| 199 |
userDir = os.path.join(userDir, cfgDir) |
| 200 |
if not os.path.exists(userDir): |
| 201 |
try: |
| 202 |
os.mkdir(userDir) |
| 203 |
except OSError: |
| 204 |
if not idlelib.testing: |
| 205 |
warn = ('\n Warning: unable to create user config directory\n' + |
| 206 |
userDir + '\n Check path and permissions.\n Exiting!\n') |
| 207 |
try: |
| 208 |
print(warn, file=sys.stderr) |
| 209 |
except OSError: |
| 210 |
pass |
| 211 |
raise SystemExit |
| 212 |
# TODO continue without userDIr instead of exit |
| 213 |
return userDir |
| 214 |
|
| 215 |
def GetOption(self, configType, section, option, default=None, type=None, |
| 216 |
warn_on_default=True, raw=False): |
| 217 |
"""Return a value for configType section option, or default. |
| 218 |
|
| 219 |
If type is not None, return a value of that type. Also pass raw |
| 220 |
to the config parser. First try to return a valid value |
| 221 |
(including type) from a user configuration. If that fails, try |
| 222 |
the default configuration. If that fails, return default, with a |
| 223 |
default of None. |
| 224 |
|
| 225 |
Warn if either user or default configurations have an invalid value. |
| 226 |
Warn if default is returned and warn_on_default is True. |
| 227 |
""" |
| 228 |
try: |
| 229 |
if self.userCfg[configType].has_option(section, option): |
| 230 |
return self.userCfg[configType].Get(section, option, |
| 231 |
type=type, raw=raw) |
| 232 |
except ValueError: |
| 233 |
warning = ('\n Warning: config.py - IdleConf.GetOption -\n' |
| 234 |
' invalid %r value for configuration option %r\n' |
| 235 |
' from section %r: %r' % |
| 236 |
(type, option, section, |
| 237 |
self.userCfg[configType].Get(section, option, raw=raw))) |
| 238 |
_warn(warning, configType, section, option) |
| 239 |
try: |
| 240 |
if self.defaultCfg[configType].has_option(section,option): |
| 241 |
return self.defaultCfg[configType].Get( |
| 242 |
section, option, type=type, raw=raw) |
| 243 |
except ValueError: |
| 244 |
pass |
| 245 |
#returning default, print warning |
| 246 |
if warn_on_default: |
| 247 |
warning = ('\n Warning: config.py - IdleConf.GetOption -\n' |
| 248 |
' problem retrieving configuration option %r\n' |
| 249 |
' from section %r.\n' |
| 250 |
' returning default value: %r' % |
| 251 |
(option, section, default)) |
| 252 |
_warn(warning, configType, section, option) |
| 253 |
return default |
| 254 |
|
| 255 |
def SetOption(self, configType, section, option, value): |
| 256 |
"""Set section option to value in user config file.""" |
| 257 |
self.userCfg[configType].SetOption(section, option, value) |
| 258 |
|
| 259 |
def GetSectionList(self, configSet, configType): |
| 260 |
"""Return sections for configSet configType configuration. |
| 261 |
|
| 262 |
configSet must be either 'user' or 'default' |
| 263 |
configType must be in self.config_types. |
| 264 |
""" |
| 265 |
if not (configType in self.config_types): |
| 266 |
raise InvalidConfigType('Invalid configType specified') |
| 267 |
if configSet == 'user': |
| 268 |
cfgParser = self.userCfg[configType] |
| 269 |
elif configSet == 'default': |
| 270 |
cfgParser=self.defaultCfg[configType] |
| 271 |
else: |
| 272 |
raise InvalidConfigSet('Invalid configSet specified') |
| 273 |
return cfgParser.sections() |
| 274 |
|
| 275 |
def GetHighlight(self, theme, element): |
| 276 |
"""Return dict of theme element highlight colors. |
| 277 |
|
| 278 |
The keys are 'foreground' and 'background'. The values are |
| 279 |
tkinter color strings for configuring backgrounds and tags. |
| 280 |
""" |
| 281 |
cfg = ('default' if self.defaultCfg['highlight'].has_section(theme) |
| 282 |
else 'user') |
| 283 |
theme_dict = self.GetThemeDict(cfg, theme) |
| 284 |
fore = theme_dict[element + '-foreground'] |
| 285 |
if element == 'cursor': |
| 286 |
element = 'normal' |
| 287 |
back = theme_dict[element + '-background'] |
| 288 |
return {"foreground": fore, "background": back} |
| 289 |
|
| 290 |
def GetThemeDict(self, type, themeName): |
| 291 |
"""Return {option:value} dict for elements in themeName. |
| 292 |
|
| 293 |
type - string, 'default' or 'user' theme type |
| 294 |
themeName - string, theme name |
| 295 |
Values are loaded over ultimate fallback defaults to guarantee |
| 296 |
that all theme elements are present in a newly created theme. |
| 297 |
""" |
| 298 |
if type == 'user': |
| 299 |
cfgParser = self.userCfg['highlight'] |
| 300 |
elif type == 'default': |
| 301 |
cfgParser = self.defaultCfg['highlight'] |
| 302 |
else: |
| 303 |
raise InvalidTheme('Invalid theme type specified') |
| 304 |
# Provide foreground and background colors for each theme |
| 305 |
# element (other than cursor) even though some values are not |
| 306 |
# yet used by idle, to allow for their use in the future. |
| 307 |
# Default values are generally black and white. |
| 308 |
# TODO copy theme from a class attribute. |
| 309 |
theme ={'normal-foreground':'#000000', |
| 310 |
'normal-background':'#ffffff', |
| 311 |
'keyword-foreground':'#000000', |
| 312 |
'keyword-background':'#ffffff', |
| 313 |
'builtin-foreground':'#000000', |
| 314 |
'builtin-background':'#ffffff', |
| 315 |
'comment-foreground':'#000000', |
| 316 |
'comment-background':'#ffffff', |
| 317 |
'string-foreground':'#000000', |
| 318 |
'string-background':'#ffffff', |
| 319 |
'definition-foreground':'#000000', |
| 320 |
'definition-background':'#ffffff', |
| 321 |
'hilite-foreground':'#000000', |
| 322 |
'hilite-background':'gray', |
| 323 |
'break-foreground':'#ffffff', |
| 324 |
'break-background':'#000000', |
| 325 |
'hit-foreground':'#ffffff', |
| 326 |
'hit-background':'#000000', |
| 327 |
'error-foreground':'#ffffff', |
| 328 |
'error-background':'#000000', |
| 329 |
'context-foreground':'#000000', |
| 330 |
'context-background':'#ffffff', |
| 331 |
'linenumber-foreground':'#000000', |
| 332 |
'linenumber-background':'#ffffff', |
| 333 |
#cursor (only foreground can be set) |
| 334 |
'cursor-foreground':'#000000', |
| 335 |
#shell window |
| 336 |
'stdout-foreground':'#000000', |
| 337 |
'stdout-background':'#ffffff', |
| 338 |
'stderr-foreground':'#000000', |
| 339 |
'stderr-background':'#ffffff', |
| 340 |
'console-foreground':'#000000', |
| 341 |
'console-background':'#ffffff', |
| 342 |
} |
| 343 |
for element in theme: |
| 344 |
if not (cfgParser.has_option(themeName, element) or |
| 345 |
# Skip warning for new elements. |
| 346 |
element.startswith(('context-', 'linenumber-'))): |
| 347 |
# Print warning that will return a default color |
| 348 |
warning = ('\n Warning: config.IdleConf.GetThemeDict' |
| 349 |
' -\n problem retrieving theme element %r' |
| 350 |
'\n from theme %r.\n' |
| 351 |
' returning default color: %r' % |
| 352 |
(element, themeName, theme[element])) |
| 353 |
_warn(warning, 'highlight', themeName, element) |
| 354 |
theme[element] = cfgParser.Get( |
| 355 |
themeName, element, default=theme[element]) |
| 356 |
return theme |
| 357 |
|
| 358 |
def CurrentTheme(self): |
| 359 |
"Return the name of the currently active text color theme." |
| 360 |
return self.current_colors_and_keys('Theme') |
| 361 |
|
| 362 |
def CurrentKeys(self): |
| 363 |
"""Return the name of the currently active key set.""" |
| 364 |
return self.current_colors_and_keys('Keys') |
| 365 |
|
| 366 |
def current_colors_and_keys(self, section): |
| 367 |
"""Return the currently active name for Theme or Keys section. |
| 368 |
|
| 369 |
idlelib.config-main.def ('default') includes these sections |
| 370 |
|
| 371 |
[Theme] |
| 372 |
default= 1 |
| 373 |
name= IDLE Classic |
| 374 |
name2= |
| 375 |
|
| 376 |
[Keys] |
| 377 |
default= 1 |
| 378 |
name= |
| 379 |
name2= |
| 380 |
|
| 381 |
Item 'name2', is used for built-in ('default') themes and keys |
| 382 |
added after 2015 Oct 1 and 2016 July 1. This kludge is needed |
| 383 |
because setting 'name' to a builtin not defined in older IDLEs |
| 384 |
to display multiple error messages or quit. |
| 385 |
See https://bugs.python.org/issue25313. |
| 386 |
When default = True, 'name2' takes precedence over 'name', |
| 387 |
while older IDLEs will just use name. When default = False, |
| 388 |
'name2' may still be set, but it is ignored. |
| 389 |
""" |
| 390 |
cfgname = 'highlight' if section == 'Theme' else 'keys' |
| 391 |
default = self.GetOption('main', section, 'default', |
| 392 |
type='bool', default=True) |
| 393 |
name = '' |
| 394 |
if default: |
| 395 |
name = self.GetOption('main', section, 'name2', default='') |
| 396 |
if not name: |
| 397 |
name = self.GetOption('main', section, 'name', default='') |
| 398 |
if name: |
| 399 |
source = self.defaultCfg if default else self.userCfg |
| 400 |
if source[cfgname].has_section(name): |
| 401 |
return name |
| 402 |
return "IDLE Classic" if section == 'Theme' else self.default_keys() |
| 403 |
|
| 404 |
@staticmethod |
| 405 |
def default_keys(): |
| 406 |
if sys.platform[:3] == 'win': |
| 407 |
return 'IDLE Classic Windows' |
| 408 |
elif sys.platform == 'darwin': |
| 409 |
return 'IDLE Classic OSX' |
| 410 |
else: |
| 411 |
return 'IDLE Modern Unix' |
| 412 |
|
| 413 |
def GetExtensions(self, active_only=True, |
| 414 |
editor_only=False, shell_only=False): |
| 415 |
"""Return extensions in default and user config-extensions files. |
| 416 |
|
| 417 |
If active_only True, only return active (enabled) extensions |
| 418 |
and optionally only editor or shell extensions. |
| 419 |
If active_only False, return all extensions. |
| 420 |
""" |
| 421 |
extns = self.RemoveKeyBindNames( |
| 422 |
self.GetSectionList('default', 'extensions')) |
| 423 |
userExtns = self.RemoveKeyBindNames( |
| 424 |
self.GetSectionList('user', 'extensions')) |
| 425 |
for extn in userExtns: |
| 426 |
if extn not in extns: #user has added own extension |
| 427 |
extns.append(extn) |
| 428 |
for extn in ('AutoComplete','CodeContext', |
| 429 |
'FormatParagraph','ParenMatch'): |
| 430 |
extns.remove(extn) |
| 431 |
# specific exclusions because we are storing config for mainlined old |
| 432 |
# extensions in config-extensions.def for backward compatibility |
| 433 |
if active_only: |
| 434 |
activeExtns = [] |
| 435 |
for extn in extns: |
| 436 |
if self.GetOption('extensions', extn, 'enable', default=True, |
| 437 |
type='bool'): |
| 438 |
#the extension is enabled |
| 439 |
if editor_only or shell_only: # TODO both True contradict |
| 440 |
if editor_only: |
| 441 |
option = "enable_editor" |
| 442 |
else: |
| 443 |
option = "enable_shell" |
| 444 |
if self.GetOption('extensions', extn,option, |
| 445 |
default=True, type='bool', |
| 446 |
warn_on_default=False): |
| 447 |
activeExtns.append(extn) |
| 448 |
else: |
| 449 |
activeExtns.append(extn) |
| 450 |
return activeExtns |
| 451 |
else: |
| 452 |
return extns |
| 453 |
|
| 454 |
def RemoveKeyBindNames(self, extnNameList): |
| 455 |
"Return extnNameList with keybinding section names removed." |
| 456 |
return [n for n in extnNameList if not n.endswith(('_bindings', '_cfgBindings'))] |
| 457 |
|
| 458 |
def GetExtnNameForEvent(self, virtualEvent): |
| 459 |
"""Return the name of the extension binding virtualEvent, or None. |
| 460 |
|
| 461 |
virtualEvent - string, name of the virtual event to test for, |
| 462 |
without the enclosing '<< >>' |
| 463 |
""" |
| 464 |
extName = None |
| 465 |
vEvent = '<<' + virtualEvent + '>>' |
| 466 |
for extn in self.GetExtensions(active_only=0): |
| 467 |
for event in self.GetExtensionKeys(extn): |
| 468 |
if event == vEvent: |
| 469 |
extName = extn # TODO return here? |
| 470 |
return extName |
| 471 |
|
| 472 |
def GetExtensionKeys(self, extensionName): |
| 473 |
"""Return dict: {configurable extensionName event : active keybinding}. |
| 474 |
|
| 475 |
Events come from default config extension_cfgBindings section. |
| 476 |
Keybindings come from GetCurrentKeySet() active key dict, |
| 477 |
where previously used bindings are disabled. |
| 478 |
""" |
| 479 |
keysName = extensionName + '_cfgBindings' |
| 480 |
activeKeys = self.GetCurrentKeySet() |
| 481 |
extKeys = {} |
| 482 |
if self.defaultCfg['extensions'].has_section(keysName): |
| 483 |
eventNames = self.defaultCfg['extensions'].GetOptionList(keysName) |
| 484 |
for eventName in eventNames: |
| 485 |
event = '<<' + eventName + '>>' |
| 486 |
binding = activeKeys[event] |
| 487 |
extKeys[event] = binding |
| 488 |
return extKeys |
| 489 |
|
| 490 |
def __GetRawExtensionKeys(self,extensionName): |
| 491 |
"""Return dict {configurable extensionName event : keybinding list}. |
| 492 |
|
| 493 |
Events come from default config extension_cfgBindings section. |
| 494 |
Keybindings list come from the splitting of GetOption, which |
| 495 |
tries user config before default config. |
| 496 |
""" |
| 497 |
keysName = extensionName+'_cfgBindings' |
| 498 |
extKeys = {} |
| 499 |
if self.defaultCfg['extensions'].has_section(keysName): |
| 500 |
eventNames = self.defaultCfg['extensions'].GetOptionList(keysName) |
| 501 |
for eventName in eventNames: |
| 502 |
binding = self.GetOption( |
| 503 |
'extensions', keysName, eventName, default='').split() |
| 504 |
event = '<<' + eventName + '>>' |
| 505 |
extKeys[event] = binding |
| 506 |
return extKeys |
| 507 |
|
| 508 |
def GetExtensionBindings(self, extensionName): |
| 509 |
"""Return dict {extensionName event : active or defined keybinding}. |
| 510 |
|
| 511 |
Augment self.GetExtensionKeys(extensionName) with mapping of non- |
| 512 |
configurable events (from default config) to GetOption splits, |
| 513 |
as in self.__GetRawExtensionKeys. |
| 514 |
""" |
| 515 |
bindsName = extensionName + '_bindings' |
| 516 |
extBinds = self.GetExtensionKeys(extensionName) |
| 517 |
#add the non-configurable bindings |
| 518 |
if self.defaultCfg['extensions'].has_section(bindsName): |
| 519 |
eventNames = self.defaultCfg['extensions'].GetOptionList(bindsName) |
| 520 |
for eventName in eventNames: |
| 521 |
binding = self.GetOption( |
| 522 |
'extensions', bindsName, eventName, default='').split() |
| 523 |
event = '<<' + eventName + '>>' |
| 524 |
extBinds[event] = binding |
| 525 |
|
| 526 |
return extBinds |
| 527 |
|
| 528 |
def GetKeyBinding(self, keySetName, eventStr): |
| 529 |
"""Return the keybinding list for keySetName eventStr. |
| 530 |
|
| 531 |
keySetName - name of key binding set (config-keys section). |
| 532 |
eventStr - virtual event, including brackets, as in '<<event>>'. |
| 533 |
""" |
| 534 |
eventName = eventStr[2:-2] #trim off the angle brackets |
| 535 |
binding = self.GetOption('keys', keySetName, eventName, default='', |
| 536 |
warn_on_default=False).split() |
| 537 |
return binding |
| 538 |
|
| 539 |
def GetCurrentKeySet(self): |
| 540 |
"Return CurrentKeys with 'darwin' modifications." |
| 541 |
result = self.GetKeySet(self.CurrentKeys()) |
| 542 |
|
| 543 |
if sys.platform == "darwin": |
| 544 |
# macOS (OS X) Tk variants do not support the "Alt" |
| 545 |
# keyboard modifier. Replace it with "Option". |
| 546 |
# TODO (Ned?): the "Option" modifier does not work properly |
| 547 |
# for Cocoa Tk and XQuartz Tk so we should not use it |
| 548 |
# in the default 'OSX' keyset. |
| 549 |
for k, v in result.items(): |
| 550 |
v2 = [ x.replace('<Alt-', '<Option-') for x in v ] |
| 551 |
if v != v2: |
| 552 |
result[k] = v2 |
| 553 |
|
| 554 |
return result |
| 555 |
|
| 556 |
def GetKeySet(self, keySetName): |
| 557 |
"""Return event-key dict for keySetName core plus active extensions. |
| 558 |
|
| 559 |
If a binding defined in an extension is already in use, the |
| 560 |
extension binding is disabled by being set to '' |
| 561 |
""" |
| 562 |
keySet = self.GetCoreKeys(keySetName) |
| 563 |
activeExtns = self.GetExtensions(active_only=1) |
| 564 |
for extn in activeExtns: |
| 565 |
extKeys = self.__GetRawExtensionKeys(extn) |
| 566 |
if extKeys: #the extension defines keybindings |
| 567 |
for event in extKeys: |
| 568 |
if extKeys[event] in keySet.values(): |
| 569 |
#the binding is already in use |
| 570 |
extKeys[event] = '' #disable this binding |
| 571 |
keySet[event] = extKeys[event] #add binding |
| 572 |
return keySet |
| 573 |
|
| 574 |
def IsCoreBinding(self, virtualEvent): |
| 575 |
"""Return True if the virtual event is one of the core idle key events. |
| 576 |
|
| 577 |
virtualEvent - string, name of the virtual event to test for, |
| 578 |
without the enclosing '<< >>' |
| 579 |
""" |
| 580 |
return ('<<'+virtualEvent+'>>') in self.GetCoreKeys() |
| 581 |
|
| 582 |
# TODO make keyBindings a file or class attribute used for test above |
| 583 |
# and copied in function below. |
| 584 |
|
| 585 |
former_extension_events = { # Those with user-configurable keys. |
| 586 |
'<<force-open-completions>>', '<<expand-word>>', |
| 587 |
'<<force-open-calltip>>', '<<flash-paren>>', '<<format-paragraph>>', |
| 588 |
'<<run-module>>', '<<check-module>>', '<<zoom-height>>', |
| 589 |
'<<run-custom>>', |
| 590 |
} |
| 591 |
|
| 592 |
def GetCoreKeys(self, keySetName=None): |
| 593 |
"""Return dict of core virtual-key keybindings for keySetName. |
| 594 |
|
| 595 |
The default keySetName None corresponds to the keyBindings base |
| 596 |
dict. If keySetName is not None, bindings from the config |
| 597 |
file(s) are loaded _over_ these defaults, so if there is a |
| 598 |
problem getting any core binding there will be an 'ultimate last |
| 599 |
resort fallback' to the CUA-ish bindings defined here. |
| 600 |
""" |
| 601 |
# TODO: = dict(sorted([(v-event, keys), ...]))? |
| 602 |
keyBindings={ |
| 603 |
# virtual-event: list of key events. |
| 604 |
'<<copy>>': ['<Control-c>', '<Control-C>'], |
| 605 |
'<<cut>>': ['<Control-x>', '<Control-X>'], |
| 606 |
'<<paste>>': ['<Control-v>', '<Control-V>'], |
| 607 |
'<<beginning-of-line>>': ['<Control-a>', '<Home>'], |
| 608 |
'<<center-insert>>': ['<Control-l>'], |
| 609 |
'<<close-all-windows>>': ['<Control-q>'], |
| 610 |
'<<close-window>>': ['<Alt-F4>'], |
| 611 |
'<<do-nothing>>': ['<Control-x>'], |
| 612 |
'<<end-of-file>>': ['<Control-d>'], |
| 613 |
'<<python-docs>>': ['<F1>'], |
| 614 |
'<<python-context-help>>': ['<Shift-F1>'], |
| 615 |
'<<history-next>>': ['<Alt-n>'], |
| 616 |
'<<history-previous>>': ['<Alt-p>'], |
| 617 |
'<<interrupt-execution>>': ['<Control-c>'], |
| 618 |
'<<view-restart>>': ['<F6>'], |
| 619 |
'<<restart-shell>>': ['<Control-F6>'], |
| 620 |
'<<open-class-browser>>': ['<Alt-c>'], |
| 621 |
'<<open-module>>': ['<Alt-m>'], |
| 622 |
'<<open-new-window>>': ['<Control-n>'], |
| 623 |
'<<open-window-from-file>>': ['<Control-o>'], |
| 624 |
'<<plain-newline-and-indent>>': ['<Control-j>'], |
| 625 |
'<<print-window>>': ['<Control-p>'], |
| 626 |
'<<redo>>': ['<Control-y>'], |
| 627 |
'<<remove-selection>>': ['<Escape>'], |
| 628 |
'<<save-copy-of-window-as-file>>': ['<Alt-Shift-S>'], |
| 629 |
'<<save-window-as-file>>': ['<Alt-s>'], |
| 630 |
'<<save-window>>': ['<Control-s>'], |
| 631 |
'<<select-all>>': ['<Alt-a>'], |
| 632 |
'<<toggle-auto-coloring>>': ['<Control-slash>'], |
| 633 |
'<<undo>>': ['<Control-z>'], |
| 634 |
'<<find-again>>': ['<Control-g>', '<F3>'], |
| 635 |
'<<find-in-files>>': ['<Alt-F3>'], |
| 636 |
'<<find-selection>>': ['<Control-F3>'], |
| 637 |
'<<find>>': ['<Control-f>'], |
| 638 |
'<<replace>>': ['<Control-h>'], |
| 639 |
'<<goto-line>>': ['<Alt-g>'], |
| 640 |
'<<smart-backspace>>': ['<Key-BackSpace>'], |
| 641 |
'<<newline-and-indent>>': ['<Key-Return>', '<Key-KP_Enter>'], |
| 642 |
'<<smart-indent>>': ['<Key-Tab>'], |
| 643 |
'<<indent-region>>': ['<Control-Key-bracketright>'], |
| 644 |
'<<dedent-region>>': ['<Control-Key-bracketleft>'], |
| 645 |
'<<comment-region>>': ['<Alt-Key-3>'], |
| 646 |
'<<uncomment-region>>': ['<Alt-Key-4>'], |
| 647 |
'<<tabify-region>>': ['<Alt-Key-5>'], |
| 648 |
'<<untabify-region>>': ['<Alt-Key-6>'], |
| 649 |
'<<toggle-tabs>>': ['<Alt-Key-t>'], |
| 650 |
'<<change-indentwidth>>': ['<Alt-Key-u>'], |
| 651 |
'<<del-word-left>>': ['<Control-Key-BackSpace>'], |
| 652 |
'<<del-word-right>>': ['<Control-Key-Delete>'], |
| 653 |
'<<force-open-completions>>': ['<Control-Key-space>'], |
| 654 |
'<<expand-word>>': ['<Alt-Key-slash>'], |
| 655 |
'<<force-open-calltip>>': ['<Control-Key-backslash>'], |
| 656 |
'<<flash-paren>>': ['<Control-Key-0>'], |
| 657 |
'<<format-paragraph>>': ['<Alt-Key-q>'], |
| 658 |
'<<run-module>>': ['<Key-F5>'], |
| 659 |
'<<run-custom>>': ['<Shift-Key-F5>'], |
| 660 |
'<<check-module>>': ['<Alt-Key-x>'], |
| 661 |
'<<zoom-height>>': ['<Alt-Key-2>'], |
| 662 |
} |
| 663 |
|
| 664 |
if keySetName: |
| 665 |
if not (self.userCfg['keys'].has_section(keySetName) or |
| 666 |
self.defaultCfg['keys'].has_section(keySetName)): |
| 667 |
warning = ( |
| 668 |
'\n Warning: config.py - IdleConf.GetCoreKeys -\n' |
| 669 |
' key set %r is not defined, using default bindings.' % |
| 670 |
(keySetName,) |
| 671 |
) |
| 672 |
_warn(warning, 'keys', keySetName) |
| 673 |
else: |
| 674 |
for event in keyBindings: |
| 675 |
binding = self.GetKeyBinding(keySetName, event) |
| 676 |
if binding: |
| 677 |
keyBindings[event] = binding |
| 678 |
# Otherwise return default in keyBindings. |
| 679 |
elif event not in self.former_extension_events: |
| 680 |
warning = ( |
| 681 |
'\n Warning: config.py - IdleConf.GetCoreKeys -\n' |
| 682 |
' problem retrieving key binding for event %r\n' |
| 683 |
' from key set %r.\n' |
| 684 |
' returning default value: %r' % |
| 685 |
(event, keySetName, keyBindings[event]) |
| 686 |
) |
| 687 |
_warn(warning, 'keys', keySetName, event) |
| 688 |
return keyBindings |
| 689 |
|
| 690 |
def GetExtraHelpSourceList(self, configSet): |
| 691 |
"""Return list of extra help sources from a given configSet. |
| 692 |
|
| 693 |
Valid configSets are 'user' or 'default'. Return a list of tuples of |
| 694 |
the form (menu_item , path_to_help_file , option), or return the empty |
| 695 |
list. 'option' is the sequence number of the help resource. 'option' |
| 696 |
values determine the position of the menu items on the Help menu, |
| 697 |
therefore the returned list must be sorted by 'option'. |
| 698 |
|
| 699 |
""" |
| 700 |
helpSources = [] |
| 701 |
if configSet == 'user': |
| 702 |
cfgParser = self.userCfg['main'] |
| 703 |
elif configSet == 'default': |
| 704 |
cfgParser = self.defaultCfg['main'] |
| 705 |
else: |
| 706 |
raise InvalidConfigSet('Invalid configSet specified') |
| 707 |
options=cfgParser.GetOptionList('HelpFiles') |
| 708 |
for option in options: |
| 709 |
value=cfgParser.Get('HelpFiles', option, default=';') |
| 710 |
if value.find(';') == -1: #malformed config entry with no ';' |
| 711 |
menuItem = '' #make these empty |
| 712 |
helpPath = '' #so value won't be added to list |
| 713 |
else: #config entry contains ';' as expected |
| 714 |
value=value.split(';') |
| 715 |
menuItem=value[0].strip() |
| 716 |
helpPath=value[1].strip() |
| 717 |
if menuItem and helpPath: #neither are empty strings |
| 718 |
helpSources.append( (menuItem,helpPath,option) ) |
| 719 |
helpSources.sort(key=lambda x: x[2]) |
| 720 |
return helpSources |
| 721 |
|
| 722 |
def GetAllExtraHelpSourcesList(self): |
| 723 |
"""Return a list of the details of all additional help sources. |
| 724 |
|
| 725 |
Tuples in the list are those of GetExtraHelpSourceList. |
| 726 |
""" |
| 727 |
allHelpSources = (self.GetExtraHelpSourceList('default') + |
| 728 |
self.GetExtraHelpSourceList('user') ) |
| 729 |
return allHelpSources |
| 730 |
|
| 731 |
def GetFont(self, root, configType, section): |
| 732 |
"""Retrieve a font from configuration (font, font-size, font-bold) |
| 733 |
Intercept the special value 'TkFixedFont' and substitute |
| 734 |
the actual font, factoring in some tweaks if needed for |
| 735 |
appearance sakes. |
| 736 |
|
| 737 |
The 'root' parameter can normally be any valid Tkinter widget. |
| 738 |
|
| 739 |
Return a tuple (family, size, weight) suitable for passing |
| 740 |
to tkinter.Font |
| 741 |
""" |
| 742 |
family = self.GetOption(configType, section, 'font', default='courier') |
| 743 |
size = self.GetOption(configType, section, 'font-size', type='int', |
| 744 |
default='10') |
| 745 |
bold = self.GetOption(configType, section, 'font-bold', default=0, |
| 746 |
type='bool') |
| 747 |
if (family == 'TkFixedFont'): |
| 748 |
f = Font(name='TkFixedFont', exists=True, root=root) |
| 749 |
actualFont = Font.actual(f) |
| 750 |
family = actualFont['family'] |
| 751 |
size = actualFont['size'] |
| 752 |
if size <= 0: |
| 753 |
size = 10 # if font in pixels, ignore actual size |
| 754 |
bold = actualFont['weight'] == 'bold' |
| 755 |
return (family, size, 'bold' if bold else 'normal') |
| 756 |
|
| 757 |
def LoadCfgFiles(self): |
| 758 |
"Load all configuration files." |
| 759 |
for key in self.defaultCfg: |
| 760 |
self.defaultCfg[key].Load() |
| 761 |
self.userCfg[key].Load() #same keys |
| 762 |
|
| 763 |
def SaveUserCfgFiles(self): |
| 764 |
"Write all loaded user configuration files to disk." |
| 765 |
for key in self.userCfg: |
| 766 |
self.userCfg[key].Save() |
| 767 |
|
| 768 |
|
| 769 |
idleConf = IdleConf() |
| 770 |
|
| 771 |
_warned = set() |
| 772 |
def _warn(msg, *key): |
| 773 |
key = (msg,) + key |
| 774 |
if key not in _warned: |
| 775 |
try: |
| 776 |
print(msg, file=sys.stderr) |
| 777 |
except OSError: |
| 778 |
pass |
| 779 |
_warned.add(key) |
| 780 |
|
| 781 |
|
| 782 |
class ConfigChanges(dict): |
| 783 |
"""Manage a user's proposed configuration option changes. |
| 784 |
|
| 785 |
Names used across multiple methods: |
| 786 |
page -- one of the 4 top-level dicts representing a |
| 787 |
.idlerc/config-x.cfg file. |
| 788 |
config_type -- name of a page. |
| 789 |
section -- a section within a page/file. |
| 790 |
option -- name of an option within a section. |
| 791 |
value -- value for the option. |
| 792 |
|
| 793 |
Methods |
| 794 |
add_option: Add option and value to changes. |
| 795 |
save_option: Save option and value to config parser. |
| 796 |
save_all: Save all the changes to the config parser and file. |
| 797 |
delete_section: If section exists, |
| 798 |
delete from changes, userCfg, and file. |
| 799 |
clear: Clear all changes by clearing each page. |
| 800 |
""" |
| 801 |
def __init__(self): |
| 802 |
"Create a page for each configuration file" |
| 803 |
self.pages = [] # List of unhashable dicts. |
| 804 |
for config_type in idleConf.config_types: |
| 805 |
self[config_type] = {} |
| 806 |
self.pages.append(self[config_type]) |
| 807 |
|
| 808 |
def add_option(self, config_type, section, item, value): |
| 809 |
"Add item/value pair for config_type and section." |
| 810 |
page = self[config_type] |
| 811 |
value = str(value) # Make sure we use a string. |
| 812 |
if section not in page: |
| 813 |
page[section] = {} |
| 814 |
page[section][item] = value |
| 815 |
|
| 816 |
@staticmethod |
| 817 |
def save_option(config_type, section, item, value): |
| 818 |
"""Return True if the configuration value was added or changed. |
| 819 |
|
| 820 |
Helper for save_all. |
| 821 |
""" |
| 822 |
if idleConf.defaultCfg[config_type].has_option(section, item): |
| 823 |
if idleConf.defaultCfg[config_type].Get(section, item) == value: |
| 824 |
# The setting equals a default setting, remove it from user cfg. |
| 825 |
return idleConf.userCfg[config_type].RemoveOption(section, item) |
| 826 |
# If we got here, set the option. |
| 827 |
return idleConf.userCfg[config_type].SetOption(section, item, value) |
| 828 |
|
| 829 |
def save_all(self): |
| 830 |
"""Save configuration changes to the user config file. |
| 831 |
|
| 832 |
Clear self in preparation for additional changes. |
| 833 |
Return changed for testing. |
| 834 |
""" |
| 835 |
idleConf.userCfg['main'].Save() |
| 836 |
|
| 837 |
changed = False |
| 838 |
for config_type in self: |
| 839 |
cfg_type_changed = False |
| 840 |
page = self[config_type] |
| 841 |
for section in page: |
| 842 |
if section == 'HelpFiles': # Remove it for replacement. |
| 843 |
idleConf.userCfg['main'].remove_section('HelpFiles') |
| 844 |
cfg_type_changed = True |
| 845 |
for item, value in page[section].items(): |
| 846 |
if self.save_option(config_type, section, item, value): |
| 847 |
cfg_type_changed = True |
| 848 |
if cfg_type_changed: |
| 849 |
idleConf.userCfg[config_type].Save() |
| 850 |
changed = True |
| 851 |
for config_type in ['keys', 'highlight']: |
| 852 |
# Save these even if unchanged! |
| 853 |
idleConf.userCfg[config_type].Save() |
| 854 |
self.clear() |
| 855 |
# ConfigDialog caller must add the following call |
| 856 |
# self.save_all_changed_extensions() # Uses a different mechanism. |
| 857 |
return changed |
| 858 |
|
| 859 |
def delete_section(self, config_type, section): |
| 860 |
"""Delete a section from self, userCfg, and file. |
| 861 |
|
| 862 |
Used to delete custom themes and keysets. |
| 863 |
""" |
| 864 |
if section in self[config_type]: |
| 865 |
del self[config_type][section] |
| 866 |
configpage = idleConf.userCfg[config_type] |
| 867 |
configpage.remove_section(section) |
| 868 |
configpage.Save() |
| 869 |
|
| 870 |
def clear(self): |
| 871 |
"""Clear all 4 pages. |
| 872 |
|
| 873 |
Called in save_all after saving to idleConf. |
| 874 |
XXX Mark window *title* when there are changes; unmark here. |
| 875 |
""" |
| 876 |
for page in self.pages: |
| 877 |
page.clear() |
| 878 |
|
| 879 |
|
| 880 |
# TODO Revise test output, write expanded unittest |
| 881 |
def _dump(): # htest # (not really, but ignore in coverage) |
| 882 |
from zlib import crc32 |
| 883 |
line, crc = 0, 0 |
| 884 |
|
| 885 |
def sprint(obj): |
| 886 |
nonlocal line, crc |
| 887 |
txt = str(obj) |
| 888 |
line += 1 |
| 889 |
crc = crc32(txt.encode(encoding='utf-8'), crc) |
| 890 |
print(txt) |
| 891 |
#print('***', line, crc, '***') # Uncomment for diagnosis. |
| 892 |
|
| 893 |
def dumpCfg(cfg): |
| 894 |
print('\n', cfg, '\n') # Cfg has variable '0xnnnnnnnn' address. |
| 895 |
for key in sorted(cfg): |
| 896 |
sections = cfg[key].sections() |
| 897 |
sprint(key) |
| 898 |
sprint(sections) |
| 899 |
for section in sections: |
| 900 |
options = cfg[key].options(section) |
| 901 |
sprint(section) |
| 902 |
sprint(options) |
| 903 |
for option in options: |
| 904 |
sprint(option + ' = ' + cfg[key].Get(section, option)) |
| 905 |
|
| 906 |
dumpCfg(idleConf.defaultCfg) |
| 907 |
dumpCfg(idleConf.userCfg) |
| 908 |
print('\nlines = ', line, ', crc = ', crc, sep='') |
| 909 |
|
| 910 |
|
| 911 |
if __name__ == '__main__': |
| 912 |
from unittest import main |
| 913 |
main('idlelib.idle_test.test_config', verbosity=2, exit=False) |
| 914 |
|
| 915 |
_dump() |
| 916 |
# Run revised _dump() (700+ lines) as htest? More sorting. |
| 917 |
# Perhaps as window with tabs for textviews, making it config viewer. |