lib/python/Components/config.py

   1 import time
   2 from Tools.NumericalTextInput import NumericalTextInput
   3 from Tools.Directories import resolveFilename, SCOPE_CONFIG
   4 import copy
   5
   6
   7 # ConfigElement, the base class of all ConfigElements.
   8
   9 # it stores:
  10 #   value    the current value, usefully encoded.
  11 #            usually a property which retrieves _value,
  12 #            and maybe does some reformatting
  13 #   _value   the value as it's going to be saved in the configfile,
  14 #            though still in non-string form.
  15 #            this is the object which is actually worked on.
  16 #   default  the initial value. If _value is equal to default,
  17 #            it will not be stored in the config file
  18 #   saved_value is a text representation of _value, stored in the config file
  19 #
  20 # and has (at least) the following methods:
  21 #   save()   stores _value into saved_value,
  22 #            (or stores 'None' if it should not be stored)
  23 #   load()   loads _value from saved_value, or loads
  24 #            the default if saved_value is 'None' (default)
  25 #            or invalid.
  26 #
  27 class ConfigElement(object):
  28         def __init__(self):
  29                 object.__init__(self)
  30                 self.saved_value = None
  31                 self.save_disabled = False
  32                 self.notifiers = []
  33                 self.enabled = True
  34
  35         # you need to override this to do input validation
  36         def setValue(self, value):
  37                 self._value = value
  38                 self.changed()
  39
  40         def getValue(self):
  41                 return self._value
  42
  43         value = property(getValue, setValue)
  44
  45         # you need to override this if self.value is not a string
  46         def fromstring(self, value):
  47                 return value
  48
  49         # you can overide this for fancy default handling
  50         def load(self):
  51                 if self.saved_value is None:
  52                         self.value = self.default
  53                 else:
  54                         self.value = self.fromstring(self.saved_value)
  55
  56         def tostring(self, value):
  57                 return str(value)
  58
  59         # you need to override this if str(self.value) doesn't work
  60         def save(self):
  61                 if self.save_disabled or self.value == self.default:
  62                         self.saved_value = None
  63                 else:
  64                         self.saved_value = self.tostring(self.value)
  65
  66         def cancel(self):
  67                 self.load()
  68
  69         def changed(self):
  70                 for x in self.notifiers:
  71                         x(self)
  72
  73         def addNotifier(self, notifier):
  74                 assert callable(notifier), "notifiers must be callable"
  75                 self.notifiers.append(notifier)
  76
  77         def disableSave(self):
  78                 self.save_disabled = True
  79
  80         def __call__(self, selected):
  81                 return self.getMulti(selected)
  82
  83         def helpWindow(self):
  84                 return None
  85
  86 KEY_LEFT = 0
  87 KEY_RIGHT = 1
  88 KEY_OK = 2
  89 KEY_DELETE = 3
  90 KEY_TIMEOUT = 4
  91 KEY_NUMBERS = range(12, 12+10)
  92 KEY_0 = 12
  93 KEY_9 = 12+9
  94
  95 def getKeyNumber(key):
  96         assert key in KEY_NUMBERS
  97         return key - KEY_0
  98
  99 #
 100 # ConfigSelection is a "one of.."-type.
 101 # it has the "choices", usually a list, which contains
 102 # (id, desc)-tuples (or just only the ids, in case the id
 103 # will be used as description)
 104 #
 105 # all ids MUST be plain strings.
 106 #
 107 class ConfigSelection(ConfigElement):
 108         def __init__(self, choices, default = None):
 109                 ConfigElement.__init__(self)
 110                 self.choices = []
 111                 self.description = {}
 112
 113                 if isinstance(choices, list):
 114                         for x in choices:
 115                                 if isinstance(x, tuple):
 116                                         self.choices.append(x[0])
 117                                         self.description[x[0]] = x[1]
 118                                 else:
 119                                         self.choices.append(x)
 120                                         self.description[x] = x
 121                 elif isinstance(choices, dict):
 122                         for (key, val) in choices.items():
 123                                 self.choices.append(key)
 124                                 self.description[key] = val
 125                 else:
 126                         assert False, "ConfigSelection choices must be dict or list!"
 127
 128                 assert len(self.choices), "you can't have an empty configselection"
 129
 130                 if default is None:
 131                         default = self.choices[0]
 132
 133                 assert default in self.choices, "default must be in choice list, but " + repr(default) + " is not!"
 134                 for x in self.choices:
 135                         assert isinstance(x, str), "ConfigSelection choices must be strings"
 136
 137                 self.value = self.default = default
 138
 139         def setValue(self, value):
 140                 if value in self.choices:
 141                         self._value = value
 142                 else:
 143                         self._value = self.default
 144
 145                 self.changed()
 146
 147         def tostring(self, val):
 148                 return (val, ','.join(self.choices))
 149
 150         def getValue(self):
 151                 return self._value
 152
 153         value = property(getValue, setValue)
 154
 155         def getIndex(self):
 156                 return self.choices.index(self.value)
 157
 158         index = property(getIndex)
 159
 160         # GUI
 161         def handleKey(self, key):
 162                 nchoices = len(self.choices)
 163                 i = self.choices.index(self.value)
 164                 if key == KEY_LEFT:
 165                         self.value = self.choices[(i + nchoices - 1) % nchoices]
 166                 elif key == KEY_RIGHT:
 167                         self.value = self.choices[(i + 1) % nchoices]
 168                 elif key == KEY_TIMEOUT:
 169                         self.timeout()
 170                         return
 171
 172         def getMulti(self, selected):
 173                 return ("text", self.description[self.value])
 174
 175         # HTML
 176         def getHTML(self, id):
 177                 res = ""
 178                 for v in self.choices:
 179                         if self.value == v:
 180                                 checked = 'checked="checked" '
 181                         else:
 182                                 checked = ''
 183                         res += '<input type="radio" name="' + id + '" ' + checked + 'value="' + v + '">' + self.description[v] + "</input></br>\n"
 184                 return res;
 185
 186         def unsafeAssign(self, value):
 187                 # setValue does check if value is in choices. This is safe enough.
 188                 self.value = value
 189
 190 # a binary decision.
 191 #
 192 # several customized versions exist for different
 193 # descriptions.
 194 #
 195 class ConfigBoolean(ConfigElement):
 196         def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
 197                 ConfigElement.__init__(self)
 198                 self.descriptions = descriptions
 199                 self.value = self.default = default
 200         def handleKey(self, key):
 201                 if key in [KEY_LEFT, KEY_RIGHT]:
 202                         self.value = not self.value
 203
 204         def getMulti(self, selected):
 205                 return ("text", _(self.descriptions[self.value]))
 206
 207         def tostring(self, value):
 208                 if not value:
 209                         return "false"
 210                 else:
 211                         return "true"
 212
 213         def fromstring(self, val):
 214                 if val == "true":
 215                         return True
 216                 else:
 217                         return False
 218
 219         def getHTML(self, id):
 220                 if self.value:
 221                         checked = ' checked="checked"'
 222                 else:
 223                         checked = ''
 224                 return '<input type="checkbox" name="' + id + '" value="1" ' + checked + " />"
 225
 226         # this is FLAWED. and must be fixed.
 227         def unsafeAssign(self, value):
 228                 if value == "1":
 229                         self.value = True
 230                 else:
 231                         self.value = False
 232
 233 class ConfigYesNo(ConfigBoolean):
 234         def __init__(self, default = False):
 235                 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
 236
 237 class ConfigOnOff(ConfigBoolean):
 238         def __init__(self, default = False):
 239                 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("off"), True: _("on")})
 240
 241 class ConfigEnableDisable(ConfigBoolean):
 242         def __init__(self, default = False):
 243                 ConfigBoolean.__init__(self, default = default, descriptions = {False: _("disable"), True: _("enable")})
 244
 245 class ConfigDateTime(ConfigElement):
 246         def __init__(self, default, formatstring, increment = 86400):
 247                 ConfigElement.__init__(self)
 248                 self.increment = increment
 249                 self.formatstring = formatstring
 250                 self.value = self.default = int(default)
 251
 252         def handleKey(self, key):
 253                 if key == KEY_LEFT:
 254                         self.value = self.value - self.increment
 255                 if key == KEY_RIGHT:
 256                         self.value = self.value + self.increment
 257
 258         def getMulti(self, selected):
 259                 return ("text", time.strftime(self.formatstring, time.localtime(self.value)))
 260
 261         def fromstring(self, val):
 262                 return int(val)
 263
 264 # *THE* mighty config element class
 265 #
 266 # allows you to store/edit a sequence of values.
 267 # can be used for IP-addresses, dates, plain integers, ...
 268 # several helper exist to ease this up a bit.
 269 #
 270 class ConfigSequence(ConfigElement):
 271         def __init__(self, seperator, limits, censor_char = "", default = None):
 272                 ConfigElement.__init__(self)
 273                 assert isinstance(limits, list) and len(limits[0]) == 2, "limits must be [(min, max),...]-tuple-list"
 274                 assert censor_char == "" or len(censor_char) == 1, "censor char must be a single char (or \"\")"
 275                 #assert isinstance(default, list), "default must be a list"
 276                 #assert isinstance(default[0], int), "list must contain numbers"
 277                 #assert len(default) == len(limits), "length must match"
 278
 279                 self.marked_pos = 0
 280                 self.seperator = seperator
 281                 self.limits = limits
 282                 self.censor_char = censor_char
 283
 284                 self.default = default
 285                 self.value = copy.copy(default)
 286
 287         def validate(self):
 288                 max_pos = 0
 289                 num = 0
 290                 for i in self._value:
 291                         max_pos += len(str(self.limits[num][1]))
 292
 293                         while self._value[num] < self.limits[num][0]:
 294                                 self.value[num] += 1
 295
 296                         while self._value[num] > self.limits[num][1]:
 297                                 self._value[num] -= 1
 298
 299                         num += 1
 300
 301                 if self.marked_pos >= max_pos:
 302                         self.marked_pos = max_pos - 1
 303
 304                 if self.marked_pos < 0:
 305                         self.marked_pos = 0
 306
 307         def validatePos(self):
 308                 if self.marked_pos < 0:
 309                         self.marked_pos = 0
 310
 311                 total_len = sum([len(str(x[1])) for x in self.limits])
 312
 313                 if self.marked_pos >= total_len:
 314                         self.marked_pos = total_len - 1
 315
 316         def handleKey(self, key):
 317                 if key == KEY_LEFT:
 318                         self.marked_pos -= 1
 319                         self.validatePos()
 320
 321                 if key == KEY_RIGHT:
 322                         self.marked_pos += 1
 323                         self.validatePos()
 324
 325                 if key in KEY_NUMBERS:
 326                         block_len = []
 327                         for x in self.limits:
 328                                 block_len.append(len(str(x[1])))
 329
 330                         total_len = sum(block_len)
 331
 332                         pos = 0
 333                         blocknumber = 0
 334                         block_len_total = [0, ]
 335                         for x in block_len:
 336                                 pos += block_len[blocknumber]
 337                                 block_len_total.append(pos)
 338                                 if pos - 1 >= self.marked_pos:
 339                                         pass
 340                                 else:
 341                                         blocknumber += 1
 342
 343                         number = getKeyNumber(key)
 344
 345                         # length of numberblock
 346                         number_len = len(str(self.limits[blocknumber][1]))
 347
 348                         # position in the block
 349                         posinblock = self.marked_pos - block_len_total[blocknumber]
 350
 351                         oldvalue = self._value[blocknumber]
 352                         olddec = oldvalue % 10 ** (number_len - posinblock) - (oldvalue % 10 ** (number_len - posinblock - 1))
 353                         newvalue = oldvalue - olddec + (10 ** (number_len - posinblock - 1) * number)
 354
 355                         self._value[blocknumber] = newvalue
 356                         self.marked_pos += 1
 357
 358                         self.validate()
 359                         self.changed()
 360
 361         def getMulti(self, selected):
 362                 value = ""
 363                 mPos = self.marked_pos
 364                 num = 0;
 365                 for i in self._value:
 366                         if len(value):  #fixme no heading separator possible
 367                                 value += self.seperator
 368                                 if mPos >= len(value) - 1:
 369                                         mPos += 1
 370
 371                         if self.censor_char == "":
 372                                 value += ("%0" + str(len(str(self.limits[num][1]))) + "d") % i
 373                         else:
 374                                 value += (self.censorChar * len(str(self.limits[num][1])))
 375                         num += 1
 376
 377                         # only mark cursor when we are selected
 378                         # (this code is heavily ink optimized!)
 379                 if self.enabled:
 380                         return ("mtext"[1-selected:], value, [mPos])
 381                 else:
 382                         return ("text", value)
 383
 384         def tostring(self, val):
 385                 return self.seperator.join([self.saveSingle(x) for x in val])
 386
 387         def saveSingle(self, v):
 388                 return str(v)
 389
 390         def fromstring(self, value):
 391                 return [int(x) for x in self.saved_value.split(self.seperator)]
 392
 393 class ConfigIP(ConfigSequence):
 394         def __init__(self, default):
 395                 ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
 396
 397 class ConfigMAC(ConfigSequence):
 398         def __init__(self, default):
 399                 ConfigSequence.__init__(self, seperator = ":", limits = [(1,255),(1,255),(1,255),(1,255),(1,255),(1,255)], default = default)
 400
 401 class ConfigPosition(ConfigSequence):
 402         def __init__(self, default, args):
 403                 ConfigSequence.__init__(self, seperator = ",", limits = [(0,args[0]),(0,args[1]),(0,args[2]),(0,args[3])], default = default)
 404
 405 class ConfigClock(ConfigSequence):
 406         def __init__(self, default):
 407                 ConfigSequence.__init__(self, seperator = ":", limits = [(0,23),(0,59)], default = default)
 408
 409 class ConfigInteger(ConfigSequence):
 410         def __init__(self, default, limits):
 411                 ConfigSequence.__init__(self, seperator = ":", limits = [limits], default = default)
 412
 413         # you need to override this to do input validation
 414         def setValue(self, value):
 415                 self._value = [value]
 416                 self.changed()
 417
 418         def getValue(self):
 419                 return self._value[0]
 420
 421         value = property(getValue, setValue)
 422
 423         def fromstring(self, value):
 424                 return int(value)
 425
 426         def tostring(self, value):
 427                 return str(value)
 428
 429 class ConfigPIN(ConfigSequence):
 430         def __init__(self, default, len = 4, censor = ""):
 431                 ConfigSequence.__init__(self, seperator = ":", limits = [(0, (10**len)-1)], censor_char = censor, default = [default])
 432
 433 class ConfigFloat(ConfigSequence):
 434         def __init__(self, default, limits):
 435                 ConfigSequence.__init__(self, seperator = ".", limits = limits, default = default)
 436
 437         def getFloat(self):
 438                 return float(self.value[1] / float(self.limits[1][1] + 1) + self.value[0])
 439
 440         float = property(getFloat)
 441
 442 # an editable text...
 443 class ConfigText(ConfigElement, NumericalTextInput):
 444         def __init__(self, default = "", fixed_size = True):
 445                 ConfigElement.__init__(self)
 446                 NumericalTextInput.__init__(self, nextFunc = self.nextFunc, handleTimeout = False)
 447
 448                 self.marked_pos = 0
 449                 self.fixed_size = fixed_size
 450
 451                 self.value = self.default = default
 452
 453         def validateMarker(self):
 454                 if self.marked_pos < 0:
 455                         self.marked_pos = 0
 456                 if self.marked_pos >= len(self.text):
 457                         self.marked_pos = len(self.text) - 1
 458
 459         #def nextEntry(self):
 460         #       self.vals[1](self.getConfigPath())
 461
 462         def handleKey(self, key):
 463                 # this will no change anything on the value itself
 464                 # so we can handle it here in gui element
 465                 if key == KEY_DELETE:
 466                         self.text = self.text[0:self.marked_pos] + self.text[self.marked_pos + 1:]
 467                 elif key == KEY_LEFT:
 468                         self.marked_pos -= 1
 469                 elif key == KEY_RIGHT:
 470                         self.marked_pos += 1
 471                         if not self.fixed_size:
 472                                 if self.marked_pos >= len(self.text):
 473                                         self.text = self.text.ljust(len(self.text) + 1)
 474                 elif key in KEY_NUMBERS:
 475                         number = self.getKey(getKeyNumber(key))
 476                         self.text = self.text[0:self.marked_pos] + str(number) + self.text[self.marked_pos + 1:]
 477                 elif key == KEY_TIMEOUT:
 478                         self.timeout()
 479                         return
 480
 481                 self.validateMarker()
 482                 self.changed()
 483
 484         def nextFunc(self):
 485                 self.marked_pos += 1
 486                 self.validateMarker()
 487                 self.changed()
 488
 489         def getValue(self):
 490                 return self.text.encode("utf-8")
 491
 492         def setValue(self, val):
 493                 try:
 494                         self.text = val.decode("utf-8")
 495                 except UnicodeDecodeError:
 496                         self.text = val
 497                         print "Broken UTF8!"
 498
 499         value = property(getValue, setValue)
 500         _value = property(getValue, setValue)
 501
 502         def getMulti(self, selected):
 503                 return ("mtext"[1-selected:], self.value, [self.marked_pos])
 504
 505         def helpWindow(self):
 506                 from Screens.NumericalTextInputHelpDialog import NumericalTextInputHelpDialog
 507                 return (NumericalTextInputHelpDialog,self)
 508
 509         def getHTML(self, id):
 510                 return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
 511
 512         def unsafeAssign(self, value):
 513                 self.value = str(value)
 514
 515 # a slider.
 516 class ConfigSlider(ConfigElement):
 517         def __init__(self, default = 0, increment = 1, limits = (0, 100)):
 518                 ConfigElement.__init__(self)
 519                 self.value = self.default = default
 520                 self.min = limits[0]
 521                 self.max = limits[1]
 522                 self.increment = increment
 523
 524         def checkValues(self):
 525                 if self.value < self.min:
 526                         self.value = self.min
 527
 528                 if self.value > self.max:
 529                         self.value = self.max
 530
 531         def handleKey(self, key):
 532                 if key == KEY_LEFT:
 533                         self.value -= self.increment
 534                 elif key == KEY_RIGHT:
 535                         self.value += self.increment
 536                 else:
 537                         return
 538
 539                 self.checkValues()
 540                 self.changed()
 541
 542         def getMulti(self, selected):
 543                 self.checkValues()
 544                 return ("slider", self.value, self.max)
 545
 546         def fromstring(self, value):
 547                 return int(value)
 548
 549 # a satlist. in fact, it's a ConfigSelection.
 550 class ConfigSatlist(ConfigSelection):
 551         def __init__(self, list, default = None):
 552                 if default is not None:
 553                         default = str(default)
 554                 if list == [ ]:
 555                         list = [0, "N/A"]
 556                 ConfigSelection.__init__(self, choices = [(str(orbpos), desc) for (orbpos, desc) in list], default = default)
 557
 558         def getOrbitalPosition(self):
 559                 return int(self.value)
 560
 561         orbital_position = property(getOrbitalPosition)
 562
 563 # nothing.
 564 class ConfigDummy(ConfigSelection):
 565         def __init__(self):
 566                 ConfigSelection.__init__(self, choices = [""])
 567
 568 # until here, 'saved_value' always had to be a *string*.
 569 # now, in ConfigSubsection, and only there, saved_value
 570 # is a dict, essentially forming a tree.
 571 #
 572 # config.foo.bar=True
 573 # config.foobar=False
 574 #
 575 # turns into:
 576 # config.saved_value == {"foo": {"bar": "True"}, "foobar": "False"}
 577 #
 578
 579
 580 class ConfigSubsectionContent(object):
 581         pass
 582
 583 # we store a backup of the loaded configuration
 584 # data in self.stored_values, to be able to deploy
 585 # them when a new config element will be added,
 586 # so non-default values are instantly available
 587
 588 # A list, for example:
 589 # config.dipswitches = ConfigSubList()
 590 # config.dipswitches.append(ConfigYesNo())
 591 # config.dipswitches.append(ConfigYesNo())
 592 # config.dipswitches.append(ConfigYesNo())
 593 class ConfigSubList(list, object):
 594         def __init__(self):
 595                 object.__init__(self)
 596                 list.__init__(self)
 597                 self.stored_values = {}
 598
 599         def save(self):
 600                 for x in self:
 601                         x.save()
 602
 603         def load(self):
 604                 for x in self:
 605                         x.load()
 606
 607         def getSavedValue(self):
 608                 res = {}
 609                 for i in range(len(self)):
 610                         sv = self[i].saved_value
 611                         if sv is not None:
 612                                 res[str(i)] = sv
 613                 return res
 614
 615         def setSavedValue(self, values):
 616                 self.stored_values = dict(values)
 617                 for (key, val) in self.stored_values.items():
 618                         if int(key) < len(self):
 619                                 self[int(key)].saved_value = val
 620
 621         saved_value = property(getSavedValue, setSavedValue)
 622
 623         def append(self, item):
 624                 list.append(self, item)
 625                 i = str(len(self))
 626                 if i in self.stored_values:
 627                         item.saved_value = self.stored_values[i]
 628                         item.load()
 629
 630 # same as ConfigSubList, just as a dictionary.
 631 # care must be taken that the 'key' has a proper
 632 # str() method, because it will be used in the config
 633 # file.
 634 class ConfigSubDict(dict, object):
 635         def __init__(self):
 636                 object.__init__(self)
 637                 dict.__init__(self)
 638                 self.stored_values = {}
 639
 640         def save(self):
 641                 for x in self.values():
 642                         x.save()
 643
 644         def load(self):
 645                 for x in self.values():
 646                         x.load()
 647
 648         def getSavedValue(self):
 649                 res = {}
 650                 for (key, val) in self.items():
 651                         if val.saved_value is not None:
 652                                 res[str(key)] = val.saved_value
 653                 return res
 654
 655         def setSavedValue(self, values):
 656                 self.stored_values = dict(values)
 657                 for (key, val) in self.items():
 658                         if str(key) in self.stored_values:
 659                                 val = self.stored_values[str(key)]
 660
 661         saved_value = property(getSavedValue, setSavedValue)
 662
 663         def __setitem__(self, key, item):
 664                 dict.__setitem__(self, key, item)
 665                 if str(key) in self.stored_values:
 666                         item.saved_value = self.stored_values[str(key)]
 667                         item.load()
 668
 669 # Like the classes above, just with a more "native"
 670 # syntax.
 671 #
 672 # some evil stuff must be done to allow instant
 673 # loading of added elements. this is why this class
 674 # is so complex.
 675 #
 676 # we need the 'content' because we overwrite
 677 # __setattr__.
 678 # If you don't understand this, try adding
 679 # __setattr__ to a usual exisiting class and you will.
 680 class ConfigSubsection(object):
 681         def __init__(self):
 682                 object.__init__(self)
 683                 self.__dict__["content"] = ConfigSubsectionContent()
 684                 self.content.items = { }
 685                 self.content.stored_values = { }
 686
 687         def __setattr__(self, name, value):
 688                 if name == "saved_value":
 689                         return self.setSavedValue(value)
 690                 self.content.items[name] = value
 691                 if name in self.content.stored_values:
 692                         #print "ok, now we have a new item,", name, "and have the following value for it:", self.content.stored_values[name]
 693                         value.saved_value = self.content.stored_values[name]
 694                         value.load()
 695
 696         def __getattr__(self, name):
 697                 return self.content.items[name]
 698
 699         def getSavedValue(self):
 700                 res = self.content.stored_values
 701                 for (key, val) in self.content.items.items():
 702                         if val.saved_value is not None:
 703                                 res[key] = val.saved_value
 704                 return res
 705
 706         def setSavedValue(self, values):
 707                 values = dict(values)
 708
 709                 self.content.stored_values = values
 710
 711                 for (key, val) in self.content.items.items():
 712                         if key in values:
 713                                 val.setSavedValue(values[key])
 714
 715         saved_value = property(getSavedValue, setSavedValue)
 716
 717         def save(self):
 718                 for x in self.content.items.values():
 719                         x.save()
 720
 721         def load(self):
 722                 for x in self.content.items.values():
 723                         x.load()
 724
 725 # the root config object, which also can "pickle" (=serialize)
 726 # down the whole config tree.
 727 #
 728 # we try to keep non-existing config entries, to apply them whenever
 729 # a new config entry is added to a subsection
 730 # also, non-existing config entries will be saved, so they won't be
 731 # lost when a config entry disappears.
 732 class Config(ConfigSubsection):
 733         def __init__(self):
 734                 ConfigSubsection.__init__(self)
 735
 736         def pickle_this(self, prefix, topickle, result):
 737                 for (key, val) in topickle.items():
 738                         name = prefix + "." + key
 739
 740                         if isinstance(val, dict):
 741                                 self.pickle_this(name, val, result)
 742                         elif isinstance(val, tuple):
 743                                 result.append(name + "=" + val[0]) # + " ; " + val[1])
 744                         else:
 745                                 result.append(name + "=" + val)
 746
 747         def pickle(self):
 748                 result = [ ]
 749                 self.pickle_this("config", self.saved_value, result)
 750                 return '\n'.join(result) + "\n"
 751
 752         def unpickle(self, lines):
 753                 tree = { }
 754                 for l in lines:
 755                         if not len(l) or l[0] == '#':
 756                                 continue
 757
 758                         n = l.find('=')
 759                         val = l[n+1:].strip()
 760
 761                         names = l[:n].split('.')
 762 #                       if val.find(' ') != -1:
 763 #                               val = val[:val.find(' ')]
 764
 765                         base = tree
 766
 767                         for n in names[:-1]:
 768                                 base = base.setdefault(n, {})
 769
 770                         base[names[-1]] = val
 771
 772                 # we inherit from ConfigSubsection, so ...
 773                 #object.__setattr__(self, "saved_value", tree["config"])
 774                 self.setSavedValue(tree["config"])
 775
 776         def saveToFile(self, filename):
 777                 f = open(filename, "w")
 778                 f.write(self.pickle())
 779                 f.close()
 780
 781         def loadFromFile(self, filename):
 782                 f = open(filename, "r")
 783                 self.unpickle(f.readlines())
 784                 f.close()
 785
 786 config = Config()
 787 config.misc = ConfigSubsection()
 788
 789 class ConfigFile:
 790         CONFIG_FILE = resolveFilename(SCOPE_CONFIG, "config2")
 791
 792         def load(self):
 793                 try:
 794                         config.loadFromFile(self.CONFIG_FILE)
 795                 except IOError, e:
 796                         print "unable to load config (%s), assuming defaults..." % str(e)
 797
 798         def save(self):
 799                 config.save()
 800                 config.saveToFile(self.CONFIG_FILE)
 801
 802         def getResolvedKey(self, key):
 803                 return None # FIXME
 804
 805 def NoSave(element):
 806         element.disableSave()
 807         return element
 808
 809 configfile = ConfigFile()
 810
 811 configfile.load()
 812
 813 def getConfigListEntry(desc, config):
 814         return (desc, config)
 815
 816 #def _(x):
 817 #       return x
 818 #
 819 #config.bla = ConfigSubsection()
 820 #config.bla.test = ConfigYesNo()
 821 #config.nim = ConfigSubList()
 822 #config.nim.append(ConfigSubsection())
 823 #config.nim[0].bla = ConfigYesNo()
 824 #config.nim.append(ConfigSubsection())
 825 #config.nim[1].bla = ConfigYesNo()
 826 #config.nim[1].blub = ConfigYesNo()
 827 #config.arg = ConfigSubDict()
 828 #config.arg["Hello"] = ConfigYesNo()
 829 #
 830 #config.arg["Hello"].handleKey(KEY_RIGHT)
 831 #config.arg["Hello"].handleKey(KEY_RIGHT)
 832 #
 833 ##config.saved_value
 834 #
 835 ##configfile.save()
 836 #config.save()
 837 #print config.pickle()